函数名的本质

函数名本质上就是函数的内存地址

函数名的五种运用:

 1、函数名是一个变量

def func():
    print(666)
print(func)    # 函数的内存地址 <function func at 0x000002B6D2559AE8>

2、函数名可以当做变量赋值

def func():
    print(666)
f1 = func
f2 = f1
f2()                

3、函数名可以当做容器类数据类型的元素

def func1():
    print(111)
def func2():
    print(222)
def func3():
    print(333)
l1 = [func1, func2 ,func3]
for i in l1:
    i()

4、函数名可以当做函数的参数

def func(x):   #  x  == func1
    x()
    print('in func')
def func1():
    print('in func1')
func(func1)

5、函数名可以当做函数的返回值

def func(x):  # x ---> func1
    return x  # func1

def func1():
    print('in func1')

ret = func(func1)  #  ret = func1
ret()     # func1()
func(func1)()  # x() == func1()

满足3,4,5 函数名也称为第一类对象

闭包:

什么是闭包:

def func():
    name = 666
    print(111)
    def func1():
        print(name)  # 这就是闭包, 内层函数对外层函数(非全局)变量的引用
    func1()
func()
1,内层函数对外层函数(非全局)变量的引用。
2,闭包只存在于内层函数中。
3,函数都要逐层返回,最终返回给最外层函数。
def func():
    name = 'alex'
    def inner():
        print(name)
    return inner           
f = func()    #  f = inner
f()

闭包的判断

f.__closure__[0].cell_contents   闭包引用的外部变量
def func():
    name = 'alex'
    age = 19
    def inner():
        print(name)
        print(age)
    return inner
f = func()         # 定义f,因为f是闭包
# 获取闭包引用的外层变量,如果不是闭包则报错
print(f.__closure__[0].cell_contents)  #固定用法  19
print(f.__closure__[1].cell_contents)  # alex

闭包有什么用?

闭包:解释器执行程序时,如果遇到函数,随着函数的结束而关闭临时名称空间,但是!!!如果遇到闭包,有一个机制:那么闭包的空间不会随着函数的结束而关闭。

def wrapper(step):
    num =1
    def inner():
        nonlocal num
        num += step
        print(num)     # 输出 4   7   10  13  16
    return inner
f = wrapper(3)
j = 0
while j < 5:
    f()
    j += 1

闭包就是在内存中开一个空间,常贮存一些内容,以便后续程序调用
闭包的应用:
1、装饰器
2、爬虫

迭代对象:
iterable: 可迭代对象
内部含有__iter__方法的就是可迭代对象,遵循可迭代协议
s1 = 'barry'
l1 = [1, 2, 3]
print('__iter__' in dir(s1))  # True  是可迭代对象

可迭代对象不能直接取值(含索引的迭代对象除外) ,需要转换成迭代器才能取值

迭代器

迭代器:内部含有'__iter__'并且含有'__next__'方法的就是迭代器,遵循迭代器协议。

可迭代对象转换成迭代器:

  可迭代对象.__iter__()

  obj = iter(可迭代对象)

 

判断一个一个对象是否是迭代器(含iter,next)或迭代对象

 方法一:  看__iter__ , __next__  在不在dir() 里面

s1 = 'abcdefg'
obj = iter(s1)    # 将s1转换成迭代器
print('__iter__' in dir(s1))   # True
print('__iter__' in dir(obj))  # True
print('__iter__' in dir(s1) and '__next__' in dir(s1))  # False
print('__iter__' in dir(obj) and '__next__' in dir(obj)) # True
方法二:   isinstance(obj, Iterable/Iterator)
s1 = 'abcdefg'
obj = iter(s1)    # 将s1转换成迭代器
from collections import Iterable   # 迭代对象
from collections import Iterator   # 迭代器
print(isinstance(obj,Iterator))  # 判断obj是否为迭代器     True
print(isinstance(obj,Iterable))  # 判断obj是否为可迭代对象 True
print(isinstance(s1,Iterator))   # 判断obj是否为迭代器     False
print(isinstance(s1,Iterable))   # 判断obj是否为可迭代对象 True

迭代器取值

s2 = [1, 2, 3]
obj = iter(s2)
print(obj.__next__())    # 方法一
print(next(obj))            # 方法二
type() isinstance()区别?

# type()只是判断该对象的数据类型
# isinstance()不仅可以判断该对象的数据类型,而且可以判断其他很多

迭代器的作用:
1、节省内存
2、惰性机制 (netx())一下,出一个值
3、一条路走到黑,不走回头路

While循环模拟for循环机制
l1 = [i for i in range(10)]
obj = iter(l1)
while 1:
    try:     # 试一试,如果报错就执行下面的命令
        print(next(obj))
    except StopIteration:  
        break

 




 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  

posted on 2019-01-02 19:42  拾玥大熊  阅读(129)  评论(0编辑  收藏  举报