Python基础第七天（局部变量，全局变量，嵌套函数，命名空间，作用域，abs()、max()、sort()、map()、filter()、zip()函数，lambda，global关键字）

局部变量，全局变量

函数内部定义的变量是局部变量，函数外部定义的变量是全局变量

def hanshu():
    b = 3
    print("函数内部", b)
    print(a)
a = 6
hanshu()

global 关键字

def hanshu():
    global a #将局部变量变成全局变量所以外面外面可以输出，但不可在还没调用就输出
    a=10
# print(a)
hanshu()
print(a)

nonlocal 关键字

def hsw():
    a=9
    def hsn():
        nonlocal a#可以修改外部变量（非全局）
        a=98
        print("我是内部",a)
    hsn()
    print('我是外部',a)
hsw()

嵌套函数

a= 9
def wb():
    a=7
    def nb():
        nonlocal a
        a=999
        print(a)
    nb()
    print("______",a)
wb()

命名空间

命名空间指的是保存程序变量名和值的地方。命名空间的本质是一个字典，用来记录变量名称和值。
命名空间分为三种：局部命名空间，全局命名空间，内置命名空间。

a=3
b=4
def hanshu(x):
    c=5
    d=6
    print(locals())
print(globals())
hanshu(6)

作用域

作用域的查找顺序和规则LEGB

a=3
b=30
c=300
def hsw():
    a=4
    b=40
    def hsn():
        a=5
        print(a)#L LOCAL 优先使用本地的
        print(b)#E enclosing 本地没有找嵌套作用域
        print(c)#G GLOBAL 全局作用域
        print(_name_,max,min,id) #B built_in 找内置作用域
    hsn()
hsw()

Python内置函数

1、abs() 求数字的绝对值

a=-1
b=2
print(abs(a))
print(abs(b))

2、max() 求迭代器的最大值

a=[-1,-2,-3,-5,-4]
b=max(a,key=abs)#先将a元素一个一个放进abs中后，在max函数，这里的abs是内置函数。没有abs()所以不是调用。
print(b)

3、map()
有两个参数，第一个参数是一个函数，第二个参数是可迭代的内容。

def hs(x):
    return x*x
a=[1,2,3]
b=map(hs,a)
print(b)
for x in b:
    print(x)

4、filter()
用于过滤序列，过滤掉不符合条件的元素

def gl(a):
    if a%3==0 or a%7==0:
        return True
    else:
        return False
a=[1,2,3,4,5,6,7,8,9]
b=filter(gl,a)
print(b)
print(list(b))

5、zip()
接受任意多个可迭代对象作为参数，将对象中对应的元素打包成一个tuple

a=[1,2,3]
b=['a','b','c','d']
c=zip(a,b)
print(c)
for x in c:
    print(x)

6、lambda 关键字
lambda关键字是创建小型函数

hs=lambda x:x*x
a=[1,2,3]
b=map(hs,a)
print(b)
print(list(b))

x=lambda a,b: a if a>b else b
y=x(2,3)
print(y)

练习

i=7
def x2(x=i):
    print(x)
x1()
x2()
def hehe():
    a=[]
    for i in range(3):
        b=lambda y,i=i:y*i#与上面的区别
        a.append(b)
    return a
z=hehe()
print(z[0](2))
print(z[1](2))
print(z[2](2))


def hehe():
    a=[]
    for i in range(3):
        b=lambda y:y*i
        a.append(b)
    return a
z=hehe()
# i=9#加这个值不会变，先是内嵌作用域不是全局作用域
print(z)#输出的是列表中的三次lambada
print(z[0](2))#,这里开始给lambda中值，给y的值为2，i的值一直都是for循环三次结束后最后一次i的值为2 所以为2*2
print(z[1](2))#2*2
print(z[2](2))#2*2