Python基础学习笔记
本博客采用思维导图式笔记，所有思维导图均为本人亲手所画。因为本人也是初次学习Python语言所以有些知识点可能不太全。
基础班第一天学习笔记：链接
基础班第二天学习笔记：链接
基础班第三天学习笔记：链接
基础班第四天学习笔记：链接
基础班第五天学习笔记：链接
基础班第六天学习笔记：链接
基础班第七天学习笔记：链接
基础班第八天学习笔记：链接
基础班第九天学习笔记：链接
基础班第十天学习笔记：链接
字符串思维导图 列表思维导图 元组思维导图 集合思维导图 字典思维导图 容器类型的公共方法
函数的思维导图 文件思维导图 if判断语句思维导图 面向对象思维导图 enumerate()方法的使用
模拟用户登陆实现：
# 编写代码模拟用户登陆。
# 要求：用户名为 python，密码 123456，
# 如果输入正确，打印“欢迎光临”，程序结束，
# 如果输入错误，提示用户输入错误并重新输入
user = input("请输入用户名：")
password = input("请输入密码：")
if user == 'python' and password == '123456':
print("欢迎光临！")
else:
print("用户名或密码错误！")♥三目运算符的使用：
age = int(input("请输入您的年龄："))
print("恭喜小伙，已经成年。") if age >= 18 else print("小伙，你还没成年。")♥利用random模块实现猜拳游戏：
1 import random
2 player = int(input("请出拳：石头（1)、剪刀（2）、布（3）："))
3 computer = random.randint(1, 3)
4 print(computer)
5 if (player == 1 and computer == 2) or \
6 (player == 2 and computer == 3) or \
7 (player == 3 and computer == 1):
8 print("你赢了")
9 elif player == computer:
10 print("平局")
11 else:
12 print("你输了")过7游戏实现：
# 设计“过7游戏”的程序, 打印出1-100之间除了7和7的倍数之外的所有数字
num = 1
while num <= 100:
if num % 7 != 0:
print(num, end="|")
num += 1♥通过eval()方法实现高级版计算器：
# 升级版计算器：
# eval()方法：取出字符串包裹的内容
num1 = float(input("请输入第一个数："))
num2 = float(input("请输入第二个数："))
operator = input("请输入操作符：")
result = eval("%d %s %d" % (num1, operator, num2))
print("%d %s %d = %d" % (num1, operator, num2, result))九九乘法表的实现：
# 正向打印九九乘法表
for row in range(1, 10):
for col in range(1, row + 1):
print("%d * %d = %d" % (col, row, row * col), end="\t")
print("")
# 逆向打印九九乘法表
for col in range(9, 0, -1):
for row in range(col, 0, -1):
print("%d * %d = %d" % (row, col, row * col), end="\t")
print("")循环输出三角形：
# 1.如何使用循环嵌套循环输出如下图形：
#
# *****
# ****
# ***
# **
# *
# 利用for循环实现
for row in range(0, 5):
for col in range(row, 5):
print("*", end=" ")
print("")
# 利用while循环实现
row = 1
while row <= 5:
col = 0
while col <= 5 - row:
print("*", end="")
col += 1
print("")
row += 1王朴矩阵：（王朴为Python48期同学）
# 输出如下矩阵：
# &*&*&
# &*&*&
# &*&*&
# &*&*&
# &*&*&
for row in range(5):
for col in range(5):
if col % 2 == 0:
print("&", end="")
else:
print("*", end="")
print("")字符串结合切片使用：
1 # 现有字符串： str1 = '1234567890'，根据题目要求，将截取后的新字符串赋值给str2 2 str1 = '1234567890' 3 # 截取字符串的第一位到第三位的字符 4 str2 = str1[0:3] 5 print(str2) 6 # 截取字符串最后三位的字符 7 str2 = str1[-3:] 8 print(str2) 9 # 截取字符串的全部字符 10 str2 = str1[::] 11 print(str2) 12 # 截取字符串的第七个字符到结尾 13 str2 = str1[7:] 14 print(str2) 15 # 截取字符串的第一位到倒数第三位之间的字符 16 str2 = str1[1:-3] 17 print(str2) 18 # 截取字符串的第三个字符 19 str2 = str1[2] 20 print(str2) 21 # 截取字符串的倒数第一个字符 22 str2 = str1[-1] 23 print(str2) 24 # 截取与原字符串顺序相反的字符串 25 str2 = str1[::-1] 26 print(str2) 27 # 截取字符串倒数第三位与倒数第一位之间的字符 28 str2 = str1[-3:-1] 29 print(str2) 30 # 截取字符串的第一位字符到最后一位字符之间的字符，每隔一个字符截取一次。 31 str2 = str1[0:-1:2] 32 print(str2) 33 34 # 通过for循环将列表逆序输出 35 my_list = ['a', 'b', 'c', 'd'] 36 for data in my_list[::-1]: 37 print(data)
字符串的格式化输出：
1 # 字符串的格式化输出: 把字符串里面的内容按照指定的数据类型进行输出显示
2
3 # 学习字符串格式化的目的：以后字符串里面的内容有动态内容时，需要使用字符串的格式化
4
5 # 格式化占位符:
6 # %d 表示格式化显示整型数字
7 # %f 表示格式化显示小数
8 # %s 表示格式化显示字符串
9
10 # 字符串的内容进行了格式化
11 # 注意点：如果字符串里面有多个格式化占位符，那么多个参数在进行传参的时候，需要加上小括号
12 msg = "姓名: %s 年龄: %d" % ("王五", 22)
13 # 输出格式化后的字符串
14 print(msg)
15
16 # 如果字符串中只有一个格式化占位符，在进行传参的时候，参数不需要加上小括号
17 info = "性别: %s" % "男"
18 print(info, type(info))
19 print("性别: %s" % "男")
20
21 pi = 3.16
22 # %f 默认保留6位小数
23 # print("圆周率: %f" % pi)
24 # 注意点格式化占位符会进行四舍五入
25 print("圆周率: %.2f" % pi)
26
27
28 # 格式化占位符的注意点: 扩展：
29
30 student_no = 123
31
32 # %03d: 正数要求是3位，不够三位前面补0
33 print("学号:%03d" % student_no)
34
35 # 格式化占位符结合百分号一起使用的时候，两个百分号表示一个
36 print("百分比: %d%%" % 50)
37
38
39 # 定义整数变量 student_no ，输出 我的学号是 000001
40 student_no = 1
41 print("我的学号为: %06d" % student_no)
42
43 # 定义⼩数 price 、 weight 、 money ，输出 苹果单价 9.00 元／⽄，购买了 5.00 ⽄，需要⽀付 45.00 元
44 price = 9.0
45 weight = 5.0
46 money = 45.0
47 print("苹果单价%.2f 元／⽄，购买了 %.2f ⽄，需要⽀付 %.2f 元" % (price, weight, money))f-string的使用：
1 # fstring：用来给字符串动态绑定数据
2
3 # fstring的使用语法格式:
4
5 # f"姓名: {'李四'} 年龄: {20}"
6
7 name = "李四"
8 age = 20
9
10 info = f"姓名:{name} 年龄:{age}"
11 print(info, type(info))
12
13 info = f"姓名:{'王三'} 年龄:{20}"
14 print(info, type(info))
15
16 # 3 + 4 = 7
17
18 num1 = float(input("请输入第一个数字:"))
19 num2 = float(input("请输入第二个数字:"))
20
21 result = F'{num1} + {num2} = {num1 + num2}'
22 print(result)
23
24 # 总结： fstring只能在python3.6及以上版本才能使用，如果兼容之前的代码可以使用字符串的格式化输出学生信息管理系统（文件版）：
1 student_list = [] # 定义一个空列表，用来保存用户输入的学生信息
2
3
4 def menu(): # 定义函数用于菜单输出
5 print("------------------------------")
6 print("----欢迎使用学生信息管理系统------")
7 print("----1.显示学生信息--------------")
8 print("----2.添加学生信息--------------")
9 print("----3.删除学生信息--------------")
10 print("----4.修改学生信息--------------")
11 print("----5.保存学生信息--------------")
12 print("----6.退出学生信息系统-----------")
13 print("------------------------------")
14
15
16 def menu_msg(): # 定义函数用于获取用户选择的功能
17 menu()
18 user = int(input("请输入需要的功能代码："))
19 if user == 1:
20 show_msg() # 学生信息显示函数
21 elif user == 2:
22 add_msg() # 添加学生信息函数
23 elif user == 3:
24 del_msg() # 删除学生信息函数
25 elif user == 4:
26 modify_msg() # 修改学生信息函数
27 elif user == 5:
28 save_msg() # 保存学生信息函数
29 elif user == 6:
30 print("欢迎下次使用本系统！")
31 exit() # 结束程序
32
33
34 def show_msg(): # 显示学生信息函数
35 if len(student_list) > 0:
36 for data in student_list:
37 # 通过循环将列表中数据输出
38 print(data)
39 else:
40 print("系统中无学生信息！")
41 menu_msg()
42
43
44 def add_msg(): # 添加学生信息函数
45 name = input("请输入学生姓名：")
46 age = input("请输入学生年龄：")
47 sex = input("请输入学生性别：")
48 # 使用字典保存用户输入的学生信息
49 student_dict = {"name": name, "age": age, "sex": sex}
50 student_list.append(student_dict)
51 print("添加成功！")
52 user = input("是否继续添加学生信息（是：y或Y，否：N或n）：")
53 if user == 'y' or user == 'Y':
54 add_msg()
55 elif user == 'n' or user == 'N':
56 menu_msg()
57 else:
58 print("非法数据")
59 exit()
60
61
62 def del_msg(): # 删除学生信息函数
63 # 通过enumerate方法给字典中存储的学生信息分配一个学号
64 for index, dict in enumerate(student_list):
65 print(f"学号是:{index + 1 },其余信息为：{dict}")
66 student_no = int(input("请输入学生学号："))
67 # 判断用户输入的索引是否在0-len(student_list)内
68 # student_no - 1 是因为显示学号是将索引+1了
69 if student_no >= 0 and student_no - 1 < len(student_list):
70 del student_list[student_no - 1]
71 print("恭喜您删除学生信息成功！")
72 else:
73 print("您输入的学号不存在！")
74 menu_msg()
75
76
77 def modify_msg(): # 修改学生信息函数
78 # 通过enumerate方法给字典中存储的学生信息分配一个学号
79 for index, dict in enumerate(student_list):
80 print(f"学号是:{index + 1 },其余信息为：{dict}")
81 student_no = int(input("请输入学生学号："))
82 if 0 <= (student_no - 1) < len(student_list):
83 # 通过列表[索引号]["键名"] 对存储在列表中字典里的数据进行修改
84 student_list[student_no - 1]["name"] = input("请输入学生姓名：")
85 student_list[student_no - 1]["age"] = input("请输入学生年龄：")
86 student_list[student_no - 1]["sex"] = input("请输入学生性别：")
87 print("修改学生信息成功")
88 else:
89 print("您输入的学号不存在！")
90 menu_msg()
91
92
93 def save_msg(): # 保存数据函数
94 # 将列表所存储的信息通过类型转换写入txt文件中
95 f = open("student.txt", "w")
96 student_str = str(student_list)
97 f.write(student_str)
98 f.close()
99 menu_msg()
100
101
102 menu_msg()列表的嵌套使用：
1 # 已知列表 my_list = [["李三", 20], ["王五", 22], ["刘三", 30]] ， 2 # 1. 对该列表进行过滤获取年龄大于20的列表 3 # 比如: [["王五", 22], ["刘三", 30]] 4 my_list = [["李三", 20], ["王五", 22], ["刘三", 30]] 5 new_list = [] 6 for value in my_list: 7 if value[1] > 20: 8 new_list.append(value) 9 print(new_list) 10 11 # 2. 对该列表进行过滤获取名字结尾叫'三'的列表 12 # 比如: [["李三", 20], ["刘三", 30]] 13 14 my_list = [["李三", 20], ["王五", 22], ["刘三", 30]] 15 new_list = [] 16 17 for data in my_list: 18 if data[0][-1] == '三': 19 new_list.append(data) 20 print(new_list)
1 # 使用列表嵌套，完成8名老师随机分配3个办公室 2 import random 3 office = [[], [], []] 4 teacher = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] 5 6 for value in teacher: 7 office[random.randint(0,2)].append(value) 8 9 print(office)
1 # 将8个老师随进分配到3个办公室，
2 # 每个办公室至少有一个人
3
4
5 import random
6
7 office_list = [[], [], []]
8
9 teacher_list = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
10
11 while True:
12 for teacher in teacher_list:
13 index = random.randint(0, 2)
14 office_list[index].append(teacher)
15
16 print(office_list)
17
18 num = 1
19 for office in office_list:
20 print("第%d个办公室有%d人" % (num, len(office)))
21 for teacher in office:
22 print(teacher)
23 num += 1
24
25 if len(office_list[0]) == 0 or len(office_list[1]) == 0 or len(office_list[2]) == 0:
26 continue
27 else:
28 break
29 #
30 #
31
32
33 # 进阶版
34
35 import random
36
37 office_list = [[], [], []]
38
39 teacher_list = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
40
41 while True:
42 for teacher in teacher_list:
43 index = random.randint(0, 2)
44 office_list[index].append(teacher)
45
46 print(office_list)
47
48 for index, office in enumerate(office_list):
49 print("第%d个办公室有%d人" % (index + 1, len(office)))
50 for teacher in office:
51 print(teacher)
52
53 if len(office_list[0]) == 0 or len(office_list[1]) == 0 or len(office_list[2]) == 0:
54 continue
55 else:
56 break列表结合random使用：
1 从键盘中输入5个学生的名字，存储到列表中，然后打印出每个学生名字中的第2个字母
2 name_list = []
3 for _ in range(5):
4 name = input("请输入学生姓名：")
5 name_list.append(name)
6
7 for index in range(len(name_list)):
8 print(name_list[index][1])
9
10 从键盘获取5个学生的名字，然后随机抽出一名学生去打扫卫生
11 import random
12
13 name_list = []
14 for _ in range(5):
15 name = input("请输入学生姓名：")
16 name_list.append(name)
17
18 print("%s打扫卫生！" % name_list[random.randint(0, len(name_list))])练习enumerate函数的使用:
1 # enumerate：使用for循环遍历容器类型数据时， 2 # 既要下标又要数据可以结合enumerate函数来使用 3 4 # 将自定义的列表输出并输出每个数据的下标 5 6 my_list = ['a', 'b', 'c', 'd', 'e', 'f'] 7 8 for index, value in enumerate(my_list): 9 print(index, value)
字典的应用：
1 # 编程：
2 # 使用字典来存储一个人的信息
3 # （姓名、年龄、学号、QQ、微信、住址等），
4 # 这些信息来自 键盘的输入
5
6 msg_dict = {}
7
8 name = input("请输入您的姓名：")
9 age = int(input("请输入您的年龄："))
10 student_no = input("请输入您的学号：")
11 QQ = input("请输入您的QQ：")
12 VX = input("请输入您的微信：")
13 address = input("请输入您的住址：")
14
15 msg_dict["name"] = name
16 msg_dict["age"] = age
17 msg_dict["student_no"] = student_no
18 msg_dict["QQ"] = QQ
19 msg_dict["VX"] = VX
20 msg_dict["address"] = address
21
22
23 print(msg_dict) 1 1. 使用程序描述一个学生信息，
2 # 接收信息包含姓名、年龄、喜欢的书籍
3 # (西游记、红楼梦、三国演义、水浒传)
4
5 my_dict = {}
6 book_list = []
7 name = input("请输入您的姓名：")
8 age = int(input("请输入您的年龄："))
9
10 my_dict["name"] = name
11 my_dict["age"] = age
12 book = int(input("请输入你喜欢书的个数（1-4）："))
13
14 if 1 <= book <= 4:
15 for value in range(book):
16 book_list.append(input("请输入你喜欢的第%d本书的名字：" % (value + 1)))
17
18 my_dict["books"] = book_list
19 print(my_dict)
20
21 # 2. 已知 my_list = [{'name': '李四', 'age': 20},
22 # {'name': '王五', 'age': 22}]
23 # 过滤出来年龄大于20的数据， 比如: [{'name': '王五', 'age': 22}]
24
25 my_list = [{'name': '李四', 'age': 20},
26 {'name': '王五', 'age': 22}]
27 new_list = []
28 for dict in my_list:
29 if dict['age'] > 20:
30 new_list.append(dict)
31 print(new_list)
32
33
34 # 3. 使用函数完成对第1道题的开发
35
36 def books():
37 my_dict = {}
38 book_list = []
39 name = input("请输入您的姓名：")
40 age = int(input("请输入您的年龄："))
41
42 my_dict["name"] = name
43 my_dict["age"] = age
44 book = int(input("请输入你喜欢书的个数（1-4）："))
45
46 if 1 <= book <= 4:
47 for value in range(book):
48 book_list.append(input("请输入你喜欢的第%d本书的名字：" % (value + 1)))
49
50 my_dict["books"] = book_list
51 print(my_dict)
52
53 books()字符串、列表、字典的综合应用：
1 # 字符串、列表、字典综合应用
2 # 设计一个程序
3 # 要求用户可以实现登录、注册、注销登录等功能
4 # 用户的用户名(长度6-20)、密码(长度8-20)、昵称、年龄信息保存到字典中
5 # 将每个已注册用户的保存到列表中，即将上一步的字典保存到列表中
6 # 维护用户的登录状态，每次只能有一个用户处于登录状态，直到选择注销登录
7 # 如果不选择退出系统，该程序应当一直运行
8
9 user = []
10
11 user_dict = {}
12 while True:
13 print("1.登录")
14 print("2.注册")
15
16 user_chose = int(input("请输入您想要的功能："))
17 if user_chose == 1:
18 user_name = input("请输入您的用户名：")
19 password = input("请输入您的密码：")
20 if user_name == user_dict["user_name"] and password == user_dict["password"]:
21 print("登陆成功")
22 user_chose = input("是否注销登陆：是y或Y")
23 user_chose = user_chose.upper()
24 if user_chose == 'Y':
25 print("注销成功！")
26 break
27 else:
28 print("用户名或密码错误！")
29 elif user_chose == 2:
30 user_name = input("请输入您的用户名(长度6-20)：")
31 password = input("请输入您的密码(长度8-20)：")
32 name = input("请输入您的昵称：")
33 age = input("请输入您的年龄：")
34 if 6<= len(user_name) <= 20 and 8 <= len(password)<= 20:
35 user_dict["user_name"] = user_name
36 user_dict["password"] = password
37 user_dict["name"] = name
38 user_dict["age"] = age
39 user = user_dict
40 else:
41 print("请输入正确长的用户名或密码！")
42 continue
43 else:
44 print("非法数据")
45 continue不定长位置参数和不定长关键字参数使用：
1 # 使用不定长位置参数、不定长关键字参数完成多个数的平均值计算 2 3 4 def sum_num(*aegs, **kwargs): 5 num_sum = 0 6 for value in kwargs.values(): 7 num_sum += value 8 9 for value in aegs: 10 num_sum += value 11 12 return num_sum 13 14 15 def avg_sum(*args, **kwargs): 16 num_sum = sum_num(*args, **kwargs) 17 avg_num = num_sum / (len(args) + len(kwargs)) 18 return avg_num 19 20 21 result = avg_sum(1, 2, 3, 4, a=1, b=2, c=3, d=4) 22 23 print(result)
1 # 使用不定长参数定义一个函数max_min， 2 # 接受的参数类型是数值， 3 # 最终返回这些数中的最大值和最小值 4 5 def max_min(*args): 6 return max(args), min(args) 7 8 9 max_value, min_value = max_min(1, 2, 3, 4, 5, 67, 7, 235, 53, 3) 10 print(max_value, min_value)
1 # 分别定义加减乘除四个函数实现两个数之间的加减乘除操作 2 3 def add(a, b): 4 return a + b 5 6 7 def jian(a, b): 8 return a - b 9 10 11 def cheng(a, b): 12 return a * b 13 14 15 def chu(a, b): 16 return a / b 17 18 19 value1 = add(1, 2) 20 value2 = jian(2, 1) 21 value3 = cheng(4, 2) 22 value4 = chu(5, 6) 23 24 print(value1, value2, value3, value4)
1 # 定义一个函数min，接受的参数类型是数值，最终返回两个数中的最小值 2 def min_values(num1, num2): 3 result = num1,num2 4 value = min(result) 5 return value 6 7 min_value = min_values(666,787) 8 print(min_value)
# 定义一个函数max，接受的参数类型是数值，最终返回两个数中的最大值
def max_values(num1, num2):
result = num1,num2
value = max(result)
return value
max_value = max_values(4,777)
print(max_value)1 # 定义一个使用不定长参数的函数，并在函数中打印出参数及其类型，统计传入参数的个数 2 def show(*args): 3 print(args, type(args), len(args)) 4 5 6 show(1, 2, 34, 5, 6, 7, 8, 9) 7 8 9 def show(**kwargs): 10 print(kwargs, type(kwargs), len(kwargs)) 11 12 13 show(a=1, b=2, c=3, d=4)
1 # 定义一个函数cut_str，
2 # 接受三个参数，
3 # 分别为字符串s、数值a1、数值a2，
4 # 将字符串s从下标a1开始的a2个字符删除，
5 # 并把结果返回
6
7 #
8 def cut_str(s="", a1=0, a2=-1):
9 result = s[a1:a2]
10 new_str = s.replace(result, "")
11 return new_str
12
13 result = cut_str("abcdweasfsajfgjas",2,4)
14 print(result)♥对find()方法进行扩充：
1 # 1.定义函数findall，
2 # 实现对字符串find方法的进一步封装，
3 # 要求返回符合要求的所有位置的起始下标，
4 # 如字符串"helloworldhellopythonhelloc++hellojava"，
5 # 需要找出里面所有的"hello"的位置，
6 # 最后将返回一个元组(0,10,21,29)，
7 # 即将h的下标全部返回出来，
8 # 而find方法只能返回第一个
9
10 def findall(str="", chr=""):
11 # 定义一个列表用于存储找到的索引值
12 find_list = []
13 # 执行循环，循环次数为指定字符在字符串中出现的次数
14 for value in range(str.count(chr)):
15 # 定义变量用于存储指定字符对应的索引
16 find_count = str.find(chr)
17 # find_count + len(chr) * value ：
18 # 除第一次找到指定字符串的索引外，
19 # 其余次数均要加上替换掉的字符串的长度，
20 # 才能够获取到指定字符在最初字符串中最初的索引
21 find_list.append(find_count + len(chr) * value) # 将索引追加到列表中
22 # 去除已经找到的指定字符串
23 str = str.replace(chr, "", 1)
24 return find_list
25
26
27 result = findall("helloworldhellopythonhelloc++hellojava", "hello")
28
29 print(result)函数的递归调用：
1 # 使用递归函数求n的阶乘 2 3 4 def calc_num(num): 5 # 函数递归调用是必须要有结束条件 6 if num == 1: 7 return 1 8 else: 9 return num * calc_num(num - 1) 10 11 result = calc_num(5) 12 print(result) 13 14 15 # 使用递归的方法打印出前n个斐波那契数列 16 # 斐波那契数列起始数字为0和1，之后每个数都是前两个数之和,比如:0,1,1,2,3,5,8,... 17 # 0 1 1 2 3 5 8 13 21 .... 18 19 num_list = [0,1] 20 21 def fbnq_num(n): 22 if n == 2: 23 return num_list 24 else: 25 # 将列表中最后两个数的和相加后追加到列表后 26 num_list.append(num_list[-1]+ num_list[-2]) 27 return fbnq_num(n-1) 28 29 result = fbnq_num(9) 30 print(result)
Python中对文件的操作练习：
1 # 文件的相关操作、练习及应用
2 # 创建一个新项目中新创建一个名字py文件夹
3 import os
4 my_dir = os.mkdir("文件操作")
5 # 进入py文件夹中创建5个文件，文件名分别为
6 # python-06基础班-1.txt，
7 # python-06基础班-2.txt，
8 # python-06基础班-3.txt，
9 # python-06基础班-4.txt，
10 # python-06基础班-5.txt
11 for value in range(5):
12 f = open(f"文件操作/python-06基础班-{value+1}.txt","w")
13 f.close()
14 # 然后将py文件夹中的所有文件都改名为
15 # [黑马]python-06基础班-1.txt，
16 # [黑马]python-06基础班-2.txt，
17 # [黑马]python-06基础班-3.txt，
18 # [黑马]python-06基础班-4.txt，
19 # [黑马]python-06基础班-5.txt
20 for value in range(5):
21 f = os.rename(f"文件操作/python-06基础班-{value+1}.txt",f"文件操作/[黑马]python-06基础班-{value+1}.txt") 1 # 编写一段代码以完成两份文件之间的相互备份
2 import os
3 # 在python用户目录下创建python基础班文件夹
4 os.mkdir("python基础班")
5 # 在文件夹中创建gailun.txt文件
6 # 打开文件在gailun.txt中写入"德玛西亚！人在塔在！"
7 f = open("python基础班/gailun.txt", "w")
8 f.write("德玛西亚！人在塔在！")
9 f.close()
10 # 在文件夹中创建gailun副本.txt文件
11 f = open("python基础班/gailun副本.txt", "w")
12 # 将gailun.txt文件中的数据写入gailun副本.txt文件中
13 f1 = open("python基础班/gailun.txt", "r")
14 # .read()将文件内容读取并返回字符串
15 # .readlins()将文件内容读取并返回列表
16 result = f1.readline()
17 f1.close()
18 f.write(result)
19 f.close()
20 print(result, type(result))
21 # 打开文件，查看文件中是否有内容继承的应用：
1 # 1. 定义一个Student类，统计Student类创建的实例(对象)个数, 使用属性返回创建实例的个数
2 class Studnet(object):
3 obj_num = 0
4
5 def __init__(self):
6 Studnet.obj_num += 1
7 print("实例个数：", Studnet.obj_num)
8
9
10 s1 = Studnet()
11 s2 = Studnet()
12 # 2. 定义一个Person类，添加两个实例属性(name, age),
13 # 创建两个实例对象添加到列表里面, 例如: [p1, p2]
14 obj_list = []
15
16
17 class Person(object):
18 def __init__(self, name, age):
19 self.name = name
20 self.age = age
21
22
23 p1 = Person("李四", 20)
24 obj_list.append(p1)
25 p2 = Person("王超", 22)
26 obj_list.append(p2)
27 print(obj_list)
28 # 3. 把列表中的person对象改成列表中的字典,
29 # 例如: [{"name": "李四", "age": 20}, {"name": "李四", "age": 20}]
30 new_list = [obj.__dict__ for obj in obj_list]
31 print(new_list)
32 # 4. 把该数据[{"name": "李四", "age": 20}, {"name": "李四", "age": 20}]保存到文件
33 f = open("obj_msg.data", "w", encoding="utf-8")
34 f.write(str(new_list))
35 f.close()
36 # 5. 读取上一题中文件中的数据，
37 # 把 [{"name": "李四", "age": 20}, {"name": "李四", "age": 20}]
38 # 转成 [p1, p2]
39 f = open("obj_msg.data", "r", encoding="utf-8")
40 new_obj_list = eval(f.read())
41 f.close()
42 print(new_obj_list)
43 last_obj_list = [Person(**obj_dict) for obj_dict in new_obj_list]
44 print(last_obj_list)学生管理系统-面向对象版：
1.创建student_system包
2.在student_system包中创建studnet_model.py：
class Student(object):
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex3.在student_system包中创建student_system_model.py：
import os
from student_system import student_model
class StudentSystem(object):
def __init__(self):
# 定义类属性的学生列表
self.student_list = [] # list()
# 显示功能菜单
@staticmethod
def show_menu():
print("----学生管理系统V1.0----")
print("1. 添加学生")
print("2. 修改学生")
print("3. 删除学生")
print("4. 查询学生")
print("5. 显示所有学生")
print("6. 退出")
# 添加学生的功能方法
def add_student(self):
name = input("请输入您的姓名:")
age = input("请输入您的年龄:")
sex = input("请输入您的性别:")
stu = student_model.Student(name, age, sex)
self.student_list.append(stu)
print("添加成功")
# 显示所有学生的功能方法
def show_all_student(self):
for index, stu in enumerate(self.student_list):
# 学号 = 下标 + 1
num = index + 1
print("学号: %d 姓名: %s 年龄: %s 性别: %s" % (num,
stu.name,
stu.age,
stu.sex))
# 修改学生信息的功能方法
def modify_student(self):
for index, stu in enumerate(self.student_list):
# 学号 = 下标 + 1
num = index + 1
print("学号: %d 姓名: %s 年龄: %s 性别: %s" % (num,
stu.name,
stu.age,
stu.sex))
student_no = int(input("请输入您要修改学生信息的学号:"))
# 根据学号计算对应的下标
index = student_no - 1
# 判断index是否是一个合法的下标
if 0 <= index < len(self.student_list):
# 根据下标获取要修改的学生字典
stu = self.student_list[index]
# 接收用户输入的最新数据
new_name = input("请输入您修改后的姓名:")
new_age = input("请输入您修改后的年龄:")
new_sex = input("请输入您修改后的性别:")
# 修改指定字典里面的信息
stu.name = new_name
stu.age = new_age
stu.sex = new_sex
print("修改成功!")
else:
print("请输入合法学号!")
# 删除学生信息的功能方法
def remove_student(self):
for index, stu in enumerate(self.student_list):
# 学号 = 下标 + 1
num = index + 1
print("学号: %d 姓名: %s 年龄: %s 性别: %s" % (num,
stu.name,
stu.age,
stu.sex))
student_no = int(input("请输入要删除学生的学号:"))
# 根据学号计算对应下标
index = student_no - 1
# 判断index是否是一个合法的下标
if 0 <= index < len(self.student_list):
# 根据下标删除学生列表中的数据
del self.student_list[index]
print("删除成功!")
else:
print("请输入合法的学号!")
# 查询学生的功能方法
def query_student(self):
name = input("请输入您要查询学生的姓名:")
# 遍历学生列表，获取每一个学生字典信息
for index, stu in enumerate(self.student_list):
# 根据学生字典取出姓名，判断是否和用户输入的姓名一致
if stu.name == name:
# 生成学号
num = index + 1
print("学号: %d 姓名: %s 年龄: %s 性别: %s" % (num,
stu.name,
stu.age,
stu.sex))
break
else:
print("对不起，您查询的学生信息不存在!")
# 保存学生对象列表数据到文件
def save_data(self):
with open("student_list.data", "w", encoding="utf-8") as file:
student_dic_list = [stu.__dict__ for stu in self.student_list]
# print(student_dic_list)
file.write(str(student_dic_list))
# 加载缓存文件中的历史数据
def load_data(self):
# 判断文件是否存在
if os.path.exists("student_list.data"):
with open("student_list.data", "r", encoding="utf-8") as file:
stu_dict_list = file.read()
new_stu_list = [Student(**stu_dict) for stu_dict in eval(stu_dict_list)]
self.student_list.extend(new_stu_list)
# 程序启动的入口方法
def start(self):
# 加载历史数据，只加载一次即可
self.load_data()
while True:
# 显示功能菜单
self.show_menu()
# 2. 接收用户输入的功能选项
menu_option = input("请输入您需要的功能选项:")
# 3. 判断用户输入的功能选项
if menu_option == "1":
# print("执行添加学生的功能")
self.add_student()
elif menu_option == "2":
# print("执行修改学生的功能")
self.modify_student()
elif menu_option == "3":
# print("执行删除学生的功能")
self.remove_student()
elif menu_option == "4":
# print("执行查询学生的功能")
self.query_student()
elif menu_option == "5":
# print("执行显示所有学生的功能")
self.show_all_student()
elif menu_option == "6":
print("退出系统")
# 退出程序之前，保存数据到文件
self.save_data()
break4.创建main模块：
from student_system import studnet_system_model sys = studnet_system_model.StudentSystem() sys.start()
基础班考试题：
# 1.定义一个Person类
# 1)属性:姓名name,体重weight
#
# 2)方法：init方法
import random
class Person(object):
def __init__(self, name, weight):
self.name = name
self.weight = weight
# 2.在Person类外面完成以下要求：
#
# 1)创建四个对象（"牛一",60 ; "陈二",55 ; "张三",70 ; "王五",65 ),
# 将这四个对象添加到列表。
n1 = Person("牛一", 60)
c2 = Person("陈二", 55)
z3 = Person("张三", 70)
w5 = Person("王五", 65)
person_list = []
person_list.append(n1)
person_list.append(c2)
person_list.append(z3)
person_list.append(w5)
# 2).获取60-70之间的随机数作为体重标准线（包含60和70）,
# 遍历列表将体重大于等于体重标准线的元素写入健康体重名单health.txt。格式如下：
# 姓名:牛一 体重:60 状态:健康
#
# 姓名:张三 体重:70 状态:健康
#
# 姓名:王五 体重:65 状态:健康
# def write_dict(name, weight):
# return "姓名：" + name + " 体重：" + str(weight) + " 状态:健康\n"
with open("health.txt", "w", encoding="utf-8") as file:
# prn_dict_list = [prn.__dict__ for prn in person_list if prn.weight > random.randint(60, 70)]
# new_list = [write_dict(**prn_dict) for prn_dict in prn_dict_list]
# for data in new_list:
# file.write(str(data))
new_list = [prn for prn in person_list if prn.weight > random.randint(60, 70)]
for prn in new_list:
new_str = "姓名：" + prn.name + " 体重：" + str(prn.weight) + " 状态:健康\n"
file.write(new_str) 1 # 提示用户循环录入字符串，直到输入的字符串以's'结尾时结束录入，
2 # 将录入的字符串存入列表，遍历列表，将列表中以'a'开头的字符串打印到控制台。
3
4 my_list = []
5 while True:
6 my_str = input("请输入字符串：")
7
8 if my_str.endswith('s'):
9 my_list.append(my_str)
10
11 new_lsit = [str_msg for str_msg in my_list if str_msg.startswith('a')]
12 for data in new_lsit:
13 print(data)
14 break
15 elif my_str.startswith('a'):
16 my_list.append(my_str)