Python iter()函数用法实例分析

本文实例讲述了Python iter()函数用法。分享给大家供大家参考,具体如下:

python中的迭代器用起来非常灵巧,不仅可以迭代序列,也可以迭代表现出序列行为的对象,例如字典的键、一个文件的行,等等。

迭代器就是有一个next()方法的对象,而不是通过索引来计数。当使用一个循环机制需要下一个项时,调用迭代器的next()方法,迭代完后引发一个StopIteration异常。

但是迭代器只能向后移动、不能回到开始、再次迭代只能创建另一个新的迭代对象。

反序迭代工具:reversed()将返回一个反序访问的迭代器。python中提供的迭代模块:itertools模块

先看几个例子:

>>> l=[2,3,4]
>>> iterl=iter(l)
>>> iterl.next()
2
>>> iterl.next()
3
>>> iterl.next()
4
>>> iterl.next()
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
StopIteration
>>> d={'one':1,'two':2,'three':3}
>>> d
{'three': 3, 'two': 2, 'one': 1}
>>> iterd=iter(d) #字典的迭代器会遍历字典的键(key)
>>> iterd.next()
'three'
>>> iterd.next()
'two'
>>> iterd.next()
'one'
>>> iterd.next()
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
StopIteration

下面查看iter()函数的帮助信息:

>>> help(iter)
Help on built-in function iter in module __builtin__:
iter(...)
  iter(collection) -> iterator
  iter(callable, sentinel) -> iterator
  Get an iterator from an object. In the first form, the argument must
  supply its own iterator, or be a sequence.
  In the second form, the callable is called until it returns the sentinel.

iter()函数有两种用法,一种是传一个参数,一种是传两个参数。结果都是返回一个iterator对象。

所谓的iterator对象,就是有个next()方法的对象。next方法的惯例或约定(convention)是,每执行一次就返回下一个值(因此它要自己记录状态,通常是在iterator对象上记录),直到没有值的时候raiseStopIteration。

传1个参数:参数collection应是一个容器,支持迭代协议(即定义有__iter__()函数),或者支持序列访问协议(即定义有__getitem__()函数),否则会返回TypeError异常。

传2个参数:当第二个参数sentinel出现时,参数callable应是一个可调用对象(实例),即定义了__call__()方法,当枚举到的值等于哨兵时,就会抛出异常StopIteration。

>>> s='abc' #s支持序列访问协议,它有__getitem__()方法
>>> help(str.__getitem__)
Help on wrapper_descriptor:
__getitem__(...)
  x.__getitem__(y) <==> x[y]
>>> s.__getitem__(1)
'b'
>>> s[1]
'b'
>>> iters=iter(s) #iters是一个iterator对象,它有next()和__iter__()方法
>>> iters1=iters.__iter__()
>>> iters2=iter(iters)
>>> iters
<iterator object at 0x030612D0>
>>> iters1
<iterator object at 0x030612D0>
>>> iters2
<iterator object at 0x030612D0>
iters iters1  iters2 是同一个迭代器!!
>>> iters.next()
'a'
>>> iters.next()
'b'
>>> iters.next()
'c'
>>> iters.next()
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
StopIteration
>>> class test: # test 类支持迭代协议,因为它定义有__iter__()函数
...   def __iter__(self):
...     print '__iter__ is called!'
...     self.result=[1,2,3]
...     return iter(self.result)
...
>>> t=test() # t支持迭代协议
>>> for i in t:  #当执行for i in t 时,实际上是调用了t.__iter__(),也就是__iter__(t),返回一个iterator对象
...   print i,
...
__iter__ is called!
1 2 3
>>> for i in t.__iter__():
        print i,
__iter__ is called!!
1 2 3
>>> for i in test.__iter__(t):
        print i,
__iter__ is called!!
1 2 3
>>> l=[1,2,3]
>>> for i in l:
...   print i,
...
1 2 3
#上述for循环实际上是这样工作的(for循环会自动调用迭代器的next()方法),如下:
>>> iterl=iter(l)
>>> while True:
...   try:
...     i=iterl.next()
...   except StopIteration:
...     break
...   print i,
...
1 2 3
>>> f=open(r'C:\Users\Administrator\Desktop\test.txt','w')
>>> f.writelines(['love python\n','hello python\n','love python\n'])
>>> f.close()
>>> f=open(r'C:\Users\Administrator\Desktop\test.txt','r')
>>> for line in f: # 文件对象生成的迭代器会自动调用readline()方法,这样循环遍历就可以访问文本文件的所有行
...   print line[:-1]
...
love python
hello python
love python

