Python基础（类和实例）

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