A hard exercise to help build the right mental model for Python data.

The “Solution” link visualizes execution and reveals what’s actually happening using 𝗺𝗲𝗺𝗼𝗿𝘆_𝗴𝗿𝗮𝗽𝗵: https://github.com/bterwijn/memory_graph

  • eleijeep ( eleijeep@piefed.social ) English
    13·
    1 month ago

    The | and |= operators for dict were added in 3.9 which was released in 2020, so it’s a relatively recent feature.

    I like having an operator for set union but I don’t like that a |= b has different semantics to a = a|b. This violates the principle of least surprise, since the former is supposed to be a shorthand for the latter.

      • lad ( sukhmel@programming.dev ) English
        4·
        1 month ago

        I feel that things like this lead people to say something along the lines of ‘mutability was a mistake’

        I’m only half serious, but this is really surprising without Python background

        • bterwijn ( bterwijn@programming.dev ) OP
          2·
          1 month ago

          If you don’t want mutability you have to go to a pure functional language like Haskell, but then you have to copy a big list every time you make a change. There are ways to optimize copying by secretly sharing data behind the scene but you pay a performance price in some way. Then again, Python is slow and has mutability but popular for other reasons.

          • lad ( sukhmel@programming.dev ) English
            2·
            1 month ago

            I don’t think mutability is wrong as a concept, albeit I enjoyed learning and toying with Haskell, but I really think these functions in Python should have been two sets of operations, one set to do what a += b does and one set to do what a = a + b does.

            I’ve been doing C++ for quite some time and amount of implicit things that happen magically and not everyone get them right and this leads to bugs and confusion had really grown on me with time, and I feel like this is the same pattern here, where we get implicit magic instead of being clear with intentions and results

            • bterwijn ( bterwijn@programming.dev ) OP
              2·
              1 month ago

              I think the confusion comes from a += b being equivalent to a = a + b for immutable types, so some people generalize that incorrectly to mutable types too. Otherwise I think it’s pretty clear a += b mutates a, and a = a + b first computes a + b and then reassigns that to a so that its identity changes, just like in c = a + b.

              If you implement these operations in a class you have to implement each dunder, __iadd__(self, other) and __add__(self, other) separately, same thing in C++.