python   学习笔记 (核心)

Posted 2020-09-25

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