#encoding:utf8
# 設定編碼-支持中文
1 基礎
安裝python2.7
wget https://www.python.org/ftp/python/2.7.9/Python-2.7.9.tgz
tar xvf Python-2.7.9.tgz
cd Python-2.7.9
./configure --prefix=/usr/local/python27
make
make install
mv /usr/bin/python /usr/bin/python_old
ln -s /usr/local/python27/bin/python /usr/bin/python
python # 查看版本
解決YUM無法使用的問題
vim /usr/bin/yum
vim /usr/bin/repoquery
兩文件首行#!/usr/bin/python 替換為老版本python #!/usr/bin/python2.6 注意可能為2.4
pip模塊安裝
yum install python-pip # centos安裝pip
sudo apt-get install python-pip # ubuntu安裝pip
pip官方安裝腳本
wget https://raw.github.com/pypa/pip/master/contrib/get-pip.py
python get-pip.py
pip編譯安裝
# https://pypi.python.org/pypi/setuptools
wget http://pypi.python.org/packages/source/s/setuptools/setuptools.tar.gz
tar zxvf setuptools.tar.gz
cd setuptools/
python setup.py build
python setup.py install
# https://pypi.python.org/pypi/ez_setup
tar zxvf ez_setup.tar.gz
cd ez_setup/
python setup.py build
python setup.py install
# https://pypi.python.org/pypi/pip
tar zxvf pip.tar.gz
cd pip/
python setup.py build
python setup.py install
加載環境變量
vim /etc/profile
export PATH=/usr/local/python27/bin:$PATH
. /etc/profile
pip freeze # 查看包版本
pip install -r file # 安裝包文件列表
pip install Package # 安裝包 pip install requests
pip show --files Package # 查看安裝包時安裝了哪些文件
pip show --files Package # 查看哪些包有更新
pip install --upgrade Package # 更新一個軟件包
pip uninstall Package # 卸載軟件包
pip list # 查看pip安裝的包及版本
pip install django==1.5 # 指定版本安裝
pip install kafka-python -i http://pypi.douban.com/simple --trusted-host pypi.douban.com
python3安裝
yum install python36.x86_64 python36-pip
查看幫助
python -c "help('modules')" # 查看python所有模塊
import os
for i in dir(os):
print i # 模塊的方法
help(os.path) # 方法的幫助
python中關鍵字
import keyword
keyword.iskeyword(str) # 字符串是否為python關鍵字
keyword.kwlist # 返回pytho所有關鍵字
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
調試
python -m trace -t aaaaaa.py
strace -p pid # 用系統命令跟蹤系統調用
變量
r=r'\n' # 輸出時原型打印
u=u'中文' # 定義為unicode編碼
global x # 全局變量
a = 0 or 2 or 1 # 布爾運算賦值,a值為True既不處理後面,a值為2. None、字符串''、空元組()、空列表[],空字典{}、0、空字符串都是false
name = raw_input("input:").strip() # 輸入字符串變量
num = int(raw_input("input:").strip()) # 輸入字符串str轉為int型
locals() # 所有局部變量組成的字典
locals().values() # 所有局部變量值的列表
os.popen("date -d @{0} +'%Y-%m-%d %H:%M:%S'".format(12)).read() # 特殊情況引用變量 {0} 代表第一個參數
基於字典的字符串格式化
params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
"%(pwd)s" % params # 'secret'
"%(pwd)s is not a good password for %(uid)s" % params # 'secret is not a good password for sa'
"%(database)s of mind, %(database)s of body" % params # 'master of mind, master of body'
打印
# 字符串 %s 整數 %d 浮點 %f 原樣打印 %r
print '字符串: %s 整數: %d 浮點: %f 原樣打印: %r' % ('aa',2,1.0,'r')
print 'abc', # 有逗號,代表不換行打印,在次打印會接著本行打印
print '%-10s %s' % ('aaa','bbb') # 左對齊 占10個字符
print '%10s %s' % ('aaa','bbb') # 右對齊 占10個字符
列表
# 列表元素的個數最多 536870912
shoplist = ['apple', 'mango', 'carrot', 'banana']
shoplist[2] = 'aa'
del shoplist[0]
shoplist.insert(4,'www')
shoplist.append('aaa')
shoplist[::-1] # 倒著打印 對字符翻轉串有效
shoplist[2::3] # 從第二個開始每隔三個打印
shoplist[:-1] # 排除最後一個
'\t'.join(li) # 將列表轉字符串 用字表符分割
sys.path[1:1]=[5] # 在位置1前面插入列表中一個值
list(set(['qwe', 'as', '123', '123'])) # 將列表通過集合去重復
eval("['1','a']") # 將字符串當表達式求值,得到列表
# enumerate 可得到每個值的對應位置
for i, n in enumerate(['a','b','c']):
print i,n
元組
# 不可變
zoo = ('wolf', 'elephant', 'penguin')
字典
ab = { 'Swaroop' : '[email protected]',
'Larry' : '[email protected]',
}
ab['c'] = 80 # 添加字典元素
del ab['Larry'] # 刪除字典元素
ab.keys() # 查看所有鍵值
ab.values() # 打印所有值
ab.has_key('a') # 查看鍵值是否存在
ab.items() # 返回整個字典列表
復制字典
a = {1: {1: 2, 3: 4}}
b = a
b[1][1] = 8888 # a和b都為 {1: {1: 8888, 3: 4}}
import copy
c = copy.deepcopy(a) # 再次賦值 b[1][1] = 9999 拷貝字典為新的字典,互不干擾
a[2] = copy.deepcopy(a[1]) # 復制出第二個key，互不影響 {1: {1: 2, 3: 4},2: {1: 2, 3: 4}}
迭代器
# 創建迭代接口，而不是原來的對象 支持字符串、列表和字典等序列對象
i = iter('abcd')
print i.next()
s = {'one':1,'two':2,'three':3}
m = iter(s)
print m.next() # 迭代key
流程結構
if判斷
# 布爾值操作符 and or not 實現多重判斷
if a == b:
print '=='
elif a < b:
print b
else:
print a
while循環
while True:
if a == b:
print "=="
break
print "!="
else:
print 'over'
count=0
while(count<9):
print count
count += 1
for循環
sorted() # 返回一個序列(列表)
zip() # 返回一個序列(列表)
enumerate() # 返回循環列表序列 for i,v in enumerate(['a','b']):
reversed() # 反序迭代器對象
dict.iterkeys() # 通過鍵迭代
dict.itervalues() # 通過值迭代
dict.iteritems() # 通過鍵-值對迭代
readline() # 文件迭代
iter(obj) # 得到obj迭代器 檢查obj是不是一個序列
iter(a,b) # 重復調用a,直到迭代器的下一個值等於b
for i in range(1, 5):
print i
else:
print 'over'
list = ['a','b','c','b']
for i in range(len(list)):
print list[i]
for x, Lee in enumerate(list):
print "%d %s Lee" % (x+1,Lee)
# enumerate 使用函數得到索引值和對應值
for i, v in enumerate(['tic', 'tac', 'toe']):
print(i, v)
流程結構簡寫
[ i * 2 for i in [8,-2,5]]
[16,-4,10]
[ i for i in range(8) if i %2 == 0 ]
[0,2,4,6]
tab補全
# vim /usr/lib/python2.7/dist-packages/tab.py
# python startup file
import sys
import readline
import rlcompleter
import atexit
import os
# tab completion
readline.parse_and_bind('tab: complete')
# history file
histfile = os.path.join(os.environ['HOME'], '.pythonhistory')
函數
def printMax(a, b = 1):
if a > b:
print a
return a
else:
print b
return b
x = 5
y = 7
printMax(x, y)
def update(*args,**kwargs):
p=''
for i,t in kwargs.items():
p = p+ '%s=%s,' %(i,str(t))
sql = "update 'user' set (%s) where (%s)" %(args[0],p)
print sql
update('aaa',uu='uu',id=3)
模塊
# Filename: mymodule.py
def sayhi():
print 'mymodule'
version = '0.1'
# 使用模塊中方法
import mymodule
from mymodule import sayhi, version
mymodule.sayhi() # 使用模塊中函數方法
裝飾器
# 為已存在的功能添加額外的功能,只在初始化腳本的時候執行一次
#!/usr/bin/env python
def deco(func):
def wrapper(*args, **kwargs):
print "Wrap start"
func(*args, **kwargs)
func(*args, **kwargs)
print "Wrap end\n"
return wrapper
@deco
def foo(x):
print "In foo():"
print "I have a para: %s" % x
@deco
def foo_dict(x,z='dict_para'):
print "In foo_dict:"
print "I have two para, %s and %s" % (x, z)
if __name__ == "__main__":
# 裝飾器 @deco 等價於 foo = deco(foo)
foo('x')
foo_dict('x', z='dict_para')
結果
Wrap start
In foo():
I have a para: x
In foo():
I have a para: x
Wrap end
Wrap start
In foo_dict:
I have two para, x and dict_para
In foo_dict:
I have two para, x and dict_para
Wrap end
類對象的方法
__xxx__ # 系統定義名字
__init__ # 實例化初始化類的方法
__all__ = ['xs'] # __all__ 用於模塊import導入時限制,定義了只有all內指定的屬性、方法、類可被導入,沒定義則模塊內的所有將被導入
_xxx # _開頭的為私有類,只有類對象和子類對象自己能訪問到這些變量 不能用 from module import * 導入 class _status:
__xxx # __開頭的為類中的私有變量名,只有類對象自己能訪問,連子類對象也不能訪問到這個數據
class Person:
# 實例化初始化的方法
def __init__(self, name ,age):
self.name = name
self.age = age
print self.name
# 有self此函數為方法
def sayHi(self):
print 'Hello, my name is', self.name
# 對象消逝的時候被調用
def __del__(self):
print 'over'
# 實例化對象
p = Person('Swaroop',23)
# 使用對象方法
p.sayHi()
# 繼承
class Teacher(Person):
def __init__(self, name, age, salary):
Person.__init__(self, name, age)
self.salary = salary
print '(Initialized Teacher: %s)' % self.name
def tell(self):
Person.tell(self)
print 'Salary: "%d"' % self.salary
t = Teacher('Mrs. Shrividya', 40, 30000)
getattr(object,name,default)
# 返回object的名稱為name的屬性的屬性值,如果屬性name存在,則直接返回其屬性值.如果屬性name不存在,則觸發AttribetError異常或當可選參數default定義時返回default值
class A:
def __init__(self):
self.name = 'zhangjing'
def method(self):
print"method print"
Instance = A()
print getattr(Instance, 'name', 'not find') # 如果Instance 對象中有屬性name則打印self.name的值，否則打印'not find'
print getattr(Instance, 'age', 'not find') # 如果Instance 對象中有屬性age則打印self.age的值，否則打印'not find'
print getattr(Instance, 'method', 'default') # 如果有方法method，否則打印其地址，否則打印default
print getattr(Instance, 'method', 'default')() # 如果有方法method，運行函數並打印None否則打印default
setattr(object,name,value)
# 設置object的名稱為name(type：string)的屬性的屬性值為value，屬性name可以是已存在屬性也可以是新屬性。
#等同多次 self.name = name 賦值 在外部可以直接把變量和值對應關系傳進去
#class Person:
# def __init__(self, name ,age):
# self.name = name
# self.age = age
config = {'name':'name','age','age'}
class Configure(object):
def __init__(self, config):
self.register(config)
def register(self, config):
for key, value in config.items():
if key.upper() == key:
setattr(self, key, value)
模塊包
# 文件 ops/fileserver/__init__.py
import readers
import writers
# 每個模塊的包中，都有一個 __init__.py 文件，有了這個文件，才能導入這個目錄下的module，在導入一個包時 import ops.fileserver ，實際上是導入了它的 __init__.py 文件，可以再 __init__.py 文件中再導入其他的包，或者模塊。就不需要將所有的import語句寫在一個文件裡了，也可以減少代碼量，不需要一個個去導入module了。
# __init__.py 有一個重要的變量 __all__ 。有時會需要全部導入，from PackageName import * ，這時 import 就會把注冊在包 __init__.py 文件中 __all__ 列表中的子模塊和子包導入到當前作用域中來。如：
__all__ = ["Module1", "Module2", "subPackage1", "subPackage2"]
執行模塊類中的所有方法
# moniItems.py
import sys, time
import inspect
class mon:
def __init__(self):
self.data = dict()
def run(self):
return self.runAllGet()
def getDisk(self):
return 222
def getCpu(self):
return 111
def runAllGet(self):
for fun in inspect.getmembers(self, predicate=inspect.ismethod):
print fun[0], fun[1]
if fun[0][:3] == 'get':
self.data[fun[0][3:]] = fun[1]()
print self.data
return self.data
# 模塊導入使用
from moniItems import mon
m = mon()
m.runAllGet()
文件處理
# 模式: 讀'r' 寫[清空整個文件]'w' 追加[文件需要存在]'a' 讀寫'r+' 二進制文件'b' 'rb','wb','rb+'
寫文件
i={'ddd':'ccc'}
f = file('poem.txt', 'a')
f.write("string")
f.write(str(i))
f.flush()
f.close()
讀文件
f = file('/etc/passwd','r')
c = f.read().strip() # 讀取為一個大字符串，並去掉最後一個換行符
for i in c.split('\n'): # 用換行符切割字符串得到列表循環每行
print i
f.close()
讀文件1
f = file('/etc/passwd','r')
while True:
line = f.readline() # 返回一行
if len(line) == 0:
break
x = line.split(":") # 冒號分割定義序列
#x = [ x for x in line.split(":") ] # 冒號分割定義序列
#x = [ x.split("/") for x in line.split(":") ] # 先冒號分割,在/分割 打印x[6][1]
print x[6],"\n",
f.close()
讀文件2
f = file('/etc/passwd')
c = f.readlines() # 讀入所有文件內容,可反復讀取,大文件時占用內存較大
for line in c:
print line.rstrip(),
f.close()
讀文件3
for i in open('b.txt'): # 直接讀取也可迭代,並有利於大文件讀取,但不可反復讀取
print i,
追加日志
log = open('/home/peterli/xuesong','a')
print >> log,'faaa'
log.close()
with讀文件
# 自動關閉文件、線程鎖的自動獲取和釋放等
with open('a.txt') as f:
for i in f:
print i
print f.read() # 打印所有內容為字符串
print f.readlines() # 打印所有內容按行分割的列表
文件隨機讀寫
# 文件本沒有換行,一切都是字符,文件也沒有插入功能
f.tell() # 當前讀寫位置
f.read(5) # 讀取5個字符並改變指針
f.seek(5) # 改變用戶態讀寫指針偏移位置,可做隨機寫
f.seek(p,0) # 移動當文件第p個字節處，絕對位置
f.seek(p,1) # 移動到相對於當前位置之後的p個字節
f.seek(p,2) # 移動到相對文件尾之後的p個字節
f.seek(0,2) # 指針指到尾部
# 改變指針超出文件尾部,會造成文件洞,ll看占用較大，但du -sh卻非常小
f.read(65535) # 讀取64K字節
f.write("str") # 寫會覆蓋當前指針後的響應字符,無插入功能
內建函數
dir(sys) # 顯示對象的屬性
help(sys) # 交互式幫助
int(obj) # 轉型為整形
str(obj) # 轉為字符串
len(obj) # 返回對象或序列長度
open(file,mode) # 打開文件 #mode (r 讀,w 寫, a追加)
range(0,3) # 返回一個整形列表
raw_input("str:") # 等待用戶輸入
type(obj) # 返回對象類型
abs(-22) # 絕對值
random # 隨機數
choice() # 隨機返回給定序列的一個元素
divmod(x,y) # 函數完成除法運算，返回商和余數。
round(x[,n]) # 函數返回浮點數x的四捨五入值，如給出n值，則代表捨入到小數點後的位數
strip() # 是去掉字符串兩端多於空格,該句是去除序列中的所有字串兩端多余的空格
del # 刪除列表裡面的數據
cmp(x,y) # 比較兩個對象 #根據比較結果返回一個整數，如果x<y，則返回-1；如果x>y，則返回1,如果x==y則返回0
max() # 字符串中最大的字符
min() # 字符串中最小的字符
sorted() # 對序列排序
reversed() # 對序列倒序
enumerate() # 返回索引位置和對應的值
sum() # 總和
list() # 變成列表可用於迭代
eval('3+4') # 將字符串當表達式求值 得到7
exec 'a=100' # 將字符串按python語句執行
exec(a+'=new') # 將變量a的值作為新的變量
tuple() # 變成元組可用於迭代 #一旦初始化便不能更改的數據結構,速度比list快
zip(s,t) # 返回一個合並後的列表 s = ['11','22'] t = ['aa','bb'] [('11', 'aa'), ('22', 'bb')]
isinstance(object,int) # 測試對象類型 int
xrange([lower,]stop[,step]) # 函數與range()類似，但xrnage()並不創建列表，而是返回一個xrange對象
列表類型內建函數
list.append(obj) # 向列表中添加一個對象obj
list.count(obj) # 返回一個對象obj在列表中出現的次數
list.extend(seq) # 把序列seq的內容添加到列表中
list.index(obj,i=0,j=len(list)) # 返回list[k] == obj 的k值,並且k的范圍在i<=k<j;否則異常
list.insert(index.obj) # 在索引量為index的位置插入對象obj
list.pop(index=-1) # 刪除並返回指定位置的對象,默認是最後一個對象
list.remove(obj) # 從列表中刪除對象obj
list.reverse() # 原地翻轉列表
list.sort(func=None,key=None,reverse=False) # 以指定的方式排序列表中成員,如果func和key參數指定,則按照指定的方式比較各個元素,如果reverse標志被置為True,則列表以反序排列
序列類型操作符
seq[ind] # 獲取下標為ind的元素
seq[ind1:ind2] # 獲得下標從ind1到ind2的元素集合
seq * expr # 序列重復expr次
seq1 + seq2 # 連接seq1和seq2
obj in seq # 判斷obj元素是否包含在seq中
obj not in seq # 判斷obj元素是否不包含在seq中
字符串類型內建方法
string.expandtabs(tabsize=8) # tab符號轉為空格 #默認8個空格
string.endswith(obj,beg=0,end=len(staring)) # 檢測字符串是否已obj結束,如果是返回True #如果beg或end指定檢測范圍是否已obj結束
string.count(str,beg=0,end=len(string)) # 檢測str在string裡出現次數 f.count('\n',0,len(f)) 判斷文件行數
string.find(str,beg=0,end=len(string)) # 檢測str是否包含在string中
string.index(str,beg=0,end=len(string)) # 檢測str不在string中,會報異常
string.isalnum() # 如果string至少有一個字符並且所有字符都是字母或數字則返回True
string.isalpha() # 如果string至少有一個字符並且所有字符都是字母則返回True
string.isnumeric() # 如果string只包含數字字符,則返回True
string.isspace() # 如果string包含空格則返回True
string.isupper() # 字符串都是大寫返回True
string.islower() # 字符串都是小寫返回True
string.lower() # 轉換字符串中所有大寫為小寫
string.upper() # 轉換字符串中所有小寫為大寫
string.lstrip() # 去掉string左邊的空格
string.rstrip() # 去掉string字符末尾的空格
string.replace(str1,str2) # 把string中的str1替換成str2,如果num指定,則替換不超過num次
string.startswith(obj,beg=0,end=len(string)) # 檢測字符串是否以obj開頭
string.zfill(width) # 返回字符長度為width的字符,原字符串右對齊,前面填充0
string.isdigit() # 只包含數字返回True
string.split("/") # 把string切片成一個列表
":".join(string.split()) # 以:作為分隔符,將所有元素合並為一個新的字符串
字典內建方法
dict.clear() # 刪除字典中所有元素
dict copy() # 返回字典(淺復制)的一個副本
dict.fromkeys(seq,val=None) # 創建並返回一個新字典,以seq中的元素做該字典的鍵,val做該字典中所有鍵對的初始值
dict.get(key,default=None) # 對字典dict中的鍵key,返回它對應的值value,如果字典中不存在此鍵,則返回default值
dict.has_key(key) # 如果鍵在字典中存在,則返回True 用in和not in代替
dict.items() # 返回一個包含字典中鍵、值對元組的列表
dict.keys() # 返回一個包含字典中鍵的列表
dict.iter() # 方法iteritems()、iterkeys()、itervalues()與它們對應的非迭代方法一樣,不同的是它們返回一個迭代子,而不是一個列表
dict.pop(key[,default]) # 和方法get()相似.如果字典中key鍵存在,刪除並返回dict[key]
dict.setdefault(key,default=None) # 和set()相似,但如果字典中不存在key鍵,由dict[key]=default為它賦值
dict.update(dict2) # 將字典dict2的鍵值對添加到字典dict
dict.values() # 返回一個包含字典中所有值得列表
dict([container]) # 創建字典的工廠函數。提供容器類(container),就用其中的條目填充字典
len(mapping) # 返回映射的長度(鍵-值對的個數)
hash(obj) # 返回obj哈希值,判斷某個對象是否可做一個字典的鍵值
集合方法
s.update(t) # 用t中的元素修改s,s現在包含s或t的成員 s |= t
s.intersection_update(t) # s中的成員是共用屬於s和t的元素 s &= t
s.difference_update(t) # s中的成員是屬於s但不包含在t中的元素 s -= t
s.symmetric_difference_update(t) # s中的成員更新為那些包含在s或t中,但不是s和t共有的元素 s ^= t
s.add(obj) # 在集合s中添加對象obj
s.remove(obj) # 從集合s中刪除對象obj;如果obj不是集合s中的元素(obj not in s),將引發KeyError錯誤
s.discard(obj) # 如果obj是集合s中的元素,從集合s中刪除對象obj
s.pop() # 刪除集合s中的任意一個對象,並返回它
s.clear() # 刪除集合s中的所有元素
s.issubset(t) # 如果s是t的子集,則返回True s <= t
s.issuperset(t) # 如果t是s的超集,則返回True s >= t
s.union(t) # 合並操作;返回一個新集合,該集合是s和t的並集 s | t
s.intersection(t) # 交集操作;返回一個新集合,該集合是s和t的交集 s & t
s.difference(t) # 返回一個新集合,改集合是s的成員,但不是t的成員 s - t
s.symmetric_difference(t) # 返回一個新集合,該集合是s或t的成員,但不是s和t共有的成員 s ^ t
s.copy() # 返回一個新集合,它是集合s的淺復制
obj in s # 成員測試;obj是s中的元素 返回True
obj not in s # 非成員測試:obj不是s中元素 返回True
s == t # 等價測試 是否具有相同元素
s != t # 不等價測試
s < t # 子集測試;s!=t且s中所有元素都是t的成員
s > t # 超集測試;s!=t且t中所有元素都是s的成員
序列化
#!/usr/bin/python
import cPickle
obj = {'1':['4124','1241','124'],'2':['12412','142','1241']}
pkl_file = open('account.pkl','wb')
cPickle.dump(obj,pkl_file)
pkl_file.close()
pkl_file = open('account.pkl','rb')
account_list = cPickle.load(pkl_file)
pkl_file.close()
文件對象方法
file.close() # 關閉文件
file.fileno() # 返回文件的描述符
file.flush() # 刷新文件的內部緩沖區
file.isatty() # 判斷file是否是一個類tty設備
file.next() # 返回文件的下一行,或在沒有其他行時引發StopIteration異常
file.read(size=-1) # 從文件讀取size個字節,當未給定size或給定負值的時候,讀取剩余的所有字節,然後作為字符串返回
file.readline(size=-1) # 從文件中讀取並返回一行(包括行結束符),或返回最大size個字符
file.readlines(sizhint=0) # 讀取文件的所有行作為一個列表返回
file.xreadlines() # 用於迭代,可替換readlines()的一個更高效的方法
file.seek(off, whence=0) # 在文件中移動文件指針,從whence(0代表文件起始,1代表當前位置,2代表文件末尾)偏移off字節
file.tell() # 返回當前在文件中的位置
file.truncate(size=file.tell()) # 截取文件到最大size字節,默認為當前文件位置
file.write(str) # 向文件寫入字符串
file.writelines(seq) # 向文件寫入字符串序列seq;seq應該是一個返回字符串的可迭代對象
文件對象的屬性
file.closed # 表示文件已被關閉,否則為False
file.encoding # 文件所使用的編碼 當unicode字符串被寫入數據時,它將自動使用file.encoding轉換為字節字符串;若file.encoding為None時使用系統默認編碼
file.mode # Access文件打開時使用的訪問模式
file.name # 文件名
file.newlines # 未讀取到行分隔符時為None,只有一種行分隔符時為一個字符串,當文件有多種類型的行結束符時,則為一個包含所有當前所遇到的行結束符的列表
file.softspace # 為0表示在輸出一數據後,要加上一個空格符,1表示不加
異常處理
# try 中使用 sys.exit(2) 會被捕獲,無法退出腳本,可使用 os._exit(2) 退出腳本
class ShortInputException(Exception): # 繼承Exception異常的類,定義自己的異常
def __init__(self, length, atleast):
Exception.__init__(self)
self.length = length
self.atleast = atleast
try:
s = raw_input('Enter something --> ')
if len(s) < 3:
raise ShortInputException(len(s), 3) # 觸發異常
except EOFError:
print '\nWhy did you do an EOF on me?'
except ShortInputException, x: # 捕捉指定錯誤信息
print 'ShortInputException: %d | %d' % (x.length, x.atleast)
except Exception as err: # 捕捉所有其它錯誤信息內容
print str(err)
#except urllib2.HTTPError as err: # 捕捉外部導入模塊的錯誤
#except: # 捕捉所有其它錯誤 不會看到錯誤內容
# print 'except'
finally: # 無論什麼情況都會執行 關閉文件或斷開連接等
print 'finally'
else: # 無任何異常 無法和finally同用
print 'No exception was raised.'
不可捕獲的異常
NameError: # 嘗試訪問一個未申明的變量
ZeroDivisionError: # 除數為零
SyntaxErrot: # 解釋器語法錯誤
IndexError: # 請求的索引元素超出序列范圍
KeyError: # 請求一個不存在的字典關鍵字
IOError: # 輸入/輸出錯誤
AttributeError: # 嘗試訪問未知的對象屬性
ImportError # 沒有模塊
IndentationError # 語法縮進錯誤
KeyboardInterrupt # ctrl+C
SyntaxError # 代碼語法錯誤
ValueError # 值錯誤
TypeError # 傳入對象類型與要求不符合
內建異常
BaseException # 所有異常的基類
SystemExit # python解釋器請求退出
KeyboardInterrupt # 用戶中斷執行
Exception # 常規錯誤的基類
StopIteration # 迭代器沒有更多的值
GeneratorExit # 生成器發生異常來通知退出
StandardError # 所有的內建標准異常的基類
ArithmeticError # 所有數值計算錯誤的基類
FloatingPointError # 浮點計算錯誤
OverflowError # 數值運算超出最大限制
AssertionError # 斷言語句失敗
AttributeError # 對象沒有這個屬性
EOFError # 沒有內建輸入,到達EOF標記
EnvironmentError # 操作系統錯誤的基類
IOError # 輸入/輸出操作失敗
OSError # 操作系統錯誤
WindowsError # windows系統調用失敗
ImportError # 導入模塊/對象失敗
KeyboardInterrupt # 用戶中斷執行(通常是ctrl+c)
LookupError # 無效數據查詢的基類
IndexError # 序列中沒有此索引(index)
KeyError # 映射中沒有這個鍵
MemoryError # 內存溢出錯誤(對於python解釋器不是致命的)
NameError # 未聲明/初始化對象(沒有屬性)
UnboundLocalError # 訪問未初始化的本地變量
ReferenceError # 若引用試圖訪問已經垃圾回收了的對象
RuntimeError # 一般的運行時錯誤
NotImplementedError # 尚未實現的方法
SyntaxError # python語法錯誤
IndentationError # 縮進錯誤
TabError # tab和空格混用
SystemError # 一般的解釋器系統錯誤
TypeError # 對類型無效的操作
ValueError # 傳入無效的參數
UnicodeError # Unicode相關的錯誤
UnicodeDecodeError # Unicode解碼時的錯誤
UnicodeEncodeError # Unicode編碼時的錯誤
UnicodeTranslateError # Unicode轉換時錯誤
Warning # 警告的基類
DeprecationWarning # 關於被棄用的特征的警告
FutureWarning # 關於構造將來語義會有改變的警告
OverflowWarning # 舊的關於自動提升為長整形的警告
PendingDeprecationWarning # 關於特性將會被廢棄的警告
RuntimeWarning # 可疑的運行時行為的警告
SyntaxWarning # 可疑的語法的警告
UserWarning # 用戶代碼生成的警告
觸發異常
raise exclass # 觸發異常,從exclass生成一個實例(不含任何異常參數)
raise exclass() # 觸發異常,但現在不是類;通過函數調用操作符(function calloperator:"()")作用於類名生成一個新的exclass實例,同樣也沒有異常參數
raise exclass, args # 觸發異常,但同時提供的異常參數args,可以是一個參數也可以是元組
raise exclass(args) # 觸發異常,同上
raise exclass, args, tb # 觸發異常,但提供一個跟蹤記錄(traceback)對象tb供使用
raise exclass,instance # 通過實例觸發異常(通常是exclass的實例)
raise instance # 通過實例觸發異常;異常類型是實例的類型:等價於raise instance.__class__, instance
raise string # 觸發字符串異常
raise string, srgs # 觸發字符串異常,但觸發伴隨著args
raise string,args,tb # 觸發字符串異常,但提供一個跟蹤記錄(traceback)對象tb供使用
raise # 重新觸發前一個異常,如果之前沒有異常,觸發TypeError
跟蹤異常棧
# traceback 獲取異常相關數據都是通過sys.exc_info()函數得到的
import traceback
import sys
try:
s = raw_input()
print int(s)
except ValueError:
# sys.exc_info() 返回值是元組，第一個exc_type是異常的對象類型，exc_value是異常的值，exc_tb是一個traceback對象，對象中包含出錯的行數、位置等數據
exc_type, exc_value, exc_tb = sys.exc_info()
print "\n%s \n %s \n %s\n" %(exc_type, exc_value, exc_tb )
traceback.print_exc() # 打印棧跟蹤信息
抓取全部錯誤信息存如字典
import sys, traceback
try:
s = raw_input()
int(s)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback_details = {
'filename': exc_traceback.tb_frame.f_code.co_filename,
'lineno' : exc_traceback.tb_lineno,
'name' : exc_traceback.tb_frame.f_code.co_name,
'type' : exc_type.__name__,
'message' : exc_value.message,
}
del(exc_type, exc_value, exc_traceback)
print traceback_details
f = file('test1.txt', 'a')
f.write("%s %s %s %s %s\n" %(traceback_details['filename'],traceback_details['lineno'],traceback_details['name'],traceback_details['type'],traceback_details['message'], ))
f.flush()
f.close()
調試log
# cgitb覆蓋了默認sys.excepthook全局異常攔截器
def func(a, b):
return a / b
if __name__ == '__main__':
import cgitb
cgitb.enable(format='text')
func(1, 0)
函數式編程的內建函數
apply(func[,nkw][,kw]) # 用可選的參數來調用func,nkw為非關鍵字參數,kw為關鍵字參數;返回值是函數調用的返回值
filter(func,seq) # 調用一個布爾函數func來迭代遍歷每個seq中的元素;返回一個使func返回值為true的元素的序列
map(func,seq1[,seq2]) # 將函數func作用於給定序列(s)的每個元素,並用一個列表來提供返回值;如果func為None,func表現為一個身份函數,返回一個含有每個序列中元素集合的n個元組的列表
reduce(func,seq[,init]) # 將二元函數作用於seq序列的元素,每次攜帶一堆(先前的結果以及下一個序列元素),連續地將現有的結果和下一個值作用在獲得的隨後的結果上,最後減少我們的序列為一個單一的返回值;如果初始值init給定,第一個比較會是init和第一個序列元素而不是序列的頭兩個元素
lambda x,y:x+y # 創建一個匿名函數 可用於上面幾種方法中直接創建匿名函數式
# filter 即通過函數方法只保留結果為真的值組成列表
def f(x): return x % 2 != 0 and x % 3 != 0
f(3) # 函數結果是False 3被filter拋棄
f(5) # 函數結果是True 5被加入filter最後的列表結果
filter(f, range(2, 25))
[5, 7, 11, 13, 17, 19, 23]
# map 通過函數對列表進行處理得到新的列表
def cube(x): return x*x*x
map(cube, range(1, 11))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
# reduce 通過函數會先接收初始值和序列的第一個元素，然後是返回值和下一個元素，依此類推
def add(x,y): return x+y
reduce(add, range(1, 11)) # 結果55 是1到10的和 x的值是上一次函數返回的結果，y是列表中循環的值
reduce(lambda x,y:x+y, range(1,11)) # 等同上面兩條 lambda來創建匿名函數[ lambda x,y:x+y ] ,後面跟可迭代的對象
編碼轉換
a='中文' # 編碼未定義按輸入終端utf8或gbk
u=u'中文' # 定義為unicode編碼 u值為 u'\u4e2d\u6587'
u.encode('utf8') # 轉為utf8格式 u值為 '\xe4\xb8\xad\xe6\x96\x87'
print u # 結果顯示 中文
print u.encode('utf8') # 轉為utf8格式,當顯示終端編碼為utf8 結果顯示 中文 編碼不一致則亂碼
print u.encode('gbk') # 當前終端為utf8 故亂碼
ord('4') # 字符轉ASCII碼
chr(52) # ASCII碼轉字符
設置讀取編碼為utf8 避免轉換出錯
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
遍歷遞歸
[os.path.join(x[0],y) for x in os.walk('/root/python/5') for y in x[2]]
for i in os.walk('/root/python/5/work/server'):
print i
元類
# 實現動態curd類的或者實例中的方法屬性
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Name: metaclass.py
# Author: ZhiPeng Wang.
# Created: 15/8/12
# Copyright: (c) TigerJoys-SA 2015
# -----------------------------------------------------------------------------
"""首先檢查__metaclass__屬性, 如果設置了此屬性, 如果設置了此屬性則調用對應Metaclass,
Metaclass本身也是Class 當調用時先調用自身的__new__方法新建一個Instance然後Instance調
用__init__返回一個新對象(MyClss), 然後正常執行原Class
"""
ext_attr = {
'wzp': 'wzp',
'test': 'test',
}
class CustomMeta(type):
build_in_attr = ['name', ]
def __new__(cls, class_name, bases, attributes):
# 獲取`Meta` Instance
attr_meta = attributes.pop('Meta', None)
if attr_meta:
for attr in cls.build_in_attr: # 遍歷內置屬性
# 自省, 獲取Meta Attributes 不是build_in_attr的屬性不處理
print "Meta:", getattr(attr_meta, attr, False)
# 擴展屬性
attributes.update(ext_attr)
return type.__new__(cls, class_name, bases, attributes)
def __init__(cls, class_name, bases, attributes):
super(CustomMeta, cls).__init__(class_name, bases, attributes)
class MyClass(object):
__metaclass__ = CustomMeta # metaclass
class Meta:
name = 'Meta attr'
if __name__ == '__main__':
# TODO 此處返回一個類｀Instance｀對象
print MyClass()
# TODO 此處返回一個類對象, 並不是｀Instance｀
print type("MyClass", (), {})
