python进阶day10

python进阶之路

Day10

hello world！今日是python学习的第十天，我将会在下面文章对基础语法进行一些介绍，主要为函数的进阶学习、实参高阶函数与列表推导式等。

1 函数就是变量

1.1 函数就是变量

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

def a():
 print('函数1')

b = [1,2,3]

1) 查看变量类型

print(type(b))
print(type(a))

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

print(b)
print(a)

b2 = b
print(b2[1])
a2 = a
a2()

3) 修改变量的值

a = 'abc'

c = lambda x : x\*2
"""
def c(x):
    return x\*2
"""

4) 变量可以作为列表元素

x = 100

def y():
    return 'abc'

list1 = [x,y,y()]
print(list1)
print(list1[0] * 2,list1[0] % 10)
print(list1[2][0] * 2,list1[2].replace('a','A'))
print(list1[1]())

list1 = []
for i in range(5):
    list1.append(lambda x : x * i)
print(list1[2](2)) # 返回值是2 * i,循环后i的值为4

2 实参高阶函数

from functools import reduce # 用reduce时，需要导入

def func1(x):
    print(f'x:{x}')

a = 100

​ 普通变量作为函数

func1(a)

def b():
    return 'abc'

func1(b)
func1(b())

2.1实参高阶函数

​ 如果一个函数的参数是函数，那么这个函数就是实参高阶函数

1) 怎么确定调用函数的时候参数传什么值

​ 看这个参数在函数中支持什么数据

def func2(x):
    print(x + 10)


func2(20)
func2(1.34)
func2(True)


def func4(x):
    x.append(100)


func4([1,2,3])

​ func5就是一个实参高阶函数

def func5(x):
    print(x(100)) #-> print(1000#)

def test(a):
    return a*10


func5(test)

2.2 实参高阶函数的应用

​ 除了写装饰器以外，一般不会自己去定义实参高阶函数，主要使用系统定义好的实参高阶函数
​ 系统中常用的实参高阶函数：max、min、sorted、reduce、map

1) max、min

​ max(序列)\min(序列) - 获取指定序列中元素的最大值\最小值

​ max（序列，key）\min(序列，key) - 参数key类型就是一个函数；
​ key的要求： a.是一个函数 b.函数有且只有一个参数，并且这个函数指向的是序列中的每一个元素。
​ c.函数需要一个返回值，这个返回值就是比较大小的时候的比较对象。

nums = [12,34,56,75,95]
print(max(nums))

print(max(nums,key = lambda item: item % 10))


def test(item):
    sum1 = 0
    for x in str(item):
        sum1 += int(x)
    return sum1
print(max(nums,key = test))
list1 = ['as','qw','fd','sdas']
print(max(list1))
print(max(list1, key = lambda item:len(item)))

​ 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

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

print(yt_max([10,30,52,6,98]))
print(yt_max([10,30,52,6,92],key = lambda item: item % 10))

问题二：求students中分数最高的学生

students = [
    {'name':'小明','score':90,'age':23},
    {'name':'张三','score':89,'age':28},
    {'name':'隔壁老王','score':78,'age':45}
]
print(max(students, key = lambda item: item['score']))

求年龄最小的学生

print(min(students, key = lambda item: item['age']))

2) sorted

​ sorted(序列) - 将序列按照元素的大小进行排序，返回排序后的列表。
​ sorted(序列，key） - key: a. 函数 b. 有且只有一个参数（参数就是序列中的元素）
​ c. 有一个返回值（用于比较大小）

nums = [78,69,52,61,45,21]
print(sorted(nums))

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

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

​ 按照分数对学生进行从大到小排序

print(sorted(students,reverse = True, key = lambda item: item['score']))

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)

new_nums1 = list(map(lambda item: item / 100,nums))
print(new_nums1)

​ 示例：使用map创建一个新的列表，元素是nums中元素的100倍

nums = [0.23,0.35,0.67,0.91,0.25,0.45]
new_nums2 = list(map(lambda item: item * 100,nums))
print(new_nums2)

[‘23.00%’，‘45.00%’，‘89.00%’，‘12.00%’，‘65.00%’]
print(list(map(lambda item: f'{item:.2%}' ,nums)))

strs = ['axc','how','you','love']
nums = [1,20,4,60]
new_list = list(map(lambda x,y:x+str(y),strs,nums))
print(new_list)

prices = [67,256,302,89]
discount = [1,0.8,0.75,0.95]
new_prices = list(map(lambda x,y: x * y,prices,discount))
print(new_prices)

4) reduce

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

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

​ 合并成一个字符串

result1 = reduce(lambda x,y: str(x) + str(y),nums)
print(result1)

students = [
    {'name':'小明','score':90,'age':23},
    {'name':'张三','score':89,'age':28},
    {'name':'隔壁老王','score':78,'age':45}
]
result2 = reduce(lambda x,y: x['score'] + y['score'],nums)
print(result2)
reduce(函数，序列，默认值)
result2 = reduce(lambda x,y: x + y['score'],students,0)
print(result2)

3 列表推导式

3.1 什么是列表推导式 - 用来快速创建列表

​ 方法一：
​ 列表 = [ 表达式 for 变量 in 序列] - 产生一个新的列表，变量在序列中每取一个元素就将表达式的值添加入新的列表中。

​ 方法二：
​ 列表 = [表达式 for 变量 in 序列 if 条件语句]

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

list1 = [10 for x in range(5)]
print(list1)
list2 = [x * 2 for x in range(1,5)]
print(list2)
list3 = [f'{x:0>3}' for x in range(10,15)]#限制长度与填充符号
print(list3)
list4 = [x for x in range(10) if x % 2]
print(list4)

nums = [23,89,67,56,10,33]
list5 = [x % 10 for x in nums ]
print(list5)

list6 = [f'{x}:{y}' for x in range(1,5) for y in range(10,14)]
print(list6)

3.2 字典的推导式

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

dict2 = {'a':1, 'b':2, 'c':3}
dict3 = {value:key for key,value in dict2.items() if type(value) not in (dict,list,set)}
print(dict3)

num = 8
if num != 3 and num != 8:
    print('不是38')

if num not in (3,8):
    print('不是38')