python-day14(正式学习)

三元表达式
列表推导式
字典生成式
- zip()方法
生成器
匿名函数
- 与内联函数联用

三元表达式

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

x = 10
y = 20

print(f"x if x > y else y: {x if x > y else y}")

x if x > y else y: 20

列表推导式

[expression for item1 in iterable1 if condition1
for item2 in iterable2 if condition2
...
for itemN in iterableN if conditionN
]
类似于
res=[]
for item1 in iterable1:
    if condition1:
        for item2 in iterable2:
            if condition2
                ...
                for itemN in iterableN:
                    if conditionN:
                        res.append(expression)
                        
print(F"[i for i in range(10)]: {[i for i in range(10)]}")

##[i for i in range(10)]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(F"[i**2 for i in range(10)]: {[i**2 for i in range(10)]}")

##[i**2 for i in range(10)]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

说实话没啥用，仅限于装逼。。。

字典生成式

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()方法

keys = ['name', 'age', 'gender']
values = ['nick', 19, 'male']

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

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


##zip(keys,values): <zip object at 0x11074c088>
##info_dict: {'name': 'nick', 'age': 19, 'sex': 'male'}

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

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'}

这个还有点用。。。

生成器

yield关键字

yield的英文单词意思是生产，在函数中但凡出现yield关键字，再调用函数，就不会继续执行函数体代码，而是会返回一个值。

def func():
    print(1)
    yield
    print(2)
    yield


g = func()
print(g)
<generator object func at 0x10ddb6b48>

生成器的本质就是迭代器，同时也并不仅仅是迭代器，不过迭代器之外的用途实在是不多，所以我们可以大声地说：生成器提供了非常方便的自定义迭代器的途径。并且从Python 2.5+开始，[PEP 342：通过增强生成器实现协同程序]的实现为生成器加入了更多的特性，这意味着生成器还可以完成更多的工作。这部分我们会在稍后的部分介绍。

def func():
    print('from func 1')
    yield 'a'
    print('from func 2')
    yield 'b'


g = func()
print(F"g.__iter__ == g: {g.__iter__() == g}")

res1 = g.__next__()
print(f"res1: {res1}")

res2 = next(g)
print(f"res2: {res2}")

# next(g)  # StopIteration
g.__iter__ == g: True
from func 1
res1: a
from func 2
res2: b
def func():
    print('from func 1')
    yield 'a'
    print('from func 2')
    yield 'b'


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

print(f"list(func()): {list(func())}")
from func 1
a
from func 2
b
from func 1
from func 2
list(func()): ['a', 'b']

生成器就没必要加return了

迭代套迭代

如果我需要在生成器的迭代过程中接入另一个生成器的迭代怎么办？写成下面这样好傻好天真。并且你这样做的意图是什么？？？

def sub_generator():
    yield 1
    yield 2
    for i in range(3):
        yield i


for i in sub_generator():
	print(i)
##	
1
2
0
1
2
##
def sub_generator():
    yield 1
    yield 2
    yield from range(3)


for i in sub_generator():
    print(i)
##
1
2
0
1
2
##

send(value)

send是除next外另一个恢复生成器的方法。Python2.5+中，yield语句变成了yield表达式，这意味着yield现在可以有一个值，而这个值就是在生成器的send方法被调用从而恢复执行时，调用send方法的参数。

def h():
    print('--start--')
    first = yield 5  # 等待接收 Fighting! 值
    print('1', first)
    second = yield 12  # 等待接收 hahaha! 值
    print('2', second)
    yield 13
    print('--end--')


g = h()
first = next(g)  # m 获取了yield 5 的参数值 5
# (yield 5)表达式被赋予了'Fighting!',  d 获取了yield 12 的参数值12
second = g.send('Fighting!')
third = g.send('hahaha!')  # (yield 12)表达式被赋予了'hahaha!'
print(f'--over--')
print(f"first:{first}, second:{second}, third:{third}")
--start--
1 Fighting!
2 hahaha!
--over--
first:5, second:12, third:13

调用send传入非None值前，生成器必须处于挂起状态，否则将抛出异常。不过，未启动的生成器仍可以使用None作为参数调用send。
如果使用next恢复生成器，yield表达式的值将是None。

close()

这个方法用于关闭生成器。对关闭的生成器后再次调用next或send将抛出StopIteration异常。

def repeater():
    n = 0
    while True:
        n = (yield n)


r = repeater()
r.close()
print(next(r))  # StopIteration

