函数名的使⽤以及第⼀类对象 闭包 迭代器

一丶函数名的应用

函数名是一个变量,但它是一个特殊的变量,与括号配合可以执行函数的变量.

1.函数名的内存地址

def func():
 print("呵呵")
print(func)
结果:
<function func at 0x1101e4ea0>

2.函数名可以赋值给其他变量

def  func():
    print("呵呵")
    
print(func)

a = func    #把函数当成一个变量赋值给另一个变量  
a()    #函数调用   func()

3.函数名可以当做容器类的元素

def func1()
　　print("呵呵")
def func2()
      print("呵呵")
def func3
      print("呵呵")
list    = [func1,func2,func3]
for i in lst:
    i()

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

def my():
    print("我是my")

def proxy(fn): # 代理模式. 装饰器
    print("在处理之前")
    fn()
    print("在处理之后")

proxy(my) # 把函数名作为参数传递给另一个函数

5.函数名可以做函数的返回值

def func_1():
 print("这⾥是函数1")
 def func_2():
 print("这⾥是函数2")
 print("这⾥是函数1")
 retururn_2

fn = func_1() # 执⾏函数1. 函数1返回的是函数2, 这时fn指向的就是上⾯函数2
fn() # 执⾏上⾯返回的函数

二丶闭包

闭包. 在内层函数中访问外层函数的变量
闭包的作用:
    1. 可以保护你的变量不收侵害
    2. 可以让一个变量常驻内存
我们可以使⽤__closure__来检测函数是否是闭包. 使⽤函数名.__closure__返回cell就是闭包,返回none 就不是闭包.

def func1():
 name = "alex"
 def func2():
 print(name) # 闭包
 func2()
 print(func2.__closur__) # (<cell at 0x10c2e20a8: str object at
0x10c3fc650>,)
func1()

　　函数外部调用内部函数

def outer():
 name = "alex"
 # 内部函数
 def inner():
 print(name)
 return inner
fn = outer() # 访问外部函数, 获取到内部函数的函数地址
fn() # 访问内部函数

在闭包中. 如果变量被销毁了. 那内部函数将不能正常执⾏. 所
以. python规定. 如果你在内部函数中访问了外层函数中的变量. 那么这个变量将不会消亡.
将会常驻在内存中

扫描二维码关注公众号，回复： 2721735 查看本文章

from urllib.request import urlopen

def but():
 content = urlopen("http://www.xiaohua100.cn/index.html").read()
 def get_content():
 return content
 return get_content
fn = but() # 这个时候就开始加载校花100的内容
# 后⾯需要⽤到这⾥⾯的内容就不需要在执⾏⾮常耗时的⽹络连接操作了  
content = fn() # 获取内容
print(content)
content2 = fn() # 重新获取内容
print(content2)

闭包的作⽤就是让⼀个变量能够常驻内存. 供后⾯的程序使⽤.

三丶迭代器

 我们可以通过dir函数来查看类中定义好的所有⽅法. 

s = "我的哈哈哈"
print(dir(s)) # 可以打印对象中的⽅法和函数
print(dir(str)) # 也可以打印类中声明的⽅法和函数

在打印结果中. 寻找__iter__ 如果能找到. 那么这个类的对象就是⼀个可迭代对象. (进⾏for循环的东⻄都有__iter__函数, 包括range也有)　　　　

我们还可以通过isinstence()函数来查看⼀个对象是什么类型的

l = [1,2,3]
l_iter = l.__iter__()
from collections import Iterable
from collections import  Iterator
print(isinstance(l,Iterable)) #True
print(isinstance(l,Iterator)) #False
print(isinstance(l_iter,Iterator)) #True
print(isinstance(l_iter,Iterable)) #True

这⾥的__iter__是帮助我们获取到对象的迭代器. 我们使⽤迭代
器中的__next__()来获取到⼀个迭代器中的元素.

s = "我爱北京天安⻔"
c = s.__iter__() # 获取迭代器
print(c.__next__()) # 使⽤迭代器进⾏迭代. 获取⼀个元素 我
print(c.__next__()) # 爱
print(c.__next__()) # 北
print(c.__next__()) # 京
print(c.__next__()) # 天
print(c.__next__()) # 安
print(c.__next__()) # ⻔
print(c.__next__()) # StopIteration

for循环的机制:

for i in [1,2,3]:
print(i)

使⽤while循环+迭代器来模拟for循环

lst = [1,2,3]
lst_iter = lst.__iter__()
while True:
  try:
  i = lst_iter.__next__()
  print(i)
 except StopIteration:
 break

总结:
Iterable: 可迭代对象. 内部包含__iter__()函数
Iterator: 迭代器. 内部包含__iter__() 同时包含__next__().
迭代器的特点:
1. 节省内存.
2. 惰性机制
3. 不能反复, 只能向下执⾏.

it = lst.__iter__()

# 偏方
print("__iter__" in dir(it))
print("__next__" in dir(it))
可以通过dir来判断数据是否是可迭代的, 以及数据是否是迭代器

官方方案
from collections import Iterable  # 可迭代对象
from collections import Iterator    # 迭代器

print(isinstance(lst, Iterable))
print(isinstance(lst, Iterator))

print(isinstance(it, Iterable))
print(isinstance(it, Iterator))