Python 基础

发表于： 2025-11-02 分类于：编程学习

字数： 3930 阅读：≈ 8分钟浏览：评论：

总结摘要

简单的python基础，方便入门。

Python 中的列表

list

Python中内置的就是 list，这是一种有序列表

1
2
city = ['武汉','成都','长沙']
print(city)

变量 city就是一个列表，用len()函数可以获得list元素的个数：

1
2
>>> len(city)
3

用索引访问 list中的元素，是从 [0]开始的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
print(city[0])
print(city[1])
print(city[2])
print(city[3])

>>> 武汉
>>> 成都
>>> 长沙
>>> print(city[3])
IndexError: list index out of range

如果超出索引范围，python会报错，要记得最后一个元素的索引是len(city) - 1

1
2
print(city[-1])
>>> 长沙

以此类推，可以获取倒数第2个、倒数第3个

list是一个有序列表，我们可以追加元素到末尾，也可以加到前面。

可以使用 city.pop()的方法删除末尾元素，要删除指定位置的元素可以使用pop(i)，其中的i是序号，比如删除武汉可以使用 city.pop(0)

我们也可以把某个元素替换为别的元素，比如把 武汉 替换为 北京

1
2
3
4
city[0] = '北京'
print(city)

>>> '北京', '成都', '长沙'

list 里面的数据类型也可以不同，比如 a = ['小明', 123, False]

list 里面的元素也可以是另一个 list，比如 b = ['apple', ['red', 'green', 'blue'], 0.12, True]，当我们使用 len(b)可以发现实际上只有4个元素，因为里面的b[1]被当作了一个元素

如果要拿到 b[1]中的第一个元素 red可以使用 b[1][0]

如果list中一个元素都没有，则 len()就是0

tuple

另一种有序列表就是 tuple，它与 list非常类似，但是它不能想 list那样可以修改，一旦初始化后就无法更改。

1
city = ('武汉', '成都', '长沙')

不过我们可以正常的使用[i]来获取其中的元素

如果你要在 tuple中定义一个元素，你像这么定义：

1
2
3
a = (1)
print(a)
>>> 1

上述方法定义的不是1而是1这个数，因为在python中规定，() 既可以表示 tuple 也可以表示数学中的小括号，为了消除歧义，你可以令 a = (1,)则会输出 (1,) ，为了避免产生误解 python会在后面加上一个逗号

tuple 可以极大的保护我们的系统不被篡改，但是如果你想使用一个可变的 tuple，可以这样：

1
2
3
4
5
6
a = ('apple', 'banana', ['red', 'yellow'])
a[2][0] = 'blue'
a[2][1] = 'pink'
print(a)

>>> ('apple', 'banana', ['blue', 'pink'])

表面上看确实是 tuple中的元素发生了改变，但是实际上是里面的 list 发生了改变

Python 中的格式化

常见的占位符

占位符	替换内容
%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数
其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：

1
2
print('%2d-%02d' % (3, 1))
print('%.2f' % 3.1415926)

在第一个例子中，%2d 表示宽度为2的整数，如果整数位数不足2位，会在前面填充空格。 %02d 表示宽度为2的整数，如果整数位数不足2位，会在前面填充0。在第二个例子中，%.2f则表示小数点前两位的浮点数

如果你实在不确定到底应该用什么，那么可以使用 %s，它将永远起作用

1
2
print('Age: %s. Gender: %s' % (25, True))
>>> Age: 25. Gender: True

如果你想使用 %这个符号怎么办？你可以是使用转义 %%

1
2
print('growth rate: %d %%' % 7)
>>> growth rate: 7 %

{% note warning simple %} 如果你使用 'growth rate: %d %%' 7 % 则会

1
print('growth rate: %d %%' 7 %) ^ SyntaxError: invalid syntax

{% endnote %}

format()

另一种方法比前一种要复杂的多，它使用传入的参数依次替换字符串内的占位符 {0}，{1} ……

1
2
print('我是 {0}, 我考了 {1:.1f}%' .format('小明', 17.125))
>>> 我是 小明, 我考了 17.1%

