# 8.1 Define Functions

A simple function

```def greet_user():
'''Show simple greetings'''
print('Hello!')

greet_user()
'''
Output:
Hello!

'''
```

## 8.1.1 Passing Information to Functions

```def greet_user(username):
# Show simple greetings

greet_user('jesse')
greet_user('jim')
'''
Output:
Hello, Jesse.
Hello, Jim.

'''
```

## 8.1.2 Formal and Actual Parameters

In the code above, the variable username is a parameter, and the values'jesse'and'jim' are arguments

# 8.2 Transfer parameters

Function definitions may include more than one parameter, and function calls may include more than one argument. The methods for passing arguments to a function are: positional arguments, keyword arguments

## 8.2.1 Positional arguments

When calling a function, associate arguments to parameters based on their position

```def describe_pet(animal_type, pet_name):
'''Show pet information'''
print(f"\nI have a {animal_type}.")
print(f"My {animal_type}'s name is {pet_name}.")

describe_pet('mouse', 'Micky')
describe_pet('dog', 'Harry')
describe_pet('Harry', 'dog')
'''

I have a mouse.
My mouse's name is Micky.

I have a dog.
My dog's name is Harry.

I have a Harry.
My Harry's name is dog.

'''
```
1. Calling functions multiple times
2. The order of positional arguments is important, as illustrated by the second and third calls

## 8.2.2 Key Arguments

Keyword arguments associate names with values directly in the argument, so that the order of arguments is not considered

```def describe_pet(animal_type, pet_name):
'''Show pet information'''
print(f"\nI have a {animal_type}.")
print(f"My {animal_type}'s name is {pet_name}.")

describe_pet(animal_type = 'mouse',pet_name = 'Micky')
describe_pet(pet_name = 'Micky', animal_type = 'mouse')

'''
Output:

I have a mouse.
My mouse's name is Micky.

I have a mouse.
My mouse's name is Micky.

Process ended with exit code of 0

'''
```

## 8.2.3 Default

When writing a function, you can specify a default value for the parameter. When calling a function, when you provide an argument for the parameter, the program will use the supplied argument, otherwise the default value for the parameter will be used
Note here that it is important to consider the parameter position (where the parameter-default value also takes up a parameter position)

```def describe_pet(pet_name, animal_type = 'mouse'):
'''Show pet information'''
print(f"\nI have a {animal_type}.")
print(f"My {animal_type}'s name is {pet_name}.")

describe_pet('Micky')
describe_pet(pet_name = 'Harry', animal_type = 'dog')

'''
Output:

I have a mouse.
My mouse's name is Micky.

I have a dog.
My dog's name is Harry.

```

## 8.2.4 Equivalent function call

You can mix location, keyword, and default values

slightly

# 8.3 Return Value

Functions can return one or a set of values using the return statement

## 8.3.1 Returns a simple value

```def get_formatted_name(first_name, last_name):
'''Return a neat name'''
full_name = f"{first_name} {last_name}"
return full_name.title()

musician = get_formatted_name('jim', 'hendrix')
print(musician)
'''
Output:
Jim Hendrix

```

## 8.3.2 Make arguments optional

Not everyone has a middle name. To make the middle name optional, move the middle name to the end of the parameter, using the default method

```def get_formatted_name(first_name, last_name, middle_name = ''):
'''Return a neat name'''
if middle_name:
full_name = f"{first_name} {middle_name} {last_name}"
else:
full_name = f"{first_name} {last_name}"
return full_name.title()

musician = get_formatted_name('jim', 'hendrix')
print(musician)
musician = get_formatted_name('john', 'hooker', 'lee')
print(musician)

'''
Output:
Jim Hendrix
John Lee Hooker

'''
```

```def build_person(first_name, last_name):
person = {'first': first_name, 'last': last_name}
return person

musician = build_person('jim', 'hendrix')
print(musician)

'''
Output:
{'first': 'jim', 'last': 'hendrix'}

'''
```

## 8.3.4 Combining functions with while loops

```def get_formatted_name(first_name, last_name):
'''Return a neat name'''
full_name = f"{first_name} {last_name}"
return full_name.title()

while True:
print("(enter 'q' at any time to quit)")

f_name = input("First name: ")
if f_name == 'q':
break

l_name = input("Last name: ")
if l_name == 'q':
break

formatted_name = get_formatted_name(f_name, l_name)
print(f"\nHello, {formatted_name}!")

'''
Output:

(enter 'q' at any time to quit)
First name: zhang
Last name: xy

Hello, Zhang Xy!

(enter 'q' at any time to quit)
First name: wang
Last name: q

'''
```

# 8.4 Delivery List

Pass a list to the function

```def greet_users(names):
for name in names:
msg = f"Hello, {name.title()}."
print(msg)

'''
Output:
Hello, Hannah.
Hello, Ty.
Hello, Margot.

'''
```

## 8.4.1 Modifying lists in functions

Once a list is passed to a function, it can be modified, and the function is permanently modifying the list
Print elements from unprinted list, move elements from printed list to finished list

General procedure:

```unprint_designs = ['phone case', 'robot pendant', 'dodecahedron']
completed_designs = []

while unprint_designs:
current_design = unprint_designs.pop()
print(f"Printing model: {current_design}")
completed_designs.append(current_design)

print("\nThe following models have been printed: ")
print(completed_design)

'''
Output:
Printing model: dodecahedron
Printing model: robot pendant
Printing model: phone case

The following models have been printed:
dodecahedron
robot pendant
phone case

'''
```

