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
In last week’s post we showed that a Python for-loop works through the Iterator Protocol.
This same protocol also enables values to be produced lazily.
In this new Lazy Evalution Example we show one sink reading values from five different sources:
The same for-loop consumes all five sources. The eager sources produce all values before the sink starts consuming them. In the lazy sources producer and consumer take turns:
Each value is produced only when the for-loop requests it.
Generator functions and generator expressions are concise, readable ways to create lazy iterables. The final source makes their underlying mechanism explicit:
iter() obtains an iterator.next() requests the next value.StopIteration signals that no values remain.This clearly shows that generators achieve lazy iteration by implementing Python’s Iterator Protocol.
Yesterday my exercise got downvoted, probably because its point was unclear. I'd like to try again with this reworked exercise. Hope you'll like this one better.
__eq__() and __hash__() methods by default (inherited from the object class); with them, all objects compare unequal (except with themselves) and x.__hash__() returns an appropriate value such that x == y implies both that x is y and hash(x) == hash(y).”#Python #memory_graph #Equality #Hashing
An exercise to help build the right mental model for Python data.
#Python #memory_graph #Equality #Hashing
Recursion becomes much easier once students have the right mental model. Visualization will help get them there.
Take the Tower of Hanoi problem. The recursive solution is beautifully short, to move n disks we:
But when students try to implement recursion, they often get stuck, and adding debug prints only adds to the confusion. That is where visualization can help to bring the right mental model. Here is the Tower of Hanoi problem solved recursively, visualized with 𝗶𝗻𝘃𝗼𝗰𝗮𝘁𝗶𝗼𝗻_𝘁𝗿𝗲𝗲: https://www.invocation-tree.com/#codeurl=https%3A%2F%2Fraw.githubusercontent.com%2Fbterwijn%2Fmemory_graph_examples%2Frefs%2Fheads%2Fmain%2Ftowers_of_hanoi.py×tep=0.5&play=
Instead of thinking about “a function calling itself again and again” students can now see the depth-first execution of a tree of subproblems showing the divide-and-conquer strategy in action. Once a student can think in terms of a tree of subproblems, recursion becomes much easier to understand, explain, and debug.
#Python #invocation_tree #Recursion
The difference in Python OOP between:
visually explained using 𝗺𝗲𝗺𝗼𝗿𝘆_𝗴𝗿𝗮𝗽𝗵:
An 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
Data structures like Trie can in Python be easier understood and debugged after visualization using the memory_graph package.
A Trie is a tree of dictionaries and can be used for things like word completion.
Data structures become much easier to understand when students can see the structure of their data visualized using memory_graph. A data structure is no longer an abstract idea but concrete, clear and debuggable. Here’s a live demo of a Linear Linked List: https://memory-graph.com/#codeurl=https%3A%2F%2Fraw.githubusercontent.com%2Fbterwijn%2Fmemory_graph%2Frefs%2Fheads%2Fmain%2Fsrc%2Flinked_list_lin.py&breakpoints=27&continues=1×tep=0.2&play=
An exercise to help build the right mental model for Python data. The “Solution” link uses memory_graph to visualize execution and reveals what’s actually happening:
Understanding and debugging Python data structures gets easier with memory_graph visualization. Here's a Multiway Tree example. A Multiway Tree is similar to a Binary Tree but has an arbitrary number of children making the tree less deep and more efficient.
An exercise to help build the right mental model for Python data. The “Solution” link uses memory_graph to visualize execution and reveals what’s actually happening:
An exercise to help build the right mental model for Python data. The “Solution” link uses memory_graph to visualize execution and reveals what’s actually happening:
Teaching and learning Python bitwise operators gets much easier after showing the binary representations of integers using memory_graph: bitwise operators in Memory Graph Web Debugger
Understanding of the inverse ~ operator is helped by showing the two’s complement representation.
An exercise to help build the right mental model for Python data. The “Solution” link uses memory_graph to visualize execution and reveals what’s actually happening:
Some struggle with recursion, but as package invocation_tree visualizes the Python call tree in real time, it gets easy to understand what is going on and to debug any remaining issues.
See this one-click Quick Sort demo in the Invocation Tree Web Debugger.
Better understand the Python Data Model or Data Structures by memory_graph visualization with just one click:
See the Solution and Explanation.
Hi, I'm new, I'd like to share my new Memory Graph Web Debugger that you can use to visualize and debug your Python data structures with just one click. This is an example of a binary tree implementation. I feel this tool could level up Python education. I'm interested in your thoughts about it, feedback welcome.
