Python进阶系列：（一）面向对象编程之类、封装、继承、多态

---

前言

Python系列文章主要是记录自己学习成果及知识输出整合，提供一个温故而知新的场所。
注意建立自己面向对象编程的思路
面向对象编程：object oriendted programming(oop)
定义：通过对象把程序的逻辑及数据进行封装，通过外部进行访问，从而实现提高代码的重用性、灵活性及扩展性

---

一、类、对象、属性、方法

1. 什么是对象？

一切皆是对象，对象也是程序的基本单元

2.定义对象

比如：所有人、所有动物
有些对象存在一些相同的行为+相同的属性
那么把这些对象的相同行为、相同属性归到一个类别里，就有了人类、动物类、植物类

3.在面向对象编程中，通过类（Class）来实现

类：用来描述具有相同属性、相同行为的对象的集合
定义类：

Class 类名:
	类主体（描述对象的相同属性及行为）
	
class CrateClass:
	# 以下类主体（描述对象=属性+方法）

	# 对象的数据：属性
	name = ''
	# 对象的行为：方法
	def action(self):
		print('会写代码，是大佬')
# 类不指具体某个对象：类=对象的集合
# 那如何描述具体某个对象？需要进行类的实例化，类的实例化=对象
# 类的实例化 变量名=类名()
CC = CrateClass()
# 对象调用执行某个行为
CC.action()
# 假设有两个对象，张三和李四，都会写代码，符合这个类，都要用到action这个方法
# 首先实例化对象
zs = CrateClass()
ls = CrateClass()
# 然后调用类中的方法
zs.action()
ls.action()	

4.构造方法

class CrateClass:
	def __init__(self, name):
		"""构造方法"""
		# 实例属性，self表示当前类的实例
		self.name = name
	
cc = CrateClass('AA')
bb = CrateClass('BB')

5.类的内置属性

类名.__dict__:类的属性（包含一个字典，由类的数据属性组成）
类名.__doc__:类的文档字符串
类名.__name__:类名
类名.__module__:类定义所在的模块（类的全名是'__main__.className',如果类位于一个导入模块mymod中，那么className.__module__等于mymod）
类名.__bases__:类的所有父类构成元素（包含了一个由所有父类组成的元组）

6.类的方法

"""实例方法:
第一个参数必须是self的函数（实例方法只能通过对象来引用）
"""
class CrateClass:
    def __init__(self, name):
        """构造方法"""
# 实例属性，self表示当前类的实例
        self.name = name
    def action(self):
        print('会写代码，是大佬')
    
    @classmethod（类方法）
    def class_founction(cls):
        print('这是一个类方法')
	
	@staticmethod（静态方法）
    def j_founction():
        print('这是一个静态方法')

shil = CrateClass('实例')
# 通过对象来引用
shil.action()

"""类方法：
由@classmethod装饰的方法，它的第一个参数不是self，是cls，他表示这个类的本身，可以被类或者类的对象调用
如果方法体中需要涉及调用类的属性及方法，那么可以考虑用类方法实现
"""
# 类方法
shil.class_founction()
CrateClass.class_founction()


"""静态方法：
由@staticmethod装饰的方法，默认是没有参数，可以当做一个普通的函数来使用，只是它定义在类中，如果需要实现的业务不依赖于类中的任何属性及方法，则可以定义一个静态方法（比如：获取系统时间）
可以被类或类的对象引用
"""
# 静态方法
shil.j_founction()
CrateClass.j_founction()

7.内置方法

"""
python中常用的内置方法
"""
# __init__(self,....):构造方法，在生产对象时调用可以用来进行一些初始化操作，不需要显示去调用，系统会默认去执行
# __del__(self,.....)：析构方法，在释放对象时调用（创建的对象不再有操作后，会自动去执行），支持重载，不需要显示调用
    def __del__(self):
        print('创建的对象执行完后，会释放对象的内存地址，每个对象都会默认执行一次')
# __str__(self,.....):自定义实例输出方法，写好该方法后，替换实例默认的输出操作
    def __str__(self):
        return 'Heloise'

