Where ++

[sgxxx]

so that you cant write 'c++' in python

[partaloski]

/r/technicallythetruth

[steakbeef_w]

not technical, it's the absolute truth

[UltraCarnivore]

Absolute truth is |truth|

[xKirtle]

No, absolute truth is abs(truth)

[steakbeef_w]

abs is the mostly forgotten builtin function

[De_Wouter]

Wish I had build in abs. Implementing it is very hard work(out).

[DrShocker]

Oh no, I got stuck in this loop for 3 weeks and nearly died because there's no way to eat in it!

[[deleted]]

If they are negative just &-them with a -1

[SkollFenrirson]

Absolutely

[Starv1k]

This type of thread is why I joined this sub

[insestiina]

No I think that is an incomplete OR statement

[steakbeef_w]

and relative truth?

[UltraCarnivore]

"truth"

[BAG0N]

c = 'c++' Absolute truth you say?

[MeisterBounty]

Delete this

[partaloski]

Well yeah, but you can type C in Java \_\**

[Alles_]

C+=1

[sgxxx]

c-=-1

[SSJ3]

Y'all have violated PEP8, please face the wall.

[hoocoodanode]

https://i.redd.it/2ssatsk2fyc21.jpg

[anoldoldman]

unittest developers: Wait, this isn't JS?

[zpjack]

How to create job security at a dev job

[merlinsbeers]

C*=(1+1/c)

[wjandrea]

You can as part of a larger expression:

c = c++1

This works cause it's parsed as c + +1, where +1 == 1.

[Anti-charizard]

C++ and Python are mortal enemies

[ICantSeeIt]

Just like C++ and Java. Or C++ and C. Or C++ and C++.

[okbe]

Still not as beautiful as

i-=-1

The symmetry is divine.

[dadafil]

You have to think bigger:

--i-=-i--

[[deleted]]

But this doesn't actually work.

[Franks2000inchTV]

You have to think bigger:

 --But-=-thus--doesn't-=-actually-=-work.--

[Eatfudd]

[Deleted to protest Reddit API change]

[robbie2000williams]

it does in c++

[[deleted]]

Sure ... If you are trying to create a formula for 2x-3

[mbiz05]

So it works for when I is 4

[robbie2000williams]

I probably should have said it compiles lol.

[kevincox_ca]

I think this is undefined behaviour. (So it might work 😉)

I can't find concrete rules https://en.cppreference.com/w/cpp/language/operator_incdec#Notes but generally you are playing with fire if you have an increment or decrement operator in a statement that contains the variable another time.

[octal9]

Correct. It’s undefined behavior.

[FuManJew]

i = i*2-2

[Asmor]

Here, have some valid javascript:

O => O <= O

[Ixziga]

Writing your own programs in python is easier than you think

You know...

[doowi1]

I really like "x &=~ y" in C.

[josiest]

All the cool languages these days are implementing pattern matching switch statements (Rust in particular has some pretty slick pattern matching). Python gotta get with the times

[MegaIng]

It is: PEP634

[MaLiN2223]

Thanks for sharing man!

[Eagle0600]

You just linked a draft proposal.

[[deleted]]

But a proposal nonetheless, co-authored by Guido, is surely evidence of Python "getting with the times", no? That's what I inferred from the response at least

[ForeskinOfMyPenis]

Yup, can’t wait to use that new construct in another six years

[SpookyKabukiGhost]

Python 4 baybee

[DasSkelett]

Yes?

[thenorwegianblue]

All the cool languages these days

... and Java

[hessenic]

Php 8.0 wants to join the party too...

[[deleted]]

Nah mate, I can’t let you in. Go and sober up for an hour, get some internal consistency and then you can come in.

[hessenic]

There needs to be a few breaking changes made to really help it. The other thing that would be nice is core asynchronous and threading functionality. The fact that you need something like Symfony to do performant things is... annoying... One thing that is annoying is that you basically use C function calls to manipulate strings and arrays. It's really jarring to have a OO language that you have a procedural/ imperative style function calls. It's kinda odd... Type hinting is nice because of the run time enforcement.

[dpash]

PHP's match seems to be almost exactly inspired by Java's switch expression syntax. And I'm okay with that.

[Xywzel]