这里的 {0}对应的是小明，而 {1:.1f} 实际上就是 {1} 和 .1f加起来的意思， .1f代表保留一位小数的浮点数

f-string

最后一种方式就是 f开头的字符串，如果变量中存在 {xxx}，那么就会以对应的变量替换

1
2
3
4
5
l = 20.2
w = 30.125
s = l * w
print(f'由长 {l} 和 宽 {w} 为矩形的面积是 {s:.2f}')
>>> 由长 20.2 和 宽 30.125 为矩形的面积是 608.52

在上述代码中， {l}，{w}被变量 l和w替换，{s:.2f}被变量s的值替换，并且:后面的.2f指定了格式化参数（即保留两位小数）

dict和set

python里面内置了字典，例如我们要查看某些同学的成绩，你也许会这么写：

1
2
name = ['小明', '小华', '小李']
score = [99, 60, 30]

然后给定一个名字，再在list里面查找，这样的效率极低，且很慢，所以我们可以这样：

1
2
d = ['小明':99, '小华': 60, '小李': 30]
d['小华']

除了把数据通过初始化放入，我们也可以用 key放入

1
2
3
>>> d['小王'] = 100
>>> d['小王']
100

由于一个key只能对应一个值，在后面的值会把前面的冲掉，如果值不存在就会报错，比如 d['小力']，这显然不在dict里面。

我们可以利用两种方法来检查是不是存在这个值，第一种方法就是用 in

1
2
>>> '小王' in d
True

第二种则可以使用 get()，如果不存在就不会返回任何值，也就是 none，当然也可以定义一下，类似于-1例如

1
2
3
>>> d.get('小孙')
>>> d.get('小孙', 0)
0

值得注意的是，列表不能作为 dict的健，因为 dict是不可变的哈希，而列表是可变的。

set

set与dict类似，都是一组key的集合，但是set只存储key，而dict存储key的值。

我们可以用 {x,y,z,...} 创建一组key， s = {1, 2, 3}

也可以提供一个list作为输入集合： s = set([1, 2, 3])

{% note info simple %} 显示的 {1, 2, 3} 只是告诉你里面有1，2，3这几个元素，显示的顺序也不是有序的。 {% endnote %}

set不会显示相同的键，也就是说：

1
2
3
s1 = {1, 2, 3, 4, 4, 1,2}

>>> {1, 2, 3, 4}

set用于统计两种数据中有没有相同的元素有奇效，例如：

1
2
3
4
5
6
7
s1 = {1, 2, 3, 4}
s2 = {1, 2, 5, 6}
s1 & s2

>>> {1, 2}
>>> s1 | s2
{1, 2, 3, 4, 5, 6}

我们可以使用 add() 和 remove() 添加或移除 set 里面的元素，如：

1
2
s1.add(5)
s1.remove(1)

不可变对象

我们之前讲过 str 是不可变对象，而 list 是可变对象.

比如我们对 list进行操作：

1
2
3
4
>>> a = [3, 2, 1]
>>> a.sort()
>>> a
[1, 2, 3]

而对于不可变对象 str呢：

1
2
3
4
5
>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
>>> a
'abc'

这样怎么理解？我们可以把 a.replace 当成另一个对象就很好理解了，比如引入 b = a.replace('a', 'A') ，这样就很直观了。

模式匹配

当我们要匹配某个特定的值而不是一个范围区间时，使用 if...else...肯定会过于复杂，可读性较差

如果学生的成绩只能是特定的值：

1
2
3
4
5
6
7
8
9
score = 'c'  
  
match score:  
    case 'A':  
        print('成绩是A')  
    case 'B':  
        print('成绩是B')  
    case _:  
        print('成绩是???')

复杂匹配

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
age = 10  
  
match age:  
    case x if x < 10:  
        print(f'他是 {x} 岁的儿童')  
    case 10:  
        print('他是10岁的儿童.')  
    case 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18:  
        print('11~18 years old.')  
    case 19:  
        print('19 years old.')  
    case _:  
        print('not sure.')

