[Python知识库]day12函数进阶

day12函数进阶（9.29）

1.review

"""
def 函数名（形参列表）：
    函数说明文档
    函数体
"""
# 1.返回值（产生新的数据返回）
"""
return 数据1，数据2，。。。（形成的元组，省略括号）
函数名（数据1，数据2，数据3，。。。）
函数名（实参列表） - 调用函数（函数调用表达式）

函数调用表达式的值就是函数的返回值
"""
def func1():
    return 100, 12

result = func1()
print(result)   # (100, 12)

x, y = func1()
print(x, y)  # 100 12
# 3.函数调用过程
"""
1.回到函数定义的位置，传参（用实参给形参赋值）
2.执行函数体
3.确定函数返回值（执行函数体的时候如果遇到return，return后面的值就是函数返回值，否则返回值是None）（没有return是None）
4.回到函数调用的位置接着往后执行（这个时候函数调用表达式的值就是函数的返回值）
"""
def func2(x, y):
     # x=10, y=20
    print('++++')
    print('----')
    return x*10 + y

result = func2(10, 23)
# 4，return的作用
# 1）确定函数返回值
# 2）提前结束函数

# 5.函数的参数
# 1）位置参数和关键字参数
func2(10, 20)
func2(x=10, y=201)
func2(y=201, x=10)
func2(10, y=10)

# 2)参数默认值
def func3(x=10, y=20, z=30):
    pass
def func3(x, y=20, z=30):
    pass
# 3)参数类型说明，返回值类型说明(便于代码提示)
def func4(x:str, y = 10, z='')->float:
    pass

# 4)不定长参数
"""
*参数名 - 本质是元组；必须是位置参数
**参数名 - 本质是字典；必须是关键字参数

"""
def func5(x, y, *,m,n):#*后面是关键字传参，前面可以是任意传参
    pass

2、day11函数基础作业更改版

# 写一个函数，实现maketrans的功能，将两个字符串转换成一个字典，第一个字符串中的字符是键，第二个字符串中的字符是值
# 第一个字符串： 'abcmn'   第二个字符串：'一二三四五'
# 结果：{'a': '一', 'b': '二', 'c': '三', 'm': '四', 'n': '五'}
# 'abcdf' '123' -> {'a':'1','b':'2','c':'3'}
# 'abc' '12356' -> {'a':'1','b':'2','c':'3'} 键值对由短的对应，对应用下标对应
def maketrans(key_str:str, value_str:str):
    """
    将两个字符串转换成字典
    :param key_str: 提供键的字符串
    :param value_str: 提供值的字符串
    :return:
    """
    len1 = len(key_str)
    len2 = len(value_str)
    result = {}
    for index in range(min(len1, len2)): # **用小的下标进行遍历(不够熟练)
        result[key_str[index]]=value_str[index] # **通过键给到对应的值(不够熟练)
    return result
print(maketrans('abc', '1234'))
print(maketrans('abcdef', '1234'))
s1 = {}
s1[2] = 1
print(s1)

# 2.写一个属于自己的join函数，可以将任意序列中的元素以指定的字符串连接成一个新的字符串
def join(str1:str, seq): #seq序列
    new_str = ''
    for x in seq:
        new_str += str(x)+str1
    return new_str[:-len(str1)]  # 100++abc++12.3++True++集合不能切片，所以在最后面对字符串进行切片
print(join('++',[100,'abc',12.3,True]))
# 3.写一个输入自己的upper函数，判断指定字符串是否是纯大写字母字符串（出现多次）
def upper(str1:str):
    for x in str1:
        if not 'A'<= x <='Z':
            return False
    return True
print(upper('ABZNCMS-AAA'))
# 4.写一个clear函数，清空指定列表。（应该从后面开始遍历删除，就不用产生一个新的列表）
# 注意：功能是将原列表清空，不产生新的列表
def clear(list1:list):
    #方法一
    # for x in list1[:]: # 注意remove清不干净，需要【:】
    #     list1.remove(x)
    # 方法二
    len1 = len(list1)
    for _ in range(len1):# _在后面内容不需要，所以用下划线_命名
        del list1[0]
nums = [12, 32, 14, 10]
clear(nums)
print(nums) # []
# 5.写一个reverse函数，将列表中的元素逆序
# 两种方法：1.产生一个新的列表   2.不产生新的列表，直接修改原列表元素的顺序
# 方法一
def reverse(list1:list):
    return list1[::-1]
nums = [23, 19, 20, 90]
result = reverse(nums)
print(nums,result)

