前言 

前面我们学习类和对象以及面向对象的三大特征。类和对象还是很好理解的，在Python中一切皆是对象，而类是创建对象的模版，创建对象的过程，也被称为"类的实例化"，因为类从一个飘无虚渺的概念，变为了一个实实在在的、看得见摸得着（可以去访问方法与属性）的对象，因此就叫实例化。紧接着我们又学习了面向对象编程的三大特征，封装、继承、多态。封装主要是体现在类的属性与方法带有访问权限了，并且外部在调用该方法时，不需要知道底层是如何实现的，相当于隐藏了内部的细节。继承是对共性的一个抽取（猫和狗，抽象成动物）主要是实现了代码的复用（动物类有了姓名、年龄这些属性之后，子类可以直接用，而不用再去定义）。继承之中有一个知识点是方法重写，即子类定义了一个与父类同名的方法，就称子类的方法为重写的方法。多态是描述不同的对象在面对同一件事情时，所表现出的行为不同，而Python中的多态要和其他语言区分开来，这里的多态只要两个类的对象都有同一个方法，那么当把这些对象封装一下（使用 obj = A/B），然后再去调用这个方法，就会表现出不同的行为。这其实也很好理解，虽然表面上看起来是同一个对象在调用同一个方法，但其底层根本就是不同的对象，自然调用同一个方法时，所表现出行为就不同了。

其实Python中的面向对象还是很好理解的，多去想一想，通过代码辅助的话，应该理解的更快了。接下来，我们学习新的知识。

object对象

通过前面的学习，我们已经知道了：object类是所有类的直接父类或者间接父类，那么这些类肯定都是会拥有object类中所有共有与受保护的属性、方法。我们接下来就是要学习某些属性与方法。

代码演示：

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

    def show(self):
        print(f'我的名字是{},今年{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就是None
        return super().__new__(cls)

    def __init__(self,name,age):
        print('init方法执行了')
         = name
        self.age = age

    def show(self):
        print(f'我的名字是{},今年{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.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():
    pass

class B:
    pass

class C(A,B):
    def __init__(self,name,age):
         = name
        self.age = age

a = 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():
    pass

a = 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):
         = name
        self.dog = dog

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

    def show(self):
        print(f'我叫{},今年{self.age}岁了')

dog = Dog('小狗',3)
person1 = Person('小明',dog)
# person2 指向了 person1 所指向的对象
person2 = person1
print(f'person1.dog == person2.dog?{person1.dog == person2.dog}')
# 修改 person2 所指向的dog的属性
 = '大白'
# 再打印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的属性
 = '小猫'
person1.dog.show()
person2.dog.show()

运行结果：

按理来说，将 对象拷贝一份之后，正常的应该就是两者相互不影响了呀，为什么后面修改小狗的属性还是会影响到前面的呢？还是用堆栈图来表述：

上面是直接将person1赋值给person2的结果，而下面的就是拷贝person1所指向的对象的结果，因此当我们通过person2去修改小狗的属性时，person1的小狗属性也会随之变化。之所以导致上面的情况，就是因为在拷贝时，对象包含的子对象内容不拷贝，原来的对象与拷贝的对象都会指向同一个子对象。这就是浅拷贝。

可能有小伙伴会好奇，Python中不是一切皆对象嘛，那如果把name属性修改了，还会影响到原来的吗？答案是不会，因为name这里是字符串类型，而字符串是不可变对象，当我们去修改时只会产生一个新的对象，也就是原本存放字符串的内容地址变为了别的字符串地址，我们来可以画图来表示：

要是实在不理解，就记住，浅拷贝与深拷贝不同的结果，只是针对可变对象的，对于哪些不可变对象不存在这样的问题。 

那如果要把浅拷贝改为深拷贝呢？可以利用 copy 模块中的 deepcopy函数，来将子对象来拷贝。因此我们上面的代码也只需要将copy.copy() 改为 copy.deepcopy()即可。

好啦！本期 初始Python篇（12）—— object类、对象的特殊属性与方法、深拷贝与浅拷贝 的学习之旅 就到此结束啦！我们下一期再一起学习吧！