# 函数
'''
所谓的函数就是一个独立的代码块，在需要的时候调用
定义函数--封装独立的功能
调用函数--调用函数的代码块
函数的命名规则：可以由字母、下划线和数字组成，但是不能以数字开头，不能与关键字重名
形参：定义函数时，小括号中的参数，是用来接收参数用的，在函数内部使用
实参：调用函数时，小括号中的参数，是用来把数据传递到函数内部用的
为了使函数灵活的运用，建议把函数内部可变(不确定)的数据都改变成参数
#函数编写指南
编写函数时，需要牢记几个细节。应给函数指定描述性名称，且只在其中使用小写字母和下
划线。描述性名称可帮助你和别人明白代码想要做什么。给模块命名时也应遵循上述约定。
每个函数都应包含简要地阐述其功能的注释，该注释应紧跟在函数定义后面，并采用文档字
符串格式。文档良好的函数让其他程序员只需阅读文档字符串中的描述就能够使用它：他们完全
可以相信代码如描述的那样运行；只要知道函数的名称、需要的实参以及返回值的类型，就能在
自己的程序中使用它。
'''
# 函数名括号中，有多少个形参，调用函数的时候，就要有多少个实参
# 定义一个名为 greet_user()的函数
def greet_user(): # 使用关键字def来定义函数，def下面缩进后的代码，就是在函数体里面
"""显示简单的问候语""" # 文档字符串注释，相当于注释，其作用是可以注释该函数有什么作用
print("Hello!")
greet_user() # 调用函数，直接写函数名加（）就可以了，就会执行名为greet_user函数体里面的代码
# 向函数传递信息
# 在函数名括号里面写入的参数，我理解这个为变量名，定义变量名写在括号里面，调用函数的时候，就给变量名赋值
def greet_user(username): # 在函数名括号里面写入一个参数，再你调用该函数的时候，可以接收你输入的值
""" 显示简单的问候语 """
print("Hello, " + username.title() + "!") # 将该值插入到语句当中，我这里理解的参数是像变量名一样
greet_user('jesse') # 在调用函数时，因为函数有一个参数，所以调用时也要赋值
# 实参和形参
def greet_user(username): # 在函数名括号里面写入参数的叫 ‘形参’
""" 显示简单的问候语 """
print("Hello, " + username.title() + "!") # 将
greet_user('jesse') # 调用函数的时候，括号里面写的值叫实参，这里也就是 ‘jesse’ 属于实参
# 传递实参
# 鉴于函数定义中可能包含多个形参，因此函数调用中也可能包含多个实参。
# 向函数传递实参的方式很多，可使用位置实参，这要求实参的顺序与形参的顺序相同；
# 也可使用关键字实参，其中每个实参都由变量名和值组成；还可使用列表和字典。
# 位置实参
def describe_pet(animal_type, pet_name): # 定义两个参数（形参），调用的时候需要按顺序赋值
"""显示宠物的信息"""
print("\nI have a " + animal_type + ".") # 插入到语句当中
print("My " + animal_type + "'s name is " + pet_name.title() + ".") # 插入到语句当中
describe_pet('hamster', 'harry') # 调用函数，给函数里面的参数赋值，（animal_type == hamster）、（pet_name == harry）
# 实参 'hamster' 存储在形参 animal_type 中，而实参 'harry' 存储在形参 pet_name 中
# 可调用函数多次，给形参赋值可以不相同，记得要按形参的顺序赋值
describe_pet('cat', 'hello')
describe_pet('gou', 'heihei')
# 关键字实参
# 关键字实参直接将定义的形参与实参的值关联起来，这样就不会将值顺序弄乱
def describe_pet(animal_type, pet_name): # 定义两个形参
"""显示宠物的信息"""
print("\nI have a " + animal_type + ".")
print("My " + animal_type + "'s name is " + pet_name.title() + ".")
# 使用describe_pet函数时，直接将实参与形参关联起来，这样的话就算使用函数的时候，怎么打乱赋值顺序，形参的值都不会弄乱
describe_pet(animal_type='hamster', pet_name='harry')
# 将顺序打乱，输出的结果还是一样，不会乱，因为已经将实参 'hamster' 与形参 animal_type 关联起来了，而实参 'harry' 与形参 pet_name 也关联起来了，所以顺序不会那么弄乱
describe_pet(pet_name='harry', animal_type='hamster')
# 默认值
# 编写函数时，可给每个形参指定默认值。在调用函数中给形参提供了实参时，
# Python将使用指定的实参值；否则，将使用形参的默认值
def describe_pet(pet_name, animal_type='dog'): # 定义两个形参，在这里将“dog‘赋值给形参animal_type的，叫默认值
"""显示宠物的信息"""
print("\nI have a " + animal_type + ".")
print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet(pet_name='willie') # 当形参animal_type有默认值的时候，调用函数时可不赋值给它
describe_pet('willie') # 同上
describe_pet(pet_name='willie', animal_type='cat') # 也可以在调用时，重新赋值给animal_type形参，当重新赋值时，将会执行新的值。就会忽略默认值
describe_pet('willie', 'cat') # 同上
# 得出的结论，当形参有默认值的时候，你可以赋值也可以不赋值，不赋值的话就会输入默认值，如果在实参这里再赋值，就可以输出实参的值
# 避免实参错误，你提供的实参多于或少于函数完成其工作所需的信息时，将出现实参不匹配错误
# 返回值 return
# 函数并非总是直接显示输出，相反，它可以处理一些数据，并返回一个或一组值。
# 函数返回的值被称为返回值。在函数中，可使用 return 语句将值返回到调用函数的代码行。
# 返回值让你能够将程序的大部分繁重工作移到函数中去完成，从而简化主程序。
# 当def函数执行到了return返回值的时候，就会退出def模块
# return返回值的意思就是将结果保存起来，待你调用函数的时候，输出的结果就是返回值的结果
# return返回值的意思就是，当你使用函数的时候，需要有什么结果返回给你，你就在返回值里写什么，简单说返回值就是一个表达式
# 返回值有点类似于print语法
# return[表达式]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回一个None。
# 一个简单的返回值
def get_formatted_name(first_name, last_name): # 定义两个形参
"""返回整洁的姓名"""
full_name = first_name + ' ' + last_name # 将两个形参储存到full_name变量当中
return full_name.title() # 使用return语句将full_name的值转换开头大写字母，并将结果返回到函数调用行
musician = get_formatted_name('jimi', 'hendrix') # 将函数储存到变量里面
print(musician) # 将其输出出来
print(get_formatted_name('jimi', 'hendrix')) # 原理同上两行，因为使用了return返回值，要么将函数储存到变量里面再输出，要么直接使用print将其输出出来
# get_formatted_name('jimi', 'hendrix') #如果你直接这样调用，是不会有东西输出出来的
# 让实参变成可选的
# 例如输出对方姓和名
def get_formatted_name(first_name, middle_name, last_name):
"""返回整洁的姓名"""
full_name = first_name + ' ' + middle_name + ' ' + last_name
return full_name.title()
musician = get_formatted_name('john', 'lee', 'hooker')
print(musician)
# 上面输出的是一个姓两个名的名字，但是如果对方的姓名是两个字的呢？一个姓一个名，则用下面的方法解决
def get_formatted_name(first_name, last_name, middle_name=''): # 定义三个形参，其中最后一个形参赋默认值为空白
# 只要字符串里面没有东西，就为False，当middle_name形参中没有定义实参，就是空，为False，if语句就不会成立，将执行else
"""返回整洁的姓名"""
if middle_name: # 当middle_name形参有赋值实参，那将执行下面缩进的代码
full_name = first_name + ' ' + middle_name + ' ' + last_name
else: # 否则，middle_name没有赋值实参的话，就为空，将执行else代码
full_name = first_name + ' ' + last_name
return full_name.title() # 无论执行哪个表达式，都将其使用返回值储存起来，并用title函数将值开头大写字母输出
musician = get_formatted_name('jimi', 'hendrix') # 当赋值两个实参时，第三个形参因为没有赋值实参，所以执行默认值，为空白
print(musician)
musician = get_formatted_name('john', 'hooker', 'lee')
print(musician)
# 返回字典
# 函数可返回任何类型的值，包括列表和字典等较复杂的数据结构.
def build_person(first_name, last_name):
"""返回一个字典，其中包含有关一个人的信息"""
# 定义字典，将first_name的实参储存在键first相关联的值中，将last_name的实参储存在键last_name相关联的值中
person = {'first': first_name, 'last': last_name}
return person
musician = build_person('jimi', 'hendrix')
print(musician)
# 还可以这样
def build_person(first_name, last_name):
"""返回一个字典，其中包含有关一个人的信息"""
# 定义字典，将first_name的实参储存在person字典中的键，将first_name的实参储存在person字典中的值，与键last_name相关联
person = {last_name: first_name}
return person
musician = build_person('jimi', 'hendrix')
print(musician)
# 还可以添加年龄进去
def build_person(first_name, last_name, age=''):
"""返回一个字典，其中包含有关一个人的信息"""
person = {'first': first_name, 'last': last_name}
if age: # 当age有实参时，将为True,执行缩进代码
person['年龄'] = age # 在字典中添加键值对
return person
musician = build_person('jimi', 'hendrix', age=18)
print(musician)
# 结合使用函数和 while 循环
def get_formatted_name(first_name, last_name): # 定义两个形参
"""返回整洁的姓名"""
full_name = first_name + ' ' + last_name # 将两个形参储存在full_name变量里
return full_name.title() # 将full_name变量的值以大写开头输出，并保存到函数中
# 这是一个无限循环!
while True:
print("\nPlease tell me your name:")
f_name = input("First name: ")
l_name = input("Last name: ")
# 为以防while一直循环下去，定义个退出功能
if f_name and l_name == 'q': # 当f_name和l_name的值为q的时候，将退出循环
break
formatted_name = get_formatted_name(f_name, l_name) # 调用函数，并将f_name和l_name的值存放到实参里面
print("\nHello, " + formatted_name + "!") # 使用print打印出来
# 传递列表
# 你经常会发现，向函数传递列表很有用，这种列表包含的可能是名字、数字或更复杂的对象（如字典）。
# 将列表传递给函数后，函数就能直接访问其内容。下面使用函数来提高处理列表的效率。
def greet_users(names):
"""向列表中的每位用户都发出简单的问候"""
for name in names:
msg = "Hello, " + name.title() + "!"
print(msg)
usernames = ['hannah', 'ty', 'margot'] # 定义一个列表并储存到变量名usernames里面
greet_users(usernames) # 将列表的变量名赋值给greet_users函数的实参，对应着names形参
# 在函数中修改列表
# 将列表传递给函数后，函数就可对其进行修改。
# 在函数中对这个列表所做的任何修改都是永久性的，这让你能够高效地处理大量的数据。
# 首先创建一个列表，其中包含一些要打印的设计
# 在不创建def函数的情况下
unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron'] # 有数据的列表
completed_models = [] # 空列表
while unprinted_designs: # 当unprinted_designs列表有数据的时候，这里就为True，如果没有数据，那就为False
current_design = unprinted_designs.pop() # 提取unprinted_designs列表末尾的值（删除），并存放到变量名current_design当中
print("Printing model: " + current_design) # 插入到语句中
completed_models.append(current_design) # 将current_design变量提取的值，添加到completed_models列表中
# 遍历列表
print("\nThe following models have been printed:")
for completed_model in completed_models:
print(completed_model)
# 为重新组织这些代码，我们可编写两个函数，每个都做一件具体的工作。大部分代码都与原来相同，只是效率更高
# 其意思也是跟上一个一样
def print_models(unprinted_designs, completed_models):
"""
模拟打印每个设计，直到没有未打印的设计为止
打印每个设计后，都将其移到列表completed_models中
"""
while unprinted_designs:
current_design = unprinted_designs.pop()
print("Printing model: " + current_design)
completed_models.append(current_design)
def show_completed_models(completed_models):
"""遍历"""
print("\nThe following models have been printed:")
for completed_model in completed_models:
print(completed_model)
unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron']
completed_models = []
print_models(unprinted_designs, completed_models)
show_completed_models(completed_models)
# 上面的例子告诉你，编写函数时，如果你发现它执行的任务太多，请尝试将这些代码划分到两个函数中
# 传递任意数量的实参
# 有时候，你预先不知道函数需要接受多少个实参，好在Python允许函数从调用语句中收集任意数量的实参
# 任意数量实参是多个一个一个值的(用作元祖、列表等等)，任意数量关键字实参是一对一对的(用作字典中的键值对)
# 函数中用*命名方式接受数据，以元祖(tuple)的形式传参
# 一个简单的任意数量的实参
def make_pizza(*toppings): # 想要任意数量实参，只需要在定义形参的时候，在形参名字前加 * 就可以了
"""打印顾客点的所有配料"""
# print(list(toppings)) #这样输出可以将元祖改成列表
print(toppings) # 输出格式默认是元祖
make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')
# 插入for循环
def make_pizza(*toppings):
print("\nMaking a pizza with the following toppings:")
for topping in toppings:
print("- " + topping)
make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')
# 结合使用位置实参和任意数量实参
# 如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。
# Python先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中.
def make_pizza(size, *toppings): # 定义两个形参，一个位置形参，一个任意数量形参
"""概述要制作的比萨"""
print("\nMaking a " + str(size) +
"-inch pizza with the following toppings:")
for topping in toppings:
print("- " + topping)
# 基于上述函数定义，Python将收到的第一个值(实参)存储在形参 size 中，并将其他的所有值都存储在元组 toppings 中
make_pizza(16, 'pepperoni')
# 任意数量实参是一个一个值的
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese') # 第一个值存放到位置形参，剩下的值存放到任意数量形参
# 使用任意数量的关键字实参
# 任意数量关键字实参是两项(xx = xx)的(用作字典中的键值对)
# 函数中使用**命名方式接收数据，以字典(dict)的形式传参
def build_profile(first, last, **user_info): # 定义任意数量的关键字的形参（**xxx）要以**开头
# 形参**user_info中的两个星号让Python创建一个名为user_info的空字典，并将收到的所有名称 — 值对都封装到这个字典中
"""创建一个字典，其中包含我们知道的有关用户的一切"""
profile = {}
profile['first_name'] = first
profile['last_name'] = last
for key, value in user_info.items(): # 遍历user_info形参，当user_info形参返回了一对关键字实参时，将执行缩进代码
profile[key] = value # 将关键字实参添加到字典中
return profile
# 任意数量关键字实参的值是一对一对的，用在字典中
user_profile = build_profile('albert', 'einstein',
location='princeton',
field='physics')
print(user_profile)
#必选参数
print('必选参数')
def fun(a): #有多少个参数，调用的时候就要有多少个元素
print(a)
fun('A') #有多少个参数，调用的时候就要有多少个元素
#默认参数
print('默认参数')
def fiu(s = 2): #在这里把2赋值给s参数，就叫默认参数
print(s)
fiu() #默认参数可填写元素或可不写元素都行，不填写元素就默认打印s的值，返回2
fiu(3) #s的默认参数元素可被修改，当调用fiu函数的时候，可以赋值就直接修改了s的元素，注：（元素可填写字符串）
fiu('hello,wenge!')
#可变参数，也加不定长参数
print('可变参数，也加不定长参数')
def fqw(*args): #当你的def函数不知道要有多少个参数的时候，可以这样定义，在参数前加个*符号
print(args)
fqw(2) #这样就可以赋值多个元素 ，你会发现，这样返回的是元祖
fqw(3,4) #这样就可以赋值多个元素 ，你会发现，这样返回的是元祖
fqw('hello','haha!') #这样就可以赋值多个元素 ，你会发现，这样返回的是元祖
#关键字参数
print('关键字参数')
def fas(**asdz): #当参数出现**个星的时候，就要用关键字引入了，否则会报错
print(asdz)
fas(name = 'wenge', age = '10000') #你会发现，这样返回的是一个字典，当参数出现**个星的时候，就要用关键字引入了，否则会报错
fas(name = 'wenge', age = '10000',dizhi = '广东') #你会发现，这样返回的是一个字典，当参数出现**个星的时候，就要用关键字引入了，否则会报错
#关键字参数
#下面例子属于关键字参数，使用关键字参数允许函数调用时参数的顺序与声明时不一致
print('关键字参数')
def sdf(xiao,hacker):
print("%s --> %s"%(xiao,hacker))
sdf('让小黑客','改变互联网')
sdf(hacker='改变互联网',xiao='让小黑客') #如果怕元素搞乱顺序，可以这样打印指定的参数匹配元素，把指定参数赋值元素就加关键字参数
#组合参数
#组合参数的顺序必须是：必选参数>默认参数>可变参数>关键字参数
print('组合参数')
def duo(z,x = 8,*c,**v): # z必选参数, x默认参数, c可变参数, v关键字参数
print(z,x,c,v)
duo(1)
duo(1,2)
duo(1,2,3)
duo(1,2,3,4)
duo(1,2,3,(4,5))
duo(1,2,3,[4,5])
duo(1,2,3,{4,5})
duo(1,2,3,4,q=1,w=2)
#变量作用域，全局变量和局部变量
print('变量作用域，全局变量和局部变量')
a = 10 #全局变量
def wen():
a=100
print(a)
def wen():
a=100
wen()
print(a)
def wen():
#使用global等于修改a全局变量
global a #声明a是全局变量，像上面这两个例子，如果不声明的话，将无法使用局部变量，使用了global函数之后，在函数外面调用a的时候，永远都是100了
a=100 #然后再给a赋值，这个就属于局部变量
wen()
print(a)
def wen():
a=100 #把a变量的值修改为100
print(a) #然后再函数里面调用，也属于使用了局部变量
wen() #这里显示了函数里面的局部变量100
print(a) #这里显示了全局变量的10
def hehe(name): #函数定义的过程（比如这里的name）叫形参，形参只是一个形式，表示占据一个参数位置
'函数文档' #def函数里面可以用''来实现函数文档，''里面的内容不会被打印，可以用做标记该函数的作用，相当于注释
print('调用了之后叫'+name) #只有使用了这个参数才叫实参
hehe('实参')
print(hehe.__doc__) #使用__doc__参数可以打印函数文档里面的内容
def sdf(xiao,hacker):
print(xiao + '-->' + hacker)
sdf('让小黑客','改变互联网')
sdf(hacker='改变互联网',xiao='让小黑客') #如果怕元素搞乱顺序，可以这样打印指定的参数匹配元素
def xiao(names='冥狼', hackers='世界!'): #可以给参数指定初始值
print('让' + names + '改变' + hackers)
xiao()
xiao('冥王') #当值给出一个值的时候，将自动匹配给第一个参数
xiao(hackers='互联网') #可以指定跟换参数的值，没提出更换的将自动使用初始值
xiao('冥王','互联网') #重新定义值，更换了初始值
def text(*duobian): #当你的def函数不知道要有多少个参数的时候，可以这样定义，在参数前加个*符号
print('查看参数的值有多少个:', len(duobian)) #元祖序列的坐标是从1开始算
print('查看第二个参数是:', duobian[1]) #调用第二个参数，列表形式的坐标是从0开始算
text('nash','小ck','hehe','haha') #这个属于元祖
#返回值return
def back():
return [1,'小蝎子',132.154]
print(back())
#修改全局变量和局部变量
#在def函数里面的变量叫局部变量，在def外面的叫全局变量
count = 5
def myf():
count = 10
print(count)
myf() #调用def函数的时候，发现count变量的值已经修改了，这个我理解为局部修改变量，因为你调用myf函数的时候，count变量的值才会改变
print(count) #现在再打印一下count，这个就属于打印def函数外面的变量了，所以没有被修改值
#当你想把def外的count变量的值修改，可以使用global关键字
def ddd():
global count
count = 11
print(count)
ddd()
print(count)
#内嵌函数，也就是说在def函数里面再嵌套def函数
def fan1():
print('fan1正在执行...')
def fan2(): #在fan1函数里面再嵌套一个def函数
print('fan2正在执行...')
fan2()
fan1()
#闭包，这个有点复杂
def fanx(x):
def fany(y):
return x * y
return fany
#当使用了return这个关键字，那么调用的时候就要使用print调用函数了
print(fanx(8)(5)) #8赋值给了x，5赋值给了y
print('-'*40)
def ds(x):
return 2 * x + 1
print(ds(5)) #这个就等于2乘5加1
print('-'*40)
print('****************************************************************')
#局部变量和全局变量
"""
局部变量：就是在函数内部定义的变量，只能在函数内部使用
全局变量：就是在函数外部定义的变量(没有定义在某个函数内)，所有的内部函数都可以使用变量
提示：在开发中，大多不推荐使用全局变量，可变范围太大，导致程序不好维护
如果全局变量和局部变量同名，那么在调用函数的时候，就会使用函数里面的变量
"""
#局部变量
def a():
aa = 3 #局部变量
print(aa)
#如果在外部使用函数里面的变量，就会报错
#print(aa)
# a()
#全局变量
aa = 3 #全局变量
def q():
aa = 10 #这里只是定义了一个局部变量，而不会修改到全局变量的值
print(aa)
# print(aa)
# q()
# print(aa) #输出10
# 在函数内部修改全局变量的值，需要使用global关键字
ww = 10
def w():
global ww #使用global告诉解释器，ww 是一个全局变量
ww = 30
print(ww)
w()
print(ww) #这里就会输出30
print('****************************************************************')
#递归函数
#递归函数是指自己调用自己的函数，在函数内部直接调取自己
'''
#注意：这样就会造成死循环，程序会一直执行，然后报错
def test():
print('test')
#在函数里面调用自己的函数
test()
print('*****') #函数执行不到这里
test()
'''
#所以在写递归的时候，要写终止条件
def f(n):
print(n)
if n==0:
print('over...')
else:
f(n-1)
print('f****',n)
f(5)
# 函数指南
# def函数的形参实参排列顺序（位置实参(如xx,xx,xx)-->关键字实参(如xx = xx)-->任意数量实参(如*xx)-->任意数量的关键字实参(**xx)）
# 位置形参和关键字形参，都只接收一个实参，任意数量形参才可以接收多个一个实参(如xx,xx,xx,xx)，任意关键字形参，接收的实参是一对一对的，(如xx = xx)
# 给形参指定默认值时，等号两边不要有空格
print('*********************************************************')
print('*********************************************************')
#将函数存储在模块中
'''
函数的优点之一是，使用它们可将代码块与主程序分离。通过给函数指定描述性名称，可让
主程序容易理解得多。你还可以更进一步，将函数存储在被称为模块的独立文件中，再将模块导
入到主程序中。 import 语句允许在当前运行的程序文件中使用模块中的代码。
通过将函数存储在独立的文件中，可隐藏程序代码的细节，将重点放在程序的高层逻辑上。
这还能让你在众多不同的程序中重用函数。将函数存储在独立文件中后，可与其他程序员共享这
些文件而不是整个程序。知道如何导入函数还能让你使用其他程序员编写的函数库。
'''
#导入整个模块
#创建一个名pizza.py的文件，写入代码并保存起来
def make_pizza(size, *toppings):
"""概述要制作的比萨"""
print("\nMaking a " + str(size) +
"-inch pizza with the following toppings:")
for topping in toppings:
print("- " + topping)
#然后再打开另文件
import pizza #导入模块，写模块的文件名
pizza.make_pizza(16, 'pepperoni') #模块的文件名.文件里面的函数名(给予实参)
pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
#使用 as 给函数指定别名
#如果要导入的函数的名称可能与程序中现有的名称冲突，或者函数的名称太长，
#可指定简短而独一无二的别名——函数的另一个名称，类似于外号。
#要给函数指定这种特殊外号，需要在导入它时这样做。
#创建一个名pizza.py的文件，写入代码并保存起来
def make_pizza(size, *toppings):
"""概述要制作的比萨"""
print("\nMaking a " + str(size) +
"-inch pizza with the following toppings:")
for topping in toppings:
print("- " + topping)
#然后再打开另文件
from pizza import make_pizza as mp #意思是从pizza文件中导入make_pizza模块，假如文件名过长，可使用as将文件名改为mp，这个改名只是在当前文件中有效
mp.make_pizza(16, 'pepperoni') #模块的文件名.文件里面的函数名(给予实参)
mp.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
#导入模块中的所有函数
#使用星号（ * ）运算符可让Python导入模块中的所有函数：
from pizza import *
make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
print('****************************************************************')
# 函数高级语法
print('****************************************************************')
# 匿名函数
#lambda匿名函数，他的作用就是省去了def定义函数那么麻烦
g = lambda x : 2 * x + 1
#这语句解释就是，直接用lambda代替函数名，lambda后面紧跟着就是参数（x是参数），然后 ： 后面的就是相当于return关键字，直接写返回值
print(g(5))
print('-'*40)
#匿名函数多个参数
g = lambda x,y : x + y
print(g(2,3))
#lambda匿名函数，只允许包含一个表达式，不能包含复杂语句
# 语法书写 变量名=lambda 形参 ：return返回值
f = lambda a,b,c:a+b+c
print(f)
print(f(2,3,4))
def f(a,b,c):
"""这个函数等价于上面那个匿名函数"""
return a*b*c
#包含多个函数
x = [lambda q:q*2,lambda w:w*2,lambda e:e*2]
#输出的时候，因为x是一个列表，所以写实参的时候写上列表的下标，代表赋值实参给哪个函数
print(x[0](3),x[1](5),x[2](6)) # 输出 6 10 12
print('****************************************************************')
# map()函数
'''
map函数是python内置高阶函数，会根据提供的函数对指定序列做映射，
第一个参数function是个函数对序列中每个元素都调用function函数返回值的新序列
格式：map(function，iterable，。。。)
参数说明：
function：是个函数，通过函数依次作用在序列中的每个元素中。
iterable：一个或多个序列，也被称为可迭代对象。
函数有多少个参数，map就要写多少个实参
'''
def xx(x):
return x * x
result = map(xx,[1,2,3])
print(list(result)) # 输出 [1, 4, 9]
# map函数接收了一个函数xx和一个list，并通过把函数xx依次作用在list的每个元素中
# 得到一个新的list并返回。map的返回值是一个循环对象，可利用list函数，将该循环转换成列表
# 在匿名函数中运用mao函数
aa = map((lambda x : x * x),[2,3,4])
print(list(aa)) # 输出 [4, 9, 16]
# 输出的结果其实将序列里面的每一个元素，循环用在函数里面，然后通过返回值输出回来
# 两个参数
aa = map((lambda x,y:x+y),[1,2,3],[4,5,6])
print(list(aa)) # 输出 [5, 7, 9]
# 得出的结论是：函数有多少个参数，map就要有多少个实参
print('****************************************************************')
# reduce()函数
'''
reduce函数会对参数序列中的元素进行累计，reduce将一个数据集合(列表，元祖等)
中的国有数据进行下列操作，格式：reduce(function，iterable)
参数说明：
function：接收函数，必须带有两个参数的函数
iterable：一个或多个序列，也可以成为可迭代对象
reduce函数在python3中不能直接使用，需要调用functools包
'''
from functools import reduce
def xx(x,y):
return x+y
e = [1,2,3,4]
aa = reduce(xx,e)
print(aa) # 输出 10
'''
执行流程：
因为返回值只有两个参数，所以先
xx(1,2) = 3
xx(3,3) = 6
xx(6,4) = 10
序列中没有更多元素了，就返回结果
'''
扫一扫
3万+
评论
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
查看更多评论
添加红包
