面向對象是一種抽象化的編程思想，就是將編程當成是一個事物。對於外界來說，事物是直接使用的，不用管內部情況，而編程則是設置事物應該做什麼事。
用類創建對象。類是對一系列具有相同**特征（屬性）和行為（方法）**的事物的統稱，是一個抽象的概念，不是真實存在的。對象是由類創造出來真實存在的事物。
Python2中類分為：經典類和新式類
class 類名():
代碼
# 類名要滿足標識符命名規則，同時遵循大駝峰命名習
# 不由任何內置類型派生出來的類叫做經典類
對象名=類名（）
#創建對象也叫實例化對象
self:調用該函數的對象
# 1.定義類
class Washer():
def wash(self):
print('我會洗⾐服')
# <__main__.Washer object at 0x0000024BA2B34240>
print(self)
# 2.創建對象
haier1 = Washer()
# <__main__.Washer object at 0x0000018B7B224240>
print(haier1)
# haier1 對象調⽤實例⽅法
haier1.wash()
haier2 = Washer()
# <__main__.Washer object at 0x0000022005857EF0>
print(haier2)
對象屬性既可以在類外⾯添加和獲取，也能在類⾥⾯添加和獲取。
# 類外添加成員屬性
對象名.屬性名=值
#類外獲取對象屬性
對象名.屬性名
#類內獲取對象屬性
self.屬性名
class Washer():
def print_info(self):
#類⾥⾯獲取實例屬性
print(f'haier1 洗⾐機的寬度是{
self.width}')
print(f'haier1洗⾐機的高度是{
self.height}')
#創建對象
haier1 = Washer()
#添加實例屬性
haier1.width = 500
haier1.height = 800
haier1.print_info()
在Python中，xx()的函數叫做魔方⽅法，指的是具有特殊功能的函數。
_init_():初始化對象
#該方法在創建對象時會被默認調用
#_init_(self)的self參數。不需要開發者傳遞，python解釋器會把對當前對象的引用傳遞過去
class Washer():
#定義初始化功能的函數
def __init__(self):
#添加實例屬性
self.width = 500
self.height = 800
def print_info(self):
#類⾥⾯調⽤實例屬性
print(f'洗⾐機的寬度是{
self.width},⾼度是{
self.height}')
haier1 = Washer()
haier1.print_info()
帶參數的_init_()方法：
#⼀個類可以創建多個對象，可以通過傳參數對不同的對象設置不同的初始化屬性
class Washer():
def __init__(self, width, height):
self.width = width
self.height = height
def print_info(self):
print(f'洗⾐機的寬度是{
self.width}')
print(f'洗⾐機的⾼度是{
self.height}')
haier1 = Washer(10, 20)
haier1.print_info()
haier2 = Washer(30, 40)
haier2.print_info()
_str_()
#當使⽤print輸出對象的時候，默認打印對象的內存地址。
#如果類定義了__str__⽅法，那麼就會打印從在這個⽅法中return的數據。
class Washer():
def __init__(self, width, height):
self.width = width
self.height = height
def __str__(self):
return'這是海爾洗⾐機的說明書'
haier1 = Washer(10, 20)
#這是海爾洗⾐機的說明書
print(haier1)
_del_()
#當刪除對象的時候，python解釋器也會默認調用_del_()方法
class Washer():
def __init__(self, width, height):
self.width = width
self.height = height
def __del__(self):
print(f'{
self}對象已經被刪除')
haier1 = Washer(10, 20)
# <__main__.Washer object at 0x0000026118223278>對象已經被刪除
del haier1
將屬性和⽅法書寫到類的⾥⾯的操作即為封裝+封裝可以為屬性和⽅法添加私有權限
在Python中，所有類默認繼承object類，object類是頂級類或基類；其他⼦類叫做派⽣類。
class 類名(object):
代碼
#⽗類A
class A(object):
def __init__(self):
self.num = 1
def info_print(self):
print(self.num)
#⼦類B
class B(A):
pass
result = B()
result.info_print()# 1
（1）當⼀個類有多個⽗類的時候，默認使⽤第⼀個⽗類的同名屬性和⽅法。
（2）⼦類和⽗類具有同名屬性和⽅法，默認使⽤⼦類的同名屬性和⽅法。
class Master(object):
def __init__(self):
self.kongfu = '[古法煎餅果⼦配⽅]'
def make_cake(self):
print(f'運⽤{
self.kongfu}制作煎餅果子')
class School(object):
def __init__(self):
self.kongfu = '[⿊⻢煎餅果⼦配⽅]'
def make_cake(self):
print(f'運⽤{
self.kongfu}制作煎餅果子')
class Prentice(School, Master):
def __init__(self):
self.kongfu = '[獨創煎餅果⼦配⽅]'
def make_cake(self):
#如果是先調⽤了⽗類的屬性和⽅法，⽗類屬性會覆蓋⼦類屬性，故在調⽤屬性前，先調⽤⾃⼰⼦類的初始化
self.__init__()
print(f'運⽤{
self.kongfu}制作煎餅果⼦')
#調⽤⽗類⽅法，但是為保證調⽤到的也是⽗類的屬性，必須在調⽤⽅法前調⽤⽗類的初始化
def make_master_cake(self):
Master.__init__(self)
Master.make_cake(self)
def make_school_cake(self):
School.__init__(self)
School.make_cake(self)
daqiu = Prentice()
daqiu.make_cake()
daqiu.make_master_cake()
daqiu.make_school_cake()
daqiu.make_cake()
super（）:調用父類方法
使⽤super()可以⾃動查找⽗類。調⽤順序遵循__mro__類屬性的順序。⽐較適合單繼承使⽤。
在Python中，可以為實例屬性和⽅法設置私有權限，即設置某個實例屬性或實例⽅法不繼承給⼦類。設置私有權限的⽅法：在屬性名和⽅法名前⾯加上兩個下劃線__
self._money=200000
(1)使用get__xx獲取私有屬性，使用set__xx修改私有屬性
#獲取私有屬性
def get_money(self):
return self.__money
#修改私有屬性
def set_money(self):
self.__money = 500
傳⼊不同的對象，產⽣不同的結果
多態指的是⼀類事物有多種形態，（⼀個抽象類有多個⼦類，因⽽多態的概念依賴於繼承）。
定義：
（1）多態是⼀種使⽤對象的⽅式，⼦類重寫⽗類⽅法，調⽤不同⼦類對象的相同⽗類⽅法，可以產⽣不同的執⾏結果
（2）好處：調⽤靈活，有了多態，更容易編寫出通⽤的代碼，做出通⽤的編程，以適應需求的不斷變化！
實現步驟：
（1）定義⽗類，並提供公共⽅法
（2）定義⼦類，並重寫⽗類⽅法，傳遞⼦類對象給調⽤者，可以看到不同⼦類執⾏效果不同
class Dog(object):
def work(self):
#⽗類提供統⼀的⽅法，哪怕是空⽅法
print('指哪打哪...')
class ArmyDog(Dog):
#繼承Dog類
def work(self):
#⼦類重寫⽗類同名⽅法
print('追擊敵人...')
class DrugDog(Dog):
def work(self):
print('追查毒品...')
class Person(object):
def work_with_dog(self, dog):
#傳⼊不同的對象，執⾏不同的代碼，即不同的work函數
dog.work()
ad = ArmyDog()
dd = DrugDog()
daqiu = Person()
daqiu.work_with_dog(ad)
daqiu.work_with_dog(dd)
類屬性就是類對象所擁有的屬性，它被該類的所有實例對象所共有。類屬性可以使⽤類對象或實例對象訪問。
類的實例記錄的某項數據始終保持⼀致時，則定義類屬性。實例屬性要求每個對象為其單獨開辟⼀份內存空間來記錄數據，⽽類屬性為全類所共有，僅占⽤⼀份內存，更加節省內存空間。
類屬性只能通過類對象修改，不能通過實例對象修改，如果通過實例對象修改類屬性，表示的是創建了⼀個實例屬性。
類方法是第⼀個形參是類對象的⽅法，需要⽤裝飾器@classmethod來標識其為類⽅法，對於類⽅法，第⼀個參數必須是類對象，⼀般以cls作為第⼀個參數。
靜態方法需要通過裝飾器@staticmethod來進⾏修飾，靜態⽅法既不需要傳遞類對象也不需要傳遞實例對象（形參沒有self/cls）。靜態⽅法也能夠通過實例對象和類對象去訪問。
class Dog(object):
@staticmethod
def info_print():
print('這是⼀個狗類，⽤於創建狗實例...')
wangcai = Dog()
#靜態⽅法既可以使⽤對象訪問⼜可以使⽤類訪問
wangcai.info_print()
Dog.info_print()
產品設計需求：
（1）被烤的時間和對應的狀態
（2）調料：用戶可以按照自己的意願進行添加
步驟分析：
地⽠的屬性
地⽠的⽅法
#定義類
class SweetPotato():
def __init__(self):
#被烤的時間
self.cook_time = 0
#地⽠的狀態
self.cook_static = '⽣的'
#調料列表
self.condiments = []
def cook(self, time):
"""烤地⽠的⽅法"""
self.cook_time += time
if 0<= self.cook_time<3:
self.cook_static = '⽣的'
elif 3<= self.cook_time<5:
self.cook_static = '半⽣不熟'
elif 5<= self.cook_time<8:
self.cook_static = '熟了'
elif self.cook_time>= 8:
self.cook_static = '烤糊了'
def add_condiments(self, condiment):
"""添加調料"""
self.condiments.append(condiment)
def __str__(self):
return f'這個地⽠烤了{
self.cook_time}分鐘,狀態是{
self.cook_static},添加的調料有{
self.condiments}'
digua1 = SweetPotato()
print(digua1)
digua1.cook(2)
digua1.add_condiments('醬油')
print(digua1)
digua1.cook(2)
digua1.add_condiments('辣椒⾯⼉')
print(digua1)
digua1.cook(2)
print(digua1)
digua1.cook(2)
print(digua1)
需求：將小於房子剩余面積的家具擺放到房子中
class Furniture():
def __init__(self, name, area):
#家具名字
self.name = name
#家具占地⾯積
self.area = area
class Home():
def __init__(self, address, area):
#地理位置
self.address = address
#房屋⾯積
self.area = area
#剩余⾯積
self.free_area = area
#家具列表
self.furniture = []
def __str__(self):
return f'房⼦坐落於{
self.address},占地⾯積{
self.area},剩余⾯積{
self.free_area},家具有{
self.furniture}'
def add_furniture(self, item):
"""容納家具"""
if self.free_area>= item.area:
self.furniture.append(item.name)
#家具搬⼊後，房屋剩余⾯積=之前剩余⾯積-該家具⾯積
self.free_area -= item.area
else:print('家具太⼤，剩余⾯積不⾜，⽆法容納')
bed = Furniture('雙⼈床',6)
jia1 = Home('北京',1200)
jia1.add_furniture(bed)
sofa = Furniture('沙發',10)
jia1.add_furniture(sofa)
ball = Furniture('籃球場',1500)
jia1.add_furniture(ball)
