a = 函数名 # a()

# print(func)  # 函数的内存地址

# def func():
#     print(1)
# a = func
# a()
# func()   # 函数名可以当做值赋值给变量

# def func():
#     print(1)
#
# def func2():
#     print(2)
#
# li = [func,func2]
# print(li)  # 函数名可以当做元素放到容器里

# 函数名可以当做值赋值给变量

# 函数名可以当做元素放到容器里

# def f():
#     def a():
#         def b():
#             def c():
#                 return '哈撒给!'
#             return c()
#         return b()
#     return a()
# print(f())

# 返回值函数名 # 返回函数名的时候不能加括号 # 函数名: 可以容器的元素 # 函数名可以当做参数被传递

# 2.闭包:

#     1.首先有一个嵌套函数#     2.嵌套函数内部函数调用非全局的变量
#       3.将内部函数名当做返回值返回,在全局调用
      # 怎么去查看闭包??
      # 函数名.__closure__ 返回None 就不是闭包

# 1.一个嵌套函数
# 2.在嵌套函数的内部函数使用外部(非全局的变量)
# 满足以上两条就是闭包


# def wrapper():
#     a = 10
#     def inner():
#        print(a)
#     # print(inner.__closure__) # 不是None 就是闭包
#     inner()
# wrapper()

# 全局里存放的变量会有污染和不安全的现象

# money = 10
# 全局里存放会有污染和不安全的现象

# def wrapper():
#     money = 10
#     def inner(num):
#         nonlocal money
#         money += num
#         print(money)
#     return inner
# wrapper()(100)
# python中闭包,会进行内存驻留, 普通函数执行完后就销毁了
# 全局里存放会有污染和不安全的现象
# 面试必问,装饰器 -- 装饰器的本质就是闭包
# 闭包有个弊端:会出现内存泄漏

# python中闭包,会进行内存驻留, 普通函数执行完后就销毁了
# 全局里存放会有污染和不安全的现象
# 面试必问,装饰器 -- 装饰器的本质就是闭包
# 闭包有个弊端:会出现内存泄漏

# 3.迭代器:

# 可迭代对象: 具有__iter__方法就是可迭代对象

# 迭代器: 具有__iter__方法,__next__就是迭代器

# for循环的机制就是迭代器,

# 可迭代对象:

    # 可以被for的就是可迭代对象
    # Python 协议
    # 具有.__iter__方法的就是可迭代对象
    # a = 对象.__iter__ # 创建一个迭代器

    # 具有__iter__和__next__就是一个迭代器

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

# li = [1,2,3]
# a = li.__iter__()
# a.__iter__()
# a.__next__()


# li = [1,2,3]
# a = li.__iter__()
# print(a.__next__())
# print(a.__next__())  #一个一个取
# print(a.__next__())

# 迭代器特性:
#     惰性机制
#     不能从下向上走
#     一次性的,用完就没了

for的机制

# for的机制:

# li = [1,2,3,4,6,7,87,8,9,90,0,0,0,0,8,7,7,67,]
# em = li.__iter__()
# while 1:
#     try:
#         print(em.__next__())
#
#     except StopIteration:
#         break

# for i in range(10):
#     print(i)

# 4.递归:

# 1. 自己玩自己 (自己调用自己本身)
# 2. 玩的有限制 (有明确结束条件)

import sys
# sys.setrecursionlimit(10)
# count = 0
# def func():
#     global count
#     count += 1
#     print(count)
#     if count == 500:
#         return
#     func()
# func()

# def func(n): # n+=1 # print(n) # if n == 100: # return # func(n) # func(0)

# 1,1,2,3,5,8,13,21,34,55

# 超出了递归的最大层次 # 递归默认层次,官方说明 1000,实际测试 998/997

测试值根据每个电脑的配置不同,测试数值也不一样,nb的电脑可以达到999,有兴趣的可以试试看自己的电脑能不能999!

# def func(n): # n+=1 # print(n) # if n == 5: # return # func(n) # func(2)

# 递归的效率比较低,尾递归的用时和 for的用时是一样的,比for慢

# 递归的应用场景:

# 在不明确要循环的次数时候,可以用递归

# 递归操作文件目录

11函数名的使用,迭代器,递归

a = 函数名 # a()

# 2.闭包:

# 3.迭代器:

# 4.递归:

猜你喜欢