1. Python的兩種運行模式：
   • 命令行模式，運行python,然后在命令行中輸入python命令
   • 程序腳本, 在命令行中輸入 ./hello.py運行
2. Python是解釋形語言，但可以通過工具打包成二進制可執(zhí)行文件
3. 指定Python文件的編碼方式:#coding:utf-8
4. 注釋符為#,多行注釋以'''開始，以'''結(jié)束
5. 變量不需要聲明類型，可以自動推導(dǎo)，type()函數(shù)可以獲得變量類型
6. 序列（sequence）是一組由順序的元素的集合，各元素類型可以不同，序列分三種
   • tuple(元組):tuple中的元素不可以變更，用()定義，也可以省略(),字符串是一種特殊元組
   • list:各個元素可以再變更,用[]定義
   • range:表示由數(shù)字組成的不可變序列，通常用于循環(huán)
     
     
7. 一個序列可以作另一個序列的元素，用[]可以訪問序列元素，也可以使用范圍引用，表達式為[下限:上限:步長],獲取的數(shù)據(jù)索引到上限前一個元素
8. 列表推導(dǎo)(list comPRehension):快速生成表(list)的方法，示例:
   L=[x**2 for x in range(10)],這與生成器表達式類似，只不過用的是中括號
9. 詞典類型的定義dic={key1:value1,key2:value2},key可以使字符串，數(shù)字，bool型等，不可變對象都可以做鍵，創(chuàng)建字典的方法有:
   

   dict exampledict([('sape', 4139), ('guido', 4127), ('jack', 4098)])#{'sape': 4139, 'jack': 4098, 'guido': 4127}{x: x**2 for x in (2, 4, 6)}#{2: 4, 4: 16, 6: 36}dict(sape=4139, guido=4127, jack=4098)#{'sape': 4139, 'jack': 4098, 'guido': 4127}

   字典的循環(huán)如下，注意循環(huán)的key值
   for key in dic:
       print(dic[key])
10. 字典的常用函數(shù): keys(),values(),items(),clear()，還有一個常用用法是del dic['Tom'],刪除key為Tom的元素，del是Python中的關(guān)鍵字，不是函數(shù)，用于刪除對象
11. set:不重復(fù)元素的集合，可以用大括號或者set()函數(shù)創(chuàng)建set,set支持，支持交集,并集，差集等運算,并且也支持列表推導(dǎo)
    

    set examplebasket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}print(basket)#返回{'orange', 'banana', 'pear', 'apple'}#定義空集a=set()#注意{}定義的是空詞典b={}a = set('abracadabra')b = set('alacazam')print(a)#{'a', 'r', 'b', 'c', 'd'}print(a-b)#{'r', 'd', 'b'}#列表推導(dǎo),注釋是大括號a = {x for x in 'abracadabra' if x not in 'abc'}print(a)#{'r', 'd'}

12. 函數(shù)定義的關(guān)鍵字：def, return可以返回多個值，如return a,b,c，相當(dāng)于return(a,b,c)
    • 函數(shù)參數(shù)的傳遞，可以使用關(guān)鍵字傳遞參數(shù)，這樣不用遵守位置的對應(yīng)關(guān)系。定義函數(shù)時參數(shù)可以指定默認值
    • 包裹參數(shù)傳遞：定義函數(shù)時在相應(yīng)的元組或者字典前加*或者**,如
      • func(*arr):arr是一個tuple,調(diào)用時，func(1,2,3,4)
      • func(**dic):dic是一個字典，調(diào)用時,func(a=1,b=2,c=3)
    • 解包裹:函數(shù)定義時未使用包裹參數(shù)，調(diào)用時傳入包裹參數(shù)，函數(shù)會自動進行拆解，注意調(diào)用時，參數(shù)值前要加*或者**,對應(yīng)tuple和字典,如:

      def func(a,b,c):       print(a,b,c)args = (1,3,4)func(*args) 
      

    • 函數(shù)也是對象,也可以作為參數(shù)傳給其他函數(shù)
13. python中一切都是對象,class是對象，實例也是對象，python中所有對象都允許動態(tài)添加屬性和方法,當(dāng)類添加新屬性后，類的實例同樣能訪問該屬性。當(dāng)訪問一個對象的屬性如obj.age時，查找該屬性的順序為:
    • 對象自身的屬性(obj.__dict__中)
    • 對象的類屬性(obj.__class__.__dict__中)
    • 對象的類的基類，以及基類的基類(obj.__class__.__bases__中的每一個類的__dict__)，一直下去
    • 最后未找到屬性，會拋出AttributeError異常
