Day 08 python学习笔记

函数

---

作用域

作用域：变量的访问权限

全局变量与局部变量

声明在函数外边的变量----全局变量        ----》全局作用域
函数内部的变量------局部变量                ----》局部作用域
顶格创建的函数也是全局的

例：
a = 100


def test_01():
    a = 0
    b = 110
    print(a)
    print(b)


test_01()  #都是局部变量里的
print(a)   #全局变量的a
print(b)   #报错，因为b变量是局部变量，无访问权限

结果：
0
110
100
Traceback (most recent call last):
  File "D:python\Day08\代码\02-函数中变量的作用域.py", line 19, in 
    print(b)
NameError: name 'b' is not defined

注意:局部的东西，一般都是局部自己访问使用的

但全局变量都可访问

例：
a = 100


def test_02():
    print(a)
    
    
test_02()


结果：
100

扩展：

函数内部可以使用全局变量但是无法修改全局变量

例：
a = 100


def test_03():
    a += 100   #报错，函数内部可以使用全局变量但是无法修改全局变量
    print(a)


test_03()


结果：
Traceback (most recent call last):
  File "D:\python\Day08\代码\02-函数中变量的作用域.py", line 17, in 
    test_03()
  File "D:\python\Day08\代码\02-函数中变量的作用域.py", line 13, in test_03
    a += 100
UnboundLocalError: local variable 'a' referenced before assignment

如果要进行修改，使用globle关键字

例：
a = 100


def test_03():
    # 函数内部可以使用全局变量但是无法修改全局变量,如果要进行修改，使用globle关键字
    global a   #添加修改全局变量的权限
    a += 100
    print(a)


test_03()

函数注释

函数内部：

'''

xxx

'''

例：
def sum_01(a,b):
    return a+b


sum_01(1,2)

将鼠标拖到sum_01(1,2)上，它会显示如下图所示，下方会显示这个函数的一些注释

而我们如果要修改注释

方法如下：

1. 在函数内部输入'''(解释器会自动给你在后面补充三个''')
2. 直接按回车键
3. 将出现的注释删除，写上你想展示的注释

例：

展示

扩展：

我们也可以直接按住ctrl键然后将鼠标移到函数上，然后点击，可以转到注释

例：round()

例round() 我定义在全局中

值传递与引用传递

值传递：在传递参数时，仅仅是把值拷贝一份传递给参数的函数，变量的值不发生变化

例：
def test01(x, y):
    x += 10
    y += 20
    print(x, y)


a = 10
b = 20
test01(a, b)  #只是拷贝
print(a)      #原变量的值不发生变化
print(b)

结果：
20 40
10
20

引用传递：在传递参数的时候，传地址，函数形参获取的值，也是同一块内存

例：
def test02(nums):
    print(id(nums))    #id()用来查看地址，后面会讲
    nums.append(10)
    nums.append(100)
    print(nums)


list1 = [1, 2, 3]
print(id(nums))
test02(list1)   #传地址，函数形参获取的值，也是同一块内存
print(list1)


结果：
2273748378816
2273748378816  #可以看出不是拷贝，是同一个地址
[1, 2, 3, 10, 100]
[1, 2, 3, 10, 100]

匿名函数

匿名函数：python中将函数作为参数传到另外一个函数里边去

python中函数参数的数据类型：只要是对象就可以

python ：函数本身就是一个对象

例：
def compute(a,b):
    return a+b


def test01(fn):
    a = fn(1,2)
    print(a)


test01(compute)  #注意：不能写成test01(compute())
                 #compute()是函数调用，不是对象了,返回的要么是return值，要么是None


结果:
3

lambda匿名函数

匿名函数：临时使用一次

python中，存在函数作为参数传递给函数，并且不想被外界访问，而且参数函数足够简单，即可以定义为匿名函数(lambda 表达式)

格式：
lambda 传入参数 ：函数体 （函数体只能写一行，不能写多行）

lambda [a,b] : 代码块  （[ ]包起来代表可有可无，可能无传入参数）

例：

例：
与上面效果相同
def test01(fn):
    a = fn(1,2)
    print(a)




test01(lambda a, b: a + b)


结果：
3

偏函数：

Python的functools模块提供了很多有用的功能，其中一个就是偏函数（Partial function）。要注意，这里的偏函数和数学意义上的偏函数不一样。

在介绍函数参数的时候，我们讲到，通过设定参数的默认值，可以降低函数调用的难度。而偏函数也可以做到这一点。举例如下：
int()函数可以把字符串转换为整数，当仅传入字符串时，int()函数默认按十进制转换：

>>> int('12345')
12345

但int()函数还提供额外的base参数，默认值为10。如果传入base参数，就可以做N进制的转换：

>>> int('12345', base=8)   #注意前面需要加''
5349    #将8进制‘12345’转换为10进制
>>> int('12345', 16)
74565   #将16进制‘12345’转换为10进制

