面向对象是什么我就不说了，直接上要点。

类与实例

在Python中如何定义类与创建类的实例？又如何指定构造函数呢？如下：

# class后面紧接着是类名，即Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，继承的概念我们后面再讲，
# 通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。
class Person(object):
    name = ''
    score = 0

    # 由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，
    # 在创建实例的时候，就把name，score等属性绑上去,这个也就类似java的构造函数
    def __init__(self, name, score):
        self.name = name
        self.score = score


# 创建实例是通过类名+()实现的
p = Person('张三',18)

# 变量p指向的就是一个Person的实例，后面的0x000000000210CEB8是内存地址
print(p)
# Person本身则是一个类
print(Person)
# 给实例p绑定一个name属性
p.name = '李四'
print(p.name,p.score)

注意：特殊方法“init”前后分别有两个下划线！！！

注意到init方法的第一个参数永远是self，表示创建的实例本身，因此，在init方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。
有了init方法，在创建实例的时候，就不能传入空的参数了，必须传入与init方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去。

和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。

访问限制

这里就说说对象是如何进行封装的，如何限定变量访问的，如何提供外部接口访问类中的变量的。

class Student(object):

    # 如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，
    # 就变成了一个私有变量（private），只有内部可以访问，外部不能访问
    def __init__(self, name, score):
        self.__name = name
        self.__score = score

    # 下面定义变量的get方法来获取私有变量的值
    def get_name(self):
        return self.__name

    def get_score(self):
        return self.__score

    # 通过set方法来设置私有变量的值
    def set_score(self, score):
        self.__score = score

    def set_name(self,name):
        self.__name = name

    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))

# 这个时候student就不能调用student.__name来访问了，要不然会报错的。
student = Student('张三',100)
# 可以通过get方法来获取私有变量
student.print_score()
# 通过set方法来改变私有变量的值
student.set_name('李白')
student.set_score(120)
student.print_score()

# 注意以下写法：表面上看，外部代码“成功”地设置了__name变量，但实际上这个__name变量和class内部的__name变量不是一个变量！
# 内部的__name变量已经被Python解释器自动改成了_Student__name，而外部代码给bart新增了一个__name变量。
student._name = 'sss'
print(student._name)
print(student.get_name())

# 结果
张三: 100
李白: 120
sss
李白

需要注意的是，在Python中，变量名类似xxx的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用name、score这样的变量名。

有些时候，你会看到以一个下划线开头的实例变量名，比如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。

双下划线开头的实例变量是不是一定不能从外部访问呢？其实也不是。不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name，所以，仍然可以通过_Student__name来访问__name变量：

# 但是强烈建议你不要这么干，因为不同版本的Python解释器可能会把__name改成不同的变量名。
student._Student__name

总的来说就是，Python本身没有任何机制阻止你干坏事，一切全靠自觉。

继承和多态

继承

在Python中如何继承？其实在如何定义类的时候说到过，看如下代码：

class Father():
    def hair(self):
        print('我的头发是黑色')

class Son(Father):
    def hair(self):
        print('我的是白色')

Son().hair()

上面，son继承了father类。这就是继承。

多态

首先说说为啥有多态吧，首先必须要有继承，才会有多态，上面的Son继承了Father类，并且覆盖改变了hair方法，这就体现了Son是多态，表现一个类的多种不同形态。其实多态也体现了“开闭”的设计原则：

对扩展开放：允许新增Animal子类；
对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。

看看下面示例，体现多态的好处了：

class Father():
    def hair(self):
        print('我的头发是黑色')

class Mother():
    def hair(self):
        print('我的头发是黄色')

class Son(Father):
    def hair(self):
        print('我的是白色')

class Daughter(Father):
    def hair(self):
        print('我的是红色')


def testHair(father):
    father.hair()

testHair(Son())
testHair(Daughter())
# 下面的代码有意思，体现了什么是“file-like object“的概念
testHair(Mother())

多态的好处就是，当我们需要传入Son、Daughter……时，我们只需要接收Father类型就可以了，因为Son、Daughter……都是Father类型，然后，按照Father类型进行操作即可。由于Father类型有hair()方法，因此，传入的任意类型，只要是Father类或者子类，就会自动调用实际类型的hair方法，这就是多态的意思：

对于一个变量，我们只需要知道它是Father类型，无需确切地知道它的子类型，就可以放心地调用hair()方法，而具体调用的hair()方法是作用在Father、Son、Daughter对象上，由运行时该对象的确切类型决定，这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种Father的子类时，只要确保hair()方法编写正确，不用管原来的代码是如何调用的。