14. Python使用class定義類，類的實例方法第一個參數(shù)必須是self,用于引用對象本身，類似于this,類的成員以self.member形式在類中訪問，python中沒有public,private等關(guān)鍵字，類成員默認都為公開的,類的私有成員命名必須以__開始,在python內(nèi)部使用name mangling技術(shù)將__membername重命名為_class__membername(classname是成員所在的類名),所以使用原有的私有成員名字會提示找不到，但使用_classname__membername仍然可以訪問該私有變量，所以python的私有成員不是絕對無法訪問的.注意以__開始__結(jié)尾的成員是系統(tǒng)保留名字，普通變量不能這樣命名
15. python的類方法包括三種:
    • 實例方法，至少帶一個self(其他名也可以)參數(shù)，表示實例本身,由類的實例訪問，也可以由類直接訪問，但第一個參數(shù)的含義就變了
      

      實例方法class A:    def test(self,age):        print("hello")#self='b'A.test('b','c')a=A()#self=a，也可以寫為A.test(a,’c’)a.test('c')

    • 帶@classmethod裝飾器的方法,至少帶一個參數(shù)cls,表示類本身可以通過類名訪問也可以通過實例訪問
    • 帶@staticmethod裝飾器的方法，可以不帶參數(shù)，由類或者類的實例訪問
16. python class中的”靜態(tài)方法”和”靜態(tài)成員”:在python類作用域中，不帶self參數(shù)的方法和不使用self訪問的成員起到靜態(tài)成員的作用。對靜態(tài)成員要注意:
    • 靜態(tài)成員使用class.member或者instance.member都可以訪問(如果沒有同名的實例成員，有則訪問實例成員). class是類名，instance是類的實例
    • 如果靜態(tài)成員是值類型,為instance.member賦值相當(dāng)于新建一個與該靜態(tài)成員同名的實例成員,不會影響class.Member的值，之后對class.member的改動不會反應(yīng)到instance.member。如果未對instance.member進行賦值，對class.member的改動會反應(yīng)到instance.member
    • 如果靜態(tài)成員是引用類型，則對instance.member的改動會反應(yīng)到class.member,也會反應(yīng)到其他同類型實例的member
17. 繼承的語法: class SubClass(ParentClass1,ParentClass2), ParentClass是父類，SubClass是子類
    
    
18. _特殊方法(special method):通過特殊的語法實現(xiàn)某些操作，是python實現(xiàn)操作符重載的方式,常用特殊方法有:
    • object.__new__(cls,…):是一個靜態(tài)方法(特殊方法，不用像聲明靜態(tài)函數(shù)那樣聲明)，用于創(chuàng)建一個類對象，創(chuàng)建出的對象會傳遞給__init__的self參數(shù)，函數(shù)的其余參數(shù)也傳遞給__init__。函數(shù)的參數(shù)由構(gòu)造函數(shù)而來。如果子類中重寫了__new__函數(shù)，實例化對象時會調(diào)用子類的__new__,子類的__new__方法可以顯示調(diào)用基類的__new__,否則不會調(diào)用基類的__new__,子類如果沒重寫__new__則調(diào)用基類的__new__.
    • object._init__(self,…):相當(dāng)于初始化過程。如:human = Human("male"); 參數(shù)male先傳給__new__再傳給__init__()方法,如果父類有__init__函數(shù)，子類重寫了__init__函數(shù)，應(yīng)當(dāng)在子類的__init__中調(diào)用父類的__init__函數(shù)以完成初始化,否則不會自動調(diào)用父類的__init__函數(shù)，如果子類沒有重寫__init__函數(shù)，實例化子類時則會調(diào)用父類的__init__函數(shù)
    • object.__del__():析構(gòu)器,父類中如果有__del__函數(shù)，應(yīng)該在子類的__del__函數(shù)中顯示調(diào)用此函數(shù)以確保資源被正常釋放
    • object.__call__():定義類型時，如果實現(xiàn)了實例方法__call__,那么實例就是可調(diào)用的，如x(5),相當(dāng)于調(diào)用了x.__call__(5).如果是metaclass定義了__call__函數(shù)，那么其創(chuàng)建的類就是可調(diào)用的，與類實現(xiàn)__call__，則其實例是可調(diào)用的是一個道理
    • object__repr__():返回對象的offical representation string, 對于許多類型，將返回值傳給eval()函數(shù)可以得到一個具有相同值得對象
    • object.__str__():返回對象的informal representation string
    • object.__bytes__():返回對象的byte-string representation
    • class.__subclasses__():返回直接集成該類的子
