7 python--高阶函数和迭代器

把函数作为参数传入，这样的函数称为高阶函数

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