上述for循环部分功能与以下代码一致:

>>> while True:
...   line=f.readline()
...   if line!='':
...     print line[:-1]
...   else:
...     break
...
love python
hello python
love python
>>> f=open(r'C:\Users\91135\Desktop\test.txt','r')
>>> f.readlines()
['love python\n', 'hello python\n', '\n', 'love python\n']
>>> f.seek(0)
>>> f.next()
'love python\n'
>>> f.next()
'hello python\n'
>>> f.next()
'\n'
>>> f.next()
'love python\n'
>>> f.next()
Traceback (most recent call last):
 File "<pyshell#140>", line 1, in <module>
  f.next()
StopIteration
>>> f.seek(0)
>>> it1=iter(f)
>>> it2=f.__iter__()

f    iter1    iter2 三者是同一个对象!!!

>>> f
<open file 'C:\\Users\\91135\\Desktop\\test.txt', mode 'r' at 0x030E9A70>
>>> it1
<open file 'C:\\Users\\91135\\Desktop\\test.txt', mode 'r' at 0x030E9A70>
>>> it2
<open file 'C:\\Users\\91135\\Desktop\\test.txt', mode 'r' at 0x030E9A70>
>>> f.next()
'love python\n'
>>> it1.next()
'hello python\n'
>>> next(it2)
'\n'
>>> next(f)
'love python\n'
>>> next(f)
Traceback (most recent call last):
 File "<pyshell#247>", line 1, in <module>
  next(f)
StopIteration
>>> it1.next()
Traceback (most recent call last):
 File "<pyshell#248>", line 1, in <module>
  it1.next()
StopIteration
>>> it2.next()
Traceback (most recent call last):
 File "<pyshell#249>", line 1, in <module>
  it2.next()
StopIteration
iter(callable, sentinel) -> iterator

如果是传递两个参数给 iter() , 第一个参数必须是callable ,它会重复地调用第一个参数,

直到迭代器的下个值等于sentinel:即在之后的迭代之中,迭代出来sentinel就立马停止。

关于Python中,啥是可调用的,可以参考:python callable()函数

>>> class IT(object):
    def __init__(self):
        self.l=[1,2,3,4,5]
        self.i=iter(self.l)
    def __call__(self):  #定义了__call__方法的类的实例是可调用的
        item=next(self.i)
        print "__call__ is called,which would return",item
        return item
    def __iter__(self): #支持迭代协议(即定义有__iter__()函数)
        print "__iter__ is called!!"
        return iter(self.l)
>>> it=IT() #it是可调用的
>>> it1=iter(it,3) #it必须是callable的,否则无法返回callable_iterator
>>> callable(it)
True
>>> it1
<callable-iterator object at 0x0306DD90>
>>> for i in it1:
print i
__call__ is called,which would return 1
1
__call__ is called,which would return 2
2
__call__ is called,which would return 3

可以看到传入两个参数得到的it1的类型是一个callable_iterator,它每次在调用的时候,都会调用__call__函数,并且最后输出3就停止了。

>>> it2=iter(it)
__iter__ is called!!
>>> it2
<listiterator object at 0x030A1FD0>
>>> for i in it2:
print i,
1 2 3 4 5

与it1相比,it2就简单的多,it把自己类中一个容器的迭代器返回就可以了。

上面的例子只是为了介绍iter()函数传两个参数的功能而写,如果真正想写一个iterator的类,还需要定义next函数,这个函数每次返回一个值就可以实现迭代了。

>>> class Next():
        def __init__(self,data=825):
              self.data=data
        def __iter__(self):
              return self
        def next(self):
              print "next is called!!"
              if self.data>828:
                  raise StopIteration
              else:
                  self.data+=1
                  return self.data
>>> for i in Next():
print i
next is called!!
826
next is called!!
827
next is called!!
828
next is called!!
829
next is called!!
>>> for i in Next(826):
print i
next is called!!
827
next is called!!
828
next is called!!
829
next is called!!
>>>

