【Finish】Python Day 10

# 函数：可读性强 复用性强

# def 函数名（）：

　　# 函数体

　　# return 返回值

# 所有函数：只定义不调用则一定不执行；

　　　　　　# 先定义后调用

# 函数名（）不接受返回值

# 返回值 = 函数值（）接受返回值

# 返回值：

　　# 没有返回值；

　　　　不写return：函数内的代码执行完毕则自动结束，

　　　　只写return：结束一个函数

　　　　return none

　　# 返回一个值；结束了函数且返回一个值，可以是任意值

　　# 返回多个值：多个值之间用逗号隔开，接收的时候 可以使用1个或者等量的多个变量接收（元祖）

# 参数

　　# 形参：定义函数的时候

　　　　　　# 位置参数：必须传

　　　　　　# *args：动态参数 可以接受任意多个按照位置传入的参数

　　　　　　# 默认参数：可以不穿 —— 陷阱

　　　　　　#  **kwargs：动态参数 可以接受任意多个按照关键字传入的参数

　　# 实参：调用函数的时候

　　　　　　# 按照位置传参数

　　　　　　# 按照关键字传参数

　　　　　　　　# 可以混用 位置参数必须在关键字传参之前

　　　　　　　　# 不能对一个参数重复赋值

　　　　　　

# 如果默认参数的值是一个可变的数据类型，那么每一次调用函数的时候，如果不传值就公用这个数据类型的资源

# 函数的进阶
# 命名空间和作用域

# 命名空间
# 内置命名空间——Pyhton解释器
      # 就是Python解释器，已启动就可以使用的名字存储在内置命名空间中
      # 内置的名字在启动解释器的时候被加载进内存

# 全局命名空间——我们写的代码但是非函数中的代码
    # 在程序从上到下被执行的过程中 依次被加载进内存里
    #  放置 了我们设置的所有变量名 和 函数名

# 局部命名空间——与函数有关系
    # 就是函数内部定义的名字
    # 当调用函数的时候才会产生这个名称空间，随着函数执行的技术，这个命名空间就又消失了

# 在局部：可以使用全局命名空间 和 内置命名空间 中的名字
# 在全局：可以使用内置命名空间中的名字，但是不能局部中使用
# 在内置：不能使用局部和全局空间中的名字

# 在正常情况下，直接使用内置的名字
# 当我们在全局定义了和内置名字空间中同名的名字时，会使用全局的名字
# 当我自己有的时候 不找上级要了
# 如果自己没有，则找上一级要，上一级没有再找上一级 如果内置空间都没有 就报错
# 多喝函数应该拥有多个独立的局部空间，不互相共享

# def func():
#     # input = 1
#     print(input)
#
# func    # 指向函数的内存地址
# func()  # 函数的调用 = 函数的内存地址 + ()
# print(func)

# 作用域
# 全局作用域——作用域在全局——内置和全局名字空间都属于全局作用域 —— globals
# 局部作用域——作用在局部——函数（局部空间中的名字属于局部作用域）—— 使用locals查看局部作用域
# 对于不可变数据类型，在局部可查看全局作用域的变量
# 但是不能直接修改
# 如果想要修改，需要再程序的一开始就添加global申明
# 如果在一个局部函数内声明了一个global变量，那么这个变量在局部的所有操作将对全局的变量有效
# globals用于答应全局的名字
# 把locals放在全局，本地则是全局；如果locals放在局部，本地则是局部 —— 输出什么 是 根据locals的位置

# a = 1
# def func():
#     global a
#     a += 2
# func()
# print(a)

# a = 1
# b = 1
# def func():
#     x = 'aaa'
#     y = 'bbb'
#     print(locals())
# func() # {'y': 'bbb', 'x': 'aaa'}

# a = 1
# b = 1
# def func():
#     x = 'aaa'
#     y = 'bbb'
#     print(globals())
# func() #{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x101fbc3c8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/wonderful0714/PycharmProjects/selflearningproject/day10.py', '__cached__': None, 'a': 1, 'b': 1, 'func': <function func at 0x101f61e18>}


# a = 1
# b = 1
# def func():
#     x = 'aaa'
#     y = 'bbb'
# func()
# print(locals())# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x101fbc3c8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/wonderful0714/PycharmProjects/selflearningproject/day10.py', '__cached__': None, 'a': 1, 'b': 1, 'func': <function func at 0x101f61e18>}
# print(globals())#{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x101fbc3c8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/wonderful0714/PycharmProjects/selflearningproject/day10.py', '__cached__': None, 'a': 1, 'b': 1, 'func': <function func at 0x101f61e18>}

# 闭包 ： 嵌套函数，内部函数调用外部函数的变量
# def outer():
#     a = 1
#     def inner():
#         print(a)
#     print(inner.__closure__) # (<cell at 0x1040a9f78: int object at 0x1009dfc80>,) cell 表示 闭包
#
# outer()

# def outer():
#     a = 1
#     def inner():
#         print(a)
#     return inner
# inn = outer()
# inn() # 1

# import urllib   # 模块
# from urllib.request import urlopen
# def get_url():
#     url = 'http://www.baidu.com'
#     def inner():
#         ret = urlopen(url).read()
#         print(ret)
#     return inner()
# get_func = get_url()
# get_func

# # 函数的嵌套和作用域
# def max(a,b):
#     return a if a>b else b
#
# def the_max(x,y,z):
#     c = max(x,y)    # 函数的嵌套
#     return  max(c,z)
#
# print(the_max(1,2,3))

# 函数的嵌套定义
# 内部函数可以使用外部函数的变量
# nonlocal 只能用于局部变量 找上层中离当前函数最近一层的局部变量，声明了nonlocal的内部函数的变量修改会影响到离当前函数最近一层的局部变量
# nonlocal 对全局无效；对局部也只是对最近一层有影响
# a = 1 # 全局变量
# def outer():
#     a = 1 # 局部变量，不受global a的影响
#     def inner():
#         a = 3
#         b = 2
#         def inner2():
#             # global a    # 申明了一个全局变量
#             nonlocal a  # 申明了一个上层的局部变量，作用范围，自下往上找到的第一个变量
#             a += 1
#             # a += 1    # 不可变数据类型的修改
#             print('inner2：'+ str(a))
#             print(b)
#         inner2()
#         print('inner：'+str(a))
#     inner()
#     print('outer：'+str(a))
# outer()
# print(str(a))

# 打印结果
# inner2：4
# 2
# inner：4
# outer：1
# 1

# 重要
def func():
    print(123)

func()  # 函数名就是内存地址
fun2 = func # 函数名可以赋值
fun2()

l = [func,fun2] # 函数名可以作为容器类型的元素
print(l)    # [<function func at 0x101e61e18>, <function func at 0x101e61e18>]

def wahaha(f):
    f()
    return f
z = wahaha(func)    # 函数名可以作为函数的参数