面向物件(二)

昨日回顧

物件概念：資料與功能的組合可以被稱為物件

面向過程程式設計：根據功能編寫程式碼

面向對線程式設計：根據特點物件編寫特定程式碼

類與物件的概念：擁有相同功能的群體就叫做類，根據物件的抽象概念，類也是個物件

程式碼定義類：

​ 語法結構

class 類名:
		公共的資料
		公共的功能

程式碼產生物件：

​ 類名加括號產生,這個過程我們稱之為例項化

物件 = 類名()
物件1 = 類名()

​ 類產生的多個物件都可以訪問到類中公共的資料和功能

物件獨有的資料

物件.__init__['屬性'] = '值'
因為其內部好似一個字典

繫結方法

所以類中定義的函式第一個形參會自動幫你寫self
你傳入的第一個引數，就預設會作為該字典的k值
  class 類名:
      def __init__(self, 屬性):
        物件.屬性 = 值
      def func(self):
        pass
      def index(self):
        pass
 

今日學習內容

動態方法與靜態方法

動態方法

第一種就是我們昨天學過的
1.繫結給物件
class 類名:
  def 物件(self):
    呼叫物件

類呼叫繫結給物件，傳參，有幾個就傳幾個引數
類名.物件(1,2,3)
物件呼叫繫結給物件的方法，會將物件當做第一個引數傳入
物件1.物件()

2.繫結給類的方法
class 類名:
  @classmethod
  def 物件(cls):
    呼叫物件
    
 類呼叫繫結給類的方法:會自動將類當做第一個引數傳入
print(類名)  
類名.物件()		結果相同

物件呼叫繫結給類的方法:不需要傳參，會將產生該物件的類自動當做第一個引數傳入
物件1.物件()	結果相同
 

靜態方法

class 類名:
    	@staticmethod
      def 物件(a):
          print(a)
	1.普普通通的函式:無論誰來調 都必須傳固定的引數個數
    # 類呼叫靜態方法:要自己傳值
    類名.物件(對應的引數)
    # 物件呼叫靜態方法:要自己傳值
    物件1.物件(對應的引數)

面向物件三大特性

繼承 封裝 多型

其中封裝和多型更多的表現是一種概念

繼承就更變相與實用性

繼承的概念

現實生活中:

​ 一切從他人獲取的原不屬於自己或者自己不擁有的資源，精神都可以算作繼承

​ 西撒:繼承我最後的波紋吧！

面向物件中

​ 繼承原不不屬於該類的功能或資料，通過繼承的方法去獲取。

​ 例子:類A原不不擁有a的值，類b中有a = 1，類A繼承類B後，類A就可以呼叫這個a = 1

繼承的意義

​ 現實生活中：物質方面接收饋贈，以更小的付出去完成想要的事物。精神層面獲得傳承，實現被繼承者的目標。

​ 面向物件中：減少程式碼冗餘，提高開發效率，提升程式碼上限。

​ 例子：類A可以繼承類B的功能資料，同時也可以繼承類C的功能和資料，繼承的數量不受限制。

繼承的基本使用

class A(B)
	pass
被繼承的類:父類，基類     	  B
繼承者的類:子類，派生類			 A

繼承的本質

減少已有過的資源消耗，直接分享其結果

簡單來說，就是為了減少不必要的程式碼冗餘，結束程式碼量，提高工作上限。

物件：資料與功能的結合體
類：多個具有相同功能的物件的與他們公有的功能的結合體
父類：多個類於其功能的結合體

class Person:  # 定義一個類
    def __init__(self, name, age, gender):  # 使用雙下init方法定義需要接收的引數
        self.name = name  # 用self的變數名name接受傳入的形參
        self.age = age
        self.gender = gender
class Teacher(Person):  # 子類繼承父類
    def teach(self):  # 定義函式
        print(f'{self.name}老師正在講課')  # 呼叫父類的引數
class Student(Person):  # 子類繼承父類
    def study(self):  # 定義函式
        print(f'{self.name}學生正在學習')  # 呼叫父類中的引數

名字的查詢順序

在不繼承的情況下

​ 先從物件自己的名稱空間中查詢，沒有則去類裡面的名稱空間查詢

單繼承的情況下

​ 經典案例

  	class A:  # 定義一個類
      def f1(self):  # 定義A類的功能，f1函式
          print('from A.f1')
      def f2(self):  # 定義A類的功能，f2函式
          print('from A.f2')  # 定義f2類的功能
          self.f1()	 # 執行f1函式
    class MyClass(A):  # 繼承A類
       def f1(self):  # 自己定義一個f1的函式
            print('from MyClass.f1')  # f1的功能
    obj = MyClass()  # 例項化
    obj.f2()  # 呼叫f2函式
    
    他的執行路線為
    1.在物件名稱空間中沒有找到
    2.在類的名稱空間中沒有找到
    3.在父類A的名稱空間中找到了
    4.執行f2，先列印'from A.f2'
    5.執行self.f1()
    6.因為第一次傳參self是MyClass()
    7.執行f1，列印'from MyClass.f1'

多繼承的情況下

Python2與python3的小差距

在python2中，存在經典類，表示該定義的類中不包含內建的(object)

這個object中代表了很多種方法，而python中需要呼叫這個object

則需要:

將他轉成新式類

class MyClass(object):
        pass

而python3中只存在新式類。自動新增object

深度優先：一直接找到最後的父類

廣度優先：優先走完所有的子類，最後找到父類

派生類

派生類就是子類，子類可以基於父類的功能或資料，增添屬於自己的功能或資料

class Person:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
        
class Teacher(Person):
    def __init__(self,name,age,gender,level,salary):  # 呼叫了父類以外的引數
        super().__init__(name,age,gender)  # 獲取父類中擁有的引數
        self.level = level  # 重新自己增加需要的引數
        self.salary = salary

派生功能前瞻

class MyClass(list):  # 呼叫list父類
    def append(self,args):  # 重寫父類中append內建方法
        if args == 123:  # 進行判斷
            print('數字123不能追加')  # 列印 
            return  # 直接結束函式
        super(MyClass, self).append(args)  # 否則執行原來內建方法
obj1 = MyClass()
obj1.append(333)
obj1.append(222)
obj1.append(123)
print(obj1)

小結

搞明白了，最後這個派生功能很有意思，可以決定我是否需要使用本身的內建方法。