python练习题

原创已于 2025-03-25 15:57:54 修改 · 188 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#python

于 2023-10-30 20:40:02 首次发布

Python 专栏收录该内容

3 篇文章

订阅专栏

#coding=utf-8

## if条件判断
## 练习1：小明身高1.75，体重80.5kg。请根据BMI公式（体重除以身高的平方）
# 帮小明计算他的BMI指数，并根据如下BMI指数，判断胖瘦情况
   # 低于18.5：过轻
   # 18.5-25：正常
   # 25-28：过重
   # 28-32：肥胖
   # 高于32：严重肥胖

'''
high = 1.75
weight = 80.5
BMI = weight / (high ** 2)
if BMI < 18.5:
print("过轻")
elif BMI >= 18.5 and BMI < 25:
print("正常")
elif BMI >= 25 and BMI < 28:
print("肥胖")
else:
print("严重肥胖")
'''

## if条件判断
## 练习2：一个程序读入3个数，把这三个数值看作一个三角形的3条边的长度值。
# 这个程序要打印出信息，说明这个三角形是普通的、是等腰的、还是等边的，
# 如果构不成三角形，则提示输入有误。

'''
a = int(input("请输入第1个整数："))
b = int(input("请输入第2个整数："))
c = int(input("请输入第3个整数："))
if a > 0 and b > 0 and c > 0 and a+b > c and a+c > b and b+c > a:
if a == b == c:
print("等边三角形")
elif a == b or b == c or a == c:
print("等腰三角形")
else:
print("普通三角形")
else:
print("输入有误，无法构成三角形")
'''

## while循环
## 练习3：求100以内的奇数之和 99+97+95+93+92+91......1
'''
a = 100
total = 0
while a >0:
if a % 2 == 1:
# print(a)
total = total + a
# print(total)
a -= 1
print(total)
'''

## while循环
## 练习4：使用while循环，创建一个包含1到100以内奇数的列表
'''
a = 1
list1 = []
while a <= 100:
if a % 2 != 0:
# print(a)
list1.append(a)
a += 1
print(list1)
'''

## for循环
## 练习5：用for循环，求1到100的偶数的和
'''
total = 0
for i in range(2,101,2):
# print(i)
total = total + i
print(total)

#方法2：
total2 = 0
for j in range(1,101):
if j % 2 == 0:
total2 = total2 + j
print(total2)

#方法3：一行代码打印1到100的偶数的和
print(sum(range(2,101,2)))
'''

## 列表推导式
## 练习6：把1-10写入列表
'''
list1 = [i for i in range(1,11) ]
print(list1)
'''

## 列表推导式
## 练习7：把1到10之间的偶数写入列表
'''
list2 = [j for j in range(1,11) if j % 2 == 0 ]
print(list2)
'''

## 列表推导式
## 练习8：列表推导式求所有奇数并构造新列表，a = [1,2,3,4,5,6,7,8,9,10]
'''
a = [1,2,3,4,5,6,7,8,9,10]
list3 = [i for i in a if i % 2 == 1]
print(list3)
'''

## 列表推导式
## 练习9：有个包含0和1的字符串，求出连续的0或连续的1的最大值
'''
str1 = '11111111110010000000000001111011'
# print(str1.split('1'))
list1 = []
for i in str1.split('1'): #指定字符串切割
list1.append(len(i))
# print(list1) #打印每个元素的长度
print("连续的0最大值是",max(list1))

#方法2
str1 = '11111111110010000000000001111011'
# print(str1.split('1'))
max1 = max([len(i) for i in str1.split('0')])
print("连续的1的最大值是",max1)

max0 = max(len(j) for j in str1.split('1'))
print("连续的0的最大值是{}".format(max0))
print(f"连续的0的最大值是{max0}")
'''

## 列表推导式
## 练习10：s='2020 8 11 23 5 59 8 6 999',将s变成'202008112305590806999',
# 即不足2位的补0，最终连起来
'''
s = '2020 8 11 23 5 59 8 6 999'
list0 = []
for i in s.split(" "):
if len(i) < 2:
list0.append("0" + i)
else:
list0.append(i)
# print(list0)
s1 = "".join(list0)
print(s1)

#方法2，列表推导式
s = '2020 8 11 23 5 59 8 6 999'
s2= "".join(["0" + i if len(i) <2 else i for i in s.split(" ")])
print(s2)
'''