唯一需要注意下的就是next中必须控制iterator的结束条件,不然就死循环了。

>>> it=Next()
>>> it.__iter__()
<__main__.Next instance at 0x02E75F80>
>>> Next.__iter__(it)
<__main__.Next instance at 0x02E75F80>
>>> iter(it)
<__main__.Next instance at 0x02E75F80>
>>> it
<__main__.Next instance at 0x02E75F80>
>>> it=Next()
>>> it.next()
next is called!!
826
>>> next(it)
next is called!!
827
>>> Next.next(it)
next is called!!
828
>>> next(it)
next is called!!
829
>>> it.next()
next is called!!
Traceback (most recent call last):
 File "<pyshell#68>", line 1, in <module>
  it.next()
 File "<pyshell#1>", line 9, in next
  raise StopIteration
StopIteration

更多关于Python相关内容感兴趣的读者可查看本站专题:《Python函数使用技巧总结》、《Python数据结构与算法教程》、《Python字符串操作技巧汇总》、《Python入门与进阶经典教程》及《Python文件与目录操作技巧汇总》

希望本文所述对大家Python程序设计有所帮助。

您可能感兴趣的文章:

  • Python中zip()函数用法实例教程
  • python进阶教程之循环相关函数range、enumerate、zip
  • Python中的zip函数使用示例
  • Python用zip函数同时遍历多个迭代器示例详解
  • python中lambda函数 list comprehension 和 zip函数使用指南
  • 浅谈Python中的zip()与*zip()函数详解
  • Python callable()函数用法实例分析
  • Python 函数基础知识汇总
  • python 文件和路径操作函数小结
  • Python入门篇之函数
  • Python zip()函数用法实例分析
时间: 2018-03-15

Python用zip函数同时遍历多个迭代器示例详解

前言 本文主要介绍的是Python如何使用zip函数同时遍历多个迭代器,文中的版本为Python3,zip函数是Python内置的函数.下面话不多说,来看详细的内容. 应用举例 >>> list1 = ['a', 'b', 'c', 'd'] >>> list2 = ['apple', 'boy', 'cat', 'dog'] >>> for x, y in zip(list1, list2): print(x, 'is', y) # 输出 a is

Python中zip()函数用法实例教程

本文实例讲述了Python中zip()函数的定义及用法,相信对于Python初学者有一定的借鉴价值.详情如下: 一.定义: zip([iterable, ...]) zip()是Python的一个内建函数,它接受一系列可迭代的对象作为参数,将对象中对应的元素打包成一个个tuple(元组),然后返回由这些tuples组成的list(列表).若传入参数的长度不等,则返回list的长度和参数中长度最短的对象相同.利用*号操作符,可以将list unzip(解压). 二.用法示例: 读者看看下面的例子,

python进阶教程之循环相关函数range、enumerate、zip

在"循环"一节,我们已经讨论了Python基本的循环语法.这一节,我们将接触更加灵活的循环方式. range() 在Python中,for循环后的in跟随一个序列的话,循环每次使用的序列元素,而不是序列的下标. 之前我们已经使用过range()来控制for循环.现在,我们继续开发range的功能,以实现下标对循环的控制: 复制代码 代码如下: S = 'abcdefghijk' for i in range(0,len(S),2):     print S[i] 在该例子中,我们利用l

Python中的zip函数使用示例

