Python进阶 - 对象,名字以及绑定

写在前面

如非特别说明,下文均基于Python3

1、一切皆对象

Python哲学:

Python中一切皆对象

1.1 数据模型-对象,值以及类型

对象是Python对数据的抽象。Python程序中所有的数据都是对象或对象之间的关系表示的。(在某种意义上,为顺应冯·诺依曼“存储式计算机”的模型,Python中的代码也是对象。)

Python中每一个对象都有一个身份标识,一个值以及一个类型。对象创建后,其身份标识绝对不会改变;可以把身份标识当做对象在内存中的地址。is操作符比较两个对象的身份标识;id()函数返回表示对象身份标识的整数。

CPython实现细节:CPython解释器的实现中,id(x)函数返回存储x的内存地址

对象的类型决定了对象支持的操作(例如,对象有长度么?),同时也决定了该类型对象可能的值。type()函数返回对象的类型(这个类型本身也是一个对象)。与其身份标识一样,对象的类型也是不可改变的[1]

一些对象的值可以改变。可改变值的对象也称作可变的(mutable);一旦创建,值恒定的对象也叫做 不可变的(immutable)。(当不可变容器对象中包含对可变对象的引用时,可变对象值改变时,这个不可变容器对象值也被改变了;然而,不可变容器对象仍被认为是不可变的,因为对象包含的值集合确实是不可改变的。因此,不可变性不是严格等同于拥有不可变的值,它很微妙。) (译注:首先不可变容器对象的值是一个集合,集合中包含了对其他对象的引用;那么这些引用可以看做地址,即使地址指向的内容改变了,集合中的地址本身是没有改变的。所以不可变容器对象还是不可变对象。) 对象的可变性取决于其类型;例如,数字,字符串和元组是不可变的,但字典和列表是可变的。

对象从不显式销毁;当对象不可达时会被垃圾回收(译注:对象没有引用了)。一种解释器实现允许垃圾回收延时或者直接忽略——这取决于垃圾回收是如何实现的,只要没有可达对象被回收。

CPython实现细节: CPython解释器实现使用引用计数模式延时探测循环链接垃圾,这种方式可回收大多数不可达对象,但并不能保证循环引用的垃圾被回收。查看gc模块的文档了解控制循环垃圾回收的更多信息。其他解释器实现与CPython不同,CPython实现将来也许会改变。因此不能依赖垃圾回收器来回收不可达对象(因此应该总是显式关闭文件对象。)。

需要注意,使用工具的调试跟踪功能可能会导致应该被回收的对象一直存活,使用try...except语句捕获异常也可以保持对象的存活。

一些对象引用了如文件或者窗口的外部资源。不言而喻持有资源的对象被垃圾回收后,资源也会被释放,但因为没有机制保证垃圾回收一定会发生,这些资源持有对象也提供了显式释放外部资源的方式,通常使用close()方法。强烈推荐在程序中显式释放资源。try...finally语句和with语句为释放资源提供了便利。

一些对象包含对其他对象的引用,这些对象被称作 容器。元组,列表和字典都是容器。引用的容器值的一部分。大多数情况下,谈论容器的值时,我们暗指容器包含的对象值集合,而不是对象的身份标识集合;然而,谈论容器的可变性时,我们暗指容器包含的对象的身份标识。因此,如果不可变对象(如元组)包含对可变对象的引用,可变对象改变时,其值也改变了。

类型影响对象的绝大多数行为。在某些情况下甚至对象的身份标识的重要性也受到影响:对于不可变类型,计算新值的操作实际上可能会返回已存在的,值和类型一样的对象的引用,然而对于可变对象来说这是不可能的。例如,语句a = 1; b = 1执行之后,ab可能会也可能不会引用具有相同值得同一个对象,这取决于解释器实现。但是语句c = []; d = []执行之后,可以保证cd会指向不同的,唯一的新创建的空列表。(注意 c = d = []分配相同的对象给cd)

Note: 以上翻译自 《The Python Language References#Data model# Objects, values, types》 3.6.1版本。

1.2 对象小结

官方文档已经对Python 对象做了详细的描述,这里总结一下。

对象的三个特性:

  • 身份标识
    唯一标识对象;不可变;CPython解释器实现为对象的内存地址。
    操作:id(),内建函数id()函数返回标识对象的一个整数;is比较两个对象的身份标识。
    示例:

      >>> id(1)
      1470514832
      >>> 1 is 1
      True
    
  • 类型
    决定对象支持的操作,可能的值;不可变。
    操作:type(),内建函数返回对象的类型
    示例:

      >>> type('a')
      <class 'str'>
    

  • 数据,可变/不可变
    操作:==操作符用于比较两个对象的值是否相等,其他比较运算符比较对象间大小情况。
    示例:

      >>> 'python'
      'python'
      >>> 1 == 2
      False
    

可变与不可变:一般认为,值不可变的对象是不可变对象,值可变的对象是可变对象,但是要注意不可变集合对象包含可变对象引用成员的情况。

Python中的对象:

# -*- coding: utf-8 -*-
# filename: hello.py

'a test module'

__author__ = 'Richard Cheng'

