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

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:

What do you need to do to get the right answer? Use data types that understand decimals for each of the divisions:

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".

* 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 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.

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!

print "Hello"

print "Python, I'm your #1 fan!"

print "Hello" + "World"

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.

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 in a Python object as input and produces a string version of that input as output.

====String length====

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

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>:.

You can test if Python objects are equal or unequal. The result is a boolean:

<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:

You can check for containment with the <code>in</code> keyword, which also results in a boolean:

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:

You can use the <code>else</code> keyword to execute code only when the <code>if</code> expression isn't trueTrue:

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.

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> condition until it finds a trueTrue condition or reaches the default <code>else</code> block.

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 cases<code>if</code> matchor <code>elif</code> conditions are True:

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

* You call a function by using its name followed by theits input<b>arguments</b> in parenthesis.

RunningExecuting this code assigns the length of the string "Mississippi" to the variable <code>length</code>.

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:

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: