Statements.html

<div id="ipython-notebook">
            <a class="interact-button" href="http://datahub.berkeley.edu/user-redirect/interact?repo=textbook&path=notebooks/Statements.ipynb">Interact</a>
            
<script type="text/x-mathjax-config">
  MathJax.Hub.Config({
    tex2jax: {
      inlineMath: [['$','$']],
      processEscapes: true
    }
  });
</script>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h2 id="0.-Introduction">0. Introduction<a class="anchor-link" href="#0.-Introduction">¶</a></h2><p>In this note, we'll go over the structure of Python code in a bit more detail than we have before.  When you've absorbed this material, you should be able to read Python code and decompose it into simple, understandable parts.  This note should be particularly useful if you've seen a lot of Python code, but you have a hard time interpreting complicated-looking code like <code>table['foo'] = np.array([1,2,3]) + table['bar']</code>.</p>
<p>Decomposing Python into small parts is kind of like diagramming an English sentence.  While our brains are perfectly capable of generating and understanding English without explicitly identifying things like subjects and predicates, Python interprets code very literally according to its rules (its <em>syntax</em>).  So if you want to understand Python code, it's more important to have a precise model of Python's rules in your head.  On the flip side, Python's rules are much simpler than those of English (see, for example, <a href="https://en.wikipedia.org/wiki/Buffalo_buffalo_Buffalo_buffalo_buffalo_buffalo_Buffalo_buffalo">this amusingly complicated English sentence</a>).  They just seem complicated because we're less familiar with them.  That makes it possible to learn Python much faster than you learned English.</p>
<p>Note: Everything in this note is also available, with even more pedantic precision, at the <a href="https://docs.python.org/3/reference/index.html">official Python language reference</a>.  This note is focused on the material in chapters 6, 7, and 8 of the reference.  We will omit some details and fudge some truths in the interest of pedagogy.  Once you feel like an expert in this stuff, feel free to brave the official documentation.</p>
<h3 id="How-to-read-this-document">How to read this document<a class="anchor-link" href="#How-to-read-this-document">¶</a></h3><p>This note contains a bunch of code cells, in addition to text.  The code cells typically illustrate points from the text.  Please run the code cells as you go through the note, and pay attention to what their output is.  Recall that the thing that's printed when you run a cell is the value of the last line.</p></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h2 id="1.-Code-is-a-sequence-of-statements">1. Code is a sequence of statements<a class="anchor-link" href="#1.-Code-is-a-sequence-of-statements">¶</a></h2><p>Below is a cell containing various Python code that might look familiar by now.</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="mi">3</span>                                               <span class="c1"># Line 1.0</span>
<span class="n">z</span> <span class="o">=</span> <span class="mi">3</span>                                           <span class="c1"># Line 1.1</span>
<span class="mi">4</span><span class="o">+</span><span class="mi">3</span>                                             <span class="c1"># Line 1.2</span>
<span class="n">y</span> <span class="o">=</span> <span class="mi">4</span><span class="o">+</span><span class="mi">3</span>                                         <span class="c1"># Line 1.3</span>
<span class="p">(</span><span class="mi">2</span><span class="o">+</span><span class="mi">3</span><span class="p">)</span><span class="o">+</span><span class="n">z</span>                                         <span class="c1"># Line 1.4</span>
<span class="s2">"foo"</span><span class="o">+</span><span class="s2">"bar"</span>                                     <span class="c1"># Line 1.5</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"># Line 1.6</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="c1"># Line 1.7</span>
<span class="nb">sum</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>                                          <span class="c1"># Line 1.8</span>
<span class="n">x</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span>                                            <span class="c1"># Line 1.9</span>
<span class="n">x</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="o">=</span> <span class="mi">4</span>                                        <span class="c1"># Line 1.10</span>
<span class="n">t</span> <span class="o">=</span> <span class="n">Table</span><span class="p">()</span>                                     <span class="c1"># Line 1.11</span>
<span class="n">t</span><span class="p">[</span><span class="s1">'Things'</span><span class="p">]</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="s2">"foo"</span><span class="p">,</span> <span class="s2">"bar"</span><span class="p">,</span> <span class="s2">"baz"</span><span class="p">])</span>   <span class="c1"># Line 1.12</span>
<span class="n">t</span><span class="o">.</span><span class="n">sort</span><span class="p">(</span><span class="s1">'Things'</span><span class="p">)</span>                                <span class="c1"># Line 1.13</span>
<span class="n">u</span> <span class="o">=</span> <span class="n">t</span><span class="o">.</span><span class="n">sort</span><span class="p">(</span><span class="s1">'Things'</span><span class="p">)</span>                            <span class="c1"># Line 1.14</span>
<span class="n">u</span><span class="o">.</span><span class="n">relabel</span><span class="p">(</span><span class="s1">'Things'</span><span class="p">,</span> <span class="s1">'Nonsense'</span><span class="p">)</span>                 <span class="c1"># Line 1.15</span>
<span class="n">u</span>                                               <span class="c1"># Line 1.16</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>(The <code># Line X</code> comments are just there for labeling; don't consider them part of the lines.  Similarly, other instances of <code># some text here</code> that you see in this note are just for explanation.)  Each line in the cell is a <em>statement</em>.  A statement is a (somewhat) self-contained piece of code.  Python executes statements in the order in which they appear.  There are many kinds of statements, and to execute a statement, Python first has to figure out what kind of statement it is.</p></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h2 id="2.-Expressions">2. Expressions<a class="anchor-link" href="#2.-Expressions">¶</a></h2><p>The most basic kind of statement is the <em>expression</em>.</p>
<p>Line 0 above is just an expression: <code>3</code>.  Like many (but not all) expressions, it has a value, the integer 3.  Like some (but not all) expressions, computing its value causes nothing to "happen" to the world.  (We say it has no <em>side effects</em>.)  When Python executes line 0, it computes that value.  Since nothing is done with it, it just gets discarded.  The same is true of lines 2, 4, 5, 6, 8, 9, 13, and 16 -- those are expression statements that cause values to be computed, but the computation has no side effects, and the value of the full expression is eventually discarded.  Line 15 is an expression that does have side effects -- it causes the <code>'Things'</code> column in the table named <code>t</code> to be renamed to <code>'Nonsense'</code>.  The other lines are statements but not expressions, but we will see that, like many statements, they <em>contain</em> expressions.</p>
<p>Expressions are themselves usually made up of several smaller expressions joined together by some rules; we call these <em>compound expressions</em>, and we sometimes call the component expressions <em>subexpressions</em>.  Line 2, for example, is a compound expression made up of the subexpressions <code>4</code> and <code>3</code> joined by <code>+</code>.  Python knows what a <code>+</code> between two expressions means, and it puts them together so that the value of <code>4+3</code> is the value of <code>4</code> plus the value of <code>3</code>, or 7.</p>
<p>Line 4 is another compound expression.  We can think of it as the subexpressions <code>(2+3)</code> and <code>z</code>, again joined by <code>+</code>.  But <code>(2+3)</code> is itself a compound expression, made up of <code>2</code> and <code>3</code> joined by <code>+</code>.  Python first computes the value of <code>(2+3)</code>, which is 5, and then computes the value of <code>z</code>, which is 3 (<code>z</code> having been assigned previously), and then adds 5 and 3 to get 8.  <code>(2+3)*(4*((5*6)+7))</code> is also a valid expression.  It contains 10 subexpressions (not including itself):</p>
<ul>
<li><code>2</code></li>
<li><code>3</code></li>
<li><code>(2+3)</code></li>
<li><code>4</code></li>
<li><code>5</code></li>
<li><code>6</code></li>
<li><code>(5*6)</code></li>
<li><code>7</code></li>
<li><code>((5*6)+7)</code></li>
<li><code>(4*((5*6)+7))</code></li>
</ul>
<p>Compound expressions can be arbitrarily complicated compositions of expressions.</p></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p><strong>Question.</strong>  How many subexpressions are contained in the expression <code>((1+2)+(3+4))+((5+6)+(7+8))</code>?</p></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>It's <em>critical</em> to recognize that subexpressions are valid expressions that could be written by themselves or made part of other compound expressions.  If you see a complicated expression like the one above (or even more exotic ones later), and you don't understand what it does, you can always break it down into smaller bits until you get to very basic expressions.  There is a fairly small list of basic expression types (things that can't be broken down into subexpressions) to learn.</p>
<p>This note will tell you the rules about most of the basic expressions in Python, but in order to understand and write real code (which very regularly involves large compound expressions) you'll need to develop the skill of breaking down compound expressions into subexpressions.  You can try to do that mentally while you're reading code, but if that's too hard, you can <em>just type them into a Python code cell</em> and see what they do.</p>
<p><strong>Question.</strong> What's the value of each subexpression you found above?  You can just type them into the empty code cell below if you like.</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span> 
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h4 id="A-note-on-errors">A note on errors<a class="anchor-link" href="#A-note-on-errors">¶</a></h4><p>Line 5 (<code>"foo"+"bar"</code>) is a compound expression adding two strings, with <code>"foo"</code> and <code>"bar"</code> as subexpressions.  This is okay, since the <code>+</code> operator knows how to handle two strings.  It produces the string "foobar" as its value.</p>
<p>When the following cell is executed, however, there is an error.  (Run the cell to confirm that.)</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="s2">"foo"</span><span class="o">+</span><span class="mi">5</span> <span class="c1"># Error!</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>When you see an error, don't just give up.  Often (though unfortunately not always) the error message will tell you what's wrong.  The error message first tells us that the problem happened on line 1 of the cell (in this case, the only line) and the text of the error is "TypeError: Can't convert 'int' object to str implicitly".  Python evaluates <code>"foo"</code> and <code>5</code> just fine, but when the <code>+</code> operator tries to apply itself "foo" and 5, it becomes unhappy.  The error refers to the fact that the <code>+</code> operator tries to convert its arguments to something it can add.  For example, adding an integer and a float, like <code>3+4.5</code>, works because <code>+</code> converts the integer <code>3</code> to a float.  But <code>+</code> can't convert a number to text (or vice-versa), so it gives up.</p>
<p>The important thing to realize about that cell, for our purposes, is exactly where the error happens.  In the next cell, for example, some work is done before an error happens:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="p">(</span><span class="s2">"foo"</span><span class="o">+</span><span class="s2">"bar"</span><span class="p">)</span><span class="o">+</span><span class="mi">5</span> <span class="c1"># Error!</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>Python actually evaluates the subexpression <code>("foo"+"bar")</code> successfully, producing the string "foobar", before again failing to add "foobar" and 5.  The error occurs only when trying to add a string and a number, and not before.</p>
<p>Now, let's go over the kinds of expressions that Python has.</p></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h3 id="Strings,-ints,-and-floats">Strings, ints, and floats<a class="anchor-link" href="#Strings,-ints,-and-floats">¶</a></h3><p>The most basic kinds of expressions, which we've seen repeatedly above, are string, int, and float expressions.  These just look like this:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="s2">"foo"</span> <span class="c1"># a string expression, whose value is the string "foo"</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="s1">'foo'</span> <span class="c1"># a string expression, essentially identical to the one above</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="s1">'5'</span>   <span class="c1"># a string expression, which happens to contain a single character called 5</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="mi">5</span>     <span class="c1"># an int expression, whose value is the integer number 5</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="mf">5.1</span>   <span class="c1"># a float expression, whose value is the decimal number 5.1</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>It's important to recognize that string, int, and float expressions produce values of different types.  A string is not an int, nor is it a float.  You can see the type of anything by calling <code>type(thing)</code> (or print it out with <code>print(type(thing))</code>, as in <code>type(2)</code>, <code>type('foo')</code>, or</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">i_am_a_string</span> <span class="o">=</span> <span class="s2">"blah"</span>
<span class="nb">type</span><span class="p">(</span><span class="n">i_am_a_string</span><span class="p">)</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>Confusingly but conveniently, many functions built into Python will try to convert values of one type to another.  <code>3+4.5</code> was one example we just saw -- in order to add <code>3</code> and <code>4.5</code>, Python first converts the integer <code>3</code> to the float <code>3.</code>.  <code>print(3)</code> is another -- in order to print anything so you can see its value, the <code>print</code> function first converts it to a string.  So sometimes you can forget about the types of values.  Other times, as in the error we saw before, you have to think about types.</p>
<p>You can do conversions between these three types yourself with the <code>str()</code>, <code>int()</code>, and <code>float()</code> functions.</p></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h4 id="Triple-quoted-strings">Triple-quoted strings<a class="anchor-link" href="#Triple-quoted-strings">¶</a></h4><p>Here is a more exotic kind of string expression:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="sd">"""blah</span>

<span class="sd">...</span>
<span class="sd"># looks like a comment but isn't</span>
<span class="sd">last line"""</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>The result is just a string like <code>"foo"</code> above, with a few differences.  Triple double-quotation marks denote the beginning and end of this string, and it can take up multiple lines, unlike an ordinary string expression.</p>
<p>Frankly, this is an arcane detail of Python, but we bring it up because triple-quoted strings are often used for writing long-form comments in code, instead of <code>#</code> comments.  This works even though the string is just an expression, not a special device for long comments.  That's because an expression doesn't <em>do</em> anything by itself, except that the last expression in a Jupyter notebook cell gets printed.  So you can sprinkle string expressions (or other expressions that have no side-effects) throughout your code (on their own lines) and no harm will come of it.</p>
<p>The following (oddly and excessively) documented code shows this:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="sd">"""The code in this cell produces</span>
<span class="sd">pi rounded to 5 decimal digits."""</span>
<span class="s2">"First, let's give a name to pi."</span>
<span class="n">my_name_for_pi</span> <span class="o">=</span> <span class="n">math</span><span class="o">.</span><span class="n">pi</span>
<span class="c1"># Now, we round it to 5 decimal</span>
<span class="c1"># digits.</span>
<span class="n">pi_rounded</span> <span class="o">=</span> <span class="nb">round</span><span class="p">(</span><span class="n">my_name_for_pi</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="s2">"Now make that the last expression in this cell."</span>
<span class="n">pi_rounded</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h3 id="Names">Names<a class="anchor-link" href="#Names">¶</a></h3><p>Names, also called <em>variables</em>, are just expressions like <code>x</code> or <code>my_name_for_pi</code> that refer to some actual values.  When Python sees a name expression, it basically just substitutes the current value of that name for the name.  We'll later talk about what kinds of statements assign names to values.</p></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h3 id="Lists">Lists<a class="anchor-link" href="#Lists">¶</a></h3><p>Line 6 above, <code>[1,2,3]</code>, is another kind of compound expression, the <em>list literal</em>.  Python knows that when square brackets (<code>[]</code>) appear by themselves with a comma-separated list of expressions inside them, we are asking for a list consisting of those expressions' values.</p>
<p>Again, each expression in the list can be a compound expression.  So it's okay to write something like:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="p">[</span><span class="s2">"foo"</span><span class="o">+</span><span class="s2">"bar"</span><span class="p">,</span> <span class="nb">sum</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="p">[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">]]</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p><strong>Question.</strong> Describe the value of the above list expression in English.</p></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h3 id="Calls">Calls<a class="anchor-link" href="#Calls">¶</a></h3><p>Line 8, <code>sum(x)</code>, is also a compound expression, a <em>function call</em>.  Python evaluates the subexpression <code>sum</code>, producing a <em>function</em> that adds members of lists, and the subexpression <code>x</code>, which was previously set to a list of integers.  Then the parentheses <code>()</code> direct Python to <em>call</em> the function on the left of the parenthesis (the one named <code>sum</code>) on the value of <code>x</code>, producing the value 6.  Note that it's possible to write things like <code>5(3)</code> or <code>nonexistent_function(0)</code>.  Python will just complain that <code>5</code> is not a function (specifically, that it is not "callable") or that <code>nonexistent_function</code> hasn't been defined, respectively.</p>
<p>The following line is similar to line 8, but the subexpression inside the parentheses, <code>x + [4]</code>, is itself a compound expression:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="nb">sum</span><span class="p">(</span><span class="n">x</span> <span class="o">+</span> <span class="p">[</span><span class="mi">4</span><span class="p">])</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>(Recall that adding two lists with <code>+</code> makes a new list consisting of the two lists smashed together.  So <code>x + [4]</code> above has value equal to <code>[1,2,4,4]</code>.  <code>x</code> is equal to <code>[1,2,4]</code>, not <code>[1,2,3]</code> as it was defined on line 7, because on line 10 we set its last element to <code>4</code>.)</p>
<p>We haven't seen how to define new functions yet, but here is one example to see how the expression before the <code>(</code> is just an expression (whose value must be a function):</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">my_name_for_sum</span> <span class="o">=</span> <span class="nb">sum</span>
<span class="n">my_name_for_sum</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h3 id="Indexing">Indexing<a class="anchor-link" href="#Indexing">¶</a></h3><p>Line 9, <code>x[2]</code>, is yet another compound expression.  Python evaluates the subexpression <code>x</code>, producing a list, and the subexpression <code>2</code>.  The square brackets <code>[]</code>, appearing immediately after an expression and with another expression inside them, tell Python to <em>index</em> into the value of the first expression using the value of the second expression.  For this list as it's defined on line 9, this produces the value 3.</p>
<p>Notice that the code string <code>[2]</code> can have two different meanings, depending on the code immediately around it.  If there is an expression to the left, for example <code>x[2]</code>, then Python will take it to mean an indexing expression.  If not, Python will think you mean a list with a single element, 2.</p>
<p>Like parentheses, the things on either side of the square brackets can be compound expressions:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">x</span><span class="p">[</span><span class="mi">2</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="p">(</span><span class="n">x</span> <span class="o">+</span> <span class="p">[</span><span class="mi">13</span><span class="p">])[</span><span class="mi">2</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p><strong>Question.</strong>  In the last cell, there are 7 subexpressions, not counting the whole expression <code>(x + [13])[2+1]</code>.  Can you identify all of them?</p></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>Finally, note that different kinds of values support different kinds of indexing.  A Table, for example, supports indexing by strings, producing a column:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">t</span><span class="p">[</span><span class="s1">'Things'</span><span class="p">]</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p><strong>Question.</strong> To put together list indexing and function calls, try to figure out what the following code is doing.  (Note that an expression like <code>sum</code> has a value, like any other name expression, and that value is a function.  We can put function values into lists, just like other values.)</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">some_functions_on_lists</span> <span class="o">=</span> <span class="p">[</span><span class="nb">sum</span><span class="p">,</span> <span class="nb">len</span><span class="p">]</span>
<span class="p">(</span><span class="n">some_functions_on_lists</span><span class="p">[</span><span class="mi">0</span><span class="p">])(</span><span class="n">x</span><span class="p">)</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h3 id="Dots-and-attributes">Dots and attributes<a class="anchor-link" href="#Dots-and-attributes">¶</a></h3><p>Objects (just another name for a value, like 1, "four score", or a Table) often have things called properties, attributes, fields, or (in the case when the things are functions) methods.  Let's call them attributes.  Though in this class we won't see how to create new kinds of objects, we will use attributes all the time.</p>
<p>We access attributes using a <code>.</code>.  For example:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">t</span><span class="o">.</span><span class="n">rows</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>Generically, the thing on the left of the <code>.</code> must be an expression whose value is an object with the attribute we want.  As with calling and indexing, it can be an arbitrarily complicated compound expression.  The thing on the right of the dot is the name of the attribute.  Unlike the arguments of a function or the index in an indexing expression, it is <em>not</em> an expression.  It must be the name of an attribute that the object on the left has.</p>
<p>As we said, sometimes an attribute is a function, in which case we sometimes call it a <em>method</em> instead.  The syntax is the same as other attribute accesses:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">t</span><span class="o">.</span><span class="n">sort</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">t</span><span class="o">.</span><span class="n">sort</span><span class="p">(</span><span class="s1">'Things'</span><span class="p">)</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>The only difference between a method and a normal function is that the object itself (<code>t</code> in this case) is automatically passed as the first argument to the method.  So the <code>sort</code> function technically has two arguments -- the first is the table that <code>sort</code> is being called on, and the second is the column name.  This is how <code>sort</code> knows which table to sort!  Normally this is a really technical detail that you don't need to worry about, but it can come up when you accidentally pass the wrong number of arguments to a method:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">t</span><span class="o">.</span><span class="n">sort</span><span class="p">(</span><span class="s1">'This'</span><span class="p">,</span> <span class="s1">'is'</span><span class="p">,</span> <span class="s1">'too'</span><span class="p">,</span> <span class="s1">'many'</span><span class="p">,</span> <span class="s1">'arguments'</span><span class="p">)</span> <span class="c1"># Error!</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>The error complains that we gave 6 arguments to <code>sort</code>, but it looks like we only passed 5.  The extra first argument is the table <code>t</code>.</p></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h4 id="A-weird-thing-about-dot-syntax">A weird thing about dot syntax<a class="anchor-link" href="#A-weird-thing-about-dot-syntax">¶</a></h4><p>You might notice at some point that dots are used in two ways in Python: accessing attributes, and in expressions for floating-point numbers.  For example, <code>x.y</code> is accessing the attribute named <code>y</code> in the value named <code>x</code>, while <code>1.2</code> is just an expression for the number 1.2.  This is one reason why you can't have numbers at the start of names.  It also means that the expression on the left of a <code>.</code> can't just be number.  For example, we can't access the attribute <code>real</code> of an integer this way (for this example, you don't need to know what <code>real</code> is doing, other than that it should just return the same value as the integer):</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="mf">1.</span><span class="n">real</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>That's because Python can't tell whether we're trying to write an (invalid) decimal number <code>1.real</code> or access the <code>real</code> attribute of the value <code>1</code>.  Surrounding the <code>1</code> in parentheses makes it clear to Python:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="p">(</span><span class="mi">1</span><span class="p">)</span><span class="o">.</span><span class="n">real</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h3 id="Is-that-all-the-expressions?">Is that all the expressions?<a class="anchor-link" href="#Is-that-all-the-expressions?">¶</a></h3><p>No.  We might see more as the class goes on.  But these are most of the important ones, and you've seen most of the difficult ideas.</p></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h3 id="Exercises-to-put-it-all-together">Exercises to put it all together<a class="anchor-link" href="#Exercises-to-put-it-all-together">¶</a></h3><p><strong>Question.</strong>  Many people, when they first encounter tables and try to use them to manipulate data, assume that Python allows more syntactic flexibility than it really does.  Below are some examples of things we might <em>hope</em> would work, but don't.  For each one, describe what it actually does, what its author was probably trying to do, what went wrong, and how to fix it.</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="c1"># No error here, just setup for the next cells.  Run this cell to see the table we're working with.</span>
<span class="n">my_table</span> <span class="o">=</span> <span class="n">Table</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="mi">4</span><span class="p">],</span> <span class="p">[</span><span class="mi">9</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="mi">1</span><span class="p">]],</span> <span class="p">[</span><span class="s1">'x'</span><span class="p">,</span> <span class="s1">'y'</span><span class="p">],</span> <span class="p">)</span>
<span class="n">my_table</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">my_table</span><span class="p">[</span><span class="s1">'x + y'</span><span class="p">]</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">my_table</span><span class="p">[</span><span class="s1">'x'</span> <span class="o">+</span> <span class="s1">'y'</span><span class="p">]</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">my_table</span><span class="p">[</span><span class="s1">'x'</span><span class="p">]</span> <span class="o">+</span> <span class="p">[</span><span class="s1">'y'</span><span class="p">]</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">my_table</span><span class="o">.</span><span class="n">where</span><span class="p">(</span><span class="s1">'x'</span> <span class="o">&gt;=</span> <span class="mi">3</span><span class="p">)</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">my_table</span><span class="o">.</span><span class="n">where</span><span class="p">([</span><span class="s1">'x'</span><span class="p">]</span> <span class="o">&gt;=</span> <span class="mi">3</span><span class="p">)</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">my_table</span><span class="o">.</span><span class="n">sort</span><span class="p">(</span><span class="s1">'y'</span><span class="p">)</span>
<span class="n">row_with_smallest_y</span> <span class="o">=</span> <span class="n">my_table</span><span class="o">.</span><span class="n">rows</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h2 id="3.-Assignments">3. Assignments<a class="anchor-link" href="#3.-Assignments">¶</a></h2></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>If we had only expressions, it would be difficult to put together many steps in our code.  For example, which piece of code is more legible?</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">Table</span><span class="p">([[</span><span class="s1">'Alice'</span><span class="p">,</span> <span class="s1">'Bob'</span><span class="p">,</span> <span class="s1">'Alice'</span><span class="p">,</span> <span class="s1">'Alice'</span><span class="p">,</span> <span class="s1">'Connie'</span><span class="p">],</span> <span class="p">[</span><span class="mf">119.99</span><span class="p">,</span> <span class="mf">29.99</span><span class="p">,</span> <span class="mf">10.00</span><span class="p">,</span> <span class="mf">350.00</span><span class="p">,</span> <span class="mf">5.29</span><span class="p">]],</span> <span class="p">[</span><span class="s1">'Customer'</span><span class="p">,</span> <span class="s1">'Bill'</span><span class="p">])</span><span class="o">.</span><span class="n">group</span><span class="p">(</span><span class="s1">'Customer'</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">sum</span><span class="p">)</span><span class="o">.</span><span class="n">sort</span><span class="p">(</span><span class="s1">'Bill sum'</span><span class="p">,</span> <span class="n">descending</span><span class="o">=</span><span class="kc">True</span><span class="p">)[</span><span class="s1">'Customer'</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">transactions</span> <span class="o">=</span> <span class="n">Table</span><span class="p">()</span>                                                                                  <span class="c1"># Line 3.0</span>
<span class="n">transactions</span><span class="p">[</span><span class="s1">'Customer'</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'Alice'</span><span class="p">,</span> <span class="s1">'Bob'</span><span class="p">,</span> <span class="s1">'Alice'</span><span class="p">,</span> <span class="s1">'Alice'</span><span class="p">,</span> <span class="s1">'Connie'</span><span class="p">]</span>                                 <span class="c1"># Line 3.1</span>
<span class="n">transactions</span><span class="p">[</span><span class="s1">'Bill'</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="mf">119.99</span><span class="p">,</span> <span class="mf">29.99</span><span class="p">,</span> <span class="mf">10.00</span><span class="p">,</span> <span class="mf">350.00</span><span class="p">,</span> <span class="mf">5.29</span><span class="p">]</span>                                             <span class="c1"># Line 3.2</span>
<span class="n">total_bill_per_customer</span> <span class="o">=</span> <span class="n">transactions</span><span class="o">.</span><span class="n">group</span><span class="p">(</span><span class="s1">'Customer'</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">sum</span><span class="p">)</span>                                        <span class="c1"># Line 3.3</span>
<span class="n">customers_sorted_by_total_bill</span> <span class="o">=</span> <span class="n">total_bill_per_customer</span><span class="o">.</span><span class="n">sort</span><span class="p">(</span><span class="s1">'Bill sum'</span><span class="p">,</span> <span class="n">descending</span><span class="o">=</span><span class="kc">True</span><span class="p">)[</span><span class="s1">'Customer'</span><span class="p">]</span>  <span class="c1"># Line 3.4</span>
<span class="n">top_customer</span> <span class="o">=</span> <span class="n">customers_sorted_by_total_bill</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>                                                        <span class="c1"># Line 3.5</span>
<span class="n">top_customer</span>                                                                                            <span class="c1"># Line 3.6</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>Many programs do hundreds (or millions) of different things, and it would be cumbersome to do this only using expressions.  In this example, we are doing only one thing, using several steps.  The first cell is concise, but it's very hard to read.  In the second cell, we use <em>assignment statements</em> to break down the steps into things that are (hopefully) understandable.</p>
<p>An assignment statement is executed like other statements, but it always causes an effect on the world (recall that we called these <em>side effects</em>).  That is subsequent statements will see the changes made by the assignment.</p></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h3 id="Name-assignments">Name assignments<a class="anchor-link" href="#Name-assignments">¶</a></h3><p>An assignment statement generally has two expressions separated by an equals sign.  The expression on the right can be anything, but the expression on the left must be an "assignable thing".  The simplest case is a name that has not been assigned to anything yet, like <code>total_bill_per_customer</code> on line 3 above.  Before line 3 is executed, it would be an error to refer to <code>total_bill_per_customer</code>, but after line 3, that name can be used to refer to the table created by <code>transactions.group('Customer', np.sum)</code>.</p>
<p>Assignment statements can also reassign existing names to something else:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">number</span> <span class="o">=</span> <span class="mi">3</span>
<span class="n">number</span> <span class="o">=</span> <span class="mi">4</span>
<span class="n">number</span> <span class="o">=</span> <span class="n">number</span> <span class="o">+</span> <span class="mi">2</span>
<span class="n">number</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>As a matter of code style, it is best to avoid this where possible, because it can make your code more confusing.  (If everything is assigned only once, it's trivial to see what its value is when you read code.  Otherwise you might need to hunt down all the assignments.)  But occasionally it is useful, and sometimes it is necessary.  We'll see examples of the latter when we cover iteration.</p></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h3 id="Indexing-assignments">Indexing assignments<a class="anchor-link" href="#Indexing-assignments">¶</a></h3><p>Lines 1 and 2 above are assignments to parts of an <em>indexable</em> thing.  In this case, they add new columns to the <code>transactions</code> Table associated with the strings "Customer" and "Bill", respectively.  Generically, an indexing assignment looks like:</p>

<pre><code>&lt;expression with indexable value&gt;[&lt;expression&gt;] = &lt;expression&gt;

</code></pre>
<p>The same pattern happens when we assign elements of a list or array:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">my_list</span> <span class="o">=</span> <span class="p">[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="s2">"foo"</span><span class="p">]</span>
<span class="n">my_list</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="s2">"bar"</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>Different indexable things can have different behavior when you set something in them.  For example, Tables use string indexing instead of number indexing, and they are okay with adding new columns using indexing assignments (as we saw in lines 1 and 2) or with replacing existing columns with something else.  If we want to change the customer names (say because we made a mistake the first time), we could do that by changing the whole "Customer" column:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">transactions</span><span class="p">[</span><span class="s1">'Customer'</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'Alice'</span><span class="p">,</span> <span class="s1">'Bob'</span><span class="p">,</span> <span class="s1">'Alice'</span><span class="p">,</span> <span class="s1">'Alice'</span><span class="p">,</span> <span class="s1">'Dora'</span><span class="p">]</span> <span class="c1"># </span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>Lists, however, don't let us add new elements.  We can only assign new things to the slots a list had when it was created:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">my_list</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="o">=</span> <span class="s2">"baz"</span>    <span class="c1"># Okay.</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">my_list</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span> <span class="o">=</span> <span class="s2">"garply"</span> <span class="c1"># Error.</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>Note that it is possible to make an existing list longer using extend(), or to make a new, longer copy of the list with <code>+</code>.  You just can't do it with index assignment.</p>
<p>Why do lists have this restriction?</p>
<p>Lists are supposed to contain contiguous ranges of things; they can't have "holes" that aren't indexable.  If you could extend a list by assigning to it at whatever indices you wanted, you could assign elements, say, 0, 1, and 3, leaving 2 unassigned.  Then what should <code>len</code> return for that list -- 3 or 4?  And what should happen when you print it?  Should it say <code>[0,1,&lt;blank&gt;,3]</code>?  It's not clear.  To make sure you don't have to worry about this when you use lists, Python doesn't let you do it.</p></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h2 id="4.-Import-statements">4. Import statements<a class="anchor-link" href="#4.-Import-statements">¶</a></h2><p>A simple, standalone kind of statement is the <em>import statement</em>, as in <code>import numpy as np</code>.  It has the side effect of making the <code>numpy</code> module available, giving it the name <code>np</code>.  Notice that the import statement has its own special rules, and it doesn't include other expressions as subexpressions anywhere.</p>
<p>Modules are actually values, just like strings or functions.  Saying <code>import numpy</code> just loads the module named numpy from the computer's library of modules and assigns it the name <code>numpy</code>.  <code>import numpy as np</code> assigns it the name <code>np</code> instead.  We could imagine that <code>import numpy as np</code> does something like this:</p>

<pre><code>np = load_module('numpy') # BEWARE: NOT REAL PYTHON CODE.

</code></pre>
<p>When you say something like <code>np.array([1,2,3])</code>, you're accessing the <code>array</code> attribute of the module named <code>np</code> and calling it on the list given by <code>[1,2,3]</code>.  (Note that, unlike function attributes of some other values, function attributes of modules are not usually called methods, and they don't get the module value as an extra argument.)</p>
<p><strong>Question.</strong> How many subexpressions (not counting the whole expression) are there in the following expression?</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="o">+</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">4</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h2 id="5.-Function-definitions">5. Function definitions<a class="anchor-link" href="#5.-Function-definitions">¶</a></h2><p>Another important statement is the <em>function definition</em>:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">def</span> <span class="nf">square</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">x</span><span class="o">*</span><span class="n">x</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">square</span><span class="p">(</span><span class="mf">5.5</span><span class="p">)</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>After this line, the function <code>square</code> will be available for calling.  Defining a function doesn't do anything else.  In particular, it's not called unless you call it somewhere.</p>
<p>The function definition is our first example of a statement that takes up multiple lines.  In fact, a function definition is a <em>compound statement</em> that typically includes multiple <em>substatements</em>; its general form is:</p>

<pre><code>def &lt;function name&gt;(&lt;argument list&gt;):
    &lt;substatement 0&gt;
    &lt;substatement 1&gt;
    ...

</code></pre>
<p>Notice the indentation of the statements inside the function.  Indentation tells Python where your function definition ends.  You can use as many spaces as you want (as long as you're consistent), but 4 is traditional.</p></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>When a function is executed (using the function call syntax we saw above), its substatements are executed sequentially, just like an ordinary sequence of statements in a cell.  A substatement can be any statement you want, just like a subexpression can be any expression you want.  You can even put function definitions as substatements inside function definitions.  A special kind of substatement often seen in functions (and nowhere else) is the <code>return</code> statement, which is covered in detail next.  When a return statement is reached, execution finishes (even if there are statements below) and the expression after <code>return</code> becomes the value of the function call.</p>
<p>Before the statements are executed, each name in the <em>argument list</em> is set to the corresponding value in the arguments passed to the function.  For example, when we call <code>square(5.5)</code> above, Python starts executing the statements in the <code>square</code> function, but first sets <code>x</code> to 5.5.  Arguments are how we pass information into functions; functions with no arguments can only behave one way.</p>
<h3 id="Why-functions?">Why functions?<a class="anchor-link" href="#Why-functions?">¶</a></h3><p>Functions are extremely useful for packaging small pieces of functionality into easily-understandable pieces.  Computer code is so powerful that organizing and maintaining it is often much more difficult than just getting the computer to do what we want.  If you can wrap a complicated procedure into a single function, then you can focus once on getting that function written correctly, and then move on to something else, never worrying about its correctness again.  In most moderate- or large-scale software, all code is organized this way -- that is, <em>all code</em> is just a bunch of (relatively short) functions that call each other.</p>
<p>In your labs, and in coding you do outside and after this class, you'll often notice yourself repeating the same thing several times, with slight modifications.  For example, you might analyze a dataset and then perform the same analysis with a different dataset for comparison.  Or you might find yourself repeatedly doing the same mathematical operation, like "square each element and add 5".  When that happens, you should rewrite your code so that the thing you're repeating happens inside a function with a memorable name.</p></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h3 id="Details-about-function-execution">Details about function execution<a class="anchor-link" href="#Details-about-function-execution">¶</a></h3><p>Let's go back to our definition of <code>square</code> for a moment.</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">def</span> <span class="nf">square</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">x</span><span class="o">*</span><span class="n">x</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>It's important to know that the name <code>x</code> is assigned to a value <em>only</em> for the purposes of the statements inside the function.  Outside the function call, argument names are not modified or visible.  For example:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">x</span> <span class="o">=</span> <span class="mi">5</span>
<span class="k">def</span> <span class="nf">cube</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">x</span><span class="o">*</span><span class="n">x</span><span class="o">*</span><span class="n">x</span>
<span class="n">cube</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span> <span class="c1"># 27</span>
<span class="n">x</span> <span class="c1"># Still 5!</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">def</span> <span class="nf">square_root</span><span class="p">(</span><span class="n">does_not_appear_elsewhere</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">does_not_appear_elsewhere</span><span class="o">**</span><span class="p">(</span><span class="mi">1</span><span class="o">/</span><span class="mi">2</span><span class="p">)</span>
<span class="n">square_root</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="n">does_not_appear_elsewhere</span> <span class="c1"># Causes an error.  does_not_appear_elsewhere was only defined inside the function while it was being called.</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>Similarly, any names defined inside a function are only defined inside the function while it's running.  They don't even stick around across calls to the function; each time the function body finishes, the names defined inside it are wiped out, just like argument names.</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">def</span> <span class="nf">times_three</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
    <span class="n">multiplier</span> <span class="o">=</span> <span class="mi">3</span>
    <span class="k">return</span> <span class="n">multiplier</span><span class="o">*</span><span class="n">x</span>

<span class="n">six</span> <span class="o">=</span> <span class="n">times_three</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="n">three</span> <span class="o">=</span> <span class="n">multiplier</span> <span class="c1"># Error!</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h3 id="Functions-as-values">Functions as values<a class="anchor-link" href="#Functions-as-values">¶</a></h3><p>A function definition like</p>

<pre><code>def my_func(x):
    return 2*x

</code></pre>
<p>is really just producing a <em>function value</em> and assigning the name <code>my_func</code> to that value.  In this case, the function value is the function that multiplies its single argument by 2.  You should imagine <code>def</code> as doing something similar to the following (non-functioning) code:</p>

<pre><code>my_func = make_a_function(x): # BEWARE: NOT REAL PYTHON CODE.
    return 2*x

</code></pre>
<p>...where we're imagining for a moment that the special syntax <code>make_a_function(...): ...</code> returns a function.  So names assigned to functions are really just ordinary names, and function values are just like other values.  Of course, function values, like other values, have special behaviors; they can be called using <code>()</code>, and they can't be added together like strings or numbers.</p>
<p><em>Names</em> assigned to functions are also just ordinary names.  It is possible, for example, to redefine a name that was previously defined as a function using <code>def</code> (though this is so confusing that it is usually a bad idea):</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">def</span> <span class="nf">my_func</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
    <span class="k">return</span> <span class="mi">2</span><span class="o">*</span><span class="n">x</span>

<span class="n">eight</span> <span class="o">=</span> <span class="n">my_func</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="n">my_func</span> <span class="o">=</span> <span class="mi">3</span> <span class="c1"># Technically possible, but inadvisable!</span>
<span class="n">my_func</span> <span class="o">+</span> <span class="mi">2</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>We can also put function values into a list, as we saw earlier:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">def</span> <span class="nf">my_func_0</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
    <span class="k">return</span> <span class="mi">0</span><span class="o">*</span><span class="n">x</span>
<span class="k">def</span> <span class="nf">my_func_1</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
    <span class="k">return</span> <span class="mi">1</span><span class="o">*</span><span class="n">x</span>
<span class="n">funcs</span> <span class="o">=</span> <span class="p">[</span><span class="n">my_func_0</span><span class="p">,</span> <span class="n">my_func_1</span><span class="p">]</span>
<span class="n">zero</span> <span class="o">=</span> <span class="n">funcs</span><span class="p">[</span><span class="mi">0</span><span class="p">](</span><span class="mi">3</span><span class="p">)</span>
<span class="n">zero</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>Though Python prints function values in a slightly cryptic way, you can print them if you want:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">funcs</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h2 id="6.-Return-statements">6. Return statements<a class="anchor-link" href="#6.-Return-statements">¶</a></h2><p>Inside a function definition, we very often see yet another kind of statement: the <em>return statement</em>.  This has the form <code>return &lt;expression&gt;</code>.  Any of the expressions we saw above can appear after the <code>return</code>.  This is the value produced by calls to the function.  For example, the value of <code>square(5)</code> is 25, since <code>square</code> will return <code>5*5</code> when it is called with the argument <code>5</code>.</p>
<p><code>return</code> stops execution of the function; subsequent statements are not reached.  For example:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">def</span> <span class="nf">weird_but_technically_correct_square</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">x</span><span class="o">*</span><span class="n">x</span>
    <span class="k">return</span> <span class="p">(</span><span class="n">x</span><span class="o">*</span><span class="n">x</span><span class="p">)</span><span class="o">+</span><span class="mi">1</span>

<span class="n">weird_but_technically_correct_square</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>If a return statement is never reached, calling the function produces no value.  The following code is wrong, for example:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">def</span> <span class="nf">wrong_circle_area</span><span class="p">(</span><span class="n">r</span><span class="p">):</span>
    <span class="n">math</span><span class="o">.</span><span class="n">pi</span><span class="o">*</span><span class="p">(</span><span class="n">r</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span>

<span class="n">some_name</span> <span class="o">=</span> <span class="n">wrong_circle_area</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="n">some_name</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>Unfortunately, this is a mistake that Python will not complain about; it will just silently let <code>some_name</code> have no value.  (Technically it is given a special value called None.  If a statement with value None is the last statement in a cell, Jupyter doesn't print anything, and that's what happens in the above cell.  But you can see the value of <code>some_name</code> if you write, for example, <code>str(some_name)</code>.)</p>
<p>To be clear, we just fix this by <code>return</code>ing whatever we want the function to return:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">def</span> <span class="nf">correct_circle_area</span><span class="p">(</span><span class="n">r</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">math</span><span class="o">.</span><span class="n">pi</span><span class="o">*</span><span class="p">(</span><span class="n">r</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span>

<span class="n">circle_radius_four_area</span> <span class="o">=</span> <span class="n">correct_circle_area</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="n">circle_radius_four_area</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<h2 id="7.-Conditionals">7. Conditionals<a class="anchor-link" href="#7.-Conditionals">¶</a></h2><p>Conditionals are another important kind of multi-line statement:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></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="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">&gt;</span> <span class="mi">4</span><span class="p">:</span>
    <span class="n">message</span> <span class="o">=</span> <span class="s2">"x is a long list!"</span>
<span class="k">else</span><span class="p">:</span>
    <span class="n">message</span> <span class="o">=</span> <span class="s2">"x is a short list!"</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="n">message</span>
</pre></div></div></div>
<div class="inner_cell">
<div class="text_cell_render border-box-sizing rendered_html">
<p>The general form of a conditional is:</p>

<pre><code>if &lt;boolean-valued expression 0&gt;:
    &lt;statement 0.0&gt;
    ...
elif &lt;boolean-valued expression 1&gt;:
    &lt;statement 1.0&gt;
    ...
elif &lt;boolean-valued expression 2&gt;:
    &lt;statement 2.0&gt;
    ...
...
else:
    &lt;statement n.0&gt;
    ...

</code></pre>
<p>If there is an <code>else</code> clause, then exactly one of the statement groups will be executed; otherwise, it's possible that none of them will happen (if none of the expressions next to <code>if</code> or <code>elif</code> are True).</p>
<p>Conditionals are pretty simple, but like functions, they are very important for writing code that does interesting things.</p>
<p>Something to watch out for is that Python will implicitly convert non-boolean values to boolean values, sometimes using surprising rules.  Typically, the convention is that something that is "zero-like" or "empty" is False, while other things are True.  It's best not to rely on this behavior, though; use an explicit comparison that produces a boolean value.  See what happens in the following examples:</p></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">if</span> <span class="mi">0</span><span class="p">:</span>
    <span class="n">x</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">else</span><span class="p">:</span>
    <span class="n">x</span> <span class="o">=</span> <span class="kc">False</span>
<span class="n">x</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">if</span> <span class="mi">1</span><span class="p">:</span>
    <span class="n">x</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">else</span><span class="p">:</span>
    <span class="n">x</span> <span class="o">=</span> <span class="kc">False</span>
<span class="n">x</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">if</span> <span class="s2">"some string"</span><span class="p">:</span>
    <span class="n">x</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">else</span><span class="p">:</span>
    <span class="n">x</span> <span class="o">=</span> <span class="kc">False</span>
<span class="n">x</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">if</span> <span class="s2">""</span><span class="p">:</span>
    <span class="n">x</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">else</span><span class="p">:</span>
    <span class="n">x</span> <span class="o">=</span> <span class="kc">False</span>
<span class="n">x</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">if</span> <span class="p">[]:</span> <span class="c1"># (an empty list)</span>
    <span class="n">x</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">else</span><span class="p">:</span>
    <span class="n">x</span> <span class="o">=</span> <span class="kc">False</span>
<span class="n">x</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">if</span> <span class="p">[</span><span class="mi">3</span><span class="p">]:</span>
    <span class="n">x</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">else</span><span class="p">:</span> 
    <span class="n">x</span> <span class="o">=</span> <span class="kc">False</span>
<span class="n">x</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">if</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([]):</span>
    <span class="n">x</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">else</span><span class="p">:</span> 
    <span class="n">x</span> <span class="o">=</span> <span class="kc">False</span>
<span class="n">x</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">if</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="kc">True</span><span class="p">]):</span>
    <span class="n">x</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">else</span><span class="p">:</span> 
    <span class="n">x</span> <span class="o">=</span> <span class="kc">False</span>
<span class="n">x</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">if</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="kc">False</span><span class="p">]):</span>
    <span class="n">x</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">else</span><span class="p">:</span> 
    <span class="n">x</span> <span class="o">=</span> <span class="kc">False</span>
<span class="n">x</span>
</pre></div></div></div>
<div class="inner_cell">
    <div class="input_area">
<div class=" highlight hl-ipython3"><pre><span></span><span class="k">if</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="kc">True</span><span class="p">,</span> <span class="kc">False</span><span class="p">]):</span>
    <span class="n">x</span> <span class="o">=</span> <span class="kc">True</span>
<span class="k">else</span><span class="p">:</span> 
    <span class="n">x</span> <span class="o">=</span> <span class="kc">False</span>
<span class="n">x</span>
</pre></div></div></div></div>