Python: Functions
def square(n): """Returns the square of a number.""" square = n ** 2 print "%d squared is %d." % (n, square) return squared # Call the square function on line 10! Make sure to # include the number 10 between the parentheses. square(10) ... 10 squared is 100.
Call and Response After defining a function, it must be called to be implemented. In the previous exercise, spam() in the last line told the program to look for the function called spam and execute the code inside it. Instructions 1. We've set up a function, square. Call it on the number 10 (by putting 10 between the parentheses of square()) on line 9!
# Print out the types of an integer, a float, # and a string on separate lines below. print type(42) print type(3.2) print type('spam') ... <type 'int'> <type 'float'> <type 'str'>
FUNCTIONS type() Finally, the type() function returns the type of the data it receives as an argument. If you ask Python to do the following: print type(42) print type(4.2) print type('spam') Python will output: <type 'int'> <type 'float'> <type 'str'> Instructions 1. Have Python print out the type of an int, a float, and a str string in the editor. You can pick any values on which to call type(), so long as they produce one of each.
# Import *just* the sqrt function from math on line 3! from math import sqrt
Function Imports Nice work! Now Python knows how to take the square root of a number. However, we only really needed the sqrt function, and it can be frustrating to have to keep typing math.sqrt(). It's possible to import only certain variables or functions from a given module. Pulling in just a single function from a module is called a function import, and it's done with the from keyword: from module import function Now you can just type sqrt() to get the square root of a number—no more math.sqrt()! Instructions 1. Let's import only the sqrt function from math this time. (You don't need the () after sqrt in the from math import sqrt bit.)
# Define your spam function starting on line 5. You # can leave the code on line 10 alone for now--we'll # explain it soon! def spam(): """Prints 'Eggs!' to the console.""" print "Eggs!" # Define the spam function above this line. spam() ... Eggs!
Function Junction Functions are defined with three components: The header, which includes the def keyword, the name of the function, and any parameters the function requires. Here's an example: def hello_world(): # There are no parameters An optional comment that explains what the function does. """Prints 'Hello World!' to the console.""" The body, which describes the procedures the function carries out. The body is indented, just like conditional statements. print "Hello World!" Here's the full function pieced together: def hello_world(): """Prints 'Hello World!' to the console.""" print "Hello World!" Instructions 1. Go ahead and create a function, spam, that prints the string "Eggs!" to the console. Don't forget to include a comment of your own choosing (enclose it in triple quotes!).
def one_good_turn(n): return n + 1 def deserves_another(n): return one_good_turn(n) + 2
Functions Calling Functions We've seen functions that can print text or do simple arithmetic, but functions can be much more powerful than that. For example, a function can call another function: def fun_one(n): return n * 5 def fun_two(m): return fun_one(m) + 7 Instructions 1. Let's look at the two functions in the editor: one_good_turn (which adds 1 to the number it takes in as an argument) and deserves_another (which adds 2). Change the body of deserves_another so that it always adds 2 to the output of one_good_turn.
# Ask Python to print sqrt(25) on line 3. import math print math.sqrt(25) ... 5.0
Generic Imports Did you see that? Python said: NameError: name 'sqrt' is not defined. Python doesn't know what square roots are—yet. There is a Python module named math that includes a number of useful variables and functions, and sqrt() is one of those functions. In order to access math, all you need is the import keyword. When you simply import a module this way, it's called a generic import. Instructions 1. You'll need to do two things here: Type import math on line 2 in the editor. Insert math. before sqrt() so that it has the form math.sqrt(). This tells Python not only to import math, but to get the sqrt() function from within math. Then hit Run to see what Python now knows.
def hotel_cost(nights): # Hotel costs $140 per night return 140 * nights def plane_ride_cost(city): if city == "Charlotte": return 183 elif city == "Tampa": return 220 elif city == "Pittsburgh": return 222 elif city == "Los Angeles": return 475
Getting There You're going to need to take a plane ride to get to your location. def fruit_color(fruit): if fruit == "apple": return "red" elif fruit == "banana": return "yellow" elif fruit == "pear": return "green" The example above defines the function fruit_color that accepts a string as the argument fruit. The function returns a string if it knows the color of that fruit. Instructions 1. Below your existing code, define a function called plane_ride_cost that takes a string, city, as input. The function should return a different price depending on the location, similar to the code example above. Below are the valid destinations and their corresponding round-trip prices. "Charlotte": 183 "Tampa": 220 "Pittsburgh": 222 "Los Angeles": 475
def hotel_cost(nights): # Hotel costs $140 per night return 140 * nights def plane_ride_cost(city): if city == "Charlotte": return 183 elif city == "Tampa": return 220 elif city == "Pittsburgh": return 222 elif city == "Los Angeles": return 475
Getting There You're going to need to take a plane ride to get to your location. def fruit_color(fruit): if fruit == "apple": return "red" elif fruit == "banana": return "yellow" elif fruit == "pear": return "green" The example above defines the function fruit_color that accepts a string as the argument fruit. The function returns a string if it knows the color of that fruit. Instructions 1. Below your existing code, define a function called plane_ride_cost that takes a string, city, as input. The function should return a different price depending on the location, similar to the code example above. Below are the valid destinations and their corresponding round-trip prices. "Charlotte": 183 "Tampa": 220 "Pittsburgh": 222 "Los Angeles": 475
import math # Imports the math module everything = dir(math) # Sets everything to a list of things from math print everything # Prints 'em all! ... ['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
Here Be Dragons Universal imports may look great on the surface, but they're not a good idea for one very important reason: they fill your program with a ton of variable and function names without the safety of those names still being associated with the module(s) they came from. If you have a function of your very own named sqrt and you import math, your function is safe: there is your sqrt and there is math.sqrt. If you do from math import *, however, you have a problem: namely, two different functions with the exact same name. Even if your own definitions don't directly conflict with names from imported modules, if you import * from several modules at once, you won't be able to figure out which variable or function came from where. For these reasons, it's best to stick with either import module and type module.name or just import specific variables and functions from various modules as needed. Instructions 1. The code in the editor will show you everything available in the math module. Click Run to check it out (you'll see sqrt, along with some other useful things like pi, factorial, and trigonometric functions.
def hotel_cost(nights): # Hotel costs $140 per night return 140 * nights def plane_ride_cost(city): if city == "Charlotte": return 183 elif city == "Tampa": return 220 elif city == "Pittsburgh": return 222 elif city == "Los Angeles": return 475 def rental_car_cost(days): if days >= 7: return 40 * days - 50 elif days >= 3: return 40 * days - 20 else: return 40 * days def trip_cost(city, days, spending_money): return rental_car_cost(days) + hotel_cost(days) + plane_ride_cost(city) + spending_money
Hey, You Never Know! You can't expect to only spend money on the plane ride, hotel, and rental car when going on a vacation. There also needs to be room for additional costs like fancy food or souvenirs. Instructions 1. Modify your trip_cost function definition. Add a third argument, spending_money. Modify what the trip_cost function does. Add the variable spending_money to the sum that it returns.
# Ask Python to print sqrt(25) on line 3. print sqrt(25) ... Traceback (most recent call last): File "python", line 3, in <module> NameError: name 'sqrt' is not defined
I Know Kung Fu Remember import this from the first exercise in this course? That was an example of importing a module. A module is a file that contains definitions—including variables and functions—that you can use once it is imported. Instructions 1. Before we try any fancy importing, let's see what Python already knows about square roots. On line 3 in the editor, ask Python to print sqrt(25) which we would expect to equal five. Instead, it throws an error.
"""This program is designed to roll a pair of six-sided die. The user will guess a number. If that number is greater than the roll, the user wins. If the number is less than the roll, the user loses.""" from random import randint from time import sleep def get_user_guess(): user_guess = int(raw_input("Guess a number: ")) return user_guess def roll_dice(number_of_sides): first_roll = randint(1, number_of_sides) second_roll = randint(1, number_of_sides) max_val = number_of_sides * 2 print "The maximum possible value of a roll is: " + str(max_val) sleep(1) user_guess = get_user_guess() if user_guess > max_val: print "Your guess is invalid." return else: print "Rolling..." sleep(2) print "The first roll is %d" % first_roll sleep(1) print "The second roll is %d" % second_roll sleep(1) total_roll = first_roll + second_roll print "The total of both rolls is %d" % total_roll sleep(1) if user_guess > total_roll: print "You win!" return else: print "You lose!" return roll_dice(6)
Number Guess Wanna play a game? In this project, we'll build a program that rolls a pair of dice and asks the user to guess a number. Based on the user's guess, the program should determine a winner. If the user's guess is greater than the total value of the dice roll, they win! Otherwise, the computer wins. The program should do the following: Randomly roll a pair of dice Add the values of the roll Ask the user to guess a number Compare the user's guess to the total value Decide a winner (the user or the program) Inform the user who the winner is Let's begin! Mark the tasks as complete by checking them off Number Guess 1. Remember, it's helpful to let other developers know what your program does. Begin by including a multi-line comment that starts on line 1 that describes what your program does. You can use the instructions above to help you write the comment. Stuck? Get a hint 2. Since the program will roll dice, we need to make sure that the rolls are random. To do so, we will need some Python code that isn't built-in or readily available to us. Thankfully, we can import the module that will help us. Somewhere after your multi-line comment, write the following line of code: from random import randint Stuck? Get a hint 3. You'll also need to import more Python code that will be used to simulate dice rolling. On the next line, type: from time import sleep 4. Great! We've imported the code we'll need. We won't use it for now, but we will need it later, so let's move on. First, we'll have to prompt the user for their guess. Begin by creating a function called get_user_guess(). The function should take no arguments. Stuck? Get a hint 5. Inside of the function, prompt the user for their guess. Store the input into a variable called user_guess. Don't forget to use proper Python indentation! Stuck? Get a hint 6. By default, using raw_input alone will store the user's input as a string. Since the user is guessing a whole number, we will need an integer, not a string. This can be accomplished by wrapping the raw_input("Guess a number: ") part of your code with int(). Stuck? Get a hint 7. The name of this function is get_user_guess(), which implies that when the function is called, it should get, or return, the user's guess. On the next line, return the user's guess. Stuck? Get a hint 8. Great! This function is complete and we will use it later to complete our entire program. Now it's time to start building the rest of the game. Create a second function called roll_dice(). Stuck? Get a hint 9. Let's give the user the freedom to specify the number of sides that a single die will have. Modify the function to include a parameter called number_of_sides. Stuck? Get a hint 10. Perfect! The roll_dice function will be used to simulate the rolling of a pair of dice. A single die can land on any value, but we know its value will be at least 1 and be no greater than the number of sides on that die. Inside of the function, let's simulate the first die roll. Use the randint function that you imported earlier to generate a random integer between 1 and number_of_sides. This is how the randint function works. Set the result equal to a variable called first_roll. Stuck? Get a hint 11. On the next line, simulate the second roll. Your line of code will look identical to the line of code you wrote in Step 10, except this time, set the result equal to a variable called second_roll. Stuck? Get a hint 12. Now let's calculate the maximum value the program can possibly roll. This will help us set some rules for our game later. On the next line, create a variable called max_val and set it equal to number_of_sides times 2 (since there are two die). Stuck? Get a hint 13. On the next line, let the user know what the maximum possible value is by using the print command and a message. You can concatenate the message and the value of max_val. Remember, max_val is an integer, so you will have to explicitly convert it to a string by wrapping it with str() when you concatenate. Hint def roll_dice(number_of_sides): first_roll = randint(1, number_of_sides) second_roll = randint(1, number_of_sides) max_val = number_of_sides * 2 print "The maximum possible value is: " + str(max_val) 14. On the next line, sleep the program for 1 second. Stuck? Get a hint 15. On the next line, call the get_user_guess() function. Remember that the function will return the user's guess after prompting the user. Store the returned value into a variable called user_guess. Stuck? Get a hint 16. Great! We have written code that simulates a dice roll and asks the user for their guess. Now it's time to write the rules that will determine the winner of the game. But what if the user guesses a number that's larger than the total possible value of the dice roll? That shouldn't be allowed... On the next line, write an if statement that checks if the user's guess is greater than the maximum value. Stuck? Get a hint 17. Within the if block, let the user know that their guess is invalid by printing an appropriate message. On the following line, use the return keyword to exit the if block and terminate the program if this condition is met. Stuck? Get a hint 18. Otherwise, the user can proceed to play the game! Add to the if statement by starting an else block. Inside of the else block, first print the message Rolling... to the user. Stuck? Get a hint 19. Staying inside the else block, sleep the program for 2 seconds on the next line to simulate the dice rolling. Stuck? Get a hint 20. On the next line, use string formatting to print the first roll. Remember that you stored the first roll in a variable earlier. This time, don't use %s, but use %d. Note that %s is used to format string variables, while %d is used to format integers. Then, on the next line, sleep the program for 1 second. Stuck? Get a hint 21. On the next line, print the value of the second roll. On the line after that, sleep the program again for 1 second. Stuck? Get a hint 22. To determine a winner, we will need to use the total value of the dice roll. On the next line, create a variable called total_roll and set it equal to the sum of the first roll and the second roll. Stuck? Get a hint 23. On the next line, print the total roll to the user, similar to what you did in Step 21. On the following line, print Result... to the user. Directly after that, sleep the program for 1 second to build suspense! Stuck? Get a hint 24. Keeping inside of the else block, add an if statement checks if the user's guess is greater than the total roll. If it is, print a friendly message to the user informing them that they won. Then, return on the next line. Stuck? Get a hint 25. What if the user's guess is less than the total roll? Inside of an else block, print a message to the user informing them that they lost. Then, return on the next line. Hint def roll_dice(number_of_sides): # ... if user_guess > max_val: # ... else: # ... if user_guess > total_roll: # ... else: print "You lost, try again." return In the hint above, # ... simply indicates that the code has been abbreviated to avoid a lengthy hint. Actual code should not be removed or replaced. 26. Great! We're almost done! For this program to run, we have to call the function. Somewhere outside of the roll_dice function, call the roll_dice function. Make sure to specify the number of sides a single die has as the parameter! Stuck? Get a hint 27. Finally, let's play Guess the Number! First, click Save. Then, in the terminal, type the following command and press "Enter" on your keyboard: python NumberGuess.py You should see the program run and prompt you for your guess. Pick a number and press "Enter" on your keyboard. Did you win or lose? Have fun!
def biggest_number(*args): print max(args) return max(args) def smallest_number(*args): print min(args) return min(args) def distance_from_zero(arg): print abs(arg) return abs(arg) biggest_number(-10, -5, 5, 10) smallest_number(-10, -5, 5, 10) distance_from_zero(-10) ... 10 -10 10
On Beyond Strings Now that you understand what functions are and how to import modules, let's look at some of the functions that are built in to Python (no modules required!). You already know about some of the built-in functions we've used with strings, such as .upper(), .lower(), str(), and len(). These are great for doing work with strings, but what about something a little more analytic? Instructions 1. What do you think the code in the editor will do? Click Run when you think you have an idea.
def power(base, exponent): # Add your parameters here! result = base ** exponent print "%d to the power of %d is %d." % (base, exponent, result) power(37, 4) # Add your arguments here! ... 37 to the power of 4 is 1874161.
Parameters and Arguments Let's reexamine the first line that defined square in the previous exercise: def square(n): n is a parameter of square. A parameter acts as a variable name for a passed in argument. With the previous example, we called square with the argument 10. In this instance the function was called, n holds the value 10. A function can require as many parameters as you'd like, but when you call the function, you should generally pass in a matching number of arguments. Instructions 1. Check out the function in the editor, power. It should take two arguments, a base and an exponent, and raise the first to the power of the second. It's currently broken, however, because its parameters are missing. Replace the ___s with the parameters base and exponent and call power on a base of 37 and a power of 4.
def hotel_cost(nights): # Hotel costs $140 per night return 140 * nights
Planning Your Trip When planning a vacation, it's very important to know exactly how much you're going to spend. def wages(hours): # If I make $8.35/hour... return 8.35 * hours The above example is just a refresher in how functions are defined. Let's use functions to calculate your trip's costs. Instructions 1. Define a function called hotel_cost with one argument nights as input. The hotel costs $140 per night. So, the function hotel_cost should return 140 * nights.
def cube(number): return number ** 3 def by_three(number): if number % 3 == 0: return cube(number) else: return False
Practice Makes Perfect Let's create a few more functions just for good measure. def shout(phrase): if phrase == phrase.upper(): return "YOU'RE SHOUTING!" else: return "Can you speak up?" shout("I'M INTERESTED IN SHOUTING") The example above is just there to help you remember how functions are structured. Don't forget the colon at the end of your function definition! 1. First, def a function called cube that takes an argument called number. Don't forget the parentheses and the colon! Make that function return the cube of that number (i.e. that number multiplied by itself and multiplied by itself once again). Define a second function called by_three that takes an argument called number. if that number is divisible by 3, by_three should call cube(number) and return its result. Otherwise, by_three should return False. Don't forget that if and else statements need a : at the end of that line! Hint if n % 3 == 0: print "n is divisible by 3" else: print "n is not" Make sure both functions return their values rather than printing them. Both branches of the if/else statement in by_three need to have return statements in them (that's three returns total, two for by_three and one for cube).
def hotel_cost(nights): # Hotel costs $140 per night return 140 * nights def plane_ride_cost(city): if city == "Charlotte": return 183 elif city == "Tampa": return 220 elif city == "Pittsburgh": return 222 elif city == "Los Angeles": return 475 def rental_car_cost(days): if days >= 7: return 40 * days - 50 elif days >= 3: return 40 * days - 20 else: return 40 * days def trip_cost(city, days): return rental_car_cost(days) + hotel_cost(days) + plane_ride_cost(city)
Pull it Together Great! Now that you've got your 3 main costs figured out, let's put them together in order to find the total cost of your trip. def double(n): return 2 * n def triple(p): return 3 * p def add(a, b): return double(a) + triple(b) We define two simple functions, double(n) and triple(p) that return 2 times or 3 times their input. Notice that they have n and p as their arguments We define a third function, add(a, b) that returns the sum of the previous two functions when called with a and b, respectively. Instructions 1. Below your existing code, define a function called trip_cost that takes two arguments, city and days. Like the example above, have your function return the sum of calling the rental_car_cost(days), hotel_cost(days), and plane_ride_cost(city) functions. It is completely valid to call the hotel_cost(nights) function with the variable days. Just like the example above where we call double(n) with the variable a, we pass the value of days to the new function in the argument nights.
def distance_from_zero(num): if type(num) == int or type(num) == float: return abs(num) else: return "Nope"
Review: Built-In Functions Perfect! Last but not least, let's review the built-in functions you've learned about in this lesson. def is_numeric(num): return type(num) == int or type(num) == float: max(2, 3, 4) # 4 min(2, 3, 4) # 2 abs(2) # 2 abs(-2) # 2 Instructions 1. First, def a function called distance_from_zero, with one argument (choose any argument name you like). If the type of the argument is either int or float, the function should return the absolute value of the function input. Otherwise, the function should return "Nope"
def shut_down(s): if s == "yes": return "Shutting down" elif s == "no": return "Shutdown aborted" else: return "Sorry"
Review: Functions Okay! Let's review functions. def speak(message): return message if happy(): speak("I'm happy!") elif sad(): speak("I'm sad.") else: speak("I don't know what I'm feeling.") Again, the example code above is just there for your reference! Instructions 1. First, def a function, shut_down, that takes one argument s. Don't forget the parentheses or the colon! Then, if the shut_down function receives an s equal to "yes", it should return "Shutting down" Alternatively, elif s is equal to "no", then the function should return "Shutdown aborted". Finally, if shut_down gets anything other than those inputs, the function should return "Sorry"
from math import sqrt print sqrt(13689) ... 117.0
Review: Modules Good work! Now let's see what you remember about importing modules (and, specifically, what's available in the math module). Instructions 1. Import the math module in whatever way you prefer. Call its sqrt function on the number 13689 and print that value to the console.
def answer(): return int(42)
TAKING A VACATION Before We Begin Let's first quickly review functions in Python. def bigger(first, second): print max(first, second) return True In the example above: We define a function called bigger that has two arguments called first and second. Then, we print out the larger of the two arguments using the built-in function max. Finally, the bigger function returns True. Now try creating a function yourself! Instructions 1. Write a function called answer that takes no arguments and returns the value 42. Even without arguments, you will still need parentheses.Don't forget the colon at the end of the function definition!
def hotel_cost(nights): # Hotel costs $140 per night return 140 * nights def plane_ride_cost(city): if city == "Charlotte": return 183 elif city == "Tampa": return 220 elif city == "Pittsburgh": return 222 elif city == "Los Angeles": return 475 def rental_car_cost(days): if days >= 7: return 40 * days - 50 elif days >= 3: return 40 * days - 20 else: return 40 * days def trip_cost(city, days, spending_money): return rental_car_cost(days) + hotel_cost(days) + plane_ride_cost(city) + spending_money print trip_cost("Los Angeles", 5, 600) ... 1955
TAKING A VACATION Plan Your Trip! Nice work! Now that you have it all together, let's take a trip. What if we went to Los Angeles for 5 days and brought an extra 600 dollars of spending money? Instructions 1. After your previous code, print out the trip_cost( to "Los Angeles" for 5 days with an extra 600 dollars of spending money. Don't forget the closing ) after passing in the 3 previous values!
def hotel_cost(nights): # Hotel costs $140 per night return 140 * nights def plane_ride_cost(city): if city == "Charlotte": return 183 elif city == "Tampa": return 220 elif city == "Pittsburgh": return 222 elif city == "Los Angeles": return 475 def rental_car_cost(days): if days >= 7: return 40 * days - 50 elif days >= 3: return 40 * days - 20 else: return 40 * days
Transportation You're also going to need a rental car in order for you to get around. def finish_game(score): tickets = 10 * score if score >= 10: tickets += 50 elif score >= 7: tickets += 20 return tickets In the above example, we first give the player 10 tickets for every point that the player scored. Then, we check the value of score multiple times. First, we check if score is greater than or equal to 10. If it is, we give the player 50 bonus tickets. If score is just greater than or equal to 7, we give the player 20 bonus tickets. At the end, we return the total number of tickets earned by the player. Remember that an elif statement is only checked if all preceding if/elif statements fail. 1. Below your existing code, define a function called rental_car_cost with an argument called days. Calculate the cost of renting the car: Every day you rent the car costs $40. if you rent the car for 7 or more days, you get $50 off your total. Alternatively (elif), if you rent the car for 3 or more days, you get $20 off your total. You cannot get both of the above discounts. Return that cost. Just like in the example above, this check becomes simpler if you make the 7-day check an if statement and the 3-day check an elif statement.
# Import *everything* from the math module on line 3! from math import *
Universal Imports Great! We've found a way to handpick the variables and functions we want from modules. What if we still want all of the variables and functions in a module but don't want to have to constantly type math.? Universal import can handle this for you. The syntax for this is: from module import * Instructions 1. Use the power of from module import * to import everything from the math module on line 3 of the editor.
absolute = abs(-42) print absolute ... 42
abs() The abs() function returns the absolute value of the number it takes as an argument—that is, that number's distance from 0 on an imagined number line. For instance, 3 and -3 both have the same absolute value: 3. The abs() function always returns a positive value, and unlike max() and min(), it only takes a single number. Instructions 1. Set absolute equal to the absolute value of -42 on line 1.
# Set maximum to the max value of any set of numbers on line 3! maximum = max(1,2,3) print maximum
max() The max() function takes any number of arguments and returns the largest one. ("Largest" can have odd definitions here, so it's best to use max() on integers and floats, where the results are straightforward, and not on other objects, like strings.) For example, max(1,2,3) will return 3 (the largest number in the set of arguments). Instructions 1. Try out the max() function on line 3 of the editor. You can provide any number of integer or float arguments to max().
# Set minimum to the min value of any set of numbers on line 3! minimum = min(1,2,3) print minimum
min() min() then returns the smallest of a given series of arguments. Instructions 1. Go ahead and set minimum equal to the min() of any set of integers or floats you'd like.