python中的对象

一、python对象

　　python使用对象模型来存储数据。构造任何类型的值都是一个对象。

　　所有python对象都拥有三个特性：身份、类型、值

　　　　身份：每个对象都有一个唯一的身份标识自己，任何对象的身份可以使用内建函数 id() 来得到。

　　　　类型：对象的类型决定了该对象可以保存什么类型的值，可以进行什么样的操作，以及遵循什么样的规则。可以使用 type() 函数查看python对象的类型。type()返回的是对象而不是简单的字符串。

　　　　值：对象表示的数据。

1 2 3 4 5 6 7 8

>>> value = "abc" >>> id(value)   #身份 39102784L >>> type(value) #类型 <type 'str'> >>> value  #值 'abc' >>>

二、python类型

　　（1）.标准类型

　　　　1.数字（分为几个字类型，其中三个是整型）

　　　　2.Integer  整型

　　　　3.Boolean  布尔型

　　　　4.Long integer  长整型

　　　　5.Floating point real number  浮点型

　　　　6.Complex number 复数型

　　　　7.String 字符串

　　　　8.List 列表

　　　　9.Tuple 元祖

　　　　10.Dictionary 字典

　　（2）.其他内建类型

　　　　类型、Null对象（None）、文件、集合/固定集合、函数/方法、模块、类

　　　　通过type()函数可以查看对象的类型

1 2 3 4 5 6 7 8 9

>>> type(1) <type 'int'>  #它是一个类型对象 >>> type("123") <type 'str'>　　#它是一个类型对象 >>> type([1,2,"3"]) <type 'list'>　　#它是一个类型对象 >>> type((1,2,"3")) <type 'tuple'>　　#它是一个类型对象 >>>

　　　　类型对象的类型是type，它是所有python类型的根和所有python标准类的默认元类

1 2 3 4 5

>>> type(type(1)) <type 'type'> >>> type(type("123")) <type 'type'> >>>

　　注意：所有标准对象均可用于布尔测试，同类型的对象之间可以比较大小。每个对象天生具有布尔True或False值。值为零的任何数字或者Null对象None的布尔值都是False。

　　下列对象的布尔值是False：None、False、所有的值为零的数、0（整数）、0.0（浮点数）、0L(长整数)、0.0+0.0j（复数）、“”（空字符串）、[]（空列表）、（）（空元祖）、{}（空字典）。值不是上面列出来的任何值的对象的布尔值都是True。

三、对象的比较

　　（1）.对象值值的比较

贴代码

　　（2）.对象身份的比较（重点理解哦）

　　　　对象可以被赋值到另一个变量（通过引用）。因为每个变量都指向同一个（共享的）数据对象，只要任何一个引用发生改变，该对象的其他引用也会随之改变。

　　　　例子1：foo1和foo2指向相同的对象

　　　　　　foo1 = foo2 = 4.3

　　　　　　这个语句的实际意思是一个值为4.3的数字对象被创建，然后这个对象的引用被赋值给foo1和foo2，结果就是foo1和foo2指向同一个对象

                                                

　　　　例子2：foo1和foo2指向相同的对象

　　　　　　foo1 = 4.3

　　　　　　foo2 = foo1

　　　　　　这个例子非常类似上一个，一个值为 4.3 的数值对象被创建，然后赋给一个变量，当执行 foo2 = foo1 时， foo2 被指向 foo1 所指向的同一个对象， 这是因为 Python 通过传递引用来 处理对象。foo2 就成为原始值 4.3 的一个新的引用。这样 foo1 和 foo2 就都指向了同一个对 象。示意图也上图一样。

　　　　例子3：foo1和foo2指向不相同的对象

　　　　　　foo1 = 4.3

　　　　　　foo2 = 1.3 + 3

　　　　　　这个例子有所不同。首先一个数字对象被创建，然后赋值给 foo1. 然后第二个数值对象被 创建并赋值给 foo2. 尽管两个对象保存的是同样大小的值，但事实上系统中保存的都是两个独立的对象，其中foo1是第一个对象的引用， foo2则是第二个对象的引用。如下图给我们这里有两个不同的对象，尽管这两个对象有同样大小的数值。我们为什么在示意图中使用盒子？没错，对象就象一个装着内容的盒子。当一个对象被赋值到一个变量，就象在这个盒子上贴了一个标签，表示创建了一个引用。每当这个对象有了一个新的引用，就会在盒子上新贴一张标签。当一个引用被销毁时，这个标签就会被撕掉。当所有的标签都被撕掉时，这个盒子就会被回收。

                                                                

　　　　那么，Python 是怎么知道这个盒子有多少个标签呢？每个对象都天生具有一个计数器，记录它自己的引用次数。这个数目表示有多少个变量指向该对象。他就是上一节提到的引用计数器。

　　　　提供了is和is not运算符来测试两个变量是否指向同一个对象。

1 2 3 4 5 6 7 8 9 10 11

>>> a = "123" >>> id(a) 48523104L >>> b = "123" >>> id(b) 48523104L >>> a is b True >>> id(a) == id(b) True >>>

四、工厂函数

　　他们看上去像函数，但实际上他们是类。当你调用它们时，实际上是生成了该类型的一个实例。

　　他们包含：int()、long()、float()、complex()、str()、unicode()、basestring()、list()、tuple()、type()、dict()、bool()、set()、frozenset()、object()、classmethod()、staticmethod()、super()、property()、file()

五、类型的分类

　　按存储模型

　　　　1.标量/原子类型（数值，字符串）

　　　　2.容器类型（列表、元祖、字典）

　　按更新模型（重点看看哦）

　　　　1.可变类型（列表、字典）

　　　　　　所谓可变对象是指，对象的内容可变，而不可变对象是指对象内容不可变。

1 2 3 4 5 6 7 8 9 10 11 12 13 14

>>> aList = ['java',66,88,'python'] >>> aList ['java', 66, 88, 'python'] >>> aList[2] 88 >>> id(aList)  #注意观察id值 48255112L >>> aList[2] = aList[2] + 12 >>> aList[3] = "python2" >>> aList ['java', 66, 100, 'python2'] >>> id(aList) 48255112L　　#注意观察id值 >>>

　　　　2.不可变类型（数字、字符串、元祖）

　　　　注意喽：下面的例子中，事实上是一个新对象被创建，然后它取代了旧对象。新创建的对象被关联到原来的变量名，旧对象被丢弃，垃圾回收器会在适当的时机回收这些对象。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

>>> v1 = "python" >>> id(v1) 31631080L >>> v1 = "java" >>> id(v1) 31632240L  #由于str是不可变的，重新创建了java对象，随之id改变，旧对象python会在某个时刻被回收 >>> >>> v2 = 12 >>> v3 = 12 >>> id(v2),id(v3)　　#同指同一内存区域，id相同 (31489840L, 31489840L) >>> v2 += 1 >>> v2 13 >>> id(v2),id(v3) (31489816L, 31489840L) >>>

　　按访问模型

　　　　1.直接访问（数字）

　　　　2.顺序访问（字符串、列表、元祖）

　　　　3.映射访问（字典)

六、不支持的类型（该版本是2.*的不支持，3.*版本的个别可能会有支持了）

　　1.char或byte

　　2.指针

　　3.int vs short vs long

　　4.float vs double