python自学Day07（自学书籍python编程从入门到实践）

第8章 函数

• 函数是带名字的代码块，用于完成具体的工作。
• 学习定义函数，向函数传递信息。
• 学习如何编写主要任务是显示信息的函数，还有用于处理数据并返回一个或一组值得函数。
• 学习如何将函数存储在被称为模块的独立文件中，让主程序文件的组织更为有序。

8.1 定义函数

• 使用def关键字来告诉python你要定义一个函数。
• def 函数名（参数）：基本的函数构造语法。
• 使用三引号编辑文档字符串的注释，描述函数做了什么，python用它生成有关程序中的函数文档。

#使用def定义函数
def greet_user():
    #使用''' ''' 概述函数作用
    '''显示简单问候语函数'''
    print('你好！世界。')
#调用函数
greet_user()

输出结果为：

你好！世界。

8.1.1 向函数传递信息

• 我们在上面的代码中稍加修改，在括号内添加一个参数变量。

#在之前的代码基础上我们加上一个形参username
def greet_user(username):
    '''简单显示打招呼函数'''
    print('你好，'+username.title()+'!')
#获取用户输入的信息，并且调用函数显示输出。
username = input('请输入您的英文名： ')
greet_user(username)

输出的结果为：

请输入您的英文名： robert
你好，Robert!

8.1.2 实参和形参

• 前面定义greet_user时，要求给变量username一个值，在定义中username是一个形参。函数完成其工作需要的一个信息。
• 用户输入的信息rober我们存储在第6行username中，并且把这个信息传到函数中，这个robert就是实参。

8.2 传递实参

• 鉴于函数定义中包括多个形参，因此函数调用中也可能包含多个实参。
• 使用位置参数，这要求实参的顺序与形参的顺序相同。
• 使用关键字参数，这要求每个实参都由变量名和值组成。
• 还可以使用列表和字典。

8.2.1 位置参数

• 当调用函数时，你必须将函数调用中的每个实参都关联函数定义中的每个形参，为此最简单的关联方式是基于实参的顺序，这种关联方式称为位置实参。

def info(name,age):
    '''定义一个简单的显示名字加年龄的函数'''
    age = str(age)
    print('你的名字叫'+name+',你今年'+age+'岁。')
#根据位置传递实参
info('饶庆龙',26)

输出的结果为：

你的名字叫饶庆龙,你今年26岁。

1. 调用函数多次

• 你可以根据需求调用函数任意次数。
• 调用函数是一种极为高效的编程方法，事先我们可以先进行定义函数，然后在我们需要的时候调用。
• python中将按顺序将函数调用中的实参关联函数定义中的形参。

2. 位置实参的顺序很重

• 使用位置实参的时候我们一定要注意参数的顺序关联，否则将会闹出笑话。

def info(name,age):
    '''定义一个简单的显示名字加年龄的函数'''

    print('你的名字叫'+str(name)+',你今年'+age+'岁。')
#根据位置传递实参
info(26,'饶庆龙')

输出结果为：

你的名字叫26,你今年饶庆龙岁。

8.2.2 关键字实参

• 关键字实参是传递给函数的名称-值对。你直接在实参中将名称和值关联起来。
• 关键字实参让您无需考虑函数调用中的实参顺序，还清楚的支出值得用途。
• 使用关键字实参务必准确地指定函数定义中的形参名。

def info(name,age):
    '''定义一个简单的显示名字加年龄的函数'''
    age = str(age)
    print('你的名字叫'+name+',你今年'+age+'岁。')
#使用关键字传递实参
info(age = 26,name='饶庆龙')

输出的结果为：

你的名字叫饶庆龙,你今年26岁。

8.2.3 默认值

• 编写函数时，可以将每个形参指定默认值。
• 在调用函数中给形参提供实参时，python将使用指定的实参值。否则将使用形参的默认值！
• 给形参指定默认值后，可在函数中调用中省略相应的实参，使用默认值可简化的函数调用，还可清楚的指定函数的典型用法。
• 使用默认值的时候，在形参列表中必须现列出没有默认值的形参，再列出有默认值得实参，这让python依然能够正确的解读位置实参。
• 当有多个指定默认值形参时，我们要么按位置顺序传递，要么使用关键字实参，注意顺序！！！

