Python的数字/字符/切片等介绍(3)python入门教程
在以下示例中,输入和输出通过提示符( >>>和… )的存在与否来区分:要重复该示例,您必须在提示符出现时键入提示符后的所有内容;不以提示开头的行由解释器输出。请注意,在示例中单独一行的辅助提示意味着您必须键入一个空行;这用于结束多行命令。
本手册中的许多示例,即使是在交互式提示中输入的示例,都包含注释。Python 中的注释以井号字符 开头 #
,并延伸到物理行的末尾。注释可能出现在行首或空格或代码之后,但不会出现在字符串文字中。字符串文字中的哈希字符只是一个哈希字符。由于注释是为了阐明代码而不是由 Python 解释,因此在键入示例时可能会省略它们。
一些例子:
# this is the first comment
spam = 1 # and this is the second comment # ... and now a third!
text = "# This is not a comment because it's inside quotes."
3.1使用Python作为计算器
让我们尝试一些简单的Python命令。启动解释器并等待主要提示符>>>
。(不应该花很长时间。)
3.1.1数字
解释器充当一个简单的计算器:您可以在其上键入表达式,它将写入值。表达式语法是直接的:运营商+
,-
,*
和/
工作就像在大多数其他语言(例如,C或Pascal); 括号( ( ) )可用于分组。例如:
>>> >>> 2 + 2 4 >>> 50 - 5*6 20 >>> (50 - 5*6) / 4 5.0 >>> 8 / 5 # division always returns a floating point number 1.6
整数(例如2
, )具有 type ,带有小数部分的整数(例如4
, )具有 type 。我们将在本教程后面看到更多关于数字类型的信息。20
int,
5.0
1.6
float
除法 ( /
) 总是返回一个浮点数。要进行地板除法并获得整数结果(丢弃任何小数结果),您可以使用//
运算符;计算你可以使用的余数%
:
>>> >>> 17 / 3 # classic division returns a float 5.666666666666667 >>> >>> 17 // 3 # floor division discards the fractional part 5 >>> 17 % 3 # the % operator returns the remainder of the division 2 >>> 5 * 3 + 2 # result * divisor + remainder 17
使用Python,可以使用**
运算符来计算幂:
>>> >>> 5 ** 2 # 5 squared 25 >>> 2 ** 7 # 2 to the power of 7 128
等号(=
)用于为变量赋值。之后,在下一个交互式提示之前不会显示任何结果:
>>> >>> width = 20 >>> height = 5 * 9 >>> width * height 900
如果变量没有“定义”(赋值),尝试使用它会给你一个错误:
>>> >>> n # try to access an undefined variable Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'n' is not defined
浮点数完全支持; 具有混合类型操作数的运算符将整数操作数转换为浮点数:
>>> >>> 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
该变量应被用户视为只读。不要为其显式赋值 – 您将创建一个具有相同名称的独立局部变量,以使用其魔术行为屏蔽内置变量。
除了int
和之外float
,Python还支持其他类型的数字,例如Decimal
和Fraction
。Python还内置了对复数的支持,并使用j
或J
后缀来表示虚部(例如3+5j
)。
3.1.2字符串
除了数字,Python 还可以操作字符串,字符串可以用多种方式表示。它们可以用单引号 ( '...'
) 或双引号 ( "..."
) 括起来,结果相同。 \
可用于转义引号:
>>> >>> 'spam eggs' # single quotes 'spam eggs' >>> 'doesn\'t' # use \' to escape the single quote... "doesn't" >>> "doesn't" # ...or use double quotes instead "doesn't" >>> '"Yes," they said.' '"Yes," they said.' >>> "\"Yes,\" they said." '"Yes," they said.' >>> '"Isn\'t," they said.' '"Isn\'t," they said.'
在交互式解释器中,输出字符串用引号括起来,特殊字符用反斜杠转义。虽然这有时看起来与输入不同(封闭的引号可能会改变),但两个字符串是等价的。如果字符串包含单引号而没有双引号,则字符串用双引号括起来,否则用单引号括起来。该print()
函数通过省略封闭引号并打印转义字符和特殊字符来产生更易读的输出:
>>> >>> '"Isn\'t," they said.' '"Isn\'t," they said.' >>> print('"Isn\'t," they said.') "Isn't," they said. >>> s = 'First line.\nSecond line.' # \n means newline >>> s # without print(), \n is included in the output 'First line.\nSecond line.' >>> print(s) # with print(), \n produces a new line First line. Second line.
如果您不希望以 开头的字符\
被解释为特殊字符,您可以通过在第一个引号前添加一个来使用原始字符串:r
>>> >>> print('C:\some\name') # here \n means newline! C:\some ame >>> print(r'C:\some\name') # note the r before the quote C:\some\name
字符串文字可以跨越多行。一种方法是使用三引号: """..."""
或'''...'''
. 行尾自动包含在字符串中,但可以通过\
在行尾添加 a 来防止这种情况。下面的例子:
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 times 'un', followed by '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' # can't concatenate a variable and a string literal File "<stdin>", line 1 prefix 'thon' ^ SyntaxError: invalid syntax >>> ('un' * 3) 'ium' File "<stdin>", line 1 ('un' * 3) 'ium' ^ SyntaxError: invalid syntax
如果要连接变量或变量和文字,请使用+
:
>>> >>> prefix + 'thon' 'Python'
字符串可以被索引(下标),第一个字符具有索引0.没有单独的字符类型; 一个字符只是一个大小为1的字符串:
>>> >>> word = 'Python' >>> word[0] # character in position 0 'P' >>> word[5] # character in position 5 'n'
指数也可能是负数,从右边开始计算:
>>> >>> word[-1] # last character 'n' >>> word[-2] # second-last character 'o' >>> word[-6] 'P'
请注意,由于-0与0相同,因此负索引从-1开始。
除索引外,还支持切片。虽然索引用于获取单个字符,但切片允许您获取子字符串:
>>> >>> word[0:2] # characters from position 0 (included) to 2 (excluded) 'Py' >>> word[2:5] # characters from position 2 (included) to 5 (excluded) 'tho'
请注意如何始终包含开始,并始终排除结束。这可以确保s始终等于 s[:i] + s[i:]
>>> >>> word[:2] + word[2:] 'Python' >>> word[:4] + word[4:] 'Python'
切片索引具有有用的默认值; 省略的第一个索引默认为零,省略的第二个索引默认为要切片的字符串的大小。
>>> >>> word[:2] # character from the beginning to position 2 (excluded) 'Py' >>> word[4:] # characters from position 4 (included) to the end 'on' >>> word[-2:] # characters from the second-last (included) to the end 'on'
记住切片如何工作的一种方法是将索引视为指向 字符之间,第一个字符的左边缘编号为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] # the word only has 6 characters 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
3.1.3列表
Python 知道许多复合数据类型,用于将其他值组合在一起。最通用的是list,它可以写成方括号之间的逗号分隔值(项目)列表。列表可能包含不同类型的项目,但通常所有项目都具有相同的类型。
>>> >>> squares = [1, 4, 9, 16, 25] >>> squares [1, 4, 9, 16, 25]
像字符串(以及所有其他内置序列类型)一样,列表可以被索引和切片:
>>> >>> squares[0] # indexing returns the item 1 >>> squares[-1] 25 >>> squares[-3:] # slicing returns a new list [9, 16, 25]
所有切片操作都返回包含所请求元素的新列表。这意味着以下切片返回列表的新(浅)副本:
>>> >>> squares[:] [1, 4, 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] # something's wrong here >>> 4 ** 3 # the cube of 4 is 64, not 65! 64 >>> cubes[3] = 64 # replace the wrong value >>> cubes [1, 8, 27, 64, 125]
您还可以使用该append()
方法在列表末尾添加新项目(我们稍后会看到有关方法的更多信息):
>>> >>> cubes.append(216) # add the cube of 6 >>> cubes.append(7 ** 3) # and the cube of 7 >>> cubes [1, 8, 27, 64, 125, 216, 343]
>>> >>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] >>> letters ['a', 'b', 'c', 'd', 'e', 'f', 'g'] >>> # replace some values >>> letters[2:5] = ['C', 'D', 'E'] >>> letters ['a', 'b', 'C', 'D', 'E', 'f', 'g'] >>> # now remove them >>> letters[2:5] = [] >>> letters ['a', 'b', 'f', 'g'] >>> # clear the list by replacing all the elements with an empty list >>> 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.2迈向编程的第一步
当然,我们可以将 Python 用于比将两个和两个相加更复杂的任务。例如,我们可以编写 斐波那契数列的初始子序列, 如下所示:
>>> >>> # Fibonacci series: ... # the sum of two elements defines the next ... a, b = 0, 1 >>> while a < 10: ... print(a) ... a, b = b, a+b ... 0 1 1 2 3 5 8
这个例子介绍了几个新特性。
- 第一行包含一个多重赋值:变量
a
和b
同时获得新值 0 和 1。在最后一行再次使用它,证明右侧的表达式在任何赋值发生之前都首先被评估. 右侧的表达式从左到右计算。 while
只要条件(此处:)保持为真,循环就会执行。在 Python 中,就像在 C 中一样,任何非零整数值都为真;零是假的。条件也可以是字符串或列表值,实际上是任何序列;任何长度非零的东西都是真的,空序列是假的。示例中使用的测试是一个简单的比较。标准比较运算符的写法与 C 中的相同:(小于)、(大于)、 (等于)、(小于或等于)、(大于或等于)和(不等于)。a < 10
<
>
==
<=
>=
!=
- 循环体是缩进的:缩进是 Python 对语句进行分组的方式。在交互式提示下,您必须为每个缩进的行键入一个制表符或空格。在实践中,您将使用文本编辑器为 Python 准备更复杂的输入;所有体面的文本编辑器都有自动缩进功能。当以交互方式输入复合语句时,它必须后跟一个空行以表示完成(因为解析器无法猜测您何时键入最后一行)。请注意,基本块中的每一行必须缩进相同的数量。
- 该
print()
函数写入给定参数的值。它在处理多个参数、浮点数和字符串的方式上与仅编写您想要编写的表达式(正如我们前面在计算器示例中所做的那样)不同。字符串打印时不带引号,并在项目之间插入空格,因此您可以很好地格式化,如下所示:
>>>
>>> i = 256*256
>>> 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,