Performing variable assignments

When working with applications, you store information in variables. A variable is a kind of storage box. Whenever you want to work with the information, you access it using the variable. If you have new information you want to store, you put it in a variable. Changing information means accessing the variable first and then storing the new value in the variable. Just as you store things in boxes in the real world, so you store things in variables (a kind of storage box) when working with applications. To store data in a variable, you assign the data to it using any of a number of assignment operators (special symbols that tell how to store the data). Table 4-1 shows the assignment operators that Python supports.

Doing arithmetic

Storing information in variables makes it easily accessible. However, in order to perform any useful work with the variable, you usually perform some type of arithmetic operation on it. Python supports the common arithmetic operators you use to perform tasks by hand. They appear in Table 4-2.

Sometimes you need to interact with just one variable. Python supports a number of unary operators, those that work with just one variable, as shown in Table 4-3.

Computers can perform other sorts of math tasks because of the way in which the processor works. It’s important to remember that computers store data as a series of individual bits. Python makes it possible to access these individual bits using bitwise operators, as shown in Table 4-4.

Comparing data using Boolean expressions

Using arithmetic to modify the content of variables is a kind of data manipulation. To determine the effect of data manipulation, a computer must compare the current state of the variable against its original state or the state of a known value. In some cases, detecting the status of one input against another is also necessary. All these operations check the relationship between two variables, so the resulting operators are relational operators, as shown in Table 4-5.

Sometimes a relational operator can’t tell the whole story of the comparison of two values. For example, you might need to check a condition in which two separate comparisons are needed, such as MyAge > 40 and MyHeight < 74. The need to add conditions to the comparison requires a logical operator of the sort shown in Table 4-6.

Computers provide order to comparisons by making some operators more significant than others. The ordering of operators is operator precedence. Table 4-7 shows the operator precedence of all the common Python operators, including a few you haven’t seen as part of a discussion yet. When making comparisons, always consider operator precedence because otherwise, the assumptions you make about a comparison outcome will likely be wrong.

Creating reusable functions

You go to your closet, take out pants and shirt, remove the labels, and put them on. At the end of the day, you take everything off and throw it in the trash. Hmmm … that really isn’t what most people do. Most people take the clothes off, wash them, and then put them back into the closet for reuse. Functions are reusable, too. No one wants to keep repeating the same task; it becomes monotonous and boring. When you create a function, you define a package of code that you can use over and over to perform the same task. All you need to do is tell the computer to perform a specific task by telling it which function to use. The computer faithfully executes each instruction in the function absolutely every time you ask it to do so.

When you work with functions, the code that needs services from the function is named the caller, and it calls upon the function to perform tasks for it. Much of the information you see about functions refers to the caller. The caller must supply information to the function, and the function returns information to the caller.

At one time, computer programs didn’t include the concept of code reusability. As a result, developers had to keep reinventing the same code. It didn’t take long for someone to come up with the idea of functions, though, and the concept has evolved over the years until functions have become quite flexible. You can make functions do anything you want. Code reusability is a necessary part of applications to

• Reduce development time
• Reduce programmer error
• Increase application reliability
• Allow entire groups to benefit from the work of one programmer
• Make code easier to understand
• Improve application efficiency

In fact, functions do a whole list of things for applications in the form of reusability. As you work through the examples in this book, you see how reusability makes your life significantly easier. If not for reusability, you’d still be programming by plugging 0s and 1s into the computer by hand.

Creating a function doesn’t require much work. To see how functions work, open a copy of IPython and type in the following code (pressing Enter at the end of each line):

def SayHello():
    print('Hello There!')

To end the function, you press Enter a second time after the last line. A function begins with the keyword def (for define). You provide a function name, parentheses that can contain function arguments (data used in the function), and a colon. The editor automatically indents the next line for you. Python relies on whitespace to define code blocks (statements that are associated with each other in a function).

You can now use the function. Simply type SayHello( ) and press Enter. The parentheses after the function name are important because they tell Python to execute the function, rather than tell you that you are accessing a function as an object (to determine what it is). Figure 4-3 shows the output from this function.

Calling functions in a variety of ways

Functions can accept arguments (additional bits of data) and return values. The ability to exchange data makes functions far more useful than they otherwise might be. The following sections describe how to call functions in a variety of ways to both send and receive data.

Sending required arguments

A function can require the caller to provide arguments to it. A required argument is a variable that must contain data for the function to work. Open a copy of IPython and type the following code:

def DoSum(Value1, Value2):
    return Value1 + Value2

