OpenHatch wiki

Boston Python Workshop 3/Friday/Tutorial: Difference between revisions

Page Discussion

Boston Python Workshop 3/Friday/Tutorial (view source)

Revision as of 13:12, 24 September 2011

2,675 bytes added ,  12 years ago
m
Protected "Boston Python Workshop 3/Friday/Tutorial" ([edit=autoconfirmed] (indefinite) [move=autoconfirmed] (indefinite))
imported>Jesstess
imported>Jesstess
m (Protected "Boston Python Workshop 3/Friday/Tutorial" ([edit=autoconfirmed] (indefinite) [move=autoconfirmed] (indefinite)))
 
(66 intermediate revisions by 3 users not shown)
Line 47:
</pre>
 
Hey now! That last result is probably not what you expected. What's going on here is that integer divison produces an integer. You need a number that knows about the decimal point to get a decimal out of division:
 
<pre>
Line 59:
</pre>
 
What do you need to do to get the right answer? Use data types that understand decimals for each of the divisions:
 
<pre>
Line 66:
</pre>
 
The two previous expressions produce the same result. You only need to make one of the numbers in each fraction have a decimal. When the Python interpreter goes to do the division, it notices that one of the numbers in the fraction cares about decimals and says '"that means I have to make the other number care about decimals too".
 
===Modulus===
 
The modulus operator <code>%</code> gives you the remainder after division. For example, 6 % 3 returns 0 because 3 goes into 6 twice, with nothing left over. 5 % 3 returns 2, because 3 goes into 5 once, with 2 left over.
 
<pre>
10 % 2
10 % 3
10 % 4
10 % 5
</pre>
 
==Types==
Line 72 ⟶ 83:
[[File:Geometry.png|150px]]
 
There's a helpful <b>function</b> (more on what a function is in a second) called <code>type</code> that tells you what kind of thing -- what <b>data type</b> -- Python thinks something is. We can check for ourselves that Python considers '1' and '1.0' to be different data types:
 
<pre>
Line 79 ⟶ 90:
</pre>
 
So now we've seen two data types: <b>integers</b> and <b>floats</b>.
 
I used the term 'function' without explaining what it is -- we'll talk about functions more in a bit, and write our own, but for now know these things:
 
* Functions doencapsulate some useful bit of work. We save that useful bit of work inside the function so we don't have to type it over and over again every time we want to use it. So, for example, some nice person decided that being able to determine the type of an object was useful, so he or she put the Python code that figures out an object's type into the function <code>type</code>, and now we all get to use it, instead of having to write it ourselves.
* Functions are asort lotof like functions in math class. You provide input to a function, and it possibly produces output. 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, possiblywhat somethe datafunction takes as input (we call that datainput the <b>arguments</b> to the function), and then a close parenthesis.
 
So in this case 'type' is the name of the function, and it takes one argument; in the example we first give <code>type</code> an argument of 1 and then give it an argument of 1.0.
Line 91 ⟶ 102:
===Command history===
 
Stop here and try hitting the Up arrow on your keyboard a few times. The Python <b>interpreter</b> saves a history of what you've entered, so you can arrow up to old commands and hit Return to re-run them!
 
==Variables==
Line 113 ⟶ 124:
<code>magic_number = 1500</code><br />
<code>amountOfFlour = .75</code><br />
<code>divisible_by_6my_name = 54"Jessica"</code>
 
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
Line 162 ⟶ 173:
</pre>
 
Note that the spacing doesn't matter.:
 
<pre>
Line 174 ⟶ 185:
</pre>
 
are both valid Python <b>syntax</b>and mean the same thing.
 
<pre>
Line 186 ⟶ 197:
</pre>
 
are also both valid syntaxand mean the same thing. You should strive to be consistent with whatever syntaxspacing 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! :)
Line 197 ⟶ 208:
 
<pre>
print "Hello"
print "Python, I'm your #1 fan!"
</pre>
 
Like with the math data types above, we can use the <code>type</code> function to check the type of strings:
 
<pre>
type("Hello")
type(1)
type("1")
</pre>
 
Line 204 ⟶ 223:
 
<pre>
print "Hello" + "World"
print "Hello", "World"
</pre>
 
<pre>
name = "Jessica"
print "Hello " + name
</pre>
 
===Printing===
 
You can print strings using <code>print</code>:
 
<pre>
Line 216 ⟶ 243:
 
<pre>
my_string = "Alpha " + "Beta " + "Gamma " + "Delta"
print my_string
</pre>
 
How about printing different data types together?
Like with the math data types above, we can use the <code>type</code> function to check the type of these strings:
 
<pre>
type("Hello")
type(1)
type("1")
</pre>
 
Printing different data types together
 
<pre>
Line 235 ⟶ 254:
</pre>
 
Hey now! The output from the previous example iswas really different and interesting; let's break down exactly what is happeninghappened:
 
<code>>>> print "Hello" + 1</code><br />
Line 272 ⟶ 291:
</pre>
 
Python is actually turning the integer 1 into a string before printing, and that's why thethat concatenation works: Python does know how to concatenate two strings.
 
We can convert an integer into a string ourselves, using the <code>str</code> function:
Line 280 ⟶ 299:
</pre>
 
