day12 - 函数进阶 - 学习总结

day 12 - 函数进阶

01 返回值

1. 返回值 - 就是从函数内部传递到函数外部的数据

1）怎么确定函数返回值 - 怎么将函数内部的数据传递出去

• 执行函数体的时候，遇到return，return 后面的值就是函数的返回值。（需要将哪个数据从函数内部传递到函数外部，就将哪个数据放在 return 的后面）

2）怎么获取函数返回值 - 获取函数调用表达式的值，就是获取函数的返回值。

• 每一个函数调用表达式都有结果，结果就是这个函数的返回值

• 函数调用表达式 - 调用函数的语句

• 函数返回值能做的事情，函数调用表达式都可以做

3）什么时候使用函数返回值

• 如果实现函数的功能产生了新的数据，就将新的数据作为返回值返回（而不是在函数内部打印这个数据）

def func1(num1, num2):
    result = num1 + num2
    return result  

print('1:', 30)                     # 1: 30
print('2:', func1(10, 20))          # 2: 30

x = 30
y = func1(10, 20)
print(x, y)                        #  30 30

02 return 的作用

1. return - 函数体中的关键字

1）确定函数返回值

2）提前结束函数 - 在执行函数体的时候，什么时候遇到return, 函数什么时候结束

03 变量的作用域

1. 变量的作用域 - 变量定义后可以使用的范围

根据变量作用域的不同，可以将变量分为全局变量和局部变量两种。

2. 全局变量和局部变量

1）全局变量

• Python 中没有定义在函数中、类中的变量就是全局变量；
• 全局变量的作用域：从定义开始，到程序结束；（函数外面和函数里面都可以用）
• 底层内存逻辑：全局变量默认情况下保存在全局栈区间（全局栈区间在程序结束后才会自动释放）

# a是全局变量
a = 100

# x 和 b是全局变量
for x in range(3):
    b = 200

print('函数外面:', a, x, b)       # 函数外面: 100 2 200
def func1():
    print('函数里面:', a, x, b)   # 函数里面: 100 2 200

2）局部变量

• 定义在函数中的变量是局部变量（形参是属于定义在函数中的变量）；
• 局部变量的作用域：从定义开始，到函数结束；（只有函数里面可用）。
• 底层内存逻辑：每次调用函数的时候，系统都会自动为这个函数创建一个临时栈区间，这个函数中产生的所有的数据，在默认情况下都是保存在临时栈区间中的，当函数调用结束的时候，这个临时栈区间会被自动释放（里面的数据都会被自动销毁）。

# c和d是局部变量
def func2(c):
   #c = 220
    d = 300
    print('函数里面:', c, d)   
func2(220)                    #  函数里面: 220 300

# print('函数外面:', d)        # 报错

3. global 的用法

在函数里面修改全局变量的值，不会修改成功，而是定义一个新的局部变量

1）用法1：如果想要在函数中修改一个全局变量的值，就可以在函数中变量使用前用global 对变量进行说明，改变后变量依然是全局变量。

def func3():
    # 在函数里面修改全局变量的值，不会修改成功，而是定义一个新的局部变量
    m = 299
    print('函数里面的m:', m)          # 函数里面的m: 299

    global n
    n = 299
    print('函数里面的n:', n)          # 函数里面的n: 299

    global t
    t = 300


func3()
print('函数外面的m:', m)        # 函数外面的m: 100
print('函数外面的n:', n)        # 函数外面的n: 299
print('函数外面的t:', t)        # 函数外面的t: 300

04 参数

1. 位置参数和关键字参数

• 根据实参提供方式的不同，将实参分为位置参数和关键字参数两种

1）位置参数 ：以 ’ 数据1，数据2，数据3，…’ 的形式存在,让实参对应的数据和形参的变量位置一 一对应。

def func1(x,y,z):
    print(f'x:{x},y:{y},z:{z}')
func1(100,200,300)   #  x:100,y:200,z:300
func1(200,300,100)   #  x:200,y:300,z:100

2）关键字参数：以’ 参数名1=数据1，参数名2=数据2，参数名3=数据3，…’ 的形式存在。

注意：多个关键字参数可以随意交换位置，它不会影响形参和实参的对应关系。

def func1(x,y,z):
    print(f'x:{x},y:{y},z:{z}')
func1(x=100,y=200,z=300)  # x:100,y:200,z:300
func1(y=200,x=100,z=300)  # x:100,y:200,z:300
func1(x=300,z=100,y=200)  # x:300,y:200,z:100

3）混用：调用函数的时候位置参数和关键字参数可以一起使用，但是位置参数必须放在关键字参数的前面。

def func1(x,y,z):
    print(f'x:{x},y:{y},z:{z}')
func1(100,z=200,y=300)   # x:100,y:300,z:200
func1(100,z=200,300)     # 报错！位置参数必须放在关键字参数的前面。

2. 参数默认值

1）定义函数的时候，可以以 ’ 变量名=值 ’ 的形式，给形参赋默认值。已经有默认值的参数，在调用函数的时候可以不用传参。

def func1(x=10,y=20,z=30):
    x=100
    print(f'x:{x},y:{y},z:{z}')
func1()                # x:100,y:20,z:30
func1(100)             # x:100,y:20,z:30
func1(100,200)         # x:100,y:200,z:30
func1(100,200,300)     # x:100,y:200,z:300
func1(z=300)           # x:100,y:20,z:300

2）定义函数的时候，可以有的参数有默认值，有的参数没有默认值，但是没有默认值的参数必须在有默认值的参数的前面。

def func2(x,y=20,z=30):     #  调用时，x必须赋值。
    print(f'x:{x},y:{y},z:{z}')

func2(10)            # x:10,y:20,z:30

3. 参数类型说明

1）没有默认值的参数说明类型的方法：（形参名：类型名）
2）有默认值的参数，默认值的类型就是对应的参数类型

def  func3(str1:str,str2='')

4. 不定长参数

1）带*的不定长参数：定义函数的时候在某个形参的前面加 * ，那么这个参数就变成了一个不定长参数，一个不定长参数可以同时接收多个实参。

• 原因：（* 形参）会自动变成一个元组，当你在调用的时候，这个元组的元素会由0变成n个。

• 如果一个定长参数放在一个不定长参数的后面，那个定长参数必须用关键字参数传参。

• 单独的 * 后面的参数也必须使用关键字参数传参。

  def  func4(a,*,b):   # 函数调用时，b必须使用关键字参数传参
      pass
  func4(10,b=23)
  func4(a=20,b=34)
  

2）带**的不定长参数 （了解即可）

• 原因：（** 形参）会自动变成一个字典，必须使用关键字参数传参。