7_variable_scope&arbitary_arguments

Variable Scope

module,class,def,lambda可以引入新的变量作用域。

if/elif/else/try/except/for/while不会引入新的变量作用域。

def test():
    msg = 'I am from Shanghai.'
print(msg)

"""
error
"""

函数内外定义的变量互不相干，即使名称一样也不影响。

msg = 'I am from Shanghai.'
def test():
    msg = 'I am from Chengdu.'
    print(msg)
test()
print(msg)

"""
I am from Chengdu.
I am from Shanghai.
"""

若函数外定义的变量在函数内没有定义，只调用，函数内的变量会引用对应的全局变量。

msg = 'I am from Shanghai.'
def test():
    print(msg)
test()

"""
I am from Shanghai.
"""

在刚才的情况下，若要修改变量，即先引用，再修改，会报错。

msg = 'I am from Shanghai.'
def test():
    print(msg)
    msg = 'I am from Chengdu.'
test()

"""
报错（局部变量已经被引用）
"""

不是很明显的“先引用，再修改”

a = 10
def fun():
    a = a+1
    print(a)
fun()

"""
a+1处引用了a
=的赋值操作修改了a
即先引用再修改，会报错
"""

 

Nested Functions

在嵌套函数中，一个函数对应一个作用域，层级可分为：

Local ---> Enclosing ---> Global --->Build-in (LEGB)

build-in对应系统的作用域。

Global

声明为全局变量。

num = 1
def fun():
    global num
    num = 123
    print(num)
fun()
print(num)

"""
123
123
"""

一定要在最开始的时候声明，先引用，再声明会报错。 

num = 1
def fun():
    print(num)
    global num
fun()

"""
报错
"""

Nonlocal

声明后，变量的作用域扩大到enclosing

def outer():
    num = 10
    def inner():
        nonlocal num   
        # nonlocal keyword
        num = 100
        print(num)
    inner()
    print(num)
outer()

"""
100
100
"""

num = 0                        
def f():
    num = 1
    def ff():
        nonlocal num
        num = 2
        def fff():
            num = 3
            def ffff():
                nonlocal num
                num = 4
                print(num,'ffff')
            ffff()
            print(num,'fff')
        fff()
        print(num,'ff')
    ff()
    print(num,'f')
f()
print(num,'global')

"""
4 ffff
4 fff
2 ff
2 f
0 global
"""

Mutable in Function

可以通过方法进行修改，但不能直接赋值。

a = [1,2,3]
def test():
    print(a)
    a = [1,2,3,4]
test()

"""
先引用，再修改，报错
"""

通过attend的方法进行修改是允许的。

a = [1,2,3]
def test():
    print(a)
    a.append(4)
test() 
print(a)   

"""
[1,2,3]
[1,2,3,4]
"""

 字典可以直接修改key对应的value

a = {"color": "green"}
def test():
    print(a)
    a["color"] = "red"
    a["position"] = "left"
test() 
print(a)

"""
{'color': 'green'}
{'color': 'red', 'position': 'left'}
"""

传入参数的赋值不会改变原变量，但可以通过方法改变原变量，例如：

def changeme(mylist):
   mylist = [1,2]
   print("inside: ", mylist)
 
x = [10,20]
changeme(x)
print("outside: ", x)

"""
inside:  [1, 2]
outside:  [10, 20]
"""

若在函数中调用方法进行修改：

def changeme(mylist):
   mylist.extend([1,2])
   print ("inside: ", mylist)
 
x = [10,20]
changeme(x)
print ("outside: ", x)

"""
inside:  [10, 20, 1, 2]
outside:  [10, 20, 1, 2]
"""

 

Arbitary Arguments

传递任意参数：

def func(*args, **kwargs):
    """
    function
    """