#没有默认值的形参必须在有默认值的形参前面。
def info(name,age = 26,sex = 'man'):
    '''定义一个简单的显示名字加年龄的函数'''
    age = str(age)
    print('你的名字叫'+name+',你今年'+age+'岁,你的性别是'+sex)
#使用关键字传递实参
info(name='饶庆龙')

输出结果为：

你的名字叫饶庆龙,你今年26岁,你的性别是man

8.2.4 等效的函数调用

• 鉴于可以混合使用位置实参，关键字实参和默认值，通常有多种等效的函数调用方式。

#没有默认值的形参必须在有默认值的形参前面。
def info(name,age = 26,sex = 'man'):
    '''定义一个简单的显示名字加年龄的函数'''
    age = str(age)
    print('你的名字叫'+name+',你今年'+age+'岁,你的性别是'+sex)
#使用关键字传递实参
info(name='饶庆龙')
info('饶庆龙')
info('令狐冲',34)
info('任盈盈',sex='lady',age=36)

输出结果为：

你的名字叫饶庆龙,你今年26岁,你的性别是man
你的名字叫饶庆龙,你今年26岁,你的性别是man
你的名字叫令狐冲,你今年34岁,你的性别是man
你的名字叫任盈盈,你今年36岁,你的性别是lady

8.2.5 避免实参错误

• 实参顺序需要留意。
• 实参与形参需要匹配（实参不能多于或少于形参）

练习：

#8-3 T恤
def make_shirt(size,words):
    print('你T恤的尺码是：'+size+'码,\n你想印的字是：'+words)
size = input('请输入您T恤的尺码：')
words = input('请输入你要印在T恤上的话：')
make_shirt(size,words)

输出的结果为：

请输入您T恤的尺码：32
请输入你要印在T恤上的话：人生苦短，我选python！
你T恤的尺码是：32码,
你想印的字是：人生苦短，我选python！

#8-4 大号T恤
def make_shirt(size = '',words = 'I love python!'):
    print('你T恤的尺码是：'+size+'码,\n你想印的字是：'+words)
#输出默认值36码的带有 I love python！的T恤
make_shirt()
#输出码子28 字样默认的
make_shirt('')
#输出默认尺码，字样为 T T
make_shirt(words='T T')

输出的结果为：

你T恤的尺码是：36码,
你想印的字是：I love python!
你T恤的尺码是：28码,
你想印的字是：I love python!
你T恤的尺码是：36码,
你想印的字是：T T

8.3 返回值

• 函数并非总是直接显示输出，相反我们可以用它处理一些数据，并返回一个或一组值。函数返回的值被称为返回值！
• 在函数中使用return语句将值返回到调用函数的代码行，返回值能让你的大部分法中工作移到函数中去完成。

8.3.1 返回简单的值

#定义一个加法函数 设置两个形参 x，y，返回x+y的结果
def add(x,y):
    return x+y
#传递实参 x=2 y=3 调用函数 将返回值存储在变量z中并且打印出来
z = add(2,3)
print(z)

输出的结果为：

 5

8.3.2 让实参变成可选的

• 将形参默认值设置为空字符串
• 使用if语句，如果没有指定实参，那么判断空字符串则为False，以此来控制程序。

#定义函数，将中间名称形参设置默认值为空字符串
def get_full_name(firstname,lastname,middlename=''):
#如果没有指定参数的传入，那么if语句将不会通过条件测试，直接执行else下的代码
    if middlename:
        full_name = firstname+' '+middlename+' '+lastname
    else:
        full_name = firstname+' '+lastname
    return full_name.title()
my_name= get_full_name('rao','long')
print(my_name)
my_name = get_full_name('rao','long','qing')
print(my_name)

输出的结果为：

Rao Long
Rao Qing Long

8.3.3 返回字典

• 函数可返回任何类型的值，包括字典和列表等比较复杂的数据结构。

#定义一个函数，形参设置为三个 一个接受名字 一个接受年龄 还有一个可选参数 接受性别
def build_person(name,age,sex=''):
#创建一个字典接受两个没有默认值的参数
    person = {'name':name,'age':age}
