python3.x 類和對象

　　python同樣支持類和對象。在python3.x中沒有了經典類，只有新式類，默認創建的就是新式類。具體的新式類與經典類的不同在python3.x中已經沒有意義了。

　　類的定義和實例化

　　python定義簡單類如下。

class Car(object):
    pass

c1=Car()

　　我們定義了一個Car類，其中什么方法也沒有實現。c1是我們實例化的類Car，成為對象。

　　靜態變量

　　我們可以在類中定義靜態變量，靜態變量屬於類，既可以使用類訪問，也可以使用對象訪問。

class Car(object):
    type='car'

c1=Car()
print(c1.type)
print(Car.type)

　　運行結果是：

car
car

　　動態變量

　　動態變量屬於類，在第一次創建類的時候傳入類中。動態變量只屬於對象，只能由對象訪問。

class Car(object):
    type='car'

    def __init__(self, name, colour):
        self.name = name
        self.colour = colour
        print('我被創建了。')

c1=Car('Lamborghini','yellow')
print(c1.type)
print(Car.type)
print('name:%s,colour:%s'%(c1.name,c1.colour))

　　運行結果是：

我被創建了。
car
car
name:Lamborghini,colour:yellow

　　類被創建的時候就會訪問__init__()方法，上面的類__init__方法中請求了兩個參數，所以創建的時候就必須要傳入兩個傳輸，其中self的意思是對象本身，以本例來說，當創建Car的實例c1時，self就是c1。

　　因為作用域的原因，傳入的兩個參數只能在__init__()中使用，如果想要在其它地方調用，就需要將值傳給self。而這個參數就被稱為動態參數。

　　動態方法

　　類的動態方法是自定義的方法，同時只有對象能夠調用。

class Car(object):
    type='car'

    def __init__(self, name, colour):
        self.name = name
        self.colour = colour
        print('我被創建了。')
    def show(self):
        print("The car's name is %s and colour is %s." % (self.name, self.colour))
        
c1=Car('Lamborghini','yellow')
print(c1.type)
print(Car.type)
print('name:%s,colour:%s'%(c1.name,c1.colour))
c1.show()

　　運行結果是：

我被創建了。
car
car
name:Lamborghini,colour:yellow
The car's name is Lamborghini and colour is yellow.

　　show()就是類的動態方法。

　　靜態方法

　　有動態方法必然會有靜態方法。靜態方法屬於類，類和對象都可以進行調用。

class Car(object):
    @staticmethod
    def description():
        print('This is a very fast car.')

c1=Car()
c1.description()
Car.description()

　　靜態方法的寫法就是在動態方法前加入裝飾器，並且不傳入self參數。

　　類的屬性

　　在方法前面加入@property裝飾器，這個方法就變成了類的屬性，可以以調用屬性的方式進行方法的調用。

class Car(object):
    def __init__(self, name, colour):
        self.name = name
        self.colour = colour
    @property
    def show(self):
        print("The car's name is %s and colour is %s." % (self.name, self.colour))

c1=Car('Lamborghini','yellow')
c1.show

　　運行結果是：

The car's name is Lamborghini and colour is yellow.

　　可見，運行的時候不需要添加括號。

　　私有變量

　　在變量前面加入兩個下划線就將這個變量變為了私有變量，創建的對象沒有變法訪問私有變量，私有變量只能內部訪問。那么私有變量怎么顯示呢？

class Car(object):
    def __init__(self, name, colour):
        self.__name = name
        self.__colour = colour
    def show(self):
        print("The car's name is %s and colour is %s." % (self.__name, self.__colour))

c1=Car('Lamborghini','yellow')
c1.show()

　　運行結果是：

The car's name is Lamborghini and colour is yellow.

　　私有變量能在類內部定義方法進行讀取。

　　利用類的特性也可以訪問私有字段。

lass Car(object):
    def __init__(self, name, colour):
        self.__name = name
        self.__colour = colour
    def show(self):
        print("The car's name is %s and colour is %s." % (self.__name, self.__colour))
    @property
    def name(self):
        return self.__name

c1=Car('Lamborghini','yellow')
c1.show()
print(c1.name)

　　運行結果是：

The car's name is Lamborghini and colour is yellow.
Lamborghini

　　通過設定和私有字段相似的名稱的特性名稱，從程序外部看來就好像是訪問了私有字段一樣，這種方法也是可以訪問私有字段的。

　　私有方法

　　將方法前面加上兩個下划線就會變成私有方法，外部就無法訪問這個方法了。而如果要訪問這個方法只能在類的內部才可以訪問。

class Car(object):
    def __init__(self, name, colour):
        self.__name = name
        self.__colour = colour
    def __show(self):
        print("The car's name is %s and colour is %s." % (self.__name, self.__colour))
    def func(self):
        self.__show()

c1=Car('Lamborghini','yellow')
c1.func()

　　運行結果是：

The car's name is Lamborghini and colour is yellow.

　　私有方法也可以使用以下方法進行調用，但是並不建議這樣使用。

class Car(object):
    def __init__(self, name, colour):
        self.__name = name
        self.__colour = colour
    def __show(self):
        print("The car's name is %s and colour is %s." % (self.__name, self.__colour))
    def func(self):
        self.__show()

c1=Car('Lamborghini','yellow')
c1._Car__show()

　　運行結果是：

The car's name is Lamborghini and colour is yellow.

　　私有變量更改

　　如果我們必須更改私有變量呢？其實也是有辦法的，可以使用以下的方法。

class Car(object):
    def __init__(self, name, colour):
        self.__name = name
        self.__colour = colour
    def show(self):
        print("The car's name is %s and colour is %s." % (self.__name, self.__colour))
    @property
    def func(self):
        return self.__name
    @func.setter
    def func(self,value):
        self.__name=value

c1=Car('Lamborghini','yellow')
c1.show()
c1.func='car'
c1.show()

　　運行結果是：

The car's name is Lamborghini and colour is yellow.
The car's name is car and colour is yellow.

　　這樣就實現了私有變量的更改的操作

　　析構函數

　　__init__()在對象被創建的時候進行調用，成為構造函數。而對象被銷毀的時候就會調用__del__()函數，成為析構函數。

class Car(object):
    def __init__(self):
        print('我被創建了')
    def __del__(self):
        print('我要被銷毀了')

c1=Car()

　　運行結果是：

我被創建了
我要被銷毀了

　　__call__方法

　　python中也有一個方法叫做__call__()，這個方法是干什么用的呢？當對象作為一個函數進行執行的時候，就會執行這個方法。

class Car(object):
    def __call__(self, *args, **kwargs):
        print('call')

c1=Car()
c1()

　　運行結果是：

call

　　可以看到使用這個方法之后，對象就能添加括號直接進行執行了。