Python tutorial摘要1

调用解释器时，脚本名和附加参数传入一个名为 sys.argv 的字符串列表。你能够通过执行 import sys 来获取这个列表，列表的长度大于等于1；没有给定脚本和参数时，它至少也有一个元素：sys.argv[0] 此时为空字符串。

在Python源文件中可以使用非 ASCII 编码。最好的方法是在 #! 行的后面再增加一行特殊的注释来定义源文件的编码:
#!/usr/bin/python
# -*- coding: <UTF-8|GB2312|...> -*-

Python 中的注释以 # 字符起始，直至实际的行尾。

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

交互模式中，最近一个表达式的值赋给变量 _。此变量对于用户是只读的。不要尝试给它赋值 —— 你只会创建一个独立的同名局部变量，它屏蔽了系统内置变量的魔术效果。


字符串：
Python 也提供了可以通过几种不同方式表示的字符串。它们可以用单引号 ('...') 或双引号 ("...") 标识，\ 可以用来转义引号。

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

字符串文本能够分成多行。一种方法是使用三引号："""...""" 或者 '''...'''。行尾换行符会被自动包含到字符串中，但是可以在行尾加上 \ 来避免这个行为。

字符串可以由 + 操作符连接(粘到一起)，可以由 * 表示重复。

相邻的两个字符串文本自动连接在一起，它只用于两个字符串文本，不能用于字符串表达式。如果你想连接多个变量或者连接一个变量和一个字符串文本，使用 +。

字符串也可以被截取(检索)。类似于 C ，字符串的第一个字符索引为 0 。Python没有单独的字符类型；一个字符就是一个简单的长度为1的字符串。索引也可以是负数，这将导致从右边开始计算。

除了索引，还支持切片。索引用于获得单个字符，切片让你获得一个子字符串。注意，包含起始的字符，不包含末尾的字符。这使得 s[:i] + s[i:] 永远等于 s。切片的索引有非常有用的默认值；省略的第一个索引默认为零，省略的第二个索引默认为切片的字符串的大小。

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

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

Python字符串不可以被更改 — 它们是不可变的。内置函数 len() 返回字符串长度。


关于Unicode:
在 Python 中创建 Unicode 字符串和创建普通的字符串一样简单:

>>> u'Hello World !'
u'Hello World !'

引号前的 'u' 表示这会创建一个 Unicode 字符串。如果想要在字符串中包含特殊字符，可以使用 Python 的 Unicode-Escape。请看下面的例子:

>>> u'Hello\u0020World !'
u'Hello World !'

特别的，和普通字符串一样，Unicode 字符串也有原始模式。可以在引号前加 “ur”，Python 会采用 Raw-Unicode-Escape 编码(译者：原始 Unicode 转义)。如果有前缀为 ‘u’ 的数值，它也只会显示为 uXXXX:

>>> ur'Hello\u0020World !'
u'Hello World !'
>>> ur'Hello\\u0020World !'
u'Hello\\\\u0020World !'

如果你需要大量输入反斜杠，原始模式非常有用，这在正则表达式中几乎是必须的。


列表:
Python 有几个 复合 数据类型，用于表示其它的值。最通用的是 list (列表) ，它可以写作中括号之间的一列逗号分隔的值。列表的元素不必是同一类型。

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

就像字符串一样，列表可以被索引和切片。所有的切片操作都会返回一个包含请求的元素的新列表。这意味着切片操作返回列表一个新的（浅）拷贝副本。

不像不可变的字符串，列表允许修改元素。你还可以使用 append() 方法在列表的末尾添加新的元素。也可以对切片赋值，此操作可以改变列表的尺寸，或清空它。

允许嵌套列表(创建一个包含其它列表的列表)。


语句：
Python 中的 for 语句和 C 或 Pascal 中的略有不同。通常的循环可能会依据一个等差数值步进过程(如 Pascal)，或由用户来定义迭代步骤和中止条件(如 C )，Python 的 for 语句依据任意序列(链表或字符串)中的子项，按它们在序列中的顺序来进行迭代。

在迭代过程中修改迭代序列不安全(只有在使用链表这样的可变序列时才会有这样的情况)。如果你想要修改你迭代的序列(例如：复制选择项)，你可以迭代它的复本。

如果你需要一个数值序列，内置函数 range() 会很方便，它生成一个等差级数链表:

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

循环可以有一个 else 子句；它在循环迭代完整个列表 (对于 for) 后或执行条件为 false (对于 while) 时执行，但循环被 break 中止的情况下不会执行。

pass 语句什么也不做。它用于那些语法上必须要有什么语句，但程序什么也不做的场合。另一方面，pass 可以在创建新代码时用来做函数或控制体的占位符。可以让你在更抽象的级别上思考。


