Python Tutorial: Variables, Functions, Arguments, and Exceptions

This Python programming tutorial covers variables, functions, arguments, and exceptions.

Program Organization and Functions

We will cover the following topics on this page:

• How to organize larger programs
• Details on program execution
• Defining and working with functions
• Exceptions and Error Handling

What is a “Script?”

A “script” is a program that simply runs a series of statements and stops.

# program.py
statement1
statement2
statement3
...

Program Structure

Recall: programs are a sequence of statements.

height = 442             # Meters
thickness = 0.1*(0.001) # Meters (0.1 millimeter)
numfolds = 0
while thickness <= height:
    thickness = thickness * 2
    numfolds = numfolds + 1

print(numfolds, thickness)
print(numfolds, "folds required")
print("final thickness is", thickness, "meters")

Programs run by executing the statements in the same order that they are listed.

Defining Things

You must always define things before they get used later on in a program.

a = 42
b = a + 2  # Requires that a is already defined

def square(x):
    return x*x

z = square(b) # Requires square to be defined

The order is important. You almost always put the definitions of variables and functions near the beginning.

Defining Functions

It is a good idea to put all of the code related to a single “task” all in one place.

def read_prices(filename):
    pricesDict = {}
    for line in open(filename):
        fields = line.split(',')
        name = fields[0].strip('"')
        pricesDict[name] = float(fields[1])
    return pricesDict

A function also simplifies repeated operations.

oldprices = read_prices("oldprices.csv")
newprices = read_prices("newprices.csv")

What is a function?

A function is a sequence of statements.

def funcname(args):
    statement
    statement
    ...
    statement

Any Python statement can be used inside.

def foo():
    import math
    print(math.sqrt(2))
    help(math)

There are no “special” statements in Python.

Function Definitions

Functions can be defined in any order.

def foo(x):
    bar(x)

def bar(x):
    statements

Functions must only be defined before they are actually used during program execution.

foo(3)  # foo must be defined already

Stylistically, it is more common to see functions defined in a “bottom-up” fashion.

Bottom-up Style

Functions are treated as building blocks. The smaller/simpler blocks go first.

# myprogram.py
def foo(x):
    ...

def bar(x):
    ...

foo(x)
...

def spam(x):
    ...
    bar(x)
    ...

spam(42)  # Call spam() to do something

Functions can be redefined in Python.

def foo(x):
    return 2*x

print(foo(2))  # Prints 4

def foo(x,y): # Redefine foo(). This replaces
    return x*y # foo() above.

print(foo(2,3))  # Prints 6
#print(foo(2))  # Error : foo takes two arguments

A repeated function definition silently replaces the previous definition. There are no overloaded functions (vs. C++, Java).

Function Design

Functions should be easy to use. The whole point of a function is to define code for repeated operations. Some things to think about:

• Function inputs and output
• Side-effects

Function Arguments

Functions operate on passed arguments.

def square(x):
    return x*x

a = square(3)

The argument names are only visible inside the function body (are local to the function).

Default Arguments

Sometimes you want an optional argument.

def read_prices(filename,delimiter=','):
    ...

If a default value is assigned, the argument is optional in function calls.

d = read_prices("prices.csv")

Calling a Function

Consider a simple function.

def read_prices(filename,delimiter=','):
    ...

Calling with “positional” args.

prices = read_prices("prices.csv",",")

Keyword Arguments

Calling with “keyword” arguments.

prices = read_prices(filename="price.csv",delimiter=",")

Here, you explicitly name and assign a value to each argument. Common use case: functions with many optional features.

def sort(data,reverse=False,key=None):
    statements

sort(s,reverse=True)

Mixed Arguments

Positional and keyword arguments can be mixed together in a function call.

read_prices("prices.csv",delimiter=',')

The positional arguments must go first. Basic rules:

• All required arguments get values
• No duplicate argument values

Return Values

The return statement returns a value.

def square(x):
    return x*x

If no return value, None is returned.

def bar(x):
    statements
    return

a = bar(4) # a = None

The return value is discarded if not assigned/used.

square(4) # Calls square() but discards result

Multiple Return Values

A function may return multiple values by returning a tuple.

def divide(a,b):
    q = a // b # Quotient
    r = a % b  # Remainder
    return q,r  # Return a tuple

Usage examples:

x = divide(37,5)  # x = (7,2)
x,y = divide(37,5) # x = 7, y = 2

Understanding Variables

Programs assign values to variables.

x = value # Global variable

def foo():
    y = value # Local variable

Variable assignments occur outside and inside function definitions. Variables defined outside are “global”. Variables inside a function are “local”.

