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