小结
三元表达式
dog_name = 'crazy_dog'
if dog_name =='crazy_dog':
print('舔狗')
else:
print('溜了')
三元表达式/列表推导式/字典生成式，都只是让你的代码更少了，但是逻辑没有变化
print('舔狗') if dog_name == 'crazy-dog' else print('溜了')
三元表达式只支持双分支结构
# 列表推到式
# lt = [1,2,3,4,]
# lt = []
# for i in range(10):
# lt.append(i)
# print(lt)
# lt.append(i**2)
# print(lt)
# dic = {'a':1, 'b':2}
#
# lt = [(k,v) for (k,v) in dic.items()]
# print(lt)
# dic = {'a': 1, 'b': 2}
# lt = [(k,v) for k,v in dic.items()]
# print(lt) #[('a', 1), ('b', 2)]
# 字典生成式
# dict = {'a': 1, 'b': 2}
# dict1 = {k * 2: v ** 2 for k, v in dict.items()}
# print(dict1) # {'aa': 1, 'bb': 4}
# 字典生成式一般与zip（拉链函数--》列表里面包了元组）连用
# z = zip(['a','b','c','d'],[1,2,3,4]) # zip压缩方法，解释器内置方法
# for k,v in z:
# print(k,v) # a 1
# 解包赋值 # b 2
# c 3
# d 4
# dic = {k: v** 2 for k, v in zip(['a','b','c','d'],[1,2,3,4])}
# print(dic) # {'a': 1, 'b': 4, 'c': 9, 'd': 16}
# 生成器：自定义迭代器，生成器就是迭代器（自己造出来的）
# 关键字 yield
# 函数里面加 yield 就表示这是一个迭代器
# 迭代器对象：具有__iter__和__next__的方法的对象叫做迭代器对象
# def func():
# return 123
# f =func()
# print(f) # 123
# def func():
# yield 123
# yield 456
# f = func()
# print(f) # <generator object func at 0x00000000028F9200>
# f_iter = f.__iter__()
# print(f_iter.__next__()) # 123
# print(f_iter.__next__()) # 456
# 牢记：yield 的三个特性
# 1. yield 可以把函数变成生成器（自定制的迭代对象，具有__iter__和__next__的方法）
# 2. yield 可以停止函数，在下一次next时再次运行yield下面的代码
# 3. 有n个yield生成器就有n个元素，就可以next n次，在第n+1次时会报错
# return 特性
# 1.有返回值
# 2.终止函数
# def func():
# yield [1,1,2] yield会让函数func()变成生成器 ，因此具有__iter__的方法
# print(789) yield 会停止函数，当运行下一次next才会继续运行下面的代码
# yield 123 一个yield只能对应一个next
# print(111)
# g = func()
# for i in g:
# print(i) [1, 1, 2]
# 789
# 123
# 111
# 用生成器自定制一个range方法
# 思路：1.生成一个可迭代对象--》 我要把range函数变成一个可迭代对象（迭代器对象）
# 2. 丢一个 10 进去，然后通过for循环的迭代next会丢出0-9的数字
# def range(x):
# count = 0
# while count < x:
# yield count
# count += 1
# f = range(10)
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# for i in f:
# print(i)
# for i in range(1,10):
# print(i)
# 生成器表达式
# 把列表推导式的[]换成（）
# lt = [i for i in range(10)]
# print(lt) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#
# g = (i for i in range(10))
# print(g)#<generator object <genexpr> at 0x00000000028F9200>
# print(g.__next__()) # 0
# print(g.__next__()) # 1
# 列表和元组的区别
# 列表就是一筐鸡蛋；元组是一只老母鸡（节省空间）
# 匿名函数
# 匿名函数--》就是没有名字的函数
# 匿名函数需要关键字 lambda
# f = lambda x: x+1 # （x 是参数）， x+1 是代码块
# res = f(2)
# print(res) # 3
# 匿名函数一般不单独使用，和filter():过滤，筛选/map():映射/sorted()/列表的sort()：排序；
# salary_dict = {'nick': 3000,
# 'jason': 100000,
# 'tank': 5000,
# 'sean': 2000}
# salary_list = list(salary_dict.items())
# print(salary_list) #[('nick', 3000), ('jason', 100000), ('t
# def func(i): # i=('sean', 2000), ('nick', 3000),('tank', 5
# return i[1] # 2000,3000,5000,100000
#
# salary_list.sort(key = lambda i :i[0]) # 内置方法是对原值排序
# print(salary_list) # [('jason', 100000), ('nick', 3000), (
#
# salary_list.sort(key=lambda i: i[1])
# print(salary_list) #[('sean', 2000), ('nick', 3000), ('tank
#
# new_salary_list = sorted(salary_list,key=lambda i: i[1])
# print(new_salary_list) # [('sean', 2000), ('nick', 3000),
# salary_dict = {
# 'nick': 3000,
# 'jason': 100000,
# 'tank': 5000,
# 'sean': 2000
# }
# salary_list = list(salary_dict.items())
# print(salary_list) #[('nick', 3000), ('jason', 100000), ('t
#
# new_salary_list = max(salary_list,key=lambda i: i[1])
# print(new_salary_list) # ('jason', 100000) 取出最大值
#
# new_salary_list2 = min(salary_list,key=lambda i: i[1])
# print(new_salary_list2) # ('sean', 2000) 取出最小值
# salary_dict = {
# 'nick': 3000,
# 'jason': 100000,
# 'tank': 5000,
# 'sean': 2000
# }
# salary_list = list(salary_dict.items())
# print(salary_list) # [('nick', 3000), ('jason', 100000), ('
#
# new_list = list(filter(lambda i: i[1] < 5000,salary_list))
# print(new_list)
# new_list = list(map(lambda i: i[1] + 2000,salary_list) )
# print(new_list) # [5000, 102000, 7000, 4000]
# print(list(map(lambda i: i[1] + 2000,salary_list))) #[5000,