Cheatsheets / Introduction to Python

Functions

Function Parameters

Sometimes functions require input to provide data for their code. def write_a_book(character, setting,
This input is defined using parameters.
special_skill):
Parameters are variables that are defined in the function
definition. They are assigned the values which were passed as print(character + " is in " +
arguments when the function was called, elsewhere in the code. setting + " practicing her " +
For example, the function definition defines parameters for a
special_skill)
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 def ready_for_school(backpack, pencil_case):
wouldn’t go to school without both a backpack and a pencil case,
if (backpack == 'full' and pencil_case ==
functions may also need more than one input to carry out their
operations. 'full'):
To define a function with multiple parameters, parameter names print ("I'm ready for school!")
are placed one after another, separated by commas, within the
parentheses of the function definition.

Functions

Some tasks need to be performed multiple times within a # Define a function my_function() with
program. Rather than rewrite the same code in multiple places, a
parameter x
function may be defined using the 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 keyword followed
return x + 1
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 # Indentation is used to identify code blocks
the same block should be indented at the same level. A Python
function is one type of code block. All code under a function
declaration should be indented to identify it as part of the def testfunction(number):
function. There can be additional indentation within a function to # This code is part of testfunction
handle other statements such as for and if so long as the lines
print("Inside the testfunction")
are not indented less than the first line of the function code.
sum = 0
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 doHomework()

function. A function can be called by writing 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 def sales(grocery_store, item_on_sale, cost):
values the function needs. When the function is called, these
print(grocery_store + " is selling " +
values are passed in as arguments.
For example, the arguments passed into the function .sales() item_on_sale + " for " + cost)
are the “The Farmer’s Market”, “toothpaste”, and “$1” which
correspond to the parameters grocery_store , item_on_sale ,
sales("The Farmer’s Market", "toothpaste",
and cost .
"$1")
Function Keyword Arguments

Python functions can be defined with named arguments which def findvolume(length=1, width=1, depth=1):
may have default values provided. When function arguments are
print("Length = " + str(length))
passed using their names, they are referred to as keyword
arguments. The use of keyword arguments when calling a function print("Width = " + str(width))
allows the arguments to be passed in any order — not just the print("Depth = " + str(depth))
order that they were defined in the function. If the function is
return length * width * depth;
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 def square_point(x, y, z):
return statement. All values that should be returned are listed
x_squared = x * x
after the return keyword and are separated by commas.
In the example, the function square_point() returns y_squared = y * y
x_squared , y_squared , and z_squared . z_squared = z * z
# 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 a = 5

variable. It cannot be used outside of the scope of the function,
and attempting to do so without defining the variable outside of
the function will cause an error. def f1():
In the example, the variable a is defined both inside and outside a = 2
of the function. When the function f1() is implemented, a is
print(a)
printed as 2 because it is locally defined to be so. However,
when printing a outside of the function, a is printed as 5
because it is implemented outside of the scope of the function. print(a) # Will print 5
f1() # Will print 2
Returning Value from Function

A return keyword is used to return a value from a Python def check_leap_year(year):

function. The value returned from a function can be assigned to a
if year % 4 == 0:
variable which can then be used in the program.
In the example, the function check_leap_year returns a string return str(year) + " is a leap year."
which indicates if the passed parameter is a leap year or not. else:
return str(year) + " is not a leap 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 a = "Hello"

variable. It can be accessed inside the body of a function.
In the example, the variable a is a global variable because it is
defined outside of the function prints_a . It is therefore def prints_a():
accessible to prints_a , which will print the value of a . print(a)

# will print "Hello"

prints_a()

Parameters as Local Variables

Function parameters behave identically to a function’s local def my_function(value):

variables. They are initialized with the values passed into the
print(value)
function when it was called.
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 of the
my_function(7)
definition of my_function , and therefore can only be accessed
within my_function . Attempting to print the contents of value
from outside the function causes an error. # Causes an error as `value` no longer exists
print(value)

Print Share