面向對象(OOP)

時間 2019-11-16

標籤面向對象 oop 欄目軟件設計简体版

原文原文鏈接

一 . 面向對象python

概念編程

類名:car
屬性: color type
行爲: 跑安全

面向對象首先要設計類
類名: 見名之之意首字母大寫其餘遵循駝峯命名法
屬性：見名之意其餘遵循駝峯命名法
行爲:（方法/功能）：見名之意其餘遵循駝峯命名法ide

建立類:
類:一種數據類型自己並不佔空間根據所學過的 number string boolean 等相似
用類建立實例化(變量)
對象佔內存空間函數

格式:
class 類名 (父類列表):
屬性
行爲spa

類名:car設計

屬性: color typecode

行爲: 跑對象

面向對象首先要設計類blog

類名:
見名之之意首字母大寫其餘遵循駝峯命名法

屬性：見名之意其餘遵循駝峯命名法

行爲:（方法/功能）：見名之意其餘遵循駝峯命名法

建立類:

類:一種數據類型自己並不佔空間根據所學過的 number string boolean 等相似
用類建立實例化(變量) 對象佔內存空間

格式:
class 類名 (父類列表):
屬性
行爲

object :基類超類全部類的父類
通常沒有合適的父類就寫object

1. 建立一個簡單的類基礎屬性方法實例化

類名 (父類列表):
          屬性
          行爲


object  :基類  超類  全部類的父類
                   
  通常沒有合適的父類就寫object





# 建立一個簡單的類
class ClassName(object):
       name=""
       age=0
       height=0
       weight=0

       # 定義方法(定義函數)
       # 注意: 方法參數必須self 當第一個參數

       self 表明類的實例(某個對象)
          def run(self):
             print("run")

          
             
          def eat(self,food):
            print("eat"+food)

View Code

# 建立一個簡單的類
class person(object):

  # 實例化對象
       name=""
       age=0
       height=0
       weight=0

       定義方法(定義函數)
       注意: 方法參數必須self 當第一個參數

       self 表明類的實例(某個對象)
       
       def run(self):
          print("run")

       def eat(self,food):
         print("eat"+food)
# 實例化對象
#        格式:對象名=類名(參數列表)    注意:沒有參數列表小括號也不能省略

per1=person()
print(per1)

per2=person()
print(per2)

# 建立一個簡單的類
class person(object):

  # 實例化對象
       name=""
       age=0
       height=0
       weight=0

       # 定義方法(定義函數)
       # 注意: 方法參數必須self 當第一個參數
       # self 表明類的實例(某個對象)
       
       def run(self):
          print("run")

       def eat(self,food):
         print("eat"+food)

# 實例化對象
#        格式:對象名(變量名)=類名(參數列表)    注意:沒有參數列表小括號也不能省略

per1=person()
print(per1)  # <__main__.person object at 0x024E37D0>
print(type(per1))  #<class '__main__.person'>
print(id(per1))   #33731888

per2=person()
print(per2) # <__main__.person object at 0x024E3870>
print(type(per1))  #<class '__main__.person'>
print(id(per2))    #33731984

# 建立一個簡單的類
class person(object):

  # 實例化對象
       name=""
       age=0
       height=0
       weight=0

       # 定義方法(定義函數)
       # 注意: 方法參數必須self 當第一個參數

       # self 表明類的實例(某個對象)
       
       def run(self):
          print("run")

       def eat(self,food):

         print("eat"+food)

       def openDoor(self,food):

         print("我已經打開了冰箱門")

       def filEle(self):

         print("我已經把大象裝進了冰箱了哈哈哈")

        def closeDoor(self):

                 print("我已經關閉了冰箱門")

# 實例化對象

#        格式:對象名(變量名)=類名(參數列表)    注意:沒有參數列表小括號也不能省略
per1=person()

# 鍒涘緩涓涓畝鍗曠殑綾
class person(object):

  # 瀹炰緥鍖栧璞
       name=""
       age=0
       height=0
       weight=0

       # 瀹氫箟鏂規硶(瀹氫箟鍑芥暟)
       # 娉ㄦ剰: 鏂規硶鍙傛暟蹇呴』self 褰撶涓涓弬鏁

       # self 浠ｈ〃綾葷殑瀹炰緥(鏌愪釜瀵硅薄)
       
       def run(self):
          print("run")

       def eat(self,food):

         print("eat"+food)

       def openDoor(self,food):

         print("鎴戝凡緇忔墦寮浜嗗啺綆遍棬")

       def filEle(self):

         print("鎴戝凡緇忔妸澶ц薄瑁呰繘浜嗗啺綆變簡鍝堝搱鍝")

        def closeDoor(self):

                 print("鎴戝凡緇忓叧闂簡鍐扮闂")

# 瀹炰緥鍖栧璞

#        鏍煎紡:瀵硅薄鍚(鍙橀噺鍚)=綾誨悕(鍙傛暟鍒楄〃)    娉ㄦ剰:娌℃湁鍙傛暟鍒楄〃灝忔嫭鍙蜂篃涓嶈兘鐪佺暐


