Editing Community Data Science Workshops (Core)/Day 0 Tutorial

Welcome to the Friday tutorial!

This tutorial covers several core programming concepts that we'll build upon during an interactive lecture tomorrow morning. It will take 1-2 hours to complete. There's a break in the middle, and exercises at the middle and end to help review the material.

To get started, fire up a new Jupyter notebook. Name it as you like. 

This is an interactive tutorial! As you go through this tutorial, any time you see something that looks like this:

<syntaxhighlight lang="python">
 a = "Hello"
</syntaxhighlight>

you should type the expression in a new cell of your Jupyter notebook (found in the 'Insert' menu), then hold Shift and hit Return (or Enter) after every line and check the output, making sure it matches your expectations.

No copying and pasting! You'll learn the concepts better if you type them out yourself.

==Math== 

[[File:Calculator.png|100px]]

Math in Python looks a lot like math you type into a calculator. A Jupyter notebook makes a great calculator if you need to crunch some numbers and don't have a good calculator handy.

===Addition===

<syntaxhighlight lang="python">
 2 + 2</syntaxhighlight>
<syntaxhighlight lang="python">

 1.5 + 2.25
</syntaxhighlight>

===Subtraction===
<syntaxhighlight lang="python">
 4 - 2</syntaxhighlight>
<syntaxhighlight lang="python">

 100 - .5</syntaxhighlight>
<syntaxhighlight lang="python">

 0 - 2
</syntaxhighlight>

===Multiplication===
<syntaxhighlight lang="python">
 2 * 3
</syntaxhighlight>
===Division===

First, lets try some basic fractions:

<syntaxhighlight lang="python">
 1 / 2
</syntaxhighlight>

Sure enough, Python says that the answer is 0.5 which is the same as 1/2.

Let's try the same thing:

<syntaxhighlight lang="python">
 4 / 2
</syntaxhighlight>

Hey now! That last result is a little strange. When you divide a number in Python, even if the answer doesn't need a decimal place (like <code>4/2</code> which equals 2), you get an answer with a decimal point!

What's going on here is that in Python, division produces an what's called a <code>float</code> which essentially means a number with a decimal point.

When the Python interpreter goes to do the division, it knows that (unlike multiplication for example) division can lead to numbers that aren't whole numbers (like <code>1/2</code>) so it makes sure that the result will always include a decimal place just in case it's needed.


This shouldn't be important for this workshop but it might be worth knowing that older versions of Python (before version 3) would always round down and return integers instead of giving numbers with decimal places.

==Types==

[[File:Geometry.png|150px]]

