Python初步學習

1、基本語法
一、標識符首字符必須是字母或者下劃線_，其餘部分由字母、數字或下劃線_組成。
二、保留字以下：

>>> import keyword
   >>> keyword.kwlist
   ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

三、單行註釋使用#，多行註釋使用'''或者"""。
四、代碼塊使用縮進來表示，而不是使用大括號{}，同一代碼塊的語句必須包含相同的縮進空格數。
五、多行語句使用反斜槓\來實現，在[],{}和()中多行語句不須要反斜槓。
六、多條語句同一行使用分號;分割。
七、導入模塊使用import或者from...import。
   （1）將整個模塊(somemodule)導入，格式爲： import somemodule
   （2）從某個模塊中導入某個函數,格式爲： from somemodule import somefunction
  （3）從某個模塊中導入多個函數,格式爲： from somemodule import firstfunc, secondfunc, thirdfunc
   （4）將某個模塊中的所有函數導入，格式爲： from somemodule import *
八、每一個模塊都有一個__name__屬性，當其值是'__main__'時，代表該模塊自身在運行，不然是被引入
九、序列解包（可迭代對象解包）是將一個序列解包，並將獲得的值存儲到一系列變量中。

   
2、基本數據
一、變量不須要聲明，但使用前都必須賦值。
二、六個標準數據類型：
   （1）Number（數字）：int、float、complex(複數)、bool
   （2）String（字符串）：（a）反斜槓能夠用來轉義，使用r可讓反斜槓不發生轉義
                                          （b）加號+是鏈接運算符，星號*是重複運算符
                                          （c）字符串有兩種索引方式，從左往右以0開始，從右往左以-1開始
                                          （d）字符串截取語法格式：變量[頭下標:尾下標]
                                          （e）Python不支持單字符類型
                                          （f）原始字符串用前綴r表示，反斜槓結尾要加轉義符
   （3）List（列表）：元素寫在方括號[]裏，之間用逗號分隔開，類型能夠不一樣
   （4）Tuple（元組）：（a）元素寫在小括號()裏，之間用逗號分隔開，類型能夠不一樣
                                      （b）元組可使用+號進行組合和*號進行復制，運算後會生成一個新的元組
   （5）Set（集合）：（a）元素寫在花括號{}裏，之間用逗號分隔開，無序不重複
                                  （b）可使用大括號 { } 或者 set() 函數建立集合，建立空集合必須用 set()
   （6）Dictionary（字典）：（a）字典是一種映射類型，用"{ }"標識，是一個無序的鍵(key) : 值(value)對集合
                                             （b）鍵(key)必須使用不可變類型且惟一
                                             （c）建立空字典用{}
    其中，（1）（2）（4）（5）數據不可變，（3）（6）數據可變。
    
    
3、運算符
一、算術運算符：+  -  *  /  %  **（冪） //（取整除）
二、比較運算符：==  !=  >  <  >=  <=
三、賦值運算符：=  +=  -=  +=  /=  %/  **=  //=  （Python沒有自增++和自減--）
四、位運算符：&  |  ^（按位異或）  ~（按位取反）  <<  >>
五、邏輯運算符：and  or  not
六、成員運算符：in  not in
七、身份運算符：is  is not（用於判斷兩個標識符是否引用自同一個對象，不要用於數和字符串等不可變的基本值）
                         is與==區別：is用於判斷兩個變量引用對象是否爲同一個，==用於判斷引用變量的值是否相等。
               示例：

>>>a = [1, 2, 3]
>>> b = a
>>> b is a
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True

 

                    
4、經常使用數學函數
一、abs(x)              返回數字的絕對值，如abs(-10)返回10
二、ceil(x)              返回數字的上入整數，如math.ceil(4.1)返回5
三、exp(x)              返回e的x次冪(ex)，如math.exp(1)返回2.718281828459045
四、fabs(x)             返回數字的絕對值，如math.fabs(-10)返回10.0
五、floor(x)            返回數字的下舍整數，如math.floor(4.9)返回4
六、log(x)              返回對數，如math.log(math.e)返回1.0，math.log(100,10)返回2.0
七、log10(x)          返回以10爲基數的x的對數，如math.log10(100)返回2.0
八、max(x1, x2,...)  返回給定參數的最大值，參數能夠爲序列
九、min(x1, x2,...)   返回給定參數的最小值，參數能夠爲序列
十、modf(x)         返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示
十一、pow(x, y)       返回x**y 運算後的值
十二、round(x [,n])  返回浮點數x的四捨五入值，如給出n值，則表明舍入到小數點後的位數
1三、sqrt(x)           返回數字x的平方根。

