Python 学习成长记（三）---- Python 基本用法简介

最近准备重新系统学习一下Python语言，着手研读Python 3.6.1官方教程文档，于是想着不如翻译整理出来 , 希望能帮到一起学习Python的同学们，与大家一起进步，由于水平有限，翻译若有不妥之处，请大家指正 。

---

本文翻译 Python 官方教程第三章：An Informal Introduction to 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　Numbers

　　Python解释器作为一个简单的计算器：你可以在其中键入一个表达式，它将输出该表达式的结果。 表达式语法很简单：运算符+， - ，*和/ ，用起来就像大多数其他语言（例如，Pascal或C）一样; 括号()可用于组合。 例如：

>>> 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，4，20）是int类型，具有小数部分（例如5.0,1.6）的j float类型。 本教程稍后将介绍有关数字类型的更多信息。
　　除法（/）总是返回一个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 “”, line 1, in
NameError: name ‘n’ is not defined

　　Python完全支持浮点数; 带有混合类型操作数的运算符会将整数操作数转换为浮点数：

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

　　该变量应该被用户视为只读。 不要显式分配一个值给‘_’，如果你这么做，将会创建一个具有相同名称的独立本地变量，并屏蔽该内置变量。
　　除了int和float类型外，Python还支持其他类型的数字，例如Decimal和Fraction。 Python还内置了对复数的支持，并使用j或J后缀来表示虚部（例如3 + 5j）。

3.1.2 String

　　除了数字，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.’

　　在交互式解释器中，输出字符串用引号括起来，特殊字符用反斜杠转义。 虽然这有时可能看起来不同于输入（封闭的引号可能会改变），但是两个字符串是等效的。 如果字符串包含单引号并且没有双引号，则该字符串用双引号括起来，否则将其括在单引号中。 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.

　　如果您不希望以\开头的字符被转义为特殊字符，则可以在第一个引号之前添加一个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(“”“\
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’

　　这只适用于两个字符串，但不适用于变量或表达式：

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

　　当您想要打断长字符串时，此功能特别有用：

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

　　字符串可以通过下标索引，第一个字符的下标索引为0. 没有单独的字符类型; 一个字符是一个大小为一的字符串：

>>> 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开始。
　　除索引之外，Python还支持slice。 当使用索引来获取单个字符时，slice可以让您获取子字符串：

>>> 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[0:i]，若索引值冒号后缺省，则认为不包含i, 例如s[i:]是不包含s[i]这个字符的。即确保s [：i] + s [i：]始终等于s：

>>> word[:2] + word[2:]
‘Python’
>>> word[:4] + word[4:]
‘Python’

　　Slice需要有有效的默认值索引值; 省略的第一个索引默认为零，省略的第二个索引默认为要分割的字符串的大小。

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

　　记住slice如何工作的一种方式是将索引视为指向字符之间，第一个字符的左边缘编号为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的slice分别由标记为i和j的边缘之间的所有字符组成。
　　对于非负指数，slice的长度是索引的差值，如果两者都在范围内。 例如，字[1：3]的长度为2。
　　如果使用过大的索引值将导致错误：

>>> word[42] # the word only has 6 characters
Traceback (most recent call last):
File “”, line 1, in
IndexError: string index out of range

　　但是，超出范围的slice索引可以正常处理：

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

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

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

　　内置函数len（）返回字符串的长度：

>>> s = ‘supercalifragilisticexpialidocious’
>>> len(s)
34

也可以参考

文本序列类型 - str
　　字符串是序列类型的示例，并支持这些类型支持的常见操作。
String方法
　　字符串支持大量的基本转换和搜索方法。
格式化字符串文字
　　具有嵌入表达式的字符串文字。
格式化字符串语法
　　有关使用str.format（）的字符串格式化的信息。
Printf类型的字符串格式
　　当字符串是％操作符的左操作数时调用的旧格式化操作在此更详细地描述。

3.1.3. Lists

　　Python支持复合数据类型，用于将其他值组合在一起。 最通用的是list列表，可以写成方括号之间的逗号隔开的列表。 列表可能包含不同类型的item，但通常这些item都具有相同的类型。

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

　　像字符串（和所有其他内置的序列类型）一样，list可以索引和slice：

>>> squares[0] # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:] # slicing returns a new list
[9, 16, 25]

　　所有slice操作返回的是包含所请求元素的新列表。 这意味着以下切片返回列表的新列表：

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

　　你还可以在列表末尾添加新item，方法是使用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]

　　赋值到slice也是可以的，它甚至可以更改列表的大小或完全清除它：

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

　　Python也可以支持嵌套列表（创建包含其他列表的列表），例如：

>>> 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的初始子序列：

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

　　此示例介绍了几个新特性。
　　第一行包含一个多重赋值：变量a和b同时获取新的值0和1. 在最后一行，也是这样，表明在任何赋值之前，右侧的表达式先执行（计算）。右侧表达式从左到右进行执行（计算）。
　　只要条件（这里：b <10）保持为true，则while循环继续将执行。在Python中，像在C中，任何非零整数值都为真;零是假的条件也可以是任何序列包括字符串或列表值;任何具有非零长度的东西都是真的，空的序列是假的。该示例中使用的是一个简单的比较。标准比较运算符与C语言一样：<（小于），>（大于），==（等于），<=（小于或等于），> =（大于或等于）和！=（不等于）。
　　循环体是缩进的：缩进是Python对语句进行分组的方法。在交互式提示符下，您必须为每个缩进行键入一个tab键或空格。在实践中，你需要使用文本编辑器来编写更复杂的Python代码; 好的代码编辑器都有自动缩进功能。当以交互方式输入复合语句时，它必须后跟一个空行来指示完成（因为解析器无法猜测哪一行是最后一行）。请注意，基本块中的每一行必须缩进相同的数量。
　　print()函数写入给定的参数的值。它不同于只需要以处理多个参数，浮点数量和字符串的方式编写表达式（如我们之前在计算器示例中所做的那样）。打印没有带引号字符串，并且在item之间插入一个空格，所以你可以很好地格式化它们，如下所示：

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