函数进阶

函数就是变量

定义函数的时候，其实就是在定义一个类型时function的变量，函数名就是变量名
普通变量能做的事情，函数都可以做

print('===================1.函数就是变量======================')
def a():
print('函数1')
b= [1,2,3]

1）查看变量类型

print(type(a))   # <class 'function'>
print(type(b))   #<class 'list'>

2)使用变量中保存的数据

print(b)     #[1, 2, 3]
print(a)     #<function a at 0x000001D811053DC8>

b2=b
print(b2[1])    # 2
a2=a
a2()            # 函数1（相当于是函数a（））

3) 修改变量的值

a='abc'
print(a)    #此处a不在是函数的地址

4) 变量可以作为函数的参数

x=100
def y():
return 'abc'
list1=[x,y,y()]
print(list1)    #[100, <function y at 0x000001F9EBD84F78>, 'abc']

面试题:求print的打印值（函数在定义时,并没有被调用）

list1=[]
for i in range(5):
list1.append(lambda  x: x*i)
"""
执行for循环时，lambda函数表达式没有被调用执行，
所以遍历完成之后，i=4，list列表中的值都为
lambda x：x*4
list1[1]=lambda x：x*4
list1[1](2)相当于调用lambda表达式，并且给它传的参数为x=2
list1[2](2)也是一样
"""
print(list1[1](2))     #8
print(list1[2](2))     #8

实参高阶函数

1 实参高阶函数

如果一个函数的中有参数的值是函数，那么这种函数就是实参高阶函数
1）怎么确定调用函数的时候怎样传参
看这个参数在函数中怎么使用的

2.实参高阶函数的应用

除了写装饰器以外,一般不会自己去定义实参高阶函数,主要是使用系统已经定义好的实参高阶函数
系统中常用的实参高阶函数:max\min\sorted\reduce\map
1)max\min
max\min(序列) - 获取指定序列中元素的最大值或者最小值
max(序列,key)\min(序列,key) - 参数key的类型是函数,
key的要求:
a. 是一个函数
b. 有且只有一个参数,并且这个参数指向的是序列中的每一个元素
c. 需要一个返回值,这个返回值就是比较大小的时候的比较对象

nums = [12, 232, 343, 2, 12, 9]
print(max(nums))

问题一:求nums中个位数最大的元素

print(max(nums, key=lambda item: item))  # 比较元素本身的大小    343
print(max(nums, key=lambda item: item % 10))    # 比较元素个位数的大小     9

问题二:求nums中每位数字和的最大元素

def test(item): #取列表中的元素已经封装在了max函数中,所以此处没有取元素的过程,item直接就是元素
sum1 = 0
for x in str(item):
sum1 += int(x)
print('sum1:', sum1)
return sum1

print(max(nums, key=test))

问题三:求字符串例表中最长的字符串

list1 = ['abc', 'klysdfdf', 'hdda', 'dsfsd']
print(max(list1, key=lambda item: len(item)))   #klysdfdf

问题四:求students中分数最高的学生

stus = [{'name': '小明', 'score': 90, 'age': 23},
{'name': '张三', 'score': 95, 'age': 22},
{'name': '老王', 'score': 60, 'age': 35}
]
print(max(stus, key=lambda item: item["score"]).get('name'))
print(min(stus, key=lambda item: item["age"]))

max的实现原理

def yt_max(seq, key=None):
list1 = list(seq)
temp = list1[0]
if not key:
for x in list1:
if x > temp:
temp = x
else:
for x in list1:
if key(x) > key(temp):
temp = x
return temp

2)sorted
sorted(序列) - 将序列按照序列元素的大小进行排序,返回时排序后的列表
sorted(序列,key) - key的要求:
**a:**函数
**b:**有且只有一个参数(参数就是序列中的元素)
**c:**有一个返回值(比较大小的比较对象)
按照元素大小进行排序

nums = [78, 69, 57, 28, 71, 54]
print(sorted(nums))  # [28, 54, 57, 69, 71, 78]

按照个位数的大小,从小到大排序

print(sorted(nums, key=lambda item: item % 10))
nums.sort(key=lambda item: item % 10)

print(nums)

将stus中按照分数数值从大到小排序

stus = [{'name': '小明', 'score': 90, 'age': 23},
{'name': '张三', 'score': 95, 'age': 22},
{'name': '老王', 'score': 60, 'age': 35}
]
print(sorted(stus, key=lambda item: item['score']))  #从小到大
print(sorted(stus, key=lambda item: item['score'], reverse=True))   #从大到小