Optimize the code (each function tries to do only one thing, which is more effective, and the main function is more concise; the first function prints and moves list elements, and the second function displays printed information)

```def print_modules(unprinted_designs, completed_designs):
while unprinted_designs:
current_design = unprint_designs.pop()
print(f"Printing model: {current_design}")
completed_designs.append(current_design)

def show_completed_designs(completed_designs):
print("\nThe following models have been printed: ")
print(completed_design)

unprint_designs = ['phone case', 'robot pendant', 'dodecahedron']
completed_designs = []

print_modules(unprint_designs, completed_designs)
show_completed_designs(completed_designs)

'''
Output:
Printing model: dodecahedron
Printing model: robot pendant
Printing model: phone case

The following models have been printed:
dodecahedron
robot pendant
phone case

'''

```

## 8.4.2 Disallow function modification list

Actually, instead of strictly prohibiting modification of the list, a backup is generated on the original list and operated on in the backup list so as not to affect the original list

```function_name(list_name[:])
```

# 8.5 Pass any number of parameters

*The asterisk in toppings causes the program to create an empty tuple named toppings and load all values received into it

```def make_pizza(*toppings):
print("\nMaking a pizza with the following toppings: ")
for topping in toppings:
print(f"- {topping}")

make_pizza('peperoni')
make_pizza('mushrooms', 'green peppers', 'extra chesese')

'''
Output:

Making a pizza with the following toppings:
- peperoni

Making a pizza with the following toppings:
- mushrooms
- green peppers
- extra chesese

'''
```

## 8.5.1 Combines positional and any number of arguments

If a function accepts different types of arguments, it must put the last parameter that accepts any number of arguments so that the program matches the positional and keyword parameters before collecting the remaining arguments into the last parameter

```def make_pizza(size, *toppings):
print(f"\nMaking a {size}-inch pizza with the following toppings: ")
for topping in toppings:
print(f"- {topping}")

make_pizza(16, 'peperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra chesese')

'''
Output:

Making a 16-inch pizza with the following toppings:
- peperoni

Making a 12-inch pizza with the following toppings:
- mushrooms
- green peppers
- extra chesese

'''

```

## 8.5.2 Use any number of keyword arguments

**user_info is used to collect any number of key-value pairs

```def build_profile(first, last, **user_info):
user_info['first_name'] = first
user_info['last_name'] = last
return user_info
# Keyword arguments are stored as key-value pairs directly, and non-key arguments are stored as key-value pairs instead.
user_proflie = build_profile('albert', 'einstein', location = 'princeton', field = 'physics')
print(user_proflie)

'''
Output:
{'location': 'princeton', 'field': 'physics', 'first_name': 'albert', 'last_name': 'einstein'}

'''
```

# 8.6 Store functions in modules

Use the import statement to make the current program use the code in the module, which can be understood as a stand-alone file with many useful functions

## 8.6.1 Import entire module

Using the pizza.py file as a module in making_ This module is called in pizza.py, and the syntax used to use the functions in the module is:

```module_name.function_name()
```

pizza.py file

```def make_pizza(size, *toppings):
# pizza.py module, containing function make_pizza()
print(f"\nMaking a {size}-inch pizza with the following toppings: ")
for topping in toppings:
print(f"- {topping}")
```

making_pizza.py file

```import pizza

pizza.make_pizza(16, 'pepperoni')
pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
'''
Output:

Making a 16-inch pizza with the following toppings:
- pepperoni

Making a 12-inch pizza with the following toppings:
- mushrooms
- green peppers
- extra cheese

'''
```

## 8.6.2 Import specific functions

Import the specific functions in the module with the following syntax:

```from module_name import function_name
```

If multiple functions are imported, separate them with commas

```from module_name import function0, function1, function2
```

In this case, you do not need to use the.Operator when calling a function

```from pizza import make_pizza

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
'''
Output:

Making a 16-inch pizza with the following toppings:
- pepperoni

Making a 12-inch pizza with the following toppings:
- mushrooms
- green peppers
- extra cheese

'''
```

## 8.6.3 Use as to alias functions

If the function you are importing conflicts with an existing name in the program, or if the name of the function is too long, you can alias the function
The syntax is as follows:

```from module_name import function_name as mp
```

The code in the previous section can be expressed as

```from pizza import make_pizza as mp

mp(16, 'pepperoni')
mp(12, 'mushrooms', 'green peppers', 'extra cheese')
```

## Assigning an alias to a module using as

You can also assign an alias to a module in the following syntax:

```import module_name as mn
```

The 8.6.1 code can be rewritten to:

```import pizza as mn

mn.make_pizza(16, 'pepperoni')
mn.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
```

## 8.6.5 Import all functions in the module

The syntax is as follows:

```from module_name import *
```

This practice is not recommended and recommended

1. Import only the functions you need, not the.Operator
2. Import the entire module and call the function with the.Operator

# 8.7 Function Writing Guide

1. Naming functions with lowercase letters and underscores only
2. Comments for functions should follow the function definition and be in document string format
3. Do not have spaces on either side of the equal sign when specifying a default value for a parameter

# 8.8 Summary

slightly

Tags: Python

Posted on Mon, 18 Oct 2021 12:30:26 -0400 by ozfred