python筆記

概覽：

變量類型：整形，浮點型，字符串，但定義變量時不須要指定類型，在第一次賦值時肯定類型

列表、元組(定死了不可改變的列表)、字典，集合(set,無序不可重複)；對以上iterable的操做，初始化(按照括號不一樣來區分，小括號-元組，中括號-列表，大括號-字典)，訪問，改變，增長，刪除

方法，實參，形參；

lambda，map，列表推導式

iterable迭代器，可用列表等來保存其值，也可直接用for等直接拿到其返回值

positional argument：位置參數

關鍵字：

---

對比：

列表，sort(iterable)永久排序，sorted()臨時排序，進對sorted(iterable)這一句執行是進行排序，後面的不變

字典也有sort()與sorted()

---

day01

python中():

    沒有封號’；’，而用回車符來代替，因此一句話結束後開始另外一句話必須回車

    也沒有大括號{}，而使用tab來代表在方法內，而沒有tab則表示方法結束

    而冒號’:’主要是爲了像if a<3 : a=2這種就不會出現混亂

def定義方法

變量

    不須要定義類型，必需要初始化即賦值；沒有字符型char，被併到字符串類型中了

    動態類型：在運行期間肯定變量的類型，python肯定一個變量的類型是在第一次給他賦值的時候；

    強類型：有強制的類型定義，一個整數，除非顯示的類型轉換，不然毫不能將它看成一個字符串

    變量賦值，能夠同時多個，如a,b = 2,3;c,d = a,b

    標準數據類型：數字-int,float；字符串-str ；列表-list ；元組-tuple ；字典-dict ；

除標準類型外，還有方法類型，及自定義類型-類；都包括在class中，即class:’int’，class:’function’,class:type-指類

python中的變量都是一個個對象，如a=1，type(a)則會輸出<class 'int'>

單行註釋#，多行註釋’’’… …’’’或」」」… …」」」

字符串，單引號’’和雙引號」」是等同的，能夠進行’+’操做和’*’操做；單行保留格式r’……’，多行’’’……’’’（和註釋符號同樣）

使用 j 或 J 後綴，能夠賦值虛數，但j/J前必須有實數，如2+1j，而不能寫成2+j；這樣能夠和變量j進行區分

列表的長度可變，可存儲各種型變量/常量，可用append()改變自身；也可經過’+’與其餘列表組合造成新的列表

切片[a:b]是一個很便捷的工具，左右切片位置能夠是變量，但a必須小於b，不然爲空[]。

切片位置

切片可用於列表、

range

    range(start, stop, step)返回的是range對象，list(range(1,4))返回從1開始，到4以前的3，即[1，2，3]

    list(range(5))，默認開始爲0，則返回[0,1,2,3,4]；

    list(range(1,5,2))返回[1,3]

break是結束整個循環體，continue是結束單次循環

形參（位置參數a，默認參數b=1，*c，**d）

    默認參數：形參中的賦值的參數，def abc(a,b,c=[]，d=4)，其中c，d即爲默認值參數，調用方法時可傳可不傳

    位置參數：調用函數時根據位置來傳遞的參數，像上面的a,b，調用是爲abc(1,3,…)，位置參數必須傳值

    位置參數在前原則：形參中有位置參數a，與默認參數b=3，默認參數必須在後，即abc(a,b=3)，而不能相反

        一樣的，實參中，位置參數必須在關鍵字參數以前

    注意：默認值只初始化一次，當默認值是一個可變對象（如列表，字典或大多數類的實例）時，方法執行完後不會釋放

        def f(a,b=[]): b.append(a) return b，

        第一次調用f(1)後，輸出[1],第二次調用f(2)後，輸出[1,2]

    形參可接收元組和字典，一個星（*）：表示接收的參數做爲元組來處理；兩個星（**）：表示接收的參數做爲字典來處理

        如：def abc(a,*c,**d):   調用：abc(2,'asddasff',car='betles',phone='apple',pc='dell')，a=2，b-元組，c-字典

    不過元組會把後面的參數當成元組元素，因此若是傳的是鍵值對，就要用關鍵字參數；而字典會把關鍵字參數當成字典元素，

    而關鍵字參數又不能放在位置元素(也即字典參數)前，而直接傳又會出錯，不清楚爲何，因此暫時沒有解決辦法；