#方法二
def reverse(list1:list):
    len1 = len(list1)
    for index1 in range(len1//2): # **
        index2 = len1 - index1 -1
        list1[index1],list1[index2] = list1[index2],list1[index1]


nums = [23, 19, 20, 90] # [90,20,19,23] 4个：0->3,1->2 5个：0->4,1->3
nums = [23, 19, 20, 90]
result = reverse(nums) # 返回值为 None
print(nums,result)
# 交换变量
# a = 10
# b = 20
# a, b = b, a
# print(a,b)

3、匿名函数

1.*匿名函数 - 没有名字的函数
“”"
匿名函数的本质还是函数，但是匿名函数只能实现一句代码就能实现的功能
语法：
函数名 = lambda 参数列表:返回值(返回值有结果的表达式)（类型说明不支持）

说明：
lambda - 关键字；固定写法
参数列表 - 普通函数写在（）普通函数中的形参列表
: - 固定写法
返回值 - 相当于普通函数的return后面的值

注意：匿名函数需要先保持才能再调用

函数名（变量） = lambda 参数列表:返回值
相当于
def 函数名(参数列表)：
return 返回值
“”"

sum1 = lambda x,y:x+y
result = sum1(10, 20)
print(result) # 30 匿名函数和普通函数的定义不一样，调用时一样，其他是一一的

result = sum1(y=200, x=100)
print(result)  # 300
# def sum1(x, y):
#     return x+y
#
#
# print('======')
sum1 = lambda x,y=2:x+y
result = sum1(10)
print(result) # 12
# *练习：写一个匿名函数，判断指定整数是否是偶数
is_even = lambda num: num % 2 ==0 # 返回值是有结果的表达式
print(is_even(1))

list1 = [10, lambda x:x*3]
list1[-1](10)
print(list1[-1](10))  # 30

dict1 = {'a':1 , 'b':lambda x:x*3}
print(dict1['b'](12) + 100) # 136 # 函数也是特殊的数据，可以调用它

func1 = lambda *x: 100
func1(10)
func1(12, 23)

4、变量作用域

1.变量作用域 - 变量可以使用的范围
“”"
根据变量作用域的不同，可以将变量分为：全局变量和局部变量

“”"
2.全局变量
“”"
没有定义在函数或者类里面的变量就是全局变量;
全局变量的作用域：从定义开始到程序结束（从定义开始到文件结束的任何位置都可以使用）
“”"

# a是全局变量
a = 100
# x,b也是全局变量：没有定义在函数或者类里面的变量就是全局变量
for x in range(3):
    b = 10
print(f'函数外a：{a},x:{x},b:{b}')  # 函数外a：100,x:2,b:10
def func1():
    print(f'函数外a：{a},x:{x},b:{b}')
func1()  # 函数外a：100,x:2,b:10

3.局部变量
“”"
局部变量就是定义在函数里面的变量（形参也是局部变量）；
局部变量的作用域：从定义开始到函数结束
“”"

print('--------局部变量------------')
# m和n是局部变量


def func2(m):
    # m =100
    n = 10
    print(f'函数里面m:{m},n:{n}')


func2(100)  # 函数里面m:100,n:10
# print(f'函数里面m:{m},n:{n}')

4.全局变量和局部变量的底层逻辑
“”"
全局变量是保存在全局的栈区间中，全局栈区间是在程序运行结束的时候才会被释放。
当程序调用函数的时候，系统会自动给这个函数创建一个独立的栈区间，专门用来保存在函数中产生的数据（局部变量就是保存在这个内存区间中）
，当函数调用结束这个栈区间会自动释放。
“”"

5.global和nonlocal
“”"
python调试工具：https://pythontutor.com/visualize.html#mode=edit
1）global
应用1：在函数内部修改全局变量的值使用global 变量名（放在变量修改的前面）
应用2：在函数内部定义一个全局变量

注意：使用global的时候必须保证在函数里面global修饰的变量不会出现在它的前面。
“”"

xx = 1000
yy = 1000

def func3():
    # 在函数里面不能直接修改全局变量的值，而是定义一个新的局部变量
    xx = 2000
    print(f'函数内部xx:{xx}')
    # 应用1：在函数内部修改全局变量的值使用global 变量名（放在变量修改的前面）
    global yy #先声明yy变量再修改全局变量
    yy = 2000
    print(f'函数内部yy:{yy}')
    # 应用2：函数内部局部变量定义成全局变量
    global num
    num = 100
    print(f'函数内部num:{num}')
func3()

print(f'函数外部xx:{xx}')
print(f'函数外部yy:{yy}')
print(f'函数外部num:{num}')

# （了解）nonlocal - 在局部的局部修改一个局部变量的值
def func4():
    k = 100
    def func5():
        # nonlocal局部的局部修改局部变量的值
        nonlocal k
        k = 200
        print(f'func5k:{k}')
    func5()
    print(f'func4中k:{k}')

func4()

5、高阶函数（重要）

**1.函数就是变量（函数名就是变量名）
“”"
python中定义函数其实就是定义一个类型是function的变量，函数名就是变量名.
变量能做的事情，函数都能做。
“”"
函数名= lambda 参数列表：返回值
def 函数名（参数列表）：
return 返回值

a = lambda x:x*22
print(type(a))  # <class 'function'>

a = 100
print(type(a)) # <class 'int'>

def a(x):
    return x*2
print(type(a)) # <class 'function'>

场景一：可以通过使用变量来使用变量中保存的数据，如果这个数据的函数，函数的通用操作是调用它。

x = 100
print(x % 2)
x = 'abc'
print(x[-1])
#举例说明列表，字典
x = [1, 2, 3, 4]
x.append(12)
x = {12, }


x = lambda m:m+100
print(x(7))

def x(m):
    return m+100
x(7)
print(x) # <function x at 0x000001C18E156280>

场景二：用一个变量给另外一个变量赋值

m = 100
n = m
print(n * 100)
def mm():
    print('这是一个函数')
nn = mm # (函数名就是变量)
nn()

场景三：修改变量的值

m = 100
print(m % 10)
m = [10, 21]
print(m[-1])


def mm():
    print('-----')
mm()
mm = 100 # 不能进行调用，只能作为整数来进行使用
print(mm % 10) # 0
# **
a = 100
def b():
    print('我是另外一个函数')
list1 = [a, 200, b] # b是函数，只能调用
list1[-1]() # 我是另外一个函数。执行函数体的时候运行的。
print('x:',list1[-1]()) # x: None
list1 = [a, 200, b()] # b()看返回值，是空，函数调用是函数返回值.(调用函数获取函数返回值)
print(list1) # [100, 200, None]

2.高阶函数
“”"
1)变量可以作为函数的实参
实参高阶函数 - 如果一个函数的参数是函数，那么这个函数就是一个实参高阶函数
2)函数可以作为函数的返回值
返回值高阶函数 - 如果一个函数的返回值是函数，那么这个函数就是一个返回值高阶函数
“”"