## 列表去重
## 练习11：写出代码，要求删除列表里面的重复元素
'''
list1 = [1,2,2,3,3,3,4,5]
list2 = []
for i in list1:
if i not in list2:
list2.append(i)
print(list2)
'''

## for循环嵌套
## 练习12：二次嵌套循环：九九乘法口诀表
'''
for i in range(1,10):
for j in range(1,i+1):
print("%d*%d=%d"%(j,i,j*i),end = "\t")
print()
'''

## for循环嵌套
## 练习13.冒泡排序：列表lst=[3,8,2,12,56,9]，把列表中的数据由高到低排序。
'''
lst = [3,8,2,12,56,9]
num = len(lst)
for i in range(num-1): #外层循环控制对比轮次
for j in range(num-i-1): #内层循环表示每轮的对比次数
if lst[j] < lst[j+1]:
lst[j],lst[j+1] = lst[j+1],lst[j]
print(lst)
'''

## 字典根据值获取键
## 练习14：字典，通过指定的值，获取字典的键
'''
#方法一：使用for循环
dict3 = {'key1':'a', 'key2':'b','key3':'c'}
for k in dict3.keys():
if dict3.get(k) == 'b':
print("b对应的key是：",k)

#方法二：使用列表[下标]
print(list(dict3.keys())[list(dict3.values()).index("b")])
'''

## 字典推导式
## 练习15：有一个字典{"数学":89,"英语":70,"物理":90,"化学":78}，
# 获取分数最高的学科
'''
#方法一，使用字典推导式
dict5 = {"数学":89,"英语":70,"物理":90,"化学":78}
dict6 = {k:v for k,v in dict5.items() if v == max(list(dict5.values()))}
print(dict6)

#方法二，使用for循环
dict7 = {}
for k,v in dict5.items():
if v == max(list(dict5.values())):
dict7[k] = v
print(dict7)
'''

## 集合推导式
## 练习16：获取1到10的偶数，并加入到集合中
'''
#方法一，使用for循环
set1 = set()
for i in range(1,11):
if i % 2 == 0:
set1.add(i)
print(set1)
#方法二，使用集合推导式
set2 = {a for a in range(1,11) if a%2==0}
print(set2)
print(set2[1])
'''

## for循环嵌套
## 练习17：请用你所熟悉的程序语言实现求一个整数数组里面两个数之和
# 为183的所有整数对，(例如：输入数组为[183,0,1,2,-184,367]，
# 得到结果为{(183,0),(-184,367)})
'''
list1 = [183,0,1,2,-184,367]
set1 = set()
#外层循环，获取需要和后面的值相加的下标对应的值
for i in range(len(list1)-1):
#内层循环，控制循环的次数，当i增加，内层循环相应减少
for j in range(i+1,len(list1)):
if list1[i] + list1[j] == 183:
# print(list1[i],list1[j])
#集合嵌套元组的形式保存结果
set1.add((list1[i],list1[j]))
print(set1)
'''

## 练习18: 1到9999中，包含数字2的数字共有多少个？
'''
total = 0
for i in range(10000):
if '2' in str(i):
total+=1
print(total)
'''

