global修饰符

当变量在函数内，这个变量是“局部变量”;

当变量在函数外，这个变量是“全局变量”。

1. 引例：尝试“跨函数”批改全局变量

a=10
def test1(a):#想要通过函数把a改成20
    a+=20
test1(a) #执行批改函数
print(a)
#输入：10！批改失败

2. 为什么批改失败？

因为在本例中，把“全局变量”传给“形参”。

而办法体的运算操作，是对“形参”操作。

输入时，却输入的是“全局变量”

因为当完结调用函数时，函数内的变量主动销毁。

局部变量 只能在 函数内 拜访和批改

3.解决方案：global修饰符

a=10
def test2():#global解决方案的函数
    global a #应用global修饰符
    a+=20
    return a
print(test2())
#输入：30！批改胜利

当应用global修饰符，解释器就在“局部变量块”中应用“全局变量”

4. global的bug：确保global变量的唯一性

def test1(b):
    a=9999
    global a
    a+=20
    return a
#SyntaxError:
#name 'a' is assigned to before global declaration
#global变量 不能和 局部变量 反复
def test1(a):
    global a
    a+=20
    return a
#SyntaxError: 
#name 'a' is parameter and global
#global变量 不能和 形参 反复

#global不能放for里

可变类型 / 不可变类型 の批改

可变类型：列表、字典、汇合

不可变类型:数字、字符串、元组

这些类型都是对象。在Python中，对这些对象明确规定了：哪些能够批改、哪些不能够批改。这样就造成了可变类型和不可变类型。

援用 & 理论内存

在一条赋值语句中：a=1，a是一个援用，1是理论的内存空间，a指向1。所有数据类型的赋值都是这样的内存示意。

可变类型：内存的共享

为什么说“列表、字典、汇合”是可变类型？那是因为可变类型的内存是可共享的：可被多个援用（变量）指向。

list=[1,2,3,4,5]
def modify(l_ist):
    l_ist+=[6,7]
    print("我操控形参来批改，后果：",list)
    li_st=list #让局部变量li_st指向list
    li_st+=[8,9,10]
    print("我操控局部变量来批改，后果",list)
modify(list)
print("最初我再输入下全局变量，后果",list)！
#我操控形参来批改，后果： [1, 2, 3, 4, 5, 6, 7]
#我操控局部变量来批改，后果 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#最初我再输入下全局变量，后果 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

全局变量list、形参l_ist、局部变量li_st尽管是不同（栈内存）的变量，但它们都指向理论的内存空间：[1,2,3,4,5]。

理论内存空间，都被三个指向（援用），所共享！

因而，对任意一个援用进行运算操作，都能扭转理论的空间！

不可变类型：内存不能共享

a=10
def modify2(a):
    a+=10
print(a)

所以a+=10仅仅是对形参的操作。

形参和全局变量是息息相关的，所以互不影响。

可变类型批改的bug：批改有效

list=[1,3,5,7,9]
def modify3(list): #批改list
    list=[2,4,6,8,10]
print(list) #批改有效
#输入：[1,3,5,7,9]，批改失败

那是因为：

形参list 指向 [1,3,5,7,9]

局部变量list 指向 [2,4,6,8,10] (新的内存空间)

要留神 形参 和 局部变量 不是一个货色！他们尽管同名，但别离指向不同的内存空间！

怎么利用 局部变量 也能拜访批改 全局list呢？（提醒：用批改指向）

批改指向的思路是对的，但因为局部变量在函数完结调用被销毁，所以即便批改了指向，也是有效的。

总结

不可变类型 的 批改

1. 因为内存不被共享（不能共享援用），不能在部分块中批改

2. 只能用global修饰符批改

   可变类型 的 批改

3. 因为内存被共享（可共享多个援用），能够在任意中央批改
4. 也能够通过global修饰符批改

递归

def jiec(i):
    if i==1:
        return 1
    return i*jiec(i-1)

看懂递归代码的关键点：

1. 函数入口（层） 2.函数进口（返回值）

匿名函数

匿名函数是个函数，是没有名字的函数。

参数、返回值是一个函数的必需品。匿名函数把这两个必需品的语法格局进行了最大地简化。

sum=lambda a,b:a+b
'''
lambda:匿名函数申明标记
形参：用逗号距离
返回值：后面加冒号
'''

匿名函数的利用

sort函数

stus=[
    {"name":"zhangsan","age":22},
    {"name": "lisi", "age": 21},
    {"name": "wangwu", "age": 19}
]
stus.sort(key=lambda i:i["age"])

sort函数有一个参数：key。形参key是一个函数。

被sort()的汇合的所有元素，都会执行key函数

key有什么作用？key就是指定针对什么进行排序。

咱们想要针对age排序，就要想方法把age的值赋值给key。这就用到了匿名函数

stus.sort(key=lambda i:i["age"]) 
#形参是i，是字典元素
#返回值是i["age"]，是每个字典元素age键的值