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

封装：
1.将有相关功能的代码还有变量放进方法里，方便以后的操作。
面向过程中，其按流程来走，当其中的某个变量要变动，其余的也需要变动，而不像面向对象般直接调用修改便可，且面向过程在修改的时候，若是程序过多，会加大修改的复杂程度。

2.封装的代码放进类里，为每一个对象提供调用方法和独立的变量，相互之间不影响
（1）通过调用具有相关功能的方法，能减少编程的复杂程度，提高编程效率。
（2）使用类创建实例的时候，生成的实例里的变量，虽然变量名相同，且调用的是类里的相同模块里的相同变量，但是到了单独的实例里面，它们便是毫无瓜葛的独立变量，即使变量名相同。

继承：

1.父类、子类的定义
父类：也称为基类，定义的是所有子类的共同特性（共同的特性，指的是大家都有的，而不是独特的存在，例如:大多鸟类都会飞行，飞行便是共同特性，鸟大部分都拥有翅膀）
子类：也称为派生类，子类可以继承父类的属性和方法
子类继承父类，个数不限，可以继承多个父类，也可以只继承一个父类

2.父子类关系：可以说子类是父类，但不能说父类是子类
子类Isinstance父类 True
父类isinstance子类 False
例子:苹果属于水果，水果不单单只有苹果
苹果 =水果
水果 ！=苹果

3.构造函数
init(),也被称为初始化函数,子类在继承的时候，会继承父类的方法和属性,方法中的初始化函数(构造函数)init()也一并继承,对象实例化后，会运行父类的init()方法。
若是即将继承父类的子类有初始化函数(构造器)init()，则子类继承其属性和方法，运行自己本身的构造器（初始化函数）__init()

若是子类不创建构造函数（初始化函数）init()，则默认继承父类的初始化函数（运行父类的初始化函数），若是子类想要自己创建初始化函数输出，并运行父类的构架器（初始化函数）init(),有两种方法

第一种方法：父类.init(self，参数) 参数是实例变量，也可以使类变量
（）里面若是有参数，添加参数进去，没有参数不用填写
若是父类有参数，一定要写，下面的就是因为在父类.init(self)里面没有参数，子类的初始化函数（构架器）里没有父类的全部参数，以及调用没有参数所以才报错。或者也可以不再init(self)里边放其他参数：
class Base(object):
def init(self, name, age, height, weight):
self.name = ‘li’
self.age = 15
self.height = 54
self.weight = 69
print(‘我是Base父类构造器’)

class A(Base):
def init(self):
Base.init(self)
# super(A, self).init()
print(‘我是子类A的构造器’)

a = A()
报错：
TypeError: init() takes 1 positional argument but 5 were given

正确调用：
class Base(object):
def init(self):
self.name = ‘li’
self.age = 15
self.height = 54
self.weight = 69
print(‘我是Base父类构造器’)

class A(Base):
def init(self):
Base.init(self)
self.kk = ‘yyy’
# super(A, self).init()
print(‘我是子类A的构造器’)

a = A()
print(a.name)

正确调用：
class Base(object):
def init(self, name, age, height, weight):

    print('我是Base父类构造器')

class A(Base):
def init(self, name, age, height, weight):
Base.init(self, name, age, height, weight)
self.kk = ‘yyy’
# super(A, self).init()
print(‘我是子类A的构造器’)

a = A(1, 2, 6, 8)

第二种方法：super(子类，self).init()或者super().init()

当父类初始化函数里没有参数时，子类里的初始化函数以及super的初始化里不用放入参数，若是父类有参数的话，子类的初始化函数以及super的初始化里面要放入参数
错误使用方式：NameError: name ‘age’ is not defined
class Base(object):
def init(self,age):
# self.age = 15
print(‘我是Base父类构造器’)

class A(Base):
def init(self):
super(A, self).init(age)
print(‘我是子类A的构造器’)

a = A()

正确使用
class Base(object):
def init(self,age):
# self.age = 15
print(‘我是Base父类构造器’)

