python的内置类型是什么意思_Python——内置类型

Python定义了丰富的数据类型，包括：

数值型：int, float, complex

序列：(iterable) str, unicode, tuple, list, bytearray, buffer, xrange

集合：set, fronzeset

映射：dict

文件：file

布尔值：True、False 和 bool() 函数，其中 bool() 函数将一个值转变成布尔对象 True 或 False 。

可调用对象：凡是可以使用 x() 调用 x 的对象 x ，称为可调用的，x 可以是类型、函数、类型中定义了 __call__() 方法的实例等。

None：

memoryview：memoryview对象是Python2.7的新增对象，允许Python代码访问一个支持缓冲协议(buffer protocol)的对象它的内部数据，然后可以将其转变为字节字符串或字符对应ASCII值的列表等。

上下文管理器：上下文管理器用在 with 语句中，上下文管理协议(context management protocol)包括了 contextmanager.__enter__() 和  contextmanager.__exit__(exc_type, exc_val, exc_tb) 两个方法。

装饰器：装饰器实际上就是高阶函数，属于函数式编程的范畴，得益于Python中“一切皆对象”的思想，装饰器接受函数对象作为参数，返回的则是一个修改后的函数对象。

其他：

python中，模块、类型、函数、实例、都是对象，可谓一切皆对象，此外，还有 code 对象， Type 对象即一个对象所属的类型，通过 type() 函数来获取；

类型

名称

构造方法

介绍

basestring

抽象的(不能实例化)的类型，是str和unicode类型的基类型，可以通过isinstance(x, basestring)来判断x是不是str或者unicode类型。

bool

bool(x)

用来计算表达式x并返回x是True还是False。bool是int的子类，只有两个实例：True和False，True和False的值分别为1和0，但str(True)和str(False)的值分别是'True'和'False'。

buffer

buffer(obj, offset=0, size=-1)

obj必须是string或者是array，该函数返回一个从offset开始，大小为size的obj的部分只读的buffer对象，如果size<0，或者obj的大小小于size，则会从offset开始直达obj结尾。

classmethod

类方法

classmethod(function)

返回一个类方法，只能在类的定义中使用，可以用@classmethod替代。

code

代码对象

compile(source, filename, mode[, flags[, dont_inherit]])

code 对象一般通过内置函数 compile() 方法创建，也可以通过一个函数的func_code属性查看，关于code对象的细节，在下文介绍。

complex

复数

complex(real, imag=0)

dict

字典

dict(x={})

如果参数x是一个字典，那么返回它的一个拷贝，参数x也可以是一个可迭代对象，其中每一个元素是一个二元组，如：x = [('a', 1), ('b', 2)]

enumerate

枚举

enumerate(iterable, start=0)

从一个可迭代对象生成一个新的迭代器，这个迭代器的每一个item都是一个二元组，二元组的首元是从start开始连续递增的下标，而二元组的次元是参数可迭代对象从一个开始的内部元素。

open

文件

open(filename, mode='r', bufferzies=-1)

以参数mode形式打开指定的filename，返回一个file对象。

float

浮点型

float(x)

把数字或合适的字符串转换成浮点数。

frozenset

frozenset(seq=[])

返回一个冻结集合对象，关于set和frozenset的讨论请见 这篇博文。

int

整型

int(x[, radix])

将数字或合适的字符串转换成整数，当x是一个字符串时，radix需要指定，表示转换时的基数，默认是10，实际上转换基数可以介于2和36之间

list

列表

list(seq=[])

如果参数seq是一个列表，则返回它的拷贝；参数seq必须是一个可迭代对象，list()返回和这个可迭代对象具有相同顺序相同元素的列表。

long

长整型

long(x [, radix])

将数字或合适的字符串转换成长整数

object

object()

返回一个最基本的类型的新实例。

property

属性

property(fget=None, fset=None, fdel=None, doc=None)

只能在类定义中使用，通常使用装饰器@property

reversed

reversed(seq)

返回一个迭代器，这个迭代器和序列seq有着相反的元素对象，这个方法不会改变参数seq

set

集合

set(seq=[])

返回一个set对象，set对象是可变的，如果seq是一个set对象，那么set(seq)返回它的拷贝，关于内置类型set和frozenset的详细讨论参考这篇博文

slice

切片

slice([start, ] stop[, step])

返回一个slice对象，

staticmethod

静态方法

staticmethod(function)

只在类定义中调用，返回一个静态方法对象，或使用装饰器@staticmethod

str

plain string

str(obj)

如果obj本身就是str类型的，则返回obj对象；否则，返回obj对象的面向读者的形式，主要区别于repr面向python解释器的形式

super

super(cls, obj)

返回参数obj的父类的对象，obj必须是cls或cls子类的实例，这个方法主要用于调用父类的方法，这个函数只在方法代码中调用

tuple

元组

tuple(seq)

如果seq就是tuple对象，则返回它的拷贝；否则，返回一个和seq具有相同顺序相同元素的tuple对象，seq必须是一个可迭代对象

type

type(obj)

type(x)等价于x.__class__，即x所属的类型对象。

type 本身是一个内置的类型，也可以作为一个工厂对象，返回的是类型对象。Python中的类型对象只要支持相等与否的比较(equality comparison)和字符串表现形式即可。

按照面向对象的特点，类型对象又常常是可调用的，比如内置的 int, float, list 等等，调用这些对象可以创建他们的实例，同时类型对象可以被继承(subclass)，这都是类型的基本特征。

unicode

unicode string

unicode(string [,codec, [, errors]])

返回一个unicode字符串对象

xrange

xrange([start, ] stop [,step=1])