19. 特殊屬性(special attributes):只讀屬性,常用特殊屬性有:
    • object.__dict__:字典類型，存儲對象的屬性，不包括只讀屬性.要注意的是類實例的__dict__中不含其class.__dict__中的值,只包含實例本身的屬性和新加的屬性。
    • instance.__class__:對象的類型,準(zhǔn)確說是創(chuàng)建該instance的類
    • class.__bases__:類的基類的元組,只有類類型才有該屬性，實例沒有
      

      __class__ __bases__ example#返回<class 'type'>,因為int 類是由type類創(chuàng)建的對象int.__class__#返回<class 'object'>,int類的基類是objectint.__bases__x="abc"#返回<class 'str'>x是由str類創(chuàng)建的對象x.__class__

    • class.__name__:類名
    • class.__mro__:一個class的tuple，當(dāng)解析方法時按照tuple中定義類的順序查找基類中的方法
    • class.__module__:class所屬的模塊名
20. python descriptor:如果定義的類(對象)具有__get__,__set__,__delete__方法中的任意一個，這個類(對象)就叫descriptor,作用是攔截屬性的訪問.descriptor屬性會改變普通屬性訪問時的查找
    

    descriptor exampleclass Descriptor(object):    def __init__(self, label):        self.label = label #本例中，instance是f,owner是Foo    def __get__(self, instance, owner):        print( '__get__', instance, owner)        return instance.__dict__.get(self.label)     def __set__(self, instance, value):        print ('__set__')#使用__dict__生成實例屬性，可以防止所有的實例都同樣的值，因為descriptor是類屬性        instance.__dict__[self.label] = value class Foo(list):#decriptor只能應(yīng)用與類屬性，不能用于實例屬性    x = Descriptor('x')    y = Descriptor('y')f = Foo()f.x = 5#會調(diào)用__set__print(f.x)#會調(diào)用__get__

    
    
21. 模塊(Module):一個.py文件就是一個模塊，模塊名必須是小寫字母和下劃線，使用import關(guān)鍵字引入其他模塊，使用模塊.對象的方式來訪問引入模塊中的對象.每個模塊中都有一個內(nèi)置變量__name__,如果是模塊自己運行,__name__=’__main__’,如果被其他模塊import，則模塊的__name__就是等于模塊名(不包含擴展名),python中所有加載到內(nèi)存的模塊都放在sys.modules中,import一個模塊時會首先查找這個列表。import的模塊會被加入當(dāng)前模塊的名字空間，import模塊時會執(zhí)行模塊中的代碼，import package時則會執(zhí)行__init__.py中的代碼
22. import的一些用法：
    • import a as b :引入模塊a,并重命名為b
    • from a import func1: 從模塊a中引入func1對象，之后可以直接使用func1，而不用使用a.func1
    • from a import *:從模塊a中引入所有對象，這樣可以直接使用a中的對象，而不必用a.對象
    • module或package所在的目錄再sys.path中，那么就可以import模塊或package
23. Python會在以下路徑搜索它想要的模塊:
    • 程序所在的文件夾
    • 標(biāo)準(zhǔn)庫的安裝路徑
    • 操作系統(tǒng)環(huán)境變量PYTHONPATH所包含的路徑
      
      
24. package：功能相似的模塊放在同一個文件夾中，就構(gòu)成一個package，文件夾中必須包含一個__int__.py的文件(可以為空)以通知Python，該文件夾是一個package,通過：
    import dir.module引用dir文件夾中的module
25. 用于循環(huán)的函數(shù)：
    • range:
    • enumerate():可以在每次循環(huán)中同時得到下標(biāo)和元素，for(index,value) in enumerate(arr)
    • zip():用于循環(huán)多個等長序列，每次循環(huán)從各個序列中分別取一個元素，for(a,b,c)in zip(arr1,arr2,arr3).zip的作用就是從各個序列中依次取出一個元素，合成一個tuple,返回值是一個zip類型對象，可以用list()函數(shù)轉(zhuǎn)換為list類型
