Python

Python 语句可直接在解释器的交互模式中执行，如：

$ python3
Python 3.4.2 (default, Oct  8 2014, 10:45:20)
[GCC 4.9.1] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print("hello world")
hello world
>>> exit()

用 python 命令可执行保存在文件中的 Python 脚本，如：

$ cat hello.py
#!/usr/bin/env python
print("hello world")
$ python hello.py
hello world

Python 程序中的每个语句都以换行符结束。特别长的语句可以使用续行符(\)来分成几行。要在一行上放置多条语句，可以使用分号(;)隔开各条语句。

Python 是动态语言（变量名没有类型，值有类型）。同一变量名可以（在程序运行的不同阶段）代表不同类型的值。
Python 中变量在赋值中同时生成，无需声明。

$ python3 -q
>>> a = 1;
>>> print(a)
1
>>> a = "test"
>>> print(a)
test

内置的数字字面量分为 4 种类型：
(1) 布尔值，标识符 True 和 False 被解释为布尔值，其整数值分别是 1 和 0
(2) 整数，其位数是任意的，如 1234 ，又如 12345678901234567890 。要使用八进制、十六进制或二进制指定整数，可以在值的前面加上 0, 0x, 或 0b 。例如 0644, 0x100fea8, 0b11101010
(3) 浮点数，如 123.34 ，又如 1.234e+02
(4) 复数，如 1.2 + 12.34j