函数：
函数 调用 会为函数局部变量生成一个新的符号表。确切地说，所有函数中的变量赋值都是将值存储在局部符号表。变量引用首先在局部符号表中查找，然后是包含函数的局部符号表，然后是全局符号表，最后是内置名字表。因此，全局变量不能在函数中直接赋值 (除非用 global 语句命名)，尽管他们可以被引用。

函数引用的实际参数在函数调用时引入局部符号表，因此，实参总是 传值调用 (这里的 值 总是一个对象引用，而不是该对象的值)。一个函数被另一个函数调用时，一个新的局部符号表在调用过程中被创建。

最常用的一种形式是为一个或多个参数指定默认值。这会创建一个可以使用比定义时允许的参数更少的参数调用的函数。
def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
重要警告: 默认值只被赋值一次。这使得当默认值是可变对象时会有所不同，比如列表、字典或者大多数类的实例。

函数可以通过 关键字参数 的形式来调用，形如 keyword = value。
def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
在函数调用中，关键字的参数必须跟随在位置参数的后面。传递的所有关键字参数必须与函数接受的某个参数相匹配（例如 actor 不是 parrot 函数的有效参数），它们的顺序并不重要。这也包括非可选参数（例如 parrot(voltage=1000) 也是有效的）。任何参数都不可以多次赋值。

引入一个形如 **name 的参数时，它接收一个字典，该字典包含了所有未出现在形式参数列表中的关键字参数。这里可能还会组合使用一个形如 *name 的形式参数，它接收一个元组，包含了所有没有出现在形式参数列表中的参数值。( *name 必须在 **name 之前出现)。

def cheeseshop(kind, *arguments, **keywords):
    print "-- Do you have any", kind, "?"
    print "-- I'm sorry, we're all out of", kind
    for arg in arguments:
        print arg
    print "-" * 40
    keys = sorted(keywords.keys())
    for kw in keys:
        print kw, ":", keywords[kw]


cheeseshop("Limburger", "It's very runny, sir.",
           "It's really very, VERY runny, sir.",
           shopkeeper='Michael Palin',
           client="John Cleese",
           sketch="Cheese Shop Sketch")


-- Do you have any Limburger ?
-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
client : John Cleese
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch

注意在打印关键字参数之前，通过对关键字字典 keys() 方法的结果进行排序，生成了关键字参数名的列表；如果不这样做，打印出来的参数的顺序是未定义的。

最后，一个最不常用的选择是可以让函数调用可变个数的参数。这些参数被包装进一个元组(参见 元组和序列 )。在这些可变个数的参数之前，可以有零到多个普通的参数:

def write_multiple_items(file, separator, *args):
    file.write(separator.join(args))

另有一种相反的情况: 当你要传递的参数已经是一个列表，但要调用的函数却接受分开一个个的参数值。这时候你要把已有的列表拆开来。例如内建函数 range() 需要独立的 start ，stop 参数。 你可以在调用函数时加一个 * 操作符来自动把参数列表拆开。

>>> list(range(3, 6))            # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
>>> list(range(*args))            # call with arguments unpacked from a list
[3, 4, 5]

以同样的方式，可以使用 ** 操作符分拆关键字参数为字典:

>>> def parrot(voltage, state='a stiff', action='voom'):
...     print "-- This parrot wouldn't", action,
...     print "if you put", voltage, "volts through it.",
...     print "E's", state, "!"
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

通过 lambda 关键字，可以创建短小的匿名函数。这里有一个函数返回它的两个参数的和：lambda a, b: a+b。Lambda 形式可以用于任何需要的函数对象。出于语法限制，它们只能有一个单独的表达式。语义上讲，它们只是普通函数定义中的一个语法技巧。类似于嵌套函数定义，lambda 形式可以从外部作用域引用变量:

>>> def make_incrementor(n):
...     return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43

上面的示例使用 lambda 表达式返回一个函数。另一个用途是将一个小函数作为参数传递:

>>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
>>> pairs.sort(key=lambda pair: pair[1])
>>> pairs
[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

编码风格：
它给出了一个高度可读，视觉友好的编码风格。每个 Python 开发者都应该读一下，大多数要点都会对你有帮助：

使用 4 空格缩进，而非 TAB。

折行以确保其不会超过 79 个字符。

使用空行分隔函数和类，以及函数中的大块代码。

可能的话，注释独占一行

使用文档字符串

把空格放到操作符两边，以及逗号后面，但是括号里侧不加空格：a = f(1, 2) + g(3, 4)。

统一函数和类命名。推荐类名用 驼峰命名，函数和方法名用 小写_和_下划线。总是用 self 作为方法的第一个参数。

不要使用花哨的编码，如果你的代码的目的是要在国际化 环境。Python 的默认情况下，UTF-8，甚至普通的 ASCII 总是工作的最好。

同样，也不要使用非 ASCII 字符的标识符，除非是不同语种的会阅读或者维护代码。