假设要转换大量的二进制字符串，每次都传入int(x, base=2)非常麻烦，于是，我们想到，可以定义一个int2()的函数，默认把base=2传进去：

def int2(x, base=2):  #缺点是base=2可以改，不固定
return int(x, base)

这样，我们转换二进制就非常方便了：

>>> int2('1000000')
64
>>> int2('1010101')
85

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

>>> import functools   #导入模块（后面会讲）
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85

所以，简单总结functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

注意到上面的新的int2函数，仅仅是把base参数重新设定默认值为2，但也可以在函数调用时传入其他值：

>>> int2('1000000', base=10)
1000000

最后，创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数，当传入：

int2 = functools.partial(int, base=2)

实际上固定了int()函数的关键字参数base，也就是：

int2('10010')

相当于：

kw = { 'base': 2 }
int('10010', **kw)

当传入：

max2 = functools.partial(max, 10)

实际上会把10作为*args的一部分自动加到左边，也就是：

max2(5, 6, 7)

相当于：

args = (10, 5, 6, 7)
max(*args)   #求最大值


结果：
10

小结：

当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。

python3.8新特性

---

声明函数参数类型

在C/C++/JAVA时我们函数传参的时候都是有严格限制参数类型，而我们python则没有

例：
python：
def fun(a,b,c):

Java：
public static void fn(int a,double b,String c){

}

但是python3.8之后添加了一个限制方法（注：这个限制是非强制的，只是会提醒你）

def add(x: int, y: float): #用来限制传入的参数类型
    print(x + y)


add(1, 1)
add("1","1")   #你鼠标放上去会提醒你，但依旧可以执行

结果：
2
11


def add(x: int, y: float) -> float:  #->指向限制返回值的类型
    print(x + y)
    return x + y


add(1, 1)
add("1","1")

函数的嵌套

def fun1():
    b = 20
    def fun2():
        pass

函数的嵌套，此时的fun2是局部变量.想像成：
#fun2 = def():

注意:局部的东西，一般都是局部自己访问使用的

局部变量，就想在外边使用:return

想在外边访问fun2，可以将fun2像变量一样进行返回
return fun2

def fun1():
    b = 20
    def fun2():
        pass
    return fun2     #此时我们把函数当做变量进行返回的

b1 = fun1()    #此时的b1事实上就是函数fun2（）
b1()

函数作为返回值：

例：
def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

a = lazy_sum(1)
print(a)
a = lazy_sum(1)
print(a)


结果：
.sum at 0x000002130129A8C0>#返回一个fun2的函数
.sum at 0x000002130129B910>

调用一次lazy_sum，返回一个新的函数，即使是相同的参数，两次调用生成的函数也不一样

并且返回的函数可以再调用，即调用内层函数

def fun1():
    b = 20

    def fun2():   #fun2 = def(){}
        print(b)
        print("222222222")
    return fun2  #注意：返回函数不要带小括号，有括号是调用


a = fun1()  #返回fun2的函数
a()         #调用fun2函数


结果：
20
222222222

函数作为参数进行传递

此时的实参可以是函数
代理模式：函数test_func代理了compute

综上：

1. 函数可以作为返回值进行返回
2. 函数可以当做参数进行传递
3. 函数名本质上就是变量名，指向函数所在的内存地址

闭包

闭包：一个函数嵌套另一个函数，内层函数用到外层函数的局部变量，内层函数即为闭包

def outer():
    a = 10
    def inner():
        print(a)
    return inner   


#内层函数inner即为闭包
a = outer()
a()


结果：
10

如果内层变量想要更改外部变量的值（直接修改）

例：
def outer():
    a = 10
    def inner():
        a += 1   #报错
        print(a)
    return inner


a = outer()
a()


结果：
Traceback (most recent call last):
  File "D:\python\Day08\代码\09-闭包.py", line 17, in 
    a()
  File "D:\python\Day08\代码\09-闭包.py", line 11, in inner
    a += 1
UnboundLocalError: local variable 'a' referenced before assignment

我们需要用到关键字nonlocla

nonlocla：内层变量想要更改外部变量的值，
在内层函数添加x的声明：
nonlocal x

语法结构和规则：

def func():
    a = 10
    def inner():
        nonlocal a
        print("原", a)
        a += 1
        print(a)
    return inner

ret = func()
ret()  #a = 11
ret()  #a = 12
#事实上实现了在全局作用域(外层)对局部变量进行更改

#局部变量的好处：外界很难更改
#不通过inner去更改a:改不了


结果：
原 10
11
原 11
12

闭包：

1. 可以让一个变量常驻在内存当中
2. 可以避免全局变量被修改

本质：内层函数对外层函数的局部变量的使用，内层函数被称为闭包