## 字典、冒泡排序的综合使用
## 练习19：给定一个只包含正整数且非空的数组，返回该数组中
# 重复次数最多的前N个数字（返回结果按重复次数从大到小降序排列，
# N不存在取值非法的情况），试用代码实现该需求
'''
#方法一
list1 = [5,2,5,6,9,8,7,2,1,5,6,2,4,5,8,2,1,2,6]
#统计每个元素的次数，并构造成字典
dict1 = {i:list1.count(i) for i in list1}
# print(dict1)
#将每个键值对转化成列表
list2 = []
for k,v in dict1.items():
list2.append({k:v})
# print(list2)
#按元素出现次数由大到小排列(冒泡排序)
for i in range(len(list2)-1):
for j in range(len(list2)-i-1):
if list(list2[j].values())[0] < list(list2[j+1].values())[0]:
list2[j],list2[j+1] = list2[j+1],list2[j]
# print(list2)
#取前N个（比如前3个）
print(list2[:3])
'''
#方法二，使用匿名函数
'''
list1 = [5,2,5,6,9,8,7,2,1,5,6,2,4,5,8,2,1,2,6]
#统计每个元素的次数，并构造成字典
dict1 = {i:list1.count(i) for i in list1}
# print(dict1)
list2 = list(dict1.items())
# print(list2)
list2.sort(key= lambda tup:tup[1],reverse=True)
# print(list2)
for v in list2[:3]:
print("{}出现{}次".format(v[0],v[1]))
'''

## 字典推导式
## 练习20：给定一个字符串，找出该字符串中出现次数最多的那个字符，
# 并打印出该字符及次数，如输入 aaaabbc，输出 a:4
'''
a = 'aaaabbc'
dict1 = {s:a.count(s) for s in set(a)}
# print(dict1)
dict2 = {k:v for k,v in dict1.items() if v == max(dict1.values())}
# print(dict2)
for k,v in dict2.items():
print(k+":"+str(v))
'''

############################# 03练习#############################

## 练习21：在1到100中随机获取10个唯一的整数
'''
from random import randint
list1 = []
while True:
i = randint(1,100)
if i not in list1:
list1.append(i)
if len(list1) == 10:
break
print(list1)
'''

## 练习22：有一个字典{'key1':'123456','key2':[1,2,3,5,6,8],'k3':'34'},
# 检查传入的每个字典的长度，如果长度大于2的话，
# 保留前两个长度的内容，并将新内容返回给调用者。
'''
def test(arg):
dict1={}
for key,value in arg.items():
if len(value) > 2:
dict1[key]=value[0:2]
else:
dict1[key]=value
return dict1
dict1={'key1':'123456','key2':[1,2,3,5,6,8],'k3':'34'}
print(test(dict1))
'''

## 冒泡排序
## 练习23：定义一个my_min()函数，限定输入参数类型是list[int]。
# 实现输入任意整数型列表，输出列表中的最小值，不能使用python
# 内置的min、sorted、sort等方法，如输入[1,5,4]，输出结果：1
'''
def my_min(lst):
# 先冒泡排序
for i in range(len(lst)-1):
for j in range(len(lst)-i-1):
if lst[j] < lst[j+1]:
lst[j],lst[j+1] = lst[j+1],lst[j]
# 从大到小排序后，取最后一位就是最小值
return lst[-1]
list1 = [1,5,4]
print(my_min(list1))
'''

## 字典推导式
## 练习24：请定义一个lst_to_dict()函数，限定输入参数类型是list[int]。
# 实现输入任意整数型列表，输出此列表中各元素出现个数的字典，不能使用
# python列表的count、index等内置方法。如输入[1,2,3,1,2]，
# 输出结果为{1:2, 2:2, 3:1}。
'''
def lst_to_dict(lst):
return {i:lst.count(i) for i in set(lst)}
list1 = [1,2,3,1,2]
print(lst_to_dict(list1))
'''

## 格式化输出
## 练习25：编写一个函数处理金额类的字符串，保留小数后两位，如输入5元，
# 返回5.00元，输入5.1元，返回5.10元，输入5.12元，返回5.12元，
# 输入5.123元，返回5.12元
'''
def money(num):
return '%.2f元'%num
a = float(input("请输入金额："))
print(money(a))
'''

