04 Python 对象 - 《Python 核心编程》

4.3 其他内建类型

    ?? 类型     [所有类型对象的类型都是type，它也是所有Python 类型的根和所有Python 标准类的默认元类（metaclass）]

    ?? Null 对象 (None)     [空对象、值为零的任何数字或者Null 对象 None 的布尔值都是False.]

    ?? 文件

    ?? 集合/固定集合

    ?? 函数/方法

    ?? 模块

    ?? 类

    类型对象和type 类型对象

        对象具有一系列固有行为和特性（比如支持哪些运算，具 有哪些方法）必须事先定义好。

        从这个角度看，类型正是保存这些信息的最佳位置。

        描述一种类型所需要的信息不可能用一个字符串来搞定，所以类型不能是一个简单的字符串，这些信息不能也不应该和数据保存在一起， 所以我们将类型定义成对象。

            >>> type(42)
            <type ‘int‘>
            >>> type(type(42))
            <type ‘type‘>
            >>>

    None, Python 的 Null 对象

        Python 有一个特殊的类型，被称作 Null 对象或者 NoneType，它只有一个值，那就是 None。

            >>> type(None) 
            <type ‘NoneType‘> 
            >>>

        它不支持任何运算也没有任何内建方法。

        如果非常熟悉C 语言，和None 类型最接近的C 类型就 是void，None 类型的值和C 的NULL 值非常相似（其他类似的对象和值包括Perl 的undef 和Java 的void 类型与null 值）。 

        None 没有什么有用的属性，它的布尔值总是False。

        核心笔记：布尔值 

            所有标准对象均可用于布尔测试，同类型的对象之间可以比较大小。

            每个对象天生具有布 尔 True 或 False 值。
            空对象、值为零的任何数字或者Null 对象 None 的布尔值都是False。 

            下列对象的布尔值是False。 

                ?? None 

                ?? False (布尔类型) 

                ?? 所有的值为零的数： 

                    ?? 0 (整型) 

                    ?? (浮点型) 

                    ?? 0L (长整型) 

                    ?? 0.0+0.0j (复数)         

                ?? "" (空字符串) 

                ?? [] (空列表)

                ?? () (空元组)

                ?? {} (空字典)

            值不是上面列出来的任何值的对象的布尔值都是 True，例如non-empty、 non-zero 等等。 

            用户创建的类实例如果定义了nonzero(__nonzero__())或length（__len__()）且值为0，那么它们的布尔值就是 False。

4.4 内部类型

    ?? 代码

    ?? 帧

    ?? 跟踪记录

    ?? 切片

    ?? 省略

    ?? Xrange

    代码对象

        代码对象是编译过的Python 源代码片段，它是可执行对象。

        通过调用内建函数compile() 可以得到代码对象。

        代码对象可以被 exec 命令或 eval()内建函数来执行。

        代码对象本身不包含任何执行环境信息， 它是用户自定义函数的核心， 在被执行时动态 获得上下文。

        （事实上代码对象是函数的一个属性）一个函数除了有代码对象属性以外，还有一些其它函数必须的属性，包括函数名，文档字符串，默认参数，及全局命名空间等等。

    帧对象

        帧对象表示 Python 的执行栈帧。

        帧对象包含Python 解释器在运行时所需要知道的所有信 息。

        它的属性包括指向上一帧的链接，正在被执行的代码对象（参见上文），本地及全局名字空间字典以及当前指令等。

        每次函数调用产生一个新的帧，每一个帧对象都会相应创建一个C 栈帧。

        用到帧对象的一个地方是跟踪记录对象。

    跟踪记录 对象

        当异常发生时，一个包含针对异常的栈跟踪信息的跟踪记录对象被创建。

        如果一个异常有 自己的处理程序，处理程序就可以访问这个跟踪记录对象。

    切片对象

        当使用Python 扩展的切片语法时，就会创建切片对象。

        扩展的切片语法允许对不同的索引 切片操作，包括步进切片， 多维切片，及省略切片。

        多维切片语法是 sequence[start1 : end1, start2 : end2]， 或使用省略号， sequence[...,start1 : end1 ]。

        切片对象也可以由内建函数 slice()来生成。

        步进切片允许利用第三个切片元素进行步进切片，它的语法为sequence[起始索引 : 结束索引 : 步进值]。

        Python 很早就支持扩展步进切片语法了，但直到Python2.3 以前都必须依靠 C API 或 Jython 才能工作。 

            >>> foostr = ‘abcde‘
            >>> foostr[::-1]
            ‘edcba‘
            >>> foostr[::-2]
            ‘eca‘
            >>> foolist = [123, ‘xba‘, 342.23, ‘abc‘]
            >>> foolist[::-1]
            [‘abc‘, 342.23, ‘xba‘, 123]

    省略对象

        省略对象用于扩展切片语法中，起记号作用。 这个对象在切片语法中表示省略号。

        类似 Null 对象 None, 省略对象有一个唯一的名字 Ellipsis, 它的布尔值始终为 True.

    XRange 对象

        调用内建函数 xrange() 会生成一个Xrange 对象，xrange()是内建函数 range()的兄弟版 本， 用于需要节省内存使用或 range()无法完成的超大数据集场合。

