python語法基礎學習筆記Task10:類與對象

1、一些基本概念

• 類(Class): 用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的實例。
• 方法：類中定義的函數。
• 類變量：類變量在整個實例化的對象中是公用的。類變量定義在類中且在函數體之外。類變量通常不作爲實例變量使用。
• 數據成員：類變量或者實例變量用於處理類及其實例對象的相關的數據。
• 方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程叫方法的覆蓋（override），也稱爲方法的重寫。
• 局部變量：定義在方法中的變量，只作用於當前實例的類。
• 實例變量：在類的聲明中，屬性是用變量來表示的。這種變量就稱爲實例變量，是在類聲明的內部但是在類的其他成員方法之外聲明的。
• 繼承：即一個派生類（derived class）繼承基類(base class）的字段和方法。繼承也允許把一個派生類的對象作爲一個基類對象對待。例如，有這樣一個設計：一個Dog類型的對象派生自Animal類，這是模擬"是一個（is-a）"關係（例圖，Dog是一個Animal）。
• 實例化：創建一個類的實例，類的具體對象。
• 對象：通過類定義的數據結構實例。對象包括兩個數據成員（類變量和實例變量）和方法。

2、類定義

• 類實例化後，可以使用其屬性，實際上，創建一個類之後，可以通過類名訪問其屬性

class ClassName:
    <statement-1> 
    .
    .
    .
    <statement-N>

3、類對象

• 類對象支持兩種操作：屬性引用和實例化。
• 屬性引用使用和 Python 中所有的屬性引用一樣的標準語法：obj.name。
• 類對象創建後，類命名空間中所有的命名都是有效屬性名
• 以下創建了一個新的類實例並將該對象賦給局部變量 x，x 爲空的對象。

class MyClass:
    """一個簡單的類實例"""
    i = 12345
    def f(self):
        return 'hello world'
 
# 實例化類
x = MyClass()
 
# 訪問類的屬性和方法
print("MyClass 類的屬性 i 爲：", x.i)
print("MyClass 類的方法 f 輸出爲：", x.f())
'''
運行結果：
MyClass 類的屬性 i 爲： 12345
MyClass 類的方法 f 輸出爲： hello world
'''

• 類有一個名爲 __ init() __的特殊方法（構造方法），該方法在類實例化時會自動調用

def __init__(self):
    self.data = []

• __ init __() 方法可以有參數，參數通過 __ init __() 傳遞到類的實例化操作上

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 輸出結果：3.0 -4.5

4、self

• self 代表的是類的實例，代表當前對象的地址，而 self.class 則指向類
• 類的方法與普通的函數只有一個特別的區別——它們必須有一個額外的第一個參數名稱, 按照慣例它的名稱是 self
• self 不是 python 關鍵字，我們把他換成 runoob 也是可以正常執行的

class Test:
    def prt(self):
        print(self)
        print(self.__class__)
 
t = Test()
t.prt()
'''
運行結果：
<__main__.Test instance at 0x100771878>
__main__.Test
'''
#以下程序的運行結果同上
class Test:
    def prt(runoob):
        print(runoob)
        print(runoob.__class__)
 
t = Test()
t.prt()

5、類的方法

• 在類的內部，使用 def 關鍵字來定義一個方法，與一般函數定義不同，類方法必須包含參數 self, 且爲第一個參數，self 代表的是類的實例

#類定義
class people:
    #定義基本屬性
    name = ''
    age = 0
    #定義私有屬性,私有屬性在類外部無法直接進行訪問
    __weight = 0
    #定義構造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 說: 我 %d 歲。" %(self.name,self.age))
 
# 實例化類
p = people('runoob',10,30)
p.speak()
'''
運行結果：
runoob 說: 我 10 歲。
'''

6、繼承

• Python 同樣支持類的繼承，如果一種語言不支持繼承，類就沒有什麼意義
• BaseClassName（示例中的基類名）必須與派生類定義在一個作用域內
• 需要注意圓括號中基類的順序，若是基類中有相同的方法名，而在子類使用時未指定，python從左至右搜索，即方法在子類中未找到時，從左到右查找基類中是否包含方法。

#派生類的定義
class DerivedClassName(BaseClassName1):
    <statement-1>
    .
    .
    .
    <statement-N>

#除了類，還可以用表達式，基類定義在另一個模塊中時這一點非常有用:
class DerivedClassName(modname.BaseClassName):

#類定義
class people:
    #定義基本屬性
    name = ''
    age = 0
    #定義私有屬性,私有屬性在類外部無法直接進行訪問
    __weight = 0
    #定義構造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 說: 我 %d 歲。" %(self.name,self.age))
 
#單繼承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #調用父類的構函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆寫父類的方法
    def speak(self):
        print("%s 說: 我 %d 歲了，我在讀 %d 年級"%(self.name,self.age,self.grade))
 
 
 
s = student('ken',10,60,3)
s.speak()
'''
運行結果：
ken 說: 我 10 歲了，我在讀 3 年級
'''

7、多繼承

• 需要注意圓括號中父類的順序，若是父類中有相同的方法名，而在子類使用時未指定，python從左至右搜索，即方法在子類中未找到時，從左到右查找父類中是否包含方法。

#多繼承的類定義
class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

#類定義
class people:
    #定義基本屬性
    name = ''
    age = 0
    #定義私有屬性,私有屬性在類外部無法直接進行訪問
    __weight = 0
    #定義構造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 說: 我 %d 歲。" %(self.name,self.age))
 
#單繼承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #調用父類的構函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆寫父類的方法
    def speak(self):
        print("%s 說: 我 %d 歲了，我在讀 %d 年級"%(self.name,self.age,self.grade))
 
#另一個類，多重繼承之前的準備
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一個演說家，我演講的主題是 %s"%(self.name,self.topic))
 
#多重繼承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默認調用的是在括號中排前地父類的方法

#運行結果：我叫 Tim，我是一個演說家，我演講的主題是 Python

8、方法重寫

• 如果父類方法的功能不能滿足的需求，可以在子類重寫父類的方法
• super() 函數是用於調用父類(超類)的一個方法

class Parent:        # 定義父類
   def myMethod(self):
      print ('調用父類方法')
 
class Child(Parent): # 定義子類
   def myMethod(self):
      print ('調用子類方法')
 
c = Child()          # 子類實例
c.myMethod()         # 子類調用重寫方法
super(Child,c).myMethod() #用子類對象調用父類已被覆蓋的方法
'''
運行結果：
調用子類方法
調用父類方法
'''

9、子類繼承父類構造函數

• 如果在子類中需要父類的構造方法就需要顯式地調用父類的構造方法，或者不重寫父類的構造方法
• 子類不重寫 __ init __，實例化子類時，會自動調用父類定義的 __ init __

class Father(object):
    def __init__(self, name):
        self.name=name
        print ( "name: %s" %( self.name) )
    def getName(self):
        return 'Father ' + self.name
 
class Son(Father):
    def getName(self):
        return 'Son '+self.name
 
if __name__=='__main__':
    son=Son('runoob')
    print ( son.getName() )
'''
運行結果：
name: runoob
Son runoob
'''

• 如果重寫了__init__ 時，實例化子類，就不會調用父類已經定義的 __ init __

class Father(object):
    def __init__(self, name):
        self.name=name
        print ( "name: %s" %( self.name) )
    def getName(self):
        return 'Father ' + self.name
 
class Son(Father):
    def __init__(self, name):
        print ( "hi" )
        self.name =  name
    def getName(self):
        return 'Son '+self.name
 
if __name__=='__main__':
    son=Son('runoob')
    print ( son.getName() )
'''
運行結果：
hi
Son runoob
'''

• 如果重寫了__init__ 時，要繼承父類的構造方法，可以使用 super 關鍵字

super(子類，self).__init__(參數1，參數2，....)
#或者
父類名稱.__init__(self,參數1，參數2，...)

class Father(object):
    def __init__(self, name):
        self.name=name
        print ( "name: %s" %( self.name))
    def getName(self):
        return 'Father ' + self.name
 
class Son(Father):
    def __init__(self, name):
        super(Son, self).__init__(name)
        print ("hi")
        self.name =  name
    def getName(self):
        return 'Son '+self.name
 
if __name__=='__main__':
    son=Son('runoob')
    print ( son.getName() )
'''
運行結果：
name: runoob
hi
Son runoob
'''

10、類的屬性與方法

• 類的方法
  在類的內部，使用 def 關鍵字來定義一個方法，與一般函數定義不同，類方法必須包含參數 self，且爲第一個參數，self 代表的是類的實例。
  self 的名字並不是規定死的，也可以使用 this，但是最好還是按照約定是用 self
• 類的私有屬性---- __private_attrs
  兩個下劃線開頭，聲明該屬性爲私有，不能在類的外部被使用或直接訪問。在類內部的方法中使用時 self.__private_attrs

class JustCounter:
    __secretCount = 0  # 私有變量
    publicCount = 0    # 公開變量
 
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)
 
counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount)  # 報錯，實例不能訪問私有變量
'''
運行結果：
1
2
2
Traceback (most recent call last):
  File "test.py", line 16, in <module>
    print (counter.__secretCount)  # 報錯，實例不能訪問私有變量
AttributeError: 'JustCounter' object has no attribute '__secretCount'
'''

• 類的私有方法----__private_method
  兩個下劃線開頭，聲明該方法爲私有方法，只能在類的內部調用 ，不能在類的外部調用。在類的內部調用時用self.__private_methods

class Site:
    def __init__(self, name, url):
        self.name = name
        self.__url = url

    def who(self):
        print('name:', self.name)
        print('url:', self.__url)

    def __foo(self):
        print('這是私有方法')

    def foo(self):
        print('這是公共方法')
        self.__foo()
        
x = Site('啦啦啦', '哈哈哈')
x.who()
x.foo()
x.__foo()

'''
運行結果：
name: 啦啦啦
url: 哈哈哈
這是公共方法
    x.__foo()
這是私有方法
AttributeError: 'Site' object has no attribute '__foo'
'''

11、類的專有方法

12、運算符重載

• 可以對類的專有方法進行重載

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b
 
   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)
 
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

#Vector(7,8)

13、類與對象一些常用的內置函數（BIF）

