Python Tutorial

Haitham El-Ghareeb, Ph.D.May 2012

Twitter: @helghareeb

Session One - Agenda

• Whetting Your Appetite• Using Python Interpreter• Informal Introduction to Python• More Control Flows

Session Two - Agenda

• Data Structures• Modules• Input and Output• Errors and Exceptions• Classes

Bonus Session - Agenda

• Unit Testing– Hopefully!

Python

• easy to learn, powerful programming language.

• has efficient high-level data structures and a simple but effective approach to object-oriented programming.– elegant syntax – dynamic typing– interpreted nature,

Whetting Your Appetite

• You could write a Unix shell script or Windows batch files for some tasks, but:– Shell scripts are best at moving around files and

changing text data, not well-suited for GUI applications or games.

• You could write a C/C++/Java program, but:– It can take a lot of development time to get even a

first-draft program.

Python

• Simpler to use• Available on Windows, Mac OS X, and Unix• Help you get the job done more quickly• Split your program into modules that can be reused• Python is an interpreted language:– Save you considerable time during program

development because no compilation and linking is necessary.

– Interpreter can be used interactively

Python

• Python is extensible: if you know how to program in C it is easy to add a new built-in function or module to the interpreter,

• Named after the BBC show “Monty Python’s Flying Circus” and has nothing to do with reptiles.

Using the Python Interpreter

• Python interpreter is usually installed as /usr/local/bin/python

• Invoking the Interpreter– A second way of starting the interpreter is python

-c command [arg] ..., which executes the statement(s) in command

– Some Python modules are also useful as scripts. These can be invoked using python -m module [arg] ..., which executes the source file for module

Using Python Interpreter

• Argument Passing• Interactive Mode

• Error Handling

Executable Python Scripts

Source Code Encoding

• It is possible to use encodings different than ASCII in Python source files.

• The best way to do it is to put one more special comment line right after the #! line to define the source file encoding:

Informal Introduction

Using Python as a Calculator

Numbers

Strings

Strings

String Concatenation

String Indexing

String Slicing

Strings are Immutable!

Indices May be Negative

How Come?!

Lists

• compound data type• used to group together other values • The most versatile• can be written as a list of comma-separated

values (items) between square brackets. • List items need not all have the same type.

Shallow Copy

First Steps toward Programming

More Control Flow Tools

If Statement

For Statement

For Statement with Shallow Copy

Range Function

Break, Continue, Else

Pass

• Does Nothing!

Functions

Return Statement

Default Argument Value

Keyword Arguments

Keyword Arguments

• When a final formal parameter of the form **name is present, it receives a dictionary containing all keyword arguments except for those corresponding to a formal parameter.

• This may be combined with a formal parameter of the form *name which receives a tuple containing the positional arguments beyond the formal parameter list.

• (*name must occur before **name.)

Declaration

Calling

Output

Lambda Strings

Documentation String

Coding Style - PEP8

• Use 4-space indentation, and no tabs.• 4 spaces are a good compromise between small

indentation (allows greater nesting depth) and large indentation (easier to read). Tabs introduce confusion, and are best left out.

• Wrap lines so that they don’t exceed 79 characters.• This helps users with small displays and makes it possible

to have several code files side-by-side on larger displays.• Use blank lines to separate functions and classes, and

larger blocks of code inside functions.

Coding Style - PEP8

• When possible, put comments on a line of their own.• Use docstrings.• Use spaces around operators and after commas, but not

directly inside bracketing constructs: a = f(1, 2) + g(3, 4).• Name your classes and functions consistently; the

convention is to use CamelCase for classes and lower_case_with_underscores for functions and methods. Always use self as the name for the first method argument.

• Don’t use fancy encodings if your code is meant to be used in international environments. Plain ASCII works best in any case.

Data Structures - Lists

• list.append(x) Add an item to the end of the list.• list.extend(L) Extend the list by appending all the

