q

其实我也可以从网上复制来水博客，但是留不下的印象的话就没有意义。网上别的完好的笔记我会以链接的形式放在这里。我这篇博客里面的只会是我自己的理解和自己一个字一个字打出来的笔记。

笔记1

果然自己还是懒得做笔记。直接抓去重要的也不失为一种两得的好方法。转载声明如下

作者：yxc
链接：https://www.acwing.com/file_system/file/content/whole/index/content/9960888/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

  1. 输入

使用input()函数，可以输入一行内容，返回的类型为str。一般配合split()、map()、int()、float()等函数使用。

例如：

1
2
a, b = map(int, input().split())  # 读入两个整数
print(a + b)  # 计算两个数的和

image-20240603205713950

image-20240603205810109

  1. 输出
    使用print()函数可以输出多个变量，默认用空格隔开，且行末会默认添加回车。如果想自定义行末字符，可以添加end参数。例如：
1
2
3
4
5
a, b, c = 1, 2, 'x'
print(a, b, c, end='!')
print(a)
print(b)
print(c)

部分题目会要求保留若干位小数，此时可以使用round()函数。例如：

1
2
3
x = 12.34567
print("x = " + str(round(x, 1)))  # 保留1位小数
print("x = " + str(round(x, 3)))  # 保留3位小数

另外可以使用格式化字符串，在后面的章节会详细讲解，本章中大家会使用下面用法即可：

1
2
3
4
5
6
x = 12.34567
y = 12

print("x = %.1f" % x)  # 保留1位小数
print("x = %.3f" % (x * y))  # 保留3位小数
print("x = %f, y = %d" % (x, y))  # 输出整数
  1. 其它函数
    本章中部分题目会要求开根号，可以使用如下方式：
1
2
3
4
from math import sqrt  # 引入开根号函数
x = 2
y = sqrt(x)
print(y)

笔记2

学习语言最好的方式就是实践和模仿，每当掌握一个新功能时，就要立即将这个功能应用到实践中。——闫学灿

一、if 语句

  1. 基本if-else语句

当条件成立时，执行某些语句；否则执行另一些语句。
注意：

if和else后需要加上冒号:
if语句的代码块需要缩进统一长度，规范写法是缩进4个空格。

else语句可以省略：

当只有一条语句时，可以写在同一行，但这样写不规范，只要了解即可：

1
2
3
4
a = int(input())

if a > 5: print("%d is big!" % a)
else: print("%d is small!" % a)
  1. pass 语句
    pass 语句不执行任何动作。语法上需要一个语句，但程序毋需执行任何动作时，可以使用该语句。例如：
1
2
3
4
5
6
x = int(input())

if x > 5:
    pass  # 先空出来等以后再实现
else:
    print(x)
  1. 变量的作用域
    if语句内部的变量，可以在语句外访问。例如：
1
2
3
4
5
6
7
8
a, b = map(int, input().split())

if a > b:
    max_value = a
else:
    max_value = b

print(max_value)

二、条件表达式
(1) 与 and
(2) 或 or
(3) 非 not

注意：运算符优先级：not > and > or。

练习：用一条if语句，判断闰年。

1
2
3
4
5
6
year = int(input())

if year % 100 != 0 and year % 4 == 0 or year % 400 == 0:
    print("yes")
else:
    print("no")

三、三元运算
类似于C++、Java中的问号表达式。例如：

1
2
3
a, b = map(int, input().split())
max_value = a if a > b else b
print(max_value)

四、match语句
python3.10开始新增了match语句。目前作业评测器的Python3采用旧版本，尚未支持match语法。

注意：

只有第一个匹配的模式会被执行。且跟C++、Java不同，匹配后只会执行当前模式，不会顺次执行后面的case。
可以用 | 表示匹配多个模式。
变量名 _ 被作为 通配符 并必定会匹配成功。
如果没有 case 匹配成功，则不会执行任何分支。

1
2
3
4
5
6
7
8
9
10
11
status = int(input())

match status:
    case 400:
        print("Bad request")
    case 404:
        print("Not found")
    case 418 | 420 | 422:
        print("I'm a teapot")
    case _:
        print("Something's wrong with the internet")

