学习Python，你看这篇就够了 | 【详细】Python基础（二）
2021/4/8 12:10:50
本文主要是介绍学习Python，你看这篇就够了 | 【详细】Python基础（二），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
文章目录
- 11.1 abs()和round()函数
- 11.2 内置高阶函数（map、reduce、filter）
- 9.1 函数的使用
- 9.2 函数的说明文档
- 9.3 函数的嵌套调用
- 9.4 变量的作用域
- 9.5 函数返回值（多返回值）
- 9.6 函数的参数的类型
- 9.7 引用作实参
- 9.8 可变和不可变类型汇总
- 9.9 递归函数和匿名函数（lambda）
- 8.1 列表推导式
- 8.2 字典推导式
- 8.3 集合推导式
- 8.4 推导式总结
- 7.1 运算符
- 7.2 公共方法
- 7.3 容器类型转换
- 前言
- 7. 公共操作
- 8. 推导式
- 9. Python函数
- 10. 学生管理系统
- 11. 高级函数
前言
- 在Python基础（一）中，非常感谢大家的点赞、收藏、评论、关注。
- 在Python基础（二）中，尽量用简洁易懂的方式来梳理知识点。
- 如果对你的学习有帮助，点个赞支持一下，一键三连哦~????
Python基础（一）：https://blog.csdn.net/weixin_46818279/article/details/108576298
7. 公共操作
什么是公共操作那？？？
公共操作：数据序列基本上都支持的一些操作
7.1 运算符
| 运算符 | 描述 | 支持的容器类型 |
|---|---|---|
| + | 合并 | 字符串、列表、元组 |
| * | 复制 | 字符串、列表、元组 |
| in | 元素是否存在 | 字符串、列表、元组、字典 |
| not in | 元素是否存在 | 字符串、列表、元组、字典 |
运算符：+（合并的作用）
str1 = 'aa'str2 = 'bb'list1 = [1,2]list2 = [10,20]t1 = (1,2)t2 = (10,20)dict1 = {'name':'tom'}dict2 = {'age':30}# 1. + : 合并print(str1+str2) # 输出 aabbprint(list1+list2) # 输出 [1, 2, 10, 20]print(t1+t2) # 输出 (1, 2, 10, 20)print(dict1+dict2) # 报错：字典不支持合并运算
运算符：*（复制的作用）
str1 = 'a'list = ['hello']t1 = ('world',)# *:复制 支持字符串、列表、元组print(str1 * 5) # 输出aaaaaprint('-' * 10) # 输出10个----------print(list * 5) # 输出['hello', 'hello', 'hello', 'hello', 'hello']print(t1 * 5) # 输出 ('world', 'world', 'world', 'world', 'world')
运算符：in、not in（判断元素是否存在）
str1 = 'abcd'list1 = [10,20,30]t1 = (100,200,300)dict1 = {'name':'Python', 'age':30}# in 和 not in# 1. 字符a是否存在print('a' in str1) # 输出 Trueprint('a' not in str1) # 输出 false# 2. 数据10是否存在print(10 in list1) # 输出Trueprint(10 not in list1) # 输出False# 3. 100是否存在print(100 in t1) # 输出 Trueprint(100 not in t1) # 输出Fasle# 4. name是否存在print(dict1)print('name' in dict1) # Trueprint('name' not in dict1) # Falseprint('name' in dict1.keys()) # Trueprint('name' in dict1.values() ) # False
7.2 公共方法
公共方法之len()、del()、max()、min()、range(start,end,step)、enumerate()
这六个函数的作用以及用法，举栗子说明
（1）len()：计算容器中元素的个数
str1 = 'abcd'list1 = [10, 20, 30]t1 = (100, 200, 300)dict1 = {'name':'Python', 'age':30}s1 = {10 , 20}# len() 计算容器中元素个数print(len(str1)) # 输出4print(len(list1)) # 输出3print(len(t1)) # 输出3print(len(dict1)) # 输出2print(len(s1)) # 输出2
（2）del()：删除
str1 = 'abcd'list1 = [10, 20, 30]t1 = (100, 200, 300)dict1 = {'name':'Python', 'age':30}s1 = {10 , 20}# 1. del 目标 或者 del(目标)# str1字符串del str1 # 删除整个字符串print(str1) # 报错说明已经删除成功============================================================================# list1 列表del(list1)print(list1) # 报错说明已经删除成功# del(list1[0])# print(list1) # 输出[20, 30]# del list1[0]# print(list1) # 输出[20, 30]==============================================================================# dict1 字典del dict1print(dict1) # 报错，已经删除成功del dict1['name']print(dict1) # 输出结果为 {'age': 30}==============================================================================# s1 集合del s1print(s1) # 报错，已经删除成功
（3）max()：返回容器中元素最大值
min()：返回容器中元素最小值
str1 = 'abcde'list1 = [10, 20, 30]# 1. max()最大值print(max(str1)) # 输出eprint(max(list1)) # 输出30# 2. min():最小值print(min(str1)) # 输出aprint(min(list1)) # 输出10
（4）range()：生成从start到end的数字，步长为step，供for循环使用
""" 注意事项： 1. 如果不写开始，默认从0开始 2. 如果不写步长，默认为1 """print(range(1,10,1)) # 输出 range(1, 10)，返回的是可迭代的对象，需要配合for循环才能拿到数字for i in range(1,10,1):# 遍历可迭代对象，并且拿到了对象内部的这些数字print(i) # 输出的是1，2，3，4，5，6，7，8，9for i in range(1,10):print(i) # 如果不写步长，则默认步长是1for i in range(1,10,2):print(i) # 因为步长是2，所以输出1，3，5，7，9for i in range(10):print(i) # 这里的10代表结束。开始不写，默认从0开始。步长不写，默认为1。 但是不能不写结束！
（5）enumerate()：函数用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标，一般用于在for循环当中。
# 1. 语法： enumerate(可遍历对象，start = 0)# 2. start参数用来设置遍历数据的下标的起始值，默认为0list1 = ['a', 'b', 'c', 'd', 'e']# enumerate 返回结果是元组，元组第一个数据是原迭代对象的数据对应的下标，元组第二个数据是原迭代对象的数据for i in enumerate(list1):print(i)''' 输出的结果为： (0, 'a') (1, 'b') (2, 'c') (3, 'd') (4, 'e') '''for i in enumerate(list1,start = 1):print(i)''' 这时的start为1，输出的结果为： (1, 'a') (2, 'b') (3, 'c') (4, 'd') (5, 'e') '''
7.3 容器类型转换
直接上栗子：
# 已有的数据类型和程序想要的数据类型不一样，这个时候利用函数做类型的转换就可以了。list1 = [10,20,30]s1 = {100, 200, 300}t1 = ('a', 'b', 'c')# tuple():将某个序列转换成元组print(tuple(list1)) # 输出结果为(10, 20, 30)print(tuple(s1)) # 输出结果为(200, 100, 300)# list():转换成列表print(list(s1)) # 输出结果为 [200, 100, 300]print(list(t1)) # 输出结果为 ['a', 'b', 'c']# set():转换成集合print(set(list1)) # 输出结果为{10, 20, 30}print(set(t1)) # 输出结果为{'c', 'b', 'a'}'''
注意：
1. 集合可以快速完成列表去重
2. 集合不支持下标（因为没有顺序）
'''
8. 推导式
推导式的作用：简化代码
列表推导式会返回一个列表 ，字典推导式会返回一个字典，集合推导式会返回一个集合
8.1 列表推导式
直接上代码：推导式如何简化代码的，如何使用推导式
''' 书写代码： 1. 创建空列表 2. 循环将有规律的数据写入到列表 方法实现: 1. 循环实现 2. 列表推导式（化简代码，创建或控制有规律的列表） 得出结论： 1. 列表推导式代码量最少，起到了简化代码的作用 '''=========================================================================# while 实现list1 = []i = 0while i < 10:list1.append(i)i += 1print(list1) # 输出结果为[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]==========================================================================# for 实现# 用for实现比while实现所需的代码量少list1 = []for i in range(10):list1.append(i)print(list1) # 输出结果为[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]==========================================================================# 列表推导式实现list1 = [i for i in range(10)] # 中括号里面第一个i,是接收数据的返回值，然后保存在列表中print(list) # 输出[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
再举个栗子：带if的列表推导式
# 需求：0-10偶数数据的列表# 1. 简单的列表推导式，range()步长实现list1 = [i for i in range(0,10,2)]print(list1) # 输出结果为 [0, 2, 4, 6, 8]# 2. for循环加if 创建有规律的列表list2 = []for i in range(10):if i % 2 == 0:list2.append(i)print(list2)# 3. 把for循环配合if的代码 改写 带if的列表推导式list3 = [i for i in range(10) if i % 2 == 0]print(list3)
再来个栗子：
''' 需求：创建列表如下：[(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)] 1. 用for循环嵌套的方法进能够解决 数据1：1 和 2 range(1,3) 数据2：0 1 2 用 range(3) 2. 用列表推导式解决：多for的列表推导式等同于for循环嵌套，就是去掉标点、回车符和缩进。 '''# 1. 用for循环嵌套list1 = []for i in range(1,3):for j in range(3):# 列表里面追加元素：循环前准备一个空列表，然后这里追加元组数据到列表list1.append((i,j))print(list1) # 输出结果为[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]# 2. 多个for实现列表推导式list2 = [(i,j) for i in range(1,3) for j in range(3)]print(list2) # 输出结果为[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
经过上面这三个栗子，已经对推导式有一定的了解了，那么继续学习下面推导式的学习。
8.2 字典推导式
直接上栗子：
# 创建字典 key是1-4的数字，value是这个数字的平方dict1 = {i: i**2 for i in range(1,5)}print(dict1) # 输出 {1: 1, 2: 4, 3: 9, 4: 16}
再举个栗子：合并列表为字典
# 1. 长度一样的列表合并字典# list1 = ['name', 'age', 'gender']# list2 = ['tom', 20, 'man']# dict1 = {list1[i]: list2[i] for i in range(len(list1))}# print(dict1) # 输出的结果为 {'name': 'tom', 'age': 20, 'gender': 'man'}# 长度不一样的列表合并成字典list3 = ['name', 'age', 'gender', 'id']list4 = ['tom', 20, 'man']# 下面的语句会报错，因为不对等，如果取长的列表len(list3)则会报错# dict1 = {list3[i]: list4[i] for i in range(len(list3))}# 下面的语句才正确dict2 = {list3[i]: list4[i] for i in range(len(list4))}print(dict2) # 输出结果为{'name': 'tom', 'age': 20, 'gender': 'man'}'''
总结：
1. 如果两个列表数据个数相同，len统计任何一个列表的长度都可以
2. 如果两个列表数据个数不同，len统计数据多的列表数据个数会报错，len统计数据少的列表数据个数不会报错
'''
再来个栗子：提取字典中的目标数据
counts = {'MBP': 268, 'HP':125, 'DELL':201, 'Lenovo': 199, 'acer': 99}'''
1. 需求：提取电脑台数大于等于200
获取所有键值对数据，判断v值大于等于200返回
'''# 返回一个迭代器，内部是元组dict_items([('MBP', 268), ('HP', 'DELL'), ('Lenovo', 199), ('acer', 99)])print(counts.items())# 提取字典中目标数据，这个用法非常重要！！！dict1 = {key:value for key,value in counts.items() if value >= 200}print(dict1) # {'MBP': 268, 'DELL': 201}
8.3 集合推导式
这个用的不多，简单的来个栗子：
# 需求：创建一个集合，数据为下方列表的2次方list1 = [1,1,2]set1 = {i ** 2 for i in list1}print(set1) # 输出 {1, 4}# 集合有数据去重功能，所以这个集合数据只有两个数据，分别是1，4
8.4 推导式总结
三种推导式书写的格式
1. 列表推导式[xx for xx in range]2. 字典推导式{xx1 : xx2 for ... in ...}3. 集合推导式{xx for xx in ...}
9. Python函数
Python函数的使用其实跟C、和Java函数的使用都是大同小异的。
函数的作用： 装代码，高效的代码重用
9.1 函数的使用
基本使用
# 1. 定义函数def sel_func():print('I Love Python')# 2. 函数调用print('恭喜你登录成功')sel_func()'''
注意
1. 不同的需求，参数可有可无
2. 在Python中，函数必须先定义后使用
3. 当调用函数的时候，解释器回到定义函数的地方去执行下方缩进的代码，当这些代码执行完，
回到调用函数的地方继续向下执行定义函数的时候，函数体内部缩进的代码并没有执行
'''
有参数的函数
函数的参数：函数调用的时候可以传入真实数据，增大函数的使用的灵活性
形参：函数定义时书写的参数（非真实数据）
实参：函数调用时书写的参数（真实数据）
# 参数形式传入真实数据，做加法运算# 这里的a、b是形参def add_num2(a,b):result = a + bprint(result)# 10，20是实参add_num2(10,20) # 输出30
函数中return的作用
def buy():return '烟'# print('ok') #这一行代码不执行goods = buy()print(goods)'''
return 作用：
1. 负责函数返回值
2. 退出当前函数：导致return下方的所有代码（函数体内部）不执行
'''
9.2 函数的说明文档
就是自己书写函数的时候，可以在函数里写一个说明文档，以后通过这个说明文档可以直接查看这个函数什么作用。
# len是内置函数，早在定义的时候就已经封装好说明文档了# 自己写的函数没有说明文档，为了方便后期查看这种解释说明的信息更快捷更方便，定义函数的同时，定义一个说明文档就可以了# 函数内部缩进的第一行书写的多行注释才是说明文档。如果敲了回车，则会更详细的显示（参数和返回值）。help(len) # help函数作用：查看函数的说明文档（函数解释说明的信息）# def sum_num(a,b):# ''' 求和函数 ''' # 定义函数的说明文档# return a + b# help(sum_num)# 函数的说明文档的高级使用。 就是多行注释按回车，会出现参数1、2和renturn,说明他们的作用。def sum_num1(a,b):''' 求和函数sum_num1 :param a: 参数1 :param b: 参数2 :return: 返回值 '''return a + bhelp(sum_num1)
9.3 函数的嵌套调用
来个栗子感受一下嵌套调用
# 所谓函数嵌套调用指的是一个函数里面有调用了另外一个函数# 需求：两个函数testA 和 testB ---- 在A里面嵌套调用Bdef testB():print('B函数开始-----')print('这是B函数')print('B函数结束-----')def testA():print('A函数开始')# 嵌套调用BtestB()print('A函数结束')testA()
打印横线图形
def print_line():print('-' * 20)# 函数嵌套调用，实现多条横线def print_lines(num):i = 0while i < num:print_line()i += 1print_lines(5)
任意三个数求平均值
# 任意三个数求平均值# Python语言当中，做除法运算，不管参与运算的是不是浮点数，只要是除法，结果就是浮点数。def sum_num(a,b,c):return a + b + c def average_num(a, b ,c):# 先求和，再除以3sumResult = sum_num(a, b, c)return sumResult / 3averageResult = average_num(1, 2, 3)print(averageResult) # 输出结果为 2.0
9.4 变量的作用域
局部访问
# 定义一个函数，声明一个变量：函数体内部访问，函数体外部访问def testA():a = 100print(a) # 函数体内部访问，能访问到a变量testA()print(a) # 报错：a变量是函数内部的变量，函数外部无法访问，这里的a是一个局部变量
访问全局变量
# 声明全局变量：函数体内外都能访问a = 100 print(a)def testA():print(a)def testB():print(a)testA()testB()
修改全局变量
# 函数体内修改全局变量a = 100print(a) # 输出100def testA():print(a)def testB():global a a = 200print(a)testA() # 输出100testB() # 输出200print(a) # 输出200''' 总结： 1. 如果在函数里面直接把变量a = 200赋值，此时的a不是全局变量的修改，而是相当于在函数内部声明了一个新的局部变量 2. 函数体内部修改全局变量：先global声明a为全局变量，然后再变量重新赋值 '''
多函数执行流程
# 1.声明全局变量 2. 定义两个函数 3.函数1修改全局变量：函数2访问全局变量glo_num = 0def test1():global glo_num glo_num = 100def test2():print(glo_num) # 疑问：已经再test1中修改了全局变量，为什么这个地方输出结果不是100？因为进行函数调用，没有执行函数体内的代码。print(glo_num) # 输出结果为0test2() # 输出的结果为0。还是因为因该全局变量的函数没有执行test1() # 执行了函数体内的代码test2() # 输出100print(glo_num) # 输出100，因为test1函数调用了，修改了全局变量。
9.5 函数返回值（多返回值）
返回值作为参数传递
def test1():return 50def test2(num):print(num)# 先得到函数1的返回值，再把这个返回值传入到函数2result = test1()test2(result)
函数的返回值（多返回值）
# 需求：一个函数有两个返回值1和2# 一个如果有多个return不能都执行，只执行第一个return：无法做到一个函数多个返回值# def return_num():# return 1# return 2## result = return_num()# print(result) # 输出结果为1。第二个return不起作用'''
1. 下面是一个函数多个返回值的正确写法
2. return a,b写法，返回多个数据的时候，默认是元组类型
3. return后面可以连接列表、元组或字典，以返回多个值
'''def return_num():return 1,2 # 返回值是元组# return 后面可以直接写元组、列表、字典、返回多个值.# return (10,20) # 返回的是元组# return [100,200] # 返回的是列表# return {'name':'Python', 'age': 20} # 返回的是字典result = return_num()print(result) # return 1,2 输出结果是(1, 2)
9.6 函数的参数的类型
位置参数
def user_info(name,age,gender):print(f'您的姓名是{name},年龄是{age}，性别是{gender}')user_info('tom',20,'男') # 输出结果为 您的姓名是tom,年龄是20，性别是男# 注意：传递和定义参数的顺序及个数必须一致# user_info('tom',20) # 个数定义和传入不一致会报错# user_info(20,'tom','男') # 顺序也和定义必须是一致的，否则倒是数据无意义
关键字参数
# 函数调用，通过"键=值"形式加以指定def user_info(name,age,gender):print(f'您的姓名是{name},年龄是{age}，性别是{gender}')# 1. 调用函数传参user_info('jack', age=20 , gender='男') # 您的姓名是jack,年龄是20，性别是男# 2. 关键字参数之间部分先后循序user_info('jack', gender='男', age=20) # 您的姓名是jack,年龄是20，性别是男# 3. 位置参数必须写在关键字参数的前面# user_info(age=20 , gender='男', 'jack') # 报错了。必须关键词放在前面
缺省参数
'''
1.缺省参数（默认参数）：为了节省用户的时间成本，提高用户体验，可以把一些需求上带有默认值的这种参数，设置成一个默认值，这样写法的参数，叫做缺省参数（默认参数）。
2. 所有的位置参数必须出现在默认参数的前面
3. 函数调用时，如果为缺省参数传值则修改默认参数值；否则使用这个默认值
'''def user_info(name,age,gender='男'): # gender='男'是缺省参数print(f'您的姓名是{name},年龄是{age}，性别是{gender}')# 没有为缺省参数传值，表示使用默认值user_info('tom', 18) # 您的姓名是tom,年龄是18，性别是男# 为缺省参数传值，使用了gender='女 '，即修改了默认值user_info('tom', 18, gender='女') # 您的姓名是tom,年龄是18，性别是女
不定长参数之位置参数
'''
1.不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数（不传也可以）的场景。
此时可以用包裹位置参数或者包裹关键字参数，来进行参数传递。
2. 传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组，args是元组类型，这就是包裹位置传递
'''# 接收所有位置参数，返回一个元组def user_info(*args):print(args)# 包裹位置传递# 如果是*args接收不定长的位置参数据，可以传数据，也可以不传数据，无论传与不传，将来接收的都是所有位置参数，返回的是都是一个元组user_info() # ()user_info('tom') # ('tom',)user_info('tom', 20) # ('tom', 20)user_info('tom', 20,'男') # ('tom', 20, '男')
不定长参数之关键字参数
# 收集所有关键字参数，返回一个字典# 包裹关键字传递def user_info(**kwargs):print(kwargs)user_info()user_info(name='tom')user_info(name='tom', age=20)# 无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程
扩展1：拆包
上面说了不定长参数是组包的过程，那就来说一下拆包的过程
# 1. 拆包元组数据# def return_num():# return 100, 200# result = return_num()# print(result) # 输出 (100, 200)# num1, num2 = return_num()# print(num1) # 输出 100# print(num2) # 输出 200# 2. 字典数据拆包：变量存储的数据是key值# 先准备字典，然后拆包dict1 = {'name': 'tom', 'age': 20}# dict1中有两个键值对，拆包的时候用两个变量接收数据a , b = dict1print(a) # 输出nameprint(b) # 输出age# 提取value的值print(dict1[a]) # 输出tomprint(dict1[b]) # 输出20print(dict1['name']) # 输出tom
扩展2：交换变量的值
# 方法1：a= 10b = 20c = 0c = a a = b b = cprint(a) # 20print(b) # 10# 方法2：a, b = 1, 2print(a) # 输出1print(b) # 输出2a, b = 1, 2a, b = b, aprint(a) # 输出2print(b) # 输出1
9.7 引用作实参
体验引用
# 变量就是存储数据的名字而已，这个名字就可以理解为引用，再python语言中数据其实传递来传递去都是通过变量的形式来传递的# 简单粗暴的理解，引用就是变量名。引用可以当作实参传入到函数里面# 1. 不可变类型：int# 1.1 声明变量保存整型数据，把这个数据赋值到另一个变量：id()检测两个变量的id值（内存的十进制值）a = 1b = aprint(b) # 输出1# 发现a和b的id值相同的print(id(a)) # 输出 140708418216784print(id(b)) # 输出 140708418216784# 修改a的数据测试id值a = 2print(b) # 输出1# 因为修改了a的数据，内存要开辟另外一份内存存储2，id()检测a和b的地址不同print(id(a)) # 输出 140708418216816print(id(b)) # 输出 140708418216784============================================================================# 2. 可变类型：列表aa = [10, 20] bb = aaprint(bb) # [10, 20]print(id(aa)) # 2266328490632print(id(bb))# 2266328490632# 增加数据# 列表是可变类型aa.append(30)print(aa) # [10, 20, 30]print(bb) # [10, 20, 30]print(id(aa)) # 2266328490632 地址值print(id(bb)) # 2266328490632
引用当作实参
def test(a):print(a)print(id(a))a += aprint(a)print(id(a))b = 100test(b) # 这是不可变类型数据c = [11, 22]test(c) # 这是可变类型数据
9.8 可变和不可变类型汇总
小总结：
''' 数据的可变类型：如果对数据进行修改，修改的是原数据，这样的数据是可变类型 数据的不可变类型：如果数据修改的时候改的不是原数据，这样的数据是不可变类型。 可变类型： 列表 字典 集合 不可变类型： 整型 浮点型 字符串 元组 重点： 作用域、函数多返回值、函数的参数 '''
9.9 递归函数和匿名函数（lambda）
递归函数的应用
# 递归函数：1.内部自己调用自己 2.必须有出口# 递归是一种编程思想，函数是编程的一种体现# return有两个作用: 1. 返回值 2. 退出当前函数''' 需求：3以内数字累加和3 + 2 + 1 = 6 6 = 3 + 2以内数字累加和 2以内的累加和 = 2 + 1以内的累加和 1以内的累加和 = 1 # 出口 '''def sum_numbers(num):# 2.出口if num == 1:return 1# 1. 当前数字 + 当前数字减一的累加和return num + sum_numbers(num - 1)result = sum_numbers(3)print(result)# 如果没有出口，报错：超出最大递归深度
匿名函数lambda，来个栗子感受一下
''' 应用场景： 1.lambda的作用就是简化代码 2.如果一个函数有一个返回值，并且只有一句代码，可以使用lambda简化 语法：lambda 参数列表 ：表达式 注意： lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用 lambda表达式能接收多个参数但只能返回一个表达式的值 '''# 需求：函数 返回值100# 1. 函数# def fn1():# return 100## result = fn1()# print(result)# 2. lambda 匿名函数,就是不在用def语句定义的函数。如果要声明匿名函数，则要使用lambda关键字# lambda参数列表：表达式fn2 = lambda : 100print(fn2) # lambda内存地址# 100返回值 调用函数print(fn2()) # 100
lambda的参数形式
# 1.无参数# fn1 = lambda: 100# print(fn1())# 2. 一个参数# fn2 = lambda a: a# print(fn2('hello world'))# 3. 默认参数/缺省参数# fn3 = lambda a, b, c = 200 : a + b + c# print(fn3(10, 20))# print(fn3(10, 20, 300))# 4. 可变参数：*args# fn4 = lambda *args: args# print(fn4(10))# print(fn4(10, 20))# print(fn4(10,20,30,40)) # (10, 20, 30, 40)# 5. 可变参数: **kwargsfn5 = lambda **kwargs : kwargsprint(fn5(name = 'Python'))print(fn5(name = 'Python', age = 30)) # {'name': 'Python', 'age': 30}
带判断的lambda
# lambda应用# 1. lambda 两个数字比大小，谁大返回值fn1 = lambda a, b : a if a > b else bprint(fn1(1000, 500)) # 1000
列表数据排序
'''
students是一个序列名，指代的就是列表序列，key等于一个 lambda的表达式，
这里面就用到了lambda，sort里面有个参数key，如果列表里面有字典，按照字典某个key进行排序用的。
将来要进行升或降序排序的数据，这里指得是字典，返回值，排序的依据是name key还是age key
里面形参x指代的是所有的字典，
'''students = [{'name':'tom','age':20},{'name':'jock','age':21},{'name':'rose','age':22}]# 1. name key对应的值进行降序排序students.sort(key=lambda x: x['name'])print(students)# 2. age key对应的值进行升序排序students.sort(key=lambda x: x['age'])print(students)# 3. age key对应的值进行降序排序students.sort(key=lambda x: x['age'],reverse=True)print(students)
lambda小总结
''' 一、 lambda （1）语法 lambda 参数列表: 表达式 （2）lambda的参数形式 无参数: lambda: 表达式 一个参数(多个参数用逗号隔开): lambda 参数:表达式 默认参数: lambda key=value:表达式 不定长位置参数: lambda *args:表达式 不定长关键字参数: lambda **kwargs:表达式 '''
10. 学生管理系统
根据前面所学的知识，把知识综合起来，来做一个简单的学生管理系统。
# 定义功能界面def info_print():print('请选择功能------------------')print('1. 添加学生')print('2. 删除学生')print('3. 修改学生')print('4. 查询学生')print('5. 显示所有学生')print('6. 退出系统')print('-' * 20)info = []# 所有的功能函数都是操作学生信息，所有存储所有学生信息应该是一个全局变量，数据类型为列表。# 添加学生信息的函数def add_info():"""添加学生函数""" # 添加函数的说明文档pass # 当我们还不知道函数体内部要写什么代码的时候，加一个pass作占位，，避免语法出现错误。# 1.用户输入：学号、姓名、手机号new_id = input('请输入学号：')new_name = input('请输入姓名：')new_tel = input('请输入手机号：')# 2. 判断是否添加这个学生，如果学生姓名已经存在报错提示；如果姓名不存在则添加数据global info# 2.1 不允许姓名重复：判断用户输入的姓名 和 列表里面字典的name对应的值相等，提示for i in info:if new_name == i['name']:print('此用户已经存在')# return作用：退出当前函数：准备空字典，字典新增数据，列表追加字典return# 2.2 如果输入的姓名不存在，添加数据：准备空字典，字典新增数据，列表追加数据info_dict = {}# 字典新增数据info_dict['id'] = new_id
info_dict['name'] = new_name
info_dict['tel'] = new_tel# print(info_dict)# 列表追加字典info.append(info_dict)print(info)# 删除学生def del_info():"""删除学生"""del_name = input('请输入要删除学生的姓名：')global info # 声明全局变量for i in info: # 遍历列表if del_name == i['name'] :# 如果姓名存在，则在列表删除数据info.remove(i)breakelse: # else的作用：当循环正常结束要执行的代码。就是遍历完列表中的数据，还没有break。print('该学员不存在！！！')print(info)# 修改函数def modify_info():"""修改学生信息"""modify_name = input('请输入要修改的学生的姓名：')global infofor i in info:if modify_name == i['name']:i['tel'] = input('请输入新的手机号：')breakelse:print('该学生不存在！！！')# 打印infoprint(info)# 查询学员信息def search_info():"""查询学生信息"""search_name = input('请输入要查询的学生的姓名：')global info # 声明全局变量for i in info:if search_name == i['name'] :print('查询到的学生信息如下--------------------------')print(f"学生的学号：{i['id']} , 姓名：{i['name']}, 手机号：{i['tel']}")breakelse:print('查无此人.....')# 显示所有学生信息def print_all():'''显示所有学生信息'''print('学号\t姓名\t手机号')# 打印所有学生的数据for i in info:print(f"{i['id']}\t{i['name']}\t{i['tel']}")while True:# 1. 显示功能界面info_print()# 2. 用户输入功能序号user_num = int(input('请输入功能序号：'))# 3. 按照用户输入的功能序号，执行不同的功能（函数）if user_num == 1:# print('添加')add_info()elif user_num == 2:# print('删除')del_info()elif user_num == 3:# print('修改')modify_info()elif user_num == 4:# print('查询')search_info()elif user_num == 5:# print('显示所有')print_all()elif user_num == 6:# 退出系统exit_flag = input('确定要退出吗？yes or no：')if exit_flag == 'yes':break # break是最主要的else:print('输入的功能序号有误')# 这个退出系统功能，不用函数去做，1.代码比较简单 2.有一个必要的功能，封装到函数里面可能会出问题# 退出系统依赖于break，break是当一定条件成立，终止循环用的。终止的是就近的这一层循环，如果把这些代码封装# 一个函数里面去，这个时候跟while True循环不在一起了，就有可能发生问题的。
11. 高级函数
高阶函数作用：为了化简代码，增加函数的灵活性
11.1 abs()和round()函数
这两个函数的用法比较简单，来个栗子就会了。but这两个函数不是高阶函数
# abs() 求绝对值用的print(abs(-10)) # 10# round() 四舍五入的计算print(round(1.2)) # 1print(round(1.6)) # 2# abs()和round()不是高阶函数
11.2 内置高阶函数（map、reduce、filter）
先来体验一下高阶函数
# 需求: 任意两个数字，先进行数字处理（绝对值或四舍五入）在求和运算# 1. 写法一def add_num(a,b):# 绝对值return abs(a) + abs(b)result = add_num(-1.1, 1.0)print(result) # 2.1# 2. 写法二def sum_num(a, b, f):return f(a) + f(b)result1 = sum_num(-1,-2,abs)print(result1) # 3result2 = sum_num(1.2, 1.4, round)print(result2) # 2# 方法二的代码更加简洁，函数灵活性较快# 函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快''' 高阶函数：把函数作为参数传入，这样的函数称为高阶函数，高阶函数是函数式编程的体现。函数式编程就是指这种高度抽象的编程范式。 高阶函数其实作用就是为了化简代码，增加函数的灵活性 '''
map()函数
''' map(func, lst),将传入的函数变量func作用到lst变量的每个元素中,并将结果组成新的列表(Python2)/ 迭代器(Python3)返回 '''# 1. 准备列表数据list1 = [1, 2, 3, 4, 5]# 2. 准备2次方计算的函数def func(x):return x ** 2# 3. 调用mapresult = map(func, list1)# 4. 验收成果# 在打印迭代器的时候,只能返回内存地址,这时要用list()转换数据类型print(result) # 输出 <map object at 0x00000208211131D0>print(list(result)) # [1, 4, 9, 16, 25]
reduce函数
''' reduce(func, lst),其中func必须有两个参数. 每次func计算的结果继续和序列的下一个元素作累计计算. 注意: reduce()传入的参数func必须接收2个参数 '''list1 = [1, 2, 3, 4, 5]# 1. 导入模块import functools# 2.定义功能模块def func(a, b):return a + b# 3. 调用reduce. 作用:功能函数计算的结果和序列的下一个数据作累计计算result = functools.reduce(func, list1)print(result) # 输出结果为 15
filter()函数
''' filter(func, lst)函数用于过滤序列,过滤掉不符合条件的元素,返回一个filter对象. 如果要转换为列表,可以使用list()来转换 '''list1 = [1,2,3,4,5,6,7,8,9,10]# 1. 定义功能函数:过滤序列中的偶数def func(x):return x % 2 == 0# 2. 调用filterresult = filter(func,list1)print(result) # <filter object at 0x000002AEA49031D0>print(list(result)) # [2, 4, 6, 8, 10]
这篇关于学习Python，你看这篇就够了 | 【详细】Python基础（二）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
- 2024-05-08有遇到过吗？同样的规则 Excel 中 比Python 结果大
- 2024-03-30开始python成长之路
- 2024-03-29python optparse
- 2024-03-29python map 函数
- 2024-03-20invalid format specifier python
- 2024-03-18pool.map python
- 2024-03-18threads in python
- 2024-03-14python Ai 应用开发基础训练，字符串，字典，文件
- 2024-03-13id3 algorithm python
- 2024-03-13sum array elements python
