（1）python 实现向班级中添加学生、删除学生、查看学生、按照指定条件排序(使用面向对象的思想)：
设计一个学生类
属性：姓名、学号、年龄、成绩
设计一个班级类
属性：班级代号，所有学生
要求：实现向班级中添加学生、删除学生、查看学生、按照指定条件排序
#实现向班级中添加学生、删除学生、查看学生、按照指定条件排序
class Student: #定义学生类
def __init__(self,name,school_num,age,grade):
self.name = name
self.school_num = school_num
self.age = age
self.grade = grade
def __getitem__(self, item): #使其能够通过下标获取值
return self.__dict__.get(item)
class Banji: #定义班级类
def __init__(self,num,lt): #lt为一个列表
self.num = num
self.lt = lt
def add(self,student): #增加学生方法
self.lt.append(student)
def shanchu(self,student): #删除学生方法
self.lt.remove(student)
def see_student(self,num,key): #查看学生，num为名字或学号等，key为num的类型
for i in range(len(self.lt)):
if num == self.lt[i][key]:
break
print("姓名:{},学号:{},年龄:{},成绩:{}".format(self.lt[i].name,self.lt[i].school_num,self.lt[i].age,self.lt[i].grade))
def paixv(self,key): #对学生进行排序，key为排序标准，比如按成绩排序
for i in range(len(self.lt) - 1):
for j in range(len(self.lt) - 1 - i):
if self.lt[j][key] > self.lt[j + 1][key]:
t = self.lt[j]
self.lt[j] = self.lt[j + 1]
self.lt[j + 1] = t
#测试代码
student = Student('mao',14,18,100)
student1 = Student('chen',15,17,99)
student3 = Student('shang',22,23,99)
test = Banji(302,[])
test.add(student)
test.add(student1)
test.add(student3)
#test.shanchu(student)
#test.see_student('xynu')
#print(test.lt)
print(test.lt[1].age)
test.paixv('age')
#print(test.lt[0].age)
print(test.lt[1].age)
test.see_student('mao','name')
#test.see_student(15,'school_num')（2）python 将歌词解析封装成类，要求：提供一个方法(根据时间返回歌词)(面向对象思想)
#将歌词解析封装成类，要求：提供一个方法(根据时间返回歌词)
class Song: #定义歌词类
def __init__(self,song):
self.song = song
class Song_jiexi: #定义歌词解析函数
def __init__(self,song_word):
self.song_word = song_word
def chazhao_time(self,t):
# 准备一个字典，用来保存歌曲信息
song_dict = {}
# 准备一个字典，用来保存歌词信息
lrc_dict = {}
# 按照换行进行切割
str_list = (self.song_word.song).splitlines()
# 遍历处理
for string in str_list:
# 判断是否是歌词信息
if string[1].isdecimal():
# [02:11.55][01:50.60][00:22.63]穿过幽暗的岁月
# 按照']'进行切割
lrc_list = string.split(']')
# 提取歌词信息
lrc_info = lrc_list[-1]
# 提取时间信息
time_info = lrc_list[:-1]
# 遍历处理时间信息
for time_str in time_info:
# [00:00.70
# 去掉左边的'['
time_str = time_str[1:]
# 00:00.70
# 按照':'进行切割
time_info_list = time_str.split(':')
# 提取分钟
time_min = float(time_info_list[0])
# 提取秒数
time_sec = float(time_info_list[1])
# 合并时间
time = time_min * 60 + time_sec
# 保存到歌词字典中
lrc_dict[time] = lrc_info
else:
# 去掉两边的[]
string = string[1:-1]
# 按照':'进行切割
song_list = string.split(':')
# 保存到歌曲字典中
if song_list[0] == 'ti':
song_dict['标题'] = song_list[1]
elif song_list[0] == 'ar':
song_dict['艺术家'] = song_list[1]
elif song_list[0] == 'al':
song_dict['专辑'] = song_list[1]
# 提取歌词字典中所有的键
time_list = list(lrc_dict)
# 排序
time_list.sort(reverse=True)
for i in time_list:
if i <= t:
tt = i
break
return lrc_dict[tt]
#测试代码
test = Song('''[ti:蓝莲花]
[ar:许巍]
[al:留声十年绝版青春北京演唱会]
[00:-01.70]蓝莲花
[00:-00.70]演唱：许巍
[00:00.00]
[00:00.70]没有什么能够阻挡
[00:06.01]你对自由的向往
[00:11.43]天马行空的生涯
[00:16.99]你的心了无牵挂
[00:21.20]
[02:11.55][01:50.60][00:22.63]穿过幽暗的岁月
[02:16.93][01:55.60][00:27.81]也曾感到彷徨
[02:22.21][02:01.09][00:33.13]当你低头的瞬间
[02:27.62][02:06.33][00:38.32]才发觉脚下的路
[02:31.64][02:10.23][00:42.37]
[02:32.97][00:43.79]心中那自由的世界
[02:38.23][00:49.50]如此的清澈高远
[02:43.30][00:54.31]盛开着永不凋零
[02:47.70][00:58.50]蓝莲花
[02:53.95][03:00.06][01:05.41]''')
test2 = Song_jiexi(test)
#print(type(test.song))
print(test2.chazhao_time(50))（3）python 统计一个字符串中字母、数字及其他字符的个数，返回一个元组：
def tongji(s):
count1 = 0
count2 = 0
count3 = 0
for i in range(len(s)):
if (s[i] >= 'a' and s[i] <= 'z') or (s[i] >= 'A' and s[i] <= 'Z'):
count1 = count1 + 1
elif (s[i] >= '0' and s[i] <= '9'):
count2 = count2 + 1
else:
count3 = count3 + 1
return (count1,count2,count3)
s = input("请输入一个字符串:")
print(tongji(s))（4）删除列表中重复的元素 ：
def de(ln):
lt = []
for i in range(len(ln) - 1):
j = i + 1
for k in range(i + 1):
if(ln[k] == ln[j]):
ln[j] = " "
for m in reversed(range(len(ln))):
if ln[m] == " ":
ln.remove(" ")
ln = [1,11,1,2,2,8,8,3,3,66,9,1,1,1,1,1]
de(ln)
print(ln)（5）python 终端计算器，完成加减乘除功能：
import sys
print(sys.argv)
if sys.argv[2] == '+':
print(int(sys.argv[1]) + int(sys.argv[3]))
elif sys.argv[2] == '-':
print(int(sys.argv[1]) - int(sys.argv[3]))
elif sys.argv[2] == '*':
print(int(sys.argv[1]) * int(sys.argv[3]))
elif sys.argv[2] == '/':
print(int(sys.argv[1]) / int(sys.argv[3]))
elif sys.argv[2] == '//':
print(int(sys.argv[1]) // int(sys.argv[3]))
elif sys.argv[2] == '%':
print(int(sys.argv[1]) % int(sys.argv[3]))
else:
print("出错")（6）python 号码归属地查询：
def sim(number):
s = '''5582|1860101|010|北京市|北京联通GSM卡
5583|1860100|010|北京市|北京联通GSM卡
5584|1368141|010|北京市|北京移动神州行卡
5585|1860111|010|北京市|北京联通GSM卡
5586|1358198|010|北京市|北京移动动感地带卡
5587|1361139|010|北京市|北京移动预付费卡
5588|1361138|010|北京市|北京移动神州行卡
5591|1360110|010|北京市|北京移动全球通卡
5748|1364110|010|北京市|北京移动神州行卡
10186|1581584|020|广东省广州市|广东移动全球通卡
15046|1391897|021|上海市|上海移动全球通卡
17250|1502207|022|天津市|天津移动全球通卡
21137|1345272|023|重庆市万州|重庆移动大众卡
22700|1347812|024|辽宁省沈阳市|辽宁移动大众卡
24256|1377065|025|江苏省南京市|江苏移动全球通卡
26360|1898606|027|湖北省武汉市|湖北电信CDMA卡
28709|1860802|028|四川省成都市|四川联通GSM卡
30641|1552961|029|陕西省西安市|陕西联通GSM卡
31700|1563007|0310|河北省邯郸市|河北联通GSM卡
33360|1583396|0311|河北省石家庄市|河北移动全球通卡
34825|1508122|0312|河北省保定市|河北移动全球通卡
35363|1551235|0313|河北省张家口|河北联通GSM卡
37700|1331326|0316|河北省廊坊市|河北电信CDMA卡
43500|1350358|0358|山西省吕梁市|山西移动全球通卡
43908|1553625|0359|山西省运城市|山西联通GSM卡
44521|1335360|0370|河南省商丘市|河南电信CDMA卡
50078|1509369|0378|河南省开封市|河南移动全球通卡
53603|1583981|0398|河南省三门峡|河南移动全球通卡
53916|1335897|0410|辽宁省铁岭市|辽宁电信CDMA卡
55248|1554254|0411|辽宁省大连市|辽宁联通GSM卡
58618|1374272|0427|辽宁省盘锦市|辽宁移动全球通卡
58932|1554183|0429|辽宁省葫芦岛|辽宁联通GSM卡
60268|1340475|0431|吉林省长春市|吉林移动大众卡'''
s2 = s.splitlines()
for i in range(len(s2)):
s3 = s2[i].split("|")
if number == s3[1]:
print(s3[4])
break
else:
print("不存在此号码")
while True:
number = input("请输入电话号码:")
if number == "#":
break
sim(number)（7）python 使用递归，完成传入n，返回1! + 2! + 3! + ... + n!
# 使用递归，完成传入n，返回1! + 2! + 3! + ... + n!
def jc(x): //单个数的阶乘
if x == 1:
return 1
t = x * jc(x - 1)
return t
def j(n):
if n == 1:
return 1
sum = jc(n) + j(n - 1)
return sum
print(j(4))
def jiechenghe(n):
if n == 1:
return 1
elif n == 2:
return 3
return jiechenghe(n - 1) + n * (jiechenghe(n - 1) - jiechenghe(n - 2))
print(jiechenghe(2))（8）python 统计一个目录的大小
# 统计一个目录的大小，需要使用递归
import os
def tjdx(path):
m = 0
lt = os.listdir(path) #展开目录下的信息
for i in lt: #遍历目录下信息
if os.path.isdir(os.path.join(path,i)): #判断是否为目录
m = m + tjdx(os.path.join(path,i)) #调用递归，求得目录大小
else:
m = m + os.path.getsize(os.path.join(path,i)) #若不是目录，加上该文件的大小
return m #返回目录总大小
print(tjdx('E:/test'))（9）python 删除目录
# 删除一个目录，需要使用递归
import os
def deletemulu1(path):
lt = os.listdir(path) #获取目录信息
for i in lt: #遍历目录信息
if os.path.isdir(os.path.join(path,i)): #判断是否是目录
deletemulu1(os.path.join(path,i)) #把当前目录传入deletemulu1
else:
os.remove(os.path.join(path,i)) #删除非目录
os.rmdir(os.path.join(path)) #删除空目录
deletemulu1('E:/test') #测试（10）python 实现一个文件的拷贝功能
# 实现一个文件的拷贝功能
import os
def copy(path,path1): #path原文件地址，path1指定地址
fp = open(path,'r')
fp1 = open(path1,'w')
for i in fp:
fp1.write(i) #向新文件中写入数据
fp.close()
fp1.close()
copy("E:/test/1.text","E:/test/6.text")（11）python 移动一个目录
扫描二维码关注公众号，回复：
2539316 查看本文章
# 移动一个目录
from os import path
import os
def copmulu(path, path1): # path原文件地址，path1指定地址
s = path.split("\\") # 获得以原路径按“/”切割的字符串，取最后一个s[-1]得到文件名
newpath = os.path.join(path1, s[-1]) # 更新新路径
os.makedirs(newpath) # 创建目录
lt = os.listdir(path) # 获得老目录下的信息
for i in lt:
if os.path.isdir(os.path.join(path, i)): # 如果是目录就调用函数进行递归
copmulu(os.path.join(path, i), newpath)
else:
fp = open(os.path.join(path, i), 'r')
fp1 = open(os.path.join(newpath, i), 'w') # 如果是文件则在新目录下创建
for j in fp:
fp1.write(j) # 向新文件中写入数据
fp.close()
fp1.close()
os.remove(os.path.join(path, i)) #删除原文件
os.rmdir(os.path.join(path)) #删除原目录
copmulu('E:\\test1', 'E:\\test2') # 测试（12）python 实现find函数
# 第五题：自己实现一个字符串的find函数
# 1.在一个字符串中查找另一个字符串
# 2.找到了返回第一次出现的位置
# 3.没找到返回-1
# 4.参数s1为源字符串，参数s2为要查找的字符串
# '''
def index_of_str(s1, s2):
for i in range(len(s1)):
if s1[i] == s2[0]:
j = i
for k in range(len(s2)):
if s1[j] != s2[k]:
break
j = j + 1
else:
return i
return -1
print(index_of_str("asdfhjgfdsgfdf","gfd"))（13）python 计算字符串中所有数字的和
'''
第二题：计算字符串中所有数字的和
1.字符串中只有小写字母和数字
2.数字可能连续，也可能不连续
3.连续数字要当做一个数处理
如：'12abc34de5f' => 12 + 34 + 5 => 51
'''
def sum_of_num(s):
m = 0
sum = 0
for i in range(len(s)):
if ord(s[i]) >= 48 and ord(s[i]) <= 57:
m = (m * 10) + int(s[i]) #求得连续数字
#print(m)
else:
sum = sum + m
m = 0
if ord(s[-1]) >= 48 and ord(s[-1]) <= 57:
sum = sum + m
return sum
print(sum_of_num('12abc34de5s1s2f'))
#print(ord('0'),ord('9'))（14）python 返回一个列表中第二大的数的下标
# 返回一个列表中第二大的数
def second(lt):
max = 0
s = {}
for i in range(len(lt)):
flag = 0
for j in range(len(lt)):
if lt[i] <= lt[j] and i != j:
flag = flag + 1
s[i] = flag
if flag > max:
max = flag
print(s)
for i in s:
if s[i] == max - 1:
break
return i
print(second([1,5,7,4,5,6,8,5,9,9,10,11,5,20,19]))（15）python 计算一个字符串中所有数字的和
# 计算一个字符串中所有数字的和
def numsum(s):
sum = 0 #定义变量，准备记录数字的和
for i in range(len(s)): #遍历字符串
if s[i] >= '0' and s[i] <= '9': #如果i处的字符属于数字字符
sum = sum + int(s[i]) #将字符转成int，求和
return sum
s = input("请输入一个字符串:")
print(numsum(s))（16）python 实现列表的排序，要求支持逆序和指定标准(key)(模仿sort函数)
# 实现列表的排序，要求支持逆序和指定标准(key)
def paixv(lt, key = False,reverse = False): #列表lt，指定标准key，是否逆序reverse
for i in range(len(lt) - 1):
for j in range(i+1,len(lt)):
if key:
if reverse :
if key(lt[i]) < key(lt[j]):
t = lt[i]
lt[i] = lt[j]
lt[j] = t
else:
if key(lt[i]) > key(lt[j]):
t = lt[i]
lt[i] = lt[j]
lt[j] = t
else:
if reverse:
if lt[i] < lt[j]:
t = lt[i]
lt[i] = lt[j]
lt[j] = t
else:
if lt[i] > lt[j]:
t = lt[i]
lt[i] = lt[j]
lt[j] = t
#字典测试
lt = [
{'name': 'ergou', 'age': 18, 'height': '180'},
{'name': 'dagou', 'age': 20, 'height': '170'},
{'name': 'dahua', 'age': 19, 'height': '190'},
{'name': 'cuihua', 'age': 21, 'height': '165'},
{'name': 'Ton', 'age': 28, 'height': '185'},
{'name': 'Tom', 'age': 30, 'height': '198'}
]
paixv(lt,key = lambda d: d["age"],reverse = True)
# 普通测试
# lt = [1,2,3,4,5,9,8]
#
# paixv(lt,reverse=True)
print(lt)（17）python 递归实现斐波那契
# 斐波那契
def f(n):
if n == 1 or n == 2:
return 1
return f(n - 1) + f(n - 2)
print(f(7))
（18）python 返回一个列表中第二大的数
# 返回一个列表中第二大的数
def second(ln):
max = 0
s = {}
for i in range(len(ln)):
flag = 0
for j in range(len(ln)):
if ln[i] >= ln[j] and i != j:
flag = flag + 1
s[i] = flag
if flag > max:
max = flag
print(s)
for i in s:
if s[i] == max - 1:
break
print(ln[i])
second([1,2,7,4,5,6,8,5,3,3,9,9,10,11,5,3,20,19])（19）python 完成列表的排序，支持逆序
# 完成列表的排序，支持逆序
def paixv(lt,n = 1):
for i in range(len(lt) - 1):
for j in range(i+1,len(lt)):
if n == 0:
if lt[i] < lt[j]:
t = lt[i]
lt[i] = lt[j]
lt[j] = t
else:
if lt[i] > lt[j]:
t = lt[i]
lt[i] = lt[j]
lt[j] = t
ln = [1,2,55,3,55,33,8,4]
paixv(ln,n = 1)
print(ln)