Anonymous user
Boston Python Workshop 3/Friday/Tutorial: Difference between revisions
Boston Python Workshop 3/Friday/Tutorial (view source)
Revision as of 13:12, 24 September 2011
, 12 years agoProtected "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))) |
||
(60 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
===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
* Functions are
* To use a function, write the name of the function followed by an open 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>
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
<pre>
Line 186 ⟶ 197:
</pre>
are also both valid
You aren't cheating and skipping typing these exercises out, are you? Good! :)
Line 197 ⟶ 208:
<pre>
</pre>▼
Like with the math data types above, we can use the <code>type</code> function to check the type of
<pre>▼
type("Hello")▼
type(1)▼
type("1")▼
</pre>
Line 204 ⟶ 223:
<pre>
print "Hello", "World"▼
</pre>
<pre>▼
name = "Jessica"
</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>
▲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>
Line 235 ⟶ 254:
</pre>
Hey now! The output from the previous example
<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
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
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("")
fish = "humuhumunukunukuapuaʻa"
print fish, "is a Hawaiian fish whose name is", len(fish), "characters long."
</pre>
Line 310 ⟶ 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 325 ⟶ 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 427 ⟶ 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 445 ⟶ 465:
</pre>
You can test if Python objects are equal or unequal. The result is a boolean:
<pre>
Line 469 ⟶ 489:
</pre>
<code><</code>, <code><=</code>, <code>></code>, and <code>>=</code> have the same meaning as in math class. The result of these tests is a boolean:
<pre>
Line 487 ⟶ 507:
</pre>
You can check for containment with the <code>in</code> keyword, which also results in a boolean:
<pre>
Line 522 ⟶ 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>>>></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
<pre>
Line 564 ⟶ 584:
====more choices: <code>if</code> and <code>else</code>====
You can use the <code>else</code> keyword to
<pre>
Line 575 ⟶ 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 616 ⟶ 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 626 ⟶ 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
For example:
<pre>
length = len("Mississippi")
</pre>
We can write our own functions to encapsulate bits of useful work so we can reuse them. Here's how you do it:
Line 640 ⟶ 691:
<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 701 ⟶ 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
We could have written the above function like this if we wanted. It's the same logic, just more typing:
<pre>
Line 733 ⟶ 780:
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==
|