一、函数 function

1.函数格式

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

• 例子：

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

2.为什么使用函数

7个长度的字符串，替换第三个字符

• 不使用函数实现：

str1 = 'abcdefg'
str1 = str1[:2] + 'z' + str1[3:]
print(str1)

str1 = '1234567'
str1 = str1[:2] + '8' + str1[3:]
print(str1)

• 改进封装成函数，任意长度字符串：

def set_str(msg,index,char):
    """
    将目标字符串的指定位置进行替换
    :param msg: 目标字符串
    :param index: 替换字符串的索引位置
    :param char: 要替换的字符
    :return: 返回替换完成的字符串
    """
    #对给定的char进行判定  isinstance(char,type)判断char是否属于type类型
    if isinstance(char,int):
        char = str(char)
    return msg[:index] + char + msg[index+1:]

res1 = set_str('1234567',2,'9')
res2 = set_str('abcdefgddd',1,9)
print(res1)
print(res2)

3.函数的形参和实参

• 形参`：形式参数
• 实参`：实际调用参数
• 区别：形参是虚拟的，不占用内存空间，形参变量只有在被调用的时候才分配内存空间；实参是一个变量，占用内存空间
• 数据是单向传送的 实参传给形参
• 例子：求矩形面积

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

4.函数参数

1.必须参数：

以正确的顺序传入参数，调用的时候必须和声明的时候保持一致

• 例子：

def f(name,age):
    print('我叫%s,我今年%d岁'%(name,age))
f('张三',18) #正确
f(18,'李四') #错误

2.关键字参数

允许函数调用时参数的顺序与声明不一致，因为python解释器能够用参数名匹配参数值

• 例子：

f(age=18,name='李四')

3.默认参数（缺省参数）

在调用函数时，缺省的参数如果没有被传入，则会使用默认值

• 例子

def f(name,age,sex='male'):
    print('我叫%s,我今年%d岁'%(name,age))
    print('性别%s'%(sex))
f(age=19,name='李四')
f(age=19,name='李四',sex='female')

4.不定长参数

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

def funcname([formal_args,]*args,**kwargs):
    """文档字符串"""
    pass
#加了星号（*）的变量args会存放所有未命名的变量参数，args为元祖
#加了星星号（**）的变量kwargs会存放命名参数，即形如 ket=value形式的参数，kwargs为字典

#demo
def func(a,b,*args,**kwargs):
    print('a=',a)
    print('b=',b)
    print('args=',args)
    print('kwargs=')
    for k, v in kwargs.items():
        print(k,'----->',v)

func(1,2,3,4,5,m=6,n=7,p=8)
c = (3,4,5)
b = {'m':6,'n':7,'p':8}
func(1,2,*c,**b)
func(1,2,c,b) #注意不加星号的传入方式

5.函数的返回值

• 如果想要获取函数的执行结果，我们一般要编写函数的返回值，使用return可以把结果返回
• return 作用： return停止这个函数的执行，返回指定的结果
• python中的return可以返回多个对象，解释器会将其组装成一个元祖作为一个整体结果输出
• 如果未指定return，那么这个函数的返回值是None
• 例子：
  给定一个list 将列表中所有数字进行累加，并且返回他们的累加和以及平均数

def sum_and_ave(list):
    """

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

二、高阶函数

• 高阶函数满足 ：
  输入：接受一个或多个函数
  输出：一个函数
• 例子1：

def add(x,y,f):
    return f(x) + f(y)
#传入的是函数名
res = add(3,-6,abs)  #abs()是求绝对值的函数
print(res)  #输出结果为9

• 例子2：

def method():
    x = 2
    def double(n):
        return n*x
    return double
d = method()
res2 = d(10)
print(res2)

三、匿名函数

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

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

def mul(x,y):
     return x*y

 mul2 = lambda x,y:x*y
 print(mul2(3,4))

• 回顾三目运算符

普通方式：

store = ['吴楠家的书店']
print(len(store))
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表达式进行编写：

f1 = lambda x,y:x*y if x>y else x/y
print(f1(2,5))
print(f1(5,2))

四、系统高阶函数

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, 2, 3, 4, 5, 6, 7, 8, 9] --> ['1', '2', '3', '4', '5', '6', '7', '8', '9']

def func1(x):
    return str(x)
result = map(func1,[1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(result))

2.reduce()

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

• reduce()函数的导入：
  from functools import reduce
• 举例：

def mul(x,y):
    return x*y
li = [1,2,3,4,5]
res = reduce(mul,li)
print(res)

使用lambda表达式改写：

print(reduce(lambda x, y: x * y, li))

• reduce()函数的具体运行：
  第一次运算时从迭代对象中取出两个参数 1 x 2 = 2
  第二次运算运算时将第一次运行的结果 2 作为第一个参数传入，再取出一个数 3 作为第二个参数 2 x 3 = 6
  同理 6 x 4 = 24
  .....
  最后返回最后一次处理结果
• 举例2：把序列[1,3,5,7,9] 变成整数13579

使用函数形式实现：

def fn(x,y):
    return x*10 + y

print(reduce(fn, [1, 3, 5, 7, 9])) 

使用lambda表达式实现：

print(reduce(lambda x,y:x*10+y,[1,3,5,7,9]))

• 实际应用：写出str 转化为int的函数
  hint：
  1.编写函数fn进行累加移动位置
  2.编写一个函数将char转化成num map函数中的映射模式
  {'0':0,'1':1}
  3.'13579' ------> 13579
  4.使用map和reduce函数结合编写

def fn(x,y):
    return x*10 + y
def fn2(x):
    digits = {'0': 0, '1': 1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}
    return digits[x]

print(map(fn2,'13579'))
print(reduce(fn, map(fn2, '13579')))

• 将上述功能封装为一个str2int函数：

def str2int(s):
    from functools import reduce
    digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
    def fn(x, y):
        return x * 10 + y

    def fn2(x):
        return digits[x]

    return reduce(fn, map(fn2, s))

print(str2int('13579'))

写成lambda表达式的形式：

def str2int(s):
    from functools import reduce
    digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
    return reduce(lambda x,y:x*10+y, map(lambda x:digits[x], s))

print(str2int('13579'))

3.filter()

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

• 举例：将li中所有的奇数筛选出来（li = [i for i in range(1,15)]）

li = [i for i in range(1,15)]
print(list(filter(lambda x: x % 2 == 1, li)))

4.sorted()

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

• 举例：

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

res = sorted(li2,key=abs)
print(res)

• 举例2：对chars进行排序 按照字母的长度 降序 （chars = ['lee','james','kobe','Antetokounpo','jordan']）

chars = ['lee','james','kobe','Antetokounpo','jordan']
chars = sorted(chars,key=len,reverse=True)
print(chars)
chars = sorted(chars,key=lambda x:len(x),reverse=True) #使用lambda表达式实现
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),('yanjiulin',39),('hanlei',17),('chenzhenqi',90)
]
print(stu_info)
#按照年龄降序排序
stu_info = sorted(stu_info,key=lambda x:x[1],reverse=True)
print(stu_info)