class Point(object):

    def __init__(self,name,score):

        self.__name = name

        self.__score = score

    def print_data(self):

        print('name:%s score:%s' % (self.__name,self.__score))

    def get_grade(self):

        if self.__score >= 90:

            return 'A'

        elif self.__score >= 60 and self.__score < 90:

            return 'B'

        else:

            return 'C'

    def get_name(self):

        return self.__name

    def get_score(self):

        return self.__score

    def set_name(self,name):

        self.__name = name

    def set_score(self,score):

        self.__score = score

    def run(self):

        print('Point')

p1 = Point('傻狗1',30)

p1.print_data()

print(p1.get_grade())

#print(p1.__name)#无法从外部访问实例变量.__name和实例变量.__score，确保了外部代码不能随意修改对象内部的状态

print(p1.get_name())#外部代码要获取name和score，给Ponit类增加get_name和get_score

p1.set_score(300)#允许外部代码修改score

print(p1.get_score())

#变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用__name__、__score__这样的变量名

#_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”

class PointExtend(Point):

    def run(self):#可以对子类增加一些方法

        print('PointExtend')

p2 = PointExtend('子类1',30)

print(p2.get_grade())

#p1.run()

#p2.run()#当子类和父类都存在相同的run()方法时，我们说，子类的run()覆盖了父类的run()，在代码运行的时候，总是会调用子类的run()

#理解什么是多态，我们首先要对数据类型再作一点说明。当我们定义一个class的时候，我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型，比如str、list、dict没什么两样

#a = list() # a是list类型

#b = Point() # b是Point类型

#c = PointExtend() # c是PointExtend类型

#isinstance(a, list) True

#isinstance(b, Point) True

#isinstance(c, PointExtend) True

#对于一个变量，我们只需要知道它是Point类型，无需确切地知道它的子类型，就可以放心地调用run()方法

def run_twice(point):

    point.run()

run_twice(p1)#Point

run_twice(p2)#PointExtend

#新增一种Point的子类时，只要确保run()方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则

#对扩展开放：允许新增Point子类；

#对修改封闭：不需要修改依赖Point类型的run_twice()等函数。

#对于静态语言（例如Java）来说，如果需要传入Point类型，则传入的对象必须是Point类型或者它的子类，否则，将无法调用run()方法。

#对于Python这样的动态语言来说，则不一定需要传入Point类型。我们只需要保证传入的对象有一个run()方法就可以了

class NoPoint(object):

    def run(self):

        print('NoPoint')

p3 = NoPoint()

run_twice(p3)#NoPoint

#这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子