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

　　可以看到使用这个方法之后，对象就能添加括号直接进行执行了。