Python之函数、组包、解包

一. 函数

1. 函数的基本使用 (重点)

"""
函数的作用：可以将具有独立功能的代码块包装成一个整体
使用函数： 1.定义函数（将具有独立功能的代码包装起来）
          2.调用函数（执行包装的代码）
函数的优点：1.更方便的使用功能
           2.减少重复代码，避免代码的冗余
           3.有利于代码重构
"""


import random

# 1.定义函数 def 函数名():
def func1():
    # 使用模块功能 randint(m, n) 从[m, n]范围中随机出一个整数
    # print(random.randint(3, 5)) # 3 4 5

    # 1.使用变量记录用户输入的出拳编号
    player = int(input("请输⼊要出的拳：⽯头（1）／剪⼑（2）／布（3）"))
    # 2.定义变量记录电脑的出拳编号
    computer = random.randint(1, 3)
    print("玩家出拳：%s 电脑出拳：%s" % (player, computer) )

    # 判断胜负
    if (player == 1 and computer == 2) or \
            (player == 2 and computer == 3) or \
            (player ==3 and computer == 1):
        print("玩家胜利")
    elif computer == player:
        print("平局")
    else:
        print("电脑胜利")

# 2.调用函数  函数名()
func1()

print("其他的一些功能")

func1()

2. 函数的调试

# 函数必须先定义后调用
# func1()  # 函数还没有定义，会报错
print("开始")

# 定义函数  将函数名添加到内存中
def func1():
    print("*" * 10)
    print("func1")
    print("*" * 10)

# 调用函数（才会执行函数中代码）到内存中查询该函数名，如果有，就会执行函数中的代码；如果没有就报错
func1()
print("其他一些处理")
func1() # 想要单步执行函数中的代码，需要使用step into功能

3. 函数文档

def func1():
    """函数1
    设置函数文档：在函数定义的下方第一行，添加多行注释"""
    print("func1")

func1() # 查看函数文档 View- Quick Documentation

4. 函数参数 (重点)

# 函数参数的作用：可以将数据传递到函数内部，增加函数的通用性

# 需求：定义函数，实现加法运算

# 1.设置形参（定义函数时设置的参数）给真实数据进行“占位” num1 = 3， num =4
def func_sum(num1, num2):
    num = num1 + num2 # 将代码转为 num = 3 + 4
    print(num)

func_sum(1, 3) # 设置实参（调用函数时设置的参数）传递给函数的真实数据
func_sum(3, 4)

• 形参的作用域

# 形参的作用域（使用范围）：定义形参的函数内部

# 形参只在定义自己的函数中有效，不同函数的形参可以同名（相互没有影响）
def func_sum(num1, num2):
    """求和"""
    print(num1 + num2)

def func_sub(num1, num2):
    """求差"""
    print(num1 + num2)

func_sum(10, 20)
func_sub(30, 12)
# print(num1) 形参只能在函数内部使用，在外部使用会报错

5. 全局变量和局部变量

• 局部变量

"""
局部变量：在函数中定义的变量
使用范围：函数内部
"""

def func1():
    num = 10
    print(num)

func1()
# 局部变量只能在函数内部使用，在外部使用会报错
# print(num)

• 全局变量

"""
局部变量：在函数外部定义的变量
使用范围：整个文件
"""

num = 10 # 全局变量

def func1():
    print(num) # 函数中可以使用

func1()
# 函数外也可以使用
print(num)

• 声明全局变量

# 全局变量
num = 10

def func1():
    num = 3 # 在函数中对变量赋值时，会创建一个新的局部变量
    print(num) # 3 局部变量（全局变量和局部变量同名时，函数中优先使用局部变量）

func1()
print(num) # 10 全局变量（局部变量只能在函数中使用，所以函数外部使用的只可能是全局变量）


"""声明全局变量"""

num = 10 # 全局变量

def func1():
    # 如果想要在函数中修改全局变量，需要先声明变量为全局变量  global 全局变量名
    global num # 声明后，不再创建新的局部变量num，而是使用全局变量num
    num = 3 # 全局变量
    print(num)

func1()
print(num) #全局变量

5. 函数返回值 (重点)

"""
函数的返回值：函数的执行结果

什么时候设置函数的返回值：函数的调用者需要获取到函数的执行结果，并进行进一步的处理
"""

def func_sum(num1, num2):
    sum = num1 + num2
    print(sum)
    # 函数的返回值默认为None

    # 设置返回值
    return sum
    print("123") # 一旦执行了return，函数中后续的代码将不会执行

# 需求：需求根据求和的结果，进行横杠打印 "-" * “和”
a = func_sum(10, 2)
# print(a)
# None
print("-" * a)


"""
四种函数类型：
1.无参数，无返回值
2.有参数，无返回值
3.无参数，有返回值
4.有参数，有返回值
"""

6. 函数嵌套调用 (重点)

# 函数嵌套调用：在函数中 调用 另一个函数
def func1():

    print("func1开始") # 2
    print("func1结束") #3

def func2():

    print("func2开始") # 1

    func1()

    print("func2结束") # 4

func2()
print("完成") # 5

• 练习1

"""需求1：定义函数 实现单行打印 可以指定 字符 和 长度"""
def print_line(char, length): # char = "/", length = 8
    """单行打印"""
    print(char * length)

# print_line("-", 10)
# print_line("*", 20)


"""需求2：定义函数 实现多行打印  可以指定 字符 长度 行数"""
def print_lines(char, length, line): # char = "/", length = 8, line = 10
    """多行打印"""
    i = 1
    while i <= line: # 替换为while i <= 10:
        print_line(char, length) # 替换为print_line("/", 8)
        i += 1

print_lines("/", 8, 10)