# func2就是实参高阶函数
def func2(x):
    x()+10
# func3就是返回值高阶函数
def func3(x):
    def t():
        pass
    return t
func3(10)() # t()-->None
# def t():有问题
#     return 12.9
# func2(t)

# def func2(str1:str):
#     print(str1[-1])
#
# name = '张三'
# func2(name)
#
# def func2(xx):
#     print(xx)
#
# name = '张三'
# func2(name)
#
# def func3():
#     pass
#
# func2(func3)
# func2(func3())
def func2(x):
    x * 1.2 # 数字
    x() # 只能传函数，函数调用的东西
    x[-1] #字典，列表
    x['a'] #字典
    x()#调用函数
func2()

6、实参高阶函数（重要）

1.max,min,sorted
“”"

1. max(序列，key=函数) - 根据函数提供的方式来获取序列中元素的最大值
   函数的要求：1)有且只有一个参数，这个参数指向的是序列中的每个元素
   2)需要一个返回值，返回值是比较对象

“”"

nums = [28, 52, 61, 70, 84, 9]
print(max(nums))

# def f(item):
#     return item
f = lambda item: item
print(max(nums, key=f)) # 84 （既可以用普通函数，也可以用匿名函数，一句话可以搞定的时候用匿名函数）
print(max(nums, key=lambda item:item)) # 84

# 练习1：获取nums中个位数最大的元素
# [28, 52, 61, 70, 84, 39]  -> 39
# [8,2,1,0,4,9]
nums = [28, 52, 61, 70, 84, 39]
print(max(nums, key=lambda item:item%10)) #39 #item原本的数据每个数据，item%10最后比较的值

# 练习2：获取年龄最大的学生
students = [
    {'name': 'stu1', 'age': 28, 'score': 90},
    {'name': 'stu2', 'age': 20, 'score': 99},
    {'name': 'stu3', 'age': 18, 'score': 88},
    {'name': 'stu4', 'age': 32, 'score': 92}
]
# [28,20,18,32] # {'name': 'stu4', 'age': 32, 'score': 92}
print(max(students, key=lambda item:item['age'])) # item是每个字典，item['age']比较字典里面的年龄
# ***练习3：获取nums中各个位数的和最大的元素
# [123, 78, 90, 301, 49]   ->  [6, 15, 9, 4, 13]  -> 78
nums = [123, 78, 90, 301, 49]
# print(max(nums, key=lambda item:(item % 10)+(item // 10 % 10)+(item // 100 % 10))) # 78
nums = [123, 78, 90, 301, 49]

def t(item):
    sum1 = 0
    for x in str(item):
        sum1 += int(x)
    return sum1