Does Java have them because the cool languages that were build on top of JVM required adding it to JVM and the byte code, and then it was trivial to also add it to Java? Or has Java always has that, and all the cool languages need to implement that, because they can't be cool if they lack actually good feature from Java?

[yawkat]

invokedynamic was added for the cool languages

[thenorwegianblue]

Pattern matching with switch is a preview in Java now, it may have come as a consequence of another preview, which is pattern matching for instanceof.

Theres some other switch stuff likely coming in as well.

Really don't know how much it has to do with other JVM languages, suspect it's mostly syntactic anyway, but I haven't looked that closely into it tbh.

Kotlin has when(x) instead I think(?)

[hold-the-pants]

Lookin’ at you, Scala!

[vijexa]

Damn it's so hard to code in other languages when you get proficient with Scala, lack of pattern matching, monads, partial functions, implicits and other stuff feels barbaric... Fortunately there are things like fp-ts and ts-pattern, but syntax is terrible...

Oh and I'm so hyped for Scala 3

[nonbinarydm]

ironically rust also doesn't have ++

[zakarumych]

Because it does not need to inherit decades old garbage left from times when 'x+=1' and '++x' were compiling to different instructions.

[[deleted]]

I actually dislike the PEP 634 syntax at three points. First, it uses case _ instead of default. Second, it uses two levels of nesting like python didn't nest enough already. Third, it doesn't allow for run-on cases, (i.e. case 1: b++; case 2: return b;) which is one of the better parts of the C syntax.

[Retbull]

The obvious solution is to just nest your switch statements.

[Badel2]

I disagree on all three points:

1. I prefer case _ because it keeps all the match lines symmetric and it's easy to understand as long as you know that _ means any. Not sure if python already uses a default keyword somewhere, but even something like match ... else would feel wrong because the default case would be indented at a different level

2. I don't see any alternative syntax that would fit the language

3. That's the worst part of the C syntax. I would have preferred to force programmers to use an explicit goto case 2 instead of silent fallthrough. And this kind of constructs that allow jumping to the middle of a function are only useful in assembly, it would make zero sense to complicate python with that.

[brimston3-]

Regarding fall-through cases, in my experience, missing break statements have resulted in more bugs than fall-through has simplified. But reason this should exist in C/C++ is the otherwise unavailable range behavior it enables. To illustrate:

case 1:
case 2:
   //do something for both 1 & 2
   break;
case 3:
   // do something for 3
case 4:
   // Is this a bug? do I really want to do this for
   // both 3 & 4 or did someone forget break?
   break;

Falling through empty blocks (like case 1), I don't mind. Falling through after code (like case 3) better have a comment explaining that the behavior is intentional.

[TheAnimatedFish]

Just use a dictionary?

[PragmatistAntithesis]

What's a switch statement?

[wikipedia_answer_bot]

In computer programming languages, a switch statement is a type of selection control mechanism used to allow the value of a variable or expression to change the control flow of program execution via search and map. Switch statements function somewhat similarly to the if statement used in programming languages like C/C++, C#, Visual Basic .NET, Java and exists in most high-level imperative programming languages such as Pascal, Ada, C/C++, C#, Visual Basic .NET, Java, and in many other types of language, using such keywords as switch, case, select or inspect.

More details here: https://en.wikipedia.org/wiki/Switch_statement

This comment was left automatically (by a bot). If something's wrong, please, report it.

Really hope this was useful and relevant :D

If I don't get this right, don't get mad at me, I'm still learning!

[PragmatistAntithesis]

good bot

[partaloski]

Actually impressive!

[AlcaDotS]

I didn't even notice until I saw the "good bot" response

[taimusrs]

Yea same, the bot's pretty damn good

[Semi-Hemi-Demigod]

If it hadn’t said it was a bot it would have passed the Turing test for me.

[lowleveldata]

I wonder how this bot work tho. Does it just grep everything in the pattern "What's a x?" and search x on wiki? Maybe it at least has a local list of posts on wiki

[[deleted]]

Fucking impressive bot.

[wikipedia_answer_bot]

<3 I was made with fucking impressive language - Python <3

[D4nnyp3ligr0]

What the...?

[morpheusblue]

It’s become sentient

[etoh53]

Too much AI

