【Python2】03、Python对象

一、Python对象的相关术语

      python中一切皆对象，Python程序中保存的所有数据都是围绕对象这个概念展开的；所有的对象都是由类实例化而来的，只不过这些类有些是python内置的类；例如，整数和浮点数，字符串都是由python内置的类实例化而来的。除此之外用户还可以自定义类型，就是类。

python程序中存储的所有数据都是对象

每个对象都有一个身份、一个类型和一个值

         例如，school=“MaGe linux”会以“MaGe Linux”创建一个字符串对象，其身份是指向它在内存中所处位置的指针(其在内存中的地址)，而school就是引用这个具体位置的名称

对象的类型也称对象的类别，用于描述对象的内部表示及它支持的方法和操作

创建特定类型的对象时，有时也将该对象称为该类型的实例

class：自定义类型

type：内置类型

instance：实例化

实例被创建后，其身份和类型就不可改变

       如对象值是可修改的，则称为可变对象

       如果对象的值不可修改，则称为不可变对象

如果某个对象包含对其它对象的引用，则将其称为容器；

大多数对象都拥有大量特有的数据属性和方法

类=数据（变量）+方法（函数）

       属性：与对象相关的值；就是类实例化为对象时可以为内部的变量赋值，对象内部可用变量名就称之为对象的属性

       方法：被调用时将在对象上执行某些操作的函数

       使用点(.)运算符可以访问属性和方法

In [1]: name="xiejun"      #name是引用内存中的地址的名称

In [2]: id(name)
Out[2]: 28642832           #身份就是内存中的地址

In [3]: type(name)
Out[3]: str                #类型也就是类

In [4]: str.    
str.capitalize  str.fORMat      str.isupper     str.rfind       str.startswith
str.center      str.index       str.join        str.rindex      str.strip
str.count       str.isalnum     str.ljust       str.rjust       str.swapcase
str.decode      str.isalpha     str.lower       str.rpartition  str.title
str.encode      str.isdigit     str.lstrip      str.rsplit      str.translate
str.endswith    str.islower     str.mro         str.rstrip      str.upper
str.expandtabs  str.isspace     str.partition   str.split       str.zfill
str.find        str.istitle     str.replace     str.splitlines

Python内置函数id()可返回一个对象的身份，即该对象在内存中的位置

is运算符用于比较两个对象的身份

type()用于返回一个对象的类型

对象类型本身也是一个对象，称为对象的类

该对象的定义是唯一的，且对于某类型的所有实例都是相同的

所有类型对象都有一个指定的名称，可用于执行类型检查，

两个对象的比较：

1、值比较：对象中的数据是否相同

2、身份比较：两个变量名引用的是否为同一对象

3、类型比较：两个对象的类型是否相同

In [4]: num1=5

In [5]: num2=5

In [6]: num1==num2        #值相同
Out[6]: True

In [7]: num1 is num2      #值相同身份不一定相同，只是此处恰好相同
Out[7]: True

In [8]: type(num1) is type(num2)  #类型相同
Out[8]: True

二、Python对象类型

1、Python核心数据类型

类型分类                                 对象类型                                                               例子

数字                  int，long(长×××),foloat,complex（复数）,bool（布尔值）        3077, 3.14, 300000

字符                                  str,unicode,                                             ‘mageedu.com’, “spam”

列表                         [‘one’, ‘two’, ‘three’]

字典                        {‘course’:’linux’, ‘tutor’:’mage’}

元组                        (32, ‘spam’, ‘eggs’)

文件                         myFile=open(‘/tmp/tfile’,’r’)

集合                         set(‘abc’), frozenset(不可变类型)                              {‘a’, ‘b’, ‘c’}

其它类型                  类类型、None（空）、bool(布尔型)

编程单元类型            函数、模块、类

与实现相关的类型      编译的代码堆栈跟踪

其它文件类型工具：pipes(管道)，fifos(先进先出管道)，Sockets

2、类型转换

 1）使用内置函数：           #显示转换

             str(),repr()精确值或format()转换为特定格式：将非字符型数据转换为字符串

           int()：转换为整数

             float()：转换为浮点数

             list()：将字符串转换为列表

             tuple（）：将字符串转换为元祖

             set()：将字符串转为集合

             frozenset()：将字符串转换为不可变集合

             dict(d):创建字典;d必须元素为键值对的元祖的列表

             chr():将整数转换为字符

              ord():将字符转换为整数值

             hex（）：将整数转换为十六制字符串

              bin()：二进制

              oct（）：八进制

