本博客采用思维导图式笔记，所有思维导图均为本人亲手所画。因为本人也是初次学习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模块实现猜拳游戏：
import random
player = int(input("请出拳：石头（1)、剪刀（2）、布（3）："))
computer = random.randint(1, 3)
print(computer)
if (player == 1 and computer == 2) or \
(player == 2 and computer == 3) or \
(player == 3 and computer == 1):
print("你赢了")
elif player == computer:
print("平局")
else:
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)
字符串的格式化输出：
# 字符串的格式化输出: 把字符串里面的内容按照指定的数据类型进行输出显示 # 学习字符串格式化的目的：以后字符串里面的内容有动态内容时，需要使用字符串的格式化 # 格式化占位符:
# %d 表示格式化显示整型数字
# %f 表示格式化显示小数
# %s 表示格式化显示字符串 # 字符串的内容进行了格式化
# 注意点：如果字符串里面有多个格式化占位符，那么多个参数在进行传参的时候，需要加上小括号
msg = "姓名: %s 年龄: %d" % ("王五", 22)
# 输出格式化后的字符串
print(msg) # 如果字符串中只有一个格式化占位符，在进行传参的时候，参数不需要加上小括号
info = "性别: %s" % "男"
print(info, type(info))
print("性别: %s" % "男") pi = 3.16
# %f 默认保留6位小数
# print("圆周率: %f" % pi)
# 注意点格式化占位符会进行四舍五入
print("圆周率: %.2f" % pi) # 格式化占位符的注意点: 扩展： student_no = 123 # %03d: 正数要求是3位，不够三位前面补0
print("学号:%03d" % student_no) # 格式化占位符结合百分号一起使用的时候，两个百分号表示一个
print("百分比: %d%%" % 50) # 定义整数变量 student_no ，输出 我的学号是 000001
student_no = 1
print("我的学号为: %06d" % student_no) # 定义⼩数 price 、 weight 、 money ，输出 苹果单价 9.00 元／⽄，购买了 5.00 ⽄，需要⽀付 45.00 元
price = 9.0
weight = 5.0
money = 45.0
print("苹果单价%.2f 元／⽄，购买了 %.2f ⽄，需要⽀付 %.2f 元" % (price, weight, money))
f-string的使用：
# fstring：用来给字符串动态绑定数据
# fstring的使用语法格式:
# f"姓名: {'李四'} 年龄: {20}"
name = "李四"
age = 20
info = f"姓名:{name} 年龄:{age}"
print(info, type(info))
info = f"姓名:{'王三'} 年龄:{20}"
print(info, type(info))
# 3 + 4 = 7
num1 = float(input("请输入第一个数字:"))
num2 = float(input("请输入第二个数字:"))
result = F'{num1} + {num2} = {num1 + num2}'
print(result)
# 总结： fstring只能在python3.6及以上版本才能使用，如果兼容之前的代码可以使用字符串的格式化输出
学生信息管理系统（文件版）：
student_list = [] # 定义一个空列表，用来保存用户输入的学生信息 def menu(): # 定义函数用于菜单输出
print("------------------------------")
print("----欢迎使用学生信息管理系统------")
print("----1.显示学生信息--------------")
print("----2.添加学生信息--------------")
print("----3.删除学生信息--------------")
print("----4.修改学生信息--------------")
print("----5.保存学生信息--------------")
print("----6.退出学生信息系统-----------")
print("------------------------------") def menu_msg(): # 定义函数用于获取用户选择的功能
menu()
user = int(input("请输入需要的功能代码："))
if user == 1:
show_msg() # 学生信息显示函数
elif user == 2:
add_msg() # 添加学生信息函数
elif user == 3:
del_msg() # 删除学生信息函数
elif user == 4:
modify_msg() # 修改学生信息函数
elif user == 5:
save_msg() # 保存学生信息函数
elif user == 6:
print("欢迎下次使用本系统！")
exit() # 结束程序 def show_msg(): # 显示学生信息函数
if len(student_list) > 0:
for data in student_list:
# 通过循环将列表中数据输出
print(data)
else:
print("系统中无学生信息！")
menu_msg() def add_msg(): # 添加学生信息函数
name = input("请输入学生姓名：")
age = input("请输入学生年龄：")
sex = input("请输入学生性别：")
# 使用字典保存用户输入的学生信息
student_dict = {"name": name, "age": age, "sex": sex}
student_list.append(student_dict)
print("添加成功！")
user = input("是否继续添加学生信息（是：y或Y，否：N或n）：")
if user == 'y' or user == 'Y':
add_msg()
elif user == 'n' or user == 'N':
menu_msg()
else:
print("非法数据")
exit() def del_msg(): # 删除学生信息函数
# 通过enumerate方法给字典中存储的学生信息分配一个学号
for index, dict in enumerate(student_list):
print(f"学号是:{index + 1 },其余信息为：{dict}")
student_no = int(input("请输入学生学号："))
# 判断用户输入的索引是否在0-len(student_list)内
# student_no - 1 是因为显示学号是将索引+1了
if student_no >= 0 and student_no - 1 < len(student_list):
del student_list[student_no - 1]
print("恭喜您删除学生信息成功！")
else:
print("您输入的学号不存在！")
menu_msg() def modify_msg(): # 修改学生信息函数
# 通过enumerate方法给字典中存储的学生信息分配一个学号
for index, dict in enumerate(student_list):
print(f"学号是:{index + 1 },其余信息为：{dict}")
student_no = int(input("请输入学生学号："))
if 0 <= (student_no - 1) < len(student_list):
# 通过列表[索引号]["键名"] 对存储在列表中字典里的数据进行修改
student_list[student_no - 1]["name"] = input("请输入学生姓名：")
student_list[student_no - 1]["age"] = input("请输入学生年龄：")
student_list[student_no - 1]["sex"] = input("请输入学生性别：")
print("修改学生信息成功")
else:
print("您输入的学号不存在！")
menu_msg() def save_msg(): # 保存数据函数
# 将列表所存储的信息通过类型转换写入txt文件中
f = open("student.txt", "w")
student_str = str(student_list)
f.write(student_str)
f.close()
menu_msg() menu_msg()
列表的嵌套使用：
# 已知列表 my_list = [["李三", 20], ["王五", 22], ["刘三", 30]] ，
# 1. 对该列表进行过滤获取年龄大于20的列表
# 比如: [["王五", 22], ["刘三", 30]]
my_list = [["李三", 20], ["王五", 22], ["刘三", 30]]
new_list = []
for value in my_list:
if value[1] > 20:
new_list.append(value)
print(new_list) # 2. 对该列表进行过滤获取名字结尾叫'三'的列表
# 比如: [["李三", 20], ["刘三", 30]] my_list = [["李三", 20], ["王五", 22], ["刘三", 30]]
new_list = [] for data in my_list:
if data[0][-1] == '三':
new_list.append(data)
print(new_list)
# 使用列表嵌套，完成8名老师随机分配3个办公室
import random
office = [[], [], []]
teacher = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] for value in teacher:
office[random.randint(0,2)].append(value) print(office)
# 将8个老师随进分配到3个办公室，
# 每个办公室至少有一个人 import random office_list = [[], [], []] teacher_list = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] while True:
for teacher in teacher_list:
index = random.randint(0, 2)
office_list[index].append(teacher) print(office_list) num = 1
for office in office_list:
print("第%d个办公室有%d人" % (num, len(office)))
for teacher in office:
print(teacher)
num += 1 if len(office_list[0]) == 0 or len(office_list[1]) == 0 or len(office_list[2]) == 0:
continue
else:
break
#
# # 进阶版 import random office_list = [[], [], []] teacher_list = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] while True:
for teacher in teacher_list:
index = random.randint(0, 2)
office_list[index].append(teacher) print(office_list) for index, office in enumerate(office_list):
print("第%d个办公室有%d人" % (index + 1, len(office)))
for teacher in office:
print(teacher) if len(office_list[0]) == 0 or len(office_list[1]) == 0 or len(office_list[2]) == 0:
continue
else:
break
列表结合random使用：
从键盘中输入5个学生的名字，存储到列表中，然后打印出每个学生名字中的第2个字母
name_list = []
for _ in range(5):
name = input("请输入学生姓名：")
name_list.append(name) for index in range(len(name_list)):
print(name_list[index][1]) 从键盘获取5个学生的名字，然后随机抽出一名学生去打扫卫生
import random name_list = []
for _ in range(5):
name = input("请输入学生姓名：")
name_list.append(name) print("%s打扫卫生！" % name_list[random.randint(0, len(name_list))])
练习enumerate函数的使用:
# enumerate：使用for循环遍历容器类型数据时，
# 既要下标又要数据可以结合enumerate函数来使用 # 将自定义的列表输出并输出每个数据的下标 my_list = ['a', 'b', 'c', 'd', 'e', 'f'] for index, value in enumerate(my_list):
print(index, value)
字典的应用：
# 编程：
# 使用字典来存储一个人的信息
# （姓名、年龄、学号、QQ、微信、住址等），
# 这些信息来自 键盘的输入 msg_dict = {} name = input("请输入您的姓名：")
age = int(input("请输入您的年龄："))
student_no = input("请输入您的学号：")
QQ = input("请输入您的QQ：")
VX = input("请输入您的微信：")
address = input("请输入您的住址：") msg_dict["name"] = name
msg_dict["age"] = age
msg_dict["student_no"] = student_no
msg_dict["QQ"] = QQ
msg_dict["VX"] = VX
msg_dict["address"] = address print(msg_dict)
1. 使用程序描述一个学生信息，
# 接收信息包含姓名、年龄、喜欢的书籍
# (西游记、红楼梦、三国演义、水浒传) my_dict = {}
book_list = []
name = input("请输入您的姓名：")
age = int(input("请输入您的年龄：")) my_dict["name"] = name
my_dict["age"] = age
book = int(input("请输入你喜欢书的个数（1-4）：")) if 1 <= book <= 4:
for value in range(book):
book_list.append(input("请输入你喜欢的第%d本书的名字：" % (value + 1))) my_dict["books"] = book_list
print(my_dict) # 2. 已知 my_list = [{'name': '李四', 'age': 20},
# {'name': '王五', 'age': 22}]
# 过滤出来年龄大于20的数据， 比如: [{'name': '王五', 'age': 22}] my_list = [{'name': '李四', 'age': 20},
{'name': '王五', 'age': 22}]
new_list = []
for dict in my_list:
if dict['age'] > 20:
new_list.append(dict)
print(new_list) # 3. 使用函数完成对第1道题的开发 def books():
my_dict = {}
book_list = []
name = input("请输入您的姓名：")
age = int(input("请输入您的年龄：")) my_dict["name"] = name
my_dict["age"] = age
book = int(input("请输入你喜欢书的个数（1-4）：")) if 1 <= book <= 4:
for value in range(book):
book_list.append(input("请输入你喜欢的第%d本书的名字：" % (value + 1))) my_dict["books"] = book_list
print(my_dict) books()
字符串、列表、字典的综合应用：
# 字符串、列表、字典综合应用
# 设计一个程序
# 要求用户可以实现登录、注册、注销登录等功能
# 用户的用户名(长度6-20)、密码(长度8-20)、昵称、年龄信息保存到字典中
# 将每个已注册用户的保存到列表中，即将上一步的字典保存到列表中
# 维护用户的登录状态，每次只能有一个用户处于登录状态，直到选择注销登录
# 如果不选择退出系统，该程序应当一直运行 user = [] user_dict = {}
while True:
print("1.登录")
print("2.注册") user_chose = int(input("请输入您想要的功能："))
if user_chose == 1:
user_name = input("请输入您的用户名：")
password = input("请输入您的密码：")
if user_name == user_dict["user_name"] and password == user_dict["password"]:
print("登陆成功")
user_chose = input("是否注销登陆：是y或Y")
user_chose = user_chose.upper()
if user_chose == 'Y':
print("注销成功！")
break
else:
print("用户名或密码错误！")
elif user_chose == 2:
user_name = input("请输入您的用户名(长度6-20)：")
password = input("请输入您的密码(长度8-20)：")
name = input("请输入您的昵称：")
age = input("请输入您的年龄：")
if 6<= len(user_name) <= 20 and 8 <= len(password)<= 20:
user_dict["user_name"] = user_name
user_dict["password"] = password
user_dict["name"] = name
user_dict["age"] = age
user = user_dict
else:
print("请输入正确长的用户名或密码！")
continue
else:
print("非法数据")
continue
不定长位置参数和不定长关键字参数使用：
# 使用不定长位置参数、不定长关键字参数完成多个数的平均值计算 def sum_num(*aegs, **kwargs):
num_sum = 0
for value in kwargs.values():
num_sum += value for value in aegs:
num_sum += value return num_sum def avg_sum(*args, **kwargs):
num_sum = sum_num(*args, **kwargs)
avg_num = num_sum / (len(args) + len(kwargs))
return avg_num result = avg_sum(1, 2, 3, 4, a=1, b=2, c=3, d=4) print(result)
# 使用不定长参数定义一个函数max_min，
# 接受的参数类型是数值，
# 最终返回这些数中的最大值和最小值 def max_min(*args):
return max(args), min(args) max_value, min_value = max_min(1, 2, 3, 4, 5, 67, 7, 235, 53, 3)
print(max_value, min_value)
# 分别定义加减乘除四个函数实现两个数之间的加减乘除操作 def add(a, b):
return a + b def jian(a, b):
return a - b def cheng(a, b):
return a * b def chu(a, b):
return a / b value1 = add(1, 2)
value2 = jian(2, 1)
value3 = cheng(4, 2)
value4 = chu(5, 6) print(value1, value2, value3, value4)
# 定义一个函数min，接受的参数类型是数值，最终返回两个数中的最小值
def min_values(num1, num2):
result = num1,num2
value = min(result)
return value min_value = min_values(666,787)
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)
# 定义一个使用不定长参数的函数，并在函数中打印出参数及其类型，统计传入参数的个数
def show(*args):
print(args, type(args), len(args)) show(1, 2, 34, 5, 6, 7, 8, 9) def show(**kwargs):
print(kwargs, type(kwargs), len(kwargs)) show(a=1, b=2, c=3, d=4)
# 定义一个函数cut_str，
# 接受三个参数，
# 分别为字符串s、数值a1、数值a2，
# 将字符串s从下标a1开始的a2个字符删除，
# 并把结果返回 #
def cut_str(s="", a1=0, a2=-1):
result = s[a1:a2]
new_str = s.replace(result, "")
return new_str result = cut_str("abcdweasfsajfgjas",2,4)
print(result)
♥对find()方法进行扩充：
# 1.定义函数findall，
# 实现对字符串find方法的进一步封装，
# 要求返回符合要求的所有位置的起始下标，
# 如字符串"helloworldhellopythonhelloc++hellojava"，
# 需要找出里面所有的"hello"的位置，
# 最后将返回一个元组(0,10,21,29)，
# 即将h的下标全部返回出来，
# 而find方法只能返回第一个 def findall(str="", chr=""):
# 定义一个列表用于存储找到的索引值
find_list = []
# 执行循环，循环次数为指定字符在字符串中出现的次数
for value in range(str.count(chr)):
# 定义变量用于存储指定字符对应的索引
find_count = str.find(chr)
# find_count + len(chr) * value ：
# 除第一次找到指定字符串的索引外，
# 其余次数均要加上替换掉的字符串的长度，
# 才能够获取到指定字符在最初字符串中最初的索引
find_list.append(find_count + len(chr) * value) # 将索引追加到列表中
# 去除已经找到的指定字符串
str = str.replace(chr, "", 1)
return find_list result = findall("helloworldhellopythonhelloc++hellojava", "hello") print(result)
函数的递归调用：
# 使用递归函数求n的阶乘 def calc_num(num):
# 函数递归调用是必须要有结束条件
if num == 1:
return 1
else:
return num * calc_num(num - 1) result = calc_num(5)
print(result) # 使用递归的方法打印出前n个斐波那契数列
# 斐波那契数列起始数字为0和1，之后每个数都是前两个数之和,比如:0,1,1,2,3,5,8,...
# 0 1 1 2 3 5 8 13 21 .... num_list = [0,1] def fbnq_num(n):
if n == 2:
return num_list
else:
# 将列表中最后两个数的和相加后追加到列表后
num_list.append(num_list[-1]+ num_list[-2])
return fbnq_num(n-1) result = fbnq_num(9)
print(result)
Python中对文件的操作练习：
# 文件的相关操作、练习及应用
# 创建一个新项目中新创建一个名字py文件夹
import os
my_dir = os.mkdir("文件操作")
# 进入py文件夹中创建5个文件，文件名分别为
# python-06基础班-1.txt，
# python-06基础班-2.txt，
# python-06基础班-3.txt，
# python-06基础班-4.txt，
# python-06基础班-5.txt
for value in range(5):
f = open(f"文件操作/python-06基础班-{value+1}.txt","w")
f.close()
# 然后将py文件夹中的所有文件都改名为
# [黑马]python-06基础班-1.txt，
# [黑马]python-06基础班-2.txt，
# [黑马]python-06基础班-3.txt，
# [黑马]python-06基础班-4.txt，
# [黑马]python-06基础班-5.txt
for value in range(5):
f = os.rename(f"文件操作/python-06基础班-{value+1}.txt",f"文件操作/[黑马]python-06基础班-{value+1}.txt")
# 编写一段代码以完成两份文件之间的相互备份
import os
# 在python用户目录下创建python基础班文件夹
os.mkdir("python基础班")
# 在文件夹中创建gailun.txt文件
# 打开文件在gailun.txt中写入"德玛西亚！人在塔在！"
f = open("python基础班/gailun.txt", "w")
f.write("德玛西亚！人在塔在！")
f.close()
# 在文件夹中创建gailun副本.txt文件
f = open("python基础班/gailun副本.txt", "w")
# 将gailun.txt文件中的数据写入gailun副本.txt文件中
f1 = open("python基础班/gailun.txt", "r")
# .read()将文件内容读取并返回字符串
# .readlins()将文件内容读取并返回列表
result = f1.readline()
f1.close()
f.write(result)
f.close()
print(result, type(result))
# 打开文件，查看文件中是否有内容
继承的应用：
# 1. 定义一个Student类，统计Student类创建的实例(对象)个数, 使用属性返回创建实例的个数
class Studnet(object):
obj_num = 0 def __init__(self):
Studnet.obj_num += 1
print("实例个数：", Studnet.obj_num) s1 = Studnet()
s2 = Studnet()
# 2. 定义一个Person类，添加两个实例属性(name, age),
# 创建两个实例对象添加到列表里面, 例如: [p1, p2]
obj_list = [] class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age p1 = Person("李四", 20)
obj_list.append(p1)
p2 = Person("王超", 22)
obj_list.append(p2)
print(obj_list)
# 3. 把列表中的person对象改成列表中的字典,
# 例如: [{"name": "李四", "age": 20}, {"name": "李四", "age": 20}]
new_list = [obj.__dict__ for obj in obj_list]
print(new_list)
# 4. 把该数据[{"name": "李四", "age": 20}, {"name": "李四", "age": 20}]保存到文件
f = open("obj_msg.data", "w", encoding="utf-8")
f.write(str(new_list))
f.close()
# 5. 读取上一题中文件中的数据，
# 把 [{"name": "李四", "age": 20}, {"name": "李四", "age": 20}]
# 转成 [p1, p2]
f = open("obj_msg.data", "r", encoding="utf-8")
new_obj_list = eval(f.read())
f.close()
print(new_obj_list)
last_obj_list = [Person(**obj_dict) for obj_dict in new_obj_list]
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 = sex
3.在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 == "":
# print("执行添加学生的功能")
self.add_student()
elif menu_option == "":
# print("执行修改学生的功能")
self.modify_student()
elif menu_option == "":
# print("执行删除学生的功能")
self.remove_student()
elif menu_option == "":
# print("执行查询学生的功能")
self.query_student()
elif menu_option == "":
# print("执行显示所有学生的功能")
self.show_all_student()
elif menu_option == "":
print("退出系统")
# 退出程序之前，保存数据到文件
self.save_data()
break
4.创建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)
# 提示用户循环录入字符串，直到输入的字符串以's'结尾时结束录入，
# 将录入的字符串存入列表，遍历列表，将列表中以'a'开头的字符串打印到控制台。 my_list = []
while True:
my_str = input("请输入字符串：") if my_str.endswith('s'):
my_list.append(my_str) new_lsit = [str_msg for str_msg in my_list if str_msg.startswith('a')]
for data in new_lsit:
print(data)
break
elif my_str.startswith('a'):
my_list.append(my_str)