璁塊棶灞炴:
      
        鏍煎紡 : 瀵硅薄鍚.灞炴у悕

         璧嬪 錛 瀵硅薄鍚.灞炴у悕 =鏂板

per1=person()
per1.name="寮犱笁"

per1.age=25

per1.height=165

per1.weight="80kg"

print(per1.name,per1.age,per1.height,per1.weight)

# 建立一個簡單的類
class person(object):

  # 實例化對象
       name="哈哈"
       age=56
       height=150
       weight=78

       # 定義方法(定義函數)
       # 注意: 方法參數必須self 當第一個參數

       # self 表明類的實例(某個對象)
       
       def run(self):
          print("run")

       def eat(self,food):

         print("eat"+food)

       def openDoor(self,food):

         print("我已經打開了冰箱門")

       def filEle(self):

         print("我已經把大象裝進了冰箱了哈哈哈")

       def closeDoor(self):
         print("我已經關閉了冰箱門")

# 實例化對象

#        格式:對象名(變量名)=類名(參數列表)    注意:沒有參數列表小括號也不能省略
# 訪問屬性:
      
#         格式 : 對象名.屬性名
#          賦值 ： 對象名.屬性名 =新值

per1=person()
             # 若是建立的類裏面的屬性帶有參數 就用默認參數   沒有就傳參數

per1.name="張三"

per1.age=25

per1.height=165

per1.weight="80kg"

print(per1.name,per1.age,per1.height,per1.weight)  #張三 25 165 80kg

# 建立一個簡單的類
class person(object):

  # 實例化對象
       name=""
       age=0
       height=0
       weight=0

       # 定義方法(定義函數)
       # 注意: 方法參數必須self 當第一個參數
       # self 表明類的實例(某個對象)
       
       def run(self):
          print("run")

       def eat(self,food):

         print("eat"+food)

       def openDoor(self):

         print("我已經打開了冰箱門")

       def filEle(self):

         print("我已經把大象裝進了冰箱了哈哈哈")

       def closeDoor(self):
         print("我已經關閉了冰箱門")

# 實例化對象

#        格式:對象名(變量名)=類名(參數列表)    注意:沒有參數列表小括號也不能省略
# 訪問屬性:      
#         格式 : 對象名.屬性名
#          賦值 ： 對象名.屬性名 =新值

per1=person()
per1.name="張三"
per1.age=25
per1.height=165
per1.weight="80kg"

print(per1.name,per1.age,per1.height,per1.weight)  #張三 25 165 80kg

# 訪問方法：
#       格式: 對象名.方法名(參數列表)

per1.openDoor()
per1.filEle()
per1.closeDoor()

# 我已經打開了冰箱門
# 我已經把大象裝進了冰箱了哈哈哈
# 我已經關閉了冰箱門# 建立一個簡單的類class person(object):

# 實例化對象 name="" age=1000000000 height=0 weight=0 # 定義方法(定義函數) # 注意: 方法參數必須self 當第一個參數 # self 表明類的實例(某個對象) def run(self): print("run") def eat(self,food): print("eat--"+food) def openDoor(self): print("我已經打開了冰箱門") def filEle(self): print("我已經把大象裝進了冰箱了哈哈哈") def closeDoor(self): print("我已經關閉了冰箱門") # 實例化對象 # 格式:對象名(變量名)=類名(參數列表) 注意:沒有參數列表小括號也不能省略 # 訪問屬性: # 格式 : 對象名.屬性名 # 賦值 ： 對象名.屬性名 =新值  per1=person() per1.name="張三" per1.age=25 per1.height=165 per1.weight="80kg" print(per1.name,per1.age,per1.height,per1.weight) #張三 25 165 80kg # 訪問方法： # 格式: 對象名.方法名(參數列表)  per1.openDoor() per1.filEle() per1.closeDoor() # 我已經打開了冰箱門 # 我已經把大象裝進了冰箱了哈哈哈 # 我已經關閉了冰箱門

 per1.eat("蘋果") # eat--蘋果 # 目前來看person建立的全部對象屬性都是同樣的 不符合邏輯常理 # 對象沒有如出一轍的 per2=person() print(per2.age) per3=person() print(per3.age) # 1000000000 # 1000000000

2 . 對象的初始狀態 (構造函數)

# 建立一個簡單的類
class person(object):

  # 實例化對象
       name=""
       age=1000000000
       height=0
       weight=0

       # 定義方法(定義函數)
       # 注意: 方法參數必須self 當第一個參數
       # self 表明類的實例(某個對象)
       
       def run(self):
          print("run")

       def eat(self,food):
         print("eat--"+food)

       def __init__(self):
         print("這裏是構造函數")

# 構造函數: __int__() 在使用類建立對象的時候自動調用

# 注意: 若是不顯示的寫出構造函數 默認會自動添加一個空的構造函數

per1=person()   # 這裏是構造函數

