python—面向對象設計

一：三大編程范式

1.面向過程編程
2.函數式編程
3.面向對象編程

 （類：把一類事物的相同的特征和動作整合到一起就是類，類是一個抽象的概念）

 （對象：就是基於類而創建的一個具體的事物 [具體存在的] 也是特征和動作整合到一起）

 

 二：類與對象

（在python2中，分新式類與經典類，python3統一都是新式類【新式類，class 類名:】【經典類，class 類名(object)】）

class Chinese:   #class是關鍵字，表示類名
    pass
print(Chinese)

p1=Chinese() #實例化過程，創建對象，類名后面加括號
print(p1)

      實例化，由類產生對象的過程叫做實例化，類實例化的結果就是一個對象，或者叫做一個實例   

      ps：類中的函數第一個參數必須是self  類中定義的函數叫做 “方法”

類是用來描述一類事物，類的對象指的是這一類事物中的一個個體
是事物就要有屬性，屬性分為:
1.數據屬性：就是變量
2.函數屬性：就是函數，在面向對象里通常稱為方法
注：類和對象均是用點來訪問自己的屬性

類是用來描述一類事物，類的對象指的是這一類事物中的一個個體
是事物就要有屬性，屬性分為:
1.數據屬性：就是變量
2.函數屬性：就是函數，在面向對象里通常稱為方法
注：類和對象均是用點來訪問自己的屬性

class Chinese:
    dang='我愛中國'
    def tu_tan():
        print('張口就是一痰')
    def queue(self):
        print('隨意就是一插')
print(Chinese.dang) #調用類Chinese的數據屬性
Chinese.tu_tan() #調用方法
Chinese.queue('zy') #queue方法必須傳一個參數
print(Chinese.__dict__)  #Chinese所有的方法
print(Chinese.__dict__['dang'])  #在字典中找出了dang這個數據屬性
print(Chinese.__dict__['tu_tan']) #內存地址，加()就是地址的內容
Chinese.__dict__['tu_tan']()
Chinese.__dict__['queue'](666) #必須給queue傳一個參數

# 我愛中國
# 張口就是一痰
# 隨意就是一插
# {'__dict__': <attribute '__dict__' of 'Chinese' objects>, '__module__': '__main__', 'queue': <function Chinese.queue at 0x0000029230A14C80>, 'tu_tan': <function Chinese.tu_tan at 0x0000029230A148C8>, 'dang': '我愛中國', '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>}
# 我愛中國
# <function Chinese.tu_tan at 0x0000029230A148C8>
# 張口就是一痰
# 隨意就是一插

 

 對象：

class Chinese:
    dang='我愛中國'
    # def __init__(name,age,gender):  #開頭結尾都有兩個_ _表示是系統內置的方法
    #     dic={
    #         'name':name,
    #         'age':age,
    #         'gender':gender
    #     }
    #     return dic
    def __init__(self,name,age,gender):
        print('開始')
        self.mingzi=name  # 其實就是字典中封裝了名字，年級，性別
        self.nianji=age
        self.xingbie=gender
        print('結束')
#class的__init__就是不需要返回任何值，它會自動返回
    def tu_tan():
        print('張口就是一痰')
    def queue(self):
        print('隨意就是一插')

person1=Chinese('zy',18,'female')  #實例化就是在觸發系統內置的__init__
print(person1.__dict__)  #實例化后的字典形式 __dict__
print(person1.mingzi)  #調用person1字典的mingzi
print(person1.dang)  #person1調用類class的屬性

Chinese.tu_tan()
Chinese.queue(person1)  #必須傳參數

結果：
# 開始
# 結束
# {'xingbie': 'female', 'nianji': 18, 'mingzi': 'zy'}
# zy
# 我愛中國
# 張口就是一痰
# 隨意就是一插

 

 類屬性的增刪改查：

class Chinese:
    country='China'
    def __init__(self,name):
        self.name=name
    def play_ball(self,ball):
        print("%s 正在打%s" %(self.name，ball))

print(Chinese.country)  #查看

Chinese.country='Japan'
print(Chinese.country)   #修改

p1=Chinese('alex')
print(p1.__dict__)
print(p1.country)

Chinese.dang='dang' #增加
print(Chinese.dang)
print(p1.dang)

del Chinese.dang   #刪除
del Chinese.country
print(Chinese.__dict__)

結果：
# China
# Japan
# {'name': 'alex'}
# Japan
# dang
# dang
# {'__module__': '__main__', '__init__': <function Chinese.__init__ at 0x000001FE771948C8>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, 'play_ball': <function Chinese.play_ball at 0x000001FE77194C80>, '__doc__': None}

 

實例屬性的增刪改查：  （實例只有數據屬性）

class Chinese:
    country='China'
    def __init__(self,name):
        self.name=name
    def play_ball(self,ball):
        print("%s 正在打%s" %(self.name,ball))
p1=Chinese('alex')
print(p1.__dict__)  #實例屬性只有{'name': 'alex'}

#查看
print(p1.name)
print(p1.play_ball)  #這一步實際上是訪問類

#增加
p1.age=18
print(p1.__dict__)
print(p1.age)

#修改
p1.age=19
print(p1.__dict__)
print(p1.age)

#刪除
del p1.age
print(p1.__dict__)

結果：
#{'name': 'alex'}
# alex
# <bound method Chinese.play_ball of <__main__.Chinese object at 0x000002042B47A400>>
# {'age': 18, 'name': 'alex'}
# 18
# {'age': 19, 'name': 'alex'}
# 19
# {'name': 'alex'}

 

對象與實例屬性：

class Chinese:
    country='China'
    def __init__(self,name):
        self.name=name
    def play_ball(self,ball):
        print("%s 正在打%s" %(self.name,ball))
p1=Chinese('alex')
print(p1.country)
p1.country='Japan'
print(Chinese.country) #類的
print(p1.country)  #實例的
結果：
#China
#China
#Japan

country='China'
class Chinese:

    def __init__(self,name):
        self.name=name
    def play_ball(self,ball):
        print("%s 正在打%s" %(self.name,ball))
p1=Chinese('alex')
print(p1.country)   #報錯，因為p1調用country在class里面找，找不到不會出去找

country='China'
class Chinese:
    country='中國'
    def __init__(self,name):
        self.name=name
        print(country)
#只是返回一個普通的變量，只有點調用的時候才在類屬性或者實例屬性字典里面去找，所以返回China
p1=Chinese('alex')
print(p1.country) #這才是調用實例屬性，country才是'中國'

class Chinese:
    country = 'China'
    def __init__(self,name):
        self.name=name
p1=Chinese('alex')
p1.country='Japan'
print(Chinese.country)  #類屬性沒有變，所以結果還是China


class Chinese:
    country = 'China'
    li=['a','b']
    def __init__(self,name):
        self.name=name
p1=Chinese('alex')
print(p1.li)
# p1.li=[666]
# print(Chinese.li)  #類的列表還是沒變的
p1.li.append('cc')   #直接改了類里面的列表
print(p1.__dict__)
print(Chinese.li)  #類里面的列表被改變之后，打印出來的里邊當然是新列表['a', 'b', 'cc']

 

靜態屬性：

class Room:
    def __init__(self,name,owner,width,length,heigh):
        self.name=name
        self.owner=owner
        self.width=width
        self.length=length
        self.heigh=heigh
    @property  #在類的普通方法上應用@property裝飾器
    def cal_area(self):
        print("%s住的%s總面積是%s" % (self.owner, self.name, self.width * self.heigh * self.length))
r1=Room('豪宅','zy',1000,1000,1000)
r2=Room('別墅','zt',1000,1200,1300)
r1.cal_area
r2.cal_area

結果：
zy住的豪宅總面積是1000000000
zt住的別墅總面積是1560000000

 

類方法：

class Room:
    tag=1
    def __init__(self,name,owner,width,length,heigh):
        self.name=name
        self.owner=owner
        self.width=width
        self.length=length
        self.heigh=heigh
    @property  
    def cal_area(self):
        print("%s住的%s總面積是%s" % (self.owner, self.name, self.width * self.heigh * self.length))
    def test(self):
        print('from test',self.name)
    def tell_info(self):
        print(self.tag)
print(Room.tag)    #類可以調用自己的數據屬性
r1=Room('wc','alex',10,100,30) #折中方案，必須先實例化，再。。。。
Room.tell_info(r1)

結果：1  1

優化，類方法：
class Room:
    tag=1
    def __init__(self,name,owner,width,length,heigh):
        self.name=name
        self.owner=owner
        self.width=width
        self.length=length
        self.heigh=heigh
    @property
    def cal_area(self):
        print("%s住的%s總面積是%s" % (self.owner, self.name, self.width * self.heigh * self.length))
    def test(self):
        print('from test',self.name)
    @classmethod
    def tell_info(cls):
        print(cls)
        print('--->',cls.tag)
Room.tell_info()  #用類調用類方法，自動傳值，把Room傳給了tell_info

結果：
#<class '__main__.Room'>
#---> 1

 

靜態方法：

靜態方法只是類的工具包
class Room:
    tag=1
    @staticmethod
    def wash_body(a,b,c):
        print('%s,%s,%s正在洗澡' %(a,b,c))
Room.wash_body('zy','zt','zc')
結果：zy,zt,zc正在洗澡

 

三：組合（類與類之間沒有共同點，但是有關聯，拼接類使之間能完成某項功能）

#組合
class School:
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr
    def zhao_sheng(self):
        print('%s正在招生' %self.name)
class Course:
    def __init__(self,name,price,period,school):
        self.name=name
        self.price=price
        self.period=period
        self.school=school

s1=School('oldboy','beijin')
s2=School('oldboy','nanjin')
s3=School('oldboy','dongjin')

c1=Course('linux','10','1h',s1)

print(c1.__dict__)
print(c1.school.name)

結果：
#{'price': '10', 'school': <__main__.School object at 0x00000229CB1EA898>, 'name': 'linux', 'period': '1h'}
#oldboy

改進，自己傳值：
class School:
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr
    def zhao_sheng(self):
        print('%s正在招生' %self.name)
class Course:
    def __init__(self,name,price,period,school):
        self.name=name
        self.price=price
        self.period=period
        self.school=school

s1=School('oldboy','beijin')
s2=School('oldboy','nanjin')
s3=School('oldboy','dongjin')

# c1=Course('linux','10','1h',s1)
message='''
1 oldboy beijin
2 oldboy nanjin
3 oldboy dongjin
'''
while True:
    print(message)
    menu={
        '1':s1,
        '2':s2,
        '3':s3
    }
    choice=input('選擇學校:')
    school_obj=menu[choice]

    name=input('課程名：')
    price=input('課程費用：')
    period=input('課程周期：')

    new_course=Course(name,price,period,school_obj)
    print('課程%s屬於%s學校' %(new_course.name,new_course.school.name))

結果：
#1 oldboy beijin
#2 oldboy nanjin
#3 oldboy dongjin

#選擇學校:2
#課程名：linux
#課程費用：100
#課程周期：1h
#課程linux屬於oldboy學校

 

四：面向對象編程三大特性

     【1】繼承（分：單繼承，多繼承）

class Dad:
    money=10000
    def __init__(self,name):
        print('baba')
        self.name=name
    def hit_son(self):
        print('%s 正在打兒子' %self.name)

class Son(Dad):
    pass

s1=Son('zy')
print(s1.money)
print(s1.__dict__)

結果：
#baba
#10000
#{'name': 'zy'}

1.當類之間有顯著不同，且較小的類是較大類所需的組件時，用組合比較好。
2.當類之間有很多相同的功能，提取這些共同的功能做成基類，用繼承比較好。

含義一：繼承基類的方法，並且做出自己的改變或者擴展（代碼重用）
含義二：聲明某個子類兼容於某個基類，定義一個接口類，子類繼承接口類，並且實現接口中定義的方法。