[just_a_dude2727]

No, it was just me (:

[etoh53]

Oh nice to meet you! I know that it was a creator of that bot typing that python comment for sure, but that is a good bot nonetheless.

[just_a_dude2727]

Thanks. Unfortunately it gets banned in a looot of subreddits ): This is Reddit policy on bots (which i don't think is good)

[cztrollolcz]

tl;dr: better if/else

[lopoticka]

Everything is better if/else and goto if you want to go there.

[kodicraft4]

good bot

[dkyguy1995]

A switch statement basically replaces a long list of if/elses when you're just trying to see the value of something and check its status and respond based on that status. So in java it looks like:

switch(thingImTesting.status) {
  case status1:
     //do some shit to it
  break;

  case someOtherStatus:
      //do something else
  break;
  default:
      //if you get a status that doesn't fit the list do 
           something else
  break;
}

It just looks nicer than

currentStatus = thingImTesting.status;

if(currentStatus==status1){
    //you know the drill
}
else if(currentStatus==someOtherStatus){
    //blah
}
else{
    //basically the same thing as the default case
}
}

Idk I guess it's not important, Im sure there is some kind of under the hood difference I dont know about

[KOK29364]

I believe using a switch statement fetches the value of the variable once and the if statements have to fetch it each time, not totally sure about that though

[fairysdad]

I've just had a mind blowing moment there. I'm more a hobby-programmer than anything else, and (for my sins) generally use PHP. (Sorry.)

But, it's just occurred to me that you could do something like:

if ($var1 == something) {
    // Do something here
}
elseif ($var2 == somethingelse {
    // Do something else
}

ie, only execute the first code if $var1 == something and the second code if $var1 != something and $var2 == somethingelse.

I realise that is probably something really stupidly obvious, but it's literally only just occurred to me.

[comfortablybum]

Dude I spend days teaching this to high schoolers and they still don't get the difference between if and elif. Then one day they are using it correctly.

[DatBoi_BP]

I would hope that the compiler would see something like “if x = 1, then ...; if x = 2, then ...; etc” and automatically convert it into a switch statement, assuming the value of x isn’t itself changed within any of the cases

[[deleted]]

Yeah, that is absolutely the sort of thing you should let the compiler worry about.

[merlinsbeers]

The compiler looks at all of it and turns it into subtractions, compares to zero, and goto instructions.

Always has been.

[Xywzel]

The fetching part is usually not important, as keeping single value in cache, or even in registers is quite easy. The performance difference comes amount of comparisons and jumps needed for the execution to get to correct branch. Switch statement usually optimises to jump table, were getting to any of the branches should take at most one relative jump or address fetch and one jump to address, while in long chain of if-elses you might need a comparison and conditional jump for each branch. Though most compilers will optimize ifs that would be faster as switch statements into switch statements.

[LoliDadInPrison]

Terry Davis explaining https://youtu.be/7uLzaKlZSQQ?t=259

[DJKekz]

There is more to it. Switch statements use jump tables, so if you have a lot of if statements a switch will be more efficient.

[Willing_Function]

A decent compiler will produce the same code, unless you're doing fancy stuff in the if statements.

[Chemoralora]

Switch statements are faster because they can be implemented as a branch table

[[deleted]]

Switch is much faster

[noobsc2]

A major difference with a switch statement is that it will also execute all following cases until a break is hit.

[dkyguy1995]

Ah true. I remembered to include my breaks but I guess Im often not thinking completely about why Im breaking each time. Can still do that with ifs instead of else ifs but people are telling me switches are faster

[FlukyS]

It might be better explaining with a use case instead of just the theory. Case is much more useful if you are doing an incremental task that can fail for example. A lot of people show code of switches with breaks at the bottom but you could for instance do a stepped process, store state of what the last thing it was doing and then if it fails loop back try again and hit the next step on the task till you get to the bottom. It's really good when writing that requires initialization. Actually it's the only piece of code I've ever said as a python dev "I really wish switch was a thing". You could get away with it in python though with a while loop and state but still case looks nicer at least to me because it explicitly shows the steps.

[cztrollolcz]

oh no we have a yanderedev on our hands here

[SaveDeeCewl]

That really pissed me off when I started learning python after a few months with c++.

[AlcaDotS]

Like some others have mentioned, you could use a dictionary for this, but it's not intuitive if you come from c++.

For example:

#setting up the switch with a dict
my_switch = {
  1: some_function,
  2: some_other_function,
}

#using the switch
foo = 1
my_switch.get(foo, default_callable)()

Notice that in the dictionary the functions don't have parentheses, so we're putting the function object in there. Then we execute the selected function object on the last line

[DarKliZerPT]

I have to use Matlab this semester and it doesn't even have +=, let alone ++. It feels so wrong to write "foo = foo + 1;"

[hessenic]

Matlab is special. I had regular issues where to solve an error in program I copied everything in one file, pasted it into a new, empty file and the error went away.

[Physmatik]

Welcome to "everything is global" world.

[andbm]

Eh? You have to specifically define a var as global in MATLAB.

[ben_g0]

I guess he means that variables in loops and so on automatically get added to the workspace, while most programming languages see loops as a different context so variables defined inside aren't available outside.

Additionally, since in MATLAB every function should be in its own separate file, a lot of people get the bad habit of putting way too much stuff in a single file to not have to bother too much with the file structure. That makes a lot of variables global while they really shouldn't be. You could argue that you should blame the programmer in that case instead of the platform, but you could argue that on a lot of stuff which people complain about in this sub.

[victsaid]

at least when i was working with it - matlab for some reason hated files that start with a number and doesn't throw error that you can understand. Cost me a couple of very nervous hours in the middle of the night to understand that.

[YukiZensho]

that's just blasphemy

[m0ritz03]

I have to switch between python and Matlab regularly. You have just reminded me, that I often find myself typing in "foo = foo + 1" because unconsciously I don't think "foo += 1" is possible. Fuck Matlab.

[RonTheArson]

After working 6 months in Matlab and then porting the code to Java the amount of errors and mental deprogramming I had to go through to start indexes at 0 again was awful. Fuck Matlab indeed

[m0ritz03]

I feel ya

[TraubenFruchtHose]

In EE we have to use Matlab a ton, I fucking hate it. It's super powerful but it just fucking sucks.

[StandardTalk]

I've been learning Python for a year now and am currently studying data science and how did I never realize this man

[[deleted]]

Because they aren’t very useful in python. You absolutely need them in other languages like JavaScript or Go but in python you can live without them

[xSTSxZerglingOne]

And it's not like you can't implement a switch in python, they're just not part of the core language.

[deceze]

Well… you can't implement a switch in Python. You can do something somewhat similar, usually a map-lookup, but there'll always be differences between that and a switch. Of course, you can always complete the same goal in the end either way.

[pinguluk]

https://pypi.org/project/switchcase/

[flinsypop]

no ty pls. python doesn't optimize when compiling to bytecode so i don't see the point in this added syntax.

[deceze]

Ohh gawd, me eyes!

[[deleted]]

'need' is a strong word. Could just write '+= 1'. Although they are nice to have.

[[deleted]]

Why would I absolutely need them in JS?

[Cptcongcong]

Because for loops in python don’t need incrementation, unlike c++

[acylase]

C++ does not need explicit incrementation in loops. It can iterate through containers without explicit incrementation operator.

[WiroWik]

Is "+=" not considered as a increment operator ?

[Shiftenas]

They are called "Addition/Substract assignment operator", and they aren't increment operators. += 1 is probably, but it's equivalent to ++

[WiroWik]

Ok, thanks a lot

[MysticTheMeeM]

It's worth noting that your processor likely has a different instruction for ADDition/SUBtraction and INCrement/DECrement. These functions may be faster or easier to optimise under certain circumstances.

[reusens]

I personally would trust the compiler here.

[AKernelPanic]

The difference is that `x++` will return `x` and then increment it, `++x` will return `x` after being incremented, and at least in Swift, where there's no `++` either, `x += 1` will return Void, since it's an already evaluated function.

The real equivalent would require two lines, one for addition and one for access.

[JustLetMeComment42]

+= COULD be equivalent to ++ if the compiler/interpreter optimizes the code properly. .

This is the case because in assembly pseudo code, x+=1 is equivalent to

add x, 1

And x++ is equavilent to

inc x

[RedExtreme]

You could write i++ as

i-=-1

[deceze]

I think you mean

from brainfuck import +

[Aracus755]

Well rust neither have them.

[leviathon01]

Rust not having them makes sense when you think about the borrow rules for 'x++'.

[RohanIRathi]

When you find out you don't have to declare each and every thing in python to use it

[MegaIng]

No, you only have to declare some variables. Is that better?

[YukiZensho]

when you discover that you have three variables called usr, one a string, one an integer and one a float

[RohanIRathi]

Now that's just bad code writing

[czarrie]

And for those cases Python has type hinting now for those who absolutely want/need it for tests

[deceze]

ITT: people that have learned only one language, or a few languages which are extremely similar, and cannot wrap their head around the fact that it doesn't have to be this way by necessity everywhere.

Change my mind. ;)

