面向對象編程

面向對象編程 Object Oriented Programming 簡稱 OOP，是一種程序設計思想。OOP把對象作為程序的基本單元，一個對象包含了數據和操作數據的函數。

面向過程的程序設計把計算機程序視為一系列的命令集合，即一組函數的順序執行。為了簡化程序設計，面向過程把函數繼續切分為子函數，即把大塊函數通過切割成小塊函數來降低系統的復雜度。

而面向對象的程序設計把計算機程序視為一組對象的集合，而每個對象都可以接收其他對象發過來的消息，并處理這些消息，計算機程序的執行就是一系列消息在各個對象之間傳遞。

在Python中，所有數據類型都可以視為對象，當然也可以自定義對象。自定義的對象數據類型就是面向對象中的類（Class）的概念。面向對象的抽象程度又比函數要高，因為一個Class既包含數據，又包含操作數據的方法。

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類，就可以根據Student類創建出Student的實例，創建實例是通過類名+()實現的。__init__函數與其它函數有所不同，它的第一個參數永遠是實例變量self，并且，調用時，不用傳遞該參數。

數據封裝

類本身擁有數據和方法，相當于將“數據”封裝起來了。對于外部來說，并不需要知道內部的邏輯。

訪問限制

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

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__的，也就是以雙下劃線開頭，并且以雙下劃線結尾的，是特殊變量，特殊變量是可以直接訪問的，不是private變量，所以，不能用__name__、__score__這樣的變量名。

繼承和多態

在OOP程序設計中，當我們定義一個class的時候，可以從某個現有的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…')

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

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

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

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

鴨子類型

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

獲取對象信息

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

type()

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

>>> import types

>>> def fn():

... pass

...

>>> type(fn)==types.FunctionType

True

>>> type(abs)==types.BuiltinFunctionType

True

>>> type(lambda x: x)==types.LambdaType

True

>>> type((x for x in range(10)))==types.GeneratorType

True

isinstance()

對于類和實例，使用type()就不是很方便，可以使用isinstance()。基本數據類型也可以使用isinstance()判斷。還可以判斷一個變量是否是某些類型中的一種。

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

True

>>> isinstance((1, 2, 3), (list, tuple))

True

dir()

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

實例屬性和類屬性

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

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

面向對象高級編程

數據封裝、繼承和多態是面相對象程序設計中的三個基本概念，另外還有很多特性，包括多重繼承、定制類等。

使用 slots()

在Python中，可以對類動態的增加屬性和方法，這在靜態語言中很難實現。

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

class Student(object):

def __init__(self):

print("Instance Created")

Tracy = Student()

Tracy.age = 30

Bob = Student()

Bob.age = 41

Ceaser = Student()

print(Tracy.age)

print(Bob.age)

def set_age(self, age):

self.age = age

from types import MethodType

s = Student()

s.set_age = MethodType(set_age, s)

s.set_age(25)

print(s.age)

Student.set_age = set_age

Ceaser.set_age(33)

print(Ceaser.age)

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

class Student(object):

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

使用@Property

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

還記得裝飾器（decorator）可以給函數動態加上功能嗎？對于類的方法，裝飾器一樣起作用。Python內置的@property裝飾器就是負責把一個方法變成屬性調用的。

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的實現比較復雜，我們先考察如何使用。把一個getter方法變成屬性，只需要加上@property就可以了，此時，@property本身又創建了另一個裝飾器@score.setter，負責把一個setter方法變成屬性賦值，于是，我們就擁有一個可控的屬性操作。

>>> s = Student()

>>> s.score = 60 # OK，實際轉化為s.set_score(60)

>>> s.score # OK，實際轉化為s.get_score()

60

>>> s.score = 9999

Traceback (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

多重繼承

繼承是面向對象編程的一個重要的方式，因為通過繼承，子類就可以擴展父類的功能。舉例來說對于動物的對象設計，可以按照“哺乳動物”、“鳥類”來設計分類對象，按照不同的維度，也可以按照“能跑的”、“能飛的”或者“寵物”、“非寵物”設計分類，如果按照單一繼承的方式，類的設計就像下圖，會變的非常復雜。

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

class Animal(object):

pass

# 大類:

class Mammal(Animal):

pass

class Bird(Animal):

pass

# 各種動物:

class Dog(Mammal):

pass

class Bat(Mammal):

pass

class Parrot(Bird):

pass

class Ostrich(Bird):

pass

class Runnable(object):

def run(self):

print('Running...')

class Flyable(object):

def fly(self):

print('Flying…’)

class Dog(Mammal, Runnable):

pass

class Bat(Mammal, Flyable):

pass

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

定制類

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

str

定義print 函數調用時的返回結果。

>>> 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

定義返回程序開發者看到的字符串，也就是在命令行狀態下執行時的返回值。

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循環，類似list或tuple那樣，就必須實現一個__iter__()方法，該方法返回一個迭代對象，然后，Python的for循環就會不斷調用該迭代對象的__next__()方法拿到循環的下一個值，直到遇到StopIteration錯誤時退出循環。

class Fib(object):

def __init__(self):

self.a, self.b = 0, 1 # 初始化兩個計數器a，b

def __iter__(self):

return self # 實例本身就是迭代對象，故返回自己

def __next__(self):

self.a, self.b = self.b, self.a + self.b # 計算下一個值

if self.a > 100000: # 退出循環的條件

raise StopIteration()

return self.a # 返回下一個值

getitem

Fib實例雖然能作用于for循環，看起來和list有點像，但是，把它當成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

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

getattr

正常情況下，當我們調用類的方法或屬性時，如果不存在，就會報錯。要避免這個錯誤，除了可以加上一個屬性外，Python還有另一個機制，那就是寫一個__getattr__()方法，動態返回一個屬性。

class Student(object):

def __init__(self):

self.name = 'Michael'

def __getattr__(self, attr):

if attr=='score':

return 99

call

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

class Student(object):

def __init__(self, name):

self.name = name

def __call__(self):

print('My name is %s.' % self.name)

使用枚舉類

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

from enum import Enum

Month = 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裝飾器可以幫助我們檢查保證沒有重復值。

class Weekday(Enum):

Sun = 0 # Sun的value被設定為0

Mon = 1

Tue = 2

Wed = 3

Thu = 4

Fri = 5

Sat = 6

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

使用元類

type()

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

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

>>> def fn(self, name='world'): # 先定義函數

... print('Hello, %s.' % name)

...

>>> Hello = type('Hello', (object,), dict(hello=fn)) # 創建Hello class

>>> h = Hello()

>>> h.hello()

Hello, world.

>>> print(type(Hello))

>>> print(type(h))

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

1.class的名稱；

2.繼承的父類集合，注意Python支持多重繼承，如果只有一個父類，別忘了tuple的單元素寫法；

3.class的方法名稱與函數綁定，這里我們把函數fn綁定到方法名hello上。

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

metaclass

metaclass，直譯為元類，簡單的解釋就是：

當我們定義了類以后，就可以根據這個類創建出實例，所以：先定義類，然后創建實例。

但是如果我們想創建出類呢？那就必須根據metaclass創建出類，所以：先定義metaclass，然后創建類。

# 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)

總結

以上是生活随笔為你收集整理的python3.6程序实例_Python3.6学习笔记（三）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。