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=‘ ‘)：結束最後的換行
 

2、文件流
文件流對應的基礎操作：
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個位置
 

3、列表、字典、元組操作
1、列表:
strList=[‘‘]：列表的創建。
str=‘字符串‘
newStr=‘新的字符串‘。
strList.append：進行列表數據信息的添加操作。
strList[0]=newStr：根據下標，進行列表指定元素數據信息的修改操作
str in strLsit：返回boolen類型，指定字符串信息是否在列表中存在。
for item in strList：進行列表數據的遍歷操作，item為元素值
del strList[0]：根據列表下標，刪除指定的列表元素。
strList.pop()：刪除列表最後一個元素的數據信息。
strList.remove(‘元素的值‘)：根據元素的值進行刪除操作。

2、字典：
    修改元素：根據Key值進行修改
    添加元素：infor[‘age‘]=18
    刪除元素：del
    清空字典中的數據信息：infor.clear

3、字典的常見操作
    dic={1:‘xiaohao‘,2:‘xiaodong‘}：創建一個字典對象。
    dic.keys()：獲取字典所有對應的鍵，以列表的形式進行返回。
    dic.valuses()：獲取字典所有對應的值，以列表的形式進行返回。
    dic.items()：獲取字典中的鍵值數據，以列表的形式返回，每個元素都一個元組，分別存放著鍵和值。
    dic.has_key(1)：返回boolen類型，判斷鍵值是否存在

4、元組：
    tuple=(1,2,3,4,5)：創建一個元組。
    tuple[2]：根據下標讀取到第三個元素。
    tuple[-2]：根據下標讀取到倒數第二個元素。
    tuple[1:]：截取元組第二個元素到最後。
    cmp(tuple1,tuple2)：比較兩個元組中的元素。
    max(tuple)：返回元組中元素的最大值。
    min(tuple)：返回元組中元素的最小值。
    tuple(seq)：將列表轉換為元組。

5、運算符操作列表、字典、元組的技巧：
    1、len((1,2,3,4))：獲取到元組中元素的個數。
    2、(1,2,3,4) +(1,2,3,4,5) ；進行兩個元組的合並，獲取到一個新的元組。
    3、[‘Hi‘]*4：創建一個新的列表，並將列表中的數據進行復制四次。
    4、1 in (1,2,3,4)：判斷元素是否存在；返回boolen類型。

4、異常捕獲
定義：某些錯誤操作導致程序無法正常運行
異常捕獲：
try：
except(NameError,IOError),result：
print(result)#返回具體的錯誤信息
else：
print("我是else")
finally:
print("我是finally")

5、range：獲取
1、help(range):
range(stop) -> list of integers
range(start, stop[, step]) -> list of integers
2、參數分析：
1、start:計數從start開始。默認是從0開始。例如range（5）等價於range（0， 5）。
2、stop:到stop結束，但不包括stop.例如：range（0， 5） 是[0, 1, 2, 3, 4]沒有5。
3、step:每次跳躍的間距，默認為1。例如：range（0， 5） 等價於 range(0, 5, 1)。
3、示例：
a = range(5)
list(a)

6、map：函數
1、help(map):
map(...)
map(function, sequence[, sequence, ...]) -> list
2、參數分析：
1、function:是一個函數
2、sequence:是一個或多個序列,取決於function需要幾個參數
3、返回值是一個list
3、語法：
參數序列中的每一個元素分別調用function函數，返回包含每次function函數返回值的list。
4、示例
#函數需要一個參數
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)]

7、filter：函數
1、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.
2、參數分析：
    1、function:接受一個參數，返回布爾值True或False
    2、sequence:序列可以是str，tuple，list
3、語法
    filter函數會對序列參數sequence中的每個元素調用function函數，最後返回的結果包含調用結果為True的元素。返回值的類型和參數sequence的類型相同
4、示例
    filter(lambda x: x%2, [1, 2, 3, 4])
    [1, 3]

    filter(None, "she")
    ‘she‘

8、reduce：函數
1、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.
2、參數分析：
    1、function:該函數有兩個參數
    2、sequence:序列可以是str，tuple，list
    3、initial:固定初始值

3、語法
    reduce依次從sequence中取一個元素，和上一次調用function的結果做參數再次調用function。 第一次調用function時，如果提供initial參數，會以sequence中的第一個元素和initial 作為參數調用function，否則會以序列sequence中的前兩個元素做參數調用function。 註意function函數不能為None。
4、示例
    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‘

9、sorted：函數
1、help(sorted):
sorted(...)
sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list
2、參數分析：
自定義cmp比較函數，返回三種情況：
x<y 返回-1
x>y 返回1
x==y 返回0
3、示例
def cmp_ignore_case(s1, s2):
u1 = s1.upper()
u2 = s2.upper()
if u1 < u2:
return -1
if u1 > u2:
return 1
return

-------------------系統庫函數，幫助文檔查找-------------------
1、庫函數：print()、raw_input() 系統給的叫庫函數