5、經常使用字符串函數
一、capitalize()   將字符串的第一個字符轉換爲大寫
二、count(str, beg= 0,end=len(string))  返回str在string裏面出現的次數，若是beg或者end指定則返回指定範圍內str出現的次數
三、find(str, beg=0 end=len(string))   檢測str是否包含在字符串中，若是指定範圍beg和end，則檢查是否包含在指定範圍內，若是包含返回開始的索引值，不然返回-1
四、index(str, beg=0, end=len(string))   跟find()方法同樣，只不過若是str不在字符串中會報一個異常
五、expandtabs(tabsize=8)       把字符串string中的tab符號轉爲空格，tab符號默認的空格數是8
六、isalnum()  若是字符串至少有一個字符而且全部字符都是字母或數字則返回True，不然返回False
七、isalpha()   若是字符串至少有一個字符而且全部字符都是字母則返回True，不然返回False
八、isdigit()                              若是字符串只包含數字則返回True 不然返回False
九、isnumeric()                        若是字符串中只包含數字字符則返回True，不然返回False
十、len(string)                       返回字符串長度
十一、lower()                            轉換字符串中全部大寫字符爲小寫
十二、upper()                            轉換字符串中全部小寫字符爲大寫
1三、replace(str1, str2, max)   把將字符串中的str1替換成str2，若是max指定，則替換不超過max次
1四、split(str, num)                  以str爲分隔符截取字符串，若是num有指定值，則僅截取num個子字符串

6、經常使用列表函數
一、len(list)                        返回列表元素個數
二、max(list)                      返回列表元素最大值
三、min(list)                       返回列表元素最小值
四、list(seq)                        將元組轉換爲列表
五、del list[i]                      刪除下標爲i的元素
六、list.append(obj)          在列表末尾添加新的對象
七、list.extend(seq)           在列表末尾一次性追加另外一個序列中的多個值（用新列表擴展原來的列表）
八、list.count(obj)              統計某個元素在列表中出現的次數
九、list.index(obj)              從列表中找出某個值第一個匹配項的索引位置
十、list.insert(index, obj) 將對象插入列表
十一、list.pop([index=-1]])  移除列表中的一個元素（默認最後一個元素），而且返回該元素的值
十二、list.remove(obj)         移除列表中某個值的第一個匹配項
1三、list.reverse()               反向列表中元素
1四、list.sort(cmp=None, key=None, reverse=False) 對原列表進行排序
1五、list.clear()                  清空列表
1六、list.copy()                  複製列表

7、經常使用元組函數
一、len(tuple)   返回元組元素個數
二、max(tuple) 返回元組中元素最大值
三、min(tuple)  返回元組中元素最小值
四、tuple(seq)   將列表轉換爲元組

8、經常使用字典函數
一、len(dict)                               返回字典元素個數，即鍵的總數
二、str(dict)                                輸出字典，以可打印的字符串表示
三、del dict['Name']                   刪除鍵對應的元素
四、radiansdict.clear()                刪除字典內全部元素
五、radiansdict.get(key, default=None) 返回指定鍵的值，若是值不在字典中返回default值
六、radiansdict.setdefault(key, default=None)   和get()相似, 但若是鍵不存在於字典中，將會添加鍵並將值設爲default
七、radiansdict.items()               以列表返回可遍歷的(鍵, 值)元組數組
八、radiansdict.keys()                 以列表返回一個字典全部的鍵
九、radiansdict.values()              以列表返回字典中的全部值
十、radiansdict.update(dict2)  把字典dict2的鍵/值對更新到dict裏
十一、pop(key[,default])              刪除字典給定鍵key所對應的值，返回值爲被刪除的值，key值必須給出，不然返回default值
十二、popitem()                           隨機返回並刪除字典中的一對鍵和值(通常刪除末尾對)

