Python3學(xué)習(xí)筆記（三）

huitu_灰兔 2017-10-08

展開全文

面向?qū)ο缶幊?/h2>
面向?qū)ο缶幊?Object Oriented Programming 簡稱 OOP，是一種程序設(shè)計思想。OOP把對象作為程序的基本單元，一個對象包含了數(shù)據(jù)和操作數(shù)據(jù)的函數(shù)。
面向過程的程序設(shè)計把計算機程序視為一系列的命令集合，即一組函數(shù)的順序執(zhí)行。為了簡化程序設(shè)計，面向過程把函數(shù)繼續(xù)切分為子函數(shù)，即把大塊函數(shù)通過切割成小塊函數(shù)來降低系統(tǒng)的復(fù)雜度。
而面向?qū)ο蟮某绦蛟O(shè)計把計算機程序視為一組對象的集合，而每個對象都可以接收其他對象發(fā)過來的消息，并處理這些消息，計算機程序的執(zhí)行就是一系列消息在各個對象之間傳遞。
在Python中，所有數(shù)據(jù)類型都可以視為對象，當(dāng)然也可以自定義對象。自定義的對象數(shù)據(jù)類型就是面向?qū)ο笾械念悾–lass）的概念。面向?qū)ο蟮某橄蟪潭扔直群瘮?shù)要高，因為一個Class既包含數(shù)據(jù)，又包含操作數(shù)據(jù)的方法。
`class Student(object): def init(self, name, score): self.name = name self.score = score def print_score(self): print('%s: %s' % (self.name, self.score))`

類和實例

class后面緊接著是類名，即Student，類名通常是大寫開頭的單詞，緊接著是(object)，表示該類是從哪個類繼承下來的，繼承的概念我們后面再講，通常，如果沒有合適的繼承類，就使用object類，這是所有類最終都會繼承的類。

定義好了Student類，就可以根據(jù)Student類創(chuàng)建出Student的實例，創(chuàng)建實例是通過類名+()實現(xiàn)的。__init__函數(shù)與其它函數(shù)有所不同，它的第一個參數(shù)永遠是實例變量self，并且，調(diào)用時，不用傳遞該參數(shù)。

數(shù)據(jù)封裝

類本身擁有數(shù)據(jù)和方法，相當(dāng)于將“數(shù)據(jù)”封裝起來了。對于外部來說，并不需要知道內(nèi)部的邏輯。

訪問限制

Class可以有屬性和方法，我們可以對屬性和方法進行控制，以達到允許或者不允許外部訪問的目的。如果要讓內(nèi)部屬性不被外部訪問，可以把屬性的名稱前加上兩個下劃線__，在Python中，實例的變量名如果以__開頭，就變成了一個私有變量（private），只有內(nèi)部可以訪問，外部不能訪問。

