一、函数 function

def 函数名():
    # 函数实现
    pass  # pass 空语句

1、函数执行的顺序，调用的时候才会被执行

def say_hello():
    print('hello')
# 调用函数
say_hello()

2、为什么使用函数

# 7个长度的字符串，替换第三个字符
str1 = 'abcdefg'
str1 = str1[:2] + 'z' + str1[3:]
print(str1)
#abzdefg
str1 = '1234567'
str1 = str1[:2] + '8' + str1[3:]
print(str1)
#1284567

将其改进封装成函数

# 改进封装成函数
def set_str(msg,index,char):
    """
    将目标字符串的指定位置进行替换
    :param msg: 目标字符串
    :param index: 替换字符串的索引位置
    :param char: 要替换的字符
    :return: 返回替换完成的字符串
    """
    res = msg[:index] + char + msg[index+1:]
    return res
res = set_str('1234567', 2, '9')#1294567

 # 对给定的char进行判断   isinstance(char,type) 判断两个变量是否属于某种类型
    if isinstance(char, int):
        char = str(char)
    return msg[:index] + char + msg[index + 1:]
# set_str('abcdefg', 1, 9)   # Ctrl+q 可以查看函数文档
res = set_str('abcdefg', 1, 9)
print(res)#a9cdefg

3、函数的返回值

如果想要获取函数的执行结果，我们一般要编写函数的返回值，使用return可以把结果返回

return 作用: return停止这个函数的执行，返回指定的结果

Python中的return可以返回多个对象， 解释器会将其组装成一个元组作为一个整体结果输出

如果未指定return，那么这个函数的返回值是 None

• 给定一个list 将列表中所有数字进行累加，并且返回他们的累加和以及平均数

def sum_and_ave(list):
    """
    :param list: 给定一个list
    :return: 返回他们的累加和以及平均数
    """
    count = 0
    sum = 0
    for x in list:
        if isinstance(x, int) or isinstance(x, float):
            # 进行累加
            sum += x
            # 计数
            count += 1
    ave = sum/count
    return sum, ave
li = [20, 15, 2.8, 'a', 35, 5.9, -1.8]
print(sum_and_ave(li))  # (76.9, 12.816666666666668)
print('累加和', sum_and_ave(li)[0])  # 累加和 76.9
print('平均数', sum_and_ave(li)[1])  # 平均数 12.816666666666668

4、函数的形参和实参

1、形式参数、实际调动的参数
2、区别：
形参是虚拟的，不占内存空间，形参变量只有在被调用的时候才分配内存空间
实参是一个变量，占用内存空间
3、数据是单向传送的，实参传给形参

• 求矩形面积

def area(width,length):
    return width*length
    pass
w = 4
l = 6
print(area(width=4, length=6))#24
print(area(4, 6))#24

4.1、函数参数

# 必须参数：以正确的顺序传入函数，调用的时候必须和声明的时候保持一致
def f(name,age):
    print('我叫%s,我今年%d岁' % (name, age))
f('zhangsan', 18)
f(18,'zhangsan') # 错误的
# 关键字参数， 关键字参数允许函数调用时参数的顺序与声明不一致，因为Python解释器能够用参数名匹配参数值
f(age=19, name='李四')

4.2默认参数（缺省参数）

# 在调用函数时，缺省的参数如果没有被传入，则会使用默认值
def f(name,age,sex='male'):
    print('我叫%s,我今年%d岁' % (name, age))
    print('性别%s'%(sex))
f(age=19, name='李四') # 我叫李四,我今年19岁  性别male
f(age=19, name='李四',sex='female')  # 我叫李四,我今年19岁   性别female

4.3不定长参数

有时候可能需要一个函数能处理比当初声明时更多的参数，这些参数叫不定长参数

• 语法如下

def funcname([formal args,]*args,**kwargs):  #[]里的表示可写可不写
    """文档字符串"""
    pass

加了星号（*）的变量args会存放所有未命名的变量参数，args为元组
加了星星号( ** )的变量kwargs会存放命名参数，即形如key=value形式的参数，kwargs为字典

