概念:
面向对象的设计思想是从自然界中来的,因为在自然界中,类(Class)和实例(Instance)的概念是很自然的。Class是一种抽象概念,比如我们定义的Class——Student,是指学生这个概念,而实例(Instance)则是一个个具体的Student,比如,Bart Simpson和Lisa Simpson是两个具体的Student:
所以,面向对象的设计思想是抽象出Class,根据Class创建Instance。
面向对象的抽象程度又比函数要高,因为一个Class既包含数据,又包含操作数据的方法
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
def print_score(self):
print '%s: %s' % (self.name, self.score)
(object)
,表示该类是从哪个类继承下来的,object
类,这是所有类最终都会继承的类
__init__
方法,在创建实例的时候,就把name
,score
等属性绑上去:
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
注意到__init__
方法的第一个参数永远是self
,表示创建的实例本身,因此,在__init__
方法内部,就可以把各种属性绑定到self
,因为self
就指向创建的实例本身。
有了__init__
方法,在创建实例的时候,就不能传入空的参数了,必须传入与__init__
方法匹配的参数
bart = Student('Bart Simpson', 59)
数据封装
面向对象编程的一个重要特点就是数据封装。在上面的Student
类中,每个实例就拥有各自的name
和score
这些数据。我们可以通过函数来访问这些数据,比如打印一个学生的成绩:Student
实例本身就拥有这些数据,可以直接在Student
类的内部定义访问数据的函数。
创建实例需要给出name
和score
,而如何打印,都是在Student
类的内部定义的,这些数据和逻辑被“封装”起来了,调用很容易,但却不用知道内部实现的细节。
封装的另一个好处是可以给Student
类增加新的方法,比如get_grade,
可以直接在实例变量上调用,不需要知道内部实现细节
访问限制
在Class内部,可以有属性和方法,而外部代码可以通过直接调用实例变量的方法来操作数据,这样,就隐藏了内部的复杂逻辑。
但是,从前面Student类的定义来看,外部代码还是可以自由地修改一个实例的name
、score
属性,在Python中,实例的变量名如果以__
开头,就变成了一个私有变量(private),只有内部可以访问,外部不能访问
class Student(object):
def __init__(self, name, score):
self.__name = name
self.__score = score
def print_score(self):
print '%s: %s' % (self.__name, self.__score)
此时,
无法从外部访问
实例变量.__name
和
实例变量.__score
get_name
和
get_score
这样的方法,为什么要定义一个方法大费周折?因为在方法中,可以对参数做检查,避免传入无效的参数:
class Student(object):
...
def set_score(self, score):
if 0 <= score <= 100:
self.__score = score
else:
raise ValueError('bad score')
Python解释器对外把__name
变量改成了_Student__name
,所以,仍然可以通过_Student__name
来访问__name
变量:
>>> bart._Student__name
'Bart Simpson'
不同版本的Python解释器可能会把
__name
改成不同的变量名,不建议这样做!!!
继承和多态
继承有什么好处?最大的好处是子类获得了父类的全部功能。由于Animial实现了run()
方法,因此,Dog和Cat作为它的子类,什么事也没干,就自动拥有了run()
方法:
run()
方法时,我们说,子类的run()
覆盖了父类的run()
,在代码运行的时候,总是会调用子类的run()
。这样,我们就获得了继承的另一个好处:多态。
当我们定义一个class的时候,我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型,比如str、list、dict没什么两样:
a = list() # a是list类型
b = Animal() # b是Animal类型
c = Dog() # c是Dog类型
判断一个变量是否是某个类型可以用isinstance()
判断:
>>> isinstance(a, list)
True
>>> isinstance(b, Animal)
True
>>> isinstance(c, Dog)
True
c是dog类,同时也是animal类(Dog继承自animal)
def run_twice(animal):
animal.run()
animal.run()
当一个函数接受animal变量时,比如Animal类中的方法,传入Dog的实例时,会调用dog的方法。类似的,再定义一个新的动物子类cat,以及响应的run()方法,传入cat会自动调用cat
run()
方法,因此,传入的任意类型,只要是Animal类或者子类,就会自动调用实际类型的run()
方法,这就是多态的意思。(新增子类,而不用修改需要传入Animal类型的方法)对扩展开放:允许新增Animal子类; 对修改封闭:不需要修改依赖Animal类型的run_twice()
等函数
小结
继承可以把父类的所有功能都直接拿过来,这样就不必重零做起,子类只需要新增自己特有的方法,也可以把父类不适合的方法覆盖重写;
有了继承,才能有多态。在调用类实例方法的时候,尽量把变量视作父类类型,这样,所有子类类型都可以正常被接收;(就是说传入的参数类型是父类,而不必具体到子类,不用子类的对象会调用各自的方法)
获取对象信息
当我们拿到一个对象的引用时,如何知道这个对象是什么类型、有哪些方法呢?
使用type()
基本类型都可以用type()
判断:
>>> type(123)
<type 'int'>
如果一个变量指向函数或者类,也可以用type()
判断:
>>> type(abs)
<type 'builtin_function_or_method'>
使用isinstance()
判断class的类型isinstance(h, Animal)
能用type()
判断的基本类型也可以用isinstance()
判断,还可以判断一个变量是否是某些类型中的一种
isinstance(u'a', basestring)
使用dir()
如果要获得一个对象的所有属性和方法,可以使用dir()
函数,它返回一个包含字符串的list,比如,获得一个str对象的所有属性和方法
dir('ABC')
__len__
方法返回长度。在Python中,如果你调用len()
函数试图获取一个对象的长度,实际上,在len()
函数内部,它自动去调用该对象的__len__()
方法
我们自己写的类,如果也想用len(myObj)
的话,就自己写一个__len__()
方法:
>>> class MyObject(object):
... def __len__(self):
... return 100
...
>>> obj = MyObject()
>>> len(obj)
100
配合getattr()
、setattr()
以及hasattr()
,我们可以直接操作一个对象的状态
hasattr(obj, 'x') # 有属性'x'吗?
setattr(obj, 'y', 19) # 设置一个属性'y'
getattr(obj, 'y') # 获取属性'y'
小结
通过内置的一系列函数,我们可以对任意一个Python对象进行剖析,拿到其内部的数据。要注意的是,只有在不知道对象信息的时候,我们才会去获取对象信息。如果可以直接写:
sum = obj.x + obj.y
就不要写:
sum = getattr(obj, 'x') + getattr(obj, 'y')