Python入门(四)——高级特性【分分快三计划】

作者:编程技术

4、执行顺序不同:普通函数执行到最后一句或者return语句时,就返回结果.而生成器函数,则是每次调用next()方法时执行,遇到yied语句就返回结果,再次执行时从上次结束的yield语句处开始执行.(执行顺序的问题,设个断点运行一次就清楚了)。

可迭代对象

要判断一个对象是可迭代对象,通过collections模块的Iterable类型判断。

>>> from collections import Iterable
>>> isinstance('abc', Iterable)
True
>>> isinstance((), Iterable)
True
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance(100, Iterable)
False

5. 生成器的调用方式

要调用生成器产生新的元素,有两种方式:

  • 调用内置的next()方法
  • 使用循环对生成器对象进行遍历(推荐)
  • 调用生成器对象的send()方法

分分快三计划 1

迭代

使用for ... in来遍历listtuplestrdict可迭代对象

CJava等语言不一样,python并不要求对象需要有下标。比如dict,注意dict是无序的。

字典默认遍历的是key,遍历value使用for v in d.values(),同时迭代key和value使用for k, v in d.items()

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

l = [1, 2, 3, 4, 5]
for x in l:
    print(x)

t = ('1', 'hello', 2.3)
for x in t:
    print(x)

s = 'hello'
for ch in s:
    print(ch)

d = {'name': 'Tim', 'age': 22, 'city': 'bj'}
for k in d:
    print(k)

for v in d.values():
    print(v)

for k, v in d.items():
    print(k, v)

如果要打印可迭代对象的下标,使用内置的enumerate(obj)转成枚举对象。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

l = [1, 2, 3, 4, 5]
for i, x in enumerate(l):
    print(i, x)

t = ('1', 'hello', 2.3)
for i, x in enumerate(t):
    print(i, x)

s = 'hello'
for i, ch in enumerate(s):
    print(i, ch)

d = {'name': 'Tim', 'age': 22, 'city': 'bj'}
for i, k in enumerate(d):
    print(i, k)

for i, v in enumerate(d.values()):
    print(i, v)

for i, t in enumerate(d.items()):   # t是tuple
    print(i, t, t[0], t[1])

在python中,for循环里面引用两个变量很常见:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

for x, y in [(0, 0), (12, 90), (2, 9)]:
    print(x, y)

基础语法格式

[exp for iter_var in iterable]

工作过程:

  • 迭代iterable中的每个元素;
  • 每次迭代都先把结果赋值给iter_var,然后通过exp得到一个新的计算值;
  • 最后把所有通过exp得到的计算值以一个新列表的形式返回。

相当于这样的过程:

L = []
for iter_var in iterable:
    L.append(exp)

2、在函数中定义yield语句就行了(执行到yield语句时,就会返回结果,不过生成器函数和普通函数还是有区别的,下面会说明)

迭代器

其中,生成器还可以被next()函数调用获取下一个值。

可以被next()函数调用并不断返回下一个值的对象称为迭代器Iterator

使用isinstance(obj, type)判断对象是否是迭代器Iterator,需要从collections导入Iterator。

>>> from collections import Iterator
>>> isinstance([], Iterator)
False
>>> isinstance((), Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('', Iterator)
False
>>> isinstance(set([]), Iterator)
False
>>> isinstance((x for x in range(3)), Iterator)
True

可以看到,listtuplestrdictset等都不是迭代器。

但是,可以通过iter()listtuplestrdictset转为迭代器。

>>> it = iter([])
>>> it
<list_iterator object at 0x10e4536d8>
>>> type(it)
<class 'list_iterator'>
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter(()), Iterator)
True
>>> isinstance(iter({}), Iterator)
True
>>> isinstance(iter(''), Iterator)
True
>>> isinstance(iter(set([])), Iterator)
True

为什么listtuplestrdictset等数据类型不是Iterator?

这是因为Python的Iterator对象表示的是一个数据流,Iterator对象可以被next()函数调用并不断返回下一个数据,直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列,但我们却不能提前知道序列的长度,只能不断通过next()函数实现按需计算下一个数据,所以Iterator的计算是惰性的,只有在需要返回下一个数据时它才会计算。