# demo
def func(a,b,*args,**kwargs):
    """
   可变参数演示示例
    :param a: formal args
    :param b: formal args
    :param args: 未命名的变量参数  args为元组
    :param kwargs: 命名参数  kwargs为字典
    :return: 无
    """
    print('a=', a)
    print('b=', b)
    print('args=', args)
    for k, v in kwargs.items():
        print(k, '--->', v)
func(1, 2, 3, 4, 5, m=6, n=7, p=8)
#"""
#a= 1
#b= 2
#args= (3, 4, 5)
#m ---> 6
#n ---> 7
#p ---> 8
#"""
c = (3, 4, 5)
d = {'m': 6, 'n': 7, 'p': 8}
func(1, 2, *c, **d)
# """
# a= 1
# b= 2
# args= (3, 4, 5)
# m ---> 6
# n ---> 7
# p ---> 8
# """
c = (3, 4, 5)
d = {'m': 6, 'n': 7, 'p': 8}
func(1, 2, c, d)  # 注意不加星号的传入方式
# """
# a= 1
# b= 2
# args= ((3, 4, 5), {'m': 6, 'n': 7, 'p': 8})
# """

def f(*args):
    print(args)

f(*[1,2,5])  # (1, 2, 5)

def f1(**kargs):
    print(kargs)

f1(**{'name':'alex'})  # {'name': 'alex'}

5、高阶函数

满足——输入：接受一个或多个函数，输出：一个函数

def add(x, y, f):
    return f(x) + f(y)
# 传入的是函数名
res = add(3, -6, abs)  # abs 绝对值
print(res)#9
def method():
    x = 2
    def double(n):
        return n*x
    return double
d = method()
res2 = d(10)
print(res2)#20

6、Python系统高阶函数

插入知识——匿名函数（lambda表达式）：不需要显示指定名字的函数

格式——函数名 = lambda 参数1， 参数2， ... : 返回表达式
lambda 的参数可以是无限个，但是返回表达式只能有一个
优点：1. 不用担心函数名冲突 2. 减少代码量 3. 优雅
主要目的是联合其他函数使用

1、
#普通函数
def mul(x, y):
    return x*y
print(mul(3, 4))#12
#lanmbda表达式
mul2 = lambda x,y : x*y
print(mul2(3, 4))#12
2、
# x,y  如果 x>y 返回x*y else x<y x/y
def cheng_chu(x, y):
    if x > y:
        return x*y
    else:
        return x/y
print(cheng_chu(2, 5))  # 0.4
print(cheng_chu(5, 2))  # 10

# 回顾三目运算符
store = ['*']
print(len(store))  # 1
if len(store) == 0:
    store = '当当自营'
else:
    store = store[0]
print(store)#*
# 改成三目运算符
print('当当自营' if len(store) == 0 else store[0])#*
# 满足条件时返回的值 if 满足的条件 else 不满足条件时返回的值

# 将x,y  如果 x>y 返回x*y else x<=y x/y需求使用lambda表达式进行编写
res = lambda x, y: x*y if x > y else x / y
print(res(2, 5))  # 0.4
print(res(5, 2))  # 10

6.1、map()

map(func,iterable) 该函数使用函数作为自己的一个参数，
它可以将iterable（可迭代对象）中的数据依次传递给func函数处理，
最后把处理的结果最为新的可迭代对象返回

• 举例：[1, 2, 3, 4, 5] -> [1, 4, 9, 16, 25]

def power(x):
    return x*x
result = map(power, [1, 2, 3, 4, 5])
print(list(result))  # [1, 4, 9, 16, 25]

• 使用map函数：[1, 2, 3, 4, 5, 6, 7, 8, 9] -> ['1', '2', '3', '4', '5', '6', '7', '8', '9']

res2 = map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(res2))  # ['1', '2', '3', '4', '5', '6', '7', '8', '9']

6.2、reduce()