# 建立一個簡單的類
class person(object):

  # 實例化對象
       name=""
       age=1000000000
       height=0
       weight=0

       # 定義方法(定義函數)
       # 注意: 方法參數必須self 當第一個參數
       # self 表明類的實例(某個對象)
       
       def run(self):
          print("run")
          
       def eat(self,food):
         print("eat--"+food)

       def __init__(self,name,age,height,weight):
         print(name,age,height,weight)
         print("這裏是構造函數")


# 構造函數: __int__() 在使用類建立對象的時候自動調用
# 注意: 若是不顯示的寫出構造函數 默認會自動添加一個空的構造函數
# self  表明當前對象

per1=person("張三",20,170,"65kg") 


# 張三 20 170 65kg
# 這裏是構造函數

# 建立一個簡單的類
class person(object):

  # 實例化對象
       name=""
       age=1000000000
       height=0
       weight=0

       # 定義方法(定義函數)
       # 注意: 方法參數必須self 當第一個參數
       # self 表明類的實例(某個對象)
       
       def run(self):
          print("run")

       def eat(self,food):
         print("eat--"+food)

       def __init__(self,name,age,height,weight):
        # 定義屬性       
         self.name=name
         self.age=age
         self.height=height
         self.weight=weight

# 使用構造函數建立出來的每一個對象是不同的

# 構造函數: __int__() 在使用類建立對象的時候自動調用
# 注意: 若是不顯示的寫出構造函數 默認會自動添加一個空的構造函數

# self  表明當前對象

per1=person("張三",20,170,"65kg") 
print(per1.name,per1.age,per1.height,per1.weight)
# 張三 20 170 65kg

per2=person("李四",2000,170000,"650000000kg")  
print(per2.name,per2.age,per2.height,per2.weight)
# 李四 2000 170000 650000000kg

3 . self (關鍵字)

# self 表明類的實例     而非類

# # 那個對象調用的方法 name該方法中的self 就表明那個對象

# self.__class__   :表明類名

#注意self 不是python中 的關鍵字

# 建立一個簡單的類
class person(object):
       # 定義方法(定義函數)
       # 注意: 方法參數必須self 當第一個參數
       # self 表明類的實例(某個對象)
       def run(self):
          print("run")

       def eat(self,food):
         print("eat--"+food)

       def say(self):
         print(self.name ,self.age ,self.height ,self.weight)
        
       def play(aa):
          print("注意self不是關鍵字換成其餘的標誌符也是能夠的")

       def __init__(self,name,age,height,weight):
        # 定義屬性       
         self.name=name
         self.age=age
         self.height=height
         self.weight=weight

# 使用構造函數建立出來的每一個對象是不同的

per1=person("李四",20,160,80)   
per1.say()    #李四 20 160 80

per2=person("張三丰",20000,1600000,80000)
per2.say()      #張三丰 20000 1600000 80000

per2.play()  #注意self不是關鍵字

# self 表明類的實例     而非類

# # 那個對象調用的方法 name該方法中的self 就表明那個對象

# self.__class__   :表明類名

# 建立一個簡單的類
class person(object):

       # 定義方法(定義函數)
       # 注意: 方法參數必須self 當第一個參數

       # self 表明類的實例(某個對象)
       
       def run(self):
          print("run")

       def eat(self,food):
         print("eat--"+food)

       def say(self):
         print(self.name ,self.age ,self.height ,self.weight)
         print(self.__class__)    #<class '__main__.person'>
      
       def __init__(self,name,age,height,weight):
        # 定義屬性       
         self.name=name
         self.age=age
         self.height=height
         self.weight=weight

# 使用構造函數建立出來的每一個對象是不同的

per1=person("李四",20,160,80)   
per1.say()    #李四 20 160 80


per2=person("張三丰",20000,1600000,80000)
per2.say()      #張三丰 20000 1600000 80000

# self 表明類的實例     而非類
# # 那個對象調用的方法 name該方法中的self 就表明那個對象
# self.__class__   :表明類名
# 建立一個簡單的類
class person(object):
       # 定義方法(定義函數)
       # 注意: 方法參數必須self 當第一個參數
       # self 表明類的實例(某個對象)
       
       def run(self):
          print("run")

       def eat(self,food):
         print("eat--"+food)

       def say(self):
         print(self.name ,self.age ,self.height ,self.weight)
         print(self.__class__)    #<class '__main__.person'>
      
       def __init__(self,name,age,height,weight):
        # 定義屬性       
         self.name=name
         self.age=age
         self.height=height
         self.weight=weight

# 使用構造函數建立出來的每一個對象是不同的
per1=person("李四",20,160,80)   
per1.say()    #李四 20 160 80


per2=person("張三丰",20000,1600000,80000)
per2.say()      #張三丰 20000 1600000 80000

4. 析構函數

# 析構函數(destructor) 與構造函數相反，當對象結束其生命週期時(例如對象所在的函數已調用完畢)，系統自動執行析構函數。析構函數每每用來作"清理善後" 的工做
# (例如在創建對象時用new開闢了一片內存空間，delete會自動調用析構函數後釋放內存)。

# 析構函數 :__del__()釋放對象自動調用

