3. Python简介

以下的示例中，输入和输出通过有没有以提示符（>>>和…）来区分：如果要重复该示例，你必须在提示符出现后，输入提示符后面的所有内容；没有以提示符开头的行是解释器的输出。注意示例中出现从提示符意味着你一定要在最后加上一个空行；这用于结束一个多行命令。

本手册中的很多示例，甚至在交互方式下输入的示例，都带有注释。Python 中的注释以“井号”， #，开始，直至实际的行尾。注释可以从行首开始，也可以跟在空白或代码之后，但不能包含在字符串字面量中。字符串字面量中的#字符仅仅表示#。因为注释只是为了解释代码并且不会被Python解释器解释，所以敲入示例的时候可以忽略它们。

例如：

  1. # this is the first comment
  2. spam = 1  # and this is the second comment
  3.           # ... and now a third!
  4. text = "# This is not a comment because it's inside quotes."

3.1. 将 Python 当做计算器

让我们尝试一些简单的 Python 命令。启动解释器然后等待主提示符 >>>。（应该不需要很久。）

3.1.1. 数字

解释器可作为一个简单的计算器：你可以向它输入一个表达式，它将返回其结果。表达式语法很直白: 运算符+、 -、 *和/的用法就和其它大部分语言一样（例如 Pascal 或 C）；括号(())可以用来分组。例如：

  1. >>> 2 + 2
  2. 4
  3. >>> 50 - 5*6
  4. 20
  5. >>> (50 - 5*6) / 4
  6. 5.0
  7. >>> 8 / 5  # division always returns a floating point number
  8. 1.6

整数(例如 2, 4, 20)的类型是int，带有小数部分数字(e.g. 5.0, 1.6)的类型是float。在本教程的后面我们会看到更多关于数字类型的内容。

除法(/)永远返回一个浮点数。如要使用floor 除法并且得到整数结果（丢掉任何小数部分），你可以使用//运算符；要计算余数你可以使用%：

  1. >>> 17 / 3  # classic division returns a float
  2. 5.666666666666667
  3. >>>
  4. >>> 17 // 3  # floor division discards the fractional part
  5. 5
  6. >>> 17 % 3  # the % operator returns the remainder of the division
  7. 2
  8. >>> 5 * 3 + 2  # result * divisor + remainder
  9. 17

通过Python，还可以使用**运算符符计算幂乘方[1]：

  1. >>> 5 ** 2  # 5 squared
  2. 25
  3. >>> 2 ** 7  # 2 to the power of 7
  4. 128

等号 (=) 用于给变量赋值。赋值之后，在下一个提示符之前不会有任何结果显示：

  1. >>> width = 20
  2. >>> height = 5*9
  3. >>> width * height
  4. 900

如果变量没有“定义”（赋值），使用的时候将会报错：

  1. >>> n  # try to access an undefined variable
  2. Traceback (most recent call last):
  3.   File "<stdin>", line 1, in <module>
  4. NameError: name 'n' is not defined

浮点数完全支持；整数和浮点数的混合计算中，整数会被转换为浮点数：

  1. >>> 3 * 3.75 / 1.5
  2. 7.5
  3. >>> 7.0 / 2
  4. 3.5

在交互模式下，最近一次表达式的值被赋给变量_。这意味着把 Python 当做桌面计算器使用的时候，可以方便的进行连续计算，例如：

  1. >>> tax = 12.5 / 100
  2. >>> price = 100.50
  3. >>> price * tax
  4. 12.5625
  5. >>> price + _
  6. 113.0625
  7. >>> round(_, 2)
  8. 113.06

用户应该将这个变量视为只读的。不要试图去给它赋值 — — 你将会创建出一个独立的同名局部变量，并且屏蔽了内置变量的魔术效果。

除了int 和 float，Python还支持其它数字类型，例如小数 and 分数。Python还内建支持复数，使用后缀j 或 J 表示虚数部分（例如3+5j）。

3.1.2. 字符串

除了数值，Python 还可以操作字符串，可以用几种方法来表示。它们可以用单引号('…')或双引号("…")括起来，效果是一样的[2]。\ 可以用来转义引号。

  1. >>> 'spam eggs'  # single quotes
  2. 'spam eggs'
  3. >>> 'doesn\'t'  # use \' to escape the single quote...
  4. "doesn't"
  5. >>> "doesn't"  # ...or use double quotes instead
  6. "doesn't"
  7. >>> '"Yes," he said.'
  8. '"Yes," he said.'
  9. >>> "\"Yes,\" he said."
  10. '"Yes," he said.'
  11. >>> '"Isn\'t," she said.'
  12. '"Isn\'t," she said.'

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

  1. >>> '"Isn\'t," she said.'
  2. '"Isn\'t," she said.'
  3. >>> print('"Isn\'t," she said.')
  4. "Isn't," she said.
  5. >>> s = 'First line.\nSecond line.'  # \n means newline
  6. >>> s  # without print(), \n is included in the output
  7. 'First line.\nSecond line.'
  8. >>> print(s)  # with print(), \n produces a new line
  9. First line.
  10. Second line.

