python之路——函数名的应用，闭包，迭代器

Posted 2020-12-30 chenhuping

 

# ##函数名的应用
# def func():
#     print(666)
# func()
#
# 1.函数名就是函数的内存地址
# print(func)     #结果<function func at 0x000002AC2188C1E0>

# 2.函数名可以作为变量
# a = 2
# b = a
# c = b
# print(c)

# def func1():
#     print(666)
# f1 = func1()
# f2 = f1
# f2()

# 3.函数名可以作为函数的参数
# def func1():
#     print(666)
# def func2(x):
#     print(x)    #<function func1 at 0x0000026C3D983BF8>
# x()
# func1()

# def func():
#     print(666)
# def func1():
#     print(123)       # 疑问
#     func()
# def func2(x):
#     x()
# func2(func1)

# 4.函数名可以当作函数的返回值
# def wraaper():
#     def inner():
#         print(‘inner    ‘)
#     return inner
# ret = wraaper()     # inner
# ret()   # inner()

# def func2():
#     print(‘in func‘)
#
# def func3(x):
#     print(‘in func3‘)
#     return x
# f1 = func3((func2()))

# f1()
# 5.函数名可以作为容器类类型的元素
# a = 6
# b = 4
# c = 5
# l1 = [a,b,c]
# print(l1)

# def func1():
#     print(‘in func1‘)
# def func2():
#     print(‘in func2‘)
# def func3():
#     print(‘in func2‘)
# def func4():
#     print(‘in func4‘)
# l1 = [func1,func2,func3,func4]
# for i in l1:
#     i()

# 向上面的函数名这种，第一类对象

#   #返回当前位置的局部变量的字典globals()  locals()
# # globals() #返回全局变量的一个字典
# # locals()

# def func1():
#     a= 2
#     b = 3
#     print(globals())    #返回全局变量的一个字典
# func1()

# def func1():          #返回当前位置局部变量的一个字典
#     a = 2             # {‘a‘: 2, ‘b‘: 3}
#     b = 3
#     print(locals())
# func1()

# 闭包
# 内层函数对外层函数的变量(非全局变量)的引用
# 并返回，这样就形成了闭包

# def wraaper():
#     name = ‘alex‘         #最里层函数调用了上一级的局部变量
#     def inner():          #内存种不会立刻消失，再在函数里面
#         print(name)       #调用的话可以调用成功
#     print(inner.__closure__)
#     inner()
#     def qwe():
#         print(name)
#     qwe()
#     return inner
#
# wraaper()
# print(name)

‘‘‘闭包的作用
    当程序执行时，遇到了函数执行，他会在内存开辟一个空间，
    局部名称空间，如果这个函数内部形成了闭包
    那么他就不会随着函数的结束而消失。
‘‘‘
#可迭代对象

#对象内部含有_iter_方法就是可迭代对象。
# 可迭代对象满足可迭代协议
# 可迭代对象
#str list dict tuple set ranger()

# s1 = ‘strs‘
# print(dir(s1))   #可以查字符串的所有方法

# 判断一个对象是否是可迭代对象
# 第一个方法
# dic = {‘name‘:‘alex‘,‘age‘:‘18‘}
# print(‘__iter__‘ in dir(dic))
# print(dir(dic))

# s1 = [1,2,3]
# print(dir(s1))
# 第二种方法
# from collections import Iterable
# from collections import Iterator
#
# print(isinstance(‘alex‘,Iterable))
# print(isinstance(‘alex‘,Iterator))  # True

# print(isinstance(‘alex‘,str))

# 迭代器
# 对象内部含有__iter__方法且含有__next_方法就是迭代器
# 一个文件句柄就是一个迭代器
# f = open(‘t1.txt‘,encoding=‘utf-8‘,mode=‘r‘)
# print(‘__iter__‘ in dir(f))     #True
# print(‘__next__‘ in dir(f))     #True
# print(‘__iter__‘ in dir(dict))  #False
# print(‘__next__‘in dir(dict))   #False

# dic = {‘name‘:‘alex‘}
# print(‘__iter__‘ in dir(dic))   #True

# 可迭代对象和迭代器的区别
# 可迭代对象不能取值,迭代器是可以取值的
# 可迭代对象可以转化为迭代器

# lis = [1,2,3,4,5,6]
# ite1 = lis.__iter__()  #迭代器
# ite1 = iter(lis)
# print(ite1)     #itel的内存地址
# print(ite1.__next__())  #取迭代器第一个值

# l1 = {‘name‘:‘alex‘}
# l2 = l1.__iter__()
# # l3 = iter(l2)
# print(l2.__next__())

# l1 = [1,2,3,4,5,6,7,8,9,10]
# l2 = l1.__iter__()
# print(l2.__next__())

# 将可迭代对象转化为迭代器
# 迭代器 = 可迭代对象.__iter__()

# 迭代器如何取值?    next一次,去一个值
# print(ite1.__next__())
# print(ite1.__next__())
# print(ite1.__next__())
# print(ite1.__next__())
#调用__next__取值

# 1.可迭代对象不能取值,迭代器是可以取值的
# 2.迭代器非常节省内存
# 3.迭代器每次只能取一个值
# 4.迭代器是单向的,一条路走到头

# 利用异常处理停止报错
# try

# s1 = ‘1233456‘
# s = s1.__iter__()
# while 1:
#     try:
#         print(s.__next__())
#     except StopIteration:
#         break