Python基础语法篇（三）：类和对象

---

一、类和对象介绍

面向对象的编程中最重要的概念就是类（Class）和实例（ Instance ），必须牢
记类是抽象的模板，而实例是根据类创建出来的 一个个
的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。
类和对象的关系即数据类型与变量（数据）的关系，根据一个类可以创建多个对象，而每个对象只能是某一个类的对象。
类规定了可以用于存储什么数据，而对象用于实际存储数据，每个对象可存储不同的数据。
与C/C++等语言不同，Python中提供的基本数据类型也是类，如int，float等。
类是对具有相同属性和方法的对象的抽象。

二、类的定义和创建实例

类的定义：在python中，是通过class关键字定义类的。在一个类中，除了可以包含前面所说的属性，还可以包含各种方法。
属性对应一个类可以用来保存哪些数据，而方法对应一个类可以支持哪些操作（即数据处理）。
类的定义形式多样：
我们既可以直接创建新的类，也可以基于一个或多个已有的类创建新的类；
我们既可以创建一个空的类，然后再动态添加属性和方法，也可以在创建类的同时设置属性和方法。
注：类中的属性对应变量，类中的方法对应函数。通过类，可以把数据和操作封装在一起，从而使得程序结构更加清晰，这也就是所谓的类的封装性。
定义类时指定类属性：
我们可以在定义类时指定该类的属性，即类属性。对类属性的访问，既可以通过类名访问，也可以通过该类的对象访问。访问方式为：类名或对象名.属性名。

class Student:      #定义Student类
    name = 'Unknown'#定义Student类中有一个name属性
#类属性访问示例
if __name__ == '__main__':
    print('直接通过类名访问Student类属性name：',Student.name)
    stu1 = Student()  #创建Student类对象stu1
    stu2 = Student()  #创建Student类对象stu2
    print('通过类对象访问类属性：stu1:%s,stu1:%s'%(stu1.name,stu2.name))
    Student.name = '未知'  #将Student类的属性name赋为‘未知’
    print('输出Student类的属性name：',Student.name)
    print('通过对象访问name属性：stu1:%s,stu2:%s'%(stu1.name,stu2.name))
    stu1.name = '李晓明'  #将stu1的name属性赋值为李晓明
    stu2.name = '马红'    #将stu2的name属性赋值为马红
    print('再次输出Student类的属性name：',Student.name)
    print('再次通过对象访问类属性：stu1:%s,stu2:%s'%(stu1.name,stu2.name))
    Student.name = '学生' #将Student类的属性name赋为‘学生’
    print('输出Student类的属性name：',Student.name)
    print('再次通过对象访问类属性：stu1:%s,stu2:%s'%(stu1.name,stu2.name)) 

为对象动态绑定新属性：
Python作为一种动态语言，除了可以在定义类时指定类属性外，还可以动态的为已经创建的对象绑定新的属性。
为对象动态绑定新属性示例：

class Student:
    name = 'Unknown' #定义Student类中有一个name属性
if __name__ == '__main__':
    stu1 = Student() #定义Student类对象stu1
    stu2 = Student() #定义Student类对象stu2
    stu1.age = 19 #为对象stu1动态绑定新的属性age
    print('stu1姓名：%s，年龄：%d'%(stu1.name,stu1.age))
    #print('stu2年龄：%d'%stu2.age)   #报错'Student' object has no attribute 'age'
    #print('使用类名访问年龄属性：',Student.age)  #报错：type object 'Student' has no attribute 'age'

四、类中普通方法定义及调用

类中的普通方法实际上就是执行某种数据处理功能的函数。
与普通函数定义一样，类中的方法在定义时也需要使用def关键字。
类中的方法分为两类：普通方法和内置方法。
（1）普通方法需要通过类的实例对象根据方法名调用；
（2）内置方法是在特定情况下由系统自动执行。
在定义类的普通方法时，要求第一个参数需要对应调用方法时所使用的实例对象（一般命名为self，但也可以改为其他名字）
当使用一个实例对象调用类的普通方法时，其语法格式为：实例对象名.方法名(实参列表)

注：在通过类的实例对象调用类中的普通方法时，并不需要传入self参数的值，self会自动对应调用该方法时所使用的对象。

class Student:  #定义Student类
    name = 'Unknown'  #定义Student类中有一个name属性
    def SetName(self,newname): #定义类的普通方法SetName
        self.name = newname #将self对应实例对象中的name属性值赋为newname
    def PrintName(self): #定义类的普通方法PrintName
        print('姓名：%s'%self.name)  #输出self对应实例对象中的name属性值
if __name__ == '__main__':
    stu1 = Student() #定义Student类的对象stu1
    stu2 = Student() #定义Student类的对象stu2
    stu1.SetName('李晓明') #通过stu1对象调用SetName方法
    stu2.SetName('马红')  #通过stu2对象调用SetName方法
    stu1.PrintName() #通过stu1对象调用PrintName方法
    stu2.PrintName() #通过stu2对象调用PrintName方法

注：类的普通方法必须通过实例对象调用，而不能通过类名直接调用。这是因为通过实例对象调用时会自动将该实例对象传给self，而通过类调用时则不会有这个隐含的参数传递。

五、私有属性

私有属性，是指在类内可以直接访问、而在类外无法直接访问的属性。Python中规定，在定义类时，如果一个类属性名是以__(两个下划线)开头，则该类属性为私有属性。

