IdeaWazaWiki - User contributions [en]

Truth and flow control in Python

2007-12-07T13:37:30Z

195.99.136.50: /* For concept in lesson: learn(concept) */

==Boolean Expressions==
Python has a Boolean type. The two values for this type are True and False. Note the capitalization: the first letter must be capitalized. Most text editors, including IDLE, will highlight True and False when properly capitalized.

===The bool() Function===
If you need to convert something into a boolean value, use the bool() function. For example:
>>> bool(1)
True
>>> bool(0)
False
>>> bool(500)
True
>>> bool(-1)
True
In Python, the integer 0 evaluates to False. All other integers will evaluate to True. As a general rule, try to avoid using Floating Point numbers in boolean expressions: use the int() operator to turn them into integers first.

Strings behave similarly: an empty string evaluates to False, all other strings evaluate to True.
>>> bool("Hello World!")
True
>>> bool("")
False
>>> bool("True")
True
>>> bool("False")
True
>>> bool("0")
True
Note that what is ''in'' the string does not matter: It can be "0", "False" or "ReallyReallyFalse": Everything that is not simply an empty string will evaluate to true.

==Comparison Operators==
Python has a number of built-in comparison operators. They are very versatile and can often be used across data types.
=== Equality===
The Python operator for Equality is ==. Let's try it out:
>>> 1==1
True
>>> "1"=="1"
True
>>> 2+4 == 24
False
>>> "2"+"4" == "24"
True

=== Conjunction ===
The Python operator for conjunction is '''''and'''''.
>>> True and False
False
>>> True and True
True
>>> False and False
False
>>> False and True
False

The '''and''' operator works by evaluating until it runs into something false, and return the value that evaluated to false. If everything is True, it returns the last thing it evaluated.

>>> "a" and "b"
<nowiki>'b'</nowiki>
>>> "" and "b"
<nowiki>''</nowiki>
>>> True and 7
7
>>> True and [] and "a"
[]

=== Disjunction ===
The '''''or''''' operator works similar to the '''and''' operator. It returns the first value to be true, or the final value if there is no true value.

>>> False or ('a', 'b') or 'c'
('a', 'b')
>>> False or True
True
>>> <nowiki>''</nowiki> or False
False
>>> <nowiki>''</nowiki> or False or ()
()

*Todo: Add other operators (not, is, in...)

==Flow Control==
Now that you know all these great ways to work with booleans, let's use them!

==If, Elif, and Else==
Python uses a simple keyword called "if" to determine ''if'' it should execute a section of code. You can tell which lines are in this section by the level of indentation. The general format of if goes like this:
if [Boolean Expression]:
some code
rest of code
This allows for very simple logic. What if you want to have two options, similar to "case" in other languages? Instead of Case, python uses "elif".
if [Boolean Expression]:
code
elif [Boolean Expression]:
More code
else:
Even more code
rest of program
One thing that's important to realize is that if the boolean expression for the first "if" is True, nothing in the elif section will execute, nor will anything in the else section. If there are multiple things that could evaluate to True, use multiple if statements.

That code sample also introduced the "else" statement. Else gets executed if the "if" statement's boolean expression, and the boolean expressions for all elifs (if there are any), evaluate to False.

So, how about some actual code? Here's a simple program; try entering this into IDLE and running it.
name = raw_input("What is your name?")
if name == "":
print "Hey! You didn't enter a name!"

elif name == "spam" or name == "eggs":
print "A moose once bit my sister!"

else:
print "Nice to meet you, %s." % name
===While===
While is our first example of a loop. While evaluates a boolean expression, and if that expression is True, it runs some section of code. It then re-evaluates that boolean expression: if it still evaluates to True, then it runs again. It keeps running - possibly forever! - until that loop evaluates to False, at which point the program continues with whatever comes after the while loop.

Let's take our previous example. That program ran once, and even if nothing was entered, it was done. Let's suppose we instead want a program that "won't take no" for an answer: We'll use a while loop to make the prompt show up again and again until we get some response:
name = raw_input("What is your name?")
while name == "":
print "Hey! You didn't enter a name!"
name = raw_input("Okay, REALLY tell me your name this time:")
if name == "spam" or name == "eggs":
print "A moose once bit my sister!"
else:
print "Nice to meet you, %s" % name
That's even better. However, there are a couple of things I don't like about it. First, I don't like that first boolean expression. After all, we know that:
bool("")==False
Therefore, wouldn't it make more sense just to test if name is False than to test if it's ''True'' that it's ''equal'' to ""?
while bool(name) == False:
And do we really want to test if it's True than to Test that it's ''True'' that it's equal to ''False''?
while not bool(name):
That's right! Python has a "not" keyword, which acts a lot like ! in other languages. Python as ! too, but not is often clearer when working with long boolean expressions.