# 建立一個簡單的類
class person(object):

       # 定義方法(定義函數)
       # 注意: 方法參數必須self 當第一個參數
       # self 表明類的實例(某個對象)
       
       def run(self):
          print("run")

       def eat(self,food):
         print("eat--"+food)
         
       def __init__(self,name,age,height,weight):
        # 定義屬性       
         self.name=name
         self.age=age
         self.height=height
         self.weight=weight

       def__del__(self):
         print("這裏是析構函數")

per=person("張三",25,300,100)
# 釋放對象       就至關於刪除了    就不能訪問了   這是手動釋放
del per

# 在函數裏定義的對象會在函數結束時自動釋放（刪除）  能夠減小內存浪費空間
def fun():
    per2=person("李四",1000,2000,30000)
fun()

5 . 重寫__repr__和__str__函數

# 重寫: 就是將函數重寫一遍

 __str__() 在調用print 打印對象時自動調用 是給用戶用的 是一個描述對象的方法
    
 __repr__()    是給機器用的在python 解釋器裏面直接敲對象在回車後調用次方法

注意:在沒str時 且有repr 

優勢: 當一個對象屬性值不少 而且須要都須要打印 重寫了
     __str__方法後簡化了代碼

# 建立一個簡單的類
class person(object):
       def __init__(self,name,age,height,weight):
        # 定義屬性       
         self.name=name
         self.age=age
         self.height=height
         self.weight=weight
       def __str__(self):
         return "%s-%d-%d-%d" % (self.name,self.age,self.height,self.weigh)

per2=person("張三丰",200,165,65)
# print(per2.name,per2.age,per2.height,per2.weight)  #張三丰 200 165 65kg
print(per2)  #張三丰 200 165 65kg

# 建立一個簡單的類
class person(object):
       def __init__(self,name,age,height,weight):
        # 定義屬性       
         self.name=name
         self.age=age
         self.height=height
         self.weight=weight
       def __repr__(self):
         return "%s-%d-%d-%d" % (self.name,self.age,self.height,self.weigh)

per2=person("張三丰",200,165,65)

print(per2.name,per2.age,per2.height,per2.weight)  #張三丰 200 165 65kg

print(per2)  #張三丰 200 165 65kg

6 . 訪問限制

# 建立一個簡單的類
class person(object):

       # 定義方法(定義函數)
       # 注意: 方法參數必須self 當第一個參數

       # self 表明類的實例(某個對象)
       def run(self):
          print("run")
       def eat(self,food):
         print("eat--"+food)
       def __init__(self,name,age,height,weight):
        # 定義屬性       
         self.name=name
         self.age=age
         self.height=height
         self.weight=weight

per=person("張三",25,300,100)

per.age=1000000000000000000000000

print(per.age)  #1000000000000000000000000

# 建立一個簡單的類
class person(object):

       # 定義方法(定義函數)
       # 注意: 方法參數必須self 當第一個參數
       # self 表明類的實例(某個對象)
       def run(self):
          print("run")

       def eat(self,food):
         print("eat--"+food)

       def __init__(self,name,age,height,weight,money):
        # 定義屬性       
         self.name=name
         self.age=age
         self.height=height
         self.weight=weight
         self.__money=money
per=person("張三",25,300,100,20000)
per.age=1000000000000000000000000
print(per.age)  #1000000000000000000000000

# 若是要讓內部屬性不被外部屬性直接訪問    在屬性前加上兩個下劃線__   
# 在python中 若是在屬性前加上兩個下劃線那麼這個屬性就變成了私有屬性
# 若是你想被外部訪問內部屬性直接加上  __                   列如這裏__money  
print(per.__money)  #在屬性前面加上__不能訪問內部屬性  會報錯   因此只要在內部訪問

# 1000000000000000000000000
# 22222222元

# 析構函數(destructor) 與構造函數相反，當對象結束其生命週期時(例如對象所在的函數已調用完畢)，系統自動執行析構函數。析構函數每每用來作"清理善後" 的工做
# (例如在創建對象時用new開闢了一片內存空間，delete會自動調用析構函數後釋放內存)。

# 析構函數 :__del__()釋放對象自動調用

# 建立一個簡單的類
class person(object):
       # 定義方法(定義函數)
       # 注意: 方法參數必須self 當第一個參數
       # self 表明類的實例(某個對象)
       
       def run(self):
          print(self.__money)  # 內部訪問     #22222222元

       def eat(self,food):
         print("eat--"+food)

       def __init__(self,name,age,height,weight,money):
        # 定義屬性       
         self.name=name
         self.age=age
         self.height=height
         self.weight=weight
         self.__money=money

per=person("張三",25,300,100,"22222222元")

per.age=1000000000000000000000000

print(per.age)  #1000000000000000000000000

# 若是要讓內部屬性不被外部屬性直接訪問    在屬性前加上兩個下劃線__   
# 
# 在python中 若是在屬性前加上兩個下劃線那麼這個屬性就變成了私有屬性
# 
# 若是你想被外部訪問內部屬性直接加上  __                   列如這裏__money  
# 
# print(per.__money)  #在屬性前面加上__不能訪問內部屬性  會報錯   因此只要在內部訪問
per.run()

