Python注释
Python的注释以#开头，后面的文字直到行尾都算注释
Python基本数据类型
整数、浮点数（浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的）、字符串（字符串是以''或""括起来的任意文本）、布尔值、
空值（空值是Python里一个特殊的值，用None表示）
print语句
print语句也可以跟上多个字符串，用逗号“,”隔开，就可以连成一串输出，遇到逗号“,”会输出一个空格；使用“+”拼接不会产生空格
print 'The quick brown fox', 'jumps over', 'the lazy dog'
print("I'm Python. Nice to meet you!") # Python 3.x的语句方式
Python之字符串
字符串通过 " 或 ' 括起来，用对字符串中的特殊字符进行转义；且字符串是不可变的；
其它值转换为字符串机制：repr函数和str函数；
多行字符串，可以用'''...'''表示：
'''Line 1
Line 2
Line 3'''
在字符串前面加个前缀 r ，表示这是一个raw字符串，表示里面的字符不需要转义。
在多行字符串前面添加 r ，把这个多行字符串也变成一个raw字符串；
r'...'表示包含'和 "的字符串时需注意匹配：
print r'Python is created by "Guido". Let's start learn Python in imooc!' # r'...' --里面r 的第一个 ' 和 Let' 的 ' 匹配了
print r'Python is created by "Guido".’ #不会报错
r'...'不能再结尾处输入反斜线“”
Unicode字符串:因为计算机只能处理数字，如果要处理文本，就必须先把文本转换为数字才能处理（字节编码表）。而早期的的Python只支持ASCII编码，Python在后来添加了对Unicode的支持，以Unicode表示的字符串用u'...'表示，比如：print u'中文'；
Python 3.x直接对Unicode进行支持，所有的字符串都是unicode字符串;
Unicode字符串除了多了一个 u 之外，与普通字符串没啥区别，转义字符、raw字符串和多行表示法仍然有效；
raw+多行：
ur'''Python的Unicode字符串支持"中文",
"日文",
"韩文"等多种语言'''
如果中文字符串在Python环境下遇到 UnicodeDecodeError，这是因为.py文件保存的格式有问题。可以在第一行添加注释 # -*- coding: utf-8 -*-；
目的是告诉Python解释器，用UTF-8编码读取源代码。注意点：当第一行添加了注释后，不能再在语法中使用 u,否则会报错；
字符串格式化：老式的格式化语法 %：可以用来格式化字符串，用指定的参数替代 %s，如程序需在Python2.5以下环境运行才建议使用；
转换说明符：%s %.3f
模板字符串：string模块的Template() 和 substitute()方法
推荐使用方法 format 方法来格式化字符串
Python中布尔类型
布尔类型运算： 与运算（and）：只有两个布尔值都为 True 时，计算结果才为 True。
或运算(or)：只要有一个布尔值为 True，计算结果就是 True。
非运算（not）：把True变为False，或者把False变为True。
布尔类型还可以与其他数据类型做 and、or和not运算，Python把0、空字符串''和None看成 False，其他数值和非空字符串都看成True;注：只是看成，没有进行转换
a = True
print a and 'a=T' or 'a=F' #=> a=T
and 和 or 运算的一条重要法则：短路计算
- 在计算
a and b时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b的值。 - 在计算
a or b时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b的值。
Python变量
变量是用一个变量名表示，变量名必须是大小写英文、数字和下划线（_）的组合，且不能用数字开头；
在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量；这种变量本身类型不固定的语言称之为动态语言；
示例 a = 123 # a是整数
a = 'imooc' # a变为字符
Python数据结构
序列（sequence）：最基本的数据结构，每个元素被自动分配一个序号(索引)；内建序列数据结构（列表、元组、字符串、Unicode字符串、buffer对象和xrange对象）；
映射（mapping）：通过名称来引用值得数据结构；内建数据结构（字典dict）；
集合（set）:
堆（heap）:是优先队列的一种，Python没有独立的堆类型，只有一个包含一些堆操作函数的模块headq(q是queue的缩写)；
双端队列（deque）:在需要按照元素增加的顺序来移除元素时非常有用。Python 2.4及以上新增在collections模块中；
Python列表：list
list是一种有序的集合(元素是按照顺序排列)，可以随时添加和删除其中的元素。
直接用 [ ] 把list的所有元素都括起来，就是一个list对象。
由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型，我们完全可以在list中包含各种数据：L = ['Michael', 100, True]
通过索引来获取list中的指定元素。如：L[0]
倒序索引: 我们可以用 -1 这个索引来表示最后一个元素：L[-1]
添加新的元素: 第一个办法是用 list 的 append() 方法，把新同学追加到 list 的末尾;
第二个方法是用list的 insert()方法，它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素；原来索引号及后面的值都自动向后移动一位。
删除元素：1. del语句--- del L[index]
2. pop()方法删掉list的最后一个元素，pop(index)方法删掉list中指定索引的元素，并且它还返回这个元素；
3.remove方法，移除列表中某个值的第一个匹配项,修改了列表无返回值
对list中的某一个索引赋值，就可以直接用新的元素替换掉原来的元素，list包含的元素个数保持不变。
生成表达式(conprehension expression)：把要生成的元素语法放到前面，后面跟for循环(变量的取值)，就可以把序列/集合创建出来；
[x * x for x in range(1, 11)] #=>[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
生成表达式的 for 循环后面还可以加上 if 判断,只有 if 判断为 True 的时候，才把循环的当前元素添加到列表中。
[x * x for x in range(1, 11) if x % 2 == 0] #=>[4, 16, 36, 64, 100]
可以用多层 for 循环来生成列表
[m + n for m in 'ABC' for n in '123'] #=>['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
L = []
for m in 'ABC':
for n in '123':
L.append(m + n)
M = [[1, 2, 3], # A 3X3 matrix, as nested lists
[4, 5, 6], # Code can span lines if bracketed
[7, 8, 9]]
G={sum(row) for row in M}
G={i:sum(M[i]) for i in range(3)}
Python元组：tuple
tuple是另一种有序的列表。tuple和list非常类似，但是，tuple一旦创建完毕，就不能修改。tuple没有 append()方法，也没有insert()和pop()方法。
创建tuple和创建list唯一不同之处是用( )替代了[ ]。
定义单元素的tuple: 单元素tuple要多加一个逗号“,”，避免歧义; //t = (1,)
在打印单元素tuple时，也自动添加了一个“,”，为了更明确地告诉你这是一个tuple。 //print t #=>(1,)
多元素 tuple 加不加这个额外的“,”效果是一样的：
t = (1, 2, 3,) print t #=>(1, 2, 3)
tuple所谓的“不变”是指“指向不变”，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的；
Python序列通用操作
切片（Slice）操作符：简化取指定索引范围的操作；语法 L[fromIndex : toIndex]
L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3（可以看做数学之中左闭右开区间）；<=> L[:3] 从零开始的索引可省略不写;
L[1:] :省略末尾,从1开始直到结束；
L[:]表示复制出了一个新list；
L[fromIndex : toIndex : N]:切片操作可以指定第三个参数，第三个参数表示每N个取一个 ,L[::2] 每两个元素取出一个;N不能为0；
步进为正，必须让开始索引小于结束索引；步进为负，必须让开始索引大于结束索引；------否则获取的是空列表；
支持倒序切片；如果使用倒序切片时，需要获取结束索引的值，只能通过省略末尾来获取；
list换成tuple，切片操作完全相同，只是切片的结果也变成了tuple。同样也适用于字符串（字符串可以被视为字符的列表），操作结果仍是字符串；
序列相加：使用加运算符可以进行序列的连接操作生成一个新的序列，并不会改变原始序列；注只有相同类型的序列才可以进行连接操作；
分片赋值:不能用于不可变的序列（元组，字符串，Unicode字符串）
#不等长序列替换
name=list('Perl')
name[1:]=list('ython')
numbers=[1,5]
#插入元素
numbers[1:1]=[2,3,4]
#删除元素
numbers[2:4]=[]
序列乘法：用数字N乘以一个序列会生成一个新的序列，新的序列中，原来的序列将被重复N次；
temp=[1,2]*4 #=>[1, 2, 1, 2, 1, 2, 1, 2]
temp=(2,3)*4 #=>(2,3,2,3,2,3,2,3)
成员资格：用 in 来返回元素是否在序列中；
长度 最大值 最小值 ：len(L) max(L) min(L)
Python字典：dict
花括号 {} 表示这是一个dict，然后按照 key: value, 写元素。最后一个 key: value 的逗号可以省略。使用 d[key] 的形式来查找对应的 value；
filled_dict = {"one": 1, "two": 2, "three": 3}
判断key是否存在：用 in 操作符; 'Paul' in filled_dict #=> false
使用dict本身提供的一个get 方法，在Key不存在的时候，返回None；
get 方法支持在不存在的时候返回一个默认值 ； filled_dict.get("four", 4) # => 4
dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。缺点是占用内存大，还会浪费很多内容；
dict的第二个特点就是存储的key-value序对是没有顺序的；key不能重复。不能用dict存储有序的集合。
dict的第三个特点是作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，不能作为 key。
用赋值语句可以往dict中添加新的 key-value或当 key 已经存在时直接更新value ; filled_dict["four"]=4
values() 方法实际上把一个 dict 转换成了包含 value 的list。 itervalues() 方法不会转换；
items() 方法把dict对象转换成了包含tuple的list；items() 也有一个对应的 iteritems()，iteritems() 不把dict转换成list；
setdefault 是一个更安全的添加字典元素的方法:
filled_dict.setdefault("five", 5) # filled_dict["five"] 的值为 5
filled_dict.setdefault("five", 6) # filled_dict["five"] 的值仍然是 5
Python集合：set
创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素：
some_set = set(); #空列表
some_set = set([1, 2, 2, 3, 4]) # some_set 现在是 set([1, 2, 3, 4])
set内部存储的元素是无序的。set不能包含重复的元素，会自动去掉重复的元素；
Python 2.7 之后，大括号可以用来表示集合 : filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4}
用in操作符判断一个元素是否在set中；10 in filled_set # => False
添加元素，用set的add()方法：如果添加的元素已经存在于set中，add()不会报错；
删除set中的元素，用set的remove()方法，如果元素不存在set中，remove()会报错；
Python之条件判断
if 语句后接表达式，然后用:表示代码块开始。
if ... else ... 语句，else 后面有个“:”
if ... 多个elif ... else ... 的结构，一次写完所有的规则；
if 语句可以作为表达式来使用
"yahoo!" if 3 > 2 else 2 # => "yahoo!"
Python之循环
for 循环就可以依次把list或tuple的每个元素迭代出来：
L = ['Adam', 'Lisa', 'Bart']
for name in L:
print name
在Python中，迭代是通过 for ... in 来完成的，迭代操作就是对于一个集合，无论该集合是有序还是无序，我们用 for 循环总是可以依次取出集合的每一个元素。
while 循环，while 循环不会迭代 list 或 tuple 的元素，而是根据表达式判断循环是否结束。
N = 10
x = 0
while x < N:
print x
x = x + 1
break语句：退出循环
continue：跳过后续循环代码，继续下一次循环。
pass: 什么也不做，相当于C#中的空语句“{ }”。
Python之函数
定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，在缩进块中编写函数体，函数的返回值用 return 语句返回。return None可以简写为return。
调用一个函数，需要知道函数的名称和参数，如果传入的参数数量不对，会报TypeError的错误;
如果传入的参数数量是对的，但参数类型不能被函数所接受，也会报TypeError的错误，并且给出错误信息;
函数返回多值：其实就是返回一个tuple，在语法上，返回一个tuple可以省略括号；
import math
def move(x, y, step, angle):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
r = move(100, 100, 60, math.pi / 6)
函数的默认参数的作用是简化调用，只需要把必须的参数传进去。在需要的时候，传入额外的参数来覆盖默认参数值。默认参数只能定义在必需参数的后面;
定义可变参数：让一个函数能接受任意个参数，可变参数的名字前面有个 * 号，我们可以传入0个、1个或多个参数给可变参数（这些参数是按照顺序排列）；
Python解释器会把传入的一组参数组装成一个tuple传递给可变参数；
def varargs(*args):
if args:
return args
else:
return 0.0
varargs(1, 2, 3) # => (1,2,3)
参数的分拆：当你要传递的参数已经是一个列表，但调用的函数却接受分开一个个的参数值
#使用* 操作符来自动把参数列表拆开:
args=[3,6]
x=list(range(*args)) # *args 将列表 args 拆分成3，6 两个参数
print x
#使用 ** 操作符自动进行参数字典的分拆:
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)
def keyword_args(**kwargs):
return kwargs
# 实际效果：
keyword_args(big="foot", loch="ness") # => {"big": "foot", "loch": "ness"}
关键字lambda表示匿名函数，冒号前面的x表示函数参数。
限制:只能有一个表达式，不写return，返回值就是该表达式的结果。
(lambda x: x > 2)(3) # => True
enumerate() 函数自动把每个元素变成 (index, element) 这样的tuple
L = ['Adam', 'Lisa', 'Bart', 'Paul']
enumerate(L) #=>[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]
内置高阶函数
#map接收一个函数f和一个list，并通过把函数f依次作用在list的每个元素上，得到一个新的list并返回
map(add_10, [1, 2, 3]) # => [11, 12, 13]
#reduce()函数接收一个函数f一个list，传入的函数f必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值
def f(x, y):
return x + y
reduce(f, [1, 3, 5, 7, 9]) # =>25 f(1, 3) -> f(f(1,3),5) >>>>
#reduce()还可以接收第3个可选参数，作为计算的初始值
reduce(f, [1, 3, 5, 7, 9], 100) #=>125
#接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list
filter(lambda x: x > 5, [3, 4, 5, 6, 7]) # => [6, 7]