python   學習筆記 (核心)

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_);#    獲取每個樣本的分類號