In [20]: l1="xie jun"

In [21]: type(l1)
Out[21]: str

In [22]: l2=list(l1)

In [23]: type(l2)
Out[23]: list

In [24]: print l2
['x', 'i', 'e', ' ', 'j', 'u', 'n']

In [25]: l3=12345

In [26]: type(l3)
Out[26]: int

In [27]: l4=list(l3)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-27-da565bf35804> in <module>()
----> 1 l4=list(l3)

TypeError: 'int' object is not iterable

In [28]:


In [36]: d1=dict([("x",1),("y",2)])     # d必须是元素为键值对的元祖的列表   

In [37]: d1
Out[37]: {'x': 1, 'y': 2}

3、数字类型

python的数字字面量

布尔型：True，False    1，0

整数：

浮点数：

复数：

注意：

       字面量是指由字母，数字等构成的字符串或者数值，它只能作为右值出现，所谓右值是指等号右边的值，如：int a=123这里的a为左值，123为右值。
常量和变量都属于变量，只不过常量是赋过值后不能再改变的变量，而普通的变量可以再进行赋值操作

例如：

int a;               #a变量
const int b=10;              #b为常量,10为字面量
string str="hello world";                #str为变量,hello world为也字面量

数字类型操作

Python使用5种数字类型：布尔型、整型、长整型、浮点型和复数，所有数字类型均为不可变

数字操作：

比较运算：

In [7]: 3<<3          #就是在用二进制表示向左移动3位，加3个0
Out[7]: 24

In [8]: 24>>3         #就是在用二进制表示向向移动3位，去掉前3位，剩下2位就是2**0+2**1=3
Out[8]: 3

In [9]: 9<<3
Out[9]: 72

In [10]: 9>>3
Out[10]: 1

In [11]: 10>>3
Out[11]: 1

In [12]: 20>>3
Out[12]: 2

In [14]: 56>>3
Out[14]: 7
 
In [15]: import math            #实现高级算计运算的库

In [16]: math.
math.acos       math.cos        math.factorial  math.ldexp      math.sin
math.acosh      math.cosh       math.floor      math.lgamma     math.sinh
math.asin       math.degrees    math.fmod       math.log        math.sqrt
math.asinh      math.e          math.frexp      math.log10      math.tan
math.atan       math.erf        math.fsum       math.log1p      math.tanh
math.atan2      math.erfc       math.gamma      math.modf       math.trunc
math.atanh      math.exp        math.hypot      math.pi         
math.ceil       math.expm1      math.isinf      math.pow        
math.copysign   math.fabs       math.isnan      math.radians    

In [16]: math.pi
Out[16]: 3.141592653589793

In [17]: math.sqrt
Out[17]: <function math.sqrt>

In [18]: math.sqrt(4)          #开平方
Out[18]: 2.0

 
In [22]: math.pow(2,4)          #平方
Out[22]: 16.0

4、序列类型

序列表示索引为非负整数的有序对象集合，包括字符串、列表和元组

字符串字面量：把文本放入单引号（必须在同一行） ，双引号（必须在同一行），三引号（跨行）中；

       字符串是字符的

       列表和元组是任意Python对象的序列

字符和元组属于不可变序列，而列表则支持插入、删除和替换元素

所有序列都支持迭代

如果要使用unicode编码，则在字符之前使用字符u进行标识，如u“magedu”

文档字符串：模块、类或函数的第一条语句是一个字符串的话，该字符串就是就成为文档字符串，可以使用__doc__引用。

In [24]: str1="magedu"

In [25]: type(str1)
Out[25]: str

In [26]: str2=u"magedu"      #3.0的Python则不用加u

In [27]: type(str2)
Out[27]: unicode

In [28]: def printName():
   ....:     "test function"
   ....:     print "hello magedu.com"
   ....: 

In [31]: printName
Out[31]: <function __main__.printName>

In [32]: printName()
hello magedu.com

In [33]: printName().
.Xauthority    .bash_loGout   .bashrc        .ipython/      .tcshrc        
.bash_history  .bash_profile  .cshrc         .lesshst       .viminfo       

In [33]: printName().__doc__            #调用函数
hello magedu.com

In [34]: printName.__doc__              #引用函数对象
Out[34]: 'test function'

适用于所有序列的操作和方法：

s[i]: 索引运算符

s[i:j]为切片运算符

s[i:j:stride]为扩展切片运算符

min(s)和max(s)只适用于能够对元素排序的序列

sum(s)只适用于数字序列 