We're missing one last thing: whatever comes after the "while" is automatically evaluated as a boolean expression. That means that in many cases (this one included) we can leave out the "bool()." (There will still be cases where it's needed, though, so remember that it exists!)
while not name: # This is exactly the same as 'while name == "":', but a lot clearer.
Okay, good? Cool. It's time to add a new feature: The for loop.

===For concept in lesson: learn(concept)===
If you thought the Python idioms for the while loop were cool, the for loop is even better. A for loop takes this basic form syntax-wise:
for [variable name] in [sequence]:
code
The for loop will execute enough times that each element of "sequence" is assigned to "variable" once. For example:
for i in [1,2,3]:
print i, # 1 2 3
Of course, any data type could be within the sequence. While we're at it, let's use a descriptive variable name:
for letter in ['a','b','c']:
print letter # output is a b c
As you can see, then, for loops make it easy to iterate over a sequence, or in simpler terms, to do something with each entry in a list. For loops are also excellent for times when you need to run a while loop a fixed number of times. Let's compare doint that with a for loop and a while loop:
c = 0
while c <10:
someFunction(c)
# code, code code
c +=1
While this is legal Python code, it's not really descriptive. Furthermore, when working with large code blocks, it's easy to forget to add 1 to the variable (in this case 'c') at the end. Fortunately, we can do the same thing with a for loop, in a clearer fashion.
for i in range(10):
someFunction(i)
# More code as needed
Note how we don't have to worry about declaring i, or automatically incrementing it. It's also significantly faster, although most of the time your code will run fast enough anyway.

Note that while I used 'i' as the variable name, you could use anything else. AS a general rule, when using the variable as a counter, simply use 'i'; this convention is widely followed and helps other programmers know exactly why you chose a for loop. Otherwise, use a descriptive variable name. For example:
aListOfDates = someFunction()
for date in aListOfDates:
doSomethingWith(date)
[[User:AdamG|I]] can personally say that I rarely use while loops. The main reason I use them at all, in fact, is when I need to repeatedly prompt a user until I get valid input.

Simply put, use while when you don't know or can't calculate how many times a loop will run. If you can, use for.

[[Category:Python]]
[[Category:Programming]]

Archive:Python/Operators

2007-12-07T11:48:43Z

195.99.136.50: /* Indexing */

=Operations, The Format Specifier, and Other Commands=

==Operations==

There are certain things that you can do with all of the ''types''. You can ''do simple math, index, slice, and check for membership.'' You can also use the Format Specifier in ''strings''.

===Simple Math===

Math is very straight forward in Python. + adds, - subtracts, / divides, and believe it or not * multiplies. The main thing to comment on is %. % divides a problem and then returns the remainder. This is called the modulo operation.

Type:

>>> '''9 % 3'''

0

Now Type:

>>> '''9 % 2'''

1

The % command can be used to find out if something is even or odd or if it is a multiple of some number. Here is some code that is a little advanced for you right now. Just type it in and now that within a couple of lessons you will know what you did. When you type '''"print a is even"''' it must be 4 spaces to the right of the '''i''' in '''if''', I am having trouble working with Wikiversity and can't get it to do that on this page without forming some kind of box.

Type:

>>> '''a = 4'''
>>> '''if a % 2 == 0:'''
... '''print "a is even"'''
'''a is even'''

You can also use variables, and elements and values in simple math.

Type:

>>> '''x = 1'''

>>> '''y = 5'''

Now Type:

>>> '''x + y'''

'''6'''

That is how the variable works.

Type:

>>> '''x = [1, 2, 3]'''

Now Type:

>>> '''x[1] + x[2]'''

'''5'''

That is how you use elements from a tuple or list to do math.

Type:

>>> '''x = {'a':1, 'b':2}'''
=You can also add and multiply strings, tuples, and lists.
Now Type:

