Python程序设计应用基础
Python下
读取并显示文本文件第2行和第3行内容。
#1.读取并按格式要求输出文本文件cj_utf8.txt第2行和第3行数据
# 打开文件
with open('cj_utf8.txt', 'r', encoding='utf-8') as file:
# 读取所有行
lines = file.readlines()
# 获取第2行和第3行
line2 = lines[1].strip()
line3 = lines[2].strip()
# 输出结果
print(line2)
print(line3)
读取csv文件表头和第3列数据。
#1.导入模块csv
import csv
#2.打开文件
with open("liangshan108.csv","r",encoding="gbk") as f:
#3.创建reader对象
reader = csv.reader(f)
#4.读取并输出表头
header = next(reader)
print(header)
#5.读取并输出表格第3列内容
column3 = [row[3] for row in reader]
print(column3)
利用pandas库读取"ls108uft8.csv"文件指定列。
#1.导入pandas模块
import pandas as pd
#2.调用pandas模块中的read_csv()函数读取文件"ls108uft8.csv"中“诨名”和“姓名”两列数据的前3行到变量data中
data = pd.read_csv("ls108uft8.csv", usecols=["诨名", "姓名"], nrows=3)
#3.输出变量data值
print(data)
将两个csv文件按行合并成一个文件。
# -*- coding: utf-8 -*-
#1.导入csv模块
import csv
#2.打开scoreupdate.csv文件
f=open("scoreupdate.csv","r",encoding="utf8")
#3.调用csv模块中函数DictReader()将文件f放入字典header中
header = csv.DictReader(f)
#4.调用fieldnames属性获取文件中所有字段
fields = header.fieldnames
try:
#5.以追加模式打开scoremain.csv文件
with open("scoremain.csv","a",encoding="utf8",newline="") as csv_file:
#6.调用csv模块DictWriter()函数和writerows()方法将"scoreupdate.csv"文件记录追加到scoremain.csv文件末尾
writer = csv.DictWriter(csv_file, fieldnames=fields)
writer.writerows(header)
print("写入完成！")
except:
print("操作有误！")
“cj.csv”源文件如图1所示，扩展文件“cjexpand.csv”内容如图2所示。将两个文件进行列合并，合并后内容保存为“cjout.csv”文件。
# -*- coding: utf-8 -*-
#1.导入pandas库
import pandas as pd
#2.利用pandas库读取文件cj.csv和文件cjexpand.csv中内容,其中文件编码encoding="utf8"
df_cj = pd.read_csv("cj.csv", encoding="utf8")
df_expand = pd.read_csv("cjexpand.csv",encoding="utf8")
#3.调用pandas库函数merge()按“姓名”字段合并以上两个表格
merged_df = pd.merge(df_cj, df_expand, on="姓名", how="left")
#4.将合并后的记录重新写入新的文件cjout.csv中
merged_df.to_csv("cjout.csv", index=False)
print("文件合并完成")
“stock.xlsx”文件有2个工作表（股票数据片段1、股票年报数据片段2），内容如下图。
#1.导入xlrd库
import xlrd
#2.以读模式打开"stock.xlsx"文件
workbook = xlrd.open_workbook("stock.xlsx")
#3.通过索引顺序获取第1个工作表sheet1，并输出工作表名称
sheet1 = workbook.sheet_by_index(0)
print("工作表1：", sheet1.name)
#4.输出工作表1第3行第6列单元格数据
cell_value = sheet1.cell_value(2, 5)
print("第3行第6列：", cell_value)
#5.通过索引顺序获取第2个工作表sheet2，并输出工作表名称
sheet2 = workbook.sheet_by_index(1)
print("工作表2：", sheet2.name)
#6.输出工作表2第4行数据
row_values = sheet2.row_values(3)
print("第4行：", row_values)
#7.输出工作2第4列数据
column_values = sheet2.col_values(3)
print("第4列：", column_values)
创建一个新文件“RedDream.xls”，添加一个工作表’红楼梦_sheet’，并写入相关数据。
'''任务：创建一个新文件“RedDream.xls”，添加一个工作表'红楼梦_sheet'，并写入相关数据'''
#1.导入xlwt库
import xlwt
#2.定义二维列表数据stus
stus = [['姓名', '年龄', '性别', '分数'],
['宝玉', 20, '男', 90],
['黛玉', 18, '女', 95],
['宝钗', 18, '女', 88],
['晴雯', 16, '女', 80]
]
#3.新建一个Excel文件“RedDream.xls”
workbook = xlwt.Workbook()
#4.文件中添加一个工作表sheet，工作表名称为'红楼梦_sheet'
sheet = workbook.add_sheet('红楼梦_sheet')
#5.将二维列表stus中元素逐个写入工作表sheet单元格中
for row_index, row in enumerate(stus):
for col_index, value in enumerate(row):
sheet.write(row_index, col_index, value)
workbook.save('RedDream.xls')
print("Excel文件写入完成！")
利用第三方库jieba库进行中文分词，按要求进行不同模式的分词处理。
# -*- coding: utf-8 -*-
def return_values():
#**********Begin**********#
#1.导入jieba库
import jieba
#2.给变量s赋值
s="小明就读于长沙理工大学某专业"
#3.变量s精确模式中文分词结果存于变量d1
d1 = jieba.lcut(s)
#4.变量s全模式中文分词结果存于变量d2
d2 = jieba.lcut(s, cut_all=True)
#5.变量s精搜索引擎模式中文分词结果存于变量d3
d3 = jieba.lcut_for_search(s)
#**********End**********#
return d1,d2,d3 # 子函数返回值
统计sgyy.txt中中文词语出现的次数，输出前10。
# -*- coding: utf-8 -*-
'''利用jieva库分析统计出三国演义中出现次数排前10的中文词语'''
#1.导入jieba库
import jieba
#2.读取文本文件sgyy.txt所有内容
with open("sgyy.txt", "r", encoding="utf-8") as f:
content = f.read()
#3.按中文分词处理读取文本内容
seg_list = jieba.lcut(content)
#4.统计分词结果保存到字典中，其中字典的key为词语，value为出现的次数
word_count = {}
for word in seg_list:
if len(word) > 1: # 过滤掉单个字符的词语
word_count[word] = word_count.get(word, 0) + 1
#5.按中文词语出现个数降序排列
sorted_word_count = sorted(word_count.items(), key=lambda x: x[1], reverse=True)
#6.按格式要求输出出现次数排前10的词语及词频
top_10 = sorted_word_count[:10]
print(top_10)
# -*- coding: utf-8 -*-
'''利用jieva库分析统计出三国演义中出现次数排前10的中文词语'''
#1.导入jieba库
import jieba
import logging
jieba.setLogLevel(logging.ERROR)
#2.读取文本文件sgyy.txt所有内容
with open("sgyy.txt", "r", encoding="utf-8") as f:
content = f.read()
#3.按中文分词处理读取文本内容
seg_list = jieba.lcut(content)
#4.统计分词结果保存到字典中，其中字典的key为词语，value为出现的次数
word_count = {}
for word in seg_list:
if len(word) > 1: # 过滤掉单个字符的词语
word_count[word] = word_count.get(word, 0) + 1
#5.按中文词语出现个数降序排列
sorted_word_count = sorted(word_count.items(), key=lambda x: x[1], reverse=True)
#6.按格式要求输出出现次数排前10的词语及词频
top_10 = sorted_word_count[:10]
for top in top_10:
print(top, end='')
程序有语法错误，发现并更正。
def return_values():
#*************begin*************#
#改正下列代码中的语法错误
class Person:
def __init__(self,name,age):
self.name=name
self.age=age
#*************end*************#
return 1
分析程序的运行错误，更正错误，使程序能正常运行，计算两个变量之和c。
def return_values():
#*************begin*************#
#改正下列代码中的错误
a=6*2
b='2'
c=str(a)+b
#*************end*************#
return c
程序的功能输入演员姓名，即可输出其出演的电影。
发现程序中的错误并更正。
# ** ** ** ** ** ** * begin ** ** ** ** ** ** * #
#输入演员姓名， 即可返回其出演的电影
#改正下列代码中的逻辑错误
movie = {
'金刚川': ['张译', '吴京'],
'八佰': ['黄志忠', '欧豪', '王千源'],
'卧龙藏虎': ['章子怡', '周润发', '杨祡琼']
}
name = input("演员名字：")
for film, actors in movie.items():
if name in actors:
print(name + "出演了" + film)
# ** ** ** ** ** ** * end ** ** ** ** ** ** * #
编程计算两个从键盘输入的数之商，程序能捕获各种异常。
'''
(1) 从键盘输入两个数值，计算并输出商。
利用try…except捕获异常：
(2) 如果输入的不是数字，是字母，程序将处理该异常，输出提示信息"程序发生了数字格式异常"
(3) 如果输入的除数为0，程序将处理该异常，输出提示信息"程序发生了算术异常"
(4) 如果程序运行时出现其他异常，程序将处理该异常，输出提示信息"未知异常"
'''
#*************begin*************#
try:
# 从键盘输入两个数值
num1 = float(input("输入被除数："))
num2 = float(input("输入除数："))
# 计算并输出商
result = num1 / num2
print("您输入的两个数相除的结果是：", result)
except ValueError:
# 输入的不是数字，是字母
print("程序发生了数字格式异常")
except ZeroDivisionError:
# 输入的除数为0
print("程序发生了算术异常")
except Exception as e:
# 其他异常
print("未知异常:", e)
#*************end*************#
从键盘读取2个数，输出商。当输入数字有误时，捕获异常，并按要求输出异常对象属性。
'''教材例10.7，访问异常信息示例
（1）从键盘输入两个数，计算并输出商值。
（2）如果输入的不是数字，是字母，或者输入的除数为0，程序将处理该异常，
（3）如果程序运行时出现其他异常，程序将处理该异常
'''
#*************begin*************#
#1.try语句块
try:
# 从键盘输入两个数值
num1 = int(input("输入被除数："))
num2 = int(input("输入除数："))
# 计算并输出商值
result = num1 / num2
print("您输入的两个数相除的结果是：", result)
#2.except语句块，当发生数字异常或除数为0异常时，输出提示信息及异常相关属性
except (ValueError, ZeroDivisionError) as e:
print("程序发生了数字格式异常,或者算术异常")
#3.输出异常的描述字符串,即异常对象的args属性
print(e.args)
#4.输出异常对象字符串
print(str(e))
#5.输出较全的异常信息，包括异常信息的类型
print(repr(e))
#6.except语句块，输出提示信息"未知异常"
except Exception as e:
print("未知异常")
#*************end*************#
掌握try…except…else…finally结构处理异常。
#理解try…except…else…finally异常处理结构，根据提示补充代码：
#*************begin*************#
#1.try语句块
try:
data={'金刚川':['张译','吴京'],
'八佰':['黄志忠','欧豪','王千源'],
'卧龙藏虎':['章子怡','周润发','杨祡琼']}
data["无问西东"]
#2.IndexError,KeyError类型的异常处理
except (IndexError, KeyError) as e:
print("IndexError异常或者KeyError异常")
#3.其它异常语句块
except Exception as e:
print(e)
#4.没有异常处理
else:
print("没有异常")
#5.回收资源处理（不管有没有异常都运行）
finally:
print("不管有没有错，都执行finally")
#*************end*************#
自定义异常类示例，如果输入的年龄不在0到120的范围内，则抛出异常。
'''教材例10.12，自定义异常类示例，如果输入的年龄不在0~120的范围内，则抛出异常自定义异常MyError。'''
#**************Begin***************#
#1.自定义异常类MyError，写初始化方法获得实例属性age，重写特殊方法__str__返回对象的实例属性age
class MyError(Exception):
def __init__(self, age):
self.age = age
def __str__(self):
return "'年龄只能在0~120之间'"
#2.try语句块：接受键盘输入年龄，利用raise语句触发自定义异常MyError。
try:
age = int(input("请输入年龄："))
if age < 0 or age > 120:
raise MyError(age)
#3.except语句块：如果发生MyError异常，则输出类对象
except MyError as e:
print(e)
#**************End***************#
计算100与某数相除的商，程序能获取异常信息。
'''注意：下列代码行之间不要出现空行！！！'''
#1.导入sys模块
import sys
#2.导入traceback模块
import traceback
#3.try代码块，输入除数x，输出100与x之商，输入输出格式见测试说明。
try:
x = int(input("请输入除数："))
print("100除以"+str(x)+"等于：",100/x)
#4.except代码块，输出sys.exc_info()元组中异常实例（即第2个元素），输出出错的行数、位置等数据，输出格式见测试说明 。
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
print(exc_value)
traceback.print_tb(exc_traceback)
print("异常")
从键盘输入一个数，判断正负性，断言为正数，成立则输出该数，否则输出提示信息。
'''从键盘输入一个数，判断正负性，断言为正数，成立则输出该数，否则输出提示信息'''
#1.从键盘输入一个数赋值给变量x
x = int(input("请输入一个正数："))
#2.try代码块，断言x>0，并输出x
try:
assert x > 0
print(x)
#3.except代码块，断言不成立，则输出提示信息。
except AssertionError:
print("请输入一个正数！")
设计一个Person类，包含名字、性别、体重属性，设计方法描述运动对体重的影响，每次运动会减肥0.2公斤，每次吃东西体重会增加0.25公斤，打印对象的具体属性值。
'''参考实验教材第10章案例：
（1）定义Person类，写构造方法、实例方法sport()与food()、特殊方法__str__().
（2）将类实例化，并执行food和sport方法
（3）打印类的实例化对象'''
class Person:
# 1.定义构造方法__init__()，用来初始化实例属性name，sex，weight。
def __init__(self, name, sex, weight):
self.name = name
self.sex = sex
self.weight = weight
# 2.定义实例方法sport(),用来执行运动，并且weight的值减少0.2公斤。
def sport(self):
self.weight -= 0.2
# 3.定义实例方法food(),用来执行吃东西，并且weight的值增加0.25公斤。
def food(self):
self.weight += 0.25
# 4.定义特殊方法__str__()，用来打印对象的具体属性值。
def __str__(self):
return f"姓名：{self.name}\n性别：{self.sex}\n体重：{self.weight}公斤"
# 5.类的实例化，三个属性分别为'Xiaoming','male',70
p=Person('Xiaoming','male',70)
# 6.对象p执行food方法
p.food()
# 7.对象p执行sport方法
p.sport()
# 8.打印对象p
print(p)
设计一个游戏类Game，记录各玩家的姓名，记录游戏历史最高分，能够显示游戏的帮助信息，显示历史最高分，执行当前玩家的游戏。
'''
（1）定义Game类，初始化类属性和实例属性
（2）定义构造方法、静态方法、类方法、实例方法、特殊方法
（3）设计主程序步骤，首先创建游戏对象，然后查看帮助信息，开始游戏，最后查看历史最高分。
'''
class Game:
high_score=0 # 游戏最高分，类属性
score=0 # 分数，实例属性
# 1.定义构造方法__init__()，用来初始化实例属性player_name。
def __init__(self, player_name):
self.player_name = player_name
# 2.定义静态方法display_help，用来输出帮助提示"游戏帮助信息：猫和老鼠"。
@staticmethod
def display_help():
print("游戏帮助信息：猫和老鼠")
# 3.定义类方法display_highscore，用来输出显示游戏最高分，类方法需要使用类属性high_score。
@classmethod
def display_highscore(cls):
print(f"游戏最高分是{cls.high_score}")
# 4.定义实例方法start_game,用来执行当前玩家的游戏，输出play_name开始游戏，最高分和分数均为98
def start_game(self):
print(f"[{self.player_name}]开始游戏……")
self.__class__.high_score = 98
self.score = 98
# print("最高分：", self.high_score)
# print("当前分数：", self.score)
# 5.定义特殊方法__repr__方法,对实例化对象进行“自我描述”。
def __repr__(self):
return f"包含属性name={self.player_name}和score={self.score}"
# 6.创建类的实例
g=Game("Eric")
# 7.调用静态方法display_help
Game.display_help()
# 8.调用实例方法start_game
g.start_game()
# 9.打印实例
print(g)
# 10.调用类方法display_highscore
Game.display_highscore()
定义Person类，拥有姓名和年龄属性，其中年龄为私有属性，然后提供相应的方法用来访问和设置私有属性(使用@property装饰器)。提供show()方法输出所有属性的值。派生出Worker类，增加薪水属性，重定义show()方法输出所有属性的值。
参考实验教程第10章案例3
'''
（1）定义Person类：包含name、 age属性，分别表示姓名和年龄，其中age为私有属性；
(2) 定义构造方法__init__(self, name, age)，用来初始化实例属性。
(3) 使用@property装饰器，定义方法def age(self): 用来返回age的值。
(4) 使用@age.setter，定义方法def age(self, age):用来设置age的值。
(5) 定义方法def show(self):输出属性的值。
'''
class Person:
def __init__(self, name, age):
self.name = name
self.__age = age # 私有属性
@property
def age(self):
return self.__age
@age.setter
def age(self, age):
self.__age = age
def show(self):
print(self.name, self.age)
'''
(6)派生出Worker类：包含name、age、salary属性。
(7)重定义show()方法。'''
class Worker(Person):
def __init__(self, name, age, salary):
super().__init__(name, age)
self.salary = salary
def show(self):
super().show()
print(self.salary)
'''
(8)设计主程序步骤，首先创建Worker类的对象，输出属性age的值；修改属性age的值为23并输出查看age的值。
(9) 调用show方法'''
p=Worker("Xiaoming",22,10000)
print(p.age)
p.age = 23
print(p.age)
p.show()
定义Person类，具有姓名和年龄属性，具有交谈(talk)的功能。派生出中国人(ChPerson)类，增加语言属性并赋值为“chinese”，重写talk方法，表示使用chinese进行交谈。增加用筷子吃饭的方法。
# 1.定义Person类，具有姓名和年龄属性，具有交谈（talk）的功能。
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def talk(self):
pass
# 2.派生出中国人（ChPerson）类，增加语言属性并赋值为“chinese”,重写talk方法，表示 使用Chinese进行交谈。增加筷子吃饭的方法。
class ChPerson(Person):
def __init__(self, name, age):
super().__init__(name, age)
self.language = "Chinese"
print(self.name, self.age, self.language)
def talk(self):
print(f"{self.name} is speaking {self.language}")
def eat(self):
print("is eating with chopsticks")
# 3.创建ChPerson实例，属性为"Lili",22
p = ChPerson("Lili", 22)
# 4.执行talk方法
p.talk()
# 5.执行eat方法
p.eat()
定义Vector矢量类，对运算符重载，实现矢量的相加和相减。
# 1.定义Vector矢量类，对运算符重载，实现矢量的相加和相减
class Vector:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Vector(self.x + other.x, self.y + other.y)
def __sub__(self, other):
return Vector(self.x - other.x, self.y - other.y)
def __str__(self):
return "Vector({},{})".format(self.x, self.y)
# 2.创建矢量对象v1，坐标为(2,8)
v1 = Vector(2, 8)
# 3.创建矢量对象v2，坐标为(6,-2)
v2 = Vector(6, -2)
# 4.输出v1和v2之和
v_sum = v1 + v2
print(v_sum)
# 5.输出v1和v2之差
v_diff = v1 - v2
print(v_diff)
定义交通工具类，具有交通工具名称属性，提供描述交通工具在行驶的方法；派生出货车和火车类，货车类增加载重属性，火车类增加车厢数目的属性。重写父类的描述行驶的方法，其中货车类增加对载重属性的描述，火车类增加对车厢数目的描述。
# 1.定义交通工具类，具有交通工具名称属性，提供描述交通工具在行驶的方法
class Vehicle:
def __init__(self, name):
self.name = name
def run(self):
print("在行驶")
# 2.派生出货车类，增加载重属性weight,重写run方法
class Truck(Vehicle):
def __init__(self, name, weight):
super().__init__(name)
self.weight = weight
def run(self):
print("卡车{}，载重{}".format(self.name, self.weight), end="，")
super().run()
# 3.派生出火车类，增加车厢数目属性,重写run方法
class Train(Vehicle):
def __init__(self, name, num_cars):
super().__init__(name)
self.num_cars = num_cars
def run(self):
print("火车{}，车厢个数{}".format(self.name, self.num_cars), end="，")
super().run()
# 4.创建货车对象，属性为（'东风牌',15），并执行run方法
truck = Truck("东风牌", 15)
truck.run()
# 5.创建火车对象，属性为('和谐号',12)，并执行run方法
train = Train("和谐号", 12)
train.run()
假设共有10个裁判，每个裁判给该参赛选手打分（分值在0~10之间）后，去掉一个最高分和一个最低分之后的平均分即为该运动员的最后得分。
'''
（1）从键盘输入文件名
（2）读取输入的文件名中的分数（以空格分隔）
（3）去掉一个最高分和一个最低分
（4）计算平均分，并按要求格式输出结果（保留2位小数）
'''
#######begin########
filename = input("")
with open(filename, 'r') as file:
scores = file.readline().split()
scores = list(map(float, scores))
scores.remove(max(scores))
scores.remove(min(scores))
average_score = sum(scores) / len(scores)
final_score = round(average_score, 2)
print(f"filename=最后得分：{final_score}")
########end#########
某些文件中每一行内容分别为购买的商品名称、价格、数量，三项数据之间以空格分隔，读出文件内容，计算所有商品的总费用。
'''
（1）从键盘输入文件名
（2）该文件中每一行内容分别为购买的商品名称、价格、重量
（3）读取文件中商品价格和重量，计算所有商品总价钱
'''
########begin#########
filename = input("")
total_cost = 0
with open(filename, 'r') as file:
lines = file.readlines()
for line in lines:
data = line.split()
price = float(data[1])
quantity = float(data[2])
total_cost += price * quantity
formatted_total_cost = "{:.1f}".format(total_cost)
if formatted_total_cost.endswith('.0'):
formatted_total_cost = formatted_total_cost[:-2]
print(f"filename=总费用={formatted_total_cost}")
########end#########
读取某英文文章，统计文件中行数hs和单词个数dc。
'''
（1）从键盘输入某文件名
（2）读取该文件，统计并返回文件中行数和单词个数。
'''
filename = input("")
line_count = 0
word_count = 0
with open(filename, 'r') as file:
lines = file.readlines()
line_count = len(lines)
for line in lines:
words = line.split()
word_count += len(words)
print(f"本文有{line_count}行，{word_count}个单词")
编写程序随机产生100个两位正整数，并将这100个数写入文本文件number.txt中。要求每行10个整数，整数之间用一个空格分隔。
'''自定义函数return_values功能：
（1）编写程序随机产生100个两位正整数，并将这100个数写入文本文件number.txt中
（2）要求每行10个整数，整数之间用一个空格分隔。
本程序无须调用该函数，系统将自动检测函数是否正确。
'''
def return_values():
##########Begin###########
#（1）导入random
import random
#（2）产生100个随机数，放入列表data中
data = []
# 产生100个两位正整数
for _ in range(100):
num = random.randint(10, 99)
data.append(num)
#（3）打开文件，写入以上随机数，要求每行10个数，以空格分隔。
with open("number.txt","w",encoding="utf8") as f:
for i in range(0, len(data), 10):
line = ' '.join(map(str, data[i:i+10]))
f.write(line + '\n')
return_values()
############End#############
（1）文件website存放的是网站名称
（2）文件url存放的是网站的网址
（3）编写程序将这两个文件内容合并后保存至一个新的文件内
'''
完善自定义函数return_values
（1）分别读取文件website.txt中的内容和文件url.txt中的内容，
（2）并将2个文件中的第1行与第1行文字用半角逗号相连写入新的文件new.txt第1行，
其它行执行相同的操作。
无须调用return_values，系统将检查函数功能是否正确。
'''
def return_values():
###########Begin###########
with open("website.txt", "r") as file1, open("url.txt", "r") as file2, open("new.txt", "w") as file3:
lines1 = file1.readlines()
lines2 = file2.readlines()
# 合并内容并写入新文件
for line1, line2 in zip(lines1, lines2):
merged_line = f"{line1.strip()},{line2.strip()}\n"
file3.write(merged_line)
############End###########
文件cjd.txt保存了学生的平时成绩和期末成绩，内容如下：
'''自定义函数return_values功能：
（1）读取cjd.txt文件，计算总评成绩
（2）并将新的数据写入cjd_t.txt文件中。
本程序无须调用该函数，系统将自动检测函数是否正确。
'''
def return_values():
###########Begin############
#（1）导入csv模块
import csv
#（2）打开cjd.txt文件,encoding="utf8",读取行记录，计算并添加总评成绩
with open("cjd.txt","r",encoding="utf8") as f:
# 读取文件内容
reader = csv.reader(f)
next(reader) # 跳过第一行表头
data = list(reader)
# 计算总评成绩
for i in data:
score = round(float(i[1])*0.4+float(i[2])*0.6,2)
i.append(str(score))
#（3）按总评成绩降序排列，并且添加表头数据
# 按总评成绩降序排列
data.sort(key=lambda x: float(x[3]), reverse=True)
#（4）将新的数据写入cjd_t.txt文件中
with open("cjd_t.txt", "w", encoding="utf8", newline="") as f:
# 添加表头数据
data.insert(0, ["学号", "平时成绩", "期末成绩", "总评成绩"])
# 写入新文件
writer = csv.writer(f)
writer.writerows(data)
###########End############
设计一个简单的GUI事件驱动程序,运行程序打开左图窗口，单击“点我"按钮。
#导入模块
import tkinter as tk
from tkinter import *
import tkinter.messagebox
#下面的代码写在test函数中，请注意缩进
def test():
#*************Begin*****************#
#创建主窗口，定义窗口标题和大小
root = tk.Tk()
root.title("主窗口")
root.geometry("500x500")
#自定义函数hit_me
def hit_me():
global s #该语句不能删除
#调用普通消息框，赋值给变量s，请补充下面语句中括号内的参数
s=tkinter.messagebox.showinfo("Hi", "你好！" )
# 设置标签文本、位置、间距
label = tk.Label(root, text="欢迎使用《Python应用程序设计》")
label.pack()
# 设置按钮1的文本、颜色、事件、位置
button1 = tk.Button(root, text='点我', bg='Pink', font=('楷体', 14),command=hit_me)
button1.pack(side=LEFT)
# 设置按钮2的文本、颜色、事件、位置
button2 = tk.Button(root, text="退出", bg='Pink', font=('楷体', 14),command=root.quit)
button2.pack(side=RIGHT)
#事件触发主循环
root.mainloop()
#*************End*****************#
编写一个只能做加法运算的计算器程序。
from jsq_test import test_num
# 导入标准模块-图形用户接口
from tkinter import *
#创建窗口，设置好窗口标题
root = Tk()
root.title("计算器")
# 创建框架
frame = Frame(root)
#定义三个StringVar对象，存储加数v1、被加数v2、和v3。
v1 = StringVar()
v2 = StringVar()
v3 = StringVar()
#验证参数是否为数字的函数
def test(content):
return content.isdigit()
#用register方法将验证函数包装
testCMD = root.register(test)
#设置第一个文本框
e1 = Entry(frame, width=10, textvariable=v1, validate='key', validatecommand=(testCMD, '%P')).grid(row=0, column=0)
#设置“+”标签
label_plus = Label(frame, text="+")
label_plus.grid(row=0, column=1)
#设置第二个文本框
e2 = Entry(frame, width=10, textvariable=v2, validate='key', validatecommand=(testCMD, '%P'))
e2.grid(row=0, column=2)
#设置“=”标签
label_equal = Label(frame, text="=")
label_equal.grid(row=0, column=3)
#设置结果标签
label_result = Label(frame, width=10, textvariable=v3)
label_result.grid(row=0, column=4)
#计算和的函数
def calc():
num1 = int(v1.get())
num2 = int(v2.get())
result = num1 + num2
v3.set(result)
#不要修改下面两行语句
tag=test_num(result,int(v1.get()),int(v2.get()))
if tag==1: sys.exit()
#不要删除上面两行语句
#设置“计算结果”按钮
button_calc = Button(frame, text="计算结果", command=calc)
button_calc.grid(row=1, columnspan=5, pady=10)
frame.pack()
#窗口消息主循环
root.mainloop()
依照案例教程例6-2，用多边形函数绘制各种多边形图形。
# -*- coding: utf-8 -*-
import turtle
#【绘制三角形】
turtle.pensize(3)
turtle.penup()
turtle.goto(-100,-50)
turtle.pendown()
turtle.begin_fill()
turtle.color("red")
turtle.circle(40,steps=3)
turtle.end_fill()
#【绘制圆形】
turtle.penup()
turtle.goto(0, -50)
turtle.pendown()
turtle.begin_fill()
turtle.color("yellow")
turtle.circle(50)
turtle.end_fill()
#【绘制六边形】
turtle.penup()
turtle.goto(100, -50)
turtle.pendown()
turtle.begin_fill()
turtle.fillcolor("green")
turtle.circle(40, steps=6)
turtle.end_fill()
#【绘制文字】
turtle.penup()
turtle.goto(-100, 100)
turtle.pendown()
turtle.color("blue")
turtle.write("各种形状的图形", font=("Times", 18, "bold"))
turtle.end_fill()
#隐藏画笔光标
turtle.hideturtle()
#***********请不要修改、删除下面三行代码********
#保存图形
ts=turtle.getscreen()
ts.getcanvas().postscript(file="tu1/result/result.ps")
turtle.bye()
绘制一个黄色边内部填充红色的五角星。
import turtle
turtle.pensize(5)
turtle.pencolor("yellow")
turtle.fillcolor("red")
turtle.begin_fill()
for _ in range(5):
turtle.forward (200)
turtle.right(144)
turtle.end_fill()
turtle.penup()
turtle.goto(-150,-120)
turtle.color( "violet")
turtle.write("五角星",font=("simhei",30))
#***********请不要修改、删除下面三行代码********
#保存图形
ts=turtle.getscreen()
ts.getcanvas().postscript(file="tu2/result/result.ps")
turtle.bye()
（1）利用Turtle模块绘制一个太极图，绘图步骤见下图。
（2）太极图是一个对称图形，可以定义一个yin()函数绘制左半边的图形，然后在调用函数绘制另外右半边的图形。
（3）太极图左右两边的颜色相反，因此需要调用函数两次，并且传递的填充颜色参数是相反的。
from turtle import *
#绘制半边太极图函数
def yin(radius, color1, color2):
width(3)
color("black",color1)
begin_fill()
circle(radius/2.,180)
circle(radius,180)
left(180)
circle( -radius/2.,180)
end_fill()
left(90)
up()
forward(radius*0.35)
right(90)
down()
color(color1,color2)
begin_fill()
circle(radius*0.15)
end_fill()
left(90)
up()
backward(radius*0.35)
down()
left(90)
#主函数
def main():
reset()
yin(200, "black" , "white")
yin(200 , "white", "black")
ht()
return "Done!"
if __name__ == '__main__':
main()
# mainloop()
#***********请不要修改、删除下面三行代码********
#保存图形
ts=getscreen()
ts.getcanvas().postscript(file="tu3/result/result.ps")
bye()
Koch曲线绘制图形，程序的输入为：递归深度n（整数）、线段长度size、起点坐标、终点坐标、旋转角度等参数。。
import turtle
#定义科赫函数
def Koch(size, n):
if n == 0:
turtle.forward(size)
else:
for angle in [0, 60, -120,60]:
turtle.left(angle)
Koch(size / 3, n - 1)
#主函数
def main():
turtle.setup(600,600)
turtle.penup()
turtle.goto(-200,100)
turtle.pendown()
turtle.pensize(2)
level=2
Koch(400,level)
turtle.right(120)
Koch(400,level)
turtle.right(120)
Koch(400,level)
main()
#***********请不要修改、删除下面三行代码********
#保存图形
ts=turtle.getscreen()
ts.getcanvas().postscript(file="tu4/result/result.ps")
turtle.bye()
利用递归函数绘制一个分形树，绘制顺序如图。
import turtle
#定义分形树绘制递归函数
def draw_branch(L):
if L>=5:
turtle.forward(L)
turtle.right(20)
draw_branch(L-5)
turtle.left(40)
draw_branch(L-5)
turtle.right(20)
turtle.backward(L)
#主函数
def main():
turtle.penup()
turtle.backward(50)
turtle.pendown()
turtle.left(90)
turtle.pencolor("red")
#调用递归函数绘制分开树，树枝起始长度L=30
draw_branch(30)
#turtle.exitonclick()
#程序入口，调用主函数
if __name__ == '__main__':
main()
#***********请不要修改、删除下面三行代码********
#保存图形
ts=turtle.getscreen()
ts.getcanvas().postscript(file="tu5/result/result.ps")
turtle.bye()
基于SQLite3的通讯录管理系统
'''
请完成《Python程序设计实验教程》P95页12.3 实验内容中第1题。
编写一个基于SQLite3的通讯录管理系统。
本系统能实现添加记录、修改记录、删除记录、查询记录基本功能
'''
import sqlite3
#*************************Begin********************************#
connect = sqlite3.connect("txlglxt.db")
cursor = connect.cursor()
cursor.execute("drop TABLE IF EXISTS tongxunlu")
#1.打开数据库子函数
def opendb():
connect = sqlite3.connect("txlglxt.db")
cursor = connect.cursor()
cursor.execute("""
CREATE TABLE IF NOT EXISTS tongxunlu (
usernum INTEGER PRIMARY KEY,
username VARCHAR(128),
password VARCHAR(128),
address VARCHAR(128),
telnum VARCHAR(128)
)""")
return cursor, connect
#2.显示数据表中记录
def showalldb():
print("----处理后的数据----")
cursor, connect = opendb()
cursor.execute("SELECT * FROM tongxunlu")
res = cursor.fetchall()
for line in res:
for h in line:
print(h)
cursor.close()
connect.close()
#3.输入记录信息
def into():
usernum = int(input("请输入学号:"))
username = input("请输入姓名:")
password = input("请输入密码:")
address = input("请输入地址:")
telnum = input("请输入联系电话:")
return usernum, username, password, address, telnum
#4.向数据库添加记录子函数
def adddb():
welcome = "-----添加数据功能------"
print(welcome)
person = into()
cursor, connect = opendb()
cursor.execute("""
INSERT INTO tongxunlu (usernum, username, password, address, telnum)
VALUES (?, ?, ?, ?, ?)
""",
(person[0], person[1], person[2], person[3], person[4]))
connect.commit()
print("---提交成功---")
showalldb()
cursor.close()
connect.close()
#5.按学号删除数据库中的记录
def deldb():
welcome = "---数据库删除功能---"
print(welcome)
delchoice = input("请输入要删除的学号:")
cursor, connect = opendb()
cursor.execute("DELETE FROM tongxunlu WHERE usernum=" + delchoice)
connect.commit()
print("----数据删除成功-----")
showalldb()
cursor.close()
connect.close()
#6.输入学号，修改数据库中的记录
def alterdb():
print("------数据库修改功能------")
alterchoice = input("请输入要修改数据的学生学号:")
cursor, connect = opendb()
person = into()
cursor.execute("""
UPDATE tongxunlu
SET usernum=?, username=?, password=?, address=?, telnum=?
WHERE usernum=?
""",
(person[0], person[1], person[2], person[3], person[4], alterchoice))
connect.commit()
showalldb()
cursor.close()
connect.close()
print("------数据修改成功------")
#7.按学号查询数据库中的记录
def searchdb():
cursor, connect = opendb()
cursor.execute("SELECT * FROM tongxunlu")
choice = input("请输入要查询的学生学号:")
res = cursor.fetchall()
print("---查询数据显示如下---")
for row in res:
if row[0] == choice:
print(row[0], row[1], row[2], row[3], row[4])
cursor.close()
connect.close()
#8.是否继续子函数
def conti():
choice = input("请输入你的选项（y/n或Y/N）")
if choice.lower() == 'y':
return True
else:
return False
'''以下为程序的主入口，为了测试程序方便，语句if __name__=="__main__":被注释，
改为主函数
def main():
'''
#if __name__=="__main__":
def main():
flag = True
while flag:
print("---数据库通讯录---")
menu = """
--菜单--
1-添加数据记录
2-删除数据记录
3-修改数据记录
4-查询数据记录
5-退出
请输入你的选择:"""
choice = input(menu)
if choice == "1":
while True:
adddb()
if not conti():
break
elif choice == "2":
while True:
deldb()
if not conti():
break
elif choice == "3":
while True:
alterdb()
if not conti():
break
elif choice == "4":
while True:
searchdb()
if not conti():
break
elif choice == "5":
flag = False
else:
print("输入错误，请重新输入!")
#**************************End*********************************#
#调用主函数
#main()
本关任务：创建一个sqlite3数据库文件mytest.db，再创建一个数据表mytb.db，往表里插入三行记录。
#（1）导入sqlite3模块
import sqlite3
#（2）创建数据库文件mytest.db
conn = sqlite3.connect('mytest.db')
#（3）定义一个游标对象
cursor = conn.cursor()
#（4）定义创建数据表SQL语句
create_table_sql = '''CREATE TABLE IF NOT EXISTS mytb (
name TEXT,
score INTEGER,
major TEXT
);'''
#（5）执行SQL语句，创建数据表mytb
cursor.execute(create_table_sql)
#（6）依次插入3条记录，内容分别为：('宝玉',85,'计算机')、('黛玉',92,'计算机')、('宝钗',80,'数据库')
records = [('宝玉', 85, '计算机'),
('黛玉', 92, '计算机'),
('宝钗', 80, '数据库')]
for record in records:
insert_sql = f"INSERT INTO mytb VALUES (?, ?, ?)"
cursor.execute(insert_sql, record)
#（7）提交事务
conn.commit()
#（8）关闭连接
conn.close()
本关任务：设计一个程序，查询已有数据库文件myfile.db中数据表mytb中所有记录，及查询数据表结构。
#（1）导入sqlite3模块
import sqlite3
#（2）打开数据库文件myfile.db
conn = sqlite3.connect('myfile.db')
#（3）定义一个游标对象
cursor = conn.cursor()
#（4）查询数据表mytb中所有记录，并赋值给列表
cursor.execute("SELECT * FROM mytb")
records = cursor.fetchall()
#（5）输出记录数
print("共", len(records), "条记录")
#（6）输出所有记录列表
print(records)
#（7）从sqlite_master表中查询数据表的名称和创建时的sql语句，查询结果赋值给列表，并输出列表内容
cursor.execute("SELECT name, sql FROM sqlite_master WHERE type='table' AND name='mytb'")
table_info = cursor.fetchall()
print(table_info)
本关任务：在sqlite数据库中更新和删除记录。
#（1）导入sqlite3模块
import sqlite3
#（2）打开数据库my.db
conn = sqlite3.connect('my.db')
#（3）定义游标
cursor = conn.cursor()
#（4）更新记录，将xm“宝玉”的成绩cj改为0
cursor.execute("UPDATE mytb SET cj = 0 WHERE xm = '宝玉'")
#（5）删除成绩cj>90的记录
cursor.execute("DELETE FROM mytb WHERE cj > 90")
#（6）删除数据表mytb中所有记录
cursor.execute("DELETE FROM mytb")
#（7）删除整个数据表mytb
cursor.execute("DROP TABLE IF EXISTS mytb")
#（8）提交事务
conn.commit()
#（9）关闭游标
cursor.close()
#（10）关闭数据库连接
conn.close()
本关任务：在SQLite中创建数据库mybook.db；在数据库中创建数据表mytb；在表中定义：isbn（text）、书名（text）、价格（real）等字段，并插入记录。
#（1）导入sqlite3模块
import sqlite3
#（2）创建数据库mybook.db
conn = sqlite3.connect('mybook.db')
#（3）定义游标对象
cursor = conn.cursor()
#（4）创建表mytb
create_table_sql = '''CREATE TABLE IF NOT EXISTS mytb (
isbn TEXT,
title TEXT,
price REAL
);'''
cursor.execute(create_table_sql)
#（5）插入记录('9787302518358','欧美戏剧选读',88.00)
records = [('9787302518358', '欧美戏剧选读', 88.00),
('9787302454038', '组织理论与设计 第12版', 75.00),
('9787302496878', '中国文化经典读本', 45.00)]
#（6）插入记录('9787302454038','组织理论与设计 第12版',75.00)
#（7）插入记录('9787302496878','中国文化经典读本',45.00)
for record in records:
insert_sql = f"INSERT INTO mytb VALUES (?, ?, ?)"
cursor.execute(insert_sql, record)
#（8）提交事务，保存数据
conn.commit()
#（9）读入所有记录，将查询记录赋值给列表，遍历输出列表内容
cursor.execute("SELECT * FROM mytb")
result = cursor.fetchall()
for record in result:
print(record)
#（10）关闭游标
cursor.close()
#（11）关闭数据库
conn.close()
本关任务：创建或打开数据表示例。
#（1）导入sqlite3模块
import sqlite3
#（2）创建conn连接对象，建立mytest.db数据库
conn = sqlite3.connect('mytest.db')
drop_table_sql = "DROP TABLE IF EXISTS mytb;"
conn.execute(drop_table_sql)
#（3）定义sql语句，创建mytb数据表，表中有三个字段xm、cj、kc,其数据类型分别为char、real、text
create_table_sql = '''CREATE TABLE IF NOT EXISTS mytb (
xm CHAR,
cj REAL,
kc TEXT
);'''
#（4）执行sql语句
conn.execute(create_table_sql)
#（5）关闭连接
conn.close()
本关任务：在D盘新建ks文件夹及如下图6个子文件夹.
'''#注意，下面函数中字符串参数一律用双引号'''
#（1）导入os模块
import os
#（2）在D盘下的“ks”中创建“bady”子文件夹
os.makedirs("D:\\ks\\bady")
#（3）在D盘下的“ks”中创建“head”子文件夹
os.makedirs("D:\\ks\\head")
#（4）在D盘下的“ks”中创建“play”子文件夹
os.makedirs("D:\\ks\\play")
#（5）在D盘下的“ks”中创建“swim”子文件夹
os.makedirs("D:\\ks\\swim")
#（6）在D盘下的“ks”中创建“think”子文件夹
os.makedirs("D:\\ks\\think")
#（7）在D盘下的“ks”中创建“wrong”子文件夹
os.makedirs("D:\\ks\\wrong")
本关任务：
对D盘下文件夹“ks”，完成下列操作：
(1) 将ks下bady文件夹中的hand.txt文件移动到ks下head文件夹中，并改名为new.wri。
(2)将ks下play文件夹中的sing.bas文件复制到ks下swim文件夹中。
(3)将ks下think文件夹中的think.new文件删除。
'''#注意：下面函数调用时字符串参数一律用双引号'''
#（1）导入os模块
import os
#（2）导入shutil模块
import shutil
#（3）将D:盘ks下bady文件夹中的hand.txt文件移动到ks下head文件夹中，并改名为new.wri。
os.rename("D:\\ks\\bady\\hand.txt", "D:\\ks\\head\\new.wri")
#（4）将D:盘ks下play文件夹中的sing.bas文件复制到ks下swim文件夹中
shutil.copy("D:\\ks\\play\\sing.bas", "D:\\ks\\swim\\sing.bas")
#（5）将D:盘ks下think文件夹中的think.new文件删除
os.remove("D:\\ks\\think\\think.new")
扫一扫
893
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