zip函数接受任意多个(包括0个和1个)序列作为参数,返回一个tuple列表.具体意思不好用文字来表述,直接看示例: 1.示例1: 复制代码 代码如下: x = [1, 2, 3] y = [4, 5, 6] z = [7, 8, 9] xyz = zip(x, y, z) print xyz 运行的结果是: [(1, 4, 7), (2, 5, 8), (3, 6, 9)] 从这个结果可以看出zip函数的基本运作方式. 2.示例2: 复制代码 代码如下: x = [1, 2, 3] y = [

浅谈Python中的zip()与*zip()函数详解

前言 1.实验环境: Python 3.6: 2.示例代码地址:下载示例: 3.本文中元素是指列表.元组.字典等集合类数据类型中的下一级项目(可能是单个元素或嵌套列表). zip(*iterables)函数详解 zip()函数的定义 从参数中的多个迭代器取元素组合成一个新的迭代器: 返回: 返回一个zip对象,其内部元素为元组:可以转化为列表或元组: 传入参数:元组.列表.字典等迭代器. zip()函数的用法 当zip()函数中只有一个参数时 zip(iterable)从iterable中依次取

python中lambda函数 list comprehension 和 zip函数使用指南

lambda 函数 Python 支持一种有趣的语法,它允许你快速定义单行的最小函数.这些叫做 lambda 的函数,是从 Lisp 借用来的,可以用在任何需要函数的地方. def f(x): return x*2,用lambda函数来替换可以写成:g = lambda x: x*2`g(3)结果是6.(lambda x: x*2)(3)`也是同样的效果. 这是一个 lambda 函数,完成同上面普通函数相同的事情.注意这里的简短的语法:在参数列表周围没有括号,而且忽略了 return 关键字

Python zip()函数用法实例分析

本文实例讲述了Python zip()函数用法.分享给大家供大家参考,具体如下: 这里介绍python中zip()函数的使用: >>> help(zip) Help on built-in function zip in module __builtin__: zip(...) zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)] Return a list of tuples, where each tuple c

python 文件和路径操作函数小结

1: os.listdir(path) //path为目录 功能相当于在path目录下执行dir命令,返回为list类型 print os.listdir('..') 2: os.path.walk(path,visit,arg) path :是将要遍历的目录 visit :是一个函数指针,函数圆形为: callback(arg,dir,fileList) 其中arg为为传给walk的arg , dir是path下的一个目录,fileList为dir下的文件和目录组成的list, arg:传给v

Python入门篇之函数

Pythond 的函数是由一个新的语句编写,即def,def是可执行的语句--函数并不存在,直到Python运行了def后才存在. 函数是通过赋值传递的,参数通过赋值传递给函数 def语句将创建一个函数对象并将其赋值给一个变量名,def语句的一般格式如下: 复制代码 代码如下: def function_name(arg1,arg2[,...]):     statement [return value] 返回值不是必须的,如果没有return语句,则Python默认返回值None. 函数名的命

Python callable()函数用法实例分析

本文实例讲述了Python callable()函数用法.分享给大家供大家参考,具体如下: python中的内建函数callable( ) ,可以检查一个对象是否是可调用的 . 对于函数, 方法, lambda 函数式, 类, 以及实现了 _ _call_ _ 方法的类实例, 它都返回 True. >>> help(callable) Help on built-in function callable in module __builtin__: callable(...) calla

Python 函数基础知识汇总

一.函数基础 简单地说,一个函数就是一组Python语句的组合,它们可以在程序中运行一次或多次运行.Python中的函数在其他语言中也叫做过程或子例程,那么这些被包装起来的语句通过一个函数名称来调用. 有了函数,我们可以在很大程度上减少复制及粘贴代码的次数了(相信很多人在刚开始时都有这样的体验).我们可以把相同的代码可以提炼出来做成一个函数,在需要的地方只需要调用即可.那么,这样就提高了代码的复用率了,整体代码看起来比较简练,没有那么臃肿了. 函数在Python中是最基本的程序结构,用来最大化地

学习Python列表的基础知识汇总

千里之行,始于足下.要练成一双洞悉一切的眼睛,还是得先把基本功扎扎实实地学好.今天,本喵带大家仔细温习一下Python的列表.温故而知新,不亦说乎. 当然,温习的同时也要发散思考,因为有些看似无关紧要的.约定俗成的语言习惯,例如数组索引为何从0开始,其背后可能大有来历.知其然,亦需知其所以然啊喵喵喵~~~ 最后,在基础知识之上,更要探索进阶,例如学习生成器表达式,这样既能更扎实地掌握基础,又能融会贯通,获得更全面的认知升级. Python的列表是怎样滴? 列表(list)是一种有序的集合,可以随

Java基础知识汇总

Java基础知识 1.Java语言的优点: 1)Java是纯面向对象语言 2)与平台无关性,一次编译到处运行 3)Java提供了狠多内置类库 4)提供了对web应用的支持 5)具有较好的安全性(数组边界检测.Bytecode检测)和健壮性(强制型机制.垃圾回收器.异常处理) 6)去除c++难以理解的一些特性(头文件 指针 运算符重载 多重继承) 2.java与c++的异同: 1)Java为解释型语言,c++为编译型语言,java会慢但是跨平台 2)Jave为纯面向对象,c++既面向对象又能面向过

