一、类与实例
面向对象的设计思想是抽象出Class,根据Class创建Instance。
classStudent(object):def __init__(self, name, score):
self.name=name
self.score=scoredefprint_score(self):print('%s: %s' % (self.name, self.score))
__init__下是类的属性,print_score()是类的方法,self指向创建的实例本身。在创建实例的时候,self不需要传,Python解释器自己会把实例变量传进去。
二、访问限制
在Class内部,可以有属性和方法,而外部代码可以通过直接调用实例变量的方法来操作数据,这样,就隐藏了内部的复杂逻辑。
但是,从前面Student类的定义来看,外部代码还是可以自由地修改一个实例的name、score属性。
如果要让内部属性不被外部访问,可以把属性的名称前加上两个下划线__,在Python中,实例的变量名如果以__开头,就变成了一个私有变量(private),只有内部可以访问,外部不能访问,所以,我们把Student类改一改:
classStudent(object):def __init__(self, name, score):
self.__name =name
self.__score =scoredefprint_score(self):print('%s: %s' % (self.__name, self.__score))
改完后,对于外部代码来说,没什么变动,但是已经无法从外部访问实例变量.__name和实例变量.__score了。
但是如果外部代码要获取name和score,要允许外部代码修改score,就在Student类下增加获取与修改的代码。
classStudent(object):
...defget_name(self):return self.__name
defget_score(self):return self.__score
defset_score(self, score):if 0 <= score <= 100:
self.__score =scoreelse:raise ValueError('bad score')
你也许会问,原先那种直接通过bart.score = 99也可以修改啊,为什么要定义一个方法大费周折?因为在方法中,可以对参数做检查,避免传入无效的参数。
需要注意的是,在Python中,变量名类似__xxx__的,也就是以双下划线开头,并且以双下划线结尾的,是特殊变量,特殊变量是可以直接访问的,不是private变量,所以,不能用__name__、__score__这样的变量名。
有些时候,你会看到以一个下划线开头的实例变量名,比如_name,这样的实例变量外部是可以访问的,但是,按照约定俗成的规定,当你看到这样的变量时,意思就是,“虽然我可以被访问,但是,请把我视为私有变量,不要随意访问”。
双下划线开头的实例变量是不是一定不能从外部访问呢?其实也不是。不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name,所以,仍然可以通过_Student__name来访问__name变量:
但是强烈建议你不要这么干,因为不同版本的Python解释器可能会把__name改成不同的变量名。
注意下面这种错误写法:
classStudent():def __init__(self, name, score):
self.__name =name
self.__score =scoredefprint_score(self):print('%s: %s' %(self.__name, self.__score))defget_name(self):return self.__name
defget_score(self):return self.__score
defset_score(self,score):if 0 <= score <= 100:
self.__score =scoreelse:raise ValueError('bad score')
bart= Student('simon',59)print(bart.get_name)print(bart.get_name())
bart.__name = 'peter'
print(bart.__name)#创建了一个新的__name变量
print(bart.get_name())
Output:
>simon
peter
simon
表面上看,外部代码“成功”地设置了__name变量,但实际上这个__name变量和class内部的__name变量不是一个变量!内部的__name变量已经被Python解释器自动改成了_Student__name,而外部代码给bart新增了一个__name变量。
三、继承和多态
在OOP程序设计中,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类(Subclass),而被继承的class称为基类、父类或超类(Base class、Super class)。
classAnimal():defrun(self):print('Animal is running...')classDog(Animal):defrun(self):print('Dog is running...')classCat(Animal):defrun(self):print('Cat is running...')
dog=Dog()
dog.run()
cat=Cat()
cat.run()
Output:
Dog isrunning...
Catis running...
继承可以把父类的所有功能都直接拿过来,这样就不必重零做起,子类只需要新增自己特有的方法,也可以把父类不适合的方法覆盖重写。
当我们定义一个class的时候,我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型,比如str、list、dict没什么两样。
在继承关系中,如果一个实例的数据类型是某个子类,那它的数据类型也可以被看做是父类。但是,反过来就不行。
多态的好处:
classAnimal():defrun(self):print('Animal is running...')classDog(Animal):defrun(self):print('Dog is running...')classCat(Animal):defrun(self):print('Cat is running...')defrun_twice(animal):
animal.run()
animal.run()
run_twice(Animal())
run_twice(Cat())
run_twice(Dog())
Output:
Animal isrunning...
Animalisrunning...
Catisrunning...
Catisrunning...
Dogisrunning...
Dogis running...
你会发现,新增一个Animal的子类,不必对run_twice()做任何修改,实际上,任何依赖Animal作为参数的函数或者方法都可以不加修改地正常运行,原因就在于多态。
多态的好处就是,当我们需要传入Dog、Cat、Tortoise……时,我们只需要接收Animal类型就可以了,因为Dog、Cat、Tortoise……都是Animal类型,然后,按照Animal类型进行操作即可。由于Animal类型有run()方法,因此,传入的任意类型,只要是Animal类或者子类,就会自动调用实际类型的run()方法,这就是多态的意思:
对于一个变量,我们只需要知道它是Animal类型,无需确切地知道它的子类型,就可以放心地调用run()方法,而具体调用的run()方法是作用在Animal、Dog、Cat还是Tortoise对象上,由运行时该对象的确切类型决定,这就是多态真正的威力:调用方只管调用,不管细节,而当我们新增一种Animal的子类时,只要确保run()方法编写正确,不用管原来的代码是如何调用的。这就是著名的“开闭”原则:
对扩展开放:允许新增Animal子类;
对修改封闭:不需要修改依赖Animal类型的run_twice()等函数。
静态语言 vs 动态语言
对于静态语言(例如Java)来说,如果需要传入Animal类型,则传入的对象必须是Animal类型或者它的子类,否则,将无法调用run()方法。
对于Python这样的动态语言来说,则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了:
classAnimal():defrun(self):print('Animal is running...')classDog(Animal):defrun(self):print('Dog is running...')classCat(Animal):defrun(self):print('Cat is running...')classTimer(object):defrun(self):print('Start...')defrun_twice(animal):
animal.run()
animal.run()
run_twice(Animal())
run_twice(Cat())
run_twice(Dog())
run_twice(Timer())
Output:
Animal isrunning...
Animalisrunning...
Catisrunning...
Catisrunning...
Dogisrunning...
Dogisrunning...
Start...
Start...
这就是动态语言的“鸭子类型”,它并不要求严格的继承体系,一个对象只要“看起来像鸭子,走起路来像鸭子”,那它就可以被看做是鸭子。
动态语言的鸭子类型特点决定了继承不像静态语言那样是必须的。
四、获取对象信息
type()
isinstance(对象,类型)
总是优先使用isinstance()判断类型,可以将指定类型及其子类“一网打尽”。
使用dir()
如果要获得一个对象的所有属性和方法,可以使用dir()函数,它返回一个包含字符串的list,比如,获得一个str对象的所有属性和方法:
dir('123')----------------------------------------Output:
['__add__','__class__','__contains__','__delattr__','__dir__','__doc__','__eq__','__format__','__ge__','__getattribute__','__getitem__','__getnewargs__','__gt__','__hash__','__init__','__init_subclass__','__iter__','__le__','__len__','__lt__','__mod__','__mul__','__ne__','__new__','__reduce__','__reduce_ex__','__repr__','__rmod__','__rmul__','__setattr__','__sizeof__','__str__','__subclasshook__','capitalize','casefold','center','count','encode','endswith','expandtabs','find','format','format_map','index','isalnum','isalpha','isdecimal','isdigit','isidentifier','islower','isnumeric','isprintable','isspace','istitle','isupper','join','ljust','lower','lstrip','maketrans','partition','replace','rfind','rindex','rjust','rpartition','rsplit','rstrip','split','splitlines','startswith','strip','swapcase','title','translate','upper','zfill']
内置函数 getattr() hasattr() setattr()可以直接操作一个对象的状态(包括对象的属性和方法)。
五、实例属性和类属性
实例属性属于各个实例所有,互不干扰;
类属性属于类所有,所有实例共享一个属性;
不要对实例属性和类属性使用相同的名字,由于实例属性优先级比类属性高,因此,它会屏蔽掉类的同名属性。也就是python在寻找属性的时候,会先从实例中找,在实例中找不到才会从实例所属的类中找。