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.0*6) / 4
  6. 5.0
  7. >>> 8 / 5.0
  8. 1.6

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

除法(/)返回的类型取决于它的操作数。如果两个操作数都是int，将采用floor除法(floor division)并返回一个int。如果两个操作数中有一个是float，将采用传统的除法并返回一个float。还提供//运算符用于floor division 而无论操作数是什么类型。余数可以用%操作符计算：

  1. >>> 17 / 3  # int / int -> int
  2. 5
  3. >>> 17 / 3.0  # int / float -> float
  4. 5.666666666666667
  5. >>> 17 // 3.0  # explicit floor division discards the fractional part
  6. 5.0
  7. >>> 17 % 3  # the % operator returns the remainder of the division
  8. 2
  9. >>> 5 * 3 + 2  # result * divisor + remainder
  10. 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

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

  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还支持其它数字类型，例如DecimalandFraction。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.'

在交互式解释器中，输出的字符串会用引号引起来，特殊字符会用反斜杠转义。虽然可能和输入看上去不太一样，但是两个字符串是相等的。如果字符串中只有单引号而没有双引号，就用双引号引用，否则用单引号引用。

  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..6各索引的位置；第二行给出了相应的负索引。从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

请参阅

序列类型 — str, unicode, list, tuple, bytearray, buffer, xrange字符串和下节描述的Unicode字符串是序列类型的例子，它们支持这种类型共同的操作。字符串方法字符串和Unicode字符串都支持大量的方法用于基本的转换和查找。字符串格式化这里描述了使用str.format()进行字符串格式化的信息。字符串格式化操作这里描述了旧式的字符串格式化操作，它们在字符串和Unicode字符串是%操作符的左操作数时调用。

3.1.3. Unicode 字符串

从Python2.0开始，程序员们有了一个新的用来存储文本数据的类型：Unicode对象。它可以用来存储和处理Unicode数据(见http://www.unicode.org/)，并与现有的字符串对象有良好的集成，必要时提供自动转换。

Unicode 的优点在于为现代和古代的每一种文字的每一个字符提供了统一的序号。以前，脚本只有256个可用的字符编码。通常，文本被绑定到映射字符编码的代码页上。这带来很多麻烦，尤其是软件国际化（通常写成i18n — 'i' + 18个字符 + 'n'）。Unicode 为所有脚本定义一个代码页，从而解决了这些问题。

在Python中创建Unicode字符串和创建普通字符串一样简单：

  1. >>> u'Hello World !'
  2. u'Hello World !'

引号前面小写的'u'表示创建一个Unicode字符串。如果你想要在字符串中包含特殊字符，你可以通过使用Python的Unicode转义编码。下面的示例演示如何使用：

  1. >>> u'Hello\u0020World !'
  2. u'Hello World !'

转义序列u0020表示在给定位置插入序号值为0x0020（空格字符）的Unicode字符。

其他字符就像 Unicode 编码一样被直接解释为对应的编码值。如果你有使用在许多西方国家使用的标准Latin-1编码的字符串，你会发现编码小于256的Unicode字符和在Latin-1编码中的一样。

和普通字符串一样，Unicode字符串也有raw模式。要使用Raw-Unicode-Escape编码，必须在引号的前面加上'ur'。只有在小写的'u'前面有奇数个反斜杠，才会用上面的uXXXX 转换

  1. >>> ur'Hello\u0020World !'
  2. u'Hello World !'
  3. >>> ur'Hello\\u0020World !'
  4. u'Hello\\\\u0020World !'

当你需要输入很多反斜杠时，raw 模式非常有用，这在正则表达式中几乎是必须的。

除了这些标准的编码，Python提供了基于已知编码来创建Unicode字符串的一整套方法。

内置函数unicode()提供对所有已注册的Unicode编解码器（编码和解码）的访问。这些编解码器可以转换的比较有名的编码有Latin-1、ASCII、UTF-8和UTF-16。后两个是可变长度编码，它们存储每个Unicode字符在一个或多个字节中。默认编码通常设置为ASCII，此编码接受0到127这个范围的编码，否则报错。当打印、向文件写入、或者用str()转换一个Unicode字符串时，转换将使用默认编码。

  1. >>> u"abc"
  2. u'abc'
  3. >>> str(u"abc")
  4. 'abc'
  5. >>> u"äöü"
  6. u'\xe4\xf6\xfc'
  7. >>> str(u"äöü")
  8. Traceback (most recent call last):
  9.   File "<stdin>", line 1, in ?
  10. UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-2: ordinal not in range(128)

Unicode对象提供encode()方法将Unicode字符串转换为使用指定编码的8位字符串，它接收一个编码名称作为参数。编码名应该小写。

  1. >>> u"äöü".encode('utf-8')
  2. '\xc3\xa4\xc3\xb6\xc3\xbc'

如果有一个已知编码的数据，希望从它生成一个Unicode字符串，你可以使用unicode()函数并以编码名作为第二个参数。

  1. >>> unicode('\xc3\xa4\xc3\xb6\xc3\xbc', 'utf-8')
  2. u'\xe4\xf6\xfc'

3.1.4. 列表

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

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

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

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

尾部的逗号可以避免输出换行符：

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

注意，如果最后一行没有结束，解释器会插入一个新行（在打印下一个提示符之前）。

脚注
[1] 因为的优先级高于-，所以-32将解释为-(32)且结果为-9。为了避免这点并得到9，你可以使用(-3)2。
[2] 与其它语言不同，特殊字符例如\n在单引号('…')和双引号("…")中具有相同的含义。两者唯一的区别是在单引号中，你不需要转义"（但你必须转义\')，反之亦然。

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