9、條件控制
一、if語句：
    （1）關鍵字是if-elif-else
    （2）每一個條件後面要使用冒號:，表示接下來是知足條件後要執行的語句塊
    （3）使用縮進來劃分語句塊，相同縮進數的語句在一塊兒組成一個語句塊
    （4）Python中沒有switch–case語句

           
10、循環控制
一、循環語句：
    （1）關鍵字是for和while
    （2）一樣須要注意冒號和縮進
    （3）Python中沒有do-while循環
二、break語句能夠跳出for和while的循環體
三、continue語句能夠跳過當前循環塊中的剩餘語句，而後繼續進行下一輪循環
四、pass是空語句，不作任何事情，通常用作佔位語句，是爲了保持程序結構的完整性
五、內置函數zip用於並行迭代，可以使用list將返回值對象轉換爲由元組組成的列表，zip函數「縫合」以最短序列長度爲準
六、內置函數enumerate用於索引-值對迭代，其中索引是自動提供的

11、迭代器和生成器
一、迭代器：
    （1）迭代器是一個能夠記住遍歷位置的對象，迭代器對象從集合的第一個元素開始訪問，直到全部的元素被訪問完結束，只能往前不會後退
    （2）迭代器有兩個基本的方法：iter() 和 next()
         示例：

>>>list=[1,2,3,4]
>>>it = iter(list)    # 建立迭代器對象
>>>print (next(it))   # 輸出迭代器的下一個元素
1

    （3）字符串，列表或元組對象均可用於建立迭代器
二、生成器：
    （1）使用了 yield 的函數被稱爲生成器（generator）
    （2）生成器是一個返回迭代器的函數，只能用於迭代操做，更簡單點理解生成器就是一個迭代器
    （3）在調用生成器運行的過程當中，每次遇到yield時函數會暫停並保存當前全部的運行信息，返回yield的值, 並在下一次執行next()方法時從當前位置繼續運行
    
    
12、函數
一、簡單規則：
    （1）函數代碼塊以 def 關鍵詞開頭，後接函數標識符名稱和圓括號()
    （2）任何傳入參數和自變量必須放在圓括號中間，圓括號之間能夠用於定義參數
    （3）函數的第一行語句能夠選擇性地使用文檔字符串—用於存放函數說明
    （4）函數內容以冒號起始，而且縮進
    （5）return [表達式] 結束函數，選擇性地返回一個值給調用方。不帶表達式的return至關於返回 None
二、格式：def 函數名（參數列表）:
             函數體
三、不可變對象和可變對象：
    （1）numbers, strings, tuples和sets是不可變的對象，而list和dict等則是可變的對象
    （2）不可變對象在函數中修改了參數，原始參數並不改變
    （3）可變對象在函數裏修改了參數，那麼在調用這個函數的函數裏，原始的參數也被改變了
四、參數類型：
    （1）必須參數：必需參數須以正確的順序傳入函數，調用時的數量必須和聲明時的同樣
    （2）關鍵字參數：函數調用使用關鍵字參數來肯定傳入的參數值，參數順序能夠與聲明時不一致
    （3）默認參數：調用函數時，若是沒有傳遞參數，則會使用默認參數
    （4）不定長參數：用於函數處理比當初聲明時更多的參數，加了星號（*）的變量名會存放全部未命名的變量參數
五、匿名函數：
    （1）使用lambda來建立
    （2）lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去
    （3）lambda函數擁有本身的命名空間，且不能訪問本身參數列表以外或全局命名空間裏的參數
    （4）格式：lambda [arg1 [,arg2,.....argn]]:expression
六、return [表達式]語句用於退出函數，選擇性地向調用方返回一個表達式，不帶參數值的return語句返回None
七、變量做用域：
    （1）L （Local）        局部做用域
    （2）E （Enclosing） 閉包函數外的函數中
    （3）G （Global）     全局做用域
    （4）B （Built-in）    內建做用域
    （5）以 L –> E –> G –>B 的規則查找
    （6）只有模塊（module），類（class）以及函數（def、lambda）纔會引入新的做用域
         示例：