You have a new function, DoSum(). This function requires that you provide two arguments to use it. At least, that’s what you’ve heard so far. Type DoSum() and press Enter. You see an error message, as shown in Figure 4-4, telling you that DoSum requires two arguments.

Trying DoSum() with just one argument would result in another error message. In order to use DoSum() you must provide two argument. To see how this works, type DoSum(1, 2) and press Enter. You see the result in Figure 4-5.

Notice that DoSum() provides an output value of 3 when you supply 1 and 2 as inputs. The return statement provides the output value. Whenever you see return in a function, you know the function provides an output value.

Making decisions using the if statement

You use “if” statements regularly in everyday life. For example, you may say to yourself, “If it’s Wednesday, I’ll eat tuna salad for lunch.” The Python if statement is a little less verbose, but it follows precisely the same pattern. To see how this works, open a copy of IPython and type the following code:

def TestValue(Value):
    if Value == 5:
        print('Value equals 5!')
    elif Value == 6:
        print('Value equals 6!')
    else:
        print('Value is something else.')
        print('It equals ' + str(Value))

Every Python if statement begins, oddly enough, with the word if. When Python sees if, it knows that you want it to make a decision. After the word if comes a condition. A condition simply states what sort of comparison you want Python to make. In this case, you want Python to determine whether Value contains the value 5.

Notice that the condition uses the relational equality operator, ==, and not the assignment operator, =. A common mistake that developers make is to use the assignment operator rather than the equality operator.

The condition always ends with a colon (:). If you don’t provide a colon, Python doesn’t know that the condition has ended and will continue to look for additional conditions on which to base its decision. After the colon comes any tasks you want Python to perform.

You may need to perform multiple tasks using a single if statement. The elif clause makes it possible to add an additional condition and associated tasks. A clause is an addendum to a previous condition, which is an if statement in this case. The elif clause always provides a condition, just like the if statement, and it has its own associated set of tasks to perform.

Sometimes you need to do something no matter what the condition might be. In this case, you add the else clause. The else clause tells Python to do something in particular when the conditions of the if statement aren’t met.

Notice how indenting is becoming more important as the functions become more complex. The function contains an if statement. The if statement contains just one print() statement. The else clause contains two print() statements.

To see this function in action, type TestValue(1) and press Enter. You see the output from the else clause. Type TestValue(5) and press Enter. The output now reflects the if statement output. Type TestValue(6) and press Enter. The output now shows the results of the elif clause. The result is that this function is more flexible than previous functions in the chapter because it can make decisions.

Choosing between multiple options using nested decisions

Nesting is the process of placing a subordinate statement within another statement. You can nest any statement within any other statement in most cases. To see how this works, open a copy of IPython and type the following code:

def SecretNumber():
    One = int(input("Type a number between 1 and 10: "))
    Two = int(input("Type a number between 1 and 10: "))

    if (One >= 1) and (One <= 10):
        if (Two >= 1) and (Two <= 10):
           print('Your secret number is: ' + str(One * Two))
        else:
           print("Incorrect second value!")
    else:
        print("Incorrect first value!")

In this case, SecretNumber() asks you to provide two inputs. Yes, you can get inputs from a user when needed by using the input() function. The int() function converts the inputs to a number.

There are two levels of if statement this time. The first level checks for the validity of the number in One. The second level checks for the validity of the number in Two. When both One and Two have values between 1 and 10, then SecretNumber() outputs a secret number for the user.

To see SecretNumber() in action, type SecretNumber() and press Enter. Type 20 and press Enter when asked for the first input value, and type 10 and press Enter when asked for the second. You see an error message telling you that the first value is incorrect. Type SecretNumber() and press Enter again. This time, use values of 10 and 20. The function will tell you that the second input is incorrect. Try the same sequence again using input values of 10 and 10.

Performing repetitive tasks using for

Sometimes you need to perform a task more than one time. You use the for loop statement when you need to perform a task a specific number of times. The for loop has a definite beginning and a definite end. The number of times that that loop executes depends on the number of elements in the variable you provide. To see how this works, open a copy of IPython and type the following code:

def DisplayMulti(*VarArgs):
    for Arg in VarArgs:
        if Arg.upper() == 'CONT':
            continue
            print('Continue Argument: ' + Arg)
        elif Arg.upper() == 'BREAK':
            break
            print('Break Argument: ' + Arg)
        print('Good Argument: ' + Arg)

In this case, the for loop attempts to process each element in VarArgs. Notice that there is a nested if statement in the loop and it tests for two ending conditions. In most cases, the code skips the if statement and simply prints the argument. However, when the if statement finds the words CONT or BREAK in the input values, it performs one of these two tasks:

• continue: Forces the loop to continue from the current point of execution with the next entry in VarArgs.
• break: Stops the loop from executing.

The keywords can appear capitalized in any way because the upper() function converts them to uppercase. The DisplayMulti() function can process any number of input strings. To see it in action, type DisplayMulti('Hello', 'Goodbye', 'First', 'Last') and press Enter. You see each of the input strings presented on a separate line in the output. Now type DisplayMulti('Hello', 'Cont', 'Goodbye', 'Break', 'Last') and press Enter. Notice that the words Cont and Break don’t appear in the output because they’re keywords. In addition, the word Last doesn’t appear in the output because the for loop ends before this word is processed.

Using the while statement

The while loop statement continues to perform tasks until such time that a condition is no longer true. As with the for statement, the while statement supports both the continue and break keywords for ending the loop prematurely. To see how this works, open a copy of IPython and type the following code:

def SecretNumber():
    GotIt = False
    while GotIt == False:
        One = int(input("Type a number between 1 and 10: "))
        Two = int(input("Type a number between 1 and 10: "))

        if (One >= 1) and (One <= 10):
            if (Two >= 1) and (Two <= 10):
                print('Secret number is: ' + str(One * Two))
                GotIt = True
                continue
            else:
                print("Incorrect second value!")
        else:
            print("Incorrect first value!")
        print("Try again!")

This is an expansion of the SecretNumber() function first described in the “Choosing between multiple options using nested decisions” section, earlier in this chapter. However, in this case, the addition of a while loop statement means that the function continues to ask for input until it receives a valid response.

To see how the while statement works, type SecretNumber( ) and press Enter. Type 20 and press Enter for the first prompt. Type 10 and press Enter for the second prompt. The example tells you that the first number is wrong and then tells you to try again. Try a second time using values of 10 and 20. This time the second number is wrong and you still need to try again. On the third try, use values of 10 and 10. This time you get a secret number. Notice that the use of a continue clause means that the application doesn’t tell you to try again.

Performing operations on sets

Most people have used sets at one time or another in school to create lists of items that belong together. These lists then became the topic of manipulation using math operations such as intersection, union, difference, and symmetric difference. Sets are the best option to choose when you need to perform membership testing and remove duplicates from a list. You can’t perform sequence-related tasks using sets, such a indexing or slicing. To see how you can work with sets, start a copy of IPython and type the following code:

from sets import Set
SetA = Set(['Red', 'Blue', 'Green', 'Black'])
SetB = Set(['Black', 'Green', 'Yellow', 'Orange'])
SetX = SetA.union(SetB)
SetY = SetA.intersection(SetB)
SetZ = SetA.difference(SetB)

Notice that you must import the Set capability into your Python application. The module sets contain a Set class that you import into your application in order to use the resulting functionality. If you try to use the Set class without first importing it, Python displays an error message. The book uses a number of imported libraries, so knowing how to use the import statement is important.

You now have five different sets to play with, each of which has some common elements. To see the results of each math operation, type print '{0} {1} {2}'.format(SetX, SetY, SetZ) and press Enter. You see one set printed on each line, like this:

Set(['Blue', 'Yellow', 'Green', 'Orange', 'Black', 'Red'])
Set(['Green', 'Black'])
Set(['Blue', 'Red'])

The outputs show the results of the math operations: union(), intersection(), and difference(). (When working with Python 3.4, the output may vary from the Python 2.7 output shown. All output in the book is for Python 2.7, so you may see differences from time to time when using Python 3.4.) Python’s fancier print formatting can be useful in working with collections such as sets. The format() function tells Python which objects to place within each of the placeholders in the string. A placeholder is a set of curly brackets ({}) with an optional number in it. The escape character (essentially a kind of control or special character), /n, provides a newline character between entries. You can read more about fancy formatting at https://docs.python.org/2/tutorial/inputoutput.html.

You can also test relationships between the various sets. For example, type SetA.issuperset(SetY) and press Enter. The output value of True tells you that SetA is a superset of SetY. Likewise, if you type SetA.issubset(SetX) and press Enter, you find that SetA is a subset of SetX.

It’s important to understand that sets are either mutable or immutable. All the sets in this example are mutable, which means that you can add or remove elements from them. For example, if you type SetA.add('Purple') and press Enter, SetA receives a new element. If you type SetA.issubset(SetX) and press Enter now, you find that SetA is no longer a subset of SetX because SetA has the 'Purple' element in it.

Working with lists

The Python specification defines a list as a kind of sequence. Sequences simply provide some means of allowing multiple data items to exist together in a single storage unit, but as separate entities. Think about one of those large mail holders you see in apartment buildings. A single mail holder contains a number of small mailboxes, each of which can contain mail. Python supports other kinds of sequences as well:

• Tuples: A tuple is a collection used to create complex list-like sequences. An advantage of tuples is that you can nest the content of a tuple. This feature lets you create structures that can hold employee records or x-y coordinate pairs.
• Dictionaries: As with the real dictionaries, you create key/value pairs when using the dictionary collection (think of a word and its associated definition). A dictionary provides incredibly fast search times and makes ordering data significantly easier.
• Stacks: Most programming languages support stacks directly. However, Python doesn’t support the stack, although there’s a workaround for that. A stack is a first in/first out (LIFO) sequence. Think of a pile of pancakes: You can add new pancakes to the top and also take them off of the top. A stack is an important collection that you can simulate in Python using a list.
• Queues: A queue is a last in/first out (FIFO) collection. You use it to track items that need to be processed in some way. Think of a queue as a line at the bank. You go into the line, wait your turn, and are eventually called to talk with a teller.
• Deques: A double-ended queue (deque) is a queue-like structure that lets you add or remove items from either end, but not from the middle. You can use a deque as a queue or a stack or any other kind of collection to which you’re adding and from which you’re removing items in an orderly manner (in contrast to lists, tuples, and dictionaries, which allow randomized access and management).

Of all the sequences, lists are the easiest to understand and are the most directly related to a real-world object. Working with lists helps you become better able to work with other kinds of sequences that provide greater functionality and improved flexibility. The point is that the data is stored in a list much as you would write it on a piece of paper — one item comes after another. The list has a beginning, a middle, and an end. As shown in the figure, the items are numbered. (Even if you might not normally number them in real life, Python always numbers the items for you.) To see how you can work with lists, start a copy of IPython and type the following code:

ListA = [0, 1, 2, 3]
ListB = [4, 5, 6, 7]
ListA.extend(ListB)
ListA

When you type the last line of code, you see the output of [0, 1, 2, 3, 4, 5, 6, 7]. The extend() function adds the members of ListB to ListA. Beside extending lists, you can also add to them using the append() function. Type ListA.append(-5) and press Enter. When you type ListA and press Enter again, you see that Python has added –5 to the end of the list. You may find that you need to remove items again and you do that using the remove() function. For example, type ListA.remove(-5) and press Enter. When you list ListA again, you see that the added entry is gone.

Lists also support concatenation using the plus (+) sign. For example, if you type ListX = ListA + ListB and press Enter, you find that the newly created ListX contains both ListA and ListB in it with the elements of ListA coming first.

Creating and using Tuples

A tuple is a collection used to create complex lists, in which you can embed one tuple within another. This embedding lets you create hierarchies with tuples. A hierarchy could be something as simple as the directory listing of your hard drive or an organizational chart for your company. The idea is that you can create complex data structures using a tuple.

Tuples are immutable, which means you can’t change them. You can create a new tuple with the same name and modify it in some way, but you can’t modify an existing tuple. Lists are mutable, which means that you can change them. So, a tuple can seem at first to be at a disadvantage, but immutability has all sorts of advantages, such as being more secure as well as faster. In addition, immutable objects are easier to use with multiple processors. To see how you can work with tuples, start a copy of IPython and type the following code:

MyTuple = (1, 2, 3, (4, 5, 6, (7, 8, 9)))

MyTuple is nested three levels deep. The first level consists of the values 1, 2, and 3, and a tuple. The second level consists of the values 4, 5, and 6, and yet another tuple. The third level consists of the values 7, 8, and 9. To see how this works, type the following code into IPython:

for Value1 in MyTuple:
    if type(Value1) == int:
        print Value1
    else:
        for Value2 in Value1:
            if type(Value2) == int:
                print " ", Value2
            else:
                for Value3 in Value2:
                    print " ", Value3

When you run this code, you find that the values really are at three different levels. You can see the indentations showing the level:

1
2
3
        4
        5
        6
                7
                8
                9

It is possible to perform tasks such as adding new values, but you must do it by adding the original entries and the new values to a new tuple. In addition, you can add tuples to an existing tuple only. To see how this works, type MyNewTuple = MyTuple.__add__((10, 11, 12, (13, 14, 15))) and press Enter. MyNewTuple contains new entries at both the first and second levels, like this: (1, 2, 3, (4, 5, 6, (7, 8, 9)), 10, 11, 12, (13, 14, 15)). If you were to run the previous code against MyNewTuple, you’d see entries at the appropriate levels in the output, as shown here.

1
2
3
        4
        5
        6
                7
                8
                9
10
11
12
        13
        14
        15