4.python函数1

什么是函数

def 函数名():    

函数体

def u():

    print("123")

# 调用u()函数

u()

 

 

函数的返回值

执行完函数之后. 我们可以使用return来返回结果. 

函数中return的使用:

1. 函数中遇到return, 此函数结束, 不再继续执行.

def u():

    print("123")

    return

    print("456")# 这句话不会被执行

2. 给函数的调用者一个访问结果

def u():

    print("123")

    return"456"

3. 函数的返回值可以有多个结果

def u():

    print("123")

    return"456","678"

总结一下: 

1. 遇到return. 此函数结束, 函数后面的东西将不会再执行

2. return 返回值

        关于返回值: 

            如果return什么都不写 或者 干脆不写return .那么返回的就是None

            如果return后面写了一个值. 则调用者可以接收一个结果

            如果return后面写了多个结果, 则调用者可以接收一个tuple, 调用者可以直接解构成多个变量

 

函数的参数

    参数, 函数在调用的时候指定具体的一个变量的值. 就是参数.  语法: 

def 函数名(参数列表):    

函数体

1. 位置参数

def u(si):  #形参

    print("abc"+si)

# 调用u()函数

u("d") #实参

2. 关键字参数

def max(a,b):

    if a>b:

        return a

    else:

        return b

print(max(a = 2,b = 1))

3. 混合参数,  位置参数必须在关键字参数前面

def max(a,b):

    if a>b:

        return a

    else:

        return b

print(max(2,b = 1))

4默认值参数

def max(a,b = 1):

    if a>b:

        return a

    else:

        return b

print(max(2))

 

5函数参数--动态传参

def min(*a,b):

    print(a)

    print(b) 

min(2,3,b=1)

b=1必须加不然就被a元组全部接收

或者

位置参数放动态参数前面

def min(b,*a):

    print(a)

    print(b)

 min(1,2,3)

# 多个参数传递进去. 收到的内容是元组tuple

顺序最好: 位置参数, 动态参数*, 默认值参数

def ch(a, b , *c, d="123"):

 

6动态接收关键字参数

def func(**kwargs):

    print(kwargs)

func(a=1, b=2, c=3)

func(a=1, b=2)

结果: {'a': 1, 'b': 2, 'c': 3} {'a': 1, 'b': 2}

这个时候接收的是一个dict

最终顺序(*重点):

       位置参数 >  *args > 默认值参数 > **kwargs

在实参位置上给一个序列,列表,可迭代对象前面加个*表示把这个序列按顺序打散. 

在形参的位置上的* 表示把接收到的参数组合成一个元组

如果是一个字典, 那么也可以打散. 不过需要用两个*

def fun(*args):

     print(args)

lst = [1, 4, 7]

fun(lst[0], lst[1], lst[2])

fun(*lst)

s = "147"

fun(*s)

(1, 4, 7)

(1, 4, 7)

('1', '4', '7')

def fun(**kwargs):

    print(kwargs)

dic = {'a':1, 'b':2}

fun(**dic)

{'a': 1, 'b': 2}

函数的嵌套和作用域

在函数外面的变量被称为全局变量. 它的作用域是整个py文件. 在函数内部的变量被称为局部变量.作用范围仅限于函数内部.

我们可以通过globals()和locals()查看全局和局部作用域中的内容

a = 10

def func():

    a = 40

    b = 20

    print(a, b) # 这里使用的是局部作用域

    print(globals()) # 打印全局作用域中的内容

    print(locals()) # 打印局部作用域中的内容

func()

 
global和nonlocal关键字

a = 10

def func():

    global a

    a = a+10

    print(a)

func()

在函数内部想要修改全局变量. 必须使用global关键字把外面的变量引入才可以进行修改(赋值).

a = 100

def func1():

    a = 20

    def func2():

        nonlocal a

        a = 30

        print(a)

    func2()

    print(a)

func1()

加了nonlocal 30 30 不加nonlocal 30 20

nonlocal也是一样的操作. 它负责在内层函数中引入外层函数的局部变量