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 = 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 == "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()
                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)
 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)
posted @ 2019-11-13 22:41  老王同鞋  阅读(1376)  评论(4)  编辑  收藏  举报