2、用戶自定義函數：如果系統中，沒有需要的功能，那麽此時就需要自己開發一個，這就是自定義函數

3、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：獲取到執行文件時，對應的參數信息

-------------------functools：常用的工具-------------------
1、概念：
functools 是python2.5被引人的,一些工具函數放在此包裏。

2、操作：
    1、import functools ：引用對應的包
    2、dir(functools) ：查看包中對應的工具函數

1、partial函數（偏函數）：
    1、概念：
        把一個函數的某些參數設置默認值，返回一個新的函數，調用這個新函數會更簡單。
    2、示例：
        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‘)

2、wraps函數：
    1、概念：
        使用裝飾器時，有一些細節需要被註意。例如，被裝飾後的函數其實已經是另外一個函數了（函數名等函數屬性會發生改變）。Python的functools包中提供了一個叫wraps的裝飾器來消除這樣的副作用
    2、示例：
        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 ：

1、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號

2、進程創建的第二種方式：
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()：從管道中取出對應的數據信息。

3、from multiprocessing import Process,Queue：應用對應的包，為實現進程之間的通信操作；管道的倆個端一個是負責向裏面寫入數據，一個是負責向外面讀取數據。
q=Queue()：創建一個隊列對象。
q.put(要添加到隊列中的數據信息)：將制定的數據添加到隊列當中去。
q.get(True)：從隊列中要提取出的隊列數據信息。
q.empty()：判斷當前隊列是否為空。

-------------------threading：多線程-------------------
1、線程應用的第一種模式thread模塊是比較底層的模塊
import thread：引用對應的模塊包。

    thread.start_new_thread(defName,())創建開啟一個新的線程；第一個參數為新線程要執行的方法，第二個參數為元組傳遞執行方法對應需要參數；註：python元組為一個時需要(元素,)一個元素加一個‘，‘進行表示。
    thread.exit_thread()：主線程調用該方法表示所有的線程結束操作；子線程通過調用exit.thread()的方法來表示實現當前子線程的結束操作。
    thread.join()： python的Thread類中還提供了join()方法，使得一個線程可以等待另一個線程執行結束後再繼續運行。這個方法還可以設定一個timeout參數，避免無休止的等待。因為兩個線程順序完成，看起來象一個線程，所以稱為線程的合並
    thread.setDaemon(True)：默認情況主線程退出時會等待子線程的結束，如果希望主線程不等待子線程，可以設置子線程為後臺線程，主線程退出，子線程隨即結束。

2、線程應用的第二種模式threading模塊是對thread模塊進行了一定的封裝，可以更方便我們的使用。
    import threading：引用對應的模塊包。
    myThread=threading.Thread(target=defName,args=(‘Alice‘,))創建一個線程，target賦值要執行線程的方法，args復制執行方法需要的參數信息。
    myThread.start()：線程開始執行。
    num=len(threading.enumerate)：查看當前執行的線程的數量。

3、線程的應用的第三種方式創建一個線程類，繼承基類threading.Thead；重寫基類的def run(self):方法，將該線程要執行的程序寫在該方法中。
    class MyThread(threading.Thread)：創建一個線程類
    進行基類構造函數的創建操作
    def __init__(self,name,time):
         threading.Thread.__init__(self,name=‘可以為線程的名字進行復制‘)

    myThread=MyThread()：線程對象的創建。
    myThread.start()：該線程執行。

4、threading模塊中定義了Lock()類，可以方便的處理鎖定。
    mutex=threading.Lock()：互斥鎖對象的創建。
    if mutex.acquire([blocking])：進行鎖定，鎖定成功後返回true；鎖定方法acquire()可以有一個blocking參數。如果設定blocking為True，則當前線程會堵塞，直到獲取到這個鎖為止（如果沒有指定，那麽默認為True）；如果設定blocking為False，則當前線程不會堵塞。
    mutex.release()：執行完程序內容後進行鎖的釋放操作。

5、支持同一線程多次請求同一資源，python提供了可重入鎖。RLock對象中，同時維護著一個Lock和一個counter變量；counter變量存儲acquire的次數，從而使得資源可以多次被acquire；直到一個線程中的所有的acquire被release，其他的線程才可以獲得資源
    mutex=threading.RLock()：創建可重入鎖對象。
    mutex.acquire()：進行上鎖。
    mutex.release()：進行釋放。

6、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 [email protected]‘)：根據匹配進行切割字符串，並返回一個列表。案例：根據：或空格進行字符串的切割操作，結果：[‘address‘,‘beijing‘,‘[email protected]‘]

-------------------socket：標準的 BSD Sockets API-------------------

-------------------shutil：文件和目錄管理-------------------

-------------------glob：基於文件通配符搜索-------------------

-------------------keyword:關鍵字-------------------
import keyword：引用對應的包
keyword.kwlist()：獲取對應的列表，列表中存儲python中的對應關鍵字

python常用標準庫