接口繼承
接口繼承實際上是要求“做出一個良好的抽象，這個抽象規定了一個兼容接口，使得外部調用者無須關心具體細節，可一視同仁的處理實現了特定接口的所有對象”——這個在程序設計上叫做歸一化。（歸一化使得高層的外部使用者可以不加區分的處理所有的接口兼容的對象集合）

繼承順序：深度優先，廣度優先

（當時經典類時，多繼承情況下，會按照深度優先的方法查找。當時新式類時，會按照廣度優先的方式查找。）

 

在子類中如何調用父類的方法：

(子類繼承父類的方法，然后想基於原有的基礎上進行修改，那么就需要在子類中調用父類的方法。)

class Vehicle:
    Country='china'
    def __init__(self,name,speed,load,power):
        self.name=name
        self.speed=speed
        self.load=load
        self.power=power
    def run(self):
        print('開動了')
class Subway(Vehicle):
    def __init__(self,name,speed,load,power,line):
        Vehicle.__init__(self,name,speed,load,power)
        self.line = line  #子類中派生出的新的方法
    def show_info(self):
        print(self.name,self.speed,self.load,self.power,self.line)
line13=Subway('北京地鐵','10km/s',10000,'電',13)
line13.show_info()
line13.run()

結果：
#北京地鐵 10km/s 10000 電 13
#開動了

super調用父類方法：

class Vehicle:
    Country='china'
    def __init__(self,name,speed,load,power):
        self.name=name
        self.speed=speed
        self.load=load
        self.power=power
    def run(self):
        print('開動了')
class Subway(Vehicle):
    def __init__(self,name,speed,load,power,line):
        # Vehicle.__init__(self,name,speed,load,power)
        super().__init__(name,speed,load,power)  #不用寫父類了，用super調到父類的方法
        self.line = line  #子類中派生出的新的方法
    def show_info(self):
        print(self.name,self.speed,self.load,self.power,self.line)
line13=Subway('北京地鐵','10km/s',10000,'電',13)
line13.show_info()
line13.run()

結果：
北京地鐵 10km/s 10000 電 13
開動了

 

  【2】多態（多態的概念指出了對象如何通過他們共同的屬性和動作來操作及訪問，而不需要考慮他們具體的類。執行過程中才顯示出多態。）

  【3】封裝

（三個層面的封裝，第一，類本身就是一種封裝；第二，類中定義私有的，只在類的內部使用外部無法訪問；第三，明確區分內外，內部的實現邏輯，外部無法知曉，並且為封裝到內部的邏輯提供一個訪問接口給外部使用）

class People:       
    __star='earth' 
    def __init__(self,id,name,age,salary):
        print('--->',self.__star)
        self.id=id
        self.name=name
        self_age=age
        self._salary=salary
    def get_id(self):
        print('這是私有方法，它的id是【%s】' %self.id)
    #訪問函數,間接訪問
    def get_star(self):
        print(self.__star)
p1=People('216513548','zy','18',100000000)
print(People.__dict__)
print(p1._People__star)
p1.get_star()
結果：
#---> earth
#{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'People' objects>, '__init__': <function People.__init__ at 0x000001AB8B8248C8>, 'get_star': <function People.get_star at 0x000001AB8B824D08>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None, '_People__star': 'earth', 'get_id': <function People.get_id at 0x000001AB8B824C80>}
#earth
#earth

class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width   #加__后變成私有的，外部訪問不到
        self.__length=length
        self.__high=high
    def tell_area(self):   #求面積函數在類class內部，可以訪問長寬高；求面積；等於開了一個接口
        return self.__width*self.__length*self.__high
r1=Room('Bighouse','zy',100,60,90)
area=r1.tell_area()  #實例化求體積
print(area)
結果：540000

 