x = int(2.9) # 內建做用域
g_count = 0  # 全局做用域
def outer():
    o_count = 1  # 閉包函數外的函數中
    def inner():
        i_count = 2  # 局部做用域

八、全局變量和局部變量：
    （1）定義在函數內部的變量擁有局部做用域，局部變量只能在其被聲明的函數內部訪問
    （2）定義在函數外部的變量擁有全局做用域，全局變量能夠在整個程序範圍內訪問
九、global和nonlocal關鍵字：
    （1）global修改全局變量
        示例：

num = 1
def func():
    global num  # global關鍵字聲明
    num = 123
    print(num)

func()
print(num)

    （2）nonlocal修改嵌套做用域（enclosing 做用域，外層非全局做用域）中的變量
        示例：

def outer():
    num = 1

def inner():
    nonlocal num   # nonlocal關鍵字聲明
    num = 123
    print(num)

inner()
print(num)
outer()

                                      
十3、遍歷
一、在字典中遍歷時，關鍵字和對應的值可使用items()方法同時解讀出來
二、在序列中遍歷時，索引位置和對應值可使用 enumerate()函數同時獲得
三、同時遍歷兩個或更多的序列，可使用zip()組合
四、要反向遍歷一個序列，調用reversed()函數
五、要順序遍歷一個序列，調用sorted()函數

十4、輸入和輸出
一、Python提供了input()內置函數從標準輸入讀入一行文本，默認的標準輸入是鍵盤。
   input能夠接收一個Python表達式做爲輸入，並將運算結果返回。
二、Python兩種輸出值的方式: 表達式語句和print()函數
三、pickle模塊實現了基本的數據序列和反序列化，基本接口pickle.dump(obj, file, [,protocol])

十5、文件讀寫
一、讀寫文件使用open()將會返回一個file對象，基本語法open(filename, mode)
二、打開文件模式：
    （1）r         以只讀方式打開文件
    （2）rb       以二進制格式打開一個文件用於只讀
    （3）r+      打開一個文件用於讀寫
    （4）rb+    以二進制格式打開一個文件用於讀寫
    （5）w       打開一個文件只用於寫入
    （6）wb     以二進制格式打開一個文件用於寫入
    （7）w+    打開一個文件用於讀寫
    （8）wb+  以二進制格式打開一個文件用於讀寫
    （9）a       打開一個文件用於追加
    （10）ab   以二進制格式打開一個文件用於追加
    （11）a+   打開一個文件用於讀寫
    （12）ab+ 以二進制格式打開一個文件用於讀寫
三、操做文件方法：
    （1）f.read(size)         讀取必定數目的數據, 而後做爲字符串或字節對象返回
    （2）f.readline()         從文件中讀取單獨的一行，換行符爲 '\n'。f.readline()若是返回一個空字符串, 說明已經已經讀取到最後一行
    （3）f.readlines()       返回該文件中包含的全部行
    （4）f.next()               返回文件下一行
    （5）f.write(string)     將string寫入到文件中，而後返回寫入的字符數
    （6）f.tell()                 返回文件對象當前所處的位置, 它是從文件開頭開始算起的字節數
    （7）f.seek(offset, from_what) 改變文件當前的位置，from_what的值0表示開頭，1表示當前位置，2表示文件的結尾
    （8）f.close()              關閉文件並釋放系統的資源
                

十6、異常處理
一、try-except處理異常
二、raise語句拋出一個指定的異常

十7、面向對象
一、類定義的語法格式以下：
   class ClassName:
        <statement-1>
        .
        .
        .
        <statement-N>
二、類對象支持兩種操做：屬性引用（obj.name）和實例化
三、類的方法必須有一個額外的第一個參數名稱，按照慣例它的名稱是self，self表明的是類的實例，是當前對象的地址，而self.class則指向類
四、派生類定義的語法格式以下：
   class DerivedClassName(BaseClassName1):
        <statement-1>
        .
        .
        .
        <statement-N>