## TXT文件的读写
## 练习26：把下面的文件内容写到一个文件里面，然后读取文件的内容
# 并计算平均分，文件内容如下:
# 小白,88
# 小黑,90.5
# 小黄,
# 小花,33
'''
#写入文件内容
f = open("../test01.txt","w") # w覆盖写入，不存在就创建
str1 = "小白,88\n小黑,90.5\n小黄,\n小花,33"
f.write(str1)
f.close()
print("文件是否关闭：",f.closed)

#读取文件,用with open方法会自动关闭文件
with open("../test01.txt","r") as f: # r只读模式打开，不能创建
#读取所有的内容，并以列表的形式保存
res = f.readlines()
print("文件是否关闭：",f.closed)
print(res)
total = 0
for i in res:
# print(i)
# strip()移除字符串两端的空格，split()以指定字符切割字符串，
# 切割后保存为列表
res2 = i.strip().split(",")[1]
# print(res2)
if res2 != "":
total = total + float(res2)
#计算平均分
avg = total / len(res)
print(avg)
'''

## Excel文件的读写
## 练习27：有以下列表
# [ ['13058126836','abc123456'],
# ['13058126837','abc123457'],
# ['13058126838','abc123458'],
# ['13058126839','abc123459'] ]
# 请将该列表的数据，输入到excel中，第一列为用户名、第二列为密码
'''
import openpyxl
#创建文件
wb = openpyxl.Workbook()
#打开文件，并激活当前sheet页
sh = wb.active
#写入数据
sh.cell(1,1,"用户名")
sh.cell(1,2,"密码")
accounts = [ ['13058126836','abc123456'],['13058126837','abc123457'],
['13058126838','abc123458'],['13058126839','abc123459'] ]
rownum = 2
colnum = 1
for i in accounts:
print(i)
sh.cell(rownum,colnum,i[0])
sh.cell(rownum,colnum+1,i[1])
#行数下移
rownum = rownum + 1
#保存文件
wb.save("../test02.xlsx")
'''

## 递归算法
## 练习28：从键盘输入一个整数，并求这个整数的阶乘。
'''
def jie(arg):
if arg == 1:
return 1
else:
return arg * jie(arg-1)
num = int(input("请输入一个整数："))
print(jie(num))
'''

## 递归算法
## 练习29.把指定文件夹及子文件夹下面的所有后缀为.py的文件路径
# 找出来，并且按格式“test_序列号_时间戳.py”进行命名，比如
# test_01_20220210112025.py，用递归方法做
'''
import os,time
allFile = []
num = 0
path = os.path.join(os.getcwd(),"找出该文件夹下所有.py的文件")
def get_pyFile(path):
# 列出文件夹下所有文件或目录
files = os.listdir(path)
# print(files)
for file in files:
filepath = os.path.join(path,file)
if os.path.isfile(filepath) == True:
if file.split(".")[1] == 'py':
global num
num +=1
# 构建新文件名
new_name = "brtc_"+str(num)+"_"+\
time.strftime("%Y%m%d%H%M%S",time.localtime())+".py"
# 新文件完整路径
new_filepath = os.path.join(path,new_name)
# 重命名文件
os.rename(filepath,new_filepath)
# 保存所有的py文件
allFile.append(new_filepath)
else:
get_pyFile(filepath)
get_pyFile(path)
print(allFile)
'''

## 练习30：实现注册功能：
#输入：username、password，cpassword
#最多可以输错3次
#3个都不能为空
#用户名长度最少6位，最长20位，用户名不能重复
#密码长度最少8位，最长15位
#两次输入的密码要一致
#注册成功之后，用户名和密码要写到文件(txt文件)里面
#----- PS:三个参数一起输入后，再进行判断
'''
#### 注册
def register(username,password,cpassword):
# 判断用户名、密码及确认密码是否为空
if len(username)!=0 and len(password)!=0 and len(cpassword)!=0:
# 判断用户名长度是否合法
if len(username)>=6 and len(username)<=20:
# 判断用户名是否重复
if username not in getAllUsers():
# 判断密码长度是否合法
if len(password)>=8 and len(password)<=15:
# 判断两次密码是否一致
if password == cpassword:
# 注册，将用户名和密码保存到txt
saveUser(username,password)
return True
else:
return "两次输入的密码要一致。"
else:
return "密码长度最少8位，最长15位。"
else:
return "用户名不能重复。"
else:
return "用户名长度最少6位，最长20位。"
else:
return "用户名、密码和确认密码都不能为空。"

#### 保存数据到TXT文件
def saveUser(username,password):
with open("../test03.txt","a+") as f: # a追加写入，可创建
f.write("%s,%s\n"%(username,password))

#### 获取系统中已存在的用户名
def getAllUsers():
usernames = []
with open("../test03.txt","a+") as f:
for user in f.readlines():
username = user.split(",")[0].strip()
usernames.append(username)
return usernames

####
if __name__ == "__main__":
for times in range(2,-1,-1):
username = input("请输入用户名：")
password = input("请输入密码：")
cpassword = input("请输入确认密码：")
res = register(username,password,cpassword)
if res == True:
print("恭喜你，注册成功！")
break
else:
if times == 0:
print("不好意思，您的错误次数过多，已退出系统。")
else:
print(res + "您还有%s次机会。"%times)
'''

