三元表达式、列表推导式、字典生成式、生成器、匿名函数

目录

• 一、三元表达式
• 二、列表推导式
• 三、字典生成式
• 四、生成器
  • 4.1 生成器：
  • 4.2 yield关键字
  • 4.3 yield的三个特性
  • 4.4 用生成器自定制一个range方法
  • 4.5 生成器表达式
• 五、匿名函数
  • 5.1 什么是匿名函数
  • 5.2 与内置函数联用

一、三元表达式

x=10
y=20
if x>y:
    print(x)
else:
    print(y)
# 三元表达式为：
print(f"x if x>y else y:{x if x>y else y}")   #  x if x>y else y:20

二、列表推导式

lt=[]
for i in range(10):
    lt.append(i)
print(lt)
# 列表推导式为：
print(f"[i for i in range(10)]: {[i for i in range(10)]}")

三、字典生成式

# 字典生成式为：
print({i: i**2 for i in range(10)})
#  {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

zip()方法：

dic = {'a': 1, 'b': 2}

new_dic = {k * 2: v ** 2 for k, v in dic.items()}
print(new_dic)

# 字典生成式一般与zip(拉链函数--》列表里面包了元组)连用
z = zip(['a', 'b', 'c', 'd'], [1, 2, 3, 4])  # 压缩方法，Python解释器的内置方法
# for k,v in z:
#     print(k,v)
dic = {k: v ** 2 for k, v in zip(['a', 'b', 'c', 'd'], [1, 2, 3, 4])}  # 不能写这种代码
print(dic)

通过解压缩函数生成一个字典

info_dict = {'name': 'nick', 'age': 19, 'gender': 'male'}
print(f"info_dict.keys(): {info_dict.keys()}")
print(f"info_dict.values(): {info_dict.values()}")

res = zip(info_dict.keys(), info_dict.values())
print(F"zip(keys,values): {zip(info_dict.keys(),info_dict.values())}")

info_dict = {k: v for k, v in res}
print(f"info_dict: {info_dict}")

info_dict.keys(): dict_keys(['name', 'age', 'gender'])
info_dict.values(): dict_values(['nick', 19, 'male'])
zip(keys,values): <zip object at 0x1105cefc8>
info_dict: {'name': 'nick', 'age': 19, 'gender': 'male'}

四、生成器

4.1 生成器：

自定义迭代器， 生成器就是迭代器（自己造出来的）

4.2 yield关键字

在函数中但凡出现yield关键字，再调用函数，就不会继续执行函数体代码，而是会返回一个值。

4.3 yield的三个特性

1、yield可以把函数变成生成器（自定制的迭代器对象，具有__iter__和__next__方法）

2、yield可以经常停止函数，在下一次next再次运行yield下面的代码

3、有n个yield生成器就有n个元素，就可以next n次，第n+1次next会报错

 def func():
 	 yield 456  # yield会使函数func()变成生成器对象，因此他就具有__iter__方法
     print(789) # yield会停止函数，当运行下一次next才会继续运行下面的代码
     yield 101112 # 一个yield对应一个next
     print(131415)

 f = func()  # 生成器
 print(f)  # <generator object func at 0x000001F0E44237D8>
 f_iter = f.__iter__()
 print(f_iter.__next__())
 print(f_iter.__next__())
 print(f_iter.__next__())

4.4 用生成器自定制一个range方法

range(10)

# 1. 生成一个可迭代器对象 --- 》 我要把我的range函数变成一个可迭代对象（迭代器对象）
# 2. 丢一个10进去，然后通过for循环的迭代next会丢出0，1，2，3，4，5，6，7，8，9
def range(x):
    count = 0
    while count < x:
        yield count
        count += 1
for i in range(10):
    print(i)        

4.5 生成器表达式

# 把列表推导式的[]换成()
lt = [i for i in range(10000000)]
print(lt)
g = (i for i in range(10000000))
print(g)
print(g.__next__())


# 列表和元组的区别
# 列表就是一筐鸡蛋,元组是一只老母鸡(节省空间)

五、匿名函数

5.1 什么是匿名函数

匿名函数：也就是没有绑定函数名，使用一次即被收回，加括号既可以运行。

匿名函数要用关键字lambda

# 匿名需要关键字lambda

lambda 参数:<代码块>

f = lambda x: x+1  
res = f(1)
print(res)  # 2

5.2 与内置函数联用

匿名函数一般不单独使用，通常与列表的sort()内置方法、sorted()、map()、filter()联用

• sort和sorted（对容器进行从小到大排序）

 salary_dict = {
     'nick': 3000,
     'jason': 100000,
     'tank': 5000,
     'sean': 2000
 }
 salary_list = list(salary_dict.items())
 print(salary_list)  # [('nick', 3000), ('jason', 100000), ('tank', 5000), ('sean', 2000)]

 def func(i):  # i = ('sean', 2000), ('nick', 3000),('tank', 5000),('jason', 100000)
     return i[1]  # 2000,3000,5000,100000

 salary_list.sort(key=lambda i: i[1])  # 内置方法是对原值排序
 # 按照func的规则取出一堆元素2000,3000,5000,100000
 # 然后按照取出的元素排序
 print(salary_list)  # [('sean', 2000), ('nick', 3000), ('tank', 5000), ('jason', 100000)]

 new_salary_list = sorted(salary_list, key=lambda i: i[1], reverse=True)  # sorted是重新创建一个新的列表进行排序，reverse是翻转一下
 print(new_salary_list)  # [('jason', 100000), ('tank', 5000), ('nick', 3000), ('sean', 2000)]

• max()和min()

salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000
}

salary_list = list(salary_dict.items())
print(salary_list)  # [('nick', 3000), ('jason', 100000), ('tank', 5000), ('sean', 2000)]

print(max(salary_list,key=lambda i:i[1]))  # 找出薪水最高的，('jason', 100000)
print(min(salary_list,key=lambda i:i[1]))  # 找出薪水最低的，('sean', 2000)

• map()：对容器中的薪资做一个映射

salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000
}

salary_list = list(salary_dict.items())
print(salary_list)  # [('nick', 3000), ('jason', 100000), ('tank', 5000), ('sean', 2000)]

print(list(map(lambda i: i[1] + 2000, salary_list)))  # [5000, 102000, 7000, 4000],把容器中每个薪水加2000并映射出来

• filter():对容器中满足条件的元素进行筛选

salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000
}

salary_list = list(salary_dict.items())
print(salary_list)  # [('nick', 3000), ('jason', 100000), ('tank', 5000), ('sean', 2000)]

print(list(filter(lambda i: i[1] < 5000, salary_list)))  # [('nick', 3000), ('sean', 2000)],找出薪水小于5000的

工作原理

1.首先将可迭代对象变为迭代器对象

2.将i当做参数传给第一个参数指定的函数，然后内置方法判断函数