对象值的比较

    比较运算符用来判断同类型对象是否相等，所有的内建类型均支持比较运算，比较运算返回布尔值 True 或 False。

    注意，实际进行的比较运算因类型而异。

        换言之，数字类型根据数值的大小和符号比较，字符串按照字符序列值进行比较，等等。

            >>> 2 == 2 
            True 
            >>> 2.46 <= 8.33 
            True 
            >>> 5+4j >= 2-3j 
            True 
            >>> ‘abc‘ == ‘xyz‘ 
            False 
            >>> ‘abc‘ > ‘xyz‘ 
            False 
            >>> ‘abc‘ < ‘xyz‘ 
            True 
            >>> [3, ‘abc‘] == [‘abc‘, 3] 
            False 
            >>> [3, ‘abc‘] == [3, ‘abc‘] 
            True

    不同于很多其它语言，多个比较操作可以在同一行上进行，求值顺序为从左到右。

            >>> 3 < 4 < 7 # same as ( 3 < 4 ) and ( 4 < 7 ) 
            True 
            >>> 4 > 3 == 3 # same as ( 4 > 3 ) and ( 3 == 3 ) 
            True 
            >>> 4 < 3 < 5 != 2 < 7 
            False

    比较操作是针对对象的值进行的，也就是说比较的是对象的数值而不是对象本身。

    标准类型值比较运算符 

        运算符                    功能 

        expr1 < expr2         expr1 小于 expr2 

        expr1 > expr2         expr1 大于 expr2 

        expr1 <= expr2      expr1 小于等于 expr2 

        expr1 >= expr2      expr1 大于等于 expr2 

        expr1 == expr2      expr1 等于 expr2 

        expr1 != expr2       expr1 不等于 expr2 (C 风格) 

        expr1 <> expr2      expr1 不等于 expr2 (ABC/Pascal 风格) 

        注： 未来很有可能不再支持 <> 运算符，建议您一直使用 != 运算符。

对象身份比较 (比较对象本身是一个更好地方案)

    作为对值比较的补充，Python 也支持对象本身的比较。

    对象可以被赋值到另一个变量（通 过引用）。

    因为每个变量都指向同一个（共享的）数据对象，只要任何一个引用发生改变，该对象的其它引用也会随之改变。

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

        foo1 = foo2 = 4.3

        当你从值的观点看这条语句时， 它表现的只是一个多重赋值，将4.3 这个值赋给了foo1 和foo2 这两个变量。

        这当然是对的， 不过它还有另一层含义。 事实是一个值为4.3 的数字对象被创建，然后这个对象的引用被赋值给foo1 和foo2, 结果就是 foo1 和 foo2 指向同一个对象。

        

           图4–1 foo1 和 foo2 指向相同的对象

    核心提示：实践

        整数对象和 字符串对象是不可变对象，所以Python 会很高效的缓存它们。

            这会造成我们认为Python 应该创建新对象时，它却没有创建新对象的假象。

        Python 仅缓存简单整数，因为它认为在Python 应用程序中这些小整数会经常被用到。

        Python 2.3 中决定，在预定义缓存字符串表之外的字符串，如果不再有任何引用指向它， 那这个字符串将不会被缓存。

            也就是说， 被缓存的字符串将不会象以前那样永生不灭，对象回收器一样可以回收不再被使用的字符串。

            从Python 1.5 起提供的用于缓存字符的内建函数intern() 也已经不再推荐使用， 即将被废弃。

布尔类型

    布尔逻辑运算符 and， or 和 not 都是Python 关键字。

    not 运算符拥有最高优先级，只比所有比较运算符低一级， and 和 or 运算符则相应的再低一级。

    Python 支持一个表达式进行多种比较操作， 其实这个表达式本质上是由 多个隐式的 and 连接起来的多个表达式。 

        >>> 3 < 4 < 7 # same as "( 3 < 4 ) and ( 4 < 7 )" 

        True

4.6 标准类型内建函数

    函数                              功能

    cmp(obj1, obj2)       比较 obj1 和 obj2, 根据比较结果返回整数 i:

                                      i < 0 if obj1 < obj2

                                      i > 0 if obj1 > obj2

                                      i == 0 if obj1 == obj2

    repr(obj) 或 `obj`      返回一个对象的字符串表示

    str(obj)                      返回对象适合可读性好的字符串表示

    type(obj)                  得到一个对象的类型，并返回相应的type 对象

type()

    type() 的用法如下：

        type(object)

        type() 接受一个对象做为参数，并返回它的类型。它的返回值是一个类型对象。

            >>> type(4) # int type 

            <type ‘int‘> 

            >>> 

            >>> type(‘Hello World!‘) # string type 

            <type ‘string‘> 

            >>> 

            >>> type(type(4)) # type type 

            <type ‘type‘>

            >>> class Foo:pass 

            ... 

            >>> class Bar(object):pass 

            ... 

            >>> type(Foo) 

            <type ‘classobj‘> 

            >>> type(Bar) 

            <type ‘type‘> 

            >>> type(Foo() ) 

            <type ‘instance‘> 

            >>> type(Bar()) 

            <class ‘__main__.Bar‘> 

            >>>

