一、字符串
str='這是一個字符串數據測試數據'對應
str[0]：獲取str字符串中下標爲0的字符。
str[3]：獲取str字符串中下標爲3的字符。
str[0:3]：獲取到字符串中從下標爲0到下標爲3的字符串。
str.find()：返回指定str字符串中是否存在指定的字符串數據信息；若是存在則返回字符串首字母的下標，若是不存在則返回-1。
str.index()：返回指定str字符串中是否存在指定的字符串數據信息；若是存在則返回字符串首字母的下標，若是不存在進行錯誤異常處理。
str.count()：返回指定str字符串中被查找字符串存在的個數信息。
len(str)：返回指定str字符串的字符總長度；若是字符串爲空，則返回值爲0。
str.replace('替換前字符','替換後字符'，指定替換的次數)：進行指定str字符串中指定字符數據的替換操做，並將替換後的數據進行返回。
str.split(" ",切割次數):進行指定字符串的切割，返回被切割後的字符串列表數據信息；若是切割次數不填，默認進行最大的切割次數。
str.capitalize()：將指定str字符串的第一個字符進行大寫。
str.startswith(匹配字符串數據)：返回boolen類型，匹配指定str字符串是否以指定字符串數據開頭。
str.endswith(匹配字符串數據)：返回boolen類型，匹配指定str字符串是否以指定字符串數據結尾。
str.lower()：將指定的字符串數據信息進行統一的小寫轉換並返回轉換後的數據。
str.upper()：將指定的字符串數據信息進行統一的大寫轉換並返回轉換後的數據。
str.ljust(指定返回的字符串長度)：返回一個字符串，將指定str進行左對齊，若是str字符串長度小於指定的長度，則進行右側的空格補充操做。
str.rjust(指定返回的字符串長度)：返回一個字符串，將指定str進行右對齊，若是str字符串長度小於指定的長度，則進行左側的空格補充操做。
str.center(制定返回的字符串長度)：返回一個字符串，將制定str進行中間對齊，若是str字符串長度小於指定的長度，則進行兩邊的空格的補充操做。
str.lstrip()：返回字符串，刪除左側的空格。
str.rstrip()：返回字符串，刪除末尾的空格。
str.rfind()：相似find函數，從指定字符串的右側開始進行查找，返回查找到的字符串第一個字符的下標。
str.rindex()：相似index函數，從指定str字符串的左側開始進行查找，返回查找到的字符串第一個字符串下標。
str.partition(指定分割的字符串)：從指定str字符串中，查找制定分割的字符串，返回一個列表包含它的前面部分，它自身和它的後面部分；若是字符串的匹配沒有成功，則返回它自身和先後兩個空字符。
str.rpartition(指定分割的字符串)：相似partition函數，只是指定的分割字符串是從右開始查找的。
str.splitlines()：進行行分割，返回一個列表，以每行數據做爲一個元素進行保存。
str.isdigit()：返回boolen類型，判斷指定str字符串中的數據是否爲字母或數字。
str.isalpha()：返回boolen類型，判斷指定str字符串中的數據是否爲純字母。
str.isalnum()：返回boolen類型，判斷指定str字符串中的數據是否爲純數字。
str.isspace()：返回boolen類型，判斷指定str字符串中的數據是否只包含空格。
str.isupper()：返回boolen類型，判斷指定str字符串中的數據是否爲純大寫。
str.islower()：返回boolen類型，判斷指定str字符串中的數據是否爲純小寫。
mystr.join(str)：將類表mystr中的數據，根據指定的str字符串進行拼接操做；返回拼接後的字符串數據信息。
print("%0.1f",float(result*1.0))：進行浮點數的轉換，並打印小數點後一位的數據
print("%d*%d=%d"%(j,i,i*j),end=' ')：結束最後的換行
二、文件流
文件流對應的基礎操做：
f=open('文件名','訪問模式')；if f：返回boolen類型，判斷文件是否打開。
w：打開一個文件只用於寫入；若是該文件已經存在則將其覆蓋；若是該文件不存在，則建立一個新的文件。
r：以只讀的方式打開文件；文件的指針將會放在文件的開頭；這個是默認模式。
a：打開一個文件用於追加；若是該文件已存在，文件指針將會放在文件的結尾；也就是說，新的內容將會被寫入到已有內容以後。若是該文件不存在，建立新文件進行寫入。
rb：以二進制格式打開一個文件用於只讀，文件指針將會放在文件的開頭。這是默認模式。
wb：以二進制格式打開一個文件用於寫入，若是該文件已存在則將其進行覆蓋。若是該文件不存在則建立新文件。
ab：以二進制格式打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容以後；若是該文件不存在，建立新文件進行寫入操做。
r+：打開一個文件用於讀寫；文件指針將會放在文件的開頭。
w+：打開一個文件用於讀寫；若是噶文件已存在則將其覆蓋。若是該文件不存在，建立新文件
a+：打開一個文件用於讀寫；若是該文件存在，文件指針將會放在文件的結尾。文件打開時會是追加模式。若是該文件不存在，建立新文件用於讀寫。
rb+：以二進制格式打開一個文件用於讀寫；文件指針將會放在文件的開頭。
wb+：以二進制格式打開一個文件用於讀寫；若是該文件已存在則將其覆蓋。若是該文件不存在，建立新文件。
ab+：以二進制格式打開一個文件用於追加；若是該文件已存在，文件指針將會放在文件的結尾；若是文件不存在，建立新文件用於讀寫。
f.close()：文件流操做結束後進行關閉。
f.wirte(寫入的內容)：打開文件後，將指定內容寫入文件中。
f.read(讀取數據的長度)：使用read能夠從文件中讀取指定長度的數據，並將指針移到這條數據以後；默認讀取所有數據。
f.readline()：讀取文件中一行數據的信息，指針移動的下一行。
f.readlines()：讀取整個文件的數據信息信息，返回一個列表，列表中每一個元素爲一行數據的信息。
f.tell()：查看當前位置，就是指針對應的位置。
seek(offset,from)：將指針定位到某個位置
from：方向
0：表示文件的開頭。
1：表示文件的當前位置。
2：表示文件的末尾。
offset：偏移量
測試
f.seek(5,0)：文件開頭，向後偏移5個位置
f.seek(-3,2)：文件結尾，向前偏移3個位置
三、列表、字典、元組操做
一、列表:
strList=['']：列表的建立。
str='字符串'
newStr='新的字符串'。
strList.append：進行列表數據信息的添加操做。
strList[0]=newStr：根據下標，進行列表指定元素數據信息的修改操做
str in strLsit：返回boolen類型，指定字符串信息是否在列表中存在。
for item in strList：進行列表數據的遍歷操做，item爲元素值
del strList[0]：根據列表下標，刪除指定的列表元素。
strList.pop()：刪除列表最後一個元素的數據信息。
strList.remove('元素的值')：根據元素的值進行刪除操做。
二、字典：
修改元素：根據Key值進行修改
添加元素：infor['age']=18
刪除元素：del
清空字典中的數據信息：infor.clear
三、字典的常見操做
dic={1:'xiaohao',2:'xiaodong'}：建立一個字典對象。
dic.keys()：獲取字典全部對應的鍵，以列表的形式進行返回。
dic.valuses()：獲取字典全部對應的值，以列表的形式進行返回。
dic.items()：獲取字典中的鍵值數據，以列表的形式返回，每一個元素都一個元組，分別存放着鍵和值。
dic.has_key(1)：返回boolen類型，判斷鍵值是否存在
四、元組：
tuple=(1,2,3,4,5)：建立一個元組。
tuple[2]：根據下標讀取到第三個元素。
tuple[-2]：根據下標讀取到倒數第二個元素。
tuple[1:]：截取元組第二個元素到最後。
cmp(tuple1,tuple2)：比較兩個元組中的元素。
max(tuple)：返回元組中元素的最大值。
min(tuple)：返回元組中元素的最小值。
tuple(seq)：將列表轉換爲元組。
五、運算符操做列表、字典、元組的技巧：
一、len((1,2,3,4))：獲取到元組中元素的個數。
二、(1,2,3,4) +(1,2,3,4,5) ；進行兩個元組的合併，獲取到一個新的元組。
三、['Hi']*4：建立一個新的列表，並將列表中的數據進行復制四次。
四、1 in (1,2,3,4)：判斷元素是否存在；返回boolen類型。
四、異常捕獲
定義：某些錯誤操做致使程序沒法正常運行
異常捕獲：
try：
except(NameError,IOError),result：
print(result)#返回具體的錯誤信息
else：
print("我是else")
finally:
print("我是finally")
五、range：獲取
一、help(range):
range(stop) -> list of integers
range(start, stop[, step]) -> list of integers
二、參數分析：
一、start:計數從start開始。默認是從0開始。例如range（5）等價於range（0， 5）。
二、stop:到stop結束，但不包括stop.例如：range（0， 5） 是[0, 1, 2, 3, 4]沒有5。
三、step:每次跳躍的間距，默認爲1。例如：range（0， 5） 等價於 range(0, 5, 1)。
三、示例：
a = range(5)
list(a)
六、map：函數
一、help(map):
map(...)
map(function, sequence[, sequence, ...]) -> list
二、參數分析：
一、function:是一個函數
二、sequence:是一個或多個序列,取決於function須要幾個參數
三、返回值是一個list
三、語法：
參數序列中的每個元素分別調用function函數，返回包含每次function函數返回值的list。
四、示例
#函數須要一個參數
map(lambda x: x*x, [1, 2, 3])
[1, 4, 9]
#函數須要兩個參數
map(lambda x, y: x+y, [1, 2, 3], [4, 5, 6])
[5, 7, 9]
#函數爲None,至關於合併參數爲元祖
map(None, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]
#兩個序列參數個數不一致時，個數少的補None
map(None, [1, 3, 5, 7, 9], [2, 4, 6])
[(1, 2), (3, 4), (5, 6), (7, None), (9, None)]
七、filter：函數
一、help(filter):
filter(...)
filter(function or None, sequence) -> list, tuple, or string
Return those items of sequence for which function(item) is true. If
function is None, return the items that are true. If sequence is a tuple
or string, return the same type, else return a list.
二、參數分析：
一、function:接受一個參數，返回布爾值True或False
二、sequence:序列能夠是str，tuple，list
三、語法
filter函數會對序列參數sequence中的每一個元素調用function函數，最後返回的結果包含調用結果爲True的元素。返回值的類型和參數sequence的類型相同
四、示例
filter(lambda x: x%2, [1, 2, 3, 4])
[1, 3]
filter(None, "she")
'she'
八、reduce：函數
一、help(reduce):
reduce(...)
reduce(function, sequence[, initial]) -> value
Apply a function of two arguments cumulatively to the items of a sequence,
from left to right, so as to reduce the sequence to a single value.
For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
((((1+2)+3)+4)+5). If initial is present, it is placed before the items
of the sequence in the calculation, and serves as a default when the
sequence is empty.
二、參數分析：
一、function:該函數有兩個參數
二、sequence:序列能夠是str，tuple，list
三、initial:固定初始值
三、語法
reduce依次從sequence中取一個元素，和上一次調用function的結果作參數再次調用function。 第一次調用function時，若是提供initial參數，會以sequence中的第一個元素和initial 做爲參數調用function，不然會以序列sequence中的前兩個元素作參數調用function。 注意function函數不能爲None。
四、示例
reduce(lambda x, y: x+y, [1,2,3,4])
10
reduce(lambda x, y: x+y, [1,2,3,4], 5)
15
reduce(lambda x, y: x+y, ['aa', 'bb', 'cc'], 'dd')
'ddaabbcc'
九、sorted：函數
一、help(sorted):
sorted(...)
sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list
二、參數分析：
自定義cmp比較函數，返回三種狀況：
x<y 返回-1
x>y 返回1
x==y 返回0
三、示例
def cmp_ignore_case(s1, s2):
u1 = s1.upper()
u2 = s2.upper()
if u1 < u2:
return -1
if u1 > u2:
return 1
return
-------------------系統庫函數，幫助文檔查找-------------------
一、庫函數：print()、raw_input() 系統給的叫庫函數
二、用戶自定義函數：若是系統中，沒有須要的功能，那麼此時就須要本身開發一個，這就是自定義函數
三、ipython下：
dir(包名)：查看該包下的對應的函數信息
help(包名)：查看該包中的分裝的函數信息
包名.path：能夠獲取到指定包對應的文件路徑
-------------------builtins：內建函數默認加載-------------------
-------------------os：操做系統接口-------------------
import os引用系統的包
os.name()：判斷如今正在使用的平臺，widows返回'nt'；Linux返回'posix'。
os.getcwd()：獲得當前工做的目錄。
os.listdir()：指定全部目錄下全部的文件和目錄名。
os.remove()：刪除指定文件。
os.rmdir()：刪除指定目錄。
os.mkdir()：建立目錄，只能創建一層。
os.makedirs()：遞歸建立目錄。
os.path.isfile()：判斷制定對象是否爲文件。是返回True，不然False。
os.path.isdir()：判斷指定對象是否爲目錄。是True，不然False。
os.path.exists()：檢驗指定的對象是否存在。是True，不然False。
os.path.split()：返回路徑的目錄和文件名。
os.getcwd()：得到當前工做的目錄。
os.system()：執行shell命令。
os.chdir()：改變目錄到指定目錄。
os.path.getsize()：得到文件的大小，若是爲目錄，返回0。
os.path.abspath()：得到絕對路徑。
os.path.join(path,name)：鏈接目錄和文件名。
os.path.basename(path)：返回文件名。
os.path.dirname(path)：返回文件路徑。
-------------------sys：Python自身的運行環境-------------------
import sys引用系統的包
sys.stdin
sys.argv[i]：獲取到執行文件時，對應的參數信息
-------------------functools：經常使用的工具-------------------
一、概念：
functools 是python2.5被引人的,一些工具函數放在此包裏。
二、操做：
一、import functools ：引用對應的包
二、dir(functools) ：查看包中對應的工具函數
一、partial函數（偏函數）：
一、概念：
把一個函數的某些參數設置默認值，返回一個新的函數，調用這個新函數會更簡單。
二、示例：
import functools
def showarg(*args, **kw):
print(args)
print(kw)
p1=functools.partial(showarg, 1,2,3)
p1()
p1(4,5,6)
p1(a='python', b='itcast')
p2=functools.partial(showarg, a=3,b='linux')
p2()
p2(1,2)
p2(a='python', b='itcast')
二、wraps函數：
一、概念：
使用裝飾器時，有一些細節須要被注意。例如，被裝飾後的函數其實已是另一個函數了（函數名等函數屬性會發生改變）。Python的functools包中提供了一個叫wraps的裝飾器來消除這樣的反作用
二、示例：
import functools
def note(func):
"note function"
@functools.wraps(func)
def wrapper():
"wrapper function"
print('note something')
return func()
return wrapper
@note
def test():
"test function"
print('I am test')
test()
print(test.__doc__)
-------------------json：編碼和解碼 JSON 對象-------------------
-------------------logging：記錄日誌，調試-------------------
-------------------fork/multiprocessing：多進程-------------------
import os ：
一、pid=os.fork()：程序執行到os.fork()時，操做系統會建立一個新的進程（子進程），而後複製父進程的全部信息到子進程中；而後父進程和子進程都會從fork()函數中獲得一個返回值，其進程中這個值必定是0，而父進程中是子進程的 id號；主：fock()函數只能在Unix/Linux/Mac上運行，windows不能夠運行。
import os
# 注意，fork函數，只在Unix/Linux/Mac上運行，windows不能夠
pid = os.fork()
if pid == 0:
print('哈哈1')
else:
print('哈哈2')
os.getpid()：獲取到當前進程的PID號
os.getppid()：獲取到父進程的PID號
二、進程建立的第二種方式：
from multiprocessing import Process：引用對應的包。
p=Process(target=run_proc,args=('test',))：調用Process類，進行進程對象的建立操做。爲參數target賦值進程要實現的方法，爲參數args賦值方法中傳入對應的參數。
p.start()：開啓執行對應的進程操做。
p.join()：等待當前進程執行結束，能夠等待子進程結束後再繼續向下運行，一般用於進程間的同步。
multiprocessing.cpu_count()：獲取到進程執行的所使用的cpu的內核個數。
pipe=multiprocessing.Pipe()：管道實現進程間的通信。一個管道有兩個端口，分別爲pipe[0]與pipe[1]
pipe[0].send(向管道中添加的數據)：管道的添加操做。
pipe[0].recv()：從管道中取出對應的數據信息。
三、from multiprocessing import Process,Queue：應用對應的包，爲實現進程之間的通訊操做；管道的倆個端一個是負責向裏面寫入數據，一個是負責向外面讀取數據。
q=Queue()：建立一個隊列對象。
q.put(要添加到隊列中的數據信息)：將制定的數據添加到隊列當中去。
q.get(True)：從隊列中要提取出的隊列數據信息。
q.empty()：判斷當前隊列是否爲空。
-------------------threading：多線程-------------------
一、線程應用的第一種模式thread模塊是比較底層的模塊
import thread：引用對應的模塊包。
thread.start_new_thread(defName,())建立開啓一個新的線程；第一個參數爲新線程要執行的方法，第二個參數爲元組傳遞執行方法對應須要參數；注：python元組爲一個時須要(元素,)一個元素加一個'，'進行表示。
thread.exit_thread()：主線程調用該方法表示全部的線程結束操做；子線程經過調用exit.thread()的方法來表示實現當前子線程的結束操做。
thread.join()： python的Thread類中還提供了join()方法，使得一個線程能夠等待另外一個線程執行結束後再繼續運行。這個方法還能夠設定一個timeout參數，避免無休止的等待。由於兩個線程順序完成，看起來象一個線程，因此稱爲線程的合併
thread.setDaemon(True)：默認狀況主線程退出時會等待子線程的結束，若是但願主線程不等待子線程，能夠設置子線程爲後臺線程，主線程退出，子線程隨即結束。
二、線程應用的第二種模式threading模塊是對thread模塊進行了必定的封裝，能夠更方便咱們的使用。
import threading：引用對應的模塊包。
myThread=threading.Thread(target=defName,args=('Alice',))建立一個線程，target賦值要執行線程的方法，args複製執行方法須要的參數信息。
myThread.start()：線程開始執行。
num=len(threading.enumerate)：查看當前執行的線程的數量。
三、線程的應用的第三種方式建立一個線程類，繼承基類threading.Thead；重寫基類的def run(self):方法，將該線程要執行的程序寫在該方法中。
class MyThread(threading.Thread)：建立一個線程類
進行基類構造函數的建立操做
def __init__(self,name,time):
threading.Thread.__init__(self,name='能夠爲線程的名字進行復制')
myThread=MyThread()：線程對象的建立。
myThread.start()：該線程執行。
四、threading模塊中定義了Lock()類，能夠方便的處理鎖定。
mutex=threading.Lock()：互斥鎖對象的建立。
if mutex.acquire([blocking])：進行鎖定，鎖定成功後返回true；鎖定方法acquire()能夠有一個blocking參數。若是設定blocking爲True，則當前線程會堵塞，直到獲取到這個鎖爲止（若是沒有指定，那麼默認爲True）；若是設定blocking爲False，則當前線程不會堵塞。
mutex.release()：執行完程序內容後進行鎖的釋放操做。
五、支持同一線程屢次請求同一資源，python提供了可重入鎖。RLock對象中，同時維護着一個Lock和一個counter變量；counter變量存儲acquire的次數，從而使得資源能夠屢次被acquire；直到一個線程中的全部的acquire被release，其餘的線程才能夠得到資源
mutex=threading.RLock()：建立可重入鎖對象。
mutex.acquire()：進行上鎖。
mutex.release()：進行釋放。
六、python提供的Condition對象提供了對複雜線程同步問題的支持；Condition被稱爲條件變量；Condition維護着一個鎖和一個waiting池。
con=threading.Condition()：建立條件變量對象；能夠接受一個Lock/RLock對象做爲參數，若是沒有指定則內部默認建立一個RLock
con.acquire()：進行加鎖。
con.wait()：線程會釋放Condition內部的鎖並進入blocked（堵塞）狀態，同時在waiting池中記錄這個線程。
con.notify()：Condition對象會從waiting池中挑選一個線程，通知其調用acquire方法嘗試取到鎖。
con.notifyAll()：Condition對象通知waiting池中全部的線程，嘗試acquire內部鎖。做用防止有的線程永遠處於沉默狀態。
con.release()：進行釋放。
threading.Event能夠是一個線程等待其餘線程的通知。其內置了一個標誌，初始值爲False。線程經過wait()方法進入等待狀態，直到另外一個線程調度set()方法將內置標誌設置爲True是，Event通知全部等待狀態的線程回覆運行。還能夠用isSet()方法查詢Event對象內置狀態的當前值。
event=threading.Event()：進行對應Envent對象的建立。
def __init__(self,threadName,event):
self.threadEvent=event ：重構對應threading.Thread基類中__init__的方法。
self.threadEvent.wait()：使線程進入等待狀態。
event.set()：啓動waiting池中等待的線程。
-------------------Queue：隊列-------------------
from Queue import Queue：引用對應的模塊包。
queue=Queue()：建立一個隊列對象。
queue.qsize()：獲取隊列中元素的數量。
queue.put(向隊列中添加的數據)：想隊列中添加元素。
queue.set()：從隊列中取出元素。
queue.empty()：判斷隊列是否爲空。
-------------------copy：拷貝-------------------
-------------------time：時間-------------------
-------------------datetime：日期和時間-------------------
-------------------calendar：日曆-------------------
-------------------hashlib：加密算法-------------------
-------------------random：生成隨機數-------------------
import random：引用對應的包
random.random()：默認在0到1之間隨機獲取數據信息。
random.uniform(1,5)：1到5之間隨機獲取對應的數值；包含小數部分。
random.randint(10.50)：10到50之間對應隨機獲取對應的整數
random.randrange(0,51,2)：0到51之間對應隨機獲取對應的3的倍數
-------------------re：字符串正則匹配-------------------
import re：引用對應的包
result=re.match(正則表達式，要匹配的字符串)：從第一個字符向後依次進行正則匹配操做，匹配出對應的數據信息。
result.group()：若是上一步匹配到數據的話，可使用group方法來提取數據。
result=re.search(正則表達式，要匹配的字符串)：從匹配到的第一個字符向後依次進行匹配操做。
result==None：判斷獲取的書數據是否爲空。
re.search(r'\d+','my hight 177 cm').group()：匹配出指定字符串中符合正則表達式的第一條數據（只能匹配一個）。
re.findall(r'\d+','my hight 177 cm my weight 100 kg')：配匹配出指定字符串中全部符合正則表達式的有效數據，並以列表的形式進行返回。
re.sub(r'\d+','100','my high 177 cm')：將匹配到的數據進行替換，參數：對應的正則表達式，要替換的數據，匹配出來的數據；
方法一：
#coding=utf-8
import re
ret = re.sub(r"\d+", '998', "python = 997")
print ret
返回結果：998
方法二：
#coding=utf-8
import re
def add(temp):
strNum = temp.group()
num = int(strNum) + 1
return str(num)
ret = re.sub(r"\d+", add, "python = 997")
print ret
ret = re.sub(r"\d+", add, "python = 99")
print ret
返回結果：100
re.split(r':| ','address:beijing xxx@126.com')：根據匹配進行切割字符串，並返回一個列表。案例：根據：或空格進行字符串的切割操做，結果：['address','beijing','xxx@126.com']
-------------------socket：標準的 BSD Sockets API-------------------
-------------------shutil：文件和目錄管理-------------------
-------------------glob：基於文件通配符搜索-------------------
-------------------keyword:關鍵字-------------------
import keyword：引用對應的包
keyword.kwlist()：獲取對應的列表，列表中存儲python中的對應關鍵字