## 练习31：存在一个文件，文件名test.txt，内容如下：
# 01 success
# 02 fail
# 03 fail
# 04 success
# ....
# 使用python语言实现统计该文件有多少success，多少fail
'''
with open("../test.txt","r") as f:
# res = str(f.readlines())
res = f.read()
print("success有%d个，fail有%d个"%(res.count("success"),res.count("fail")))
'''

## 练习32：将test0000~test9999共一万行的账号写入txt文件。
'''
with open("test01.txt","w+") as f: # w覆盖写，可创建
for i in range(10000):
# print("test%04d"%i)
f.write("test%04d\n"%i)
'''

## 练习33：将Excel表格内容全部输出
'''
import openpyxl
wb = openpyxl.load_workbook("../test05.xlsx")
sh = wb.get_sheet_by_name("Sheet")

for row in range(1,sh.max_row+1):
for col in range(1,sh.max_column+1):
print(sh.cell(row,col).value, end="\t")
print()
'''

## 练习34：将两个列表[1,2,3]和["tom","lily","lucy"]按以下格式输出
# 1 tom
# 2 lily
# 3 lucy
'''
list1 = [1,2,3]
list2 = ["tom","lily","lucy"]
for j,k in zip(list1,list2):
print(j,k)
'''

## 练习35：按以下格式将Excel里面内容输出
# name psword
# tom a123456
# lily a123457
# lucy a123458
'''
import xlrd
wb = xlrd.open_workbook("../test06.xls")
sh = wb.sheet_by_name("Sheet1")
nrows = sh.nrows # 获取行数
for i in range(nrows):
print(sh.row_values(i)[0],sh.row_values(i)[1])

# 方法2：使用zip()函数
import xlrd
wb = xlrd.open_workbook("../test06.xls")
sh = wb.sheet_by_name("Sheet1")
for j,k in zip(sh.col_values(0),sh.col_values(1)):
print(j,k)
'''

## 练习36：将以下内容复制到json文件后，按指定格式存放在CSV表格中
## （其中第1列是姓名，第2列是课程）
# { "01": [{"姓名":"tom","课程":"语文"}, {"姓名":"lily","课程":"数学"}],
# "02": [{"姓名":"rofey","课程":"音乐"},{"姓名":"rose","课程":"美术"}],
# "03": [{"姓名":"roy","课程":"政治"}, {"姓名":"fine","课程":"地理"}] }
'''
import json
import pandas # pandas要先安装：pip install pandas
list1 = []
with open("./base_test/json_to_csv.json","r",encoding="utf-8") as f:
res = json.load(f)
# print(res)
for k,v in res.items():
# print(v)
for ele in v:
# print([ele["姓名"],ele["课程"]])
list1.append([ele["姓名"],ele["课程"]])
# print(list1)
# 将列表内容写入CSV文件
columns = ["姓名","课程"]
# DataFrame()是一个表格型的数据结构
data = pandas.DataFrame(list1,columns=columns)
data.to_csv("./base_test/json_to_csv.csv",index=0)
'''

## 练习37：有一json形式的字符串s，使用python将num大于5的id以列表方式返回
"""
import json,jsonpath

def get_id(var):
to_dict = json.loads(s)
# print(to_dict)
num = jsonpath.jsonpath(to_dict,"$..num")
# print(num)
if float(num[0]) >5:
# print(jsonpath.jsonpath(to_dict,"$..id"))
return jsonpath.jsonpath(to_dict,"$..id")
if __name__ == "__main__":
s = '''{
"desc":"this is a goods",
"glist":{
"brand":"smartisan",
"id":"1001",
"num":"8" },
"level":"01"
}'''
# 调用函数
res = get_id(s)
print(res)
"""

