课本：

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')

8. 思政题

1. 模块与包
   Python 中引入“模块”和“包”的概念，可以实现将较大规模程序开发任务分解为多个小规模任务来开展。现代社会是一个复杂的巨系统，我们在处理很多问题时，都需要借鉴这种模块化的理念，团队之间要分工合作，团结一心，将问题分而治之，逐个击破，而不是逞匹夫之勇，导致问题愈加难以解决。

2. 有继承的多态
   我们不仅要继承中华民族的优秀文化传统和中华古圣先贤的智慧成果，在新时代，还要发扬和创新，从多形态呈现出“枝繁叶茂、开花结果”的繁荣景象，一味模仿，或者崇洋媚外的否定自己，都是错误的。创新是一个民族发展与进步的灵魂。

3. 自动类型转换
   “不积跬步，无以至千里；不积小流，无以成江海。”希望同学们在学习的过程中，不断积累，实现从初学者到业务高手的“自动类型转换”，为祖国实现“强国梦”贡献自己的力量。

4. 文件操作
   大家在平时工作中，要做好对数据的维护和备份工作，提高安全意识。特别是在互联网时代，数据都存放在服务器中，一旦网络被攻破，数据就会被窃取或丢失。对于计算机专业的学生而言，要加强网络安全意识，做到有备无患。

---

转载请注明出处
作者：HinsCoder
博客链接： 作者博客主页