python 学习笔记 (核心)

cyc1111

　　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_);#    获取每个样本的分类号