實參（位置參數a，關鍵字參數b=3，解包*c，解包**d）

    關鍵字參數:調用方法時，經過「鍵-值」形式傳值的參數，形參中必須有名稱一致的默認參數，鍵值對形式使得能夠不用管順序

    實參不能夠定義變量，如abc(i=5)，但能夠是關鍵字參數，即字母一致，必須是abc(a=5)，這裏的a=5是參數而非定義

    實參中的關鍵順字參數序不重要，便可以abc(b=1,a=2)

    解包參數列表，即在元組或字典變量前加*或**完成解包，如d=[3,4,5]，abc(*d)就可分別把值傳到abc(a,b,c)中了

day02

---

iterable：可迭代的對象，如list，tuple，dict，str，都是iterable(凡是能夠for循環的，都是Iterable)

元組，長度和每一個元素不能改變，且爲圓括號或不用括號，定義，tuple0=()，tuple1=(1,2)，tuple2=1,2 一個元素時後面要加逗號，(1，)，死的，皆不可變的列表即元組

集合

    沒有順序且不可重複

    set1 = {‘a’,’b’,’c’}，也可用set(iterable)方法-返回集合，但大括號定義時不能爲空，由於{}特指字典

    增長，add() ，刪除remove()，由於沒有順序因此不須要指定位置

    可進行邏輯運算& | ^

字典

    初始化：a = {‘key1’:value1}，添加：a[‘key2’]=value2；也可用dict()方法或列表推導式構建字典

    索引指的是根據鍵而不是位置，鍵必須是不可變的類型，數字、字符串、不包含可變類型的元組可做爲鍵

    鍵不能重複。兩個相同的鍵，後一個值會被記住

    遍歷：鍵-值：for a,b in dict.items():，a,b即分別拿到鍵與值；總體：for a in items():

不像列表有順序號，字典靠key來遍歷，或者靠value，因此有如下三個方法

        keys()方法返回dict_keys類型(iterable，非list，不能索引)而不是列表，須要用list(dict1.keys())後才能夠索引；

        values()，items()同理，返回值也爲iterable

    鍵：for a in dict.keys():，值：for a in dict.values():，

    增長，直接dict1[‘key1’] = 1就好了；

    刪除del dict1[‘key1’]，pop(key1)彈出key1所對應的元素，popitem()彈出最後一個元素，爲字典獨有

列表：

    初始化：a = [1,2,3]，也可用list1 = list()建立空列表；另外list2 = list(tuple1)可將元組轉變爲列表

    添加：append(x)，x是常數；extend(a)，追加列表；insert(i, c)，i是位置，c能夠是常數也能夠是列表

    刪除：remove(x)，x是常量且必須存在於要移除列表中，僅移除第一個；

            pop()彈出末尾的， pop(i)，移除i 位置上的數且返回i 位置上的數

            del list1[2]刪除2位置上的元素；del list1[i1:i2]，根據索引刪除，i1和i2是索引；del不是list的方法，是獨立的方法

            clear()清空列表

    index(x)，返回第一是x的索引；獨有sort()方法，根據字母排序

    len(list1)返回列表長度

    list1.reverse()將列表翻轉

lambda關鍵字建立小的匿名函數，被侷限於只能有一個單獨的表達式

     c = lambda a, b: a+b （a,b爲形參，返回a+b)

map方法

    提供了一種建立list的簡便方法。建立列表時，列表中的元素來源於其餘序列、可迭代對象，至關於用函數建立一個列表

    分別將各個iterable的對應元素(如同爲第一個元素)，傳入func方法中，而後依次獲得返回的值

    map(func, iterable,iterable,……)，func爲方法，後面至少一個iterable，而iterable的數量和順序必須與func形參一致

    返回值爲：傳進func的各iterable值計算後的結果，map()返回值爲map對象，須要用list(map())等，將返回值保存起來

