RFPython Tutorial: Variables, Functions, Arguments, and Exceptions
Advertisement
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:
ArithmeticErrorAssertionErrorEnvironmentErrorEOFErrorImportErrorIndexErrorKeyboardInterruptKeyErrorMemoryErrorNameErrorReferenceErrorRuntimeErrorSyntaxErrorSystemErrorTypeErrorValueError
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
Advertisement
