A Quick Peek at Making Our Own Functions

Functions

What's a function (again)? →

Built-In Functions

What are some built-in function that we just learned about? →

Our Very Own Functions!

• we can actually create our own functions
• that means:
  • we can group a bunch of statements together
  • name that group of statements
  • execute that group of statements simply by calling its name!

Motivation for Creating Functions

Why would the ability to create our own functions be useful? →

Defining a Function

def the_name_of_your_function(parameter_1, paramter_2):
	""" some code """
	print("I'm doing something useful!")

Defining a Function Continued

1. a function definition always starts with the reserved word, def (the function header)
2. … followed by the name of your function
   • (function names adhere to the same rules as variable names)
3. … followed by parentheses
4. with an optional, comma separated list of inputs enclosed in parentheses (depends on function)
   • if the parentheses are empty, then the function is being called without arguments
     • no_inputs_needed()
5. lastly, an indented block of code (the function body)
   • this is just one level of indentation in →

What's This About an Indented Block?

• remember - in Python, whitespace characters (such as space, tabs, newlines, etc.) are significant
• consecutive lines of code can be grouped together based on indentation
• you can tell the start and end of a function body by its level of indentation
• it is indented one level in from the function header

def the_name_of_your_function(parameter_1, paramter_2):
	""" inside the function """
	print("something")
	print("another thing")

""" outside of the function """
print("and another thing")

Let's Try Creating a Function!

Write a function called say_multilingual_meow: →

• it'll say meow in two different languages
• it should print out two lines
• one line with "meow", the other line with "nyan"

def say_multilingual_meow():
	japanese_meow = "nyan"
	english_meow = "meow"
	print(japanese_meow)
	print(english_meow)

Calling Your Function

So… now that you have a shiny new function, how would you call it? How many arguments would it take? 0, 1, or 2? →

def say_multilingual_meow():
	japanese_meow = "nyan"
	english_meow = "meow"
	print(japanese_meow)
	print(english_meow)

"""
Once the function is defined in your file, you can call it!
"""

say_multilingual_meow()

Let's See How This All Works!

In one file, write the function definition and function call from the previous slides.

• try running it!
• print out "done" after your function call
• what do you think the output will be? →

def say_multilingual_meow():
	japanese_meow = "nyan"
	english_meow = "meow"
	print(japanese_meow)
	print(english_meow)

say_multilingual_meow()
print("done!")

nyan
meow
done!

Calling Your Function Continued

So… what actually happened there? →

def say_multilingual_meow():
	japanese_meow = "nyan"
	english_meow = "meow"
	print(japanese_meow)
	print(english_meow)

say_multilingual_meow()
print("done!")

• when you call your function…
• imagine that you're jumping back to your function definition
• …and then executing the body of your function
• once it's done, execution goes back to where you called your function (printed done for clarity)

Just the Definitions, Please!

Let's look at the same program, but without the function call. What do you think the output of this program will be? →

def say_multilingual_meow():
	japanese_meow = "nyan"
	english_meow = "meow"
	print(japanese_meow)
	print(english_meow)

Just the Calls, Please!

What about this version of the program? What do you think the output will be? →

say_multilingual_meow()

Traceback (most recent call last):
  File "/tmp/foo.py", line 1, in <module>
    say_multilingual_meow()
NameError: name 'say_multilingual_meow' is not defined

Multiple Function Definitions

You can define more than one function in your program!

def my_first_function():
	print("first")

def my_second_function():
	print("second")

Functions in Functions

In fact, you can use a function that you've already defined in another function that you're creating. What do you think the output of this program will be? →

def say_moo():
	print("moo")

def main():
	say_moo()
	say_moo()

main()

moo
moo

Functions in Functions Continued

Notice that in the previous code…

def say_moo():
	print("moo")

def main():
	say_moo()
	say_moo()

main()

• we defined a function called say_moo
• we defined another function called main that uses say_moo

"Local" Variables

• variables defined in your function are available only to that function
• the variables in your function are local to that function
• they cannot be used in another function or outside of the current function definition

"Local" Variables Continued

def my_first_function():
	a = 1
	print(a)

def my_second_function():
	b = 2
	print(b)

The variables a and b are local to my_first_function and my_second_function respectively.

"Local" Variables Continued Some More

Because variables defined within a function are local

• using the same variable name in two different functions doesn't cause any errors
• nothing gets overwritten

def my_first_function():
	a = 1
	print(a)

def my_second_function():
	a = 200
	print(a)

(calling both functions consecutively prints out 1, then 200)

Defining a Main Function

• it is common practice to have the entirity of your program in a single function called main
• main is usually defined at the end of the file
• with other additional functions defined outside as well
• the examples in Starting Out with Python use this pattern often
• here's a template:

def main():
	print("in main function")

main()

Main Function Continued

For example, these two programs are equivalent:

print("About to do stuff")
print("Doing stuff")
print("Done")

def main():
	print("About to do stuff")
	print("Doing stuff")
	print("Done")

main()

(Totally Optional) A Whirlwind Tour of Conditionals