There seem to be a fundamental disconnect here based on people not 
understanding what can happen when spaces are optional. Yes, I have had my 
share of times I found what I programmed was not quite right and been unhappy 
but the result was mostly learning how to not not not not do that next time and 
follow the rules.

When I write:

Var = -----1

The result of five minus signs in a row is not a new long operator called 
"-----". It is five instances of "-" and looks more like:

Var=-(-(-(-(-1))))

You can even throw in some plus signs and they are effectively ignored.

It is no different than some other operators like:

Var = not not not not True

So the "=-" case is not a single operator even as "-=" is a single operator.

If I add another negative symbol to the above, I have two operators with a 
binary operator of "-=" that may be implemented more efficiently or use a 
dunder method that handles it and then a unary "-" operator. 

>>> Var = 1
>>> Var -=-1
>>> Var
2

Yes, I can sympathize with humans who think the computer should do what they 
meant. They may also not like scenarios where they mess up the indentation and 
assume the computer should guess what they meant.

But life is generally not like that. Whenever you are in doubt as to how 
something will be parsed especially given how many precedence levels python has 
and so on, USE PARENTHESES and sometimes spaces.

If you type "Var - = 5" you get a syntax error because it sees two different 
operators that do not mesh well. If you type "Var = - 5" you get a result that 
should make sense as the minus binds to the 5 and negates it and then the 
assignment is done. If you leave the space between symbols out, then "-=" 
evaluates to a new operator and "=-" evaluates to two operators as described.

There are lots of trivial bugs people find including truly simple ones like 
subtracting instead of adding or using a floating point number like 5.0 when 
you meant to use an integer or forgetting that 5/3 and 5//3 do somewhat 
different things. People often substitute things like bitwise operators and the 
computer does what you tell it. Many languages have doubled operators like "&" 
versus "&&" that do different things. And if you want to make a list and 
instead of using square brackets use curly brackets, in python, you get a set! 
There are so many places you can mess up.

ALL languages have such features where people can and do make mistakes and 
sometimes cannot easily find them. Add in mistakes where different parts of a 
program use the same variable name and one changes it out and the other gets a 
confusing result. Simply put, lots of stuff is not only legal but often useful 
and even when a linter or other program sees what might be a mistake, it will 
often be wrong and something you wanted done.

Consider another such arena in the lowly spelling Checker that keeps telling me 
things are spelled wrong because it does not know Schwarzenegger is a name or 
that Grosz and Groß are valid variations on the spelling of my name.  Imagine 
what it does when I write in any language other than English. One solution has 
been to have it add such words to a dictionary but that backfires when it 
allows words as valid even though in the current context, it is NOT VALID. So 
some such programs allow you to designate what dictionary/language to use to 
check a region such as a paragraph. Some may transition to being closer to 
grammar checkers that try to parse your sentences and make sure not only that a 
word is a valid spelling but valid given what role it plays in the sentence!

Computer languages are both far simpler and yet weirder. You need to use them 
in ways the documentation says. But when you consider various ideas about 
scope, you can end up with it needing to know which of perhaps many copies of 
the same variable name is being referenced. So if you wrote a program where you 
had a local variable inside a function that you changed and you ASS U ME d you 
could use that variable outside the scope later and another variable already 
exists there with the same name, how is it supposed to know you made a mistake? 
How does it know you wanted a deep copy rather than a reference or shallow copy?

There are so many other examples that the short answer to many questions is 
something like THAT IS THE WAY IT IS. Don't do that!

I doubt anyone would like it if computer programs were written with multiple 
layers of redundancy so that many errors could be detected when all the parts 
do not align along with a checksum. Human languages that do something similar 
are, frankly, a royal pain. I mean once you have a gender and a tense and a  
singular/plural, for example, everything else nearby, such as adjectives, must 
be adjusted to have the right form or endings to match it. That may have been 
great when it was hard to hear a speaker from the back of the theater so the 
redundancy helped offer possible corrections but these days just makes the 
language much harder to learn. I vastly prefer a designed language like 
Esperanto to any human ones that evolved into monstrosities.

We have lots of computer languages to choose from and some are designed to 
protect you from yourself to the extent that I simply have no interest in 
programming in them. Some take quite a bit of work to even get it to compile so 
you can then look to see if there are any bugs not caught. Python is towards 
the other end of a spectrum where the idea is to let you write programs easier. 
There are people now trying to in some ways ruin the usability by putting in 
type hints that are ignored and although potentially helpful as in a linter 
evaluating it, instead often make it harder to read and write code if required 
to use it. Some programmers like freedom and others like dependability. Of 
course, freedom is relative and after you have been mugged a few times by your 
errors, you may decide it is worth getting some protection.

So, consider having code reviews where fresh eyes may spot your errors.







-----Original Message-----
From: Python-list <python-list-bounces+avi.e.gross=gmail....@python.org> On 
Behalf Of Morten W. Petersen
Sent: Tuesday, March 14, 2023 4:31 PM
To: Jon Ribbens <jon+use...@unequivocal.eu>
Cc: python-list@python.org
Subject: Re: =- and -= snag

Hoi.

After reading the replies, I think some script / linter etc. is the right
thing to do. What's the best linter for Python out there that covers this
as well?

At first glance I thought =- was a new assignment operator, and this is
what seemed unpythonic to me, to have two operators that were so similar.

-Morten

On Tue, Mar 14, 2023 at 5:31 PM Jon Ribbens via Python-list <
python-list@python.org> wrote:

> On 2023-03-13, Morten W. Petersen <morp...@gmail.com> wrote:
> > I was working in Python today, and sat there scratching my head as the
> > numbers for calculations didn't add up.  It went into negative numbers,
> > when that shouldn't have been possible.
> >
> > Turns out I had a very small typo, I had =- instead of -=.
> >
> > Isn't it unpythonic to be able to make a mistake like that?
>
> Why would it be? How could it be? Mandating white-space between
> operators would be unpythonic.
>
> That's nothing anyway - yesterday I had an issue in TypeScript which
> confused me for a while which turned out to be because 1 + 1 = 11.
> (I thought the whole point of TypeScript was to prevent things like
> that...)
> --
> https://mail.python.org/mailman/listinfo/python-list
>


-- 
I am https://leavingnorway.info
Videos at https://www.youtube.com/user/TheBlogologue
Twittering at http://twitter.com/blogologue
Blogging at http://blogologue.com
Playing music at https://soundcloud.com/morten-w-petersen
Also playing music and podcasting here:
http://www.mixcloud.com/morten-w-petersen/
On Google+ here https://plus.google.com/107781930037068750156
On Instagram at https://instagram.com/morphexx/
-- 
https://mail.python.org/mailman/listinfo/python-list

-- 
https://mail.python.org/mailman/listinfo/python-list

Reply via email to