class Student: #定义Student类
    name = '未知' #定义Student类中有一个name属性
    __id = '未知' #定义Student类中有一个__id私有属性
    def SetInfo(self,newname,newid): #定义SetInfo方法
        self.name = newname #将self对应实例对象的name属性赋为newname
        self.__id = newid #将self对应实例对象的__id属性赋为newid
    def PrintInfo(self): #定义PrintInfo方法
        print('姓名：%s，身份证号：%s'%(self.name,self.__id))
if __name__ == '__main__':
    stu = Student() #定义Student类对象stu
    stu.SetInfo('李晓明','120XXXXXXXXXXXXXXXXXX') #通过stu调用SetInfo方法
    stu.PrintInfo() #通过stu对象调用PringtInfo方法
    #print('身份证号：%s'%stu.__id)  #报错：'Student' object has no attribute '__id'
    #访问私有属性
    print('身份证号：%s'%stu._Student__id) #运行结果：身份证号：120XXXXXXXXXXXXXXXXXX

注：1、实际上，Python中并不存在无法访问的私有属性。如果我们在类中定义了一个私有属性，则在类外访问该私有属性时需要在私有属性名前加上“_类名”。
2、类中的方法本质上是（基础语法篇一中的）函数，所以类中的方法也可以有默认的参数值。

六、构造方法

构造方法是Python类中的内置方法之一，它的方法名为__init__，在创建一个类对象时会自动执行，负责完成新创建对象的初始化工作。

'''只有一个参数的构造方法'''
class Student: #定义Student类
    def __init__(self): #定义构造方法
        print('构造方法被调用！')
        self.name = '未知' #将self对应对象的name属性赋值为‘未知’
    def PrintInfo(self): #定义普通方法PrintInfo
        print('姓名：%s'%self.name) #输出姓名信息
if __name__ == '__main__':
    stu = Student() #创建Student类对象stu，自动执行构造方法
    stu.PrintInfo() #通过stu对象调用PrintInfo方法

'''带默认参数的构造方法'''
class Student: #定义Student类
    def __init__(self,name = '未知'): #定义构造方法
        print('构造方法被调用！')
        self.name = name #将self对应对象的name属性赋值为形参name的值
    def PrintInfo(self): #定义普通方法PrintInfo
        print('姓名：%s'%self.name) #输出姓名信息
if __name__ == '__main__':
    stu1 = Student() #创建Student类对象stu1，自动执行构造方法
    stu2 = Student('李晓明')
    stu1.PrintInfo() #通过stu1对象调用PrintInfo方法
    stu2.PrintInfo() #通过stu2对象调用PrintInfo方法

七、析构方法

析构方法是类的另一个内置方法，它的方法名为__del__，在销毁一个类对象时会自动执行，负责完成待销毁对象的资源清理工作，如关闭文件等。
类对象销毁有如下三种情况：
（1）局部变量的作用域结束。
（2）使用del删除对象。
（3）程序结束时，程序中的所有对象都将被销毁。

class Student: #定义Student类
    def __init__(self,name): #定i义构造方法
        self.name = name #将self对应对象的name属性赋值为形参name的值
        print('姓名为%s的对象被创建！'%self.name)
    def __del__(self): #定义析构方法
        print('姓名为%s的对象被销毁！'%self.name)
    def func(name):
        stu = Student(name) #创建Student类对象stu
if __name__ == '__main__':
    stu1 = Student('李晓明') #创建Student类对象stu1
    stu2 = Student('马红') #创建Student类对象stu2
    stu3 = stu2
    del stu2 #使用del删除stu2对象
    func('张刚') #调用func函数
    del stu3 #使用del删除stu3对象
    stu4 = Student('刘健') #创建Student类对象stu4

注：如果多个变量对应同一片内存空间，则只有这些变量都删除后才会销毁这片内存空间中所保存的对象，也才会自动执行析构方法。

八、常用内置方法

调用str函数对类对象进行处理时或者调用Python内置函数format()和print()时自动执行，__str__方法的返回值必须是字符串。

class Complex: #定义复数类Complex
    def __init__(self,real,image): #定义构造方法
        self.real = real #将self对应对象的real属性赋值为形参real的值
        self.image = image #将self对应对象的image属性赋值为形参image的值
    def __str__(self): #定义内置方法__str__
        return str(self.real)+ '+' +str(self.image)+'i'
if __name__ == '__main__':
    c = Complex(3.2,5.3) #定义Complex类对象c
    print(c) #输出 “3.2+5.3i”

比较运算的内置方法
类中一组用于比较对象大小的内置方法。

内置方法	功能描述
__gt__(self,other)	进行self > other运算时自动执行
__lt__(self,other)	进行self < other运算时自动执行
__ge__(self,other)	进行self >= other运算时自动执行
__le__(self,other)	进行self <= other运算时自动执行
__eq__(self,other)	进行self == other运算时自动执行
__ne__(self,other)	进行self != other运算时自动执行

class Student: #定义Student类
    def __init__(self,name,age): #定义构造方法
        self.name = name #将self对应对象的name属性赋为形参name的值
        self.age = age #将self对应对象的age属性赋为形参age的值
    def __le__(self,other): #定义内置方法__le__
        return self.age <= other.age
if __name__ == '__main__':
    stu1 = Student('李晓明',19) #定义Student类对象stu1
    stu2 = Student('马红',20) #定义Student类对象stu2
    print('马红的年龄小于等于李晓明的年龄：',stu2 <= stu1)

python初级–基础语法篇（一）
python初级–基础语法篇（二）