当前位置：首页 > news >正文

Python教程(一)——Python速览

news 来源：原创 2025/6/22 21:03:10

1. 引言

本系列的目的主要是重新回顾Python的语法，以供阅读由Python编写的源码。
在安装完Python后，在命令行中输入python就可以进入交互模式。下文代码段中以>>>或···开头的内容表明是交互模式的输入，除此之外的内容都是输出。

2. Python用作计算器

2.1 数字

解释器像一个简单的计算器：你可以输入一个表达式，它将给出结果值。表达式语法很直观：运算符+、-、*和/可被用来执行算术运算；圆括号()可被用来进行分组。例如：

>>> 2 + 2
4
>>> 50 - 5 * 6
20
>>> ( 50 - 5 * 6 ) / 4
5.0
>>> 8 / 5 # 除法运算总是返回一个浮点数
1.6

整数如2、4、20的类型是int，带小数如5.0、1.6的类型是float。
除法运算/总是返回浮点数。如果要进行向下取整除法得到一个整数，必须使用//运算符；要计算余数，必须使用%运算符。

>>> 17 / 3 # 经典除法运算返回一个浮点数
5.666666666666667
>>> 17 // 3 # 向下取整除法运算会丢弃小数部分
5
>>> 17 % 3 # 运算返回相除的余数
2
>>> 5 * 3 + 2 # 向下取整的商 * 除数 + 余数
17

Python用**运算符计算乘方：

>>> 5 ** 2 # 5的平方
25
>>> 2 ** 7 # 2的7次方
128

等号=用于给变量赋值。赋值后，下一个交互提示符不显示任何结果：

>>> width = 20
>>> height = 5 * 9
>>> width * height
900

如果变量未赋值，使用该变量会提示错误：

>>> n # 试图访问一个未定义的变量
Traceback (most recent call last):File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

Python全面支持浮点数，混合类型运算过程中会把整数转换为浮点数：

>>> 4 * 3.75 - 1
14.0

交互模式下，上次输出的表达式会赋给变量_。把Python当作计算器时，用该变量实现下一步计算更简单，例如：

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

最好将_当作只读变量，不要为它显式赋值，否则会创建一个同名独立局部变量，该变量会用它的魔法行为屏蔽内置变量。

2.2 文本

除了数字Python还可以操作文本(由str类型表示，称为“字符串”)。这包括字符!，单词rabbit，名称Paris，句子Got your back.等等。它们可以用成对的单引号’'或双引号""来标示，结果完全相同。

>>> 'spam eggs' # 单引号
'spam eggs'
>>> "Paris rabbit got your back :)! Yay!" # 双引号
'Paris rabbit got your back :)! Yay!'
>>> '1975' # 用引号括起来的数字也是字符串
'1975'

要标示引号本身，我们需要对它进行“转义”，即在前面加一个\。或者，我们也可以使用不同类型的引号：

>>> 'doesn\'t' # 使用\'来转义单引号
"doesn't"
>>> "doesn't" # ...或者改用双引号
"doesn't"
>>> '"Yes," they said.'
'"Yes." they said.'
>>> "\"Yes,\" they said."
'"Yes," they said.'
>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'

在Python shell中，字符串定义和输出字符串看起来可能不同。print()函数会略去标示用的引号，并打印经过转义的特殊字符串，产生更为易读的输出：

>>> s = 'First line.\nSecond line.' # \n标示换行符
>>> s # 不用print()，特殊字符将包括在字符串中
'First line.\nSecond line.'
>>> print(s) # 用print()，特殊字符会被转写，因此\n将产生一个换行
First line.
Second line.

如果不希望前置\的字符转义成特殊字符，可以使用原始字符串，在引号前添加r即可：

>>> print('C:\some\name') # 这里\n表示换行符！
C:\some
ame
>>> print(r'C:\some\name') # 请注意引号前的r
C:\some\name

原始字符串还有一个微妙的限制：一个原始字符串不能以奇数个\字符结束。解决办法有如下3种方法：
1. 使用常规字符串以及双反斜杠：

>>> 'C:\\this\\will\\work\\'
'C:\\this\\will\\work\\'