• 练习2

"""需求1：定义一个函数实现3个数字的求和"""
def add3num(num1, num2, num3):
    ret = num1 + num2 + num3
    print("和为：%s" % ret)
    return ret

# print(add3num(1, 2 ,5))


"""需求2：定义一个函数实现求3个数字的平均值   3个数字和/3"""
def avg3num(num1, num2, num3): # num1 = 1, num2 = 30, num3 =2
    # 求和
    ret1 = add3num(num1, num2, num3) # 替换为add3num(1, 30, 2)
    # 除3，求平均值
    avg_num = ret1 / 3
    print("平均值：%s" % avg_num)

avg3num(1, 30, 2)

• 练习3

# 调用者 通过 参数 将数据 传递到函数中
# 函数 通过 返回值 将数据 返回给调用者

"""需求1：定义函数 实现三个数字的升序排列  提示list.sort()"""
def func_sort(num1, num2, num3):
    my_list = [num1, num2, num3]
    # 排序列表
    my_list.sort()
    print(my_list)
    return my_list

# print(func_sort(10, 50, 20))

"""需求2：定义函数 实现三个数字的最大值 升序排列的最后一个"""
def func_max(num1, num2, num3): # num1 = 10  num2 =50  num3 =20
    # 调用排序函数，实现升序处理
    list1= func_sort(num1, num2, num3) # 替换为 func_sort(1, 50, 20)
    # 获取排序列表的最后一个
    ret2 = list1[-1]
    print("最大值：%s" % ret2)

func_max(10, 50, 20)


"""需求3：定义函数 实现三个数字的最小值 升序排列的第一个"""
def func_max(num1, num2, num3):
    # 调用排序函数，实现升序处理
    list1= func_sort(num1, num2, num3)
    # 获取排序列表的第一个
    ret2 = list1[0]
    print("最小值：%s" % ret2)

func_max(10, 50, 20)

7. 参数详解

• 实参类型

"""
parameter 形参  argument 实参
实参类型 ：位置实参    关键字实参（命名参数）
形参类型： 普通形参    默认形参（缺省参数）  可变形参
"""

# 位置参数：普通实参  -> 按照位置顺序赋值给形参，要求和形参一一对应
def func1(num1, num2):
    print(num1)
    print(num2)

# func1(1, 3)

# 关键字参数：可以将实参赋值给指定的形参
# 关键字实参必须在位置参数的后面
func1(num2=1, num1=3)

• 默认形参(缺省参数）

# 默认形参（缺省参数）：可以给形参设置默认值  设置实参则使用实参，不设置则使用默认值
# 默认形参必须在普通形参的后边
def func1(num1, num2=10):
    print(num1)
    print(num2)

func1(1)

• 元组型可变形参

"""
元组型可变形参：可以接收任意数量的位置实参
格式：在形参前加* 表示该形参为 元组型可变形参
机制：可以将任意数量的位置实参包装为元组，再赋值给可变形参args
"""

def func_sum(*args):
    print(args)

func_sum(1, 2, 4, 5)
func_sum(1, 2)
# (1, 2, 4, 5)
# (1, 2)

def func_sum(*args):
    """求和函数"""
    sum = 0
    for num in args:
        sum += num

    print(sum)

# 需求：求和函数
func_sum(1, 2, 4, 5)
func_sum(1, 2)

• 字典型可变形参

"""
字典型可变形参：可以接收任意数量的关键字实参
格式：在形参前加** 表示该形参为 字典型可变形参
机制：可以将任意数量的关键字实参包装为字典，再赋值给形参kwargs
"""

def save_userinfo(**kwargs):
    print(kwargs)

save_userinfo(name = "张三", age = 20, weight = 75, gender = True)
# {'name': '张三', 'age': 20, 'weight': 75, 'gender': True}


def save_userinfo(name, **kwargs):
    print(name)
    print(kwargs) # 字典
    # print(kwargs.get("age"))
    # print(kwargs.get("height"))

save_userinfo("张三", age = 20)
save_userinfo("张三",height = 1.7, weight = 75, gender = True)

二. 高级特性

1. 组包和解包

"""组包： =号右边有多个数据时，会自动包装为元组"""
a = 10, 20, 30
print(a)

"""解包/拆包：变量数量 = 元素数量，元素会自动一一对应赋值"""
a, b, c = [10, 20, 30]
print(a)
print(b)
print(c)

"""先将10，20组包为元组(10, 20), 然后解包一一对应赋值 a = 10 b = 20"""
a, b = 10, 20
print(a)
print(b

• 应用场景

"""应用场景1 交换两个变量的值"""
a = 5
b = 4

# 方案1 临时变量
temp = a  # temp = 5
a = b  # a = 4
b = temp  # b =5
print(a)
print(b)

# 方案2  数学公式
a = a + b
b = a - b
a = a - b
print(a)
print(b)

# 方案3 组包
a, b = b, a  # a, b = 4, 5
print(a)
print(b)


"""应用场景2 设置多个返回值"""
def func1():
    return 10, 20, 30  # 本质就是组包，多个返回值会包装为元组

a = func1()
print(a)
# (10, 20, 30)

a, b, c = func1()
print(a)
print(b)
print(c)


"""应用场景3 字典.items()"""
dict1 = {"name": "zs", "age": 20}
for key in dict1: # 遍历字典取出的是键
    print(key)

# 字典.items()  返回一个可迭代对象,遍历后取出键值对(元组形式)
for data in dict1.items(): # data = ("name", "zs")
    print(data)
# ('name', 'zs')
# ('age', 20)


for key, value in dict1.items(): # key, value = ("name", "zs")
    print(key)
    print(value)
# name
# zs
# age
# 20