面向對象基礎語法

01.dir 內置函數

在Python中對象幾乎是無處不在額，咱們以前學習的變量、數據、函數都是對象

在Python中可使用如下兩種方法驗證：

1.在 標識符/數據 後輸入一個 . 點，而後按下TAB鍵，ipython會提示該對象可以調用的方法列表

2.使用內置函數 dir 傳入 標識符/數據，能夠查看對象內的全部屬性及方法

提示： _方法名_ 格式的方法是Python提供的 內置方法/屬性，例如

序號　　　方法名　　類型　　做用

01　　　　_new_　　方法　　建立對象時，會被自動調用

02　　　　_init_　　  方法　　對象被初始化時，會被自動調用

03　　　　_del_　　  方法　　對象被從內存中銷燬前，會被自動調用

04　　　　_str_　　   方法　　返回對象的描述信息，print函數輸出使用

提示：利用好 dir（）函數，在學習時不少內容就不須要死記硬背了

 

02.定義簡單的類（只包含方法）

面向對象是最大的封裝，在一個類中 封裝多個方法，這樣經過這個類建立出來的對象，就能夠直接調用這些方法了！

2.1定義只包含方法的類

在Python中要定義一個只包含方法的類，語法格式以下

class 類名：
    def 方法1（self，參數列表）：
        pass
    def 方法2（self，參數列表）：
        pass

方法的定義格式和以前學習過的函數幾乎同樣

區別在於第一個參數必須是self

　注意：類名的命名規則要符合大駝峯命名法（每一個單詞首字母都大寫）

2.2 建立對象當一個類定義完成以後，要使用這個類來建立對象，語法格式以下：

對象變量 = 類名（）

2.3 第一個面向對象程序

需求：小貓愛吃魚，小貓要喝水

分析：

1.定義一個貓類 cat

2.定義兩個方法 eat和drink

3.按照需求——不須要定義屬性

class cat:
    def eat(self):
        print("小貓愛吃魚")

    def drink(self):
        print("小貓要喝水")
        
# 建立貓對象
tom = cat()

tom.eat()
tom.drink()

引用概念的強調

在面向對象開發中，引用的概念是一樣適用的！

#在Python中適用類 建立對象以後，Tom變量中仍然記錄的是對象在內存中的地址
#也就是tom變量引用了 新建的貓對象
#適用print輸出 對象變量 默認狀況下，是可以輸出這個變量引用的對象時由哪一類建立的對象，
以及在內存中的地址（十六進制表示）

提示：在計算機中，一般適用十六進制表示內存地址

　　十進制和十六進制都是用來表達數字的，只是表示的方式不同

　　十進制和十六進制的數字之間能夠來回轉換

# %d 能夠以10進制 輸出數字
# %x 能夠以16進制 輸出數字

class cat:
    def eat(self):
        print("小貓愛吃魚")

    def drink(self):
        print("小貓要喝水")

# 建立貓對象
tom = cat()

tom.eat()
tom.drink()

print(tom) # 對象是以十六進制數在內存中存儲的
addr = id(tom) # id函數能夠查詢數據在內存中的地址
print("%d" % addr) # 由於是%d 因此輸出的是十進制數
print("%x" % addr) # 用%x 輸出的就一樣是十六進制數

 

案例進階 —— 使用cat類再建立一個對象

class cat:
    def eat(self):
        print("小貓愛吃魚")

    def drink(self):
        print("小貓要喝水")

# 建立貓對象
tom = cat()

tom.eat()
tom.drink()
print(tom)

# 再建立一個貓對象
lazy_cat = cat()

lazy_cat.eat()
lazy_cat.drink()
print(lazy_cat) 
# 雖然輸出都是小貓愛吃魚小貓要喝水
# 可是其實存儲位置的十六進制數是不一樣的，
# 表示這兩個是兩個對象，是不一樣的對象
lazy_cat2 = lazy_cat
print(lazy_cat2)
# 只有這樣用賦值語句，表明的纔是同一個對象
# 不論是lazy_cat仍是lazy_cat2，都是同一個對象

03.方法中的self參數

　3.1案例改造 —— 給對象增長屬性

#在Python中，要給對象設置屬性，很是的容易，可是不推薦使用
    由於：對象屬性的封裝在類的內部
只須要在類的外部的代碼中直接經過 . 設置一個屬性便可
注意：這種方式雖然簡單 可是不推薦使用！

class cat:
    def eat(self):
        print("小貓愛吃魚")

    def drink(self):
        print("小貓要喝水")

# 建立貓對象
tom = cat()
# 可使用 .屬性名  利用賦值語句就能夠設置對象屬性
tom.name = "Tom"

tom.eat()
tom.drink()

# 再建立一個貓對象
lazy_cat = cat()
lazy_cat.name = "大懶貓"
lazy_cat.eat()
lazy_cat.drink()

3.2 使用self在方法內部輸出每一隻貓的名字

由哪個對象調用的方法，方法內的self就是哪個對象的引用