列表推導式-List Comprehensions

    提供了一種建立list的簡便方法。建立列表時，列表中的元素來源於其餘序列、可迭代對象，至關於用函數建立一個列表

    與list(map(func,iterable,…))相似，形如：list([(x, y) for x in [1,2] for y in [3,1] if x != y])，每循環一小次則返回 

        一個元組，list會將這些所有保存起來，結果爲[(1,3),(2,3),(2,1)]

    規則：由一對方括號組成，方括號包含一個表達式，其後跟隨一個for子句，而後是零個或多個for或if子句

        表達式如(x,y)，在展開的形式中爲list1.append((x,y))，即表達式是最裏面的語句

        其中for語句是嵌套的，if爲實際語句

    列表推導式的嵌套，[[row[i] for row in [[1,2],[3,4]]] for i in range(2)]，結果爲[[1,3],[2,4]]，展開則爲：

         list2 = []

         for i in range(2):

              list1 = []

              for row in [[1,2],[3,4]]:

                   list1.append(row[i])

              list2.append(list1)

    注意，變量名要保持一直，(x,y)與其對應的for x ..for y；row[i]與for row

zip()方法，zip([iterable, ...])，將iterable壓縮成元組，能夠看做是把列轉換爲行

解壓縮zip(*zip())就是再轉一次行列

enumerate方法，list(enumerate(iterable, start))，結果如：[(0,’ab’),(1,’bc’),(2,’ef’)]

比較：

    in/not in，is/is not；比較操做符優先級小於算數操做符

    級聯比較，a < b == c測試a是否小於b而且b是否等於c；and/or/not，邏輯優先級小於比較操做符，且not>and>or

sort()方法僅用在list上,對原有list進行修改，而sorted(iterable)是對全部可迭代的對象，返回新的iterable對象

day03

---

方法

    方法的本質上是對象，能夠用變量對其引用，def abc():，a=abc，這樣a()與abc()就是等同的，注意與a=abc()的區別

    在方法中也能夠定義方法，即方法可嵌套，但外部沒法直接調用嵌套中的方法

    嵌套方法的使用：①僅在主方法內部使用，在方法內部得到/使用嵌套方法的計算結果

    ②外部使用，先‘return 嵌套方法’，而後a=abc()調用主方法賦值給變量，便可完成在外部調用嵌套方法a()，毋忘加括號

拼接

    +，僅限於相同類型，如同爲字符串/元組/列表，但不能是字典/集合；

    要想輸出字符串+列表，必須把列表轉換成字符串，如print(‘the list is:’+str([3,4,5,]))

input(‘提示信息’)，用戶輸入

模塊-module

    導入模塊，import module1，調用方法必須加模塊名，module.func1

    從模塊中導入方法或變量，from module1 import func1/var1，調用時可直接用func1/var1而不用加模塊名

    from xx import xx形式，變量會被加入到當前的命名空間中，因此可能致使覆蓋狀況發生，故不推薦使用

    使用as來避免重名，import module1 as md1，from mod import func/var as f/v

包-package，包是一個有層次的文件目錄結構，它定義了由n個模塊或n個子包組成的python應用程序執行環境

namespace命名空間，四個：Locals-函數內部，Enclosing-外面一層函數，Globals運行的全局變量，Builtin內置模塊空間

LEGB，程序引用某個變量的名字時，就會從名字空間開始搜索，搜索順序規則即是:LEGB，一層層查找，找到後便中止搜索

裝飾器，使得方法變得可擴展，如對方法增長功能等

__name__，它的值由Python解釋器設定：

    若是腳本文件是做爲主程序調用，其值就設爲__main__，若是是做爲模塊被其餘文件導入，它的值就是其文件名

locals()，返回局部變量所構成的字典；globals()，返回全局變量所構成的字典

vars(object)，返回對象的屬性和屬性值的字典，沒有參數時與locals()方法一致

reduce(function，iterable)方法，根據給定方法對迭代器中元素進行計算

day04

---

