The difference between a |= b and a = a | b is exactly the same as the difference between a += b and a = a + b. Nothing new about that, try:

a = [1]
b = a
b += [2]
b.append(3)
b = b + [4]
b.append(5)

print(a)

or see: https://fosstodon.org/@bterwijn/116328991093782469

For immutable types there is no difference between a += b and a = a + b, try with a tuple.

It's mainly targeted to Python programmers at: https://programming.dev/c/python

The Solution link gives you a visualization of program execution, I've started to make the same sort of visualizer for C. What do you think?

C already has that class of operators, but lacks a set in the base language.

You are probably interacting with analogous operators all day long.

I don't see why extending those notions would cause you issues as a C programmer.

If you are interested see the dictionary docs (https://docs.python.org/3/builtins/stdtypes.html#dict):

d |= other Update the dictionary d with keys and values from other, which may be either a mapping or an iterable of key/value pairs. The values of other take priority when d and other share keys. Added in version 3.9.

Pick your answer and check the Solution link.

I didn't have previous exposure to that exact syntax either, but:

• Python and plenty other languages have assignment variations with an operator like +
• | in plenty of languages means logical OR
  • possibly bitwise, but that seems unlikely in Python
• Dicts are sorta complex siblings of sets
• In terms of sets, OR is equivalent to a union

Hence, a |=b should have the same meaning as a = a | b or a = a.union(b)

and then the quiz is about basically implementation details and what the actual semantics winds up being in a language like python, where stuff is mutable by default and references are implicit (even though the zen of python states a preference for being explicit)

Thanks, maybe I should have added that possible answer instead of 'D', adding one more feels too many.

Can you tell me what the problem is for you when you click the first link? I tried to make it work for all browsers (even mobile, but the UI isn't very mobile friendly), so I would like to get it working on your system too. If you can give me a bug report (and maybe try from different system), that would be great.

The second link explains:

• mutability: https://github.com/bterwijn/memory_graph#mutable-type
• shallow copy: https://github.com/bterwijn/memory_graph#copying-values-of-mutable-type
• difference between x += y and x = x + y: https://github.com/bterwijn/memory_graph#name-rebinding

It's left to the reader to generalize this to x |= y vs x = x | y.

The dict union operator is similar to that of set, but in addition the right operand overwrites values of keys of the left operand. It's a nice operator once you get used to it.

Easy to make a mistake with this exercise:

• first realize b = b | {3: []} makes a shallow copy
• then realize the shallow copy still references the value of key 2 in a so we can still append to that and change a

This is what the solution link is supposed to give you at the end of the execution animation:

It's hard to support all mobile browsers, on some it does work.