python入门之函数

---

一、函数定义与调用

"""
1.函数就是将一段具有独立功能的代码块整合到一个整体并命名，
在需要的时候调用这个名称即可完成对应的需求

2.函数在写代码过程中可以高效的实现代码重用
"""


# 1.函数必须先定义（在前）后使用（在后），python 中没有main函数
def info_print():
    print("hello")


info_print()


# 2.
def add(a, b):  # a, b 是形参
    print(a + b)


add(20, 30)  # 20， 30 是实参


# 3.
def add_1(a, b):
    return a * b  # 遇见return 结束并退出当前函数，返回值返回到函数调用的地方
    print("return后面的语句不执行")


print(add_1(30, 2))

二、函数说明文档

# 1.help可以用来查看函数说明文档或者将光标放在函数名上，Ctral+Q也可查看
help(len)


# 2.
def sum_num(a, b, c, d):
    """
    对输入的实参进行求和
    """
    return a + b + c + d


help(sum_num)


# 3.
def qiu_ji(a, b, c, d):
    """求积函数
    @param a: 参数1
    @param b: 参数2
    @param c: 参数3
    @param d: 参数4
    @return: 返回值
    """
    return a * b * c * d


help(qiu_ji)

三、函数嵌套Ⅰ

# 1.
def add(a, b):
    """
    求和
    :param a:
    :param b:
    :return:
    """
    return a + b


def sum1(c, d):
    """
    求和
    :param c:
    :param d:
    :return:
    """
    return c + d + add(a=10, b=20)


print(sum1(3, 2))


# 2.
def print_line():
    print('-' * 20)


def print_lines(num):
    i = 0
    while i < int(num):
        print_line()
        i += 1


print("请输入行数：")
print_lines(input())

四、函数嵌套Ⅱ

def sum_num(a, b, c):
    return int(a) + int(b) + int(c)


def average():
    return sum_num(a=input(), b=input(), c=input()) / 3


print(average())

五、函数中的全局和局部变量

a = 100
print(f'全局变量：{a}')


def text():
    print(f'全局变量：{a}')


def text01():
    a = 200  # 这是定义定义并初始化局部变量 a ，并不是对全局变量 a 的修改
    print(f'局部变量：{a}')


text()
text01()  # 打印的是局部变量

print(f'全局变量并没有被修改：{a}')


def text02():
    global a  # 这个声明了这个 a 是全局变量 a
    a = 3000  # 此时就是对全局变量的修改
    print(f'全局变量被修改了：{a}')


text02()
print("--------------")

六、函数返回值

def text03():
    return 500


def text04(num):
    print(num)


text04(text03())  # 函数返回值作为实参传递到形参


def return_fun():
    # return 1, 2  # 返回多个值是，默认以元组形式返回，但返回一个值时不是这样
    # return (10, 20, 30, 40)
    # return [10, 20, 30, 40]  # 可以直接返回这个列表
    # return {'name': 'zmz', 'age': 40, 'gender': 'boy'}
    return {10, 20, 30, 40, 40, 50, 10}


print(return_fun())

七、函数参数传递

# 1.按顺序进行参数传递
def user_info1(name, age, gender):
    print(f'名字是{name},年龄是{age},性别是{gender}')


user_info1('张明', 21, '男')


# 2.关键字参数 -- 调用函数时采用关键字参数传参时，与顺序无关，不必放在相应位置
def user_info2(name, age, gender):
    print(f'名字是{name},年龄是{age},性别是{gender}')


user_info2("张明", age=18, gender="男")
user_info2("李楠", gender="女", age=19)  # 关键字参数与顺序无关，不必放在相应位置
user_info2("张明", 18, gender="男")
# user_info(name="张明志", 18, gender="男")  # 位置参数必须放在关键字参数的前面，并且放在相应位置

print("=========================")


# 3.缺省参数 -- 传参的个数可以少于被调用的函数的形参个数，但定义函数时要注意初始化形参
def user_info3(name, age, gender='男'):  # 设置gender默认值为“男”
    print(f'{name}\t{age}\t{gender}')


user_info3("张明", 20)
user_info3("李楠", 20, "女")  # 修改默认值为“女”

print("=========================")

# 4.不定长参数 -- 用于不确定调用时会传递多少个参数时（不传参也可以）的场景
"""
（1）包裹位置传递 -- 传进来的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组（tuple），
args是元组类型，这就是包裹位置传递
"""


def user01(*args):
    print(args)  # 打印输出数据默认是元组类型


user01()  # ()
user01("张明")  # ('张明',) -- 单个元素的元组，必须有逗号
user01("张明", 20, "男")  # ('张明志', 20, '男')

print("=========================")

"""
（2）包裹关键字传递 -- 传进来的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个字典（dict），
"""


def user02(**args):
    print(args)  # 打印输出数据默认是字典类型


user02()
user02(name='张明')
user02(name='张明', age=18)
# user02('张明', 18) # 这种格式是错误的
'''
包裹位置传递 和 包裹关键字传递 都是组包的过程
'''

八、函数中的拆包

# 1.元组拆包
def return_num():
    return 100, 200


print(return_num())  # 多个返回值，所以是元组类型


