python基础知识（十三）

函数
全局变量调用
eg：

a = 100
def hanshu():
    global a      #使用全局变量a
    a = 2000
print(a)          #函数不执行，全局变量a不变
hanshu()
print(a) 

结果为：100 2000
nonlocal修饰外部非全局变量
eg：

def hanshu():
    x = 100
    def neibu():
        nonlocal x     #修饰x，说明x是外部非全局变量
        x = 1000
    print(x)
    neibu()
    print(x)
hanshu()

结果为： 100 1000
一个值接收多个值，返回一个元组
多个值接收多个值，返回各个值
eg：

def qiuhe(a,b):
    c = a+b
    d = a*b
    e = a-b
    f = a/b
    return c,d,e,f
s = qiuhe(8,4)                 #一个值接收多个值，会返回一个元组
print(s)
x,y,z,w=qiuhe(8,4)             #多个值接收多个值，返回各个的值
print(x,y,z,w)

结果为：

如果形参没有对应的实参，则默认输出形参
eg：

def hanshu(name,age,sex="男"):
    print("我叫",name,end=" ")
    print("今年",age,end=" ")
    print("性别",sex)
hanshu("雷克顿",34)
hanshu("莫甘娜",28,"女")
hanshu("嘉文四世",30,"男")

结果为：

函数里的可变参数改变了，下次调用时会使用之前改变后的值
eg：

def hanshu(b,a=[]):     #a是可变参数，函数里改变了，下次调用时会使用之前改变后的值
    a.append(10)
    print(a,b)
hanshu(10)
hanshu(12)

结果为：

lambda（小型函数）
eg：

a=lambda x,y:x*2+y             #lambda为小型函数，简便def函数，：前面是参数，后面是要返回的值
print(a(3,4))
# 解析
def hanshu(x,y):
    return x*2+y
print(hanshu(3,4))

结果为：10 10
eg：

b = {"name":"hehe","age":18}
def getA(a):
    return a["age"]
print(getA(b))
# 简化
c = lambda a:a["age"]         #：前面是参数，后面是要返回的值
x=c(b)
print(x)

结果为：18 18
列表排序（绝对值排序）

a = [1,3,-5,6]
a.sort()                   #a中的元素排序
print(a)
a.sort(key=abs)            #调用ads绝对值函数，以a中元素的绝对值进行排序，且a的元素不变
print(a)

结果为：

key调用
eg：

def hanshu(a):
    return a["age"]
a = [{"name":"zs","age":29},
     {"name":"ls","age":38},
     {"name":"ww","age":31}]
b = max(a,key=hanshu)        #，调用hanshu（），以hanshu为比较对象，返回了每个元素的age值，求最大
print(b)
# 简化
c = max(a,key=lambda x:x["age"])
print(c)

结果为：

简化循环
eg：

a = [i for i in range(1,10)]
print(a)
b = [i*2 for i in range(1,50) if i%3==0]
print(b)
c = [i*3 for i in range(1,20) if i%5==0 or i%7==0]
print(c)

结果为：

二维列表的简单循环
eg：

a = [[1,2,3],[4,5,6],[7,8,9]]       #二维列表
print(a[0][0])
print(a[1][2])
b = [a[0][i] for i in range(3)]
print(b)
c = [a[i][0] for i in range(3)]
print(c)
d = [a[i][i] for i in range(3)]
print(d)
e = [a[x][y] for x in range(3) for y in range(3) if x+y==2]
print(e)
f = [a[i][2-i] for i in range(3)]
print(f)

结果为：

左右置换
eg：

a = {"a":1,"b":2,"c":3}
b = {y:x for x,y in a.items()}
print(b)

结果为：

zip打包
eg：

a = [1,2,3,4]
b = ["a","b","c"]
c = zip(a,b)           #打包成一个zip，内部是元组类型，两个参数以短的决定其长度
for x in c:
    print(x)

结果为：

map对象
eg：

def hanshu(x):
    return x*x

a = [1,2,3,4]
d = map(hanshu,a)       #map对象。对每个a中的元素进行函数加工，返回一个新的序列
print(d)
for x in d:
    print(x)

结果为：

filter过滤函数
eg：

def hanshu(a):
    if a%2==0:
        return True

a = [1,2,3,4,6]
b = filter(hanshu,a)               #过滤数据，符合hanshu内部条件的留下
print(b)
for x in b:
    print(x)

结果为：