如果你前面带有\的字符被当作特殊字符，你可以使用原始字符串，方法是在第一个引号前面加上一个r:

  1. >>> print('C:\some\name')  # here \n means newline!
  2. C:\some
  3. ame
  4. >>> print(r'C:\some\name')  # note the r before the quote
  5. C:\some\name

字符串可以跨多行。一种方法是使用三引号："""…"""或者'''…'''。行尾换行符会被自动包含到字符串中，但是可以在行尾加上 \ 来避免这个行为。下面的示例：

  1. print("""\
  2. Usage: thingy [OPTIONS]
  3.      -h                        Display this usage message
  4.      -H hostname               Hostname to connect to
  5. """)

将生成以下输出（注意，没有开始的第一行）：

  1. Usage: thingy [OPTIONS]
  2.      -h                        Display this usage message
  3.      -H hostname               Hostname to connect to

字符串可以用 +操作符联接，也可以用* 操作符重复多次：

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

相邻的两个或多个字符串字面量（用引号引起来的）会自动连接。

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

然而这种方式只对两个字面量有效，变量或者表达式是不行的。

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

如果你想连接多个变量或者连接一个变量和一个常量，使用+：

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

这个功能在你想输入很长的字符串的时候特别有用：

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

字符串可以索引，第一个字符的索引值为0。Python 没有单独的字符类型；字符就是长度为 1 的字符串。

  1. >>> word = 'Python'
  2. >>> word[0]  # character in position 0
  3. 'P'
  4. >>> word[5]  # character in position 5
  5. 'n'

索引也可以是负值，此时从右侧开始计数：

  1. >>> word[-1]  # last character
  2. 'n'
  3. >>> word[-2]  # second-last character
  4. 'o'
  5. >>> word[-6]
  6. 'P'

注意，因为 -0 和 0 是一样的，负的索引从 -1 开始。

除了索引，还支持切片。索引用于获得单个字符，切片让你获得子字符串：

  1. >>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
  2. 'Py'
  3. >>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
  4. 'tho'

注意，包含起始的字符，不包含末尾的字符。这使得s[:i]+s[i:] 永远等于 s：

  1. >>> word[:2] + word[2:]
  2. 'Python'
  3. >>> word[:4] + word[4:]
  4. 'Python'

切片的索引有非常有用的默认值；省略的第一个索引默认为零，省略的第二个索引默认为切片的字符串的大小。

  1. >>> word[:2]  # character from the beginning to position 2 (excluded)
  2. 'Py'
  3. >>> word[4:]  # characters from position 4 (included) to the end
  4. 'on'
  5. >>> word[-2:] # characters from the second-last (included) to the end
  6. 'on'

有个方法可以记住切片的工作方式，把索引当做字符之间的点，第一个字符的左边是0。含有 n 个字符的字符串的最后一个字符的右边是索引 n，例如：

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

第一行给出了字符串中 0..5 各索引的位置；第二行给出了相应的负索引。从 i 到 j 的切片由 i 和 j 之间的所有字符组成。

对于非负索引，如果上下都在边界内，切片长度就是两个索引之差。例如，word[1:3] 的长度是 2。

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

  1. >>> word[42]  # the word only has 7 characters
  2. Traceback (most recent call last):
  3.   File "<stdin>", line 1, in <module>
  4. IndexError: string index out of range

但是，当用于切片时，超出范围的切片索引会优雅地处理：

  1. >>> word[4:42]
  2. 'on'
  3. >>> word[42:]
  4. ''

Python 字符串不可以改变—它们是不可变的。因此，赋值给字符串索引的位置会导致错误：

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

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

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

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

  1. >>> s = 'supercalifragilisticexpialidocious'
  2. >>> len(s)
  3. 34

请参阅

Text Sequence Type — strStrings are examples of sequence types, and support the common operations supported by such types.String MethodsStrings support a large number of methods for basic transformations and searching.String FormattingInformation about string formatting with str.format() is described here.printf-style String FormattingThe old formatting operations invoked when strings and Unicode strings are the left operand of the % operator are described in more detail here.

3.1.3. 列表

