函数名的运用

Posted 2021-01-07 zhao-peng-

函数名的运用：

1.函数名的内存地址

def func():
    print(‘呵呵‘)
print(func)

结果：
<function func at 0x0000000001D51E18>

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

def func():
    print(‘呵呵‘)
print(func)

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

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

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

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

def func():
    print(‘吃了吗‘)

def func(fn):
    print(‘我是func2‘)
    fn()   # 执行传递过来的fn
    print(‘我是func2‘)
func2(func)

5.函数名可以作为函数的返回值

def func():
    print(‘这里是函数1‘)
    def func():
        print(‘这里是函数2‘)
     print(‘这里是函数1‘)
     return func_2
fn = func_1()  # 执行函数1，函数1返回的是函数2，这是fn指向的就是上面的函数2
fn()  # 执行上面的函数

.闭包

闭包：是内层函数，对外层函数（非全局）的变量的引用

def func1():
    name = ‘alex‘
    def func2():
        print(name)
    func2()
func1()

结果：
alex

我们可以使用__closuer__来检测函数是否是闭包。使用函名.__closuer__返回cell就是闭包，返回None就不是闭包。

def func1():
    name = ‘alex‘
    def func2():
    print(name)
 func2()
 print(func2.__closuer__)  
 
结果：alex
(<cell at 0x0000000002178588: str object at 0x00000000024F9308>,)

如何在函数内外调用内部函数

def outer():
    name = ‘alex‘
    # 内部函数
    def inner():
        print(name)
    return inner
 fn  = outer()  # 访问外部函数，获取到内部函数的函数地址
 fn()   # 访问内部函数
 
  结果： alex

多层嵌套

def func1():
    def func2()
        def func3()
            print(‘嘿嘿‘)
         return func3
     return func2
func()()()

.迭代器

s = ‘abc‘
for c in s:
    print(c)   #  对的
    
 for i in 123:
    print(i)   #  错的
    
结果：
Traceback (most recent call last):
  File "E:/python s16/day11 闭包和迭代器/code/day011 迭代器和闭包/05  迭代器.py", line 111, in <module>
    for i in 123:
TypeError: ‘int‘ object is not iterable

报错信息中有这么一句话：‘int‘ object is not iterable。整数是不可迭代对象。 iterable 表示可迭代的，表示可迭代协议。

如何判断按数据类型是否符合可迭代协议，我们可以通过dir函数来查看类中定义好的所有方法。

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

在打印结果中，寻找__iter__如果能找到，那这个类的对象就是一个可迭代对象。 迭代器.py"

[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__dir__‘,
 ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, 
 ‘__getitem__‘, ‘__getnewargs__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘,
  ‘__init_subclass__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘,
   ‘__mod__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ]

tuple,list,open,set,dict,进行for 循环的内容都有__iter__函数，包括range。 这是查看一个对象是否可迭代对象的第一种办法，我们还可以通过isinstence()函数来查看一个对象是什么类型的。

l = [1,2,3,]
l__iter = l,l.__iter__()
form collections import Iterable
form collections import Iterable
print(isinstence(l,Iterable))  # True
print(isinstence(l,Iterator))  # False
print(isinstence(l__iter__,Iterabtor))  # True
print(isinstence(l__iter__,Iterable))   # True

通过以上代码，我们可以确定，如果对象中有__iter__函数，那我们可以认为这个对象遵守了可迭代协议。 就可以获取到相应的的迭代器。这里的__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循环（必须掌握）

lat = [1,2,3,]
lst__iter = lst.__iter__()  
while True:
    try；
        i = lst__iter__.__nexy__()
        print(i)
    except StopIteration:
        break

.总结：

lterable:可迭代对象,内不包含函数__iter__()函数
lterator:迭代器，内部包括含__tier__()同时包含__next__().
迭代器的特点：
    1.节省内存
    2.惰性机制
    3.不能反复，只能向下执行