## 练习38：现有3行字符串，分别是姓名、手机号、楼栋、单元，
# 用python处理成以下格式：
# 姓名：xxx，电话：xxx，地址：xxx
# 姓名：xxx，电话：xxx，地址：xxx
"""
# 线性代码
s = '''ZhangSan: 13200012345 15 3D
Li Si: 13200012346 27 5B
Wang Wu: 13200012347 20 1C'''
# print(s)
res1 = s.split("\n")
# print(res1)
for ele in res1:
name = ele.split(": ")[0]
# print(name)
res2 = ele.split(": ")[1]
# print(res2)
tel =res2.split(" ")[0]
# print(tel)
addr = res2.split(" ")[1] + " " + res2.split(" ")[2]
print("姓名：%s，电话：%s，地址：%s"%(name,tel,addr))

# 使用函数，提高代码复用性
def get_info(ele):
name = ele.split(": ")[0]
res2 = ele.split(": ")[1]
tel =res2.split(" ")[0]
addr = res2.split(" ")[1] + " " + res2.split(" ")[2]
return "姓名：%s，电话：%s，地址：%s"%(name,tel,addr)

# 以下是主程序入口，调试代码用的，
# __name__里面的内容不会被别的模块调用
if __name__ == "__main__":
list1 = s.split("\n")
for info in list1:
print(get_info(info))
"""

## 练习39：定义一个学生类。
# 类属性：
# 1、姓名：张三
# 2、年龄：18
# 3、成绩：{"语文":85,"数学":90,"英语":65}
#
# 类方法：
# 1、获取学生的姓名：get_name() 返回类型:str
# 2、获取学生的年龄：get_age() 返回类型:int
# 3、返回3门科目中最高分的科目名和对应的分数。get_course()
'''
# 方法一：
class Stu():
name = "张三"
age = 18
score = {"语文":85,"数学":90,"英语":65}
def get_name(self):
return self.name
def get_age(self):
return self.age
def get_course(self):
return {k:v for k,v in self.score.items() \
if v == max(self.score.values())}
s = Stu()
print(s.get_name())
print(s.get_course())
'''

# 方法二：
'''
class Stu():
def __init__(self,name,age,**score):
self.name = name
self.age = age
self.score = score
def get_name(self):
return self.name
def get_age(self):
return self.age
def get_course(self):
return {k:v for k,v in self.score.items() \
if v == max(self.score.values())}
name = input("请输入学生姓名：")
age = int(input("请输入学生年龄："))
Chinese = float(input("请输入语文成绩："))
Math = float(input("请输入数学成绩："))
English = float(input("请输入英语成绩："))
score = {"语文":Chinese,"数学":Math,"英语":English}
s = Stu(name,age,**score)
print(s.get_name())
print(s.get_age())
print(s.get_course())
'''

