标签：sha 封装 show 类方法 实例化 过程 构造 声音 Speak
类是一个抽象的概念，而对象是一个实体的存在，对象由类创造而出，每个对象之间互相独立互不影响，一个对象可以同时拥有多个类的方法，实例化就是通过某类创建对象的过程。
比如，某一个人是一个具体的对象，而人类则是人这个对象的来源，人类是一个抽象的概念并且人类又属于哺乳类，所以人也应该具有哺乳类的方法和行为（继承），每个人具有不同的样貌，声音及其自身的不同习惯（多态）。一只猴子不属于人类，因为他没有人类共有的属性和方法，比如：人没有尾巴，人会说话 等等。（封装）
从程序功能角度来看，类是其对象存放共有方法以及属性的地方。并不存在什么抽象不抽象，我一样可以用类来做很多事情。对象确实是由类产生的但是类也是一个对象，因为类它的确可以存放属性以及方法。
类与对象的关系就在于，类可以存放其实例化对象所需要用到的公共方法与属性，而实例化对象则可以具有类对象不具有的某些属性或方法。
=====定义类发生的几件事===== 1.申请内存空间保存类体代码 2.将上述内存地址绑定给类名 3.创建类专属的局部命名空间（注意与函数区分。函数是在执行阶段才会做这件事） 4.执行类体代码（注意与函数区分。函数的定义阶段不会执行其内部代码）
=====实例化类发生的几件事情===== 1.调用执行__new__方法进行类的实例化 2.调用执行__init__方法进行实例对象的构造 3.创建实例对象独有的命名空间
class People(object): # <-- 类名：驼峰体， （继承类），可以写也可以不写，推荐写上。 """这是人类""" # <-- 说明 number_of_eyes = 2 # 眼睛数量 number_of_mouths = 1 # 嘴巴数量 number_of_ears = 2 # 耳朵数量 number_of_noses = 1 # 鼻子数量 def __init__(self, name, color, height, weight): # 方法/功能 self.name = name # self ---> 实例化对象 self.color = color self.height = height self.weight = weight def speak(self, content): # 方法/功能 print("{0}说:{1}".format(self.name, content)) # ==== 实例化对象 ==== Ps：可以看到实例化出的对象内存地址完全不同。并且他们还具备了类本身不具备的某些属性，这些属性被称为实例属性 p1 = People("云崖", "黄色", 192, 158) print(p1) # <__main__.People object at 0x00000183AECE3E80> print(id(p1)) # 1665085095552 print(type(p1)) # <class ‘__main__.People‘> p2 = People("二狗", "黑色", 145, 148) print(p2) # <__main__.People object at 0x00000183AED502B0> print(id(p2)) # 1665085538992 print(type(p2)) # <class ‘__main__.People‘> # ==== 执行结果 === Ps:可以看到并没有使用（）调用类 """ 执行了... """
类：可以查看到当前类下所有的类属性以及类方法
实例对象：可以查看到当前实例下所有的实例属性以及实例方法
class People(object): # <-- 类名：驼峰体， （继承类），可以写也可以不写，推荐写上。 """这是人类""" # <-- 说明 number_of_eyes = 2 # 眼睛数量 number_of_mouths = 1 # 嘴巴数量 number_of_ears = 2 # 耳朵数量 number_of_noses = 1 # 鼻子数量 def __init__(self, name, color, height, weight): # 方法/功能 self.name = name # self ---> 实例化对象 self.color = color self.height = height self.weight = weight def speak(self, content): # 方法/功能 print("{0}说:{1}".format(self.name, content)) # ==== 查看类字典 ==== print(People.__dict__) # ==== 查看实例字典 ==== p1 = People("云崖", "黄色", 192, 158) print(p1.__dict__) # {‘name‘: ‘云崖‘, ‘color‘: ‘黄色‘, ‘height‘: 192, ‘weight‘: 158} # ==== 执行结果 === Ps: 可以看到类字典中具有类所有的属性及方法，而实例字典中只有实例自己的实例属性。（当然你也可以为其添加实例方法） """ {‘__module__‘: ‘__main__‘, ‘__doc__‘: ‘这是人类‘, ‘number_of_eyes‘: 2, ‘number_of_mouths‘: 1, ‘number_of_ears‘: 2, ‘number_of_noses‘: 1, ‘__init__‘: <function People.__init__ at 0x000001B8650DFF70>, ‘speak‘: <function People.speak at 0x000001B86D4B9700>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘People‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘People‘ objects>} {‘name‘: ‘云崖‘, ‘color‘: ‘黄色‘, ‘height‘: 192, ‘weight‘: 158} """
无论是对实例化属性/方法，或者是对类属性/方法进行增删改查，实际上都是非常单纯的对__dict__进行操作。
类属性、类方法的增删改查：会影响所有实例化对象，只要是实例化对象们所共有的属性/方法都将全部改变。
实例属性、实例方法的增删改查：只会影响当前实例化对象，不会影响其他实例化对象以及类。
class People(object): # <-- 类名：驼峰体， （继承类），可以写也可以不写，推荐写上。 """这是人类""" # <-- 说明 number_of_eyes = 2 # 眼睛数量 number_of_mouths = 1 # 嘴巴数量 number_of_ears = 2 # 耳朵数量 number_of_noses = 1 # 鼻子数量 def __init__(self, name, color, height, weight): # 方法/功能 self.name = name # self ---> 实例化对象 self.color = color self.height = height self.weight = weight def speak(self, content): # 方法/功能 print("{0}说:{1}".format(self.name, content)) # ==== 实例化对象 ==== p1 = People("云崖", "黄色", 192, 158) p2 = People("二黑", "黑色", 155, 148) # ==== 类方法属性的增 ==== def test(self): print("这是新增的类方法", self) People.number_of_leg = 2 # 腿的数量 相当于 People.__dict__["number_of_leg"] = 2 People.test = test # 相当于 People.__dict__["test"] = test # ==== 类方法属性的删 ==== del People.number_of_eyes # 解除属性名number_of_eyes与其堆内存存储值的绑定关系 相当于 del People.__dict__["number_of_eyes"] del People.speak # 解除方法名speak与类方法内存空间的绑定关系 相当于 del People.__dict__["speak"] # === 类方法的改 ==== People.number_of_mouths = "一" # 相当于 People.__dict__["number_of_mouths"] = "一" # === 类方法的查 ==== print(People.number_of_leg) # 2 print(People.number_of_mouths) # 一 print(People.test) # <function test at 0x00000206294761F0> # === 类的增删改查对实例的影响 === 总结：类属性/方法的任何增删改查都会影响其实例化对象 print(p1.number_of_mouths) # 一 print(p2.number_of_mouths) # 一 p1.test() # 这是新增的类方法 <__main__.People object at 0x0000020629603E80> p2.test() # 这是新增的类方法 <__main__.People object at 0x00000206296702B0>
class People(object): # <-- 类名：驼峰体， （继承类），可以写也可以不写，推荐写上。 """这是人类""" # <-- 说明 number_of_eyes = 2 # 眼睛数量 number_of_mouths = 1 # 嘴巴数量 number_of_ears = 2 # 耳朵数量 number_of_noses = 1 # 鼻子数量 def __init__(self, name, color, height, weight): # 方法/功能 self.name = name # self ---> 实例化对象 self.color = color self.height = height self.weight = weight def speak(self, content): # 方法/功能 print("{0}说:{1}".format(self.name, content)) # ==== 实例化对象 ==== p1 = People("云崖", "黄色", 192, 158) p2 = People("二黑", "黑色", 155, 148) # ==== 实例化对象方法属性的增 ==== def test(self): print("这是新增的类方法", self) p1.number_of_leg = 2 # 腿的数量 相当于 p1.__dict__["number_of_leg"] = 2 p1.test = test # 相当于 p1.__dict__["test"] = test p1.p1_del_val = "将要删除的值" # 相当于 p1.__dict__[p1_del_val] = "将要删除的值" # ==== 实例化对象方法属性的删 ==== del p1.p1_del_val # === 实例化对象方法的改 ==== p1.number_of_mouths = "一" # 相当于 p1.__dict__["number_of_mouths"] = "一" # === 实例化对象方法的查 ==== print(p1.number_of_leg) # 2 print(p1.number_of_mouths) # 一 print(p1.test) # <function test at 0x00000206294761F0> # p1.test(p1) # 请注意，当对实例化对象绑定一个实例方法，使用的时候并不会直接传入self，因为它并不是一个绑定方法。 # === 实例化对象的增删改查对其他实例化对象及类的影响 === 总结：实例化对象对于属性/方法的增删改查只影响自己，并不影响其他实例化对象，更不会影响类本身。 # -- 类，与其他实例化对象没有下面两个属性与方法 -- # print(p2.number_of_leg) # print(People.number_of_leg) # print(p2.test) # print(People.test) print(p1.number_of_mouths) # 一 print(People.number_of_mouths) # 1 print(p2.number_of_mouths) # 1
该方法是实例化对象时所自动调用的方法。必须返回一个None，否则抛出异常，通常我们用它来构造实例化对象特有的一些属性。
前面说过，类是存放实例化对象中一些共有的方法与属性的，这些共用的方法和属性称之为类方法、类属性。那么我们肯定是允许每一个实例化对象拥有自己一些差异化的内容，这些差异化内容的传递其中最简便的方法就是使用Python为我们提供的 __init__ 方法。
def __init__(self, name, color, height, weight): # 方法/功能 self.name = name # self ---> 实例化对象 self.color = color self.height = height self.weight = weight
self参数：在__init__方法中应当是一个即将被实例化的空对象，下面的self.xxx = yyy 其实都是在为这个空对象中的变量名进行赋值操作。
而在其他方法中，self参数指的是已经实例化好的对象本身。
class TestInit(object): def __init__(self): print(self) # 此时产生一个空对象 print(self.__dict__) # {} self.x = "任意值" print(self.__dict__) def testobj(self): print(self.__dict__) t1 = TestInit() # 这一步实际上是将生产的空对象self赋值给了t1 print(t1) print(t1.__dict__) # === self的常规玩法 === t1.testobj() # 我们的实例对象在调用该方法时，会将自身传入进去 # === self的其他玩法 === 当使用类调用某类方法时，我们只需要为其传入一个对象对应上self参数即可。 TestInit.testobj(t1) # 和上面均属于相同的操作。 t2 = TestInit() t2.__dict__ = {"t2专属__dict__": None} TestInit.testobj(t2) # ==== 执行结果 ==== """ <__main__.TestInit object at 0x000001A1FF763E80> {} {‘x‘: ‘任意值‘} <__main__.TestInit object at 0x000001A1FF763E80> {‘x‘: ‘任意值‘} {‘x‘: ‘任意值‘} {‘x‘: ‘任意值‘} <__main__.TestInit object at 0x000001A1FF7D02B0> {} {‘x‘: ‘任意值‘} {‘t2专属__dict__‘: None} """
当实例化一个类对象的过程中，类方法会变为该实例化对象的绑定方法。绑定方法的作用在于不用传入self参数，而是自动传入self参数为当前的实例化对象。
# class People(object): # <-- 类名：驼峰体， （继承类），可以写也可以不写，推荐写上。 """这是人类""" # <-- 说明 number_of_eyes = 2 # 眼睛数量 number_of_mouths = 1 # 嘴巴数量 number_of_ears = 2 # 耳朵数量 number_of_noses = 1 # 鼻子数量 def __init__(self, name, color, height, weight): # 方法/功能 self.name = name # self ---> 实例化对象 self.color = color self.height = height self.weight = weight def speak(self, content): # 方法/功能 print("{0}说:{1}".format(self.name, content)) # ==== 实例化对象 ==== p1 = People("云崖", "黄色", 192, 158) # ==== 查看类方法 ==== print(People.speak) # <function People.speak at 0x0000024EE94A8700> # ==== 查看绑定方法 ==== print(p1.speak) # <bound method People.speak of <__main__.People object at 0x000001C6D32B3E80>> bound method 绑定方法
标签：sha 封装 show 类方法 实例化 过程 构造 声音 Speak
原文地址：https://www.cnblogs.com/Yunya-Cnblogs/p/13046931.html
