Python Functions (PyAtl Beginners Night)

Python Functions
Rick Copeland

Beginner’s
Night
Python Functions
Rick Copeland

What is a function, anyway?
• Reusable bit of Python code

• … beginning with the keyword def

• … that can use parameters (placeholders)

• … that can use parameters (placeholders)
• … that can provide a return value

Define a Function
>>> def x_squared(x):!
... return x * x

Use a Function
... return x * x!
...!
>>> x_squared(1)!
1!
>>> x_squared(2)!
4!
>>> x_squared(4)!
16

Use a Function
• To actually execute the
function we’ve defined, we
need to call or invoke it.
... return x * x!
...!
>>> x_squared(1)!
1!
>>> x_squared(2)!
4!
>>> x_squared(4)!
16

Use a Function
• In Python, we call functions
by placing parentheses after
the function name…
... return x * x!
...!
>>> x_squared(1)!
1!
>>> x_squared(2)!
4!
>>> x_squared(4)!
16

Use a Function
• In Python, we call functions
by placing parentheses after
the function name…
• … providing arguments
which match up with the
parameters used when
defining the function
... return x * x!
...!
>>> x_squared(1)!
1!
>>> x_squared(2)!
4!
>>> x_squared(4)!
16

Substitution
x_squared(4) >>> def x_squared(x):!
... return x * x

Substitution
... return x * x
x = 4!
return x * x

Substitution
... return x * x
x = 4!
return x * x
4 * 4

Substitution
... return x * x
x = 4!
return x * x
4 * 4
16

Recursion
• Functions can call themselves

Recursion
• Functions can call themselves
• … we call this recursion

Recursion
>>> def x_fact(x):!
... if x < 2:!
... return 1!
... else:!
... return x * x_fact(x-1)!
...!
>>> x_fact(3)!
6

Recursion, step-by-step
fact(3)

fact(3)
def x_fact(x):!
if x < 2:!
return 1!
else:!
return x * x_fact(x-1)

fact(3)
return 3 * x_fact(3-1)
def x_fact(x):!
if x < 2:!
return 1!
else:!

fact(3)
(3 * fact(2)) return 3 * x_fact(3-1)
def x_fact(x):!
if x < 2:!
return 1!
else:!

fact(3)
(3 * fact(2))
(3 * (2 * fact(1)))
def x_fact(x):!
if x < 2:!
return 1!
else:!

fact(3)
(3 * fact(2))
(3 * (2 * fact(1)))
return 1
def x_fact(x):!
if x < 2:!
return 1!
else:!

fact(3)
(3 * fact(2))
(3 * (2 * fact(1)))
(3 * (2 * (1)))
return 1
def x_fact(x):!
if x < 2:!
return 1!
else:!

fact(3)
(3 * fact(2))
(3 * (2 * fact(1)))
(3 * (2 * (1)))
(3 * (2))
return 1
def x_fact(x):!
if x < 2:!
return 1!
else:!

fact(3)
(3 * fact(2))
(3 * (2 * fact(1)))
(3 * (2 * (1)))
(3 * (2))
return 1
(6)
def x_fact(x):!
if x < 2:!
return 1!
else:!

Different ways to call
functions

functions
def my_awesome_function(something): …

functions
def my_awesome_function(something, something_else): …

functions
def my_awesome_function(something, something_else, banana): …

functions
def my_awesome_function(something, something_else, banana, apple): …

functions
def my_awesome_function(something, something_else, banana, apple, pear): ...

