Python学习----Day08

函数变量的作用域

全局作用域

• 全局作用域在程序执行时创建，在程序执行结束时销毁。
• 所有函数以外的区域都是全局作用域。
• 在全局作用域中定义的变量，都属于全局变量，全局变量可以在程序的任意位置被访问。

函数作用域

• 函数作用域在函数调用时创建，在调用结束时销毁。
• 函数每调用一次就会产生一个新的函数作用域（不调用不产生）。
• 在函数作用域中定义的变量，都是局部变量，它只能在函数内部被访问

实例：全局变量、局部变量

变量a是定义在testA函数内部的变量，在函数外部访问则立即报错。

局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量。

def testA():
    # 局部变量a
    # 在函数中为变量赋值时，默认都是为局部变量赋值
    # 局部变量不会影响函数外的变量。
    a = 100
    # 函数体内部访问，能访问到a变量
    print(a)
 
 
testA()  # 100
print(a)  # 报错：name 'a' is not defined

全局变量，指的是在函数体内、外都能生效的变量

# 定义全局变量a
a = 100
 
def testA():
    print(a)  # 访问全局变量a，并打印变量a存储的数据
 
def testB():
    print(a)  # 访问全局变量a，并打印变量a存储的数据
 
testA()  # 100
testB()  # 100

修改全局变量——global

       global 关键字的作用是，在函数内部声明一个变量为全局变量。换句话说如果希望在函数内部修改全局变量，则需要使用 global 关键字来声明变量。

a = 100
 
def testA():
    print(a)
 
def testB():
    # 想要修改全局变量a的值是200
    # global 关键字声明a是全局变量
    global a
    a = 200
    print(a)
 
 
testA()  # 100
testB()  # 200
print(f'全局变量a = {a}')  # 全局变量a = 200

注：如果在函数里面直接把变量 a=200 赋值，此时的 a 不是全局变量的修改，而是相当于在函数内部声明了一个新的局部变量。函数体内部修改全局变量： 先 global 声明 a 为全局变量，然后再变量重新赋值。

函数注释

函数说明的添加

对函数说明的添加，可以通过”””对实现对函数的说明的添加

 函数的注释

以上定义了名为my_function的函数，该函数有一个名为egg的参数，egg参数后面的“:str”是对该参数的注释，表示egg的类型是str，如图①所示。在函数参数列表与冒号之间的部分是对函数返回值的注释，如图②所示，表示my_function的返回值是str

函数的值传递和引用传递

Python 值传递和引用传递是根据实际参数的类型不同进行区分的，如下所示：

• 值传递：指的是实参类型为不可变类型（数字、字符串、元组）；
• 引用传递（或叫地址传递）：指的是实参类型为可变类型（列表，字典，set 集合，np矩阵，torch.Tensor矩阵）

所谓值传递，通常就是拷贝参数的值，然后传递给函数里的新变量。这样，原变量和新变量之间互相独立，互不影响。 

def modify_x(x):
    x = 99
    print("函数中修改过后的值: " , x)
    
x=66
modify_x(x)
print("执行modify_x函数后的值:" , x)


在上述代码中，我们定义了一个变量x，并赋值为66
后将x传入其modify_x函数中，在函数中，我们将x赋值为99
打印一下函数中的x值，函数结果。 在主函数中再打印一下x的值

 

所谓引用传递，通常是指把参数的引用传给新的变量，这样，原变量和新变量就会指向同一块内存地址。如果改变了其中任何一个变量的值，那么另外一个变量也会相应地随之改变。

def modify_x(dict):
    dict["x"] = 99
    print("数中修改过后的值:" , dict)

a={
    "x":66
}
modify_x(a)
print("执行modify_x函数后的值:", a)

如上代码，我们定义了一个字典a，该字典有一个key为x，值为66
在调用modify_x函数中，我们将a传递给了函数，在函数中
我们将该字典key为x的赋值为99，函数结束，在主函数中打印a的值。

 

匿名函数

Python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数

语法：lambda 参数：表达式 

• 先写lambda关键字，然后依次写匿名函数的参数，多个参数中间用逗号连接，然后是一个冒号，冒号后面写返回的表达式。
• 使用lambda函数可以省去函数的定义，不需要声明一个函数然后使用，而可以在写函数的同时直接使用函数。

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

运行结果
相加后的值为 :  30
相加后的值为 :  40

使用场景：

• 需要将一个函数对象作为参数来传递时，可以直接定义一个lambda函数（作为函数的参数或返回值）
• 要处理的业务符合lambda函数的情况（任意多个参数和一个返回值），并且只有一个地方会使用这个函数，不会在其他地方重用，可以使用lambda函数
• 与一些Python的内置函数配合使用，提高代码的可读性

 匿名函数与普通函数的对比

def sum_func(a, b, c):
    return a + b + c
 
 
sum_lambda = lambda a, b, c: a + b + c
 
print(sum_func(1, 100, 10000))
print(sum_lambda(1, 100, 10000))

运行结果
10101
10101

