python函数进阶

1.作用域

1.1含义：指变量生效的范围

1.2全局变量：函数外部定义的变量，在整个文件中都是有效的

函数内部重新定义值，外部的值不会被覆盖，因为函数内部如果使用变量，会先从函数内部找，有的话直接使用，没有的话再从函数外部找。

1.3局部变量：函数内部定义的变量，从定义位置开始到函数结束有效

局部变量只能在被定义的函数中使用，在函数外部不能使用。

作用：在函数体内临时保存数据，即当函数调用完成后，就销毁局部变量

a = 100   #全局变量
def test1():
    print(a)
def test2():
    a = 120    #局部变量
    print(a)

print(a)  #100
test1()   #100
test2()   #120
print(a)  #100

全局变量和局部变量命名相同，全局变量不会被局部变量覆盖。

在函数内部修改全局的变量，可以使用global关键字

1.4global关键字：

将变量升级为全局变量

语法格式：global 变量名

总结：global关键字可以对全局变量进行修改，也可以在局部作用域中声明一个全局变量

a = 100   #全局变量
def test1():
    print(a)
def test2():
    global a
    a = 120    #声明全局变量
    print(a)

print(a)  #100
test1()   #100
test2()   #120
print(a)  #120

 声明多个变量，直接加个，

def study():
    global name,age
    name = 'panda'
    age = '5'
    print(f'{age}岁的{name}在学习python')   
study()    #5岁的panda在学习python
print(name)   #panda
print(age)    #5

 1.5 nonlocal关键字:

将变量声明为外层变量（外层函数的局部变量，而且不能是全局变量），只能在嵌套函数中使用，在外部函数中先进行声明，在内层函数中进行nonlocal声明

def outer():
    a = 5
    print(a)
    def inner():
        nonlocal a
        a = 20
        def inner2():
            a = 30
            print("inner2函数中a的值",a)    #30
        inner2()
        print("inner函数中a的值",a)    #20
    inner()
    print("outer函数中a的值",a)    #20
outer()

def outer():
    a = 5
    print(a)
    def inner():
        a = 20
        def inner2():
            nonlocal a
            a = 30
            print("inner2函数中a的值",a)    #30
        inner2()
        print("inner函数中a的值",a)    #30
    inner()
    print("outer函数中a的值",a)    #5
outer()

总结：nonlocal只能对上一层进行修改

2.匿名函数

2.1语法格式:函数名 = lambda 形参：返回值（表达式）

lambda是定义匿名函数的关键字

调用：结果 = 函数名（实参）

lambda不需要写return来返回值，表达式本身结果就是返回值

#普通函数
def add(a,b):
    return a+b
print(add(1,3))

#匿名函数
add = lambda a,b : a+b   #a,b就是匿名函数的形参，a+b是返回值表达式
print(add(1,3))

2.2 lambda的参数形式

注意多个返回值是以元组的形势返回

#无参
funa = lambda : "一本书"
print(funa())    #一本书

#一个参数
funa = lambda name :name
print(funa('panda'))   #panda

#默认参数
funa = lambda name,age = 5 : (name ,age)
print(funa('panda'))     #('panda', 5)
print(funa('panda',7))   #('panda', 7)

funa = lambda a,b,c = 4 : a+b+c
print(funa(1,2))    #7
print(funa(1,2,5))   #8

#关键字参数
funa = lambda **kwargs :kwargs
print(funa(name='panda',age='5'))    #{'name': 'panda', 'age': '5'}

2.3 lambda结合if判断

a = 5
b = 8
print("a<b") if a<b else print("a>=b")   #三目运算   #a<b

comp = lambda a,b:"a<b" if a<b else  "a>=b"
print(comp(5,8))   #a<b

特点：lambda只能实现简单的逻辑，如果代码复杂，或代码量大，不建议使用lambda，降低代码的可读性，为后期的代码维护造成困难

3.内置函数

查看所有内置函数 

import builtins
print(dir(builtins))

大写字母开头的一般为内置常量名，小写字母开头的一般为内置函数名

3.1内置函数一:

3.1.1转换函数

set():创建一个无序不重复元素集

list（）：将一个可迭代对象转换成列表

tuple（）：将一个可迭代对象转换成元组

3.1.2abs（）：返回绝对值

print(abs(-10))   #10
print(abs(10))   #10

3.1.3sum（）：求和

sum函数里需要放可迭代对象（可以用列表，元组，集合），不能直接放整形

字符串不能与整型相加，sum智能计算整型运算

字典也不能与整形进行相加

print(sum((1,2)))   #3元组
print(sum({1,2,3.5}))  #6.5集合
print(sum([1,2,3,4]))  #10列表

运算时只要有一个为浮点数，结果必定为浮点数 

3.2内置函数二

3.2.1 min()：求最小值

print(min(4,1,8))     #1
print(min((4,5,8)))   #4
print(min([3,7,2]))   #2
print(min({1,2,3}))   #1

我们也可以计算绝对值的大小，利用key=abs（传入了绝对值函数，则参数就会先求绝对值，再取较大者）

print(min(-8,5,key=abs))   #5

3.2.2 max()：求最大值

print(max(3,-5,-1,key=abs))  #-5

3.2.3 zip()：将可迭代对象作为参数，将对象中对应的元素打包成一个个元组

打印的两种方式：

1.通过for循环打印

2.通过转换成列表打印

li1 = [1,2,3]
li2 = ['a','b','c']
print(zip(li1,li2))   #<zip object at 0x000001DF191C2CC8>

#way1
for i in zip(li1,li2):
    print(i)    #(1, 'a')  (2, 'b')     (3, 'c')
    print(type(i))    #<class 'tuple'>
#way2
print(list(zip(li1,li2)))     #[(1, 'a'), (2, 'b'), (3, 'c')]

3.2.4 map()：可以对可迭代对象中的每一个元素进行映射，分别去执行（也叫映射函数）

map(func,inter1):   func--自己定义的函数，inter1--要放进去的可迭代对象

简单来说就是对象中的每一个元素都会去执行这个函数。

li = [1,2,3,4]
def func(x):
    return x*5
mp = map(func,li)    #注意func只需要写函数名，不需要加小括号
print(mp)   #<map object at 0x000001EBCCEC2D08> 打印一个对象，有两种方式取出
#way1
for i in mp:
    print(i)    #5    10    15     20
#way2
print(list(mp))   #[5, 10, 15, 20]

3.2.5 reduce()：先把对象中的两个元素取出来，计算出一个值保存着，再把计算这个值跟第三个元素进行计算

需要先导包:from functools import reduce

reduce(function,sequence)   #function--函数，必须是有两个参数的函数，sequence--序列：必须是可迭代对象

from functools import reduce
li = [1,2,3,4]
def add(x,y):
    return x+y
res = reduce(add,li)
print(res)     #10   1+2=3+3=6+4=10

前两个元素取出来计算充当新的x，后面一个是y，依次进行 

4.拆包

含义：对于函数中的多个返回数据，去掉元组，列表或者字典 直接获取里面的数据的过程

方法一：由变量接收，要求元组内的个数与接收的变量个数相同，对象内有多少个数据，就需要定义多少个变量接受，否则报错（ValueError）

一般在获取元组值的时候使用。

tua = (1,2,3,4)
print(tua)   #(1, 2, 3, 4)

a,b,c,d = tua
print("a=",a,"b=",b,'c=',c,'d=',d)   #a= 1 b= 2 c= 3 d= 4

方法二：*可以取多个（先把单独的取完，其他剩下的都交给带*号的变量）

tua = (1,2,3,4)
print(tua)   #(1, 2, 3, 4)

a,*b = tua
print(a,b)  #1 [2, 3, 4]
c,d,e = b
print(c,d,e)  #2 3 4

一般在函数调用时使用：

def func(a,b,*args):
    print(a,b)                  #1  2
    print(args,type(args))      #(3, 4, 5, 6, 7) <class 'tuple'>
func(1,2,3,4,5,6,7)
# arg = (1,2,3,4,5,6,7)
# func(*arg)