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

Welcome To My Blog

一.实现可迭代对象和迭代器

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

#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

1. 继承迭代器Iterator,实现next()方法(接口)

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

1. 继承可迭代对象Iterable,实现 iter()接口(方法)

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

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

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.

    l = [1,2,3,4,5]
    l.reverse() #这样相当于是改变了原列表
    for x in l:
        print x

#使用带步进值的切片操作,需要使用额外的空间
for x in l[::-1]:
    print x

1. 3.

#使用内置函数reversed()得到反向迭代器
for x in reversed(l):
    print x

1. 实现reversed()接口,类似iter()

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

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

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