num1, num2 = return_num()
print(num1, num2)
"""
拆包完成 -- 把元组拆成一个个元素，但这样拆要注意，接收变量num1, num2...数目要和元组内元素数目相同
但这样拆要注意，接收变量num1, num2...数目要和元组内元素数目相同
"""

# 2.字典拆包
dict1 = {'name': "张明志", 'age': 20, 'gender': "男"}
a, b, c = dict1
print(a, b, c)  # 把 key 赋给a, b

print(dict1[a], dict1[b], dict1[c])  # 通过 key 查找 value 值并打印，字典不支持下标

# 这也是一种拆包
t1 = (100, 200, 300, 400)
a, b, c, d = t1
print(a, b, c, d)

九、函数中的引用Ⅰ

# 一.变量交换
a, b = 20, 100
print(a, b)
a, b = b, a  # 非常简单
print(a, b)

print("======================")

# 二.“引用”的解释 -- 类比C语言中的指针
"""
1.不可变数据类型的引用
"""
a = 1
b = a
print(id(a), id(b))  # 十进制地址值
print(a, b)

a = 2  # 这里会开辟一个新的存储空间，即整型是不可变类型 --不能把某一地址对应的存储空间里的整型数据直接修改
print(id(a), id(b))
print(a, b)

print("======================")

"""
2.可变数据类型的引用
"""
aa = [1, 2, 3, 4, 5, 6]
bb = aa

print(id(aa), id(bb))
print(aa, bb)

aa.append(100)

print(aa, bb)
print(id(aa), id(bb))

十、函数中的引用Ⅱ

def text01(a):
    print(a)
    print(id(a))

    a += a
    print(a)
    print(id(a))

    print("============")


b = 100  # 整型，不可变类型
text01(b)

c = [10, 20, 30]
text01(c)

"""
可变类型：
列表
字典
集合

不可变类型：
整型
浮点型
字符串
元组
"""

十一、函数综合举例

def print_info():
    print("请选择功能：")
    print("1.添加学员")
    print("2.删除学员")
    print("3.恢复刚才删除的数据")
    print("4.修改学员")
    print("5.查询学员")
    print("6.显示所有学员")
    print("7.退出系统")
    print("------------------")


info_list = []  # 存储所有学员信息


def add_info():  # 此函数用于输入学员信息
    """添加学员函数"""
    # 输入并临时存储单个学员信息
    new_id = input('请输入学号：')
    new_name = input('请输入姓名：')
    new_tel = input('请输入手机号码：')
    info_dict = {'id': new_id, 'name': new_name, 'tel': new_tel}

    # 检验学员信息是否重复
    text = True
    global info_list
    for i in info_list:
        if (i['id'] == info_dict['id']) or (i['tel'] == info_dict['tel']):
            print("添加信息已经存在！请重新添加！")
            text = False
            add_info()
            break
    if text:
        info_list.append(info_dict)  # 不重复则添加


deleted = {}
deleted_index = 0


def del_info():
    """删除学员函数"""
    del_num = input('请输入需要删除的学员的<学号>：')
    global info_list
    global deleted
    global deleted_index
    for i in info_list:
        if i['id'] == del_num:
            deleted = i  # 先保存需要的删除数据及其下标
            deleted_index = info_list.index(i)

            info_list.remove(i)
            break
    else:
        print("您想要删除的数据不存在！")


def undel_info():
    """恢复学员函数"""
    global info_list
    info_list.insert(deleted_index, deleted)


def modify_info():
    """修改学员函数"""
    global info_list
    sign = False
    modify_id = input("请输入需要修改的学员的学号：")
    for i in info_list:
        if i['id'] == modify_id:
            while True:
                sign = input("a:修改学号，b:修改姓名，c:修改号码，d:保存并退出")
                if sign == 'a':
                    i['id'] = input("修改后学号：")
                elif sign == 'b':
                    i['name'] = input("修改后姓名：")
                elif sign == 'c':
                    i['tel'] = input("修改后号码：")
                elif sign == 'd':
                    sign = True
                    break
                else:
                    print("无效字母！")
        if sign:
            break
    else:
        print("您想要修改的数据不存在！")


def search_info():
    """查询学员函数"""
    global info_list
    search_id = input("请输入需要查询的学员的学号：")
    for i in info_list:
        if i['id'] == search_id:
            print(f"学号：{i['id']}, 姓名：{i['name']}, 号码：{i['tel']}")
            break
    else:
        print("查询的学员不存在！")


def print_all():
    """显示所有成员"""
    global info_list
    print("学号\t姓名\t号码")
    for i in info_list:
        print(f"{i['id']}\t{i['name']}\t{i['tel']}")


print_info()  # 打印操作提示
while True:
    user_num = int(input("请输入序号："))
    if user_num == 1:  # 添加学员
        add_info()
        print(info_list)
    elif user_num == 2:  # 删除学员
        del_info()
        print(info_list)
    elif user_num == 3:  # 恢复刚才删除的学员
        undel_info()
        print(info_list)
    elif user_num == 4:  # 修改学员
        modify_info()
        print(info_list)
    elif user_num == 5:  # 查询学员
        search_info()
    elif user_num == 6:  # 显示所有学员
        print_all()
    elif user_num == 7:
        print('退出系统')
        break
    else:
        print("输入序号有误！请重新输入！")

---