第一个case x if x < 10表示当age < 10成立时匹配，且赋值给变量x，第二个case 10仅匹配单个值，第三个case 11|12|...|18能匹配多个值，用|分隔。

匹配列表

match语句还可以匹配列表，功能非常强大。

我们假设用户输入了一个命令，用args = ['gcc', 'hello.c']存储，下面的代码演示了如何用match匹配来解析这个列表：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
args = ['gcc', 'hello.c', 'world.c']
# args = ['clean']
# args = ['gcc']

match args:
    # 如果仅出现gcc，报错:
    case ['gcc']:
        print('gcc: missing source file(s).')
    # 出现gcc，且至少指定了一个文件:
    case ['gcc', file1, *files]:
        print('gcc compile: ' + file1 + ', ' + ', '.join(files))
    # 仅出现clean:
    case ['clean']:
        print('clean')
    case _:
        print('invalid command.')

第一个case ['gcc']表示列表仅有'gcc'一个字符串，没有指定文件名，报错；

第二个case ['gcc', file1, *files]表示列表第一个字符串是'gcc'，第二个字符串绑定到变量file1，后面的任意个字符串绑定到*files，它实际上表示至少指定一个文件；

第三个case ['clean']表示列表仅有'clean'一个字符串；

最后一个case _表示其他所有情况。

条件判断

Python可以自动化处理很多东西，其中绝大部分都是由条件判断组成的

比如，要识别考试分数是否及格：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
score = 70
if score >= 60:
	print('He\'s score is', score)
	print('pass')
else:
	print('He\'s score is', score)
	print('not pass')
	
>>> He's score is 70
pass

当然这些只是粗略的判断，要是更细致的判断可以:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
s = input('输入你的分数:')  
point = int(s)  
if point >= 90:  
    print(' very good')  
elif point >= 80:  
    print('good')  
elif point >= 60:  
    print('pass')  
elif point <= 40:  
    print('bad')  
else:  
    print('not pass')

我们将s 的类型由 str 变成了 int ，如果不加这个

1
2
    if point >= 90:
TypeError: '>=' not supported between instances of 'str' and 'int'

当然你也可以直接指定 s 为 int，例如 s = int(input('输入你的分数:'))

循环

Python的循环有两种，一种是for…in，例如：

1
2
3
4
5
6
7
a = ['apple', 'banana', 'orange']
for b in a:
	print(b)

>>> apple
>>> banana
>>> orange

它会依次打印出列表里面的所有元素

所以如果我们想求出1到10的总和可以使用 sum变量累加，如下：

1
2
3
4
5
a = [1,2,3,4,5,6,7,8,9,10]  
sum = 0  
for x in a:  
    sum = sum + x  
print(sum)

但是要求1到1000的话使用这种方法会变得非常困难，所以我们可以用 range()生成一个整数序列，如 range(101) 就是从0到100，所以要求1到1000可以使用:

1
2
3
4
sum = 0
for x in range(10001):
	sum = sum + x
print(sum)

第二种循环就是 while，如果不满足就会一直运行，例如要计算100以内的奇数和：

1
2
3
4
5
6
sum = 0
n = 99
while n > 0:
	sum = sum + n
	n = n - 2
print(sum)

break

如果要提前结束循环，可以使用 break语句，例如要打印1到100的数：

1
2
3
4
5
n = 1
while n <= 100:
    print(n)
    n = n + 1
print('END')

我们可以使用 break中断：

1
2
3
4
5
6
7
n = 1
while n <= 100:
	if n > 10: # 当n = 11时，条件满足，执行break语句
		break
	print(n)
	n = n + 1
print('end')

continue

在循环过程中我们可以通过 continue跳过当前的循环，例如下面的代码是打印1到10：

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

如果我们只想打印奇数的话：

1
2
3
4
5
6
n = 0  
while n < 10:  
    n = n + 1  
    if n % 2 == 0:  
        continue  
    print(n)

里面的 %是取余数，==是比较，与=不同

参考资料廖雪峰的Python教程 PDF 下载链接