在類封裝的方法內部，self就就表示 當前調用方法的對象本身
調用方法時，程序員不須要傳遞self參數
在方法內部
    能夠經過 self. 訪問對象的屬性
    也能夠經過 self. 調用其餘的對象方法
改造代碼以下：

class cat:
    def eat(self):
        # 哪個對象調用的方法，self就是哪個對象的引用
        # 就會輸出哪個對象的屬性名
        print("%s 愛吃魚" % self.name)

# 建立貓對象
tom = cat()
# 可使用 .屬性名  利用賦值語句就能夠設置對象屬性
tom.name = "Tom"

tom.eat()

# 再建立一個貓對象
lazy_cat = cat()
lazy_cat.name = "大懶貓"
lazy_cat.eat()

 在類的外部，經過 變量名. 訪問對象的 屬性和方法

在類封裝的方法中，經過 self. 訪問對象的屬性和方法

 

04.初始化方法

4.1 以前代碼存在的問題 —— 在類的外部給對象增長屬性

提示：

在平常開發中，不推薦在類的外部給對象增長屬性

　　若是在運行時，沒有找到屬性，程序會報錯

對象應該i包含有哪些屬性、應該封裝在類的內部

 

4.2 初始化方法

# 當使用 類名（）建立對象時，會自動執行如下操做：
#    1.爲對象在內存中分配空間 —— 建立對象
#    2.爲對象的屬性設置初始值 —— 初始化方法（init）
# 這個初始化方法就是 _init_ 方法，_init_ 是對象的內置方法

_init_ 方法是專門用來定義一個類具備哪些屬性的方法！

在cat中增長 _init_方法，驗證該方法在建立對象時會被自動調用

class Cat:
    def __init__(self):
        print("這是一個初始化方法")

# 當使用類名（）建立對象的時候，會自動調用初始化方法_init_
tom = Cat()

4.3 在初始化方法內部定義屬性

在_init_方法內部使用self. 屬性名=屬性的初始值 就能夠定義屬性

定義屬性以後，再使用 Cat 類建立的對象，都會擁有該屬性

class Cat:
    def __init__(self):
        print("這是一個初始化方法")
        # self.屬性名 = 屬性的初始值
        self.name = "Tom"

    def eat(self):
        print("%s 愛吃魚" % self.name)
# 當使用類名（）建立對象的時候，會自動調用初始化方法_init_
tom = Cat()

print(tom.name)
tom.eat()

 

4.4 改造初始化方法 —— 初始化的同時設置初始值

在開發中，若是但願在建立對象的同事，就設置對象的屬性，能夠對_init_方法進行改造
1.把但願設置的屬性值，定義成_init_方法的參數
2.在方法內部使用 self.屬性 = 形參 接收外部傳遞的參數
3.在建立對象時，使用 類名（屬性1，屬性2...）調用

class Cat:
    def __init__(self,new_name):
        print("這是一個初始化方法")

        # self.屬性名 = 屬性的初始值
        # self.name = "Tom"
        self.name = new_name

    def eat(self):
        print("%s 愛吃魚"% self.name)

# 使用類名()建立對象的時候，會自動調用初始化方法_init_
tom = Cat("Tom")

print(tom.name)
tom.eat()

lazy_cat = Cat("大懶貓")
lazy_cat.eat()

 

05.內置方法和屬性

序號    方法名    做用
01      _del_    對象被內存中銷燬前，會被自動調用
02      _str_     返回對象的描述信息，print函數輸出使用

5.1 _del_ 方法

在Python中
    當使用 類名（）建立對象時，爲對象 分配完空間後，自動調用_init_ 方法
    當一個對象被從內存中銷燬前，會自動調用 _del_ 方法
應用場景
    _init_ 改造初始化方法，可讓建立對象更加靈活
    _del_ 若是但願在對象被銷燬前，再作一些事情，能夠考慮一下 _del_ 方法
生命週期
    一個對象從調用 類名（）建立，生命週期開始
    一個對象的 _del_ 方法一旦被調用，生命週期結束
    在對象的生命週期內，能夠訪問對象屬性，或者讓對象調用方法

class Cat:
    def __init__(self,new_name):
        self.name = new_name
        print("%s 來了" % self.name)
    def __del__(self):
        print("%s 我去了" % self.name)

# tom是一個全局變量
tom = Cat("Tom")
print(tom.name)

# del關鍵字能夠刪除一個對象
del tom

print("-" * 50)

5.2 _str_方法

# 在樸有Python中，使用print輸出對象變量，默認狀況下，
會輸出這個變量引用的對象時由哪個類建立的對象，以及內存中的地址（十六進制表示）
# 若是在開發中，但願使用print輸出對象變量時，可以打印自定義的內容，
就能夠利用_str_這個內置辦法了

注意：_str_方法必須返回一個字符串

class Cat:
    def __init__(self,new_name):
        self.name = new_name
        print("%s 來了" % self.name)
    def __del__(self):
        print("%s 我去了" % self.name)
    def __str__(self):
        # 必須返回一個字符串
        return "我是小貓[%s]" % self.name
# tom是一個全局變量
tom = Cat("Tom")
print(tom)