函数进阶(2)

目录

• 1. 三元表达式
• 2. 列表推导式
• 3. 字典生成式
• 4. 生成器
• 5. 生成器表达式
• 6. 匿名函数

1. 三元表达式

条件成立时的返回值 if 条件 else 条件不成立时的返回值

dog_name = 'crazy_dog'

if dog_name == 'crazy_dog':
    print('1')
else:
    print('2')

# 三元表达式/列表推导式/字典生成式，只是让你的代码代码更少了，但是逻辑没有变化
print('1') if dog_name == 'crazy_dog' else print('2')

2. 列表推导式

lt = [0,1,2,3,4]

lt = []
for i in range(10):
    lt.append(i)
print(lt)

lt = [i for i in range(10)]
print(lt)

lt = []
for i in range(10):
    lt.append(i**2)
print(lt)

lt = [i**2 for i in range(10)]
print(lt)

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

lt1 = [i for i in dic.items()]
print(lt1)

lt = [(k,v) for (k,v) in dic.items()]
print(lt)

3. 字典生成式

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

new_dic = {k*2:v**2 for k,v in dic.items()}
print(new_dic)  # {'aa': 1, 'bb': 4}

# 字典生成式一般与zip(拉链函数--》列表里面包了元组)联用
z = zip([1,2,3,4],[1,2,3,4]) # 压缩方法，python解释器的内置方法
print(z.__next__())  # (1, 1)
print(z.__next__())  # (2, 2)

z = zip([1, 2, 3, 4], [1, 2, 3, 4])  # 压缩方法，python解释器的内置方法
for k, v in z:
    print(k, v)

z = zip([1, 2, 3, 4], [1, 2, 3, 4])
dic = {k ** 2: v ** 2 for k, v in z}
print(dic)   # {1: 1, 4: 4, 9: 9, 16: 16}

z = zip(['a','b','c','d'], [1, 2, 3, 4])
dic = {k:v for k,v in z}
print(dic)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

4. 生成器

生成器：自定义迭代器，生成器就是迭代器(自己造出来的)。

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

迭代器对象：具有__iter__,__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 0x000001A294AD4ED0>
f_iter = f.__iter__()
print(f_iter.__next__())
print(f_iter.__next__())
# print(f_iter.__next__()) # 报错

yield的三个特性：

1. yield可以把函数变成生成器(自定制的迭代器对象，具有__iter__方法)

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

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

return 的特性：

1.返回值

2.终止函数

def func():
    yield [1,1,23] 
    print(789) 
    yield 101112 
    print(131415)

g = func()
for i in g:
    print(i)

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

# 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)

5. 生成器表达式

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

# 列表和元组的区别
# 列表就是一筐鸡蛋，元组就是一只老母鸡(节省空间，一次只产生一个值在内存中)

6. 匿名函数

我们之前定义的函数都是有名函数，它是基于函数名使用。

def max2(x,y):
    if x > y:
        return x
    return y

res = max(10,20)
print(res)

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

匿名需要关键字lambda。

lambda 参数:<代码块>

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

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

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

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[0]) # 内置方法是对原值排序
# 按照func的规则取出一堆元素2000,3000,5000,100000
# 然后按照取出的元素排序
print(salary_list)

new_salary_list = sorted(salary_list,key=lambda i:i[1],reverse=True)  # 重新创建一个新的列表进行排序
print(new_salary_list)

# max():找出薪资最高的人
print(max(salary_list,key=lambda i:i[1]))
# min():找出薪资最低的人
print(min(salary_list,key=lambda i:i[1]))

# filter()：对列表中的人做筛选
print(list(filter(lambda i:i[1] < 5000,salary_list)))

# map()：对一个列表中的人做处理
print(list(map(lambda i:i[1] + 2000,salary_list)))