# 析構函數(destructor) 與構造函數相反，當對象結束其生命週期時(例如對象所在的函數已調用完畢)，系統自動執行析構函數。析構函數每每用來作"清理善後" 的工做
# (例如在創建對象時用new開闢了一片內存空間，delete會自動調用析構函數後釋放內存)。
# 析構函數 :__del__()釋放對象自動調用
# 建立一個簡單的類
class person(object):

       # 定義方法(定義函數)
       # 注意: 方法參數必須self 當第一個參數
       # self 表明類的實例(某個對象)
       def run(self):
          print(self.__money)  # 內部訪問     #22222222元

       def eat(self,food):
         print("eat--"+food)
      
       def __init__(self,name,age,height,weight,money):
        # 定義屬性       
         self.name=name
         self.age=age
         self.height=height
         self.weight=weight
         self.__money=money

   # 經過內部的方法 修改私有屬性
   # 經過自定義的方法實現對私有屬性的賦值和取值

         def setMoney (self,money):
              # 數據過濾
              if money<0:
                 money=0
              self.__money=money

         def getMoney(self):
               return self.__money

per=person("張三",25,300,100,"22222222元")

# per.age=1000000000000000000000000

# print(per.age)  #1000000000000000000000000

# 若是要讓內部屬性不被外部屬性直接訪問    在屬性前加上兩個下劃線__   
# 
# 在python中 若是在屬性前加上兩個下劃線那麼這個屬性就變成了私有屬性
# 若是你想被外部訪問內部屬性直接加上  __                   列如這裏__money  
# print(per.__money)  #在屬性前面加上__不能訪問內部屬性  會報錯   因此只要在內部訪問
per.run()

# 析構函數(destructor) 與構造函數相反，當對象結束其生命週期時(例如對象所在的函數已調用完畢)，系統自動執行析構函數。析構函數每每用來作"清理善後" 的工做
# (例如在創建對象時用new開闢了一片內存空間，delete會自動調用析構函數後釋放內存)。

# 析構函數 :__del__()釋放對象自動調用

# 建立一個簡單的類
class person(object):
       # 定義方法(定義函數)
       # 注意: 方法參數必須self 當第一個參數
       # self 表明類的實例(某個對象)
       
       def run(self):
          print(self.__money)  # 內部訪問     #22222222元

       def eat(self,food):
         print("eat--"+food)
     
       def __init__(self,name,age,height,weight,money):
        # 定義屬性       
         self.name=name
         self.age=age
         self.height=height
         self.weight=weight
         self.__money=money
   # 經過內部的方法 修改私有屬性
   # 經過自定義的方法實現對私有屬性的賦值和取值
       def setMoney (self,money):
        # 數據過濾
        if money<0:
           money=0
        self.__money=money

       def getMoney(self):
          return self.__money

per=person("張三",25,300,100,"22222222元")

# per.age=1000000000000000000000000

# print(per.age)  #1000000000000000000000000

# 若是要讓內部屬性不被外部屬性直接訪問    在屬性前加上兩個下劃線__   
# 
# 在python中 若是在屬性前加上兩個下劃線那麼這個屬性就變成了私有屬性
# 
# 若是你想被外部訪問內部屬性直接加上  __                   列如這裏__money  
# 
# print(per.__money)  #在屬性前面加上__不能訪問內部屬性  會報錯   因此只要在內部訪問
# per.run()  內部能夠使用
per.setMoney(50)
print(per.setMoney())  #50

# 析構函數(destructor) 與構造函數相反，當對象結束其生命週期時(例如對象所在的函數已調用完畢)，系統自動執行析構函數。析構函數每每用來作"清理善後" 的工做
# (例如在創建對象時用new開闢了一片內存空間，delete會自動調用析構函數後釋放內存)。

# 析構函數 :__del__()釋放對象自動調用

# 建立一個簡單的類
class person(object):
       # 定義方法(定義函數)
       # 注意: 方法參數必須self 當第一個參數
       # self 表明類的實例(某個對象)
       def run(self):
          print(self.__money)  # 內部訪問     #22222222元

       def eat(self,food):
         print("eat--"+food)

       def __init__(self,name,age,height,weight,money):
        # 定義屬性       
         self.name=name
         self.__age__=age
         self.height=height
         self.weight=weight
         self.__money=money
   # 經過內部的方法 修改私有屬性
   # 經過自定義的方法實現對私有屬性的賦值和取值
       def setMoney (self,money):
        # 數據過濾
        if money<0:
           money=0
        self.__money=money

       def getMoney(self):
          return self.__money
per=person("張三",25,300,100,"22222222元")

# per.age=1000000000000000000000000
# print(per.age)  #1000000000000000000000000

# 若是要讓內部屬性不被外部屬性直接訪問    在屬性前加上兩個下劃線__   
# 
# 在python中 若是在屬性前加上兩個下劃線那麼這個屬性就變成了私有屬性
# 
# 若是你想被外部訪問內部屬性直接加上  __                   列如這裏__money  
# print(per.__money)  #在屬性前面加上__不能訪問內部屬性  會報錯   因此只要在內部訪問