There's a helpful '''function''' (more on what a function is in a second) called <code>type</code> that tells you what kind of thing -- what '''data type''' -- Python thinks something is. We can check for ourselves that Python considers '1' and '1.0' to be different data types:
<syntaxhighlight lang="python">
 type(1)</syntaxhighlight>
<syntaxhighlight lang="python">

 type(1.0)
</syntaxhighlight>
So now we've seen two data types: '''integers''' and '''floats'''. Python tags your variables with a data type to make better guesses about what you want and to prevent errors. Another data type you'll run into is strings (a sequence of letters, numbers, and symbols, like the ones you're reading right now -- we'll look at strings a bit more in a moment).

What's a "function"? Here are the important ideas about functions:

* A function encapsulates (packages up) a useful bit of work and gives that work a name.
* You provide input to a function and it produces output. For example, the <code>type</code> function takes data as an input, and produces what type of data the data is (e.g. an integer or a float) as output.
* To use a function, write the name of the function, followed by an open parenthesis, then what the function needs as input (we call that input the '''arguments''' to the function), and then a close parenthesis.
* Programmers have a lot of slang around functions. They'll say that functions "take" arguments, or that they "give" or "pass" arguments to a function. "call" and "invoke" are both synonyms for using a function.

In the example above, "type" was the name of the function. <code>type</code> takes one argument; we first gave <code>type</code> an argument of 1 and then gave it an argument of 1.0.

==== Diagram of "calling" a function ====

[[File:Function_diagram.png]]

===Jupyter history===

In your Jupyter notebook, any time you want to re-run a command, you can select that cell again and repeat the same Shift+Enter action to re-run the cell.

==Variables==

[[File:Fraction.png|100px]]

A lot of work gets done in Python using variables. Variables are a lot like the variables in math class, except that in Python variables can be of any data type, not just numbers.
<syntaxhighlight lang="python">
 type(4)</syntaxhighlight>
<syntaxhighlight lang="python">

 x = 4
</syntaxhighlight>
<syntaxhighlight lang="python">
 x
</syntaxhighlight>
<syntaxhighlight lang="python">

 type(x)
</syntaxhighlight>
<syntaxhighlight lang="python">
 2 * x
</syntaxhighlight>
Giving a name to something, so that you can refer to it by that name, is called '''assignment'''. Above, we assigned the name 'x' to 4, and after that we can use <code>x</code> wherever we want to use the number 4. You'll see that there wasn't any output here when you ''assigned'' 4 to <code>x</code>; that's fine! Not all Python operations have output, and in fact most of the time that's what you expect.

Variables can't have spaces or other special characters, and they need to start with a letter. Here are some valid variable names:
<syntaxhighlight lang="python">
 magic_number = 1500
 amountOfFlour = .75
 my_name = "Jessica"
</syntaxhighlight>

Projects develop naming conventions: maybe multi-word variable names use underscores (like <code>magic_number</code>), or "camel case" (like <code>amountOfFlour</code>). The most
important thing is to be consistent within a project, because it makes the code more readable.

==Output==

[[File:Pacman.png|100px]]

Notice how if you type a 4 and hit enter, the Python interpreter spits a 4 back
out:
<syntaxhighlight lang="python">
 4
</syntaxhighlight>
But if you assign 4 to a variable, nothing is printed:
<syntaxhighlight lang="python">
 x = 4
</syntaxhighlight>
You can think of it as that something needs to get the output. Without an assignment, the winner is the screen. With assignment, the output goes to the variable.

You can reassign variables if you want. What do you think will print if you type in:
<syntaxhighlight lang="python">
 x = 4
 x
 x = 5
 x
</syntaxhighlight>
Sometimes reassigning a variable is an accident and causes bugs in programs.
<syntaxhighlight lang="python">
 x = 3
 y = 4
 x * y
 x * x
 2 * x - 1 * y
</syntaxhighlight>
Order of operations works pretty much like how you learned in school. If you're unsure of an ordering, you can add parentheses like on a calculator:
<syntaxhighlight lang="python">
 (2 * x) - (1 * y)
</syntaxhighlight>
Note that the spacing doesn't matter:
<syntaxhighlight lang="python">
 x = 4
</syntaxhighlight>
and
<syntaxhighlight lang="python">
 x=4
</syntaxhighlight>
are both valid Python and mean the same thing.
<syntaxhighlight lang="python">
 (2 * x) - (1 * y)
</syntaxhighlight>
and
<syntaxhighlight lang="python">
 (2*x)-(1*y)
</syntaxhighlight>
are also both valid and mean the same thing. You should strive to be consistent with whatever spacing you like or a job requires, since it makes reading the code easier.

You aren't cheating and skipping typing these exercises out, are you? Good! :)

==Strings==

[[File:Letter.png|100px]]

So far we've seen two data types: '''integers''' and '''floats'''. Another useful data type is a '''string''', which is just what Python calls a bunch of characters (like numbers, letters, whitespace, and punctuation) put together. Strings are indicated by being surrounded by quotes:
<syntaxhighlight lang="python">
 "Hello"
</syntaxhighlight>
<syntaxhighlight lang="python">
 "Python, I'm your #1 fan!"
</syntaxhighlight>
Like with the math data types above, we can use the <code>type</code> function to check the type of strings:
<syntaxhighlight lang="python">
 type("Hello")
</syntaxhighlight>
<syntaxhighlight lang="python">
 type(1)
</syntaxhighlight>
<syntaxhighlight lang="python">
 type("1")
</syntaxhighlight>
===String Concatenation===

You can smoosh strings together (called "concatenation") using the '+' sign:
<syntaxhighlight lang="python">
 "Hello" + "World"
</syntaxhighlight>
<syntaxhighlight lang="python">

 name = "Jessica"
 "Hello " + name
</syntaxhighlight>
How about concatenating different data types?
<syntaxhighlight lang="python">
 "Hello" + 1
</syntaxhighlight>
Hey now! The output from the previous example was really different and interesting; let's break down exactly what happened: (you'll see a ''slightly'' different "Traceback" statement, that difference doesn't matter.)

<pre>
In[ ]: "Hello" + 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects
</pre>

Python is giving us a '''traceback'''. A traceback is details on what was happening when Python encountered an Exception or Error -- something it doesn't know how to handle.

There are many kinds of Python errors, with descriptive names to help us humans understand what went wrong. In this case we are getting a <code>TypeError</code>: we tried to do some operation on a data type that isn't supported for that data type.

Python gives us a helpful error message as part of the TypeError:

<code>"cannot concatenate 'str' and 'int' objects"</code>

We saw above that we can concatenate strings:

 "Hello" + "World"

works just fine.

However,

 "Hello" + 1

produces a <code>TypeError</code>. We are telling Python to concatenate a string and an integer, and that's not something Python understands how to do.

We can convert an integer into a string ourselves, using the <code>str</code> function:

 "Hello" + str(1)

Like the <code>type</code> function from before, the <code>str</code> function takes 1 argument. In the above example it took the integer 1. <code>str</code> takes a Python object as input and produces a string version of that input as output.

===String length===

There's another useful function that works on strings called <code>len</code>. <code>len</code> returns the length of a string as an integer:

<syntaxhighlight lang="python">
 len("Hello")
</syntaxhighlight>
<syntaxhighlight lang="python">
 len("")
 fish = "humuhumunukunukuapua'a"
 name_length = len(fish)
 fish + " is a Hawaiian fish whose name is " + str(name_length) + " characters long."
</syntaxhighlight>

===Quotes===

We've been using double quotes around our strings, but you can use either double or single quotes:
<syntaxhighlight lang="python">
 'Hello'
 "Hello"
</syntaxhighlight>
Like with spacing above, use whichever quotes make the most sense for you, but be consistent.

You do have to be careful about using quotes inside of strings:

 'I'm a happy camper'

This gives us another '''traceback''', for a new kind of error, a <code>SyntaxError</code>. When Python looks at that expression, it sees the string 'I' and then

<code>m a happy camper'</code>

which it doesn't understand -- it's not 'valid' Python. Those letters aren't variables (we haven't assigned them to anything), and that trailing quote isn't balanced. So it raises a <code>SyntaxError</code>.

We can use double quotes to avoid this problem:

 "I'm a happy camper"

One fun thing about strings in Python is that you can multiply them:
<syntaxhighlight lang="python">
 "A" * 40
 "ABC" * 12
 h = "Happy"
 b = "Birthday"
 (h + b) * 10
</syntaxhighlight>

==Part 1 Practice==

[[File:Detective.png|100px]]

Read the following expressions, but don't execute them. Guess what the output will be. After you've made a guess, copy and paste the expressions into your Jupyter notebook and check your guess.

1.
<syntaxhighlight lang="python">
 total = 1.5 - 1/2
 total
 type(total)
</syntaxhighlight>

2.
<syntaxhighlight lang="python">
 a = "quick"
 b =  "brown"
 c = "fox jumps over the lazy dog"
 "The " +  a * 3 + " " +  b * 3 + " " + c
</syntaxhighlight>
==End of Part 1==

Congratulations! You've learned about and practiced math, strings, variables, data types, exceptions, tracebacks, and executing Python from the Python prompt.

Take a break, stretch, meet some neighbors, and ask the staff if you have any questions about this material.

[[File:Fireworks.png|200px]]

==Making choices==

We can use these expressions that <i>evaluate</i> to booleans to make decisions and conditionally execute code.

[[File:Fork.png|100px]]

====if statements====

The simplest way to make a choice in Python is with the <code>if</code> keyword. Here's an example (don't try to type this one, just look at it for now):

&nbsp;&nbsp;&nbsp;&nbsp;<code>if 6 > 5:</code><br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<code>print("Six is greater than five!")</code>

That is our first multi-line piece of code, and the way to type it into a Jupyter notebook is a little different. Let's break down how to do this (type this out step by step):

First, type the <code>if 6 > 5:</code>, then hit enter. ''Not'' Shift + Enter, because this time we want to write more than one line before we ask Jupyter to run it!

Once you've hit enter, you'll see that your carat is indented already for you; Jupyter understands that you're now inside the <code>if</code> ''code block'', and adjusts your indentation position for you. In Python, all lines of a block are at the same indentation level, and the block ends when you reduce your indentation again.

Write <code>print("Six is greater than five!")</code>, then hit enter, and now hit Shift+Enter to run this if statement!
<ol>
<li>First, type the<br />
<br />
&nbsp;&nbsp;&nbsp;&nbsp;<code>if 6 > 5:</code><br />
<br />
part, and press Enter. The next line will have <code>...</code> as a prompt, instead of the usual <code>&gt;&gt;&gt;</code>. This is Python telling us that we are in the middle of a '''code block''', and so long as we indent our code it should be a part of this code block.</li>

<li>Press the spacebar 4 times to indent.</li>
<li>Type<br />
<br />
&nbsp;&nbsp;&nbsp;&nbsp;<code>print("Six is greater than five!")</code><br /><br /></li>
<li>Press Enter to end the line. The prompt will still be a <code>...</code></li>
<li>Press Enter one more time to tell Python you are done with this code block. The code block will now execute.</li>
</ol>

All together, it will look like this:

<pre>
if 6 > 5:
     print("Six is greater than five!")

Six is greater than five!
</pre>

What is going on here? When Python encounters the <code>if</code> keyword, it <i>evaluates</i> the <i>expression</i> following the keyword and before the colon. If that expression is '''True''', Python executes the code in the indented code block under the <code>if</code> line. If that expression is '''False''', Python skips over the code block.

In this case, because 6 really is greater than 5, Python executes the code block under the if statement, and we see "Six is greater than five!" printed to the screen. Guess what will happen with these other expressions, then type them out and see if your guess was correct:

<pre>
if 0 > 2:
     print("Zero is greater than two!")
</pre>

<pre>
if "banana" in "bananarama":
    print("I miss the 80s.")
</pre>

====more choices: <code>if</code> and <code>else</code>====

'''<code>if</code>''' lets you execute some code only if a condition is <code>True</code>. What if you want to execute different code if a condition is <code>False</code>?

Use the '''<code>else</code>''' keyword, together with <code>if</code>, to execute different code when the <code>if</code> condition isn't <code>True</code>. Try this:

<syntaxhighlight lang="python">
sister_age = 15
brother_age = 12
if sister_age > brother_age:
    print("sister is older")
else:
    print("brother is older")
</syntaxhighlight>

Like with <code>if</code>, the code block under the <code>else</code> condition must be indented so Python knows that it is a part of the <code>else</code> block.

====compound conditionals: <code>and</code> and <code>or</code>====

You can check multiple expressions together using the '''<code>and</code>''' and '''<code>or</code>''' keywords. If two expressions are joined by an <code>and</code>, they '''both''' have to be <code>True</code> for the overall expression to be <code>True</code>. If two expressions are joined by an <code>or</code>, as long as '''at least one''' is <code>True</code>, the overall expression is <code>True</code>.

Try typing these out and see what you get:

<syntaxhighlight lang="python">
1 > 0 and 1 < 2
</syntaxhighlight>

<syntaxhighlight lang="python">
1 < 2 and "x" in "abc"
</syntaxhighlight>

<syntaxhighlight lang="python">
"a" in "hello" or "e" in "hello"
</syntaxhighlight>

<syntaxhighlight lang="python">
1 <= 0 or "a" not in "abc"
</syntaxhighlight>

Guess what will happen when you enter these next two examples, and then type them out and see if you are correct. If you have trouble with the indenting, call over a staff member and practice together. It is important to be comfortable with indenting for tomorrow.

<syntaxhighlight lang="python">
temperature = 32
if temperature > 60 and temperature < 75:
    print("It's nice and cozy in here!")
else:
    print("Too extreme for me.")
</syntaxhighlight>

<syntaxhighlight lang="python">
hour = 11
if hour < 7 or hour > 23:
    print("Go away!")
    print("I'm sleeping!")
else:
    print("Welcome to the cheese shop!")
    print("Can I interest you in some choice gouda?")
</syntaxhighlight>

You can have as many lines of code as you want in <code>if</code> and <code>else</code> blocks; just make sure to indent them so Python knows they are a part of the block.

====even more choices: <code>elif</code>====

If you need to execute code conditional based on more than two cases, you can use the '''<code>elif</code>''' keyword to check more cases. You can have as many <code>elif</code> cases as you want; Python will go down the code checking each <code>elif</code> until it finds a <code>True</code> condition or reaches the default <code>else</code> block.

<syntaxhighlight lang="python">
sister_age = 15
brother_age = 12
if sister_age > brother_age:
    print("sister is older")
elif sister_age == brother_age:
    print("sister and brother are the same age")
else:
    print("brother is older")
</syntaxhighlight>

You don't have to have an <code>else</code> block, if you don't need it. That just means there isn't default code to execute when none of the <code>if</code> or <code>elif</code> conditions are <code>True</code>:

<syntaxhighlight lang="python">
color = "orange"
if color == "green" or color == "red":
  print("Christmas color!")
elif color == "black" or color == "orange":
  print("Halloween color!")
elif color == "pink":
  print("Valentine's Day color!")
</syntaxhighlight>

If color had been "purple", that code wouldn't have printed anything.

'''Remember that  '=' is for assignment and '==' is for comparison.'''

====In summary: the structure of if/elif/else====

Here's a diagram of <code>if/elif/else</code>:

[[File:If-elif-else.png]]

Do you understand the difference between <code>elif</code> and <code>else</code>? When do you indent? When do you use a colon? If you're not sure, talk about it with a neighbor or staff member.

==Booleans==

Please return to the interactive Python interpreter for the rest of the tutorial. And remember: type out the examples. You'll thank yourself tomorrow. :)

[[File:Scales.png|100px]]

So far, the code we've written has been <i>unconditional</i>: no choice is getting made, and the code is always run. Python has another data type called a '''boolean''' that is helpful for writing code that makes decisions. There are two booleans: <code>True</code> and <code>False</code>.
<syntaxhighlight lang="python">
 True

 type(True)

 False

 type(False)
</syntaxhighlight>
You can test if Python objects are equal or unequal. The result is a boolean:
<syntaxhighlight lang="python">
 0 == 0

 0 == 1
</syntaxhighlight>
Use <code>==</code> to test for equality. Recall that <code>=</code> is used for <i>assignment</i>.

This is an important idea and can be a source of bugs until you get used to it: '''= is assignment, == is comparison'''.

Use <code>!=</code> to test for inequality:
<syntaxhighlight lang="python">
 "a" != "a"

 "a" != "A"
</syntaxhighlight>
<code>&lt;</code>, <code>&lt;=</code>, <code>&gt;</code>, and <code>&gt;=</code> have the same meaning as in math class. The result of these tests is a boolean:
<syntaxhighlight lang="python">
 1 > 0

 2 >= 3

 -1 < 0

 .5 <= 1
</syntaxhighlight>
You can check for containment with the <code>in</code> keyword, which also results in a boolean:
<syntaxhighlight lang="python">
 "H" in "Hello"

 "X" in "Hello"
</syntaxhighlight>
Or check for a lack of containment with <code>not in</code>:
<syntaxhighlight lang="python">
 "a" not in "abcde"

 "Perl" not in "Python Workshop"
</syntaxhighlight>
==End of Part 2==

Congratulations! You've learned about and practiced executing Python scripts, booleans, conditionals, and making choices with if, elif, and else. This is a huge, huge accomplishment!

[[File:Champagne.png|100px]][[File:Party.png|125px]]

Take a break, stretch, meet some neighbors, and ask the staff if you have any questions about this material.

==Common Issues==
===I was expecting python to print lots of lines of text when I ran this cell, but it only prints one line!===
Jupyter only outputs the last line of a code chunk unless you explicitly wrap the code in print() statements. If you split your code into multiple chunks or print() the line, it should look like you expect.
[[Category:Shared_Pages]]
[[Category:CDSW]]