# -- coding: utf-8 --# @Time : 2022/8/29 16:31# @Author : siyu.yang# @File : demo_05.py# @desc : 第五章# 面向对象继续概念# 创建类和对象# 属性 、 方法# 三大特性之封装实现# 三大特性之继承实现# 抽象类# 三大特性之多态实现#                          面向对象基础概念#    python 是解释性语言，但是它同时和java等高级语言一样，可以采用面向对象的编程# 思想和方式进行编程。# 什么是面向对象(Object Oriented)?#     面向对象是一种程序设计设计方阿飞，它以对象作为基本的单元来构建系统，它利用对象# 将系统的复杂性隐形在对象里，从而构建出系统。面向对象包括三个过程：面向对象分析(OOA)# 、面向对象设计(OOD)、面向对象编程(OOP).# * 面向对象分析指的是分析要开发的系统的各个方面，从而找出类和对象# * 面向对象设计指我们设计出一些特殊的类(如：抽象类)来表达系统种不通对象的共性和机制，# 系统的对象相互协作，满足系统需要实现功能的设计过程；# * 面向对象编程指我们能用特定的面型对象编程语言实现我们的设计，实现系统种的对象和类# 的过程。# 即：# 面向对象# 类：具有相同特征和行为的某一类事物的总称，是抽象化出来的。# 对象：类中具体的实例'''# 狗-----颜色、身高、体重（属性）  抓老鼠、看家（方法）class Dog:    # class 类名    color = '黄色'   # 类属性    height = '60cm'    weight = 30    # 类中的方法都会自带self参数，标识当前类的所有的属性和方法    def catch_the_mouse(self):        print('我会抓老鼠')    def eat(self):        print('我需要吃饭')# 创建对象 对象名 = 类名（）tom = Dog()tom.color = '黄色'tom.height = '30cm'jeck = Dog()print('颜色：{}，身高：{}，体重：{}'.format(tom.color,tom.height,tom.weight))tom.catch_the_mouse()print('颜色：{}，身高：{}，体重：{}'.format(jeck.color,jeck.height,jeck.weight))jeck.eat()'''# 世界是由深组成的？ ---- 万物皆可是对象# 对象的特性 ---- 属性# 属性 ---- 对象具有的各种特性# 每个对象的每个属性都拥有特定值# 对象的特征 ---- 方法# 方法 ---- 对象执行的操作# 类是对象的类型#  不同于一般数据类型：具有方法'''# 练习1：# 创建一个猫类：属性 品种、价格、颜色   方法--- 睡觉、吃鱼、被撸# 创建一个对象对该类进行测试，输出改对象的所有信息class Cat:    name = '喵星人'  # 类属性    # 构造方法    def __init__(self,bread,color,price):   # 实例属性        self.bread = bread        self.color = color        self.price = price    def sleep(self):        print('我喜欢睡觉')    def eat_fish(self):        print('我喜欢吃鱼')    def bei_lu(self):        print('我喜欢被主人撸')tom = Cat('星罗猫','白色',2000)jeck = Cat('狸花猫','渐变色',1500)print(tom.name)print(jeck.name)print('种类：{}，颜色：{}，价格：{}'.format(tom.bread,tom.color,tom.price))print('种类：{}，颜色：{}，价格：{}'.format(jeck.bread,jeck.color,jeck.price))tom.sleep()jeck.eat_fish()'''# 关于抽象的而理解：# 把相同的或相似的对象归为一类的这个过程就是抽象，所以，抽象就是分析文件的方法；# 抽象程度基本原则：#   只关心主要问题，而不关系次要问题；#   只关心主要矛盾，尔不关系次要矛盾；#   只关心相同的东西，而不关心不通的东西；#   只关心问题是什么，能够完成什么，而不关系怎么样区完成。#  抽象的过程其实就是面向对象编程的核心思想# 类和对象有什么区别？#  - 类士抽象的概念，仅仅是模板，比如说‘人’#  - 对象是一个你能看得到、摸得着的具体实体，#                             创建类和对象# python实现类的语法：# class ClassName:#       '类的帮助信息'   # 类文档字符串#       class_suit    # 类体#      在class_suit里面就可以定义属性、方法、实例属性等。但一个类定义完成之后，就#   产生了一个类对象。类对象支持两种操作：引用和实例化。引用操作是通过类对象区调用#   类种的属性或者方法，而实例化是产生出一个类对象的实例，称作实例对象。# 创建实例对象语法：# objectName = ClassName(args) # 其中args初始化参数列表# 访问属性# 可以使用. 来访问对象的属性# 举例：'''class people:    name = '人类'  # 类属性    def __init__(self,name,age):        self.name = name  # 实例属性        self.age = ageliuze = people('刘泽',30)      # 创建对象print(people.name)  # 访问类属性print(liuze.name)   # 访问对象属性'''# 该段代码定义了一个people类，里面定义了name属性# people.name 表示进行引用操作，类对象区应用类属性# liuze.name 表示实例化操作，实例对象去引用实例属性# python 种的类是由属性和方法组成的，具体的划分如下图：'''        属性       类属性                  实例属性（私有）                  内置属性类       方法       构造方法                   类方法                   实例方法(私有)                   静态方法                   内置方法'''# 类属性：类对象的属性，如之前例子中 name = '人类'# 实例属性：通过实例化对象后，对象可以使用的属性，如print(liuze.name)# 私有属性：在类中，两个下划线开头，声明该属性属于私有，不能在类的外部被使用或# 直接访问，在类内部的方法中使用时 self.__private_attrs; 也可以使用object.# __className_attrName(对象名._类名_私有属性名) 访问属性# 内置属性：python 类中系统默认自带的属性# 内置属性如下：# _dict_:类的属性(包含一个字典，由类的数据属性组成)# _doc_ : 类的文档字符串# _name_: 类名# _module_:类定义所在的模块(类的全名是‘_main_.className’),如果类位于一个# 导入模块mymod中，那么className._module_ 等于mymod)# _bases_:类的所有父类构成元素(包含了一个由所有父类组成的元组)'''#  创建一个人类，属性：姓名、年龄、性别   使用构造方法完成class People:    # 我是People类，是类说明，只能放在类名下面    name = '好人'    def __init__(self,name,age,sex):        self.name = name        self.age = age        self.sex = sexPerson1 = People('Michael',32,'formal')# 内置属性：python类中系统默认自带的属性# 类名.内置属性print(People.__dict__)   # 类属性print(People.__doc__)    # 类的文档字符串， 类说明print(People.__name__)   # 返回类名print(People.__module__)  # 类定义所在模块print(People.__base__)     # 类的父类，如果没有默认就是object'''#                              属性、方法# 构造方法：#    构造方法是负责对象成员初始化工作，为实例变量(对象属性)赋予合适的初始化值#    在python中构造方法使用的是__init__()方法，当创建了这个类的实例时就会#    调用该方法# self 是什么？#    在上页PPT的例子中，构造方法中第一个形参为self，它代表类的实例。在python# 中，slef在定义类的方法时必须有一个参数，且必须是第一个参数，但我们在调用# 类的方法时不需要传入相应的参数。是否方法中存在self也是区分类的方法与普通的函数# 的一个标识。#     self 不是python 关键字，我们把它换成其它的也是可以正常执行的。但建议用# self。如下：'''def __init__(this,name,age): # 可以改为this    this.name = name    this.age = age'''# 实例方法#    在类中最常定义的成员方法，它至少有一个参数并且必须以实例对象作为其第一个参数，# 一般以名为‘self’的变量作为第一个参数。(注意：不能通过类对象引用实例方法)#    在实例方法中，以两个下划线开头，则表示改方法为私有方法，不能在类外部调用。在类# 的内部调用方法： self.__private_methods,在外部调用方法：实例._方法名()# 举例如下：'''class people:    def __init__(self,name):        self.name = name        def getName(self):        return self.name    def __say(self,con):        print(self.name+'说：'+con)liuze = people('刘泽')print(liuze.getName())  # 通过实例对象引用liuze._people__say('你好') # 外部调用私有方法'''# 类方法#    时类对象所拥有的方法，需要用修饰器“@classmethod”来标识其它类方法，它能够# 够通过实现对象和类对象去访问。类方法的用途就是可以对类属性进行修改。对于类方法，# 第一个参数必须是类对象，一般以"cls"作为抵押给参数。# 静态方法：#    需要通过修饰器“@staticmethod”来进行修饰，静态方法不需要多定义参数。类和实例# 都能调用。'''class country:    name = 'china'    @classmethod    def setName(cls,name):  #类方法        cls.name = name    @staticmethod    def getName():  # 静态方法        print(country.name)''''''# 属性：类属性、实例属性、了内置属性# 方法：类方法、实例方法、静态方法class People:    name = '无名氏'   # 类属性    def __init__(self,name,age,sex):   # 实例属性        self.name = name        self.age = age        self.sex = sex    def say(self):   # 实例方法,类当中的普通方法        print('我是实例方法 say() ')    @classmethod    # 修饰器，它下main的方法就是类方法    def sleep(cls): # 类方法的第一个参数默认就是cls        print('我是类方法 sleep() ')    @staticmethod     # 它下面的方法就是静态方法    def goto_wc():    # 静态方法不会带默认的参数        print('我是静态方法 goto_wc()')tom = People('汤姆',22,'男')# 1、可以通过 类和对象 访问类属性print(People.name)print(tom.name)# 2、只能通过对象 访问实例属性# print(People.age)print(tom.age)# 3、可以通过 类和对象 访问内置属性,但是还值是不一样的print(People.__dict__)print(tom.__dict__)# 4、可以通过 类和对象 访问类方法print(People.sleep())print(tom.sleep())# 5、通过对象 访问实例方法# People.say()   # 通过类直接访问时，它会被当作一个普通方法啊，所以需要对self传参tom.say()# 6、可以通过 类和对象 访问静态方法People.goto_wc()tom.goto_wc()'''# 常用内置方法：#    在 python 中有一些内置的方法，这些方法命名都有比较特殊的地方(其方法名以2个下划线)# 开始然后以2个下划线结束。#     1、__init__(self,.....): 构造方法，在生成对象时调用，可以用来进行一些初始化# 操作，不需要显示去调用，系统回默认去执行。构造方法支持重载，如果用户自己没有重新定义构# 造方法，系统就会自动执行默认的构造方法。#     2、__del__(self,......): 析构方法，在释放对象时调用，支持重载，可以在里面进行一些释# 放资源的操作，不需要显示调用#     3、__str__(self,.......): 自定义实例输出方法，写好改方法后，替换实例默认的输出操作。#     4、__add__(self,......): 两个实例的加法操作。#     5、__getattribute__(.....): 获取实例属性的值，柯直接结合对象使用。'''# 内置方法class People:    # 1、构造方法，支持重载(使用最后一个)    def __init__(self, name, age):        self.name = name        self.age = age    # def __init__(self, name):    #     self.name = name    # 2、析构方法，作用时释放资源    def __del__(self):        print('我是析构方法，作用是释放资源')    # 3、自定义输出方法    def __str__(self):        return '我是默认的str实例输出方法'    # 4、两个实例的加法操作    def __add__(self, other):        return self.name + other.namezs = People('张三',20)tom = People('tom',15)print(zs+tom)print(zs)# del zs# print(zs.name)'''#                              面向对象编程三大特性#    面向对象编程三大特性：封装，继承和多态# 封装：#    面向对象的程序设计中，某个类把所需要的数据（也可以说是类的属性）和对数据的操作# （也可以说是类的行为）全部封装在类中，分别称为类的成员变量和方法（或成员函数），这# 种把成员变量和成员函数封装在一起的编程特性称为封装。'''# 封装： 数据封装、方法封装class People:    # 1、构造方法，支持重载(使用最后一个)    def __init__(self, name, age,money):        self.name = name        self.age = age        # 私有属性：只能在类的内部使用，类外部访问不来（数据封装）        self.__money = money    # 方法封装    def get_money(self):        return self.__money    def set_money(self,m):        self.__money = mzs = People('张三',20,100)zs.set_money(200)print('我叫{}，我有{}块钱！'.format(zs.name,zs.get_money()))'''# 继承：#    继承也指可以使用现有类的所有功能，并在无重新编写原来的类的情况下对这些功能进行扩展# 多态：#    多态指的是一类事务有多种形态。如序列类型有多种形态：字符串，列表，元组；动物有多种# 形态：牛、狗、猪#    多态性是允许你将父对象设置称为和一个或更多的他的子对象相等的技术，赋值之后，父对象# 就可以根据当前赋值给它的子对象的特性以不同的方式运作。# 封装分为数据封装与方法封装#    数据封装即把对象的属性具体的值隐藏起来，对外显示的只是对象的属性名。比如刘泽的名字，# 钱包里的钱等。#    方法封装即对外只需要通过方法就能调用方法，而不选哟了解具体方法种的细节。比如洗衣机# 按洗衣的功能按钮，就能进行洗衣，我们不需要知道这个过程中的原理；在用支付宝进行付款的时候，# 只需要在用的时候把二维码给收款方或是扫一下收款方提供的二维码就可以完成支付，不需要# 知道支付宝的支付接口，以及后台处理数据的能力等。#    封装的而作用：封装数据的主要原因是保护隐私；封装方法的而主要原因是隔离复杂度。# 封装分为两个层面：# 第一层面的封面：创建类和对象时，分别创建两种的名称空间。只能通过类名加“.”或者obj# .的方式访问里面的名字。# 第二层面的封装，类种把某些属性和方法隐藏起来，或者定义为私有，只在类的内部使用，在类# 的外部无法访问，或者留下少量的接口（函数）供外部访问#    当我们定义一个class 的时候，可以从某个现有的class继承属性和方法，新的class# 称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class，Super# class）。如下图:'''              object    Animal             Plant  Dog        Cat     Tree      Flower'''#    在python中，object类时所有类的父类。Python3 中默认都是继承object ,称为# 新式类；在python2中，不能指定继承object类的类称为经典类。# 继承的语法如下；# class 派生类名（基类名）：#    ...# 举例：'''class Parent:  # 定义父类    parentAttr = 100    def __init__(self):        print("调用父类的构造函数")    def parentMethod(self):        print("调用父类的方法")class Child(Parent):    def __init__(self):        print("调用子类构造方法")    def childMethod(self):        print("调用子类方法")child_01 = Child()child_01.parentMethod()  # 调用父类的方法print(child_01.parentAttr) # 调用父类的属性child_01.childMethod()   # 调用自己的方法# 继承：一个类(子类)获取另外一个类（父类）的属性和方法的过程# 人类：name,age,sex   方法:say()   sleep()# 学生： name、age、sex、class、id  方法：say()  sleep()   study()class People:    def __init__(self,name,age,sex):   #私有的方法和属性是不能被继承的        self.name = name        self.age = age        self.sex = sex    def say(self):        print('我是people类的say()方法。')     def sleep(self):        print('我是people类的sleep()方法。')class Student(People):     # 父类是people    # 当子类由构造方法的时候，子类必须实现父类的构造方法    def __init__(self,name,age,sex,class_name,id):       # 1.父类名.__init__()  必须传self        People.__init__(self,name,age,sex)        # 2.super().__init__() 不需要传self        super().__init__(name,age,sex)        # 3.super(子类,self).__init()        super(Student,self).__init__(name,age,sex)        self.class_name = class_name        self.id = id    def study(self):    # 子类重写父类方法，子类对象会优先调用自己方法        print('study()！！！')    def say(self):        print('我是学生类中的say()!!!1')zs = Student('张三',21,'男','火箭班','1班')print(zs.class_name,zs.id)zs.sleep()zs.say()zs.study()'''# isinstance() 及 issubclass()#    python 与其他语言不同点在于，当我们定义一个class 的时候，我们实际上就定义了一个# 数据类型。我们定义的数据类型和 Python 自带的数据类型,比如： str、list、dict没什么# 两样。#    python 有两个判断继承的函数： isinstance(obj,Class)用于检查实例类；# issubclass(sub,sup)用于检查类继承。# python 中的继承特定#    1）在 Python 中,如果父类和子类都重新定义构造方法__init__(),在进行子类实例化的# 时候，子类的构造方法不会自动调用父类的构造方法，必须在子类中显示调用。#    2）如果需要在子类中调用父类的方法：需要以 父类名.方法 这种方式调用，以这种方式# 调用的时候，注意：要传递self参数过去；另一种方法啊是使用super(),直接使用super()# .xxx 或 super(Class,self).xxx#    3) Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才# 开始到基类中逐个查找。（现在本类中查找调用方法，找不到才去基类中找）#    4）对于继承关系，子类继承父类所有的共有的属性和方法，可以在子类中通过父类名来调用，# 而对于私有的属性和方法，子类时不进行继承的，因此子类中无法通过父类名来访问的。#    5）python中支持多继承，能够让又给子类有多个父类。如果有多个父类，多个父类名之间# 用都好隔开。#                        class SubClass(SuperClass1,SuperClass2)#     如果SubClass没有重新定义构造方法，它自动调用第一个父类的构造方法，以第一个父类# 为中心。#     如果Subclass 没有定义构造方法，需要显示去调用父类的构造方法，此时调用那个父类# 的构造方法由你自己决定；若SubClass 没有重新定义构造方法，则只会执行第一个父类的构造# 方法。并且若SuperClass1和SuperClass2中有同名的方法，通过子类的实例化对象去# 调用改方法时嗲用的时第一个父类中的方法。# 实例：'''class UniversityMember:    def __init__(self,name,age):        self.name = name        self.age = age    def getName(self):        return self.nameclass Student(UniversityMember):    def __init__(self,name,age,sno,mark):        UniversityMember.__init__(self,name,age)  # 注意显示调用父类构造方法        self.sno = sno        self.mark = mark    def getMark(self):        return self.mark    # 代码解释：大学中的每个成员都有姓名和名称，而学生有学号和分数2个属性，大学成员    # 为父类，学生为子类# 多继承：一个子类可以有多个父类# 人类、动物 --- 学生class People:    def __init__(self, name):        self.name = name    def say(self):        print('我是people类')class Animal:    def __init__(self, age):        self.age = age    def say(self):        print('我是Animal类')class Student(People, Animal):   # 多继承    # 当父类中有同名的方法时，按照继承的先后顺序调用    # 实现多个父类构造方法(非必须实现)    def __init__(self, name, age, id):        People.__init__(self,name)        Animal.__init__(self,age)        self.id = id    #    # def say(self):    #     print('我是一个好学生')zs = Student('张三', 16, 11)print(zs.name)print(zs.age)print(zs.id)zs.say()'''#                         抽 象 类#    抽象类是包含抽象方法的类，而抽象方法不包含任可实现的代码，只能在其子类中实现抽象# 函数的代码。# 为什么要有抽象的类？#    如果说类是从一堆对象中抽象相同的内容而来的，那么抽象类就是从一堆类中抽取形同# 内容来的，内容包括数据属性和函数属性。#     比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类中抽取相同的内容就是水果# 这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么吃一个具体的桃子，你永远无法# 吃到一个叫做水果的食物。#     在定义抽象时需要在类定义中加入如下代码：__metaclass__ABCmeta,即指定该类# 的元类时ABCmeta。所谓元类就是创建类的类。#     在定义抽象方法时需要在前面加入如下代码：@abstractmethod 因为抽象方法不包含# 任何可实现的代码，因此其函数体通常使用pass# 抽象类实现举例；'''from abc import ABCMeta, abstractmethodclass People:    __metaclass__ = ABCMeta    @abstractmethod    def set_name(self):        passclass Student(People):    def set_name(self, name):  # 参数个数不同,重载        print('Student,set_name = %s' % name)        # 抽象类：# 1.必须包含抽象方法# 2.抽象方法只声明不实现# 3.抽象类就是用来被继承的，子类必须实现父类的抽象方法。from abc import abstractmethod, ABCMetaclass Animal(metaclass=ABCMeta):  # 这种方式子类继承Animal后必须实现    # __metclass__ = ABCMeta  # 定义抽象类，这种方式子类继承后不必须实现抽象方法【不推荐】    def __init__(self, name):        self.name = name    @abstractmethod  # 定义抽象方法修饰器    def say(self):  # 只声明不实现        passclass Cat(Animal):    def say(self):        print('实现父类抽象say()方法')    def eat(self):        print('猫喜欢吃鱼！')tom = Cat('汤姆')print(tom.name)tom.eat()tom.say()'''#    多态指的时一类事务具有多种形态，只有存在父子类关系才会让一类事物具有多种不# 同的形态，因而多态的实现过程中，经常会使用抽象类。# 举例：# 1、序列类型有多种形态：字符串，列表，元组# 2、动物有多种形态：猪，狗，牛# 多态性：#    多态性是指具有不通功能的函数可以使用相同的函数名，这样就可以用一个函数名# 调用不同的内容的函数。在面向对象方法中一般是这样表述多态性；向不通的对象发送# 同一条消息，不通对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可# 以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同# 的实现，即执行不同的函数。# 举例：#    内置函数len(object),len函数不仅可以计算字符串的长度，还可以计算列表、# 元组等对象中的数据个数，这里在运行时通过擦拭农户类型确定其具体的计算过程，正# 是多态的一种体现。# 举例编码：# 多态：一类事物具有多种形态# 多态性：只具有不同功能的函数可以使用相同的函数名'''import abcclass File(metaclass=abc.ABCMeta):  # 同一类事物：文件    @abc.abstractmethod    def click(self):        pass# 实现多态class Text(File):  # 文件的形态之一：文本文件    def click(self):        print('open file')# 实现多态class ExeFile(File):  # 文件的形态之一：可执行文件    def click(self):        print('execute file')# 多态性def openFile(obj):    obj.click()txt = Text()exe = ExeFile()# 调用openFile()实现多态性openFile(txt)openFile(exe)'''