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