第四章 函数（初级）

目录

4.1 函数定义

4.2 局部变量、全局变量和返回值

4.3 函数的嵌套调用

4.4 函数的应用

4.5 函数传参的两种形式

4.6 函数形参

4.7 拆包

4.8 引用（有待后续学习……）

4.9 可变数据和不可变数据

4.10 引用作函数参数（函数传参传递的是引用）

4.11 学生管理系统

1.添加学生信息 2.修改学生信息 3.删除学生信息

4.查询单个学生信息 5.查询所有学生信息 6.退出系统

4.12 递归函数

 4.13 匿名函数

4.14 列表排序

4.15 列表推导式：快速创建列表

4.16 集合（set）

---

4.1 函数定义

（1）函数的定义

def 函数名():
    代码
函数名()

 （2）带有参数的函数定义

#函数定义
def fun(a,b):
    a = a + b
    print(f'{a}小赵你好')

fun(1,8)#调用函数
>>> 9小赵你好

4.2 局部变量、全局变量和返回值

（1）局部变量：在函数内部定义的变量，只能在函数内部使用

（2）全局变量：在函数外部定义的变量，函数的内部和外部都可以使用，在函数内部修改全局变量时，需要提前使用global 全局变量 声明

num1 = 3
def jubu():
    num = 1 + num1#使用全局变量但没有修改
    print(num)
jubu()
>>> 4

num1 = 3
def quanju():
    global num1
    num1 = 4
    num = 1 + num1
     print(num)
quanju()
>>> 5

（3）返回值（return）

在python定义函数时，可以使用return 或print来输出

①return 的作用：终止函数并将return值返回。程序遇到第一个return时会结束函数并返回，不会运行第二个return,但并不是说函数只有一个return。且return一次可以返回多个值

def d(x,y):
    if x == y:
        return x,y
d(1,1)
>>> (1, 1)

②return 与print的区别：需要传递函数结果的时候必须使用return

# 当在函数中使用print 时
def result(a):
    if a//2 != 0:
        print(a)
    else:
        print(0)
b = result(2)#此时，b=print(2),因为没有传递结果
print(b)
>>> 2
None

#当在函数中使用return 时
def result(a):
    if a//2 != 0:
        return a
    else:
        return 0
b = result(2)
print(b)#return 可以将函数的结果再函数外使用
>>> 2

③return后面可以不加数值，默认终止函数运行，返回None，函数也可以不写Return,默认返回None

4.3 函数的嵌套调用

（1）函数的嵌套是在一个函数中调用另一个

def func1():
    print('这是第一个函数')
def func2():
    print('这是第二个函数')
    func1()
>>> 这是第二个函数
这是第一个函数

（2）在函数外调用内函数，要先调用内函数，创造内函数的使用环境

（3）使用return 函数名()和函数名()相同

def func3():
    print('这是外函数')
    def func4():
        print('这是内函数')
    return func4()
func3()
>>> 这是外函数
这是内函数

4.4 函数的应用

（1）写一个函数打印一条直线

（2）打印自定义行数的直线

（3）写一个函数：求三个函数的和

①
def one_line():定义函数
    print('-'* 30)
one_line()
>>> ------------------------------
②
def multi_lines(b):#b代表行数,打印多条直线
    a = '-'* 30
    i = 0
    while i < b:
        print (a)#重复打印一行函数
        i = i + 1
multi_lines(5)
>>> ------------------------------
------------------------------
------------------------------
------------------------------
------------------------------
③
def sum(x,y,z):#求三个数的和
    c = x + y + z
    return c
sum(1,2,3)
>>> 6

4.5 函数传参的两种形式

（1）位置传参。按照形参的位置将实参的值传递给形参

def func1(a,b,c):
    print(f'a:{a}')
    print(f'b:{b}')
    print(f'c:{c}')
func1(1,2,3)
>>> a:1
b:2
c:3

（2）关键字传参。指定实参给到哪个形参

func1(b=1,a=2,c=3)
>>> a:2
b:1
c:3

4.6 函数形参

（1）缺省参数（默认参数）

①在函数定义的时候给形参一个默认值，这个形参就是缺省参数

②在函数调用时，如果给缺省参数传递实参值，使用的是传递的实参值，如果没有传递，使用默认值。

def func1(a,b,c=10):#定义函数，缺省参数放在最后
    print(a)
    print(b)
    print(c)
func1(1,2)
func1(1,2,3)
>>> 1
2
10
1
2
3

（2）不定长参数

①在形参前面加上一个 * ,该形参变为不定长元祖形参，可以接收所有位置的位置实参，类型是元祖。

②在形参前面加上两个 ** ，该形参变为不定长形参，可以接收所有的关键字实参，类型是字典