items in the given list.• list.insert(i, x) Insert an item at a given position. The

first argument is the index of the element before which to insert, so a.insert(0, x) inserts at the front of the list, and a.insert(len(a), x) is equivalent to a.append(x).

• list.remove(x) Remove the first item from the list whose value is x. It is an error if there is no such item.

Data Structures - Lists

• list.pop([i]) Remove the item at the given position in the list, and return it. If no index is specified, a.pop() removes and returns the last item in the list.

• list.index(x) Return the index in the list of the first item whose value is x. It is an error if there is no such item.

• list.count(x) Return the number of times x appears in the list.

• list.sort() Sort the items of the list, in place.• list.reverse() Reverse the elements of the list, in place.

Lists Example

Using Lists as Stack

Using List as a Queue

Functional Programming Tools

• There are three built-in functions that are very useful when used with lists: filter(), map(), and reduce().

Filter()

• filter(function, sequence) returns a sequence consisting of those items from the sequence for which function(item) is true.

• If sequence is a string or tuple, the result will be of the same type; otherwise, it is always a list.

• For example, to compute a sequence of numbers not divisible by 2 and 3:

Filter()

Map()

• map(function, sequence) calls function(item) for each of the sequence’s items and returns a list of the return values.

• For example, to compute some cubes:

Map()

• More than one sequence may be passed; the function must then have as many arguments as there are sequences and is called with the corresponding item from each sequence (or None if some sequence is shorter than another). For example:

Reduce()

• reduce(function, sequence) returns a single value constructed by calling the binary function function on the first two items of the sequence, then on the result and the next item, and so on.

• For example, to compute the sum of the numbers 1 through 10:

List Comprehension

• List comprehensions provide a concise way to create lists.

• Common applications are to make new lists where each element is the result of some operations applied to each member of another sequence or iterable, or to create a subsequence of those elements that satisfy a certain condition.

List of Squares

List Comprehension

• A list comprehension consists of brackets containing an expression followed by a for clause, then zero or more for or if clauses. The result will be a new list resulting from evaluating the expression in the context of the for and if clauses which follow it.

• For example, this listcomp combines the elements of two lists if they are not equal:

Del()

Tuples and Sequences

Comma at the end!

Sets

• A set is an unordered collection with no duplicate elements.

• Basic uses include membership testing and eliminating duplicate entries.

• Set objects also support mathematical operations like union, intersection, difference, and symmetric difference.

Dictionaries

• Dictionaries are sometimes found in other languages as “associative memories” or “associative arrays”.

• Unlike sequences, which are indexed by a range of numbers, dictionaries are indexed by keys, which can be any immutable type; strings and numbers can always be keys.

• Tuples can be used as keys if they contain only strings, numbers, or tuples; if a tuple contains any mutable object either directly or indirectly, it cannot be used as a key.

Dictionaries

• You can’t use lists as keys, since lists can be modified in place using index assignments, slice assignments, or methods like append() and extend().

• It is best to think of a dictionary as an unordered set of key: value pairs, with the requirement that the keys are unique (within one dictionary).

• A pair of braces creates an empty dictionary: {}. Placing a comma-separated list of key:value pairs within the braces adds initial key:value pairs to the dictionary; this is also the way dictionaries are written on output.

Dictionaries

• The main operations on a dictionary are storing a value with some key and extracting the value given the key.

• It is also possible to delete a key:value pair with del. If you store using a key that is already in use, the old value associated with that key is forgotten. It is an error to extract a value using a non-existent key.

• The keys() method of a dictionary object returns a list of all the keys used in the dictionary, in arbitrary order (if you want it sorted, just apply the sorted() function to it).

• To check whether a single key is in the dictionary, use the in keyword.

Dict() Constructor

Looping Techniques

Looping over Two Sequences

Loop in Reverse

More on Conditions

• Include and, or

Comparing Objects of Different Types