## 练习40：学生分数查询系统。学生分数在excel表格中以以下方式存放:
# 第一列是姓名，第二列是语文成绩，第三列是数学成绩，第四列是语文成绩。
# 输入查询的学生的名字，就可以把该学生的所有科目的考试成绩显示出来；
# 如果学生名字不存在，就提示：您查询的学生不存在。使用面向对象的方法完成。
'''
# 方法一：线性代码
import xlrd
wb = xlrd.open_workbook("./base_test/学生成绩表.xls")
sh = wb.sheet_by_index(0)
# 获取所有学生姓名
names = sh.col_values(0)
print(names)
# 确定用户所在的行
name = input("请输入学生姓名：")
row = 0
for i in names:
if i == name:
break
else:
row = row +1
if len(names) == row:
print("用户不存在。")
else:
res = sh.row_values(row)
print("%s的语文成绩是%s，数学成绩是%s，英语成绩是%s"\
%(res[0],res[1],res[2],res[3]))
'''
'''
# 方法二：面向对象
# 比如客户到公司找人，会询问前台，前台找部门经理，部门经理找人事
# 前台stuInfoSys()，部门经理GetStu()，人事Resd_excel()
import xlrd

class Read_excel():
# 初始化Excel
def __init__(self,excel="./base_test/学生成绩表.xls",sheetName="Sheet1"):
# 打开excel表格
wb = xlrd.open_workbook(excel)
self.sh = wb.sheet_by_name(sheetName)

# 获取所有学生姓名
def _getNames(self):
return self.sh.col_values(0)

# 获取指定学生姓名所在行
def _get_row(self,stuName):
res = self._getNames()
if stuName not in res:
return False
else:
return res.index(stuName)

# 获取指定学生整行信息
def get_score(self,stuName):
res = self._get_row(stuName)
if res == False:
return False
else:
return self.sh.row_values(res)

class GetStu():
def __init__(self):
self.r = Read_excel()

def get_info(self,stuName):
res = self.r.get_score(stuName)
if res == False:
return "用户不存在。"
else:
return "%s的语文成绩是%s，数学成绩是%s，英语成绩是%s"\
%(res[0],res[1],res[2],res[3])

class StuInfoSys():
def __init__(self):
self.g = GetStu()

def main(self,stuName):
# 凡是被调用的就return，最后的不调用，可以直接打印
print(self.g.get_info(stuName))

if __name__ == "__main__":
# r = Read_excel()
# print(r._getNames())
# print(r.get_score("小明"))
# g = GetStu()
# stuName = input("请输入查询的学生姓名：")
# print(g.get_info(stuName))
s = StuInfoSys()
stuName = input("请输入查询的学生姓名：")
s.main(stuName)
'''
# 方法三：分层写法，提高代码复用性
# 新建一个工程project，里面新建三个文件夹：
# readexc文件夹，里面放读取文件的模块及Excel文件，
# logic文件夹，里面放逻辑层，
# resource文件夹，里面放主程序文件main，
# 最后还有一个运行文件run，与三个文件夹同级
# 注意调试时的路径问题，run文件与其他几个路径不一致的

## 练习41：使用面向对象的方式，实现注册功能：
# 输入：username、password，cpassword
# 最多可以输错3次，3个都不能为空
# 用户名长度最少6位，最长20位，用户名不能重复
# 密码长度最少8位，最长15位
# 两次输入的密码要一致
# 注册成功之后，要写到文件(txt文件)里面
# 将注册功能重写，注册时，每输入一个参数，系统都会判断该参数是否合法，
# 直到所有参数都合法，再将用户名和密码保存到txt文件中。

'''
# 读取文件
class ReadFile():
# 获取所有用户名
def getUserName(self):
usernames = []
with open("base_test/register_user.txt","r") as f:
# print(f.readlines())
# 可以使用for循环，获取到用户名
# for user in f.readlines():
# usernames.append(user.split(",")[0])
# 也可以使用列表推导式获取用户名
usernames = [user.split(",")[0] for user in f.readlines()]
return usernames

# 保存用户名、密码
def saveUser(self,userName,passwd):
try:
with open("base_test/register_user.txt","a+") as f:
f.write(userName + "," + passwd + "\n")
return True
except Exception as msg:
return "信息保存失败，原因是：\n",msg

# 对用户名、密码、确认密码判断
class JudgeUser():
# 初始化用户数据
def __init__(self):
self.user = ReadFile()

# 判断用户名是否合法
def judgeUserName(self,userName):
if len(userName) == 0:
return "用户名不能为空"
elif len(userName) >= 6 and len(userName) <= 20:
if userName not in self.user.getUserName():
return True
else:
return "用户名不能重复"
else:
return "用户名长度最少6位，最长20位"

# 判断密码是否合法
def judgePasswd(self,passwd):
if len(passwd) == 0:
return "密码不能为空"
elif len(passwd) >= 8 and len(passwd) <= 15:
return True
else:
return "密码长度最少8位，最长15位"

# 判断确认密码是否合法
def judgeCpasswd(self,passwd,cpasswd):
if len(cpasswd) == 0:
return "确认密码不能为空"
elif cpasswd == passwd:
return True
else:
return "两次输入的密码要一致"

if __name__ == "__main__":
# r = ReadFile()
# print(r.getUserName())

j = JudgeUser()
times = 3
# 判断用户名
while times > 0:
username = input("请输入用户名：")
res = j.judgeUserName(username)
if res != True:
if times-1 != 0:
print("%s，还剩%d次机会"%(res,times-1))
else:
print("%s，您的错误次数过多，系统已退出。"%res)
times = times - 1
else:
break
# 判断密码
while times > 0:
passwd = input("请输入密码：")
res = j.judgePasswd(passwd)
if res != True:
if times-1 != 0 :
print("%s，还剩%d次机会"%(res,times-1))
else:
print("%s，您的错误次数过多，系统已退出。"%res)
times = times -1
else:
break
# 判断确认密码
while times > 0:
cpasswd = input("请输入确认密码：")
res = j.judgeCpasswd(passwd,cpasswd)
if res != True:
if times-1 != 0 :
print("%s，还剩%d次机会"%(res,times-1))
else:
print("%s，您的错误次数过多，系统已退出。"%res)
times = times -1
else:
break
# 保存用户名、密码
if times > 0:
res = j.user.saveUser(username,passwd)
if res != True:
print(res)
else:
print("注册成功")
'''