cmp()

    内建函数cmp()用于比较两个对象obj1 和obj2， 如果obj1 小于obj2, 则返回一个负整 数，如果obj1 大于obj2 则返回一个正整数， 如果obj1 等于obj2， 则返回0。

    它的行为非常类似于C 语言的strcmp()函数。

    比较是在对象之间进行的，不管是标准类型对象还是用户自定义对象。

    如果是用户自定义对象， cmp()会调用该类的特殊方法__cmp__()。

str()和 repr() (及 `` 运算符)

    内建函数 str() 和 repr() 或反引号运算符(``) 可以方便的以字符串的方式获取对象的 内容、类型、数值属性等信息。

    str()函数得到的字符串可读性好， 而repr()函数得到的字符串通常可以用来重新获得该对象, 通常情况下 obj == eval(repr(obj)) 这个等式是成立的。 

    这两个函数接受一个对象做为其参数， 返回适当的字符串。

        >>> str(4.53-2j) 

        ‘(4.53-2j)‘ 

        >>> 

        >>> str(1) 

        ‘1‘ 

        >>> 

        >>> str(2e10) 

        ‘20000000000.0‘ 

        >>> 

        >>> str([0, 5, 9, 9]) 

        ‘[0, 5, 9, 9]‘ 

        >>> 

        >>> repr([0, 5, 9, 9]) 

        ‘[0, 5, 9, 9]‘ 

        >>> 

        >>> `[0, 5, 9, 9]` 

        ‘[0, 5, 9, 9]‘

    尽管str(),repr()和``运算在特性和功能方面都非常相似， 事实上 repr() 和 `` 做的是完全一样的事情，它们返回的是一个对象的“官方”字符串表示。

    也就是说绝大多数情况下可以通过求值运算(使用eval()内建函数)重新得到该对象，但str()则有所不同。

    str() 致力于生成一个对象的可读性好的字符串表示，它的返回结果通常无法用于eval()求值， 但很适合用于 print 语句输出。

    并不是所有repr()返回的字符串都能够用 eval()内建函数得到原来的对象： 

        >>> eval(`type(type))`) 

        File "<stdin>", line 1 

        eval(`type(type))`) 

        ^ 

        SyntaxError: invalid syntax

    也就是说 repr() 输出对 Python 比较友好， 而str()的输出对人比较友好。

    虽然如此， 很多情况下这三者的输出仍然都是完全一样的。

    核心笔记：为什么我们有了repr()还需要``？ 

        在Python 学习过程中，你偶尔会遇到某个运算符和某个函数是做同样一件事情。之所以如 

    此是因为某些场合函数会比运算符更适合使用。举个例子， 当处理类似函数这样的可执行对象 

    或根据不同的数据项调用不同的函数处理时，函数就比运算符用起来方便。另一个例子就是双 

    星号(**)乘方运算和pow()内建函数，x ** y 和 pow(x,y) 执行的都是x 的y 次方。 

    译者注：事实上Python 社区目前已经不鼓励继续使用``运算符。

type() 和 isinstance()

    Python 不支持方法或函数重载， 因此你必须自己保证调用的就是你想要的函数或对象。

    type()返回任意Python 对象对象的类型，而不局限于标准类型。

    Python2.2 统一了类型和类.

        >>> type(‘‘) 

        <type ‘str‘> 

        >>> 

        >>> s = ‘xyz‘ 

        >>> type(s) 

        <type ‘str‘> 

        >>> 

        >>> type(100) 

        <type ‘int‘> 

        >>> type(0+0j) 

        <type ‘complex‘> 

        >>> type(0L) 

        <type ‘long‘> 

        >>> type(0.0) 

        <type ‘float‘> 

        >>> 

        >>> type([]) 

        <type ‘list‘> 

        >>> type(()) 

        <type ‘tuple‘>

        >>> type({}) 

        <type ‘dict‘> 

        >>> type(type) 

        <type ‘type‘> 

        >>> 

        >>> class Foo: pass # new-style class 

        ... 

        >>> foo = Foo() 

        >>> class Bar(object): pass # new-style class 

        ... 

        >>> bar = Bar() 

        >>> 

        >>> type(Foo) 

        <type ‘classobj‘> 

        >>> type(foo) 

        <type ‘instance‘> 

        >>> type(Bar) 

        <type ‘type‘> 

        >>> type(bar) 

        <class ‘__main__.Bar‘>

    使用 isinstance() 函数

    

Python 类型运算符和内建函数总结

    表4.5 列出了所有运算符和内建函数，其中运算符顺序是按优先级从高到低排列的。

    同一 种灰度的运算符拥有同样的优先级。

    注意在operator 模块中有这些（和绝大多数Python)运算符相应的同功能的函数可供使用。