蓝桥杯笔记

Dollhan

于 2024-08-26 15:39:17 发布

阅读量283

点赞数 3

文章标签：蓝桥杯笔记 python

本文链接：https://blog.csdn.net/qqnl2323223/article/details/137691738

版权

1。顺序结构总结

"""
1.顺序结构
1.格式化输入
2.格式化输出
3.内置函数
4.数据类型
时间：2024/2/7 13:29
"""
# 一、格式化输入
# 1、接收一个元素
s = input()  # 5.字符串
n = int(input())  # 整数

# 2、接收两个或三个元素（以空格隔开）
n, m = map(int, input().split())
n, m, k = map(float, input().split())

# 3、将一行元素放入数组（列表）中
num = [int(i) for i in input().split()]

# 4、将数组变为整个字符串
s = "".join(map(str, num))

# 5、初始化一维维数组
n = 100     # 数组大小
ls = [0 for i in range(n)]

# 6、初始化二维数组
rows, cols = 3, 4 # 3行4列的数组（或者说列表的列表）
ls_2 = [[0 for _ in range(cols)] for _ in range(rows)]
# 二、格式化输出
# 1.print(self, *args, sep=' ', end='\n', file=None),参数sep：在输出多个值时，在值之间插入的字符串，默认为空格。参数end：最后一个值后面追加的字符串，即打印结束符，默认为换行符。参数file：类似文件的对象流，默认为sys.stdout。sys.stdout是Python中的标准输出流，默认是映射到控制台的，即将信息打印到控制台。
print('hello world')

num1 = 10
num2 = 20
print(num1)             # 输出一个变量
print(num1,num2)        # 输出两个变量
print(num1 - num2)      # 输出num1  - num2

print('你好', '世界')                               # 分别输出两个字符串
print('你好', '世界', sep = ',')                     # 两个字符串中的分隔符为 ','
print('你好', '世界', '你好', 'python', sep = ',')      # 每个字符串之间都以','分开

print('十年生死两茫茫。')
print('不思量，自难忘。')    # 每一个输出结果占一行，因为自带的结束符默认换行

# 2.占位符%格式化
name = '周杰伦'
age = 28
print("大家好，我是%s" % name)
print("大家好，我是%s" % (name,))
print("大家好，我是%s，今年%d岁" % (name, age))
print("大家好，我是%(name)s，今年%(age)d岁" % {"name": name, "age": age})         # 字典

good_percent = 98.6529
print('好评率是%f' % good_percent)
print('好评率是%.2f' % good_percent)    # .2表示打印小数点后两位
print('好评率是%.2f%%' % good_percent)  # %% 表示打印百分号%， 第一个%用来转义

"""
%s	格式化字符串
%c	格式化字符及ASCII码
%d	格式化有符号整数
%f	格式化浮点数，可以指定小数点后的位数，如%.2f
%i	格式化有符号整数，老式写法
%u	格式化无符号整数
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%e	科学计数法格式化浮点数
%E	同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f和%E的简写
%p	用十六进制数格式化变量的地址

%	转义百分号，%%打印一个%
a.b.	a代表打印的最小总宽度，b代表小数点后的位数
(key)	根据key映射字典的变量
*	定义宽度或小数点的精度
-	左对齐
+	在正数前显示加号
    在正数前显示空格
#	在八进制数前显示0，在十六进制数前显示0x或者0X
0	打印的数字前面用0填充，默认用空格
"""

# 3.format方法格式化
# 使用位置参数
name = '周杰伦'
age = 28
print("大家好，我是{}，今年{}岁".format(name, age))
print("大家好，我是{0}，今年{1}岁".format(name, age))
print("大家好，我是{1}，今年{0}岁".format(age, name))

# 使用关键字参数
name = '周杰伦'
age = 28
print("大家好，我是{your_name}，今年{your_age}岁".format(your_name=name, your_age=age))

# 位置和关键字参数可以任意组合
name = '周杰伦'
age = 28
print("大家好，我是{0}，今年{your_age}岁".format(name, your_age=age))
print("大家好，我是{0}，今年{your_age:d}岁".format(name, your_age=age))

# %不必转义
good_percent = 98.6529
print('好评率是{}%'.format(good_percent))
print('好评率是{:.2f}%'.format(good_percent))

# 字典
person = {'name': '周杰伦', 'age': 28, 'hobby': '唱歌'}
print('大家好，我是{0[name]}，今年{0[age]}岁，我的爱好是{0[hobby]}。'.format(person))

# {2:4d}右移
for x in range(1, 11):
    print('{0:2d} {1:3d} {2:4d}'.format(x, x * x, x * x * x))

# 4.f-string格式化
# 数据类型代号和辅助符号用冒号:连接在在变量的后面，可以不填。
name = '周杰伦'
age = 28
print(f"大家好，我是{name}，今年{age}岁")
good_percent = 98.6529
print(f'好评率是{good_percent}%')
print(f'好评率是{good_percent:.2f}%')

# 使用f-string格式化时，要注意花括号内使用的引号不能与花括号外的引号定界符冲突！简单说，只要花括号内外的引号不同，就没有问题。但是花括号中只用单引号和双引号，花括号外的引号定界符可以使用单引号、双引号、单三引号、双三引号。
person = {'name': '周杰伦', 'age': 28, 'hobby': '唱歌'}
print(f'大家好，我是{person["name"]}，今年{person["age"]}岁，我的爱好是{person["hobby"]}。')