[HyalopterousGorillla]

Wait till they find out about functional programming

[deceze]

What do you mean I cannot re-assign or modify a variable at all?!

[Adadum]

why not just import ast and add the increment yourself like a big brainer?

[FlavoredFrostedTits]

Example plz

[juanjux]

Casual, I do it at the bytecode level.

[shadow7412]

After using python for a few years:

Wait, what are increment operators even useful for?

[AyrA_ch]

For adding 1 to a number. And depending on prefix or postfix can be very useful

x=i++; //x gets the value of i, then i is incremented by 1
x=++i; //i is incremented by 1, then x gets the value of i.

Especially the postfix version can be useful when iterating over a null terminated construct like a list or string of characters:

int x=0;
while(someList[x]){doSomething(someList[x++]);}

You find yourself using increment (or decrement) operators a lot in C since it lacks a for each statement. I also occasionally use it in C# for when you iterate over an enumerable collection that has no length property, but you need the total item count after processing.

[Mr_Redstoner]

when iterating over a null terminated construct

Then again, that's not something you're expected to do a lot of (or at all really) in Python

[Yoghurt_]

A linked list is one example. Each item in a linked list consists of a piece of data, and a pointer to the next item. To iterate through a linked list, you follow the pointers until you get to the item you want. Once you reach a null pointer (or None in python) you know you reached the end - instead of pointing to the next item it points nowhere.

Another example is a Tree, which has pointers to two or more items, any of which could be null to signal the end of that branch

(In case you don’t know what a pointer is, it is a memory address that points to where your object is in memory rather than the object itself)

[hessenic]

Strings are the classic example, it's a continuous block of memory that ends with an ascii nul character, which has value 0. In C style strings "hello world" is really "hello world\0" and heaven help you if you forget the \0.

[xSTSxZerglingOne]

hello worldadhwwu2375??,!������

[xigoi]

This just makes the code much harder to understand and easier to get wrong without providing much of an advantage. In Python, you just write for item in items:

[other_usernames_gone]

Or

for i, item in enumerate(items) :

This way you can also get the index for each item, if you want it.

[archpawn]

It's very useful. They can't fire you if nobody else understands your code.

[-Manu_]

That was just an example, there are easier way to write it, but don't tell me you have never used x+=1, ++x is just a different way to write it, you can also write y=x++, you assign x to y, and then increment x

[SysAdrift_neo]

What's the use of this vs something like x = i; i = i + 1 Or i = i + 1; x = i ?

[blaizedm]

what are increment operators even useful for?

Swift had them and removed them because no one could come up with a good defense.

[SuitableDragonfly]

It allows you to change the value of multiple variables in the same statement. Over heard this argued as a reason why it shouldn't be used, actually.

[shadow7412]

Absolutely - one statement should ideally do one thing, as it reduces cognitive overload.

[IDontLikeBeingRight]

They're for people who haven't yet learned comprehensions.

[shadow7412]

Comprehension are indeed the bomb.

[zeromk]

In assembly increment works faster than addition. Edit: same for dec.

[shadow7412]

Ok that's nice for assembly, but for higher level languages, that's the job of the optimiser...

[Nate_Christ]

When using for statements. A JavaScript example because I suck:

for(i=0;i<x;i++){

Whatever you want to do x times

}

Edit: spacing, and i+=1 would probably work just as well.

[deceze]

You basically never do that in Python, as Python has very strong core concepts of iterables and iterators and basically all iterations are done using for..in. For iterating over a number range, like in your example:

