python數據類型：（按特徵劃分）
數字類型：
整形：布爾形、長整型L、標準整形
非整形：雙精度型、複數、decimal（不是內建類型）
序列類型：
字符串（str）
元組（tuple）
列表（list）
映像類型：
字典（dict）
集合類型：
可變集合（set）
不可變集合（frozenset）
python數據類型（按可變性劃分）
可哈希的，不可變數據類型：
數字類型
不可變集合（frozenset）
字符串（str）
元組（tuple）
可變數據類型：
字典（dict）
列表（list）
可變集合（set）
python中引號的作用：
‘ ‘
“ “
''' '''
單引號和雙引號基本沒區別，同樣的作用；雙引號可以內嵌單引號。三引號作爲大段文字的註釋。
python的編解碼
ASCII
Unicode
UTF-8
python模塊
import moduleName：導入一個模塊
from module import functionName：從一個模塊中導入一個方法
import moduleName asnewModuleName：把一個模塊重新命名
python用戶交互：
使用內置函數：raw_input()，該函數接收一個字符串。
input()，該函數接收一個數字類型
python流程控制：
if … else …
split
strip
len()
for variable in range(1, 10):
while True:
break
continue
python練習：登錄測試賬號。
要求：輸入用戶名密碼；認證成功後顯示歡迎信息；輸錯三次後鎖定
python的基本語法、數據類型、導入模塊、流程控制。
python文件處理：
讀文件：代碼展示
f= file(‘filename.txt’, ‘r’)
forline in f.readlines():
line= line.strip(‘\n’).split(‘:’)
printline
文件處理模式：
r：以只讀模式打開文件
w：以只寫模式打開文件
a：以追加模式打開文件
r+b：以讀寫模式打開
w+b：以寫讀模式打開
a+b：以追加及讀模式打開
python字符串處理：
str.find(substring,[start [,end]]) #可指範圍查找子串，返回索引值，否則返回-1
str.rfind(substring,[start [,end]]) #反向查找
str.index(substring,[start [,end]]) #同find，只是找不到產生valueerror異常
str.rindex(substring,[start [,end]]) #同上反向查找
str.count(substring,[start [,end]]) #返回找到子串的個數
str.lowercase()
str.capitalize()首字母大寫
str.lower()轉小寫
str.upper()轉大寫
str.swapcase()大小寫互換
str.split(str,‘ ‘)將string轉list，以空格分割
str.join(list,’ ’)將list轉string，以空格分割
len(str)字符串長度
cmp(“myfriend”, str) 字符串比較。第一個大返回1
max(‘abcxyz’)尋找字符串中最大的字符
min(‘abcxyz’)尋找字符串中最小的字符
python中的列表：
list的方法：
list.append(var)追加元素
list.insert(index,var)
list.pop(var)返回最後一個元素，並從list中刪除
list.remove(var)刪除第一次出現的該元素
list.count(var)該元素在列表中出現的個數
list.index(var)該元素的位置，無則拋異常
list.extend(list2)追加list2，到list上。合併
list.sort()排序
list.reverse()元素順序反轉
list[1:]片段操作符，用於子list的提取
[1,2]+[3,4]爲[1,2,3,4]。同extend()
[2]*4爲[2,2,2,2]
dellist[1] 刪除指定下標的元素
dellist[1:3] 刪除指定下表範圍的元素
list= list1 list是list1的別名，內存地址相同，對list操作就是對list1的操作
list= list2[:] 生成list2的一個copy
python元組：
tuple：常量數組
tuple= (‘a’, ‘b’, ‘c’, ‘d’)
可以用list的[],:操作符提取元素，就是不能直接修改元素
little case：shopping。
初始化金錢數，商品種類、價格，選擇購買商品，直到錢不夠，退出時打印已購買的商品和剩餘金額。
開發文件替換小程序：
使用方法：
./pythonFile.py‘source string’ ‘replace string’filename.txt
./pythonFile.py‘source string’ ‘replace string’filename.txt --bak filename.txt.bak
python字典DICT：
dict.get(key,0) 同dict[key]，多了個沒有則返回默認值，0。[]沒有則拋出異常
dict.has_key(key)有該鍵返回True，否則False
dict.keys()返回字典鍵的列表
dict.values()以列表的形式返回字典中的值，返回值的列表中可包含重複元素
dict.items()將所有的字典項以列表方式返回，這些列表中的每一項都來自於(鍵，值)，但是項在返回時並沒有特殊的順序
dict.update(dict2)增加合併字典
dict.popitem()得到一個pair，並從字典中刪除它，已空則拋出異常
dict.clear()清空字典，同del dict
dict.copy()拷貝字典
dictNaNp(dict1,dict2) 比較字典，（優先級爲元素個數、鍵大小、鍵值大小
dict1= dict2 給dict2取個dict1的別名
dict2= dict.copy() 克隆，另一個拷貝
python中列表與字典的比較：
dict：
查找和插入的速度極快，不會隨着key的增加而速度變慢
需要佔用大量的內存，內存浪費多。
key不可變
默認無序
list：
查找和插入的時間隨着元素的增加而增加
佔用空間小，內存浪費少。
通過下標查詢
有序
python SET集合
特點：無序；元素不重複
功能：關係測試；去重
set集合運算：
a= set([1, 2, 3, 4])
b= set([3, 4, 5, 6])
a& b 求交集a.intersection(b)
a| b 求並集 a.union(b)
a– b 求差集a.difference(b)
a^ b 求對稱差集a.symmetric_difference(b)
a.issubset(b) a是b的子集
a.issuperset(b) a是否包含b
查詢員工信息：模糊查詢員工信息，顯示匹配的條數，匹配字符串高亮顯示。
python中目錄和python包的區別：就是包下包含一個__init__.py文件，而目錄沒有。
模塊的常用方法：
__name__
__file__
__doc__
python中的不定參數：參數前面帶一個或兩個*。
def fun(arg)
def fun(*args)
def fun(**args)
dict = {‘k1’:1, ‘k2’:2}
fun(1,2,3,4,)
fun(**dict)=fun(k1=’1’, k2=’2’)
元組和集合只有一個星號，字典是兩個星號
yield關鍵字：
yield的作用：在寫多線程的時候，可以用它創建一個線程池。什麼時候用，什麼時候拿。它是一個生成器，不是一下就給他創建了。它還能保存函數的執行狀態。
with關鍵字：
三元運算：
result = ‘human if 1>3 else ‘animal
result = animal
Lambda表達式：
a = lambda x, y: x+y
print a(4,10)
lambda的作用是：聲明一個函數，接收參數，返回參數的運算結果。
lambda是一個匿名函數。
內置函數
help()
dir()
vars()
type()
import temp
reload(temp)
id()
更多：http://www.cnblogs.com/wupeiqi/articles/4276448.html
在使用from file import module的時候多次導入不會執行，只執行第一次導入，如果要想再次導入的話，使用reload(module)再次導入模塊。
字符串的格式化佔位符：
str = ‘i am {0}’
print s.format(‘alex’)
i am alex
函數的調用：
顯示調用函數，直接寫出該函數。
隱式調用函數，Function(arg) apply(Function, (arg))
map()函數：遍歷每一個序列裏面的元素。序列裏面的每一個元素當作參數傳給第一個function參數。
map(function, sequce, [sequce, …..])
也可以使用lambda表達式：map(lambda arg:arg+10, li) li = [11, 22, 33]
filter() 過濾
reduce() 累加
apply()
zip()
eval()
__import__()
都是對序列裏面的函數進行操作，然後返回回來。
反射就是把你的導入工作當作字符串。
反射：用於開發大型程序，隨時可以切換數據庫的時候。設計模式裏面的工廠模式需要用到這個。降低程序的耦合。
通過字符串的形式導入模塊：（代碼）
temp = ‘mysqlhelper’
model = __import__(temp)
model.cont()
並以字符串的形式執行函數：（代碼）
temp = ‘mysqlhelper’
func = ‘count’
model = __import__(temp)
Funciton = getattr(model, func)
常用的模塊：
隨機數
random：
random(m)
randint(m, n)
randrange(m, n)
MD5加密
hash = hashlib.md5()
hash.update(‘admin’)
hash.hexdigest()
hash.digest()
序列化和json 序列化可以把一個對象和一個列表或字典，通過python特有的方式序列化一下，以二進制的方式加密一下。
import pickle
li = ['alex',11, 22, 'ok', 'sb']
printtype(pickle.dumps(li))
dumpsed =pickle.dumps(li)
print dumpsed
loadsed =pickle.loads(dumpsed)
print loadsed
printtype(loadsed)
pickle.dump(li,open('temp.pk' , 'w'))
printpickle.load(open('temp.pk', 'r'))
import json
j_str =json.dumps(data)
print j_str
withopen(‘file.json’, w’) as fp:
json.dump(data, fp)
RE 正則
六個函數：
compile match search findall group groups
match：只能從你給的字符串的起始位置去匹配
search：在整個字符串，在整個內容裏面去匹配
group：輸出匹配的結果。
常用格式：
\d匹配數字
\w
\t
次數： * + ? {m} {m,n}
time模塊
三種表示方法：
時間戳 1970.1.1之後的秒數
元組 包含了：年、日、星期等….time.struct_time
格式化的字符串 2014-11-11 11：11 print time.time()
time.mktime(time.localtime())
time.gmtime() 可加時間戳參數
time.localtime() 可加時間戳參數
time.strptime(‘2014-11-11’, ‘%Y-%m-%d’)
time.strftime(‘%Y-%m-%d’) 默認當前時間
time.strftime(‘%Y-%m-%d’, time.localtime()) 默認當前時間
time.asctime()
time.asctime(time.localtime())
time.ctime(time.time())
sys 模塊
sys.argv 命令行參數list， 第一個元素是程序本身路徑
sys.exit(n) 退出程序， 正常退出時exit(0)
sys.version 獲取python解釋程序的版本信息
sys.maxint 最大的int值
sys.maxunicode 最大的unicode值
sys.path 返回模塊的搜索路徑，初始化時使用pythonpath
sys.platform 返回操作系統平臺名稱
sys.stdout.write(‘please:’)
val = sys.stdin.readline()[:-1]
print val
OS 模塊
os.getcwd() 獲取當前工作目錄，即當前python腳本工作的目錄路徑
os.chdir(“dirname”) 改變當前腳本工作目錄；相當於shell下cd
os.curdir 返回當前目錄；(‘.’)
os.pardir 獲取當前目錄的父目錄字符串名：(‘..’)
os.makedirs(‘dirname1/dirname2’) 可生成多曾遞歸目錄
os.removedirs(‘dirname1’) 若目錄爲空，則刪除，並遞歸到上一
os.mkdir(‘dirname’) 生成單級目錄，相當於shell中mkdir dirname
os.rmdir(‘dirname’) 刪除單級空目錄，若目錄不爲空則無法刪除，
os.listdir(‘dirname’)
os.remove()
os.rename(“oldname”, “newname”)
os.stat(‘path/filename’)
os.sep
os.linesep
os.pathsep
os.name
os.system(“bash command”)
os.environ
os.path.abspath(path)
os.path.split(path)
os.path.dirname(path)
os.path.basename(path)
os.path.exists(path)
os.path.isabs(path)
os.path.isfile(path)
os.path.isdir(path)
os.path.join(path1[,path2…..])
os.path.getatime(path)
os.path.getmtime(path)
裝飾器（示例代碼）
def foo():
print ‘foo’
def foo():
print ‘before dosth’
print ‘foo’
print ‘after’
def foo():
print ‘foo’
def wrapper(func):
print ‘before’
func()
print ‘after’
wrapper(foo)
裝飾器
面向對象編程
異常處理
斷言
First. 裝飾器——也是一個函數，通過這個函數裝飾另一個函數。
def outer(fun):
def wrapper():
fun()
return wrapper
@outer
def fun1():
print ‘hello’
#後面還有無窮個函數。
func1()
@outer相當於@outer=outer(func1) func1沒有括號就代表這個函數，func1()帶有括號就代表執行了這個函數，結果不一樣的。
如果被調用的fun1函數帶有參數，該參數放在defwrapper(arg)裏面。帶有參數的代碼：
def outer(fun):
def wrapper(arg):
fun(arg)
return wrapper
@outer
def fun1():
print ‘hello’, arg
#後面還有無窮個函數。
func1(‘alex’)
如果func1有返回值的：
def outer(fun):
def wrapper(arg):
result = fun(arg)
return result
return wrapper
@outer
def fun1():
print ‘hello’, arg
return ‘eric’
#後面還有無窮個函數。
request= func1(‘alex’)
printrequest
second. 面向對象：
類就是一個抽象
實例化一個類就是一個對象，對象裏面有屬性和方法。
類裏面的__init__方法，就是一個對象的初始化。相當於java中的構造函數。
定義一個類：
class Person:
name = ‘這是一個人’
def __init__(self, name):
self.name = name
pp= Person(‘alex’)
printpp.name
printPerson.name
self代表的就是一個實例化對象。就像上面的代碼，self就代表的pp這個對象。
定義在類裏面的屬性，屬於類的，不屬於對象，直接可以使用使用類名.屬性名調用，如：上段代碼中的Person.name。
屬於類的字段稱爲靜態字段。通過self調用的稱爲動態字段（比如說：在__init__中調用的字段）。
類不能直接訪問對象的屬性，對象可以直接訪問類的屬性。
在一個類中定義靜態方法的辦法：直接在方法上面添加@staticmethod，去掉方法中的self。因爲self代表的是一個對象。
在類中定義的靜態方法可以使用類來調用，也可以使用對象來調用。
對象的屬性：在類中定義一個方法，在該方法上添加@property， 就把該方法變成了對象的一個屬性。訪問的方式：對象名.屬性名 pp.property 後面沒有小括號。
這個靜態方法什麼時候用：
Python中的私有方法和私有字段：都是以雙下劃線__ 開頭的。
私有方法
也是通過在內部定義一個公有的方法，該公有的方法調用該私有方法，在外部調用該公有的方法間接的訪問該私有方法。
強制訪問私有方法的辦法是：對象調用這個類的私有方法。具體是：
對象名._類名__私有方法名()。objName._class__privateFunctionName()
私有字段
在類中定義了私有字段，外部是不能訪問的，只能通過在內部定義函數訪問這個私有字段，外部調用該函數間接的訪問該私有字段。
訪問私有字段代碼：
@property
def Thailand(self):
return self.__Thailand __Thailand是之前定義的一個私有字段。
objName.Thailand 調用該對象的這個方法來訪問私有字段。
私有字段一般用在不讓別人改，但是可以訪問的情況下。
對象的屬性的只讀和可改寫：它們使用的裝飾器不一樣。 代碼：
（只讀的）
@property
defThailand(self):
return self.__Thailand
（可改寫的） 推薦使用私有字段的操作方式：
classClassName(object):
def __init__(self, __Thailand)
@Thailand.setter 還得讓這個類繼承object
def Thailand(self, value):
self.__Thailand = value 把__Thailand這個私有字段改寫成了value這個值了
析構函數：就是python解釋器在銷燬對象的時候，我們可以乾點啥，就可以寫在這個析構函數裏面。就是這個__del__
__call__方法：就是創建對象的時候，調用類中的__call__方法，在對象中使用對象名加上()即可。
classFoo():
def __call__(self):
print ‘我就是__call__方法。’
f1= Foo()
f1() --à直接調用對象中的__call__方法。
Foo()()的效果就等於 f1=Foo() f1()，這兩步
繼承：
在創建子類的時候在子類名後面的括號裏寫上父類的名字，就繼承了父類。
方法的重寫（override）：發生在類的繼承中，子類重寫父類的方法。
方法的重載（overload）：發生在本類中，兩個重名的函數，根據參數的不同，而重載
子類調用父類的構造函數（也就是父類的__init__函數）：兩種方法：
顯示調用：Father.__init__(self)
隱式調用：super(son,self).__init__() 此種方法需要申明父類繼承自object
繼承自object的類稱爲新式類，未繼承自object的類稱爲經典類。
多繼承：如果在多繼承中，多個父類含有同一函數的話，就從最左邊的父類找到該函數並執行。
抽象類：代碼如下：
from abc import ABCMeta, abstractmethod
class Bar:
__metaclass__ = ABCMeta
@abctractmethod
def fun(self): pass
class Foo(Bar):
def __init__(self):
print‘__init__’
Foo()
python中的接口：沒明確講解。
Third. python中的異常處理：
使用的是
try:
xxxxxxx
except Exception, e:
xxxxxx
else:
print ‘沒有出錯。’
finally:
print ‘這裏的代碼無論如何都會執行。’
自定義的異常類：
class MyException(Exception):
def__init(self, msg):
self.error= msg
def__str__(self, *args, **kwargs):
returnself.error
主動觸發異常：使用raise關鍵字
raiseMyException(‘自定義錯誤’)
爲什麼要主動觸發異常：
Fourth. 斷言
python中的斷言：assert(1 == 1)
python操作mysql數據庫
socket
python操作mysql數據庫。
首先使用connect函數連接mysql，使用cursor獲一個句柄，使用execute執行一條mysql語句，fetchall獲得該數據庫裏面數據表的所有數據，然後關閉句柄和連接。
把sql語句定義爲一個字符串變量，把裏面的值使用格式化字符串的形式傳遞一個%s，如：
sql = “insert into userinfo values(%s, %s) 這裏面的佔位符只能是%s.
params = (‘bababa’, ‘M’)
reCount = cur.execute(sql, params)
涉及到數據庫增刪改的時候需要調用commit()方法。
connect.commit()
完整的代碼：
importMySQLdb
connect =MySQLdb.connect(host=’localhost’, user=’root’, passwd=’root’, db=’dbname’)
current =connect.cursor()
sql = “insertinto tname(col1, col2, …) values(%s, %s, …)”
params =(‘val1’, ‘val2’)
reCount =cur.execute(sql, params)
data =cur.fetchall() 獲取所有數據
conn.commit() 與事務相關
conn.rollback() 與事務相關
cur.close()
connect.close()
print reCount
print data
獲取mysql的id值的函數：lastrowid
python項目的三層架構思想
數據訪問層， 業務邏輯層， 應用層。
socket編程：
使用：異步、多線程、socket 處理多個請求的服務端。
SocketServer：把 異步，多線程 做了處理。
用socketserver和不用socketserver的區別：
使用socketserver不會有阻塞，處理多個請求，可以多個客戶端連接。
不使用socketserver效果相反。
在之後的所有socket編程都使用socketserver庫。
線程
進程
ftp服務器
paramiko庫
ftp服務器就是使用socketserver庫建立一個ftp服務器數據的傳輸。
線程：python中的多線程：
使用threading.Thread模塊。常用的方法有：
–start
–getName()
–setName()
–isDaemon()
–setDaemon()
–join(timeout)主線程啓動了子線程後，一直等到子線程執行結束，再執行主線程的其他東西。加了timeout後，就是主線程等到timeout時間後或者子線程執行結束，再執行主線程。
–run()
使這個線程與某件事情建立關係，使用target傳遞參數。
t1= Thread(target=function, args=(1, ))
target=function,這個是傳遞的某個方法，args=(1,)) args是傳遞該方法中的參數， 參數傳遞完畢後需要接一個逗號，
代碼示例：
defFoo(arg, v):
foritem in range(100):
printitem
time.sleep(1)
print‘before’
t1= Thread(target=Foo, args=(‘ddfdfdffd’,11, ))
t1.setDaemon(True)
t1.start()
自建線程類：新建類繼承Thread
classMyThread(Thread):
defrun(self):
print‘I am a thread.’
執行線程，其實就是調用了Thread類中的run方法。
線程安全的問題，使用鎖的功能：線程鎖，能很好的保護線程安全。
線程安全：隊列
隊列：先進先出
線程棧：後進先出
多線程的使用：python不是一個線程安全語言，需要自己控制。
生產者消費者模型： 生產者生產一個放到隊列或者棧裏面，然後消費者從隊列或棧裏面取一個。
線程安全的問題： 使用線程鎖
lock = threading.Lock()定義一個鎖
lock.acquire()獲取鎖 給需要加鎖的代碼加鎖。
加鎖的代碼執行完後要釋放鎖：lock.release()
python中防止死鎖：定義鎖的時候使用遞歸鎖。
lock = threading.Rlock()
信號量：同時執行的線程幾個。
samp = threading.BoundedSemaphore(n)
異步：
paramiko模塊的使用：sshlinux主機批量管理。
ssh的rsa原理：使用非對稱加密。
公鑰：在服務器端做加密。
私鑰：在客戶端做解密。
多進程
Paramiko
審計開發
select異步模型
進程：使用multiprocessing模塊的Pool類。
多進程多線程可以繞過GlobalInterpreter Lock（全局解釋器鎖）
多進程示例代碼：
frommultiprocessing import Pool
deff(x):
returnx*x
if__name__ == ‘__main__’:
p= Pool(5)
print(p.map(f,[1,2,3]))
創建多個子進程的方法2，示例代碼：
frommultiprocessing import Process
importos
definfo(title):
ifhasattr(os, ‘getppid’):
print‘parent process:’, os.getppid()
print‘process id:’, os.getpid()
if__name__ == ‘__main__’:
info(‘mainline’)
p= Process(target = f, args = (‘bbbbb’, ))
p.start()
p.join()
進程間通信：使用隊列。
frommultiprocessing import Process,Queue
進程間同步：加上鎖，使用Manager()方法。也可以使用Value和Array
進程池：通過Pool創建多進程。
python異步：select vs poll&epoll 異步IO
審計工具：web工具：shellinabox
第8天的主要內容：實戰練習：python開發一個類似nagios的監控軟件。
python的 socket 開源框架：twistedmatrix
主題：使用PYTHON開發類Nagios監控軟件
知識點：
1. 使用Reids發佈\訂閱功能做服務器和客戶端的通信通道
2. 利用面向對象思想開發監控模板
3. 實現監控項目插件化，允許用戶自行開發監控插件
需求：
1. 每個客戶端需要監控的服務不同
2. 每個服務的監控間隔不同
3. 允許模板的形式批量修改監控指標
4. 不同設備的監控閥值不同
5. 可自定最近n分鐘內hit\max\avg\last\... 指標超過閾值
6. 報警策略、報警等級、報警自動升級
7. 歷史數據的存儲和優化
8. 跨機房、區域代理服務器
1000*20=20000 總指標，沒5分鐘一次，
1hour = 24W
1day = 576W *4Byte、
Cpu :iowait 20 idle 80 system 30 user 50
What the client side has to know before itcan invoke a plugin?
Answer: plugin_name \ interval \service name
python web框架 Django
Controller：該模型裏面存放的是一組對業務邏輯的描述代碼。
Model：該模型裏面存放的是一組對數據庫進行操作的代碼。
View：該模型裏面存放的是一組html文件。
http://www.cnblogs.com/wupeiqi/articles/4491246.html
創建django程序，使用IDE創建一個django application，並配置運行參數。