class Student(object):    def __init__(self, name, score):        self.__name = name        self.__score = score    
    def print_score(self):        print('%s: %s' % (self.__name, self.__score))    
    def get_name(self):        return self.__name    
    def get_score(self):        return self.__score    
    def set_score(self, score):        if 0 <> score <> 100:            
            self.__score = score        
        else:            
            raise ValueError('bad score’)

在Python中，變量名類似__xxx__的，也就是以雙下劃線開頭，并且以雙下劃線結(jié)尾的，是特殊變量，特殊變量是可以直接訪問的，不是private變量，所以，不能用__name__、__score__這樣的變量名。

繼承和多態(tài)

在OOP程序設(shè)計中，當(dāng)我們定義一個class的時候，可以從某個現(xiàn)有的class繼承，新的class稱為子類（Subclass），而被繼承的class稱為基類、父類或超類（Base class、Super class）。

class Animal(object):    def run(self):        print('Animal is running…')
class Dog(Animal):    def run(self):        print('Dog is running...')
class Cat(Animal):    def run(self):        print('Cat is running…')

當(dāng)子類和父類都存在相同的run()方法時，我們說，子類的run()覆蓋了父類的run()，在代碼運行的時候，總是會調(diào)用子類的run()。這樣，我們就獲得了繼承的另一個好處：多態(tài)。在繼承關(guān)系中，如果一個實例的數(shù)據(jù)類型是某個子類，那它的數(shù)據(jù)類型也可以被看做是父類。但是，反過來就不行。

對于一個變量，我們只需要知道它是Animal類型，無需確切地知道它的子類型，就可以放心地調(diào)用run()方法，而具體調(diào)用的run()方法是作用在Animal、Dog、Cat還是Tortoise對象上，由運行時該對象的確切類型決定，這就是多態(tài)真正的威力：調(diào)用方只管調(diào)用，不管細節(jié)，而當(dāng)我們新增一種Animal的子類時，只要確保run()方法編寫正確，不用管原來的代碼是如何調(diào)用的。這就是著名的“開閉”原則：

對擴展開放：允許新增Animal子類；

對修改封閉：不需要修改依賴Animal類型的外部函數(shù)。

鴨子類型

對于靜態(tài)語言（例如Java）來說，如果需要傳入Animal類型，則傳入的對象必須是Animal類型或者它的子類，否則，將無法調(diào)用run()方法。對于Python這樣的動態(tài)語言來說，則不一定需要傳入Animal類型。我們只需要保證傳入的對象有一個run()方法就可以了。這就是動態(tài)語言的“鴨子類型”，它并不要求嚴(yán)格的繼承體系，一個對象只要“看起來像鴨子，走起路來像鴨子”，那它就可以被看做是鴨子。

獲取對象信息

判斷Python中對象的類型，可以用以下方法。

type()

基本類型都可以用type()判斷，基本數(shù)據(jù)類型可以直接寫int、str，判斷是否函數(shù)需要使用types中定義的常量。

>>> import types
>>> def fn():...     pass...
>>> type(fn)==types.FunctionTypeTrue
>>> type(abs)==types.BuiltinFunctionTypeTrue
>>> type(lambda x: x)==types.LambdaTypeTrue
>>> type((x for x in range(10)))==types.GeneratorTypeTrue

isinstance()

對于類和實例，使用type()就不是很方便，可以使用isinstance()?；緮?shù)據(jù)類型也可以使用isinstance()判斷。還可以判斷一個變量是否是某些類型中的一種。

>>> isinstance([1, 2, 3], (list, tuple))True
>>> isinstance((1, 2, 3), (list, tuple))True

dir()

如果要獲得一個對象的所有屬性和方法，可以使用dir()函數(shù)，它返回一個包含字符串的list，比如，獲得一個str對象的所有屬性和方法。

實例屬性和類屬性

Python類創(chuàng)建的實例可以任意綁定屬性，如果需要對類本身綁定屬性，則需要在類中定義，這就區(qū)分了類屬性和實例屬性。

在編寫程序的時候，千萬不要把實例屬性和類屬性使用相同的名字，因為相同名稱的實例屬性將屏蔽掉類屬性，但是當(dāng)你刪除實例屬性后，再使用相同的名稱，訪問到的將是類屬性。

面向?qū)ο蟾呒壘幊?/h2>
數(shù)據(jù)封裝、繼承和多態(tài)是面相對象程序設(shè)計中的三個基本概念，另外還有很多特性，包括多重繼承、定制類等。

使用 slots()

在Python中，可以對類動態(tài)的增加屬性和方法，這在靜態(tài)語言中很難實現(xiàn)。

#!/usr/bin/env python3# -*- coding: utf-8 -*-

class Student(object):     def __init__(self):          print('Instance Created')Tracy = Student()Tracy.age = 30Bob = Student()Bob.age = 41Ceaser = Student()print(Tracy.age)print(Bob.age)
def set_age(self, age):     self.age = agefrom types import MethodTypes = Student()s.set_age = MethodType(set_age, s)s.set_age(25)print(s.age)Student.set_age = set_ageCeaser.set_age(33)print(Ceaser.age)

