合工大 宣区 python语言与系统设计 实验
实验一：Python 基础——程序控制结构与函数
实验详细要求
本课程主要学习 Python 的程序控制结构与函数设计，具体内容为分支结构
–条件表达式、循环结构–For 循环与 While 循环的基本语法、函数设计与使用。
(一) 实验目的
- 掌握判断结构的语法
- 掌握循环结构的语法
- 掌握函数编程
(二)实验环境
Python 3.6 及以上 or PyCharm
(三)实验内容
1、分支结构
编写代码：利用 if 判断来制作一个猜数字的小游戏
问题描述：程序运行时，系统在指定范围内生成一个随机数字，然后用户进行猜测，并根据用户输入进行必要的提示（right, too large, too small），如果猜对则提前结束程序，如果未有猜对，提示游戏结束并给出正确答案。
2、循环结构
编写代码：利用 while 循环判断来制作一个猜数字的小游戏
问题描述：程序运行时，系统在指定范围内生成一个随机数字，然后用户进行猜测，并根据用户输入进行必要的提示（right, too large, too small），如果猜对则提前结束程序，如果次数用完仍没有猜对，提示游戏结束并给出正确答案。
3、函数结构
（1）设计函数用来计算斐波那契数列中小于参数 n 的所有值。
（2）利用列表实现筛选法求素数
问题描述：编写程序，输入一个大于 2 的自然数，然后输出小于该数字的所有素数组成的列表。
（3）编写函数：判断回文，也就是正读反读都一样的字符串
例如：abcba”
（4） 编写函数：随机产生包含 n 个整数的列表，返回一个元组，其中第一个元素为所有参数的平均值，其他元素为所有参数中大于平均值的整数。
例如： 随机产生长度为 3 的列表[2, 1, 3]，输出为（2.0, 3）
(5) 编写函数： 一年 365 天， 每周工作 5 天，休息 2 天，休息日水平下降
0.01，工作日要努力到什么程度一年后的水平才与每天努力 1%所取得的效果（即37.78 倍）一样呢？
4、lambda 表达式
（1） 查找两个字符串首尾交叉的最大子串长度，连接两个字符串，首尾交叉部分只保留一份。例如，1234 和 2347 连接为 12347
要求：程序中使用 lambda 表达式以及函数
from random import randint
import random
def first_guessNumber(minValue,maxValue,maxTimes):
value = randint(minValue,maxValue)
prompt = 'Start to guess:'
for i in range(maxTimes):
x = int(input(prompt))
if x == value:
print('Right')
break
elif x > value:
print('Too large')
else:
print('Too small')
else:
print('End,your false')
print('The right：',value)
#first_guessNumber(1,10,3)
def second_guessNumber(minValue,maxValue,maxTimes):
m = 0
value = randint(minValue,maxValue)
prompt = 'Start to guess:'
while(m < maxTimes):
x = int(input(prompt))
if x == value:
print('Right')
break
elif x > value:
print('Too large')
else:
print('Too small')
m = m+1
else:
print('End,your false')
print('The right：',value)
#second_guessNumber(1,10,3)
def third_one_fib(n):
a,b=1,1
if n <= a:
print('false')
else:
while a < n:
print(a,end=',')
a,b=b,a+b
#third_one_fib(150)
def isprime(n):
for i in range(2,n):
if n % i == 0:
return 0
return 1
def third_second_primenumber(n):
value_list = []
for i in range(2,n):
if isprime(i) == 1:
value_list.append(i)
print(value_list)
#third_second_primenumber(150)
def third_third_palindrome(s):
a = reversed(list(s))
print(s)
if list(a) == list(s):
print('True')
else:
print('False')
#third_third_palindrome('adfgfda')
#third_third_palindrome('adegkda')
def third_forth_average(start,end,n):
a_list = random.sample(range(start,end),n)
print(a_list)
avg = sum(a_list)/n
l = [avg]
for i in a_list:
if i > avg:
l.append(i)
print(tuple(l))
#third_forth_average(1,10,5)
def dayup(du):
start = 1
for i in range(365):
if i % 7 in [6,0]:
start = start*(1-0.01)
else:
start = start*(1+du)
return start
def third_fivth_year():
start = 0.001
while dayup(start) < 37.78:
start = start+0.001
print(start)
#third_fivth_year()
def forth_lambda(s1,s2):
l1 = len(s1)
l2 = len(s2)
ls = min(l1,l2)
k = max(range(0,ls+1),key=lambda i : i if s1[l1-i:] == s2[:i] else False)
m = max(range(0,ls+1),key=lambda i : i if s2[l2-i:] == s1[:i] else False)
if k > m:
print('重复数为：',k)
print(s1+s2[k:])
elif k==0 and m==0:
print('重复数为：',k)
print('null')
else:
print('重复数为：',m)
print(s2+s1[m:])
#forth_lambda('34567899','2233456')
实验二：Python 基础二——序列数据类型及应用
Python 序列类似于 C 中的一维、多维数组等，但功能要强大很多，使用也更加灵活、方便。Python 中常用的序列结构有列表、元组、字典、字符串、集合、字典等。
（一）实验目的
1、掌握列表与列表推导式
2、掌握元组与生成器推导式
3、掌握切片的使用
4、掌握字典的用法
5、掌握集合的用法
6、掌握字符串及其应用
（二）实验环境
Python 3.6 及以上 or PyCharm
（三）实验内容
实验内容包含变量、字符串、列表、列表推导式、切片、元组、生成器推导式、字典、集合的应用。
（1） 列表推导式与字典的应用
问题描述：编写程序，先生成包含 1000 个随机字符的字符串，然后统计每
个字符出现的次数。
要求：查找资料编写至少 2 种不同的求解方法。
(2) 集合的应用
问题描述：编写程序，输入两个集合 setA 与 setB，分别输出它们两个交集
的交、差、并。
要求：采用系统类与自定义集合类两种方法进行实现
（3） 字符串与列表推导式的应用
问题描述： 编写程序，生成含有 n 个元素的嵌套列表，即列表的每个
元素仍是列表，要求列表中的元素是长度不超过 m 的数字或字符组成
的字符串，并按照字符串长度降序输出结果。
（4） 列表与切片的应用
问题描述：编写程序，生成一个整型列表，输出包含原列表中所有元素的新
列表、包含原列表中所有元素的逆序列表，以及输出具有偶数位置的元素列
表。
（5） 元组的应用
问题描述：编写程序，利用生成器推导式生成包含 n 个整数元素的元组，每
个元素值不大于 m，并过滤掉偶数整数，并输出。
（6） 字典的应用
问题描述：编写程序，输入任意长度的字符串，统计每个单词出现的次数并
存储到字典进行输出。
例如：输入：“I love China”，
输出：I：1
love: 1
China: 1
（7）正则表达式的应用
问题描述：用户输入一段英文，然后输出这段英文中所有长度为 3 个字母
的单词。
（提示：可以调用 findall 函数，也可以先调用 split 函数将字符串进行分
隔，再搜索长度为 3 的单词。）
import string
import random
import collections
import re
def first_count():
x = string.ascii_letters+string.digits
y="".join([random.choice(x) for i in range(1000)])
print('First:\n')
d = dict()
for ch in y:
d[ch]=d.get(ch,0)+1
for k,v in sorted(d.items()):
print(k,":",v)
print('\nSecond:\n')
count = collections.Counter(y)
for k,v in sorted(count.items()):
print(k,":",v)
#first_count()
def second_set(a,b):
s1 = a|b
print(s1)
s2 = a&b
print(s2)
s3 = a-b
print(s3)
#second_set({1,1,2,4},{3,3,5,1,2})
class MySet:
def second_myset(self,a,b):
s1 = a|b
print(s1)
s2 = a&b
print(s2)
s3 = a-b
print(s3)
#x = MySet()
#x.second_myset({1,1,2,4},{3,3,5,1,2})
def third_ss(n,m):
ch = string.digits + string.ascii_letters
res = [[''.join(random.sample(ch, random.randint(1, m)))] for i in range(n)]
print(sorted(res, key=lambda x: len(x[0]), reverse = True))
#third_ss(10,20)
def forth_ll():
x = []
for i in range(20):
x.append(random.randint(0,100))
x1 = x
print(x1)
x.reverse()
print(x)
x2 = []
for i in range(20):
if (i%2 == 0):
x2.append(x1[i])
print(x2)
#forth_ll()
def fivth_ou():
n,m = map(int,input().split())
a = [random.randint(1,m) for i in range(n)]
#print(a)
b = []
for i in a:
if i%2!=0:
b.append(i)
print(tuple(b))
#fivth_ou()
def sixth_te(str):
words = str.split(' ')
dict={ }
for i in words:
if i not in dict.keys():
dict[i] = 1
else:
dict[i] += 1
print(dict)
#sixth_te('this is a chanllenge')
def seveth_fi(words):
l = re.split('[\.!? ]+',words)
print(l)
i = 0
for i in l:
if len(i) == 3:
print(i)
#seveth_fi('why so serious now?')
实验三：Python 基础——面向对象、文件处理
Python 从设计之初就已经是一门面向对象的语言，面向对象程序设计的思想主要针对大型软件设计而提出，使得软件设计更加灵活，能够很好地支持代码复用和设计复用，代码具有更好的可读性和可扩展性。
(一) 实验目的
- 掌握面向对象的编程
- 掌握 python 文件读写
(二) 实验环境
Python 3.6 及以上 or PyCharm
(三) 实验内容
1、面向对象
2、 文件处理
(四) 实验步骤
1.、类的定义与使用
（1） 编程设计学生信息类，实例属性包括：学号、姓名、性别，年龄、n 门课程成绩，
要求：
- 利用文件读取，创建一个包含 n 个学生的班级;
- n 门课程成绩利用字典存储，支持成绩录入、修改;
- 求解每个学生的三门成绩的平均值，及其平均值排名。并按照成绩平均成绩排名正序输出功能：学号、姓名、性别、年龄，三门课程成绩，三门课程平均值，排名。
（2）编程设计一个雇员基类 Employee，包括姓名，编号，月薪三个实例属性，月薪计
算 pay()和信息显示 show()两个函数成员；派生两个子类 manager 类和 salesman 类，重载相应的 2 个函数成员。
要求：根据以上描述设计类，并在主函数创建两个子类的实例化对象，分别调用其成员方法。
（3）编程设计一个基类汽车类 Vehicle，包含最大速度 MaxSpeed，weight 两个实例私有属性；设计一个派生子类自行车（Bicycle）类，增加 1 个实例私有属性高度（height）和 1 个成员函数 SetMaxSpeed 实现给父类的实例属性MaxSpeed 的赋值。
要求：
1 根据以上描述设计类，并在主函数中创建子类的实例化对象，并设置对象的MaxSpeed 值。
2 利用 property 将 height 设定为可读、可修改、可删除的属性。
（4） 编程设计一个队列类 Myqueue，主要的类成员包括： 3 个数据成员（队列的最大长度 size，队列所有数据 data，队列的元素个数 current）和 6 个成员方法如下：
1初始化 ：设置队列为空;
2 判断队列为空：若为空，则返回 TRUE，否则返回 FALSE.
3 判断队列为满：若为满，则返回 TRUE，否则返回 FALSE.
4 取队头元素：取出队头元素;
条件：队列不空。
否则，应能明确给出标识，以便程序的处理.
5 入队：将元素入队，即放到队列的尾部
6 出队：删除当前队头的元素
要求：根据以上描述设计类，并在主函数中创建类的实例化对象，构建一个长度为 N 的队列，分别调用上述成员方法。
- 文件的使用
（1） 问题描述：编写程序，生成多个字符串，将字符串写入文件，同时读取当前文件，并输出统计字符串的个数。
（2）编写程序以检查用户输入的密码的有效性。
检查密码的标准为：
1） [a-z]之间至少有 1 个字母
2） [0-9]之间至少有 1 个数字
3） [A-Z]之间至少有 1 个字母
4） [$＃@]中至少有 1 个字符
5） 最短交易密码长度：6
6） 交易密码的最大长度：12
问题描述： 程序接受一系列逗号分隔的密码，进行检查。再输出符合条件
的密码，每个密码用逗 号分隔。
例如：程序的输入： abcdEF12＃@,ccword12 程序的输出： abcdEF12
＃@
import re
import collections
import string
import pandas as pd
#1
class student:
def __init__(self, ID='', Name='', Gender='',Age = '', Class='', Grades=dict()):
self.ID = ID
self.Name = Name
self.Gender = Gender
self.Age = Age
self.Class = Class
self.Grades = Grades
@classmethod
def create_class_from_file(self, file_name):
reclass = []
infor = pd.read_excel(file_name,encoding = 'utf-8')
nrows = infor.ID
for i in range(len(nrows)):
ID = infor.ID[i]
Name = infor.Name[i]
Gender = infor.Gender[i]
Age = infor.Age[i]
Class = infor.Class[i]
test = infor.Grades[i]
TGrades = {}
grades = re.split('，|：',test)
for j in range(0,len(grades)-1,2):
TGrades[grades[j]]= grades[j+1]
reclass.append(student(ID, Name, Gender, Age, Class, TGrades))
return reclass
def modify_grades(self, key, value):
if key in self.Grades.keys():
self.Grades[key] = value
print('修改', self.Name, '的', key, '为', value)
else:
self.Grades[key] = value
print('未在', self.Name, '中找到科目', key, ',已添加为:', value)
def delete_grades(self, key):
if key in self.Grades.keys():
print('删除:', key)
self.Grades.pop(key)
else:
print('未在', self.Name, '中找到科目', key)
def average_grades(self):
scores = self.Grades.values()
sum = 0
for i in scores:
sum += int(i)
average = sum / len(scores)
return average
@classmethod
def student_sort(self, students):
stus = sorted(students, key=lambda x: x.average_grades(), reverse=True)
n = 1
for i in stus:
print(i.ID, i.Name, i.Gender, i.Age, i.Grades, i.average_grades(), n)
n += 1
def student_print(self):
print(self.ID, self.Name, self.Gender, self.Age, self.Grades)
'''x = student()
oneclass = x.create_class_from_file('test.xlsx')
x.student_sort(oneclass)'''
#2
class Employee:
def __init__(self,name,number,salary):
self.name = name
self.number = number
self.salary = salary
def pay(self):
print('Employee月薪是',self.salary)
def show(self):
print('Employee的名字是',self.name)
print('Employee编号是',self.number)
class Manager(Employee):
def pay(self):
print('Manager月薪是',self.salary)
def show(self):
print('Manager的名字是',self.name)
print('Manager编号是',self.number)
class Salesman(Employee):
def pay(self):
print('Salesman月薪是',self.salary)
def show(self):
print('Salesman的名字是',self.name)
print('Salesman编号是',self.number)
'''first_one = Employee('lilei','1001','5000')
second_one = Manager('hmm','1002','7000')
third_one = Salesman('zl','1003','4500')
first_one.pay()
first_one.show()
second_one.pay()
second_one.show()
third_one.pay()
third_one.show()'''
#3
class Vehicle:
MaxSpeed=200
weight=150
def show(self):
print('汽车的最大速度为',self.MaxSpeed)
print('汽车的重量为',self.weight)
class Bicycle(Vehicle):
def __init__(self,height):
self.__height = height
def set_MaxSpeed(self,Maxspeed):
self.MaxSpeed = Maxspeed
def set_weight(self,weight):
self.weight=weight
def __get(self):
return self.__height
def __set(self,h):
self.__height=h
def show(self):
print('自行车的高度为',self.__height)
print('自行车的最大速度为',self.MaxSpeed)
print('自行车的重量为',self.weight)
height = property(__get,__set)
'''bikeone = Bicycle(10)
bikeone.set_MaxSpeed(30)
bikeone.height = 20
bikeone.show()'''
#4
class Myqueue(object):
def __init__(self,size):
self.size = size
self.data = []
self.current = len(self.data)
def is_empty(self):
if self.current == 0:
print('队列为空!')
return True
else:
print('队列不为空!')
return False
def is_full(self):
if self.current == self.size:
print('队列为满!')
return True
else:
print('队列不为满!')
return False
def head(self):
if not self.data == []:
print('队列首元素为%s'%self.data[0])
else:
print('队列为空,无队列首元素!')
def in_queue(self,element):
if self.current != self.size:
self.data.append(element)
self.current = len(self.data)
print('元素%s入队列成功!'%element)
else:
print('队列为满!')
def out_queue(self):
if not self.data == []:
out_element = self.data.pop(0)
self.current = len(self.data)
print('元素%s出队列成功!'%out_element)
else:
print('队列为空,无法出队列!')
def show(self):
print('队列为:')
for i in self.data:
print(i,',',end='')
print('\n队列最大长度为:\n',self.size)
print('\n现有元素个数：\n',self.current)
'''xx = Myqueue(10)
xx.is_empty()
for i in range(5,13):
xx.in_queue(i)
xx.is_full()
xx.show()
for i in range(5):
xx.out_queue()
xx.show()
for i in range(20):
xx.in_queue(i)
xx.is_full()
xx.show()
xx.head()'''
#5
def write_fivth():
s = 'It is only a test.The result is that:\nNO,it needs test'
file = open(r'fivth.txt','w')
file.write(s)
file.close
def fivth():
file = open(r'fivth.txt')
result = []
for line in file:
result.append(line.strip('\n'))
#print(result)
final = []
content = 0
for string in result:
string = re.sub('[,.:，。：""“”]',' ',string)
one = string.split()
for every in one:
if len(every)>0:
content = content+1
final.append(every)
print(final)
print(content)
#write_fivth()
#fivth()
#6
def Check_Password(pwd):
if len(pwd) < 6 or len(pwd) > 12:
return None
flag = [False] * 4
for ch in pwd:
if ch in string.ascii_lowercase:
flag[0] = True
if ch in string.ascii_uppercase:
flag[1] = True
if ch in string.digits:
flag[2] = True
if ch in '$#@':
flag[3] = True
if flag.count(True) == 4:
return pwd
return None
def sixth(pwd):
print('合适的输出：')
list1 = pwd.split(',')
for i in list1:
final = Check_Password(i)
if final != None:
print(final+'\n')
#sixth('abcdEF12＃@,ccword12')
#sixth('ADCapc211#@,dsfhdFKFDSL,QWer12@#!')