python学习笔记：python对象

2022-07-31 08:08:12

一、python对象

python使用对象模型来存储数据，构造任何类型的值都是一个对象。所有的python对象都拥有三个特性：身份、类型和值。

身份：每个对象都有一个唯一的身份标识自己，对象的身份可以用内建函数id()来得到。这个值可以被认为是该对象的内存地址。
类型：描述一种对象的类型所需要的信息不可能用一个字符串来搞定，所以类型不能是一个简单的字符串。这些信息不能也不应该和数据保存在一起，所以我们将类型定义成对象，这就是说类型对象，所有类型对象的类型都是type。可以用内建函数type()查看对象的类型。
值：对象表示的数据项。如果对象支持更新操作，那么它的值就可以改变，否则它的值就是只读的。对象的值是否可以改变被称为对象的可改变性。

二、标准类型操作符

比较操作符用来判断同类型对象是否相等，数字类型根据数值的大小和符号比较，字符串按照字符序列值进行比较。比较操作符是针对对象的值进行的，也就是说比较的是对象的数值而不是对象本身。

对象本身的比较，也可以说是对象身份的比较。对象就像一个装着内容的盒子，当一个对象被赋值到一个变量，就像在这个盒子上贴了一个标签，表示创建了一个引用。每当这个对象有了一个新的引用，就会在盒子上新贴一张标签。当一个引用被销毁时，这个标签就会被撕掉。当所有的标签都被撕掉时，这个盒子就会被回收。现在有下面的定义：

foo1 = foo2 = 4.3   #foo1 = 4.3  foo2 = foo1

每个对象都天生具有一个计数器，记录它自己的引用次数，这个数目表示有多少个变量指向该对象。python使用is和is not操作符来测试两个变量是否指向同一个对象。针对上面的这幅图，下面的两个表达式的值都是true。

foo1 is foo2

id(foo1) == id(foo2)

提示：

为什么上面的例子中使用的是浮点型的数据而不是整型？因为python会高效地缓存整型对象和字符串对象，python为什么会缓存它们两个呢？因为它们都是不可变对象，python认为它们在应用程序中会经常被用到。

在更新模型中会讲什么是不可变对象，其实不可变对象一共有三个，整型、字符串、元组，python仅仅缓存字符串和小整型。

>>> a = 1

>>> b = 1

>>> a is b

True

>>> c = 2.1

>>> d = 2.1

>>> c is d

False

>>> id(a)

166611120

>>> id(b)

166611120

>>> id(c)

166649004

>>> id(d)

166648988

三、标准类型内建函数

下面介绍四个有用的内建函数：

type()： type接收一个对象作为参数，返回这个对象的类型。type的返回值是一个类型对象。
cmp()：比较是在对象之间进行的，不管是标准类型对象还是用户自定义对象。如果是用户自定义对象，cmp()会调用该类的特殊方法__cmp()__。
str()：致力于生成一个对象的可读性好的字符串，str的输出对用户比较友好。
repr()：返回一个对象的字符串表示，repr的输出对python比较友好。大多数情况下可以通过求值运算，重新得到该对象。obj==eval(repr(obj))是成立的。repr和''的功能是一样的。

还有一个有用的内建函数叫做instance()，下面通过一段脚本，演示type和instance这两个内建函数。

#! /usr/bin/python

#函数displayNumType接收一个数值参数，使用内建函数type确认数值的类型

def displayNumType(num):

    print num, 'is',

    if isinstance(num, (int, long, float, complex)):

        print 'a number of type: ', type(num).__name__

    else:

        print 'not a number at all!'

displayNumType(-69)

displayNumType(999999999L)

displayNumType(98.6)

displayNumType(-5.2+1.9j)

displayNumType('xxx')

下面看一下这个dispayNumType函数的初级版本：

#函数displayNumType接收一个数值参数，使用内建函数type确认数值的类型