26. 生成器(Generator):構(gòu)建一個用戶自定義的循環(huán)對象，編寫方法與函數(shù)類似，只是return改為yield，可以有多個yield，generator遇到y(tǒng)ield時會暫停運行返回yield后面的值，再次調(diào)用生成器的時候，會從暫停的地方繼續(xù)運行，返回下一個yield值。生成器示例:
    G=(x for x in range(4)),G就是一個生成器，用__next__()方法訪問其中的值
27. 可迭代對象(iterable):python自帶的iterable包括,list,str,tuple,dict ,file,自定義了__iter__()或者__getitem__()類的實例也是,iterable.iter(iterable)就返回這個對象的迭代器
28. 迭代器(iterator):__iter__方法就返回一個迭代器，迭代器可以使用next方法調(diào)用，也就是它實現(xiàn)了__next__方法,將一個class實現(xiàn)為迭代器它必須實現(xiàn)__iter__()和__next__()方法.迭代器只能向前迭代，不能回退，直到拋出StopIteration,不是線程安全的。for關(guān)鍵字是迭代器的語法糖，封裝了迭代器的循環(huán)操作。python自帶的類型tuple,list,set,dict,字符串都支持迭代器
29. lambda:示例 func=lambda x,y:x+y 調(diào)用跟普通函數(shù)一樣，func(3,5)
30. 異常語法如下，自己拋出式樣使用raise關(guān)鍵字
    

     try:    ... 
    except exception1:    ... 
    except exception2:    ... 
    except:    ... 
    else:    ... 
    finally:    ...

    如果沒有異常，則執(zhí)行else語句,如果沒有對應(yīng)的異常類型則會向上層拋出異常
    
    
31. 上下文管理器：用于規(guī)定某個對象的使用范圍，語法：with ....as...，任何定義了__enter__()和__exit__()方法的對象都可用于上下文管理器

    # with context manager with open("new.txt", "w") as f:       print(f.closed)     f.write("Hello World!") print(f.closed)

32. 對象的Property(attribute的一種):使用內(nèi)置函數(shù)property()來返回一個property，簽名如下:

    property(fget=None, fset=None, fdel=None, doc=None)

    • fget:獲取property value的函數(shù),只傳遞此參數(shù)，省略其他參數(shù)，將會得到只讀property
    • fset:設(shè)置property value的函數(shù)
    • fdel:刪除property的函數(shù)
    • doc:property的注釋字符
      

      property exampleclass C:    def __init__(self):        self._x = None    def getx(self):        return self._x    def setx(self, value):        self._x = value    def delx(self):        del self._x    x = property(getx, setx, delx, "I'm the 'x' property.")c=C();//調(diào)用getxa=c.x//調(diào)用setxc.x=9;//調(diào)用delxdel c.x

33. 可以把@property當(dāng)做一個裝飾器，如下代碼效果同上:
    

    property exampleclass C:    def __init__(self):        self._x = None    @property    def x(self):        """I'm the 'x' property."""        return self._x#函數(shù)名要與property name相同    @x.setter    def x(self, value):        self._x = value    @x.deleter    def x(self):        del self._x

34. 通過自定義object.__getattr__函數(shù)，在對象引用的attribute不存在時自動調(diào)用該函數(shù)，此函數(shù)中返回attribute的值或者raise AttributeError exception.注意與obj.__getattribute__函數(shù)的區(qū)別，后者在每次屬性訪問時都會先調(diào)用，如果屬性不存在才會接著調(diào)用__getattr__
    

    __getattr__ exampleclass Person():    def __init__(self, age):        self.age = age    def __getattr__(self, name):        if name == 'adult':            if self.age > 18: return True            else: return False        else: raise AttributeError(name)person = Person(20)#類中未定義adult attrprint(person.adult)

35. 閉包:Python中的閉包是一個包含有環(huán)境變量取值的函數(shù)對象，環(huán)境變量取值被保存在函數(shù)對象的__closure__屬性中
36. 裝飾器：對一個函數(shù)，方法或者類進行加工，可以使用def定義裝飾器，被裝飾函數(shù)或類前要加@裝飾器函數(shù),實際上將square_sum傳遞給decorator，并將decorator返回的新的可調(diào)用對象賦給原來的函數(shù)名,即square_sum=decor(square_sum) ,square_sum變成了new_F函數(shù)

    def decor(F):     def new_F(a,b):        print('decor')           return F(a,b)    return new_F@decordef square_sum(a, b):        return a**2 + b**2print(square_sum(2,3))#調(diào)用的是new_F函數(shù)print(square_sum(4,3))

    
    

