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

python 學習筆記 (核心)