Iterator甚至可以表示一个无限大的数据流,例如全体自然数。而使用list是永远不可能存储全体自然数的。

3. 使用实例

我们可以对几个生成列表的要求分别通过“不使用列表生成式”和“使用列表生成式”来实现,然后做个对比总结。

5、局部变量和状态会被保存,一直到下一次调用。

生成器

通过列表生成式,我们可以直接创建一个列表。但是,受到内存限制,列表容量肯定是有限的。而且,创建一个包含100万个元素的列表,不仅占用很大的存储空间,如果我们仅仅需要访问前面几个元素,那后面绝大多数元素占用的空间都白白浪费了。

所以,如果列表元素可以按照某种算法推算出来,那我们是否可以在循环的过程中不断推算出后续的元素呢?这样就不必创建完整的list,从而节省大量的空间。在Python中,这种一边循环一边计算的机制,称为生成器(generator)。

创建一个生成器有几种方法。

第一种:把列表生成式的[]改成()就好了。

然后持续调用next(<generator>)输出每个元素。当没有更多元素,报StopIteration错。

>>> g = (x * x for x in range(5))
>>> g
<generator object <genexpr> at 0x101f4d728>
>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

事实上,我们永远都不会直接调用next(<generator>)去输出元素,而是使用for循环。并且也不会报StopIteration错。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

g = (x * x for x in range(5))
for x in g:
    print(x)

执行结果:

1
4
9
16

或者使用列表生成式输出。

>>> g = (x * x for x in range(5))
>>> g
<generator object <genexpr> at 0x101cdf570>
>>> [x for x in g]
[0, 1, 4, 9, 16]
>>> [i for i in (x * x for x in range(5))]
[0, 1, 4, 9, 16]

可以看到,生成器用来保存算法。当推算的算法比较复杂,使用列表生成式这样的for循环无法实现时,还可以使用函数来实现。

比如斐波那契数列。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

def fib(n):
    a, b = 0, 1
    while n > 0:
        print(a)
        a, b = b, a   b
        n -= 1

fib(10)

创建生成器的第二种方式就是使用函数。当函数中有yield关键字,调用这个函数后的返回值就是一个生成器。这个函数也可以有return语句等关键字。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

def fib(n):
    a, b = 0, 1
    while n > 0:
        yield a
        a, b = b, a   b
        n -= 1

f = fib
print(type(f))
print(f)
g = fib(10)
print(type(g))
print(g)
print([x for x in g])

执行结果:

<class 'function'>
<function fib at 0x10df42f28>
<class 'generator'>
<generator object fib at 0x10e174150>
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

这类生成器执行流程:在每次调用next()的时候执行,遇到yield语句返回,再次执行时从上次返回的yield语句处继续执行

下面的例子的运行结果证明上面的说法。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

def odd():
    print('step1')
    yield 1
    print('step2')
    yield 3
    print('step3')
    yield 5

o = odd()
print(next(o))
print(next(o))
print(next(o))
print(next(o))

执行结果:

step1
1
step2
3
step3
5
Traceback (most recent call last):
  File "./hellp.py", line 16, in <module>
    print(next(o))
StopIteration

可以看到,生成器遇到yield就中断,不会继续执行,直到下次调用next()。因此生成器需要设置合适的条件来终止生成器不停地next()

看下面的例子:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

def fun1():
    yield 1
    yield 2
    yield 3
    return 'Done'

g = fun1()
print(next(g))
print(next(g))
print(next(g))
print(next(g))

执行结果:

1
2
3
Traceback (most recent call last):
  File "./hellp.py", line 13, in <module>
    print(next(g))
StopIteration: Done

可以看到,报StopIteration错时打印了return语句的返回值。

当我们使用for循环遍历时,是获取不到的。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

def fun1():
    yield 1
    yield 2
    yield 3
    return 'Done'

for x in fun1():
    print(x)

执行结果:

1
2
3

要捕获return的返回值,不能使用for循环,只能调用next(),此时需要异常捕获。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

def fun1():
    yield 1
    yield 2
    yield 3
    return 'Done'

