文章目录
第一章 基础1.注释2.变量3.输入输出3.1 输入3.2 输出 4.转换数据类型5.运算符6 条件语句(if)三⽬运算符 7. 循环（while、for）8.字符串常用操作**（1）查找**（2）修改（3）判断 9. 列表10.元组11.集合12.字典 第二章 函数1.函数的基本概念2.变量、函数的参数3.递归、lambda 表达式4. ⾼阶函数 第三章 文件操作1.⽂件的基本操作（1）打开（2）⽂件对象⽅法（3）打开 2.⽂件备份3.⽂件和⽂件夹的操作 第四章 面向对象基础1.面向对象重要组成部分（1）类（2）对象 2.添加和获取对象属性3. 魔法⽅法（1）_ _ init_ _()（2） _ _ str_ _()（3） _ _ del _ _() 4. 继承（1）单继承、多继承、多层继承（2）⼦类重写⽗类同名⽅法和属性（3）⼦类调⽤⽗类的同名⽅法和属性（4） super()调⽤⽗类⽅法（3）私有权限**定义私有属性和⽅法****获取和修改私有属性值** 5.多态6.类属性和实例属性7.类⽅法和静态⽅法(1) 类⽅法(2) 静态⽅法 第五章 异常1.异常的写法2.⾃定义异常 第六章 模块和包1. 模块(1) 导入模块(2)制作模块(3) _ _ all _ _ 2. 包(1)**制作包**(2) 导入包 第七章 公共操作1.运算符(1) +(2) *(3)in或not in 2.公共⽅法(1) len()(2) del()(3) max()、min()(4) range()(5) enumerate() 3.容器类型转换(1) tuple()(2) list()(3)set() 第八章 练习⾯向对象版学员管理系统(1) student.py(2) managerSystem.py(3) main.py
第一章 基础
1.注释
注释分为两类：单⾏注释 和 多⾏注释。
快捷键： ctrl + /
# 注释内容""" 第⼀⾏注释 第⼆⾏注释"""''' 注释1'''2.变量
变量就是⼀个存储数据的时候当前数据所在的内存地址的名字⽽已。
变量名 = 值# 使用变量my_name = 'TOM'print(my_name)# 检测数据类型的⽅法： type()d = '12345'print(type(d)) # <class 'str'> -- 字符串e = [10, 20, 30]print(type(e)) # <class 'list'> -- 列表标识符:
由数字、字⺟、下划线组成不能数字开头能使⽤内置关键字严格区分⼤⼩写
3.输入输出
3.1 输入
当程序执⾏到 input ，等待⽤户输⼊，输⼊完成之后才继续向下执⾏。在Python中， input 接收⽤户输⼊后，⼀般存储到变量，⽅便使⽤。在Python中， input 会把接收到的任意⽤户输⼊的数据都当做字符串处理。password = input('请输⼊您的密码：')print(f'您输⼊的密码是{password}')# <class 'str'>print(type(password))3.2 输出
格式化符号
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vKSIUPSM-1666507077663)(F:\BaiduNetdiskDownload\资料-python从0开始学编程\python总结\图片\2.png)]](http://zhangshiyu.com/zb_users/upload/2022/11/20221107184102166781766274009.png)
# 格式化字符串除了%s，还可以写为 f'{表达式}'age = 18name = 'TOM'weight = 75.5student_id = 1# 我的名字是TOMprint('我的名字是%s' % name)# 我的学号是0001print('我的学号是%4d' % student_id)# 我的体重是75.50公⽄print('我的体重是%.2f公⽄' % weight)# 我的名字是TOM，今年18岁了print('我的名字是%s，今年%d岁了' % (name, age))# 我的名字是TOM，明年19岁了print('我的名字是%s，明年%d岁了' % (name, age + 1))# 我的名字是TOM，明年19岁了print(f'我的名字是{name}, 明年{age + 1}岁了')转义字符
\n ：换⾏。\t ：制表符，⼀个tab键（4个空格）的距离。结束符
print('输出的内容', end="\n")在Python中，print()， 默认⾃带 end=“\n” 这个换⾏结束符，所以导致每两个 print 直接会换⾏
展示，⽤户可以按需求更改结束符。
4.转换数据类型
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M5KbI5zl-1666507077664)(F:\BaiduNetdiskDownload\资料-python从0开始学编程\python总结\图片\3.png)]](http://zhangshiyu.com/zb_users/upload/2022/11/20221107184102166781766228383.png)
# 1. 接收⽤户输⼊num = input('请输⼊您的幸运数字：')# 2. 打印结果print(f"您的幸运数字是{num}")# 3. 检测接收到的⽤户输⼊的数据类型 -- str类型print(type(num))# 4. 转换数据类型为整型 -- int类型print(type(int(num)))5.运算符
算数运算符
+ - * / % ** ()# 混合运算优先级顺序： () ⾼于 ** ⾼于 * / // % ⾼于 + -# //:整除# print(9/4) 输出：2.25赋值运算符
=复合赋值运算符
+= -= *= /= //== %= **=⽐较运算符
== != > < >= <=# 例子a = 7b = 5print(a == b) # Falseprint(a != b) # True逻辑运算符
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B6ZkGAio-1666507077665)(F:\BaiduNetdiskDownload\资料-python从0开始学编程\python总结\图片\4.png)]](http://zhangshiyu.com/zb_users/upload/2022/11/20221107184102166781766219907.png)
与： and或：or⾮：nota = 1b = 2c = 3print((a < b) and (b < c)) # Trueprint((a > b) and (b < c)) # Falseprint((a > b) or (b < c)) # Trueprint(not (a > b)) # Truea = 0b = 1c = 2# and运算符，只要有⼀个值为0，则结果为0，否则结果为最后⼀个⾮0数字print(a and b) # 0print(b and a) # 0print(a and c) # 0print(c and a) # 0print(b and c) # 2print(c and b) # 1# or运算符，只有所有值为0结果才为0，否则结果为第⼀个⾮0数字print(a or b) # 1print(a or c) # 2print(b or c) # 16 条件语句(if)
if 条件: 条件成⽴执⾏的代码if 条件: 条件成⽴执⾏的代码else: 条件不成⽴执⾏的代码if 条件1: 条件1成⽴执⾏的代码elif 条件2: 条件2成⽴执⾏的代码else: 以上条件都不成⽴执⾏的代码三⽬运算符
条件成⽴执⾏的表达式 if 条件 else 条件不成⽴执⾏的表达式a = 1b = 2c = a if a > b else bprint(c) #27. 循环（while、for）
break退出整个循环
continue退出本次循环，继续执⾏下⼀次重复执⾏的代码
while循坏
while 条件: 条件成⽴重复执⾏的代码1 条件成⽴重复执⾏的代码2 .....//例子# 循环的计数器i = 0while i < 5: print('媳妇⼉，我错了') i += 1for循环
for 临时变量 in 序列: 重复执⾏的代码1 重复执⾏的代码2 ......# 例子str1 = 'itheima'for i in str1: print(i)while…else
循环可以和else配合使⽤，else下⽅缩进的代码指的是当循环正常结束之后要执⾏的代码。
while 条件: 条件成⽴重复执⾏的代码else: 循环正常结束之后要执⾏的代码# 例子i = 1while i <= 5: print('媳妇⼉，我错了') i += 1 #break #continueelse: print('媳妇原谅我了，真开⼼，哈哈哈哈')所谓else指的是循环正常结束之后要执⾏的代码，即如果是break终⽌循环的情况，else下⽅缩进的代码将不执⾏。
因为continue是退出当前⼀次循环，继续下⼀次循环，所以该循环在continue控制下是可以正常结束的，当循环结束后，则执⾏了else缩进的代码。
for…else
for 临时变量 in 序列: 重复执⾏的代码 ...else: 循环正常结束之后要执⾏的代码8.字符串
b = "abcdefg"print(type(b)) # <class 'str'>name = "abcdef"print(name[1]) # b切⽚
切⽚是指对操作的对象截取其中⼀部分的操作。字符串、列表、元组都⽀持切⽚操作。
序列[开始位置下标:结束位置下标:步⻓]注意
不包含结束位置下标对应的数据， 正负整数均可；步⻓是选取间隔，正负整数均可，默认步⻓为1。name = "abcdefg"print(name[2:5:1]) # cdeprint(name[2:5]) # cdeprint(name[:5]) # abcdeprint(name[1:]) # bcdefgprint(name[:]) # abcdefgprint(name[::2]) # acegprint(name[:-1]) # abcdef, 负1表示倒数第⼀个数据print(name[-4:-1]) # defprint(name[::-1]) # gfedcba常用操作
字符串的常⽤操作⽅法有查找、修改和判断三⼤类。
（1）查找
find()：检测某个⼦串是否包含在这个字符串中index()：检测某个⼦串是否包含在这个字符串中，rfind()： 和find()功能相同，但查找⽅向为右侧开始。rindex()：和index()功能相同，但查找⽅向为右侧开始。count()：返回某个⼦串在字符串中出现的次数 字符串序列.count(⼦串, 开始位置下标, 结束位置下标)mystr = "hello world and itcast and itheima and Python"print(mystr.count('and')) # 3print(mystr.count('ands')) # 0print(mystr.count('and', 0, 20)) # 1 字符串序列.find(⼦串, 开始位置下标, 结束位置下标)注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
mystr = "hello world and itcast and itheima and Python"print(mystr.find('and')) # 12print(mystr.find('and', 15, 30)) # 23print(mystr.find('ands')) # -1字符串序列.index(⼦串, 开始位置下标, 结束位置下标)注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
mystr = "hello world and itcast and itheima and Python"print(mystr.index('and')) # 12print(mystr.index('and', 15, 30)) # 23print(mystr.index('ands')) # 报错（2）修改
replace()：替换split()：按照指定字符分割字符串。join()：⽤⼀个字符或⼦串合并字符串，即是将多个字符串合并为⼀个新的字符串。capitalize()：将字符串第⼀个字符转换成⼤写。#注意：capitalize()函数转换后，只字符串第⼀个字符⼤写，其他的字符全都⼩写。title()：将字符串每个单词⾸字⺟转换成⼤写。lower()：将字符串中⼤写转⼩写。upper()：将字符串中⼩写转⼤写。lstrip()：删除字符串左侧空⽩字符。rstrip()：删除字符串右侧空⽩字符。strip()：删除字符串两侧空⽩字符。ljust()：返回⼀个原字符串左对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串rjust()：返回⼀个原字符串右对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语法和ljust()相同。center()：返回⼀个原字符串居中对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语法和ljust()相同。字符串序列.replace(旧⼦串, 新⼦串, 替换次数)# 例子mystr = "hello world and itcast and itheima and Python"# 结果：hello world he itcast he itheima he Pythonprint(mystr.replace('and', 'he'))# 结果：hello world he itcast he itheima he Pythonprint(mystr.replace('and', 'he', 10))# 结果：hello world and itcast and itheima and Pythonprint(mystr)字符串序列.split(分割字符, num)#注意：num表示的是分割字符出现的次数，即将来返回数据个数为num+1个。#例子mystr = "hello world and itcast and itheima and Python"# 结果：['hello world ', ' itcast ', ' itheima ', ' Python']print(mystr.split('and'))# 结果：['hello world ', ' itcast ', ' itheima and Python']print(mystr.split('and', 2))# 结果：['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'Python']print(mystr.split(' '))# 结果：['hello', 'world', 'and itcast and itheima and Python']print(mystr.split(' ', 2))字符或⼦串.join(多字符串组成的序列)# 例子list1 = ['chuan', 'zhi', 'bo', 'ke']t1 = ('aa', 'b', 'cc', 'ddd')# 结果：chuan_zhi_bo_keprint('_'.join(list1))# 结果：aa...b...cc...dddprint('...'.join(t1))mystr = "hello world and itcast and itheima and Python"print(mystr.capitalize())print(mystr.title())print(mystr.lower())print(mystr.upper())#输出Hello world and itcast and itheima and pythonHello World And Itcast And Itheima And Pythonhello world and itcast and itheima and pythonHELLO WORLD AND ITCAST AND ITHEIMA AND PYTHON（3）判断
所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False。
startswith()：检查字符串是否是以指定⼦串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。endswith()：：检查字符串是否是以指定⼦串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。isalpha()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟则返回 True, 否则返回 False。isdigit()：如果字符串只包含数字则返回 True 否则返回 False。isalnum()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟或数字则返 回 True,否则返回False。sspace()：如果字符串中只包含空⽩，则返回 True，否则返回 False。字符串序列.startswith(⼦串, 开始位置下标, 结束位置下标)字符串序列.endswith(⼦串, 开始位置下标, 结束位置下标)mystr = "hello world and itcast and itheima and Python "# 结果：Trueprint(mystr.startswith('hello'))# 结果Falseprint(mystr.startswith('hello', 5, 20))mystr1 = 'hello'mystr2 = 'hello12345'# 结果：Trueprint(mystr1.isalpha())# 结果：Falseprint(mystr2.isalpha())9. 列表
# 列表name_list = ['Tom', 'Lily', 'Rose']#列表嵌套 name_list = [['⼩明', '⼩红', '⼩绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四','王五']]name_list[2][1]#常⽤操作⽅法 index() len() append() pop() remove()列表：列表可以⼀次性存储多个数据，且可以为不同数据类型。
列表的作⽤是⼀次性存储多个数据，程序员可以对这些数据进⾏的操作有：增、删、改、查。
查找
index()：返回指定数据所在位置的下标 。count()：统计指定数据在当前列表中出现的次数。len()：访问列表⻓度，即列表中数据的个数。# name_list = ['Tom', 'Lily', 'Rose']print(name_list.index('Lily', 0, 2)) # 1print(name_list.count('Lily')) # 1print(len(name_list)) # 3判断是否存在
in：判断指定数据在某个列表序列，如果在返回True，否则返回Falsenot in：判断指定数据不在某个列表序列，如果不在返回True，否则返回Falsename_list = ['Tom', 'Lily', 'Rose']# 结果：Trueprint('Lily' in name_list)# 结果：Falseprint('Lilys' in name_list)# 例子：需求：查找⽤户输⼊的名字是否已经存在。name_list = ['Tom', 'Lily', 'Rose']name = input('请输⼊您要搜索的名字：')if name in name_list: print(f'您输⼊的名字是{name}, 名字已经存在')else: print(f'您输⼊的名字是{name}, 名字不存在')增加
append()：列表结尾追加数据。如果append()追加的数据是⼀个序列，则追加整个序列到列表列表序列.append(数据),extend()：列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表。insert()：指定位置新增数据。#例子name_list = ['Tom', 'Lily', 'Rose']name_list.append('xiaoming')# 结果：['Tom', 'Lily', 'Rose', 'xiaoming']print(name_list)name_list.append(['xiaoming', 'xiaohong'])# 结果：['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]print(name_list)删除
del:pop()：删除指定下标的数据(默认为最后⼀个)，并返回该数据。remove()：移除列表中某个数据的第⼀个匹配项。clear()：清空列表del
#语法del ⽬标name_list = ['Tom', 'Lily', 'Rose']# 结果：报错提示：name 'name_list' is not defineddel name_listdel name_list[0]print(name_list)pop()：删除指定下标的数据(默认为最后⼀个)，并返回该数据。
# 语法列表序列.pop(下标)name_list = ['Tom', 'Lily', 'Rose']del_name = name_list.pop(1)# 结果：Lilyprint(del_name)# 结果：['Tom', 'Rose']print(name_list)修改:
name_list[0] = 'aaa' 修改指定下标数据逆置：reverse()排序：sort()列表序列.sort( key=None, reverse=False)注意：reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）复制
函数：copy()name_list = ['Tom', 'Lily', 'Rose']name_li2 = name_list.copy()# 结果：['Tom', 'Lily', 'Rose']print(name_li210.元组
#元组 # 多个数据元组 t1 = (10, 20, 30) # 单个数据元组 t2 = (10,)元组：⼀个元组可以存储多个数据，元组内的数据是不能修改的。
11.集合
创建集合使⽤ {} 或 set() ， 但是如果要创建空集合只能使⽤ set() ，因为 {} ⽤来创建空字典。
s1 = {10, 20, 30, 40, 50}print(s1)s4 = set()s2 = {10, 30, 20, 10, 30, 40, 30, 50}print(s2) #{10,30,20,40,50}特点：
集合可以去掉重复数据；集合数据是⽆序的，故不⽀持下标增加数据
add() #s1.add(100)update(), 追加的数据是序列。s1 = {10, 20}# s1.update(100) # 报错s1.update([100, 200])s1.update('abc')print(s1)# {'a', 100, 200, 10, 'c', 20, 'b'}删除数据
remove()，删除集合中的指定数据，如果数据不存在则报错。discard()，删除集合中的指定数据，如果数据不存在也不会报错。pop()，随机删除集合中的某个数据，并返回这个数据。#s1.remove(10)s1.pop()查找数据
in：判断数据在集合序列not in：判断数据不在集合序列s1 = {10, 20, 30, 40, 50}print(10 in s1)print(10 not in s1)12.字典
字典特点：
符号为⼤括号数据为键值对形式出现各个键值对之间⽤逗号隔开# 有数据字典dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}# 空字典dict2 = {}dict3 = dict()注意：⼀般称冒号前⾯的为键(key)，简称k；冒号后⾯的为值(value)，简称v。
（1）增
写法：字典序列[key] = 值dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}dict1['name'] = 'Rose'# 结果：{'name': 'Rose', 'age': 20, 'gender': '男'}print(dict1)dict1['id'] = 110# {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}print(dict1)（2）删
del() / del：删除字典或删除字典中指定键值对。clear()：清空字典dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}del dict1['gender']# 结果：{'name': 'Tom', 'age': 20}print(dict1)dict1.clear()print(dict1) # {}（3）改
写法：字典序列[key] = 值
注意：如果key存在则修改这个key对应的值 ；如果key不存在则新增此键值对。
（3）查
key值查找
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}print(dict1['name']) # Tomprint(dict1['id']) # 报错get()
字典序列.get(key, 默认值)dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}print(dict1.get('name')) # Tomprint(dict1.get('id', 110)) # 110print(dict1.get('id')) # Nonekeys() 、values() 、 items()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}print(dict1.values()) # dict_values(['Tom', 20, '男'])dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender','男')])第二章 函数
1.函数的基本概念
函数的作⽤：封装代码，⾼效的代码重⽤
函数就是将⼀段具有独⽴功能的代码块 整合到⼀个整体并命名，在需要的位置调⽤这个名称即可完成对应的需求。
函数在开发过程中，可以更⾼效的实现代码重⽤。
# 定义函数def 函数名(参数): 代码1 代码2 ...... #调⽤函数函数名(参数)函数的参数：函数调⽤的时候可以传⼊真实数据，增⼤函数的使⽤的灵活性
形参：函数定义时书写的参数(⾮真实数据)实参：函数调⽤时书写的参数(真实数据)# 定义函数def add_num1(): result = 1 + 2 print(result)# 调⽤函数add_num1()# 定义函数时同时定义了接收⽤户数据的参数a和b，a和b是形参def add_num2(a, b): result = a + b print(result)# 调⽤函数时传⼊了真实的数据10 和 20，真实数据为实参add_num2(10, 20)函数的返回值
作⽤：函数调⽤后，返回需要的计算结果
# 写法 return 表达式#例子def sum_num(a, b, c): return a + b + cresult = sum_num(1, 2, 3)print(result) # 62.变量、函数的参数
变量作⽤域指的是变量⽣效的范围，主要分为两类：局部变量和全局变量。
缺省参数也叫默认参数。
可变和不可变类型
所谓可变类型与不可变类型是指：数据能够直接进⾏修改，如果能直接修改那么就是可变，否则是不可变.
可变类型：列表、字典、集合不可变类型：整型、浮点型、字符串、元组3.递归、lambda 表达式
（1）递归
函数内部⾃⼰调⽤⾃⼰必须有出⼝（2）lambda 表达式
如果⼀个函数有⼀个返回值，并且只有⼀句代码，可以使⽤ lambda简化。
#语法lambda 参数列表 ： 表达式注意
lambda表达式的参数可有可⽆，函数的参数在lambda表达式中完全适⽤。lambda函数能接收任何数量的参数但只能返回⼀个表达式的值def add(a, b): return a + bresult = add(1, 2)print(result)# lambda实现print((lambda a, b: a + b)(1, 2))lambda的参数形式
# ⽆参数print((lambda: 100)())#⼀个参数print((lambda a: a)('hello world'))#默认参数print((lambda a, b, c=100: a + b + c)(10, 20)) #130#可变参数：**argsprint((lambda *args: args)(10, 20, 30))#是一个元组 (10, 20, 30)#可变参数：**kwargsprint((lambda **kwargs: kwargs)(name='python', age=20))#{'name': 'python', 'age': 20}4. ⾼阶函数
把函数作为参数传⼊，这样的函数称为⾼阶函数，⾼阶函数是函数式编程的体现。
内置⾼阶函数
map()map(func, lst)，将传⼊的函数变量func作⽤到lst变量的每个元素中，并将结果组成新的列表(Python2)/迭代器(Python3)返回。
list1 = [1, 2, 3, 4, 5]def func(x): return x ** 2result = map(func, list1)print(result) # <map object at 0x0000013769653198>print(list(result)) # [1, 4, 9, 16, 25]reduce(func(x,y)，lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下⼀个元素做累积计算。
注意：reduce()传⼊的参数func必须接受2个参数。
import functoolslist1 = [1, 2, 3, 4, 5]def func(a, b): return a + bresult = functools.reduce(func, list1)print(result) # 15filter(func, lst)函数⽤于过滤序列, 过滤掉不符合条件的元素, 返回⼀个 filter 对象,。如果要转换为列表,可以使⽤ list() 来转换。
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]def func(x): return x % 2 == 0result = filter(func, list1)print(result) # <filter object at 0x0000017AF9DC3198>print(list(result)) # [2, 4, 6, 8, 10]第三章 文件操作
总结：⽂件操作的作⽤就是把⼀些内容(数据)存储存放起来，可以让程序下⼀次执⾏的时候直接使⽤，⽽不必重新制作⼀份，省时省⼒。
1.⽂件的基本操作
（1）打开
open(name, mode)#例子f = open('test.txt', 'w')#注意：此时的 f 是 open 函数的⽂件对象。name：是要打开的⽬标⽂件名的字符串(可以包含⽂件所在的具体路径)。
mode：设置打开⽂件的模式(访问模式)：只读、写⼊、追加等。
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zt6GbNut-1666507077667)(F:\BaiduNetdiskDownload\资料-python从0开始学编程\python总结\图片\5.png)]](http://zhangshiyu.com/zb_users/upload/2022/11/20221107184102166781766260696.png)
（2）⽂件对象⽅法
写
# 语法对象.write('内容')# 例子# 1. 打开⽂件f = open('test.txt', 'w')# 2.⽂件写⼊f.write('hello world')# 3. 关闭⽂件f.close()注意：
w 和 a 模式：如果⽂件不存在则创建该⽂件；如果⽂件存在， w 模式先清空再写⼊， a 模式直接末尾追加。r 模式：如果⽂件不存在则报错。读
read()⽂件对象.read(num)readlines可以按照⾏的⽅式把整个⽂件中的内容进⾏⼀次性读取，并且返回的是⼀个列表，其中每⼀⾏的数据为⼀个元素。
f = open('test.txt')content = f.readlines()# ['hello world\n', 'abcdefg\n', 'aaa\n', 'bbb\n', 'ccc']print(content)# 关闭⽂件f.close()f = open('test.txt')content = f.readline()print(f'第⼀⾏：{content}')content = f.readline()print(f'第⼆⾏：{content}')# 关闭⽂件f.close()seek()
作⽤：⽤来移动⽂件指针。
⽂件对象.seek(偏移量, 起始位置)起始位置：
0：⽂件开头
1：当前位置
2：⽂件结尾
（3）打开
⽂件对象.close()2.⽂件备份
需求：⽤户输⼊当前⽬录下任意⽂件名，程序完成对该⽂件的备份功能(备份⽂件名为xx[备份]后缀，例如：test[备份].txt)。
#1. 接收⽤户输⼊⽬标⽂件名old_name = input('请输⼊您要备份的⽂件名：')2. 规划备份⽂件名# 2.1 提取⽂件后缀点的下标index = old_name.rfind('.')# print(index) # 后缀中.的下标# print(old_name[:index]) # 源⽂件名（⽆后缀）# 2.2 组织新⽂件名 旧⽂件名 + [备份] + 后缀new_name = old_name[:index] + '[备份]' + old_name[index:]# 打印新⽂件名（带后缀）# print(new_name)3. 备份⽂件写⼊数据# 3.1 打开⽂件old_f = open(old_name, 'rb')new_f = open(new_name, 'wb')# 3.2 将源⽂件数据写⼊备份⽂件while True: con = old_f.read(1024) if len(con) == 0: break new_f.write(con)# 3.3 关闭⽂件old_f.close()new_f.close()3.⽂件和⽂件夹的操作
在Python中⽂件和⽂件夹的操作要借助os模块⾥⾯的相关功能，具体步骤如下：
# 1. 导⼊os模块import os# 2. 使⽤ os 模块相关功能os.函数名()# ⽂件重命名os.rename(⽬标⽂件名, 新⽂件名)# 删除⽂件os.remove(⽬标⽂件名)# 创建⽂件夹os.mkdir(⽂件夹名字)# 删除⽂件夹os.rmdir(⽂件夹名字)# 获取当前⽬录os.getcwd()# 改变默认⽬录os.chdir(⽬录)# 获取⽬录列表os.listdir(⽬录)第四章 面向对象基础
封装
将属性和⽅法书写到类的⾥⾯的操作即为封装封装可以为属性和⽅法添加私有权限继承
⼦类默认继承⽗类的所有属性和⽅法⼦类可以重写⽗类属性和⽅法多态
传⼊不同的对象，产⽣不同的结果1.面向对象重要组成部分
在⾯向对象编程过程中，有两个重要组成部分：类 和 对象。
⾯向对象就是将编程当成是⼀个事物，对外界来说，事物是直接使⽤的，不⽤去管他内部的情况。⽽编程就是设置事物能够做什么事。
（1）类
特征即是属性，⾏为即是⽅法
class 类名():代码......#例子class Washer(): def wash(self): print('我会洗⾐服')注意：类名要满⾜标识符命名规则，同时遵循⼤驼峰命名习惯。
（2）对象
对象⼜名实例。
# 语法对象名 = 类名()#例子# 创建对象haier1 = Washer()# haier对象调⽤实例⽅法haier1.wash()2.添加和获取对象属性
类外⾯添加对象属性
对象名.属性名 = 值类外⾯获取对象属性
对象名.属性名类⾥⾯获取对象属性
self.属性名#例子# 定义类class Washer(): def print_info(self): # 类⾥⾯获取实例属性 print(f'haier1洗⾐机的宽度是{self.width}') print(f'haier1洗⾐机的⾼度是{self.height}') # 创建对象haier1 = Washer()# 添加实例属性haier1.width = 500haier1.height = 800haier1.print_info()3. 魔法⽅法
在Python中， _ _ xx _ _() 的函数叫做魔法⽅法，指的是具有特殊功能的函数。
（1）_ _ init_ _()
⽅法的作⽤：初始化对象。
class Washer(): # 定义初始化功能的函数 def __init__(self): # 添加实例属性 self.width = 500 self.height = 800 def print_info(self): # 类⾥⾯调⽤实例属性 print(f'洗⾐机的宽度是{self.width}, ⾼度是{self.height}') haier1 = Washer()haier1.print_info()#带参数的__init__() __init__() class Washer(): def __init__(self, width, height): self.width = width self.height = height def print_info(self): print(f'洗⾐机的宽度是{self.width}') print(f'洗⾐机的⾼度是{self.height}') haier1 = Washer(10, 20)haier1.print_info()haier2 = Washer(30, 40)haier2.print_info()注意：__init__() ⽅法，在创建⼀个对象时默认被调⽤，不需要⼿动调⽤__init__(self) 中的self参数，不需要开发者传递，python解释器会⾃动把当前的对象引⽤传递过去。（2） _ _ str_ _()
当使⽤print输出对象的时候，默认打印对象的内存地址。如果类定义了 str ⽅法，那么就会打印从在这个⽅法中 return 的数据。
class Washer(): def __init__(self, width, height): self.width = width self.height = height def __str__(self): return '这是海尔洗⾐机的说明书' haier1 = Washer(10, 20)# 这是海尔洗⾐机的说明书print(haier1)（3） _ _ del _ _()
当删除对象时，python解释器也会默认调⽤ del() ⽅法。
class Washer(): def __init__(self, width, height): self.width = width self.height = height def __del__(self): print(f'{self}对象已经被删除') haier1 = Washer(10, 20)# <__main__.Washer object at 0x0000026118223278>对象已经被删除del haier14. 继承
继承的特点
⼦类默认拥有⽗类的所有属性和⽅法⼦类重写⽗类同名⽅法和属性⼦类调⽤⽗类同名⽅法和属性（1）单继承、多继承、多层继承
多继承意思就是⼀个类同时继承了多个⽗类。
# 1. 师父类，属性和方法class Master(object): def __init__(self): self.kongfu = '[古法煎饼果子配方]' def make_cake(self): print(f'运用{self.kongfu}制作煎饼果子')# 为了验证多继承，添加School父类class School(object): def __init__(self): self.kongfu = '[黑马煎饼果子配方]' def make_cake(self): print(f'运用{self.kongfu}制作煎饼果子')# 2. 定义徒弟类，继承师父类 和 学校类class Prentice(School, Master): pass# 3. 用徒弟类创建对象，调用实例属性和方法daqiu = Prentice()print(daqiu.kongfu)daqiu.make_cake()# 结论：如果一个类继承多个父类，优先继承第一个父类的同名属性和方法（2）⼦类重写⽗类同名⽅法和属性
⼦类和⽗类具有同名属性和⽅法，默认使⽤⼦类的同名属性和⽅法。
# 1. 师父类，属性和方法class Master(object): def __init__(self): self.kongfu = '[古法煎饼果子配方]' def make_cake(self): print(f'运用{self.kongfu}制作煎饼果子')# 为了验证多继承，添加School父类class School(object): def __init__(self): self.kongfu = '[黑马煎饼果子配方]' def make_cake(self): print(f'运用{self.kongfu}制作煎饼果子')# 2. 定义徒弟类，继承师父类 和 学校类， 添加和父类同名的属性和方法class Prentice(School, Master): def __init__(self): self.kongfu = '[独创煎饼果子技术]' def make_cake(self): print(f'运用{self.kongfu}制作煎饼果子')# 3. 用徒弟类创建对象，调用实例属性和方法daqiu = Prentice()print(daqiu.kongfu)daqiu.make_cake()（3）⼦类调⽤⽗类的同名⽅法和属性
# 1. 师父类，属性和方法class Master(object): def __init__(self): self.kongfu = '[古法煎饼果子配方]' def make_cake(self): print(f'运用{self.kongfu}制作煎饼果子')# 为了验证多继承，添加School父类class School(object): def __init__(self): self.kongfu = '[黑马煎饼果子配方]' def make_cake(self): print(f'运用{self.kongfu}制作煎饼果子')# 2. 定义徒弟类，继承师父类 和 学校类， 添加和父类同名的属性和方法class Prentice(School, Master): def __init__(self): self.kongfu = '[独创煎饼果子技术]' def make_cake(self): # 加自己的初始化的原因：如果不加这个自己的初始化，kongfu属性值是上一次调用的init内的kongfu属性值 self.__init__() print(f'运用{self.kongfu}制作煎饼果子') # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装 def make_master_cake(self): # 父类类名.函数() # 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init Master.__init__(self) Master.make_cake(self) def make_school_cake(self): School.__init__(self) School.make_cake(self)# 3. 用徒弟类创建对象，调用实例属性和方法daqiu = Prentice()daqiu.make_cake()daqiu.make_master_cake()daqiu.make_school_cake()daqiu.make_cake()# 输出运用[独创煎饼果子技术]制作煎饼果子运用[古法煎饼果子配方]制作煎饼果子运用[黑马煎饼果子配方]制作煎饼果子运用[独创煎饼果子技术]制作煎饼果子（4） super()调⽤⽗类⽅法
class Master(object): def __init__(self): self.kongfu = '[古法煎饼果子配方]' def make_cake(self): print(f'运用{self.kongfu}制作煎饼果子')class School(Master): def __init__(self): self.kongfu = '[黑马煎饼果子配方]' def make_cake(self): print(f'运用{self.kongfu}制作煎饼果子') # 2.1 super()带参数写法 # super(School, self).__init__() # super(School, self).make_cake() # 2.2 无参数的super super().__init__() super().make_cake()class Prentice(School): def __init__(self): self.kongfu = '[独创煎饼果子技术]' def make_cake(self): self.__init__() print(f'运用{self.kongfu}制作煎饼果子') # 需求：一次性调用父类School Master的方法 def make_old_cake(self): # 2.2 无参数super super().__init__() super().make_cake()daqiu = Prentice()daqiu.make_old_cake()运用[黑马煎饼果子配方]制作煎饼果子运用[古法煎饼果子配方]制作煎饼果子（3）私有权限
定义私有属性和⽅法
设置私有权限的⽅法：在属性名和⽅法名 前⾯ 加上两个下划线 __。
# 定义私有属性 self.__money = 2000000 # 定义私有⽅法 def __info_print(self): print(self.kongfu) print(self.__money)注意：私有属性和私有⽅法只能在类⾥⾯访问和修改。
获取和修改私有属性值
在Python中，⼀般定义函数名 get_xx ⽤来获取私有属性，定义 set_xx ⽤来修改私有属性值。
class Master(object): def __init__(self): self.kongfu = '[古法煎饼果子配方]' def make_cake(self): print(f'运用{self.kongfu}制作煎饼果子')class School(object): def __init__(self): self.kongfu = '[黑马煎饼果子配方]' def make_cake(self): print(f'运用{self.kongfu}制作煎饼果子')class Prentice(School, Master): def __init__(self): self.kongfu = '[独创煎饼果子技术]' # 定义私有属性 self.__money = 2000000 # 定义函数：获取私有属性值 get_xx def get_money(self): return self.__money # 定义函数：修改私有属性值 set_xx def set_money(self): self.__money = 500 # 定义私有方法 def __info_print(self): print('这是私有方法')class Tusun(Prentice): passxiaoqiu = Tusun()print(xiaoqiu.get_money())xiaoqiu.set_money()print(xiaoqiu.get_money())#输出20000005005.多态
定义：多态是⼀种使⽤对象的⽅式，⼦类重写⽗类⽅法，调⽤不同⼦类对象的相同⽗类⽅法，可以产⽣不同的执⾏结果
# 1. 定义父类，提供公共方法： 警犬 和 人class Dog(object): def work(self): pass# 2. 定义子类，子类重写父类方法：定义2个类表示不同的警犬class ArmyDog(Dog): def work(self): print('追击敌人...')class DrugDog(Dog): def work(self): print('追查毒品...')# 定义人类class Person(object): def work_with_dog(self, dog): dog.work()# 3. 创建对象，调用不同的功能，传入不同的对象，观察执行的结果ad = ArmyDog()dd = DrugDog()daqiu = Person()daqiu.work_with_dog(ad)daqiu.work_with_dog(dd)#追击敌人...追查毒品...6.类属性和实例属性
类属性就是 类对象 所拥有的属性，它被 该类的所有实例对象 所共有。类属性可以使⽤ 类对象 或 实例对象 访问。修改类属性
class Dog(object): tooth = 10 wangcai = Dog()xiaohei = Dog()# 修改类属性Dog.tooth = 12print(Dog.tooth) # 12print(wangcai.tooth) # 12print(xiaohei.tooth) # 12# 不能通过对象修改属性，如果这样操作，实则是创建了⼀个实例属性wangcai.tooth = 20print(Dog.tooth) # 12print(wangcai.tooth) # 20print(xiaohei.tooth) # 12实例属性
class Dog(object): def __init__(self): self.age = 5 def info_print(self): print(self.age) wangcai = Dog()print(wangcai.age) # 5# print(Dog.age) # 报错：实例属性不能通过类访问wangcai.info_print() # 57.类⽅法和静态⽅法
(1) 类⽅法
类⽅法特点
第⼀个形参是类对象的⽅法需要⽤装饰器 @classmethod 来标识其为类⽅法，对于类⽅法，第⼀个参数必须是类对象，⼀般以cls 作为第⼀个参数。当⽅法中 需要使⽤类对象 (如访问私有类属性等)时，定义类⽅法类⽅法⼀般和类属性配合使⽤class Dog(object): __tooth = 10 @classmethod def get_tooth(cls): return cls.__tooth wangcai = Dog()result = wangcai.get_tooth()print(result) # 10(2) 静态⽅法
静态⽅法特点
需要通过装饰器 @staticmethod 来进⾏修饰，静态⽅法既不需要传递类对象也不需要传递实例对象（形参没有self/cls）。静态⽅法 也能够通过 实例对象 和 类对象 去访问。静态⽅法使⽤场景
当⽅法中 既不需要使⽤实例对象(如实例对象，实例属性)，也不需要使⽤类对象 (如类属性、类⽅法、创建实例等)时，定义静态⽅法取消不需要的参数传递，有利于 减少不必要的内存占⽤和性能消耗class Dog(object): @staticmethod def info_print(): print('这是⼀个狗类，⽤于创建狗实例....') wangcai = Dog()# 静态⽅法既可以使⽤对象访问⼜可以使⽤类访问wangcai.info_print()Dog.info_print()第五章 异常
1.异常的写法
finally表示的是⽆论是否异常都要执⾏的代码，例如关闭⽂件。
try执行# 方式一try: 可能发⽣错误的代码except 异常类型: 如果捕获到该异常类型执⾏的代码# 方式二try: 可能发⽣异常的代码except: 如果出现异常执⾏的代码else: 没有异常执⾏的代码finally: ⽆论是否异常都要执⾏的代码例子：
try: print(1)except Exception as result: print(result)else: print('我是else，是没有异常的时候执⾏的代码') #输出 1我是else，是没有异常的时候执⾏的代码try:f = open('test.txt', 'r')except Exception as result: f = open('test.txt', 'w')else: print('没有异常，真开⼼')finally: f.close()#except执行，else不执行2.⾃定义异常
在Python中，抛出⾃定义异常的语法为 raise 异常类对象 。
需求：密码⻓度不⾜，则报异常（⽤户输⼊密码，如果输⼊的⻓度不⾜3位，则报错，即抛出⾃定义异常，并捕获该异常）。
# 1. 自定义异常类， 继承Exception， 魔法方法有init和str(设置异常描述信息)class ShortInputError(Exception): def __init__(self, length, min_len): # 用户输入的密码长度 self.length = length # 系统要求的最少长度 self.min_len = min_len # 设置异常描述信息 def __str__(self): return f'您输入的密码长度是{self.length}, 密码不能少于{self.min_len}'def main(): # 2. 抛出异常: 尝试执行：用户输入密码，如果长度小于3，抛出异常 try: password = input('请输入密码：') if len(password) < 3: # 抛出异常类创建的对象 raise ShortInputError(len(password), 3) # 3. 捕获该异常 except Exception as result: print(result) else: print('没有异常，密码输入完成')main()第六章 模块和包
1. 模块
(1) 导入模块
Python 模块(Module)，是⼀个 Python ⽂件，以 .py 结尾，包含了 Python 对象定义和Python语句。
模块能定义函数，类和变量，模块⾥也能包含可执⾏的代码。
# 方法一：import 模块名; # import 模块名1, 模块名2...# 模块名.功能名()import mathprint(math.sqrt(9))# 方法二： from 模块名 import 功能1, 功能2...; # 功能调用（不需要书写模块名.功能）from math import sqrtprint(sqrt(9))# 方法三：from 模块名 import *; #功能调用（不需要书写模块名.功能）from math import *print(sqrt(9))as定义别名
# 模块定义别名import 模块名 as 别名# 功能定义别名from 模块名 import 功能 as 别名# 模块别名import time as tttt.sleep(2)print('hello')# 功能别名from time import sleep as slsl(2)print('hello')(2)制作模块
在Python中，每个Python⽂件都可以作为⼀个模块，模块的名字就是⽂件的名字。也就是说⾃定义模块名必须要符合标识符命名规则。
定义模块
新建⼀个Python⽂件，命名为 my_module1.py ，并定义 testA 函数。
def testA(a, b): print(a + b)调⽤模块
import my_module1my_module1.testA(1, 1)注意事项
如果使⽤ from … import … 或 from … import * 导⼊多个模块的时候，且模块内有同名功能。当调⽤这个同名功能的时候，调⽤到的是后⾯导⼊的模块的功能。
# 模块1代码def my_test(a, b): print(a + b)# 模块2代码def my_test(a, b): print(a - b) # 导⼊模块和调⽤功能代码from my_module1 import my_testfrom my_module2 import my_test# my_test函数是模块2中的函数my_test(1, 1) #0(3) _ _ all _ _
如果⼀个模块⽂件中有 all 变量，当使⽤ from xxx import * 导⼊时，只能导⼊这个列表中的元素。
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QBX5sFlU-1666507077669)(F:\BaiduNetdiskDownload\资料-python从0开始学编程\python总结\图片\6.png)]](http://zhangshiyu.com/zb_users/upload/2022/11/20221107184102166781766293457.png)
2. 包
包将有联系的模块组织在⼀起，即放到同⼀个⽂件夹下，并且在这个⽂件夹创建⼀个名字为 _ _ init_ _.py ⽂件，那么这个⽂件夹就称之为包。
(1)制作包
[New] — [Python Package] — 输⼊包名 — [OK] — 新建功能模块(有联系的模块)。
注意：新建包后，包内部会⾃动创建 init.py ⽂件，这个⽂件控制着包的导⼊⾏为。
1. 新建包 mypackage2. 新建包内模块： my_module1 和 my_module23. 模块内代码如下
# my_module1print(1)def info_print1(): print('my_module1')# my_module2print(2)def info_print2(): print('my_module2')(2) 导入包
# ⽅法⼀import 包名.模块名包名.模块名.⽬标import my_package.my_module1my_package.my_module1.info_print1()# __init__.py __all__ = ['my_module1']#⽅法⼆#注意：必须在 __init__.py ⽂件中添加 __all__ = [] ，控制允许导⼊的模块列表。from 包名 import *模块名.⽬标from my_package import *my_module1.info_print1()第七章 公共操作
1.运算符
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FatSH1dE-1666507077671)(F:\BaiduNetdiskDownload\资料-python从0开始学编程\python总结\图片\9.png)]](http://zhangshiyu.com/zb_users/upload/2022/11/20221107184102166781766232207.png)
(1) +
# 1. 字符串str1 = 'aa'str2 = 'bb'str3 = str1 + str2print(str3) # aabb# 2. 列表list1 = [1, 2]list2 = [10, 20]list3 = list1 + list2print(list3) # [1, 2, 10, 20]# 3. 元组t1 = (1, 2)t2 = (10, 20)t3 = t1 + t2print(t3) # (10, 20, 100, 200)(2) *
# 1. 字符串print('-' * 10) # ----------# 2. 列表list1 = ['hello']print(list1 * 4) # ['hello', 'hello', 'hello', 'hello']# 3. 元组t1 = ('world',)print(t1 * 4) # ('world', 'world', 'world', 'world')(3)in或not in
# 1. 字符串print('a' in 'abcd') # Trueprint('a' not in 'abcd') # False# 2. 列表list1 = ['a', 'b', 'c', 'd']print('a' in list1) # Trueprint('a' not in list1) # False# 3. 元组t1 = ('a', 'b', 'c', 'd')print('aa' in t1) # Falseprint('aa' not in t1) # True2.公共⽅法
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WB9Z6pm2-1666507077671)(F:\BaiduNetdiskDownload\资料-python从0开始学编程\python总结\图片\10.png)]](http://zhangshiyu.com/zb_users/upload/2022/11/20221107184103166781766316750.png)
(1) len()
# 1. 字符串str1 = 'abcdefg'print(len(str1)) # 7# 2. 列表list1 = [10, 20, 30, 40]print(len(list1)) # 4# 3. 元组t1 = (10, 20, 30, 40, 50)print(len(t1)) # 5# 4. 集合s1 = {10, 20, 30}print(len(s1)) # 3# 5. 字典dict1 = {'name': 'Rose', 'age': 18}print(len(dict1)) # 2(2) del()
# 1. 字符串str1 = 'abcdefg'del str1print(str1)# 2. 列表list1 = [10, 20, 30, 40]del(list1[0])print(list1) # [20, 30, 40](3) max()、min()
# 1. 字符串str1 = 'abcdefg'print(max(str1)) # g# 2. 列表list1 = [10, 20, 30, 40]print(max(list1)) # 40# 1. 字符串str1 = 'abcdefg'print(min(str1)) # a# 2. 列表list1 = [10, 20, 30, 40]print(min(list1)) # 10(4) range()
注意：range()⽣成的序列不包含end数字。
# 1 2 3 4 5 6 7 8 9for i in range(1, 10, 1): print(i) # 1 3 5 7 9for i in range(1, 10, 2): print(i) # 0 1 2 3 4 5 6 7 8 9for i in range(10): print(i)(5) enumerate()
enumerate(可遍历对象, start=0)注意：start参数⽤来设置遍历数据的下标的起始值，默认为0。
list1 = ['a', 'b', 'c', 'd', 'e']for i in enumerate(list1): print(i)# 输出(0, 'a')(1, 'b')(2, 'c')(3, 'd')(4, 'e') for index, char in enumerate(list1, start=1): print(f'下标是{index}, 对应的字符是{char}') #输出下标是1, 对应的字符是a下标是2, 对应的字符是b下标是3, 对应的字符是c下标是4, 对应的字符是d下标是5, 对应的字符是e3.容器类型转换
(1) tuple()
作⽤：将某个序列转换成元组list1 = [10, 20, 30, 40, 50, 20]s1 = {100, 200, 300, 400, 500}print(tuple(list1))print(tuple(s1))#输出(10, 20, 30, 40, 50, 20)(100, 200, 300, 400, 500)(2) list()
作⽤：将某个序列转换成列表t1 = ('a', 'b', 'c', 'd', 'e')s1 = {100, 200, 300, 400, 500}print(list(t1))print(list(s1))(3)set()
作⽤：将某个序列转换成集合list1 = [10, 20, 30, 40, 50, 20]t1 = ('a', 'b', 'c', 'd', 'e')print(set(list1))print(set(t1))#输出{40, 10, 50, 20, 30}{'e', 'b', 'c', 'a', 'd'}注意：
集合可以快速完成列表去重集合不⽀持下标第八章 练习⾯向对象版学员管理系统
使⽤⾯向对象编程思想完成学员管理系统的开发，具体如下：
系统要求：学员数据存储在⽂件中系统功能：添加学员、删除学员、修改学员信息、查询学员信息、显示所有学员信息、保存学员信息及退出系统等功能。(1) student.py
需求：
学员信息包含：姓名、性别、⼿机号；添加 str 魔法⽅法，⽅便查看学员对象信息class Student(object): def __init__(self, name, gender, tel): # 姓名、性别、手机号 self.name = name self.gender = gender self.tel = tel def __str__(self): return f'{self.name}, {self.gender}, {self.tel}'# aa = Student('aa', 'nv', 111)# print(aa) # aa, nv, 111(2) managerSystem.py
需求：
存储数据的位置：⽂件(student.data)
加载⽂件数据
修改数据后保存到⽂件
存储数据的形式：列表存储学员对象
系统功能
添加学员
删除学员
修改学员
查询学员信息
显示所有学员信息
保存学员信息
退出系统
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HG5OFEJU-1666507077673)(F:\BaiduNetdiskDownload\资料-python从0开始学编程\python总结\图片\8.png)]](http://zhangshiyu.com/zb_users/upload/2022/11/20221107184103166781766373502.png)
class StudentManager(object): def __init__(self): # 存储学员数据 -- 列表 self.student_list = [] # 一. 程序入口函数 def run(self): # 1. 加载文件里面的学员数据 self.load_student() while True: # 2. 显示功能菜单 self.show_menu() # 3. 用户输入目标功能序号 menu_num = int(input('请输入您需要的功能序号：')) # 4. 根据用户输入的序号执行不同的功能 -- 如果用户输入1，执行添加 if menu_num == 1: # 添加学员 self.add_student() elif menu_num == 2: # 删除学员 self.del_student() elif menu_num == 3: # 修改学员信息 self.modify_student() elif menu_num == 4: # 查询学员信息 self.search_student() elif menu_num == 5: # 显示所有学员信息 self.show_student() elif menu_num == 6: # 保存学员信息 self.save_student() elif menu_num == 7: # 退出系统 -- 退出循环 break # 二. 系统功能函数 # 2.1 显示功能菜单 -- 打印序号的功能对应关系 -- 静态 @staticmethod def show_menu(): print('请选择如下功能：') print('1:添加学员') print('2:删除学员') print('3:修改学员信息') print('4:查询学员信息') print('5:显示所有学员信息') print('6:保存学员信息') print('7:退出系统') # 2.2 添加学员 def add_student(self): # 1. 用户输入姓名、性别、手机号 name = input('请输入您的姓名：') gender = input('请输入您的性别：') tel = input('请输入您的手机号：') # 2. 创建学员对象 -- 类 ？类在student文件里面 先导入student模块，再创建对象 student = Student(name, gender, tel) # 3. 将该对象添加到学员列表 self.student_list.append(student) print(self.student_list) print(student) # 2.3 删除学员 def del_student(self): # 1. 用户输入目标学员姓名 del_name = input('请输入要删除的学员姓名：') # 2. 遍历学员列表，如果用户输入的学员存在则删除学员对象，否则提示学员不存在 for i in self.student_list: if del_name == i.name: # 删除该学员对象 self.student_list.remove(i) break else: # 循环正常价结束执行的代码：循环结束都没有删除任何一个对象，所以说明用户输入的目标学员不存在 print('查无此人！') print(self.student_list) # 2.4 修改学员信息 def modify_student(self): # 1. 用户输入目标学员姓名 modify_name = input('请输入要修改的学员姓名：') # 2. 遍历列表数据，如果学员存在修改姓名性别手机号，否则提示学员不存在 for i in self.student_list: if modify_name == i.name: i.name = input('姓名：') i.gender = input('性别：') i.tel = input('手机号：') print(f'修改学员信息成功，姓名{i.name}, 性别{i.gender}, 手机号{i.tel}') break else: print('查无此人！') # 2.5 查询学员信息 def search_student(self): # 1. 用户输入目标学员姓名 search_name = input('请输入您要搜索的学员姓名：') # 2. 遍历列表。如果学员存在打印学员信息，否则提示学员不存在 for i in self.student_list: if search_name == i.name: print(f'姓名是{i.name}, 性别是{i.gender}, 手机号是{i.tel}') break else: print('查无此人！') # 2.6 显示所有学员信息 def show_student(self): # 1. 打印表头 print('姓名\t性别\t手机号') # 2. 打印学员数据 for i in self.student_list: print(f'{i.name}\t{i.gender}\t{i.tel}') # 2.7 保存学员信息 def save_student(self): # 1. 打开文件 f = open('student.data', 'w') # 2. 文件写入数据 # 2.1 [学员对象] 转换成 [字典] new_list = [i.__dict__ for i in self.student_list] # 2.2 文件写入 字符串数据 f.write(str(new_list)) # 3. 关闭文件 f.close() # 2.8 加载学员信息 def load_student(self): # 1. 打开文件：尝试r打开，如果有异常w try: f = open('student.data', 'r') except: f = open('student.data', 'w') else: # 2. 读取数据：文件读取出的数据是字符串还原列表类型；[{}] 转换 [学员对象] data = f.read() # 字符串 new_list = eval(data) self.student_list = [Student(i['name'], i['gender'], i['tel']) for i in new_list] finally: # 3. 关闭文件 f.close()(3) main.py
# 1. 导入管理系统模块from managerSystem import *# 2. 启动管理系统# 保证是当前文件运行才启动管理系统：if --创建对象并调用run方法if __name__ == '__main__': student_manager = StudentManager() student_manager.run()