面向物件：

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

　　類變數：在整個例項化的物件中是公用的。類變數 定義在類中且在函式體之外。

　　例項變數：在類的宣告中，屬性是用變數來表示的。這種變數被稱為例項變數。

　　例項化：建立一個類的例項，類的具體物件。

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)