<input id="0qass"><u id="0qass"></u></input>
  • <input id="0qass"><u id="0qass"></u></input>
  • <menu id="0qass"><u id="0qass"></u></menu>

    學Python基礎面向對象看這一篇文章就夠了【全網首推】

    目錄

    面相對象基礎語法

    目標

    01.?dir?內置函數(知道)

    02. 定義簡單的類(只包含方法)

    2.1 定義只包含方法的類

    2.2 創建對象

    2.3 第一個面向對象程序

    03. 方法中的?self?參數

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

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

    04. 初始化方法

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

    4.2 初始化方法

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

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

    05. 內置方法和屬性

    5.1?__del__?方法(知道)

    5.2?__str__?方法

    面向對象封裝案例

    目標

    01. 封裝

    02. 小明愛跑步

    2.1 小明愛跑步擴展 —— 小美也愛跑步

    03. 擺放家具

    3.1 創建家具

    3.2 創建房間

    3.3 添加家具

    3.4 小結

    面向對象封裝案例 II

    目標

    01. 士兵突擊

    1.1 開發槍類

    1.2 開發士兵類

    02. 身份運算符

    is 與 == 區別:

    私有屬性和私有方法

    01. 應用場景及定義方式

    02. 偽私有屬性和私有方法(科普)


    跟著我學Python然后new一個對象,類和對象的基本概念以及練習題

    面相對象基礎語法

    目標

    • dir?內置函數
    • 定義簡單的類(只包含方法)
    • 方法中的?self?參數
    • 初始化方法
    • 內置方法和屬性

    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,大家暫時先記住,稍后介紹?self

    注意:類名?的 命名規則 要符合?大駝峰命名法

    ?

    2.2 創建對象

    • 當一個類定義完成之后,要使用這個類來創建對象,語法格式如下:
    對象變量 = 類名()
    

    2.3 第一個面向對象程序

    需求

    • 小貓?愛??魚,小貓?要??水

    分析

    1. 定義一個貓類?Cat
    2. 定義兩個方法?eat?和?drink
    3. 按照需求 —— 不需要定義屬性

    class Cat:
        """這是一個貓類"""
    
        def eat(self):
            print("小貓愛吃魚")
    
        def drink(self):
            print("小貓在喝水")
    
    tom = Cat()
    tom.drink()
    tom.eat()
    

    引用概念的強調

    在面向對象開發中,引用的概念是同樣適用的!

    • 在?Python?中使用類?創建對象之后tom?變量中 仍然記錄的是?對象在內存中的地址
    • 也就是?tom?變量?引用?了?新建的貓對象
    • 使用?print?輸出?對象變量,默認情況下,是能夠輸出這個變量?引用的對象?是?由哪一個類創建的對象,以及?在內存中的地址十六進制表示

    提示:在計算機中,通常使用?十六進制?表示?內存地址

    • 十進制?和?十六進制?都是用來表達數字的,只是表示的方式不一樣
    • 十進制?和?十六進制?的數字之間可以來回轉換
    • %d?可以以?10 進制?輸出數字
    • %x?可以以?16 進制?輸出數字

    案例進階 —— 使用 Cat 類再創建一個對象

    lazy_cat = Cat()
    lazy_cat.eat()
    lazy_cat.drink()
    

    提問:tom?和?lazy_cat?是同一個對象嗎?

    03. 方法中的?self?參數

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

    • 在?Python?中,要?給對象設置屬性,非常的容易,但是不推薦使用
      • 因為:對象屬性的封裝應該封裝在類的內部
    • 只需要在?類的外部的代碼?中直接通過?.?設置一個屬性即可

    注意:這種方式雖然簡單,但是不推薦使用!

    tom.name = "Tom"
    ...
    
    lazy_cat.name = "大懶貓"
    

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

    由?哪一個對象?調用的方法,方法內的?self?就是?哪一個對象的引用

    • 在類封裝的方法內部,self?就表示?當前調用方法的對象自己
    • 調用方法時,程序員不需要傳遞?self?參數
    • 在方法內部
      • 可以通過?self.?訪問對象的屬性
      • 也可以通過?self.?調用其他的對象方法
    • 改造代碼如下:
    class Cat:
    
        def eat(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 之前代碼存在的問題 —— 在類的外部給對象增加屬性

    • 將案例代碼進行調整,先調用方法 再設置屬性,觀察一下執行效果
    tom = Cat()
    tom.drink()
    tom.eat()
    tom.name = "Tom"
    print(tom)
    
    • 程序執行報錯如下:
    AttributeError: 'Cat' object has no attribute 'name'
    屬性錯誤:'Cat' 對象沒有 'name' 屬性
    

    提示

    • 在日常開發中,不推薦在?類的外部?給對象增加屬性
      • 如果在運行時,沒有找到屬性,程序會報錯
    • 對象應該包含有哪些屬性,應該?封裝在類的內部

    4.2 初始化方法

    • 當使用?類名()?創建對象時,會?自動?執行以下操作:
      1. 為對象在內存中?分配空間?—— 創建對象
      2. 為對象的屬性?設置初始值?—— 初始化方法(init)
    • 這個?初始化方法?就是?__init__?方法,__init__?是對象的內置方法

    __init__?方法是?專門?用來定義一個類?具有哪些屬性的方法

    在?Cat?中增加?__init__?方法,驗證該方法在創建對象時會被自動調用

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

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

    • 在?__init__?方法內部使用?self.屬性名 = 屬性的初始值?就可以?定義屬性
    • 定義屬性之后,再使用?Cat?類創建的對象,都會擁有該屬性
    class Cat:
    
        def __init__(self):
    
            print("這是一個初始化方法")
            
            # 定義用 Cat 類創建的貓對象都有一個 name 的屬性
            self.name = "Tom"
    
        def eat(self):
            print("%s 愛吃魚" % self.name)
    
    # 使用類名()創建對象的時候,會自動調用初始化方法 __init__
    tom = Cat()
    
    tom.eat()
    
    

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

    • 在開發中,如果希望在?創建對象的同時,就設置對象的屬性,可以對?__init__?方法進行?改造
      1. 把希望設置的屬性值,定義成?__init__?方法的參數
      2. 在方法內部使用?self.屬性 = 形參?接收外部傳遞的參數
      3. 在創建對象時,使用?類名(屬性1, 屬性2...)?調用
    class Cat:
    
        def __init__(self, name):
            print("初始化方法 %s" % name)
            self.name = name
        ...
        
    tom = Cat("Tom")
    ...
    
    lazy_cat = Cat("大懶貓")
    ...
    

    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 = Cat("Tom")
    print(tom)
    

    ?

    面向對象封裝案例

    目標

    • 封裝
    • 小明愛跑步
    • 存放家具

    01. 封裝

    1. 封裝?是面向對象編程的一大特點
    2. 面向對象編程的?第一步?—— 將?屬性?和?方法?封裝?到一個抽象的??中
    3. 外界?使用??創建?對象,然后?讓對象調用方法
    4. 對象方法的細節?都被?封裝?在?類的內部

    02. 小明愛跑步

    需求

    1. 小明?體重?75.0?公斤
    2. 小明每次?跑步?會減肥?0.5?公斤
    3. 小明每次?吃東西?體重增加?1?公斤

    提示:在?對象的方法內部,是可以?直接訪問對象的屬性?的!

    • 代碼實現:
    class Person:
        """人類"""
    
        def __init__(self, name, weight):
    
            self.name = name
            self.weight = weight
    
        def __str__(self):
    
            return "我的名字叫 %s 體重 %.2f 公斤" % (self.name, self.weight)
    
        def run(self):
            """跑步"""
    
            print("%s 愛跑步,跑步鍛煉身體" % self.name)
            self.weight -= 0.5
    
        def eat(self):
            """吃東西"""
    
            print("%s 是吃貨,吃完這頓再減肥" % self.name)
            self.weight += 1
    
    
    xiaoming = Person("小明", 75)
    
    xiaoming.run()
    xiaoming.eat()
    xiaoming.eat()
    
    print(xiaoming)
    
    

    2.1 小明愛跑步擴展 —— 小美也愛跑步

    需求

    1. 小明?和?小美?都愛跑步
    2. 小明?體重?75.0?公斤
    3. 小美?體重?45.0?公斤
    4. 每次?跑步?都會減少?0.5?公斤
    5. 每次?吃東西?都會增加?1?公斤

    提示

    1. 在?對象的方法內部,是可以?直接訪問對象的屬性?的
    2. 同一個類?創建的?多個對象?之間,屬性?互不干擾!

    03. 擺放家具

    需求

    1. 房子(House)?有?戶型、總面積?和?家具名稱列表
      • 新房子沒有任何的家具
    2. 家具(HouseItem)?有?名字?和?占地面積,其中
      • 席夢思(bed)?占地?4?平米
      • 衣柜(chest)?占地?2?平米
      • 餐桌(table)?占地?1.5?平米
    3. 將以上三件?家具?添加?到?房子?中
    4. 打印房子時,要求輸出:戶型、總面積、剩余面積、家具名稱列表

    剩余面積

    1. 在創建房子對象時,定義一個?剩余面積的屬性初始值和總面積相等
    2. 當調用?add_item?方法,向房間?添加家具?時,讓?剩余面積?-=?家具面積

    思考:應該先開發哪一個類?

    答案?——?家具類

    1. 家具簡單
    2. 房子要使用到家具,被使用的類,通常應該先開發

    3.1 創建家具

    class HouseItem:
    
        def __init__(self, name, area):
            """
    
            :param name: 家具名稱
            :param area: 占地面積
            """
            self.name = name
            self.area = area
    
        def __str__(self):
            return "[%s] 占地面積 %.2f" % (self.name, self.area)
    
    
    # 1. 創建家具
    bed = HouseItem("席夢思", 4)
    chest = HouseItem("衣柜", 2)
    table = HouseItem("餐桌", 1.5)
    
    print(bed)
    print(chest)
    print(table)
    
    

    小結

    1. 創建了一個?家具類,使用到?__init__?和?__str__?兩個內置方法
    2. 使用?家具類?創建了?三個家具對象,并且?輸出家具信息

    3.2 創建房間

    class House:
    
        def __init__(self, house_type, area):
            """
    
            :param house_type: 戶型
            :param area: 總面積
            """
            self.house_type = house_type
            self.area = area
            
            # 剩余面積默認和總面積一致
            self.free_area = area
            # 默認沒有任何的家具
            self.item_list = []
    
        def __str__(self):
    
            # Python 能夠自動的將一對括號內部的代碼連接在一起
            return ("戶型:%s\n總面積:%.2f[剩余:%.2f]\n家具:%s"
                    % (self.house_type, self.area,
                       self.free_area, self.item_list))
    
        def add_item(self, item):
    
            print("要添加 %s" % item)
    
    ...
    
    # 2. 創建房子對象
    my_home = House("兩室一廳", 60)
    
    my_home.add_item(bed)
    my_home.add_item(chest)
    my_home.add_item(table)
    
    print(my_home)
    

    小結

    1. 創建了一個?房子類,使用到?__init__?和?__str__?兩個內置方法
    2. 準備了一個?add_item?方法?準備添加家具
    3. 使用?房子類?創建了?一個房子對象
    4. 讓?房子對象?調用了三次?add_item?方法,將?三件家具?以實參傳遞到?add_item?內部

    3.3 添加家具

    需求

    • 1>?判斷?家具的面積?是否?超過剩余面積如果超過,提示不能添加這件家具
    • 2> 將?家具的名稱?追加到?家具名稱列表?中
    • 3> 用?房子的剩余面積?-?家具面積
        def add_item(self, item):
    
            print("要添加 %s" % item)
            # 1. 判斷家具面積是否大于剩余面積
            if item.area > self.free_area:
                print("%s 的面積太大,不能添加到房子中" % item.name)
    
                return
    
            # 2. 將家具的名稱追加到名稱列表中
            self.item_list.append(item.name)
    
            # 3. 計算剩余面積
            self.free_area -= item.area
    

    3.4 小結

    • 主程序只負責創建?房子?對象和?家具?對象
    • 讓?房子?對象調用?add_item?方法?將家具添加到房子
    • 面積計算、剩余面積、家具列表?等處理都被?封裝?到?房子類的內部

    面向對象封裝案例 II

    目標

    • 士兵突擊案例
    • 身份運算符

    封裝

    1. 封裝?是面向對象編程的一大特點
    2. 面向對象編程的?第一步?—— 將?屬性?和?方法?封裝?到一個抽象的??中
    3. 外界?使用??創建?對象,然后?讓對象調用方法
    4. 對象方法的細節?都被?封裝?在?類的內部

    一個對象的?屬性?可以是?另外一個類創建的對象

    01. 士兵突擊

    需求

    1. 士兵?許三多?有一把?AK47
    2. 士兵?可以?開火
    3. ?能夠?發射?子彈
    4. ?裝填?裝填子彈?——?增加子彈數量

    1.1 開發槍類

    shoot?方法需求

    • 1> 判斷是否有子彈,沒有子彈無法射擊
    • 2> 使用?print?提示射擊,并且輸出子彈數量
    class Gun:
    
        def __init__(self, model):
    
            # 槍的型號
            self.model = model
            # 子彈數量
            self.bullet_count = 0
    
        def add_bullet(self, count):
    
            self.bullet_count += count
    
        def shoot(self):
    
            # 判斷是否還有子彈
            if self.bullet_count <= 0:
                print("沒有子彈了...")
    
                return
    
            # 發射一顆子彈
            self.bullet_count -= 1
            
            print("%s 發射子彈[%d]..." % (self.model, self.bullet_count))
    
    # 創建槍對象
    ak47 = Gun("ak47")
    ak47.add_bullet(50)
    ak47.shoot()
    
    

    1.2 開發士兵類

    假設:每一個新兵 都?沒有槍

    定義沒有初始值的屬性

    在定義屬性時,如果?不知道設置什么初始值,可以設置為?None

    • None?關鍵字?表示?什么都沒有
    • 表示一個?空對象沒有方法和屬性,是一個特殊的常量
    • 可以將?None?賦值給任何一個變量

    fire?方法需求

    • 1> 判斷是否有槍,沒有槍沒法沖鋒
    • 2> 喊一聲口號
    • 3> 裝填子彈
    • 4> 射擊
    class Soldier:
    
        def __init__(self, name):
    
            # 姓名
            self.name = name
            # 槍,士兵初始沒有槍 None 關鍵字表示什么都沒有
            self.gun = None
    
        def fire(self):
    
            # 1. 判斷士兵是否有槍
            if self.gun is None:
                print("[%s] 還沒有槍..." % self.name)
    
                return
    
            # 2. 高喊口號
            print("沖啊...[%s]" % self.name)
    
            # 3. 讓槍裝填子彈
            self.gun.add_bullet(50)
    
            # 4. 讓槍發射子彈
            self.gun.shoot()
    

    小結

    1. 創建了一個?士兵類,使用到?__init__?內置方法
    2. 在定義屬性時,如果?不知道設置什么初始值,可以設置為?None
    3. 在?封裝的?方法內部,還可以讓?自己的?使用其他類創建的對象屬性?調用已經?封裝好的方法

    02. 身份運算符

    身份運算符用于?比較?兩個對象的?內存地址?是否一致 ——?是否是對同一個對象的引用

    • 在?Python?中針對?None?比較時,建議使用?is?判斷
    運算符描述實例
    isis 是判斷兩個標識符是不是引用同一個對象x is y,類似 id(x) == id(y)
    is notis not 是判斷兩個標識符是不是引用不同對象x is not y,類似 id(a) != id(b)

    is 與 == 區別:

    is?用于判斷?兩個變量 引用對象是否為同一個?
    ==?用于判斷?引用變量的值?是否相等

    >>> a = [1, 2, 3]
    >>> b = [1, 2, 3]
    >>> b is a 
    False
    >>> b == a
    True

    ?

    私有屬性和私有方法

    01. 應用場景及定義方式

    應用場景

    • 在實際開發中,對象?的?某些屬性或方法?可能只希望?在對象的內部被使用,而?不希望在外部被訪問到
    • 私有屬性?就是?對象?不希望公開的?屬性
    • 私有方法?就是?對象?不希望公開的?方法

    定義方式

    • 在?定義屬性或方法時,在?屬性名或者方法名前?增加?兩個下劃線,定義的就是?私有?屬性或方法

    class Women:
    
        def __init__(self, name):
    
            self.name = name
            # 不要問女生的年齡
            self.__age = 18
    
        def __secret(self):
            print("我的年齡是 %d" % self.__age)
    
    
    xiaofang = Women("小芳")
    # 私有屬性,外部不能直接訪問
    # print(xiaofang.__age)
    
    # 私有方法,外部不能直接調用
    # xiaofang.__secret()
    
    

    02. 偽私有屬性和私有方法(科普)

    提示:在日常開發中,不要使用這種方式訪問對象的 私有屬性 或 私有方法

    Python?中,并沒有?真正意義?的?私有

    • 在給?屬性、方法?命名時,實際是對?名稱?做了一些特殊處理,使得外界無法訪問到
    • 處理方式:在?名稱?前面加上?_類名?=>?_類名__名稱
    # 私有屬性,外部不能直接訪問到
    print(xiaofang._Women__age)
    
    # 私有方法,外部不能直接調用
    xiaofang._Women__secret()
    

    感謝各位大佬的觀看,小編這邊準備了一個既能學習交流的也能接單的qq群聊 :222020937【代碼也準備好了】 歡迎加入《廣告勿加,不然你做啥啥不賺錢》最后祝大家技術能力能越來越好收入越來越多

    ?

    相關推薦
    ??2020 CSDN 皮膚主題: 終極編程指南 設計師:CSDN官方博客 返回首頁
    多乐彩