# __str__  通过对象来默认调用
print(shil)
# __getattribute(self,.):获取实例属性的值，可直接结合对象使用
    def __getattribute__(self, item):
        if item == 'num':
            return '人数'

# __getattribute__(self,.) 获取实例属性的值，可直接结合对象使用
print(shil.num)

8.私有属性及私有方法

"""
私有属性/私有方法：必须以双下划线开头，只能类内部进行访问
"""
class CrateClass:
	def __init__(self):
		# 私有属性，只能在类的内部调用
		self.__name = 'simple'
	# 私有方法
	def __sample(self):
		self.__name = '张三'
		print(f'我的名字是{self.__name}1号')
	def myname(self):
		# 调用私有方法
		self.__sample()
		print(f'我的名字是{self.__name}2号')

sample = CrateClass()
sample.myname()
print(sample._CrateClass__name)

# 私有方法
sample.myname()

---

二、封装、继承、多态

1.封装

面向对象编程的三大特征：封装、继承、多态
什么是封装？
    封装可以理解为将代码放入一个盒子，这个盒子可以是类、方法、函数。
    封装的目的为了保证变量的安全性，使用者不必在意具体实现细节，而只是通过外部调用即可以访问类的属性及方法。
    封装的具体体现：
        通过类的定义
        通过方法的定义
        从而实现代码的复用性

"""将代码封装到函数"""
# 示例：计算几个数之和，假设1+2+3=。。或2+5+8+9=。。不定长加法
# 那使用封装的思路就是定义一个函数，如 sum(*agrs),*agrs表示无论传入几个值都会将这几个值放入一个元组中，这样我们需要计算几个数之和的时候，
#就可以直接调用sum(*agrs)这个函数，而不用管函数里面的逻辑是怎么实现的,也不用自己重新写逻辑直接复用方法就行
def sum(*agrs):
    sum = 0
    for i in agrs:
        sum = sum + i
    return sum

print(sum(2, 5))

"""将代码封装到类"""
"""
面向对象编程的示例：
小明爱跑步
每次跑步会减肥0.5公斤
每次吃东西体重会增加1公斤
小美的体重是45公斤

思路：
1、找出需求中的对象：小明，小美  定义类--通过实例化类（获取对象）
对象=属性+行为（方法）
属性：名字 体重
方法：跑步 吃东西

"""
class people:
    # 属性:名字 体重
    # 初始化数据
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight

    # 方法
    def running(self):
        """
        跑步会减0.5
        """
        self.weight -= 0.5
        print(f'跑步会减肥0.5，{self.name}当前体重{self.weight}')
    def eat(self):
        """
        吃东西会增加0.5
        """
        self.weight += 0.5
        print(f'吃东西会增加0.5，{self.name}当前体重{self.weight}')

if __name__ == '__main__':
    # main表示当前模块，当程序执行的是当前模块的时候，会执行以下代码，如果上面类被其他代码调用了，在别的模块执行类，下面代码就不会执行
    xiaoming = people('小明', 75)
    xiaomei = people('小美', 45)
    xiaomei.eat()
    xiaoming.running()

"""
示例二：洗衣机洗衣服   放入衣服（人）  放入洗衣液（人）  清洗（洗衣机）  烘干（洗衣机）
面向对象编程思路：
找出需求中的对象： 洗衣机 人
定义两个类
洗衣机：
    属性：衣服、洗衣液
    方法：洗衣、烘干
人：
    属性：
    方法：放衣服、放洗衣液
"""
class wash_machine:
    # 洗衣机的属性
    def __init__(self):
        self.chothes = 0
        self.cleanagent = 0
    # 洗衣机的方法
    def washing(self):
        """洗衣"""
        # 判断洗衣机是否有衣物+洗衣液
        if self.chothes == 0:
            raise Exception('请放入衣服')
        elif self.cleanagent == 0:
            raise Exception('请放入洗衣液')
        else:
            print('开始清洗......结束清洗')

    def drying(self):
        """烘干"""
        if self.chothes == 0:
            raise Exception('主人请放入衣服')
        else:
            print('开始烘干......结束烘干')