五：面向對象進階

     【1】反射（反射指的是程序可以訪問，檢測和修改它本身狀態或行為的一種能力[自省]）

        !!!!!python面向對象中的反射：通過字符串的形式操作對象相關的屬性;python中的一切事物都是對象（都可以使用反射）!!!!!

              四種可以實現自省的函數：

 1.hasattr 2.setattr 3.getattr 4.delattr

例子：
class Zhongjie:
    feature='black'
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr
    def sell_house(self):
        print('%s正在賣房子'%self.name)
    def rent_house(self):
        print('%s正在租房子' %self.name)
z1=Zhongjie('sb','jinmao')
#對象是否有某種屬性
print(hasattr(z1,'name'))  #True
print(hasattr(z1,'sell_house'))   #True
print(hasattr(z1,'zyy'))  #False
#取對象的某種屬性
print(getattr(z1,'name'))  #sb
print(getattr(z1,'rent_house'))#<bound method Zhongjie.rent_house of <__main__.Zhongjie object at 0x0000021A6AA2A780>>
print(getattr(z1,'i am a sheep','沒有這個屬性')) #沒有這個屬性，找不到只會返回后面的值，不會報錯
#為對象設置某種屬性
setattr(z1,'sbb',True)
print(z1.__dict__)  #{'addr': 'jinmao', 'sbb': True, 'name': 'sb'}
#刪除對象某種屬性
delattr(z1,'sbb')
print(z1.__dict__)  #{'name': 'sb', 'addr': 'jinmao'}

 

    !!!!!反射機制的好處：

好處一：可以事先定義好接口，接口只有在被完成后才會真正執行，這實現了即插即用，這其實是一種‘后期綁定’，即你可以事先把主要的邏輯寫好（只定義接口），然后后期再去實現接口的功能。
好處二：動態導入模塊（基於反射當前模塊成員）

     【2】類的內置attr屬性

 1. __getattr__ 2. __delattr__ 3.__setattr__ 

實例：
#__getattr__
class Foo:
    x=666
    def __init__(self,y):
        self.y=y
    def __getattr__(self, item):   #__getattr__是在調用一個不存在的屬性時才會被執行
        print('執行__getattr__')
f1=Foo(888)
print(f1.y)   #888
print(getattr(f1,'y'))  #888
f1.zzzzzzz   #執行__getattr__

#__delattr__
class Foo:
    x=666
    def __init__(self,y):
        self.y=y
    def __delattr__(self, item):
        print('刪除操作__delattr__')  #刪除的時候會被執行
f1=Foo(360)
print(f1.y)  #360
del f1.y  #刪除操作__delattr__
del f1.x  #刪除操作__delattr__

#__setattr__
class Foo:
    x=666
    def __init__(self,y):
        self.y=y
    def __setattr__(self, key, value):
        print('__setattr__執行')
        self.__dict__[key]=value  
f1=Foo(985)
print(f1.__dict__)   #__setattr__執行{'y': 985}
f1.z=211   #觸發__setattr__
print(f1.__dict__)   #__setattr__執行{'z': 211, 'y': 985}

     【3】二次加工標准數據類型（包裝標准類型）

             包裝：python為大家提供了標准數據類型，以及豐富的內置方法，其實在很多場景下我們都需要基於標准數據類型來定制我們自己的數據類型，新增/改寫方法，這就用到了我們繼承/派生知識

                     （其他的標准類型均可以通過下面的方式進行二次加工）

#包裝標准數據類型
class List(list):
    def append_xixi(self,object):
        if type(object) is str:
            super().append(object)
        else:
            print('請添加字符串類型數據！！！')

    def show_middle(self):
        mid_index=int(len(self)/2)
        return self[mid_index]

