1.函数 function

格式：

1 def 函数名（参数列表）：
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:返回替换完成的字符串
    """
    if isinstance(char, int):
        char = str(char)
    return msg[:index] + char + msg[index + 1:]
res = set_str('abcdefghigklmn', 1, 4)
print(res)

1.1函数的形参和实参

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

举例：求矩形面积

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

1.2 函数的参数

1.2.1 必须参数：

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

def f(name,age):
    print('我叫%s,我今年%d岁'% (name,age))
f('张珊',18)#我叫张珊,我今年18岁
#f(18,'张珊')#错误的
#关键字参数，关键字参数允许函数调用时参数的顺序与声明不一致，因为python解释器能够用参数名匹配数据
f(age=19, name='张珊')#我叫张珊,我今年19岁

1.2.2 默认参数（缺省参数）

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

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

1.2.3 不定长参数

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

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

举例1：

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)
    print('kwargs = ')
    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)
kwargs =
m ----> 6
n ----> 7
p ----> 8
"""

举例2：

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)
    print('kwargs = ')
    for k, v in kwargs.items():
        print(k, '---->', v)
c = (3, 4, 5)
d = {'m': 6, 'n': 7, 'p': 8}
#func(1, 2, *c, **d)
func(1,2,c,d)#注意不加星号传入
'''
a= 1
b =  2
args =  ((3, 4, 5), {'m': 6, 'n': 7, 'p': 8})
'''

1.3 函数的返回值

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

• return 作用： return停止这个函数的执行，返回指定的结果
  python中的return可以返回多个结果,解释器会将其组装成一个元组作为一个整体结果输出
  如果未指定return ，那么这个函数的返回值是None值

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

def sum_and_ave(list):
    '''

    :param list: 给定一个list
    :return: 返回他们的累加和以及平均数
    '''
    sum = 0
    count = 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))
print('累加和', sum_and_ave(li)[0])
print('平均数', sum_and_ave(li)[1])
'''
(76.9, 12.816666666666668)
累加和 76.9
平均数 12.816666666666668
'''

1.4 高阶函数

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

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)

1.5系统高阶函数

1.5.1 map

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

举例：

def power(x):
    return x*x
res = map(power, [1, 2, 3, 4, 5])
print(list(res))#[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.5.2 reduce()

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

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

举例1：

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

举例2：把序列[1, 3, 5, 7, 9] 变成13579

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

举例3：
(1)写出 str 转化为 int 的函数
(2)编写程序 fn 进行累加移位
(3)编写一个函数将char 转化成num
(4)'13579'---->13579
(5)使用map 和reduce函数结合编写str 转化成int 的函数

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

    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]
    return reduce(fn, map(char2num, s))

print(str2int('3463213141'))

• 采用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('164252451542'))

1.5.3 filter()

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

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

1.5.4 sorted()

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

举例1：

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

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

举例2：复合列表的

grade_list = [
    {'name': '张三', 'grade': '90'},
    {'name': '李四', 'grade': '30'},
    {'name': '王五', 'grade': '70'},
    {'name': '马六', 'grade': '52'},
]
#按照成绩排序
grade_list = sorted(grade_list,key=lambda d: d['grade'])
print(grade_list)

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

1.6 匿名函数（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))
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,6))
print(cheng_chu(9, 3))

1.6.1 回顾三目运算符

三目运算格式：满足条件时返回的值 if 满足的条件 else 不满足条件时返回的值

store = []
if len(store) == 0:
    store = '当当自营'
else:
    store = store[0]
print(store)
#改成三目运算
print('当当自营' if len(store) == 0 else store[0])

举例2：x , y 如果x>y 返回x*y else x<y 返回x/y

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