一、Python中函数的定义
函数的定义：是指将一组可重复使用的、用来实现某一关联功能的语句（代码段）通过一个名字（函数名）封装起来，在想要执行这个函数时，只需要通过“函数名”直接调用即可。函数的特点：功能强大、调用方便及灵活高效。
二、Python中函数的语法
1.关键字：“ def ” 是关键字。是用来识别是否为一个函数，不可缺少。
2.函数名：“square” 是函数名。可自定义，不要使用“关键字”或“内建函数”同名。
3.参数：“x,y” 是参数（形参），“12,20”是参数（实参）。形参不是必须的，可以不填，但是（）不能省略。
4.方法：“s = x*y” 是函数方法。组织好的函数语句，默认缩进1个tab键（等同4个空格）。
5.返回值：“return” 是返回值。return后面可以没有返回值，甚至return语句也可省略，默认返回值为None。
# 1)函数的语法：
def square(x,y): # 声明一个函数（方法）
s = x * y # 函数语句（方法）
print(s) # 注意：输出语句放在函数里面！
# 没有return
square(12,20) # 调用函数（方法）
>>240
# 2)函数的语法：
def square(x,y): # 声明一个函数（方法）
s = x * y # 函数语句（方法）
# 函数内部无输出语句。
return s # 返回变量
b = square(12,20) # 调用函数（方法），并通过变量 "b" 去接收返回值 "s"
print(b) # 输出语句放在外面，打印的值是接收变量的值。
>>240
三、参数类型解析
Python函数中的参数：实参（1种）【关键字参数】+形参（4种）【必须参数；可变参数；默认值参数；可变关键字参数】。
1.关键字参数："param1" ,在实参中定义。将实参的赋值指定给予某形参，可以不用记住传参的顺序。
2.必须参数："param2" ,在形参中定义。对应于形参，有多少个形参就给出多少实参。在实参中传"param1",函数在调用时，可将它用于函数方法的运算。
3.可变参数："*args" ,在形参中定义。形参中直接传"*args",函数在调用时，实参可以传递任意个参数。
4.默认值参数："param3" , 在形参中定义。给函数的形参赋予默认值。
5.可变关键字参数："**kwargs" ,在形参中定义。形参中传"**kwargs",函数在调用时，实参可以传递任意个关键字参数。
# 示例语法展示：
def square(param2,*args,param3=0,**kwargs):
pass
return
# square(param2,param1=8)
# 1)关键字函数（在实参中定义）
def fruit(apple,lemon):
print("苹果的数量为："+ str(apple))
print("柠檬的数量为：" + str(lemon))
fruit(2,lemon=12) #lemon=12“关键字参数”可以不用记住参数的顺序
>>苹果的数量为：2
>>柠檬的数量为：12
# 2）必须参数：
# 不建议定义过多必须函数；如需要，可将多个必须参数封装成一个对象，把对象传入到函数中。
# 需求：创建一个函数，录入苹果、柠檬两种水果数量，并打印详情
def detail(apple, lemon):
print("苹果的数量为：" + str(apple))
print("柠檬的数量为：" + str(lemon))
detail(4, 5)
# >>苹果的数量为：4
# >>柠檬的数量为：5
# 3)可变参数：
# 需求：创建一个函数，用户可传入任意值，并返回任意值相加后的值
def add_all(*args):
summ = 0
for i in args:
summ = summ + i
print(summ)
return summ
# add_all(1, 2, 3, 4) # 可传入任意个参数
a = (1, 2, 3, 4) # 如果传入的是一个序列，可使用*将每个元素平埔出来，传递到可变参数的函数里面。
add_all(*a)
>>1
>>3
>>6
>>10
# 4)默认值参数:
def fruit(apple=1, lemon=2): # 在形参中定义，设置默认值。
print("苹果的数量为：" + str(apple))
print("柠檬的数量为：" + str(lemon))
fruit()
# fruit(lemon=5) # 可使用关键字参数对默认值参数赋值，改变默认值参数的定义
>>苹果的数量为：1
>>柠檬的数量为：2
# 5)可变关键字参数 ：
def fruit(**kwargs):
print("水果的数量为：" + str(kwargs))
# print(type(kwargs)) # kwargs的类型为字典
# fruit(lemon=5, apple=10) # 可传递任意个关键字参数，这些关键字参数在函数调用的时候会自动组装成一个dict。
fruits = {"lemon": 5, "apple": 10}
fruit(**fruits) # 如果传的是一个字典，用 "**" 将字典中的键值对平铺出来。
>>水果的数量为：{'lemon': 5, 'apple': 10}
# 补充内容：函数中形参的传参顺序【1.必须参数-2.可变参数-3.默认值参数-4.可变关键字参数】
def fruit(apple_num,*args,banana_num=5,lemon_num=4,**kwargs):
print("苹果的数量为："+ str(apple_num))
print("柠檬的数量为：" + str(lemon_num))
print("香蕉的数量为：" + str(banana_num))
print("数量为：" + str(args))
print("水果的数量为：" + str(kwargs))
numm=(3,5,4)
fruits={"苹果":3,"柠檬":4,"香蕉":5}
fruit(10,*numm,**fruits)
>>苹果的数量为：10
>>柠檬的数量为：4
>>香蕉的数量为：5
>>数量为：(3, 5, 4)
>>水果的数量为：{'苹果': 3, '柠檬': 4, '香蕉': 5}
四、内建函数
Python自带的函数【print()、len()、help()等】，也就是说这是python的类库帮我们已经写好的函数，只需要我们直接使用就可以了。
# 内建函数-del 的用法：
a = [1, 2, 3] # 对象[1, 2, 3]被 a 引用
b = a # 对象 a 被 b 引用
c = b # 对象 b 被 c 引用
print(a)
del a # 删除变量a，解除a对[1, 2, 3]的引用
del b # 删除变量b，解除b对[1, 2, 3]的引用
# print(a)
# print(b) # 会报错,NameError: name 'b' is not defined
print(c) # 最终变量c仍然引用1
>>[1, 2, 3]
>>[1, 2, 3]
# 内建函数-3个常见输出函数【print()、eval（)、input()】
print("你是谁！")
a = eval（"20+20") # eval（)函数去掉字符串最外侧的引号，并按照python语句方式执行去掉引号后的字符串内容。
print(a)
input("我在哪？") # 阻塞式输出。
>>你是谁！
>>40
>>我在哪？_
五、匿名函数
匿名函数：就是没有名字的函数。Python中使用 lambda 来创建匿名函数。lambda 函数的语法只包含一个语句【 lambda [arg1 [,arg2,...argn]] : expression 】。
sum = lambda arg1, arg2: arg1 + arg2
demo = sum(20, 40)
# print("相加后的值是：", sum(10, 20))
print("相加后的值是：", demo)
>>相加后的值是： 30
>>相加后的值是： 60
六、自定义函数
用户自己创建的函数被叫做自定义函数。
def summ(x, y, z):
s = x + y + z
print(s)
return s
summ(3, 4, 5)
>>12
七、递归函数
# 定义：在函数内部可以调用其他函数，如果调用的是本身，这个函数就是递归函数
# 特性：
# 1、必须要有明确的结束条件
# 2、每次更深一层递归时，问题模块相比上一次递归减少
# 3、递归效率不高，递归层次过多会导致栈溢出
def calc(n):
print(n)
if int(n/2) >0:
return calc(int(n/2))
print('...',n)
calc(10)
>>10
>>5
>>2
>>1
>>... 1
八、函数的过滤、映射与聚合
#函数的数据处理：过滤、映射与聚合
#三个基础函数：filter()、map()和reduce()
# 语法：filter(function,iterable) function是一个函数，参数iterable是可迭代对象；
#filter()函数调用时iterable会被遍历，它的元素被逐一传入function函数，function函数返回布尔值。
#在function函数中编写过滤条件，如果为True的元素被保留，如果为False的元素被过滤掉。
# 示例1：
# users=["Tony","Tom","Ben","Alex"]
# users_filter=filter(lambda u:u.startswith("T"),users) #如果字符串以指定的值开头，则 startswith() 方法返回 True，否则返回 False。
# print(users_filter)
# print(list(users_filter))
# 语法：map(function,iterable) function是一个函数，参数iterable是可迭代对象；
#示例2：
# users=["Tony","Tom","Ben","Alex"]
# users_map=map(lambda u:u.lower(),users)
# print(list(users_map))
#聚合操作会将多个数据聚合起来输出单个数据，聚合操作中最基础的是归纳函数reduce(),
#reduce()函数会将多个数据按照指定的算法积累叠加起来，最后输出一个数据。
# 语法：reduce(function,iterable[,initializer]) function是一个函数，参数iterable是可迭代对象,参数initializer是初始值；
#示例2：（实现对一个数列的求和运算）
from functools import reduce
a=(1,2,3,4)
a_reduce=reduce(lambda acc,i:acc+i,a)
print(a_reduce)