#如果可选参数不为空时，往字典添加键-值对
    if sex:
        person['sex'] = sex
#返回字典
    return person
my_person = build_person('raolong',26)
print(my_person)
my_person = build_person('raolong',27,sex='man')
print(my_person)

输出结果为：

{'name': 'raolong', 'age': 26}
{'name': 'raolong', 'age': 27, 'sex': 'man'}

8.3.4 结合使用函数和while循环

• 可将函数与前面几章所学到的的任何python结构结合起来使用。
• 下面用代码来展示与while循环的搭配使用。

#定义函数，将中间名称形参设置默认值为空字符串
def get_full_name(firstname,lastname,middlename=''):
#如果没有指定参数的传入，那么if语句将不会通过条件测试，直接执行else下的代码
    if middlename:
        full_name = firstname+' '+middlename+' '+lastname
    else:
        full_name = firstname+' '+lastname
    return full_name
#创建while循环，和标志变量
active = True
while active:
    print('您可以输入您的姓名，\n将姓氏和名字分开输入。')
    print('您也可以在输入时，随时输入q停止。')
    f_name = input('请输入您的姓氏：')
    if f_name == 'q':
        break
    l_name = input('请输入您的名字：')
    if l_name == 'q':
        break
    my_name = get_full_name(f_name,l_name)
    print('您好啊！'+my_name)

输出结果为：

您可以输入您的姓名，
将姓氏和名字分开输入。
您也可以在输入时，随时输入q停止。
请输入您的姓氏：饶
请输入您的名字：庆龙
您好啊！饶 庆龙
您可以输入您的姓名，
将姓氏和名字分开输入。
您也可以在输入时，随时输入q停止。
请输入您的姓氏：q

练习：

#8-6 城市名
def city_country(city,country):
    return (city.title()+','+country.title())
a = city_country('hongkong','china')
b = city_country('berin','german')
c = city_country('tokoyo','japan')
print(a,b,c)

输出结果为：

Hongkong,China Berin,German Tokoyo,Japan

#8-7 专辑
def make_album(singer,album,song_numbers=''):
    albums = {}
    if song_numbers:
        albums['song_numbers'] = song_numbers
    else:
        pass
    albums['singer'] = singer
    albums['album'] = album
    return albums
zhou_jielun = make_album('周杰伦','说好不哭')
print(zhou_jielun)
zhou_jielun = make_album('周杰伦','说好不哭',13)
print(zhou_jielun)

输出结果为：

{'singer': '周杰伦', 'album': '说好不哭'}
{'song_numbers': 13, 'singer': '周杰伦', 'album': '说好不哭'}

#8-8 用户的专辑
def make_album(singer,album,song_numbers=''):
    albums = {}
    if song_numbers:
        albums['歌曲数量'] = song_numbers
    else:
        pass
    albums['歌手'] = singer
    albums['专辑'] = album
    return albums
while True:
    print('填写喜爱歌手以及相关信息，\n如果不想继续输入，\n输入q可以随时退出。\n')
    singer = input('请输入歌手名称： ')
    if singer == 'q' :
        break
    album = input('请输入歌手专辑名称： ')
    if album == 'q':
        break
    song_numbers = input('请输入专辑歌曲数目：（选填）')
    if song_numbers == 'q':
        break
    dic1 = make_album(singer,album,song_numbers)
    print(dic1)
    print('------分割线------\n')

输出的结果为：

填写喜爱歌手以及相关信息，
如果不想继续输入，
输入q可以随时退出。

请输入歌手名称： 周杰伦
请输入歌手专辑名称： 不要再哭
请输入专辑歌曲数目：（选填）
{'歌手': '周杰伦', '专辑': '不要再哭'}
------分割线------

填写喜爱歌手以及相关信息，
如果不想继续输入，
输入q可以随时退出。

请输入歌手名称： 林俊杰
请输入歌手专辑名称： 江南
请输入专辑歌曲数目：（选填）36
{'歌曲数量': '', '歌手': '林俊杰', '专辑': '江南'}
------分割线------

填写喜爱歌手以及相关信息，
如果不想继续输入，
输入q可以随时退出。

请输入歌手名称： q

8.4 传递列表

