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))
# 创建对象实例
andy = Student('Andy', 90)
summer = Student('Summer', 87)
# 调用对象的方法
# Andy: 90
andy.print_score()
# Summer: 87
summer.print_score()
类(Class)是一种抽象概念,比如上述定义的class Student,是指学生这个概念,而实例(Instance)则是一个个具体的Student,比如Abdy和Summer是两个具体的Student
类(Class)是创建实例的模板,而实例(Instance)则是一个个具体的对象,各个实例拥有的数据都互相独立,互不影响
面向对象的设计思想是抽象出Class,根据Class创建Instance
在Python中,定义类是通过class关键字进行定义的,class后面紧接着是类名(类名通常是大写开头的单词),紧接着是(object),表示该类是从哪个类继承下来的,通常如果没有合适的继承类,就使用object类,这是所有类最终都会继承的类
# 创建一个Student类
class Student(object):
pass
创建实例是通过类名()实现的
andy = Student()
# <__main__.Student at 0x182b89efcf8>
andy
可以看到,变量andy指向的就是一个Student类的实例,后面的0x182b89efcf8是内存地址
可以给一个实例变量绑定属性,比如给实例andy绑定name属性和score属性
andy.name = "Andy"
andy.score = 90
# 'Andy'
andy.name
# 90
andy.score
由于类可以起到模板的作用,因此可以在创建实例的时候,把一些我们认为必须绑定的属性强制填写进去
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
通过定义一个特殊的__init__方法,在创建实例的时候,就把name,score等属性绑定上去
__init__方法的第一个参数永远是self,表示创建的实例本身,可以把各种属性绑定到self上
有了__init__方法后,在创建实例的时候,就不能传入空的参数了,必须传入与__init__方法匹配的参数,但self不需要传,Python解释器自己会把实例变量传进去
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
# 报错
# TypeError: __init__() missing 2 required positional arguments: 'name' and 'score'
andy = Student()
summer = Student('Summer',87)
# 'Summer'
summer.name
# 87
summer.score
提示Tips
1.特殊方法"__init__"前后分别有两个下划线
2.在类中定义的函数,第一个参数永远self,并且调用时,不用传递该参数
直接在Student类的内部定义访问数据的函数,这些封装数据的函数是和Student类本身是关联起来的,我们称之为类的方法
方法就是与实例绑定的函数,和普通函数不同,方法可以直接访问实例的数据
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))
要调用一个方法,只需要在实例变量上直接调用,除了self不用传递,其他参数正常传入
andy = Student('Andy',90)
# 实例变量.方法
# Andy: 90
andy.print_score()
这样一来,我们从外部看Student类,就只需要知道创建实例需要给出name和score,而如何打印成绩(print_score),都是在Student类的内部定义的,这些数据和逻辑都被“封装”了起来
通过在实例上调用方法,我们就直接操作了对象内部的数据,无需知道方法内部的实现细节
这就是面向对象编程的一个重要特点:数据封装
面向对象三大特性:封装,继承,多态
从前面Student类的定义来看,外部代码还是可以自由地修改一个实例的name、score属性
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))
andy = Student('Andy',90)
# 90
andy.score
# 修改实例变量的score值
andy.score = 100
# 100
andy.score
如果要让内部属性不被外部访问,可以把属性的名称前加上两个下划线__,这样该属性就变成了一个私有变量(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))
andy = Student('Andy',90)
# 报错
# AttributeError: 'Student' object has no attribute '__name'
andy.__name
# AttributeError: 'Student' object has no attribute '__score'
andy.__score
可以看出,已经无法从外部访问实例变量.__name和实例变量.__score了,这样就确保了外部代码不能随意修改对象内部的状态,通过访问限制的保护,代码更加健壮
问题1:双下划线开头的实例变量是不是一定不能从外部访问呢?
不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name,所以我们可以通过_Student__name来访问
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))
andy = Student('Andy', 90)
# 'Andy'
andy._Student__name
# 90
andy._Student__score
需要注意在Python中,变量名类似__xxx__的,也就是以双下划线开头,并且以双下划线结尾的变量是特殊变量,特殊变量是可以直接访问的,它不是private变量
问题2:如果外部代码要获取name和score怎么办?
可以给Student类增加get_name和get_score这样的方法
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))
def get_name(self):
return self.__name
def get_score(self):
return self.__score
andy = Student('Andy',90)
# 'Andy'
andy.get_name()
# 90
andy.get_score()
问题3:如果允许外部代码修改score怎么办?
可以再给Student类增加set_score方法
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))
def get_name(self):
return self.__name
def get_score(self):
return self.__score
def set_score(self, score):
if 0 <= score <= 100:
self.__score = score
else:
raise ValueError('bad score')
andy = Student('Andy',90)
# 90
andy.get_score()
andy.set_score(95)
# 95
andy.get_score()
提示Tips
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)) def get_name(self): return self.__name def get_score(self): return self.__score def set_score(self, score): if 0 <= score <= 100: self.__score = score else: raise ValueError('bad score') andy = Student('Andy Simpson', 85) # 'Andy Simpson' andy.get_name() # 设置__name变量 andy.__name = 'New Name' # 'New Name' andy.__name
注意上述的写法是错误的
表面上看,外部代码“成功”地设置了__name变量,但实际上这个__name变量和class内部的__name变量不是一个变量!
内部的__name变量已经被Python解释器自动改成了_Student__name,而外部代码给andy新增了一个__name变量
# get_name()内部返回self.__name # 'Andy Simpson' andy.get_name()