import sys

class Person(object):
    ''' Person class'''

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


def tset():
    print(sys.path)
    p = Person('Richard', 20)
    print(p.name, ':', p.age)

def main():
    tset()

if __name__ == '__main__':
    main()

这段Python代码中有很多对象,包括hello这个模块对象,创建的Person类对象,几个函数如test, main函数对象,数字,字符串,甚至代码本身也是对象。

2、名字即“变量”

几乎所有语言中都有“变量”的说法,严格说来,Python中的变量不应该叫变量,称为名字更加贴切。

以下翻译自 Code Like a Pythonista: Idiomatic Python # Python has "names"

2.1 其他语言有变量

其他语言中,为变量分配值就像将值放到“盒子”里。
int a = 1;

把1放到盒子里

盒子a现在有了一个整数1

为同一个变量分配值替换掉盒子的内容:
a =2;

把2放到同一个盒子里

现在盒子a中放了整数2

将一个变量分配给另一个变量,拷贝变量的值,并把它放到新的盒子里:
int b = a;

b盒子里放了2
a盒子里也放了

b是第二个盒子,装有整数2的拷贝。盒子a有一份单独的拷贝。

2.2 Python有名字

Python中,名字或者标识符就像将一个标签捆绑到对象上一样。
a = 1

将名字a捆绑到对象1上

这里,整数对象1有一个叫做a的标签。

如果重新给a分配值,只是简单的将标签移动到另一个对象:
a = 2

标签a移动到另一个对象

1对象没有标签了

现在名字a贴到了整数对象2上面。原来的整数对象1不再拥有标签a,或许它还存在,但是不能通过标签a访问它了(当对象没有任何引用时,会被回收。)

如果将一个名字分配给另一名字,只是将另一个名字标签捆绑到存在的对象上:
b = a

有两个标签的对象

名字b只是绑定到与a引用的相同对象上的第二个标签而已。

虽然在Python中普遍使用“变量”(因为“变量”是普遍术语),真正的意思是名字或者标识符。Python中的变量是值得标签,不是装值得盒子。

2.3 指针?引用?名字?

C/C++中有指针,Java中有引用,Python中的名字在一定程度上等同于指针和引用。

2.1节中其他语言的例子,也只是针对于它们的基本类型而言的,若是指针或者引用,表现也跟Python的名字一样。这也在一定程度上说明了Python将面向对象贯彻得更加彻底。

2.4 名字支持的操作

可以对一个变量做什么?声明变量,使用变量,修改变量的值。名字作为Python中的一个重要概念,可以对它做的操作有:

  • 定义;名字需要先定义才能使用,与变量需要先声明一样。
  • 绑定:名字的单独存在没有意义,必须将它绑定到一个对象上。
  • 重绑定:名字可以重新引用另一个对象,这个操作就是重绑定。
  • 引用:为什么要定义名字,目的是使用它。

3、绑定的艺术

名字以及对象,它们之间必然会发生些什么。

3.1 变量的声明

其他如C/C++Java的高级语言,变量在使用前需要声明,或者说定义。以下在Java中声明变量:

public static void main(String[] args) {
        int i = 0; // 先声明,后使用
        System.out.println(i); // 使用变量i
}

这样,在可以访问到变量i所在作用域的地方,既可以使用i了。还有其他声明变量的方法么?好像没有了。

3.2 名字的定义

Python中有多种定义名字的途径,如函数定义,函数名就是引用函数对象的名字;类定义,类名就是指向类对象的名字,模块定义,模块名就是引用模块对象的名字;当然,最直观的还是赋值语句。

赋值语句

官方对赋值语句做了这样的说明(地址):

Assignment statements are used to (re)bind names to values and to modify attributes or items of mutable objects.

即:

赋值语句被用来将名字绑定或者重绑定给值,也用来修改可变对象的属性或项

那么,我们关心的,就是赋值语句将名字和值(对象)绑定起来了。

看一个简单的赋值语句:

a = 9

Python在处理这条语句时:

  1. 首先在内存中创建一个对象,表示整数9:
整数9对象
  1. 然后创建名字a,并把它指向上述对象:
名字a引用对象

上述过程就是通过赋值语句的名字对象绑定了。名字首次和对象绑定后,这个名字就定义在当前命名空间了,以后,在能访问到这个命名空间的作用域中可以引用该名字了。

3.3 引用不可变对象

定义完名字之后,就可以使用名字了,名字的使用称为“引用名字”。当名字指向可变对象和不可变对象时,使用名字会有不同的表现。

a = 9       #1
a = a + 1   #2

语句1执行完后,名字a指向表示整数9的对象:

名字a引用对象

由于整数是不可变对象,所以在语句2处引用名字a,试图将表示整数9的对象 + 1,但该对象的值是无法改变的。因此就将该对象表示的整数值91,以整数10新建一个整数对象:

新建表示10的整数对象

接下来,将名字a 重绑定 到新建对象上,并移除名字对原对象的引用:

重绑定

使用id()函数,可以看到名字a指向的对象地址确实发生了改变:

>>> a = 9
>>> id(a)
1470514960
>>> a = a + 1
>>> id(a)
1470514976
3.4 引用可变对象
3.4.1 示例1:改变可变对象的值

可变对象可以改变其值,并且不会造成地址的改变:

>>> list1 = [1]
>>> id(list1)
42695136
>>> list1.append(2)
>>> id(list1)
42695136
>>> list1
[1, 2]
>>> 

执行语句list1 = [1],创建一个list对象,并且其值集中添加1,将名字list1指向该对象:

初始集合

执行语句list1.append(2),由于list是可变对象,可以直接在其值集中添加2

添加值

值得改变并没有造成list1引用的对象地址的改变。

3.4.2 示例2:可变对象循环引用

再来看一个比较“奇怪”的例子:

values = [1, 2, 3]
values[1] = values
print(values)

一眼望去,期待的结果应该是

[1, [1, 2, 3], 3]

但实际上结果是:

[1, [...], 3]

我们知道list中的元素可以是各种类型的,list类型是可以的:

循环引用
3.4.3 示例3:重绑定可变对象

观察以下代码段:

>>> list1 = [1]
>>> id(list1)
42695136
>>> list1 = [1, 2]
>>> id(list1)
42717432

两次输出的名字list1引用对象的地址不一样,这是因为第二次语句list 1 = [1, 2] 对名字做了重绑定:

重绑定
3.5 共享对象

当两个或两个以上的名字引用同一个对象时,我们称这些名字共享对象。共享的对象可变性不同时,表现会出现差异。

3.5.1 共享不可变对象

函数attempt_change_immutable将参数i的值修改为2

def attempt_change_immutable(i):
    i = 2

i = 1
print(i)
attempt_change_immutable(i)
print(i)

Output:

1
1

如果你对输出不感到意外,说明不是新手了 _

  1. 首先,函数的参数i与全局名字i不是在同一命名空间中,所以它们之间不相互影响。
  2. 调用函数时,将两个名字i都指向了同一个整数对象。
  3. 函数中修改i的值为2, 因为整数对象不可变,所以新建值为2的整数对象,并把函数中的名字i绑定到对象上。
  4. 全局名字i的绑定关系并没有被改变。
两个i指向同一个对象
改变函数i的绑定关系

值得注意的是,这部分内容与命名空间和作用域有关系,另外有文章介绍它们,可以参考。

3.5.2 共享可变对象

函数attempt_change_mutable为列表增加字符串。

def attempt_change_mutable(list_param):
    list_param.append('test')

list1 = [1]
print(list1)
attempt_change_mutable(list1)
print(list1)

output:

[1]
[1, 'test']

可以看到函数成功改变了列表list1的值。传递参数时,名字list_param引用了与名字list1相同的对象,这个对象是可变的,在函数中成功修改了对象的值。

首先,名字list_param与名字list1指向对象:

共享可变对象

然后,通过名字list_param修改了对象的值:

修改共享对象值

最后,这个修改对名字list1可见。

3.6 绑定何时发生

总的来说,触发名字对象绑定的行为有以下一些:

  • 赋值操作;a = 1

  • 函数定义;

      def test():
          pass
    

将名字test绑定到函数对象

  • 类定义:

      class Test(object):
          pass
    

将名字Test绑定到类对象

  • 函数传参;

      def test(i):
          pass
      test(1)
    

将名字i绑定到整数对象1

  • import语句:

     import sys
    

将名字sys绑定到指定模块对象。

  • for循环

      for i in range(10):
          pass
    

每次循环都会绑定/重绑定名字i

  • as操作符

      with open('dir', 'r') as f:
          pass
      
      try:
          pass
      except NameError as ne:
          pass
    

with open语句,异常捕获语句中的as都会发生名字的绑定

4、其他说明

待续。。。

参考

  1. The Python Language References#Data model# Objects, values, types
  2. Python的名字绑定
  3. Python一切皆对象
  4. Code Like a Pythonista: Idiomatic Python
  5. python基础(5):深入理解 python 中的赋值、引用、拷贝、作用域

脚注

<span id="jump">[1]</span> 在特定的控制条件下,改变对象的类型是可能的。但不是一种明智的做法,如果处理不当的话,会发生一些奇怪的行为。

推荐阅读更多精彩内容

  • http://python.jobbole.com/85231/ 关于专业技能写完项目接着写写一名3年工作经验的J...
    IT诸葛亮阅读 4,632评论 1 116
  • 定义类并创建实例 在Python中,类通过 class 关键字定义。以 Person 为例,定义一个Person类...
    绩重KF阅读 1,491评论 0 11
  • 1.1==,is的使用 ·is是比较两个引用是否指向了同一个对象(引用比较)。 ·==是比较两个对象是否相等。 1...
    SylarX阅读 2,754评论 2 2
  • 个人笔记,方便自己查阅使用 Py.LangSpec.Contents Refs Built-in Closure ...
    freenik阅读 66,255评论 1 5
  • 这是一款全键盘手机,触屏智能机时代很是罕见。锡色的键盘漆已经掉了不少,露出脏兮兮的塑料色,屏幕也多了好几道划痕——...
    剑白阅读 10,344评论 5 16