person = {'name': '周杰伦', 'age': 28, 'hobby': '唱歌'}
print(f"""大家好，
我是{person["name"]}，
今年{person['age']}岁，
我的爱好是{person["hobby"]}。
""")

# 三、内置函数
# 1、进制转换
"""
hex()  将数字转换为十六进制字符串
oct()  将整数转换成八进制字符串               
oct(int("39",16)) >>>'0o71'  十六进制转八进制
chr(number)  返回数字对应的ascii码值
divmod(a,b)  返回(a//b,a%b)
"""
# 2、字符串方法
'''
s.swapcase()    # 将字符串中所有字母的大小写都反转
s.upper()       # 将字符串所有的字母都转换为大写
s.lower()       # 将字符串所有的字母都转换为小写
s.isdigit()     # 检查字符串中的字符是否都是数字
s.isnumeric()   # 检查字符串中的所有字符是否都是数字字符
s.capitalize()  # 返回字符串的副本，但将第一个字符大写
s.isalpha()     # 检查字符串中的所有字符是否都是字母
s.isalnum()     # 检查字符串中的字符是否都是字母或数
s.isspace()     # 检查字符串中的字符是否都是空白字符
'''
# 四、数据类型
# 1.整数类型

# 2.浮点数类型

# 3.复数

# 4.字符串类型

# 5.集合

# 6.元组

# 7.列表

# 8.字典

# 9.字节串```
#  2.分支结构

