python学习之作用域以及命名空间

矫情吗；* 2021-10-19 15:46 276阅读 0赞

1、命名空间和作用域

命名空间：当函数执行时，将变量与值的对应关系存在一个空间中，当函数停止时，该空间会随着消失

内置命名空间：python解释内部运行时的变量函数

全局命名空间：我们在py文件中直接声明出来的变量,函数

局部命名空间：在函数内部声明的变量和函数

作用域：

全局作用域：内置命名空间+全局命名空间

通过globals()函数查找全局作用于名字

局部作用域：局部命名空间

通过locals()函数查找全局作用于名字

2、global和nonlocal（当我们在没有定义参数的值环境时，相对参数值进行更改值时我们就需要调用这两个函数来处理）

golbal：把全局变量拉倒局部来使用，也即在局部中声明一个全局变量，同时也可以将局部变量定义到全局中

nonlocal：把离当前最近的局部变量拉倒当前局部来使用，同样也可以将本地的局部标量定义到最近的局部中

作业

1、读下面两段代码，分别分析代码中打印出来的a、b、c分别是什么，并解析

第一段代码

a=10
    b=20
    def test(a,b):
        print(a,b)
    c=test(b,a)
    print(c)

答案是：a的值是20，b的值是10，c的值是None

解析：我们调用函数时试将a=10的值赋值给形参的b，将b=20的值赋值给形参的a，最后我们的c是函数test()通过return返回的None值，其中考察了全局变量和局部变量的使用

第二段代码

a=10
    b=20
    def test(a,b):
        a=3
        b=5
    print(a,b)
    c=test(b,a)
    print(c)

答案是：a的值是10，b的值是20，c的值还是None

解析：此题我们可以先将test函数抹除再来解释，因为我们的这个函数根本就没有做任何操作，此代码因为print是在全局空间打印的，所以就是原来的值，另外c的值为None的解释和上一段代码一样

2、函数中传入的任何可迭代对象时，都能将每个函数的元素作为参数传入函数中

def fun(*args):
        return args
    print(fun(*[1,2,3],*(22,33)))

输出结果是：(1, 2, 3, 22, 33)

3、传入函数的多个实参（字典形式），将每个实参的键值对依次添加到函数的动态参数kwags里面

def fun(**kwargs):
        return kwargs
    print(fun(**{"name":"alex"},**{"age":1000}))

输出结果是：\{'name': 'alex', 'age': 1000\}

4、写函数接收两个值，将较小的值返回

def fun(a,b):
        c=a if a<b else b
        return c
    print(fun(2,1))

5、接收一个参数（可迭代对象），将可迭代对象的每一个元素以"\_"相连，形成新的字符串，并输出

def fun(*args):
        ss="_".join(args)
        return ss
    print(fun(*["liuys","yunson","yunshen"]))

6、接收n个参数，以字典的形式返回最大值和最小值

def fun(*args):
        return {"最大值":max(args),"最小值":min(args)}
    print(fun(1,3,4,5,66,99,-1))

或假设逐个比较法

def fun(*args):
        ma=args[0]
        mi=args[0]
        for i in args:
            if i > ma:
                ma=i
            if i <mi:
                mi=i
        return {"最大值":ma,"最小值":mi}
    print(fun(1,3,4,5,66,99,-1))

7、传入一个数字n，返回n的阶乘

def fun(n):
        num=1
        for i in range(1,n+1):
            num=num*i
        return num
    print(fun(3))

8、更改代码使一下代码打印666

def wrapper():
        def inner()
            print(666)
    wrapper()

法一

def wrapper():
        def inner()
            print(666)
        inner()
    wrapper()

法二

def wrapper():
        def inner()
            print(666)
        return inner
    wrapper()()

9、下题反应一个问题：

如果默认值参数是一个可变参数，如果有一个调用改变了该值，则其他的调用也会改变

def fun(a,list=[]):
        list.append(a)
        return list
    list1=fun(10)
    list2=fun(123,[])
    list3=fun("a")
    print(list1,list2,list3)

此时返回的结果是：\[10, 'a'\] \[123\] \[10, 'a'\]

当我们更换打印顺序时，则结果是一下

def fun(a,list=[]):
        list.append(a)
        return list
    list1=fun(10)
    print(list1)
    list2=fun(123,[])
    print(list2)
    list3=fun("a")
    print(list3)

则结果是：\[10\]  
\[123\]  
\[10, 'a'\]

10、九九乘法表

for i in range(1,10):
        j=1
        while j<=i:
            print("%d X %d = %d\t" %(i,j,i*j),end="")
            j+=1
        print()

1 X 1 = 1      
2 X 1 = 2    2 X 2 = 4      
3 X 1 = 3    3 X 2 = 6      3 X 3 = 9      
4 X 1 = 4    4 X 2 = 8      4 X 3 = 12    4 X 4 = 16      
5 X 1 = 5    5 X 2 = 10    5 X 3 = 15    5 X 4 = 20    5 X 5 = 25      
6 X 1 = 6    6 X 2 = 12    6 X 3 = 18    6 X 4 = 24    6 X 5 = 30    6 X 6 = 36      
7 X 1 = 7    7 X 2 = 14    7 X 3 = 21    7 X 4 = 28    7 X 5 = 35    7 X 6 = 42    7 X 7 = 49      
8 X 1 = 8    8 X 2 = 16    8 X 3 = 24    8 X 4 = 32    8 X 5 = 40    8 X 6 = 48    8 X 7 = 56    8 X 8 = 64      
9 X 1 = 9    9 X 2 = 18    9 X 3 = 27    9 X 4 = 36    9 X 5 = 45    9 X 6 = 54    9 X 7 = 63    9 X 8 = 72    9 X 9 = 81