• issubclass(class,classinfo)----如果class是classinfo的子類，則返回True，否則返回false，用來判斷子類關係
• isinstance(objiect,classinfo)----檢查一個實例對象是否屬於一個類，第一個參數爲實例對象，第二個爲類
• hasattr(object,name)----測試一個對象（object）是否具有固定的屬性（name），屬性必須帶“ ”，表明是字符串
• getattr(object,name[,default])----返回一個特定對象的屬性的特定值（前提是該對象具有該屬性），如果該對象沒有這個屬性，則爲了提高用戶的體驗，可以將第三個參數default設置爲“你所訪問的屬性不存在”，這樣當不存在屬性的時候就可以返回“你所訪問的屬性不存在”
• setattr(object,name,value)----對對象進行屬性的新定義——設置新屬性
• delattr(object,name)----用來刪除對象的固定屬性，如果該對象沒有這個屬性的話，就會拋出異常
  - property(fget=none,fset=none,fdel=none.doc=none)

通過屬性定義屬性，property() 是一個比較奇葩的BIF，它的作用把方法當作屬性來訪問，從而提供更加友好訪問方式。

property() 返回一個可以設置屬性的屬性，當然如何設置屬性還是需要我們人爲來寫代碼。第一個參數是獲得屬性的方法名（例子中是 getx），第二個參數是設置屬性的方法名（例子中是 setx），第三個參數是刪除屬性的方法名（例子中是 delx）。

property() 有什麼作用呢？舉個例子，我們爲用戶提供 setx 方法名來設置 _x 屬性，提供 getx 方法名來獲取屬性。但是有一天你心血來潮，突然想對程序進行大改，可能你需要把 setx 和 getx 修改爲 set_x 和 get_x，那你不得不修改用戶調用的接口，這樣子的體驗就非常不好。

有了 property() 所有問題就迎刃而解了，因爲像上邊一樣，我們爲用戶訪問 _x 屬性只提供了 x 屬性。無論我們內部怎麼改動，只需要相應的修改 property() 的參數，用戶仍然只需要去操作 x 屬性即可，對他們來說沒有任何影響。

參考文獻

• https://www.runoob.com/python3/python3-class.html
• https://www.runoob.com/w3cnote/python-extends-init.html
• https://www.cnblogs.com/Yanjy-OnlyOne/p/10041951.html