class A(Base):
def init(self,age):
super(A, self).init(age)
print(‘我是子类A的构造器’)

a = A(6)

正确使用
class Base(object):
def init(self):
self.age = 15
print(‘我是Base父类构造器’)

class A(Base):
def init(self):
super(A, self).init()
print(‘我是子类A的构造器’)

a = A()

初始化函数（构架器）中的参数名称之间用逗号分隔开
def init(self,age):

创建实例
其中a是变量，A是类，若是有参数的话，（）里要放参数，实参
创建实例的时候，若是初始化中有打印，实例化的时候会打印
a = A（）

class Base(object):
def init(self):
# self.age = 15
print(‘我是Base父类构造器’)
b = Base()

继承：
单个继承
class BaseMode(object):
pass
这其实也算是单个继承吧
备注：object是一切的父类，可以不写()或者(object),写的话表示显示继承，不写表示隐式

1.简单的继承，子类没有初始化函数init()，默认运行父类的初始化函数（构架器）。

输出：

2.当子类拥有自己的构造函数的时候，运行本身的构造器，继承父类的方法和属性。
. `

输出：

Super继承父类的init（）方法，和在子类中编写父类的构造方法继承父类
1、父类.init(self,参数)
2、super(子类, self).init(参数)

class People(object):

def __init__(self, name, age):
    self.name = name
    self.age = age
    print('我是基类的构造器')

class Child(People):
def init(self, name, age, height): # 赋给子类属性，同时继承父类的属性
People.init(self, name, age)
self.height = height
print(‘我是个小孩，我的名字是%s,我的年龄是:%d，我的身高是%d’ % (self.name, self.age, self.height))
child = Child(‘小明’, 5, 30)

赋予子类新的属性，同时继承父类的属性

其中super(子类, self).init() 或super()init()为 深度继承
父类.init(self.参数)为广度继承
深度继承和广度继承
深度是层层递进继承 深度继承的时候，若有相同的后者覆盖前者的初始化函数，广度继承，会有重复的内容被继承下来

总结单个继承：
子类：有初始化
为了让子类自己初始化不影响子类本身的继承，用super或调用父类构造函数进子类里，
这样不仅能继承，子类还能添加属性
若是子类有初始化函数，则运行子类的初始化函数，能调用访问父类的属性和方法
子类：无初始化
若子类没有初始化函数，运行父类的初始化函数，继承父类方法和属性，方法。

多继承
使用super
子类继承多个父类
例如class D(C, B, A):
pass
B继承A,C继承B，D继承C
所以先输出A的父类——A—B—C—D
这个继承的时候，即使是有相同的构造函数，一样会去继承会打印输出。而不是像super一般，有了相同的则会不输出。

1、父类.init(self,参数)
2、super(子类, self).init(参数)

广度继承
用父类.init（self，参数）

class Base(object):
def init(self):
print(‘我是Base父类构造器’)

class A(Base):
def init(self):
Base.init(self)
print(‘我是子类A的构造器’)

class B(Base):
name = ‘abc’
def init(self):
Base.init(self)
print(‘我是子类B的构造器’)

class D(A, B):
def init(self):
A.init(self)
B.init(self)
print(‘我是子类D的构造器’)

d = D()

输出：
我是Base父类构造器
我是子类A的构造器
我是Base父类构造器
我是子类B的构造器
我是子类D的构造器

若是父类里边没有super，和另外一种用类名的引入父类的初始化，当子类从父类继承一个构造器之后，子类有了构造器之后，运行它拥有的构造器，故而输出接收到的第一个类

class A(object):
def init(self):
print(‘我是方法A’)

class B(object):
def init(self):
print(‘我是方法B’)

class C(B, A):
pass
c = C()

输出：
我是方法B

[备注：学了一个多月初学者的笔记，笔记的内容是用world写了然后复制粘贴的，所以程序才是这种模样。另外可能是初学者的问题，在语言的描述以及内容上，可能会出现错误，因为没什么空余时间，大致上不会再进行文章的修改]