名称空间,全局变量,局部变量，函数名的调用与多种用法

1. 名称空间

# 名称空间表示的是存放变量名与变量值绑定关系的地方

# 名称空间的分类
# 1.内置名称空间
# python解释器提前给我们定义好的
# len方法,print方法,del方法
# 2.全局名称空间
# 在py文件中编写的代码运行产生的名字都会存到全局名称空间
name = '李四'  # 变量名李四存入全局名称空间


def print_python_cat():  # 函数名print_python_cat存入全局名称空间
    pass


if True:
    python_cat = 111  # 变量名python_cat存入全局名称空间

for i in range(10):  # 变量名i存入全局名称空间
    pass

while True:
    cat = 222  # 变量名cat存入全局名称空间

# 3.局部名称空间
# 函数体代码运行产生的都是局部名称空间
def print_python_cat():
    name = '李四'  # name存入局部名称空间

# 存活周期
# 1.内置名称空间
# python解释器运行 产生
# python解释器关闭 销毁

# 2.全局名称空间
# py文件开始运行 产生
# py文件运行结束 销毁

# 3.局部名称空间
# 函数体代码开始运行 产生
# 函数体代码运行结束 销毁

 

2. 名字的查找顺序

# 在查找名字的时候 一定要先搞清楚自己在哪个空间
# 1.如果在局部名称空间
#     局部名称空间 >>> 全局名称空间 >>> 内置名称空间

# 2.如果在全局名称空间
#     全局名称空间 >>> 内置名称空间
# 想办法让三个名称空间中都有相同的名字

sum = '我是全局名称空间中的sum'
def print_python_cat():
    sum = '我是局部名称空间中的sum'
    print(sum)
print_python_cat()  # 调用函数 函数体就会执行 就会产生局部名称空间
print(sum)


index = 111
"""如果函数没有被调用 那么不要去管函数体代码有多复杂 先跳过"""
def print_python_cat1():
    index = 222
    def print_python_cat2():
        index = 333

print_python_cat1()



def print_python_cat1():
    index = 222
    def print_python_cat2():
        index = 333
        def print_python_cat3():
            # print(index)
            # 检测语法的时候 发现print_python_cat3的局部名称空间将来会有index 所以查找的时候就跟print_python_cat3的局部名称空间要(特例 可以忽略)
            # 但是又因为输出是在前面,index赋值在后面,获取不了index,提示定义前被调用
            index = 444
            # print(index)
        print_python_cat3()
    print_python_cat2()
print_python_cat1()


'''局部名称空间之间如果不是嵌套关系 那么互不干涉!!!,除非将此变量改为全局变量'''
def index1():
    name = 'jason'
def index2():
    age = 18
    # print(name)
    # 报错
index1()
index2()

 

3. 作用域

# 作用域就是名称空间能够作用的范围
内置名称空间
    程序任意缩进任意函数任意位置均可使用(全局有效)
全局名称空间
    程序任意缩进任意函数任意位置均可使用(全局有效) 
局部名称空间 
　　一般情况下只在各自局部名称空间中有效(局部有效) '''也可以通过一些手段打破规则'''

 

4. Global与Nonlocal关键字

'''global关键字:局部修改全局不可变类型'''
index = 111
def print_python_cat():
    index = 222  
    # # 在print_python_cat的局部产生一个index=222,并不是在修改全局的x 而是在局部名称空间中创建了一个新的x
    # 如果想要在局部名称空间中修改全局名称空间中的名字 那么需要使用关键字申明
    global index  # 申明 修改的是全局x而不是产生新的x
    index = 666
print_python_cat()
print(index)

index_list = [111, 222, 333]
def print_python_cat():
    index_list.append(444)
print_python_cat()
print(index_list)
"""
如果想要在局部修改全局的不可变类型((不能直接修改,需要重新给一个变量进行赋值)) 需要提前加关键字global申明
如果想要在局部修改全局的可变类型(能直接在变量上进行修改值) 不需要加关键字global申明
"""

'''nonlocal关键字:局部修改全局不可变类型'''
def print_python_cat():
    index = 111  # 在print_python_cat的局部产生一个index = 111
    def f1():
        index = 222  
        # 在f1的局部产生一个index=222
        print(index)
        # 局部名称空间嵌套 内层修改外层
        nonlocal index
        index = 333
    f1()
    print(index)
print_python_cat()


