一、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)