2. 将一个包含被转义反斜杠的常规字符串拼接到原始字符串上：

>>> r'C:\this\will\work' '\\'
'C:\\this\\will\\work\\'

3. 在Windows上使用os.path.join()来添加反斜杠：

>>> os.path.join(r'C:\this\will\work', '')
'C:\\this\\will\work\\'

请注意虽然在确定原始字符串的结束位置时反斜杠会对引号进行转义，但在解析原始字符串的值时并不会发生转义：

>>> r'backslash\'preserved'
"backslash\\'preserved"

字符串字面值可以跨越多行。一种做法是使用三重引号：“”“”…“”"或’‘’…‘’'。行结束符会自动包括在字符串种，但可以通过在行尾添加\来避免此行为。下面的例子种，开头的换行符将不会被包括：

>>> print("""\
··· Usage: thingy [OPTIONS]
···      -h				Display this usage message
···      -H hostname	Hostname to connect to
··· """)
Usage: thingy [OPTIONS]-h				Display this usage message-H hostname	Hostname to connect to

字符串可以用+横屏，也可以用*重复：

>>> # 3乘以'un'，再加'ium'
>>> 3 * 'un' + 'ium'
'unununium'

相邻的两个或多个字符串字面值会自动合并：

>>> 'Py' 'thon'
'Python'

拼接分隔开的长字符串时，这个功能特别使用：

