面向對象：

　　類：抽象概念，類型。用來描述具有相同的屬性和方法的對象的集合。定義了該集合中每個對象所共有的屬性和方法，對象是類的實例。

　　類變量：在整個實例化的對象中是公用的。類變量 定義在類中且在函數體之外。

　　實例變量：在類的聲明中，屬性是用變量來表示的。這種變量被稱為實例變量。

　　實例化：創建一個類的實例，類的具體對象。

class Student(object): #類屬性：類名，屬性名。
    count = 0
    def __init__(self,score):#----》構造函數：實例化對象時自動調用的
        #self：當前對象
        self.score = score
        Student.count 
 
+= 1
    #實例方法
    def setName(self,name):
        if 1<len(name)<32:
            self.name = name
            return  True
         else:
            reeturn False

#實例化對象
s1 = Student()
#訪問對象的屬性
print(s1.score)
s1.name = ‘ssss‘
print(s1.name)

def __del__(self): #析構方法：對象銷毀時自動調用。
    print(‘
 
..........‘)　　

#私有方法
def __privateFun(self):
    print(‘........‘)
# 私有屬性---》解釋器做了名字的修改
print(s1.__Student__score)

#私有方法
s1.__Student__prinvate

繼承：

　　1，如果在子類中需要父類的構造方法就需要顯示的調用父類的構造方法，或者重寫父類的構造方法

　　2，在調用基類的方法時，需要加上父類的類名前綴，且需要帶上self參數變量。

　　3，python總是首先查找對應類型的方法，如果不能在派生類中找到對應的方法，他才開始到基類中逐個查找。

class
 
 Animal(object):
    def __init__(self,name,age=1,color=‘yellow‘):
        self.name = name
        self.age = age
        self.__color = color #_Animal__color
    def show(self):
        print(self.name,self.age,self.__color)

class Dog(Animal):
    def __init__(self,name,age,breed):
        #調用父類方法
        #Animal.__init__(self,name,age)
        #super().__init__(name,age)
        super().__init__(name,age)
        self.breed = breed
    
    def show(self):
        Animal.show(self)
        print(‘.......‘)

animal = Animal（‘22’）
animal.show()#調用父類方法
d1 = Dog(‘.......‘)
d1.show()#調用子類
# 子類中不能直接訪問繼承的私有屬性。

多繼承：

　　python 支持，但不建議使用

class A(object):
    def run(self):
        print(‘run A run‘)

class B(A):
    def run(self):
        super().run()
        print(‘run B run‘)

class C(A):
    def run(self):
        super().run()
        print(‘run C run‘)

class D(B, C):
    pass


c = C()
c.run()
# 獲取類或者對象的方法和屬性
print(dir(C))
# 獲取類的繼承順序
print(C.__mro__)

d = D()
d.run()
print(D.__mro__)

多態

class Animal(object):
    def run(self):
        print(‘animal is running‘)


class Dog(Animal):
    def run(self):
        print(‘Dog run fast‘)


class Rabbit(Animal):
    def run(self):
        print(‘Rabbit jump...‘)

class Cat(Animal):
    pass

class Timer(object):
    def run(self):
        print(‘the time is running‘)


# 多態：同一種類型，不同的表現形式
def runTwice(animal):
    animal.run()
    animal.run()

a = Animal()
rabbit = Rabbit()

runTwice(a)
runTwice(rabbit)

# 鴨子類型
tm = Timer()
runTwice(tm)

限制實例 屬性

class Person(object)
    __slots__ = (‘name‘,‘age‘)#只允許有‘name’ ‘age’屬性
per1 = Person()
per1.name = ‘....‘
print(per1.name)
per1.height = .... #不允許

class Student(object):
    def __init__(self,age):
        if 0<=score<=100:
            self.__score=score
            return ‘ok‘
        else:
            return ‘error‘
    def getScore(self):
        return self.__score

    @property#訪問器，可以單獨存在
    def score(self):
        print(‘getter is called‘)
        return self.__score
    @score.setter #設置器，不單獨存在，一定要有property
    def score(self,score):
        print(‘setter is called‘)
        if 0 <=score<=100:
            self.__score = score
            return ‘ok‘
        else:
            return ‘error‘
    @ property
    def age(self):
        return self.__age
s1 = Student(20)
‘‘‘
if s1.setScore(10) == ‘ok‘: # s1.score= 100
    print(s1.getScore())
‘‘‘
s1.score = 100
print(s1.score)
print(s1.age)

設置器與訪問器的作用：

　　1，隱藏了實例變量

　　2，控制實例變量的讀寫

　　3，做正確性檢驗。

python魔法方法

class Student(object):
    def __init__(self,name = ‘python‘):
        ‘‘‘創建類和屬性時自動調用‘‘‘
        self.__name = name
    def __str__(self):
        ‘‘‘打印本類對象時，自動調用‘‘‘
        return ‘........‘
    def __repr__(self):
        ‘‘‘在解釋器環境下直接輸出本對象，自動調用的方法‘‘‘
    return self.__str__()
    def __len__(self):
        ‘‘‘調用len函數的時候自動調用的方法‘‘‘
        return 100
    def__call__(self):
        ‘‘‘調用本類對象的時候自動調用的方法‘‘‘
        print(‘Student object name:%s‘ %self.__name)

print(dir(Student))
s = Student()
print(len(s))
s()

類名.__mro__#類的繼承順序

__dir__(類名或對象)#查看所有方法和屬性

另一種構建類的方法，是先構建元類，以元類為模板構建類
class ListMetaclass(type):
    def __new__(cls, name, bases, attrs):
        ‘‘‘類方法‘‘‘
        attrs[‘add‘] = lambda self, value : self.append(value)
        return type.__new__(cls, name, bases, attrs)

class Mylist(list, metaclass=ListMetaclass):
    pass

l = Mylist()
print(type(l))
l.add(1)
l.add(‘hello‘)
print(l)

面向對象筆記。