• 你经常会发现，向函数传递列表很有用，这种列表包含的可能是名字、数字或更复杂的对象（如字典）。
• 将列表传递给函数后，函数就能直接访问其内容。

def names_greet(names):
    '''向名称列表每个名字问好，并且打印出来'''
    for name in names:
        print('Hello,'+name.title()+'!')
user_names = ['raolong','zhangyuli','yucong']
names_greet(user_names)

输出结果为：

Hello,Raolong!
Hello,Zhangyuli!
Hello,Yucong!

8.4.1 在函数中修改列表

• 将列表传递给函数之后，函数就可以对其进行修改。
• 在函数中对这个列表做任何修改都是永久性的，这让你能高效的处理大量的数据。
• 每个函数都应该只负责一项具体工作的完成。
• 下面欣赏两段输出结果一致的代码，分别为未使用函数和使用函数的。

unprintde_design = ['iphone case','robot pendant','dodecahedron']
completed_design = []
while unprintde_design:
    current = unprintde_design.pop()
    print('正在制作设计： '+current)
    completed_design.append(current)
print('\n已制作完成设计列表：')
for design in completed_design:
    print('\t'+design)

def show_do(unprintde_design,completed_design):
    while unprintde_design:
        current = unprintde_design.pop()
        print('正在制作设计： ' + current)
        completed_design.append(current)
def show_result(completed_design)   :
    print('\n已制作完成设计列表：')
    for design in completed_design:
        print('\t' + design)
unprintde_design = ['iphone case','robot pendant','dodecahedron']
completed_design = []
show_do(unprintde_design,completed_design)
show_result(completed_design)

输出结果为：

正在制作设计： dodecahedron
正在制作设计： robot pendant
正在制作设计： iphone case

已制作完成设计列表：
    dodecahedron
    robot pendant
    iphone case

• 相比没有使用函数的版本，这个程序更容易维护和拓展。

8.4.2 禁止函数修改列表

• 有时候我们需要禁止函数修改列表，因为修改是永久性的，而我们需要保留原始列表。
• 这个时候我们可以用切片表示法 [ : ]创建列表的副本，传递给函数。
• 除非有充分的理由需要传递副本，否则我们还是应该将原始列表传给函数，避免浪费时间和内存，提高编程的效率。

def show_do(unprintde_design,completed_design):
    while unprintde_design:
        current = unprintde_design.pop()
        print('正在制作设计： ' + current)
        completed_design.append(current)
def show_result(completed_design)   :
    print('\n已制作完成设计列表：')
    for design in completed_design:
        print('\t' + design)
unprintde_design = ['iphone case','robot pendant','dodecahedron']
completed_design = []
show_do(unprintde_design[:],completed_design)
show_result(completed_design)
print(unprintde_design)

输出的结果为：

正在制作设计： dodecahedron
正在制作设计： robot pendant
正在制作设计： iphone case

已制作完成设计列表：
    dodecahedron
    robot pendant
    iphone case
['iphone case', 'robot pendant', 'dodecahedron']

• 可以看到我们打印了原始列表，因为传递的是副本，原始列表并没有被函数所修改。

练习：

#8-9 魔术师
def show_magicians(magicians):
    for magician in magicians:
        print(magician.title())
magicians = ['robert','ronaldo','felix','messi']
show_magicians(magicians)

输出结果为：

Robert
Ronaldo
Felix
Messi

#8-10 方法1
magicians = ['robert','ronaldo','felix','messi']
new_magicians = []
def show_great(magicians,new_magicians):
    for magician in magicians:
        magician = 'The great '+magician
        new_magicians.append(magician)
def show_magicians(magicians):
    for magician in magicians:
        print(magician.title())
show_great(magicians,new_magicians)
show_magicians(new_magicians)

#8-10 方法2
magicians = ['robert','ronaldo','felix','messi']
def show_great(magicians):
    n = 0
    while n < len(magicians):
        magicians[n] = 'The great '+magicians[n]
        n += 1
def show_magicians(magicians):
    for magician in magicians:
        print(magician.title())
show_great(magicians)
show_magicians(magicians)

输出结果为：

The Great Robert
The Great Ronaldo
The Great Felix
The Great Messi

