1、5.1.1 类和对象的概念对象（Object）抽象为类（Class）的过程，是在系统分析阶段完成的。在现实世界中，先有一个一个具体的对象，然后将对象进行分类，总结出类。在程序中，必须先定义类，后调用类来产生对象。类并不能直接使用，通过类创建出的实例（又称对象）才能使用。5.1.2 类的定义在编程时，使用类的顺序是：先定义（创建）类，然后再创建类的对象（实例），通过对象实现特定的功能。Python中，创建一个类使用class关键字实现，其基本语法格式如下：class 类名: 类的成员1 类的成员n5.1.3 类的成员在类的定义中，类的成员可以分为3种：类变量、方法和属性。属性在“5.2类的封装”
2、介绍，这里先介绍类变量和方法。1类变量Python中，类中的变量分为：类变量和实例变量。这里介绍类变量。在类体中定义的变量称为类变量（也称类字段、成员字段、成员变量），类变量也是广义上的属性，称为类属性。格式如下。class 类名: 类变量名 = 初值 类的其他成员说明：1）类变量是指在类中，且在方法之外定义的变量。2）初值表示该字段的初始状态，例如：student_age = 18 #年龄，整型，初值18岁2实例方法在类的内部，使用def关键字定义实例方法，语法格式如下。class 类名: 类变量名 = 值 def 方法名(self, 形参1, 形参2, , 形参n) self.实例变量名
3、= 值 变量名 = 值 方法体 return 表达式 类的其他成员实例方法必须包含参数self，且为第一个参数，不能省略。【例5-1】定义学生类Student。属性：姓名name、性别gender、年龄age、班级grade。方法：显示学习的课程learn(course)，course是显示的课程名称；显示考试的课程exam(course, score)，course是课程，score是成绩。class Student: # 定义类 # 定义类变量 name = # 姓名 gender = 男 # 性别，默认“男” age = 18 # 年龄，默认18岁 grade = # 班级 # 定义实例
4、方法 def info(self): print(self.name, self.gender, self.age, self.grade) # 在方法中访问类变量使用self关键字 def learn(this, course): # 获取学习课程字符串的方法，形参course代表课程 return this.name + 正在学习 + course # self可以换成任何标识符，这里是this def exam(self, course, score): # 获取考试课程字符串的方法，形参course代表课程，score代表成绩 string = self.name + course +
5、 的考试成绩是 + str(score) # 定义局部变量string return string【例5-2】计算长方体的体积和表面积。定义长方体类Cuboid。属性：长length、宽width、高height。方法：计算长方体的体积cubage，长方体的体积 =长宽高；计算长方体的表面积totalArea，长方体的表面积=（长宽+长高宽高）2。class Cuboid: #定义类变量 length = 0 #长 width = 0 #宽 height = 0 #高 # 定义实例方法 def cubage(self): #计算长方体的体积 return self.length * self.
6、width * self.height def total_area(self): #计算长方体的表面积 return (self.length * self.width + self.length * self.height + self.width * self.height) * 2【例5-2】计算长方体的体积和表面积。定义长方体类Cuboid。属性：长length、宽width、高height。方法：计算长方体的体积cubage，长方体的体积 =长宽高；计算长方体的表面积totalArea，长方体的表面积=（长宽+长高宽高）2。也可以把方法改成传参的形式，代码如下：class Cubo
7、id1: #定义实例方法 def cubage(self, length, width, height): #计算长方体的体积，形参：长，宽，高 return length * width * height def total_area(self, length, width, height): #计算长方体的表面积，形参：长，宽，高 return (length * width + length * height + width * height) * 25.1.4 创建对象1创建对象创建类的实例也称实例化一个类的对象，简称创建对象。对已创建的类进行实例化，其语法格式如下：类名()创建的对象
8、或实例赋值给一个变量，赋值后该变量就表示这个类的一个对象。其格式为：变量名（或称对象名） = 类名()例如，下面的代码创建Student类的实例，并赋给stu对象，对stu对象进行初始化。stu = Student() # 创建Student类的实例，并赋值给stu变量，stu变量的类型是类Student的类型2. 对象访问实例变量和实例方法（1）对象访问实例变量在主程序中（或类的外部），使用已创建的对象访问类中变量（实例变量或类变量）的语法格式如下：对象名.变量名注意：实例变量只能通过“对象名.实例变量名”访问，无法通过“类名.实例变量名”访问。为对象中的变量（实例变量或类变量）赋值的语法格
9、式如下：对象名.变量名 = 值（2）对象访问实例方法访问对象中实例方法的语法格式如下：对象名.方法名(实参1, 实参2, , 实参n)注意：对象名与实例变量名、方法名之间用点“.”连接。3. 类和对象应用示例【例5-3】通过在例5-1中已经定义的类，创建两个对象，分别是“刘强”和“王芳”。liuqiang = Student() #创建Student()类的一个对象，并赋值给liuqiang变量# 初始化类变量liuqiang.name = 刘强 #用“对象名.类变量”访问liuqiang.age = 19liuqiang.grade = 计算机科学2019# 调用方法liuqiang.inf
10、o() #显示liuqiang对象的基本信息print(liuqiang.learn(数学)print(liuqiang.exam(数学, 85)print() #显示一个空行，用于隔开两位学生的信息wangfang = Student() #创建Student()类的一个对象，并赋值给wangfang变量#初始化类变量wangfang.name = 王芳 wangfang.gender = 女wangfang.age = 18wangfang.grade = 哲学2019#调用方法wangfang.info()print(wangfang.learn(英语)print(wangfang.ex
11、am(英语, 96)【例5-4】在例5-2定义类的基础上，编写创建对象和调用属性、方法的代码。cu = Cuboid() # Cuboid()类的一个对象，并赋值给cu变量cu.length = 10 # 长cu.width = 20 # 宽cu.height = 30 # 高print(cu.cubage()print(cu.total_area()调用Cuboid1()中带参数的方法，代码如下：cu1 = Cuboid1() # Cuboid1()类的一个对象，并赋值给cu1变量print(cu1.cubage(10, 20, 30)print(cu1.total_area(10, 20,
12、 30)5.1.5 在类的内部调用实例方法在类的内部调用实例方法的格式为：self.方法名(实参1, 实参2, , 实参n)或类名.方法名(self, 实参1, 实参2, , 实参n)在类的内部调用实例方法，如果不使用类名调用方法，则方法名前使用self；如果使用类名调用方法，则实参列表中使用self。【例5-5】在类的内部和外部调用实例方法示例。class Human: def eat(self,name): self.name = name # 把形参name赋值给创建的实例变量self.name print(eat and %s % self.name) def drink(self):
13、 self.eat(drink) # 在类中访问方法：self.方法名() Human.eat(self,drink) # 在类中调用方法：类名.方法名(self) man = Human() # 创建对象man.drink() # 在类外调用方法，对象调用方法：对象名.方法名()5.1.6 构造方法1. 构造方法的概念当创建一个对象时，对象表示一个实体。例如，下面的代码st = Student() # 创建对象st.name = 张三 # 设置属性值，使该对象的name值为张三st.age = 18 # 设置属性值，使该对象的age值为18构造方法又叫构造函数、构造器，它是类的一种特殊的成员
14、方法，在创建类的新对象时自动调用构造方法。它主要用于在创建对象时初始化对象，即为对象成员变量赋初始值。2. 定义构造方法在创建类时，可以添加一个_init_()方法。该方法是一个特殊的类实例方法，称为构造方法。每个类都必须至少有一个构造方法。构造方法的语法格式如下：def _init_(self, 形参1, 形参2, , 形参n): self.实例变量名1 = 值1 self.实例变量名2 = 值2 方法体构造方法是类的一个特殊的成员方法，除了具有一般成员方法的特点外，它还有自己独有的特点。3. 调用构造方法在声明类时，一个类中会包默认的构造方法，也可能包含自定义构造方法。（1）调用默认构造方
15、法假设一个类包含默认的构造方法，则调用默认构造方法的语法如下。对象名 = 类名()（2）调用自定义构造方法自定义构造方法包括无参或有参构造函数。1）调用自定义无参构造方法。自定义无参构造方法的调用与默认构造方法的调用相同。2）调用有参构造方法。调用有参构造方法的语法如下。对象名 = 类名(实参1, 实参2, , 实参n)实参列表中的参数可以是数据对象、变量或表达式，参数之间用逗号分隔。例如，如下代码在创建Student对象时传入参数：st= Student(张三丰, 18)print(st.name, st.age)4. 构造方法实例【例5-6】在Student类的_init_()方法中，定义
16、两个实例变量gender和age，并且直接赋值。在创建Student的对象st时，采用无参数创建对象，它会隐式调用_init_()方法，然后Student类的对象st中的实例变量就被赋值了。class Student: def _init_(self): # 定义无参构造方法 print(调用构造方法) self.gender = 男 # self.gender表示gender是实例变量，通过“=”创建该实例变量 self.age = 18st = Student() # 创建对象，构造方法无参数print(st的性别：0，年龄：1.format(st.gender, st.age)【例5-7
17、】用_init_()方法传递参数。class Student: def _init_(self, name, gender, age): #定义有参构造方法，小括号中是定义的形参名 print(调用构造方法) self.name = name #“=”左边的name是定义的实例变量，右边的name是形参名 self.gender = gender self.age = agest = Student(王芳, 女, 19) #有参数创建对象print(st的姓名：0，性别：1，年龄：2.format(st.name, st.gender, st.age)【例5-8】对例5-2中的类，用_init
18、_()方法重新定义类。class Cuboid: def _init_(self, length, width, height): self.length = length # 实例变量作为属性用 self.width = width self.height = height def cubage(self): # 计算长方体的体积 return self.length * self.width * self.height # 访问实例变量 def total_area(self): # 计算长方体的表面积 return (self.length * self.width + self.len
19、gth * self.height + self.width * self.height) * 2if _name_=_main_ : cu = Cuboid(10, 20, 30) # 创建对象，用构造方法的参数初始化 print(cu.cubage() print(cu.total_area()【例5-9】定义一个两个数的加法类NumberAdd，通过_init_()方法初始化两个数，定义一个实例方法add()计算两个数的和。class NumberAdd: a = 5 #定义在类中但在函数体外的变量为类变量 def _init_(self, a, b): self.x = a #self
20、.x、self.y是实例变量 self.y = b #a、b是形参，a、b是本方法内的局部变量 print(a=0, b=1.format(a, b) print(self.x=0, self.y=1.format(self.x, self.y) print(self.a=, self.a) def add(self): #定义两个数相加的方法 sum = self.x + self.y #在类内访问实例变量 return sum print(a=, a) # 显示类变量a的值if _name_ = _main_ : a = 10 #加数 b = 20 #被加数 number = Number
21、Add(a, b) #创建对象并初始化 print(0 + 1 = 2.format(a, b, number.add() #显示两个数的和运行结果如下：a= 5a=10, b=20self.x=10, self.y=20self.a= 510 + 20 = 305.1.7 类变量、实例变量及其作用域1. 类变量类变量是指在类中且在方法之外定义的变量。在主程序中（或类的外部），类变量推荐用“类名.类变量名”访问，但也可以使用“对象名.类变量名”访问（此方式不推荐使用，即类变量通常不作为实例变量使用）。【例5-10】访问例5-1中定义的类变量name、gender、age和grade。Stude
22、nt.name = 刘强 #用“类名.类变量”访问Student.gender = 男Student.age = 19Student.grade = 计算机科学20192. 实例变量从实例化的角度来说，实例变量的定义为，实例化之后，每个实例（对象）单独拥有的变量叫作实例变量。实例变量是与某个类的实例相关联的数据值，这些值独立于其他实例或类。注意，实例变量只能通过对象名访问，无法通过类名直接访问。在方法中，只要以self定义的变量都是实例变量。实例变量的定义如下：self.变量名 = 值调用实例变量有如下两种方式。1）在类外通过对象直接调用。2）在类内通过self间接调用。【例5-11】类变量和
23、实例变量在访问和赋值后的不同。class Demo: aa = 我是类变量aa def func(self, name): self.bb = name #bb是实例变量if _name_ = _main_ : print(Demo.aa = , Demo.aa) Demo.aa = Demo类，为类变量aa第1次赋值 obj1 = Demo() #创建对象obj1 # obj1.aa = obj1对象，为实例变量aa赋值 #稍后取消注释 obj1.func(obj1对象，为实例变量bb赋值) print(Demo.aa = , Demo.aa) #显示类变量Demo.aa的值 print(o
24、bj1.aa = , obj1.aa) #显示对象obj1.aa的值 print(obj1.bb = , obj1.bb) #显示对象obj1.bb的值 print() obj2 = Demo() #创建对象obj2# obj2.aa = obj2对象，为实例变量aa赋值 #稍后取消注释 obj2.func(obj2对象，为实例变量bb赋值) Demo.aa = Demo类，为类变量aa第2次赋值 print(Demo.aa = , Demo.aa) #访问Demo.aa print(obj2.aa = , obj2.aa) #访问obj2.aa print(obj2.bb = , obj2.
25、bb) #访问obj2.bb print() print(id(Demo.aa) = , id(Demo.aa) #显示内存中的地址 print(id(obj1.aa) = , id(obj1.aa) print(id(obj2.aa) = , id(obj2.aa)3. 实例变量的作用域私有成员在类的外部不能直接访问，如果要在类的外部访问，只能通过调用类里面的公有成员方法间接访问，或者通过Python支持的特殊方式访问。【例5-12】在_init_()方法中初始化一个实例变量及一个私有的实例变量。定义一个给实例变量赋值的方法、一个给私有变量赋值的方法、一个得到实例变量的方法，以及一个得到私有
26、变量的方法。class Test: def _init_(self, x, y): self._x=x #定义实例变量 self._y=y #定义私有的实例变量 def setX(self, x): self._x=x #给实例变量赋值 def setY(self, y): self._y=y # 给私有的实例变量赋值 def getX(self): return self._x #得到实例变量 def getY(self): return self._y #得到私有的实例变量 def show(self): print(self._x=,self._x) #在类内访问实例变量 print(s
27、elf._y=,self._y) #在类内访问私有的实例变量if _name_ = _main_ : t = Test(2, 3) #创建对象并初始化 print(创建对象并初始化后显示_x, _y（2,3）的值) print(t._x) #在类外访问实例变量 print(t._y) #在类外访问对象的私有变量把类外的程序改为如下。if _name_ = _main_ : t = Test(2, 3) #创建对象并初始化 print(创建对象并初始化后显示_x, _y（2,3）的值) t.show() #调用实例方法t.show() print(t.getX(),t.getY() #调用实例方
28、法t.getX(),t.getY() t._x=4 #给实例变量赋值 t._y=5 #这里实际是新建了一个与私有变量_y同名的变量 print(给变量赋值后显示_x, _y（4,5）的值（_y的值没有变）) t.show() #self._y的显示结果仍是3 print(t.getX(),t.getY() t.setX(6) t.setY(7) #用方法给私有变量赋值，赋值成功 print(用方法设置值后显示_x, _y（6,7）的值) t.show() print(t.getX(),t.getY() print(t._Test_y) #用特殊方法访问私有变量运行显示结果如下：创建对象并初始化
29、后显示_x, _y（2,3）的值self._x= 2self._y= 32 3给变量赋值后显示_x, _y（4,5）的值（_y的值没有变）self._x= 4self._y= 34 3用方法设置值后显示_x, _y（6,7）的值self._x= 6self._y= 76 77在Python中，以下画线开头的变量名和方法名有特殊的含义，尤其是在类的定义中，用下画线作为变量名和方法名前缀和后缀来表示类的特殊成员。1）_：这样的变量名或方法名叫保护成员，不能用“from module import *”导入，只有类对象和子类对象能访问。2）_：系统定义的特殊成员。3）_：类中的私有成员，只有类对象自
30、己能访问，子类对象也不能访问这个成员，但在对象外部可以通过“对象名._类名_”这样的特殊方式来访问。也就是说，Python中不存在严格意义上的私有成员。在IDLE的文件方式或交互方式中，在对象或类名后输入一个小数点“.”后等3秒钟，则会显示一个列表框，列出其所有公开成员，如图5-5所示，模块也具有同样的特点。如果在小数点“.”后面再加一个下画线，则会在列表框中列出该对象或类的所有成员，包括私有成员，如图5-6所示。5.1.8 实例方法、类方法和静态方法1. 实例方法在定义方法时，如果方法的形参以self作为第一个参数，则该方法为实例方法（也称普通方法）。构造方法也属于实例方法，只不过它比较特殊
31、。在类内，分别使用“self.类变量名”和“self.实例变量名”访问类变量和实例变量。2. 类方法在定义方法时，如果方法的形参以cls作为第一个参数，并且使用classmethod修饰，则该方法为类方法。注意，如果没有classmethod修饰，则Python解释器会将该方法认定为实例方法，而不是类方法。在类方法内，使用“cls.类变量名”访问类变量，但是不能访问实例变量。3. 静态方法在定义方法时，如果不设置默认参数，并且使用staticmethod修饰，则该方法为静态方法。静态方法其实就是函数，它与函数的区别是，静态方法定义在类这个空间（类命名空间）中，而函数则定义在程序所在的空间（全局
32、命名空间）中。静态方法没有self、cls等特殊参数。静态方法可以通过类名或实例对象名来调用。【例5-13】在Person类中定义实例方法、类方法、静态方法，然后用类名、对象名访问这些方法。class Person: gender = Male # 定义类变量（静态的变量） def _init_(self, name=Jack, age=18): # 构造方法也属于实例方法 self.name = name # 定义实例变量 self.age = age def show(self): # 定义实例方法 return 实例方法show: + self.name + self.gender +
33、str(self.age) # 类内访问实例变量、类变量 classmethod #classmethod修饰的方法是类方法 def eat(cls, name, age): eat_name = name # 类方法内无法访问实例变量 eat_gender =cls.gender # 使用“cls.类变量名”访问类变量 eat_age = str(age) # 方法内定义的变量，类外不可用 return 类方法eat: + eat_name + eat_gender + eat_age classmethod # classmethod修饰的方法是类方法 def run(cls): retu
34、rn 类方法run: + str(cls) staticmethod # staticmethod修饰的方法是静态方法 def sleep(a): # s = self.x + self.name # 静态方法内无法访问类变量和实例变量 s = zZ# + a #方法内定义的变量，类外不可用 return 静态方法sleep: + sprint(用类名调用, Person.eat(Jack, 18) # 用类名调用方法，Person类会自动绑定到第一个参数print(用类名调用, Person.run() # 用类名调用类方法，Person类会自动绑定到第一个参数print(用类名调用, Pe
35、rson.sleep(ZZZ.) # 用类名调用静态方法per = Person(Jenny, 19) # 创建对象print(用对象名调用, per.eat(Jenny, 19) # 用对象调用eat()类方法，其实依然是使用类调用print(用对象名调用, per.run() # 因此第一个参数依然被自动绑定到Person类print(用对象名调用, per.sleep(zzz.) # 用对象调用静态方法print(用对象名调用, per.show() # 用对象调用show()实例方法运行结果为：用类名调用 类方法eat:JackMale18用类名调用 类方法run:用类名调用 静态方法
36、sleep:zZ#ZZZ.用对象名调用 类方法eat:JennyMale19用对象名调用 类方法run:用对象名调用 静态方法sleep:zZ#zzz.用对象名调用 实例方法show:JennyMale195.2.1 封装的概念封装实际上有两个方面的含义：把该隐藏的隐藏起来，把该暴露的暴露出来。由于Python并没有提供类似于其他程序语言的private等的修饰符，因此Python并不能真正支持隐藏。Python中的封装有两种方法：1）用私有变量、私有方法实现封装。2）用property装饰器定义属性实现封装。5.2.2 用私有变量、私有方法实现封装Python不能真正支持隐藏。为了隐藏类中的
37、成员，Python行业建议将类的成员命名为以双下画线开头，这样程序员在看到双下划线开头的属性时，就知道是隐藏属性，也就不在外部访问了。【例5-14】定义长方形类Rectangle，在构造方法中设置私有实例变量宽_width和高_height。分别对宽、高定义get方法、set方法、del方法。再定义一个计算面积的方法area()。class Rectangle: #定义长方形类 def _init_(self, width=0, height=0): #定义构造方法 self._width = width #创建实例变量，宽 self._height = height #创建实例变量，高 de
38、f getwidth(self): #定义getwidth()方法，返回宽 return self._width def setwidth(self, width): #定义setwidth()方法，设置宽 self._width = width def delwidth(self): #定义delwidth()方法 self._width = 0 def getheight(self): #定义getheight()方法，返回高 return self._height def setheight(self, height): #定义setheight()方法,设置高 self._height
39、 = height def delheight(self): #定义delheight()方法 self._height = 0 def area(self): #定义计算面积的方法area() return self._width * self._height #按设置的宽、高计算面积rect = Rectangle() #创建对象，用默认值初始化实例rect.setwidth(20) #设置宽rect.setheight(30) #设置高print(rect.getwidth() #得到宽print(rect.getheight() #得到高print(rect.area() #计算面积运
40、行结果如下：20306005.2.3 用property装饰器定义属性实现封装1. 用property装饰器定义属性（推荐）定义方法时，使用property装饰器可以把一个实例方法变成其同名属性，以支持“对象名.属性名”的访问。用property定义属性的语法格式如下：property # 定义只读属性def 属性名(self) 代码块1属性名.setter # 定义可修改属性def 属性名(self, value): 代码块2属性名.deleter # 定义删除属性def 属性名(self): 代码块3【例5-15】把例5-14改成用property装饰器定义属性。class Rectang
41、le: # 定义长方形类 def _init_(self, width=0, height=0): #定义构造方法 self._width = width #创建实例变量，宽 self._height = height #创建实例变量，高 property def width(self): #定义只读属性width，返回宽 return self._width width.setter def width(self, width): #定义设置属性width，设置宽 self._width = width width.deleter def width(self): #定义删除属性width
42、self._width = 0 property def height(self): #定义只读属性height，返回高 return self._height height.setter def height(self, height): #定义设置属性height，设置高 self._height = height height.deleter def height(self): #定义删除属性height self._height = 0 def area(self): #定义计算面积的方法area() return self._width * self._height #按设置的宽、高
43、计算面积rect = Rectangle() #创建对象，用默认值初始化实例rect.width = 20 #用属性设置宽rect.height = 30 #用属性设置高print(rect.width =, rect.width) #得到宽print(rect.height =, rect.height) #得到高print(rect.area() =, rect.area() #计算面积print(rect._Rectangle_width) #访问私有变量运行程序的结果如下：rect.width = 20rect.height = 30rect.area() = 60020【例5-16】
44、对设定的属性值进行数据校验，并给出相应的提示。class Student(object): def _init_(self, name, age): self._name = name self._age = age self._weight = 45 property def name(self): return self._name name.setter def name(self, value): if type(value) = str: self._name = value else: self._name = No name. property def age(self): re
45、turn self._age age.setter def age(self, value): if value 0 and value 0 and value 100: self._age = value else: self._age = invalid age value. age = property(fget=get_age, fset=set_age, fdel=None, doc= age of an student ) def get_weight (self): return self._weight def set_weight (self, value): self._w
46、eight = value weight = property(fget=get_weight, fset=set_weight, fdel=None, doc= weight of an student)t = Student(Tom, 19)print(Name:, t.name)print(Age:, t.age)print(weight:, t.weight)print(-*50)t.name = Jackt.age = 300t.weight =50print(Name:, t.name)print(Age:, t.age)print(weight:, t.weight)print(
47、Student.name._doc_)运行结果如下：Name: TomAge: 19weight: 45-Name: JackAge: invalid age value.weight: 50name of an student5.3.1 继承的概念所谓继承就是使用已存在的类的定义作为基础建立新类的技术。已存在的类称为基类、父类或超类（Base Class、Father Class、Super Class）。新建的类称为派生类（Derived Class）或子类（Sub Class）。通过继承，一个新建子类从已有的父类那里获得父类的特性和行为。5.3.2 使用继承子类继承父类的语法格式如下：c
48、lass 子类名(父类名1, 父类名2, ): 类变量 = 值 def _init_(self, 参数表): 方法体1 def 方法名(self, 参数表): 方法体2 类的成员1 类的成员2 【例5-19】子类调用父类的公有变量和方法示例。class Father: # 定义父类 car = 3 # 定义类变量，公有的属性 def drive(self): # 定义方法，公有的方法 print(Father can drive a car!)class Son(Father): # 子类继承父类 pass # 空语句tom = Father() # 父类创建对象print(tom.car)
49、# 父类对象调用自己的类变量tom.drive() # 父类对象调用自己的方法print(-*50) # 显示50个“-”jerry=Son() # 子类创建对象 print(jerry.car) # 子类调用父类的类变量jerry.drive() # 子类调用父类的方法运行结果如下：3Father can drive a car!-3Father can drive a car!5.3.3 重写方法如果父类的某些方法不能满足子类的需求，可以在子类中对父类的方法进行选择性的修改，包括形参、方法体、返回值等，甚至覆盖（全部修改），称为重写方法或方法的重写。1. 构造方法的重写若要在子类中调用父类
50、的构造方法，就要在子类的构造方法中显式调用父类的构造方法，有两种方式。1）Python 3以前版本的调用语法为：ParentClassName._init_(self, parameters)2）Python 3的调用语法为：super()._init_(parameters)建议使用Python 3的调用语法，因为它可以解决类名变动后引起的修改问题。【例5-20】在子类的构造方法中调用父类构造方法示例。class Father(object): def _init_(self, name, age): self.name = name # 父类的实例变量不能定义为私有（如_name），否则不
