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