[基础部分]
Python 是一种解释型的、面向对象的、带有动态语义的高级程序设计语言。输出方式：print “Hello world”
空值是Python里一个特殊的值，用None表示。
关于除法运算：默认只取整数部分的结果：1/2=0.要得到小数：1.0/2 或者 1.0/2.0
幂（乘方）运算：2 ** 4 = 16 表示 2的4次方。
关于长整型数：普通整数不能大于 2147483647也不能小于 -2147483648 ，否则要加L。虚数：用j或者J表示
变量名可以包括字母、数字、下划线，不能以数字开头（同PHP）。
print 语句 [Python3.0中 print是函数，要写print(42)而不是 print 42 ]：
获取用户输入: input(‘words’);
使用 import 导入模块，用“模块.函数”调用：
使用 “from 模块 import 函数”可以直接使用；也可以 foo=math.sqrt赋值，然后 foo(4)得到平方根。
将Python值 转换为 字符串 的三种方法：str 、 repr 、 反引号(``) 。
在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了。如果要表示多行字符串，可以用'''...''’表示。
以Unicode表示的字符串用u'...'表示，比如：print u’中文’，注意: 不加 u ，中文就不能正常显示。
自定义一个求绝对值的函数：def my_abs(x): if x >= 0: return x else: return -x
return None可以简写为return
从模块导入函数，可以使用：① import module ② from module import function ③ from module import *
还可以在语句末尾增加一个as子句： import math as foobar ; foobar.sqrt(4); ===> 结果是 2.0
也可以为函数提供别名： from math import sqrt as foobar ; foobar(4); ===> 结果是 2.0
一次性给多个变量赋值：x,y,z = 1,2,3
链式赋值，将同一个值赋给多个变量： x = y =somefunction()
如果希望执行普通的除法，在程序前面加上： from __future__ import division
使用 import 导入模块，用“模块.函数”调用： import math; math.floor(32.9);
使用 “from 模块 import 函数”可以直接使用：from math import floor; floor(32.9);
[数据类型]
Python中基本的数据结构是“序列”。序列分为6种，最主要的两种类型是“列表”和“元组”,其他的序列：字符串、Unicode字符串、buffer对象、xrange对象。
几乎所有的情况下，列表都可以替代元组；除了 在使用元组作为字典的键，此时因为键不可修改，所以不能使用列表。
对序列的操作:索引（indexing）、分片（sliceing）、加（adding）、乘（multiplying）、计算长度、找出最大元素和最小元素、迭代（对序列中的每个元素重复执行某些操作）。
(1)索引:可以通过索引获取元素。-1表示从右边取值。
(2)分片:获取一定范围内的序列（或者字符串），用冒号(:) 分割start和end的范围，例如 tag[1:6]
(3)分片:更大的步长。例如：每隔2取一个数；每隔3取一个数。
(4)序列相加（连接）:必须是相同类型的序列才能连接在一起，用 + 符号连接。
(5)序列的乘法，用 * 符号连接：
(6)检查一个值是否在序列中用in ，返回布尔。
(7)序列的：长度 len()、最小值min()、最大值max()。
列表：
list是一种有序的集合，可以随时添加和删除其中的元素。用[]把list的所有元素都括起来，就是一个list对象。
x = ['Adam', 'Lisa', 'Bart’] 正序打印 L[0]，倒序打印 L[-1]
列表方法这样调用： 对象.方法(参数)
count()方法 统计某个元素在列表中出现的次数： x.count(y)
index()方法 从列表中找出某个值第一个匹配项的索引位置: x.index('value')
append()方法 把新的元素添加到 list 的尾部 x.append(y)
insert()方法 把新元素添加到 list 的指定位置 x.insert(1,'xyz')
pop()方法 删除最后一个元素 x.pop()，删除指定位置的元素 x.pop(1)
remove()方法 移除列表中某个值的第一个匹配项 x.remove('value')
reverse()方法 将列表中的元素翻转 x.reverse()
sort()方法 对列表排序 x.sort()
高级排序compare(x,y): x<y返回负数，x>y返回正数，x=y返回0。
元组：
tuple是不可变的集合：
t = ('Adam', 'Lisa', 'Bart')
空tuple：t = ()，单元素tuple,直接使用t = (1)，会输出 1；
Python 规定，单元素 tuple 要多加一个逗号”,"：t = (1,)
基本的元组操作：除了创建和访问之外，没有其他太多操作。
字符串：
都是不可变的。字符串格式化的操作符（%）
例如：格式化浮点数，使用如下方式： %.3f
字符串方法：
(1) find方法：在一个较长的字符串中查找子字符串，返回子串所在位置的最左端索引，若没找到则返回-1.
x.find(‘y’, start, end) 表示在start和end之间查找。
(2) join 方法：在队列中添加元素，需要添加的队列元素都必须是字符串。
(3) split方法：分割字符串，和join相反。
(4) lower方法：将字符串转换为小写
(5) replace方法：替换字符串
(6) strip方法：去除两侧的空格。
映射：
通过键引用值的数据结构，字典是Python中唯一内建的映射类型。
个人理解：Python中的“字典”就像是PHP中的“数组”，或者“json”，就是一个一个的键值对。
创建字典
phonebook = {'zhang':'111', 'wang':'222', 'zhao':'333'}
也可以用用dict函数建立字典：
item = [('name','rx'),('age',27)]
d = dict(item)
字典的操作，与“序列”很类似：
(1)字典的键不一定是整数类型，可以是任何不可变的类型（比如：浮点型、字符串、元组）
(2)字典可以自动添加（类似PHP的数组）
(3)表达式 k in d(d为字典)查找的是键 而不是值，表达式 v in l(l为列表) 查找的是值 而不是索引。
字典方法:
(1)clear方法：清除字典中所有的项，无返回值。
(2)copy方法：返回一个具有相同 key-value 的新字典。
(3)fromkeys方法：使用给定的key建立新的字典，每个key默认对应的value为None。
(4)get方法：一般情况下，访问字典中不存在的项时会出错，但使用get就不会：
(5)has_key方法：检查字典中是否包含给出的key，返回布尔。表达式 d.has_key(k) 相当于 k in d.
(6)items 和 iteritems：将所有的字典项以列表方式返回，但返回时没有特殊的顺序。
(7)keys 和 iterkeys：keys方法将字典中的键以列表的形式返回，iteritems方法返回针对键的迭代器。
(8)pop方法：获得对应于给定键的值，然后将这个key-value从字典中移除。
(9)popitem方法：弹出列表中的随机的项。
(10)setdefault方法：类似get方法。能够获得与给定键相关联的值，还能在字典中不含有给定键的情况下设定相应的键值。
(11)update方法：利用一个字典项更新另外一个字典。提供的字典中的项会被添加到旧的字典中，若有相同的键则会进行覆盖。
(12)values 和 itervalues：以列表的形式返回字典中的值（itervalues返回值的迭代器）。与返回键的列表不同的是，返回值的列表中可以包含重复的元素。
[条件判断和循环]
Python中，用冒号(:) 标识语句块的开始，块中的每一个语句都是缩进的，当回退到和已经闭合的块一样的缩进量时，表示当前块结束。
下列值在布尔类型中都表示false：False、None、0、""、()、[]、{} ，其他的则为true。
使用bool函数可以将其他类型转换为布尔：bool('hello') --> True
if ... else ... elif 语句
x is y : 判断x和y是否是同一个对象，注意和 == 对比：
使用 == 判定两个对象是否相等，使用is判定两个对象是否等同（是否是同一个对象）。
in成员资格运算符：
if 'x' in 'xyz':
print True
else:
print False
且/或/非： and/or/not
三元运算符： a if b else c :如果b为真则返回a，否则返回c。
while循环：
判断用户是否输入了名字：
while not name or name.isspace()
for循环
说明：如果能使用for循环，则尽量不要使用while循环。
words = ['a','b','c','d']
for x in words:
print x
range的使用（类似于分片）：
range(0.3) --> [0,1,2]
循环遍历字典元素:
d = {'x':1,'y':2,'z':3}
for key in d:
print key,'--->',d[key]
跳出循环:break 和 continue
另外三个语句：pass、 del、 exec
(1)Python中空代码块是非法的，所以需要在语句块中加上pass：
(2)del语句：移除对象。
(3)exec：执行一个字符串。
(4)eval：用于“求值”—— 会计算Python表达式并且返回结果值。
[抽象]
内建的callable函数可以判断函数是否可调用
定义函数：def语句，可以设置默认值，可以没有return：
def test(name='default',age=20):
return 'Hello' + name + age
print test('renxing',29)
函数的参数中定义元组，需要加*号：
def test(title,*params):
print title
print params
test('hello:','a','b','c')
函数的参数中定义字典，加**号：
def test(**params):
print params
test(x=1,y=2,z=3)
结果：{'y': 2, 'x': 1, 'z': 3}
作用域——内建的vars函数
函数内的变量称为局部变量，全局变量用global表示。
函数可以嵌套：
def foo():
def bar():
print “Hello_world”
常用函数整理：
pow(num) 乘方
abs(num) 绝对值
round(num) 四舍五入
help() 提供交互式帮助
input(prompt) 获取用户输入
raw_input(prompt) 获取用户输入，返回的类型是 字符串
repr(object) 返回值的字符串表示形式
str(object) 将值转换为字符串
[类和对象]
面向对象的三大特性：继承、封装、多态。
创建类:
class Person:
def setName(self,name):
self.name = name
def getName(self):
return self.name
调用：
foo = Person()
foo.setName('renxing')
print foo.getName()
Python并不直接支持私有方式，为了让方法或者特性变为私有（从外部无法访问），只要在函数名前面加上双下划线即可：
class Person:
def __getName():
print 'private function'
如果要查看一个类是否是另一个类的子类，使用内建的 issubclass 函数
如果想要知道已知类的基类，可以使用它的特殊特性： __bases__
同样，还能使用 isinstance 方法检查一个对象是否是一个类的实例
如果只想知道一个对象属于哪个类，可以使用 __class__ 特性
__bases__ 复数形式说明了 它的基类可能会多于一个，称为：多重继承。
接口和内省：
让对象符合当前的接口，也就是实现当前的方法
与 getattr 相对应的函数是： setattr，用来设置对象的特性
如果要查看对象内所有存储的值，可以使用 __dict__ 特性。
魔术方法： __future__ 、__init__ 、 __iter__
构造方法： __init__
析构方法： __del__
序列和映射 是对象的集合。如果对象是不可变的，那么需要使用两个魔法方法，如果是可变的则需要使用4个。
__len__(self): 返回集合中所含项目的数量。
__getitem__(self,key): 返回与所给键对应的值。
__setitem__(self,key,value): 按一定的方式存储和key相关的value（只能为可以修改的对象定义这个方法）。
__delitem__(self,key): 此方法在对一部分对象使用del语句时被调用，同时必须删除和元素相关的键。
当子类化一个内建类型（如list）的时候，就会间接地将object子类化，就会自动成为新式类，可以使用像super函数这样的特性了。
访问器方法——能够使用getHeight、setHeight这样的名字重绑定一些特性。
property 函数
静态方法： @staticmethod ；类成员方法： @classmethod
迭代器 __iter__，
具有next方法，不需要任何参数。
(1) 一个实现了 __iter__ 方法饿的对象是可迭代的，一个实现了next方法的对象是迭代器。
(2) 内建函数 iter 可以从可迭代的对象中获得迭代器。
(3) 使用list构造方法可以显式地将迭代器转化为列表
生成器是一种用普通的函数语法定义的迭代器。生成器是一个包含yield关键字的函数。
包 ：
基本上就是另外一类模块，而且能包含其他模块。当模块存储在文件中时（扩展名.py），包 就是模块所在的目录。 __init__py文件。
例如有个名为 constants的包，文件 constant/__init__.py包括语句 PI=3.14,那么可以：
import constants;
print constants.PI;
__all__ 变量：
help() 函数：例如 help(copy);
标准库: sys 模块能够访问与Python解释器联系紧密的变量和函数。使用方法：sys.argv;sys.exit;
os模块提供了访问多个操作系统服务的功能。os和它的子模块os.path还包括一些用于检查、构造、删除目录和文件的函数。
fileinput 模块——能够遍历文本文件的所有行。
[集合]
使用set创建集合：
set(range(5)) --> set([0,1,2,3,4])
集合元素是无顺序的：
set(['a','b','c']) --> set(['c','a','b'])
计算两个集合的并集，使用union方法，或者 | 运算符。
[堆]
堆 是“优先队列”的一种，使用优先队列能够以任意顺序增加对象，并且能在任何时间找到最小的元素。
Python中只有一个包含一些堆操作函数 的模块，叫做 heapq，包含6个函数。
（1）heappush 函数 用于增加堆的项，只能用于通过各种堆函数建立的列表中。
（2）heappop 函数 弹出最小的元素。
（3）heapify 函数 使用任意列表作为参数，并且通过尽可能少的移位操作，将其转换为合法的堆。
（4）heapreplace 函数 弹出堆的最小元素，并且将新元素推入，这样比 调用heappop之后再调用heappush更高效。
[双端队列] deque
双端队列——在需要按照元素增加的顺序来移除元素时非常有用。
双端队列通过可迭代对象（比如集合）创建。
[time]
time 模块所包含的函数能够实现以下功能：
获得当前时间、操作时间和日期、从字符串读取时间以及格式化时间为字符串。
time.asctime() 将当前时间格式化为字符串
[random]
random模块包括返回随机数的函数。
[shelve]
shelve是一额简单的数据存储方案，他只有一个函数就是open()，
这个函数接收一个参数就是文件名，然后返回一个shelf对象，
你可以用他来存储东西，就可以简单的把他当作一个字典，
当你存储完毕的时候，就调用close函数来关闭。
【文件和素材】
打开文件用open函数，参数'rb'可以用来读取一个二进制文件。
使用f.write(string) 追加写入，使用 f.read() 读取，使用f.close() 关闭文件。
f.readlines() 读取一个文件的所有行，f.readline() 读取一行。
按行操作——在while循环中使用readline。
用readlines 迭代行：
使用 fileinput 实现懒惰行迭代：
可以对文件迭代器执行和普通迭代器相同的操作。比如将它们转换为字符串列表，使用 list(open(filename)); 这样和使用readlines 效果一样。
【图形用户界面 GUI 】
最成熟的跨平台Python GUI工具包—— wxPython
【安装MySQL-python】
要想使python可以操作mysql 就需要MySQL-python驱动，它是python 操作mysql必不可少的模块。
检查MySQLdb 模块是否可以正常导入：import MySQLdb
python 操作mysql数据库基础：
#coding=utf-8
import MySQLdb
#Connect() 方法用于创建数据库的连接，里面可以指定参数：用户名，密码，主机等信息。
#这只是连接到了数据库，要想操作数据库需要创建游标。
conn= MySQLdb.connect(
host='localhost',
port = 3306,
user='root',
passwd='',
db ='rxpython',
)
#通过获取到的数据库连接conn下的cursor()方法来创建游标。
#通过游标cur 操作execute()方法可以写入纯sql语句。
#通过execute()方法中写如sql语句来对数据进行操作。
cur = conn.cursor()
#创建数据表
cur.execute("create table student(id int ,name varchar(20),class varchar(30),age varchar(10))")
#插入一条数据
cur.execute("insert into student values('2','Tom','3 year 2 class','9')")
#修改查询条件的数据
cur.execute("update student set class='3 year 1 class' where name = 'Tom'")
#删除查询条件的数据
cur.execute("delete from student where age='9'")
#关闭游标
cur.close()
#提交事务
conn.commit()
#关闭数据库连接
conn.close()
一次性向数据表中插入多条值：
executemany() 方法可以一次插入多条值，执行单条sql语句,但是重复执行参数列表里的参数,返回值为受影响的行数。
sqli = "insert into student values(%s,%s,%s,%s)"
cur.executemany(sqli,[
('11','zhang','aaaaa','1001'),
('12','wang','bbbbb','1002'),
('13','li','ccccc','1003'),
('14','zhao','ddddd','1004'),
])
查询语句：
（1）aa=cur.execute("select * from student"); print aa;
----> 获得的只是表中有多少条数据。
（2）fetchone() 方法可以获得表中的数据，可是每执行一次，游标会从表中的第一条数据移动到下一条数据的位置。
scroll(0,'absolute') 方法可以将游标定位到表中的第一条数据。
（3）获得表中的多条数据并打印出来，使用 fetchmany()