per.run() # 內部能夠使用
# per.setMoney(50)
# print(per.setMoney())  #50
# 在python中 __xxx__屬於特殊變量 能夠直接訪問的
print(per.__age__)

7 . 蓋房做業面向對象

class Person(object):
    
    def func(self):

        print("蓋房子")

per=Person()

per.func()

8. 繼承

繼承 :有兩個類 A類和B類
當咱們說A類繼承自B類的時候 
那麼A類就擁有了B類中的全部的屬性和方法
object類  是全部類的父類  還可稱爲基類和超類
注意: 繼承者稱爲子類 被繼承自繼承者稱父類
繼承做用 : 就簡化代碼  提升代碼的健壯性   提升代碼的安全性、
            是多肽的

這是person.py文件 class Person(object):

    def __init__(self,name ,age):
          
          self.name=name
          self.age=age
        
    def run(self):
             print("這是跑run")
    def  eat(self,food):
             print("這是吃eat"+food)

這是student.py文件 # 用student去區繼承  person 
from person import  Person
class Student(Person):
    def __init__(self,name,age):      
    
        # 調用父類中的__int__
        super(Student,self).__init__(name,age)

這是worke.py文件 # 用student去區繼承  person 
from person import  Person
class Worker(Person):
    def __init__(self,name,age):      
    
        # 調用父類中的__int__
        super(Worker,self).__init__(name,age)


執行文件.py from student import Student
from worker import Worker

stu=Student("張三丰",18)
print(stu.name,stu.age)   #張三丰 18
stu.run() # 這是跑run

stl=Worker("李四",2222222)
print(stl.name,stl.age) #李四 2222222
stl.eat("水果哈哈哈哈哈哈哈哈哈哈")   #這是吃eat水果哈哈哈哈哈哈哈哈哈哈

這是person.py文件 class Person(object):

    def __init__(self,name ,age):
          self.name=name
          self.age=age

    def run(self):
             print("這是跑run")

    def  eat(self,food):
             print("這是吃eat"+food)

這是student.py文件 # 用student去區繼承  person 
from person import  Person
class Student(Person):
    def __init__(self,name,age,stuId):      

    # stuId 是本身獨有的屬性   不是person 父類的屬性
        # 調用父類中的__int__
        super(Student,self).__init__(name,age)

        self.stuId=stuId

這是person.py文件 # 用student去區繼承  person 
from person import  Person
class Worker(Person):
    def __init__(self,name,age):      
    
        # 調用父類中的__int__
        super(Worker,self).__init__(name,age)

這是執行文件.py from student import Student
from worker import Worker

stu=Student("張三丰",18,20)
print(stu.name,stu.age)   #張三丰 18

stu.run() # 這是跑run
# 子類能夠有本身獨有的屬性
stu.stuId=1000000
print(stu.stuId)  1000000

stl=Worker("李四",2222222)
print(stl.name,stl.age) #李四 2222222
stl.eat("水果哈哈哈哈哈哈哈哈哈哈")   #這是吃eat水果哈哈哈哈哈哈哈哈哈哈

這是amimal.py文件 class Animal(object):
   def __int__(self,name)
      self.name=name
      super(Cat,self).__int__(name)
   def eat():

      print(self.name+"吃")
  
這是cat.py文件 from animal import Animal
class Cat(Animal):
   def __int__(self,name)

      #self.name=name
      super(Cat,self).__int__(name)
  #def eat():
  #print(self.name+"吃")
 這是mouse.py文件 from animal import Animal
class Mouse(Animal):
   def __int__(self,name)

      #self.name=name
      super(Cat,self).__int__(name)
  #def eat():

      #print(self.name+"吃")
 執行文件.py # 多肽: 一種事物的多種形態  叫多肽
# 例如 動物(animal)     貓  狗  .......
# 目標:人能夠喂任何動物

from mouse import Mouse

from cat import Cat
# 建立貓
tom=Cat("tom")

# 建立老鼠
jerry=Mouse("jerry")

tom.eat()

jerry.eat()
思考：若是在添加100種動物 也都有name 屬性 和eat屬性

9. 多繼承

這是Father.py文件 class Father(object):
    """docstring for Father"""
    def __init__(self,money):
        self.money=money

   def play(self):
          print("這是paly哈哈哈哈哈哈哈哈")

   def func(self):
          print("這是func啦啦啦啦啦啦啦啦")


這是Mother.py文件 class Mother(object):
    """docstring for Father"""
    def __init__(self,faceValue):
    
        self.faceValue=faceValue

   def eat(self):
          print("我要吃哈哈哈哈eat")

   def func(self):
          print("這事了綠綠綠綠func")

這是執行文件(Child.py文件去繼承父親類，母親類)
多繼承   這個Child  即繼承了父類  和母類
from Father import Father
from Mother import Mother
class Child(Father,Mother):

    def __init__(self,money,faceValue):
     Father.__init__(self,money)
     Mother.__init__(self,faceValue)