注意到上面的这段代码：

def testHair(father):
    father.hair()

其中的参数是个变量father，这个变量没有明确的指定是Father对象，只是需要满足有一个hair()函数就可以。这个和Java相比就有很大的差距了，这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。

判断对象类型

对于普通对象如何判断类型？那么对于继承class对象又如何判断类型？看如下示例：

import types

def fn():
    pass

# 判断基本类型,返回对应的类型
print(type(1) == int)
# 判断引用类型
print(type('123') == str)
# 判断对象是否是函数，可以使用types模块中定义的常量
# 判断是否是sys内的函数
print(type(abs) == types.BuiltinFunctionType)
# 判断是否是自定义函数
print(type(fn) == types.FunctionType)
# 判断是否是匿名函数
print(type(lambda x: x) == types.LambdaType)
# 判断是否是生成器
print(type(x for x in range(10)) == types.GeneratorType)

class A(object):
    pass

class B(A):
    pass

class C(B):
    pass

# 对于class的继承关系来说，使用type()就很不方便。我们要判断class的类型，可以使用isinstance()函数。
a = A()
b = B()
c = C()

print(isinstance(b,A))
print(isinstance(c,B))
print(isinstance(c,A))
# b 就不是C类型了
print(isinstance(b,C))

# 还可以判断一个变量是否是某些类型中的一种，比如下面的代码就可以判断是否是list或者tuple，dict：
print(isinstance([1, 2, 3], (list, tuple)))
print(isinstance((1, 2, 3), (list, tuple)))
print(isinstance({'a':1,'b':2}, (list, tuple)))

总是优先使用isinstance()判断类型，可以将指定类型及其子类“一网打尽”。

如何获取对象信息

下面演示如何获取对象所有方法，属性：

# 如果要获得一个对象的所有属性和方法，可以使用dir()函数，它返回一个包含字符串的list，比如，获得一个str对象的所有属性和方法
print(dir('A'))
# 类似__xxx__的属性和方法在Python中都是有特殊用途的，比如__len__方法返回长度。在Python中，如果你调用len()函数试图获取一个对象的长度，
# 实际上，在len()函数内部，它自动去调用该对象的__len__()方法，所以，下面的代码是等价的
print('A'.__len__())
print(len('A'))


# 我们自己写的类，如果也想用len(myObj)的话，就自己写一个__len__()方法
class A(object):
    def __init__(self):
        self.x = 9
        self.y = 10

    def __len__(self):
        return 10000

    def add(self):
        return self.x * self.y


print(A().__len__())

# 配合getattr()、setattr()以及hasattr()，我们可以直接操作一个对象的状态：
a = A()
# 有属性'x'吗？
print(hasattr(a, 'x'))
# 设置一个属性'y'
setattr(a, 'y', 20)
print(getattr(a, 'y'))
# 可以传入一个default参数，如果属性不存在，就返回默认值：
print(getattr(a, 'z', 404))
# 获取对象的方法
print(hasattr(a, 'add'))
# 获取属性'add'并赋值到变量fn, 调用fn()与调用a.add()是一样的
fn = getattr(a, 'add')
print(fn())

实例属性和类属性

由于Python是动态语言，根据类创建的实例可以任意绑定属性，也可以直接在class中定义属性，这种属性是类属性，归Student类所有，需要注意的是：

在编写程序的时候，千万不要对实例属性和类属性使用相同的名字，因为相同名称的实例属性将屏蔽掉类属性，但是当你删除实例属性后，再使用相同的名称，访问到的将是类属性。

class A(object):
    # 这种属性是类属性，归A类所有
    name = "123"

    def __init__(self, a):
        self.a = a

# 给实例绑定属性的方法是通过实例变量，或者通过self变量
a = A('a')
a.c = "你好"
print(a.c)
# 打印name属性，因为实例并没有name属性，所以会继续查找class的name属性
print(a.name)
# 打印类的name属性
print(A.name)
# 给实例绑定name属性
a.name = '李四'
# 由于实例属性优先级比类属性高，因此，它会屏蔽掉类的name属性
print(a.name)
# 但是类属性并未消失，用Student.name仍然可以访问
print(A.name)
# 如果删除实例的name属性,再次调用s.name，由于实例的name属性没有找到，类的name属性就显示出来了
del a.name
print(a.name)

# 结果
你好
123
123
李四
123
123

实例属性属于各个实例所有，互不干扰；
类属性属于类所有，所有实例共享一个属性；
不要对实例属性和类属性使用相同的名字，否则将产生难以发现的错误。