[Python] 面向对象(一)

引例

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类的内部定义的，这些数据和逻辑都被“封装”了起来

通过在实例上调用方法，我们就直接操作了对象内部的数据，无需知道方法内部的实现细节

这就是面向对象编程的一个重要特点：数据封装

使用对象的好处

1.封装，对外部隐藏有关对象工作原理的细节

2.继承，可基于通用类创建出专用类

3.多态，可对不同类型的对象执行相同的操作

面向对象三大特性：封装，继承，多态

从前面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()