一、类和对象：
- 类（Class）是现实或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起。
- 对象(Object)是具有类类型的变量。
- 类和对象是面向对象编程技术中的最基本的概念。
- 类和对象 的区别就是 鱼和三文鱼 的区别; 就是 猫和蓝猫 的区别。
项目 | Value |
类（Class） | 创建实例的模板 |
对象(Object) | 一个一个具体的实例 |
- 如何定义类?
class 类(): pass - 如何将类转换成对象?
实例化是指在面向对象的编程中，把用类创建对象的过程称为实例化。是将一个抽象的概 念类，具体到该类实物的过程。实例化过程中一般由类名 对象名 = 类名（参数1，参数2…参数n） 构成
# 类(Class)
class Cat:
# 属性：一般是名词，eg: name, age, gender.....
name = 'name'
kind = 'kind'
# 方法: 一般情况是动词, eg: create, delete, eating, run......
def eat(self):
print('cat like eating fish.....')
# 对象(Object):对类的实例化(具体化)
fentiao = Cat()
print(Cat) # <class '__main__.Cat'>
print(fentiao) # <__main__.Cat object at 0x00E9FD70>二、封装特性：
- 封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。 所以，在使用面向对象的封装特性时，需要：
1). 将内容封装到某处
2). 从某处调用被封装的内容 ：
①. 通过对象直接调用被封装的内容： 对象.属性名
②. 通过self间接调用被封装的内容： self.属性名
③. 通过self间接调用被封装的内容: self.方法名() - 构造方法：构造方法__init__与其他普通方法不同的地方在于，当一个对象被创建后，会立即调 用构造方法。自动执行构造方法里面的内容。
- 对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过 对象直接或者self间接获取被封装的内容。
# 类(Class)
class Cat:
def __init__(self, name, kind): # 形参
"""
1. 构造方法，实例化对象时自动执行的方法
2. self是什么? self实质上是实例化的对象
3. 类方法中, python解释器会自动把对象作为参数传给self
"""
print('正在执行__init__构造方法')
print('self:', self)
# 属性：一般是名词，eg: name, age, gender.....
# 封装: self.name将对象和name属性封装/绑定
self.name = name
self.kind = kind
# 方法: 一般情况是动词, eg: create, delete, eating, run......
def eat(self):
print('cat %s like eating fish.....' %(self.name))
# 对象(Object):对类的实例化(具体化)
fentiao = Cat("粉条", "美短虎斑")
print(fentiao.name)
print(fentiao.kind)
fentiao.eat()运行结果：
三、巩固封装特性：
"""
创建一个类People,
拥有的属性为姓名， 性别和年龄，
拥有的方法为购物,玩游戏,学习;
实例化 对象,执行相应的方法。
显示如下:
小明,18岁,男,去西安赛格购物广场购物
小王,22岁,男,去西安赛格购物广场购物
小红,10岁,女,在西部开源学习
提示:
属性:name,age,gender
方法:shopping(), playGame(), learning()
"""
class People:
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
def shopping(self):
print(f'{self.name},{self.age}岁,{self.gender},去西安赛格购物广场购物 ')
def learning(self):
print(f'{self.name},{self.age}岁,{self.gender},在西部开源学习')
p1 = People('小明', 18, '男') # 对象的实例化
p2 = People('小王', 22, '男')
p3 = People('小红', 10, '女')
p1.shopping() # 调用方法
p2.shopping()
p3.learning()运行结果：
四、继承特性：
- 继承概念：继承描述的是事物之间的所属关系,当我们定义一个class的时候,可以从某个现有的class 继承,新的class称为子类、扩展类(Subclass),而被继承的class称为基类、父类或超类(Baseclass、 Superclass)。
- 如何让实现继承?
子类在继承的时候,在定义类时,小括号()中为父类的名字 - 继承的工作机制是什么?
父类的属性、方法,会被继承给子类。 举例如下: 如果子类没有定义__init__方法,父类有,那 么在子类继承父类的时候这个方法就被继承了,所以只要创建对象,就默认执行了那个继承过来的 __init__方法。
class Student:
"""父类Student"""
def __init__(self, name, age):
self.name = name
self.age = age
def learning(self):
print(f'{self.name}正在学习')
class MathStudent(Student):
"""MathStudent的父类是Student"""
pass
# 实例化
m1 = MathStudent("粉条博士", 8) #实例化MathStudent类里是没有任何属性和方法的，都是继承Student类的
print(m1.name)
print(m1.age)
m1.learning() # 不报错，子类里没有，但父类有该方法
# m1.choice_course() # 报错, 子类里没有，父类也没有的方法运行结果：
重写父类方法：
- 重写父类方法: 就是子类中,有一个和父类相同名字的方法,在子类中的方法会覆盖掉父类中同名的方法
下面的代码中我们要求在调用子类的方法时，先执行父类中共名的方法，再执行子类的方法。
class Student:
"""父类Student"""
def __init__(self, name, age):
self.name = name
self.age = age
def learning(self):
print(f'{self.name}正在学习')
def choice_course(self):
print('正在选课中'.center(50, '*'))
class MathStudent(Student):
"""MathStudent的父类是Student"""
def choice_course(self):
# 需求: 先执行父类的choice_course方法， 在个性化执行自己的方法。
# Student.choice_course(self) # 解决方法1: 直接执行父类的方法，但不建议
# 解决方法2： 通过super找到父类，再执行方法(建议且生产环境代码常用的方式)
super(MathStudent, self).choice_course()
info = """
课程表
1. 高等数学
2. 线性代数
3. 概率论
"""
print(info)
# 实例化
m1 = MathStudent("粉条博士", 8)
m1.choice_course()
print("-----------------------------------------------一条可爱的分割线")
s1 = Student("粉条博士", 8)
s1.choice_course()运行结果：
多继承：
- 在Python 2及以前的版本中，由任意内置类型派生出的类，都属于“新式 类”，都会获得所有“新式类”的特性；反之，即不由任意内置类型派生出的类， 则称之为“经典类”。
- “新式类”和“经典类”的区分在Python 3之后就已经不存在，在Python 3.x 之后的版本，因为所有的类都派生自内置类型object(即使没有显示的继承 object类型)，即所有的类都是“新式类”。
- 最明显的区别在于继承搜索的顺序不同：
经典类多继承搜索顺序(深度优先算法):先深入继承树左侧查找，然后再返回，开始查找右侧。
新式类多继承搜索顺序(广度优先算法):先在水平方向查找，然后再向上查找，
"""
新式类: 广度优先算法(python3中所有类都是新式类)
经典类： 深度优先算法(py2中的部分类属于经典类)
python3所有的类都属于新式类。新式类的继承算法是广度优先。
# 分析多继承的相关代码
>pip install djangorestframework
from rest_framework import viewsets
viewsets.ModelViewSet
"""
class D(object):
def hello(self):
print('D')
class C(D):
def hello(self):
print('C')
class B(D):
pass
# def hello(self):
# print('B')
class A(B, C):
pass
# def hello(self):
# print('A')
a = A()
a.hello()运行结果：A的父类是B和C，B和C的父类是D，所以在广度优先时，A调用方法，B中没有的话，会优先找同级的C。
私有属性和私有方法：
- 在 Python 中,实例的变量名如果以 __ 开头,就变成了一个私有变量/属性 (private),实例的函数名如果以 __ 开头,就变成了一个私有函数/方法(private)只 有内部可以访问,外部不能访问。
- 优势：
- 确保了外部代码不能随意修改对象内部的状态,这样通过访问限制的保护, 代码更加健壮。
- 如果又要允许外部代码修改属性怎么办?可以给类增加专门设置属性方法。为什么大费周折?因为在方法中,可以对参数做检查,避免传入无效的参数。
注意：子类无法继承父类的私有属性和私有方法。
class Student:
"""父类Student"""
def __init__(self, name, age, score):
self.name = name
self.age = age
# 私有属性，以双下划线开头。
# 工作机制: 类的外部(包括子类)不能访问和操作，类的内部可以访问和操作。
self.__score = score
def get_score(self): #定义新的方法，外部可以通过调用此方法修改私有属性和调用私有方法
self.__modify_score()
return self.__score
# 私有方法是以双下划线开头的方法,
#工作机制: 类的外部(包括子类)不能访问和操作，类的内部可以访问和操作。
def __modify_score(self):
self.__score += 20
class MathStudent(Student):
"""MathStudent的父类是Student"""
def get_score(self):
self.__modify_score()
return self.__score
# 报错原因: 子类无法继承父类的私有属性和私有方法。
# s1 = MathStudent('张三', 18, 100)
s1 = Student('张三', 18, 100)
score = s1.get_score()
print(score)
五、多态特性：
- 多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口 的多种不同的实现方式即为多态。通俗来说： 同一操作作用于不同的对象，可以有不 同的解释，产生不同的执行结果。
- 多态的好处就是，当我们需要传入更多的子类，只需要继承父类就可以了，而方法既可以直接不重写（即使用父类的），也可以重写一个特有的。这就是多态的意思。调用方法只管调用，不管细节，而当我们新增一种的子类时，只要确保新方法编写正确，而不用管原来的代码。这就是著名的“开闭”原则：
对扩展开放（Open for extension）：允许子类重写方法函数
对修改封闭（Closed for modification）：不重写，直接继承父类方法函数
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
