总结自廖雪峰老师的Python教程！实力点赞！教程地址：https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014319117128404c7dd0cf0e3c4d88acc8fe4d2c163625000

1、类和对象

面向对象编程中最重要的概念就是类(class)和对象(instance)。我们首先来定义一个类，如一个动物类：

class Animal():
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight

我们用class关键字定义了一个类，同时通过__init__方法定义了该类的对象所必需绑定的一些属性。注意到__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。接下来，我们可以创建一个Animal的实例，必需传入name和weight两个属性值：

dog = Animal('hasky',90)

这样，我们就可以通过.来获取实例的属性值，同时可以直接通过赋值的方式修改属性值。

print(dog.weight) #90
dog.weight = 100
print(dog.weight) #100

在类中还可以定义方法，比如我们给增加一个打印功能：

class Animal():
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight
    def print_weight(self):
        print("%s : %s" % (self.name,self.weight))

dog = Animal('hasky',90)
dog.print_weight() # hasky : 90

2、访问限制

像刚才我们这种定义属性的方式，属性可以被随意的访问和修改，我们如何避免这种外部的随意访问呢？在java中我们可以通过private来设置变量为私有变量，这样我们只能通过get和set方法来进行访问和修改，其实在python中也是可以这样做的，只需要在变量名前面加上__即可。

class Animal():
    def __init__(self,name,weight):
        self.__name = name
        self.__weight = weight
    def print_weight(self):
        print("%s : %s" % (self.name,self.weight))
    def get_name(self):
        return self.__name
    def get_weight(self):
        return self.__weight
    def set_name(self,name):
        self.__name = name
    def set_weight(self,weight):
        self.__weight = weight

dog = Animal('hasky',90)
print(dog.get_name()) # hasky
print(dog.__name) # AttributeError: 'Animal' object has no attribute '__name'
dog.set_weight(100)
print(dog.get_weight()) # 100
print(dog.__weight) # AttributeError: 'Animal' object has no attribute '__weight'

可以看到，在给变量名前面加上__之后，不能通过.来访问属性或者修改属性了，否则会报AttributeError。

有以下几点需要注意的：
1、需要注意的是，在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用__name__、__score__这样的变量名。
2、有时候变量前有一个下划线，比如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，我们一般将其也视为私有变量，不要随意访问。
3、双下划线开头的实例变量是不是一定不能从外部访问呢？其实也不是。可以看下实例的__dict__:

可以看到，我们原先的属性名称已经被改为_Animal__name。

3、继承和多态

在面向对象编程中，我们都知道一个类可以被其他类继承，这些类被称为子类(Subclass)，子类可以继承父类的所有属性和方法。同时可以给类中增加新的方法或者覆盖父类的方法：

class Animal():
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight
    def print_weight(self):
        print("%s : %s" % (self.name,self.weight))
    def run(self):
        print('Animal is running')

class Dog(Animal):
    def eat(self):
        print('Dog is eating')
class Cat(Animal):
    def run(self):
        print('Cat is running')

dog = Dog('hasky',10)
dog.run() # Animal is running
dog.eat() # Dog is eating
cat = Cat('tt',20)
cat.run() # Cat is running

可以看到，在Animal类的基础上，我们定义了Dog和Cat两个类，Dog中继承了Animal类的name和weight属性，以及run和print_weight方法，同时增加了eat方法。而Cat类则是覆盖了Animal中的run方法。同时，在创建Dog和Cat的实例时，也调用了Animal的__init__方法，所以必须传入这两个值。

如果我们想在Dog中的增加新的属性值怎么办，考虑下面的写法：

class Dog(Animal):
    def __init__(self,height):
        self.height = height
    def eat(self):
        print('Dog is eating')

dog = Dog(20)
dog.name # 'Dog' object has no attribute 'name'

这样我们父类Animal中的两个属性值就没有了，如何在保留着两个属性的基础上增加新的属性呢？需要通过super().__init__()来调用父类的__init__()方法。

class Dog(Animal):
    def __init__(self,name,weight,height):
        super().__init__(name,weight)
        self.height = height
    def eat(self):
        print('Dog is eating')

dog = Dog('hasky',10,20)
dog.name #hasky

有了子类和父类，随之就出现了多态的概念。简单来说，在继承关系中，如果一个实例的数据类型是某个子类，那它的数据类型也可以被看做是父类。但是，反过来就不行，这就是多态。python中，我们可以用isinstance来判断一个实例是否属于某一类。我们来看下面的例子：

class Animal():
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight
    def print_weight(self):
        print("%s : %s" % (self.name,self.weight))
    def run(self):
        print('Animal is running')

class Dog(Animal):
    def eat(self):
        print('Dog is eating')

a = Dog("hasky",90)
b = Animal('tt',10)
print(isinstance(a,Dog))# True
print(isinstance(a,Animal))# True
print(isinstance(b,Animal))# True
print(isinstance(b,Dog))# False

这里我们提一下python这种动态语言和java等动态语言的区别。比如我们设计一个run_twice()函数：

def run_twice(obj):
    obj.run()
    obj.run()

a = Dog("hasky",90)
b = Animal('tt',10)
run_twice(a)
run_twice(b)

在java中，如果需要传入Animal类型，那么传入的实例必须是Animal类型或者它的子类，但是在python中，我们只需要保证传入的实例有run方法就行，比如：

class Timer(object):
    def run(self):
        print('start....')

timer = Timer()
run_twice(timer)
# start....
# start....

4、获取对象信息

如果要获得一个对象的所有属性和方法，可以使用dir()函数，它返回一个包含字符串的list，比如，获得一个str对象的所有属性和方法：

可以看到，有许多前后都带着下划线的方法，在python中，类似__xxx__的属性和方法在Python中都是有特殊用途的，比如__len__方法返回长度。在Python中，如果你调用len()函数试图获取一个对象的长度，实际上，在len()函数内部，它自动去调用该对象的__len__()方法，所以，下面的代码是等价的：

print('ABC'.__len__())
print(len('ABC'))

配合getattr()、setattr()以及hasattr()，我们可以直接操作一个对象的状态：

class Animal():
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight
    def print_weight(self):
        print("%s : %s" % (self.name,self.weight))
    def run(self):
        print('Animal is running')

dog = Animal('hasky',20)
print(hasattr(dog,'name')) # True
setattr(dog,'height',20)
print(getattr(dog,'height'))  # 20

如果获取的属性可能不存在，我们可以添加一个默认值：

print(getattr(dog,'type','dog')) #dog

当然也可以获取方法：

f = getattr(dog,'run')
print(f) # <bound method Animal.run of <__main__.Animal object at 0x104f33cc0>>
f() # Animal is running

5、实例属性和类属性

由于Python是动态语言，根据类创建的实例可以任意绑定属性。给实例绑定属性的方法是通过实例变量，或者通过self变量：

class Animal():
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight
dog = Animal('hasky',90)
dog.height = 20 
print(dog.height) # 20

但是，如果Animal类本身需要绑定一个属性呢？可以直接在class中定义属性，这种属性是类属性，归Animal类所有：

class Animal():
    tt = 'ss'
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight
print(Animal.tt) # ss
dog = Animal('hasky',90) 
print(dog.tt) # ss
dog.tt = 'aa'
print(dog.tt) # aa
print(Animal.tt)# ss

可以看到，我们创建了Animal类的一个类属性tt，所有实例都可以访问该属性，而在编写程序的时候，千万不要对实例属性和类属性使用相同的名字，因为相同名称的实例属性将屏蔽掉类属性，但是当你删除实例属性后，再使用相同的名称，访问到的将是类属性。