def func2(*args,**kwargs):#定义函数以及不定长参数
    print(args)
    print(kwargs)   
func2(1,2,3,4,5)#元祖形参，传递位置实参
func2(a=1,b=2,c=3,d=4,e=5)#字典型参数，传递关键字参数
func2(1,2,3,a=4,b=5)#混合传递
>>> (1, 2, 3, 4, 5)
{}
()
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
(1, 2, 3)
{'a': 4, 'b': 5}

（3）形参的完整格式

①形式的完整格式

普通形参、不定长元祖形参、缺省参数、不定长字典参数

②sep

print()中的sep 代表每两个字符之间是什么，默认空格

print(1)
print(1,2,sep = '$')
print(1,2,3,sep = '*')
print(1,2,3,4)
>>> 1
1$2
1*2*3
1 2 3 4

4.7 拆包

（1）组包：将多个数据组成元祖，给到一个变量。

a = 1,2,3,4
print(a)#return a,b 也可以
>>> (1,2,3,4)

（2）拆包：将容器的数据分别给到多个变量，数据的个数和变量的个数要保持一致，可以在列表、元祖、字典和函数中用到。（字典会接收key值）

①用变量接收数据

#列表中使用拆包
list1 = [1,2,3,4]
a,b,c,d = list1
print(a,b,c,d)
>>> 1 2 3 4

#元祖中使用拆包
tup1 = [1,2,3,4]
a,b,c,d = tup1
print(a,b,c,d)
>>> 1 2 3 4

#字典中使用拆包会接受key值数据
dict1 = {'a':1,'b':2,'c':3,'d':4}
e,f,g,h = dict1
print(e,f,g,h)
>>> a b c d

②用 * 接收数据