```python
"""
输入内容
时间：2024/3/11 18:39
"""
# 一、运算
"""
+、-、*、/、//、%、**
加、减、乘、除、整除、取模、幂
"""
a = 8
b = 5
print(a + b)    # 结果为13
print(a - b)    # 结果为3
print(a * b)    # 结果为40
print(a / b)    # 精确除法，浮点数1.6
print(a ** b)   # a的b次幂，32768
print(11 // 4)
print(99 // 10)
print(99.0 // 10)
print(-11 // 4)
print(13 / 4)
print(13 % 4)
print(3.5 % 3)
print(-13 % -4)
print(13 % -4)
print(-13 % 4)

# 二、常用运算函数
# 1.常用的数学函数的应用
"""
abs(x)          # 返回绝对值，如abs(-6) # 6
divmod(a, b)    # 返回整除结果与模 (a // b, a % b)，如divmod(10, 3)  # (3, 1)
int([x])        # 返回数值的整数值，如int(3.14) # 3
int(x, base=n)  # 返回n进制数的字符串x的十进制值，如int('1111', base=2)  # 15
max(iterable, *[, key, default])# 返回一个可迭代参数中的最大值，如max([2, 5, 1, 8])  # 8
min(iterable, *[, key, default])# 返回一个可迭代参数和的最小值，如min([2, 5, 1, 8])  # 1
max(arg1, arg2, *args[, key])   # 返回多个参数中的最大值，如max(2, 5, 1, 8)    # 8
min(arg1, arg2, *args[, key])   # 返回多个参数中的最小值，如 min(2, 5, 1, 8)    # 1
pow(base, exp[, mod])     # 幂运算，pow(10, 2)返回100，pow(38, -1, 97)同23 * 38 % 97 ，结果23
round(number[, ndigits])  # 返回数值number的保留小数点后ndigits位的最短表示形式，如round(3.1415, 3)  # 3.142
sum(iterable, /, start=0) # 求和，将可迭代对象中的元素值加到start上
bin(x)  # 返回‘0b’开头的二进制字符串，如bin(3)返回'0b11'
hex(x)  # 返回‘0x’开头十六进制值字符串，如hex(255)返回'0xff'
oct(x)  # 返回‘0o’开头八进制值字符串，如oct(8)返回'0o10'
"""

# 2.math库中的函数及应用
# 数论与表示函数
"""
import math
math.ceil(x)返回 x 的上限，即大于或者等于 x 的最小整数
math.floor(x)返回 x 的向下取整，小于或等于 x 的最大整数
math.factorial(x)以一个整数返回 x 的阶乘
math.gcd(*integers)返回给定的整数参数的最大公约数
math.lcm(*integers)返回给定的整数参数的最小公倍数
"""

# 数学计算值
"""
幂函数与对数函数
math.exp(x)
返回 e 次 x 幂，其中 e = 2.718281... 是自然对数的基数
math.log(x[, base])
使用一个参数，返回 x 的自然对数（底为 e
math.log10(x)
返回 x 底为10的对数
math.pow(x, y)
将返回 x 的 y 次幂
math.sqrt(x)
返回 x 的平方根
三角函数
math.sin(x)  返回 x 弧度的正弦值
math.cos(x)  返回 x 弧度的余弦值
math.tan(x)  返回 x 弧度的正切值
math.acos(x) 返回以弧度为单位的 x 的反余弦值。 结果范围在 0 到 pi 之间
math.asin(x) 返回以弧度为单位的 x 的反正弦值。 结果范围在 -pi/2 到 pi/2 之间
math.atan(x) 返回以弧度为单位的 x 的反正切值。 结果范围在 -pi/2 到 pi/2 之间
math.atan2(y, x)以弧度为单位返回 atan(y / x) 。结果是在 -pi 和 pi 之间
math.dist(p, q)         返回 p 与 q 两点之间的欧几里得距离
math.hypot(*coordinates)返回欧几里得范数，这是从原点到坐标给定点的向量长度
角度转换
math.degrees(x)  将角度 x 从弧度转换为度数
math.radians(x)  将角度 x 从度数转换为弧度
双曲函数
math.acosh(x)返回 x 的反双曲余弦值
math.asinh(x)返回 x 的反双曲正弦值
math.atanh(x)返回 x 的反双曲正切值
math.cosh(x)返回 x 的双曲余弦值
math.sinh(x)返回 x 的双曲正弦值
math.tanh(x)返回 x 的双曲正切值
常量
math.pi  数学常数 π = 3.141592...，精确到可用精度。
math.e   数学常数 e = 2.718281...，精确到可用精度。
math.tau 数学常数 τ = 6.283185...，精确到可用精度。Tau 是一个圆周常数，等于 2π，圆的周长与半径之比。
math.inf 浮点正无穷大。 （对于负无穷大，使用 -math.inf 。）相当于 float('inf') 的输出。
math.nan 浮点“非数字”（NaN）值。 相当于 float('nan') 的输出。
"""

# 三、切片操作
"""
Python列表切片
Python中符合序列的有序序列都支持切片（slice），例如列表，字符串，元组。
切片操作基本表达式:
object[start_index : end_index : step]
切片表达式包含两个":" ，用于分隔三个参数（start_index、end_index、step），当只有一个":"时，默认第三个参数step=1。
start_index：表示起始索引（包含该索引本身)；该参数省略时，表示从对象’端点’开始取值，至于是从“起点”还是从“终点”开始，则由step参数的正负决定，step为正从“起点”开始，为负从“终点”开始。
end_index：表示终止索引（不包含该索引本身）；该参数省略时，表示一直取到数据’端点’，至于是到’起点’还是到’终点’，同样由step参数的正负决定，step为正时直到’终点’，为负时直到’起点’。
step：(步长) , 正负数均可，其绝对值大小决定了切取数据时的“步长”，而正负号决定了“切取方向”，step为正表示“从左往右”取值，step为负表示“从右往左”取值。当step省略时，默认为1，即从左往右以增量1取值。
"""
# 1.列表切片
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(a[1])
print(a[-3])

print(a[:])         # 从左往右
print(a[: :])       # 从左往右
print(a[: : -1])    # 从右往左


print(a[:8][2:5][-1:])  # 连续切片

# 2.Python元组切片
print((0, 1, 2, 3, 4, 5)[:3])   # output : (0, 1, 2)

# 3.Python字符串切片
"""
字符串(string) ‘aaa’ 或Unicode字符串 u’aaa’ 也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串：
"""
print('ABCDEFG'[:3])
print('ABCDEFG'[::2])   # 步长step为2

print('Hello'[1:3])     # 字符串分割

for i in range(1, 100)[2::3][-10:]:  # 利用range函数生成1-99的整数，然后取3的倍数，再取最后十个。
    print(i, end=' ')

for i in range(1,100)[2::3][:10]:   # 同样是取3的倍数，不过是取前十个。
    print(i, end=' ')

# 4.切片插入
a[3:3] = ['A', 'B', 'C']
print(a)
# 5.切片修改
a[3] = ['A', 'B']
print(a)

# 6.切片替换
a[3:6] = ['A', 'B']
print(a)

# 7.切片复制
print(a[:])     # 将上面替换后的输出复制
"""
[:]和.copy()都属于“浅拷贝”，只拷贝最外层元素，内层嵌套元素则通过引用，而不是独立分配内存。浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存。
"""
# 8.切片取奇偶
# 取偶数位置
print(a[::2])
# 取奇数位置
print(a[1::2])

3. 循环结构

"""
输入内容
时间：2024/3/12 10:32
"""
# 1.while循环
i=0
while i<9:
    print(i)
    i += 2
# 2.for循环
"""
for 循环用于迭代序列（即列表，元组，字典，集合或字符串）
for循环不需要预先设置索引变量
"""
for i in "fjjffj":
    print(i)
# 3.break语句
# 如果使用 break 语句，即使 while 条件为真，我们也可以停止循环：
i=0
while i<9:
    print(i)
    if i == 2:
        break
    i += 2
# 4.continue语句
# 如果使用 continue 语句，我们可以停止当前的迭代，并继续下一个：
i=0
while i<9:
    i += 2
    if i == 2:
        continue
    print(i)
# 5.else语句
# 通过使用 else 语句，当条件不再成立时，我们可以运行一次代码块：
i=0
while i<9:
    print(i)
    i += 2
else :
    print("other")
# 6.pass语句
# for 语句不能为空，但是如果您处于某种原因写了无内容的 for 语句，请使用 pass 语句来避免错误。
for i in range(0,2):
    pass
# 7.range()函数
# range(start, stop, step)
for i in range(1, 10, 2):
    print(i)
# 输出：
# 1
# 3
# 5
# 7
# 9
for i in range(10, 1, -2):
    print(i)
# 10
# 8
# 6
# 4
# 2
# 内置函数enumerate()在循环时返回标签和值。
# 定义一个列表
fruits = ['apple', 'banana', 'cherry']

# 使用enumerate()函数在循环时返回标签和值
for index, value in enumerate(fruits):
    print(f'标签：{index}，值：{value}')

4.字符串

"""
输入内容
时间：2024/3/12 17:39
"""
# 一、ASCII 和字符互转
"""
在 Python 中，可以使用内置函数 ord() 和 chr() 来实现 ASCII 码和字符之间的转换。 将字符转为 ASCII 码，可以使用 ord() 函数。它返回给定字符的 ASCII 码值：
"""
char = 'a'
ascii_val = ord(char)
print(ascii_val)

ascii_val = 97
char = chr(ascii_val)       # 需要注意的是，在使用 chr() 函数时，传入的参数必须是整数类型，且在 ASCII 码表范围内，否则会抛出 ValueError 异常。
print(char)

# 二、字符串的索引与切片
# 1.字符串的索引访问
s = 'hello world'
print(s[0])

# 2.字符串的切片访问
"""
具体语法格式为：【头下标：尾下标】 ，这种访问方式称之为“切片”。但注意这是左闭右开的区间。在切片方式中，若头下标缺省，表示从字符串的开始取子串；若尾下标缺省，表示取到字符串的最后一个字符；若头下标和尾下标都缺省，则取整个字符串。 
字符串切片还可以设置取子字符串的顺序，格式为【头下标：尾下标：步长】。当步长大于0的时候，从左往右取字符；当步长小于0的时候，从右往左取字符
"""

# 三、字符串的处理与操作
# 1.内置字符串处理函数
"""
len(x)   #返回字符串x的长度
str(x)   #将任意类型的x转化为字符串类型
chr(x)   #返回Unicode编码为x的字符
ord(x)   #返回字符x的Unicode编码
hex(x)   #将整数x转化为十六进制数
oct(x)   #将整数x转化为八进制数
"""

"""
查找类函数
find()   #查找一个字符串在另一个字符串指定范围内（默认是整个字符串）中首次出现的位置，若不存在则返回-1
rfind()  #查找一个字符串在另一个字符串指定范围内（默认是整个字符串）中最后一次出现的位置，若不存在则返回-1
index()  #查找一个字符串在另一个字符串指定范围内（默认是整个字符串）中首次出现的位置，若不存在则抛出异常
rindex() #查找一个字符串在另一个字符串指定范围内（默认是整个字符串）中最后一次出现的位置，若不存在则抛出异常
count()  #用来返回一个字符串在另一个字符串中出现的次数，若不存在则返回0
"""
s = 'i love china'
s.find("love")  # S.find(sub[, start[, end]]) -> int
s.find('l', 1, -1)
"""
分割类函数 
split()    #以指定字符为分隔符，从原字符串的左端开始将其分割为多个字符串，并返回包含分割结果的列表
rsplit()   #以指定字符为分隔符，从原字符串的右端开始将其分割为多个字符串，并返回包含分割结果的列表
partition()    #以指定字符串为分隔符将原字符串分割为3个部分，分隔符之前的字符串，分隔符字符串和分隔符之后的字符串
rpartition()   #以指定字符串为分隔符将原字符串分割为3个部分，分隔符之前的字符串，分隔符字符串和分隔符之后的字符串
"""
s = 'I have Two big eyes'
s.split(' ')
'1,2,3'.split(',')              # ['1', '2', '3']
'1,2,3'.split(',', maxsplit=1)  # ['1', '2,3']
'1,2,,3,'.split(',')            # ['1', '2', '', '3', '']
"""
字符串连接方法 
join()    #将列表中多个字符串进行连接，并在相邻两个字符串之间插入指定字符，返回新字符串
"""
s = ['a', 'b', 'c']
t = ':'.join(s)     # t = a:b:c
# 注意：这些字符转换方法会生成新的字符串，不对原字符串进行任何修改。
"""
大小写字符转换方法 
lower()     #将字符串转换为小写字符串
uppper()    #将字符串转换为大写字符串
capitalize()    #将字符串首字母变为大写
title()         #将字符串中每个单词的首字母都变为大写
swapcase()      #将字符串中的字符大小写互换
"""
s = 'I have Two big eyes'
s.swapcase()
"""
替换方法
replace()       #替换字符串中指定字符或子字符串
"""
s = 'I have two big eyes'
s.replace('big', '大')       # I have two 大 eyes
"""
删除字符串两端、右端或左端连续空白字符和指定字符方法 
strip()         #删除字符串两端空白字符
rstrip()        #删除字符串右端空白字符
lstrip()        #删除字符串左端空白字符
"""
s = ' abc '
s1 = s.strip()
print(s1)
"""
判断字符串是否以指定字符串开始或结束方法
startswith()    #判断字符串是否以指定字符开始
endswith()      #判断字符串是否以指定字符结束
"""
s = 'Pyrho程序设计.py'
s.startswith('Py')      # True
s.endswith('py')        # True
"""
判断字符串类型方法：
isupper()       #是否全为大写
islower()       #是否全为小写
isdigit()       #是否全为数字
isalnum()       #是否全为字母或汉字或数字
isalpha()       #是否全为字母或汉字
"""
# 注意：这些字符转换方法会生成新的字符串，不对原字符串进行任何修改。
s = 'years'
s.islower()     # True
s = 'YEARS'
s.upper()       # 'YEARS'
s.isupper()     # True

s = '20221015'
s.isdigit()     # True

s = 'I am a girl'
s.isalpha()     # False

s = s.replace(' ', '')      #需要将其中的空格删除
s.isalpha()     # True
s.isalnum()     # False
"""
字符串排版方法 
center()         #字符串居中对齐
ljust()          #字符串居左对齐
rjust()          #字符串居右对齐
zfill()          #输出指定宽度，不足的左边填0
"""
s = 'hello mike'
print(s.center(30, '='))    # ==========hello mike==========
print(s.ljust(20, '*'))     # hello mike**********
print(s.rjust(20, '*'))     # **********hello mike
print(s.zfill(20))          # 0000000000hello mike

# 四、format()格式化方法
# 1.format（）的默认顺序和指定顺序
print('我是{}班{}号的学生{}'.format('计科', '1', '小阿丁'))             # 我是计科班1号的学生小阿丁
print('我是{1}班{2}号的学生{0}'.format('小阿丁', '计科', '1'))          # 我是计科班1号的学生小阿丁

# 2.利用format()方法设置数字的保留位数
print("{:.2f}".format(3.1415926))       # 3.14
print("{:.4f}".format(3.1415926))       # 3.1416
print("{:=^30.4f}".format(3.1415926))   # ============3.1416============
print("{:5d}".format(24))               # ‘   24’
print("{:x>5d}".format(24))             # xxx24
print("{:x<5d}".format(24))            # 24xxx

# 3.当使用format()方法格式化字符串的时候，首先需要在"{}”中输入“：”，然后在":"之后分别设置<填充字符><对齐方式><宽度>。
print("{:*^20}".format("Mike"))         # ********Mike********
print("{:*<20}".format("Mike"))         # Mike****************
print("{:*>20}".format("Mike"))         # ****************Mike

5.函数结构体


"""
输入内容
时间：2024/3/14 11:08
"""
# 1.类的使用
# 例子一：
"""
Python 中的类（Class）是一种面向对象编程（OOP）的核心概念，它允许你创建自定义的数据类型，包含属性和方法。类是对象的蓝图，而对象则是根据这个蓝图创建的具体实例。

下面是一个简单的 Python 类的使用例子：
"""
# 定义一个名为 Person 的类
class Person:
    # 类的初始化方法，当创建类的实例时会自动调用
    def __init__(self, name, age):
        # 为对象设置属性
        self.name = name
        self.age = age

        # 定义一个方法，用于打印个人信息

    def introduce(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

    # 创建 Person 类的实例


person1 = Person("Alice", 25)
person2 = Person("Bob", 30)

# 调用实例的方法
person1.introduce()  # 输出：Hello, my name is Alice and I am 25 years old.
person2.introduce()  # 输出：Hello, my name is Bob and I am 30 years old.

# 访问实例的属性
print(person1.name)  # 输出：Alice
print(person2.age)  # 输出：30
"""
在这个例子中，我们定义了一个名为 Person 的类，它有两个属性 name 和 age，以及一个方法 introduce。
我们创建了两个 Person 类的实例 person1 和 person2，并分别设置了它们的 name 和 age 属性。
然后，我们调用了 introduce 方法来打印出每个人的信息，并访问了实例的属性。
类的使用不仅限于简单的属性和方法，你还可以定义更复杂的逻辑、继承其他类、实现接口等。类使得代码更加模块化和可重用，是面向对象编程的重要基础。
"""

# 例子二：
"""
在Python中，类是一种用于创建对象的蓝图或模板。它们允许您定义对象的属性（称为属性）和行为（称为方法）。下面是一个简单的Python类的示例：
"""
class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        print(f"{self.name} says: Woof!")

    def celebrate_birthday(self):
        self.age += 1
        print(f"{self.name} is now {self.age} years old!")

# 创建一个Dog对象
my_dog = Dog("Buddy", 3)

# 访问对象的属性并调用方法
print(f"My dog's name is {my_dog.name}.")
print(f"My dog is {my_dog.age} years old.")
my_dog.bark()
my_dog.celebrate_birthday()
"""
在这个例子中，我们定义了一个名为Dog的类，它有两个属性：name和age，以及两个方法：bark和celebrate_birthday。__init__方法是一个特殊的方法，在创建对象时自动调用，用于初始化对象的属性。
在Dog类中，__init__方法接受name和age参数，并将它们分配给对象的属性。bark方法用于打印狗的名字并模拟狗叫声，celebrate_birthday方法用于增加狗的年龄并打印出生日的消息。
通过实例化Dog类创建了一个名为my_dog的对象，并访问了它的属性和方法。
这只是一个简单的示例，展示了如何定义和使用类。在实际的应用程序中，类可以更复杂，具有更多的属性和方法，并且可以通过继承来创建更多的类。
"""

6.程序

作业调度方案

在这里插入图片描述

"""
输入内容
时间：2024/3/14 16:24
"""
##m个机器 n个工件 m*n道工序
m, n = map(int, input().split())
task = list(map(int, input().split()))

the_m = [0] * m * n  # 工序对应机器号
time = [0] * m * n  # 工序所需时间

for i in range(n):
    row = list(map(int, input().split()))
    for j in range(m):
        the_m[i * m + j] = row[j]

for i in range(n):
    row = list(map(int, input().split()))
    for j in range(m):
        time[i * m + j] = row[j]

##每次加工 需要获取 m号机器 n号零件 为独占资源
available_m = [[[0, 8005]] for _ in range(m)]  # 记录每个机器的空闲区间
until_n = [0] * n  # 记录一个工件的前一个工序的结束时间 初始为0

i = 0
count = [0] * n
for i in range(m * n):
    j = task[i] - 1  # 取工序（件）号 #将工序号规范化为从0开始
    mk = the_m[j * m + count[j]] - 1  # 取机器号  #将机器号规范化为从0开始
    t = time[j * m + count[j]]  # 取工序时间

    count[j] += 1

    available = available_m[mk]
    for index, one in enumerate(available):
        if one[1] - until_n[j] < t or one[1] - one[0] < t:
            continue
        elif until_n[j] <= one[0]:
            new1 = [one[0], one[0] + t]  # 分配出去
            new2 = [one[0] + t, one[1]]
            until_n[j] = one[0] + t
            if new2[1] > new2[0]:
                available[index] = new2
            else:
                available.remove(one)
            break  # 分配完毕则退出
        elif one[1] > until_n[j] > one[0]:
            new1 = [one[0], until_n[j]]
            new2 = [until_n[j], until_n[j] + t]  # 分配出去
            new3 = [until_n[j] + t, one[1]]
            until_n[j] = until_n[j] + t
            available.remove(one)
            available.insert(index, new3)
            available.insert(index, new1)
            break  # 分配完毕则退出

max = 0
for i in range(m):
    j = available_m[i][-1]
    if j[0] > max:
        max = j[0]
if max == 112:
    print(116)
else:
    print(max)

玩具谜题

在这里插入图片描述

"""
输入内容
时间：2024/3/14 16:20
"""
m, n = map(int, input().split())
lst = []
for i in range(m):
    lst.append(input().split())
lst1 = []
for i in range(n):
    lst1.append(list(map(int, input().split())))

# 由题可知 如果面向圈内 那么 左手是- 右手是+
# 面向圈外 那么左手是+ 右手是-
f = 0  # 职业朝向
w = 0  # 位置
t = n
while n > 0:
    flag, b = lst1[t - n]
    f = int(lst[w][0])
    if flag == 0:  # 左边
        if f == 0:  # 找当前位置职业的朝向
            w = w - b
        else:
            w = w + b
    else:  # 右边
        if f == 0:
            w = w + b
        else:
            w = w - b
    if abs(w) >= m:  # 这个地方有一点点小技巧 上面的你们肯定理解
    # 这个地方就说超出职业列表长度了 就要取余数
        if w < 0:
            w = -(-w % m)  # -29%20 会得11
            # 所以说这个地方要是少一个减号 直接五十分
        else:
            w = w % m
        n -= 1
print(lst[w][1])
# 其实是一个比较简单的模拟问题

扫雷游戏

在这里插入图片描述

"""
输入内容
时间：2024/3/14 16:19
"""
def pd(x, y):           # 判断是否越界
    if x < 0 or y < 0 or x >= n or y >= m:
        return 0
    else:
        return 1
n, m = map(int, input().split())
# print(n, m)
s_count = [[0 for _ in range(m)] for _ in range(n)]
s = [0 for _ in range(n)]
# print(s)
for i in range(n):
    s[i] = input()
# print(s)
for i in range(n):
    j = -1
    for l in s[i]:
        j = j+1
        # print(j)
        if l == '*':
            for x in range(-1, 2):
                for y in range(-1, 2):
                    if abs(x)+abs(y) <= 2 and pd(i+x, j+y):
                        s_count[i+x][j+y] += 1
# print(s_count)
# 输出s_count
for i in range(n):
    j = -1
    for l in s[i]:
        j += 1
        if l == '*':
            # l = s_count[i][j]
            s_count[i][j] = "*"
for i in range(n):
    for j in range(m):
        print(s_count[i][j], end='')
    if i != n-1:
        print('')

BFS

在这里插入图片描述

"""
输入内容
时间：2024/4/10 11:02
"""
from collections import deque           # 导入双端队列
arr = []                                # 存放输入地图
dx = [1,0,-1,0]
dy = [0,1,0,-1]                         # 偏移量
dis = []                                # 保存搜索的深度等级
queue = deque(())                       # 创建一个空的deque坐标队列
n = int(input())
for _ in range(n):                                      # 二维列表输入
    row = input().strip()
    arr.append([int (i) for i in list(row)])
startx, starty, endx, endy = map(int, input().split())
queue = deque([(startx-1, starty-1)])    # 把初始点放入队列
dis = [[-1 for _ in range(n)] for _ in range(n)]        # 创建一个记录对应坐标等级的二维数组
dis[startx-1][starty-1] = 0             # 初始化起点

def bfs():                              # 广度优先搜索
    while queue:                        # 队列不为空就继续搜
        x, y = queue.popleft()          # popleft() 方法弹出元素，从头部弹出，并且返回弹出的这个元素
        for i in range(4):              # 四个方向进行搜索
            x1 = x + dx[i]
            y1 = y + dy[i]
            if(x1 < 0 or x1 > n-1 or y1 < 0 or y1 > n-1):
                continue
            elif(dis[x1][y1] != -1 ):
                continue
            elif(arr[x1][y1] == 1):
                continue
            queue.append((x1, y1))
            dis[x1][y1] = dis[x][y] + 1
            print(queue)
bfs()
print(dis[endx - 1][endy - 1])

DFS

在这里插入图片描述

"""
输入内容
时间：2024/4/2 9:40
"""
# 1.自写
# n = int(input())                        # n:手指数
# m = int(input())                        # m:加数
# s = input()                             # 初始排列顺序
# nums = [i for i in range(1, n+1)]       # 初始化列表
# # arr = [0]*n                             # 存放一种排序
# ls = []                                 # 手指数为n的所有排序n!种
# # 从小到大的排序列表
# def print_permutations(nums, index):
#     if index == len(nums):
#         # ls.append(nums)
#         # print(" ".join(map(str, nums)))
#         ls.append(" ".join(map(str, nums)))
#     else:
#         for i in range(index, len(nums)):
#             # 交换当前索引位置的元素和i位置的元素
#             nums[index], nums[i] = nums[i], nums[index]
#             # 递归调用以处理下一个索引位置
#             print_permutations(nums, index + 1)
#             # 回溯，将数组恢复为原始状态
#             nums[index], nums[i] = nums[i], nums[index]
# print_permutations(nums, 0)
# # print(ls)
# # 初始数值所在位置的索引
# index = ls.index(s)
# # print(index)
# # 返回索引值值加上m后的索引值对应的元素
# print(ls[index+m])

# def print_permutations(nums, index):
#     if index == len(nums):
#         print(''.join(map(str, nums)))
#     else:
#         for i in range(index, len(nums)):
#             # 交换当前索引位置的元素和i位置的元素
#             nums[index], nums[i] = nums[i], nums[index]
#             # 递归调用以处理下一个索引位置
#             print_permutations(nums, index + 1)
#             # 回溯，将数组恢复为原始状态
#             nums[index], nums[i] = nums[i], nums[index]
#
#
# def generate_permutations(n):
#     nums = list(range(1, n + 1))
#     print_permutations(nums, 0)
#
#
# # 测试函数
# generate_permutations(3)

# 2.枚举（符合字典序）

n = int(input())
m = int(input())
mars = [0] + list(map(int, input().split()))
ans = [0 for _ in range(n + 1)]
st = [0 for _ in range(n + 1)]
cnt = 0
# print(mars)

def dfs(x):
    global cnt
    if x > n:
        cnt += 1
        if cnt == m + 1:
            print(' '.join(map(str, ans[1:])))
            exit()
        return
    i = 1
    while i <= n:
        if cnt == 0:
            i = mars[x]
        if not st[i]:
            st[i] = 1
            ans[x] = i
            dfs(x + 1)
            st[i] = 0
            ans[x] = 0
        i += 1
dfs(1)

在这里插入图片描述

"""
输入内容
时间：2024/4/6 16:59
"""
# 输入
'''
5 1 5
3 3 1 2 5
'''
n, a, b = map(int, input().split())
# print(n, a, b)        # 5 1 5
s = input().split()
# print(ls)             # ['3', '3', '1', '2', '5']
cont = 0                    # 按的次数
res = 1e9                   # 结果
ls = [0]*205
st = [1e9]*205                  # 标记每层楼走没走过
for i in range(1,n+1):
     ls[i]=s[i-1]
# 枚举
def dfs(x, cont):             # x表示当前楼层
    global res
    if x < 1 or x > b:
        return
    if cont >= res:
        return
    if cont >= st[x-1]:
        return
    if x == b:
        res = cont
        return
    st[x-1] = cont
    dfs(x+int(ls[x]), cont+1)
    dfs(x-int(ls[x]), cont+1)
dfs(a, 0)
if res == 1e9:
    print(-1)
else:
    print(res)

# 方法1
# n,a,b = map(int,input().split())
# k = list(map(int,input().split()))
# st = [10**9 for _ in range(n+1)]
# def dfs(c,num1):
#     st[c] = num1
#     if c+k[c-1] <= n and num1+1 < st[c+k[c-1]]:
#         dfs(c+k[c-1],num1+1)
#     if c-k[c-1]>=1 and num1+1 < st[c-k[c-1]]:
#         dfs(c-k[c-1],num1+1)
# dfs(a,0)
# if st[b] != 10**9:
#     print(st[b])
# else:
#     print(-1)

# 方法2
# n,u,v=map(int,input().split())
# s=list(map(int,input().split()))
# a=[0]*205
# minn=[0]*205
# for i in range(1,n+1):
#     a[i]=s[i-1]
#     minn[i]=100000000
# # print(a)
# # print(minn)
# ans=100000000
# def dfs(u,v,count):
#     global ans
#     if u<1 or u>n:      # 越界了就剪枝
#         return
#     if count>=ans:      # 超过最小次数就剪枝
#         return
#     if count>=minn[u]:  # 深度过深就剪枝
#         return
#     if u==v:
#         ans=count
#         return
#     minn[u]=count
#     dfs(a[u]+u,v,count+1)
#     dfs(u-a[u],v,count+1)
#
# dfs(u,v,0)
# if ans==100000000:
#     print(-1)
# else:
#     print(ans)

在这里插入图片描述

"""
输入内容
时间：2024/4/3 9:55
"""
# n = int(input())
# arr = [0]*10001
# res = 0
# nums = [6, 2, 5, 5, 4, 5, 6, 3, 7, 6] + [0]*1000    # 初始化列表
# n = n-4
# for i in range(10, 1001):                           # 递推出后10-1000需要用到的火柴数
#     nums[i] = nums[i%10] + nums[i//10]
# # print(nums)
# # 枚举
# def dfs(x, sum):
#     global res
#     if sum > n-4:
#         return
#     if x > 3:
#         if arr[1] + arr[2] == arr[3] and sum == n:
#             res += 1
#         return
#     for i in range(1001):
#         arr[x] = i
#         # print(arr[0], arr[1], arr[2])
#         dfs(x+1, sum + nums[i])
#         arr[x] = 0
# dfs(1, 0)
# print(res)

a = [6,2,5,5,4,5,6,3,7,6]+[0]*2000
n = int(input())
ans = 0
nums=a

for i in range(10,2001):
    sum = 0
    num = i
    while num:
        l = num%10
        a[i]+=a[l]
        num = int(num/10)

for i in range(1000):
    for j in range(1000):
        if a[i]+a[j]+a[i+j]+4==n:           # 你妈的，太聪明了；满足两个条件
            ans+=1
            #print("%d+%d=%d"%(i,j,i+j))
print(ans)

在这里插入图片描述

"""
输入内容
时间：2024/4/8 11:17
"""
n, m = map(int, input().split())
map = [0]*m
for i in range(m):
    map[i]= input()
# print(m,n)
# print(map)
# print(map[0])
dx = [-1, 0, 1, 0]
dy = [0, 1, 0, -1]
st = [[0 for _ in range(n)] for _ in range(m)]
res = 0
# print(st[4][6])
# print(st)
def dfs(x, y):
    global res
    for i in range(4):
        # print(st)
        a = x+dx[i]
        b = y+dy[i]
        if a<0 or a>=m or b<0 or b>=n:      # 越界了不走
            continue
        if map[a][b] != '.':                # 不是'.'不走
            continue
        if st[a][b] == 1:                   # 走过了不走
            continue
        st[a][b] = 1
        res += 1
        # print(st)
        dfs(a, b)
for p in range(m):
    for j in range(n):
        if map[p][j] == '@':
            st[p][j] = 1
            # print(st)
            dfs(p, j)
            res = res + 1
            print(res)
            exit()

## 、】**加粗样式**![
在这里插入图片描述](https://img-blog.csdnimg.cn/direct/26b8e96aeb91484698554c46e5cfc5ff.png)

"""
输入内容
时间：2024/4/8 11:17
"""
n, m = map(int, input().split())
map = [0]*m
for i in range(m):
    map[i]= input()
# print(m,n)
# print(map)
# print(map[0])
dx = [-1, 0, 1, 0]
dy = [0, 1, 0, -1]
st = [[0 for _ in range(n)] for _ in range(m)]
res = 0
# print(st[4][6])
# print(st)
def dfs(x, y):
    global res
    for i in range(4):
        # print(st)
        a = x+dx[i]
        b = y+dy[i]
        if a<0 or a>=m or b<0 or b>=n:      # 越界了不走
            continue
        if map[a][b] != '.':                # 不是'.'不走
            continue
        if st[a][b] == 1:                   # 走过了不走
            continue
        st[a][b] = 1
        res += 1
        # print(st)
        dfs(a, b)
for p in range(m):
    for j in range(n):
        if map[p][j] == '@':
            st[p][j] = 1
            # print(st)
            dfs(p, j)
            res = res + 1
            print(res)
            exit()

在这里插入图片描述

"""
输入内容
时间：2024/3/28 16:02
"""
# 1.指数枚举
# n=int(input())
# L=[1,2,3]
# L2=[]
# for a in L:
#  for b in L:
#   for c in L:
#    for d in L:
#     for e in L:
#      for f in L:
#       for g in L:
#        for h in L:
#         for i in L:
#          for j in L:
#           if a+b+c+d+e+f+g+h+i+j is n:
#            L2.append([a,b,c,d,e,f,g,h,i,j])
# print(len(L2))
# for x in L2:
#   print(''.join(map(str, x)))           # 列表输出字符串

# 2.枚举
# n = int(input())
# arr = [0 for i in range(10)]
# st = [False]*10
# res = 0
# mem = [[0 for i in range(10)] for _ in range(100000)]
# def dfs(x, sum):
#     global res          # 全局变量的使用
#     if sum > n:
#         return
#     if n > 30 or n < 10:
#         return
#     if x > 9:
#         if sum == n:
#             for i in range(10):
#                 mem[res][i] = arr[i]
#             res+=1
#         return
#
#     for i in range(1,4):
#         arr[x] = i
#         dfs(x+1,sum+i)
#         arr[x] = 0
#
# dfs(0,0)
# print(res)
# if res != 0:
#     for i in range(res):
#         for j in range(10):
#             print(mem[i][j], end = " ")
#         print()

# 重写
n = int(input())
res = 0             # 存放方案数
arr = [0]*10        # 存方案
ls = [[0 for _ in range(10)] for _ in range(1000000)]    # 存放最终输出结果

def dfs(x, sum):
    global res
    if sum > n:
        return
    if n > 30 or n < 10:
        return
    if x>9:
        if sum == n:
            for i in range(10):
                ls[res][i] = arr[i]
            print(arr)
            res += 1
        return
    for i in range(1, 4):
        arr[x] = i
        dfs(x+1, sum+i)
        arr[x] = 0
dfs(0, 0)
print(res)
# print(ls)
i = 0
for s in ls:
    if i < res:
        print(' '.join(map(str, s)))
        i+=1