标签：子类 基础 了解 行操作 复用 参数 https 单词 处理
面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。面向对象编程（OOP）具体说是一种程序开发方法，一种编程思想、范式。你可以粗滤的理解为，项目经理干的活就是面向对象，负责分配任务，而coder干的活就是面向过程，负责具体任务的实施细节。
1.公式：程序 = 对象 + 交互
2.优点
(1) 思想层面：
-- 可模拟现实情景，更接近于人类思维。
-- 有利于梳理归纳、分析解决问题。
(2) 技术层面：
-- 高复用：对重复的代码进行封装，提高开发效率。
-- 高扩展：增加新的功能，不修改以前的代码。
-- 高维护：代码可读性好，逻辑清晰，结构规整。
3.缺点：学习曲线陡峭。
1.类（class）：具有相同属性（实例变量）和行为（实例方法）的对象的抽象。实际上就是一种自定义的数据类型，类也有对应的类变量和类方法。
2.对象（instance）：类的具体实例，即归属于某个类别的”个体”。
3.属性和行为：类与类方法不同，对象与对象属性值不同。
1.格式
class 类名（object）:
“””文档说明”””
def _init_(self，参数列表):
self.实例变量名= 参数（形参）
def 实例方法名(self，参数列表):
pass
2.说明
-- 类名所有单词首字母大写，多个单词不用下划线隔开，采用驼峰体。
-- (object)是表示该类是从object类继承下来的，python3.x版本可省略。
-- __init__也叫构造函数，创建对象时被调用，也可以省略。
-- self绑定的是被创建的对象的内存地址，名称可以随意。
拓展：object类和type类的区别，即基类与元类的区别
1.object类是继承层面的：其他的类或者对象都是通过继承的关系，直接或者间接的继承了object，翻阅所有对象的族谱，最后一定会发现它们的老祖宗就是object。
1 >>>list.__base__ #Python为所有类都提供了一个__bases__属性，通过该属性可以查看该类的所有直接父类，该属性返回所有直接父类组成的元组 (<class ‘object‘>,) 2 >>>type.__bases__ (<class ‘object‘>,) 3 >>>object.__bases__ #object类是所有类的基类 ()
2.type类是类创建对象层面的：python中一切皆对象，数据、对象是由str、list等数据类型和自定义类创建的，而所有数据类型和自定义类都是由元类创建的
1 >>> type(list) <class ‘type‘> 2 >>> type(object) <class ‘type‘> 3 >>> type(type) <class ‘type‘> #type类是所有类的元类，但是其本身是由虚拟机创建的
1.格式
变量 = 类名 (实参数列表)
2.说明
-- python中无处不对象，对象是python中对数据的一种抽象的表示
-- 所有对象都有三种特性：id、类型、值
id：对象的内存地址，由变量关联，查看通过：id(变量)
类型：生成对象的模型，对应类名，查看通过：type(变量)
值：对象中存放的数据，对应实参列表，查看通过：变量.__dict__
-- 每个对象都是由其对应的类创建出来的
拓展：与对象的创建，调用，删除相关的魔法方法：__new__()方法，__init__()方法，__call__()方法，__del__()方法
1.__new__()方法和__init__()方法：__new__()方法是一个类方法，在对象被创建的时候调用，该方法负责创建（实例化）一个对象。如果创建对象成功，该对象会自动的调用__init__()方法，对自身进行初始化，如果创建对象失败，没有对象了，自然也就没谁去调用__init__()方法了。
2.__call__()方法：如果类中定义了该方法，可以使对象成为像函数和类一样的可调用对象。
1 class Entity: 2 ‘‘‘ 3 调用实体来改变实体的位置。 4 ‘‘‘ 5 6 def __init__(self, size, x, y): 7 self.x, self.y = x, y 8 self.size = size 9 10 def __call__(self, x, y): 11 ‘‘‘改变实体的位置‘‘‘ 12 self.x, self.y = x, y 13 14 15 e = Entity(1, 2, 3) # 创建实例 16 print(e.__dict__) # {‘x‘: 2, ‘y‘: 3, ‘size‘: 1} 17 e(4, 5) # 实例可以象函数那样执行，并传入x y值，修改对象的x y 18 print(e.__dict__) # {‘x‘: 4, ‘y‘: 5, ‘size‘: 1}
3.__del__()方法：是python垃圾回收机制的实际应用，当类中定义了该方法时，创建的对象的引用计数为0时该方法被调用
>>> class D(object): def __init__(self): print ‘this is D.__init__()‘ def __del__(self): print ‘this is D.__del__()‘ >>> d = D() this is D.__init__() >>> d2 = d >>> d3 = d >>> >>> del d >>> del d2 >>> del d3 #当对象的引用计数为0时自动触发__del__()方法 this is D.__del__()
1.语法
(1) 定义：对象地址.变量名=数据值
(2) 调用：对象地址.变量名=数据值
2.说明
(1) 首次通过对象赋值为创建，再次赋值为修改。
(2) 通常在__init__构造函数中（self.实例变量名=形参）创建，创建对象时赋值。也可以在
(3) 每个对象存储一份，通过对象地址访问。
3.作用：描述对象自身的数据。
4.__dict__：对象的属性，用于存储自身实例变量（包括私有化变量）的字典。
1.语法
(1) 定义： def 方法名称(self, 形参列表):
方法体
(2) 调用： 对象地址.实例方法名(实参列表)
2.说明
(1) 定义时至少有一个形参，一般命名为"self"，用于绑定调用这个方法的对象地址，通过对象调用实例方法时self不用传参。
(2)每个对象共用一份，通过对象地址访问。不建议通过类名访问实例方法(对象与对象数据值不同，通过类名调用实例方法时，需要给self参数传参具体的对象)
3.作用：表示对象行为。
1 """ 2 实例成员 3 记住一句话:实例成员,使用对象地址访问. 4 """ 5 class Student: 6 pass 7 8 s01 = Student() 9 # 定义实例变量: 对象.变量名 = 数据值 10 s01.name = "lennie" 11 print(s01.name) #"lennie" 12 s02 = Student() 13 # print(s02.name)# AttributeError,因为s02指向的对象,没有创建过实例变量name 14 # 通过__dict__获取当前对象的所有实例变量 15 print(s01.__dict__) #{‘name‘: ‘lennie‘} 16 print(s02.__dict__) #{} 17 18 19 class Student02: 20 def __init__(self, name, height): 21 self.name = name 22 self.height = height 23 24 # 实例方法 25 def print_self(self): 26 print(self.name,self.height) 27 28 29 s01 = Student02("lennie", 170) 30 s02 = Student02("ginger", 162) 31 # 建议:实例方法,通过对象地址访问. 32 s01.print_self() 33 # 不建议:Student02.print_self(),若没有传递对象地址,实例方法不能正确访问对象数据. 34 Student02.print_self(s02)
1.语法
(1) 定义：在类中，方法外定义变量。
class 类名:
变量名 = 表达式
(2) 调用：类名.变量名
不建议通过对象访问类变量
2.说明
(1) 存储在类中。
(2)所有对象共享一份，可通过类或者对象直接调用。
3.作用：描述所有对象的共有数据。
1.语法
(1) 定义：
@classmethod
def 方法名称(cls,形参列表):
方法体
(2) 调用：类名.方法名(实参列表)
不建议通过对象访问类方法
2.说明
(1) 至少有一个形参，一般命名为‘cls‘，用于绑定类的内存地址。
(2) 使用@classmethod修饰的目的是调用类方法时可以隐式传递类，即通过类名调用类方法时cls不需要传参。
(3) 类方法中不能访问实例成员，实例方法中可以访问类成员。
3.作用：操作类变量。
1 """ 2 类成员,用类的地址去访问 3 """ 4 class ICBC: 5 # 类变量:总行的钱 6 total_money = 1000000 7 # 类方法 8 @classmethod 9 def print_total_money(cls): 10 # print(id(cls), id(ICBC)) 11 # cls : 存储当前类的地址 12 # print("当前总行金额:",ICBC.total_money) 13 print("当前总行金额:", cls.total_money) 14 15 def __init__(self, name, money): 16 self.name = name 17 self.money = money 18 # 从总行扣除当前支行的钱 19 ICBC.total_money -= money 20 21 22 i01 = ICBC("天坛支行", 100000) 23 i02 = ICBC("陶然亭支行", 100000) 24 # 主流:通过类访问类成员 25 ICBC.print_total_money() #"当前总行金额: 800000" 26 print(ICBC.total_money) #800000 27 # 非主流:通过对象访问类成员 28 # print(i02.total_money) 29 # i02.print_total_money()
1.语法
(1) 定义：
@staticmethod
def 方法名称(形参列表):
方法体
(2) 调用：类名.方法名(实参列表)
不建议通过对象访问静态方法
2.说明
(1) 使用@ staticmethod修饰的目的是该方法不需要隐式传参数，即参数列表不含self，cls参数，其实就是个函数
(2) 静态方法不能访问实例成员和类成员
3.作用：定义常用的工具函数。
1.定义：将一些基本属性封装成共有属性，类的创建中的__init__初始化
2.优势：将数据与对数据的操作相关联，代码可读性（相比容器）更高（类是对象的模板）。
定义：类外提供必要的功能，隐藏实现的细节，私有化操作
优势：简化编程，使用者不必了解具体的实现细节，只需要调用对外提供的功能。
私有成员：
(1) 作用：只有类内部可以直接访问，外部不能直接访问，可以对参数做检查，避免传入无效的参数
(2) 做法：__成员名
(3) 本质：障眼法，实际也可以访问。私有成员的名称被修改为：_类名__成员名，可以通过_dict_属性或dir函数查看。
1 class Coder: 2 """ 3 私有成员的读和写操作 4 """ 5 def __init__(self, name, age): 6 self.name = name 7 self.__age = age #私有化方式一：私有成员命名采用双下划线开头 8 # self.set_age(age) #私有化方式二 9 10 # 使用两个公开的方法获取和修改私有属性 11 def get_age(self): 12 return self.__age # 类内部访问无限制 13 14 def set_age(self, value): 15 if 0 <= value <= 100: # 检验数据的有效性，限制随意更改属性值 16 self.__age = value 17 else: 18 raise ValueError 19 20 age=property(get_age,set_age) #无读写限制 21 # age=property(get_age,None) #写限制 22 # age=property(None,set_age) #读限制 23 # age=property(None,None) #读写均限制 24 25 c = Coder("lennie", 26) 26 # 1.私有成员不能直接访问 27 print(c.__age) #AttributeError: ‘Coder‘ object has no attribute ‘__age‘ 28 print(c.__dict__) # {‘name‘: ‘lennie‘, ‘_Coder__age‘: 26} 29 # 2.可通过 对象._类名__成员名 访问(此种访问无限制) 30 c._Coder__age = 27 31 print(c._Coder__age) # 27 32 # 3.可通过两个私有方法实现私有成员的读写(此种方式可限制私有成员被随意改写) 33 c.set_age(30) 34 print(c.get_age()) # 30 35 #4.可通过设置property（读方法名，写方法名），实现私有成员的读写 36 c.age=32 37 print(c.age) #32
4.属性@property：
公开的实例变量，缺少逻辑验证。私有的实例变量与两个公开的方法相结合，又使调用者的操作略显复杂。而属性可以将两个方法的使用方式像操作变量一样方便。
(1) 定义：
@property #允许读，等价于定义类变量：属性名=property（读方法名，None）
def 属性名(self):
return self.__属性名
@属性名.setter #允许写，等价于定义类变量：属性名=property（读方法名，None）
def 属性名(self, value):
self.__属性名= value
(2) 调用：
对象.属性名 = 数据
变量 = 对象.属性名
(3) 说明：
1 class Coder: 2 """ 3 @property和@私有成员名.setter 4 """ 5 def __init__(self, name, age): 6 self.name = name 7 self.__age = age #私有成员 8 9 @property 10 def age(self): 11 return self.__age 12 13 @age.setter 14 def age(self, value): 15 if 0 <= value <= 100: # 检验数据的有效性，限制随意更改属性值 16 self.__age = value 17 else: 18 raise ValueError 19 20 c=Coder("lennie",26) 21 # print(c.__age) #依然不能直接调用，AttributeError 22 #1.可直接由_类名__属性名调用 23 c._Coder__age=27 24 print(c._Coder__age) #27 25 #2.避免使用两个方法的繁琐，使私有成员如变量般调用 26 c.age=30 27 # c.age=120 #ValueError 28 print(c.age) #30
(1) 分而治之
将一个大的需求分解为许多类，每个类处理一个独立的功能。 设计角度看类的创建应先考虑方法（行为，干什么），在考虑初始化（数据）
(2) 变则疏之 #拆分的度
变化的地方独立封装，避免影响其他类。
(3) 高 内 聚
类中各个方法都在完成一项任务(单一职责的类)。
(4) 低 耦 合 #低不是杜绝，是有互相调用才能完成
类与类的关联性与依赖度要低(每个类独立)，让一个类的改变，尽少影响其他类。
2.优势：
便于分工，便于复用，可扩展性强。
class 父类:
def 父类方法(self):
方法体
class 子类(父类)：
def 子类方法(self):
方法体
儿子 = 子类()
儿子.子类方法()
儿子.父类方法()
2.说明：子类直接拥有父类的方法.
class 子类(父类):
def __init__(self,参数列表):
super().__init__(参数列表)
self.自身实例变量 = 参数
2.说明
子类如果没有构造函数，将自动执行父类的，但如果有构造函数将覆盖父类的,此时必须通过super()函数调用父类的构造函数，以确保父类实例变量被正常创建。
重用现有类的功能，并在此基础上进行扩展。子类直接具有父类的成员（共性），还可以扩展新功能。
一种代码复用的方式。
耦合度高：父类的变化，直接影响子类。
将相关类的共性进行抽象，统一概念，隔离变化。
多个类在概念上是一致的，且需要进行统一的处理。
父类（基类、超类）、子类（派生类）。
父类相对于子类更抽象，范围更宽泛；子类相对于父类更具体，范围更狭小。
单继承：父类只有一个（例如 Java，C#）。
多继承：父类有多个（例如C++，Python）。
Object类：任何类都直接或间接继承自 object 类。
一个子类继承两个或两个以上的基类，父类中的属性和方法同时被子类继承下来。
同名方法的解析顺序（MRO， Method Resolution Order）:print(D.mro)
类自身 --> 父类继承列表（由左至右）--> 再上层父类
A
/ \
B C
\ /
D
父类的同一种动作或者行为，在不同的子类上有不同的实现。
子类实现了父类中相同的方法（方法名、参数）。
在调用该方法时，实际执行的是子类的方法。
Ctrl + O
Python中，以双下划线开头、双下划线结尾的是系统定义的成员。我们可以在自定义类中进行重写，从而改变其行为。
__str__函数：将对象（打印时显示内存地址）转换为字符串（打印对象时显示自定义字符串）(对人友好的)
__repr__函数：将对象转换为字符串(解释器可识别的)
定义：让自定义的类生成的对象(实例)能够使用运算符进行操作。
Open Closed Principle
对扩展开放，对修改关闭。
增加新功能，不改变原有代码。
Single Responsibility Principle
一个类有且只有一个改变它的原因。
Dependency Inversion Principle
客户端代码(调用的类)尽量依赖(使用)抽象。
抽象不应该依赖细节，细节应该依赖抽象。
Composite Reuse Principle
如果仅仅为了代码复用优先选择组合复用，而非继承复用。
组合的耦合性相对继承低。
Liskov Substitution Principle
父类出现的地方可以被子类替换，在替换后依然保持原功能。
子类要拥有父类的所有功能。
子类在重写父类方法时，尽量选择扩展重写，防止改变了功能。在Ctrl+o时，别删东西，重写后扩展重写
Law of Demeter
不要和陌生人说话。
类与类交互时，在满足功能要求的基础上，传递的数据量越少越好。因为这样可能降低耦合度（利用抽象去调用子类，隔离变化）。
标签：子类 基础 了解 行操作 复用 参数 https 单词 处理
原文地址：https://www.cnblogs.com/lennie-luo/p/11629301.html
