函数的定义和调用

函数：

单独的一个功能，经常使用，将实现该功能的代码放在一起，起个别名

语法：

函数的定义：

Def 自定义的函数名():

实现功能的代码

函数的调用：

函数名()

比如调用print函数，就是print()

函数一定是先定义，后调用

系统函数/自定义函数

# 封装一个九九乘法表的打印函数
def print99():
    for i in range(10):
        for j in range(1,i+1):
            print("%d * %d = %d\t"%(j,i,j*i),end="")
        print()

print99()

函数参数的使用

Def 函数名(参数......):

代码.....

形参：

出现在函数的定义中，定义时没有具体值

实参：

出现在函数的调用中

调用的时候，实际参数的值赋值给形式参数

上面的九九乘法表定义有所缺陷，试想一下，如果要求打印6、7行的乘法表，是不是得再写两个函数呢？

在这，我们将上面九九乘法表的函数改进一下；

# 封装一个九九乘法表的打印函数
def print99(lines):
    for i in range(lines+1):
        for j in range(1,i+1):
            print("%d * %d = %d\t"%(j,i,j*i),end="")
        print()

print99(9)
print("--------------")
print99(6)

需求：升级学生管理系统v1.2（用函数将代码进行精简）

students={}
def show_menu():
    print("欢迎光临学生管理系统v1.1：")
    print("1、添加学生")
    print("2、查找学生")
    print("3、展示所有")
    print("4、删除学生")
    print("5、修改学生")
    print("6、退出系统")

def add_stu():
    # 添加学生逻辑
    name=input("学生姓名")
    score=input("学生分数")
    student={'name':name,'score':score}
    students[name]=student
    print("添加成功")

def search_stu():
    # 输入要查找的学生姓名
    search_name=input("请输入你要查找的学生姓名")
    all_keys=students.keys()
    if search_name not in all_keys:
        print("没有你要查找的学生")
    else:
        student_dict=students[search_name]
        print("name:%s score:%d"%(student_dict['name'],student_dict['score']))

def all_stus():
    print("所有学生信息如下",end=":")
    # print(students)
    for key,stu_dic in students.items():
        print("key:%s"%key)
        print("name:%s score:%s"%(stu_dic['name'],stu_dic['score']))

def del_stu():
    del_name=input("请输入要删除的学生姓名")
    all_keys = students.keys()
    if del_name in all_keys:
        del students[del_name]
        print("删除成功")
    else:
        print("没有该学生或者已经删除")

def update_stu():
    # 修改逻辑
    update_name=input('请输入你要修改的学生的姓名:\n')
    all_keys=students.keys()
    if update_name not in all_keys:
        print("没有该学生")
    else:
        new_name=input("请输入新名字")
        new_score=int(input("请输入新分数"))
        new_stu={'name':new_name,'score':new_score}
        #将旧学生删除
        del students[update_name]
        students[new_name]=new_stu
        print("修改成功")

def exit_sys():
    print("退出系统，欢迎再次使用")
    # 调用系统的结束函数
    exit(0)

while True:
    show_menu()
    choose=input("请选择1-6：")
    if choose=='1':
       add_stu()

    elif choose=='2':
        search_stu()

    elif choose=='3':
        all_stus()

    elif choose=='4':
        del_stu()

    elif choose=='5':
       update_stu()

    elif choose=='6':
       exit_sys()
    
    else:
        print("输入有误，请重新输入！！！")

函数的返回值问题

语法：

Def maiFan(money)

Return fan

函数返回值的初步使用

# 求和1+2+3+...+100
def get_sum(n):
    result = 0
    for i in range(1,n+1):
        result+=i
    return result

# 判断一个数是偶数
def is_even_number(n):
    return n%2==0

# 求偶数和
def get_even_sum(n):
    result = 0
    for i in range(1,n+1):
        if(is_even_number(i)):
            result+=i
    return result

num1= get_sum(100)
print(num1)
print(get_even_sum(100))

小练习：

1、完成由*组成的自定义*个数的直线

2、完成 自定义函数的矩形

3、求三个数的平均数

def print_line(n):
    print("*"*n)

def print_more_lines(line,count):
    for i in range(line):
        print_line(count)
        print()

def get_avg(a,b,c):
    return (a+b+c)/3

print_line(6)
print_more_lines(10,6)
print(get_avg(10, 20, 30))

局部变量与全局变量

局部变量

定义在函数内，函数内部有效

形式参数也是局部变量

全局变量

定义在函数外，所有函数中有效

变量一定先定义，后使用

如果在函数中，修改全局变量的值：

1、如果全局变量是基本类型（int，float、bool），修改之前需要使用global声明

2、如果全局变量是引用类型，可以直接修改，不用声明

3、如果在函数中有与全局变量同名的局部变量时，优先访问的为局部变量

# 全局变量
c=100
list1=[1,2,3]

def test1():
    a=10
    a+=23
    print("a = %d"%a)

    list1[0]=22
    # [22, 2, 3]
    print(list1)
    # SyntaxError: name 'c' is assigned to before global declaration
    # c+=200
    global c
    c+=100
    print("c = %d"%c)

test1()

可变参数的使用

函数的参数问题(形参)

1、缺省参数

形式参数为缺省参数的时候，在函数调用的时候，可以不给实际参数，这时候，形参的值是给定的默认值；

如果在调用时，给出了新的实际参数，则形参的值为给的新值；

2、可变参数

*args

如果参数定义的时候，形参是可变参数（*args）

在参数调用时，可以给0个，1个，多个实参

**kwargs

如果函数定义的时候，形参是可变参数（**kwargs）

在函数调用时，可以给0个，1个，多个键值对

# 结束程序（系统程序：传入的值不一样，结束码就不一样）
# exit(code=0)
# exit(0)
# exit()
# exit(-1)
# exit(-1)
# exit(2)

# 缺省函数
def test1(code=2):
    print("code=%d"%code)

test1()
test1(8)

# 可变参数（元组）
def test2(*args):
    print(type(args))
    print(args)

# <class 'tuple'>
# ()
test2()
# (3,)
test2(3)
# (3, 4, 5)
test2(3,4,5)
# ({'name': 'www'},)
test2({'name': 'www'})

# 可变参数（字典）
def test3(**kwargs):
    print(type(kwargs))
    print(kwargs)

# <class 'dict'>
# {}
test3()
# {'name': 'zs'}
test3(name='zs')
# {'name': 'ls', 'sex': '男'}
test3(name='ls',sex='男')


# 可变参数（混合）
def test4(*args,**kwargs):
    print(args)
    print(kwargs)

# ()
# {}
test4()
# (2,)
# {}
test4(2)
# (2, 4)
# {}
test4(2,4)
# ()
# {'a': 5}
test4(a=5)
# ()
# {'a': 5, 'b': 6}
test4(a=5,b=6)
# (1, 2, 4)
# {'a': 5, 'b': 6}
test4(1,2,4,a=5,b=6)

求和运算体现可变参数的好处

# 可变参数带来的好处
def get_sum(*args):
    result=0
    for i in args:
        result+=i
    return result

print(get_sum(1,4))
print(get_sum(1,4,7,9))

注意：可变参数常见问题

# 可变参数定义的常见问题
def test5(a,*args):
    print("这么定义参数没问题！！！")

def test6(*args,b):
    print("这么定义参数是有问题的！！！")

test5(1,2,3)
# TypeError: test6() missing 1 required keyword-only argument: 'b'
# test6(1,2,3)

over......