python的動態特性

    new_class(name, bases=(), kwds=None, exec_body=None)動態建立類

    C.a=1綁定屬性，可用setattr(object, name, value)方法，delattr(object, name)刪除屬性，getattr(object, name)

    obj.func1=MethodType(func,obj)綁定方法，綁定給類時方法內部定義的屬性是公共的，綁定給實例時則僅此實例獨有

類

    定義類，」class Car(FatherClass1，FatherClass2): 「，類名不必定要大寫，但建議用大寫

    類的實例化，car1=Car(1,2) ,類中有數據屬性和方法，數據屬性會覆蓋同名的方法屬性

    類中有特殊方法__init__(self,a,b)，在實例化時便會自動調用，其中self即是實例化自己，即car1

    實例調用方法時會默認把本身傳給方法，因此方法的形參至少有一個參數用來接收實例對象，默認用self，也能夠用其餘名稱

    可是，可是，在方法中必需要寫上self，否則報錯，python的設計人員說是爲了explicit。。。既然是人家開發的那也沒轍了

    注意：類的屬性爲可變對象（如列表，字典和大多數其餘類型），只會初始化一次，即類的全部實例共享這一變量

           （這與形參的默認值問題相似），當爲不可變的基本類型（數字，字符串，元組），不存在這種問題

            要避免這種問題，可將其放入__init__()方法中，即self.a=b，b接收的爲可變對象，如[1,2,3]

方法

    類有三種方法，分別是實例方法，類方法(方法前面加@classmethod)，靜態方法(方法前面加@staticmethod)；

    類方法與靜態方法相似，當一個函數邏輯上屬於一個類又不依賴與類的屬性的時候，可使用staticmethod

    實例可調用類方法，類沒法調用實例方法：實例建立時包含隱藏參數self,cls，所以三種方法皆可調用

    類建立時包含隱藏參數cls而無self，因此只能調用類方法和靜態方法；

    也能夠理解爲類僅調用類方法時傳入本身，而調其餘方法是不傳類本身這個參數的，而實例除static外都會傳入本身