适用于字符串的的操作：

Python 2提供两种字符串对象类型

      字节字符串: 字节(8bit数据)序列

       Unicode字符串: Unicode字符(16bit数据)序列

                  Python可以使用32 bit整数保存Unicode字符，但此为可选特性

In [51]: name="xiejun"

In [52]: name.
name.capitalize  name.format      name.isupper     name.rindex      name.strip
name.center      name.index       name.join        name.rjust       name.swapcase
name.count       name.isalnum     name.ljust       name.rpartition  name.title
name.decode      name.isalpha     name.lower       name.rsplit      name.translate
name.encode      name.isdigit     name.lstrip      name.rstrip      name.upper
name.endswith    name.islower     name.partition   name.split       name.zfill
name.expandtabs  name.isspace     name.replace     name.splitlines  
name.find        name.istitle     name.rfind       name.startswith  
    
In [52]: name.capitalize()
Out[52]: 'Xiejun'

In [56]: name.index("u")
Out[56]: 4


In [47]: l1=list("xiejun")

In [48]: l1
Out[48]: ['x', 'i', 'e', 'j', 'u', 'n']

In [49]: ''.join(l1)
Out[49]: 'xiejun'

In [50]: ';'.join(l1)
Out[50]: 'x;i;e;j;u;n'

适用于列表的操作：

       容器类型

       任意对象的有序集合，通过索引访问其中的元素，可变对象，支持异构，任意嵌套

      支持在原处修改，

In [65]: l1=[1,2,3,4,5]

In [66]: l1[0]
Out[66]: 1

In [68]: l1[1:3]
Out[68]: [2, 3]

In [69]: l1[1:3]=''

In [70]: l1
Out[70]: [1, 4, 5]

In [72]: l1[:]=''

In [73]: l1
Out[73]: []

可用于列表的方法：

        list(s)可将任意可迭代类型转换为列表，而如果s已经是一个列表，则该函数构造的新列表是s的一个浅复制

l1+l2：是合并2个列表，返回一个新的列表，不会修改原列表

l1*N：把l1重复N次，返回一个新列表

in：成员判定符，

not in：

列表解析：[ ]

In [76]: l1=[1,23,"xj"]

In [77]: l1*2
Out[77]: [1, 23, 'xj', 1, 23, 'xj']

In [78]: 2 in l1
Out[78]: False

In [79]: 23 in l1
Out[79]: True

In [80]: 23 not in l1
Out[80]: False

In [81]: 2 not in l1
Out[81]: True

注意列表复制时：

In [1]: l1=[1,2,3,4]

In [2]: l2=l1               #浅复制

In [4]: print l2
[1, 2, 3, 4]

In [5]: l1.
l1.append   l1.extend   l1.insert   l1.remove   l1.sort
l1.count    l1.index    l1.pop      l1.reverse  

In [5]: l1.append(4)

In [6]: l1
Out[6]: [1, 2, 3, 4, 4]

In [7]: l2
Out[7]: [1, 2, 3, 4, 4]

In [8]: id(l1)
Out[8]: 19737488

In [9]: id(l2)
Out[9]: 19737488

In [10]: l3=l1[:]          #深复制

In [11]: l3
Out[11]: [1, 2, 3, 4, 4]

In [12]: id(l3)
Out[12]: 19724480

In [15]: l1.append(6)

In [16]: l1
Out[16]: [1, 2, 3, 4, 4, 6]

In [17]: l2
Out[17]: [1, 2, 3, 4, 4, 6]

In [18]: l3
Out[18]: [1, 2, 3, 4, 4]



In [3]: import copy

In [4]: copy.
copy.Error           copy.deepcopy        copy.name
copy.PyStringMap     copy.dispatch_table  copy.t
copy.copy            copy.error           copy.weakref



In [5]: l1=[1,2,3]

In [6]: id(l1)
Out[6]: 36145056

In [7]: l2=copy.deepcopy(l1)       #深复制

In [8]: l2
Out[8]: [1, 2, 3]

In [9]: id(l2)
Out[9]: 37443344

元组：

In [26]: t2=1,2,3      #括号可省略，但特殊情况下必须使用括号，建议不省略

In [27]: type(t2)
Out[27]: tuple

In [28]: t3="1",2

In [29]: type(t3)
Out[29]: tuple

注意：虽然元祖是不可变类型（不支持原处修改），但如果元祖内嵌套了可变类型的元素，那么此元素的修改不会返回新元祖（支持原处修改）

序列操作总结：

5、映射类型