reduce(func,sequence) 函数，累积操作。
func函数必须接收两个参数，reduce会把func的运行结果做一个参数，
然后从sequence中依次取出一个数据当做另一个参数

from functools import reduce
def mul(x, y):
    return x*y
li = [1, 2, 3, 4, 5]
res = reduce(mul, li)
print(res)  # 120
# 使用lambda表达式改写 lambda主要目的是联合其他函数使用
print(reduce(lambda x, y: x * y, li))  # 120

• reduce函数的具体运行

第一次运算时从迭代对象中取出两个参数 1x2=2
第二次运算时将第一次运行的结果2作为第一个参数传入，再取出一个数 3作为第二个参数传入 2x3=6
同理 6x4=24
......
最后返回最后一次处理结果

• 实例

1、把序列[1, 3, 5, 7, 9]变成整数 13579

def fn(x, y):
    return x*10+y
print(reduce(fn, [1, 3, 5, 7, 9]))  # 13579
# lambda表达式
print(reduce(lambda x, y: x * 10 + y, [1, 3, 5, 7, 9]))  # 13579

2、写出str 转化为int 的函数

# 编写函数 fn 进行累加移位
def fn(x, y):
    return x*10+y
# 编写一个函数 将 char 转化成num  map函数中的映射模式
def char2num(s):
    digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
    return digits[s]
# '13579'----->13579
# 使用map和reduce函数结合编写  str 转化为int 的函数
print(reduce(fn, map(char2num, '13579')))  # 13579

3、编写 str2int函数

digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
def str2int(s):
    def fn(x, y):
        return x * 10 + y
    def char2num(c):
        return digits[c]
    return reduce(fn, map(char2num, s))
# str2int('13579') ---> 13579
print(str2int('12345'))  # 12345

# 写成lambda表达式的形式
digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
def str2int(s):
    return reduce(lambda x, y: x*10+y, map(lambda c: digits[c], s))
print(str2int('12345'))  # 12345

6.3、filter()

filter(function,iterable) 根据函数func来过滤iterable,将iterable中的数据传入function中，
如果函数返回True，则保留该数据，否则就不保留

li = [i for i in range(1, 15)]
# 将li 中所有的奇数筛选出来
print(list(filter(lambda x: x % 2 == 1, li)))  # [1, 3, 5, 7, 9, 11, 13]

6.4、sorted()

对数据进行排序，并且返回一个新的对象，原对象不变，
key参数可以用来指定排序的规则，key接受的值是一个函数
reverse参数是指定排序的顺序（升序还是降序），默认是升序

from random import randint
li2 = [randint(-10, 10) for _ in range(5)]
li2 = [-9, 1, 7, 7, 10]
print('排序前', li2)  # 排序前 [7, -9, 10, 0, 2]
res = li2.sort()
print('排序后', li2)  # 排序后 [-9, 0, 2, 7, 10]
print('返回值', res)  # 返回值 None
res = sorted(li2)
print('排序后', li2)  # 排序后 [-10, -8, 5, 7, 9]
print('返回值', res)  # 返回值 [-10, -8, 5, 7, 9]
res = sorted(li2, key = abs)
print(res) # [1, 7, 7, -9, 10]

chars = ['lee', 'james', 'kobe', 'Antetokounmpo', 'jordan']
# 对chars进行排序，按照字母的长度 降序
chars = sorted(chars, key=lambda x: len(x), reverse=True)
print(chars)

# 复合列表结构的列表排序
grade_list = [
    {'name': '张三', 'grade': 90},
    {'name': '李四', 'grade': 30},
    {'name': '王五', 'grade': 70},
    {'name': '赵六', 'grade': 52}
]
print(grade_list)
# 按照成绩进行排序
grade_list = sorted(grade_list, key=lambda d: d['grade'])
print(grade_list)

stu_info = [
    ('wunan', 22), ('yangjiulin', 39), ('hanlei', 17), ('chenzhenqi', 90)
]
# 按照年龄降序排序
print(sorted(stu_info, key=lambda x: x[1], reverse=True))