函数 function

格式：

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

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

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

为什么使用函数

# 为什么使用函数
# 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: 返回替换完成的字符串
    """
    # res = msg[:index] + char + msg[index+1:]
    # return res
    # 对给定的char进行判断   isinstance(char,type) 判断两个变量是否属于某种类型
    if isinstance(char, int):
        char = str(char)
    return msg[:index] + char + msg[index + 1:]

# res = set_str('1234567', 2, '9')
set_str('abcdefg', 1, 9)   # Ctrl+q 可以查看函数文档
# res = set_str('abcdefg', 1, 9)

# print(res)

函数的形参和实参

形式参数、实际调动的参数
区别：

• 形参是虚拟的，不占内存空间，形参变量只有在被调用的时候才分配内存空间
• 实参是一个变量，占用内存空间

数据是单向传送的，实参传给形参
示例：

# 求矩形面积
def area(width,length):
    return width*length
    pass
w = 4
l = 6
print(area(width=4, length=6))
print(area(4, 6))

函数参数

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

def f(name,age):
    print('我叫%s,我今年%d岁' % (name, age))
f('zhangsan', 18)
f(18,'zhangsan') # 错误的

2. 关键字参数: 关键字参数允许函数调用时参数的顺序与声明不一致，因为Python解释器能够用参数名匹配参数值

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

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

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. 不定长参数 : 有时候可能需要一个函数能处理比当初声明时更多的参数，这些参数叫不定长参数
语法如下:

# 语法如下
# def funcname([formal args,]*args,**kwargs):  #[]里的表示可写可不写
#     """文档字符串"""
#     pass
# 加了星号（*）的变量args会存放所有未命名的变量参数，args为元组
# 加了星星号（**）的变量kwargs会存放命名参数，即形如key=value形式的参数，kwargs为字典

示例：

# 不定长参数
# 有时候可能需要一个函数能处理比当初声明时更多的参数，这些参数叫不定长参数
# 语法如下
# 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
"""
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'}

函数的返回值

• 如果想要获取函数的执行结果，我们一般要编写函数的返回值，使用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

高阶函数

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

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

匿名函数（lambda表达式）

不需要显示指定名字的函数
格式

函数名 = lambda 参数1， 参数2， ... : 返回表达式

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

# def mul(x, y):
#     return x*y
# mul2 = lambda x,y : x*y
# print(mul2(3, 4))
# 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

Python系统高阶函数

• map()

map(func,iterable)该函数使用函数作为自己的一个参数，它可以将iterable（可迭代对象）中的数据依次传递给func函数处理，最后把处理的结果最为新的可迭代对象返回
举例：[1, 2, 3, 4, 5] -> [1, 4, 9, 16, 25]

# 举例：[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']

• 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
......
最后返回最后一次处理结果
示例：

# 实例2
# 把序列[1, 3, 5, 7, 9]变成整数 13579
def fn(x, y):
    return x*10+y
print(reduce(fn, [1, 3, 5, 7, 9]))  # 13579

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

# 写出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

# 编写 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

• 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]

• 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))