| 47 | 48 | ```python 49 | import memory_graph as mg 50 | 51 | # create the lists 'a' and 'b' 52 | a = [4, 3, 2] 53 | b = a 54 | b.append(1) # changing 'b' changes 'a' 55 | 56 | # print the 'a' and 'b' list 57 | print('a:', a) 58 | print('b:', b) 59 | 60 | # check if 'a' and 'b' share data 61 | print('ids:', id(a), id(b)) 62 | print('identical?:', a is b) 63 | 64 | # show all local variables in a graph 65 | mg.show( locals() ) 66 | ``` 67 | 68 | | 69 | 70 |  71 | 72 | a graph showing `a` and `b` share data 73 | 74 | |
126 |
127 | ___
128 | ___
129 |
130 | # Python Data Model #
131 | The [Python Data Model](https://docs.python.org/3/reference/datamodel.html) makes a distiction between immutable and mutable types:
132 |
133 | * **immutable**: bool, int, float, complex, str, tuple, bytes, frozenset
134 | * **mutable**: list, set, dict, classes, ... (most other types)
135 |
136 |
137 | ## Immutable Type ##
138 | In the code below variable `a` and `b` both reference the same tuple value (4, 3, 2). A tuple is an immutable type and therefore when we change variable `b` its value **cannot** be mutated in place, and thus an automatic copy is made and `a` and `b` reference a different value afterwards.
139 |
140 | ```python
141 | import memory_graph as mg
142 |
143 | a = (4, 3, 2)
144 | b = a
145 | mg.render(locals(), 'immutable1.png')
146 |
147 | b += (1,)
148 | mg.render(locals(), 'immutable2.png')
149 | ```
150 | |  |  |
151 | |:-----------------------------------------------------------:|:-------------------------------------------------------------:|
152 | | immutable1.png | immutable2.png |
153 |
154 |
155 | ## Mutable Type ##
156 | With mutable types the result is different. In the code below variable `a` and `b` both reference the same `list` value [4, 3, 2]. A `list` is a mutable type and therefore when we change variable `b` its value **can** be mutated in place and thus `a` and `b` both reference the same new value afterwards. Thus changing `b` also changes `a` and vice versa. Sometimes we want this but other times we don't and then we will have to make a copy ourselfs so that `a` and `b` are independent.
157 |
158 | ```python
159 | import memory_graph as mg
160 |
161 | a = [4, 3, 2]
162 | b = a
163 | mg.render(locals(), 'mutable1.png')
164 |
165 | b += [1] # equivalent to: b.append(1)
166 | mg.render(locals(), 'mutable2.png')
167 | ```
168 | |  |  |
169 | |:-----------------------------------------------------------:|:-------------------------------------------------------------:|
170 | | mutable1.png | mutable2.png |
171 |
172 | One practical reason why Python makes the distinction between mutable and immutable types is that a value of a mutable type can be large, making it inefficient to copy each time we change it. Immutable values generally don't need to change as much, or are small making copying less of a concern.
173 |
174 | ## Copying ##
175 | Python offers three different "copy" options that we will demonstrate using a nested list:
176 |
177 | ```python
178 | import memory_graph as mg
179 | import copy
180 |
181 | a = [ [1, 2], ['x', 'y'] ] # a nested list (a list containing lists)
182 |
183 | # three different ways to make a "copy" of 'a':
184 | c1 = a
185 | c2 = copy.copy(a) # equivalent to: a.copy() a[:] list(a)
186 | c3 = copy.deepcopy(a)
187 |
188 | mg.show(locals())
189 | ```
190 |
191 | * `c1` is an **assignment**, nothing is copied, all the values are shared
192 | * `c2` is a **shallow copy**, only the value referenced by the first reference is copied, all the underlying values are shared
193 | * `c3` is a **deep copy**, all the values are copied, nothing is shared
194 |
195 | 
196 |
197 |
198 | ## Custom Copy ##
199 | We can write our own custom copy function or method in case the three standard "copy" options don't do what we want. For example, in the code below the copy() method of My_Class copies the `digits` but shares the `letters` between two objects.
200 |
201 | ```python
202 | import memory_graph as mg
203 | import copy
204 |
205 | class My_Class:
206 |
207 | def __init__(self):
208 | self.digits = [1, 2]
209 | self.letters = ['x', 'y']
210 |
211 | def custom_copy(self):
212 | """ Copies 'digits' but shares 'letters'. """
213 | c = copy.copy(self)
214 | c.digits = copy.copy(self.digits)
215 | return c
216 |
217 | a = My_Class()
218 | b = a.custom_copy()
219 |
220 | mg.show(locals())
221 | ```
222 | 
223 |
224 | ## Name Rebinding ##
225 | When `a` and `b` share a mutable value, then changing the value of `b` changes the value of `a` and vice versa. However, reassigning `b` does not change `a`. When you reassign `b`, you only rebind the name `b` to a new value without effecting any other variables.
226 |
227 | ```python
228 | import memory_graph as mg
229 |
230 | a = [4, 3, 2]
231 | b = a
232 | mg.render(locals(), 'rebinding1.png')
233 |
234 | b += [1] # changes the value of 'b' and 'a'
235 | b = [100, 200] # rebinds 'b' to a new value, 'a' is uneffected
236 | mg.render(locals(), 'rebinding2.png')
237 | ```
238 | |  |  |
239 | |:-----------------------------------------------------------:|:-------------------------------------------------------------:|
240 | | rebinding1.png | rebinding2.png |
241 |
242 | # Call Stack #
243 | The `mg.stack()` function retrieves the entire call stack, including the local variables for each function on the stack. This enables us to visualize the local variables across all active functions simultaneously. By examining the graph, we can determine whether any local variables from different functions share data. For instance, consider the function `add_one()` which adds the value `1` to each of its parameters `a`, `b`, and `c`.
244 |
245 | ```python
246 | import memory_graph as mg
247 |
248 | def add_one(a, b, c):
249 | a += [1]
250 | b += (1,)
251 | c += [1]
252 | mg.show(mg.stack())
253 |
254 | a = [4, 3, 2]
255 | b = (4, 3, 2)
256 | c = [4, 3, 2]
257 |
258 | add_one(a, b, c.copy())
259 | print(f"a:{a} b:{b} c:{c}")
260 | ```
261 | 
262 |
263 | In the printed output only `a` is changed as a result of the function call:
264 | ```
265 | a:[4, 3, 2, 1] b:(4, 3, 2) c:[4, 3, 2]
266 | ```
267 |
268 | This is because `b` is of immutable type 'tuple' so its value gets copied automatically when it is changed. And because the function is called with a copy of `c`, its original value is not changed by the function. The value of variable `a` is the only value of mutable type that is shared between the root stack frame **'0: \See the memory_graph python package.
59 | Log:
Python Code:
64 | 86 | 87 |Graph:
90 | 91 |Output:
95 | 96 |