#列表中进行拆包
list2 = [1,2,3,4]
print(*list
>>> 1 2 3 4

#在元祖中进行拆包
tup2 = (1,2,3,4)
print(*tup2)
>>> 1 2 3 4

#在字典中进行拆包，与key值相关联
dict2 = {'a':1,'b':2,'c':3,'d':4}
print(*dict2)
>>> a b  c d

4.8 引用（有待后续学习……）

（1）可变数据类型包括：列表、字典、集合（引用按照变量）

         不可变数据类型包括：数字、字符、布尔、元祖（引用按照数值）

（2）①无论是可变类型还是不可变类型，只要被重新赋值，他的id就会改变，即引用指向新的空间

②针对可变数据类型来说，通过一些方法修改自身的内容，id并没有发生变化，即改变改变个别元素，自身并没有改变

③针对不可变类型数据，只要自身数值发生改变，id就会改变

④通过可变类型的方法修改不可变数据类型中的可变元素时，id也不会改变。例如，修改元祖中的列表

4.9 可变数据和不可变数据

（1）在不改变变量引用的前提下，能改变变量中引用的数据的是可变类型，不能改变的是不可变类型。

（2）在不可变类型里，相同的数据值代表相同的引用，即相同的内存地址。

（3）对于整数int来说，在小整数池[-5,255],每一个数据都有自己的引用地址，超过255就不一样

4.10 引用作函数参数（函数传参传递的是引用）

列表、字典等可变类型数据，修改其中一个值，不用声明全局变量，因为内存地址并没有改变

list1 = [1,2,3]

def func1(a):
    a.append(4)#列表为可变类型，修改其中一个值不用声明全局变量，引用没有改变
    
func1(list1)
print(list1)
>>> [1, 2, 3, 4]

4.11 学生管理系统

使用相应的数字序号实现相应的功能：

1.添加学生信息 2.修改学生信息 3.删除学生信息

4.查询单个学生信息 5.查询所有学生信息 6.退出系统
 

stu_list = []
print('**********欢迎使用本系统************')
def menu():#提示菜单信息
    print('请按提示进行数字操作')
    print('1.添加学生信息')
    print('2.修改学生信息')
    print('3.删除学生信息')
    print('4.查询单个学生信息')
    print('5.查询所有学生信息')
    print('6.退出系统')
    

def insert_stu():#添加学生信息
    name = input('请输入学生姓名：')
    age = int(input('请输入学生年龄：'))
    stu_num = input('请输入学生学号：')
    stu = {'name':name,'age':age,'stu_num':stu_num}
    stu_list.append(stu)
    print('学生信息添加成功')
    

def research_stu():#查询单个学生信息
    name = input('请输入要查询信息学生的姓名：')
    for stu in stu_list:
        if stu['name'] == name:
             print(f'姓名：{stu["name"]},年龄：{stu["age"]},学号：{stu["stu_num"]}')
        else:
            print('没有查询到该生信息') 

def modify_stu():#修改学生信息
    name = input('请输入要修改信息学生的姓名：')
    for stu in stu_list:
        if stu['name'] == name:
            age = int(input('请输入新的年龄：'))
            stu['age'] = age
            print('学生信息修改成功')
        else:
            print('没有查询到该生信息')

def del_stu():#删除学生信息
    name = input('请输入要删除信息学生的姓名：')
    for stu in stu_list:
        if stu['name'] == name:
            stu_list.remove(stu)
            print('学生信息删除成功')
        else:
            print('没有查询到该生信息')
 

    
def all_stu():#查询所有学生信息
    if len(stu_list) == 0:
        print('没有学生信息')
    else:
        for stu in stu_list:
             print(f'姓名：{stu["name"]},年龄：{stu["age"]},学号：{stu["stu_num"]}')
    
while True:#循环调用菜单
    menu()
    begin = int(input('请输入相应地操作数字：'))
    if begin == 1:
        insert_stu()
    elif begin == 2:
        modify_stu()
    elif begin == 3:
        del_stu()
    elif begin == 4:
        research_stu()
    elif begin == 5:
        all_stu()
    elif begin == 6:
        print('********欢迎再次使用本系统***********')
        break
    else :
        print('输入有误，请再次输入')
        continue
    input('按回车键继续')
            

4.12 递归函数

递归函数是自己调用自己

（1）A比B大2岁，B比C大2岁，……F为18岁，求A

（2）计算阶乘factorial()

def get_age(num):#计算年龄
    if num == 1:
        return 18
    else:
        age = get_age(num - 1) + 2
        return age
get_age(3)
>>> 22

def factorial(num):#定义计算阶乘函数
    #1！ = 1
    #2! = 2*1
    #3! = 3*2*1
    if num == 1:
        return 1
    else:
        result = factorial(num - 1) * num
        return result
factorial(5)
>>> 120

 4.13 匿名函数

（1）没有名字的函数是匿名函数。格式：lambda:参数列表：表达式

（2）匿名函数中不能使用if语句、while循环和for 循环，只能编写单行的表达式，可以调用函数

（3）匿名函数不需要使用return,表达式的运行结果就是返回结果，普通函数返回结果必须return

（4）匿名函数中也可以不返回结果

4.14 列表排序

（1）使用shift + tab 键对函数进行查阅，list.sort(self,key= None,reverse=False)

（2）使用sort()函数对列表排序

list1 = [1,4,2,5,7,3]
list1.sort()
list1
>>> [1, 2, 3, 4, 5, 7]

list1.sort(reverse = True)
list1
>>> [7, 5, 4, 3, 2, 1]

（3）使用匿名函数可以为列表中字典的排序制定规则

list2 = [{'name':'b','age':18},{'name':'a','age':19},{'name':'c','age':20}]
list2.sort(key = lambda x:x['name'])
list2
>>> [{'name': 'a', 'age': 19}, {'name': 'b', 'age': 18}, {'name': 'c', 'age': 20}]

4.15 列表推导式：快速创建列表

（1）格式一：变量 = [生成数据的规则 for 临时变量 in xxx]

list1 = [i for i in range(5)]
list1
>>> [0, 1, 2, 3, 4]

list2 = ['hello' for i in range(5)]
list2
>>> ['hello', 'hello', 'hello', 'hello', 'hello']

（2）格式：变量 = [生成数据的规则 for 临时变量 in xxx if xxx]，每循环一次，并且if条件为True,生成一个列表

list3 = [i for i in range(5) if i % 2 == 0]
list3
>>> [0,2,4]

（3）格式：变量 = [生成数据的规则 for 临时变量 in xxx for j in xxx]

list4 = [i for i in range(5) for j in range(5)]
list4
>>> [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4]

（4）字典推导式：变量 = [生成字典的规则 for 临时变量 in xxx]

dict1 = {'name': i for i in range(3)}
dict1
>>> {'name': 2}

 （5）变量 = ['第{}天'.format(i) for i in range(n)]

4.16 集合（set）

（1）集合使用{}定义，{数据，数据}

（2）集合中的数据必须是不可变类型，集合本身是可变类型

（3）集合中的元素时无序的，数据的输入和输出不一致

（4）集合中的数据是不能重复的

（5）集合不支持下标操作

#集合
set1 = {3, (1,2,3) , 3.14, '啦啦啦', True}
set1
>>> {(1, 2, 3), 3, 3.14, True, '啦啦啦'}
#删除
set1.remove(3.14)
set1
>>> {(1, 2, 3), 3, True, '啦啦啦'}
#添加
set1.add(3.14)
set1
>>> {(1, 2, 3), 3, 3.14, True, '啦啦啦'}
#无重复
set2 = {1,1,3.14,'sueh'}
set2
>>> {1, 3.14, 'sueh'}