面向对象的三大特性是指：封装、继承和多态。

面向对象技术简介

类(Class):
用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类变量：
类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：
类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：
如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
实例变量：
定义在方法中的变量，只作用于当前实例的类。
继承：
即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，素以Dog也是一个Animal。
实例化：
创建一个类的实例，类的具体对象。
方法：
类中定义的函数。
对象：
通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。

python3 类创建

面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

类就是一个模板，模板里可以包含多个函数，函数里实现一些功能

对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

图片.png

图片.png

诶，你在这里是不是有疑问了？使用函数式编程和面向对象编程方式来执行一个“方法”时函数要比面向对象简便

• 面向对象：【创建对象】【通过对象执行方法】
• 函数编程：【执行函数】

观察上述对比答案则是肯定的，然后并非绝对，场景的不同适合其的编程方式也不同。

总结：函数式的应用场景 --> 各个函数之间是独立且无共用的数据

面向对象三大特性

面向对象的三大特性是指：封装、继承和多态。

一、封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

所以，在使用面向对象的封装特性时，需要：
将内容封装到某处
从某处调用被封装的内容

图片.png

self 是一个形式参数，
当执行 obj1 = Foo('wupeiqi', 18 ) 时，self 等于 obj1
当执行 obj2 = Foo('alex', 78 ) 时，self 等于 obj2
所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都有 name 和 age 属性，在内存里类似于下图来保存。

图片.png

第二步：从某处调用被封装的内容

调用被封装的内容时，有两种情况：

通过对象直接调用
通过self间接调用

1、通过对象直接调用被封装的内容
上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名

图片.png

2、通过self间接调用被封装的内容
执行类中的方法时，需要通过self间接调用被封装的内容

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

    def detail(self):
        print(self.name)
        print(self.age)

obj1 = Foo('cr',24)
obj1.detail()

obj2=Foo('python',99)
obj2.detail()
# Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 python ； self.age 是 99

图片.png

3、通过把属性的名称前加上两个下划线__

实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问。

class Student(object):

    def __init__(self, name, score):
        self.__name = name
        self.__score = score

    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))
        

如果外部代码要获取name和score怎么办？可以给Student类增加get_name和get_score这样的方法：

class Student(object):
    #这里的代码和上面一样，定义两个私有属性__name和__score
    ...

    def get_name(self):
        return self.__name

    def get_score(self):
        return self.__score

又要允许外部代码修改score怎么办？可以再给Student类增加set_score方法：

class Student(object):
    #代码同上
    ...

    def set_score(self, score):
        self.__score = score

需要注意的是，在Python中，变量名类似xxx的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用name、score这样的变量名。
有些时候，你会看到以一个下划线开头的实例变量名，比如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。

二、继承

**1.什么是继承 **
我们不想把同一段代码写好几次，之前使用的函数避免了这种情况。但现在又有个更微妙的问题。如果已经有了一个类，又想建立一个非常类似的类，只是添加几个方法。
比如有人类，我们又想在人类的基础上建立学生类、医生类，教师类。因为他们都具有共同的属性和方法，比如都有 姓名 、年龄 、性别 等共同属性，还有吃饭、睡觉等共同方法。我们就可以写一个人类作为父类，包括姓名、年龄、性别等属性和吃饭睡觉等方法。然后再写多个子类继承父类的这些属性和方法。
但需要注意的是，父类的私有属性和方法不会被子类继承
话不多说，直接上代码：

#父类
class Person():
    def __init__(self,name=None,age=None,sex=None):
        self.name=name
        self.age=age
        self.sex=sex
    def eat(self):
        print("%s正在吃饭"%self.name)

#学生子类：继承人类父类的属性
class Student(Person):
    #子类的初始化参数要和父类的一样，否则没有办法给父类传参，会报错
    def __init__(self,name=None,age=None,sex=None,score=None):
        # self.name=name
        # self.age=age
        # self.sex=sex
        #上面三行的代码等价于下面一行的代码，都是给父类的属性传参
        Person.__init__(self,name,age,sex)
        #还可以这样写
        #super().__init__(name,age,sex)
        self.score=score
    #这个可以是子类独有的方法，不会影响到父类
    def study(self):
        self.eat()
        print("%s在学习，考了%d分"%(self.name,self.score))
    #实例化一个学生对象，然后可以调用子类的方法，也可以直接调用父类的方法
stu=Student("汤姆",20,"男",80)
stu.study()

以上代码运行结果为：
汤姆正在吃饭
汤姆在学习，考了80分
**2.有了继承，我们可以实现子类对父类方法的重写 **
子类继承父类时，子类的方法签名和父类一样，此时子类重写了父类的方法，当生成子类对象时，调用的是子类重写的方法。
下面上代码：

class Person():
    def __init__(self,name=None,age=None,sex=None):
        self.name=name
        self.age=age
        self.sex=sex
    def eat(self):
        print("%s正在吃饭"%self.name)