print(max(nums,key=t)) # 78
print(max(nums,key = lambda item:sum([int(x) for x in str(item)]))) # 78 推导式，sum

# 练习4：获取分数最大的学生
students = [
    {'name': 'stu1', 'age': 28, 'score': 90},
    {'name': 'stu2', 'age': 20, 'score': 99},
    {'name': 'stu3', 'age': 18, 'score': 88},
    {'name': 'stu4', 'age': 32, 'score': 92}
]
print(max(students,key= lambda item:item['score'])) #{'name': 'stu2', 'age': 20, 'score': 99}
print(min(students,key= lambda item:item['score']))

# 练习：将nums中元素按照个位数的大小从小到大排序
nums = [28, 52, 61, 70, 84, 39]
print(sorted(nums,key=lambda item:item % 10)) # [70, 61, 52, 84, 28, 39]

# 练习：将下面列表中的元素按照数值大小从大到小排序
nums = [23, '100', 56, '12.7', '100.2']
# ['100.2', '100', 56, 23, '12.7']
print(sorted(nums, key=lambda item: float(item),reverse=True)) # '100.2', '100', 56, 23, '12.7']
# 位置参数，关键字参数

2.map
“”"
1）map(函数，序列) - 将序列中的元素按照函数提供的方式进行变换
函数的要求：1.有且只有一个参数，指向序列中的每个元素
2.需要一个返回值，返回值就是新序列中的元素（描述清楚新序列的元素和原序列元素的关系）
相当于（推导式） [返回值 for 参数 in 序列]
2）map(函数，序列1，序列2)
函数的要求：1.有且只有两个参数，分别指向两个序列中的元素
2.需要一个返回值，返回值就是新序列中的元素
3）map(函数，序列1，序列2，序列3，序列4，…)
“”"

nums = [28, 52, 61, 70, 84, 39]
# [8,2,1,0,4,9]
result = list(map(lambda item:item % 10, nums))#map得到的是序列，需要进行转换
print(result) # [8, 2, 1, 0, 4, 9]
# 练习：
# A =[10,20,30,40] B= ['a','b','c','m']
# 新列表 = ['a10','b20','c30','m40']
A =[10,20,30,40]
B= ['a','b','c','m']
result = list(map(lambda i1,i2:i2+str(i1),A,B)) #注意转换成列表，A，B元素对应 # 注意转换是括号（）list()
print(result) # ['a10', 'b20', 'c30', 'm40']

# 练习：
# names = ['张三', '小明', '李四', '小花']
# scores = [90, 89, 99, 70]
# 结束: [{'name': '张三', 'score': 90}, {'name': '小明', 'score': 89},....]
names = ['张三', '小明', '李四', '小花']
scores = [90, 89, 99, 70]
result = list(map(lambda value1, value2:{'names':value1,'score':value2},names,scores))
print(result)  # [{'names': '张三', 'score': 90}, {'names': '小明', 'score': 89}, {'names': '李四', 'score': 99}, {'names': '小花', 'score': 70}]

3.reduce(合并) - 将一个序列中的元素按照指定的规则合并成一个数据
“”"
reduce(函数，序列，初始值) - 用指定的初始值来将序列中的元素按照函数指定的规则合并成一个数据。
函数的要求：1）有且只有两个参数：第一个参数指向初始值；第二个参数指向序列中的每个元素；
2）需要一个返回值：描述清楚最后合并的结果是初始值和序列中的元素通过什么样的方式合并产生的。
“”"

from functools import reduce
nums = [10, 20, 30]
# 初始值+10+20+30->60
result = reduce(lambda x,y:x+y,nums,0) # x初始值+序列中的元素，初始值和序列中的元素得到的结果
print(result) # 60

# 初始值*10*20*30 ->6000
# result = reduce(x,nums,1) #->x(函数)，nums(序列)，1（初始值）
result = reduce(lambda x,y:x*y,nums,1) # x是初始值，y是序列中的各个元素
print(result) # 6000

# ->'102030'->'10'+'20'+'30'->str(10)+str(20)+str(30)
# 初始值+str(10)+str(20)+str(30)=='102030'
result = reduce(lambda x,y:x+str(y),nums,'')
print(result,type(result)) # 102030 <class 'str'>

nums = [10, 20, 30]
# ->'123' -> str(1)+str(2)+str(3)
# 初始值+str(10//10%10)+str(20//10%10)+str(30//10%10) 多位数取十位数
# 先确定初始值result = reduce(x,nums,''),再看函数x表达式的书写，初始值+后面的依次的元素
result = reduce(lambda x,y:x+str(y//10%10),nums,'') # 123
print(result)
# 1+2+3 ->6
result = reduce(lambda x,y:x+(y//10%10),nums,0)
print(result) # 6