Local Variables

Variables inside functions are private.

def read_portfolio(filename):
    portfolio = []
    for line in open(filename):
        fields = line.split()
        s = (fields[0],int(fields[1]),float(fields[2]))
        portfolio.append(s)
    return portfolio

Values are not retained or accessible after return.

# >>> stocks = read_portfolio("stocks.dat")
# >>> fields
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# NameError: name 'fields' is not defined

Global Variables

Functions can access the values of globals.

delimiter = ','
def read_portfolio(filename):
    ...
    for line in open(filename):
        fields = line.split(delimiter)
        ...

Modifying Globals

One quirk: Functions can’t modify globals.

delimiter = ','
def set_delimiter(newdelimiter):
    delimiter = newdelimiter

If you want to modify a global variable you must declare it as such in the function.

delimiter = ','
def set_delimiter(newdelimiter):
    global delimiter
    delimiter = newdelimiter

The global declaration must appear before use.

More on Functions

Variable Arguments

Function that accepts any number of args.

def foo(x,*args):
    ...

Here, the arguments get passed as a tuple.

foo(1,2,3,4,5)

Example:

def print_headers(*headers):
    for h in headers:
        print("%10s" % h, end=" ")
    print()
    print("-" * 10 + " ") * len(headers)

Function that accepts any keyword args.

def foo(x,y,**kwargs):
    ...

Extra keywords get passed in a dict.

foo(2,3,flag=True,mode="fast",header="debug")

Passing Tuples and Dicts

Tuples can be expanded into function args.

args = (2,3,4)
foo(1, *args) # Same as foo(1,2,3,4)

Dictionaries can expand to keyword args.

kwargs = { 'color' : 'red', 'delimiter' : ',', 'width' : 400 }
foo(data, **kwargs) # Same as foo(data,color='red',delimiter=',',width=400)

These are not commonly used except when writing library functions.

Error Checking

Python performs no checking or validation of function argument types or values. A function will work on any data that is compatible with the statements in the function.

def add(x,y):
    return x + y

If there are errors in a function, they will show up at run time (as an exception).

Example:

def add(x,y):
    return x+y

Python also performs no checking of function return values. Inconsistent use does not result in an error.

def foo(x,y):
    if x:
        return x + y
    else:
        return

Exceptions

Used to signal errors.

• Raising an exception (raise)

if name not in names:
    raise RuntimeError("Name not found")

• Catching an exception (try)

try:
    authenticate(username)
except RuntimeError as e:
    print(e)

Exceptions propagate to the first matching except.

def foo():
    try:
        bar()
    except RuntimeError as e:
        ...

def bar():
    try:
        spam()
    except RuntimeError as e:
        ...

def spam():
    grok()

def grok():
    ...
    raise RuntimeError("Whoa!")

There are many built-in exceptions in Python as listed below:

• ArithmeticError
• AssertionError
• EnvironmentError
• EOFError
• ImportError
• IndexError
• KeyboardInterrupt
• KeyError
• MemoryError
• NameError
• ReferenceError
• RuntimeError
• SyntaxError
• SystemError
• TypeError
• ValueError

Exception Values

Most exceptions have an associated value. This provides more information about what’s wrong.

raise RuntimeError("Invalid user name")

Passed to variable supplied in except.

try:
    ...
except RuntimeError as e:
    ...

It’s an instance of the exception type, but often looks like a string.

try:
    ...
except RuntimeError as e:
    print("Failed : Reason", e)

Catching Multiple Errors

Can catch different kinds of exceptions.

try:
    ...
except LookupError as e:
    ...
except RuntimeError as e:
    ...
except IOError as e:
    ...
except KeyboardInterrupt as e:
    ...

Alternatively, if handling is the same:

try:
    ...
except (IOError,LookupError,RuntimeError) as e:
    ...

Catching All Errors

Catching any exception:

try:
    ...
except Exception:
    print("An error occurred")

Ignoring an exception (pass)

try:
    ...
except RuntimeError:
    pass

finally statement

Specifies code that must run regardless of whether or not an exception occurs.

lock = Lock()
lock.acquire()
try:
    ...
finally:
    lock.release() # release the lock

It is commonly used to properly manage resources (especially locks, files, etc.).

Program Exit

Program exit is handled through exceptions.

raise SystemExit
raise SystemExit(exitcode)

An alternative sometimes seen:

import sys
sys.exit()
sys.exit(exitcode)

Catching keyboard interrupt (Control-C)

try:
    statements
except KeyboardInterrupt:
    statements