【翻译】Python3手册之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."

# 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."

1.使用Python充当计算器

现在我们来使用一些简单的Python命令，打开Python解释器等待主提示符>>>的出现。

（1）数字

解释器充当一个简单的计算器的功能：你可以输入输入一个算术表达式解释器将会输出该结果。表达式的语法很直白：运算符+，-，*，/和其他语言一样，括号（（））用于分组。例如：

>>> 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 + 2

>>> 50 - 5*6

>>> (50 - 5*6) / 4

5.0

>>> 8 / 5 # division always returns a floating point number

1.6

其中，整数（2,4,20）的类型是int类型，带有小数部分的数（5.0,1.6）的类型是float类型。后面我们将会看到更多的数值类型。

除号(/)总是返回一个float类型如果使用floor除法得到整数结果，那么可以使用//运算符来实现；若要计算余数，那么可以使用%运算符来实现。

>>> 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

>>> 17 / 3 # classic division returns a float

5.666666666666667

>>>

>>> 17 // 3 # floor division discards the fractional part

>>> 17 % 3 # the % operator returns the remainder of the division

>>> 5 * 3 + 2 # result * divisor + remainder

在Python中，使用**运算符可以用来计算幂乘方：

>>> 5 ** 2  # 5 squared
25
>>> 2 ** 7  # 2 to the power of 7
128

>>> 5 ** 2 # 5 squared

>>> 2 ** 7 # 2 to the power of 7

128

等号（=）是用来给变量赋值的，并且在下一个提示符之前不会有任何的结果显示：

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

>>> 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

>>> n # try to access an undefined variable

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

NameError: name 'n' is not defined

Python对float浮点数有完整的支持：当整数和浮点数混合计算时，整数会被转换为浮点数：

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

>>> 3 * 3.75 / 1.5

7.5

>>> 7.0 / 2

3.5

在交互模式中，最后输出的表达式会被赋值于变量_，这就意味着当你用Python充当一个桌面计算器时，它可以很方便的用于连续计算：

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

>>> 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）。

（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," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'

>>> '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," he said.'

'"Yes," he said.'

>>> "\"Yes,\" he said."

'"Yes," he said.'

>>> '"Isn\'t," she said.'

'"Isn\'t," she said.'

在交互式的解释器中，输出的字符串会被引号括起来，特殊字符会用反斜杠转义。虽然可能和输入看上去不太一样，但是两个字符串是相等的。如果字符串只有单引号而没有双引号，就用双引号引用，否则用单引号引用。print()函数生成可读性更好的输出，它会省去引号并且打印出转义后的特殊字符：

>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'
>>> print('"Isn\'t," she said.')
"Isn't," she 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.

>>> '"Isn\'t," she said.'

'"Isn\'t," she said.'

>>> print('"Isn\'t," she said.')

"Isn't," she 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

>>> 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

字符串文本能够分成多行。一种方法是使用三引号：“““…”””或者‘‘‘…’’’。行尾换行符会被自动包含到字符串中，但是可以在行尾加上\来避免这个行为。下面的示例：可以使用反斜杠为行结尾的连续字符串，它表示下一行在逻辑上是本行的后续内容：

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

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

Usage: thingy [OPTIONS]

-h Display this usage message

-H hostname Hostname to connect to

并且在Python字符串中，+号可以用来连接、*号可以用来重复：

>>> # 3 times 'un', followed by 'ium'
>>> 3 * 'un' + 'ium'
'unununium'

>>> # 3 times 'un', followed by 'ium'

>>> 3 * 'un' + 'ium'

'unununium'

相邻的两个字符串文本会自动连接在一起：

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

1 2	>>> 'Py' 'thon' 'Python'

但是这种自动连接的方式只适用于两个字符串文本，并不适用于字符串表达式：

>>> prefix = 'Py'
>>> prefix 'thon'  # can't concatenate a variable and a string literal
  ...
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
  ...
SyntaxError: invalid syntax

>>> prefix = 'Py'

>>> prefix 'thon' # can't concatenate a variable and a string literal

...

SyntaxError: invalid syntax

>>> ('un' * 3) 'ium'

...

SyntaxError: invalid syntax

所以，如果你想要在变量之间或者变量和文本字符串之间进行连接，可以使用+号：

>>> prefix + 'thon'
'Python'

1 2	>>> prefix + 'thon' 'Python'

因此，当你想要分隔很长的字符串时，这个特性就会特别有用：

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

>>> text = ('Put several strings within parentheses '

... 'to have them joined together.')

>>> text

'Put several strings within parentheses to have them joined together.'