繼承

    FatherClass爲父類，能夠多繼承，即傳入多個父類對象；方法名一致，則子類的方法覆蓋父類的方法

    多重繼承面臨的問題是搜索屬性的順序是怎樣的，即MRO-方法解析順序，MRO通過了幾回改變

    一代：DFS-深度優先搜索，而DFS會致使‘公共父類（D）的多繼承’狀況下只能繼承沒法重寫的問題

    二代：BFS-廣度優先搜索，BFS會致使在‘互不相關的類的多繼承’狀況下產生單調性問題

   而如今的C3使用拓撲排序徹底的解決了這兩個問題，super()方法指的是MRO表中的下一個類

    (參見：http://python.jobbole.com/85685/)

多態，只需有繼承便可，與Java不一樣：不須要父類引用指向子類對象，因此python多態本質和各子類直接調用本身的方法同樣

內部類

    外部類調用內部類，首先實例化外部類outc，而後outc.inc()便可獲得內部類的實例

    內部類調用外部類，直接實例化外部類便可調用，由於在內部類中能夠檢索到外部類

類-內存

    實例剛被建立時，命名空間裏什麼都沒有，所引用的變量其實都是存在於類的命名空間中的

    而za1.a其實才是把a寫到了命名空間中，而這個a與類的a不是同一個

    實例方法：id(A.ab) != id(a1.ab) == id(a2.ab)，而類方法與靜態方法，三個id()都是相等的，很奇怪，待查。。。

vars(object)方法，返回對象屬性名稱和值的字典，無參數時至關於locals()；dir(object)，返回對象的屬性名稱

type()與instance()

    isinstance(a, list)，判斷一個對象是不是一個已知的類型，判斷的是類型而不是==；type(a)方法查看對象a的類型

    type() 不會認爲子類是一種父類類型，不考慮繼承關係；isinstance() 會認爲子類是一種父類類型，考慮繼承關係

is/is not，用於判斷兩個引用所指的對象是否相同

id()方法，用於獲取對象的內存地址，注意是對象而不是對象的引用

__class__，能夠得到對象的類型，如a=’a’，則a.__class__返回str

__bases__，能夠得到對象的父類，如int.__bases__返回object

Object與Type

    如a = 1，a的類型是int，而int的類型是type，而type對象自己的類型是type

建立對象分兩種：實例對象由類對象建立出來，而類對象由PyTyObject建立出來

    直觀的說就是由於能夠在運行期間動態的建立類型，因此不能在code時就把類型寫死；而這會致使在運行期不知道分配多少內存，因此纔有了type來補充；而像Java這種前期已經明肯定義好了的，就不須要再額外來一個與Object’平分秋色‘的傢伙了

    而類型的從屬則引出了類-實例，方法instance()判斷實例是否屬於某個類，不正是在判斷類型嗎，因此，根據類型的從屬關係能夠導出以下關係，進而引出元類

元類metaclass

    首先，須要明確類也是一種對象，對，python中一切皆對象，只是類這個對象擁有建立對象的能力

    因此，元類建立類，類實例化以後成爲對象；有點像上帝造了亞當和夏娃，而亞當和夏娃實例化後產生了各類人類

    但不管上帝、亞當/夏娃，仍是如今的人類，都是對象，有屬性、方法

    當使用class時編譯器自動的建立一個類，但也能夠手動的建立，如今不用class了那用什麼呢？

    對，就是元類，type()即是一個元類，能夠用來建立類，因此，元類能夠說是建立類的類(深入理解Python中的元類)

day 05

---

with obj/func() as var1：

    with後面跟對象(跟方法，方法必須返回一個對象)，而這個對象要有__enter__和__exit__方法

    在執行with代碼塊中的語句前先執行__enter__()方法，這個方法返回值賦給as後面的變量

    而後再執行with內的內容，最後執行__exit__()方法，若是有異常這個方法能夠輸出異常信息

open(‘filename’,’r/w/a/r+/b’)方法

    要對文檔進行操做，必須先打開文檔，用完以後要關閉

    open()方法打開文檔且返回文檔對象，第一個參數爲文檔對象名字，能夠是相對路徑也能夠是絕對路徑

    第二個參數爲打開模式，r:只讀(默認)，w：只寫，不存在則建立，存在則清空後寫入，a:附加，r+:讀寫，b:二進制

    可用with open(‘filename’) as obj 來操做文件，with可以使文檔自動關閉，as用來將open()方法返回的對象賦給變量obj

    rstrip()用於將字符串後面的空白刪除，文檔末尾會有個空行，每一行末尾也都有個空行

read(size)，size爲讀取的字節數，會返回讀到的字符串，無參數時則會返回文件的內容所有，因此通常都帶參數

readline(size)，無參數時返回讀取到的文件的一行，有參數時與read()方法同樣；for a in file_obj，也可獲得文件的每一行

readlines()方法，返回文檔全部行的列表

write(‘str’)，寫入str字符串，返回寫入的字符個數

tell()方法，返回當前指針位置

seek()方法

    用於重置當前指針位置，seek(offset,from_what)，offset表示相對於參考點的偏移

    from_what爲參考點，0：文件開頭，1：當前位置，2：文件末尾，默認爲0

異常

    try … except as e，except可有多個，e即異常對象，能夠對其進行打印異常信息等操做

    else在沒有異常時執行，即except代碼與else代碼只會執行一個；finally代碼則必定會被執行

round(value，num)函數

返回value的num位的小數，與print("%.1f " % 1.95）一致

round(0.5)，2.x中保留到離0遠的一邊，爲1；3.x保留到偶數的一邊，爲0

但特殊數字round出來的結果可能未必是想要的：

round(2.675,2)在2.x與3.x中都爲2.67，但應該都是2.68，這是由於浮點數在內存中並不與標定的同樣大

參見：python中round()的小坑

可用別的方法：字符串格式化能夠作截斷使用，例如 "%.2f" % value

不過浮點數的不精確也會影響到print("%.1f " % 1.95）

decimal模塊提供了十進制浮點運算支持，from decimal import Decimal

Decimal(2.675)方法，返回實際的精確數，2.67499999999999982