L1=List('i am a beautiful girl')
print(L1,type(L1))  #['i', ' ', 'a', 'm', ' ', 'a', ' ', 'b', 'e', 'a', 'u', 't', 'i', 'f', 'u', 'l', ' ', 'g', 'i', 'r', 'l'] <class '__main__.List'>
print(L1.show_middle())  #u
L1.append_xixi('ojbk')
print(L1)  #['i', ' ', 'a', 'm', ' ', 'a', ' ', 'b', 'e', 'a', 'u', 't', 'i', 'f', 'u', 'l', ' ', 'g', 'i', 'r', 'l', 'ojbk']

 

      【4】組合的方式完成授權

              授權：授權是包裝的一個特性, 包裝一個類型通常是對已存在的類型的一些定制,這種做法可以新建,修改或刪除原有產品的功能。其它的則保持原樣。授權的過程,即是所有更新的功能都是由新類的某部分來處理,但已存在的功能就授權給對象的默認屬性。

                   實現授權的關鍵點就是覆蓋__getattr__方法

 

       【5】面向對象內置函數的補充：

isinstance(判斷是否是某種數據類型) & issubclass(判斷是否是子類)

                （1）__getattribute__

class Foo:
    def __init__(self,x):
        self.x=x

    def __getattr__(self, item):
        print('執行的是我')

    def __getattribute__(self, item):
        print('不管是否存在,都會執行')
        raise AttributeError('哈哈')

f1=Foo(10)
f1.x
f1.xxxxxx
#當__getattribute__與__getattr__同時存在,只會執行__getattrbute__,除非__getattribute__在執行過程中拋出異常AttributeError

結果：
#不管是否存在,都會執行
#執行的是我
#不管是否存在,都會執行
#執行的是我

                 （2）item系列【強調：點.的方式操作屬性就是與attr相關，中括號[]的方式操作屬性就是與item相關】

class Foo:
    def __init__(self,name):
        self.name=name

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print('del obj[key]時,我執行')
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print('del obj.key時,我執行')
        self.__dict__.pop(item)

f1=Foo('sb')
f1['age']=18
f1['age1']=19
del f1.age1
del f1['age']
f1['name']='alex'
print(f1.__dict__)

結果：
#del obj.key時,我執行
#del obj[key]時,我執行
#{'name': 'alex'}

                  （3）__str__與__repr__與__format__  (__str__規定必須return一個值)

改變對象的字符串顯示__str__,__repr__   #print觸發的是str，repr是在解釋器中觸發的，都是對輸出進行控制！當print找不到str就是去找repr作為替代品！！！

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        return 'my name is %s,and age is %s!' %(self.name,self.age)

f1=Foo('zy',18)
print(f1)  #print執行的其實是系統提供的str(F1),所以每次print的時候都是字典字符串，當自己定義__str__后就可以自己控制輸出了

結果：my name is zy,and age is 18!

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __repr__(self):
        return 'my name is %s,and age is %s!' %(self.name,self.age)

f1=Foo('zy',18)
print(f1)  #repr(f1)觸發——》__repr__()

結果一樣！！！
但是當沒有str就是去找repr作為替代品！！！

自定制format：
date_dic={
    'ymd':'{0.year}:{0.month}:{0.day}',
    'dmy':'{0.day}/{0.month}/{0.year}',
    'mdy':'{0.month}-{0.day}-{0.year}',
}
class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day

    def __format__(self, format_spec):
        if not format_spec or format_spec not in date_dic:
            format_spec='ymd'
        fmt=date_dic[format_spec]
        return fmt.format(self)

d1=Date(2016,12,29)
print(format(d1))
print('{:mdy}'.format(d1))

結果：
#2016:12:29
#12-29-2016

                （4）__slots__屬性：

