一个默默潜心修炼的程序员
超类与子类之间的关系
类的行为和属性分为两部分：自己的行为和属性以及从超类继承的行为和属性
子类使用超类的方法和属性
使用关键字extends
class A extends B{
子类中定义的方法在超类中也定义过，使用时将使用子类中的定义，因此子类可修改、替换、删除超类中的行为和属性
子类要想覆盖超类中的方法，必须以与超类相同的方式声明它，public的方法仍是public，方法的返回值类型必须相同，参数的数量和类型都不能变。
子类中使用this和supper
关键字this用于引用当前对象
关键字supper用于引用对象的上一级超类：我们最好在子类的构造函数中调用超类的构造函数，此时就会用到supper
class readFlies(String name, int length){
super(name, length);
这是子类的构造函数，它的第二行调用了超类的构造函数。如果不进行此步骤，可能会导致子类执行构造时，java自动调用无参数的超类构造函数，可能会产生错误。
将相同类型的对象存储到Vector中
Vector类类似于数组，也存储相关的数据，但其长度可以动态的增减。Vector类位于java.util包中。
import java.util.V
Vector存储的对象要么属于同一个类，要么有相同的超类。创建Vector，需要引用两个类：Vector和存储在Vector中的类
Vector&String&victor = new Vector&String&();
Vector&String& victoria = new Vector&String&(300);
victor.add("Vance");
String name = victoria.get(0);
没有更多推荐了，继承和多态 - 这是Python中一个非常重要的概念。我们必须更好地理解它。
继承面向对象编程的一个主要优势是重用。 继承是实现这一目标的机制之一。 继承允许程序员先创建一个通用类或基类，然后再将其扩展为更专门化的类。 它允许程序员编写更好的代码。
使用继承，可以使用或继承基类中可用的所有数据字段和方法。 之后，可以添加自己的方法和数据字段，因此继承提供了一种组织代码的方法，而不是从头开始重写。
在面向对象的术语中，当类X扩展类Y时，则Y称为超级/父/基类，X称为子类/子/派生类。 这里需要注意的一点是，只有数据字段和非专用的方法才能被子类访问。 私有数据字段和方法只能在类中访问。
创建派生类的语法是 -
class BaseClass:
Body of base class
class DerivedClass(BaseClass):
Body of derived class
继承属性现在看下面的代码例子 -
class Date(object):
def get_date(self):
class Time(Date):
def get_time(self):
return &09:09:09&
dt = Date()
print(&Get date from Date class: &, dt.get_date())
tm = Time()
print(&Get time from Time class: &, tm.get_time())
print(&Get date from class by inheriting or calling Date class method: &, tm.get_date())
执行上面示例代码，得到以下结果 -
E:\worksp\pycharm\venv\Scripts\python.exe E:/worksp/pycharm/main.py
Get date from Date class:
Get time from Time class:
Get date from class by inheriting or calling Date class method:
首先创建了一个名为Date的类，并将该对象作为参数传递，object是由Python提供的内置类。 之后创建了另一个名为time的类，并将Date类称为参数。 通过这个调用，可以访问Date类中的所有数据和属性。 正因为如此，创建的Time类对象tm中获取父类中get_date方法。
Object.Attribute查找层次结构
实例当前类该类继承的任何父类
继承示例让我们来看看一个继承的例子 -
让我们创建几个类来参与示例 -
Animal - 模拟动物的类Cat - Animal的子类Dog - Animal的子类
在Python中，类的构造函数用于创建对象(实例)，并为属性赋值。
子类的构造函数总是调用父类的构造函数来初始化父类中的属性的值，然后它开始为其属性赋值。
class Animal(object):
def __init__(self, name):
self.name = name
def eat(self, food):
print('%s is eating %s , '%(self.name, food))
class Dog(Animal):
def fetch(self, thing):
print('%s goes after the %s !'%(self.name, thing))
class Cat(Animal):
def swatstring(self):
print('%s shreds the string! ' % (self.name))
d = Dog('Ranger')
c = Cat(&Meow&)
d.fetch(&ball&);
c.swatstring()
d.eat(&Dog food&)
c.eat(&Cat food&)
## 调用一个没有的定义的方法
#d.swatstring()
执行上面示例，得到以下代码 -
E:\worksp\pycharm\venv\Scripts\python.exe E:/worksp/pycharm/main.py
Ranger goes after the ball !
Meow shreds the string!
Ranger is eating Dog food ,
Meow is eating Cat food ,
在上面的例子中，我们看到如何父类中的属性或方法，以便所有的子类或子类都会从父类继承那些属性。
如果一个子类尝试从另一个子类继承方法或数据，那么它将通过一个错误，就像看到当Dog类尝试调用cat类有swatstring()方法时，它会抛出一个错误(AttributeError)。
多态性(“多种形状”)多态性是Python中类定义的一个重要特性，当您在类或子类中使用通用命名方法时，可以使用它。 这允许功能在不同时间使用不同类型的实体。 所以，它提供了灵活性和松散耦合，以便代码可以随着时间的推移而扩展和轻松维护。
这允许函数使用任何这些多态类的对象，而不需要知道跨类的区别。
多态性可以通过继承进行，子类使用基类方法或覆盖它们。
我们用之前的继承示例理解多态的概念，并在两个子类中添加一个名为show_affection的常用方法 -
从这个例子可以看到，它指的是一种设计，其中不同类型的对象可以以相同的方式处理，或者更具体地说，两个或更多的类使用相同的名称或通用接口，因为同样的方法(下面的示例中的show_affection) 用任何一种类型的对象调用。
class Animal(object):
def __init__(self, name):
self.name = name
def eat(self, food):
print('%s is eating %s , '%(self.name, food))
class Dog(Animal):
def fetch(self, thing):
print(&{0} wags {1}&.format(self.name, thing))
def show_affection(self):
print(&{0} wags tail &.format(self.name))
class Cat(Animal):
def swatstring(self):
print('%s shreds the string! ' % (self.name))
def show_affection(self):
print(&{0} purrs &.format(self.name))
d = Dog('Ranger')
c = Cat(&Meow&)
d.show_affection()
c.show_affection()
执行上面示例代码，得到以下结果 -
E:\worksp\pycharm\venv\Scripts\python.exe E:/worksp/pycharm/main.py
Ranger wags tail
Meow purrs
所以，所有的动物都表现出喜爱(show_affection)，都不太相同。 “show_affection”行为因此具有多态性，因为它根据动物的不同而采取不同的行为。 因此，抽象的“动物”概念实际上并不是“show_affection”，而是特定的动物(如狗和猫)具有动作“show_affection”的具体实现。
Python本身具有多态的类。 例如，len()函数可以与多个对象一起使用，并且都会根据输入参数返回正确的输出。
重载在Python中，当子类包含一个覆盖超类方法的方法时，也可以通过调用超类方法 -
Super(Subclass, self).method而不是self.method。
class Thought(object):
def __init__(self):
def message(self):
print(&Thought, always come and go&)
class Advice(Thought):
def __init__(self):
super(Advice, self).__init__()
def message(self):
print('Warning: Risk is always involved when you are dealing with market!')
继承构造函数
从前面的继承示例中看到，__init__位于父类中，因为子类-Dog或Cat没有__init__方法。 Python使用继承属性查找来查找动物类中的__init__。 当我们创建子类时，首先它会查找dog类中的__init__方法，如果它找不到它，则查找父类Animal，并在那里找到并在那里调用它。 因此，当类设计变得复杂时，可能希望初始化一个实例，首先通过父类构造函数然后通过子类构造函数处理它。参考以下示例代码 -
import random
class Animal(object):
def __init__(self, name):
self.name = name
class Dog(Animal):
def __init__(self, name):
super(Dog, self).__init__(name)
self.breed = random.choice(['Doberman', 'German shepherd', 'Beagle'])
def fetch(self, thing):
print('%s goes after the %s !'%(self.name, thing))
d = Dog('黑皮')
print(d.name)
print(d.breed)
执行上面示例代码，得到以下结果 -
E:\worksp\pycharm\venv\Scripts\python.exe E:/worksp/pycharm/main.py
German shepherd
在上面的例子中，所有的动物都有一个名字，所有的狗都是一个特定的品种。我们用super来调用父类构造函数。所以Dog类有它自己的__init__方法，但首先调用的我们称之为超类。 Super是在函数中构建的，它是用来将一个类与它的超类或它的父类关联起来。
在这种情况下，我们说获取超类-Dog并将它实例传递给构造函数 - __init__。换句话说，我们用dog对象调用父类Animal.__init__方法。你可能会问，为什么不会只用Animal.__init__()和Dog的实例，我们可以做到这一点，但如果Animal类的名字会在将来某个时候改变。如果想重新安排类层次结构，那么该Dog会从另一个类继承。在这种情况下使用super可以让保持模块化，易于更改和维护。
所以在这个例子中，能够将通用__init__功能与更具体的功能相结合。这使有机会将通用功能与特定功能分开，从而消除代码重复，并以反映系统总体设计的方式将类相互关联。
__init__与任何其他方法一样; 它可以被继承如果一个类没有__init__构造函数，Python将检查其父类查找。只要找到有一个__init__构造函数，Python就会调用它并停止查找可以使用super()函数来调用父类中的方法。可能想要在父类以及子类进行初始化。
多重继承和查找树正如其名称所示，Python的多重继承是当一个类从多个类继承时。
例如，一个孩子继承父母(母亲和父亲)的个性特征。
Python多继承语法
要使一个类继承多个父类，可将这些类的名称写在派生类的括号内，同时定义它。 我们用逗号分隔这些名字。
下面是一个例子 -
&&& class Mother:
&&& class Father:
&&& class Child(Mother, Father):
&&& issubclass(Child, Mother) and issubclass(Child, Father)
多继承是指从两个或两个以上的类继承的能力。 当孩子从父母继承而父母从祖父母类继承时，复杂性就出现了。 Python在继承树上寻找正在被请求从对象读取的属性。 它将检查实例，在类中然后在父类中检查，最后从祖父类中检查。 现在问题出现在按什么顺序搜索类 - 广度优先或深度优先。 默认情况下，Python采用深度优先。
这就是为什么在下图中Python首先在A类中搜索dothis()方法。所以下面例子中的方法解析顺序将是 -
Mro- D→B→A→C
看下面的多重继承图 -
通过一个例子来理解Python的“mro”特性。
class A(object):
def dothis(self):
print('doing this in A')
class B(A):
class C(object):
def dothis(self):
print('doing this in C')
class D(B, C):
d_inst.dothis()
print(D.mro())
执行上面示例代码，得到以下结果 -
E:\worksp\pycharm\venv\Scripts\python.exe E:/worksp/pycharm/main.py
doing this in A
[&class '__main__.D'&, &class '__main__.B'&, &class '__main__.A'&, &class '__main__.C'&, &class 'object'&]
下面再来看另一个“菱形”多重继承的例子。
上图将被视为含糊不清。 从上之前的例子中了解“方法解析顺序”。 mro将是D→B→A→C→A，但事实并非如此。 在从C获得第二个A时，Python将忽略之前的A。因此在这种情况下mro将是D→B→C→A。
我们来根据上面的图创建一个例子 -
class A(object):
def dothis(self):
print('doing this in A')
class B(A):
class C(A):
def dothis(self):
print('doing this in C')
class D(B, C):
d_inst.dothis()
print(D.mro())
执行上面示例代码，得到以下结果 -
E:\worksp\pycharm\venv\Scripts\python.exe E:/worksp/pycharm/main.py
doing this in C
[&class '__main__.D'&, &class '__main__.B'&, &class '__main__.C'&, &class '__main__.A'&, &class 'object'&]
理解上述输出的简单规则是 - 如果在方法分辨率顺序中出现相同的类，则将从方法分辨率顺序中删除此类的早期外观。
总结如下 -
任何类都可以从多个类继承搜索继承类时，Python通常使用“深度优先”顺序。但是，当两个类从同一个类继承时，Python将从该mro中消除该类的第一次出现。
装饰器，静态和类方法函数(或方法)由def语句创建。
虽然方法的工作方式与函数完全相同，除了方法第一个参数是实例对象的一点。
我们可以根据行为方式来分类方法
简单的方法 - 在类的外部定义。 该函数可以通过提供实例参数来访问类属性:def outside_func(():
实例方法 -def func(self,)
类方法 - 如果需要使用类属性
def cfunc(cls,)
静态方法 - 没有关于该类的任何信息
def sfoo()
到目前为止，我们已经看到了实例方法，下面来了解其他两种方法。
1. 类方法装饰器是一个内置的函数装饰器，它通过调用它的类或作为第一个参数调用的实例的类。 评估结果会影响函数定义。
class C(object):
@classmethod
def fun(cls, arg1, arg2, ...):
fun: function that needs to be converted into a class method
returns: a class method for function
他们有权访问此cls参数，它不能修改对象实例状态。
它受到类的约束，而不是类的对象。类方法仍然可以修改适用于类的所有实例的类状态。
2. 静态方法静态方法既不接受自己也不接受cls(class)参数，但可以自由接受任意数量的其他参数。
class C(object):
@staticmethod
def fun(arg1, arg2, ...):
returns: a static method for function funself.
静态方法既不能修改对象状态，也不能修改类的状态。受限于可以访问的数据。
什么时候使用
通常使用类方法来创建工厂方法。 工厂方法返回不同用例的类对象(类似于构造函数)。通常使用静态方法来创建实用函数。
易百教程移动端：请扫描本页面底部(右侧)二维码并关注微信公众号，回复："教程" 选择相关教程阅读或直接访问：http://m.yiibai.com 。
上一篇：下一篇：
加QQ群啦，易百教程官方技术学习群
注意：建议每个人选自己的技术方向加群，同一个QQ最多限加3个群。
Java技术群：
（人数：2000，免费：否）
MySQL/SQL群：
（人数：2000，免费：否）
大数据开发群：
（人数：2000，免费：否）
Python技术群：
（人数：2000，免费：否）
人工智能深度学习：
（人数：2000，免费：否）
测试工程师(新群)：
（人数：1000，免费：是）
前端技术群(新群)：
（人数：1000，免费：是）
C/C++技术(新群)：
（人数：1000，免费：是）
Node.js技术(新群)：
（人数：1000，免费：是）
PostgreSQL数据库（新群）：
（人数：1000，免费：是）
Linux技术：
（人数：2000，免费：否）
PHP开发者：
（人数：2000，免费：是）
Oracle数据库：
（人数：2000，免费：否）
C#/ASP.Net开发者：
（人数：2000，免费：是）
数据分析师：
（人数：1000，免费：是）R语言，Matlab语言等技术Python——类的定义和超类
假定你已经学习了Java程序设计，那么就不难理解面向对象程序设计。在面向对象中，有几个非常重要的概念，包括：抽象、封装、继承、多态、方法重载等，不管怎样这些概念都与类相关。在Python中同样有同Java一样的类，用户可以根据设计需要对事物进行抽象，抽取主要的特征来构造需要的类并定义属于类的成员方法。
一、类的定义
__metaclass__=type
class Person:
def setName(self,name):
self.name=name
def getName(self):
return self.name
def greet(self):
print('Hello,%s' %self.name)
运算结果：
=========RESTART: C:\Users\Mr_Deng\Desktop\test.py=========
&&& test1=Person()
&&& test1.setName('Jack Chen')
&&& print(test1.getName())
注：self参数是对对象自身的引用，在调用类中的定义的方法时，例如setName函数时，test1自动将自己作为第一个参数传入函数中。没有self变量，成员方法就不能设法访问他们要对其特性进行操作的对象本身了。
二、特性、函数和方法
2.1 self参数时方法和函数的区别，方法将他的第一个参数绑定到所属的实例上，但是这个参数也可以不提供，所以可以将特性绑定到普通函数上，这样就可以消除self参数
__metaclass__=type
class Test:
def A(self):
print('self')
def fun():
print('other function')
运算结果：
=========RESTART: C:\Users\Mr_Deng\Desktop\test.py=========
&&& test=Test()
&&& test.A()
&&& test.A=fun
&&& test.A()
other function
但是，self参数并不取决于调用方法的方式，上例中采用实例调用的方式，但是实际上也可以引用同一方法的其他变量
# _*_ coding:utf-8 _*_
__metaclass__=type
class Test:
s='test class'
def outTest(self):
print(self.s)
运算结果：
=========RESTART: C:\Users\Mr_Deng\Desktop\test.py=========
&&& test=Test()
&&& test.outTest()
test class
&&& x=test.outTest
test class
注：这个例子中的方法调用于前面一个函数调用比较想死，但是x是引用绑定了Test中的方法outTest，也就是说x还是对self参数的访问。
2.2 方法私有化：在Python中若是想让某个方法或者特性变为私有的，在方法的名字前加上双下划綫即可
__metaclass__=type
class Test:
def A(self):
print('public method')
def __B(self):
print('private methon')
运算结果：
=========RESTART: C:\Users\Mr_Deng\Desktop\test.py=========
&&& test=Test()
&&& test.A()
public method
&&& test.B()
Traceback (most recent call last):
File "&pyshell#92&", line 1, in &module&
AttributeError: 'Test' object has no attribute 'B'
三、类的命名空间：位于class语句中的代码都在特殊的命名空间中执行，这个空间就是类命名空间，该命名空间可以由类内所有的成员访问
__metaclass__=type
class Member:
def init(self):
Member.count+=1
运算结果：
=========RESTART: C:\Users\Mr_Deng\Desktop\test.py=========
&&& test1=Member()
&&& test1.init()
&&& Member.count
&&& test2=Member()
&&& test2.init()
&&& Member.count
&&& test1.count
&&& test2.count
四、指定超类：子类可以扩展超类的定义，将其他类名写在class语句后的圆括号内可以指定超类，案例如下：
__metaclass__=type
class Filter:
def init(self):
self.blocked=[]
def filter(self,seq):
return [ x for x in seq if x not in self.blocked]
class ExtendFilter(Filter):
def init(self):
self.blocked=['1']
运算结果：
=========RESTART: C:\Users\Mr_Deng\Desktop\test.py=========
&&& f=Filter()
&&& f.init()
&&& f.filter([])
&&& ef=ExtendFilter()
&&& ef.init()
&&& ef.filter(['1','2','3','1','1','7'])
['2', '3', '7']
在ExtendFilter类中，继承了Filter中的filter方法
五、调查继承性
5.1 查看一个类是否是另一个类的子类，可以使用內建的函数issubclass
__metaclass__=type
class Filter:
def init(self):
self.blocked=[]
def filter(self,seq):
return [ x for x in seq if x not in self.blocked]
class ExtendFilter(Filter):
def init(self):
self.blocked=['1']
运算结果：
=========RESTART: C:\Users\Mr_Deng\Desktop\test.py=========
&&& issubclass(ExtendFilter,Filter)
或者使用bases
&&& ExtendFilter.__bases__
(&class '__main__.Filter'&,)
5.2 检查一个对象是否是一个类的实例
&&& ef=ExtendFilter()
&&& isinstance(ef,ExtendFilter)
5.3 查看一个对象属于哪个类
&&& ef.__class__
&class '__main__.ExtendFilter'&
六、多个超类
__metaclass__=type
class Cauculator:
def cauculator(self,express):
self.value=eval(express)
class Result:
def result(self):
print('result is :',self.value)
class Compute(Cauculator,Result):
运算结果：
=========RESTART: C:\Users\Mr_Deng\Desktop\test.py=========
&&& test=Compute()
&&& test.cauculator('12*2+2')
&&& test.result()
result is : 26
没有更多推荐了，机器学习基本算法
【Python】使用super初始化超类
初始化超类的传统方式，在子类的实例中调用超类的__init__()方法。但是传统的方法有两个问题，比如：问题1： 1 class MyBaseClass:
def __init__(self, value):
self.value = value
6 class TimesTwo:
def __init__(self):
self.value *= 2
11 class PlusFive:
def __init__(self):
self.value += 5
16 class OneWay(MyBaseClass, TimesTwo, PlusFive):
def __init__(self,value):
MyBaseClass.__init__(self, value)
TimesTwo.__init__(self)
PlusFive.__init__(self)
23 class AnotherWay(MyBaseClass,
PlusFive, TimesTwo):
def __init__(self,value):
MyBaseClass.__init__(self, value)
TimesTwo.__init__(self)
PlusFive.__init__(self)
29 foo = OneWay(5)
30 print('OneWay (5*2)+5=', foo.value)
31 foo = AnotherWay(5)
32 print('AnotherWay:', foo.value)结果为：从结果可以看出，即使改变了子类的继承顺序，调用的顺序并没有改变。问题2：如果子类继承自两个单独的超类，而那两个超类又继承自同一个公共基类，那么就构成了钻石型继承。这种继承会使钻石顶端的公共基类多次执行__init__()方法，从而产生意外。比如： 1 class MyBaseClass:
def __init__(self, value):
self.value = value
6 class TimesFive(MyBaseClass):
def __init__(self, value):
MyBaseClass.__init__(self, value)
self.value *= 2
12 class PlusTwo(MyBaseClass):
def __init__(self, value):
MyBaseClass.__init__(self, value)
self.value += 2
18 class ThisWay(TimesFive, PlusTwo):
def __init__(self, value):
TimesFive.__init__(self, value)
PlusTwo.__init__(self, value)
25 foo = ThisWay(5)
26 print('Should be (5*5)+2 but is ', foo.value)在调用PlusTwo.__init__()时候，又一次调用MyBaseClass.__init__()又一次把value变为5
以上两种问题都可以使用super解决，方法解析顺序mro(method resolution order),以标准的流程安排超类之间的初始化顺序。比如这次用super初始化超类 1 class MyBaseClass:
def __init__(self, value):
self.value = value
6 class TimesFive(MyBaseClass):
def __init__(self, value):
super(TimesFive, self).__init__(value)
self.value *= 5
12 class PlusTwo(MyBaseClass):
def __init__(self, value):
super(PlusTwo, self).__init__(value)
self.value += 2
18 class GoodWay(TimesFive, PlusTwo):
def __init__(self, value):
super(GoodWay, self).__init__(value)
23 foo = GoodWay(5)
24 print('Should be 5*(5+2) and is ', foo.value)并且可以使用print(GoodWay.mro())来查看初始化顺序：参考资料：Effective Python
没有更多推荐了，Python类的继承
转自：[Bigberg](https://www.cnblogs.com/bigberg/p/7182741.html)
&一、概述　
　　面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
　　通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”，继承的过程，就是从一般到特殊的过程。在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。
　　继承概念的实现方式主要有2类：实现继承、接口继承。
实现继承是指使用基类的属性和方法而无需额外编码的能力。
接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力(子类重构爹类方法)。
　　在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。
　　OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。
二、类的继承
2.1 继承的定义
12345678910111213141516171819class Person(object):&& &&&&&def talk(self):&&& &&&&&&&&print("person is talking....")&& &&class Chinese(Person):&&& &&&&&def walk(self):&&&&& &&&&&&&&print('is walking...')&c = Chinese()c.talk()&&&&& c.walk()&&&& &&person is talking....is walking...
2.2 构造函数的继承　
&　　如果我们要给实例 c 传参，我们就要使用到构造函数，那么构造函数该如何继承，同时子类中又如何定义自己的属性？
继承类的构造方法：
& & & & 1.经典类的写法： 父类名称.__init__(self,参数1，参数2，…)
& & & & 2. 新式类的写法：super(子类，self).__init__(参数1，参数2，….)
12345678910111213141516171819202122232425class Person(object):&&&&&def __init__(self, name, age):&&&&&&&&self.name = name&&&&&&&&self.age = age&&&&&&&&self.weight = 'weight'&&&&&def talk(self):&&&&&&&&print("person is talking....")&&class Chinese(Person):&&&&&def __init__(self, name, age, language):& &&&&&&&&Person.__init__(self, name, age)& &&&&&&&&self.language = language&&& &&&&&def walk(self):&&&&&&&&print('is walking...')&&class American(Person):&&&&pass&c = Chinese('bigberg', 22, 'Chinese')
　　如果我们只是简单的在子类Chinese中定义一个构造函数，其实就是在重构。这样子类就不能继承父类的属性了。所以我们在定义子类的构造函数时，要先继承再构造，这样我们也能获取父类的属性了。
& & & 子类构造函数基础父类构造函数过程如下：
& & & 实例化对象c —-& c 调用子类__init__() &—- & 子类__init__()继承父类__init__() &—– & 调用父类&__init__()
2.3 子类对父类方法的重写
　　如果我们对基类/父类的方法需要修改，可以在子类中重构该方法。如下的talk()方法　
1234567891011121314151617181920212223242526272829class Person(object):&&&&&def __init__(self, name, age):&&&&&&&&self.name = name&&&&&&&&self.age = age&&&&&&&&self.weight = 'weight'&&&&&def talk(self):&&&&&&&&print("person is talking....")&class Chinese(Person):&&&&&def __init__(self, name, age, language):& &&&&&&&&Person.__init__(self, name, age)& &&&&&&&&self.language = language&&&&&&&&print(self.name, self.age, self.weight, self.language)&&&&&def talk(self):& &&&&&&&&print('%s is speaking chinese' % self.name)&&&&&def walk(self):&&&&&&&&print('is walking...')&c = Chinese('bigberg', 22, 'Chinese')c.talk()&bigberg 22 weight Chinesebigberg is speaking chinese
&三、类继承的事例
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879class SchoolMember(object):&&&&&&&&member = 0&&&&&def __init__(self, name, age, sex):&&&&&&&&self.name = name&&&&&&&&self.age = age&&&&&&&&self.sex = sex&&&&&&&&self.enroll()&&&&&def enroll(self):&&&&&&&&'注册'&&&&&&&&print('just enrolled a new school member [%s].' % self.name)&&&&&&&&SchoolMember.member += 1&&&&&def tell(self):&&&&&&&&print('----%s----' % self.name)&&&&&&&&for k, v in self.__dict__.items():&&&&&&&&&&&&print(k, v)&&&&&&&&print('----end-----')&&&&&def __del__(self):&&&&&&&&print('开除了[%s]' % self.name)&&&&&&&&SchoolMember.member -= 1&&class Teacher(SchoolMember):&&&&'教师'&&&&def __init__(self, name, age, sex, salary, course):&&&&&&&&SchoolMember.__init__(self, name, age, sex)&&&&&&&&self.salary = salary&&&&&&&&self.course = course&&&&&def teaching(self):&&&&&&&&print('Teacher [%s] is teaching [%s]' % (self.name, self.course))&&class Student(SchoolMember):&&&&'学生'&&&&&def __init__(self, name, age, sex, course, tuition):&&&&&&&&SchoolMember.__init__(self, name, age, sex)&&&&&&&&self.course = course&&&&&&&&self.tuition = tuition&&&&&&&&self.amount = 0&&&&&def pay_tuition(self, amount):&&&&&&&&print('student [%s] has just paied [%s]' % (self.name, amount))&&&&&&&&self.amount += amount&t1 = Teacher('Wusir', 28, 'M', 3000, 'python')t1.tell()s1 = Student('haitao', 38, 'M', 'python', 30000)s1.tell()s2 = Student('lichuang', 12, 'M', 'python', 11000)print(SchoolMember.member)del s2&print(SchoolMember.member)&&&----end-----just enrolled a new school member [haitao].----haitao----age 38sex Mname haitaoamount 0course pythontuition 30000----end-----just enrolled a new school member [lichuang].3开除了[lichuang]2开除了[Wusir]开除了[haitao]
没有更多推荐了，}