def displayNumType(num):

    print num, "is",    #print默认是会换行的，后面加上一个逗号就不会换行了

    if type(num) == type(0):

        print 'an integer'

    elif type(num) == type(0L):

        print 'a long'

    elif type(num) == type(0.0):

        print 'a float'

    elif type(num) == type(0+0j):

        print 'a complex number'

    else:

        print 'not a number at all'

上面的代码存在一些效率上的不足，做以下的修改：

1. 减少type()函数的调用次数

代码每次判断都要调用两次type()函数，会付出性能的代价，可以通过引入types模块来减少type()函数的调用次数：

import types

if type(num) == types.IntType:

2. 把对象的值比较转变成对象身份比较

在运行时期，只有一个类型对象来表示整型类型。也就是说，type(0)，type(100)，type(-21)都是同一个对象<type 'int'>，types.IntType也是这个对象。既然他们都是同一个对象，就没有必要浪费时间去获得并比较他们的值，所以比较对象本身是一个好的方法。

if type(num) is types.IntType   # or type(0)

它们之间的结构布局可以是这样的：

每一个类型有且仅有一个类型对象。

3. 减少查询次数

为了得到整型的对象类型，解释器不得不首先查找types这个模块的名字，然后在该模块的字典中查找IntType。通过使用from-import，可以减少一次查询。

from types import IntType

if type(num) is IntType:

四、标准类型的分类

标准类型的定义：称它们是基本内建数据对象原始类型。具体的解释：

基本：是指这些类型都是python提供的标准或核心类型。
内建：是由于这些类型是python默认就提供的。
数据：是因为他们用于一般数据存储。
对象：是因为对象是数据和功能的默认抽象。
原始：是因为这些类型提供的是最底层的粒度数据存储。
类型：是因为他们就是数据类型。

有三种不同的模型对python标准类型分类：

1. 存储类型

第一种分类方式就是看这种类型的对象能够保存多少个对象。一个能保存单个字面对象的类型，我们称它为原子或者标量存储。那些可容纳多个对象的类型，我们称之为容器存储。容器类型又带来一个新问题，那就是它是否可以容纳不同类型的对象，所有的python容器对象都能够容纳不同类型的对象。如下表，按存储模型对python的类型分类：

注意：字符串看上去像一个容器，因为它“包含”字符，并且经常多于一个字符，不过由于python并没有字符类型，所以字符串是一个自我包含的文字类型。

2. 更新模型

另一种对标准类型的分类标准就是，对象创建成功之后，它的值是否可以更新。对于可变对象，允许他们的值被更新，而不可变对象则不允许他们的值被更新。

看下面的例子：

x = 'python numbers and strings'

x = 'are immutable? What gives?'

i = 0

i = i + 1

上面的例子中，事实上是一个新对象被创建，然后它取代了旧对象。新创建的对象被关联到原来的变量名，旧对象被丢弃，垃圾回收器会在合适的时机回收这些对象。可以通过内建函数id()查看他们的身份的变化。

3. 访问模型

在访问模型中有三种访问方式：直接存取、顺序和映射。

对非容器类型可以直接访问，所有的数值类型都归到这一类。

序列类型是指容器内的元素按从0开始的索引顺序访问。字符串、元组、列表都归到这一类，python不支持字符类型，虽然字符串是简单文字类型，但是因为它有能力按照顺序访问子字符串，所有也将它归到序列类型。

映射类型通过一个唯一的键来访问，这就是映射类型，它容纳的是哈希键-值对的集合。

五、python不支持的类型

python不支持char或者byte类型来保存一个字符或者8位整数，可以用长度为1的字符串表示。

在python中可以用id()函数得到一个对象的身份号，这是最接近指针的地址，在python中一切都是指针，但是程序员不能修改这个指针。

python的整型实现等同于C语言的长整型。

python的浮点类型实际上就是C语言的双精度浮点类型。

码农公寓