g = fun1()
while True:
    try:
        print(next(g))
    except StopIteration as e:
        print(e.value)
        break

执行结果:

1
2
3
Done

下面的例子用于打印杨辉三角,注意临时列表tmp必须拷贝res一份,否则tmp也指向res指向的对象,这样就不是杨辉三角的上一层列表了!

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

def triangle(n):
    tmp = []
    res = []
    while n >= 0:
        res.append(1)
        for i in range(len(tmp)-1):     # range(x),x<=0是没有输出的
            res[i   1] = tmp[i]   tmp[i   1]
        tmp = res[:]    # 必须拷贝一份,否则指向同一个对象!
        n -= 1
        yield res

g = triangle(5)
for x in g:
    print(x)

执行结果:

[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]

三、生成器(Generator)


从名字上来看,生成器应该是用来生成数据的。

例如:使用生成器实现杨辉三角

迭代器

实例1:使用next()方法遍历生成器

print(next(g1))
print(next(g1))
print(next(g1))
print(next(g1))

输出结果:

7
9
11
Traceback (most recent call last):
  File "***/generator.py", line 26, in <module>
    print(next(g1))
StopIteration

print(next(g2))
print(next(g2))
print(next(g2))
print(next(g2))

输出结果:

7
9
11
Traceback (most recent call last):
  File "***/generator.py", line 31, in <module>
    print(next(g2))
StopIteration

可见,使用next()方法遍历生成器时,最后是以抛出一个StopIeration异常终止。

而下面这段代码

切片

切片操作可以快速地选取listtuplestr的部分元素。

例如,l[x:y],表示截取l[x,y)索引范围的值所得的列表。