lambda作为一个参数传递

def sub_func(a, b, func):
    print('a =', a)
    print('b =', b)
    print('a - b =', func(a, b))
 
 
sub_func(100, 1, lambda a, b: a - b)

运行结果
a = 100
b = 1
a - b = 99

我们可以将匿名函数封装在一个函数内，这样可以使用同样的代

def myfunc(n):
  return lambda a : a * n
 
mydoubler = myfunc(2)
mytripler = myfunc(3)
 
print(mydoubler(11))
print(mytripler(11))

运行结果
22
33

偏函数

偏函数是固定一个函数的一些参数，然后生成一个新的函数的行为

int()函数可以把字符串转换为整数，当仅传入字符串时，int()函数默认按十进制转换。但int()函数还提供额外的base参数，默认值为10。如果传入base参数，就可以做N进制的转换。假设要转换大量的二进制字符串，每次都传入int(x, base=2)非常麻烦，于是，我们想到，可以定义一个int2()的函数，默认把base=2传进去：

functools可以帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85

函数的嵌套

通过将函数定义在已存在的函数内容，称为：嵌套函数

实例：

def func1():
    print('this is func1')
    
    def func2():	# 此函数为嵌套函数
        print('this is func2')

注意：这里要注意的是我们无法在外部函数外直接调用内部函数

调用嵌套函数

def func1():
    print('this is func1')
    def func2():
        print('this is func2')

    func2()	# 通过在同级别位置调用这个函数

func1()



def func1():
	def func2():
		print('this is func2')
	return func2	# 调用func1	将func2函数对象返回给调用者

res = func1() # 调用func1，返回了func2的返回对象
# res = func2

res() # 调用的就是func2
打印结果：'this is func2'

闭包

闭包定义：

        在函数嵌套的前提下，内部函数使用了外部函数的变量，并且外部函数返回了内部函数，我们把这个使用外部函数变量的内部函数称为闭包

必报的构成条件：

• 在函数嵌套（函数里面在定义函数）的前提下
• 内部函数使用了外部函数的变量（还包括外部函数的参数）
• 外部函数返回了内部函数

闭包书写步骤：

• 定义外部函数
• 定义外部函数，在内部函数中使用外部函数的变量
• 外部函数返回内部函数的地址

# 闭包函数的实例：outer()是外部函数，a和b都是外部函数的临时变量
def outer(a):
    b = 10
    # inner()是内部函数
    def inner():
        # 在内部函数中用到了外部函数的临时变量
        print(a+b)
    # 外部函数返回值是内部函数的引用
    return inner

# 调用外部函数，传入参数5。此时外函数两个临时变量a是5 b是10，并创建了内部函数，然后把内部函数的引用返回给了demo进行存储，外部函数结束的时候发现内部函数将会调用到自己的临时变量，这两个临时变量就不会释放，会绑定给这个内部函数
demo1 = outer(5)

# demo存储了外部函数的返回值，也就是inner()函数的引用，这里相当于执行inner函数
demo1()     # 15

demo2 = outer(7)
demo2()     # 17

修改闭包变量   

  在内部函数中想修改闭包变量(外部函数绑定给内部函数的局部变量)时：Python3中，可以使用nonlocal关键字声明一个变量，表示这个变量不是局部变量空间的变量，需要向上一层变量空间找这个变量

# 修改闭包变量实例
def outer(a):  # outer是外部函数，a和b都是外部函数的临时变量
    b = 10  # a和b都是闭包变量
    c = [a]  # 这里对应修改闭包变量的方法2

    def inner():  # inner是内部函数
        # 内函数中想修改闭包变量
        nonlocal b  # 方法1 nonlocal关键字声明，此处的b是outer()函数中的b
        b += 1 # b=11

        c[0] += 1  # 方法2 把闭包变量修改成可变数据类型，比如：列表
        print(c[0], b)

    return inner  # 外部函数返回内部函数的引用


demo = outer(5)
demo()  # 6 11

• Python3中，可以使用nonlocal关键字声明一个变量，表示这个变量不是局部变量空间的变量，需要向上一层变量空间找这个变量
• 在内部函数中声明变量b,如果我们不加nonlocal关键字，那么我们取到的b就不是外部函数中定义的b

装饰器 

        装饰器是给现有的模块增添新的小功能，可以对原函数进行功能扩展，而且还不需要修改原函数的内容，也不需要修改原函数的调用

作用：不改变原有函数的前提下，为函数添加新的功能模块，但是源代码没有改变

def guanjia(fun):
    def inner():
        print("123")
        fun()
        print("456")

    return inner()


@guanjia
def play1():
    print("静安寺大家")


@guanjia
def play2():
    print("案说法")

guanjia(play1)
guanjia(play2)

print(play1())
print(play2())

123
静安寺大家
456
None

123
案说法
456
None

装饰器雏形：

def fun(目标函数):
    def inner():
        之前添加的值
        目标函数原函数执行
        之后添加的事情
    return inner
@fun    #目标函数 = fun (没目标函数)