函数

函数对象

函数是第一类对象:函数名 指向的值可以被当做参数传递
1 函数名可以被传递

name = 'jason'
x = name
print(x)
print(id(x))
def func():
    print('fron func')  # fron func
f=func

func()
print(f)  # <function func at 0x00000000023E2E18>
f()  # fron func     虽然也是调用了函数   但是只想的也是函数func只想函数体代码的内存地址

2 函数名可以被当做参数传递给其他函数

def  func():
    print('from func')
def index(args):
    print(args)  # <function func at 0x0000000002412E18>
    args()  # 此处的args是func   所以调用func()     打印出   from func
    print('from index')  # from index
index(func)
#

3 函数名可以被当做函数的返回值

def index():
    print('index')  # index
def func():
    print('func')  # func
    return index
res = func()
print(res)  # <function index at 0x0000000002412E18>
res()

4 函数名可以被当作容器类型的参数

def func():
    print('func')
print(func())
l = [1,2,func,func()]  # [1,2,<function func at 0x000001F7D79899D8>,None]
print(l)
#

循环打印功能

def register():
    username = input('username>>>:').strip()
    pwd = input('password>>>:').strip()
    print(username,pwd)
    print('register ...')
def login():
    print('login ...')
def transfer():
    print('transfer ...')
def shopping():
    print('shopping...')
def pay():
    print('pay ...')

msg = """
1 注册
2 登陆
3 转账
4 购物
5 支付
"""
func_dict = {
    '1':register,
    '2':login,
    '3':transfer,
    '4':shopping,
    '5':pay,
}
while True:
    print(msg)
    choice = input('请现在你想要执行的功能>>>:').strip()
    if choice in func_dict:
        func_dict.get(choice)()  # 函数名()

# '''
# 这种写法会犯了python的忌讳  写重复代码     和代码冗余
#     if choice == '1':
#         register()
#     elif choice == '2':
#         login()
#     elif choice == '3':
#         transfer()
#     elif choice == '4':
#         shopping()
#     elif choice == '5':
#         pay()
# '''
    else:
        print('你输入的功能暂时没有')

函数的嵌套的调用和定义

嵌套的好处
    1 可以将复杂逻辑进行简化
    2 可以在函数内部调用其他函数(因为函数在定义之后就是可以随处调用的)

定义
    可以通过不同的情况   面对不同的参数  直接控制需要的调用的函数去执行功能

def index():
    func()
    print('index')

def func():
    # index()
    print('func')
index()

def my_max(x,y):
    if x > y:
        return x
    return y

def my_max4(a,b,c,d):
    res1 = my_max(a,b)
    res2 = my_max(res1,c)
    res3 = my_max(res2,d)
    return res3
print(my_max4(1,2,10,4))   # 10 如果数字还要增加   那么就按照这样的逻辑继续仿照比较就行

嵌套的写法(装饰器)

def outer():
    x = 1
    print('outer')
    def inner():
        print('inner')
    # print(inner)
    return inner

res = outer()
# print(res)
res()

名称空间

1 名称空间的分类
    内置名称空间
        python解释器已经定义好的具有功能的函数 打开python的以后就可以时候
    全局名称空间
        在执行文件时，存放文件级别定义的名字
    局部名称空间
        在执行文件的过程中，如果调用了函数，则会产生该函数的名称空间，
        用来存放该函数内定义的名字，该名字在函数调用时生效，调用结束后失效
    加载顺序：内置名称空间------>全局名称空间----->局部名称空间


2 他们的生命周期(存活时间)

　　　　 内置名称空间
            只要python解释器已启动立马创建   关闭python解释器的时候内置名称空间自动销毁
        全局名称空间
            只要你右键运行py文件会自动创建   py文件程序运行结束自动销毁
        局部名称空间
            在函数被调用的时候自动创建  函数指向结束立即销毁(动态创建动态销毁)

作用域

作用域:  名称空间可以工作的范围
全局作用域  任何地方都能使用   全局有效
            全局名称空间和内置名称空间都是全局作用域
局部作用域  部分可以使用   局部有效
            局部名称空间属于局部作用域

global  和nonlacal  关键字的使用
global:将局部变量升级成为全局变量  也就是将当前的全局变量进行修改
       但是这里仅仅是修改全局变量   没有创建局部名称空间

global局部修改全局

x = 1  # 不可变类型
username = 'jason'
def func():
    global x,username  # 修改全局变量 而不是创建局部名称空间
    x = 999
    username = 'egon'
func()
print(x)   # 999
print(username)   # egon

nonlocal  局部修改局部

def func():
    x = 1
    def index():
        nonlocal x
        x = 2
    index()
    print(x)  # 2
func()

ps: global:局部修改全局 如果想修改多个 逗号隔开
    nonlocal:局部修局部 如果想修改多个 逗号隔开