#学生子类：继承人类父类的属性
class Student(Person):
    #子类的初始化参数要和父类的一样，否则没有办法给父类传参，会报错
    def __init__(self,name=None,age=None,sex=None,score=None):
        # self.name=name
        # self.age=age
        # self.sex=sex
        #上面三行的代码等价于下面一行的代码，都是给父类的属性传参
        # Person.__init__(self,name,age,sex)
        #还可以这样写
        super().__init__(name,age,sex)
        self.score=score
    #这个可以是子类独有的方法，不会影响到父类
    def study(self):
        self.eat()
        print("%s在学习，考了%d分"%(self.name,self.score))

    # 方法的重写,调用的时候调用子类的方法
    # 可以对自定义的方法进行重写
    def eat(self):
        print("%d的%s正在吃饭，他是%s的" % (self.age, self.name, self.sex))

    # 也可以对自带的object类的方法进行重写。
    def __str__(self):
        return "姓名：{0}，年龄：{1}，性别：{2}，成绩：{3}".format(self.name, self.age, self.sex, self.score)

    def __lt__(self, other):
        """ if isinstance(other,Student):
            return self.age<other.age
        else:
            return False """
        if self.name == other.name:
            return self.age < other.age
        else:
            return self.name < other.name

# 实例化
stu=Student("汤姆",20,"男",80)
stu.study()
stu.eat()
list1=[]
stu1=Student("杰克",20,"男",90)
stu2=Student("杰森",21,"男",20)
stu3=Student("杰森",12,"女",50)
list1.append(stu)
list1.append(stu1)
list1.append(stu2)
list1.append(stu3)
for student in list1:
    print(student)
list1.sort()
for student in list1:
    print(student)

以上代码输出为：
20的汤姆正在吃饭，他是男的
汤姆在学习，考了80分
20的汤姆正在吃饭，他是男的
姓名：汤姆，年龄：20，性别：男，成绩：80
姓名：杰克，年龄：20，性别：男，成绩：90
姓名：杰森，年龄：21，性别：男，成绩：20
姓名：杰森，年龄：12，性别：女，成绩：50
姓名：杰克，年龄：20，性别：男，成绩：90
姓名：杰森，年龄：12，性别：女，成绩：50
姓名：杰森，年龄：21，性别：男，成绩：20
姓名：汤姆，年龄：20，性别：男，成绩：80
如上，我们对自定义的eat()方法进行了重写，也对

**3.多继承 **
一个类可以继承多个父类。

class A:
    def __init__(self,a=None):
        self.a=a
    def test(self):
        print("A...test")
class B:
    def __init__(self,b=None):
        self.b=b
    def test(self):
        print("B...test")
class C(B,A):
    def __init__(self,a):
        A.__init__(self,a)
    def t(self):
        A.test(self)#调用A的test()
        super().test()#这个调用的也是B的test
        print("C....t")
c=C("aa")
#默认调用的是父类B的test方法，因为在class C(B,A),B在A前面
c.test()
c.t()

以上实例输出结果为：
B...test
A...test
B...test
C....t
class C(B,A),当有AB均有相同方法，而子类又重写时，调用子类的方法，如果子类没有方法，则调用在继承时写在前面的父类的方法（这里也就是B）。

三、多态

**1.什么是多态？ **
当子类和父类都存在相同的方法时，我们说，子类的方法覆盖了父类的方法，在代码运行的时候，总是会调用子类的方法。这样，我们就获得了继承的另一个好处：多态。

**2.多态的实例 **
简单工厂模式就是典型的多态体现：

让用户输入要选择的汉堡，他不需要知道内部是如何制作的，只要得到一个选择的汉堡实例对象就可以

#创建汉堡的父类，并根据父类创建几个子类
class Hamburger:
    def make(self):
        print("您没有正确选择要制作的汉堡，请重新输入")
class FishHamburger(Hamburger):
    def make(self):
        print("您的鱼肉汉堡已经制作好了")
class BeafHamburger(Hamburger):
    def make(self):
        print("您的牛肉汉堡已经制作好了")
class ChickenHamburger(Hamburger):
    def make(self):
        print("您的鸡肉汉堡已经制作好了")
#工厂类，用来判断用户输入的值并创建相应的对象
class HamburgerFactory:
    @classmethod
    def getinput(cls,temp):
        if temp=="1":
            ch=FishHamburger()
        elif temp=="2":
            ch=BeafHamburger()
        elif temp=="3":
            ch=ChickenHamburger()
        else:
            ch=Hamburger()
        return ch
#主方法，通过用户输入的值调用工厂的类方法
while True:
    temp=input("请输入您要制作汉堡的序号，1.鱼肉汉堡，2.牛肉汉堡，3.鸡肉汉堡")
    if temp=="1" or temp=="2" or temp=="3":
        ch=HamburgerFactory.getinput(temp)
        ch.make()
        break
    else:
        ch=Hamburger()
        ch.make()
        continue

参考链接
https://www.cnblogs.com/wind666/p/10808654.html
https://blog.csdn.net/weixin_40313627/article/details/80783277