Like the <code>type</code> function from before, the <code>str</code> function takes 1 argument,. inIn the above example it took the integer 1. <code>str</code> takes ina 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:
 
<pre>
print len("Hello")
print len("")
fish = "humuhumunukunukuapuaʻa"
print fish, "is a Hawaiian fish whose name is", len(fish), "characters long."
</pre>
 
===Quotes===
Line 299 ⟶ 329:
</pre>
 
This gives us another <b>traceback</b>, 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>
Line 314 ⟶ 344:
 
<pre>
print 'I\'m a happy camper'
print 'Ada Lovelace is often called the world\'s first programmer.'
print "Computer scientist Grace Hopper popularized the term \"debugging\"."
Line 416 ⟶ 447:
[[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 <b>boolean</b> that is helpful for writing code that makes decisions. There are two booleans: <code>True</code> and <code>False</code>:.
 
<pre>
Line 434 ⟶ 465:
</pre>
 
You can test if Python objects are equal or unequal. The result is a boolean:
 
<pre>
Line 458 ⟶ 489:
</pre>
 
<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:
 
<pre>
Line 476 ⟶ 507:
</pre>
 
You can check for containment with the <code>in</code> keyword, which also results in a boolean:
 
<pre>
Line 511 ⟶ 542:
That was our first multi-line piece of code, and the way to enter it at a Python prompt is a little different. First, type the <code>if True:</code> part, and hit 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 <b>code block</b>, and so long as we indent our code it should be a part of this code block.
 
Type 4 spaces, and then type <code>print "I'm True!"</code>. Hit enter to end the line, and hit enter again to tell Python you are done with this code block. All together, it will look something like this:
 
<pre>
Line 553 ⟶ 584:
====more choices: <code>if</code> and <code>else</code>====
 
You can use the <code>else</code> keyword to conditionally execute code only when the expression for the <code>if</code> blockexpression isn't trueTrue:
 
<pre>
Line 564 ⟶ 595:
</pre>
 
Like with <code>if</code>, the code block under the <code>else</code> statement 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>====
Line 605 ⟶ 636:
print "Can I interest you in some choice gouda?"
</pre>
 
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 have 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 True condition or reaches the default <code>else</code> block.
 
<pre>
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"
</pre>
 
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 True:
 
<pre>
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!"
</pre>
 
If color had been "purple", that code wouldn't have printed anything.
 
==Writing Functions==
Line 615 ⟶ 677:
* They let us re-use code without having to type it out each time.
* They take input and possibly produce output (we say they <b>return</b> a value). You can assign a variable to this output.
* You call a function by using its name followed by theits input<b>arguments</b> in parenthesis.
 
For example:
 
<pre>
length = len("Mississippi")
x = type(5)
</pre>
 
RunningExecuting this code assigns the typelength of <code>5</code>the --string an"Mississippi" integerto --the tovariable <code>xlength</code>.
 
We can rightwrite our own functions to encapsulate bits of useful work so we can reuse them. Here's how you do it:
 
<b>Step 1: write a function signature</b>
 
A <b>function signature</b> tells you how the function will be called. It starts with the keyword <code>def</code>, which tells Python that you are defining a function. Then comes a space, the name of your function, an open parenthesis, the comma-separated input <b>parameters</b> for your function, a close parenthesis, and a colon. Here's what a function signature looks like for a function that takes no arguments:
 
<code>def myFunction():</code>
<pre>
def myFunction():
</pre>
 
Here's what a function signature looks like for a function that takes one argument called <code>string</code>:
 
<code>def myFunction(string):</code>
<pre>
def myFunction(string):
</pre>
 
And one for a function that takes two arguments:
 
<code>def myFunction(myList, myInteger):</code>
<pre>
def myFunction(myList, myInteger):
</pre>
 
Parameters should have names that usefully describe what they are used for in the function.
Line 690 ⟶ 746:
</pre>
 
if <code>number</code> is less than 0, you return <code>number * -1</code> and never even get to the last line of the function. However, if <code>number</code> is greater than or equal to 0, the conditional for the <code>if</code> blockexpression evaluates to <code>False</code>, so we skip the code in the <code>if</code> block and return <code>return number</code>. We could have written the above function like this if we wanted. It's the same logic, just more typing:
 
We could have written the above function like this if we wanted. It's the same logic, just more typing:
 
<pre>
Line 702 ⟶ 760:
<b>Step 4: use the function</b>
 
Once you define thisa function, you can use it as many times as you want:
 
<pre>
def add(x, y):
return x + y
 
result = add(1234, 5678)
print result
result = add(-1.5, .5)
print result
</pre>
Line 716 ⟶ 779:
 
Learning about functions opens up a whole new way for us to practice, using the programming site [http://codingbat.com codingbat.com]. The big goal of this practice section is to get you thinking about how to solve problems in Python.
 
Please visit http://codingbat.com/home/jessica.mckellar@gmail.com/Friday to complete the practice problems. You don't have to create a CodingBat account to do the exercises, but if you do create an account it'll keep track of which problems you've completed and other statistics.
 
==End of Part 2==
Anonymous user
Retrieved from "https://wiki.openhatch.org/wiki/Special:MobileDiff/7335...7402"