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 键的值