37. 裝飾器即裝飾器類示例

    

    decoratordef decorator(func): # 裝飾器函數(shù)    print('in decorator')    def wrapper(*args):        print('in decorator wrapper')        wrapper._calls += 1        print("calls = %d" % (wrapper._calls))        func(*args)    wrapper._calls = 0    return wrapper@decoratordef foo(x, y):    print("x = %d, y = %d" % (x, y))foo(1, 2) # foo對象就被賦成了wrapper對象"""in decorator #定義foo時就會輸出in decorator wrappercalls = 1x = 1, y = 2"""foo(2, 3)"""in decorator wrappercalls = 2x = 2, y = 3"""#################下面是一個裝飾類################################################class decorator: #裝飾器類    def __init__(self, func):        print('in decorator __init__')        self.func = func        self.calls = 0    def __call__(self, *args):        print('in decorator __call__')        self.calls += 1        print("calls = %d" % (self.calls))        self.func(*args)@decoratordef foo(x, y):    print("x = %d, y = %d" % (x, y))foo(1, 2) # foo對象被賦值成了decorator對象#執(zhí)行過程先以foo為參數(shù)初始化decorator對象，調(diào)用foo(1,2)時則會調(diào)用decorator的__call__"""in decorator __init__ #定義foo時輸出in decorator __call__calls = 1x = 1, y = 2"""foo(2, 3) # 實際是調(diào)用decorator對象"""in decorator __call__calls = 2x = 2, y = 3"""

38. 格式化字符串:Python使用一個字符串作
    %[(name)][flags][width].[precision]typecode
    

    print("I'm %(name)s. I'm %(age)d year old" % {'name':'Vamei', 'age':99})(使用字典傳遞真實值)

39. 常用內(nèi)置函數(shù):

    • dir()用于查詢一個類或者對象所有屬性,其結(jié)果包含類或者對象的__dict__中包含的結(jié)果
    • help()用于查詢說明文檔
    • isinstance(objec,classinfo):返回對象是否是類的實例
    • issubclass(class,classinfo):class類是否是classinfo類的子類
    • repr():調(diào)用對象的__repr__,返回offical representation string，與反引號操作符作用相同，輸出對python友好，可以作為解釋器的輸入
    • str():調(diào)用對象的__str__，類似于c#的toString()功能，對人友好
    • bytes():調(diào)用對象的__bytes_
    • getattr():返回對象的屬性值，如果該屬性不存在會拋出AttributeError
    • hasattr():判斷類或?qū)ο笫欠癜硨傩?/span>
    • setattr():設(shè)置對象的屬性值,如果不存在會為對象添加新屬性，但不影響類的屬性.setattr(x,’name’,’tom’)相當(dāng)于x.name=’tom’
    • delattr():刪除屬性,delattr(x,’foobar’) 相當(dāng)于del x.foobar,不影響類屬性
    • iter():返回一個迭代器
    • vars():返回module,class,instance,或者是其他對象(包含__dict__屬性)的__dict__屬性
    • zip():以多個支持迭代器的對象為參數(shù)，返回一個tuples的迭代器，然后可以使用__next__()方法訪問每個tuple
    • super():訪問基類函數(shù)

      class C(B):    def method(self, arg): # This does the same thing as: # super(C, self).method(arg),相當(dāng)于B.method(self,arg),但在多繼承情況下super函數(shù)能避免相同基類被多次調(diào)用        super().method(arg)

    • map(函數(shù)對象，list...):功能是將函數(shù)對象依次作用于list的每一個元素,每次作用的結(jié)果存儲在返回的循環(huán)對象中，如果函數(shù)對象有多個參數(shù)，則后面可以有多個list，map函數(shù)每次從所有的list中取出一個值，作為函數(shù)的參數(shù)

    • filter(函數(shù)對象，list...):功能是將函數(shù)對象作用于多個元素，如果函數(shù)對象返回的是True,則返回該次的元素存儲在循環(huán)對象中

    • reduce(函數(shù)對象，list):函數(shù)對象只能接受兩個參數(shù)，可以累進的從list中取值，每一次調(diào)用函數(shù)對象的返回值與list中后面一個元素作為下次函數(shù)對象調(diào)用的參數(shù)。3.x中需要引入functools包 

40. 內(nèi)置函數(shù)列表：

		Built-in Functions
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()