>>> '''x['a'] + x['b']

'''3'''

That is how you do math with values from a dictionary. Don't forget to use quotations around the keys unless you use ''integers'' as the keys. Spend a couple of minutes messing around with this stuff, its fun and it'll help you remember it better. You may also add strings, tuples, and lists.

====Concatenating====

To add two strings together. to do this you just type the first string, an addition sign, the second string.

Type:

>>> '''"Python" + " is awesome"'''

You can do the same with variables refering to strings.

Type:

>>> '''x = "Python"'''

>>> '''y = " is awesome"'''

Now Type:

>>> '''x + y'''

''''Python is awesome''''

You can do the same with tuples.

Type:

>>> '''x = ('I', 'Love')

>>> '''y = ('Wikiversity',)''' ''DON'T FORGET THE COMMA AFTER '''WIKIVERSITY'''''

Now Type:

>>> '''print x + y'''

'''('I', 'Love', 'Wikiversity')'''

It works the same with ''lists''. What you cannot do is combine two different kinds of ''types''.

Type:

>>> '''x = ('I', 'Love')'''

>>> '''y = 'Python''''

Now Type:

>>> '''print x + y'''

'''Traceback (most recent call last):'''

'''File "<pyshell#91>", line 1, in ?'''

'''print x + y'''

'''TypeError: can only concatenate tuple (not "str") to tuple'''

====Multiplying ''Types''====

Multiplying is very easy and straight forward.

Type:

>>> '''x = 'dog''''

Now type:

>>> '''x * 5'''

''''dogdogdogdogdog''''

Now with a tuple.

Type:

>>> '''x = ('dog',)'''

Now Type:

>>> '''x * 5'''

'''('dog', 'dog', 'dog', 'dog', 'dog')'''

Now with a dictionary.

Type:

>>> '''x = {'dog':1}'''

Now Type:

>>> '''x * 5'''

'''Traceback (most recent call last):'''

'''File "<pyshell#5>", line 1, in ?'''

'''x * 5'''

'''TypeError: unsupported operand type(s) for *: 'dict' and 'int''''

You can't do it with dictionaries, that would make more than one of the same key, remember.

===Indexing===
You have already learned how to index in lesson 2. When you typed x[3] you were indexing. You may also index a string without first making a variable represent it.

Type:

>>> '''"I Love Wikipedia"'''[5]

'''e'''

simple enough.

===Slicing===

''Slicing'' is used to access a range of elements the way that ''indexing'' accessess one element.

Type:

>>> '''x = "Wikipedia and Python are awesome"'''

Now Type:

>>> '''print x[14:32]

'''Python are awesome'''

The numbers that you enter after the variable (the [14:32]) are called ''indices''. The way the last one works is hard to understand at first. I'll do another example to make it clear.

Type:

>>> '''x = '1234''''

Now type:

'''print x[1:3]'''

'''23'''

It prints out the 2 because it starts numbering at 0, but the reason it prints out the 3 instead of the 4 is because it counts the '''[3]''' that you entered as the end point and does not include it. Seems wierd at first but easy to get used to.

You may also use negative numbers as the indices '''(x[-12:-])'''. If you only use one negative indice '''(x[-4:])''' Python will print starting with the element selected and go until the end of the string, tuple or list. This works for positive indices as well '''(x[:3])'''. Python will print the first 2 elements of '''x'''.

Another thing that you can do when ''splicing'' is enter the ''step'' indice.

Type:

>>> '''x = "0123456789"'''

Now Type:

>>> '''x[1:-1:3]'''

''' '147' '''

You may also just use the step indice.

Type:

>>> '''x[::3]'''

''''0369''''

You can do this to find every other element or every third or whatever your needs require. You may also make the step indice negative. By doing so you make the elements return starting with the last one.

Type:

>>> '''x='0123456789''''

Now Type:

>>> '''x[-2:1:-1]

''''8765432''''

When the step indice is negative it is important to remember to make sure that the first indice is calling an element that comes later in the string, tuple or list than the second element. Just as in the last example '''-2''' is representing '''8''' while '''1''' is representing 2.

I'll have to finish this lesson some other time, my bed is calling me.

===The Format Specifier===

You are going to use this versatile command constantly.

Type:

>>> '''print 'I Love %s' % 'Linux''''

'''I Love Linux'''

What the percent sign does is hold the place in the string and let you tell Python what to put there at the end of the string. The '''s''' behind the '''%'''

[[Category:Computer science]]
[[Category:Programming]]
[[Category:Python]]