Cheatsheets / Learn Python 3
Functions
Function Parameters
Sometimes functions require input to provide data for
their code. This input is defined using parameters. def write_a_book(character, setting,
Parameters are variables that are defined in the special_skill):
function definition.
They are assigned the values which
print(character + " is in " +
were passed as arguments when the function was
setting + " practicing her " +
called, elsewhere in the code.
special_skill)
For example, the function definition defines parameters
for a character, a setting, and a skill, which are used as
inputs to write the first sentence of a book.
Multiple Parameters
Python functions can have multiple parameters. Just as
you wouldn’t go to school without both a backpack and def ready_for_school(backpack,
a pencil case, functions may also need more than one pencil_case):
input to carry out their operations. if (backpack == 'full' and pencil_case
To define a function with multiple parameters, == 'full'):
parameter names are placed one after another,
print ("I'm ready for school!")
separated by commas, within the parentheses of the
function definition.
Functions
Some tasks need to be performed multiple times within
a program. Rather than rewrite the same code in # Define a function my_function() with
multiple places, a function may be defined using the parameter x
def keyword. Function definitions may include
parameters, providing data input to the function.
def my_function(x):
Functions may return a value using the return
return x + 1
keyword followed by the value to return.
# Invoke the function
print(my_function(2)) # Output: 3
print(my_function(3 + 5)) # Output: 9
Function Indentation
Python uses indentation to identify blocks of code.
Code within the same block should be indented at the # Indentation is used to identify code
same level. A Python function is one type of code blocks
block. All code under a function declaration should be
indented to identify it as part of the function. There can def testfunction(number):
be additional indentation within a function to handle
# This code is part of testfunction
other statements such as for and if so long as the
print("Inside the testfunction")
lines are not indented less than the first line of the
sum = 0
function code.
for x in range(number):
# More indentation because 'for' has
a code block
# but still part of he function
sum += x
return sum
print("This is not part of testfunction")
Calling Functions
Python uses simple syntax to use, invoke, or call a
preexisting function. A function can be called by writing doHomework()
the name of it, followed by parentheses.
For example, the code provided would call the
doHomework() method.
Function Arguments
Parameters in python are variables — placeholders for
the actual values the function needs. When the def sales(grocery_store, item_on_sale,
function is called, these values are passed in as cost):
arguments. print(grocery_store + " is selling "
For example, the arguments passed into the function + item_on_sale + " for " + cost)
.sales() are the “The Farmer’s Market”, “toothpaste”,
and “$1” which correspond to the parameters
sales("The Farmer’s Market",
grocery_store , item_on_sale , and cost .
"toothpaste", "$1")
Function Keyword Arguments
Python functions can be defined with named
arguments which may have default values provided. def findvolume(length=1, width=1,
When function arguments are passed using their depth=1):
names, they are referred to as keyword arguments. The print("Length = " + str(length))
use of keyword arguments when calling a function
print("Width = " + str(width))
allows the arguments to be passed in any order — not
print("Depth = " + str(depth))
just the order that they were defined in the function. If
return length * width * depth;
the function is invoked without a value for a specific
argument, the default value will be used.
findvolume(1, 2, 3)
findvolume(length=5, depth=2, width=4)
findvolume(2, depth=3, width=4)
Returning Multiple Values
Python functions are able to return multiple values
using one return statement. All values that should be def square_point(x, y, z):
returned are listed after the return keyword and are x_squared = x * x
separated by commas. y_squared = y * y
In the example, the function square_point() returns z_squared = z * z
x_squared , y_squared , and z_squared .
# Return all three values:
return x_squared, y_squared, z_squared
three_squared, four_squared, five_squared
= square_point(3, 4, 5)
The Scope of Variables
In Python, a variable defined inside a function is called
a local variable. It cannot be used outside of the scope a = 5
of the function, and attempting to do so without
defining the variable outside of the function will cause def f1():
an error. a = 2
In the example, the variable a is defined both inside
print(a)
and outside of the function. When the function f1() is
implemented, a is printed as 2 because it is locally
print(a) # Will print 5
defined to be so. However, when printing a outside of
f1() # Will print 2
the function, a is printed as 5 because it is
implemented outside of the scope of the function.
Returning Value from Function
A return keyword is used to return a value from a
Python function. The value returned from a function def check_leap_year(year):
can be assigned to a variable which can then be used in if year % 4 == 0:
the program. return str(year) + " is a leap year."
In the example, the function check_leap_year returns a
else:
string which indicates if the passed parameter is a leap
return str(year) + " is not a leap
year or not.
year."
year_to_check = 2018
returned_value
= check_leap_year(year_to_check)
print(returned_value) # 2018 is not
a leap year.
Global Variables
A variable that is defined outside of a function is called
a global variable. It can be accessed inside the body of a = "Hello"
a function.
In the example, the variable a is a global variable def prints_a():
because it is defined outside of the function prints_a . print(a)
It is therefore accessible to prints_a , which will print
the value of a .
# will print "Hello"
prints_a()
Parameters as Local Variables
Function parameters behave identically to a function’s
local variables. They are initialized with the values def my_function(value):
passed into the function when it was called. print(value)
Like local variables, parameters cannot be referenced
from outside the scope of the function. # Pass the value 7 into the function
In the example, the parameter value is defined as part
my_function(7)
of the definition of my_function , and therefore can
only be accessed within my_function . Attempting to
# Causes an error as `value` no longer
print the contents of value from outside the function
exists
causes an error.
print(value)