找往期文章包括但不限于本期文章中不懂的知识点：
个人主页：我要学编程(ಥ_ಥ)-CSDN博客
所属专栏： Python
目录
前言
object对象
object对象的特殊方法
操作符对应的特殊方法
特殊属性
类的深拷贝 与 浅拷贝
前言
前面我们学习类和对象以及面向对象的三大特征。类和对象还是很好理解的，在Python中一切皆是对象，而类是创建对象的模版，创建对象的过程，也被称为"类的实例化"，因为类从一个飘无虚渺的概念，变为了一个实实在在的、看得见摸得着（可以去访问方法与属性）的对象，因此就叫实例化。紧接着我们又学习了面向对象编程的三大特征，封装、继承、多态。封装主要是体现在类的属性与方法带有访问权限了，并且外部在调用该方法时，不需要知道底层是如何实现的，相当于隐藏了内部的细节。继承是对共性的一个抽取（猫和狗，抽象成动物）主要是实现了代码的复用（动物类有了姓名、年龄这些属性之后，子类可以直接用，而不用再去定义）。继承之中有一个知识点是方法重写，即子类定义了一个与父类同名的方法，就称子类的方法为重写的方法。多态是描述不同的对象在面对同一件事情时，所表现出的行为不同，而Python中的多态要和其他语言区分开来，这里的多态只要两个类的对象都有同一个方法，那么当把这些对象封装一下（使用 obj = A/B），然后再去调用这个方法，就会表现出不同的行为。这其实也很好理解，虽然表面上看起来是同一个对象在调用同一个方法，但其底层根本就是不同的对象，自然调用同一个方法时，所表现出行为就不同了。
其实Python中的面向对象还是很好理解的，多去想一想，通过代码辅助的话，应该理解的更快了。接下来，我们学习新的知识。
object对象
通过前面的学习，我们已经知道了：object类是所有类的直接父类或者间接父类，那么这些类肯定都是会拥有object类中所有共有与受保护的属性、方法。我们接下来就是要学习某些属性与方法。
代码演示：
class Person():def __init__(self,name,age):self.name = nameself.age = agedef show(self):print(f'我的名字是{self.name},今年{self.age}岁')# 类名() --> 这就是在实例化一个对象，并且会自动调用init方法，构造对象
person = Person('小明','18')
print(dir(person))运行结果：
object对象的特殊方法
| object类中的特殊方法 | 描述 |
| __new__() | 由系统调用，用于创建对象 |
| __init__() | 创建对象时手动调用，用于初始化对象属性值 |
| __str__() | 对象的描述，返回值是str类型，默认输出对象的内 存地址。 |
注意：
1、在创建对象时，new方法一定是最先执行的，这个方法是在申请一块内存空间给我们创建的对象使用，后续的 init 方法也是基于内存空间去构建对象的。
2、init 方法，这里手动调用是指我们需要去手动实例化一个对象，而在实例化对象的过程中就会去调用这个方法，因此就称为手动调用 init 方法。
代码演示：
class Person():def __new__(cls, *args, **kwargs):print('new方法执行了')# 我们这里只是想去打印语句，其余的所有操作都是依靠父类的# 这是在创建一个对象实例，得返回创建的结果# 如果不return创建的对象，那么最终person就是Nonereturn super().__new__(cls)def __init__(self,name,age):print('init方法执行了')self.name = nameself.age = agedef show(self):print(f'我的名字是{self.name},今年{self.age}岁')# 类名() --> 这就是在实例化一个对象，并且会自动调用init方法，构造对象
person = Person('小明','18')
print(person.__str__())
print(person)运行结果：
我们会发现：使用print函数去打印Person对象 与 调用 str 方法没有什么区别（直接去打印对象，底层也是通过对象调用str方法），都是打印出了对象在内存中的地址，与 Java类似，我们需要去重写str方法，自定义其中的内容，最终打印的就是自定义的内容。
代码演示：
# 重写 str 方法def __str__(self):# 这里返回的一定得是一个str对象return f'姓名:{self.name},年龄:{self.age}'运行结果：
当然我们也可以去看一下，没有 return 的后果：
操作符对应的特殊方法
| 运算符 | 特殊方法 | 描述 |
| + | __add__() | 执行加法运算 |
| - | __sub__() | 执行减法运算 |
| <，<=，== | __lt__()，__le__()，__eq__() | 执行比较运算 |
| >，>=，!= | __gt__()，__ge__()，__ne__() | 执行比较运算 |
| *，/ | __mul__()，__truediv__() | 执行乘法运算，非整除运算 |
| %，// | __mod__()，__floordiv__() | 执行取余运算，整除运算 |
| ** | __pow__() | 执行幂运算 |
这些了解即可，平常我们在写代码的时候，就是直接使用操作符去执行对应的功能了，不会去显式地调用这些方法。
特殊属性
| 特殊属性 | 描述 |
| obj.__dict__ | 对象的属性字典 |
| obj.__class__ | 对象所属的类 |
| class.__bases__ | 类的父类元组 |
| class.__base__ | 类的首个父类（括号内的第一个） |
| class.__mro__ | 类的层次结构 |
| class.__subclasses__() | 类的子类列表 |
代码演示：
class A():passclass B:passclass C(A,B):def __init__(self,name,age):self.name = nameself.age = agea = A()
b = B()
c =C('c',1)print('对象的属性字典:')
print(a.__dict__)
print(b.__dict__)
print(c.__dict__)print('对象所属的类:')
print(a.__class__)
print(b.__class__)
print(c.__class__)print('类的父元组:')
print(A.__bases__)
print(B.__bases__)
print(C.__bases__)print('类的父类:')
print(A.__base__)
print(B.__base__)
print(C.__base__)print('类的层次结构:')
print(A.__mro__)
print(B.__mro__)
print(C.__mro__)print('类的子类列表')
print(A.__subclasses__())
print(B.__subclasses__())
print(C.__subclasses__())运行结果：
类的深拷贝 与 浅拷贝
在正式学习之前，我们先来看一下下面的代码该怎么解读：
class A():passa = A()
b = a按照我们在前面所学的知识，这里是创建了一个A类，并且实例化了一个对象a，最后把a赋值给了b， 但由于 a 指向的是一个对象，因此 b 也指向了 a 这个对象。
用专业化的术语，b = a，称b指向了a所指向的对象，上述的过程也可以认为是拷贝。我们也可以打印出地址来观察：
既然说，b = a，是指 b 指向了 a 所指向的对象。那么我们来看一下 下面的代码：
class Person():def __init__(self,name,dog):self.name = nameself.dog = dogclass Dog():def __init__(self, name, age):self.name = nameself.age = agedef show(self):print(f'我叫{self.name},今年{self.age}岁了')dog = Dog('小狗',3)
person1 = Person('小明',dog)
# person2 指向了 person1 所指向的对象
person2 = person1
print(f'person1.dog == person2.dog?{person1.dog == person2.dog}')
# 修改 person2 所指向的dog的属性
person2.dog.name = '大白'
# 再打印person1 与 person2 的pet
person1.dog.show()
person2.dog.show()
# 此时把 person1 所指向的对象 拷贝一份 赋值给 person2(这里不是变量赋值，而是对象赋值)
import copy # 导包
person2 = copy.copy(person1)
print(f'person1.dog == person2.dog吗?{person1.dog == person2.dog}')
# 再修改 person2 所指向的dog的属性
person2.dog.name = '小猫'
person1.dog.show()
person2.dog.show()运行结果：
按理来说，将 对象拷贝一份之后，正常的应该就是两者相互不影响了呀，为什么后面修改小狗的属性还是会影响到前面的呢？还是用堆栈图来表述：
上面是直接将person1赋值给person2的结果，而下面的就是拷贝person1所指向的对象的结果，因此当我们通过person2去修改小狗的属性时，person1的小狗属性也会随之变化。之所以导致上面的情况，就是因为在拷贝时，对象包含的子对象内容不拷贝，原来的对象与拷贝的对象都会指向同一个子对象。这就是浅拷贝。
可能有小伙伴会好奇，Python中不是一切皆对象嘛，那如果把name属性修改了，还会影响到原来的吗？答案是不会，因为name这里是字符串类型，而字符串是不可变对象，当我们去修改时只会产生一个新的对象，也就是原本存放字符串的内容地址变为了别的字符串地址，我们来可以画图来表示：
要是实在不理解，就记住，浅拷贝与深拷贝不同的结果，只是针对可变对象的，对于哪些不可变对象不存在这样的问题。
那如果要把浅拷贝改为深拷贝呢？可以利用 copy 模块中的 deepcopy函数，来将子对象来拷贝。因此我们上面的代码也只需要将copy.copy() 改为 copy.deepcopy()即可。
好啦！本期 初始Python篇（12）—— object类、对象的特殊属性与方法、深拷贝与浅拷贝 的学习之旅 就到此结束啦！我们下一期再一起学习吧！