函数的参数补充与名称空间和作用域

一：命名关键字参数

在定义函数时，*后定义的参数，如下所示，称之为命名关键字参数

特点1：命名关键字实参必须按照key=value的形式为其传值

def func(x,y,*,a,b):    # 其中，a和b称之为命名关键字参数
    print(x,y)
    print(a,b)
    
func(1,2,b=222,a=111)
func()  # TypeError: func() missing 2 required positional arguments: 'x' and 'y'

# 示例
def func(x,y,*,a=11111,b):  # 不会出现语法错误，*后的a和b是命名关键字，a=111只是为命名关键字形参设置默认值
    print(x,y)
    print(a,b)

func(1,2,b=22222)

特点2：组合使用（了解）

形参混用的顺序：位置形参，默认形参,*args,命名关键字形参，**kwargs

def func(x,y=1,*args,z,**kwargs):
    print(x)
    print(y)
    print(args)
    print(z)
    print(kwargs)

二：实参混用的顺序：

def func(x,y,z,a,b,c):
    print(x,y,z,a,b,c)

func(111,y=222,*[333,444],**{'b':555,'c':666})
# 相当于：func(111,y=222,333,444,b=555,c=666)
报错：TypeError: func() got multiple values for argument 'y' 给y赋了多个值

正确顺序应该是：
def func(x,y,z,a,b,c):
    print(x,y,z,a,b,c)
    
func(111,*[222,333],a=444,**{'b':555,'c':666})
# 相当于：func(111,222,333,a=444,b=555,c=666)

# 也可以是：
# func(111,*[222,333],**{'b':555,'c':666},a=444,)
# 相当于：func(111,3333,4444,b=555,c=666,a=444)

输出：
111 222 333 444 555 666

一：名称空间namespace：存放名字的地方，是对栈区的划分

有了名称空间之后，就可以在栈区中存放相同的名字，详细的，名称空间分为3种

1.内置名称空间

存放的名字：存放的Python解释器内置的名字

'''
>>> print
<build-in function print>
>>> input
<build-in function input>
'''

存活周期：Python解释器启动 则产生，Python解释器关闭 则销毁

2.全局名称空间

存放的名字：运行顶级代码所产生的名字，只要不是函数内定义的，也不是内置的，剩下的都是全局名称空间名字

存活周期：Python执行文件就 存活，文件运行结束 则销毁

import os

x=10
if 13 > 3:
    y=20
    if 3 == 3:
        z=30

# func=函数的内存地址
def func():
    a=111
    b=222

class Foo:
    pass

3.局部名称空间

存放的名字：在调用函数时，运行函数体代码过程中 产生的函数内的名字

存活周期：在调用函数时 存活，函数调用完毕后 则 销毁

def func(a,b):
    pass

func(10,1)
func(11,12)
func(13,14)
func(15,16)

4.名称空间的加载顺序

内置名称空间 > 全局名称空间 > 局部名称空间

5.名称空间的销毁顺序

局部名称空间 > 全局名空间 > 内置名称空间

6.名字的查找优先级：当前所在的位置 向上一层一层查找

# 内置名称空间
# 全局名称空间
# 局部名称空间

如果当前在局部名称空间：

局部名称空间—>全局名称空间->内置名称空间

# input=333

def func():
    # input=444
    print(input)

func()

如果当前在全局名称空间

全局名称空间->内置名称空间

input=333
def func():
    input=444
func()
print(input)

# 示范1:
def func():
    print(x)
x=111

func()

# 示范2：名称空间的"嵌套"关系是以函数定义阶段为准，与调用位置无关
x=1
def func():
   print(x)

def foo():
    x=222
    func()

foo()

# 示范3：函数嵌套定义
input=111
def f1():
    def f2():
        # input=333
        print(input)
    input=222

    f2()
f1()

# 示范4：
x=111
def func():
    print(x) #
    x=222

func()

二：作用域 ==》 作用范围

1.全局作用域：内置名称空间、全局名称空间

① 全局存活

② 全局有效：被所有函数共享

x=111

def foo():
    print(x,id(x))

def bar():
    print(x,id(x))

foo()
bar()

print(x,id(x))

2.局部作用域：局部名称空间的名字

① 临时存活

② 局部有效：函数内有效

def foo(x):
    def f1():
        def f2():
            print(x)

3.LEGB含义解释：

L —— Local(function)；函数内的名字空间

E —— Enclosing function locals；外部嵌套函数的名字空间(例如closure)

G —— Global(module)；函数定义所在模块（文件）的名字空间

B —— Builtin(Python)；Python内置模块的名字空间

x = 10  # x => 10 的内存地址

def func(a):    # a = 10的内存地址
    a=11    # a = 11的内存地址

func(x)     # func(10的内存地址)

print(x)

输出：
10

一：示范1

x = 111

def func():
    x = 2222

func()
print(x)

输出：
111

详解：

x = 111

def func():
    x = 2222
    print(x,id(x))

func()
print(x,id(x))

输出：
2222 23019056
111 1357311632

二：示范2

如果在局部想要修改全局的名字对应的值（不可变类型），需要用global

x = 111

def func():
    global x  # 声明x这个名字是全局的名字，不要再造新的名字了
    x = 2222

func()
print(x)

输出：
222

x=0
def f1():
    x=11
    print('f1原来的x：',x)
    def f2():
        global x
        x=22
    f2()
    print('f2中的x：',x)

f1()
print('运行f1的x：',x)

输出：
f1原来的x： 11
f2中的x： 11
运行f1的x： 22

三：示范3

l=[111,222]
def func():
    print(l)    # l是list列表，属于不可变类型
    l.append(333)   # 没有创造新的值

func()
print(l)

输出：
[111, 222]
[111, 222, 333]

四：示范4

Nonlocal（了解）：修改函数外层函数包含的名字对应的值（不可变类型）

x = 0

def f1():
    x = 11
    print('f1原来的x：', x)

    def f2():
        nonlocal x  # 从当前层的外层开始找
        x = 22  # 这里f2的x没有被调用

    f2()
    print('运行f2后的x：', x)

f1()
print('输出x的值：',x)

输出：
f1原来的x： 11
运行f2后的x： 22
输出x的值： 0