#8-11 不变的魔术师 使用列表副本 保留原始列表
magicians = ['robert','ronaldo','felix','messi']
new_magicians = []
def show_great(magicians,new_magicians):
    for magician in magicians:
        magician = 'The great '+magician
        new_magicians.append(magician)
def show_magicians(magicians):
    for magician in magicians:
        print(magician.title())
show_great(magicians[:],new_magicians)
show_magicians(new_magicians)
print(magicians)

输出的结果为：

The Great Robert
The Great Ronaldo
The Great Felix
The Great Messi
['robert', 'ronaldo', 'felix', 'messi']

8.5 传递任意数量的实参

• 有时候你不知道函数需要接受多少个实参，好在python中允许函数从调用语句中手机任意数量的实参。
• 带有*号的形参名让python创建一个空元组，并将接收到的所有值都封装到这个元组中。
• 注意python将实参封装到一个元组中，即便函数只收到一个值也是如此。

def make_pizza(*toppings):
    '''打印顾客点的所有配料'''
    print(toppings)
make_pizza('peperoni')
make_pizza('mushrooms','green papers','extar chesse')

输出结果为：

('peperoni',)
('mushrooms', 'green papers', 'extar chesse')

def make_pizza(*toppings):
    '''打印顾客点的所有配料'''
    print('\nmaking a pizza with the following toppings:')
    for topping in toppings:
        print('-'+topping)
make_pizza('mushrooms','green papers','extar chesse')

输出的结果为：

making a pizza with the following toppings:
-mushrooms
-green papers
-extar chesse

8.5.1 结合使用位置实参和关键字实参

• 如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。
• python先匹配位置实参和关键字实参，再将余下的实参全部收集到最后一个形参当中去。

def make_pizza(size,*toppings):
    '''打印顾客点的所有配料'''
    print('\nmaking a '+str(size)+'-inch pizza with the following toppings:')
    for topping in toppings:
        print('-'+topping)
#使用位置实参
make_pizza(16,'mushrooms','green papers','extar chesse')

输出结果为：

making a 16-inch pizza with the following toppings:
-mushrooms
-green papers
-extar chesse

8.5.2 使用任意数量的关键字实参

• 有时候需要接受任意数量的实参，但预先不知道传递给函数的会是什么信息。
• 可将函数编译成能够接受任意数量的键-值对-调用语句提供多少接受多少。
• 带**两个星号的形参名，让python创建一个空字典，并将收到所有的名称-值封装到这个字典中去。
• 编写函数时，你可以以各种方式混合使用位置实参、关键字实参和任意数量的实参。
• 知道这些实参类型大有裨益，因为阅读别人的代码时我们会经常见到他们。

#定义一个函数用于创建球员，接受球员的信息转换为字典
def build_person(name,age,**info):
    NBA_person = {}
    NBA_person['name'] = name
    NBA_person['age'] = str(age)
    for key,vluae in info.items():
        NBA_person[key] = vluae
    return NBA_person
#定义一个函数用于打印字典中的球员信息
def print_info(my_player):
    for key, vlaue in my_player.items():
        print(key.title() + ':' + vlaue.title())
#调用函数，将球员信息传参给函数
my_player = build_person('yaoming',35,country = 'china',height = '2.36')
#调用函数，打印球员信息
print_info(my_player)

输出结果为：

Name:Yaoming
Age:35
Country:China
Height:2.36

练习：

#8-12 三明治
def customer_orders(*toppings):
    print('Customers ordered the following toppings : ')
    for topping in toppings:
        print('-' + topping)
    print('------分割线------\n')
customer_orders('mushrooms', 'green papers', 'extar chesse')
customer_orders('peperoni','green papers')
customer_orders('green papers')

输出结果为：

Customers ordered the following toppings :
-mushrooms
-green papers
-extar chesse
------分割线------

Customers ordered the following toppings :
-peperoni
-green papers
------分割线------

Customers ordered the following toppings :
-green papers
------分割线------

#8-12 用户简介
def build_person(name,age,**info):
    my_person = {}
    my_person['姓名'] = name
    my_person['年龄'] = str(age)
    for key,vluae in info.items():
        my_person[key] = vluae
    return my_person
def show_info(my_person):
    print('您的信息如下：')
    for key,vluae in my_person.items():
        print(key+':'+vluae)
