标签：eve object print 结果 高阶函数 /usr name 注意 循环
把函数作为参数传入，这样的函数称为高阶函数
#sorted() 高阶函数 print (‘#####字典排序#####‘) mm=dict(a=1,b=5,c=10,d=4) for i in mm: print i print(dir(mm)) sorted(mm,reverse=False) print sorted(mm,reverse=False)
函数嵌套
def max(x,y): return x if x > y else y def max4(a,b,c,d): res1=max(a,b) res2=max(res1,c) res3=max(res2,d) return res3 print(max4(1,2,3,4))
名称空间和作用域
#三种名称空间：内置名称空间 全局名称空间 局部名称空间 #内置名称空间 # print(sum) # print(min) # print(max) # import builtins # for i in (dir(builtins)): # print(i) #全局名称空间：在最外层定义 # x=1 # func=‘aa‘ # def func(): # print(‘func‘) # print(x) # func() #局部名称空间 在函数内部定义 调用函数时会产生局部名称空间,只在函数调用时临时绑定，调用结束时释放空间 # x = 1000 # def func(): # x=1 # print(x) # def f(): # pass # # func() #作用域 # 全局作用域 ：内置名称空间，全局名称空间 # 局部作用域：局部名称空间 #名字的查找顺序：局部名称空间--》全局名称空间--》内置名称空间 # x =1 # def func(): # # x=2 # print(x) # print(sum) # # func() #查看全局作用域内的名字：gloabls() #查看局部作用域内的名字：locals() # def func(): # x=2 # x=1000 # print(globals()) # for i in dir(globals()): # print(i) # # print(locals()) # print(globals() is locals()) # x=1000 # def func(): # x=2 # print(locals()) # print(globals()) # func() #全局作用域：全局有效，在任何位置都能被访问到，除非del删除，否则一直存活到文件执行结束 #局部作用域：局部有效，只能在局部范围调用，只在函数调用时有效，函数调用结束即失效 x =1 def f1(): def f2(): def f3(): print(x) f3() f2() f1()
迭代器和迭代对象、迭代器对象
#1、为何要有迭代器？ 对于序列类型：字符串、列表、元组，我们可以使用索引的方式迭代取出其包含的元素。但对于字典、集合、文件等类型是没有索引的，若还想取出其内部包含的元素，则必须找出一种不依赖于索引的迭代方式，这就是迭代器 #2、什么是可迭代对象？ 可迭代对象指的是内置有__iter__方法的对象，即obj.__iter__，如下 ‘hello‘.__iter__ (1,2,3).__iter__ [1,2,3].__iter__ {‘a‘:1}.__iter__ {‘a‘,‘b‘}.__iter__ open(‘a.txt‘).__iter__ #3、什么是迭代器对象？ 可迭代对象执行obj.__iter__()得到的结果就是迭代器对象 而迭代器对象指的是即内置有__iter__又内置有__next__方法的对象 文件类型是迭代器对象 open(‘a.txt‘).__iter__() open(‘a.txt‘).__next__() #4、注意： 迭代器对象一定是可迭代对象，而可迭代对象不一定是迭代器对象
生成器就是迭代器
#只要函数内部包含有yield关键字，那么函数名()的到的结果就是生成器，并且不会执行函数内部代码 def func(): print(‘====>first‘) yield 1 print(‘====>second‘) yield 2 print(‘====>third‘) yield 3 print(‘====>end‘) g=func() print(g) #<generator object func at 0x0000000002184360> g.__iter__ g.__next__ #2、所以生成器就是迭代器，因此可以这么取值 res=next(g) print(res)
深入解读迭代器
#!/usr/bin/env /python # -*- coding:utf-8 -*- # Author:big k ‘‘‘ 迭代器 迭代的概念：重复+上一次迭代的结果为下一次迭代的初始值 重复的过程称为迭代，每次重复即一次迭代 并且每次迭代的结果是下一次迭代的初始值 ‘‘‘ #while True :#只满足重复，因而不是迭代 # print(‘===>‘) #下面为迭代 # l=[1,2,3] # count=0 # while count<len(l): # print(‘===>‘,l[count]) # count +=1 # s=‘hello‘ # count=0 # while count< len(s): # print(‘===>‘,s[count]) # count +=1 #为什么要有迭代器？对于没有索引的数据类型，必须提供一种不依赖于索引的迭代方式 #可迭代对象 内置__iter__ ,都是可迭代对象 #带索引的，内置包括__iter__() # [1,2].__iter__() #列表 # ‘hello‘.__iter__() #字符串 # (1,2).__iter__() #元组 # # #不带索引的 # {‘a‘:1,‘b‘:2}.__iter__() #字典 # {1,2,3}.__iter__() #集合 #迭代器：执行__iter__方法，得到的结果就是迭代器，迭代器对象有__next__方法 # i=[1,2,3].__iter__() # print(i) # # print(i.__next__()) # print(i.__next__()) # print(i.__next__()) # print(i.__next__()) #抛出异常， StopIteration # dic={‘a‘:1,‘b‘:2,‘c‘:3} # i = dic.__iter__() # while True: # try: # key=i.__next__() # print(dic[key]) # except StopIteration: # break # s=‘hello‘ # print(s.__len__()) # print(len(s)) #s.__len__() # s={‘a‘,2,3,4} # i= iter(s) # print(next(i)) # print(next(i)) # print(next(i)) # print(next(i)) # print(next(i)) #如何判断一个对象是可迭代的对象，还是迭代器对象 from collections import Iterable,Iterator #以后都是可迭代对象 # ‘abc‘.__init__() # ().__iter__() # [].__iter__() # {‘a‘:1}.__iter__() # {1,2}.__iter__() # # f=open(‘a.ini‘,‘w‘) # f.__iter__() # print(isinstance(‘abc‘,Iterable)) # print(isinstance([],Iterable)) # print(isinstance((),Iterable)) # print(isinstance({‘a‘:1},Iterable)) # print(isinstance({1,2},Iterable)) # print(isinstance(f,Iterable)) #只有文件是迭代器对象 # ‘abc‘.__init__() # ().__iter__() # [].__iter__() # {‘a‘:1}.__iter__() # {1,2}.__iter__() # # f=open(‘a.ini‘,‘w‘) # f.__iter__() # print(isinstance(‘abc‘,Iterator)) # print(isinstance([],Iterator)) # print(isinstance((),Iterator)) # print(isinstance({‘a‘:1},Iterator)) # print(isinstance({1,2},Iterator)) # print(isinstance(f,Iterator)) ‘‘‘ 可迭代对象：只有__iter__方法，执行该方法得到的迭代器对象 迭代协议： 对象有__next__ 对象有__iter__ ‘‘‘ # f1=f.__iter__() # # print(f) # print(f1) # print(f is f1) # dic ={‘name‘:‘egon‘,‘age‘:18,‘height‘:‘180‘} # print(dic.items()) # for k,v in dic.items(): # print(k,v) # i=iter(dic) # while True: # try: # k=next(i) # print(k) # except StopIteration: # break # # for k in dic: #i=iter(dic) k=next(i) # print(k) # print(dic[k]) #for循环就是迭代器，一直__next__ # l=[‘a‘,‘b‘,3,9,10] # for i in l: # print(i) # with open(‘a.ini‘,‘r‘,encoding=‘utf-8‘) as f : # # for line in f: # # print(line) # print(next(f)) # print(next(f)) # print(next(f)) ‘‘‘ 迭代器的优点和缺点 优点： 1提供了一种不依赖下标的迭代方式 2就迭代器本期来说，更节省内存 缺点： 1无法获取迭代器对象的长度 2不如序列类型取值灵活，是一次性的，只能往后取值 ‘‘‘ l=[10000,2,3,4,5] # i=iter(l) # print(next(i)) # i.__iter__() i = enumerate(l) print(i.__next__()) print(next(i)) print(next(i)) print(next(i)) print(next(i))
标签：eve object print 结果 高阶函数 /usr name 注意 循环
原文地址：http://www.cnblogs.com/the-way-to-bifk/p/7774008.html
