day 12-函数进阶学习总结

day 12-函数进阶

1.返回值

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

1）怎么确定函数返回值

怎么将函数内部的数据传递出去

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

2)怎么获取函数返回值

获取函数调用表达式的值，就是获取函数的返回值。(每一个函数调用表达式都有结果，结果就是这个函数的返回值)函数返回的值能做的事情，调用表达式都可以做
函数调用表达式–调用函数的语句

3）什么时候需要函数返回值

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

def func1(num1, num2):
    # num1 = 10; num2 = 20
    print('=====')
    result = num1 + num2
    # print(result)
    return result    # return 30

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

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

nums = [30, func1(10, 20)]
print(nums)

print(30 * 2 + 3, func1(10, 20) * 2 + 3)

result = print('hello world!')
print(result)

result = sorted([10, 29, 8])
print(result)

# 编写一个函数，交换指定字典的key和value。
def exchange_key_value(dic):
    new_dic = {}
    for key in dic:
        value = dic[key]
        new_dic[value] = key        # 字典[键] = 值
    return new_dic


dict1 = {'a': 10, 'b': 20, 'c': 30}
result = exchange_key_value(dict1)
print(result)
result['d'] = 100
print(result)


def exchange_key_value2(dic):
    keys = dic.keys()
    for key in keys:
        value = dic.pop(key)
        dic[value] = key


dict1 = {'a': 10, 'b': 20, 'c': 30}
exchange_key_value2(dict1)
print(dict1)

2. return的作用

1. return

函数体中的关键字

1）确定函数返回值

2）提起结束函数

在执行函数体的时候，什么时候遇到return，函数什么时候结束

def func1():
    return 100


def func2():
    return          # return None


func1()
func2()


def func3():
    print('========')
    print('+++++++++')
    for x in range(3):
        if x == 1:
            return 100
        print(x)
    print('hello world!')


result = func3()     # result = 100
print('result:', result)


========
+++++++++
0
result: 100

3.变量的作用域

1.变量的作用域

变量定义后可以使用的范围

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

2.全局变量和局部变量

1）全局变量

Python中没有定义在函数中，类中的变量就是全局变量；

全局变量的作用域；从定义开始，到程序结束。

2)局部变量

定义在函数中变量是局部变量（形参是属于定义在函数中的变量);局部变量的作用域︰从定义开始，到函数结束

每次调用函数的时候系统都会自动为这个函数创建一个临时栈区间，这个函数中产生的所有的数据，默认情况下都是保存在这个临时栈区间中的。

当函数调用结束的时候，这个临时栈区间会被自动释放（里面的数据都会被自动销毁）。

print('------------------------------------全局变量-----------------------------------')
# a是全局变量
a = 100

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


print('函数外面:', a, x, b)


def func1():
    print('函数里面:', a, x, b)


func1()

print('------------------------------------局部变量-----------------------------------')


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


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

3. global的用法

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

用法2：在函数中定义全局变量，也可以使用global

print('------------------------------------global的用法-----------------------------------')
m = 100
n = 100


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

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

    global t
    t = 300


func3()
print('函数外面的m:', m)
print('函数外面的n:', n)
print('函数外面的t:', t)

4.参数

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

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

1）位置参数:

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

2）关键字参数：

以’参数名1=数据1,参数名2=数据2,参数名3=数据3,…'的形式存在。

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

3）混用：

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

def func1(x, y, z):
    print(f'x:{x}, y:{y}, z:{z}')


func1(100, 200, 300)
func1(200, 100, 300)
func1(x=100, y=200, z=300)
func1(y=200, x=100, z=300)
func1(100, z=300, y=200)
func1(100, 200, z=300)
# func1(100, y=200, 300)        # 报错！位置参数必须在关键字参数的前面

2.参数默认值

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

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

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


func2()         # x:10, y:20, z:30
func2(100)      # x:100, y:20, z:30
func2(100, 200)     # x:100, y:200, z:30
func2(100, 200, 300)       # x:100, y:200, z:300
func2(z=300)            # x:10, y:20, z:300


def func3(x, y, z=30):
    print(f'x:{x}, y:{y}, z:{z}')


def func4(x, y=20, z=30):
    print(f'x:{x}, y:{y}, z:{z}')


# def func5(x=10, y=20, z):             # 报错！
#     print(f'x:{x}, y:{y}, z:{z}')

3. 参数类型说明

没有默认值的参数 - 形参名:类型名

有默认值的参数，默认值的类就是对应的参数类型

def func6(str1: str, str2='') -> int:
    pass

4.不定长参数（了解）

1）带*的不定长参数:

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

本质：带一个的不定长参数的本质就是一个元组，它接收到的所有的实参是这个元组中的元素

*注意：*对应的不定长参数传参的时候只能用位置参数传参

2）带**的不定长参数

# 案例1：定义一个函数计算多个数的和
# sum2(19, 27, 78, 89, 2, 67)
def sum2(*num):
    # print('num:', num)
    s = 0
    for x in num:
        s += x
    return s


print(sum2())
print(sum2(10))
print(sum2(20, 30))
print(sum2(1, 34, 7, 8, 10))


def func1(x, *y):
    print(f'x:{x}, y:{y}')


func1(100)
func1(100, 233)
func1(100, 12, 23)

# 如果一个定长参数放在一个不定长参数的后面，那么这个定长参数必须用关键字参数传参!
def func2(*x, y):
    pass


func2(y=10)
func2(10, 29, 38, 29, y=300)


# ！！！！单独的*后面的参数必须使用关键字参数传参
def func3(a, *, b):
    pass


func3(10, b=23)
func3(a=20, b=34)


# 案例2：定义一个函数收集一个学生的信息（姓名、年龄、电话和各科成绩）
def create_student(name, age, tel, **score):
    print(score)


stu1 = create_student('小明', 18, '110', math=98, english=76)
stu2 = create_student('小花', 20, '112', ch=70, physics=82, math=67, english=90)