Python 有几个 复合 数据类型，用来组合其他的值。最有用的是 列表，可以写成中括号中的一列用逗号分隔的值。列表可以包含不同类型的元素，但是通常所有的元素都具有相同的类型。

  1. >>> squares = [1, 4, 9, 16, 25]
  2. >>> squares
  3. [1, 4, 9, 16, 25]

和字符串（以及其它所有内建的 序列类型）一样，列表可以索引和切片：

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

所有的切片操作都会返回一个包含请求的元素的新列表。这意味着下面的切片操作返回列表一个新的（浅）拷贝副本。

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

列表也支持连接这样的操作：

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

与不可变的字符串不同，列表是可变的 类型，例如可以改变它们的内容：

  1. >>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
  2. >>> 4 ** 3  # the cube of 4 is 64, not 65!
  3. 64
  4. >>> cubes[3] = 64  # replace the wrong value
  5. >>> cubes
  6. [1, 8, 27, 64, 125]

你还可以使用append()方法（后面我们会看到更多关于方法的内容）在列表的末尾添加新的元素：

  1. >>> cubes.append(216)  # add the cube of 6
  2. >>> cubes.append(7 ** 3)  # and the cube of 7
  3. >>> cubes
  4. [1, 8, 27, 64, 125, 216, 343]

给切片赋值也是可以的，此操作甚至可以改变列表的大小或者清空它:：

  1. >>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
  2. >>> letters
  3. ['a', 'b', 'c', 'd', 'e', 'f', 'g']
  4. >>> # replace some values
  5. >>> letters[2:5] = ['C', 'D', 'E']
  6. >>> letters
  7. ['a', 'b', 'C', 'D', 'E', 'f', 'g']
  8. >>> # now remove them
  9. >>> letters[2:5] = []
  10. >>> letters
  11. ['a', 'b', 'f', 'g']
  12. >>> # clear the list by replacing all the elements with an empty list
  13. >>> letters[:] = []
  14. >>> letters
  15. []

内置函数len()也适用于列表：

  1. >>> letters = ['a', 'b', 'c', 'd']
  2. >>> len(letters)
  3. 4

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

  1. >>> a = ['a', 'b', 'c']
  2. >>> n = [1, 2, 3]
  3. >>> x = [a, n]
  4. >>> x
  5. [['a', 'b', 'c'], [1, 2, 3]]
  6. >>> x[0]
  7. ['a', 'b', 'c']
  8. >>> x[0][1]
  9. 'b'

3.2. 编程第一步

当然，我们可以将 Python 用于比 2 加 2 更复杂的任务。例如，我们可以写一个生成斐波那契 初始子序列的程序，如下所示：

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

本示例介绍了几种新功能。

  • 第一行包括了一个多重赋值：变量a和b同时获得新的值 0 和 1。最后一行又这样使用了一次，说明等号右边的表达式在赋值之前首先被完全解析。右侧表达式是从左到右计算的。

  • 只要条件（这里是 b<10）为 true，while循环反复执行。在="" Python="" 中，和="" C="" 一样，任何非零整数值都为="" true；零为="" false。循环条件也可以是一个字符串或者列表，实际上可以是任何序列；长度不为零的序列为="" true，空序列为="" false。示例中使用的测试是一个简单的比较。标准比较运算符与="" 的写法一样：<（小于），=""> （大于）， = = (等于)， < = （小于或等于）， > = （大于或等于） 和! = （不等于）。

  • 循环体 是缩进 的：缩进是 Python 分组语句的方式。交互式输入时，你必须为每个缩进的行输入一个 tab 或（多个）空格。实践中你会用文本编辑器来编写复杂的 Python 程序；所有说得过去的文本编辑器都有自动缩进的功能。交互式输入复合语句时，最后必须在跟随一个空行来表示结束（因为解析器无法猜测你什么时候已经输入最后一行）。注意基本块内的每一行必须按相同的量缩进。

  • print()函数输出传给它的参数的值。与仅仅输出你想输出的表达式不同（就像我们在前面计算器的例子中所做的），它可以输出多个参数、浮点数和字符串。打印出来的字符串不包含引号，项目之间会插入一个空格，所以你可以设置漂亮的格式，像这样：

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

关键字参数 end 可以避免在输出后面的空行，或者可以指定输出后面带有一个不同的字符串：

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

Footnotes
[1] Since has higher precedence than -, -32 will be interpreted as -(32) and thus result in -9. To avoid this and get 9, you can use (-3)2.
[2] Unlike other languages, special characters such as \n have the same meaning with both single ('…') and double ("…") quotes. The only difference between the two is that within single quotes you don’t need to escape " (but you have to escape \') and vice versa.

原文: https://wizardforcel.gitbooks.io/python-doc-27-34/content/Text/4.3.html