字符串可以被索引（下标），字符串的第一个字符的索引为0。Python没有单独的字符类型，一个字符就是一个简单的长度为1的字符串：

>>> word = 'Python'
>>> word[0]  # character in position 0
'P'
>>> word[5]  # character in position 5
'n'

>>> 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'

>>> 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'

>>> 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[:i] + s[i:]永远等于s：

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

>>> 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'

>>> 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'

观察下图，可能有助于你理解切分功能：

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

+---+---+---+---+---+---+

| P | y | t | h | o | n |

+---+---+---+---+---+---+

0 1 2 3 4 5 6

-6 -5 -4 -3 -2 -1

试图使用太大的索引将会导致错误：

>>> 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[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:]
''

>>> word[4:42]

'on'

>>> word[42:]

Python字符串是不能改变的，因此，赋值给字符串索引的位置会导致错误：

>>> word[0] = 'J'
  ...
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
  ...
TypeError: 'str' object does not support item assignment

>>> word[0] = 'J'

...

TypeError: 'str' object does not support item assignment

>>> word[2:] = 'py'

...

TypeError: 'str' object does not support item assignment

所以，如果你需要一个不同的字符串，你应该创建一个新的：

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

>>> 'J' + word[1:]

'Jython'

>>> word[:2] + 'py'

'Pypy'

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

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

>>> s = 'supercalifragilisticexpialidocious'

>>> len(s)

（3）列表

Python有几个复合数据类型，常用的就是list列表，它可以写作一个列表，用逗号分隔，列表的元素不必是同一类型：

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

>>> 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[0] # indexing returns the item

>>> squares[-1]

>>> squares[-3:] # slicing returns a new list

[9, 16, 25]

切分的所有切片都返回一个新的列表，这意味着下面的示例返回了一个list的副本：

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

1 2	>>> squares[:] [1, 4, 9, 16, 25]

list也支持连接操作：

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

1 2	>>> 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]

>>> cubes = [1, 8, 27, 65, 125] # something's wrong here

>>> 4 ** 3 # the cube of 4 is 64, not 65!

>>> cubes[3] = 64 # replace the wrong value

>>> cubes

[1, 8, 27, 64, 125]

你也可以使用append()函数在list的尾端增加元素：

>>> 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]

>>> 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]

对list的切片进行赋值、清空等：

>>> 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
[]

>>> 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()可以用于求解list的大小：

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

>>> letters = ['a', 'b', 'c', 'd']

>>> len(letters)

内嵌list列表也是可以的，例如：

>>> 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'

>>> 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'

2.编程的第一步

当然，我们可以使用Python来完成更复杂的任务。比如，我们可以实现斐波那契数列：

>>> # Fibonacci series:
... # the sum of two elements defines the next
... a, b = 0, 1
>>> while b < 10:
...     print(b)
...     a, b = b, a+b
...
1
1
2
3
5
8

>>> # Fibonacci series:

... # the sum of two elements defines the next

... a, b = 0, 1

>>> while b < 10:

... print(b)

... a, b = b, a+b

...

从这里例子，我们可以学习如下几个新的特性：

第一行包括了一个多重赋值：变量a和分别获得了新值0和1，并且最后一行也使用了多重赋值。在变量赋值前，等号右边首先完成计算，右边的表达式从左到右计算。
条件（这里是b<10）为true时，while循环执行。在Python中，类似于C，任何非零整数都是true，0是false。条件也可以是字符串或列表，实际上可以是任何序列：所有长度不为零的是true，空序列是false。示例中的测试是一个简单的比较。标准比较操作符与C相同：<, >, ==, <=, >=和!=。
循环体是缩进的：缩进是Python组织语句的方法。Python不提供集成的行编辑功能，所以你要为每一个缩进行输入TAB或空格。实践中建议你找个文本编辑来录入复杂的Python程序，大多数文本编辑器提供自动缩进。交互式录入复合语句时，必须在最后一个空行来标识结束（因为解释器没办法猜测你输入的哪一行是最后一行），需要注意的是同一个语句块中的每一行必须缩进同样数量的空白。
关键字print()语句输出给定表达式的值。它控制多个表达式和字符串输出为你想要字符串（就像我们在前面计算器的例子中那样）。字符串打印时不用引号包围，每两个子项之间插入空间，所以你可以把格式弄得很漂亮，像这样：

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

1
2
3

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

用关键字end以一个逗号结尾就可以禁止输出换行：

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

1
2
3
4
5
6

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

参考：
Python 3.5.2 Documentation

1.使用Python充当计算器

2.编程的第一步

发表评论 取消回复

发表评论取消回复