python 学习 D10 动态参数 名称空间 作用域 作用域链 加载顺序 函数的嵌套 global nonlocal

03，动态参数 *args，**kwargs

# 用户传入到函数中的实参数量不定时，或者是为了以后拓展，
# 此时要用到动态参数*args，**kwargs(万能参数。)
# *args接收的是所有的位置参数。
# **kwargs接收的是所有的关键字参数。
# 位置参数，*args，默认参数, **kwargs

# def func1(*args, **kwargs):
#     print(args)
#     print(kwargs)

# func1(1, 2, 3, 4)
# func1(x=4, y=5, z=6)

def func1(*args, **kwargs):
     print(kwargs)
func1(1, 2, 3, x=4, y=5, z=6)

先拿位置参数 和 默认参数  发现 *args 要放在他俩中间

 

def func(a, b, *args, sex='男'):
    print(a)
    print(b)
    print(args)
    print(sex)
func(1, 2, 5, 6, 7, 8, sex ='女')

 

再拿 位置参数，*args， 默认参数，  发现 **kwargs 只能放在最后 

 

def func(a, b, *args, sex='男', age=20, **kwargs):
    print(a)
    print(b)
    print(args)
    print(sex)
    print(age)
    print(kwargs)
func(1, 2, 5, 6, 7, 8, x=5, y=9, age=33, sex ='女')

 

PS： 计算器  输入数字 进行相加

 

def sum1(*args):
    ret = 0
    for i in args:
        ret += i
    return ret
print(sum1(1, 2, 3,))

 

      * 的魔法用法

  def func(*args, **kwargs):             #  函数的定义  * 用意是聚合

  在函数的执行时，                           #    *   的用意是打撒。

 

 

 

 

def func(*args, **kwargs):
    print(args)
    # print(kwargs)
l1 = [1, 2, 6]
l2 = [55, 66, 77]
s1 = 'dhfjgdfgj'
s2 = 'vocvb,cmb'
dic1 = {'name': 'alex'}
dic2 = {'age': 99}
func(*l1, *l2)
# func(**dic1, **dic2)

 

 

def func(*args, **kwargs):
    # print(args)
    print(kwargs)
l1 = [1, 2, 6]
l2 = [55, 66, 77]
s1 = 'dhfjgdfgj'
s2 = 'vocvb,cmb'
dic1 = {'name': 'alex'}
dic2 = {'age': 99}
# func(*l1, *l2)
func(**dic1, **dic2)

04，名称空间，作用域，作用域链，加载顺序等。

#当程序运行时，代码从上至下一次读取，遇到变量与值，
# 他会在内存中开辟一个空间，存放变量与值的内存地址的对应关系。
#这样存储变量与值得对应关系的空间叫做名称空间(命名空间)。
#当解释器遇到函数时，他会将函数名存储在内存中，但是对于函数体莫不关心。
#当函数执行时，他会通过函数名找到函数体，然后将函数体里面的变量等对应关系存放在一个
# 临时开辟的空间中，随着函数的结束，临时的空间关闭，这样的空间叫做临时名称空间。

# def func1():
#     a = 2
#     b = 3
# func1()

名称空间：
 内置名称空间
 全局名称空间
 局部名称空间
加载顺序：内置名称空间 ---> 全局名称空间（程序运行时） ---->局部名称空间(函数执行时)
作用域：
 全局作用域：内置名称空间 全局名称空间
 局部作用域：局部名称空间
取值顺序(单向):局部名称空间(函数执行时) ---> 全局名称空间 ---> 内置名称空间
L local
E eclose
G global
B Built-in

 

05，函数的嵌套。
 判断 运行的 先后顺序 

print(111)   # 1
def func1():
    name = 'alex'
    print(name)  # 2
    def inner():
        a = 2
        print(a)  # 3
    inner()
func1()

print(111)        # 1
def func1():  
    name = 'alex'
    print(name)   # 3
    def inner():
        a = 2
        print(a)  # 4
    inner()
print(333)     # 2
func1()
print(444)   # 5

 

print(111)   # 1
def func1():
    name = 'alex'
    print(name)  # 2 
    def inner():
        a = 2
        print(a)  # 4
    print(444)   # 3
    inner()
    print(555)   # 5
func1()

06，global，nonlocal。

# 在全局名称空间里得到局部名称空间的变量
# 1，return
# 2，global
 # 1,在局部作用域中声明一个全局变量。
 # 2，在局部作用域中，更改一个全局变量。
 # 补充：
 # 对于可变的数据类型，函数中如果对其进行操作，改变全局不用引用global.

return

# def func1():
#     name = 'alex'
#     return name
# ret = func1()
# print(ret)

  global

1,在局部作用域中声明一个全局变量。

# def func1():
#     global name
#     name = 'alex'
# func1()
# print(name)

2，在局部作用域中，更改一个全局变量。

# name = '老男孩'
# def func1():
#     global name
#     name = 'alex'
# func1()
# print(name)

 

 # 对于可变的数据类型，函数中如果对其进行操作，改变全局不用引用global.

# l1 = [1, 2, 3]
# def func1():
#     l1.append(666)
# func1()
# print(l1)

 nonlocal

#1,不能改变一个全局变量。
# 在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改，
# 并且引用的哪层，从那层及以下此变量全部发生改变。

1,不能改变一个全局变量。 报错！

name = "老男孩"
def func1():
    nonlocal name
    print(name)
func1()

# 在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改，
# 并且引用的哪层，从那层及以下此变量全部发生改变。

def func1():
    name = 'alex'
    print(name)  # 1, alex
    def inner():
        nonlocal name
        name = '老男孩'
        print(name)  # 2 老男孩
    inner()
    print(name)  # 3 老男孩
func1()