Python函数Day3

一、函数名的应用

函数名类似于特殊的变量，打印函数名就是打印函数的内存地址

① 函数名就是函数的内存地址

def func():
    pass

>>>func
<function func at 0x000001C0BDDAF400>

② 函数名可以作为变量

def func():
    print(666)

f = func
f()         # f() == func()

③ 函数名可以作为函数的参数传入

def func1():
    print(666)

def func2(x):
    x()             # x() == func1()

func2(func1)

④ 函数名可以当作函数的返回值

def fun1():
    def fun2():
        print(666)
    return fun2

f = fun1()      # f = fun2
f()             # f() == fun2()

⑤ 函数名可以作为容器类类型的元素

def func1():
    print(111)

def func2():
    print(222)

def func3():
    print(333)

li = [func1,func2,func3]
for i in li:
    i()             # func1(),func2(),func3()

Python中一切皆对象，函数名就是第一类对象

global()　　　　#  将所有全局变量以字典的形式返回

a = 1
b = 2
c = 3
print(globals())

# 结果
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001F867E586A0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/Day11/exercise.py', '__cached__': None, 'a': 1, 'b': 2, 'c': 3}

locals()  　　　　# 将当前作用域（当前位置）的局部变量以字典的形式返回

def func():
    a = 1
    b = 2
    c = 3
    print(locals())

>>>func()
{'c': 3, 'b': 2, 'a': 1}

LEGB

二、闭包

装饰器的本质就是闭包

面试题：闭包在哪里使用？（爬虫和装饰器会用到闭包）

定义：内层函数对外层函数的变量（非全局变量）的引用，并将函数名返回，这样就形成了闭包。

子函数对父级函数的变量进行引用，并且返回函数名，就是闭包。

函数内部定义的函数称为内部函数，内部函数包含对外部作用域而非全剧作用域变量的引用，该内部函数称为闭包函数

def wraaper():
    name = 'xiaoming'
    def inner():
        print(name)
    inner()
    return inner
wraaper()

# 结果
xiaoming

函数名.__closure__

name = 'xiaoming'
def wraaper(args):
    def inner():
        print(args)
    inner()
    print(inner.__closure__)
    return inner

wraaper(name)

# 结果
xiaoming
(<cell at 0x000001CAD4F678B8: str object at 0x000001CAD4E40A30>,)

返回None就不是闭包

name = 'xiaoming'
def wraaper():
    def inner():
        print(name)
    inner()
    print(inner.__closure__)
    return inner

wraaper()

# 结果
xiaoming
None

闭包的作用：

　　当程序执行时，遇到了函数执行，它会在内存中开辟一个空间，叫局部名称空间，随着函数的结束而消失。

　　如果这个函数内部形成了闭包，那么它就不会随着函数的结束而消失，在内存中会一直存在。

三、迭代器

可迭代对象：对象内部含有__iter__方法就是可迭代对象

可迭代对象：str（字符串）、list（列表）、dict（字典）、tuple（元组）、set（集合）、range()

可以被迭代要满足的要求就叫做可迭代协议。可迭代协议的定义非常简单，就是内部实现了__iter__方法。

判断对象是否可迭代对象的方法：

① 判断__iter__是否在对象的方法中，用dir()

dir() 查看对象内的所有属性和方法

s = 'abcde'
print('__iter__'in dir(s))          # dir() 查看对象内的所有属性和方法

# 结果
True

②  isinstance() 判断是否可迭代对象

iisinstance() 判断是否属于某个已知类型，sinstance() 能判断从属于哪种类型，type()判断哪种基本数据类型

from collections import Iterable
li = [1,2,3,4,5]
print(isinstance(li,Iterable))         # 判断对象是否可迭代对象

迭代器：对象内部含有__iter__方法且含有__next__方法就是迭代器

判断对象是否迭代器

① 对象是否含有__iter__和__next__方法

li = [1,2,3,4,5]
print('__iter__' in dir(li))
print('__next__' in dir(li))

#  结果
True
False

② isinstance 判断是否迭代器

from collections import Iterator
dic = {'a':1 ,'b':2 ,'c':3}
print(isinstance(dic,Iterator))

# 结果
False

可迭代对象是不能取值，迭代器就是通过__next__方法可以一个一个取值。

for循环可迭代对象是for循环内部做了优化才能取值，for含有__next__方法，因为可迭代对象没有__next__方法

四、可迭代对象可以转化为迭代器

转化方法一：__iter__() 方法

from collections import Iterator
dic = {'a':1 ,'b':2 ,'c':3}
itel = dic.__iter__()               # 转化为迭代器
print(itel)                         # 打印是否迭代器
print(isinstance(itel,Iterator))    # 判断对象是否迭代器

# 结果
<dict_keyiterator object at 0x000002049DC76868>
True

转化方法二： iter() 方法

from collections import Iterator
li = ['a','b','c',1,2,3]
itel = iter(li)                     # 转化为迭代器
print(itel)                         # 打印是否迭代器
print(isinstance(itel,Iterator))    # 判断对象是否迭代器

# 结果
<list_iterator object at 0x0000016BEA6F7748>
True

五、迭代器的取值

迭代器的取值方式：通过__next__()方法取值，next一次取一个值

Iterator.__next__()

li = ['a','b','c',1,2,3]
itel = iter(li)                     # 转化为迭代器
i = itel.__next__()                 # 通过__next__()方法取值
print(i)
i = itel.__next__()                 # 通过__next__()方法取值
print(i)

# 结果
a
b

六、迭代器的好处：

① 可迭代对象不能取值，迭代器是可以取值的

② 迭代器非常节省内存 （__next__()一次就加载一个，加载下一个元素后，上一个元素就会释放掉，跟for的机制相似）

③ 迭代器每次在内存中只会取一个值（一个 next 对应取一个值）

④  迭代器单向的，不反复，一条路走到头。next下一个就找不到上一个了，只能全部取完再重新找

迭代器的使用：

① 迭代器没索引，为了取值

② 数据量大的时候

for 循环机制：

① 将可迭代对象转化为迭代器

② 调用__next__()方法取值

③ 利用异常处理停止报错

while 循环模拟for循环的机制

s1 = 'abcdefghijklmn'
iter = s1.__iter__()

while 1:
    try:
        print(iter.__next__())
    except StopIteration:
        break

文件就是迭代器