本文主要简单的来聊聊关于Python核心概念——对象的有关知识。

欢迎转发、分享、点赞、收藏，谢谢^_^

关于对象

在Python编程世界里，我们始终牢记：“对象”是一切程序的切入点，所谓的程序就是对象或对象间的关系处理和展现。所以，对象是Python的核心概念也是底层逻辑支撑。

你可能要问了，“数据呢？”。这个问题问得好。因为这涉及到数据和对象的关系。为此，你可以查看Python语言参考标准，会看到类似这样的表述：

“Objects are Python’s abstraction for data. All data in a Python program is represented by objects or by relations between objects.”

啥意思？就是说，对象（Objects）是Python对数据的抽象，Python程序中所有数据是由对象或对象间关系表示的。简单来说，对象既是Python程序驱动的主体，又是处理数据的载体。所以，Python编程就是“搞对象，搞好对象，优雅地搞对象”——天生是OOP的。

为了管理好形形色色的对象，对象是有区别的，即每个对象都有标识（ID）、类型（Type）和值（Value）。一旦对象被创建，它的身份标识就不会改变，这个标识你可以把它看作是对象在内存中的地址。用' is '操作符来比较两个对象的标识是否同一个对象，通常是用内置函数id()函数返回一个表示对象标识的整数。如下所示：

>>> a = 12

>>> b = a

>>> c = "abc"

>>> b is a

True

>>> c is b

False

>>> print(f"a's id={id(a)};b's id={id(b)}")

a's id=140711713118320;b's id=140711713118320

可以进一步推出，用 is 判断是不是同一个对象，其实就是比较两个对象的标识是否一致。

有些对象包含对“外部”资源的引用，如打开的文件或窗口。可以理解为当对象被垃圾回收时，这些资源将被释放，但由于垃圾回收并不保证及时发生，这样的对象还提供了一种显式的方式来释放外部资源，通常是close()方法。Python中强烈建议程序显式关闭这类对象。而' try…finally '语句和' with '语句提供了便捷方式来这样做。

有些对象包含对其他对象的引用，这些对象被称为容器。容器有元组（Tuple）、列表（List）和字典（Dict）。引用是容器值的一部分。在大多数情况下，当我们谈论容器的值时，我们暗示的是值，而不是包含的对象的标识。然而，当我们谈论容器的可变性时，只暗示了直接所包含对象的标识。因此，如果一个不可变容器(如元组)包含一个对可变对象的引用，当可变对象被改变时，它（标识对象）的值也会改变。

>>> a = [11,22,33]

>>> xt = (123,321,a)

>>> xtID = id(xt)

>>> xtID

2049391036160

>>> print(f'xtaID={id(xt[2])}')

xtaID=2049391092800

>>> xt[2].append('abc')

>>> print(f'xtaID={id(xt[2])}')

xtaID=2049391092800

>>> print(f'xtID={id(xt)}')

xtID=2049391036160

>>>

你观察下运行结果，体味下所谓的可变与不可变对象——概括而言，即身份标识可能不变，但所包含的内容（值）是可以变的。

进一步讲，对象类型几乎影响对象行为的所有方面。甚至对象标识的重要性在某种意义上也受到了影响:对于不可变类型，计算新值的操作实际上可能返回对任何具有相同类型和值的现有对象的引用，而对于可变对象，这是不允许的。例如，a = 1;b = 1, a和b可能指的是值为1的同一个对象，也可能不是，这取决于实现，但在c =[]；d =[]， c和d保证指向两个不同的、唯一的、新创建的空列表。(注意：c = d =[]将相同的对象分配给c和d。)

对象协议

你在学习Python编程中会在教程中经常看到“协议”（Protocols）这一表述。说简单点，就是相应对象的一些预定的或特定的编程约定，诸如需要实现的名字和方法等。比如数字协议、容器协议、迭代协议、生成器协议（要支持的方法）等等，你要想实现相应的类型，必须实现相应的协议（方法，或者你可理解为Java中的接口）。

我们知道，Python是动态语言，其大多数的语言特征都是基于“协议”定义完成的。动态的解释代码来判定类型，然后执行相应的操作；而不像Java这种静态语言，实现要进行编译和正确性检验，再进行相应的运算。我们看看下面的一个例子：

def computeCost(unitPrice,numUnits):

return unitPrice * numUnits

你觉得这个函数参数输入什么合适？答案看似简单——其实貌似啥都可以！

第一眼可能觉得输入数字计算量价乘积：

>>> computeCost(1.25, 50)

62.5

>>>

确实如期望地执行了，但你还可以给它指定分数和小数来运行：

>>> from fractions import Fraction

>>> computeCost(Fraction(5, 4), 50)

Fraction(125, 2)

>>> from decimal import Decimal

>>> computeCost(Decimal('1.25'), Decimal('50'))

Decimal('62.50')

>>>

甚至你不期望的方式它也能正常运行：

>>> computeCost('a lot of', 10)

'a lot ofa lot ofa lot ofa lot ofa lot ofa lot ofa lot ofa lot ofa lot ofa lot of'

>>> import numpy as np # 第三方库

>>> prices = np.array([1.25, 2.10, 3.05])

>>> units = np.array([50, 20, 25])

>>> computeCost(prices, quantities)

array([62.5 , 42. , 76.25])

>>>

然而某些类型联合就不起作用了：

>>> computeCost(Fraction(5, 4), Decimal('50'))

Traceback (most recent call last):

File "<pyshell#186>", line 1, in <module>

computeCost(Fraction(5, 4), Decimal('50'))

File "<pyshell#178>", line 2, in computeCost

return unitPrice * numUnits

TypeError: unsupported operand type(s) for *: 'Fraction' and 'decimal.Decimal'

>>>

说这么多，就是想加深你的理解。Python不像静态语言的编译器那样预先验证正确的程序行为。相反，对象的行为是由一个动态过程决定的，该过程涉及所谓的“特殊”或“神奇”方法（所谓协议）的分派。这些特殊方法的名称总是在前面和后面加上双下划线(__).

当程序执行时，解释器自动触发这些方法。例如，操作x * y由方法x.__mul__(y)执行。这些方法的名称及其对应的操作符是硬连接的(hard-wired)。任何给定对象的行为完全取决于它实现的一组特殊方法(协议)。

最后

本篇就先聊这些，后续篇章将描述与不同类别的核心解释器特性相关的特殊方法。这些类别范畴（含有特定的方法）有时称为“协议”。至于对象，包括用户定义的类，可以定义这些特性的任何组合，以使对象以不同的方式行为。

欢迎点赞 + 转发，谢谢^_^