>>> l = ['Tim', 'Trump', 'Obama', 'Ivanka', 'Jane']
>>> l
['Tim', 'Trump', 'Obama', 'Ivanka', 'Jane']
>>> l[0:3]
['Tim', 'Trump', 'Obama']
>>> l[:3]
['Tim', 'Trump', 'Obama']
>>> l[1:3]
['Trump', 'Obama']
>>> l[-2:]
['Ivanka', 'Jane']
>>> l[-2:-1]
['Ivanka']
>>> l = list(range(100))
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
>>> l[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> l[-10:]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
>>> l[10:20]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> l[:10:2]
[0, 2, 4, 6, 8]
>>> l[::5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]
>>> l1 = l[:]
>>> l1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
>>> l1 == l
True
>>> l1 is l
False
>>> id(l1)
4325251144
>>> id(l)
4325252552

id()返回变量的唯一标识,CPython则是返回指向的对象的内存地址。

  • ==判断变量指向的对象的值是否相等
  • is判断变量的唯一标识是否相等,CPython则是指向的对象的内存地址是否相等。

注意,[:]可以快速的复制一个列表,并且两个变量的地址是不同的。

tuple切片返回的依然是tuple

str切片返回的依然是str

>>> (1, 2, 3, 4, 5)[3:]
(4, 5)
>>> 'abcdefg'[2:4]
'cd'

3. 生成器构造实例

# 使用类似列表生成式的方式构造生成器
g1 = (2*n   1 for n in range(3, 6))

# 使用包含yield的函数构造生成器
def my_range(start, end):
    for n in range(start, end):
        yield 2*n   1

g2 = my_range(3, 6)
print(type(g1))
print(type(g2))

输出结果:

<class 'generator'>
<class 'generator'>

分分快三计划 2

列表生成式

更多用法参考:List Comprehensions

列表生成式(List Comprehensions),是简洁却强大的创建list的生成式。

for后面还可以接上if。还可以嵌套(>=2层)循环,比如生成全排列。

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
>>> [m   n for m in 'abc' for n in 'xyz']
['ax', 'ay', 'az', 'bx', 'by', 'bz', 'cx', 'cy', 'cz']

列出当前目录的文件和目录(不递归)。

>>> import os
>>> [d for d in os.listdir('.')]
['.DS_Store', 'dir1', 'hellp.py']

列表表达式里面的for也可以使用>=2个变量,比如遍历dict:

>>> d = {'name': 'Tim', 'age': 22}
>>> [str(k)   ' => '   str(v) for k, v in d.items()]
['name => Tim', 'age => 22']

在列表生成式里面做点函数运算。

>>> l = ['Tim', 'Trump', 'Obama', 'Ivanka', 'Jane']
>>> [s.lower() for s in l]
['tim', 'trump', 'obama', 'ivanka', 'jane']

实例2:生成一个2n 1的数字列表,n为从3到11的数字

# 不使用列表生成式实现
list3 = []
for n in range(3, 11):
    list3.append(2*n   1)

# 使用列表生成式实现
list4 = [2*n   1 for n in range(3, 11)]

(三)生成器函数和普通函数的区别

可迭代对象

能直接作用于for循环的类型称之为可迭代对象,即Iterable。有以下2类:

  • 集合数据类型:listtuplestrdictset等。
  • 生成器generator:生成器和带yield的生成器函数。

使用isinstance(obj, type)判断对象是否是可迭代对象Iterable,需要从collections导入Iterable

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance((), Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance(set([1, 2, 3]), Iterable)
True
>>> isinstance((x for x in range(5)), Iterable)
True
>>> isinstance(100, Iterable)
False

1. 迭代器的定义

可以被next()函数调用并不断返回下一个值的对象称为迭代器:Iterator

很明显上面讲的生成器也是迭代器。当然,我们可以使用isinstance()来验证一下:

from collections import Iterator
print(isinstance((x for x in range(5)), Iterator))

输出结果为:True

下面这段代码的效果和上面的列表生成式是一样的(一开始可能不太习惯列表生成式的写法,多写几次就习惯了):

1. 生成器的作用

按照某种算法不断生成新的数据,直到满足某一个指定的条件结束。

(四)生成器的使用

四、可迭代对象(Iterable)

我们经常在Python的文档中看到“Iterable”这个此,它的意思是“可迭代对象”。那么什么是可迭代对象呢?
可直接用于for循环的对象统称为可迭代对象(Iterable)。

目前我们已经知道的可迭代(可用于for循环)的数据类型有:

  • 集合数据类型:如list、tuple、dict、set、str等
  • 生成器(Generator)

可以使用isinstance()来判断一个对象是否是Iterable对象:

from collections import Iterable
print(isinstance([], Iterable))

1、易于实现,代码更简洁,容易阅读。(例如:使用迭代器我们需要自己去定义__iter__()和_next_()方法,而生成器会自动处理这些

循环嵌套语法格式

[exp for iter_var_A in iterable_A for iter_var_B in iterable_B]

工作过程:
每迭代iterable_A中的一个元素,就把ierable_B中的所有元素都迭代一遍。

相当于这样的过程:

L = []
for iter_var_A in iterable_A:
    for iter_var_B in iterable_B:
        L.append(exp)
 1 #第二行
 2 L2 = [1,1]
 3 
 4 L2.append(0) #此时变成了[1,1,0]
 5 
 6 
 7 L3  = []
 8 # 列表的索引为-1的时候,值=0. L2[-1] = 0
 9 L3.append(L2[-1]   L2[0])
10 L3.append(L2[0] L2[1])
11 L3.append(L2[1] L2[2])
12 
13 print(L3)

实例5:将一个字典转换成由一组元组组成的列表,元组的格式为(key, value)

D = {'Tom': 15, 'Jerry': 18, 'Peter': 13}

# 不使用列表生成式实现
list9 = []
for k, v in D.items():
    list9.append((k, v))

# 使用列表生成式实现
list10 = [(k, v) for k, v in D.items()]

可见,使用列表生成式确实要方便、简洁很多,使用一行代码就搞定了。

2、对内存更加友好.例如:我们创建一个列表的时候,是一创建就存放到内存中的,如果数据量很大,毫无疑问会占用大量内存(而很多时候,我们可能并不需要访问所有数据)。如果列表元素可以通过某种算法推算出来,一边循环一边计算,这样就能节省大量的内存。Python的生成器就可以实现这种功能.

带过滤功能语法格式

[exp for iter_var in iterable if_exp]

工作过程:

  • 迭代iterable中的每个元素,每次迭代都先判断if_exp表达式结果为真,如果为真则进行下一步,如果为假则进行下一次迭代;
  • 把迭代结果赋值给iter_var,然后通过exp得到一个新的计算值;
  • 最后把所有通过exp得到的计算值以一个新列表的形式返回。

相当于这样的过程:

L = []
for iter_var in iterable:
    if_exp:
        L.append(exp)
def theGe():
    i = 1
    yield i

print(type(theGe()))

本节内容


  • 语法糖的概念
  • 列表生成式
  • 生成器(Generator)
  • 可迭代对象(Iterable)
  • 迭代器(Iterator)
  • Iterable、Iterator与Generator之间的关系

2、调用生成器函数时,它返回一个生成器对象,但不会立即执行。

生成器的执行过程:

在执行过程中,遇到yield关键字就会中断执行,下次调用则继续从上次中断的位置继续执行。

(一)生成器(Generator)

6. 生成器与列表生成式对比

既然通过列表生成式就可以直接创建一个新的list,那么为什么还要有生成器存在呢?

因为列表生成式是直接创建一个新的list,它会一次性地把所有数据都存放到内存中,这会存在以下几个问题:

  • 内存容量有限,因此列表容量是有限的;
  • 当列表中的数据量很大时,会占用大量的内存空间,如果我们仅仅需要访问前面有限个元素时,就会造成内存资源的极大浪费;
  • 当数据量很大时,列表生成式的返回时间会很慢;

而生成器中的元素是按照指定的算法推算出来的,只有调用时才生成相应的数据。这样就不必一次性地把所有数据都生成,从而节省了大量的内存空间,这使得其生成的元素个数几乎是没有限制的,并且操作的返回时间也是非常快速的(仅仅是创建一个变量而已)。

我们可以做个试验:对比一下生成一个1000万个数字的列表,分别看下用列表生成式和生成器时返回结果的时间和所占内存空间的大小:

import time
import sys

time_start = time.time()
g1 = [x for x in range(10000000)]
time_end = time.time()
print('列表生成式返回结果花费的时间: %s' % (time_end - time_start))
print('列表生成式返回结果占用内存大小:%s' % sys.getsizeof(g1))

def my_range(start, end):
    for x in range(start, end):
        yield x

time_start = time.time()
g2 = my_range(0, 10000000)
time_end = time.time()
print('生成器返回结果花费的时间: %s' % (time_end - time_start))
print('生成器返回结果占用内存大小:%s' % sys.getsizeof(g2))

输出结果:

列表生成式返回结果花费的时间: 0.8215489387512207
列表生成式返回结果占用内存大小:81528056
生成器返回结果花费的时间: 0.0
生成器返回结果占用内存大小:88

可见,生成器返回结果的时间几乎为0,结果所占内存空间的大小相对于列表生成器来说也要小的多。

1 L3  = [L2[i-1] L2[i] for i in range(len(L2))]

六、Iterable、Iterator与Generator之间的关系


  • 生成器对象既是可迭代对象,也是迭代器: 我们已经知道,生成器不但可以作用与for循环,还可以被next()函数不断调用并返回下一个值,直到最后抛出StopIteration错误表示无法继续返回下一个值了。也就是说,生成器同时满足可迭代对象和迭代器的定义;
  • 迭代器对象一定是可迭代对象,反之则不一定: 例如list、dict、str等集合数据类型是可迭代对象,但不是迭代器,但是它们可以通过iter()函数生成一个迭代器对象。

也就是说:迭代器、生成器和可迭代对象都可以用for循环去迭代,生成器和迭代器还可以被next()方函数调用并返回下一个值。

可以看到,print('生成器:',theGe)输出的是一个生成器对象,不会直接输出结果

实例4:计算两个集合的全排列,并将结果作为保存至一个新的列表中

L1 = ['香蕉', '苹果', '橙子']
L2 = ['可乐', '牛奶']

# 不使用列表生成式实现
list7 = []
for x in L1:
    for y in L2:
        list7.append((x, y))

# 使用列表生成式实现
list8 = [(x, y) for x in L1 for y in L2]

实现杨辉三角:

4. 列表生成式与map()、filter()等高阶函数功能对比

我觉得,大家应该已经发现这里说的列表生成式的功能与之前 这篇文章 中讲到的map()和filter()高阶函数的功能很像,比如下面两个例子:

3、生成器可以代表一个无限的数据流.(无限的数据流是不能直接存放到内存中的,因为内存是有限的)

实例2:把一个列表中所有的字符串转换成小写,非字符串元素移除

L = ['TOM', 'Peter', 10, 'Jerry']
# 用列表生成式实现
list3 = [x.lower() for x in L if isinstance(x, str)]

# 用map()和filter()函数实现
list4 = list(map(lambda x: x.lower(), filter(lambda x: isinstance(x, str), L)))

对于大部分需求来讲,使用列表生成式和使用高阶函数都能实现。但是map()和filter()等一些高阶函数在Python3中的返回值类型变成了Iteraotr(迭代器)对象(在Python2中的返回值类型为list),这对于那些元素数量很大或无限的可迭代对象来说显然是更合适的,因为可以避免不必要的内存空间浪费。关于迭代器的概念,下面会单独进行说明。

6、函数结束时,抛出StopIteration异常。

实例2:使用循环遍历生成器

for x in g1:
    print(x)

for x in g2:
    print(x)

两个循环的输出结果是一样的:

7
9
11

可见,使用循环遍历生成器时比较简洁,且最后不会抛出一个StopIeration异常。因此使用循环的方式遍历生成器的方式才是被推荐的。

需要说明的是:如果生成器函数有返回值,要获取该返回值的话,只能通过在一个while循环中不断的next(),最后通过捕获StopIteration异常

1 L3  = []
2 # 列表的索引为-1的时候,值=0. L2[-1] = 0
3 L3.append(L2[-1]   L2[0])
4 L3.append(L2[0] L2[1])
5 L3.append(L2[1] L2[2])

2. 生成器的构造方式

构造生成器的两种方式:

  • 使用类似列表生成式的方式生成 (2*n 1 for n in range(3, 11))
  • 使用包含yield的函数来生成

如果计算过程比较简单,可以直接把列表生成式改成generator;但是,如果计算过程比较复杂,就只能通过包含yield的函数来构造generator。

说明: Python 3.3之前的版本中,不允许迭代函数法中包含return语句。

分分快三计划 3

二、列表生成式


顾名思义,列表生成式就是一个用来生成列表的特定语法形式的表达式。

1 theLi = [i*i for i in range(10)]
2 
3 print(theLi)
4 #创建一个生成器
5 theGe = (i*i for i in range(10))
6 
7 print('生成器:',theGe)

2. 对迭代器的理解

实际上,Python中的Iterator对象表示的是一个数据流,Iterator可以被next()函数调用被不断返回下一个数据,直到没有数据可以返回时抛出StopIteration异常错误。可以把这个数据流看做一个有序序列,但我们无法提前知道这个序列的长度。同时,Iterator的计算是惰性的,只有通过next()函数时才会计算并返回下一个数据。(此段内容来自 这里)

生成器也是这样的,因为生成器也是迭代器。

 

一、语法糖的概念


“语法糖”,从字面上看应该是一种语法。“糖”,可以理解为简单、简洁。其实我们也已经意识到,没有这些被称为“语法糖”的语法,我们也能实现相应的功能,而 “语法糖”使我们可以更加简洁、快速的实现这些功能。 只是Python解释器会把这些特定格式的语法翻译成原本那样复杂的代码逻辑而已,没有什么太高深的东西。

到目前为止,我们使用和介绍过的语法糖有:

  • if...else 三元表达式: 可以简化分支判断语句,如 x = y.lower() if isinstance(y, str) else y
  • with语句: 用于文件操作时,可以帮我们自动关闭文件对象,使代码变得简洁;
  • 装饰器: 可以在不改变函数代码及函数调用方式的前提下,为函数增加增强性功能;

这里会再介绍两个:

  • 列表生成式: 用于生成一个新的列表
  • 生成器: 用于“惰性”地生成一个无限序列

(五)使用生成器的优势

实例1:生成一个从3到10的数字列表

# 不使用列表生成式实现
list1 = list(range(3, 11))

# 使用列表生成式实现
list2 = [x for x in range(3, 11)]

 分分快三计划 4

实例1:把一个列表中所有的字符串转换成小写,非字符串元素原样保留

L = ['TOM', 'Peter', 10, 'Jerry']
# 用列表生成式实现
list1 = [x.lower() if isinstance(x, str) else x for x in L]

# 用map()函数实现
list2 = list(map(lambda x: x.lower() if isinstance(x, str) else x,  L))
L3  = []
for i in range(len(L2)):
    L3.append(L2[i-1]   L2[i])

4. 生成器的执行过程与特性

L = []
for i in range(10):
    L.append(i*i)

2. 应用场景

其实列表生成式也是Python中的一种“语法糖”,也就是说列表生成式应该是Python提供的一种生成列表的简洁形式,应用列表生成式可以快速生成一个新的list。它最主要的应用场景是:根据已存在的可迭代对象推导出一个新的list。

(二)创建生成器

实例3:调用生成器对象的send()方法

def my_range(start, end):
    for n in range(start, end):
        ret = yield 2*n   1
        print(ret)

g3 = my_range(3, 6)

print(g3.send(None))
print(g3.send('hello01'))
print(g3.send('hello02'))

输出结果:

7
hello01
9
hello02
11

print(next(g3))
print(next(g3))
print(next(g3))

输出结果:

7
None
9
None
11

结论:

  • next()会调用yield,但不给它传值
  • send()会调用yield,也会给它传值(该值将成为当前yield表达式的结果值)

需要注意的是:第一次调用生成器的send()方法时,参数只能为None,否则会抛出异常。当然也可以在调用send()方法之前先调用一次next()方法,目的是让生成器先进入yield表达式。

列表生成式:

生成器的特性:

  • 只有在调用时才会生成相应的数据
  • 只记录当前的位置
  • 只能next,不能prev

因为下面会用到列表生成式,这里先说明下列表生成式:

1. 语法格式:

 1 from collections import Iterable
 2 from collections import Iterator
 3 
 4 def gen():
 5 
 6     i = 1
 7     print('第一次:',end='')
 8     yield i
 9     i  = 1
10     print('第二次:',end='')
11     yield i
12     i  = 1
13     print('第三次:',end='')
14     yield i
15 
16 print(type(gen()))
17 #生成器也是迭代器
18 print(isinstance(gen(),Iterable))
19 print(isinstance(gen(),Iterator))
20 
21 g = gen()
22 print(next(g))
23 print(next(g))
24 print(next(g))
25 print(next(g))

实例3:过滤出一个指定的数字列表中值大于20的元素

L = [3, 7, 11, 14,19, 33, 26, 57, 99]
# 不使用列表生成式实现
list5 = []
for x in L:
    if x < 20:
        list5.append(x)

# 使用列表生成式实现
list6 = [x for x in L if x > 20]
theLi = [i*i for i in range(10)]

五、迭代器(Iterator)


分分快三计划 5

举个例子:

1、将列表生成式的[]换成()就行了。

1、Generator函数包含一个或多个yield语句。

分分快三计划 6

其实就是:

例如:我们知道第二行的元素,我们可以通过下面这种方式获得三行的元素(这个规律是通用的)

Python生成器是创建迭代器的简单方法。简单来说,生成器是一个函数,它返回一个我们可以迭代的对象(迭代器)(一次一个值)。

可在IDE中将结果打印出来. 

3、生成器函数会自动实现__iter__()__next__()方法。

也是(列表生成式的写法):

 1 #杨辉三角
 2 def yhTriangles(n):
 3     yh = [1]
 4     while len(yh) <= n:
 5         yield yh
 6         yh.append(0)
 7         yh = [yh[i-1]   yh[i] for i in range(len(yh))]
 8 
 9 
10 for i in yhTriangles(10):
11     print(i)

比较简单的一种理解方式,将每一行都看成一个列表,通过末尾补0的方式来计算下一行列表的值.

本文由分分快三计划发布,转载请注明来源

关键词: 分分快三计划 python Python生