python 学习笔记 (核心)
Python解释器从头到尾一行接一行执行脚本
# -*- coding: UTF-8 -*- //字符编码
不区分单引号和双引号，x=’hello’,x[0],x[-1]指最后一个字符，x[2:4]取子串，
‘’’hello’’’ #hello三引号会保留文本输入时的换行符制表符等不需要转义，用于多行原样输入保存
‘hello’+’world’ #字符串拼接，’hello’*2 #字符串重复
help(fun) #帮助，help(module.method)
print(1,2，sep=’,’) #输出常量、变量，也可以通过变量名直接查看变量
>> #重定向
int(9.9) #强制转换为int
+ - * /传统除法有小数 //用作浮点除法对结果进行四舍五入 %求余 **乘方，pow(x,y)#x^y
< <= > >= == != and or not 如：not 2<4，not优先级最高仅次于比较运算符
变量名：字符或下划线开头后接数字、字母、下划线，区分大小写
Python是动态语言：不需要预先声明变量的类型，变量的类型和值在赋值那一刻被初始化
y*=10;可以，但是y++不可以
int、long(比c语言的长整数大，int会自动扩充到long)、bool、float、complex
列表：x=[1,2,’3’] #可以用[1:3]取子列表2、3，元素可修改
元组：x=(1,2,’3’) #元组元素不可以修改，可以通过下标也可以访问子元组
字典：x={1:2,’3’:’4’},x.keys()#返回键，x.values()#值
if expression:
commands;
elif expression:
commands;
else:
commands;
if not expr1 and expr2:#not优先级比and高
while expression:#直至表达式为假
commands;
for i in range(3):#range(start=0,stop,step=1)#[start,stop),start和step要么都不出现要么同时出现
print(‘hello world’);
break可用于while和for中
continue
pass #标记的语句忽略
三元表达式：x if C else y #C?x:y
def fun_name([arguments]):#[]表示可选，函数通过引用传递即函数内对参数的改变会影响原始对象，没有return语句则自动返回None对象
commands;
class ClassName(base_class):
static_member_declarations;
__name;#定义私有变量
def __init__(...):#构造函数，在对象创建后执行的第一个方法用于初始化对象
创建对象：object=ClassName()#自动调用__init__()，每个对象都有一个计数器
import moudle后调用fun必须module.fun()
from module import * 后可直接调用fun()
模块：module_name.py,导入模块import module_name,访问模块属性和访问对象属性是一样的object.attribute即module_name.fun(),module_name.variable,如：import sys; sys.stdou.write(‘Hello World\n’)
if __name__==’__main__’:#当在命令行python module_name时脚本会自动执行，而在Python IDE下__name__为具体的模块名称不是__main__，直接执行就是__main__,被导入import就是模块名字
fun();
dir() #显示全局变量的名字，dir(x) #列出x的内建方法
cmp(x,y) # 若 x<y 返回 <0, 若 x>y 返回 >0,x==y 返回 0 ，自定义对象则会调用类的 __cmp__() 方法
repr(x) # 返回一个对象的字符串表示，可以还原对象 ,x==eval(repr(x)) 通常成立
str(x) # 返回对象适合可读性好的字符串表示
type(x) #返回对象的类型,type(x).__name__返回类型名称
isinstance(x,(int,long)) #第二个参数是元组，若x类型在元组中则返回true
id(x) # 返回对象的 id 可以认为是对象的内存地址，可以用于判断两个对象是否相同 is(a)==id(b)
x is y / x is not y # 测试两个变量是否执行同一个对象
del x #删除对象，实际是引用计数减1
\ #代码分行
y=x=1 #赋值
x,y,z=1,2,’z’ #(x,y.z)=(1,2,’z’), x,y=y,x#交换两变量值
下划线的特殊用法：可见尽量避免使用下划线作为变量名的开始
_xxx 不用从from module import *导入
__xxx__ 系统定义的名字
__xxx 类中私有成员
None #Nonetype 对象，不支持任何运算和内建方法，类似于 void ，它的 bool 为 false
所有标准对象均可用于布尔测试，同类型对象之间可以比较大小，空对象 ({}) 、值为零、 None 的 bool 值为 false
运算符优先级：内置函数如 cmp 比较运算符 对象比较 is/is not 逻辑比较 not/and/or
变量分类：
数字 标量 不可变 直接访问
字符串 标量 不可变 顺序访问
列表 容器 可变 顺序访问
元组 容器 不可变 顺序访问
字典 容器 可变 映射访问 key
数字：整型、长整形、布尔型、双精度浮点型、十进制浮点型、复数 x=complex(1,2);x.conjugate()# 共轭 ;x.real 实部 ;x.imag 虚部
1/2=0 地板除 ;1/2.0=0.5 浮点除法真正的除法
整数位运算： ~ 取反， & 按位与， | 或， ^ 异或， << 左移， >> 右移
数字类型函数： int(),long(),float(),complex(),bool(x) 即 x.__nozero__(),abs(),divmod() 返回商和余数的元组 ,pow(),round(x,num) 四舍五入 num 是小数位数，这里注意 int() 是直接截去小数部分， floor() 是返回最接近原数但小于的整数， round() 最接近原数可能大于原数的整数， coerce(x,y)# 将 x 和 y 转换为同一类型返回 (x,y) 的元组
oct(x) # 八进制， hex(x)# 十六进制
chr(97)#ASCII 字符， ord('a')#ASCII 码， unichr(num)# 将 unicode 值转为 unicode 字符
序列：下标从 0 开始至 -1
obj [not] in seq # 若对象 obj 在序列 seq 中返回 true
seq[index1:index2] # 取子序列，支持负索引
seq*num # 序列重复 num 次
seq1+seq2 # 连接两个序列
seq[::-1] # 翻转序列， seq[::2] # 隔一个取一个
enumerate(iter) # 以一个可迭代对象为参数，返回一个 enumerate 对象 ( 也是一个迭代器 ) ，该对象生成由 iter 每个元素的 index 值和 iter 值组成的元组
reversed(x) # 返回一个逆序访问的迭代器
sorted(iter,func=None,key=None,reverse=False) #iter 是可迭代对象，返回一个有序列表， key ：用列表元素的某个属性和函数进行作为关键字，有默认值，迭代集合中的一项 ;reverse ：排序规则. reverse = True 或者 reverse = False，有默认值 ;func ：用于比较的函数，比较什么由 key 决定 , 有默认值，迭代集合中的一项 ;
sum(x,init=0) # 以初值 init 求序列和
max(x),min(x)
zip(x) # 返回一个列表，列表元素是元组，元组的第一个元素的 x 的值， zip(x,y)# 构成元组
字符串是不可变的，即 x='hello world'; x[0]='H' 是错误的，可以变量赋值的方式更新字符串， x=x[:2]+x[3:]# 删除第一个 l
x=raw_input(“Input:”) # 输入
字符串内置函数：
str(3.14) # 数字转为字符 '3.14'
s.capitalize() # 把第一字符大写
s.center(width) # 将原始字符串置于宽度为 width 的中间
s.count(str,beg=0,end=len(s)) # 返回 str 在 s 出现的次数
s.encode(encoding='UTF-8',errors='strict') # 指定编码格式， s.decode 解码
s.endswith(obj,beg=0,end=len(s)) # 检查指定范围内的子串是否以 obj 结束
s.find(str,beg=0,end=len(s)) # 检测 str 是否包含在 s 中，返回开始的索引值否则返回 -1
s.index(str,beg=0,end=len(s)) # 同上 , 若不在则报一个异常
s.isalnum() #s 至少有一个字符并且所有字符都是字母或数字则返回 true
s.isalpha() # 至少一个字符且所有都是字母返回 true
s.isdecimal() # 只含有十进制数字返回 true
s.isdigit() # 只包含数字返回 true
s.islower() # 都是小写返回 true
s.isumeric() # 只包含数字字符返回 true
s.isspace() # 只包含空格返回 true
s.istitle() # 标题化的返回 true
s.isupper() # 全是大写返回 true
s.join(seq) #s='xyz';s.join('abc') 为 'axyzbxyzc'
s.ljust(width) # 左对齐
s.lower() # 小写
s.lstrip() # 截掉左边的空格
s.partition(str) # 当 s 中包含 str 时 s 被切分为元组 (pre,str,end), 若 str 不在 s 中 pre==s
s.replace(str1,str2,num=s.count(str1)) # 将 s 中的 str1 替换为 str2 不超过 num 次
s.rfind(str,beg=0,end=len(s)) # 类似于 find 但是从右边查找
s.rindex(str,beg=0,end=len(s)) # 类似于 index ，从右边开始
s.rpartition(str)
s.rstrip()
s.split(str=””,num=s.count(str))# 以 str 默认空格为分隔切分字符串， num 为分割次数
s.splitlines(num=s.count('\n')) # 返回一个包含各行作为元素的列表， num 指定元素个数
s.startswith(obj,beg=0,end=len(s)) # 检查 s 是否以 obj 开头
s.strip(obj) # 执行 lstrip 和 rstrip, 去掉左右两边的空格
s.swapcase()# 翻转大小写
s.title() # 标题化，所有单词开始都大写
s.translate(str,del='') # 根据 str 给出的表转换 s 的字符，需要过滤的字符放在 del 中
s.upper(0 # 该为大写
s.zfill(width) # 右对齐
列表 list ：可以包含任意个不同类型对象，如 x=[1,'2',['x',complex(1,1)]]
list(),tuple() # 强转
x.append('h') # 追加元素
del(x[3]) # 删除指定下标的元素， del x # 删除列表
x.remove('2') # 移除具体的元素
obj [not] in x # 检查一个对象是否在列表中
x+y # 列表连接，新建一个列表
x.extend(y) # 将 y 追加到 x 中
x*num # 列表重复 num 次
x.count(obj) # 统计 obj 在列表中出现的次数
x.index(obj,i=0,j=len(x)) # 在指定范围内查找等于 obj 的下标
x.insert(index,obj) # 指定下标 index 处插入 obj
x.pop(index=-1) # 删除并返回指定下标位置的对象
x.reverse() # 原地翻转列表
x.sort(func=None,key=None,revers=False) # 修改对象的方法是没有返回值的，字符串内置的 sort 有返回值是因为字符串不可修改
元组：不可变，连接可用，重复操作可用，元组内可变的元素还是可以变的。函数 return x,y,z; 返回的多对象就是以元组形式
浅拷贝：当对象赋值时是简单的对象引用 ( 增加计数 ) ， copy.cpoy()
深拷贝：完全拷贝， import copy; x=copy.deepcopy(y); 非容器类型没有拷贝一说，若元组只包含原子类型对象对它的深拷贝不会进行
字典： key 是不变的所以数字和字符串可以作为 key 且可 hash 的，但是列表、其它字典不可以，不支持拼接和重复操作
x=dict((['x',1],['y',2])) 或者 x={'x':1,'y':2}
for key in x.keys(): # 遍历字典
for key in x: # 遍历字典
x.has_key('x') # 检测是否有 'x'
'x' [not] in x # 检测是否有 'x'
del x['x'] # 删除 key 为 'x' 的条目， del x # 删除整个字典
x.clear() # 清空字典
x.pop('x') # 删除并返回 'x' 的值
x.copy() # 浅拷贝一个副本
x.fromkeys(seq,value=None) # 创建一个新字典 seq 是 key ， val 默认是 None
x.get(key,default=None) # 茶盏 key 的 value ，不存在则返回 default
x.items() # 返回字典中 (key,value) 的列表
x.iter() # 返回一个迭代子
x.pop(key,default) # 若 key 在则删除， key 不在且没有 default 则异常
x.setdefault(key,default=None) #x[key]=default
x.update(y) # 将字典 y 添加到 x 中
x.values()# 值列表
集合： set 、 frozenset 不可变集合，支持 [not] in,len(),for 迭代，不支持索引和切片 : 操作，没有 keys().set 是可变的所以是不可哈希的， frozenset 是不可变的故可哈希所以可以作为字典的 key 就或集合的成员
集合创建的唯一方法： x=set('123') # 可迭代作为参数，字符串可迭代， x=frozenset(range(3))
'1' in x # 检测元素，属于， not in 不属于
x.add('4') # 添加
x.update('345') # 添加
x.remove('1') # 删除元素
x.discard('3') # 删除元素
del x
x==y x!=y
x<y x<=y x 是否为 y 的真子集 / 子集
x>y x>=y x 是否为 y 的严格超集 / 超集
x|y # 并集， x.union(y)
x&y # 交集， x.intersection(y)
x-y # 差集，属于 x 不属于 y 的集合， x.difference(y)
x^y # 对称差分，不可能同时属于 x 或 y 的元素， x.symmetric_difference()
x|=y # 复合赋值
x.issubset(y) # 若 x 是 t 的子集返回 true
x.issuperset(y) # 若 y 是 x 的超集返回 true
x.copy() # 浅拷贝
i=iter(x) # 得到迭代器， i.next()# 访问迭代器
列表解析： [expr for iter in iterable] #for 迭代 iterable 对象的所有条目然后 expr 应用于序列的每个成员，最后的结果值是该表达式产生的列表
x=[y**2 for y in range(10) if not y%2] #[0, 4, 16, 36, 64] ，过滤掉满足 if 的序列成员
[(x,y) for x in range(3) for y in range(5)] # 迭代一个三行五列的矩阵
a=(x>0 for x in range(-2,3,1)); for it in a: print it; #False False False True True
lst=[0 for t in range(10)] # 生成固定长度序列，全部初始化为 0
x='hello python world'; x.split(); #['hello', 'python', 'world']
生成器表达式： (expr for iter in iterable if cond_expr) # 没产生一个符合条件的条目就用 expr 判断
x=open(file_name,mode=’rwa’) #+ 表示读写， b 二进制访问， r 文件必须存在， w 文件若存在先清空， a 追加，默认 r
for line in x: print line, # 也可以 x.readlines() 但是这样会读取文本的全部内容，而前一种是靠文件迭代器 , 这里 print Iine, 防止 print 产生换行符
data=[line.strip() for line in x.readlines()] #strip 去除换行符
x.close() # 关闭文件
x.fileno() # 返回文件的描述符
x.flush() # 刷新文件的内部缓冲区
x.isatty() # 判断 x 是否是一个类 tty 设备
x.next() # 返回文件下一行
x.read(size=-1) # 从文件读取 size 个字节，当 size 为负时读取剩余所有字节
x.readline(size=-1) # 从文件中读取并返回一行，或者返回最大 size 个字符
x.readlines(sizhint=0) # 读取文件的所有行并返回一个列表，若 sizhint>0 返回综合大约为 sizhint 字节的行
x.seek(off,whence=0) # 移动文件从 whence=0 文件开始 1 当前位置 2 文件末尾偏移 off 个字节
x.tell() # 返回当前文件的位置
x.truncate(size=x.tell()) # 截取文件到最大 size 字节，默认截取到当前位置
x.write(str) # 向文件写入字符串，若有必要 str 需要自己添加换行符
x.writelines(seq) # 向文件写入字符串序列 seq ，必要时在 seq 中每行添加换行符
x.closed # 若文件关闭返回 True
x.mode # 访问模式
x.name # 文件名
x.softspace #0 表示输出以数据后要加上一个空格符， 1 表示不加
import sys # 有 sys.stdin,sys.stdout,sys.stderr
sys.argv # 是命令行参数列表即 argv[][] ,len(sys.argv) 是参数个数， sys.argv[0] 是程序名
import os;
os.linesep # 用于在文件中分隔行的字符串， linux 是 \n
os.sep # 用于分隔文件路径的字符串
os.pathsep # 用于分隔文件路径的字符串
os.curdir # 当前工作目录的字符串名称
os.pardir # 父目录的名称
os.mkfifio() # 创建命名管道
os.remove() # 删除文件
os.rename() # 重命名文件
os.symlink() # 创建符号连接
os.utime() # 更新时间戳
os.tempfile() # 创建并打开一个临时文件
os.chdir() # 更改工作目录
os.chroot() # 改变当前进程的根目录
os.listdir() # 列出指定目录的文件
os.getcwd() # 返回当前工作目录
os.mkdir() # 创建目录
os.rmdir() # 删除目录
os.access(0 # 检验权限模式
os.chmod() # 改变权限模式
os.chown() # 改变所有者
os.umask() # 设置默认权限模式
os.path.basename() # 去掉目录路径返回文件名
os.path.dirname() # 去掉文件名，返回目录路径
os.path.join() # 将分离的各部分组合成一个路径名
os.path.split() # 返回 (dirname(),basename()) 元组
os.path.splitdrive() #(drivename,pathname)
os.path.splitext() #(filename,extension)
os.path.getatime() # 返回最近访问时间
os.path.getmtime() # 返回最近文件修改时间
os.path.getsize() # 返回文件大小
os.path.exists() # 指定路径是否存在
os.path.isabs() # 指定路径是否为绝对路径
os.path.isdir() # 指定路径是否为目录
os.path.isfile() # 指定路径是否为一个文件
os.path.islink() # 指定路径是否为一个符号链接
os.path.ismount() # 指定路径是否为一个挂载点
os.path.samefile() # 两个路径名是否指向同一个文件
函数： def fun(): 若没有显示的 return 返回元素则返回 None ，若返回多个对象则 python 把它们聚集起来并以一个元组返回，函数支持嵌套，外层函数内定义里层函数，并且外层函数需要调用里层函数才会执行里层函数
def foo():
'foo()--just an test fun'# 函数文档
print 'hello first fun';
foo.__doc__ # 输出函数文档
装饰器：函数调用之上的修饰，这些修饰仅当声明一个函数或者方法的时候才会额外调用
@g
@f
def foo():
foo()=g(f(foo))
函数和其它对象一样可以被引用、做参数、容器元素，比对象多了一个可调用特征，函数可以复制
fun=lambda arg1,.... :expression # 返回可调用的函数对象
非关键字 ( 不具名 ) 可变长的参数元组必须在位置参数和默认参数之后：
def fun(formal_args,*vargs_tuple): #* 号之后的形参作为元组传递给函数元组保存了所有传递给函数的额外参数
for ExtrArg in vargs_tuple:
print(“the extra args:”,ExtrArg);
fun(1,2,3)# fun(1,2,3,4)
关键字变长参数：保存在参数名作为 key ，参数值作为 value 的字典中
def fun(formal_args,*vargs_tuple,**vargsd): #
for ExtraArg in vargs_tuple:
print(“the extra args:”,ExtraArg);
for each in vargsd.keys():
print(each,vargsd[each]);
fun(1,2,3,a=1,b=2) #1 是位置参数， 2 、 3 是不具名非关键字变长参数， a 、 b 是关键字参数
fun(1,*(2,3),**{'a':1,'b':2}) # 结果同上
A=(2,3);B={'a':1,'b':2};fun(1,*A,**B) # 结果同上
apply(func,nkw,kw) # 用可选的参数调用 func ， nkw 是非关键字 ( 不具名 ) 参数， kw 是关键字参数，返回值的函数 func 的返回值
filter(func,seq) # 调用一个布尔函数来迭代遍历 seq 中的每个元素，返回一个使 func 为 true 的序列
filter(lambda x:x>0,range(-3,3,1)) # [1,2]
map(func,seq1,seq2...) # 将函数 func 作用 ( 映射 ) 于给定序列的每个元素 , 并用一个列表返回，多个序列时 map 会并行的迭代每个序列
reduce(func,seq,init) # 将二元函数 func 作用于 seq ，首先取出 seq 的头两个元素作为 func 的参数然后返回一个值 temp ，然后 temp 和 seq 的第三个元素作为 func 的参数 ... 直至序列尾返回一个单一的值，若有 init 则开始用 init 和 seq 第一个元素作为 func 的参数
reduce(func,[1,2,3]) <==> func(func(1,2),3)
全局变量除非被删除，否则在整个脚本都存在且对所有函数都可访问
global var # 在函数体内局部变量会覆盖同名的全局变量，但是使用 global 声明后会使用全局变量，函数体内对它的任何修改都会影响到全局变量
闭包的例子：
def fun(x):
def g():
return x+1;
return g;
a=fun(1);
a(); #2
yield ：生成器能暂停执行并返回一个中间结果并暂停执行，当生成器的 next() 方法被调用的时候会从暂停的地方继续执行，当没有更多的 next() 调用时抛出 StopIteration 异常。 for 循环有 next() 调用和 StopIteration 处理，所以 for 会自动遍历生成器。如： yield (1,2) # 返回一个元组
生成器除了通过 next() 获得下一个值 ( 调用者使用 next) ，调用者还可以向生成器发送 send() ，生成器可以抛出异常，要求生成器 close()
def counter(start=0):
count=start;
while True:
val=(yield count)
if val is not None:
count=val;
else:
count+=1;
count=counter(5);
count.next() #5
count.next() #6
count.send(9) #9
count.next() #10
coun.close()
sys.path.append('../..') # 添加搜索路径
__builtins__ 包含内建名称空间中内建名字的集合
__builtin__ 包含内建函数、异常以及其它属性， __builtins__ 包含 __bulitin__ 的所有名字
import module1,module2.... # 导入模块
from module import name1,name2... # 导入模块指定的属性， from numpy import *
import Tkinter as tk
module.__name__ # 模块名称
globals()/locals() # 返回全局 / 局部名称空间的字典
reload(module) # 重新导入模块
类必须有一个父类，默认是 object
class X(base):
'class doc--'
def __init__(self,arg):# 构造器 ( 每个类都有一个默认版本 ), 返回 None
self.no='mankind';# 实例属性
def __new__() # 构造器，必须返回一个合法的实例
def __del__() # 解构器
sex='male'; # 静态成员，类属性
类体
a,b=X(),X();
a.sex == b.sex ==X.sex =='male'
a.sex='female' # 此时实例属性覆盖掉类属性， b.sex=='male', X.sex=='male'
X.sex='animal' # a.sex=='female', b.sex=='animal' # 类属性的修改会影响到所有的实例
del a.sex
a.sex =='male' # 删除实例属性后类属性又出现了
静态方法属于类，类方法也属于类：
class test:
@staticmethod # 函数修饰符
def fun():
print(static method);
@classmethod
def foo():
print('class method');
类的特殊方法：
dir(X) / X.__dict__ # 查看类的属性 ( 数据成员和方法 )
X.__name__ 类名
X.__doc__ 类的说明文档
X.__bases__ 基类
X.__module__ 类所属模块
X.__class__ 对象所属的类
X__unicode__(self) #unicode 字符串输出，内建 unicode()
X.__call__(self,*args) # 可调用的实例
X.__nonzero__(self) # 为对象定义 bool 值，内建 bool()
X.__len__(self) # 类的长度，内建 len()
X.__cmp__(self,obj) # 对象比较，内建 cmp()
X.__lt__(self,obj) and #<=
X.__gt__(self,obj) and #>=
X.__eq__(self,obj) and #==
X.__getattr__(self,attr) # 获取属性，内建 getattr()
X.__setattr__(self,attr,val) # 设置属性
X.__delattr__(self,attr) # 删除属性
X.__getattribute__(self,attr) # 获取属性，内建 getattr()
X.__get__(self,attr) # 获取属性
X.__set(self,attr,val) # 设置属性
X.__delete__(self,attr) # 删除属性
X.__*add__(self,obj) #+,* 代表 : __and__ 显示 self+obj,__radd__,__iadd__ 相当于 +=
X.__*sub__(self,obj) #-
X.__*mul__(self,obj) #*
X.__*div__(self,obj) #/
X.__*truediv__(self,obj) #/
X.__*floordiv__(self,obj) #//
X.__*mod__(self,obj) #%
X.__*divmod__(self,obj) # 除和取模
X.__*pow__(self,obj,mod) # 内建 pow(),**
X.__*lshift__(self,obj) #<<
X.__*rshift__(self,obj) #>>
X.__*add__(self,obj) #&
X.__*or__(self,obj) #&
X.__*or__(self,obj) #|
X.__*xor__(self,obj) #^
X.__neg__(self) # 一元负
X.__pos__(self) # 一元正
X.__abds__(self) # 内建 abs()
X.__invert__(self) #~ 求反
X.__complex__(self,com) # 内建 complex ，转为复数
X.__int__(self) # 内建 int(), 转为 int
X.__long__(self) # 内建 long() ，强转为 long
X.__float__(self) # 内建 float(), 转为 float
X.__oct__(self) # 内建 oct(), 八进制表示
X.__hex__(self) # 内建 hex(), 十六进制表示
X.__coerce__(self,num) # 内建 coerce(), 压缩成同样的数值类型
X.__index__(self) # 压缩可选的数值类型为整型
X.__len__(self) # 项目数
X.__getitem__(self,ind) # 获取单个序列的元素
X.__setitem__(self,ind,val) # 设置单个序列的元素
X.__delitem__(self,ind) # 删除单个序列元素的表示
X.__getslice__(self,ind1,ind2) # 获取切片
X.__setslice__(self,i1,i2,val) # 设置序列切片
X.__delslice__(self,ind1,ind2) # 删除切片
X.__contains__(self,val) # 测试序列成员，内建 in 关键字
X.__*add__(self,obj) # 连接
X.__*mul__(self,obj) # 连接
X.__iter__(self) # 内建 iter() ，创建迭代类
X.__hash__(self) # 散列
issubclass(sub,sup) # 判断 sub 是否是 sup 的子类， sup 可以是一个元组只要满足元组中任一个即返回 true ，当然 sup 可以是 sub
isinstance(obj1,obj) # 判断 obj1 是否是类 obj 的一个实例
hasattr(obj,'foo') # 判断实例 obj 是否有属性 'foo'
getattr(obj,'foo',default) # 获取 obj.foo 属性，若属性不存在则引发 AttributeError 异常 , 若指定 defult 则没有属性时返回 default 不会抛出异常
setattr(obj,'foo',val) # 给 obj 赋值 foo 属性值为 val ， obj.foo=val
delattr(obj,'foo') # 删除属性
assert isinstance(val,float) # 断言 val 是 float 型
在类中实现 __str__() 或者 __repr__() 之一就可以用 'print 对象 ' 语句打印想要的输出：
class test:
def __str__(self): #self 必须， return 必须
return 'there is str;
def __repr__(self):
return 'there is repr';
a=class();
print a; #'there is str'
a; #'there is repr'
重载加法 : __add__()
重载 __i*__() 方法必须返回 self
callable(obj) # 若 obj 可调用返回 true
compile(string,file,type) # 从 type 类型中创建代码对象存放咋 file 中
eval(obj) # 对 obj 进行求值 eval('1+2') #3
正则表达式：
re1 | re2 匹配 re1 或 re2 ， or 关系
. 匹配任何字符，换行符除外
re.match('.end','bend').group() #'bend'
^ 字符串的开始
$ 字符串的结尾， .*\$$ 匹配以美元符号结尾的字符串
* 匹配零次或多次
+ 匹配一次或多次
? 零次或一次
{n} 匹配 n 次
{m,n} 匹配 m 到 n 次
[…] 匹配集合中的任意一个字符
[x-y0-9] 匹配序列 x 至 y 或 0-9
[^...] 不匹配集合中的任意一字符
() 分组
\d 匹配任何数字
\w 匹配任何数字、字母
\s 匹配任何空白字符
re.split('\s\s+','hello the python world') # 超过两个空格的划分
\b 匹配单词边界， \bthe\b 仅匹配 the ， \Bthe 包含 the 但不以 the 开头的单词
re.search(r'\bthe','bit the dog').group() #'the',r 表示后面是普通字符串，即 \ 不是转义的含义
\nn 匹配已保存的子组 () 产生子组 ,\16
\c 匹配特殊字符， \. \\ \*
\A \Z 字符串的开始或结束
import re;
match(pattern,string,flags=0) # 尝试用 pattern 匹配字符串 string ， flags 是可选标志符，成功返回一个匹配对象否则返回 None
search(pattern,string,flags=0) # 查找 string 模式 pattern 第一次出现，成功返回匹配对象否则返回 None
re.match('foo','seafood').group() #None
re.match('foo','seafood').group() #'foo' 说明 seach 会从字符串任意位置做匹配
findall(pattern,string) # 查找所有匹配对象
re.findall('car','scary the car'])#['car','car'] 返回一个列表
finditer(pattern,string) # 同上，但是返回的是迭代器
split(pattern,string,max=0) # 根据正则表达式 pattern 分割字符串最大 max 次默认是所有
sub(pattern,repl,string,max=0) # 将匹配的替换为 repl ， max 没有给出替换所有
re.sub('s','x','she is nurse') #'xhe ix nurxe'
group() # 返回所有匹配对象或特定子组
re.match('foo','food on table').group() #'foo'
groups() # 返回一个包含唯一或所有子组的元组，若正则表达式没有子组的话返回一个空元组
import socket # 网络编程
创建套接字： socket(socket_family,socket_type,protocol=0) #socket_family:AF_UNIX/AF_INET,socket_type:SOCK_STREAM/SOCK_DGRAM,protocal:0
x=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #tcp 套接字， udp 为 SOCK_DGRAM
x.bind() # 绑定到 IP 和 port
x.listen() # 开始监听
x.accept() # 阻塞式等待客户连接
x.connect() # 发起连接
x.connect_ex() #connect 的扩展版本出错时返回出错码而不是抛出异常
x.recv() # 开始接收 TCP 数据
x.send() # 发送 TCP 数据
x.sendall() # 完整发送 tcp 数据
x.recvfrom() # 接收 UDP 数据
x.sendto() # 发送 udp 数据
x.getperrname() # 获取到当前套接字的远端地址
x.getsockname() # 当前套接字的地址
x.getsockopt() # 返回指定套接字的参数
x.setsockopt() # 设置指定套接字的参数
x.close() # 关闭套接字
x.setblocking() # 设置为阻塞 / 非阻塞
x.settimeout() # 设置阻塞套接字操作的超时时间
x.gettimeout() # 获得阻塞套接字操作的超时时间
x.fileno() # 套机字的文件描述符
x.makefile() # 创建一个与套接字关联的文件
fromfd() # 用一个已经打开的文件描述符创建一个套接字对象
ssl() # 在套接字初始化一个安全套接字层 ssl 不做证书验证
getaddrinfo() # 得到地址信息
getfqdn() # 返回完整的域的名字
gethostname() # 得到当前主机名
gethostbyname() # 由主机名得到对应的 ip 地址
gethostbyname_ex() # 同上，返回主机所有的别名和 IP 地址列表
gethostbyaddr() # 由 IP 地址得到 DNS 信息
getprotobyname() # 由协议得到对应的号码
getservbyname() # 由服务器名得到对应的端口号或相反
getserbyport() # 由端口得到服务名
ntohl()/ntohs() # 整数网络转为主机字节序
htonl()/htons() # 整数由主机字节序转为网路 字节序
inet_aton() /inet_ntoa()#IP 地址转为整数或相反
inet_pton()/inet_ntop() # 将 IP 地址转为二进制格式或相反
getdefaulttimeout()/setdefaulttimeout() # 获得 / 设置套接字的超时时间
TCP 服务端伪码：
ss = socket() # 创建服务器套接字
ss.bind() # 把地址绑定到套接字上
ss.listen() # 监听连接
inf_loop: # 服务器无限循环
cs = ss.accept() # 接受客户的连接
comm_loop: # 通讯循环
cs.recv()/cs.send() # 对话（接收与发送）
cs.close() # 关闭客户套接字
ss.close() # 关闭服务器套接字（可选）
TCP 客户端伪码：
cs = socket() # 创建客户套接字
cs.connect() # 尝试连接服务器
comm_loop: # 通讯循环
cs.send()/cs.recv() # 对话（发送／接收）
cs.close() # 关闭客户套接字
UDP 服务端伪码：
ss = socket() # 创建一个服务器套接字
ss.bind() # 绑定服务器套接字
inf_loop: # 服务器无限循环
cs = ss.recvfrom()/ss.sendto() # 对话（接收与发送）
ss.close() # 关闭服务器套接字
UDP 客户端伪码：
cs = socket() # 创建客户套接字
comm_loop: # 通讯循环
cs.sendto()/cs.recvfrom() # 对话（发送／接收）
cs.close() # 关闭客户套接字
TCP 通信实例 ( 粗糙的逻辑设计 echo 服务 )
服务端代码：
from socket import *
server=socket(AF_INET,SOCK_STREAM)
server.bind(('192.168.13.125',8000))# 查看端口 shell 命令 netstat -ntl | grep 8000
server.listen(5)
while True:
client,addr=server.accept();
while True:
data=client.recv(1024);
if not data:
break;
client.send(data)
客户端代码：
from socket import *
client=socket(AF_INET,SOCK_STREAM)
client.connect(('192.168.13.125',8000))
while True:
client.send('hello python');
while True:
data=client.recv(1024);
if data:
print data;
break;
Python 解释器可以运行多个西啊不是但在任意时刻只有一个线程在解释器中运行， python 虚拟机的访问由全局解释器锁 GIL 来控制该锁能保证同一时刻只有一个线程在运行
threading 模块：
Thread 表示一个线程的执行的对象
Lock 锁原语对象
Rlock 可重入锁对象 ( 递归锁 )
Conditon 条件变量，条件改变时只有线程唤醒
Event 多个线程等待条件变量时，当事件发生时所有线程被唤醒
Semaphore 信号量
Timer 定时器
t=threading.Thread(target=loop,args=(...))
t.start() # 线程开始执行
t.run() # 定义线程的功能函数
t.join(timeout=None) # 程序挂起直到线程结束，若指定了 timeout 最多阻塞 timeout 秒
t.getName() # 返回线程的名字
t.setName(name) # 设置线程的名字
t.isAlive() # 线程是否在运行中
t.idDaemon() # 返回西啊不是的 dameon 标志
t.sertDaemon(daemonic) # 在 start 之前设置 daemon 标志
import Tkinter
top=Tkinter.Tk() # 底层窗口对象
Button 按钮，提供额外的功能
Canvas 画布提供绘图功能
Checkbutton 选择按钮一组方框可以选择其中的任意个
Entry 文本框
Frame 框架包含其它组件的容器
Label 标签显示文字或图片
Listbox 列表框，一个选项列表可以从中选择
Menu 菜单点下菜单按钮后弹出的一个选项列表可以供选择
Menubutton 菜单按钮用来包含菜单的组件
Message 消息框类似于标签
Radiobutton 单选按钮
Scale 进度条，
Scrollbar 滚动条
Text 文本域
Toplevel 顶级
连接 MySQL ： sudo apt-get install python-msyqldb
import MySQLdb
conn=MySQLdb.connect(host='localhost',user='root',passwd='123') # 连接数据库系统
cursor=conn.cursor() # 获取操作游标
cursor.exectue('create database test') # 创建数据库 test
cursor.close() # 关闭连接
conn.select_db('test') # 选择数据库
cursor.execute('create table student(id int,info varchar(100))') # 创建数据表
cursor.execute('insert into student values(%s,%s)',value) #value=[1,'male']# 插入一条记录
cursor.executemany('insert into student values(%s,%s)',values) # 插入一个列表 values
count=cursor.execute('select * from student') # 查询
result=cursor.fetchone() # 获取一条记录
result=cursor.fetchmany(count) # 获取查询的记录
for r in result:
print r;
cursor.scroll(0,mode='absolute') # 重置游标位置， 0 为偏移量， mode=absolute, 默认 relative, 前提是当前游标没有越界
results=cursor.fetchall()
for r in results:
print r;
cursor.close()
ctypes 模块：
dll=CDLL('../***.so') # 加载动态库
f=getattr(dll,fun_name) # 从动态库中获取函数对象
f.restype=c_int # 设置函数返回类型
f.argtypes=(c_int,...) # 设置函数参数类型
声明类和联合必须继承自 Structure 和 union, 类中必须有定义一个属性 _fileds_ 其中 _fields_ 是一个元素为 2 元组的列表， 2 元组是 ( 属性名，属性类型 ) ，如：
class Point(Structure):
_fields_=[('x',c_int),('y',c_int)]
Numpy:
1 安装numpy：sudo apt-get install python-numpy
安装Matplotlib: sudo apt-get install python-matplotlib
2 退出：quit()
3 numpy练习：
from numpy import* #
random.rand(4,4)#生成一个数组
randMat=mat(random.rand(4,4))#矩阵
randMat.I#逆矩阵
eye(4)#单位矩阵
4 查看并改变工作目录
import os
os.getcwd()
os.chdir("PATH")#PATH为目标路径
5 定义函数体
import operator#加载运算符模块
def 函数名(参数列表)
函数体语句
实例：
from numpy import *
import operator
def createDataSet()
group=array([[1,2,],[3,4],[5,6]])
labels=['A','B','C']
return group,labels
调用：
group,labels=createDataSet()
6 查看帮助help,如help(sorted)，内建函数的查询：help(array([1,2]).sort)
5） Numpy包的数组array
import numpy as np
a = np.arange(10)
a.reshape(2,5)#重塑数组为2行5列
a.dtype# 元素数据类型
print(a.shape)#数组的维度具体情况如(2,3,4)表示数组最底层为4个元素，然后是3个一维数组2个二维数组
a.ndim#数组维数
a.size# 数组元素个数
a.itemsize# 查看元素大小
a = np.array([2,3,4])# 使用 array 函数，从 Python 列表或元组中创建
b = np.array([1.2, 4.6, 7.8])
c = np.array([(1,2,3), (4,5,6)])
d = np.array( [ [1,2], [3,4] ], dtype=complex )# 创建复数数组 dtype 决定元素类型
e = np.zeros((3,4))# 创建全是 0 的数组
f = np.ones( (2,3,4), dtype=np.int16 )# 创建全是 1 的数组
g = np.empty( (2,3) )# 使用随机数来填充
h = np.arange( 10, 30, 5 )# 创建序列
i = np.arange(0,2,0.3)
j = np.linspace(0,2,9)
print(np.arange(10000))# 打印 numpy 数组与 Python 列表基本一样，但有些差别
print(np.arange(10000).reshape(100,100))
7 Numpy包
a=mat([1,2,3])#矩阵
b=matrix([1,2,3])
a[0,1]#取元素
a*b.T#矩阵相乘,.T是取矩阵转置
shape(a)#查看矩阵维数
a.shape[0]#获取a的行数
multiply(a,b)#两个矩阵每个元素对应相乘
a.sort()#a的原地排序
a.argsort()#得到矩阵中每个元素的排列序号
a.mean()#计算矩阵的均值
a=mat([[1,2,3],[4,5,6]])#多维数组
a[:,0:2]#采用冒号选取多列或行，所有行0和1列
9 sorted(iteratble,cmp=None, key=None, reverse=False)。sorted和那些容器内建的sort的区别是sort是原地排序，sorted是新建一个列表
1）key：用列表元素的某个属性和函数进行作为关键字，有默认值，迭代集合中的一项;
2）reverse：排序规则. reverse = True 或者 reverse = False，有默认值。
3）cmp：用于比较的函数，比较什么由key决定,有默认值，迭代集合中的一项;
4）iterable是需要排序的数据
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=operator.itemgetter(1,2)) #先跟句第二个域排序，再根据第三个域排序
结果：[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]
10 python数组下标从0开始
11 type(a)#查看a的数据类型
12 strip声明：s为字符串，rm为要删除的字符序列
s.strip(rm) 删除s字符串
中开头、结尾处，位于 rm删除序列的字符
s.lstrip(rm) 删除s字符串中开头处，位于 rm删除序列的字符
s.rstrip(rm) 删除s字符串中结尾处，位于 rm删除序列的字符
1） 当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')
2） 这里的rm删除序列是只要边（开头或结尾）上的字符在删除序列内，就删除掉，如：a='123a'，a.strip('21')结果为'3a'
13 包 profile 查看模块运行的时间： import profile; profile.run(“fun()”)
14 for item in set: #for 循环遍历 set 中的元素，若二维矩阵则 item 是行数据
15 in/not in 成员测试，如： if x not set 若 x 不在 set 中
16 list 的扩展： x.extend(y)# 接受列表参数 y 的扩展并且 y 的每个元素作为 x 的元素， x.expand(y) 是将列表 y 整体作为 x 的一个元素 (expand 将参数作为一个整体， extend 只能接收一个列表是逐个元素追加到原列表 )
scikit-learn:
安装：
sudo apt-get install build-essential python-dev python-numpy python-setuptools python-scipy libatlas-dev//先安装依赖
kmeans 的使用：
k_means=cluster.KMeans(k); #k 是簇数
k_means.fit(data);#data 是数据集，要求 data 的样本数大于 k
labels=list(k_means.labels_);# 获取每个样本的分类号