五、作业题易错点
注意if和else语句后一定要加冒号。
判断语句内部的代码一定要记得缩进。
格式化字符串中想表示%时，需要写%%。
Python中交换两个变量，可以用：a, b = b, a。
Python中的比较运算符支持链式操作，这一点跟C++和Java等语言不同。例如，给三个数排序的代码可以这么写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
a, b, c = map(int, input().split())
x, y, z = a, b, c

if a >= b >= c:
    print(c, b, a)
elif a >= c >= b:
    print(b, c, a)
elif b >= a >= c:
    print(c, a, b)
elif b >= c >= a:
    print(a, c, b)
elif c >= a >= b:
    print(b, a, c)
elif c >= b >= a:
    print(a, b, c)

笔记3

一、while循环
可以简单理解为循环版的if语句。if语句是判断一次，如果条件成立，则执行后面的语句；while是每次判断，如果条件成立，则执行循环体中的语句，否则停止。

注意，类似于if语句，while语句也需要满足：

while后需要加上冒号:
while语句的代码块需要缩进统一长度，规范写法是缩进4个空格。

正确写法

1
2
3
4
i = 0
while i < 10:
    print(i)
    i += 1

错误写法

1
2
3
4
i = 0
while i < 10:
    print(i)
  i += 1

练习：求斐波那契数列的第n项

1
2
3
4
5
6
7
8
9
10
11
fpre = 1
fpost = 1
i = 2
print("fiboc 0 = %d" % fpre)
print("fiboc 1 = %d" % fpost)
while i < 10:
    fpre, fpost = fpost, fpre + fpost
    print("fiboc %d = %d" % (i, fpost))
    i += 1


死循环：循环永久执行，无法结束。我们要避免写出死循环。

1
2
3
4
5
6
s = 0
i = 1
while True:
    s += i
    i += 1
print(s)

二、for循环
for循环语句用来按顺序枚举range、字符串等数据类型中的元素。类似于while和if语句，for语句同样需要满足冒号和缩进的要求。

注意：本节课重在学习for循环，而非学习列表、元组、集合、字典等复杂数据类型，所以for语句与这些数据类型配合的使用技巧会放到下一章中展开。

  1. 遍历字符串
    for语句可以遍历字符串中的每个字符。例如：
  2. 注意c本身也是字符串类型
  3. Python目前可以认为没有char类型
1
2
3
4
5
6
7
8
for c in "python":
    print(c, end=' ')  # 注意c本身也是字符串类型
print()  # 输出回车

s = "acwing"
for c in s:
    print(c, end=' ')
print()  # 输出回车
  1. 遍历range
    range()函数可以生成等差数列，可以接收1个、2个或者3个整数参数：

注意是左闭右开的区间，而且是整数数列

接收1个整数参数时：range(x)会按顺序返回 0,1,2,3,…x−1 这个数列。
接收2个整数参数时：range(x, y)会按顺序返回 x,x+1,x+2,…,y−1 这个数。
接收3个整数参数时：range(x, y, z)分为两种情况：
z > 0时，按 顺序返回 x,x+z,x+2z,x+3z,… 这个数列中小于 y 的所有数。

到 y - 1，也可能到不了，取决于z

z < 0时，按顺序返回 x,x+z,x+2z,x+3z,… 这个数列中大于 y 的所有数。

到 y + 1，也可能到不了，取决于z

三、跳转语句

每每讲到这里都会说break和continue的区别。

我总结一个口诀：continue结束某一次循环的剩余部分。break结束剩余所有循环。自己懂就好，感觉剩余这个词不是很贴切，不过这也不是给零基础的人看的，纯粹是给自己一个记忆的加深，别把自己绕进去了。

  1. break
    可以提前从最近的一层循环中退出，一般与if语句搭配。
    例题：判断一个大于1的整数是否是质数。

1 既不是质数也不是合数

1
2
3
4
5
6
7
8
9
10
11
12
n = int(input())
is_prime = True
for i in range(2, n):
    if n % i == 0:
        is_prime = False
        break

if is_prime:
    print("is prime")
else:
    print("is not prime")