Python函数基础实例详解【函数嵌套,命名空间,函数对象,闭包函数等】

本文实例讲述了Python函数基础用法.分享给大家供大家参考,具体如下: 一.什么是命名关键字参数? 格式: 在*后面参数都是命名关键字参数. 特点: 1.约束函数的调用者必须按照Kye=value的形式传值. 2.约束函数的调用者必须用我们指定的Key名. def auth(*args,name,pwd): print(name,pwd) auth(pwd='213',name='egon') def register(name,age): print(type(name),type(age)

C#多线程基础知识汇总

最近自己写了个小爬虫,里面用到了多线程技术,忽然发现对此技术竟然有些陌生了,于是乎开始疯狂的去问度娘,在此记录下来,以便自己和各位小伙伴们学习. 一.什么是线程 一个应用程序就相当于一个进程,进程拥有应用程序的所有资源进程包括线程,进程的资源被线程共享,但不拥有线程.我们可以打开电脑中的任务管理器,运行的.exe都是一个进程,里面的分支是线程. 二.多线程 多线程其实就是进程中一段并行运行的代码 1. 创建并启动线程 static void Main() { //获取线程Id var threa

node.js基础知识汇总

一.node介绍 1.node的应用场景 工具类 gulp webpack vite (node可以让js运行在服务器) 可以做服务端 优化ssr 可以做中间层 (解决跨域问题,格式化数据) 2.性能 非阻塞 异步I/O(当这个方法调用完毕后不会立即返回结果) 事件驱动(发布订阅模式) 3.优势 在Java.PHP或者.NET等服务器语言中,会为每一个客户端连接创建一个新的线程.而每个线程需要耗费大约2MB内存.也就是说,理论上,一个8GB内存的服务器可以同时连接的最大用户数为4000个左右.要

python中(str,list,tuple)基础知识汇总

python是一门动态解释型的强类型定义语言(先编译后解释) 动态类型语言 动态类型的语言编程时,永远也不用给任何变量指定数据类型,该语言会在你第一次赋值给变量时,在内部将数据类型记录下来 解释型 程序每执行到源程序的某一条指令,则会有一个称之为解释程序的外壳程序将源代码转换成二进制代码以供执行,总言之,就是不断地解释.执行.解释.执行 强类型 一旦一个变量被指定了某个数据类型,如果不经过强制转换,那么它就永远是这个数据类型了 优点:效率高,团队开发,移植,拓展,嵌入 缺点:速度慢,不能加密,禁

python数值基础知识浅析

内置数据类型 Python的内置数据类型既包括数值型和布尔型之类的标量,也包括 更为复杂的列表.字典和文件等结构. 数值 Python有4种数值类型,即整数型.浮点数型.复数型和布尔型. 整数型--1.-3.42.355.888888888888888.-7777777777,整 数没有大小限制,仅受限于可用内存的大小. 浮点数型--3.0.31e12.–6e-4. 复数型--3 + 2j.–4- 2j.4.2 + 6.3j. 布尔型--True.False. 数值类型用算术操作符进行运算操作,

Vue.js基础知识汇总

介绍 vue.js 是用来构建web应用接口的一个库 技术上,Vue.js 重点集中在MVVM模式的ViewModel层,它连接视图和数据绑定模型通过两种方式.实际的DOM操作和输出格式被抽象的方式到指令(Directives)和过滤器(Filters) 在哲学领域内,尽量让MVVM数据绑定API尽可能简单.模块化和可组合性也是重要的设计考虑.vue不是一个全面的框架,它被设计成简单的和灵活的.你可以用它快速原型,或混合和匹配与其他库定义前端堆栈. Vue.js的API是参考了AngularJS

Python序列化基础知识(json/pickle)

我们把对象(变量)从内存中变成可存储的过程称之为序列化,比如XML,在Python中叫pickling,在其他语言中也被称之为serialization,marshalling,flattening等等,都是一个意思. 序列化后,就可以把序列化后的内容写入磁盘,或者通过网络传输到其他服务器上,反过来,把变量内容从序列化的对象重新读到内存里称之为反序列化,即unpickling json(JavaScript Object Notation) 一种轻量级的数据交换格式.它基于ECMAScript的