字符串用单引号(')，双引号(")。反斜杠(\)用来转义特殊字符，比如换行符、反斜杠本身、引号以及其他非打印字符。

a = 'Hello world'
b = "Hello world"
c = 'Hello "world"'     # 单引号中可以直接包含双引号
d = "Hello 'world'"     # 双引号中可以直接包含单引号
e = 'Hello \'world\''   # 如果要在单引号中包含单引号，则需要转义
f = "Hello \"world\""   # 如果要在双引号中包含双引号，则需要转义

g = 'Hello \nworld'     # 这里 \n 是换行符，如果想原封不动输出 \n，则可以使用后面的 raw strings

也可以用三引号（ ''' 或 """ ）来定义 ASCII 字符串。 三引号字符串的好处是：字符串中可以包含不必转义的“换行符”和“引号”。 使用它可以方便地创建多行字符串，如：

s="""line 1
line 2
line 3"""

print(s)

相邻两个字符串字面量（两者之间可以包含空格或者换行）会自动进行 concatenation，当然也可以使用 + 进行 concatenation，如：

a = "hello""world"             # 相当于 "helloworld"
b = "hello"    "world"         # 可以用空格（或者换行）分隔，相当于 "helloworld"
c = 'hello' "world"            # 相当于 "helloworld"
d = "hello" + "world"          # 使用 + 也可以 concatenate 两个字符串

使用 len() 可以使用计算字符串中“字符个数”；如果想计算所占“字节数”，则使用 encode('utf-8') 转换为 bytes 后再使用 len() 计算，如：

a = "hello"
print(len(a))                   # 输出 5

b = "汉字"
print(len(b))                   # 输出 2
print(len(b.encode('utf-8')))   # 输出 6

bytes 字面量使用前缀 b 或者 B 表示，如：

a = b'abcd'           # 使用双引号也行，即 b"abcd" 也行
print(a.hex())        # 输出 61626364
b = b'ABCD'
print(b.hex())        # 输出 41424344
c = b'\0'
print(c.hex())        # 输出 00

在 bytes 字面量只能包含 ascii 字符，所以大于等于 128 的表示需要使用 \x 转义，如：

a = b'\xde\xad\xbe\xef'
print(a.hex())        # 输出 deadbeef

程序中存储的所有数据都是对象。 每个对象都有一个“身份(identity)”，一个“类型(type)或者称为类别(class)”和一个“值(value)”。 例如，执行 a = 42 这行代码时，就会使用值 42 创建一个整数类型对象， 对象身份(identity)可以看作是指向它在内存中所处位置的指针， 这个例子中 a 就是引用这个具体位置的名称。

前面说过，每个对象都有一个“身份(identity)”，一个“类型(type)或者称为类别(class)”和一个“值(value)”。

对象被创建之后，它的身份(identity)和类型（或称为类别）就不可以改变。如果对象的值是可以修改的，则称为可变对象(mutable)。如果对象的值不可以修改，则称为不可变对象(immutable)。 Python 中常见 immutable/mutable 对象如表 2 所示。

下面是不可变对象(int)的简单测试：

>>> x = 1
>>> type(x)
<type 'int'>
>>> id(x)
140377823681400
>>> x += 3
>>> id(x)
140377823681328    # 和上一个id(x)的输出不同。由于int是“不可变”的，当执行x += 3时，无法修改x关联的对象，变量x会关联到另一个对象上

下面是可变对象(list)的简单测试：

>>> x = [1, 2, 3]
>>> type(x)
<type 'list'>
>>> id(x)
4317624728
>>> x += [4, 5]
>>> id(x)
4317624728        # 和上一个id(x)的输出相同。由于list是“可变”的，当执行x += [4, 5]时，可直接修改x关联的对象

关于可变对象和不可变对象的另一个测试：

def append_to_sequence (myseq):
    myseq += (9,9,9)
    return myseq

tuple1 = (1,2,3)         # tuples are immutable
list1  = [1,2,3]         # lists are mutable

tuple2 = append_to_sequence(tuple1)
list2  = append_to_sequence(list1)

print(tuple1)   # outputs (1, 2, 3)
print(tuple2)   # outputs (1, 2, 3, 9, 9, 9)
print(list1)    # outputs [1, 2, 3, 9, 9, 9]
print(list2)    # outputs [1, 2, 3, 9, 9, 9]

大多数对象都拥有大量特有的数据属性和方法。“属性”就是与对象相关的值。方法就是被调用时将在对象上执行某些操作的函数。使用点运算符(.)可以访问属性和方法。如：

a = 3 + 4j       # 创建一个复数（对象）
r = a.real       # 获得实部（复数对象的属性之一）

b = [1, 2, 3]    # 创建一个列表（对象）
b.append(7)      # 使用列表对象的append方法添加一个新元素

Python 中的所有对象都是“第一类的”。能够命名的所有对象都可以当作数据处理。例如，下面给出了一个包含两个值的字典：

items = {
  'number' : 42,
  'text' : "Hello World"
}

给这个字典添加一些不平常的项，便可以理会到“所有对象是第一类的”这句话的含义，例如：

items["func"] = abs             # Add the abs() function
import math
items["mod"] = math             # Add a module
items["error"] = ValueError     # Add an exception type
nums = [1,2,3,4]
items["append"] = nums.append   # Add a method of another object

在这个例子中，items 字典包含一个函数、一个模块、一个异常和另一个对象的一个方法。我们可以使用 items 的字典查询代替原始名称，代码依然有效，例如：

>>> items["func"](-45)             # 执行abs(-45)
45
>>> items["mod"].sqrt(4)           # 执行math.sqrt(4)
2.0
>>> try:
...   x = int("a lot")
... except items["error"] as e:    # 等同于except ValueError as e:
...   print("Couldn't convert")
...
Couldn't convert
>>> items["append"](100)           # 执行nums.append(100)
>>> nums
[1, 2, 3, 4, 100]

Python 中表示数据的内置类型如表 3 所示。

算术运算符如表 4 所示。

下面例子演示了 / 运算符和 // 运算符的不同：

>>> 5/2                       # 返回浮点数
2.5
>>> 5//2                      # 相除后，取整数部分
2
>>> type(5/2)
<class 'float'>
>>> type(5//2)
<class 'int'>

当我们想有得到相除后的整数部分时，应该使用 x//y ，而不是 int(x/y) ，它们有区别：

>>> int(999999999999999999999999/3)    # 使用 / 运行得到浮点数，再转 int 会有精度损失
333333333333333327740928
>>> 999999999999999999999999//3        # 使用 // 直接得到 int，不会有精度损失
333333333333333333333333

and, or 和 not 关键字构成了布尔表达式。它们的行为如表 5 所示。

注 1： 使用表达式来判断 True 或者 False 值时，“True，任意非零数字、非空字符串、非空列表、非空元组或非空字典”都将返回 True，而“False，零、空字符串、空列表、空元组或空字典”都将返回 False。
注 2： and 和 or 都具有“短路求值”特性。

比较运算符返回布尔值。如表 6 所示。

常见的编程模式是根据表达式的结果，有条件地进行赋值，例如：

if a <= b:
    minvalue = a
else:
    minvalue = b

使用“条件表达式”可以简化上面代码，例如：

minvalue = a if a <= b else b         # 条件表达式实例

在“条件表达式”中，首先求值的是中间的条件。如果结果为 True，再对 if 语句左面的表达式求值，否则就会对 else 后面的表达式求值。

使用条件表达式时应该格外仔细，因为它们可能导致混淆，特别是将其嵌套或者与其他复杂表达式混在一起的时候。然而，条件表达式在列表推导中特别有用，例如：

values = [1, 100, 45, 23, 73, 37, 69]
clamped = [x if x < 50 else 50 for x in values]
print(clamped)     # 输出 [1, 50, 45, 23, 50, 37, 50]

使用 == 可以判断两个对象的值是否相同，使用 is 可以判断两个对象是否是同一个对象（内存地址是否相同）。

对于自定义的类，通过实现 __eq__ 方法可定制 == 的形为。如：

class Test(object):

    def __init__(self, attr1, attr2):
        self.attr1 = attr1
        self.attr2 = attr2

    def __str__(self):
        return str(self.__dict__)

    def __eq__(self, other):
        return self.__dict__ == other.__dict__

t1 = Test("foo", 3)
t2 = Test("foo", 3)
t3 = Test("bar", 3)

print(t1)
print(t2)
print(t3)
print(t1 == t2)  # True
print(t2 == t3)  # False

参考：https://docs.python.org/3.5/reference/datamodel.html#basic-customization

切片操作可以应用于有序对象（如 string，tuple 或 list），用于从有序对象中选出指定范围的元素。切片的基本语法为：

[start : stop : stride]   # 分别表示“开始下标”（包含），“结束下标”（不包含）和“步进”

说明 1：“步进”和紧根在前面的冒号可以省略，默认步进为 1。
说明 2：“开始下标”省略时，默认为 0；“结束下标”省略时，默认为有序对象的长度。
说明 3：Python 中切片操作得到的是有序对象的复本；而 NumPy 中的切片操作得到的是原始数组的一个视图，也就是说它与原始数组共享同一块数据空间。

下面是一些切片操作的基本实例：

>>> word='Python3'
>>> word[1:3]    # 从下标1（包含）开始，到下标3（不包含）结束
'yt'
>>> word[:3]     # 从下标0（包含）开始，到下标3（不包含）结束
'Pyt'
>>> word[1:]     # 从下标1（包含）开始，到下标7（不包含）结束
'ython3'
>>> word[1:5:2]  # 从下标1（包含）开始，到下标5（不包含）结束，步进为2
'yh'
>>> word[::1]    # 相当于复制数组
'Python3'
>>> word[::-1]   # 相当于复制倒序后的数组
'3nohtyP'

参考：https://docs.python.org/3/reference/expressions.html?#slicings

条件语句的基本格式如下所示：

if a < b:
  z=b
else:
  z=a

如果某个子句不需要任何操作，可以使用 pass 语句。如：

if a < b:
  pass
else:
  z=a

通过使用 or, and 和 not 关键字你可以建立任意的条件表达式。如：

if b >= a and b <= c:
  print("b is between a and c")
if not (b < a or b > c):
  print("b is still between a and c")

用 elif 语句可以检验多重条件。如：

if a == '+':
  op = PLUS
elif a == '-':
  op = MINUS
elif a == '*':
  op = MULTIPLY
else:
  raise RuntimeError, "Unknown operator"

可以使用 while 或 for 语句实现循环。 break 语句用于立刻中止循环。 continue 语句用于直接进入下一次循环（忽略当前循环的剩余语句）。

while expression:
     statements

while 语句循环执行块中的语句，直到表达式为假。

for i in s:
     statements

for 语句反复迭代一个序列中的元素，直到迭代完序列中最后一个元素。

下面是 for 语句的一些例子：

for i in range(0, 5):
    print(i)                           # 依次输出 5 个数，从 0 到 4

# 遍历 list 的例子
items = ["a", "b", "c"]
for item in items:
    print(item)

for index, item in enumerate(items):   # 返回两个值，前一个为索引，后一个为列表中的元素
    print(index)                       # 输出每个索引
    print(item)                        # 输出每个元素

# 遍历 dict 的例子
my_dict = {'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
for key in my_dict:                    # 直接遍历 dict，会返回 key
    print(key, '->', my_dict[key])

for key, value in my_dict.items():     # 返回两个值，前一个为 key，后一个为 value
    print(key, '->', value)

注：如果你想退出一个多重循环，可以使用异常。Python 不提供 goto 语句。

使用 try 和 except 语句来捕获并处理异常。

try:
  f = open("file.txt","r")
except OSError as err:
  print(err)

如果想捕获所有异常，则可以这样：

try:
  whatever()
except:                         # 捕获所有异常
  print("Caught it!")

如果想捕获所有异常的同时还打印出异常，则可以这样：

try:
  whatever()
except BaseException as e:      # 捕获所有异常
  print(e)

所有异常中包含了 KeyboardInterrupt 异常，如果我们不小心捕获并吞下了这个异常，则可能导致程序不能人为退出了。更常见的是捕获 Exception，如：
不过，一般情况下，我们

try:
  whatever()
except Exception as e:          # 捕获绝大部分异常（不包含 SystemExit，KeyboardInterrupt 异常）
  print(e)

Python 中异常层次如下所示：

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StopAsyncIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- AttributeError
      +-- BufferError
      +-- EOFError

参考：https://docs.python.org/3.9/library/exceptions.html#exception-hierarchy

with 语句是从 Python 2.5 开始引入的一种与异常处理相关的语句（Python 2.5 中要通过 from __future__ import with_statement 导入后才可以使用），从 Python 2.6 开始缺省可用。

正确地管理各种系统资源（如文件、锁、连接），在涉及异常时通常是一个棘手的问题：引发的异常可能导致控制流跳过负责释放关键资源的语句。

先看一个使用 with 的例子：

with open("debuglog","a") as f:
    f.write("Debugging\n")
    ## statements
    f.write("Done\n")

这将保证离开 with 后，文件会被关闭。

我们先介绍上下文管理器的概念。 如果对象实现了 __enter__() 和 __exit__() 方法，这个对象就称为上下文管理器（Context Manager）。

with 语句的功能是：在执行语句体之前会调用上下文管理器的 __enter__() 方法，执行完语句体之后会执行 __exit__() 方法。

参考：https://docs.python.org/2/reference/compound_stmts.html#the-with-statement

在 Python 中，使用 def 语句来创建函数。调用函数和 C 语言类似。

函数实例：

def remainder(a,b):
    q = a/b
    r = a - q*b
    return r

Python 中不支持函数重载。

当函数中省略 return 语句时，默认返回 None 。如：

>>> def foo():
...   x=1           # 函数foo没有return语句
...
>>> a=foo();
>>> print(a)
None
>>> type(a)
<type 'NoneType'>

使用元组可以让函数返回多个值。如：

def divide(a,b):
  q = a // b
  r = a - q*b
  return (q,r)            # 不写小括号，也行 return q, r

# 把函数的多个返回值放到单独的变量中：
quotient, remainder = divide(1456, 33)       # 1456=44*33+4, quotient=44, remainder=4
(quotient, remainder) = divide(1456, 33)     # 和上一行作用相同

Python 不允许程序员选择采用传值还是传引用。Python 参数传递采用的是“传对象引用(call by object reference)”的方式。实际上，这种方式相当于传值和传引用的一种综合。 如果函数收到的是一个可变对象（比如字典或者列表）的引用，就能修改对象的原始值——相当于通过“传引用”来传递对象。如果函数收到的是一个不可变对象（比如数字、字符或者元组）的引用，就不能直接修改原始对象——相当于通过“传值”来传递对象。

a = [1, 2, 3, 4, 5]
def square(items):
  for i,x in enumerate(items):
    items[i] = x * x

square(a)       # a 会被修改
print(a)        # a 变为了 [1, 4, 9, 16, 25]

如果在函数定义时为参数赋值（这就是参数的默认值），则这个参数是可选的，调用函数可以省略它。

def add(x, y=2):
    return x+y

add(1, 10)      # return 11
add(1)          # return 3

定义函数后，默认的参数值会传递给以值的方式提供的对象。如：

a = 10
def foo(x=a):
  return x

a = 5             # 给a重新赋值
print(foo())      # 输出10（默认值没有变）

如果给最后一个参数名加上星号(*)，函数就可以接受任意数量的参数。如：

def mySum(*args):
  sum = 0
  for i in args:          # args is 'tuple'
    sum = sum + i
  return sum

print(mySum(1, 2, 3, 4))   # output 10

在 Python3 中，可变长参数后，还可以出现带有默认值的参数。如：

>>> def concat(*args, sep="/"):                   # Python 2中不合法，Python 3中合法
...     return sep.join(args)
...
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'earth.mars.venus'

调用函数时，可以显式地命名每个参数并为其指定一个值，这称为关键字参数。使用关键字参数时，参数的顺序无关紧要。位置参数和关键字参数可以同时使用，不过要求位置参数先出现。如：

def foo(w, x, y, z):
  statements

# 关键字参数调用
foo(w='hello', x=3, y=22, z=[1,2])
foo(w='hello', z=[1,2], x=3, y=22)   # 和上行相同。关键字参数的顺序无关紧要
foo('hello', 3, y=22, z=[1,2])       # 和上面两行相同，位置参数和关键字参数可以同时使用（前提是位置参数先出现）
foo('hello', 3, z=[1,2], y=22)       # 和上面三行相同

使用 * 和 ** 可以进行 Unpacking Argument Lists，它使得为函数提供函数更加方便。下面通过两个例子来介绍什么是 Unpacking Argument Lists。

def fun(a, b, c, d):
    print(a)
    print(b)
    print(c)
    print(d)

my_list=['value1', 'value2', 'value3', 'value4']

#fun(my_list)                  # 会报错 TypeError: fun() takes exactly 4 arguments (1 given)
fun('value1', 'value2', 'value3', 'value4')
fun(*my_list)                  # Unpacking Argument Lists，和上一行作用相同

再看一个 Unpacking Argument Lists 的例子。

def fun(a, b, c, d):
    print(a)
    print(b)
    print(c)
    print(d)


my_dict={'a':'value1', 'b':'value2', 'c':'value3', 'd':'value4'}

#fun(my_dict)                  # 会报错 TypeError: fun() takes exactly 4 arguments (1 given)
fun(a='value1', b='value2', c='value3', d='value4')
fun(**my_dict)                 # Unpacking Argument Lists，和上一行作用相同

参考：https://docs.python.org/3/tutorial/controlflow.html#unpacking-argument-lists

可以为用户自定义函数的参数和返回值增加类型说明，如：

>>> def f(ham: str, eggs: str = 'eggs') -> str:
...     print("Annotations:", f.__annotations__)
...     print("Arguments:", ham, eggs)
...     return ham + ' and ' + eggs
...
>>> f('spam')
Annotations: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}
Arguments: spam eggs
'spam and eggs'

详情可参考 PEP 3107 和 PEP 484。

每次执行一个函数时，就会创建新的局部命名空间。该命名空间代表一个局部环境，其中包含函数参数的名称和在函数体内赋值的变量名称。 Python 采用 Lexical scoping（“词法作用域”，也可称为“静态作用域”），即解析这些名称时，解释器将首先搜索局部作用域，然后由内而外一层层检查外部嵌套函数定义的作用域。如果找不到匹配，最后将搜索全局命名空间和内置命名空间。

def fun():
    a = 1
    def display():
        print(a)
    return display

a = 2

f = fun()
f()              # 由于Python采用“静态作用域”，会去函数定义环境（而不是调用链）中寻找变量，所以这里会输出1（而不是2）。

注：除词法作用域外，还存在“动态作用域”，采用“动态作用域”的语言在解析名称时，会一层层往往外查找函数的调用链（而不是函数的定义环境），这会使得程序的调试变得更加复杂，且容易出错。

如果函数（要满足后面条件只能是嵌套函数）访问的变量中存在变量满足条件：即不是全局变量又不是局部变量，这时函数和变量一起构成“闭包”。

>>> def make_printer(msg):
...   def printer():
...      print(msg)                      # msg不是全局变量，也不是函数printer的局部变量
...   return printer
...
>>> printer1 = make_printer('Foo!')      # printer1是闭包
>>> printer1.__closure__
(<cell at 0x10ad83638: str object at 0x10ad82c60>,)
>>> printer1()
Foo!

下面的 printer2 不是闭包。

>>> def make_printer(msg):
...   def printer(msg=msg):
...      print(msg)                      # msg是printer的参数，它存在于printer的局部作用域中
...   return printer
...
>>> printer2 = make_printer('Foo!')      # printer2不是闭包
>>> printer2.__closure__                 # 没有输出
>>> printer2()
Foo!

参考：http://stackoverflow.com/questions/4020419/why-arent-python-nested-functions-called-closures

装饰器(Decorators)是一个函数，其主要用途是包装另一个函数或类。 这种包装的首要目的是透明地修改或增强被包装对象的行为。表示装饰器的语法是特殊符号 @ 。装饰器的语义为把函数替换为经过装饰器处理后的函数，看起来像：

@trace
def square(x):
    return x*x

######## 上面的语义相当于 ########
def square(x):
    return x*x
square = @trace(square)

装饰器本身是函数，下面是它的实例：

enable_tracing = True
if enable_tracing:
    debug_log = open("debug.log","w")

def trace(func):               # 装饰器的实现
    if enable_tracing:
        def callf(*args, **kwargs):
            debug_log.write("Calling %s: %s, %s\n" %
                                (func.__name__, args, kwargs))
            r = func(*args, **kwargs)
            debug_log.write("%s returned %s\n" % (func.__name__, r))
            return r
        return callf
    else:
        return func

@trace
def square(x):
    return x*x

square(3)

运行上面程序，生成的 debug.log 内容如下：

$ cat debug.log
Calling square: (3,), {}
square returned 9

函数使用 yield 关键字可以定义“生成器”对象。生成器是一个函数，它生成一个值的序列，以便在迭代中使用。

下面是生成器的例子：

def countdown(n):
    print("Counting down from %d" % n)
    while n > 0:
        yield n
        n -= 1
    return

和普通函数不同，调用上面生成器时，其中的代码不会开始执行，它会返回一个生成器对象。只有在生成器对象上第一次调用 next() （在 Python3 中，请使用 __next__() ）时才开始执行生成器中代码。

>>> c=countdown(10)      # 调用 countdown(10) 时，并不会开始执行生成器代码
>>> c.next()             # 在Python 3中，请使用c.__next__()
Counting down from 10
10
>>> c.next()
9
>>> c.next()
8

在生成器对象上调用 next() 时，生成器函数将不断执行语句，直到遇到 yield 语句为止。再次调用 next() 时会继续执行直到又遇到 yield 语句。

通常，不会在生成器对象上直接调用 next() 方法，而是在 for 语句， sum() 函数或者一些使用序列的其它操作中使用它。例如：

for n in countdown(10):
    print(n)

又如：

a = sum(countdown(10))
print(a)                     # output 55

在函数内，yield 语句可以作为表达式出现在赋值运算符右边， 例如：

def receiver():
    print "Ready to receive"
    while True:
        n = (yield)
        print("Got %s" % n)

以这种方式使用 yield 语句的函数称为“协程” ，它的执行是为了响应发送给它的值。它的行为也十分类似于生成器，例如：

>>> r = receiver()
>>> r.next()           # 向前执行到第一条yield语句(在Python3中是r.__next__())
Ready to receive
>>> r.send(1)
Got 1
>>> r.send(2)
Got 2
>>> r.send("Hello")
Got Hello

在这个例子中， 对 next()的初始调用是必不可少的，这样协程才能执行可通向第一个 yield 表达式的语句。在这里协程会挂起，等待相关生成器对象 r 的 send() 方法给它发送一个值。传递给 send() 的值由协程中的 (yield) 表达式返回。接收到值后，协程就会执行语句，直至遇到下一条 yield 语句。

下面是 yield 表达式的另一个例子：

def grep(pattern):
    print("Searching for %s" % pattern)
    while True:
        line = (yield)
        if pattern in line:
            print(line)

测试如下：

>>> search = grep('coroutine')
>>> search.next()
Searching for coroutine
>>> search.send('Test')
>>> search.send('I love you')
>>> search.send('I love coroutine')
I love coroutine

参考：https://docs.python.org/2/reference/expressions.html#yield-expressions

函数的常用操作是将函数应用给一个列表的所有项，并使用结果创建一个新列表，例如：

nums = [1, 2, 3, 4, 5]
squares = []
for n in nums:
    squares.append(n * n)

这种操作很常见，因此出现了叫做“列表推导(List Comprehensions)”的运算符，例如：

nums = [1, 2, 3, 4, 5]
squares = [n * n for n in nums]       # 比上面代码块更加简洁

列表推导式用来基于一个列表创建另一个列表 ，它的一般语法为：

[expression for item1 in iterable1 if condition1
            for item2 in iterable2 if condition2
            ...
            for itemN in iterableN if conditionN ]

这种语法大致上等价于以下代码：

result = []
for item1 in iterable1:
    if condition1:
        for item2 in iterable2:
            if condition2:
                ...
                for itemN in iterableN:
                    if conditionN:
                        result.append(expression)

下面是列表推导式的一些例子：

>>> vec = [-2, -1, 0, 1, 2]
>>> [x*2 for x in vec]                  # create a new list with the values doubled
[-4, -2, 0, 2, 4]
>>> [x for x in vec if x >= 0]          # filter the list to exclude negative numbers
[0, 1, 2]
>>> [abs(x) for x in vec]               # apply a function to all the elements
[2, 1, 0, 1, 2]
>>> [(x,y) for x in [-3,5,-10,7] for y in 'abc' if x > 0]
[(5, 'a'), (5, 'b'), (5, 'c'), (7, 'a'), (7, 'b'), (7, 'c')]

注：List Comprehensions 并不是 Python 所独有，其它语言也有类似结构。参考：https://en.wikipedia.org/wiki/List_comprehension

生成器表达式是一个对象，它执行的计算与列表推导式相同，但会迭代地生成结果。 生成器表达式的语法也与列表推导式相同，但要用圆括号代替方括号。 生成器表达式的语法为：

(expression for item1 in iterable1 if condition1
            for item2 in iterable2 if condition2
            ...
            for itemN in iterableN if conditionN)

和列表推导式不同， 生成器表达式不创建列表或者不立即对圆括号内的表达式求值。生成器表达式会创建一个通过迭代并按照需要生成值的生成器对象。 例如：

>>> a = [1, 2, 3, 4]
>>> b = (10*i for i in a)
>>> b
<generator object <genexpr> at 0x103377c30>
>>> b.next()
10
>>> b.next()
20
>>> b.next()
30

生成器表达式和列表推导式的差异在于： 列表推导式会一次创建好包含结果数据的列表；而生成器表达式只是创建生成器。 在某些应用中，生成器表达式会更加高效且内存占用更少。例如：

# Read a file
f = open("data.txt")                           # Open a file
lines = (t.strip() for t in f)                 # Generator expression. Read lines, strip trailing/leading whitespace

comments = (t for t in lines if t[0] == '#')   # Generator expression. All comments
for c in comments:
    print(c)

需要说明的是，在上面的 lines 和 comments 都是生成器表达式。 在上面的处理过程中绝对没有把整个文件加载到内存中。 因此，这里一种从很大的 Python 源文件中提取注释的高效方法。

生成器表达式不会创建序列形式的对象。不能对它进行索引，也不能进行任何常规的列表操作，例如 append()。但是，使用内置的 list() 函数可以将生成器表达式转换为列表。如：

clist = list(comments)                 # comments is generator expression

什么是声明式编程（Declarative Programming）呢？声明式编程是和命令式编程（Imperative Programming）相对的概念。C++、Java 等都属命令式编程风格的语言；而 SQL 语言就是声明式编程风格的语言。

声明式编程风格是特点是： 只需要声明你想要得到的结果，而不用显式指定控制流程。 比如下面 SQL 语句：

SELECT * from dogs
INNER JOIN owners
WHERE dogs.owner_id = owners.id

也可以用命令式编程方式实现上面 SQL 语句的逻辑：

// javasript code

//dogs = [{name: 'Fido', owner_id: 1}, {...}, ... ]
//owners = [{id: 1, name: 'Bob'}, {...}, ...]

var dogsWithOwners = []
var dog, owner

for(var di=0; di < dogs.length; di++) {
  dog = dogs[di]
  for(var oi=0; oi < owners.length; oi++) {
    owner = owners[oi]
    if (owner && dog.owner_id == owner.id) {
      dogsWithOwners.push({
        dog: dog,
        owner: owner

      })
    }
  }}
}

声明式编程的好处在于： 代码看起来更加简洁；且它在更高的层次进行了抽象（你只用声明想得到什么，而不用关心怎么得到），这样底层编译器可以帮我们进行优化。

使用 lambda 语句可以创建表达式形式的匿名函数。语法为：

lambda args: expression

其中 args 是以逗号为分隔的参数列表，而 expression 是用到这些参数的表达式。如：

a = lambda x,y : x+y
r = a(2, 3)             # r = 5

使用 lambda 语句定义的代码必须是合法的表达式，不能出现 for, while 等结构。

Python 中，类继承的语法如下所示：

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

如下面是栈的简单实现（它继承自 object，object 是所有 Python 类型的根类型）：

class Stack(object):              # 继承object
  def __init__(self):             # __init__ 是个特殊的方法，用来初始化一个对象实例
    self.stack = []
  def push(self,object):
    self.stack.append(object)
  def pop(self):
    return self.stack.pop()
  def length(self):
    return len(self.stack)

由于 Stack 和内置的 list 几乎完全相同，因此，我们还可以通过继承 list 然后添加额外的方法也创建 Stack。如：

class Stack(list):                # 继承list。仅需要添加push方法，list本身带有pop方法
  def push(self, object):
    self.append(object)

可以像下面这样使用上面定义的 Stack 类：

s = Stack()
s.push("Dave")
s.push(43)
x = s.pop()       # x gets 43
print(x)          # output 43
del s

使用库 abc 可以实现抽象基类，继承它的类必须实现抽象基类中定义的抽象方法，如：

from abc import ABCMeta, abstractmethod


class Bird(metaclass=ABCMeta):     # metaclass=ABCMeta 表明它是一个抽象基类
    """
    Bird 是抽象基类，不能直接实例化，继承它的类必须实现下面的抽象方法 fly
    """
    @abstractmethod
    def fly(self):
        pass


class Parrot(Bird):    # 方式一：直接继承 Bird
    """
    Parrot 继承于 Bird，必须实现抽象方法 fly
    """
    def fly(self):
        print("Parrot Flying")


@Bird.register      # 方式二：通过装饰器声明 Magpie 是 Bird 的子类
class Magpie:
    """
    Magpie 继承于 Bird，必须实现抽象方法 fly
    """
    def fly(self):
        print("Magpie Flying")


class Crow:
    def fly(self):
        print("Crow Flying")

Bird.register(Crow)     # 方式三：显式地调用 Bird.register 来声明 Crow 是 Bird 的子类


bird = Parrot()
bird.fly()
print(isinstance(bird, Bird))  # True
print(issubclass(Parrot, Bird))  # True

bird = Magpie()
bird.fly()
print(isinstance(bird, Bird))  # True
print(issubclass(Magpie, Bird))  # True

bird = Crow()
bird.fly()
print(isinstance(bird, Bird))  # True
print(issubclass(Crow, Bird))  # True

Python 中不使用 private 等关键字来表示类中的私有方法或私有实例变量。Python 采用命名约定来表示私有方法或私有变量，如果方法名或实例变量名以单个下划线 _ 开始，则认为它是私有的。如果方法名或实例变量名以两个下划线 __ 开始，则它会被解释为另一个名称来防止和子类的方法或变量冲突，具体来说就是 __bar 会变为 _ClassName__bar 。

表 7 显示了单下划线和双下划线的区别。

下面以私有实例变量为例子介绍一下单个下划线和两个下划线的区别：

>>> class MyClass():
...     def __init__(self):
...         self._foo = "This is _foo"      # 实例变量以单下划线开始
...         self.__bar = "This is __bar"    # 实例变量以双下划线开始
...
>>> obj = MyClass()
>>> print(obj._foo)
This is _foo
>>> print(obj._MyClass__bar)
This is __bar
>>> print(obj.__bar)                        # 不能直接访问 __bar，要通过 obj._MyClass__bar 访问
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyClass' object has no attribute '__bar'

参考：https://peps.python.org/pep-0008/#method-names-and-instance-variables

导入时给模块换个名字，可以使用关键字 as 。

import div as foo
a,b = foo.divide(2305,29)

可以用 from 导入指定对象到当前名称空间，这样使用模块对象时就可以省略模块前缀了。

from div import divide
a,b = divide(2305,29)        # No longer need the div prefix

可以用星号(*)把一个模块中除下划线开头的所有内容导入到当前的名称空间中：

from div import *

不过，如果一个模块如果定义有列表 __all__ ，则 from module import * 语句只能导入 __all__ 列表中存在的对象。

# module: foo.py
__all__ = [ 'bar', 'spam' ]      # 定义使用 `*` 可以导入的对象

用 dir 可查看模块中的可用函数和变量。如：

$ python3 -q
>>> import string
>>> dir(string)
['ChainMap', 'Formatter', 'Template', '_TemplateMetaclass', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_re', '_string', 'ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'capwords', 'digits', 'hexdigits', 'octdigits', 'printable', 'punctuation', 'whitespace']

每个模块都拥有 __name__ 属性，它是一个内容为模块名字的字符串。 最顶层的模块名称是__main__。命令行或是交互模式下程序都运行在__main__模块内部。 利用__name__属性，我们可以让同一个程序在不同的场合（单独执行或被导入）具有不同的行为，像下面这样做：

# 检查是单独执行还是被导入
if __name__ == '__main__':
  # Yes
  statements
else:
  # No (可能被作为模块导入)
  statements

一个 Python 源文件就是一个 Python 模块。 如果 Python 源文件所在的目录中存在一个名为 __init__.py 的文件，则这个文件夹就称为包（Package），目录名就是包名。 文件 __init__.py 可以为空文件。

假设有下面目录结构：

sound/                          Top-level package
      __init__.py               Initialize the sound package
      formats/                  Subpackage for file format conversions
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  Subpackage for sound effects
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  Subpackage for filters
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...

当执行 import sound （这是导入包）时会加载文件 sound/__init__.py 。
当执行 import sound.effects （这是导入子包）时会加载文件 sound/__init__.py 和 sound/effects/__init__.py 。
当执行 import sound.effects.echo （这是导入模块）时会加载文件 sound/__init__.py 和 sound/effects/__init__.py 和 sound/effects/echo.py 。

表 8 是 Python 3 的内置函数。

参考：Python 3 Built-in Functions

optparse 模块已经过时，推荐使用 argparser 模块（它是在 Python 2.6 和 Python 3.2 中引入的）。

实例：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import logging

logging.basicConfig(
    format = "[%(filename)s:%(lineno)s:%(funcName)15s %(levelname)8s] %(message)s",
    level = logging.INFO
)
logger = logging.getLogger(__name__)


def fun1():
    # some things
    logger.critical("This is critical msg")
    logger.error("This is error msg")
    # some things


fun1()
logger.warning("This is warning msg")
logger.info("This is info msg")
logger.debug("This is debug msg")

struct 用于在 Python 与二进制数据结构之间转换数据。这些数据结构通常在与使用 C 编写的函数，二进制文件格式、网络协议进行交互时使用。

下面是用于打包和解包的两个基本函数：

struct.pack(fmt, v1, v2, ...)   # 根据fmt中的格式字符串，将值v1,v2等打包后返回
struct.unpack(fmt, buffer)      # 把buffer中的二进制数据按fmt指定的格式进行解包后返回

下面是 Python 中枚举的使用实例：

#!/usr/bin/env python3

from enum import Enum

class Color(Enum):                               # 创建枚举的方式 1
    RED = 0
    GREEN = 1
    BLUE = 2

# Color = Enum('Color', ['RED', 'GREEN', 'BLUE'])  # 创建枚举的方式 2

color = Color.RED

print(color.name)          # 每个枚举都有 name 属性
print(color.value)         # 每个枚举都有 value 属性

match color:               # python 3.10 引入了 match 语句
    case Color.RED:
        print("I see red!")
    case Color.GREEN:
        print("Grass is green")
    case Color.BLUE:
        print("I'm feeling the blues :(")

参考：https://docs.python.org/3/library/enum.html

有时，工程 1 中使用的包 A 依赖于包 B 的 1.0 版本；而工程 2 中使用的包 C 依赖于包 B 的 2.0 版本。而包 B 的 2.0 版本和 1.0 版本不兼容，我们无法在系统中同时安装这两个版本。这时，通过创建“虚拟环境”可以解决这个问题。

Python 3.3 中增加了内置模块 venv，可以用来创建“虚拟环境”，在这个环境中安装的包会保存在当前环境关联的目录中，而不是系统目录中。

venv 的基本用法如下：

$ python3 -m venv /path/to/new/virtual/environment        # 创建虚拟环境，需要指定新环境目录
$ ls /path/to/new/virtual/environment
bin/  include/  lib/  lib64@  pyvenv.cfg  share/
$ source /path/to/new/virtual/environment/bin/activate    # 进入虚拟环境

$ pip install xxx  # 进入虚拟环境后，安装的包都会放在的当前环境目录的子目录lib/pythonX.Y/中

$ deactivate                                              # 退出虚拟环境

注：virtualenv 是另一个流行的 Python 虚拟环境创建工具，它支持 Python 2 和 Python 3（前面介绍的 venv 只支持 Python 3）。

参考：
https://virtualenv.pypa.io/en/latest/
https://docs.python.org/3/library/venv.html

$ pip install PackageName

$ pip uninstall PackageName

$ pip list
cycler (0.10.0)
functools32 (3.2.3.post2)
matplotlib (2.0.2)
numpy (1.13.0)
pip (9.0.1)
pyparsing (2.2.0)
python-dateutil (2.6.0)
pytz (2017.2)
setuptools (18.7.1)
six (1.10.0)
subprocess32 (3.2.7)
vboxapi (1.0)
wheel (0.26.0)

$ pip show numpy
Name: numpy
Version: 1.13.0
Summary: NumPy: array processing for numbers, strings, records, and objects.
Home-page: http://www.numpy.org
Author: NumPy Developers
Author-email: numpy-discussion@python.org
License: BSD
Location: /usr/local/lib/python2.7/site-packages
Requires:

$ pip search json |more
json-rpc-3 (1.8.4)                                         - Pure Python 3 JSON-RPC 2.0 transport realisation
PyWaPa-3k (0.1.1)                                          - Python WhAtever Parser is a python markup converter from xml, json, yaml and ini to python dictionary. It allows also conversion between markup languages. Python 3 compatible version.
django-json-404-middleware (0.0.1)                         - Django middleware that returns 404s as JSON instead of html
......

Python Package Index 上有很多 python 模块。推荐使用工具 pip 来在线安装 python 模块。

下面介绍的是手动安装模块的典型过程。

从 Python Package Index 中下载想要安装的模块，假设文件名为 foo-1.0.tar.gz，解压后里面会有个 setup.py 文件，执行它可进行安装。比如：

$ gunzip -c foo-1.0.tar.gz | tar xf -    # unpacks into directory foo-1.0
$ cd foo-1.0
$ python setup.py install --prefix=/Users/cig01/soft/ # 安装到系统目录中不用指定 --prefix 参数

如果想要查看帮助信息，可以执行 python setup.py --help 。如：

$ python setup.py --help
Common commands: (see '--help-commands' for more)

  setup.py build      will build the package underneath 'build/'
  setup.py install    will install the package

Global options:
  --verbose (-v)      run verbosely (default)
  --quiet (-q)        run quietly (turns verbosity off)
  --dry-run (-n)      don't actually do anything
  --help (-h)         show detailed help message
  --no-user-cfg       ignore pydistutils.cfg in your home directory
  --command-packages  list of packages that provide distutils commands

Information display options (just display information, ignore any commands)
  --help-commands     list all available commands
  --name              print package name
  --version (-V)      print package version
  --fullname          print <package name>-<version>
  --author            print the author's name
  --author-email      print the author's email address
  --maintainer        print the maintainer's name
  --maintainer-email  print the maintainer's email address
  --contact           print the maintainer's name if known, else the author's
  --contact-email     print the maintainer's email address if known, else the
                      author's
  --url               print the URL for this package
  --license           print the license of the package
  --licence           alias for --license
  --description       print the package description
  --long-description  print the long package description
  --platforms         print the list of platforms
  --classifiers       print the list of classifiers
  --keywords          print the list of keywords
  --provides          print the list of packages/modules provided
  --requires          print the list of packages/modules required
  --obsoletes         print the list of packages/modules made obsolete

usage: setup.py [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...]
   or: setup.py --help [cmd1 cmd2 ...]
   or: setup.py --help-commands
   or: setup.py cmd --help

参考：
Installing Python Modules (Legacy version): https://docs.python.org/2/install/

如何列出本地安装的所有 python 模块？
方法一，在 python 提示符中输入： help('modules') ，如：

>>> help('modules')

Please wait a moment while I gather a list of all available modules...

BaseHTTPServer      audioop             httplib             sched
Bastion             base64              ihooks              select
CGIHTTPServer       bdb                 imaplib             sets
ConfigParser        binascii            imghdr              sgmllib
Cookie              binhex              imp                 sha
DocXMLRPCServer     bisect              importlib           shelve
HTMLParser          bsddb               imputil             shlex
IN                  bz2                 inspect             shutil
MimeWriter          cPickle             io                  signal
PyQt4               cProfile            itertools           sip
Queue               cStringIO           json                sipconfig
SimpleHTTPServer    calendar            keyword             sipdistutils
SimpleXMLRPCServer  cgi                 lib2to3             site
SocketServer        cgitb               linecache           smtpd
StringIO            chunk               locale              smtplib
UserDict            cmath               logging             sndhdr
UserList            cmd                 macpath             socket
UserString          code                macurl2path         sqlite3
_LWPCookieJar       codecs              mailbox             sre
_MozillaCookieJar   codeop              mailcap             sre_compile
__builtin__         collections         markupbase          sre_constants
__future__          colorsys            marshal             sre_parse
_abcoll             commands            math                ssl
_ast                compileall          md5                 stat
_bisect             compiler            mhlib               statvfs
_bsddb              contextlib          mimetools           string
_codecs             cookielib           mimetypes           stringold
_codecs_cn          copy                mimify              stringprep
_codecs_hk          copy_reg            mmap                strop
_codecs_iso2022     crypt               modulefinder        struct
_codecs_jp          csv                 multifile           subprocess
_codecs_kr          ctypes              multiprocessing     sunau
_codecs_tw          curses              mutex               sunaudio
_collections        datetime            netrc               symbol
_csv                dbhash              new                 symtable
_ctypes             dbm                 nntplib             sys
_ctypes_test        dbus                ntpath              sysconfig
_curses             decimal             nturl2path          syslog
_curses_panel       difflib             numbers             tabnanny
_dbus_bindings      dircache            opcode              tarfile
_dbus_glib_bindings dis                 operator            telnetlib
_elementtree        distutils           optparse            tempfile
_functools          doctest             os                  termios
_hashlib            dsextras            os2emxpath          textwrap
_heapq              dumbdbm             parser              this
_hotshot            dummy_thread        pdb                 thread
_io                 dummy_threading     pickle              threading
_json               email               pickletools         time
_locale             encodings           pipes               timeit
_lsprof             errno               pkgutil             toaiff
_multibytecodec     exceptions          platform            token
_multiprocessing    fcntl               plistlib            tokenize
_osx_support        filecmp             popen2              trace
_pyio               fileinput           poplib              traceback
_random             fnmatch             posix               tty
_socket             formatter           posixfile           types
_sqlite3            fpformat            posixpath           unicodedata
_sre                fractions           pprint              unittest
_ssl                ftplib              profile             urllib
_strptime           functools           pstats              urllib2
_struct             future_builtins     pty                 urlparse
_symtable           gc                  pwd                 user
_sysconfigdata      gdbm                py_compile          uu
_testcapi           genericpath         pyclbr              uuid
_threading_local    getopt              pydoc               warnings
_warnings           getpass             pydoc_data          wave
_weakref            gettext             pyexpat             weakref
_weakrefset         gio                 pygtk               webbrowser
abc                 glib                quopri              whichdb
aifc                glob                random              wsgiref
antigravity         gobject             re                  xdrlib
anydbm              grp                 readline            xml
argparse            gzip                repr                xmllib
array               hashlib             resource            xmlrpclib
ast                 heapq               rexec               xxsubtype
asynchat            hmac                rfc822              zipfile
asyncore            hotshot             rlcompleter         zipimport
atexit              htmlentitydefs      robotparser         zlib
audiodev            htmllib             runpy

Enter any module name to get more help.  Or, type "modules spam" to search
for modules whose descriptions contain the word "spam".

方法二，在 shell 提示符中输入： pydoc modules 。

参考：
http://stackoverflow.com/questions/739993/how-can-i-get-a-list-of-locally-installed-python-modules

用命令 python -c 'import modulename' 可以检测系统中是否安装有指定模块，如果正确安装了模块 modulename，那么这个命令不会有任何输出；否则会提示错误信息，如：

$ python -c 'import pycurl'             # 当前系统中没有模块pycurl，会提示类似下面的错误
Traceback (most recent call last):
  File "<string>", line 1, in <module>
ImportError: No module named pycurl

用命令 python -c 'import modulename; print(modulename.__file__)' 可以进一步查看模块在系统中的所在路径。如：

$ python -c 'import zlib; print(zlib.__file__)'             # 检测 zlib 所在路径
/usr/lib64/python2.6/lib-dynload/zlibmodule.so
$ python -c 'import json.tool; print(json.tool.__file__)'   # 检测 json.tool 所在路径
/usr/lib64/python2.6/json/tool.pyc

下面命令可实现一个 HTTP 服务，把当前目录设为 HTTP 的根目录，可以通过 http://localhost:8000 访问。

$ python -m SimpleHTTPServer          # Python 2，默认端口8000
$ python -m SimpleHTTPServer [port]   # Python 2，指定端口

如果你使用 Python 3，上面命令会报错，你可以执行：

$ python -m http.server               # Python 3，默认端口8000
$ python -m http.server [port]        # Python 3，指定端口

Writing code that runs under both Python2 and 3: https://wiki.python.org/moin/PortingToPy3k/BilingualQuickRef
Python 3 和 Python 2 有很多不兼容的地方，请参考： The key differences between Python 2.7.x and Python 3.x with examples
编写和 Python 3 和 Python 2 都兼容的代码，请参考： Cheat Sheet: Writing Python 2-3 compatible code