這是Father.py文件 class Father(object):
    def __init__(self,money):
       self.money=money
    def play(self):
          print("這是paly哈哈哈哈哈哈哈哈")
    def func(self):
       print("這是func111111111111111111啦啦啦啦啦啦啦啦")


這是Mother.py文件 class Mother(object):
    """docstring for Father"""

    def __init__(self,faceValue):
      self.faceValue=faceValue

   def eat(self):
      print("我要吃哈哈哈哈eat")

   def func(self):
     print("這事了綠綠綠綠func")
 這是Chid.py文件 # 多繼承   這個Child  即繼承了父類  和母類
from Father import Father
from Mother import Mother

class Child(Father,Mother):
    def __init__(self,money,faceValue):
     Father.__init__(self,money)
     Mother.__init__(self,faceValue)

這是執行文件例如(main.py) from Child import Child
def main ():
  c=Child(300,100)
  print(c.money,c.faceValue)
  c.piay()
  c.eat()
    # 注意:父類中方法名相同 默認調用的是在括號中排前面的父類中方法
  c.func()
if __name__=="__main__":
  main()

10. 多肽

這是Animal.py文件 class Animal(object):
   def __init__(self,name):
      self.name=name
   def eat(self):
      print(self.name+"吃")
  
 這是Cat.py文件 讓貓這個類去繼承動物類 吃 from animal import Animal
class Cat(Animal):
   def __init__(self,name):
      #self.name=name
      super(Cat,self).__init__(name)
  #def eat():
  #print(self.name+"吃")
 這是mouset.py文件 讓老鼠這個類去繼承動物類 吃 from animal import Animal
class Mouse(Animal):
   def __init__(self,name):
      #self.name=name
      super(Mouse,self).__init__(name)
  #def eat():
      #print(self.name+"吃")

執行文件

# 多肽: 一種事物的多種形態叫多肽

# 例如動物(animal) 貓狗 .......

# 目標:人能夠喂任何動物
from cat import Cat
from mouse import Mouse

# 建立貓
tom=Cat("tom")

# 建立老鼠
jerry=Mouse("jerry")

tom.eat()
jerry.eat()

# 思考：若是在添加100種動物也都有name 屬性和eat屬性
# 定義一個有name屬性和eat 方法屬性Animal 類讓全部的動物類繼承自Animal

這是animal.py文件 # 動物類 都有名字這個屬性   和吃這個方法
class Animal(object):
   def __init__(self,name):
      self.name=name
     
   def eat(self):
      print(self.name+"吃1111111111111111")
 這是Cat.py文件 # 讓定的貓這個屬性去繼承動這個方法
from animal import Animal
class Cat(Animal):
   def __init__(self,name):
      #self.name=name
      super(Cat,self).__init__(name)
  #def eat():
  #print(self.name+"吃")
 這是mouse.py # 讓mouse去繼承動物這個類  
from animal import Animal
class Mouse(Animal):
   def __init__(self,name):
      #self.name=name
      super(Mouse,self).__init__(name)
  #def eat():
      #print(self.name+"吃")
 這是person.py文件 class Person (object):
    def feedCat(self,cat):
       print("給貓子食物")
       cat.eat()

    def feedMouse(self,mouse):
       print("給老鼠食物")
       mouse.eat()

這是執行文件 # 多肽: 一種事物的多種形態  叫多肽
# 例如 動物(animal)     貓  狗  .......
# 目標:定義一我的類能夠喂任何動物
from cat import Cat
from mouse import Mouse
from person import Person
# 定義一我的類能夠喂任何動物
tom=Cat("tom")

# 建立老鼠
jerry=Mouse("jerry")
tom.eat()
jerry.eat()
per=Person()

per.feedCat(tom)
per.feedCat(jerry)

11. 對象屬性與類屬性

# 類屬性 用類名來調用
# 對象屬性用對象來調用

class Person(object):
   # 這裏的屬性實際上屬於類屬性(用類名來調用)
   name="張三"

   def __init__(self,name):
     # 這裏是對象屬性
  
     # 對象屬性的優先級是高於類屬性
        self.name=name

print(Person.name)     #張三
per=Person("李四")
print(per.name)     #李四

# 動態的給對象添加對象屬性   只針對於當前對象生效
per.age=18
print(per.age)

# 類屬性不能添加動態屬性

注意  :對象屬性和類屬性千萬不要重名    由於對象屬性會屏蔽掉類屬性

12. 動態給實例添加屬性和方法並使用

from types import MethodType

# 建立一空類
class Person (object):
     
     pass


per=Person()

# 動態的添加屬性 這體現了動態語言的靈活性
per.name="張師傅"
print(per.name)


# 動態的添加方法     必須引入一個模塊
def say(self):

    print("動態的添加方法"+self.name)
per.speak=MethodType(say,per)
per.speak()

from types import MethodType

# 建立一空類
class Person (object):
     
     pass

per=Person()

# 動態的添加屬性 這體現了動態語言的靈活性
per.name="張師傅"
print(per.name)

# 動態的添加方法     必須引入一個模塊
def say(self):

    print("動態的添加方法"+self.name)
