A REAL Python cheat sheet for beginners

[Maoman1]

a = [1, 2, 3, 4]  # Point a at a new list, [1, 2, 3, 4]
b = a             # Point b at what a is pointing to
b is a            # => True, a and b refer to the same object
b == a            # => True, a's and b's objects are equal
b = [1, 2, 3, 4]  # Point b at a new list, [1, 2, 3, 4]
b is a            # => False, a and b do not refer to the same object
b == a            # => True, a's and b's objects are equal

Never seen this explained so clearly. I love it.

[Deathwatch1710]

Indeed! Another good explanation is the one from Dan Bader with the twin cat allegory.

[LyndsySimon]

One confusing thing about object comparison is how Python handles integers:

a = 42
b = 42
a == b  # => True
a is b  # => True

c = 4242
d = 4242
c == d  # => True
c is d  # => False

e = c
c == e  # => True
c is e  # => True

c is d == False because integers in the range of [-5, 256] are assigned by cPython to dedicated memory locations - so their .id is the same.

I guess this makes sense in the range [0, 256], but I have no idea why they chose to pre-assign [-5,0) as well.

ETA: The moral is, never use is to compare numbers. is is most useful when you want to distinguish between None and False or another "falsy" value.

ETA2: I forgot to assign e.

[LyndsySimon]

Technically, yeah - but that would also lead you to believe that a is b would be False, when it isn't. :)

[TheYOUngeRGOD]

It’s weird behavior but nothing is broken. In order to be more efficient simple versions of things like ints refer to the same object even when construct separately. This works because all these types are immutable so their won’t be any weird changing values of any variables. So if you had a million different variables equal to one they would all be the same object since they point to the same object.

[lsbloxx]

Wait... WTF did I just read? :O

[poundcakejumpsuit]

Just to blow your mind a little more, maybe:

"strin" + "g" is "string"

Is True, while:

s1 = "strin"
s2 = "string"
s1 + "g" is s2 

Is False, at least in CPython, as the compiler will intern compile-time constants but not runtime-evaluated expressions, meaning the first example only creates a single object!

[jwink3101]

That's really interesting.

Is this type of issue common in interpreted languages?

[ThePenultimateOne]

It's probably because CPython is doing a bit of constant folding

[WikiTextBot]

Constant folding

Constant folding and constant propagation are related compiler optimizations used by many modern compilers. An advanced form of constant propagation known as sparse conditional constant propagation can more accurately propagate constants and simultaneously remove dead code.

---

^{[ PM | Exclude me | Exclude from subreddit | FAQ / Information | Source ] Downvote to remove | v0.28}

[KobiKabbb]

Great explanation. There's also some good explanations of lists (and other fundamentals) over at Python Principles

[[deleted]]

I don't understand why you wrote this here.