- Notifications
You must be signed in to change notification settings - Fork 54
/
Copy pathIntroduction.html
273 lines (251 loc) · 21.7 KB
/
Introduction.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
<!DOCTYPE html>
<htmlclass="writer-html5" lang="en" >
<head>
<metacharset="utf-8" /><metacontent="Topic: introduction to control flow, Difficulty: Easy, Category: Section" name="description" />
<metacontent="overview, summary, if, else, function, for-loop, if, else, control flow" name="keywords" />
<metaname="viewport" content="width=device-width, initial-scale=1.0" />
<title>Introducing Control Flow — Python Like You Mean It</title>
<linkrel="stylesheet" href="../_static/pygments.css" type="text/css" />
<linkrel="stylesheet" href="../_static/css/theme.css" type="text/css" />
<linkrel="stylesheet" href="../_static/my_theme.css" type="text/css" />
<!--[if lt IE 9]>
<script src="../_static/js/html5shiv.min.js"></script>
<![endif]-->
<scriptdata-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
<scriptsrc="../_static/jquery.js"></script>
<scriptsrc="../_static/underscore.js"></script>
<scriptsrc="../_static/doctools.js"></script>
<scriptasync="async" src="https://www.googletagmanager.com/gtag/js?id=UA-115029372-1"></script>
<scriptsrc="../_static/gtag.js"></script>
<scriptcrossorigin="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>
<scriptdefer="defer" src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>
<scriptsrc="../_static/js/theme.js"></script>
<linkrel="index" title="Index" href="../genindex.html" />
<linkrel="search" title="Search" href="../search.html" />
<linkrel="next" title="Conditional Statements" href="ConditionalStatements.html" />
<linkrel="prev" title="Variables & Assignment" href="Variables_and_Assignment.html" />
</head>
<bodyclass="wy-body-for-nav">
<divclass="wy-grid-for-nav">
<navdata-toggle="wy-nav-shift" class="wy-nav-side">
<divclass="wy-side-scroll">
<divclass="wy-side-nav-search" >
<ahref="../index.html" class="icon icon-home"> Python Like You Mean It
</a>
<divclass="version">
1.4
</div>
<divrole="search">
<formid="rtd-search-form" class="wy-form" action="../search.html" method="get">
<inputtype="text" name="q" placeholder="Search docs" />
<inputtype="hidden" name="check_keywords" value="yes" />
<inputtype="hidden" name="area" value="default" />
</form>
</div>
</div><divclass="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
<pclass="caption" role="heading"><spanclass="caption-text">Table of Contents:</span></p>
<ulclass="current">
<liclass="toctree-l1"><aclass="reference internal" href="../intro.html">Python Like You Mean It</a></li>
<liclass="toctree-l1"><aclass="reference internal" href="../module_1.html">Module 1: Getting Started with Python</a></li>
<liclass="toctree-l1 current"><aclass="reference internal" href="../module_2.html">Module 2: The Essentials of Python</a><ulclass="current">
<liclass="toctree-l2"><aclass="reference internal" href="Basic_Objects.html">Basic Object Types</a></li>
<liclass="toctree-l2"><aclass="reference internal" href="SequenceTypes.html">Sequence Types</a></li>
<liclass="toctree-l2"><aclass="reference internal" href="Variables_and_Assignment.html">Variables & Assignment</a></li>
<liclass="toctree-l2 current"><aclass="current reference internal" href="#">Introducing Control Flow</a><ul>
<liclass="toctree-l3"><aclass="reference internal" href="#Python-Uses-Whitespace-to-Delimit-Scope">Python Uses Whitespace to Delimit Scope</a></li>
</ul>
</li>
<liclass="toctree-l2"><aclass="reference internal" href="ConditionalStatements.html">Conditional Statements</a></li>
<liclass="toctree-l2"><aclass="reference internal" href="ForLoops.html">For-Loops and While-Loops</a></li>
<liclass="toctree-l2"><aclass="reference internal" href="Iterables.html">Iterables</a></li>
<liclass="toctree-l2"><aclass="reference internal" href="Generators_and_Comprehensions.html">Generators & Comprehension Expressions</a></li>
<liclass="toctree-l2"><aclass="reference internal" href="Itertools.html">Python’s “Itertools”</a></li>
<liclass="toctree-l2"><aclass="reference internal" href="Functions.html">Basics of Functions</a></li>
<liclass="toctree-l2"><aclass="reference internal" href="Scope.html">Scope</a></li>
<liclass="toctree-l2"><aclass="reference internal" href="DataStructures.html">Data Structures (Part I): Introduction</a></li>
<liclass="toctree-l2"><aclass="reference internal" href="DataStructures_II_Dictionaries.html">Data Structures (Part II): Dictionaries</a></li>
<liclass="toctree-l2"><aclass="reference internal" href="DataStructures_III_Sets_and_More.html">Data Structures (Part III): Sets & the Collections Module</a></li>
</ul>
</li>
<liclass="toctree-l1"><aclass="reference internal" href="../module_2_problems.html">Module 2: Problems</a></li>
<liclass="toctree-l1"><aclass="reference internal" href="../module_3.html">Module 3: The Essentials of NumPy</a></li>
<liclass="toctree-l1"><aclass="reference internal" href="../module_3_problems.html">Module 3: Problems</a></li>
<liclass="toctree-l1"><aclass="reference internal" href="../module_4.html">Module 4: Object Oriented Programming</a></li>
<liclass="toctree-l1"><aclass="reference internal" href="../module_5.html">Module 5: Odds and Ends</a></li>
<liclass="toctree-l1"><aclass="reference internal" href="../changes.html">Changelog</a></li>
</ul>
</div>
</div>
</nav>
<sectiondata-toggle="wy-nav-shift" class="wy-nav-content-wrap"><navclass="wy-nav-top" aria-label="Mobile navigation menu" >
<idata-toggle="wy-nav-top" class="fa fa-bars"></i>
<ahref="../index.html">Python Like You Mean It</a>
</nav>
<divclass="wy-nav-content">
<divclass="rst-content">
<divrole="navigation" aria-label="Page navigation">
<ulclass="wy-breadcrumbs">
<li><ahref="../index.html" class="icon icon-home"></a> »</li>
<li><ahref="../module_2.html">Module 2: The Essentials of Python</a> »</li>
<li>Introducing Control Flow</li>
<liclass="wy-breadcrumbs-aside">
<ahref="../_sources/Module2_EssentialsOfPython/Introduction.md.txt" rel="nofollow"> View page source</a>
</li>
</ul>
<hr/>
</div>
<divrole="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
<divitemprop="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>
<divclass="section" id="Introducing-Control-Flow">
<h1>Introducing Control Flow<aclass="headerlink" href="#Introducing-Control-Flow" title="Permalink to this headline"></a></h1>
<p>Very simply put, to “control flow” in your code is to affect the order in which the code in your program is executed. Up until this point in the course, you have seen (and hopefully written) code that executes linearly; for example:</p>
<divclass="highlight-python notranslate"><divclass="highlight"><pre><span></span><spanclass="c1"># simple code without any "control flow"</span>
<spanclass="c1"># i.e. no branches in logic, loops, or</span>
<spanclass="c1"># code encapsulation</span>
<spanclass="n">x</span><spanclass="o">=</span><spanclass="mi">6</span>
<spanclass="n">y</span><spanclass="o">=</span><spanclass="mi">23</span>
<spanclass="nb">print</span><spanclass="p">(</span><spanclass="s2">"x + y = "</span><spanclass="p">,</span><spanclass="n">x</span><spanclass="o">+</span><spanclass="n">y</span><spanclass="p">)</span>
<spanclass="nb">print</span><spanclass="p">(</span><spanclass="s2">"x - y = "</span><spanclass="p">,</span><spanclass="n">x</span><spanclass="o">-</span><spanclass="n">y</span><spanclass="p">)</span>
</pre></div>
</div>
<p>But what if you want your code to do something different when <codeclass="docutils literal notranslate"><spanclass="pre">x</span></code> is an even number? What if you want to do an additional computation for every number that falls between <codeclass="docutils literal notranslate"><spanclass="pre">x</span></code> and <codeclass="docutils literal notranslate"><spanclass="pre">y</span></code>? By the end of this module, you should understand how to write programs that can accommodate these, and many other, branches in logic.</p>
<p>Control flow tools will vastly expand your ability to write useful code. They are the quintessential building blocks for modern programming languages, and are effectively the same across Python, C, C++, Java, and many others (barring syntactic differences).</p>
<p>As a sneak peek, let’s write a function that counts how many numbers between m and n are divisible by 3</p>
<divclass="highlight-python notranslate"><divclass="highlight"><pre><span></span><spanclass="k">def</span><spanclass="nf">cnt_div_by_3</span><spanclass="p">(</span><spanclass="n">m</span><spanclass="p">,</span><spanclass="n">n</span><spanclass="p">):</span>
<spanclass="sd">""" Counts how many numbers in the interval [m, n] are divisible by 3. """</span>
<spanclass="n">count</span><spanclass="o">=</span><spanclass="mi">0</span>
<spanclass="k">for</span><spanclass="n">num</span><spanclass="ow">in</span><spanclass="nb">range</span><spanclass="p">(</span><spanclass="n">m</span><spanclass="p">,</span><spanclass="n">n</span><spanclass="o">+</span><spanclass="mi">1</span><spanclass="p">):</span>
<spanclass="k">if</span><spanclass="n">num</span><spanclass="o">%</span><spanclass="mi">3</span><spanclass="o">==</span><spanclass="mi">0</span><spanclass="p">:</span><spanclass="c1"># recall: x % y gives the remainder of x / y</span>
<spanclass="n">count</span><spanclass="o">+=</span><spanclass="mi">1</span>
<spanclass="k">else</span><spanclass="p">:</span>
<spanclass="k">pass</span><spanclass="c1"># this `else-pass` statement is not really necessary</span>
<spanclass="c1"># it is included for the sake of clarity in this introduction</span>
<spanclass="k">return</span><spanclass="n">count</span>
</pre></div>
</div>
<p>(note: there are much more efficient ways of computing this - can you think of any?)</p>
<p>This code contains several critical “control flow” features:</p>
<ulclass="simple">
<li><p>The <codeclass="docutils literal notranslate"><spanclass="pre">def</span><spanclass="pre">cnt_div_by_3(m,</span><spanclass="pre">n):</span></code> statement signals the definition of a function: a modular block of code, which can be utilized elsewhere in your code.</p></li>
<li><p>The line <codeclass="docutils literal notranslate"><spanclass="pre">for</span><spanclass="pre">num</span><spanclass="pre">in</span><spanclass="pre">range(m,</span><spanclass="pre">n</span><spanclass="pre">+</span><spanclass="pre">1):</span></code> signifies a “for-loop” which instructs the code to iterate over a sequence of numbers, executing a common block of code for each iteration.</p></li>
<li><p><codeclass="docutils literal notranslate"><spanclass="pre">if</span><spanclass="pre">num</span><spanclass="pre">%</span><spanclass="pre">3</span><spanclass="pre">==</span><spanclass="pre">0:</span></code> and <codeclass="docutils literal notranslate"><spanclass="pre">else</span></code> instruct pieces of codes to be executed conditionally - only if a specified condition is met.</p></li>
</ul>
<p>In the following sections, you will be formally introduced to if-elif-else blocks, for-loops & iterables, and functions, all so that you can implement effective “control flow” in your code.</p>
<p>Before embarking on these sections, we must take a moment to study Python’s syntax for delimiting scope for these various control flow constructs.</p>
<divclass="section" id="Python-Uses-Whitespace-to-Delimit-Scope">
<h2>Python Uses Whitespace to Delimit Scope<aclass="headerlink" href="#Python-Uses-Whitespace-to-Delimit-Scope" title="Permalink to this headline"></a></h2>
<p>While the concepts of function definitions, loops, and conditional statements are shared across the majority of modern programming languages, the languages often differ in their syntax for delimiting the <em>bodies</em> of these constructs. For example, where C++ uses “curly braces” as delimiters, e.g.:</p>
<divclass="highlight-cpp notranslate"><divclass="highlight"><pre><span></span><spanclass="c1">// example showing that C++ uses curly braces to delimit scope</span>
<spanclass="kt">int</span><spanclass="w"></span><spanclass="n">x</span><spanclass="w"></span><spanclass="o">=</span><spanclass="w"></span><spanclass="mi">1</span><spanclass="p">;</span><spanclass="w"></span>
<spanclass="k">if</span><spanclass="w"></span><spanclass="p">(</span><spanclass="n">x</span><spanclass="w"></span><spanclass="o">></span><spanclass="w"></span><spanclass="mi">10</span><spanclass="p">)</span><spanclass="w"></span>
<spanclass="w"></span><spanclass="p">{</span><spanclass="w"></span>
<spanclass="w"></span><spanclass="c1">// we are inside the if-block, as delimited by the curly-brackets</span>
<spanclass="w"></span><spanclass="n">x</span><spanclass="w"></span><spanclass="o">=</span><spanclass="w"></span><spanclass="n">x</span><spanclass="w"></span><spanclass="o">+</span><spanclass="w"></span><spanclass="mi">1</span><spanclass="p">;</span><spanclass="w"></span>
<spanclass="w"></span><spanclass="p">}</span><spanclass="w"></span>
<spanclass="c1">// we are outside of the if-block</span>
<spanclass="n">x</span><spanclass="w"></span><spanclass="o">=</span><spanclass="w"></span><spanclass="n">x</span><spanclass="w"></span><spanclass="o">+</span><spanclass="w"></span><spanclass="mi">3</span><spanclass="p">;</span><spanclass="w"></span>
</pre></div>
</div>
<p>Python <strong>uses whitespace (i.e. indentation) to delimit scope</strong>:</p>
<divclass="highlight-python notranslate"><divclass="highlight"><pre><span></span><spanclass="c1"># example showing that Python uses whitespace to delimit scope</span>
<spanclass="n">x</span><spanclass="o">=</span><spanclass="mi">1</span>
<spanclass="k">if</span><spanclass="n">x</span><spanclass="o">></span><spanclass="mi">10</span><spanclass="p">:</span>
<spanclass="c1"># we are inside the if-block; this line starts with four blank spaces</span>
<spanclass="n">x</span><spanclass="o">=</span><spanclass="n">x</span><spanclass="o">+</span><spanclass="mi">1</span>
<spanclass="c1"># we are outside of the if-block; there are no leading whitespace characters</span>
<spanclass="n">x</span><spanclass="o">=</span><spanclass="n">x</span><spanclass="o">+</span><spanclass="mi">3</span>
</pre></div>
</div>
<p>Look to the example at the beginning of this section to see the bodies of the function definition, the for-loop, and the subsequent if-else block were all separated by increasing levels of indentation.</p>
<p>Python’s syntax is quite flexible in terms of what it defines as a whitespace delimiter. Its rules are that:</p>
<ulclass="simple">
<li><p>One or more whitespace characters (spaces or tabs) is sufficient to serve as indentation.</p></li>
<li><p>A given indented block must use a uniform level of indentation. E.g. if the first line of an indented block has two leading spaces, all subsequent lines in that block must lead with exactly two white spaces.</p></li>
</ul>
<p>While Python’s syntax is relatively forgiving, I am not: the <aclass="reference external" href="https://www.python.org/dev/peps/pep-0008/#indentation">standard style</a> for indenting in Python is to <strong>use four space characters</strong> for each level of indentation. It is strongly advised that you adhere to this standard. Most IDEs and consoles (including Jupyter notebooks) will automatically add a four-space indentation for you when you enter into the body of one of the aforementioned constructs.</p>
<p>Let’s review these rules by considering a few simple examples (including incorrect examples) of delimiting scope in Python.</p>
<divclass="highlight-python notranslate"><divclass="highlight"><pre><span></span><spanclass="c1"># OK, but gross: The use of a single whitespace</span>
<spanclass="c1"># makes the indentation hard to see. Use four spaces.</span>
<spanclass="k">if</span><spanclass="kc">True</span><spanclass="p">:</span>
<spanclass="n">x</span><spanclass="o">=</span><spanclass="mi">1</span><spanclass="c1"># one space</span>
<spanclass="n">y</span><spanclass="o">=</span><spanclass="mi">2</span><spanclass="c1"># one space</span>
</pre></div>
</div>
<divclass="highlight-python notranslate"><divclass="highlight"><pre><span></span><spanclass="c1"># BAD: the inconsistent level of indentation in this</span>
<spanclass="c1"># single block will cause this code to raise an IndentationError</span>
<spanclass="k">def</span><spanclass="nf">my_func</span><spanclass="p">(</span><spanclass="n">x</span><spanclass="p">):</span>
<spanclass="n">x</span><spanclass="o">=</span><spanclass="n">x</span><spanclass="o">+</span><spanclass="mi">1</span><spanclass="c1"># four spaces</span>
<spanclass="n">y</span><spanclass="o">=</span><spanclass="mi">3</span><spanclass="c1"># eight spaces</span>
<spanclass="n">z</span><spanclass="o">=</span><spanclass="n">x</span><spanclass="o">+</span><spanclass="n">y</span><spanclass="c1"># four spaces</span>
<spanclass="k">return</span><spanclass="n">z</span><spanclass="c1"># four spaces</span>
</pre></div>
</div>
<divclass="highlight-python notranslate"><divclass="highlight"><pre><span></span><spanclass="c1"># OK, but gross: The if-block uses four spaces as a delimiter.</span>
<spanclass="c1"># The else-block uses two spaces as a delimiter. This is technically</span>
<spanclass="c1"># okay since indentation is consistent within each block. One should</span>
<spanclass="c1"># always use four spaces for indentation.</span>
<spanclass="k">if</span><spanclass="kc">True</span><spanclass="p">:</span>
<spanclass="n">x</span><spanclass="o">=</span><spanclass="mi">3</span><spanclass="c1"># four spaces</span>
<spanclass="n">y</span><spanclass="o">=</span><spanclass="mi">2</span><spanclass="c1"># four spaces</span>
<spanclass="k">else</span><spanclass="p">:</span>
<spanclass="n">x</span><spanclass="o">=</span><spanclass="mi">2</span><spanclass="c1"># two spaces</span>
<spanclass="n">y</span><spanclass="o">=</span><spanclass="mi">1</span><spanclass="c1"># two spaces</span>
</pre></div>
</div>
<divclass="highlight-python notranslate"><divclass="highlight"><pre><span></span><spanclass="c1"># Good! The for-loop's body is defined by one level</span>
<spanclass="c1"># of four-space indentation, and the contained if-else</span>
<spanclass="c1"># blocks each have their own additional four-space indentations.</span>
<spanclass="k">for</span><spanclass="n">i</span><spanclass="ow">in</span><spanclass="p">[</span><spanclass="mi">1</span><spanclass="p">,</span><spanclass="mi">2</span><spanclass="p">,</span><spanclass="mi">3</span><spanclass="p">,</span><spanclass="mi">4</span><spanclass="p">]:</span>
<spanclass="k">if</span><spanclass="n">i</span><spanclass="o">==</span><spanclass="mi">2</span><spanclass="ow">or</span><spanclass="n">i</span><spanclass="o">==</span><spanclass="mi">4</span><spanclass="p">:</span><spanclass="c1"># four spaces</span>
<spanclass="n">x</span><spanclass="o">=</span><spanclass="s2">"even"</span><spanclass="c1"># eight spaces</span>
<spanclass="k">else</span><spanclass="p">:</span><spanclass="c1"># four spaces</span>
<spanclass="n">x</span><spanclass="o">=</span><spanclass="s2">"odd"</span><spanclass="c1"># eight spaces</span>
</pre></div>
</div>
</div>
</div>
</div>
</div>
<footer><divclass="rst-footer-buttons" role="navigation" aria-label="Footer">
<ahref="Variables_and_Assignment.html" class="btn btn-neutral float-left" title="Variables & Assignment" accesskey="p" rel="prev"><spanclass="fa fa-arrow-circle-left" aria-hidden="true"></span> Previous</a>
<ahref="ConditionalStatements.html" class="btn btn-neutral float-right" title="Conditional Statements" accesskey="n" rel="next">Next <spanclass="fa fa-arrow-circle-right" aria-hidden="true"></span></a>
</div>
<hr/>
<divrole="contentinfo">
<p>© Copyright 2021, Ryan Soklaski.</p>
</div>
Built with <ahref="https://www.sphinx-doc.org/">Sphinx</a> using a
<ahref="https://github.com/readthedocs/sphinx_rtd_theme">theme</a>
provided by <ahref="https://readthedocs.org">Read the Docs</a>.
</footer>
</div>
</div>
</section>
</div>
<script>
jQuery(function(){
SphinxRtdTheme.Navigation.enable(true);
});
</script>
</body>
</html>
