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