字典在其它编程语言中又称作关联数组或散列表

通过键实现元素存取，无序集合，可变类型容器，长度可变，支持异构、嵌套

格式：｛key1:value1,key2:value2,...｝

           {}:空字典

映射类型表示一个任意对象的集合，而且可以通过另一个几乎是任意键值的集合进行索引

与序列不同，映射是无序的，它通过键进行索引

       任何不可变对象都可用作字典的键，如字符串、数字、元组等

       包含可变对象的列表、字典和元组不能用作键

m[k]运算符用于选择映射对象中的一项，其中“k”是一个键值

       引用不存在的键会引发KeyError异常

m.iteritems()：返回一个迭代器，m.next()的结果是键值对的元祖

m.itervalues():返回一个迭代器，m.next()的结果是值

m.iterkeys()：返回一个迭代器，m.next()的结果是键

m.next()：遍历迭代器对象

m.viewitems()

m.viewkeys()

m.viewvalues()

zip()

In [43]: zip
Out[43]: <function zip>

In [45]: zip('abc',"123")
Out[45]: [('a', '1'), ('b', '2'), ('c', '3')]

In [46]: dict(zip('abc','123'))
Out[46]: {'a': '1', 'b': '2', 'c': '3'}

字典的方法和操作：

6、集合类型

无序排列，可哈希，支持集合关系测试，不支持索引，元素获取、切片

没有特定语法格式：只能通过工厂函数创建

In [48]: s1=set()

In [49]: s1
Out[49]: set()

In [50]: print s1
set([])

In [51]: s2=set(123)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-51-a88bf1ca99f8> in <module>()
----> 1 s2=set(123)

TypeError: 'int' object is not iterable

In [52]: s2=set(1,2,3)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-52-2a6eb463Da1e> in <module>()
----> 1 s2=set(1,2,3)

TypeError: set expected at most 1 arguments, got 3

In [53]: s2=set([1,2,3])      #集合的元素要支持迭代的

In [54]: s2
Out[54]: {1, 2, 3}

In [55]: print s2
set([1, 2, 3])

In [56]: s3=set("xiejun")          

In [57]: s3
Out[57]: {'e', 'i', 'j', 'n', 'u', 'x'}

In [58]: print s3
set(['e', 'i', 'j', 'n', 'u', 'x'])

In [65]: s5=set(["Mon",'Tus'])

In [66]: s5
Out[66]: {'Mon', 'Tus'}

集合是唯一项的无序集

与序列不同，集合不提供索引或切片操作

与字典不同，集合不存在相关的键值

放入集合中的项目必须是不可变的

集合有两种类型：

        可变集合：set()

        不可变集合：frozenset()

集合类型的方法和操作：

可变集合类型set的方法：

三、其它总结

1、引用计数与垃圾收集

所有对象都有引用计数

        给对象分配一个新名称或将其放入一个容器中，其引用计数都会增加

        使用del语句或为变量名重新赋值时，对象的引用计数会减少

        sys.getrefcount()可以获得对象的当前引用计数

一个对象的引用计数器归零时，它将被垃圾收集机制回收

2、点号运算符

       属性：数据

                        返回一个数据，显示则要使用print语句

       方法：操作（），就是函数

                         调用，执行一段代码

括号：调用可调用对象（函数，类，对象中的方法）

3、如何获取使用帮助

获取对象支持使用的属性和方法：dir()，

某方法的具体使用帮助：help(),例如：help(list.pop),

获取可调用对象的文档字串：print obj.__doc__

4、容器、类型、对象

 1）容器类对象（列表，元祖，字典字面量）可以在不使用续航符的情况下分布于多行，最后一个元素的后面允许使用一个逗号

 2）列表和字典都支持两种类型的复制操作：浅复制和深复制，深复制可使用copy模块中的deepcopy（）实现

 3）Python中的所有对象都是“第一类的”这意味着使用标识符命名的所有对象都有相同的状态，于是，能够命名的所有对象都可以直接当数据进行处理。

 4）所有序列都支持迭代

 5）所有序列都支持的操作和方法

        s[i]

        s[i:j]

        s[i:j:stride]

        len(s)

        min(s)

        max(s)

         sun(s)

          all(s)

          any(s)

         s1+s2

         s1*N

         obj in s1

         obj not in s1

 6）可变序列的操作

        s1[index]=value  元素赋值

        s1[i:j]=t    切片赋值

         s1[i:j:stride]=t 

        del s1[index]

        del s1[i:j]

         del s1[i:j:stride]