五、python支持單繼承和多繼承，基類必須與派生類定義在一個做用域內
六、若是父類中有相同的方法名，而在子類使用時未指定，將調用最早繼承的父類的方法
七、super()函數是用於子類已重寫父類方法而調用父類(超類)的一個方法
八、兩個下劃線開頭，聲明該屬性或方法爲私有，不能在類地外部被使用或直接訪問
九、類的專有方法：
    （1）__init__          構造函數，在生成對象時調用
    （2）__del__          析構函數，釋放對象時使用
    （3）__repr__        打印，轉換
    （4）__setitem__   按照索引賦值
    （5）__getitem__  按照索引獲取值
    （6）__len__          得到長度
    （7）__cmp__        比較運算
    （8）__call__         函數調用
    （9）__add__        加運算
    （10）__sub__      減運算
    （11）__mul__      乘運算
    （l2）__div__        除運算
    （13）__mod__    求餘運算
    （14）__pow__     乘方

    
十8、正則表達式
一、re.match 嘗試從字符串的起始位置匹配一個模式，若是不是起始位置匹配成功的話，match()就返回none
   函數語法：re.match(pattern, string, flags=0)
二、re.search 掃描整個字符串並返回第一個成功的匹配
   函數語法：re.search(pattern, string, flags=0)
三、re.findall 在字符串中找到正則表達式所匹配的全部子串，並返回一個列表，若是沒有找到匹配的，則返回空列表
   函數語法：re.findall(string[, pos[, endpos]])
四、re.finditer 在字符串中找到正則表達式所匹配的全部子串，並把它們做爲一個迭代器返回
   函數語法：re.finditer(pattern, string, flags=0)
五、re.sub 替換字符串中的匹配項
   函數語法：re.sub(pattern, repl, string, count=0)
六、re.compile 用於編譯正則表達式，生成一個正則表達式（Pattern）對象，供match()和search()這兩個函數使用
   函數語法：re.compile(pattern[, flags])
七、re.split 按照可以匹配的子串將字符串分割後返回列表
   函數語法：re.split(pattern, string[, maxsplit=0, flags=0])
   
   
十9、多線程
一、線程分爲內核線程和用戶線程。
二、Python3線程中經常使用的兩個模塊是_thread和threading。
三、線程使用的兩種方式：
    （1）函數式：調用 _thread 模塊中的start_new_thread()函數來產生新線程
             語法：_thread.start_new_thread (function, args[, kwargs])
    （2）用類來包裝線程對象。
四、Thread類方法
    （1）run()              用以表示線程活動的方法。
    （2）start()            啓動線程活動。
    （3）join([time])    等待至線程停止。
    （4）isAlive()         返回線程是否活動的。
    （5）getName()     返回線程名。
    （6）setName()     設置線程名。
五、使用 Thread 對象的Lock和Rlock能夠實現簡單的線程同步，這兩個對象都有acquire方法和release方法。
   示例：

threadLock.acquire()  # 獲取鎖，用於線程同步
print_time(self.name, self.counter, 3)       
threadLock.release()  # 釋放鎖，開啓下一個線程

六、Queuem模塊提供了同步的、線程安全的隊列類，都實現了鎖原語，可以直接在多線程中使用
    （1）FIFO（先入先出）隊列Queue
    （2）LIFO（後入先出）隊列LifoQueue
    （3）優先級隊列PriorityQueue
    
    
二10、XML解析
一、Python有三種方法解析XML：
    （1）SAX    用事件驅動模型，經過在解析XML的過程當中觸發事件並調用用戶定義的回調函數來處理XML文件
    （2）DOM  將XML數據在內存中解析成一個樹，經過對樹的操做來操做XML
    （3）ElementTree

    
二11、JSON解析
一、Python3 中可使用json模塊來對JSON數據進行編解碼，它包含了兩個函數：
    （1）json.dumps(): 對數據進行編碼
    （2）json.loads(): 對數據進行解碼

     二12、日期和時間 一、Python提供了一個time和calendar模塊能夠用於格式化日期和時間。 二、time.time()                         獲取當前時間戳      time.localtime()                  從返回浮點數的時間輟方式向時間元組轉換      time.asctime()                    獲取可讀的時間模式      time.strptime(format[, t])  格式化日期