my_info = build_person('饶庆龙',21,身高 = '1.75米',体重 = '60kg',爱好 = 'python')
show_info(my_info)

输出结果为：

您的信息如下：
姓名:饶庆龙
年龄:21
身高:1.75米
体重:60kg
爱好:python

#8-14 汽车
def make_car(model,Manufacturer,**info):
    car = {}
    car['model'] = model
    car['Manufacturer'] = Manufacturer
    for key,vlaue in info.items():
        car[key] = vlaue
    return car
car = make_car('subaru','outback',color = 'red',tow_package = True)
print(car)

输出的结果为：

{'model': 'subaru', 'Manufacturer': 'outback', 'color': 'red', 'tow_package': True}

8.6 将函数存储在模块中

• 函数的优点之一是，使用它们可将代码块与主程序分离。通过给函数指定描述性名称可以让主程序容易理解的很多。
• 我们还可以更进一步将函数存储在被称为模块的独立文件中，再将模块导入主程序中。import语句允许在当前运行的程序文件中使用模块中的代码。
• 通过将函数存储在独立的文件中，可隐藏程序代码的细节，将重点放在程序的高层逻辑上。
• 还能让你在众多的不同的程序中重用函数，将函数存储在独立的文件后，可与其他程序员共享这些文件而不是整个程序。

8.6.1 导入整个模块

• 要让函数是可以导入的，首先得创建模块，模块是扩展名为.py的文件，包含要导入到程序中的代码。
• 只需要编写一条import语句并在其中指定模块名，就可在程序中使用模块中的所有函数。 然后用 . 调用模块中的函数

def make_pizza(size,*toppoings):
    print('\nmaking a '+str(size)+'-inch pizza with the following toppings:')
    for toppoing in toppoings:
        print ('-'+toppoing)

import  pizza
pizza.make_pizza(6,'s','h')

输出结果为：

making a 6-inch pizza with the following toppings:
-s
-h

8.6.2 导入特定的函数

• 你还可以导入模块中的特定函数，from 模块名 import 函数名
• 通过逗号分隔函数名，可根据需要从模块中导入任意数量的函数 from 模块名 import 函数1，函数2，函数3
• 使用这种方法时，无需导入整个模块用 . 调用函数

from pizza import make_pizza
make_pizza(6,'s','h')

输出的结果为：

making a 6-inch pizza with the following toppings:
-s
-h

8.6.3 使用as给函数指定别名

• 如果要导入的函数的名称可能与程序中现有的名称冲突，或者函数名太长，可指定简单而独一无二的别名——外号。
• from 模块名 import 函数名 as 别名
• 再度调用函数时输入别名即可

from pizza import make_pizza as mp
mp(6,'s','h')

输出的结果为：

making a 6-inch pizza with the following toppings:
-s
-h

8.6.4 使用as给模块指定别名

• 你还可以给模块指定别名，这样可以使用简单的别名，让你能够更轻松的调用模块中的函数。
• 函数名称一般具有描述性，所以建议尽量不要重命名，重命名时可以优先考虑模块而非函数。
• import 模块名 as 别名 别名.函数调用函数

import pizza as p
p.make_pizza(6,'s','h')

输出的结果为：

making a 6-inch pizza with the following toppings:
-s
-h

8.6.5 导入模块中的所有函数

• 使用星号 * 运算符可以让python导入模块中的所有函数。
• import语句中的星号让python将模块中的所有函数复制到这个程序文件中。
• 由于导入了每个函数，可通过名称来调用函数，无需使用句点表示法。
• from 模块名 import * 这种方法不推荐 在函数较少或者相对熟悉的模块时 可以尝试使用

from pizza import *
make_pizza(6,'s','h')

输出的结果为：

making a 6-inch pizza with the following toppings:
-s
-h

8.7 函数编写指南

• 应该给函数指定描述性名称，且只在其中使用小写字母以及下划线。可以帮助你和别人明白代码究竟要做什么！
• 每个函数都应包含带有简单阐述其功能的注释，该注释应该在函数定义后面。并且采用文档字符串格式，方便阅读！
• 如果程序或者模块有多个函数，使用两个空行将其隔开、
• 所有import语句都应放在文件开头。