什麽是面向對象
# 面向對象的程序設計思想：核心是對象二字，對象就是一個事物，沒有的事物可以被創造，不要考慮過程，考慮的是對象
# 對象：一個事物的特征和技能唯一標識一個對象，系統是一個個的對象組成的，程序的發展是有對象之間的交互，擴展行很強
# 把設計程序看成是創造世界，那麽程序員就是上地，任何不存在的對象都能被創造，更加註重對現實世界的模擬
# 優點：擴展性強，優點就是用途
# 缺點：無法預知程序的發展，只知道程序的對象的屬性
# 類即種類，類別，對象是特征和技能的結合體，那麽類就是一系列相似的對象
# 特征和技能的結合體
# 在現實世界中：現有的一個個具體存在的對象，總結這些對象的相似之處，才有的類，
# 在程序中：先定義類，後使用類，類是用來生成對象的一個工具，
# 定義類一定是站在某一個角度進行區分
# 第一階段：顯示中的對象——>現實中類
# obj1：
#     特征：
#         學校=oldboy
#         名字=李大炮
#         年紀=18
#         性別=女
#     技能：
#         學習
#         吃飯
# obj2：
#     特征：
#         學校=oldboy
#         名字=張全蛋
#         年紀=28
#         性別=男
#     技能：
#         學習
#         吃飯
# obj3：
#     特征：
#         學校=oldboy
#         名字=牛榴彈
#         年紀=18
#         性別=女
#     技能：
#         學習
#         吃飯
# 顯示中的老男孩學生類：
#   相似的特征
#     學校=oldboy
#    相似的技能
#     學習
#     吃飯
class OldboyStudent:#定義類
    school=‘oldboy‘#定義特征，數據屬性，靜態屬性
    def learn(self):#定義技能，函數屬性，這倆都是類的屬性，動態屬性
        print(‘is learning‘)
    def eat(self):
        print(‘is eating‘)
#在類中，變量定義的是類的特征，函數定義的是技能
#類體的代碼在類定義階段就會執行，在類中，類體的代碼不只局限與變量和函數，還可以有其他的代碼
#在類定義的時候，有名字存在，會產生名稱空間，查看名稱空間，以字典形式產生,查看名稱空間和變量的值,這是查看的是函數的內存地址，加()可以運行
# 以及函數的內存地址
print(OldboyStudent.__dict__)
print(OldboyStudent.__dict__[‘school‘])
print(OldboyStudent.__dict__[‘learn‘])
#python訪問類的屬性的做法：
print(OldboyStudent.school) #查看類的屬性
print(OldboyStudent.learn)#learn一定不能加上（），加了（）就是找到並且調用
OldboyStudent.learn()#仍然是一個函數，符合函數所有的規則
OldboyStudent.school=‘OLD‘#更改類的屬性
del OldboyStudent.school #刪除類的屬性
OldboyStudent.school=‘111111‘#增加類的屬性
OldboyStudent.__dict__#查看類的屬性
#程序中的類是為了產生程序中的對象
####################################對象############################
 

print(callable(OldboyStudent))#是可調用對象,使用類產生對象
# 產生程序中的對象:類名+括號，調用類，產生類的實際存在的對象，類是虛擬的東西，調用之後產生了一個真的對象，這個過程就是實例化，產生的對象就是這個類的實例
obj1=OldboyStudent()#加上（）之後有返回值，一樣的特征就存在類中，不一樣的存到各自的對象中
obj2=OldboyStudent()
obj3=OldboyStudent()
#############################init######################################
class OldboyStudent:
    school=‘oldboy‘
    def __init__(self,name,age,sex):#定義類自己的特征
        self.name=name #等號右邊是參數，左邊是屬性，使用init初始化對象
        self.age=age
        self.sex=sex
    def learn(self):
        print(‘is learning‘)
    def eat(self):
        print(‘is eating‘)
obj1 = OldboyStudent(‘李大炮‘,‘18‘,‘女‘)
#init只在實例化時執行，沒有自己的特征的對象是空對象，產生空對象之後執行
#1、先產生一個空對象
#2、觸發init，把函數中的參數，連同自己一同傳進去
print(obj1.__dict__)#查看類的獨有的屬性，返回結果是字典
obj2 = OldboyStudent(‘張全蛋‘,‘28‘,‘男‘)
print(obj2.__dict__)
obj3 = OldboyStudent(‘牛榴彈‘,‘18‘,‘女‘)
print(obj3.__dict__)
###########################對象的屬性###############################
 

obj1.name
obj1.name=‘大炮‘
obj1.__dict__#使用字典的方式訪問對象的私有屬性，想操作字典一樣操作屬性，
#字典有的方法，這種都有,比如：obj1.__dict__.pop(‘name‘)，#曾刪改查的操作同理
類體中可以存在任何的代碼，
class OldboyStudent:
    school=‘oldboy‘
    def __init__(self,name,age,sex):#定義類自己的特征
        if not isinstance(name.str):
            raise TyoeError(‘類型錯誤‘)
        self.name=name #等號右邊是參數，左邊是屬性，使用init初始化對象
        self.age=age
        self.sex=sex
    def learn(self):
        print(‘is learning‘)
#init中有任意的代碼，但是在init中只能return None,不能返回其他的。
########################對象的屬性查找#################################
 

#1、類的數據屬性
print(obj1.name,obj1.age) #查看私有的
print(obj1.school)#查看相同的屬性
print(obj2.school)
print(obj3.school)
#對象可以訪問的類的數據屬性，這裏的id都是相同的，類的數據屬性是共享給對象的
#2、類的函數屬性,對象可以訪問類的函數數據，得到的是綁定方法，內存中只加載一次，有一個對象就綁定給他，這樣1、綁定可以節省內次年
#   2、在多個對象綁定的時候，每一個對象產生的結果和使用的方法都是自己的，誰綁定就操作誰，相互之間不影響
print(obj1.learn)
print(obj2.learn)
print(obj3.learn)
#綁定方法的特殊之處：綁定給誰就由誰來調用，誰來調用就把誰當作第一個參數傳進去
#由對象觸發的，都是綁定方法，是綁定方法，都會把自己作為第一個參數傳進去
#python3 中數據類型就是一個類。
#查找順序：在對象自己有一個數據屬性，類也有一個數據屬性，那麽有限在對象中找，自己沒有在在類中找
#如果該類的，所有的由這個類產生的對象都被更改，
#但是在類和對象的名稱空間外部的名稱空間，比如全局名稱空間，就無法查找。
#屬性就兩種：類的屬性，對象的屬性
#類內部的函數，綁定方法的那種一定要穿self參數。
########################################繼承###################################
# 繼承的功能：
# 1、減少類之間的代碼重復
# 2、繼承是類和類之間的關系，是什麽是什麽的關系、：人是動物，人的類和動物的類就是一種繼承的關系
# 3、派生出的子類，以自己的屬性為準
# 4、在子類派生出來的新的屬性，可以這一指名道姓的調用父類的方法
# OldboyStudent.__init__(),這種方式本身和繼承沒有關系，只是調用了一個函數的功能而已，即時沒有繼承個關系，也可以這樣使用
##################################組合####################################
#組合：
# 當一個對象有多個屬性來自多個類的時候使用組合的方式，精髓在於定一個了一個空列表，然後
#使用了一個新的類去生成了一個對象，把這個對象追加進那個空雷列表中，組合的使用場景是誰有誰的關系。
######################################################################
#1、 集成的原理：類1調用了類2，類2集成了類3 類1還集成了類4，類4上邊還有類，這樣類1的屬性的查找順序
#是從左邊開始找，類2中沒有，去類2 的父類中去找，然後從右邊在找，沒找一根，把這個全部找完
#然後在去別的地方找。
# 可惡的菱形問題，類1調用了類2 類3 類4 ， 2 3 4 都調用的5，這時候先去2 3 4 中找，沒有的話再去5中找
# 如果 2 3 4上還有一層，就先把這一根找完，再找其他的。這是經典類，新式類是先找一層，然後在找另外一層。
#查看類的調用關系MRO列表
OldboyStudent.mro()#存的就是調用關系
#############################子類調用父類################################
# 子類中調用父類的方法
#1、指名道姓
#2、super
# sum()._init_調用父類的方法，指名道姓的放吧要傳self，但是super不用
################################綁定和非綁定#################################
# 綁定方法和非綁定方法，上邊說的綁定方法是綁定給對象，那麽能夠綁定給類嗎？
#綁定給誰，就是是誰來調用，誰調用就是要hi把誰當作第一個參數穿進去
class Mysql:
    def __init__(self,host,port):
        self.host=host
        self.port=port
coon=Mysql(‘127.0.0.1‘,‘3306‘)
#從配置文件中讀取參數
import settings
class Mysql:
    def __init__(self,host,port):
        self.host=host
        self.port=port
    @classmethod#有了這個，當類在調用的時候，會把類當作參數穿進去，對象也可以調用，但是傳的就是對象了
    def from_conf(cls):
        return cls(settings.HOST,settings.PORT)
coon=Mysql(‘127.0.0.1‘,‘3306‘)
@staticmethod #和誰都不綁定
def liu():
    return  str(hhh)
#這樣就是在類中定義了一個普通的函數

python7：面向對象