Understanding Python Programming Language -Functions

function
name
text = input('Enter text: ')
To call a function, write the function name followed by
parenthesis. Arguments are the values passed into
functions. A function returns a value.
parenthes
es
Review
return value assigned to the
variable text
argume
nt

A variable is a name that refers to a value.
Variables are defined with an assignment
statement.
A function is a name that refers to a series of
statements.
Functions are defined with a function
definition.

Why define functions?
● Functions can be used to eliminate
repetitive code
● Functions make code easier to read by
naming a series of statements that form a
specific computation
● Functions make it easier to debug your
code because you can debug each function
independently

def convert_to_fahrenheit(celsius):
fahrenheit = celsius * 9 / 5 + 32
return fahrenheit
A function definition specifies the name of a new function
and the series of statements that run when the function is
called.
keyword used to start a
function definition
function name parameters (variable names
that refer to the arguments
passed in)
keyword used to return a value to the function
function
body
indented
4 spaces
the function header
ends in a colon

def get_average(number_one, number_two):
"""Returns the average of number_one and
number_two.
"""
return (number_one + number_two) / 2
Function definition style
Function names should be lowercase words separated by underscores, just
like variable names. Each function should include a docstring immediately
below the function header. This is a multi line comment starts and ends with
three double quotes (""") and should explain what the function does. This
comment should always include a description of the value that the function
returns.

# Define the function print_greeting
def print_greeting():
print('Hello')
# Call the function print_greeting
print_greeting() # This will print 'Hello'
Function with no parameters

# Define the function greet
def greet(name):
print('Hello', name)
# Call the function greet
greet('Roshan') # This will print 'Hello Roshan'
Function definition with one
parameter

# Define the function print_sum
def print_sum(number_one, number_two):
print(number_one + number_two)
# Call the function print_sum
print_sum(3, 5) # This will print 8
Function definition with two
parameters

# Define the function get_sum
def get_sum(number_one, number_two):
return number_one + number_two
# Call the function get_sum
total = get_sum(3, 5)
print(total) # This will print 8
Function definition with two
parameters and a return
statement

function runs
your
program calls
the function
your
program
continues
your program passes
arguments with the
function call
the function returns a
value for the rest of
your program to use
What happens when you call a function?

What happens when you call a function?
1) The arguments passed into the function (if
any) are assigned to the parameters in the
function definition
2) The series of statements in the function
body execute
3) When the function block ends or a return
statement is executed, the function will
return execution to the caller

return fahrenheit
boiling = convert_to_fahrenheit(100)
print(boiling)
The function convert_to_fahrenheit is
defined. Note that the series of statements in
the function body are not executed when the
function is defined.

return fahrenheit
print(boiling)
The expression on the right side of this
assignment statement is evaluated. This calls
the convert_to_fahrenheit function with the
argument of 100.

return fahrenheit
print(boiling)
During the function call, the celsius
parameter is assigned the value of the
argument, which in this case is 100.

return fahrenheit
print(boiling)
The statements in the function body now
execute. This line assigns 100 * 9 / 5 + 32
(which evaluates to 212.0) to the variable
fahrenheit.

return fahrenheit
print(boiling)
This line is called a return statement. The
syntax is simply return followed by an
expression. This return the value of 212.0
back to the caller. convert_to_fahrenheit(100)
will evaluate to this return value.

return fahrenheit
print(boiling)
After evaluating convert_to_fahrenheit(100),
the return value of 212.0 will be assigned to
the variable boiling.

return fahrenheit
print(boiling)
The print function is called with the argument
of 212.0. This will print 212.0 to the screen.

Common issues with defining functions
● The statements in a function definition are not
executed when the function is defined - only when the
function is called.
● The function definition must be written before the first
time the function is called. This is equivalent to trying
to refer to a variable before assigning a value to it.
● The number of arguments passed to a function must
equal the number of parameters in the function
definition.
● Functions and variables cannot have the same name
● The return statement can only be used within the

A return statement is needed to return a value
from a function. A function can only return a
single value (but that value can be a data
structure).
The syntax for a return statement is simply:
return expression
where expression can be any expression.
Return statements can only exist within a function body. A
function body may contain multiple return statements.
During a function call, statements are executed within the

def get_pizza_size_name(inches):
if inches > 20:
return 'Large'
if inches > 15:
return 'Medium'
return 'Small'
Which return statement executes when get_pizza_size_name(22) is called?
Multiple return statements

def contains_odd_number(number_list):
for number in number_list:
if (number % 2) == 1:
return True
return False
Which return statement executes when contains_odd_number([2, 3]) is called?
Which return statement executes when contains_odd_number([22, 2]) is called?
Which return statement executes when contains_odd_number([]) is called?
Multiple return statements

Common return statement issues
● Only one value can be returned from a
function.
● If you need to return a value from a function:
○ Make sure every path in your function
contains a return statement.
○ If the last statement in the function is
reached and it is not a return statement,
None is returned.

def convert_to_seconds(days):
hours = days * 24
minutes = hours * 60
seconds = minutes * 60
return seconds
print(minutes)
Local variables
Traceback (most recent call last):
File "python", line 6, in <module>
NameError: name 'minutes' is not
defined
Parameters and variables created within the
function body are considered local. These
variables can only be accessed within the
function body. Accessing these variables
outside of the function body will result in an

my_age = 20
def set_age(new_age):
my_age = new_age
set_age(50)
print(my_age)
Global variables
20
All variables defined outside of a function body
are considered global. Global variables cannot
be changed within the body of any function.
This will actually create a new local variable named my_age within the function body. The global my_age
variable will remain unchanged.

Variable naming best practices
● When writing a function, do not create a new
variable with the same name as a global
variable. You will see a “Redefining name
from outer score” warning in repl.it.
● You can use the same local variable name or
parameter name in multiple functions. These
names will not conflict.

1) The arguments passed into the function (if
any) are assigned to the parameters in the
function definition
2) The series of statements in the function body
execute until a return statement is executed
or the function body ends
3) The function call will evaluate to the return
value
4) Statements in the calling function will
continue to execute
Note that these steps apply for every single

What will this code print?
def get_hopscotch():
game = 'hopscotch'
return game
print(get_hopscotch())

What about this
code?
def get_scotch():
return 'scotch'
game = 'hop'
game += get_scotch()
return game

What about this
code?
def get_hop():
return 'hop'
def get_scotch():
return 'scotch'
game = get_hop()
game += get_scotch()
return game

def get_spooky(number):
return 2 * number
def get_mystery(number):
result = get_spooky(number)
result += get_spooky(number)
return result
print(get_mystery(10))
print(get_mystery(5))
What about this
code?

lunch = ['apple', 'kale', 'banana']
new_lunch = lunch
new_lunch[1] = 'pork'
print(new_lunch)
print(lunch)
['apple', 'pork', 'banana']
['apple', 'pork', 'banana']
How many list values are created here?

lunch ['apple', 'kale', 'banana']
new_lunch
new_lunch = lunch
An assignment statement assigns a variable to a
value. Only one list value is created (using the []
operator). new_lunch refers to the same value.

When a list is passed into a function as an
argument, the parameter refers to the same
list value.
def change_to_pork(food_list):
food_list[1] = 'pork'
change_to_pork(lunch)
print(lunch) ['apple', 'pork', 'banana']

def double_values(number_list):
"""Doubles all of the values in number_list.
"""
for index in range(len(number_list)):
number_list[index] = number_list[index] * 2
numbers = [3, 5, 8, 2]
double_values(numbers)
print(numbers)
Replacing list values in a function
The double_values function replaces each value in the
list with the doubled value. Notice that the function does
not need to return a value since the original list is
altered in the function.

Using multiple functions to make code more
readable
def contains_at_least_one_vowel(string):
for character in string:
if character in 'aeiou':
return True
return False
def get_strings_with_vowels(string_list):
words_with_vowels = []
for string in string_list:
if contains_at_least_one_vowel(string):
words_with_vowels.append(string)
return words_with_vowels
word_list = ['brklyn', 'crab', 'oyster', 'brkfst']
print(get_strings_with_vowels(word_list))

Understanding Python Programming Language -Functions

Recommended

More Related Content

Similar to Understanding Python Programming Language -Functions (20)

Recently uploaded (20)

Understanding Python Programming Language -Functions

Editor's Notes