Python技巧:对象迭代与反迭代

实现可迭代对象和迭代器

  1. 实例化iter()
    由可迭代对象得到迭代器
    通过给iter()传入可迭代对象(也就是实例化iter这个对象),得到迭代器对象
    可迭代对象:列表,字符串,元组,字典

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    #iter()的定义中:the argument must supply its own iterator, or be a sequence.
    #说明了要么自己是个可迭代对象,要么是一个序列

    l = [1,2,3,45]
    #使用 iter(l)相当于在内部调用 l.__iter__()
    print l.__iter__() #<listiterator object at 0x0000000004B90E10>
    print l.next()
    print l.next()



    s = 'abcde'
    #对于字符串来说并没有__iter__()方法,但是有__getitem__()方法
    print s.__getitem__ #<method-wrapper '__getitem__' of str object at 0x00000000050D20A8>
    print s.__getitem__(0) #a
    print s.__getitem__(1) #b
  2. 继承迭代器Iterator,实现next()方法(接口)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    class WeatherIterator(Iterator): #(继承迭代器)
    def __init__(self,cities):
    self.cities = cities
    self.index = -1
    #实现next()接口
    def next(self):
    self.index += 1 #保证向下进行
    print "-----", self.index
    if self.index == len(self.cities):
    raise StopIteration
    # city = self.cities[self.index]
    return self.getWeather()
    def getWeather(self):
    r = requests.get(u'http://api.yytianqi.com/observe?city=CH0%s0100&key=2t9cbchuhmjfhdrw' % self.cities[self.index])
    t = json.loads(r.text)
    return t['data']['cityName'], t['data']['qw']
  3. 继承可迭代对象Iterable,实现 iter()接口(方法)

使用生成器函数实现可迭代对象

什么是生成器函数? 调用yield语句的函数就是生成器函数
生成器和迭代器都支持.next()接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def f():
yield 1
yield 2
yield 3

t = f()
#注意! 不是f.next(),f是指向函数这个整体,或说指向函数的地址,所以应该用f().next()
#无论用几次f().next(),打印出来的都是1,因为每次使用f()时都是重新创建的对象,而不是之前那个f()
#所以想实现真正的next()得先用一个变量指向某个实例对象,eg:t = f()
# print f().next(),f().next()
# print t.next()
# print t.next()


#生成器对象也是可迭代的
for x in t:
print x

#既然t是可迭代的,说明t实现了__iter__()接口
#t.__iter__()返回值是t自身,打印下式返回true
print t.__iter__() is t
#生成器yield实现了可迭代对象接口 .__iter__()
#生成器yield也实现了迭代器接口 .next()

反向迭代与实现反向迭代

  1. 1
    2
    3
    4
    l = [1,2,3,4,5]
    l.reverse() #这样相当于是改变了原列表
    for x in l:
    print x
  2. 1
    2
    3
    #使用带步进值的切片操作,需要使用额外的空间
    for x in l[::-1]:
    print x
  3. 1
    2
    3
    #使用内置函数reversed()得到反向迭代器
    for x in reversed(l):
    print x
  4. 实现reversed()接口,类似iter()

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    class FloatRange:
    def __init__(self,start,end,step=0.1):
    self.start = start
    self.end = end
    self.step = step
    #实现正向迭代器
    def __iter__(self):
    t = self.start
    while t <= self.end:
    yield t
    t+=self.step
    #实现反向迭代器
    def __reversed__(self):
    t = self.end
    while t>= self.start:
    yield t
    t-=self.step
    #测试
    #正向迭代器(默认是正向的)
    for x in FloatRange(1.0,4.0,0.5):
    print x
    #反向迭代器,reversed()接收一个Iterable对象
    for x in reversed(FloatRange(1.0,4.0,0.5)):
    print x

对迭代器Iterator做切片操作

使用itertools中的islice

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from itertools import islice
#islice(iterable, [start,] stop [, step])
f = open('a.txt','r')
print type(islice(f,100,150))
for line in islice(f,100,150):
print line
#只有一个100,则代表stop值
#将文件指针移动到开头
f.seek(0)
for line in islice(f,100):
print line
f.seek(0)
#从100到结尾!!
for line in islice(f,100,None):
print line
f.close()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from itertools import islice
#range():Return a list containing an arithmetic progression of integers.
l = range(20)
print type(l)
#iter() Get an iterator from an object
t =iter(l)
#对l索引值为5--9的元素进行遍历
# 注意!索引值为0--4的元素先被迭代器产生,但是没有符合索引值范围,所以并没有使用
for x in islice(t,5,10):
print x
print "-----------------"
#使用islice()对迭代器有消耗,也就是说,产生过的元素不再参与迭代
for x in t:
print x
# 所以使用islice时要随时注意重新申请新的迭代对象,因为它会消耗原来的对象
# 但是直接用l没有关系,因为l是list类型, list调用__iter__(self)接口后返回一个可迭代对象,相当于t
# 这样相当于每次都创建新的可迭代对象,但是l占用空间大,有几个元素就占几个元素的空间,迭代器占用少,用到几个占用几个
for x in l:
print x
0%