class wash_people:
    # 属性
    def __init__(self, name):
        self.name = name
    # 方法
    def input_chothes(self,num, machine1:wash_machine): # 相当于放几件衣服放到洗衣机类里面，两个类要联系起来，相当于创建了一个wash_machine的对象
        """放入衣服"""
        # 衣服数量赋值洗衣机类的实例属性  洗衣机对象.chothes=num
        machine1.chothes=num
        print(f'已放入衣服：{num} 件')
    def input_cleanagent(self, num, machine1:wash_machine):
        """放入洗衣液"""
        machine1.cleanagent=num
        print(f'已放入洗衣液：{num} 毫升')

    def wash(self, machine:wash_machine, chothes_num, cleanagent_num):
        """按下清洗按钮"""
        print(f'{self.name}在操作洗衣机')
        self.input_chothes(chothes_num, haier)
        self.input_cleanagent(cleanagent_num, haier)
        # 洗衣机清洗
        machine.washing()
        # 洗衣机烘干
        machine.drying()


if __name__ == '__main__':
    # main表示当前模块，当程序执行的是当前模块的时候，会执行以下代码，如果上面类被其他代码调用了，在别的模块执行类，下面代码就不会执行
    # 张三开始洗衣服
    zhangs = wash_people('张三')
    haier = wash_machine()
    zhangs.wash(haier, 5, 10)

2.继承

什么是继承？

• 一个类（子类或派生类）继承另一个类（基类或父类）
• 继承基类的方法，并且做出自己的改变或扩展
• 子类共用的一些方法和属性直接调用父类，而不需要自己另外再定义，只需要扩展个性化

二、子类和父类之间的关系
1、子类可以使用父类的属性及方法（实现代码的重用，相同代码不需要重复编写）
2、子类调用方法，先找自己，再找父类，再找父类的父类。。。
3、子类不能继承父类的私有方法及属性
4、子类可以重写父类的方法
        1、覆盖父类的方法
        2、扩展父类的方法
            执行原来的业务逻辑+扩展功能

三、继承分为单继承，多继承
单继承：一个类继承另外一个类
多继承：一个类继承多个类
注意：
某个类存在多继承，在执行某个方法时候，先找自己，然后再按照就近原则的方式找父类

class Animail:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print('吃东西')

    def __test(self):
        print('父类的私有方法')
# 定义一个猫类，定义类的可以共用其他类的方法或属性就可以使用继承，如，猫类可以继承上面的动物类， class cat(Animail)括号里面就是父类
class Cat(Animail):
    def eat(self):
        # 执行父类原来的业务代码  父类名.方法名（self）
        Animail.eat(self)
        print('在吃鱼')

if __name__ == '__main__':
    cat = Cat('ff', 2)
    cat.eat()

3.多态

"""
多态
    不同的类对象调用相同的方法，产生不同的执行结果（呈现多态的形态）
"""

# 示例 :支付渠道：微信支付  支付宝支付  银联支付 --> 三个行为
# 因为渠道不一样，一个渠道归为一个类，那么应该创建三个类
class wx:
    """微信类"""
    def pay(self):
        self.name = '微信'
        print('微信支付')

class yl:
    """银联类"""
    def pay(self):
        self.name = '银联'
        print('银联支付')

class zfb:
    """支付宝类"""
    def pay(self):
        self.name = '支付宝'
        print('支付宝支付')

# 那么使用那种支付方式来买东西，我们可以创建一个选择支付方式的函数
def demo_pay(object):  # object随便定义，这里只是做个例子
    """商品支持各种支付：微信、支付宝、银联"""
    object.pay()
    print(f'通过{object.name}方式支付完成')

# 实例化支付方式的对象
wx = wx()  # 创建微信的对象
yl = yl()
zfb = zfb()
demo_pay(yl)

---

总结

以上就是文章要表达的内容，本文简单介绍了Python的类、对象、属性、方法及面向对象编程的三大特征（封装、继承、多态）的概念以及应用。