range()返回一个列表对象，xrange()则返回一个可迭代的xrange对象，这个对象不像range()返回的list那样将所有的元素都事先生成好放在内存中，而是在迭代的过程中每次生成一个，从而对于遍历大数据量的数字序列时，xrange在内存上具有显著优势。Python 3以后，不再使用xrange这个概念，而是将range基于Python 2中的xrange改良，使得Python 3 中range的功能更强大。

Python中的 code 对象

我们首先看一下内置函数 compile() 的介绍：

compile(source, filename, mode[, flags[, dont_inherit]]) ->code object

Compile the source string (a Python module, statementorexpression) into a code object that can be executed by theexec statement oreval().

The filename will be usedfor run-time error messages.

The mode must be'exec' to compile a module, 'single'to compile a single (interactive) statement,or 'eval'to compile an expression.

The flags argument,ifpresent, controls which future statements influence the compilation of the code.

The dont_inherit argument,if non-zero, stops the compilation inheriting the effects of any future statements in effect in the code calling compile; if absent or zero these statements do influence the compilation, in addition to any features explicitly specified.

总结起来就是：

compile()函数用于构造一个 code 对象，code对象可以作为 exec() 和 eval() 的参数；

对于任意一个Python函数而言，其 func_code 属性就是一个 code 对象，该对象是不可调用的，但是可以将它绑定给另一个具有相同参数个数的函数对象，从而创建一个新的函数对象：

>>> f = lambda x, y: x + y

>>> f.func_code

at 0000000001D74530, file "", line 1>

>>> code_obj = f.func_code

>>> def g(x, y): pass

...

>>> g.func_code = code_obj

>>> g(1, 9)

10

原本我们是没有定义函数 g 的函数体的，但是通过替换它的 func_code 属性，可以将不可调用的 code 对象替换成一个可调用的函数，是不是有一种金蝉脱壳的感觉呢。

Python的 types 模块

types模块的属性是 Python的内置类型，包括：

>>> dir(types)

['BooleanType', 'BufferType', 'BuiltinFunctionType', 'BuiltinMethodType', 'ClassType', 'CodeType', 'ComplexType', 'DictProxyType', 'DictType', 'DictionaryType', 'EllipsisType', 'FileType', 'FloatType', 'FrameType', 'FunctionType', 'GeneratorType', 'GetSetDescriptorType', 'InstanceType', 'IntType', 'LambdaType', 'ListType', 'LongType', 'MemberDescriptorType', 'MethodType', 'ModuleType', 'NoneType', 'NotImplementedType', 'ObjectType', 'SliceType', 'StringType', 'StringTypes', 'TracebackType', 'TupleType', 'TypeType', 'UnboundMethodType', 'UnicodeType', 'XRangeType', '__builtins__', '__doc__', '__file__', '__name__', '__package__']

如何知道这些属性其实是 Python 的内置类型呢？

例如：

>>> types.DictionaryType

>>> types.DictType

>>> type({})

可见，types.DictType 和 types.DictionaryType 其实就是内置类型 dict，也就是 type({}) 。

Python 类型的方法查找路径(Method Resolution Order)

Python支持多重继承，当引用一个继承了多个类型的实例的属性时，如何确定属性、方法的查找顺序，称为方法查找路径。

Python中一个继承自多个类型的类使用一种称为 C3 的方法查找路径(The Python 2.3 Method Resolution Order)，通过一个自定义类型的 __mro__ 属性可以查看该类型的方法查找路径：

>>> class D(object):

... d = 100

...

>>> class B(D):

... pass

...

>>> class C(D):

... pass

...

>>> class A(B, C): pass

...

>>> A.__mro__

(, , , , )

在Python中，只能查看一个类型(而不是实例)的 __mro__ 属性，该属性是只读的，其中各个类型显示的顺序，就是当访问该类型的属性、方法时查找的顺序。

对于一个实例而言，如果实例中绑定了某个属性，那么在属性查找时，实例绑定的属性先于类中定义的属性。

Python 中的 metaclass

metaclass 是 class 对象的“类型”，class 对象则是 metaclass 对象的实例，从而可以在 metaclass 中控制 class 的创建过程；

要定义一个 metaclass M，只要令 M 继承自内置类型 type 即可；

要为类型 C 指定其 metaclass 为 M，只要在 C 的 class body 中添加 __metaclass__ = M 即可；

M 在 创建 C 的时候，首先通过 M.__new__(M, namestring, t, d) 新建一个实例 C，然后通过 M.__init__(C, namestring, t, d) 初始化这个新的 class 对象 C。其中，namestring 是新创建类型的名称，t是一个元组，包括在定义 C 时指定的它的基类，d 就是要为 C 添加的属性字典。

Python中 type 和 object 的关系与区别

Python 中有两个非常有趣的概念——type 和 object，这里梳理一下他们的关系：

type 是自己的实例(所以type是一个内置的类型，也是自己的实例。。。)；

type 是一个可以用来创建新的类型的 metaclass；所以他是Python中一切其他类型的 类型(对应于__class__属性)；

object 是 type 的实例，而作为类型，type 又继承了 object。。。所以 object 是所有一切其他Python类型的 基类(对应于__base__属性)；

因此对于一个类型对象而言，它的基类是 object ，而它的类型则是 type，这是两个概念；

怎么样，够晕吧，下面的例子可以解释他们之间的关系，

例如：

>>> isinstance(object, type)

True

>>> issubclass(type, object)

True

>>> type(object)

>>> type(type)

>>> object.__base__

>>> type.__base__

>>>

这里挂上一张示意图，其中实线箭头代表类型继承，虚线箭头则代表实例化，从而可以看出其中的一致性。

所有的序列(Sequence)都是可迭代的(Iterable)，但是可迭代对象却不止Sequence：

序列一定是有序的，但是可迭代对象却不一定，例如set对象，可以被遍历，但是却无序，因此无法索引，切片等。