## 练习42：使用try except 优化猜数字游戏，
# 使其能够在用户输入非法时，提示用户输入有误
'''
num = 8
times = 3
while times > 0:
try:
guess = int(input("请输入一个整数："))
if guess == num :
print("恭喜您，猜对了")
break
elif guess > num:
if times - 1 == 0:
print("猜大了\n输入次数过多，系统已退出")
else:
print("猜大了，还剩%d次机会"%(times-1))
else:
if times - 1 == 0:
print("猜小了\n输入次数过多，系统已退出")
else:
print("猜小了，还剩%d次机会"%(times-1))
times -= 1
except:
if times - 1 != 0:
print("请输入整数，还剩%d次机会"%(times-1))
else:
print("输入有误，错误次数过多，系统已退出")
times -= 1
'''

########################

## 练习43.多线程应用：获取以下字典里面对应的前端页面代码，
# 并保存为html文件。（需要先安装requests模块）
# urls={"baidu":"https://www.baidu.com/",
# "360":"https://www.360.cn/"}

### 1.串行代码
'''
import requests,time
urls = {"baidu":"https://www.baidu.com/",
"360":"https://www.360.cn/"}
# print(requests.get("https://www.360.cn/").content)

def download(filename,url):
res = requests.get(url)
print("正在下载%s网站，"%filename,time.ctime())
with open("base_test/"+filename+".html","wb") as f: # b是二进制文本模式
f.write(res.content)
print("%s网站下载完成，"%filename,time.ctime())

if __name__ == "__main__":
for filename,url in urls.items():
download(filename,url)
'''
### 2.引入多线程
'''
import requests,time,threading
urls = {"baidu":"https://www.baidu.com/",
"360":"https://www.360.cn/"}

if __name__ == "__main__":
threads = []
for filename,url in urls.items():
# 调用threading的Thread方法来创建线程
t = threading.Thread(target=download,args=(filename,url))
threads.append(t)
# 启动线程
for t in threads:
t.start()
# 守护线程
for t in threads:
t.join()
'''
### 3.使用面向对象的方式启动线程
'''
import requests,time,threading
urls = {"baidu":"https://www.baidu.com/",
"360":"https://www.360.cn/"}

class MyThread(threading.Thread):
def __init__(self,filename,url):
# 调用父类的构造函数
super().__init__()
self.filename = filename
self.url = url
# 执行任务的函数: run() ，必须是run()
def run(self):
download(self.filename,self.url)

if __name__ == "__main__":
threads = []
for filename,url in urls.items():
# 实例化MyThread类来创建线程
t = MyThread(threading.Thread)
threads.append(t)
# 启动线程
for t in threads:
t.start()
# 守护线程
for t in threads:
t.join()
'''