Python-类与对象

1. 定义类与实例化
2. 继承与组合
3. 多态与鸭子形态
4. 封装与property
5. 绑定方法与非绑定方法
6. 反射与内置方法

1、定义类与实例化

1、 类即类别、种类，是面向对象设计最重要的概念，对象是特征与技能的结合体，而类则是一系列对象相似的特征与技能的结合体
2、在程序中，必须要事先定义类，然后再调用类产生对象（调用类拿到的返回值就是对象）。产生对象的类与对象之间存在关联。
3、这种关联指的是：对象可以访问到类中共有的数据与功能，所以类中的内容仍然是属于对象的，类只不过是一种节省空间、减少代码冗余的机制，面向对象编程最终的核心仍然是去使用对象。

"""
1、使用class关键字创建类，类的命名一般使用驼峰体。
2、类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
3、使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。
4、访问或修改类的属性和方法可以使用： 类.属性/方法。
5、访问或修改实例的属性和方法可以使用： self.属性/方法。
6、在属性和方法前面加(__)双下划线可以使属性和方法变成隐藏的，外部无法直接访问，仅供内部直接只访问。
7、实例化过类的对象可以使用类的所有公开的属性和方法，也可以传入参数,及该对象独有的属性。
8、__init__内置方法，在实例化类的时候执行
"""

class MyClass: 								# 定义类，类的命名应该使用“驼峰体
    a = 1  									# 定义类变量，公有属性，外部和内部都可以直接访问
    __c = 2  								# 定义类变量，隐藏属性，外部无法直接访问，仅供内部直接访问

    def __init__(self,b): 					# __init__()为类的构造函数，实例化就会执行，可以传值赋值给实例变量
        self.b = b  						# 定义实例变量，公有属性，实例化后可直接访问
        self.__d = 3  						# 定义实例变量，隐藏属性，实例化后外部无法直接访问，仅供内部直接只访问

    def __sub(self):  						# 类方法，隐藏方法，外部无法直接访问，仅供内部直接只访问
        a = 1								# 定义函数局部变量，仅函数自己使用
        self.__d -= 1  						# 通过self.属性，修改隐藏实例变量
        MyClass.__c -= 1					# 通过类.属性，修改隐藏类变量
        print('c : {}, d : {}'.format(MyClass.__c, self.__d))

    def add(self):  						# 类方法，公有方法，可以直接访问
        print('c : {}, d : {}'.format(MyClass.__c, self.__d))
        MyClass.a += 1  					# 通过类.属性，修改类变量
        self.b += 1							# 通过self.属性，修改实例变量
        self.__sub()  #						# 通过self.方法，调用隐藏方法


mm = MyClass(2)								# 实例化类得到对象
print('a : {}, b : {}'.format(mm.a, mm.b))
mm.add()  									# 实例化的对象可以直接调用类的公开的方法和属性
print('a : {}, b : {}'.format(mm.a, mm.b))

# 结果
a : 1, b : 2
c : 2, d : 3
c : 1, d : 2
a : 2, b : 3

2、继承与组合

2.1 继承

继承是一种创建新类的方式，新建的类可以继承一个或多个父类（python支持多继承），父类又可称为基类或超类，新建的类称为派生类或子类。

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): 						# 单继承，继承父类的方法和属性
    pass

class SubClass2(ParentClass1,ParentClass2):		 	# 多继承，用逗号分隔开多个继承的类
    pass

ps: 在多继承中，若是父类中有相同的方法名，而在子类使用时未指定时，则从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。

2.2 派生

当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了。

"""
1、调用父类的方法的两种方法：
	1.父类.方法				# 指名道姓，即父类名.父类方法()
	2.super().方法			# 超级方法，自动寻找父类的方法
2、重写构造函数时，需要先调用父类的构造函数，父类需要的参数也必须传值
3、重写的功能和属性不会影响父类

"""

class ParentClass:									# 定义父类
    def __init__(self, a, b):						# 定义父类的构造函数
        self.a = a									# 定义父类的实例属性
        self.b = b

    def add(self):									# 定义父类的方法
        print('{}+{}={}'.format(self.a,self.b,self.a + self.b))


class SubClass(ParentClass):						# 定义继承父类ParentClass的子类
    def __init__(self, a, b,c):						# 重写构造函数，不影响父类
        #ParentClass.__init__(self, a, b)			# 父类.__init__(self)方法继承父类的属性，父类需要的参数依旧需要传值
        super().__init__(a, b)						# super()方法继承父类的属性，父类需要的参数依旧需要传值
        self.c = c									# 定义新的实例属性

    def add(self):									# 重写方法，不影响父类
        print('{}+{}!={}'.format(self.a,self.b,self.a + self.b+1))

    def sub(self):									# 定义新的方法
        print('{}-{}={}'.format(self.a,self.b,self.a - self.b))


p = ParentClass(1, 2)								# 实例化父类
p.add()												# 调用方法
s = SubClass(1,2,3)									# 实例化子类
s.add()												# 调用方法
s.sub()

# 结果
1+2=3
1+2!=4
1-2=-1<