但這也帶來一個問題，屬性和方法可以隨意更改，如果我們要限制怎么辦？可以使用__slots。Python允許在定義class的時候，定義一個特殊的__slots__變量，來限制該class實例能添加的屬性。使用__slots__要注意，__slots__定義的屬性僅對當(dāng)前類實例起作用，對繼承的子類是不起作用的。

class Student(object): __slots__ = ('name', 'age') # 用tuple定義允許綁定的屬性名稱

使用@Property

Python中實例的屬性暴露在外面可以隨便修改，這樣就無法保證屬性的有效性符合校驗規(guī)則。雖然可以通過設(shè)置Setter和Getter來進行檢查，但如果屬性特別多，操作起來又比較麻煩。

還記得裝飾器（decorator）可以給函數(shù)動態(tài)加上功能嗎？對于類的方法，裝飾器一樣起作用。Python內(nèi)置的@property裝飾器就是負責(zé)把一個方法變成屬性調(diào)用的。

class Student(object):    @property    def score(self):        return self._score    @score.setter    def score(self, value):        if not isinstance(value, int):            
    raise ValueError('score must be an integer!')        
if value  0 or value > 100:            
    raise ValueError('score must between 0 ~ 100!')        
    self._score = value

@property的實現(xiàn)比較復(fù)雜，我們先考察如何使用。把一個getter方法變成屬性，只需要加上@property就可以了，此時，@property本身又創(chuàng)建了另一個裝飾器@score.setter，負責(zé)把一個setter方法變成屬性賦值，于是，我們就擁有一個可控的屬性操作。

>>> s = Student()
>>> s.score = 60 # OK，實際轉(zhuǎn)化為s.set_score(60)
>>> s.score # OK，實際轉(zhuǎn)化為s.get_score()60
>>> s.score = 9999Traceback (most recent call last):  ...ValueError: score must between 0 ~ 100!

還可以定義只讀屬性，只定義getter方法，不定義setter方法就是一個只讀屬性。

class Student(object):    @property    def birth(self):        return self._birth    @birth.setter    def birth(self, value):        self._birth = value    @property    def age(self):        return 2015 - self._birth

多重繼承

繼承是面向?qū)ο缶幊痰囊粋€重要的方式，因為通過繼承，子類就可以擴展父類的功能。舉例來說對于動物的對象設(shè)計，可以按照“哺乳動物”、“鳥類”來設(shè)計分類對象，按照不同的維度，也可以按照“能跑的”、“能飛的”或者“寵物”、“非寵物”設(shè)計分類，如果按照單一繼承的方式，類的設(shè)計就像下圖，會變的非常復(fù)雜。

正確的辦法是采用多重繼承。一個子類就可以同時獲得多個父類的所有功能。在設(shè)計類的繼承關(guān)系時，通常，主線都是單一繼承下來的，例如，Ostrich繼承自Bird。但是，如果需要“混入”額外的功能，通過多重繼承就可以實現(xiàn)，比如，讓Ostrich除了繼承自Bird外，再同時繼承Runnable。這種設(shè)計通常稱之為MixIn。

class Animal(object):    pass# 大類:class Mammal(Animal):    passclass Bird(Animal):    pass# 各種動物:class Dog(Mammal):    passclass Bat(Mammal):    passclass Parrot(Bird):    passclass Ostrich(Bird):    passclass Runnable(object):    def run(self):        print('Running...')class Flyable(object):    def fly(self):        print('Flying…’)class Dog(Mammal, Runnable):    passclass Bat(Mammal, Flyable):    pass