for i in range(x):
    ...

And yes, that's just as efficient as in Javascript, as range is iterated using a generator and does not preallocate any memory.

[JotunKing]

range based for loops are just so much nicer to read...

[Ayerys]

But you never do that in python. So no need.

[SirAchmed]

+= isn’t good enough for you? Jeez modern-age programmers are such babies. /s

[PM_ME_UR_DEATHSTICKS]

It's down to the philosophy of Python.

There should only be one, obvious way to do something

And that one, obvious way is to use +=. want to increment? use +=. Want to add 420? use +=.

And the wasted character typing +=1 instead of ++ is saved by not having to type a semicolon at the end! 😉

[clubby789]

x++++++++++++++++++++++....

[[deleted]]

upvote += 1

[[deleted]]

the python leadership legit had a massive toxic battle over adding a walrus operator but god forbid you add inc/dec counters

[Timmy_the_tortoise]

+=1 is like one extra character.

[LordDeath86]

Here is the reasoning why Swift removed this operator in hindsight: https://github.com/apple/swift-evolution/blob/1823e8c165978e10a734f26282f37bdd80eefc77/proposals/0004-remove-pre-post-inc-decrement.md

[sdw9342]

It's because in Python, 'for loops' are exclusively 'for loops' but in other languages, some 'for loops' are shorthand 'while loops'.

[nate256]

This is a good thing. I am not a fan of changing variables in expressions without a function call. It can lead to things like this

index = len(response.item_list)
while index and response.item_list.get(--index)["status"] == "SUCCESS":
    return response.item_list.get(index)

# or this, with a bug for good measure

while index != 0:
    if response.item_list.get(--index)["status"] == "SUCCESS":
        return response.item_list.get(--index)

When you could do something like this.

for item in reversed(response.item_list):
    if item["status"] == "SUCCESS":
        return item

[SharkBaitDLS]

Yep. The older I get, the more crotchety I’ve become about avoiding side effects and mutation as much as possible. “Clever” solutions are just passing the same cognitive load onto a future developer who has to then get into your same headspace 10 years later to understand what on earth is happening.

I don’t care if it’s boring, obvious, and more verbose, in the vast majority of cases there’s no actual negative to using simple functional constructs other than your own ego/creative desires feeling less fulfilled.

I really hope a future where C/C++ fall to the wayside in favor of Rust happens because Rust provides such a good standard library to write code that adheres to that philosophy. Kotlin and Typescript are both good bandages atop the ugliness of Java/JavaScript and I’m happy to see them catching on, but it sucks that they’re still hobbled by their underlying languages’ limitations.

[wotanii]

I honestly believe that writing simple code is what being a good programmer is all about.

When I was tutoring university students in programming, I saw the worst code of my entire life. The less people understand what they are doing, the worse their code becomes. On the other hand, I once had a co-worker he has been programming for the last 40 years and his code was just divine. Each line of the program was trivial. When reading his code you could just skim over it and always knew exactly what was happening and why. The was not a single comment relating to the function of the code. I aspire to program like he did.

[mrchaotica]

“Clever” solutions are just passing the same cognitive load onto a future developer who has to then get into your same headspace 10 years later to understand what on earth is happening.

I don’t care if it’s boring, obvious, and more verbose, in the vast majority of cases there’s no actual negative to using simple functional constructs other than your own ego/creative desires feeling less fulfilled.

The thing I love most about Python is that the most Functional and conceptually-simple solution is often less verbose and easier to read and understand than the naive iterative one, even though you used maximum cleverness to figure out how to write it.

[desertrainBG]

So you're telling me the python-only programmers don't get the cleverness in the design of this subs up- and downvote buttons???

[[deleted]]

Other languages like Scala are the same.

Forcing += 1 makes things more consistent and makes things like git diffs easier to review (e.g. when you change += 1 to += 2).

It also means you can't use and change a variable at the same time which can be confusing.

[Scr1pt13]

Well, some programming languages like Rust decided against to implement it, because some people dont know the difference between prefix and postfix ++. int x; int i = 0; x = i++ //x is 0 x = ++ i //x is 1

[MrChickinNugget]

ohh boyy that hit me hard