四、循环中的else子句和pass语句
本节内容用得不多，了解即可。

  1. 循环中的else子句
    for或while循环可以包括else子句，会在循环结束后执行。
    不过如果循环是被break结束的，那么else子句就不会执行了。

例题：判断一个大于1的整数是否是质数。

n = int(input())

for x in range(2, n):
if n % x == 0:
print(“%d = %d * %d” % (n, x, n // x))
break
else: # 注意else是for语句的子句，所以需要与for语句对齐
print(“%d is a prime number” % n)
2. pass语句
类似于if语句，当for或者while循环里不想写任何代码时，可以写上pass语句，这个语句不执行任何动作。

例如：

for i in range(10): # 不进行任何操作
pass

while True: # 死循环
pass

五、多层循环
while和for循环内的代码块中也可以包含循环语句。

例题：将1~100打印到一个10 * 10的矩阵中：

1
2
3
4
5
6
k = 0
for i in range(0, 10):
    for j in range(0, 10):
        print(k, end=' ')
        k += 1
    print()  # 输出回车

练习：打印 1∼100
1
∼
100
中的所有质数。

1
2
3
4
5
6
7
8
for i in range(2, 101):
    is_prime = True
    for j in range(2, i):
        if i % j == 0:
            is_prime = False
            break
    if is_prime:
        print(i)

六、作业题易错点
注意多层for循环中所使用的循环变量尽量使用不同的变量名，防止相互干扰。
Python3中求一个数的绝对值，可以使用abs()函数。

笔记4

列表的初始化

列表需要用方括号括起来，中间的元素用逗号隔开，最后一个元素后可以多加一个逗号。

1.1 直接初始化

1
2
3
4
a = []  # 定义一个空列表
b = [1, 2]  # 含有2个整数的列表
c = [6, "python", 3.14]  # 含有3个不同类型元素的列表
print(a, b, c)

1.2 通过append函数初始化
append()函数可以在列表末尾添加一个元素。

1
2
3
4
5
6
7
8
9
10
11
12
a = []
for i in range(5):  # 初始化[0, 0, 0, 0, 0]
    a.append(0)
print(a)

n = 4
b = []
for i in range(n):  # 初始化[0, 1, 4, 9]
    b.append(i * i)
print(b)


1.3 通过for语句初始化列表长度和每个位置的数值

1
2
3
4
5
6
a = [0 for i in range(5)]  # 初始化[0, 0, 0, 0, 0]
print(a)

n = 4
b = [i * i for i in range(n)]  # 初始化[0, 1, 4, 9]
print(b)

访问列表元素

可以通过下标读/写列表中的元素，下标从0开始，也可以是负数，负数下标表示的是除以列表长度的余数对应的位置。

负数下标相当于将列表首位相接，然后从0往前数。

如果列表长度是 n，那么下标只能取 −n∼n−1之间的整数，超出范围会报错。

1
2
3
4
5
6
7
a = [0, 1, 2]
print(a[0], a[1], a[2])  # 读取列表中每个位置的值

a[0] = 3  # 给列表中的某个位置写值
print(a)

print(a[-1])  # 由于-1 % 3 = 2，所以表示的是a[2]

使用循环语句遍历列表

可以通过下标访问，就是需要i ，例如：

1
2
3
4
a = [2, 1, 4, 5, 3]

for i in range(5):
    print(a[i], end=' ')

可以通过for … in …直接遍历，就是不需要i，例如：

但是这种方式只能读取，不能修改。

个人猜测，或者记忆口诀：感觉原因是x 是 a列表对应的一个元素的 副本

1
2
3
4
a = [2, 1, 4, 5, 3]

for x in a:
    print(x, end=' ')

列表的切片操作

列表的切片操作会返回一个新列表。用法：

a[begin:end] 会返回包含a[begin], a[begin + 1], …, a[end - 1]的列表。

记忆背诵成左闭右开的区间

省略begin时，begin的默认值是0。
省略end时，end的默认值是列表长度。
如果begin或end是负数，表示的是除以列表长度后的余数。
例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
a = [0, 1, 2, 3, 4]

print(a[1:4])  # 输出[1, 2, 3]
print(a[1:])  # 输出[1, 2, 3, 4]
print(a[:4])  # 输出[0, 1, 2, 3]
print(a[:])  # 输出[0, 1, 2, 3, 4]
print(a[-4:-1])  # 等价于print(a[1:4])
切片也支持写操作：

a = [0, 1, 2, 3, 4]

a[1:4] = [2, 3]
print(a)  # 输出[0, 2, 3, 4]


列表的复制

列表跟其他变量类型不同，如果用等号复制列表，那么原列表和新列表是同一个列表。对新列表修改，会修改原列表的值。例如：

1
2
3
4
5
a = [0, 1, 2, 3, 4]
b = a

b[0] = 5
print(a, b)  # 会发现a[0]和b[0]都被修改了

使用切片，可以得到一个原列表的浅拷贝。此时再修改新列表，原列表就不会发生变化了。例如：

1
2
3
4
5
a = [0, 1, 2, 3, 4]
b = a[:]

b[0] = 5
print(a, b)  # 会发现a[0]没有被修改

列表的运算

列表的加法可以将两个列表拼接起来，得到一个新列表。
列表乘以一个整数，可以将若干个自身拼接起来，得到一个新列表。
例如：

1
2
3
4
5
6
7
8
9
10
11
a = [0, 1, 2]
b = [3, 4]

c = a + b  # c相当于a和b的浅拷贝
print(c)  # 输出[0, 1, 2, 3, 4]

d = a * 3  # d相当于a的浅拷贝
print(d)  # 输出[0, 1, 2, 0, 1, 2, 0, 1, 2]

a += [3]  # 在a的末尾添加一个新元素3
print(a)  # 输出[0, 1, 2, 3]

列表的常用操作

假设a是一个列表，则：

len(a) 返回列表长度。
a.append(x) 在列表末尾添加一个新元素。
a.pop() 删除列表的最后一个元素,,而且会返回被删除的元素
a.reverse() 将整个列表翻转。
a.sort() 将整个列表从小到大排序。
例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
a = [0, 1, 2]

print(len(a))  # 输出3

a.append(3)
print(a)  # 输出[0, 1, 2, 3]

a.pop()
print(a)  # 将[0, 1, 2, 3]的最后一个数删掉，所以输出[0, 1, 2]

a.reverse()
print(a)  # 输出[2, 1, 0]

a.sort()
print(a)  # 输出[0, 1, 2]

更多详情可以看官方文档

https://docs.python.org/zh-cn/3/tutorial/index.html

  1. 嵌套列表
    列表中的元素也可以是列表，例如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
matrix = [  # 列表中的元素也可以是列表
    [0, 1, 2],
    [3, 4, 5],
    [6, 7, 8],  # 最后一个元素后可以添加逗号
]

matrix[1][0] = 99  # 修改嵌套列表中元素的值
print(matrix[1][0])  # 读取嵌套列表中元素的值

for i in range(len(matrix)):  # 循环打印整个矩阵
    for j in range(len(matrix[i])):
        print(matrix[i][j], end=' ')
    print()  # 在行末输出回车

for row in matrix:  # 循环打印整个矩阵
    for x in row:
        print(x, end=' ')
    print()  # 在行末输出回车


嵌套列表的常用初始化方式有两种。

采用append()函数初始化：

1
2
3
4
5
6
7
8
9
10
11
matrix = []

for i in range(3):
    row = []
    for j in range(3):
        row.append(i * 3 + j)
    matrix.append(row)

print(matrix)


更加简单的写法

1
2
matrix = [[i * 3 + j for j in range(3)] for i in range(3)]
print(matrix)

采用for语句直接初始化：

1
2
matrix = [[i * 3 + j for j in range(3)] for i in range(3)]
print(matrix)

作业题扩展内容

当需要读入一行整数时，可以用：

a = list(map(int, input().split()))

类似地，当需要读入一行浮点数时，可以用

a = list(map(float, input().split()))

min(a, b)可以求两个数的最小值。类似得min(a, b, c)可以求三个数的最小值，以此类推。同样地max()可以求最大值。

a[::-1]可以返回一个逆序的新列表。