Python自帶的很多庫也使用了MixIn。舉個例子，Python自帶了TCPServer和UDPServer這兩類網(wǎng)絡(luò)服務(wù)，而要同時服務(wù)多個用戶就必須使用多進程或多線程模型，這兩種模型由ForkingMixIn和ThreadingMixIn提供。通過組合，我們就可以創(chuàng)造出合適的服務(wù)來。

定制類

類似于__slots__，Python的class中還有許多這樣有特殊用途的函數(shù)，可以幫助我們定制類。

str

定義print 函數(shù)調(diào)用時的返回結(jié)果。

>>> class Student(object):...     
        def __init__(self, name):...         
            self.name = name...     
        def __str__(self):...         
            return 'Student object (name: %s)' % self.name...>>> print(Student('Michael'))Student object (name: Michael)

repr

定義返回程序開發(fā)者看到的字符串，也就是在命令行狀態(tài)下執(zhí)行時的返回值。

class Student(object):    def __init__(self, name):        self.name = name    
    def __str__(self):        return 'Student object (name=%s)' % self.name    
                __repr__ = __str__

iter

如果一個類想被用于for … in循環(huán)，類似list或tuple那樣，就必須實現(xiàn)一個__iter__()方法，該方法返回一個迭代對象，然后，Python的for循環(huán)就會不斷調(diào)用該迭代對象的__next__()方法拿到循環(huán)的下一個值，直到遇到StopIteration錯誤時退出循環(huán)。

class Fib(object):    def __init__(self):        self.a, self.b = 0, 1 # 初始化兩個計數(shù)器a，b    def __iter__(self):        return self # 實例本身就是迭代對象，故返回自己    def __next__(self):        self.a, self.b = self.b, self.a + self.b # 計算下一個值        if self.a > 100000: # 退出循環(huán)的條件            raise StopIteration()        
            return self.a # 返回下一個值

getitem

Fib實例雖然能作用于for循環(huán)，看起來和list有點像，但是，把它當(dāng)成list來使用還是不行，比如，取第5個元素。

class Fib(object):    def __getitem__(self, n):        if isinstance(n, int): # n是索引            a, b = 1, 1            for x in range(n):                a, b = b, a + b            
                return a        
                if isinstance(n, slice): # n是切片                    start = n.start                    stop = n.stop            
                    if start is None:                        start = 0                        a, b = 1, 1                        L = []            
                        for x in range(stop):                
                            if x >= start:                                L.append(a)                                a, b = b, a + b            
                            return L

通過上面的方法，我們自己定義的類表現(xiàn)得和Python自帶的list、tuple、dict沒什么區(qū)別，這完全歸功于動態(tài)語言的“鴨子類型”，不需要強制繼承某個接口。

getattr

正常情況下，當(dāng)我們調(diào)用類的方法或?qū)傩詴r，如果不存在，就會報錯。要避免這個錯誤，除了可以加上一個屬性外，Python還有另一個機制，那就是寫一個__getattr__()方法，動態(tài)返回一個屬性。

class Student(object):    def __init__(self):        self.name = 'Michael'    def __getattr__(self, attr):        if attr=='score':            
        return 99

call

任何類，只需要定義一個__call__()方法，就可以直接對實例進行調(diào)用。__call__()還可以定義參數(shù)。對實例進行直接調(diào)用就好比對一個函數(shù)進行調(diào)用一樣，所以你完全可以把對象看成函數(shù)，把函數(shù)看成對象，因為這兩者之間本來就沒啥根本的區(qū)別。

class Student(object):    def __init__(self, name):        self.name = name    
    def __call__(self):        print('My name is %s.' % self.name)

使用枚舉類

之前說到過，Python中其實不存在常量，但是可以通過枚舉類的方式來變通實現(xiàn)。

from enum import EnumMonth = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
for name, member in Month.__members__.items():    
    print(name, '=>', member, ',', member.value)
    from enum import Enum, unique@unique            #@unique裝飾器可以幫助我們檢查保證沒有重復(fù)值。

