Tutorial
1. Python可以带命令行启动，具体查看文档
2. 注释使用#，
指定文件编码使用：# coding[=:]\s*([-\w.]+)
3. 可以设置python启动脚本，详见tutorial 2.2.4,2.2.5
4. 在交互模式下，上次计算的结果被保存在变量[_]中
5. 字符串(字符串是不可变的)
5.1 'a' * d # 表示将'a'重复五次，即得到'aaaaa'
5.2 使用Slice indices得到子串：str[0:2]，str[:2], str[2:]
str[-1] # The last character
str[-2] # The last-but-one character
str[-2:] # The last two characters
str[:-2] # Everything except the last two characters
5.3 求长度:使用len(str`)
6. Unicode
literal: 使用前缀u，如：u'hello world'，
也可以再字符串中使用Unicode转换符：\u
6.1 str()可以将Unicode转换为ANSI，但是它只可以转换ANSII字符，即0-127
6.2 unicode()可将ansi字符转换为unicode，它也只可以转换ANSII字符
6.3 str = u'你好'.encode('utf-8')
unicode(str, 'utf-8')
7. Lists
l1 = [1, 2, 3]
l2 = l1
l2[0] = 0 # l1[0] == 0 too，即l2 = l1是传引用
7.1 浅拷贝 可使用slice indices：l2 = l1[:]
7.2 使用slice indices改变list
a = [1, 2, 3, 4]
a[0:2] = [5, 6] # replace, a == [5, 6, 3, 4]
a[0:2] = [] # remove, a == [3, 4], 等价于 del a[0:2]
a[1:1] = [5, 6] # insert, a == [3, 5, 6, 4]
a[:0] = a # insert, 在头部插入a 自身
a[len(a):] = a # insert, 在末尾插入a自身，等价于a.extend(a)
a[:] = [] # clear the list, 等价于 del a[:]。若del a, 则删除了a, 此后a不可用
7.3 成员方法
a.append(x) # equivalent to a[len(a):] = [x]
a.extend(L) # equivalent to a[len(a):] = L ,L是list类型
a.insert(i, x) # 在i之前插入x
a.remove(x) # remove the first item whose value is x
a.pop([i]) # remove 索引i处的元素，若没有指定i，则移除最后一个元素。返回被移除的元素。
a.index(x) # 返回list中第一个x的索引
a.count(x) # 返回list中x的个数
a.sort() # 排序
a.reverse() # 颠倒list中的元素
7.4 模拟stack 和 queues
使用append和pop模拟stack
对于队列，
from collections import deque
queue = deque(['one', 'two'])
queue.append('three') # insert end
queue.popleft() # remove first
7.5 build in functions (filter, map, reduce)
filter(function, sequence) # returns a sequence ，包含所有function(item) == True的元素
如果sequence的类型是string 或 tuple，则返回类型不变，否则，返回list
map(func, sequence) # 为sequence的每个item调用func(item)，返回 list of return values。
def cube(x):return x*x*x
map(cube, range(3)) # [0, 1, 8]
可以向map中传递多个sequence
def add(x, y): return x + y
map(add, range(3), range(3)) # [0, 2, 4]
reduce(func, sequence) # 对sequence中的所有元素进行运算
def add(x, y):return x + y
reduce(add, range(3)) # 3
7.6 list comprehensions 链表推导，一种简洁的方式创建链表
squares = [x**2 for x in range(3)] # [0, 1, 4]，等价于map(lambda x:x**2, range(3))
squares = [x for x in range(3) if x > 1] # [2]
squares = [(x, y) for x in range(2) for y in range(2)] # [(0, 0), (0, 1), (1, 0), (1, 1)]
Nested List Comprehensions
8. 循环
8.1 while, while循环无所不能
8.2 for, python中的for语法，for i in list:
8.3 使用range()，
range(3) # 连续的序列 [0, 1, 2]
range(3, 6) # 指定序列开头和结尾 [3, 4, 5]
range(0, 10, 3) # 指定步长 [0, 3, 6, 9]
9. pass 语句
while True:
pass # 空语句
class MyEmptyClass:
pass # 用作占位符，因为类和方法必须有实现
10. 定义函数
def funcname(params):
"doc string" # 可选
# do you work
10.1 默认参数的副作用
def f(a, L=[]): # L的默认参数是可变类型，会被随后的调用共享
L.append(a)
return L
print f(1) # [1]
print f(2) # [1, 2]
print f(3) # [1, 2, 3]
若不想使之共享，可以这样修改：
def f(a, L=None):
if L is None:
L = []
L.append(a)
return L
10.2 Keyword Arguments
函数的参数可以将之视为一个字典，在进行函数调用时，可以指定想要传递的参数。
def func(one, two='two', three = 'three'):
print one, two, three
func('one') # one two three
func('three', three='one') # three two one
func(two = 'one', one = 'two') # two one three
10.3 将tuple,dictionary作为参数
若名字格式为 *name， 则name接受一个tuple，
若名字格式为 **name, 则name接受一个dictionary
def func(*name):
for arg in name:
print arg,
func('hello', ', ', 'world') # hello, world
def func(**name):
for key in name.keys():
print key, name[key]
func(one='hello', two='world')
# two world
# one hello
10.4 Unpacking Argument List
range(3, 6) # [3, 4, 5]
args = [3, 6]
range(*args) # 参数从list中获取，[3, 4, 5]
def func(one, two='two', three = 'three'):
print one, two, three
d = {'one':'two', 'two':'three', 'three':'one'}
func(**d) # two three one
11. Tuples元组
建立空tuple：t = ()
建立一个元素的tuple: t = (1, ) # 1后面的逗号是必需的
Tuple packing : t = 1, 2, 3 # 等价于t = (1, 2, 3)
Tuple unpacking : x, y, z = t # 为x, y, z赋值
12. Set 集合
Set是无序的容器，其中不能包含重复的元素。
它可以进行 求并集，交集，差集，对称差集
12.1 创建Set
可以从其他集合中创建set，如list, str等
nums = [1, 2, 1, 2]
sn = set(nums) # set([1, 2])
a = set('banana') # set(['a', 'b', 'n'])
b = set('apple') # set(['a', 'p', 'e', 'l'])
a | b # union, set(['a', 'p', 'b', 'e', 'l', 'n'])
a & b # intersection, set(['a'])
a ^ b # symmetric difference, set(['b', 'e', 'l', 'n', 'p'])
13. Dicdionarys 字典
字典中保存的是 key:value对，以花括号包围之，如:
d = {1:'1', 2='2', 3:'3'}
d.keys() # 返回key列表，[1, 2, 3]
d.values() # 返回value列表，['1', '2', '3']
1 in d # 判断 1 是否是d的一个key，True
del d[1] # 删除 key 为1的项
13.1 使用dict()构造器
d = dict([('ome', '1'), ('two', '2'), ('three', '3')]) # {'one':'1', 'two':'2', 'three':'3'}
如果key都是字符串的话，也可以这样构建：
d = dict(one = '1', two = '2', three = '3') # {'one':'1', 'two':'2', 'three':'3'}
14. 循环技术
14.1 遍历字典时，同时获取key所对应的value
for k, v in dict.iteritems():
print k, v
14.2 enumerate(), 遍历序列时，同时获取index所对应的value
for i, v in enumerate(['one', 'two', 'three']):
print i, v
14.3 zip(), 同时遍历两个，或更多的序列
num = [1, 2, 3]
str = ['one', 'two', 'three']
for n, s in zip(num, str):
print n, s
上边代码的输出：
# 1 one
# 2 two
# 3 three
zip(num, str)的返回值为元组的列表：[(1, 'one'), (2, 'two'), (3, 'three')]
14.4 reversed(), 逆序遍历一个序列
for i in reversed(xrange(1, 10 , 2))
print i
14.5 sorted(), 按照排序后的顺序遍历一个序列
num = [3, 2, 1]
for i in sorted(num):
print i
15. Module 模块
一个模块就是一个包含python语句的文件，文件名为 模块名 + .py扩展名。
在文件中可以使用全局变量__name__获取模块名。
15.1 将模块作为一个脚本执行
在命令行中：python module_name.py
此时这个模块中的代码将会得到执行，并且，python会将此模块名__name__设置为 '__main__'
可以在模块中添加如下代码，使模块只在作为脚本时才得到执行：
if __name__ == '__main__'
import sys
# your code
15.2 module搜索路径
若一个名为hello的模块被引入，解释器首先会搜索内建模块，
如果没有找到，它会在若干目录中搜索hello.py, 这些目录名由sys.path指定。
sys.path从下面这些位置初始化：
1. .py所在目录
2. PYTHONPATH
3. 安装目录
15.3 package的概念，管理module名字空间
详见Tutorial 6.4
package实际上是一个文件夹，文件夹的名字即是包名；
但是，文件夹下需包含一个__init__.py文件，python才会将之视为一个package。