throw()

中断Generator是一个非常灵活的技巧，可以通过throw抛出一个GeneratorExit异常来终止Generator。Close()方法作用是一样的，其实内部它是调用了throw(GeneratorExit)的。我们看close的源代码：

def close(self):
    try:
        self.throw(GeneratorExit)
    except (GeneratorExit, StopIteration):
        pass 
    else:
        raise RuntimeError("generator ignored GeneratorExit") # Other exceptions are not caught

自定义range方法

def my_range(start, stop, step=1):
    while start < stop:
        yield start
        start += 1


g = my_range(0, 3)
print(f"list(g): {list(g)}")

list(g):[0,1,2]

yield:

提供一种自定义迭代器的方式
yield可以暂停住函数，并提供当前的返回值

yield和return:

相同点：两者都是在函数内部使用，都可以返回值，并且返回值没有类型和个数的限制
不同点：return只能返回一次之；yield可以返回多次值

生成器表达式

把列表推导式的[]换成()就是生成器表达式
优点：省内存，一次只产生一个值在内存中

t = (i for i in range(10))
print(t)
print(f"next(t): {next(t)}")
<generator object <genexpr> at 0x1101c4888>
next(t): 0

匿名函数

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

lambda x, y: x+y
##<function __main__.<lambda>(x, y)>
res = (lambda x, y: x+y)(1, 2)
print(res)
##3

与内联函数联用

1.如果我们想从上述字典中取出薪资最高的人，我们可以使用max()方法，但是max()默认比较的是字典的key。

首先将可迭代对象变成迭代器对象
res=next(迭代器对象)，将res当做参数传给key指定的函数，然后将该函数的返回值当做判断依据

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

print(f"max(salary_dict): {max(salary_dict)}")


def func(k):
    return salary_dict[k]


print(f"max(salary_dict, key=func()): {max(salary_dict, key=func)}")
# 'nick', v1 = func('nick')
# 'jason', v2 = func('jason')
# 'tank', v3 = func('tank')
# 'sean', v4 = func('sean')


print(
    f"max(salary_dict, key=lambda name: salary_dict[name]): {max(salary_dict, key=lambda name: salary_dict[name])}")

max(salary_dict): tank
max(salary_dict, key=func()): jason
max(salary_dict, key=lambda name: salary_dict[name]): jason

2.如果我们想对上述字典中的人，按照薪资从大到小排序，可以使用sorted()方法。

sorted()工作原理：

首先将可迭代对象变成迭代器对象
res=next(迭代器对象)，将res当做参数传给第一个参数指定的函数，然后将该函数的返回值当做判断依据。

lis = [1, 3, 2, 5, 8, 6]
sorted(lis)
print(f"lis: {lis}")
print(f"sorted(lis,reverse=True): {sorted(lis,reverse=True)}")

##lis: [1, 3, 2, 5, 8, 6]
##sorted(lis,reverse=True): [8, 6, 5, 3, 2, 1]

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

print(
    f"sorted(salary_dict, key=lambda name: salary_dict[name]): {sorted(salary_dict, key=lambda name: salary_dict[name])}")

##sorted(salary_dict, key=lambda name: salary_dict[name]): ['sean', 'nick', 'tank', 'jason']

3.如果我们想对一个列表中的某个人名做处理，可以使用map()方法。

map()工作原理：

首先将可迭代对象变成迭代器对象
res=next(迭代器对象)，将res当做参数传给第一个参数指定的函数，然后将该函数的返回值作为map()方法的结果之一。

name_list = ['jason', 'tank', 'sean']

res = map(lambda name: f"{name} sb", name_list)
print(f"list(res): {list(res)}")

##list(res): ['jason sb', 'tank sb', 'sean sb']

4.如果我们想筛选除名字中含有'sb'的名字，我们可以使用filter()方法。

filter()工作原理：

首先将可迭代对象变成迭代器对象
res=next(迭代器对象)，将res当做参数传给第一个参数指定的函数，然后filter会判断函数的返回值的真假，如果为真则留下。

name_list = ['nick', 'jason sb', 'tank sb', 'sean sb']

filter_res = filter(lambda name: name.endswith('sb'), name_list)
print(f"list(filter_res): {list(filter_res)}")

##list(filter_res): ['jason sb', 'tank sb', 'sean sb']

posted @ 2019-08-13 21:50 wind叶阅读(268) 评论(0) 编辑收藏举报

刷新页面返回顶部

wind叶