3)map
用法一:
map(函数,序列) - 将序列按照函数给定的规则,创建成一个新的序列
函数要求:
a. 是一个函数
b. 有一个参数(指向序列中的每个元素)
c. 一个返回值(产生新元素的规则)
用法二:
map(函数,序列1,序列2) - 将序列按照函数给定的规则,创建成一个新的序列
函数的要求:
a. 是一个函数
b. 有两个参数,第一个参数指向第一个序列中的元素,第二个参数指向第二个序列中的元素
c. 一个返回值(产生新元素的规则)
注意:两个序列中元素的个数一致

nums = [23, 35, 67, 91, 25, 45]
new_nums = list(map(lambda item: item % 10, nums))
print(new_nums)    #[3, 5, 7, 1, 5, 5]

nums = [0.23, 0.45, 0.89, 0.12]
new_nums = list(map(lambda item: f'{item:.2%}', nums))
print(new_nums)  # ['23.00%', '45.00%', '89.00%', '12.00%']

strs = ['abc', 'how', 'you', 'love']
nums = [1, 20, 4, 60]
new_List = list(map(lambda x, y: x + str(y), strs, nums))
print(new_List)      # ['abc1', 'how20', 'you4', 'love60']

price = [67, 256, 304, 89]  # 商品原价
discount = [1, 0.8, 0.75, 0.95]  # 折扣
discount_price = list(map(lambda x, y: x * y, price, discount))
print(discount_price)      # [67, 204.8, 228.0, 84.55]

4)reduce
reduce(函数,序列) - 将序列中所有的元素按照函数规定的操作进行合并
使用此函数需要引入模块：from functools import reduce

函数的要求:
a. 函数
b. 有两个参数(第一个参数第一次指向的时序列的第一个元素,从第二次开始指向的时上次运算的结果,第二个参数指向的时序列第二个开始的每个元素)
reduce(函数,序列,初始值) - 将序列中所有的元素按照函数规定的操作进行合并
函数的要求:
a. 函数
b. 有两个参数(第一个参数第一次是初始值,从第二次开始指向的时上次运算的结果，第二个参数指向的是序列序列的每个元素)
求和

nums = [12, 34, 45, 67, 89, 23]
result = reduce(lambda x, y: x + y, nums)
print(result)    #270

合并成一个字符串

result = reduce(lambda x, y: str(x) + str(y), nums)
print(result)       #123445678923

求所有分数和:reduce(函数,序列,默认值)

stus = [{'name': '小明', 'score': 90, 'age': 23},
{'name': '张三', 'score': 95, 'age': 22},
{'name': '老王', 'score': 60, 'age': 35}
]

result = reduce(lambda x, y: x + y['score'], stus, 0)
print(result)
result = reduce(lambda x, y: x + y['age'], stus, 0)
print(result)

列表推导式

1.什么式列表推导式 - 用来快速创建列表

方法1:
列表 = [表达式 for 变量 in 序列] - 产生一个新列表,变量在序列中每取一个元素,就将表达式的值添加到新列表

方法2:
列表 = [表达式 for 变量 in 序列 if 条件语句]

方法3:
列表 = [表达式 for 变量1 in 系列1 for 变量2 in 序列2]
列表 = [表达式 for 变量1 in 系列1 for 变量2 in 序列2 if 条件语句]

list1 = [10 for x in range(5)]
print(list1)    #[10, 10, 10, 10, 10]

list2 = [x * 2 for x in range(1, 5)]
print(list2)     #[2, 4, 6, 8]

list3 = [f'{x:0>3}' for x in range(10, 15)]
print(list3)    #['010', '011', '012', '013', '014']

list4 = [x for x in range(10) if x % 2]
print(list4)    #[1, 3, 5, 7, 9]

list5 = ['str' + str(x) for x in [10, 34, 15, 11, 78, 99] if x % 2]
print(list5)      #['str15', 'str11', 'str99']

nums = [20, 38, 26]  # 取出个位数
list6 = [x % 10 for x in nums]
print(list6)    #[0, 8, 6]

list7 = [f'{x}:{y}' for x in range(1, 5) for y in range(10, 14)]
print(list7)  #['1:10', '1:11', '1:12', '1:13', '2:10', '2:11', '2:12', '2:13', '3:10', '3:11', '3:12', '3:13', '4:10', '4:11', '4:12', '4:13']

list8 = [f'{x}:{y}' for x in range(1, 5) for y in range(10, 14) if x % 2 and y % 2 == 0]
print(list8)   #['1:10', '1:12', '3:10', '3:12']

2.字典推导式

字典 = {key:value for 变量 in 序列}
字典 = {key:value for 变量 in 序列 if 条件语句}

dict1 = {x: x * 2 for x in range(5)}
print(dict1)

dict2 = {1: 2, 3: 4, 5: 6,7:[12,25]}
dict3 = {value: key for key, value in dict2.items() if type(value) not in (dict,list,set)}
print(dict3)