per.speak=MethodType(say,per)
per.speak()

from types import MethodType
# 建立一空類
class Person (object):
     
       # 想添加什麼屬性就寫在裏面
     __slots__=("name","age","speak")

per=Person()

# 動態的添加屬性 這體現了動態語言的靈活性
per.name="張師傅"
print(per.name)

# 動態的添加方法     必須引入一個模塊
def say(self):

    print("動態的添加方法"+self.name)
per.speak=MethodType(say,per)
per.speak()  


"""
思考: 若是咱們想要 限制實例的屬性怎麼辦
好比 只容許給對象添加name age height 特定的屬性

解解方法：
      定義類的時候 定義一個特殊的屬性 (__slots__)能夠限制動態屬性的添加
      """

per.age=222222
print(per.age)     

# 222222

13. @property

class Person (object):
   def __init__(self,age):
       #屬性直接對暴露
      self.age=age

per=Person(18)

# 屬性直接暴露在外面不安全


per.age=-15
print(per.age) #-15

class Person (object):
   def __init__(self,age):
       #屬性直接對暴露
      self.age=age

per=Person(18)

# 屬性直接暴露在外面不安全


per.age=-15
print(per.age) #-15

class Person (object):
   def __init__(self,age):
       #屬性直接對暴露
       #限制訪問
      self.__age=age
   def getAge(self):
     return self.__age
   def setAge(self,age):
     if age<0:
         age=0
     self.__age=age
     
per=Person(18)
# # 屬性直接暴露在外面不安全
# per.age=-15
# print(per.age) #-15
per.setAge(15)
print(per.getAge())

class Person (object):

   def __init__(self,age):
       #屬性直接對暴露
       #限制訪問
      self.__age=age
"""
   def getAge(self):
     return self.__age


   def setAge(self,age):
     if age<0:
         age=0
     self.__age=age
"""

   # 方法名爲受限制的變量名去掉雙下劃線
@property
def age(self):
      return self.__age

@age.setter           # @age.setter  去掉下劃線 .setter 
def setAge(self,age):
     if age<0:
      age=0
     self.__age=age

per=Person(18)

# # 屬性直接暴露在外面不安全

# per.setAge(15)
# print(per.getAge())

per.age=100                  #至關於調用setAge
print(per.age)   # 100      # 至關於調用getAge

14. 運算符重載

print(4+6)  #10

print("4"+"6")  #46

# 不一樣的類型用不一樣加法會有不一樣的解釋

class Person(object):
    def __init__(self,num):
      self.num=num

    def __add__(self,other):
      return Person(self.num+other.num)

    def __str__(self):
       return "num="+str(self.num)


# 運算符重載 + - * /
     # 就是兩個對象不能相加 給對象加法解釋一下



per1=Person(1)

per2=Person(2)

print(per1+per2) #3

"""
Method  Overloads Call for
__init__  構造函數  X=Class()
__del__ 析構函數  對象銷燬
__repr__  打印轉換  print X，repr(X)
__str__ 打印轉換  print X，str(X)
__call__  調用函數  X()
__getattr_  限制  X.undefine
__setattr__ 取值  X.any=value
__getitem__ 索引  X[key]，For If
__setitem__ 索引  X[key]=value
__len__ 長度  len(X)
__iter__  迭代  
For In

__add__ + X+Y,X+=Y
__sub__ - X-Y,X-=Y
__mul__ * X*Y
__radd__  右加+ +X
__iadd__  +=  X+=Y
__or__  | X|Y,X|=Y
__cmp__ 比較 == X==Y,X<Y
__lt__  小於< X<Y
__eq__  等於= X=Y
"""

# sms.ihuyi.com
# APIID：C39463039

#APIKEY：b3858178a2526f42bce019605c5d1faa

15. 面向對象案例

分析需求 # 人開槍射擊子彈  編程題
"""

人  
 類名:  人  (Person)

 屬性: 槍   (gun)

 行爲: 開火   (fire)

槍

  類名  Gun

  屬性: bulletBOX

  行爲:  shoot    

彈夾: 
    類名    bulletBOX

    屬性     bulletCont


    行爲:

""" 這是 bulletBox.py文件 class bulletBox(object):

   def __init__(self,count):
    
     self.bulletCount=count


這是gun.py文件 class Gun(object):
    
   def __init__(self,bulletBox):
      self.bulletBox=bulletBox    


   def shoot(self):
     if self.bulletBox.bulletCount==0:
       print("沒有子彈")

     else:
       self.bulletBox.bulletCount-=1

       print("剩餘子彈:%d發" % (self.bulletBox.bulletCount))


這是person.py文件 class Person(object):
  def __init__(self,gun):    
    self.gun=gun

  def fire(self):
    self.gun.shoot()
            
這是執行文件.py # 人開槍射擊子彈  編程題
from person import Person

from gun import Gun

from bulletbox import bulletBox

# 彈夾

bulletBox=bulletBox(5)

# 槍

gun=Gun(bulletBox)

# 人
per=Person(gun)

per.fire()
per.fire()
per.fire()

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。