>>> text = ('Put several strings within parentheses''to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'

这项功能只适用于两个字面值，不能用于变量或表达式：

>>> prefix = 'Py'
>>> prefix 'thon' # 不能拼接变量和字符串字面值File "<stdin>", line 1prefix 'thon'^^^^^^
SyntaxError: invalid syntax
>>> ( 'un' * 3 ) 'ium'File "<stdin>", line 1('un' * 3) 'ium'^^^^^
SyntaxError: invalid syntax

合并多个变量，或合并变量与字面值，要用+：

>>> prefix + 'thon'
'Python'

字符串支持索引，第一个字符的索引是0：

>>> word = 'Python'
>>> word[0] # 0号位的字符
'P'
>>> word[5] # 5号位的字符
'n'

索引还支持负数，用负数进行索引时，从右边开始计数：

>>> word[-1] # 最后一个字符
'n'
>>> word[-2] # 倒数第二个字符
'o'
>>> word[-6]
'P'

注意，-0和0一样，因此，负数索引从-1开始。
除了索引操作，还支持切片。索引用来获取单个字符，而切片允许你获取子字符串：

>>> word[0:2] # 从0号位(含)到2号位(不含)
'Py'
>>> word[2:5] # 从2号位(含)到5号位(不含)
'tho'

切片索引的默认值很有用，省略开始索引时，默认值为0，省略结束索引时，默认为到字符串的末尾：

>>> word[:2] # 从开头到2号位(不含)的字符
'Py'
>>> word[4:] # 从4号位(含)到末尾
'on'
>>> word[-2:] # 从倒数第二个(含)到末尾
'on'

注意，输出结果包含切片开始，但不包含切片结束。因此，s[:i]+s[i:]总是等于s：

>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'

还可以这样理解切片，索引指向的是字符之间，第一个字符的左侧标为0，最后一个字符的右侧标为n，n是字符串的长度。例如：

 +---+---+---+---+---+---+| P | y | t | h | o | n |+---+---+---+---+---+---+0	 1	 2	 3	 4	 5	 6
-6	-5	-4	-3	-2	-1

第一行数字是字符串中索引0···6的位置，第二行数字是对应的负数索引位置。i到j的切片由i和j之间所有对应的字符组成。
对于使用非负索引的切片，如果两个索引都不越界，切片长度就是起止索引之差。例如，word[1:3]的长度为2。
索引越界会报错：

>>> word[42] # word只有6个字符
Traceback (most recent call last):File "<stdin>", line 1, in <module>
IndexError: string index out of range

但是切片会自动处理越界索引：

>>> word[4:42]
'on'
>>> word[42:]
''

Python字符串不能修改。因此，为字符串中某个索引位置赋值会报错：

>>> word[0] = 'J'
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

要生成不同的字符串，应新建一个字符串：

>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'

内置函数len()返回字符串的长度：

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

2.3 列表

Python支持多种复合数据类型，可将不同值组合在一起。最常用的列表，是用方括号标注，逗号分隔的一组值。列表可以包括不同类型的元素，但一般情况下，各个元素的类型相同：

>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

和字符串一样，列表也支持索引和切片：

>>> squares[0] # 索引操作将返回条目
1
>>> squares[-1]
25
>>> squares[-3:] # 切片操作将返回一个新列表
[9, 16, 25]

列表还支持合并操作：

>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

列表元素是可更改的：

>>> cubes = [1, 8, 27, 65, 125] # 这里有点问题
>>> 4 ** 3 # 4的立方是64，不是65！
64
>>> cubes[3] = 64 # 替换错误的值
>>> cubes
[1, 8, 27, 64, 125]

可以通过使用list.append()方法，在列表末尾增加新条目：

>>> cubes.append(216) # 添加6的立方
>>> cubes.append(7 ** 3) # 和7的立方
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

Python中的简单赋值绝不会复制数据。当你将一个列表赋值给一个变量时，该变量将引用现有的列表。通过一个变量对列表所做的任何更改都会被引用它的所有其他变量看到：

>>> rgb = ["Red", "Green", "Blue"]
>>> rgba = rgb
>>> id(rgb) == id(rgba) # 它们指向同一个对象
True
>>> rgba.append("Alph")
>>> rgb
["Red", "Green", "Blue", "Alph"]

切片操作返回包含请求元素的新列表。以下切片操作会返回列表的浅拷贝：

>>> correct_rgba = rgba[:]
>>> correct_rgba[-1] = "Alpha"
>>> correct_rgba
["Red", "Green", "Blue", "Alpha"]
>>> rgba
["Red", "Green", "Blue", "Alph"]

为切片赋值可以改变列表大小，甚至清空整个列表：

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # 通过一个空列表替代所有元素来清空列表
>>> letters[:] = []
>>> letters
[]

内置函数len()也支持列表：

>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4

还可以嵌套列表，例如：

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

3. 走向编程的第一步

还能用Python完成比二加二更复杂的任务。例如，我们可以像下面这样写出斐波那契数列初始部分的子序列：

>>> # 斐波那契数列
>>> # 前两项之和即下一项的值
>>> a, b = 0, 1
>>> while a < 10:
··· 	print(a)
···		a, b = b, a + b
···
0
1
1
2
3
5
8

本例引入了几个新功能：
1. 第一行的多重赋值：变量a和b同时获得新值0和1。最后一行又用了一次多重赋值，体现了，等号右边的所有表达式的值，都是在这一语句对任何变量赋新值之前求出来的——求值顺序为从左到右。
2. while循环只要条件为真就会一直执行。Python和C一样，任何非零整数为真，零为假。这个条件也可以是字符串或列表类型的值，事实上，任何序列都可以：长度非零为真，空序列为假。示例中的判断只是最简单的比较。比较操作符的写法和C语言一样：<小于、>大于、==等于、<=小于等于、>=大于等于、!=不等于。
3. 循环体是缩进的：缩进是Python组织语句的方式。在交互式命令行里，得为每个缩进的行输入空格或制表符。使用文本编辑器可以实现更复杂的输入方式；所有像样的文本编辑器都支持自动缩进。交互式输入复合语句时，要在最后输入空白行表示完成。注意，同一块语句的每一行的缩进相同。
4. print()函数输出给定参数的值。除了可以以单一的表达式作为参数，它还能处理多个参数，包括浮点数与字符串。它输出的字符串不带引号，且各参数之间会插入一个空格，这样可以实现更好的格式化操作，例如：

>>> i = 256 ** 2
>>> print('The value of i is', i)
The value of i is 65536

关键字end可以取消输出后面的换行，或用另一个字符串结尾：

>>> a, b = 0, 1
>>> while a < 1000:
···		print(a, end=',')
···		a, b = b, a + b
···
0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987

参考

https://docs.python.org/zh-cn/3.13/tutorial/introduction.html

目录