class Weekday(Enum):    Sun = 0 # Sun的value被設(shè)定為0    Mon = 1    Tue = 2    Wed = 3    Thu = 4    Fri = 5    Sat = 6

這樣我們就獲得了Month類型的枚舉類，可以直接使用Month.Jan來引用一個常量，或者枚舉它的所有成員。

使用元類

type()

type()函數(shù)可以查看一個類型或變量的類型，Hello是一個class，它的類型就是type，而h是一個實例，它的類型就是class Hello。我們說class的定義是運行時動態(tài)創(chuàng)建的，而創(chuàng)建class的方法就是使用type()函數(shù)。

type()函數(shù)既可以返回一個對象的類型，又可以創(chuàng)建出新的類型，比如，我們可以通過type()函數(shù)創(chuàng)建出Hello類，而無需通過class Hello(object)…的定義。

>>> def fn(self, name='world'): # 先定義函數(shù)...     
        print('Hello, %s.' % name)>>> Hello = type('Hello', (object,), 
        dict(hello=fn)) # 創(chuàng)建Hello class
>>> h = Hello()
>>> h.hello()Hello, world.
>>> print(type(Hello))class 'type'>
>>> print(type(h))class '__main__.Hello’>

要創(chuàng)建一個class對象，type()函數(shù)依次傳入3個參數(shù)：

1.class的名稱；
2.繼承的父類集合，注意Python支持多重繼承，如果只有一個父類，別忘了tuple的單元素寫法；
3.class的方法名稱與函數(shù)綁定，這里我們把函數(shù)fn綁定到方法名hello上。

通過type()函數(shù)創(chuàng)建的類和直接寫class是完全一樣的，因為Python解釋器遇到class定義時，僅僅是掃描一下class定義的語法，然后調(diào)用type()函數(shù)創(chuàng)建出class。

metaclass

metaclass，直譯為元類，簡單的解釋就是：
當(dāng)我們定義了類以后，就可以根據(jù)這個類創(chuàng)建出實例，所以：先定義類，然后創(chuàng)建實例。
但是如果我們想創(chuàng)建出類呢？那就必須根據(jù)metaclass創(chuàng)建出類，所以：先定義metaclass，然后創(chuàng)建類。

# metaclass是類的模板，所以必須從`type`類型派生：

class ListMetaclass(type):    def __new__(cls, name, bases, attrs):        attrs['add'] = lambda self, value: self.append(value)        return type.__new__(cls, name, bases, attires)

感謝大家對“Python互動中心”的關(guān)注，一起學(xué)習(xí)的可加小編為好友

本站是提供個人知識管理的網(wǎng)絡(luò)存儲空間，所有內(nèi)容均由用戶發(fā)布，不代表本站觀點。請注意甄別內(nèi)容中的聯(lián)系方式、誘導(dǎo)購買等信息，謹防詐騙。如發(fā)現(xiàn)有害或侵權(quán)內(nèi)容，請點擊一鍵舉報。

一区二区三区日韩精品-日韩经典一区二区三区-五月激情综合丁香婷婷-欧美精品中文字幕专区

Python3學(xué)習(xí)筆記（三）

類和實例

數(shù)據(jù)封裝

訪問限制

繼承和多態(tài)

鴨子類型

獲取對象信息

type()

isinstance()

dir()

實例屬性和類屬性

面向?qū)ο蟾呒壘幊?/h2>數(shù)據(jù)封裝、繼承和多態(tài)是面相對象程序設(shè)計中的三個基本概念，另外還有很多特性，包括多重繼承、定制類等。

使用 slots()

使用@Property

多重繼承

定制類

str

repr

iter

getitem

getattr

call

使用枚舉類

使用元類

type()

metaclass

面向?qū)ο蟾呒壘幊?/h2>
數(shù)據(jù)封裝、繼承和多態(tài)是面相對象程序設(shè)計中的三個基本概念，另外還有很多特性，包括多重繼承、定制類等。