functions
def my_awesome_function(something, something_else, banana, apple, pear): ...
>>> my_awesome_function(1, 4, 6, ... # now was it
banana, apple, pear or apple, pear, banana?!

Named Arguments
>>> my_awesome_function(!
something=1,!
something_else=4,!
banana=6,!
pear=9,!
apple=12)

Default Arguments
• When you’re calling a function, you have to give
Python all the argument values (1 per
parameter)

Default Arguments
• When you’re calling a function, you have to give
Python all the argument values (1 per
parameter)
• … but some of these can have default values

Default Arguments
def my_awesome_function(something, something_else,

Default Arguments
banana=1, apple=2, pear=3): ...

Default Arguments
Now when you say this:

Default Arguments
>>> my_awesome_function(1, 4, 6)

Default Arguments
It means this:

Default Arguments
It means this:
>>> my_awesome_function(!
1, 4, 6,!
apple=2, pear=3)

Variable Parameters
• Sometimes it’s nice to be able to call a function
with different numbers of arguments…

Variable Parameters
• Sometimes it’s nice to be able to call a function
with different numbers of arguments…
• … something like sum(1,2,3) or sum(1,2)…

Variable Parameters
def sum(*values):!
result = 0!
for v in values:!
result += v!
return result

Variable Parameters
• Python “packs” all the
remaining arguments into a
tuple
def sum(*values):!
result = 0!
for v in values:!
result += v!
return result

Variable Parameters
tuple
• You can then pass any
number of positional
arguments to the function
def sum(*values):!
result = 0!
for v in values:!
result += v!
return result

Variable Parameters
tuple
number of positional
arguments to the function
def sum(*values):!
result = 0!
for v in values:!
result += v!
return result
A tuple is like a list you
can’t modify, e.g. (1,2,3)

Variable Arguments
>>> def sum(*values):!
... result = 0!
... for v in values:!
... result += v!
... return result!
...!
>>> sum(*[1,2,3])!
6

Variable Arguments
• Python “unpacks” the tuple/
list/etc. into separate
arguments
... result = 0!
... result += v!
... return result!
...!
>>> sum(*[1,2,3])!
6

Variable Arguments
arguments
• You can call functions that use
variable or fixed arguments
this way
... result = 0!
... result += v!
... return result!
...!
>>> sum(*[1,2,3])!
6

Variable Arguments
arguments
variable or fixed arguments
this way
... result = 0!
... result += v!
... return result!
...!
>>> sum(*[1,2,3])!
6
>>> def x_times_y(x, y):!
... return x * y!
...!
>>> x_times_y(*[4,2])!
8

Keyword Parameters
• Sometimes I want a function, but I don’t know
what I want to name the arguments…

Keyword Parameters
• Sometimes I want a function, but I don’t know
what I want to name the arguments…
• … hard to come up with a really simple example,
but hopefully this makes sense…

Keyword Parameters
>>> def make_dict(**kwargs):!
... result = {}!
... for k, v in kwargs.items():!
... result[k] = v!
... return result!
...!
>>> make_dict(a=5, b=6)!
{'a': 5, 'b': 6}

Keyword Parameters
remaining named arguments
into a dict
... result = {}!
... result[k] = v!
... return result!
...!
{'a': 5, 'b': 6}

Keyword Parameters
into a dict
number of named arguments
to the function
... result = {}!
... result[k] = v!
... return result!
...!
{'a': 5, 'b': 6}

Keyword Parameters
into a dict
number of named arguments
to the function
A dict is like a directory
mapping “keys” to
“values” (e.g. {key: value})
... result = {}!
... result[k] = v!
... return result!
...!
{'a': 5, 'b': 6}

Keyword Parameters Step by
Step
>>> make_dict(a=5, b=6)

Step
>>> make_dict(a=5, b=6) def make_dict(**kwargs):!
result = {}!
for k, v in kwargs.items():!
result[k] = v!
return result

Step
result = {}!
result[k] = v!
return result
kwargs = {'a': 5, 'b': 6}!
make_dict(**kwargs)

Step
result = {}!
result[k] = v!
return result
kwargs = {'a': 5, 'b': 6}!
make_dict(**kwargs)
kwargs = {'a': 5, 'b': 6}!
result = {}!
for k, v in {'a': 5, 'b': 6}.items():!
result[k] = v!
return result

Step
result = {}!
result[k] = v!
return result
kwargs = {'a': 5, 'b': 6}!
make_dict(**kwargs)
kwargs = {'a': 5, 'b': 6}!
result = {}!
for k, v in {'a': 5, 'b': 6}.items():!
result[k] = v!
return result
result = {}!
result = {'a': 5}!
result = {'a': 5, 'b': 6}!
return result

Step
result = {}!
result[k] = v!
return result
kwargs = {'a': 5, 'b': 6}!
make_dict(**kwargs)
kwargs = {'a': 5, 'b': 6}!
result = {}!
for k, v in {'a': 5, 'b': 6}.items():!
result[k] = v!
return result
result = {}!
result = {'a': 5}!
result = {'a': 5, 'b': 6}!
return result
{'a': 5, 'b': 6}

Keyword Arguments
>>> make_dict(**{'a': 10, 'b': 20})!
{'a': 10, 'b': 20}

Keyword Arguments
• Python “unpacks” the dict into
separate arguments
>>> make_dict(**{'a': 10, 'b': 20})!
{'a': 10, 'b': 20}

Keyword Arguments
separate arguments
keyword or fixed arguments
this way
>>> make_dict(**{'a': 10, 'b': 20})!
{'a': 10, 'b': 20}

Keyword Arguments
>>> make_dict(**{'a': 10, 'b': 20})!
{'a': 10, 'b': 20}
separate arguments
keyword or fixed arguments
this way
>>> dct = {'x': 2, 'y': 6}!
>>> x_times_y(**dct)!
12

Keyword Arguments Step by
Step
>>> dct = {'x': 2, 'y': 6}!
>>> x_times_y(**dct)

Step
>>> dct = {'x': 2, 'y': 6}!
def x_times_y(x, y):!
return x * y

Step
>>> dct = {'x': 2, 'y': 6}!
x_times_y(x=2, y=6)
return x * y

Step
>>> dct = {'x': 2, 'y': 6}!
x_times_y(x=2, y=6)
return x * y
x=2!
y=6!
return x * y

Step
>>> dct = {'x': 2, 'y': 6}!
x_times_y(x=2, y=6)
return x * y
x=2!
y=6!
return x * y
return 2 * 6

Step
>>> dct = {'x': 2, 'y': 6}!
x_times_y(x=2, y=6)
return x * y
x=2!
y=6!
return x * y
return 2 * 6
12

Is there more?
• Of course there’s more, but it’s beginner’s night ;-)

Is there more?
• But what can I do now?

Is there more?
• Write functions to reuse code (DRY)

Is there more?
• Write recursive functions

Is there more?
• Write recursive functions
• Create and use functions with different kinds of
arguments and parameters (named, *args,
**kwargs)

“Any questions?”
–Rick Copeland

Python Functions (PyAtl Beginners Night)

More Related Content

What's hot

Similar to Python Functions (PyAtl Beginners Night)

More from Rick Copeland

Recently uploaded

Python Functions (PyAtl Beginners Night)