def print_python_cat():
    index_list = [11, 22, 33]  # 在print_python_cat的局部产生一个index_list = [11, 22, 33] 
    def f1():
        index_list.append(44)
    f1()
    print(index_list)
print_python_cat()
"""
局部名称空间嵌套的情况下 内层如果想要修改外层与全局通过内层修改外层一样,有两种情况
    情况1数据是不可变类型(不能直接修改,需要重新给一个变量进行赋值) 需要使用关键字nonlocal
    情况2数据是可变类型(能直接在变量上进行修改值) 不需要使用关键字nonlocal
"""

 

5. 函数名的多种用法

def print_python_cat():
    print('I want to look python cat')
# 用法1:函数名可以当做变量名赋值
print(print_python_cat)
res = print_python_cat
# 让print_python_cat也指向函数体代码
print(res)
res()
# print_python_cat()

# 用法2:函数名还可以当成函数的实参
def print_python_cat():
    print('Python Cat')

def want_to(func):
    print('I want to look ')
    print(func)
    func()

want_to(print_python_cat)

# 用法3:函数名还可以当做函数的返回值
def want_to():
    print('I want to look ')
    return print_python_cat  # 将print_python_cat函数名当做返回值

def print_python_cat():
    print('Python Cat')

res = want_to()
# res接收print_python_cat函数名
print(res)
# 指向的是print_python_cat函数的内存地址
res()
# print_python_cat()

# 用法4:函数名可以作为容器类型的元素
'''容器类型:内部可以存档多个元素的数据类型>>>:列表、元组、字典'''
def print_python_cat():
    print('Python Cat')

func_list = [11, 22, 33, 44, print_python_cat]
print(func_list)
func_list[-1]()
#  print_python_cat()


def register():
    print('注册功能')
def login():
    print('登录功能')
def transfer():
    print('转账功能')
def withdraw():
    print('提现功能')
def check_order():
    print('查看账单')
def shopping():
    print('购物功能')
def check_account():
    print('查看余额')


# 原本写法,下面有优化版本
while True:
    print("""
    1.注册功能
    2.登录功能
    3.转账功能
    4.提现功能
    5.查看账单
    6.购物功能
    7.查看余额
    """)
    choice = input('请输入您想要执行的功能编号>>>:').strip()
    # 当功能比较多的是 频繁的编写elif很麻烦
    if choice == '1':
        register()
    elif choice == '2':
        login()
    elif choice == '3':
        transfer()
    elif choice == '4':
        withdraw()
    elif choice == '5':
        check_order()
    elif choice == '6':
        shopping()
    else:
        print('请输入正确的功能编号')

# 优化版本
# 定义一个功能存放区
func_dict = {
    '1': register,
    '2': login,
    '3': transfer,
    '4': withdraw,
    '5': check_order,
    '6': shopping,
    '7': check_account
}

while True:
    print("""
    1.注册功能
    2.登录功能
    3.转账功能
    4.提现功能
    5.查看账单
    6.购物功能
    7.查看余额
    """)
    choice = input('请输入您想要执行的功能编号>>>:').strip()
    if func_dict.get(choice, False):
        # 获取键对应的值(函数名)
        func_name = func_dict.get(choice)
        # 执行函数
        func_name()
    else:
        print('功能编号不存在')

 

6. 函数的嵌套

# 函数的嵌套调用
def print_python_cat():
    want_to()
    print('Python Cat')

def want_to():
    print_python_cat()
    print('I want to ')

print_python_cat()  # 报错
# 此函数调用会无限对两个函数进行调用,Python会到达一定的调用,会对函数进行停止
"""在学习函数的时候 前期一定要细心 死咬概念  定义调用"""


def max_num(num1, num2):
    '''返回两个数中的较大值'''
    if num1 > num2:
        return num1
    return num2


print(max_num(100, 999))

# 四个参数中,取最大的值
def many_max_num(num1, num2, num3, num4):
    '''返回四个数中的最大值'''
    res = max_num(num1, num2)  # 两两先比
    res1 = max_num(num3, num4)
    max_res = max_num(res, res1)
    return max_res

# 函数的定义
def choice_fun(cmd):
    def register():
        print('注册功能')

    def login():
        print('登录功能')

    def transfer():
        print('转账功能')

    if cmd == '1':
        register()
    elif cmd == '2':
        login()
    elif cmd == '3':
        transfer()
    else:
        print('滚')


choice_fun('1')
choice_fun('2')
"""
函数的学习会让我们的代码逻辑更加清晰 更加便于维护
"""