python期末编程题及答案,python编程题库及答案

2401_84503581

于 2024-05-26 16:55:30 发布

阅读量345

点赞数 3

文章标签：算法人工智能

本文链接：https://blog.csdn.net/2401_84503581/article/details/139216979

版权

本篇文章给大家谈谈python期末编程题及答案，以及python编程题库及答案，希望对各位有所帮助，不要忘了收藏本站喔。

大家好，小编来为大家解答以下问题，python期末编程题及答案，python编程题库及答案，今天让我们一起来看看吧！

课本：

🕒 1. 控制结构

【例3-6】计算分段函数值。

y = { cos ⁡ x + x 2 + 1 ( x < 0 ) x x + x ( x ⩾ 0 ) y=\left\{\begin{array}{ll} \cos x+\sqrt{x^{2}+1} & (x < 0) \\ x \sqrt{x+\sqrt{x}} & (x \geqslant 0) \end{array}\right. y={cosx+x2+1 xx+x (x<0)(x⩾0)

# import math # 之后使用方法需要math.sqrt from math import sqrt,cos # 可直接使用方法 x=eval(input('请输入x的值：')) # eval返回表达式的值 if x<0: y=cos(x)+sqrt(x*x+1) if x>=0: y=x*sqrt(x+sqrt(x)) print('x={},y={:.3}'.format(x,y)) # y保留三位

【例3-7】简化PM 2.5空气质量提醒： 0~35为优，35~75为良，75以上为污染python技术开发高级证书。试根据输入的PM2.5数值，输出空气质量。

PM=eval(input("请输入PM2.5数值: ")) if PM>=0 and PM<35: print("空气优质，快去户外运动!") if PM>=35 and PM<75: print("空气良好，适度户外活动！") if PM>=75: print("空气污染，出行请小心！")

☆【例3-13】计算1+2!+3!+…+10!的结果。

s=0 t=1 for i in range(1,11): t=t*i s=s+t print("运算结果是：{}".format(s))

输出结果：运算结果是：4037913

【例3-14】采用while语句计算1至100的和。

sum=0 n=1 while n<=100: sum+=n n=n+1 print("1+2+3+…+100=", sum)

【例3-15】采用while语句输出四叶玫瑰数。四叶玫瑰数是指一个四位整数，其各位上数字的四次方（四次幂）之和等于该数本身。

n=1000 while n<10000: one=n%10 ten=n//10%10 hundred=n//100%10 thousand=n//1000 if one**4+ten**4+hundred**4+thousand**4==n: print(n) n+=1

输出结果：1634、8208、9474

【例3-16】采用while语句根据近似公式求自然对数的底数为e的值，直到最后一项绝对值小于10-6为止。

e ≈ 1 + 1 1 ! + 1 2 ! + . . . + 1 n ! e\approx 1+\frac{1}{1!} +\frac{1}{2!} + ... + \frac{1}{n!} e≈1+1!1+2!1+...+n!1

e=1 n=1 m=1 while (1/n >= pow(10, -6)): n*=m # 求阶乘 e+=1/n m+=1 print("e =", e)

输出结果：e = 2.7182818011463845

【例3-27】编程判断某一年是否为闰年。判断闰年的条件是：年份能被4整除但不能被100整除，或者能被400整除的是闰年。

#使用一个逻辑表达式判断闰年条件 y=int(input("请输入年份：")) if ((y%4==0 and y%100 != 0) or y%400==0): print("是闰年") else: print("不是闰年") #使用if-elif语句判断闰年条件 y=int(input("请输入年份：")) if (y%400==0): print("是闰年") elif (y%4 != 0): print("不是闰年") elif (y%100 == 0): print("不是闰年") else: print("是闰年") #通过使用嵌套的if语句编写判断闰年问题，程序代码如下： y=int(input("请输入年份：")) if (y%400==0): print("是闰年") else: if (y%4==0): if (y%100==0):print("不是闰年") else: print("是闰年") else: print("不是闰年")

☆【例3-29】100 以内的素数存于列表中并打印输出。

num=[] for n in range(2,100): for x in range(2, n): if (n%x==0): break else: num.append(n) print(num)

输出结果：[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

【例3-32】利用公式： π 4 = 1 − 1 3 + 1 5 − 1 7 + … \frac{π}{4}=1−\frac{1}{3}+\frac{1}{5}−\frac{1}{7}+… 4π=1−31+51−71+…计算π的近似值，直到某项绝对值小于10-6为止。

s=0 #表示累加和 t=1 #表示符号 x=1 #表示要累加的项 i=1 #表示分母 while x>=1e-6: x=1/i s=s+t*x t=-t i=i+2 s=4*s print("π的近似值为：{}".format(s))

输出结果：π的近似值为：3.1415946535856922

课后综合题

1、编写程序实现以下功能：求满足1+2+3+4+…+n>2020的最小n 并输出（要求用循环实现）

n = 1 sum = 0 while sum <= 2020: sum += n n += 1 print(n - 1)

输出结果：64

2、给出一个小于1000的正整数，编程求该数是几位数，并按逆序打印出各位上的数字。例如：原数为456，则输出为654。

num = int(input("请输入一个小于1000的正整数：")) digits = 0 reverse_num = 0 while num > 0: digits += 1 # 计算数的位数 reverse_num = reverse_num * 10 + num % 10 # 取出数的最后一位并添加到反向数中 num = num // 10 # 去掉数的最后一位 print("该数的位数为：", digits) print("按逆序打印出各位上的数字为：", reverse_num)

输出结果：请输入一个小于1000的正整数：456 该数的位数为： 3 按逆序打印出各位上的数字为： 654

🕒 2. 数据类型

课后综合题： 1、现有某高校所有教职工新冠疫苗接种调查数据。列表s中的数据是教职工年龄；列表t是对应的调查结果，1表示同意接种，0表示暂不接种。请编写程序统计其中30~50 岁（包括30岁和50 岁）同意接种疫苗的教职工数。

s=[58,43,38,51,38,45,26,38,34,53] t=[1,0,1,0,1,1,0,1,1,0] count = 0 for i in range(len(s)): if s[i] >= 30 and s[i] <= 50 and t[i] == 1: count += 1 print(count)

输出结果：5

2、已知列表s=[2,0,2,0,0,5,2,3]。请编写程序实现如下功能：①按列表元素的值生成对应字符，元素的值大于0，生成对应个数的字符@，若是0，生成1个字符&；②将所有生成的字符连接成一个字符串并输出。

s = [2,0,2,0,0,5,2,3] result = "" for num in s: if num > 0: result += "@" * num else: result += "&" print(result)

输出结果：@@&@@&&@@@@@@@@@@

3、已知字符串t=“198t2845a7293R489234S892b8347348C82923”，请编写程序实现： ①将相邻的字符交换位置，即第1个和第2个，第3个和第4个，…，第n-1个和第n个交换位置； ②将所有字母转换为大写并输出。

t = "198t2845a7293R489234S892b8347348C82923" new_t = "" for i in range(0, len(t), 2): new_t += t[i+1] + t[i] new_t = new_t.upper() print(new_t)

输出结果：91T882547A92R38429438S298B4337848C9232

4、现有列表s存储的是一批字符，编写程序将其中的小写字母按先后次序连接成一个字符串，并输出。

s=['1','e','W','M','h','T','N','r','g','r'] result = "" for char in s: if char.islower(): result += char print(result)

输出结果：ehrgr

☆ 5、九九乘法表

for i in range(1, 10): for j in range(1, i+1): print('{}*{}={}\t'.format(i, j, i*j), end='') print('')

输出结果：

1*1=1 2*1=2 2*2=4 3*1=3 3*2=6 3*3=9 4*1=4 4*2=8 4*3=12 4*4=16 5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81

🕒 3. 函数

可变参数：在定义函数时，有时候我们不确定调用的时候会传递多少个参数，在 Python 中，允许使用以下两种方式解决这一问题:

包裹位置参数。在形参前增加“∗”，用来接收任意多个实参并将其放在一个元组中。包裹关键字参数。在形参前增加“∗∗”，用来接收多个关键字参数并存放在一个字典中。这两种方式统称为可变参数，也称为不定长参数。

☆【例 5-15】使用包裹位置参数来定义函数，实现给定一组数字 a, b, c…, 计算 a2 + b2 + c2 + …。

def calc(* numbers): sum = 0 for n in numbers: sum = sum + n* n return sum >>>calc(1, 2) 5 >>>calc(1, 2 , 3) 14

在参数 numbers 前面加了一个∗号，调用函数时，参数 numbers 接收到的是元组[1, 2] 或[1, 2, 3]，由此可以传入任意多个参数，包括 0 个参数。

实际上， ∗和∗∗也可以在函数调用的时候使用，这就是参数的解包裹（unpacking）。

【例 5-17】解包裹参数使用示例。

>>>def unpackage (a, b, c): print (a, b, c) >>>args = (1, 3, 4) >>>unpackage (* args)

运行结果：1 3 4

在这个例子中，所谓的解包裹就是在传递元组类型数据时，让元组的每一个元素对应一个位置参数。在调用 func 时在实参前使用∗，把实参 args 按照定义时形参的个数进行拆分，分别传递给 a, b, c。相应的，也存在对字典的解包裹，在上例中加入如下语句:

>>>dict = {'a': 1, 'b': 2, 'c': 3} >>>func(** dict)

则运行结果为：1 2 3

☆【例 5-24】计算阶乘两种方法。自定义函数：

def fac(n): result = 1 for i in range(1, n + 1): result *= i return result >>>fac(5) 120

递归函数：

def fac(n): if n==0: return 1 return n * fac(n - 1) >>> fac(1) 1 >>> fac(5) 120

猴子有一堆桃子，每天吃前一天剩下的一半多 1 个，昨天吃完发现剩了 1 个，那么 10 天前猴子有多少个桃子? 【例 5-25】使用递归解决猴子吃桃问题。思路分析: 昨天的桃子数 y 相比今天的桃子数 x 有这样的计算公式：y = (x+1)∗2，这就是递推的关系；而目前已知的是昨天吃完后剩余一个桃子，即天数 n = 1 时桃子数为 1，这可以作为终止条件。

def f(n): if n==1: return 1 else: return (f(n-1)+1)* 2 print(f(10))

运行结果：1534

课后综合题： 1、设计一个函数，参数为整数，返回斐波那契数列的前n项之和。

def fibonacci(n): if n <= 0: return 0 elif n == 1: return 1 else: return (fibonacci(n-1) + fibonacci(n-2)) def fibonacci_sum(n): total = 0 for i in range(1, n+1): total += fibonacci(i) return total print(fibonacci_sum(5))

输出结果：12

2、设计一个函数，调用该函数能够打印一个由指定字符组成的n行金字塔。其中，指定打印的字符和行数n分别由两个形参表示。

def print_pyramid(char, n): for i in range(n): print((char * (2 * i + 1)).center(2 * n - 1)) print_pyramid('*', 5)

输出结果：

* *** ***** ******* *********

3、设计一个函数，计算传入字符串中数字、字母、空格以及其他字符的个数。

def count_chars(s): counts = {"字母": 0, "数字": 0, "空格": 0, "其他": 0} for char in s: if char.isalpha(): counts["字母"] += 1 elif char.isdigit(): counts["数字"] += 1 elif char.isspace(): counts["空格"] += 1 else: counts["其他"] += 1 return counts print(count_chars("Hello World! 123"))

输出结果：{‘字母’: 10, ‘数字’: 3, ‘空格’: 2, ‘其他’: 1}

4、设计一个函数，输入参数n，判断该数是否为水仙花数。

def is_armstrong_number(n): # 将数字转换为字符串，计算数字位数 num_str = str(n) num_len = len(num_str) # 计算每个数字的 n 次方之和 total = sum(int(x) ** num_len for x in num_str) # 判断是否为水仙花数 if n == total: print(f"{n}是水仙花数") else: print(f"{n}不是水仙花数") n = 153 is_armstrong_number(n)

输出结果：153是水仙花数

5、设计一个函数，求正整数各位上的数字之和，要求递归思路实现。

def sum_digits(n): if n == 0: return 0 else: return n % 10 + sum_digits(n // 10) n = 12345 print(f"{n}的各位之和是{sum_digits(n)}")

输出结果：12345的各位之和是15

6、设计一个函数，判断一个数是否为素数；并求出所有四位数的素数。

def is_prime(n): if n < 2: return False for i in range(2, int(n**0.5)+1): if n % i == 0: return False return True for n in range(1000, 10000): if is_prime(n): print(n, end=" ")

输出结果：1009 1013 1019 1021 1031 1033 1039 1049 1051 …

🕒 4. 文件操作

file.seek()函数的功能是将文件指针定位到文件中指定字节的位置，实现文件的随机读写。读取时遇到无法解码的字符会抛出异常。seek()方法的声明：seek(offset, from)

其中，参数offset表示偏移量，即读写位置需要移动的字节数；from用于指定文件的读写位置，该参数的取值为：0、1、2，它们代表的含义如下：

0：表示文件开头1：表示使用当前读写位置2：表示文件末尾

seek()调用成功会返回当前读写位置

【例6-11】使用file.seeks()函数重定位。

str = "中国广东广州ZHKU" with open("data3.txt","w") as fw: fw.write(str) with open("data3.txt","r") as fr: print(fr.read(4)) fr.seek(0) print(fr.read(2)) fr.seek(4) print(fr.read(2)) print(fr.tell()) print(fr.seek(5,0)) # 相对文件开头进行偏移

输出结果：

中国广东中国广东 8 5

🕒 5. 面向对象

在面向对象程序设计中，用户可以先定义一个基类（也称父类），通过父类用继承的方式来定义新类。这个新类就是子类，子类可以直接使用父类中定义的属性和方法。通过继承方式，可以大大提高代码的复用率。在Python中，Object类是所有类的父类。

1、单一继承

当一个子类继承的父类只有一个时，称继承为单一继承，也叫单继承，语法格式如下：

class ChildClassName (FatherClassName): <语句> ...

在继承结构中，父类的名称需要写在括号中。

由于通过继承机制，子类可以使用父类中任何公有的属性和方法，因此，对于一个子类来说，它的属性包括自定义属性和继承属性两部分，而它的方法也包括自定义方法与继承方法两部分。下面通过一个实例给出继承的实现。

【例7-12】编写一个父类A，通过继承方式得到子类B，在子类中使用父类的属性和方法。

class FClass: def talk(self): print("People can talk.") def read(self): print("People can read.") class CClass(FClass): def eat(self): print("People can eat.") t = CClass() t.talk() t.read() t.eat()

输出结果： People can talk. People can read. People can eat.

2、多重继承 多重继承，指的是一个子类继承多个父类。多重继承的语法格式如下所示。

Class ChildClassName (FatherClass1,…,FatherClassn): <语句> …

在多重继承模式下，用户定义子类时，需要在子类名称后的括号中加入多个父类名称，各个父类名称之间用逗号区分。

☆【例7-13】编写一个类CClass，同时继承两个类FClassA和 FClassB，并在子类中调用父类中方法。

class FClassA: def Write(self): print("I can write English.") class FClassB: def Write(self): print("I can write Chinese.") def Say(self): print("I can say Chinese.") class CClass(FClassB, FClassA): def Say(self): print("I can say good-bye.") t = CClass() t.Write() t.Say()

输出结果： I can write Chinese. I can say good-bye.

分析：子类与父类方法同名，则优先子类；继承的多父类方法同名，优先调用先出现的。

🕒 6. Excel操作

☆【例8-5】有电子表格文件Student.xlsx，其内容如上图所示。请利用openPyXL访问该文件，并利用表单属性来显示文件中sheet1表单的全部内容。

import openpyxl # 打开 Excel 文件 workbook = openpyxl.load_workbook('Student.xlsx') # 获取 sheet1 sheet = workbook['Sheet1'] # 遍历 sheet1 的每一行，打印每个单元格的值 for row in sheet.iter_rows(): for cell in row: print(cell.value, end='\t') print() # 一行打印完换行

【例8-7】显示所有大英成绩，并求最大值。

import openpyxl workbook = openpyxl.load_workbook("Student.xlsx",data_only=True) sheet = workbook['Sheet1'] celldata = sheet['C3:C8'] list = [] for row in celldata: list.append(row[0].value) print(list) print(max(list))

输出结果： [85, 90, 70, 98, 46, 73] 98

🕒 7. 实验课题目合集

1、输入两个集合setA 和 setB，求它们的交集、并集和差集

setA = set(input("请输入集合A中的元素，以空格分隔：").split()) setB = set(input("请输入集合B中的元素，以空格分隔：").split()) print("集合A和集合B的并集为：", setA | setB) # 求并集 print("集合A和集合B的交集为：", setA & setB) # 求交集 print("集合A和集合B的差集为：", setA - setB) # 求差集

输出结果：

请输入集合A中的元素，以空格分隔：2 5 10 7 6 3 请输入集合B中的元素，以空格分隔：2 4 8 9 6 10 22 集合A和集合B的并集为： {'9', '22', '5', '6', '8', '3', '10', '4', '2', '7'} 集合A和集合B的交集为： {'6', '2', '10'} 集合A和集合B的差集为： {'3', '7', '5'}

2、输入一个自然数，输出它的二进制，八进制，十六进制表示形式

num = int(input("输入一个自然数：")) print("二进制表示:", bin(num)) print("八进制表示:", oct(num)) print("十六进制表示:", hex(num))

输出结果：

输入一个自然数：66 二进制表示: 0b1000010 八进制表示: 0o102 十六进制表示: 0x42

3、输入等比数列的首项、公比（不等于1且小于36的正整数）和一个自然数n，输出这个等比数列前n项的和。

a = int(input("请输入等比数列的首项：")) q = int(input("请输入等比数列的公比（不等于1且小于36的正整数）：")) n = int(input("请输入自然数n：")) # 计算前n项的和 sum = a * (1 - q**n) // (1 - q) # 直接输出结果 print("前",n,"项的和为：", sum)

输出结果：

请输入等比数列的首项：2 请输入等比数列的公比（不等于1且小于36的正整数）：2 请输入自然数n：5 前 5 项的和为： 62

☆ 4、用蒙特卡罗方法，计算圆周率的近似值。（提示：用单位圆的模型）

import random # 生成n个随机点，判断是否落在圆内 def monte_carlo_pi(n): count = 0 for i in range(n): x = random.uniform(-1, 1) y = random.uniform(-1, 1) if x**2 + y**2 <= 1: count += 1 # 返回估算值 return 4 * count / n # 4个1/4圆 # 输入随机点个数并计算圆周率的值 n = int(input("请输入随机点个数：")) print("使用蒙特卡罗方法估算的圆周率值为：", monte_carlo_pi(n))

输出结果：

请输入随机点个数：100000 使用蒙特卡罗方法估算的圆周率值为： 3.14472

5、使用列表实现筛选法求素数：输入一个大于2的自然数，然后输出小于该数字的所有素数组成的列表

def isPrime(n): if n < 2: return [] primes = [True] * (n+1) # 将0到n的每个整数都标记位素数 primes[0] = primes[1] = False # 0和1是合数 for i in range(2, int(n**0.5)+1): # 从2开始遍历到根号n if primes[i]: for j in range(i*i, n+1, i): # 素数的倍数都是合数 primes[j] = False return [i for i in range(2, n+1) if primes[i]] n = int(input("请输入一个大于2的自然数：")) print(f"小于{n}的素数列表为：{isPrime(n)}")

输出结果：

请输入一个大于2的自然数：20 小于20的素数列表为：[2, 3, 5, 7, 11, 13, 17, 19]

☆ 6、Caesar密码

print("请输入明文") s=input() print("请输入密钥（数字）") k=int(input()) t = '' for i in s: if 'A' <= i <= 'Z': t += chr(ord('A')+((ord(i)-ord('A'))+k)%26) elif 'a'<= i <='z': t += chr(ord('a')+((ord(i)-ord('a'))+k)%26) else: t += i print(t)

输出结果：

请输入明文 hello world 请输入密钥（数字） 3 khoor zruog

☆ 7、用 try --finally 结构，实现一个文件的打开，读取和关闭的全过程。

try: file = open("D:\\text.txt", "r") content = file.read(5) print(content) finally: file.close()

☆ 8、检测密码安全的强度。

def check_password_strength(password): # 定义一个密码强度级别列表 levels = ["弱", "中", "强"] # 定义一个变量，用于统计密码强度得分 score = 0 # 检查密码长度 if len(password) < 6: score += 1 # 检查密码中是否包含数字 if any(char.isdigit() for char in password): score += 1 # 检查密码中是否包含小写字母 if any(char.islower() for char in password): score += 1 # 检查密码中是否包含大写字母 if any(char.isupper() for char in password): score += 1 # 检查密码中是否包含特殊字符 if any(char in "!@#$%^&*()-+_=\\[]{}|;:'\",.<>/?`~" for char in password): score += 1 # 根据密码强度得分，返回相应级别 if score <= 2: return levels[0] elif score == 3: return levels[1] else: return levels[2] password = input("请输入密码：") strength = check_password_strength(password) print("密码强度为：", strength)

输出结果：

请输入密码：Abc123 密码强度为：中

9、用numpy实现单位矩阵和矩阵的乘积。

import numpy as np # 创建 3x3 的单位矩阵 I = np.identity(3) # 创建 3x2 的矩阵 A = np.array([[1, 2], [3, 4], [5, 6]]) # 计算矩阵乘积 B = np.dot(I, A) print(B)

输出结果：

[[1. 2.] [3. 4.] [5. 6.]]

10、a1变量的值为字符串work ，a2=‘hard’.编写字符处理程序，实现 a1+a2, a[1:3];a[2:-3] ,等字符操作。

a1 = 'work' a2 = 'hard' # 进行字符串拼接 a = a1 + a2 print(a) # 对字符进行切片 b = a[1:3] print(b) c = a[2:-3] print(c)

输出结果：

workhard or rkh

☆ 11、垃圾邮件快速识别

import re # 判断文本是否为垃圾邮件 def is_spam(text): if re.search(r'[\*/|\]-]', text): return True else: return False # 测试代码 text1 = 'Re: 云记APP用户意见【使用异常】' text2 = '您 Steam 愿望单上的 Grand Theft Auto V 及另外 2 个项目正在特卖*！' text3 = '连接到 Microsoft 帐户的新应用!' text4 = 'Gitee | 快速入门 Gitee ，开启技术提升之路' if is_spam(text1): print('text1是垃圾邮件') else: print('text1不是垃圾邮件') if is_spam(text2): print('text2是垃圾邮件') else: print('text2不是垃圾邮件') if is_spam(text3): print('text3是垃圾邮件') else: print('text3不是垃圾邮件') if is_spam(text4): print('text4是垃圾邮件') else: print('text4不是垃圾邮件')

输出结果：

text1不是垃圾邮件 text2是垃圾邮件 text3不是垃圾邮件 text4是垃圾邮件

12、读写文本并添加行号

# 读取文件内容 with open('D://test.txt', 'r') as file: lines = file.readlines() # 添加行号 numbered_lines = [f'{i+1} {line}' for i, line in enumerate(lines)] # 写入新文件 with open('D://test.txt', 'w') as file: file.writelines(numbered_lines)

输出结果：

13、找Word中红色文本和加粗文本

import docx # 打开 Word 文件 doc = docx.Document('example.docx') for paragraph in doc.paragraphs: for run in paragraph.runs: if run.font.color.rgb == docx.shared.RGBColor(255, 0, 0): print("红色文本:", run.text) if run.bold: print("加粗文本:", run.text)

输出结果：

14、实现批量修改Excel文件格式：文本默认是黑色的，将每列的表头变为黑体并加粗；把偶数行所有列的文本设置为宋体，红色。奇数行所有单元格，设置为蓝色，宋体。

import openpyxl from openpyxl.styles import Font, PatternFill # 打开 Excel 文件 wb = openpyxl.load_workbook('成绩单.xlsx') # 遍历所有工作表 for ws in wb.worksheets: # 设置表头为黑体加粗 for cell in ws[1]: cell.font = Font(name='黑体', bold=True) # 遍历所有列 for col in ws.columns: # 设置偶数行为宋体红色，奇数行为宋体蓝色 for i, cell in enumerate(col): if i > 0 and i % 2 == 0: cell.font = Font(name='宋体', color='FF0000') # 红色 else: cell.font = Font(name='宋体', color='0000FF') # 蓝色 # 设置第一行为黑体加粗 col[0].font = Font(name='黑体', bold=True) # 保存修改后的 Excel 文件 wb.save('成绩单新.xlsx')