今日复习计划：阶段总结（新年贺礼）
1.python简介（定义，优点，缺点，应用领域）
python：一种广泛使用的解释型，高级和通用的编程语言
python极简，生产效率高，有很多大型标准库，缺点是速度慢，应用领域很广阔，包括网站开发，自动化脚本，人工智能等。
单行注释以#开头，多行注释以‘’‘ ’‘’或“”“ ”“”开头
代码默认顶格，然后根据缩进表示代码块
print（）：将print中的参数打印到终端。
print（）函数：
print（）用于打印输出，是最常见的一个函数。
语法：print(*objects,sep = ' ',end = '\n')
参数说明：objects：表示输出一个或者多个对象，输出多个对象需要用sep分隔；
sep：输出多个对象用sep分隔，默认值是一个空格；
end：输出结束以end结尾，默认值是换行符\n，可以换成其他字符串。
print(1)
print('Hello World')
a = 1
b = 'run'
print(a,b)
print('aaa''bbb')
print('aaa','bbb')
print('www','lanqiao','cn',sep = ',')运行结果：
input输入函数：
语法：input([prompt])
参数说明：prompt(提示信息)
输入的变量均为str字符串类型
a = input()
print('a = ',a)
print('type(a) = ',type(a))
a = int(a)
print('a = ',a)
print('type(a) = ',type(a))
运行结果：
例题：
题目描述：
传说古代的叙拉古国王海伦二世发现的公式利用三角形的三条边长来求取三角形面积。已知三角形的三条边长为a，b，c，求三角形的面积s。
海伦公式：s = (p(p - a)(p - b)(p - c)) ** 0.5 , 其中p = (a + b + c) / 2
输入描述：
输入三行整数a，b，c，表示三角形的边长
输出描述：
输出一个数字，表示面积
参考答案：
a = int(input())
b = int(input())
c = int(input())
p = (a + b + c) / 2
s = (p*(p - a)*(p - b)*(p - c))**0.5
print(s)运行结果：
2.运算符
算术运算符：+ - * / //（整除） % （取余） ** （幂）
关系运算符：> < == <= >= !=
赋值运算符：= += -= *= /= //= %= **=
逻辑运算符：and，not，or
成员运算符：in，not in
身份运算符：is，is not
| a | b | a and b | a or b | not a |
| True | True | True | True | False |
| True | False | False | True | False |
| False | True | False | True | True |
| False | False | False | False | True |
3.变量（定义，例子，扩展，变量的类型）
常量：程序中使用的具体的数和字符，在运行过程中，值无法更改。
变量：表示一个存储单元，其中存储的值可以更改
例如：a = 5, b = 6
变量命名：
（1）只能包含字母，数字，下划线；
（2）只能以字母，下划线开头；
（3）不能使用关键字作为变量名称。
合法的变量名称：age，month，s2
非法：9u，a < b, m.k
4.数值类型（整数，浮点数，布尔值的定义及其举例）
整数：int 浮点数：float 字符串：str 布尔：bool 获取变量类型：type()
int转float：直接转换 float转int：舍弃小数 int转bool：非零（True），0（False）
转str：直接转换
5.索引和切片
切片：列表的部分元素组成的新列表
a[start:end:step]
start：切片的下标起点（包含起点），默认为0
end：切片的下标终点（不包含终点），默认为列表长度
step：切片的步长，默认为1
与range()用法类似，只是range是数字序列，而切片面向的是任意list
a = ['apple','banana','cat','dog','egg']
b = a[2:4]
print('b = ',b)
c = a[::2]
print('c = ',c)
d = a[:3]
print('d = ',d)
e = a[-3:]
print('e = ',e)运行结果：
6.格式化输出（%s,%f的用法）
python支持格式化字符串的输出，利用format函数来调整字符串的格式；
python字符串中{}表示占位符，format里面的参数将逐个放入字符串中的占位符；
由于format中的参数要逐个放入字符串的占位符中，此时参数数量必须大于等于占位符数量
name = 'xiaowang'
age = 19
print('大家好，我叫{}，今年{}岁'.format(name,age))运行结果：
python字符串中{0} ,{1}表示占位符，其中非负整数表示这个位置为format中的第几个参数，从0开始计数，{x}中的x不可以大于format中的参数数量。
name = 'xiaowang'
age = 19
print('大家好，我叫{0}，今年{1}岁。{0}:{1}'.format(name,age))运行结果：
python字符串中{name},{age} 表示占位符，其中name，age表示format中传递参数的参数名称，此时是根据名称来找对应的位置，因此{}中的名称必须在format中出现。
print('大家好，我叫{name}，今年{age}岁。'.format(name = "xiaowang",age = 19))运行结果：
例题1：
题目描述：输入一个句子，计算单词数，大写字母数，小写字母数。
参考答案：
sentence = input('请输入一个句子：')
word_count = len(sentence.split())
uppercase_count = sum(1 for char in sentence if char.isupper())
lowercase_count = sum(1 for char in sentence if char.islower())
print('单词数：{}'.format(word_count))
print('大写字母数：{}'.format(uppercase_count))
print('小写字母数：{}'.format(lowercase_count))运行结果：
例题2：
题目描述：
开放式编程：对于给定的一大段不规范的英文文本，对其进行排版。
单词和单词之间有一个空格；
句子中的符号和前一个单词之间没有空格；
句子之间用一个空格分隔；
句子首字母大写，其他字母小写；
按照换行符划分段落，输出时每段空两个空格；
输出时每行80个字符，对于单个单词一行超过80个单词，直接下一行输出该单词。
参考答案：
def format_text(text):
formatted_text = ""
paragraphs = text.split('\n\n') # 根据换行符划分段落
for paragraph in paragraphs:
lines = paragraph.split('\n') # 根据换行符划分行
for line in lines:
words = line.split() # 根据空格划分单词
current_line = ''
for word in words:
if len(current_line) + len(word) + 1 > 80: # 当前行超过80个字符
formatted_text += current_line.strip() + '\n' # 输出当前行
current_line = word + ' ' # 开始新行
else:
current_line += word + ' ' # 添加单词到当前行
formatted_text += current_line.strip() + '\n' # 输出当前行
formatted_text += '\n' # 段落之间空两个空格
return formatted_text.strip() # 去除首尾空格
text = """
This is an unformatted English text. There are no proper spaces between words and sentences.
Each paragraph is separated by an empty line.
Please format this text according to the requirements.
Thank you for your help!
"""
formatted_text = format_text(text)
print(formatted_text)运行结果：
7.我做的第一个蓝桥杯题：妮妮的翻转游戏（我写了7种方法）
题目：在蓝桥镇，妮妮发明了一个新的游戏-----翻转游戏。游戏中有一个开关，可以处于两种状态：开（用1表示）和关（用0表示）。妮妮发现，无论开关此时处于何种状态，他都可以通过一次操作使开关的状态翻转。现在，妮妮告诉你当前开关的状态为x，他想知道，如果他进行一次操作，开关的状态会变成什么。你能帮助他解决这个问题吗？
————————————————
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
原文链接：https://blog.csdn.net/m0_73523976/article/details/134887769
方法1：
a = int (input())
if a == 1:
print(0)
if a == 0:
print(1)方法2：
a = input()
if a == '1':
print(0)
else:
print(1)方法3：
a = int(input())
print(int(not(a)))方法4：
a = int(input())
print(a^1)方法5：
a = int(input())
b = [1,0]
print(b[a])方法6：
a = int(input())
b = {1:0,0:1}
print(b[a])方法7：
a = int(input())
print(int(a==0))8.关系运算符，逻辑表达式
关系运算符用于数值的大小比较，一般用于条件表达式，包括大于(>)，小于(<)，等于(==)，不等于(!=)，大于等于(>=)，小于等于(<=)；
它们都是双目运算符；
关系运算符的结果是bool型，结果只有两种：True或False；
False代表关系不成立，True代表关系成立。
a = 5
b = 4
print(a > b)运行结果：
python提供了3种逻辑运算符：and（与运算），not（非运算），or（或运算）
与运算符和或运算符均为双目运算符，具有左结合性；
非运算符为单目运算符，具有右结合性。
短路操作：在python中，and和or不一定会计算右边表达式的值，有时候只计算左边表达式的值就能得到最终结果；
另外，and和or运算符会将其中一个表达式的值作为最终结果，而不是将True或者False作为最终结果。
对于and运算符，两边的值都为真时最终结果才为真，但是只要其中有一个为假，那么最终结果就是假，所以有下面的规则：
如果左边的表达式为假，那么就不用计算右边表达式的值了，因为不管右边表达式的值时什么，都不会影响最终计算结果，最终结果都为假，此时and会以左边表达式的值作为最终结果。
如果左边表达式的值为真，那么最终值是不能确定的，and会继续计算右边表达式的值，并将右边表达式的值作为最终结果。
对于or运算符，情况是类似的，两边的值都为假时最终结果才为假，只要其中有一个为真，那么最终结果就是真，所以有以下规则：
如果左边表达式的结果为真，那么就不用计算右边表达式的值了，因为不管右边表达式的值是什么，都不会影响最终结果，最终结果都为真，此时or会把左边表达式的值作为最终结果；
如果左边表达式为假，那么最终值是不能确定的，or会继续计算右边表达式的值，并将右边表达式的值作为最终结果。
例题：
题目描述：
输入学生的语文，数学，英语的成绩，单科满分100分；
（1）如果有一门考试是100分；
（2）如果有两门考试成绩大于90分；
（3）如果三门考试都大于80分
满足三个条件中的任意一个，就奖励一朵小红花；
以a，b，c表示三个成绩，实现逻辑表达式。
参考答案：
a = int(input())
b = int(input())
c = int(input())
d = a == 100 or b == 100 or c == 100
e = (a > 90 and b > 90) or (a > 90 and c > 90) or (b > 90 and c > 90)
f = a > 80 and b > 80 and c > 80
ans = d or e or f
print(ans)运行结果：
9.if--else的基本格式和使用示例
（1）if语句
格式：if 表达式：
代码块
注意：代码块需要缩进，“表达式”可以是一个单一的值或者变量，也可以是由运算符组成的复杂语句，形式不限，只要它能得出一个值就行。
（2）if---else语句
格式：if 表达式：
代码块1
else：
代码块2
例题1：奇偶判断
题目描述：读入一个整数a，如果a为偶数，则输出YES，否则输出NO。
参考答案：
a = int(input())
if a % 2 == 0:
print('YES')
else:
print('NO')运行结果：
例题2：范围判断
题目描述：读入一个a，若这个数a大于1且小于100，则输出yes，否则输出no。
参考答案：
a = int(input())
if a > 1 and a < 100:
print('YES')
else:
print('NO')运行结果：
例题3：比较大小
题目描述：读入a，b，若a > b，则交换a和b的值。
参考答案：
a = int(input())
b = int(input())
if a > b:
a,b = b,a
print(a,b)
else:
a,b = a,b
print(a,b)运行结果：
（3） if---elif---else
格式：if 表达式1：
代码块1
elif 表达式2：
代码块2
elif 表达式3：
代码块3
else：
代码块n
含义：如果满足表达式1，则执行代码块1，如果满足代码块2，则执行代码块2，如果满足代码块3，则执行代码块3，否则，执行代码块n。
例题1：求位数
题目描述：输入一个整数x(0 <= x < 10000)，输出x的数字的位数。
参考答案：
x = int(input())
print(len(str(x)))运行结果：
例题2：买钢笔
题目描述：期末来临了，班长小Q决定将剩余班费x元，用于购买若干支钢笔奖励给一些学习好，表现好的同学。已知商店里由三种钢笔，它们的单价分别为6元，5元，4元。小Q想购买尽量多的笔（鼓励尽量多的同学） ，同时他又不想又剩余的钱。
请你编一个程序，帮小Q定制一个方案。
参考答案：
def purchase_plan(x):
# 遍历所有可能的购买方案
for i in range(1,x // 4 + 1):
for j in range(1,x // 5 + 1):
for n in range(1,x // 6 + 1):
if i * 4 + j * 5 + n * 6 == x:
return i,j,n
return None
# 测试购买计划
x = int(input('请输入预算：'))
plan = purchase_plan(x)
if plan:
print("购买方案：第一种{}支，第二种{}支，第三种{}支".format(plan[0],plan[1],plan[2]))
else:
print("找不到满足预算的购买方案")运行结果：
例题3：
题目描述：
已知闰年的定义为：普通年（不能被100整除的年份） 能被4整除的是闰年（如2004年是闰年，1999年不是闰年），世纪年（能被100整除的年份）能被400整除的是闰年（如2000年是闰年，1999年不是闰年），现输入年份（1000到9999之间）判断是否是闰年？
参考答案：
def is_leap_year(year):
if year % 4 == 0:
if year % 100 == 0:
if year % 400 == 0:
return True
else:
return False
else:
return True
else:
return False
year = int(input("请输入年份："))
if is_leap_year(year):
print('{}年是闰年'.format(year))
else:
print('{}年不是闰年'.format(year))运行结果：
10.for循环的基本格式和应用示例
格式：for <variable> in <sequence>:
结构体
<variable>：循环变量，一般为i,j,k
<sequence>：序列或者可迭代对象，一般为range(x)
for i in range(5):
print(i)运行结果：
例题1：
题目描述：输入一个整数n，输出1到n之间的所有偶数。
参考答案：
n = int(input("请输入一个整数："))
for i in range(1,n + 1):
if i % 2 == 0:
print(i)运行结果：
例题2：计算值
题目描述：
输入一个整数n，计算1 + 2 + ... + n的值。
参考答案：（我给两种方法）
n = int(input("请输入一个整数："))
ans = 0
i = 0
for i in range(1,n + 1):
ans += i
i += 1
print(ans)n = int(input("请输入一个整数："))
ans = n * (n + 1) // 2
print(ans)运行结果：
11.range（）函数的简介，参数含义和例子
range()函数用于生成一系列数字，用于循环结构的遍历；
range(start,end,step)
从start开始，默认为0，到stop结束，不包括stop，步长为step，默认为1。
例如：range(5)等价于range(0,5),等价于range(0,5,1) ，结果为 0，1，2，3，4。
12.break介绍和在循环中的使用
break语句可以跳出for和while的循环体
n = 5
while n > 0:
n -= 1
if n == 2:
break
print(n)运行结果：
break语句可以直接结束循环。
13.continue介绍和在循环中的使用
continue语句被用来告诉python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
n = 5
while n > 0:
n -= 1
if n == 2:
continue
print(n)运行结果：
i = 0
while True:
i += 1
if i > 5:
break
if i == 2:
continue
print(i)运行结果：
i = 0
while True:
if i > 5:
break
if i == 2:
continue
i += 1
print(i)运行结果：
14.while循环应用（猜数字游戏）
格式：while 条件表达式：
代码块
条件表达式成立，执行代码块
例题1：
题目描述：
s = 1 + 2 + 3 + ... + n，当s >1000时，n最小为多少？
参考答案：
s , n = 0 , 0
while s <= 1000:
n += 1
s += n
print(n)运行结果：
例题2：
题目描述：
利用辗转相除法求数字m和n的最大公约数。
原理：两个整数的最大公约数等于其中较小的数和两数相除余数的最大公约数。
参考答案：
m = int(input())
n = int(input())
# 先求余数
r = m % n
# 当余数不为0，gcd(m,n) = gcd(n,r)
while r != 0:
m = n
n = r
r = m % n
print('gcd = ',n)运行结果：
15.for循环嵌套
for循环常用于已知循环次数的情况，或者用来遍历list和dict等数据结构。
当两个甚至多个循环结构相互嵌套时，位于外层的循环结构常简称为外层循环或外循环，位于内层的循环结构常称为内层循环或内循环。
运行顺序是：先执行外循环，对于外循环的每一个i，执行内循环。
for i in range(3):
for j in range(3):
print('i = ',i,'j = ',j)运行结果：
循环嵌套中的break和continue：
break语句适用于循环嵌套中，它的作用只是使程序跳出本层循环结构。
continue语句也适用于循环结构中 ，作用仍然是跳出本次循环，执行下一次循环。
for i in range(3):
for j in range(3):
print('i = ',i,'j = ',j)
if i == j:
break运行结果：
如何跳出多层循环？
可以设置一个跳出循环的标记
如果需要一次跳出多层循环的时候，可以将这个标记写为True，那么在下一层循环也判断一下是否需要继续跳出循环。
stop = False
for i in range(3):
for j in range(3):
print('i = ',i,'j = ',j)
if i == 2 and j == 2:
stop = True
break
if stop:
break运行结果：
例题1：求阶乘之和
题目描述： 求s = 1! + 2! + 3! + ... + n!
参考答案：
n = int(input())
res = 0
# res = 1! + 2! + ... + n!
# 外层循环，遍历[1,2,3...n]
for i in range(1,n + 1):
# 内层循环的目的是计算new_res = i! = 1*2*3*...*i
new_res = 1
for j in range(1,i + 1):
new_res *= j
res += new_res
print(res)运行结果：
例题2：采购
题目描述：一个炊事员上街采购，用500元钱买了90只鸡 ，其中母鸡一只15元，公鸡一只10元，小鸡一只5元，正好把钱买完。问母鸡，小鸡，公鸡各买了多少只？
思路:
母鸡记为x只，公鸡记为y只，小鸡记为z只。x从[0,90],y从[0,90],z从[0,90]，三重for循环求解，判断以下条件是否成立：（1）x + y + z = 90 (2)15x + 10y + 5z = 500
参考答案：
for x in range(91):
for y in range(91):
for z in range(91):
if x + y + z == 90 and 15 * x + 10 * y + 5 * z == 500:
print(x,y,z)运行结果：
但是，这种解法的时间复杂度是O(n^3) ，可能会报错，所有优化一下。
思路:母鸡记为x只，公鸡y只，小鸡z只。x从[0,min(90,500 / 15)]，y从[0,min(90,500 / 10,90 - x)]，z = 90 - x - y，两重for循环求解，判断以下条件是否成立：x + y + z = 90,15x + 10y + 5z = 500。
参考答案：
for x in range(91):
for y in range(91):
for z in range(91):
if x + y + z == 90 and 15 * x + 10 * y + 5 * z == 500:
print(x,y,z)运行结果同上。
这个方法不错，但是还可以继续优化。
思路：
x从[0,min(90,500 / 15)]中选择，用方程代换
y + z = 90 - x
10y + 5z = 500 - 15x
转换：5y + 5z = 450 - 5x
10y + 5z = 500 - 15x
下式减上式：5y = 50 - 10x，化简得：y = 10 - 2x
代入x + y + z = 90得：x + 10 - 2x + z = 90，化简得：z - x = 80 , z = 80 + x
for x in range(6):
y = 10 - 2*x
z = 80 + x
print(x,y,z)例题3：水仙花数
题目描述：
若有三位数ABC，ABC = A^3 + B^3 + C^3 ，则称ABC为水仙花数。
输出100-999中的所有水仙花数。
参考答案：
第一种方法：从[100,999]逐个枚举，单独判断每个数字。
for i in range(100,1000):
a = i // 100
b = i // 10 % 10
c = i % 10
if a ** 3 + b ** 3 + c ** 3 == i:
print(i)
运行结果：
第二种方法：枚举A,B,C,判断ABC = A^3 + B^3 + C^3是否成立。
for A in range(1,10):
for B in range(10):
for C in range(10):
left = A ** 3 + B ** 3 + C ** 3
right = A * 100 + B * 10 + C
if left == right:
print(left)运行结果同上。
例题4：素数
题目描述：
输出L到R之间所有的素数，1 <= L < R <= 1000。
参考答案：
L = int(input())
R = int(input())
for i in range(L,R + 1):
# 判断数字i是否为素数
ok = True
for j in range(2,i):
if i % j == 0:
ok = False
break
if ok and i != 1:
print(i)
运行结果：
例题5：日期
题目描述：
输出2000年至2020年每一天的日期。
思路：第一重循环枚举年份[2000,2020]，第二重循环枚举月份[1,12]，第三重循环枚举日期[1,up]，其中up表示当月天数。
需要考虑闰年的情况，通过年份和月份推断出当前月份的天数。
参考答案：
# 枚举年份
for year in range(2000,2021):
# 枚举月份
for month in range(1,13):
# 计算每个月多少天，包括闰年的情况
if month == 2:
if year % 400 == 0 or year % 100 == 0 and year % 4 == 0:
up = 29
else:
up = 28
elif month == 4 or month == 6 or month == 9 or month == 11:
up = 30
else:
up = 31
# 枚举日期
for day in range(1,up + 1):
print(year,month,day)运行结果：
太多了，我只列举出一部分。
例题6：打印九九乘法表
第一种方法：
i = 1
while i <= 9:
j = 1
while j <= i:
j = j + 1
print('%d * %d = %d'%(i,j,j*i),end = " ")
# end="" 表示向控制台输出内容结束之后，不会换行
print('') # 单纯的换行
i = i + 1运行结果：
第二种方法：
for i in range(1, 10):
for j in range(1, i+1):
print('%d*%d=%d' % (j, i, i*j), end=" ")
print("")运行结果同上。
例题7：
题目描述：如果一个数等于它的因子之和，不包括它本身，那么这个数字称之为完美数。
例如6 = 1 + 2 + 3， 28 = 1 + 2 + 4 + 7 +14
输入描述：一个整数n(n <= 10000)
输出描述：对于每个完美数输出一行。
参考答案：
def is_perfect_number(n):
factors = []
for i in range(1,n):
if n % i == 0:
factors.append(i)
if sum(factors) == n:
return True
else:
return False
n = int(input('请输入一个整数：'))
perfect_numbers = []
for num in range(1,n + 1):
if is_perfect_number(num):
perfect_numbers.append(num)
for num in perfect_numbers:
print(num)运行结果：
16.字符串输出 （%用法和format用法）
（这里我写的是字符串的相关知识点）
字符串：一系列字符，用单引号或双引号括起来。
python不支持单字符类型，单个字符也被看作字符串，许多用法与list一致：
访问字符串中的元素：使用方括号 + 下标（从0开始）
切片：s[start:end:step]，在字符串s下标为[start,end)中，步长为step
len():求字符串长度
+：字符串连接
*：重复字符串
in，not in：存在，不存在
str(x)：把x强制转换成字符串
s = 'Hello World'
print('len(s) = ',len(s))
print('s[2] = ',s[2])
print('s[-1] = ',s[-1])
print('s[4:8] = ',s[4:8])
print('s[:5] = ',s[:5])
print('s[6:] = ',s[6:])
print('s[-5:] = ',s[-5:])运行结果：
s1 = 'Hello'
s2 = 'World'
s3 = s1 + s2
s4 = s1 * 5
print('s3 = ',s3)
print('s4 = ',s4)
if 'Hello' in s3:
print('yes')
else:
print('no')运行结果：
ord和chr：
python将字符编码成Unicode码：简单理解为所有语言的字符 （所有数字，中文，字母等所有符号）一一对应一个数字（编码）；
我们常用的是ASCII码，包括字母，数字，一些标点符号和控制符号。
字符转换为Unicode码：ord(x)，x为字符，ord(x)为整数。
Unicode码转换为字符：chr(x)，x为整数，chr(x)为字符。
print(chr(34013))
print(chr(26725))
print(chr(97))
print(chr(98))
print(ord('蓝'))
print(ord('桥'))
print(ord('a'))
print(ord('b'))
运行结果：
判断类方法：
isalnum()：判断字符串是否都是字母或者数字
isalpha()：判断字符串是否都是字母或中文字符
isdigit()：判断字符串是否只包含数字
islower()：判断字符串是否全小写
isupper()：判断字符串是否全大写
isspace()：判断字符串是否只包含空白
istitle()：判断字符串是否标题化
# 标题化判断
print('Hello World'.istitle())
print('Hello world'.istitle())
print('-' * 10)
# 大小写判断
print('HELLO'.isupper())
print('hello'.islower())
print('-' * 10)
# 数字字母判断
print(''.isalpha())
print('-' * 10)
# 空白判断
print(' '.isspace())
print('\t\n\t'.isspace())
print(''.isspace())运行结果：
我把所有的方法全写在一起：
# 标题化
s = 'hello world'
t = s.title()
print('s = ',s)
print('t = ',t)
print('-' * 10)
# 删除左侧的空格
s = ' hello world'
t = s.lstrip()
print('s = ',s)
print('t = ',t)
print('-' * 10)
# 替换字符
s = 'abcd abcd abcd abcd'
t = s.replace('a','A')
z = s.replace('a','A',2)
print('s = ',s)
print('t = ',t)
print('z = ',z)
print('-' * 10)
# 转换成大写
s = 'hello world'
t = s.upper()
print('s = ',s)
print('t = ',t)
print('-' * 10)
# 删除左侧的多个字符:e,h,空格
s = ' hello world'
t = s.lstrip('eh ')
print('s = ',s)
print('t = ',t)
print('-' * 10)
# 右对齐
s = 'hello world'
t = s.rjust(30)
print('s = ',s)
print('t = ',t)
s1 = s.rjust(30,'*')
print('s1 = ',s1)
print('-' * 10)
# 大小写互换
s = 'hello world'
t = s.title().swapcase()
print('s = ',s)
print('t = ',t)
print('-' * 10)运行结果：
查找类方法：
# 统计次数
s = 'abcd abcd abcd abcd'
print(s.count('st'))
print(s.count('abcd'))
print(s.count('abcd',6))
# 查找用find即可
s = 'Hello World'
print(s.find('World'))
print(s.find('world'))
print(s.find('H'))
print(s.find('H',6))运行结果：
字符串和list：
字符串转换成list：（字符串本身不可修改，但转化成list后可以进行修改）
直接转化成list：列表的每个元素都是长度为1的字符串
s = 'Hello World'
t = list(s)
print('s = ',s)
print('t = ',t)运行结果：
利用split()方法对字符串进行分割：
str.split(str = '',num = string.count(str)) :
str表示分割符，默认为空字符，包括空格，换行，制表符等。
num--分割次数，如果设置了这个参数，则最多分割成num + 1个子字符串，默认为-1，即分割所有。
s = 'Follow your heart and go wherever you go'
t1 = s.split()
print('t1 = ',t1)
t2 = s.split(' ',4)
print('t2 = ',t2)
t3 = s.split('go')
print('t3 = ',t3)运行结果：
一行输入两个整数，输出两个数字之和：
split将输入的字符串进行分割
map(function,sequence) :把序列sequence中的每个元素利用function进行转换，最终结果是一个可迭代的对象，一般要将其转换成list。
s = ['123','456']
# 先执行map(int,s):把s里面的每个元素转换成整数
# 再把结果转换成list
t = list(map(int,s))
print('s = ',s)
print('t = ',t)运行结果：
一行输出两个整数，输出两个数字之和
# input()得到的是一个输入字符串
# 把输入字符串按照空格分割，得到一个list
s = input().split()
# s这个list里面的每一个字符串转化成int，就得到输入的两个整数
a,b = list(map(int,s))
print(a + b)运行结果：
一行输入若干个数字，求出数字之和
# input()得到的是一个输入字符串
# 把输入字符串按照空格分割，得到一个list
s = input().split()
# s这个list里面的每一个字符串转化成int，就得到输入的两个整数
a = list(map(int,s))
a = [int(x) for x in a]
# 求整个list的和
print(sum(a))运行结果：
利用str.join(sep) ：把序列每个元素用str连接起来
s = 'Hello World'
t = list(s)
print('t = ',t)
# 序列转字符串
s1 = ' '.join(t)
print('s1 = ',s1)
s2 = '_'.join(t)
print('s2 = ',s2)运行结果：
总结一下：
如何修改字符串？
直接在字符串上修改是不行的，毕竟字符串不可修改。可以用以下方法：
（1）转换成list，修改后再转换成字符串
（2）利用切片
（3）重新赋值
（4）利用replace函数
16.遍历
（1）列表遍历
（我写的是列表的知识点）
列表(list)由一系列按照特定顺序排列的元素组成。
[]表示列表，逗号分隔元素：[element 1 , element 2 , ...,element n ]
element i表示列表中的元素，个数没有限制，可以是任意数据。
a = ['apple','banana','cat','dog']
# a 的类型
print(type(a))
# 打印a
print(a)运行结果：
列表是有顺序的，访问任何元素需要通过”下标“访问；
所谓”下标“ 就是指元素在列表中从左到右为第几个，下标从0开始。
a = ['apple','banana','cat','dog']
# 获取第0个元素
print('a[0] = ',a[0])
# 获取第1个元素
print('a[1] = ',a[1])
# 获取第2个元素
print('a[2] = ',a[2])
# 获取第-1个元素
print('a[-1] = ',a[-1])运行结果：
列表的每一个元素均可以像其他变量一样进行使用
赋值，加减乘除各种运算，打印等。
a = [123,456,789]
# 列表中的元素可以正常参与运算
print(a[0] + a[1])
print(a[2] // a[0])
# 列表中的元素可以重新赋值
a[0] = 1
print('a = ',a)
a[1] = 5
print('a = ',a)运行结果：
在列表末尾添加单个元素：
a = []
a.append(123)
print(a)运行结果：
在末尾添加多个元素：
a = []
a.extend([1,2,3])
a.extend([4,5,6])
print(a)运行结果：
在中间插入元素：
a = ['apple','banana','cat','dog']
a.insert(0,'Apple')
print(a)运行结果：
利用del删除列表中的元素
利用pop删除列表中的元素
# 利用del删除元素
a = ['apple','banana','cat','dog']
del a[1]
print('a = ',a)
# 利用pop删除元素
a = ['apple','banana','cat','dog']
del_str = a.pop(1)
print('a = ',a)
print('删除的元素为：',del_str)
# pop不加参数，默认删除末尾元素
del_str = a.pop()
print('a = ',a)
print('删除的元素为：',del_str)运行结果：
所以，区别在于：del删除没有返回值，pop删除返回的是被删除的那个元素。
删除列表中的指定的所有相同元素：
a = [1,2,3,4,5,2,3,4,2,4,5,6,6,2,4]
# 只能删除第一个2
a.remove(2)
print('a = ',a)
a = [1,2,3,4,5,2,3,4,2,4,5,6,6,2,4]
x = 2
# 当x在a中，需要删除x
while x in a:
a.remove(x)
print('a = ',a)运行结果：
所以，得出结论，它的基本方法是：
利用循环结构 + remove()
in 表达式：x in a:判断x是否在a中，在就是True,否则就是False。
查找元素：
a = ['apple','banana','cat','dog','apple','cat']
print(a.count('apple'))
# 在整个列表中查找第一个cat
print(a.index('cat'))
# 从下标3开始查找第一个cat
print(a.index('cat',3))运行结果：
总结一下：
a.count(x)：计算x在a中出现的次数，如果未出现则为0，否则为出现次数；
a.index(x,start,stop) ：计算元素x在列表a下标[start,stop)中第一次出现的位置。
要保证必须在[start,stop)中存在，否则报错；
start,stop不赋值，默认在整个列表中寻找；
只赋值start，stop默认为列表长度。
翻转列表：
a = [1,2,3,4,5]
a.reverse()
print('a = ',a)
a.reverse()
print('a = ',a)运行结果：
求出列表长度：
a = [1,2,3,4,5]
# 输出a的长度
print(len(a))运行结果：
遍历整个列表：
利用for循环遍历整个列表
a = [1,2,3,4,5]
for i in a:
print(i)运行结果：
利用for循环遍历列表，同上获取下标：
a = [1,2,3,4,5]
for idx, x in enumerate(a):
print(idx,x)运行结果：
创建数值列表：
a = list(range(5))
print('a = ',a)
b = list(range(0,10,3))
print('b = ',b)
c = list(range(10,-1,-2))
print('c = ',c)运行结果：
简单来说，就是用range()函数 + list
列表操作符：
+ ：连接两个列表
a*x ：a是list，x是int，构成一个新列表，其内容为a复制x次。
a = list(range(5))
print('a = ',a)
b = list(range(0,10,3))
print('b = ',b)
c = a + b
print('c = ',c)
d = a*3
print('d = ',d)运行结果：
内置函数：
a = [1,3,5,7,9]
print('sum(a) = ',sum(a))
print('max(a) = ',max(a))
print('min(a) = ',min(a))运行结果：
列表解析式：
可以基于已有列表生成新的相关列表 [expression for member in iterable]
对于iterable中的每个元素member，都执行expression生成新列表。
a = [x ** 2 for x in range(11)]
print(a)运行结果：
对于range(11)中的每个元素，新列表的元素为x^2。
可以基于已有列表生成新的相关列表 [expression for member in iterable if conditional]
对于可迭代对象iterable的每个元素member，如果满足条件conditonal，才会执行expression生成新列表。
a = [x ** 2 for x in range(11) if x % 2 == 0]
print(a)运行结果：
复制列表：
利用片a[:]
利用copy函数，b = a.copy()
a = ['apple','banana','cat','dog','egg']
b = a.copy()
print('b = ',b)
c = a[:]
print('c = ',c)运行结果：
（2）元组遍历
（这里我写的是元组知识点）
元组：与列表类似，是由一系列按指定顺序排列的元素组成。
用()创建，或者用tuple创建。
与list的区别：list是可修改的序列，而元组是不可修改的
a = ('apple','banana','cat')
print('type(a) = ',type(a))
b = ['dog','egg']
print('type(b) = ',type(b))
c = tuple(b)
print('type(c) = ',type(c))运行结果：
元组无法修改内部元素，如果修改元素，可以转换成list或者创建新的元组。
（3）字典遍历
（这里我写的是字典相关知识点）
字典存储一系列的键值对：key:value
字典等价于数学中的映射，即一个key对应着一个value
键：key 值：value，通过key来找value，key必须唯一，因此一个key只能对应着一个value。
python中用{}表示字典，可以使用{}创建一个字典；
字典中的key和value之间用冒号分隔，元素之间用逗号分隔开；
字典的key只能为数字，字符串，元组，大多数情况使用字符串作为key，value的类型没有限制。
# 创建了一个空字典
a = {}
print('type(a) = ',type(a))
print('a = ',a)
# 创建一个字典
a = {'a':123,'b':456,0:789}
print('type(a) = ',type(a))
print('a = ',a)运行结果：
利用dict创建字典：
a = dict(key1 = value1,key2 = value2,key3 = value3)
此时key只能是字符串
# 创建了一个空字典
a = dict()
print('type(a) = ',type(a))
print('a = ',a)
# 利用dict创建字典，此时key只能是字符串，不能是数字
a = dict(a = 123,b = 456,c = 789)
print('type(a) = ',type(a))
print('a = ',a)运行结果：
利用dict创建字典：
a = dict([[key1,value1] ,[key2,value2],[key3,value3]])
可以传入一个列表或者元组，每个元素也是一个包含两个元素的列表或者元组
则此时可以将第一个元素作为key，第二个元素作为value
a = dict([['a',123],['b',456],['c',789]])
print('type(a) = ',type(a))
print('a = ',a)
a = dict([('a',123),('b',456),('c',789)])
print('type(a) = ',type(a))
print('a = ',a)运行结果：
创建字典：zip(sequence1,sequence2,...sequencen)
把多个序列相同下标的元素组装成元组，结果是一个可迭代对象
结果可以转换成list，但是首次转换后迭代器就为空。
keys = ['a','b','c']
value = [123,456,789]
zipped = zip(keys,value)
print(zipped)
print(list(zipped))运行结果：
keys = ['a','b','c']
value1 = [123,456,789]
value2 = [321,654,987,1000]
zipped = list(zip(keys,value1,value2))
print('zipped = ',zipped)运行结果：
假设有一个key列表和value列表，可以利用list(zip(key,value))将二者组装好，然后作为dict的初始化。
keys = ['a','b','c']
value = [123,456,789]
a = dict(list(zip(keys,value)))
print('type(a) = ',type(a))
print('a = ',a)运行结果：
先前所有创建字典的策略，都要满足：
（1）key不能重复，value无限制；
（2）key必须是字符串，元组，数字等不可变的类型。
访问字典：
python的字典通过key获取value，把key看作下标即可
a[x]：a为dict，x为dict中的一个key，该值必须存在，否则会报错。
keys = ['a','b','c']
value = [123,456,789]
a = dict(list(zip(keys,value)))
print('type(a) = ',type(a))
print('a = ',a)
print(a['a'],a['b'])
# 我来写一个不存在的key，肯定会报错
print(a['d'])运行结果：
如果不知道x是否在key中，需要查询字典中x对应的value，可以使用get方法
a.get(x,value = None)：a表示字典，x表示查询的key， value表示默认值。
如果x在字典的key中，则上述的结果为a[x]，如果不存在，结果为None。
keys = ['a','b','c']
value = [123,456,789]
a = dict(list(zip(keys,value)))
print('a = ',a)
# 'a'是key，则输出a['a']
print(a.get('a'))
# ’d‘不是key，则输出默认值
print(a.get('d'))运行结果：
字典通过直接利用key可以访问对应的value，类似的，添加value，修改元素也是直接利用key和value就能进行添加或者更新。
a = {}
# 添加元素
a['语文'] = 80
print('a = ',a)
# 添加元素
a['数学'] = 99
print('a = ',a)
# 添加元素
a['英语'] = 98
print('a = ',a)
# 修改元素
a['语文'] = 90
print('a = ',a)运行结果：
删除字典中的键值对，可以用python本身的删除语法del
s = {'a':123,'b':456,'c':789}
print('s = ',s)
del s['a']
print('s = ',s)
del s['b']
print('s = ',s)
del s['c']
print('s = ',s)
运行结果：
删除字典中的键值对，也可以用字典的删除方法pop
s = {'a':123,'b':456,'c':789}
s.pop('a')
print('s = ',s)
s.pop('b')
print('s = ',s)
s.pop('c')
print('s = ',s)运行结果：
与list一样，直接利用for语句就可以遍历字典
s = {'a':123,'b':456,'c':789}
for x in s:
print(x)运行结果：
for x in a：x是循环变量，a是字典，此时遍历的是a的key列表
接下来分别遍历：
s = {'a':123,'b':456,'c':789}
for x in s.keys():
print(x)
for y in s.values():
print(y)
for x,y in s.items():
print(x,y)运行结果：
字典中可以使用in，not in判断某元素是否存在于字典中：
s = {'a':123,'b':456,'c':789}
print('a' in s)
print('d' in s.keys())
print(123 in s.values())
print(135 in s.values())
print(('a',123) in s.items())
print(('b',123) in s.items())运行结果：
与list类似，直接赋值无法进行复制，需要使用copy函数进行复制
直接赋值相当于是引用，就是添加一个别名
s = {'a':123,'b':456,'c':789}
t = s
# 修改s，t也一起被修改，t就是s
s['d'] = 1000
print('修改后的s = ',s)
print('t也跟着变为：',t)
print('-' * 10)
s = {'a':123,'b':456,'c':789}
t = s.copy()
s['e'] = 2000
print('修改后的s = ',s)
print('t仍然为：',t)运行结果：
字典利用update方法可以将另一个字典是key-value键值对更新到已有字典中
a.update(b)：把字典b中的每个元素放入a中更新：
如果b中的key在a中没有，则直接在a中添加一组新的key--value对
如果b中的key在a中存在，则直接更新对应的value
s = {'a':123,'b':456,'c':789}
t = {'a':321,'d':1000}
s.update(t)
print('s = ',s)
print('t = ',t)运行结果：
总结一下：
创建字典：{},dict(),zip()用法
访问字典：把key作为下标，get()用法
修改，添加元素：key作为下标
删除元素：del，pop（）
遍历字典：keys（），values()，items（）
存在，不存在：in ，not in
拷贝：copy（）
合并字典：update（）
例题1：
题目描述：输入一行文本（一组数据） ，统计每个字符（数字）出现次数
参考答案：
text = input('请输入一行文本：')
character_count = {}
for char in text:
if char in character_count:
character_count[char] += 1
else:
character_count[char] = 1
for char,count in character_count.items():
print('字符{}出现的次数是{}'.format(char,count))运行结果：
例题2：
题目描述：
输入一个字符串s，遍历字符串s，对每个字母统计次数。
参考答案：
s = input('请输入一个字符串：')
letter_count = {}
for char in s:
if char.isalpha(): # 只统计字母字符
if char in letter_count:
letter_count[char] += 1
else:
letter_count[char] = 1
for char,count in letter_count.items():
print('字母{}出现的次数是{}'.format(char,count))运行结果：
例题3：
题目描述：
输入一篇短文，统计每个单词出现次数。
注意：句子首字母会大写，但是统计时要一起统计
参考答案：
text = input('请输入一篇短文：')
word_count = {}
words = text.split()
for word in words:
if word in word_count:
word_count[word] += 1
else:
word_count[word] = 1
for word,count in word_count.items():
print('单词{}出现的次数是{}'.format(word,count))运行结果：
17.集合
（1）定义一个空集合
（2）添加元素（add，update）
（3）删除元素（pop，remove，discard）
（4）交集(&)和并集(|)，还有差集
python中的集合和数学中的集合概念是一样的，存储不重复的元素。
集合中的元素都是唯一的，互不相同
集合中只能存储不可变的数据：数字，字符串，元组
python用{}表示集合，其中的元素用逗号分隔开
python集合是无序的
s = {1,2,3,4}
print('s = ',s)
print('type(s) = ',type(s))运行结果：
创建集合的方式：
（1） {元素1，元素2，元素3，...}：把大括号中的所有元素构造成一个集合，如果有重复元素就保留一个；
（2）{}是空字典，不是空集合；
（3）set(x)：把x转换成集合，x一般为列表，元组等；
（4）set()：空集
s = {1,2,3,4,1,2,3}
print('s = ',s)
print('type(s) = ',type(s))
print('-' * 10)
a = ['a','b','c']
s = set(a)
print('s = ',s)
print('type(s) = ',type(s))
print('-' * 10)
key = ['a','b','c']
value = [123,456,789]
dic = dict(zip(key,value))
print('dic = ',dic)
s = set(dic)
print('s = ',s)
s = set(dic.values())
print('s = ',s)
s = set(dic.items())
print('s = ',s)运行结果：
与遍历list一样，for x in a:其中x是循环变量，a是集合。
s = {1,2,3,4}
for x in s:
print(x)
print(sum(s),min(s),max(s))运行结果：
s.clear()：清空集合
x in s：判断是否存在
len(s) ：集合元素个数
# 定义一个空集
s = set()
# 添加元素
s.add(1)
s.add(2)
s.add(3)
print('s = ',s)
t = {2,3,4}
print('t = ',t)
print('-' * 10)
s.update(t)
print('s = ',s)
print('t = ',t)
# 判断s是否为t的超集
print(s.issuperset(t))
print('-' * 10)
# 删除元素
s.remove(1)
s.remove(3)
print('s = ',s)
print('t = ',t)
# 判断s是否为t的子集
print(s.issubset(t))运行结果：
下一个知识点：
s = {1,2,3}
t = {2,3,4}
print('两者的交集为{}'.format(s&t))
print('两者的并集为{}'.format(s|t))
print('两者的差集为{}'.format(s-t))
print('两者的对称差集为{}'.format(s^t))运行结果：
还有另外一种比较复杂的写法：
s = {1,2,3}
t = {2,3,4}
print('两者的交集为{}'.format(s.intersection(t)))
print('两者的并集为{}'.format(s.union(t)))
print('两者的差集为{}'.format(s.difference(t)))
print('两者的对称差集为{}'.format(s.symmetric_difference(t)))运行结果同上。
例题1：
题目描述：输入若干个数字，请将所有数字去重后输出数字个数
参考答案：
a = list(map(int,input().split()))
s = set(a)
print('s = ',s)
print(len(s))运行结果：
例题2：
题目描述：
维护一个数据结构管理表格，初始一个n行m列的表格，元素均为空，需要完成若干次操作：
set x y value：将表格第x行第y列设置为value
find x y：查找第x行第y列对应的值
del x y：删除第x行第y列的值
Many value：查找value是否在表格中，如果在表格中则出现次数为多少
参考答案：
class Table:
def __init__(self, n, m):
self.n = n
self.m = m
self.table = [[None] * m for _ in range(n)] # 初始化表格
def set_value(self, x, y, value):
self.table[x][y] = value
def find_value(self, x, y):
return self.table[x][y]
def delete_value(self, x, y):
self.table[x][y] = None
def count_value(self, value):
count = 0
for row in self.table:
count += row.count(value)
return count
# 示例操作
table = Table(3, 4) # 创建一个3行4列的表格
table.set_value(0, 0, "A")
table.set_value(0, 1, "B")
table.set_value(1, 2, "C")
print(table.find_value(0, 0)) # 输出：A
print(table.find_value(1, 1)) # 输出：None
table.delete_value(0, 1)
print(table.find_value(0, 1)) # 输出：None
print(table.count_value("A")) # 输出：1
print(table.count_value("B")) # 输出：0
运行结果：
这里我是用类来写的，可以先参考一下，我后面会写知识点的。
18.time模块
python中有很多模块可以用来处理时间，time模块可以获取时间戳，常用于计时。
如何使用time模块？
在文件顶部添加import time：导入time模块，可以使用time模块中的所有功能，
需要使用time + . + 对应功能名称即可
时间戳：s = time.time()：返回一个浮点数，表示一个时间戳
利用时间戳函数，可以计算程序运行时间
time.sleep()：程序睡眠几秒
# 导入time模块
import time
# 获取时间戳
start_time = time.time()
print('start_time = ',start_time)
# 执行代码
time.sleep(3)
# 获取时间戳
end_time = time.time()
print('end_time = ',end_time)
# 计算运行时间
print('运行时间 = {:.0f}'.format(end_time - start_time))运行结果：
获取本地时间：
time.localtime()：返回本地时间，是一个struct_time对象 ，struct_time对象之间不可加减
# 导入time模块
import time
# 获取本地时间
t = time.localtime()
print('type(t) = ',type(t))
print('t = ',t)
print('年份 = ',t.tm_year) # 4位数
print('月份 = ',t.tm_mon) # 1 - 12
print('日期 = ',t.tm_mday) # 1 - 31
print('小时 = ',t.tm_hour) # 0 - 23
print('分钟 = ',t.tm_min) # 0 - 59
print('秒 = ',t.tm_sec) # 0 - 61运行结果：
格式化日期：
time.strftime(format[,t]) ：把时间t按照format格式转换，返回一个字符串
time.strptime(string,format)：把字符串按照format转换，返回一个时间
# 导入time模块
import time
# 获取本地时间
t = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime())
print('type(t) = ',type(t))
print('t = ',t)运行结果：
19.datetime模块
datetime模块支持日期和时间的运算，包含下面四种数据
date：日期
time：时间
datetime：日期时间
timedelta：时间间隔
# 定义date，传递年，月，日
import datetime
a = datetime.date(2024,2,9)
print('type(a) = ',type(a))
print('a = ',a)
# 获取年，月，日
print('年份 = ',a.year)
print('月份 = ',a.month)
print('日期 = ',a.day)
print('具体是星期',a.weekday())
# date之间是减法
a = datetime.date(2024,2,9)
b = datetime.date(2024,4,13)
print('type(b - a) = ',type(b-a))
print('距离省赛还有{}天'.format(b - a))运行结果：
# 定义time：传递时分秒
import datetime
a = datetime.time(16,2,20)
print('type(a) = ',type(a))
print('a = ',a)
# 获取时，分，秒
print('a.hour = ',a.hour)
print('a.minute = ',a.minute)
print('a.second = ',a.second)运行结果：
# 定义datetime，传递时分秒，年月日
import datetime
a = datetime.datetime(2024,2,9,17,32,30)
print('type(a) = ',type(a))
print('a = ',a)
print('a.date = ',a.date())
print('a.time = ',a.time())
d = datetime.date(2024,2,9)
t = datetime.time(17,47,30)
b = datetime.datetime.combine(d,t)
print('b = ',b)
print(b > a)
print(b - a)运行结果：
时间差：表示两个 datetime对象之间的间隔
import datetime
a = datetime.datetime(2024,2,9,18,0,0)
delta = datetime.timedelta(days = 100)
# 计算100天前的日期
b = a - delta
print('100天前的日期为：',b)
# 计算100天后的日期
b = a + delta
print('100天后的日期是：',b)运行结果：
日期，时间，日期时间转换成字符串：strftime
import datetime
d = datetime.date(2024,2,9)
print(d.strftime('%Y-%m-%d'))
t = datetime.time(18,13,20)
print(t.strftime('%H:%M:%S'))
dt = datetime.datetime.combine(d,t)
print(dt.strftime('%Y-%m-%d %H:%M:%S'))运行结果：
字符串转换成日期时间
strptime(date_string,format)
import datetime
a = datetime.datetime.strptime('2024-2-9-18-22-30','%Y-%m-%d-%H-%M-%S')
print('a = ',a)运行结果：
获取当前日期：
import datetime
a = datetime.date.today()
print('a = ',a)
b = datetime.datetime.now()
print('b = ',b)运行结果：
例题1：
题目描述：
计算从1901年1月1日到2000年1月31日存在多少个星期一？
参考答案：
import datetime
start = datetime.date(1901,1,1)
end = datetime.date(2000,12,31)
ans = 0
while start <= end:
if start.weekday() == 0:
ans += 1
start += datetime.timedelta(days = 1)
print(ans)运行结果：
20.日期与时间相关例题（顺子日期）
题目描述：
小明特别喜欢顺子。顺子指的就是连续的3个数字：123，456等。顺子日期指定是在日期的yyyymmdd表示法中，存在任意连续的三位数是一个顺子的日期。例如20220123就是一个顺子日期，因为它出现了一个顺子：123，而20221023就不是一个顺子，因为它一个顺子都没有，小明想知道在整个2022年份中，一共有多少个顺子日期？
参考答案：
import datetime
start = datetime.date(2022,1,1)
end = datetime.date(2022,12,31)
m = ['012','123','234','345','456','567','678','789']
ans = 0
while start <= end:
now_date = start.strftime('%Y%m%d')
for x in m:
if x in now_date:
ans += 1
break
start += datetime.timedelta(days = 1)
print(ans)运行结果：
OK，这篇文章比较长，我写了4天，相当于一篇阶段总结，大家可以参考一下。下次继续！
接下来，祝大家：
龙年好运，福寿双全，
愿你天天开心，岁岁平安。
金龙翱翔，好运连连，
愿你事业顺风，心想事成！
龙年大运，财运亨通。
潜龙腾跃而起，便是人间春色万里。
2024，愿你我
有趣，有盼，无灾，无难。
最后，祝自己，也祝看到这篇博客的朋友们，蓝桥杯备赛顺利！
