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模块实现猜拳游戏：

 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)