-
Notifications
You must be signed in to change notification settings - Fork 54
/
Copy pathVariables_and_Assignment.html
349 lines (317 loc) · 33.8 KB
/
Variables_and_Assignment.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
<!DOCTYPE html>
<html class="writer-html5" lang="en" >
<head>
<meta charset="utf-8" /><meta content="Topic: variable naming and assignment, Difficulty: Medium, Category: Section" name="description" />
<meta content="variable naming, valid names, mutable, immutable, reference, pointer" name="keywords" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Variables & Assignment — Python Like You Mean It</title>
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<link rel="stylesheet" href="../_static/css/theme.css" type="text/css" />
<link rel="stylesheet" href="../_static/my_theme.css" type="text/css" />
<!--[if lt IE 9]>
<script src="../_static/js/html5shiv.min.js"></script>
<![endif]-->
<script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
<script src="../_static/jquery.js"></script>
<script src="../_static/underscore.js"></script>
<script src="../_static/doctools.js"></script>
<script async="async" src="https://www.googletagmanager.com/gtag/js?id=UA-115029372-1"></script>
<script src="../_static/gtag.js"></script>
<script crossorigin="anonymous" integrity="sha256-Ae2Vz/4ePdIu6ZyI/5ZGsYnb+m0JlOmKPjt6XZ9JJkA=" src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.4/require.min.js"></script>
<script>window.MathJax = {"tex": {"inlineMath": [["$", "$"], ["\\(", "\\)"]], "processEscapes": true}, "options": {"ignoreHtmlClass": "tex2jax_ignore|mathjax_ignore|document", "processHtmlClass": "tex2jax_process|mathjax_process|math|output_area"}}</script>
<script defer="defer" src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
<script src="../_static/js/theme.js"></script>
<link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" />
<link rel="next" title="Introducing Control Flow" href="Introduction.html" />
<link rel="prev" title="Sequence Types" href="SequenceTypes.html" />
</head>
<body class="wy-body-for-nav">
<div class="wy-grid-for-nav">
<nav data-toggle="wy-nav-shift" class="wy-nav-side">
<div class="wy-side-scroll">
<div class="wy-side-nav-search" >
<a href="../index.html" class="icon icon-home"> Python Like You Mean It
</a>
<div class="version">
1.4
</div>
<div role="search">
<form id="rtd-search-form" class="wy-form" action="../search.html" method="get">
<input type="text" name="q" placeholder="Search docs" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
</div>
</div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
<p class="caption" role="heading"><span class="caption-text">Table of Contents:</span></p>
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="../intro.html">Python Like You Mean It</a></li>
<li class="toctree-l1"><a class="reference internal" href="../module_1.html">Module 1: Getting Started with Python</a></li>
<li class="toctree-l1 current"><a class="reference internal" href="../module_2.html">Module 2: The Essentials of Python</a><ul class="current">
<li class="toctree-l2"><a class="reference internal" href="Basic_Objects.html">Basic Object Types</a></li>
<li class="toctree-l2"><a class="reference internal" href="SequenceTypes.html">Sequence Types</a></li>
<li class="toctree-l2 current"><a class="current reference internal" href="#">Variables & Assignment</a><ul>
<li class="toctree-l3"><a class="reference internal" href="#Valid-Names-for-Variables">Valid Names for Variables</a></li>
<li class="toctree-l3"><a class="reference internal" href="#Mutable-and-Immutable-Objects">Mutable and Immutable Objects</a><ul>
<li class="toctree-l4"><a class="reference internal" href="#Mutable-&-Immutable-Types-of-Objects">Mutable & Immutable Types of Objects</a></li>
</ul>
</li>
<li class="toctree-l3"><a class="reference internal" href="#Referencing-a-Mutable-Object-with-Multiple-Variables">Referencing a Mutable Object with Multiple Variables</a></li>
<li class="toctree-l3"><a class="reference internal" href="#Reading-Comprehension-Exercise-Solutions:">Reading Comprehension Exercise Solutions:</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="Introduction.html">Introducing Control Flow</a></li>
<li class="toctree-l2"><a class="reference internal" href="ConditionalStatements.html">Conditional Statements</a></li>
<li class="toctree-l2"><a class="reference internal" href="ForLoops.html">For-Loops and While-Loops</a></li>
<li class="toctree-l2"><a class="reference internal" href="Iterables.html">Iterables</a></li>
<li class="toctree-l2"><a class="reference internal" href="Generators_and_Comprehensions.html">Generators & Comprehension Expressions</a></li>
<li class="toctree-l2"><a class="reference internal" href="Itertools.html">Python’s “Itertools”</a></li>
<li class="toctree-l2"><a class="reference internal" href="Functions.html">Basics of Functions</a></li>
<li class="toctree-l2"><a class="reference internal" href="Scope.html">Scope</a></li>
<li class="toctree-l2"><a class="reference internal" href="DataStructures.html">Data Structures (Part I): Introduction</a></li>
<li class="toctree-l2"><a class="reference internal" href="DataStructures_II_Dictionaries.html">Data Structures (Part II): Dictionaries</a></li>
<li class="toctree-l2"><a class="reference internal" href="DataStructures_III_Sets_and_More.html">Data Structures (Part III): Sets & the Collections Module</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="../module_2_problems.html">Module 2: Problems</a></li>
<li class="toctree-l1"><a class="reference internal" href="../module_3.html">Module 3: The Essentials of NumPy</a></li>
<li class="toctree-l1"><a class="reference internal" href="../module_3_problems.html">Module 3: Problems</a></li>
<li class="toctree-l1"><a class="reference internal" href="../module_4.html">Module 4: Object Oriented Programming</a></li>
<li class="toctree-l1"><a class="reference internal" href="../module_5.html">Module 5: Odds and Ends</a></li>
<li class="toctree-l1"><a class="reference internal" href="../changes.html">Changelog</a></li>
</ul>
</div>
</div>
</nav>
<section data-toggle="wy-nav-shift" class="wy-nav-content-wrap"><nav class="wy-nav-top" aria-label="Mobile navigation menu" >
<i data-toggle="wy-nav-top" class="fa fa-bars"></i>
<a href="../index.html">Python Like You Mean It</a>
</nav>
<div class="wy-nav-content">
<div class="rst-content">
<div role="navigation" aria-label="Page navigation">
<ul class="wy-breadcrumbs">
<li><a href="../index.html" class="icon icon-home"></a> »</li>
<li><a href="../module_2.html">Module 2: The Essentials of Python</a> »</li>
<li>Variables & Assignment</li>
<li class="wy-breadcrumbs-aside">
<a href="../_sources/Module2_EssentialsOfPython/Variables_and_Assignment.md.txt" rel="nofollow"> View page source</a>
</li>
</ul>
<hr/>
</div>
<div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
<div itemprop="articleBody">
<style>
/* CSS overrides for sphinx_rtd_theme */
/* 24px margin */
.nbinput.nblast.container,
.nboutput.nblast.container {
margin-bottom: 19px; /* padding has already 5px */
}
/* ... except between code cells! */
.nblast.container + .nbinput.container {
margin-top: -19px;
}
.admonition > p:before {
margin-right: 4px; /* make room for the exclamation icon */
}
/* Fix math alignment, see https://github.com/rtfd/sphinx_rtd_theme/pull/686 */
.math {
text-align: unset;
}
</style>
<div class="section" id="Variables-&-Assignment">
<h1>Variables & Assignment<a class="headerlink" href="#Variables-&-Assignment" title="Permalink to this headline"></a></h1>
<div class="admonition warning">
<p class="admonition-title fa fa-exclamation-circle"><strong>Note</strong>:</p>
<p>There are reading-comprehension exercises included throughout the text. These are meant to help you put your reading to practice. Solutions for the exercises are included at the bottom of this page.</p>
</div>
<p>Variables permit us to write code that is flexible and amendable to repurpose. Suppose we want to write code that logs a student’s grade on an exam. The logic behind this process should not depend on whether we are logging Brian’s score of 92% versus Ashley’s score of 94%. As such, we can utilize variables, say <code class="docutils literal notranslate"><span class="pre">name</span></code> and <code class="docutils literal notranslate"><span class="pre">grade</span></code>, to serve as placeholders for this information. In this subsection, we will demonstrate how to define variables in Python.</p>
<p>In Python, the <code class="docutils literal notranslate"><span class="pre">=</span></code> symbol represents the “assignment” operator. The variable goes to the left of <code class="docutils literal notranslate"><span class="pre">=</span></code>, and the object that is being assigned to the variable goes to the right:</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">name</span> <span class="o">=</span> <span class="s2">"Brian"</span> <span class="c1"># the variable `name` is being assigned the string "Brian"</span>
<span class="n">grade</span> <span class="o">=</span> <span class="mi">92</span> <span class="c1"># the variable `grade` is being assigned the integer 92</span>
</pre></div>
</div>
<p>Attempting to reverse the assignment order (e.g. <code class="docutils literal notranslate"><span class="pre">92</span> <span class="pre">=</span> <span class="pre">name</span></code>) will result in a syntax error. When a variable is assigned an object (like a number or a string), it is common to say that the variable <strong>is a reference to</strong> that object. For example, the variable <code class="docutils literal notranslate"><span class="pre">name</span></code> references the string <code class="docutils literal notranslate"><span class="pre">"Brian"</span></code>. This means that, once a variable is assigned an object, it can be used elsewhere in your code as a reference to (or placeholder for) that object:</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># demonstrating the use of variables in code</span>
<span class="n">name</span> <span class="o">=</span> <span class="s2">"Brian"</span>
<span class="n">grade</span> <span class="o">=</span> <span class="mi">92</span>
<span class="n">failing</span> <span class="o">=</span> <span class="kc">False</span>
<span class="k">if</span> <span class="n">grade</span> <span class="o"><</span> <span class="mi">60</span><span class="p">:</span>
<span class="n">failing</span> <span class="o">=</span> <span class="kc">True</span>
<span class="c1"># writes: name | grade | passing-status</span>
<span class="c1"># to the end of the file "student_grades.txt"</span>
<span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="s2">"student_grades.txt"</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s2">"a"</span><span class="p">)</span> <span class="k">as</span> <span class="n">opened_file</span><span class="p">:</span>
<span class="n">opened_file</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s2">"</span><span class="si">{}</span><span class="s2"> | </span><span class="si">{}</span><span class="s2"> | </span><span class="si">{}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">grade</span><span class="p">,</span> <span class="n">failing</span><span class="p">))</span>
</pre></div>
</div>
<div class="section" id="Valid-Names-for-Variables">
<h2>Valid Names for Variables<a class="headerlink" href="#Valid-Names-for-Variables" title="Permalink to this headline"></a></h2>
<p>A variable name may consist of alphanumeric characters (<code class="docutils literal notranslate"><span class="pre">a-z</span></code>, <code class="docutils literal notranslate"><span class="pre">A-Z</span></code>, <code class="docutils literal notranslate"><span class="pre">0-9</span></code>) and the underscore symbol (<code class="docutils literal notranslate"><span class="pre">_</span></code>); a valid name cannot begin with a numerical value.</p>
<ul class="simple">
<li><p><code class="docutils literal notranslate"><span class="pre">var</span></code>: valid</p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">_var2</span></code>: valid</p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">ApplePie_Yum_Yum</span></code>: valid</p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">2cool</span></code>: <strong>invalid</strong> (begins with a numerical character)</p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">I.am.the.best</span></code>: <strong>invalid</strong> (contains <code class="docutils literal notranslate"><span class="pre">.</span></code>)</p></li>
</ul>
<p>They also cannot conflict with character sequences that are reserved by the Python language. As such, the following cannot be used as variable names:</p>
<ul class="simple">
<li><p><code class="docutils literal notranslate"><span class="pre">for</span></code>, <code class="docutils literal notranslate"><span class="pre">while</span></code>, <code class="docutils literal notranslate"><span class="pre">break</span></code>, <code class="docutils literal notranslate"><span class="pre">pass</span></code>, <code class="docutils literal notranslate"><span class="pre">continue</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">in</span></code>, <code class="docutils literal notranslate"><span class="pre">is</span></code>, <code class="docutils literal notranslate"><span class="pre">not</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">if</span></code>, <code class="docutils literal notranslate"><span class="pre">else</span></code>, <code class="docutils literal notranslate"><span class="pre">elif</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">def</span></code>, <code class="docutils literal notranslate"><span class="pre">class</span></code>, <code class="docutils literal notranslate"><span class="pre">return</span></code>, <code class="docutils literal notranslate"><span class="pre">yield</span></code>, <code class="docutils literal notranslate"><span class="pre">raises</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">import</span></code>, <code class="docutils literal notranslate"><span class="pre">from</span></code>, <code class="docutils literal notranslate"><span class="pre">as</span></code>, <code class="docutils literal notranslate"><span class="pre">with</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">try</span></code>, <code class="docutils literal notranslate"><span class="pre">except</span></code>, <code class="docutils literal notranslate"><span class="pre">finally</span></code></p></li>
</ul>
<p>There are other unicode characters that are permitted as valid characters in a Python variable name, but it is not worthwhile to delve into those details here.</p>
</div>
<div class="section" id="Mutable-and-Immutable-Objects">
<h2>Mutable and Immutable Objects<a class="headerlink" href="#Mutable-and-Immutable-Objects" title="Permalink to this headline"></a></h2>
<p>The <strong>mutability</strong> of an object refers to its ability to have its state changed. A <strong>mutable object</strong> can have its state changed, whereas an <strong>immutable object</strong> cannot. For instance, a list is an example of a mutable object. Once formed, we are able to update the contents of a list - replacing, adding to, and removing its elements.</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># demonstrating the mutability of a list</span>
<span class="o">>>></span> <span class="n">x</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
<span class="o">>>></span> <span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="o">-</span><span class="mi">4</span> <span class="c1"># replace element-0 of `x` with -4</span>
<span class="o">>>></span> <span class="n">x</span>
<span class="p">[</span><span class="o">-</span><span class="mi">4</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
</pre></div>
</div>
<p>To spell out what is transpiring here, we:</p>
<ol class="arabic simple">
<li><p>Create (initialize) a list with the state <code class="docutils literal notranslate"><span class="pre">[1,</span> <span class="pre">2,</span> <span class="pre">3]</span></code>.</p></li>
<li><p>Assign this list to the variable <code class="docutils literal notranslate"><span class="pre">x</span></code>; <code class="docutils literal notranslate"><span class="pre">x</span></code> is now a reference to that list.</p></li>
<li><p>Using our referencing variable, <code class="docutils literal notranslate"><span class="pre">x</span></code>, update element-0 of the list to store the integer <code class="docutils literal notranslate"><span class="pre">-4</span></code>.</p></li>
</ol>
<p>This does not create a new list object, rather it <em>mutates</em> our original list. This is why printing <code class="docutils literal notranslate"><span class="pre">x</span></code> in the console displays <code class="docutils literal notranslate"><span class="pre">[-4,</span> <span class="pre">2,</span> <span class="pre">3]</span></code> and not <code class="docutils literal notranslate"><span class="pre">[1,</span> <span class="pre">2,</span> <span class="pre">3]</span></code>.</p>
<p>A tuple is an example of an immutable object. Once formed, there is no mechanism by which one can change of the state of a tuple; and any code that appears to be updating a tuple is in fact creating an entirely new tuple.</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># demonstrating to the immutability of a tuple</span>
<span class="o">>>></span> <span class="n">x</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="o">>>></span> <span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="o">-</span><span class="mi">4</span> <span class="c1"># attempt to replace element-0 of `x` with -4</span>
<span class="o">---------------------------------------------------------------------------</span>
<span class="ne">TypeError</span> <span class="n">Traceback</span> <span class="p">(</span><span class="n">most</span> <span class="n">recent</span> <span class="n">call</span> <span class="n">last</span><span class="p">)</span>
<span class="o"><</span><span class="n">ipython</span><span class="o">-</span><span class="nb">input</span><span class="o">-</span><span class="mi">11</span><span class="o">-</span><span class="n">a858573fdc63</span><span class="o">></span> <span class="ow">in</span> <span class="o"><</span><span class="n">module</span><span class="o">></span><span class="p">()</span>
<span class="mi">1</span> <span class="n">x</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="o">----></span> <span class="mi">2</span> <span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="o">-</span><span class="mi">4</span> <span class="c1"># attempt to replace element-0 of `x` with -4</span>
<span class="ne">TypeError</span><span class="p">:</span> <span class="s1">'tuple'</span> <span class="nb">object</span> <span class="n">does</span> <span class="ow">not</span> <span class="n">support</span> <span class="n">item</span> <span class="n">assignment</span>
</pre></div>
</div>
<div class="section" id="Mutable-&-Immutable-Types-of-Objects">
<h3>Mutable & Immutable Types of Objects<a class="headerlink" href="#Mutable-&-Immutable-Types-of-Objects" title="Permalink to this headline"></a></h3>
<p>The following are some common immutable and mutable objects in Python. These will be important to have in mind as we start to work with dictionaries and sets.</p>
<p><strong>Some immutable objects</strong></p>
<ul class="simple">
<li><p><a class="reference external" href="https://www.pythonlikeyoumeanit.com/Module2_EssentialsOfPython/Basic_Objects.html#Number-Types">numbers</a> (integers, floating-point numbers, complex numbers)</p></li>
<li><p><a class="reference external" href="https://www.pythonlikeyoumeanit.com/Module2_EssentialsOfPython/Basic_Objects.html#Strings">strings</a></p></li>
<li><p><a class="reference external" href="https://www.pythonlikeyoumeanit.com/Module2_EssentialsOfPython/SequenceTypes.html#Tuples">tuples</a></p></li>
<li><p><a class="reference external" href="https://www.pythonlikeyoumeanit.com/Module2_EssentialsOfPython/Basic_Objects.html#The-Boolean-Type">booleans</a></p></li>
<li><p><a class="reference external" href="https://www.pythonlikeyoumeanit.com/Module2_EssentialsOfPython/DataStructures_III_Sets_and_More.html#The-%E2%80%9CSet%E2%80%9D-Data-Structure">“frozen”-sets</a></p></li>
</ul>
<p><strong>Some mutable objects</strong></p>
<ul class="simple">
<li><p><a class="reference external" href="https://www.pythonlikeyoumeanit.com/Module2_EssentialsOfPython/Basic_Objects.html#Lists">lists</a></p></li>
<li><p><a class="reference external" href="https://www.pythonlikeyoumeanit.com/Module2_EssentialsOfPython/DataStructures_II_Dictionaries.html">dictionaries</a></p></li>
<li><p><a class="reference external" href="https://www.pythonlikeyoumeanit.com/Module2_EssentialsOfPython/DataStructures_III_Sets_and_More.html#The-%E2%80%9CSet%E2%80%9D-Data-Structure">sets</a></p></li>
<li><p><a class="reference external" href="https://www.pythonlikeyoumeanit.com/module_3.html">NumPy arrays</a></p></li>
</ul>
</div>
</div>
<div class="section" id="Referencing-a-Mutable-Object-with-Multiple-Variables">
<h2>Referencing a Mutable Object with Multiple Variables<a class="headerlink" href="#Referencing-a-Mutable-Object-with-Multiple-Variables" title="Permalink to this headline"></a></h2>
<p>It is possible to assign variables to other, existing variables. Doing so will cause the variables to reference the same object:</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># demonstrating the behavior of variables</span>
<span class="c1"># referencing the same object</span>
<span class="o">>>></span> <span class="n">list1</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span> <span class="c1"># `list1` references [1, 2, 3]</span>
<span class="o">>>></span> <span class="n">list2</span> <span class="o">=</span> <span class="n">list1</span> <span class="c1"># `list2` and `list1` now both reference [1, 2, 3]</span>
<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">list1</span><span class="p">)</span>
<span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">list2</span><span class="p">)</span>
<span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
</pre></div>
</div>
<p>What this entails is that these common variables will reference the <em>same instance</em> of the list. Meaning that if the list changes, all of the variables referencing that list will reflect this change:</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">list1</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span> <span class="c1"># append 4 to the end of [1, 2, 3]</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">list1</span><span class="p">)</span>
<span class="go">[1, 2, 3, 4]</span>
</pre></div>
</div>
<p>We can see that <code class="docutils literal notranslate"><span class="pre">list2</span></code> is still assigned to reference the <em>same, updated</em> list as <code class="docutils literal notranslate"><span class="pre">list1</span></code>:</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">list2</span><span class="p">)</span>
<span class="go">[1, 2, 3, 4]</span>
</pre></div>
</div>
<p>In general, assigning a variable <code class="docutils literal notranslate"><span class="pre">b</span></code> to a variable <code class="docutils literal notranslate"><span class="pre">a</span></code> will cause the variables to reference the <em>same</em> object in the system’s memory, and assigning <code class="docutils literal notranslate"><span class="pre">c</span></code> to <code class="docutils literal notranslate"><span class="pre">a</span></code> or <code class="docutils literal notranslate"><span class="pre">b</span></code> will simply have a third variable reference this same object. Then any change (a.k.a <em>mutation</em>) of the object will be reflected in all of the variables that reference it (<code class="docutils literal notranslate"><span class="pre">a</span></code>, <code class="docutils literal notranslate"><span class="pre">b</span></code>, and <code class="docutils literal notranslate"><span class="pre">c</span></code>).</p>
<p>Of course, assigning two variables to identical but <em>distinct</em> lists means that a change to one list will not affect the other:</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">list1</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span> <span class="c1"># `list1` references [1, 2, 3]</span>
<span class="gp">>>> </span><span class="n">list2</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span> <span class="c1"># `list2` references a *separate* list, whose value is [1, 2, 3]</span>
<span class="gp">>>> </span><span class="n">list1</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span> <span class="c1"># append 4 to the end of [1, 2, 3]</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">list1</span><span class="p">)</span>
<span class="go">[1, 2, 3, 4]</span>
<span class="gp">>>> </span><span class="nb">print</span><span class="p">(</span><span class="n">list2</span><span class="p">)</span> <span class="c1"># `list2` still references its own list</span>
<span class="go">[1, 2, 3]</span>
</pre></div>
</div>
<div class="admonition note">
<p class="admonition-title fa fa-exclamation-circle"><strong>Reading Comprehension: Does slicing a list produce a reference to that list?</strong></p>
<p>Suppose <code class="docutils literal notranslate"><span class="pre">x</span></code> is assigned a list, and that <code class="docutils literal notranslate"><span class="pre">y</span></code> is assigned a “slice” of <code class="docutils literal notranslate"><span class="pre">x</span></code>. Do <code class="docutils literal notranslate"><span class="pre">x</span></code> and <code class="docutils literal notranslate"><span class="pre">y</span></code> reference the same list? That is, if you update part of the subsequence common to <code class="docutils literal notranslate"><span class="pre">x</span></code> and <code class="docutils literal notranslate"><span class="pre">y</span></code>, does that change show up in both of them? Write some simple code to investigate this.</p>
</div>
<div class="admonition note">
<p class="admonition-title fa fa-exclamation-circle"><strong>Reading Comprehension: Understanding References</strong></p>
<p>Based on our discussion of mutable and immutable objects, predict what the value of <code class="docutils literal notranslate"><span class="pre">y</span></code> will be in the following circumstance:</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">x</span> <span class="o">=</span> <span class="mi">3</span>
<span class="gp">>>> </span><span class="n">y</span> <span class="o">=</span> <span class="n">x</span>
<span class="go"># shorthand for: `x = x * 3`</span>
<span class="gp">>>> </span><span class="n">x</span> <span class="o">*=</span> <span class="mi">3</span>
<span class="gp">>>> </span><span class="n">x</span>
<span class="go">9</span>
<span class="gp">>>> </span><span class="n">y</span>
<span class="go">???</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="Reading-Comprehension-Exercise-Solutions:">
<h2>Reading Comprehension Exercise Solutions:<a class="headerlink" href="#Reading-Comprehension-Exercise-Solutions:" title="Permalink to this headline"></a></h2>
<p><strong>Does slicing a list produce a reference to that list?: Solution</strong></p>
<p>Based on the following behavior, we can conclude that slicing a list does <strong>not</strong> produce a reference to the original list. Rather, slicing a list produces a copy of the appropriate subsequence of the list:</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">x</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
<span class="gp">>>> </span><span class="n">y</span> <span class="o">=</span> <span class="n">x</span><span class="p">[:</span><span class="mi">2</span><span class="p">]</span>
<span class="gp">>>> </span><span class="n">y</span> <span class="c1"># does `y` reference the same list as `x`?</span>
<span class="go">[0, 1]</span>
<span class="gp">>>> </span><span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1</span> <span class="c1"># update one of the entries of the list that `x` references</span>
<span class="gp">>>> </span><span class="n">x</span>
<span class="go">[-1, 1, 2, 3]</span>
<span class="gp">>>> </span><span class="n">y</span> <span class="c1"># the list that `y` references was unaffected by the update</span>
<span class="go">[0, 1]</span>
</pre></div>
</div>
<p><strong>Understanding References: Solutions</strong></p>
<p>Integers are immutable, thus <code class="docutils literal notranslate"><span class="pre">x</span></code> must reference an entirely new object (<code class="docutils literal notranslate"><span class="pre">9</span></code>), and <code class="docutils literal notranslate"><span class="pre">y</span></code> still references <code class="docutils literal notranslate"><span class="pre">3</span></code>.</p>
</div>
</div>
</div>
</div>
<footer><div class="rst-footer-buttons" role="navigation" aria-label="Footer">
<a href="SequenceTypes.html" class="btn btn-neutral float-left" title="Sequence Types" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left" aria-hidden="true"></span> Previous</a>
<a href="Introduction.html" class="btn btn-neutral float-right" title="Introducing Control Flow" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right" aria-hidden="true"></span></a>
</div>
<hr/>
<div role="contentinfo">
<p>© Copyright 2021, Ryan Soklaski.</p>
</div>
Built with <a href="https://www.sphinx-doc.org/">Sphinx</a> using a
<a href="https://github.com/readthedocs/sphinx_rtd_theme">theme</a>
provided by <a href="https://readthedocs.org">Read the Docs</a>.
</footer>
</div>
</div>
</section>
</div>
<script>
jQuery(function () {
SphinxRtdTheme.Navigation.enable(true);
});
</script>
</body>
</html>