1.__slots__是什么:是一個類變量,變量值可以是列表,元祖,或者可迭代對象,也可以是一個字符串(意味着所有實例只有一個數據屬性)。
2.引子:使用點來訪問屬性本質就是在訪問類或者對象的__dict__屬性字典(類的字典是共享的,而每個實例的是獨立的）。
3.為何使用__slots__:字典會占用大量內存,如果你有一個屬性很少的類,但是有很多實例,為了節省內存可以使用__slots__取代實例的__dict__。
當你定義__slots__后,__slots__就會為實例使用一種更加緊湊的內部表示。實例通過一個很小的固定大小的數組來構建,而不是為每個實例定義一個字典,這跟元組或列表很類似。在__slots__中列出的屬性名在內部被映射到這個數組的指定小標上。使用__slots__一個不好的地方就是我們不能再給實例添加新的屬性了,只能使用在__slots__中定義的那些屬性名。
4.注意事項:__slots__的很多特性都依賴於普通的基於字典的實現。另外,定義__slots__后的類不再支持一些普通類特性了,比如多繼承。大多數情況下,你應該只在那些經常被使用到的用作數據結構的類上定義__slots__比如在程序中需要創建某個類的幾百萬個實例對象 ，關於__slots__的一個常見誤區是它可以作為一個封裝工具來防止用戶給實例增加新的屬性。盡管使用__slots__可以達到這樣的目的,但是這個並不是它的初衷。更多的是用來作為一個內存優化工具。

class Foo:
    __slots__ = ['name','age']  #定義在類當中的類屬性，使之不在具有__dict__字典
f1=Foo()
f1.name='zy'
f1.age=18
print(f1.name)
print(f1.age)
print(f1.__slots__)  #幫助省內存

結果:
#zy
#18
#['name', 'age']

                  (5)doc屬性

class Foo:
    '我是描述信息'
    pass
class Bar(Foo):
    pass
print(Bar.__doc__) #該屬性無法繼承給子類
#原理就是在每一個類當中都會加一個__doc__，之要調就有

結果：None

                （6）__module__與__class__

__module__ 表示當前操作的對象在那個模塊
__class__     表示當前操作的對象的類是什么

                （7）__del__析構方法

析構方法，當對象在內存中被釋放時，自動觸發執行。
#注：如果產生的對象僅僅只是python程序級別的（用戶級），那么無需定義__del__,如果產生的對象的同時還會向操作系統發起系統調用，即一個對象有用戶級與內核級兩種資源，比如（打開一個文件，創建一個數據庫鏈接），則必須在清除對象的同時回收系統資源，這就用到了__del__

class Foo:
    def __init__(self,name):
        self.name=name
    def __del__(self):
        print('我執行了')
f1=Foo('zy')
del f1
print('ennnn')
#結果：我執行了
#      ennnn

但是：
class Foo:
    def __init__(self,name):
        self.name=name
    def __del__(self):
        print('我執行了')
f1=Foo('zy')
#del f1
print('ennnn')
#結果：ennnn
#      我執行了

                 （8）__call__

class Foo:
    def __call__(self, *args, **kwargs):
        print('實例執行了')
f1=Foo()  #
f1()  #調用Foo類下的__call__
結果：實例執行了

                 （9）__next__與__iter__實現迭代器協議

class Foo:
    pass
f1=Foo()
for i in f1:  #因為f1是對象所以可以for循環
    print(i)
#但是：TypeError: 'Foo' object is not iterable 報錯說Foo不是可迭代的對象
#怎么實現可迭代呢？？？
class Foo:
    def __init__(self,n):
        self.n=n
    def __iter__(self):
        return self
    def __next__(self):
        self.n+=1
        return self.n
f1=Foo(1)
print(f1.__next__())
for i in f1:  #for其實就是f1實現__iter__方法，迭代器，實際就是iter(f1)——》f1.__iter__
    print(i)

結果：無限加1

拋出異常，使之停止一直循環
class Foo:
    def __init__(self,n):
        self.n=n
    def __iter__(self):
        return self
    def __next__(self):
        if self.n==12:
            raise StopIteration('停止')
        self.n+=1
        return self.n
f1=Foo(1)
print(f1.__next__())
for i in f1:  #for其實就是f1實現__iter__方法，迭代器，實際就是iter(f1)——》f1.__iter__
    print(i)

結果：2----12

利用迭代器實現的裴波那契序列：
class Fib:
    def __init__(self):
        self._a=1
        self._b=1
    def __iter__(self):
        return self
    def __next__(self):
        if self._a>100:
            raise StopIteration('停了')
        self._a,self._b=self._b,self._a+self._b
        return self._a
f1=Fib()
print(f1.__next__())
for i in f1:
    print(i)

結果：1----114