python基础教程：内置函数（二）

摘要：继续讲述更多的的内置函数。传递以切换缓冲关闭仅允许在二进制模式下，选择行缓冲仅在文本模式下可用，并且的整数以指示固定大小的块缓冲区的大小以字节为单位。启动内置的帮助系统此函数主要在交互式中使用。

继续讲述更多的Python的内置函数。

input([prompt])
如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。接下来，该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。当读取到 EOF 时，则触发 EOFError。例如:

In [25]: s = input(">>")
>>认真学python

In [26]: s
Out[26]: "认真学python"

如果加载了 readline 模块，input() 将使用它来提供复杂的行编辑和历史记录功能。

open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
打开 file 并返回对应的 file object。如果该文件不能打开，则触发 OSError。

file 是一个 path-like object，表示将要打开的文件的路径（绝对路径或者当前工作目录的相对路径），也可以是要被封装的整数类型文件描述符。（如果是文件描述符，它会随着返回的 I/O 对象关闭而关闭，除非 closefd 被设为 False 。）

mode 是一个可选字符串，用于指定打开文件的模式。默认值是 ‘r’ ，这意味着它以文本模式打开并读取。其他常见模式有：写入 ‘w’ （截断已经存在的文件）；排它性创建 ‘x’ ；追加写 ‘a’ （在 一些 Unix 系统上，无论当前的文件指针在什么位置，所有 写入都会追加到文件末尾）。在文本模式，如果 encoding 没有指定，则根据平台来决定使用的编码：使用 locale.getpreferredencoding(False) 来获取本地编码。（要读取和写入原始字节，请使用二进制模式并不要指定 encoding。）可用的模式有：

字符 意义
‘r’ 读取（默认）
‘w’ 写入，并先截断文件
‘x’ 排它性创建，如果文件已存在则失败
‘a’ 写入，如果文件存在则在末尾追加
‘b’ 二进制模式
‘t’ 文本模式（默认）
‘+’ 更新磁盘文件（读取并写入）
‘U’ universal newlines 模式（已弃用）
默认的模式是 ‘r’ （打开并读取文本，同 ‘rt’ ）。对于二进制写入， ‘w+b’ 模式打开并把文件截断成 0 字节； ‘r+b’ 则不会截断。

正如在 Overview 中提到的，Python区分二进制和文本I/O。以二进制模式打开的文件（包括 mode 参数中的 ‘b’ ）返回的内容为 bytes对象，不进行任何解码。在文本模式下（默认情况下，或者在 *mode* 参数中包含‘t’` ）时，文件内容返回为 str ，首先使用指定的 encoding （如果给定）或者使用平台默认的的字节编码解码。

注解 Python不依赖于底层操作系统的文本文件概念;所有处理都由Python本身完成，因此与平台无关。
buffering 是一个可选的整数，用于设置缓冲策略。传递0以切换缓冲关闭（仅允许在二进制模式下），1选择行缓冲（仅在文本模式下可用），并且>1的整数以指示固定大小的块缓冲区的大小（以字节为单位）。如果没有给出 buffering 参数，则默认缓冲策略的工作方式如下:

二进制文件以固定大小的块进行缓冲；使用启发式方法选择缓冲区的大小，尝试确定底层设备的“块大小”或使用 io.DEFAULT_BUFFER_SIZE。在许多系统上，缓冲区的长度通常为4096或8192字节。
“交互式”文本文件（ isatty() 返回 True 的文件）使用行缓冲。其他文本文件使用上述策略用于二进制文件。
encoding 是用于解码或编码文件的编码的名称。这应该只在文本模式下使用。默认编码是依赖于平台的（不 管 locale.getpreferredencoding() 返回何值），但可以使用任何Python支持的 text encoding 。有关支持的编码列表，请参阅 codecs 模块。

errors 是一个可选的字符串参数，用于指定如何处理编码和解码错误 – 这不能在二进制模式下使用。可以使用各种标准错误处理程序（列在 Error Handlers ），但是使用 codecs.register_error() 注册的任何错误处理名称也是有效的。标准名称包括:

如果存在编码错误，’strict’ 会引发 ValueError 异常。 默认值 None 具有相同的效果。
‘ignore’ 忽略错误。请注意，忽略编码错误可能会导致数据丢失。
‘replace’ 会将替换标记（例如 ‘?’ ）插入有错误数据的地方。
‘surrogateescape’ 将表示任何不正确的字节作为Unicode专用区中的代码点，范围从U+DC80到U+DCFF。当在写入数据时使用 surrogateescape 错误处理程序时，这些私有代码点将被转回到相同的字节中。这对于处理未知编码的文件很有用。
只有在写入文件时才支持 ‘xmlcharrefreplace’。编码不支持的字符将替换为相应的XML字符引用 nnn;。
‘backslashreplace’ 用Python的反向转义序列替换格式错误的数据。
‘namereplace’ （也只在编写时支持）用 N{…} 转义序列替换不支持的字符。
newline 控制 universal newlines 模式如何生效（它仅适用于文本模式）。它可以是 None，”，’n’，’r’ 和 ‘rn’。它的工作原理:

从流中读取输入时，如果 newline 为 None，则启用通用换行模式。输入中的行可以以 ‘n’，’r’ 或 ‘rn’ 结尾，这些行被翻译成 ‘n’ 在返回呼叫者之前。如果它是 ”，则启用通用换行模式，但行结尾将返回给调用者未翻译。如果它具有任何其他合法值，则输入行仅由给定字符串终止，并且行结尾将返回给未调用的调用者。
将输出写入流时，如果 newline 为 None，则写入的任何 ‘n’ 字符都将转换为系统默认行分隔符 os.linesep。如果 newline 是 ” 或 ‘n’，则不进行翻译。如果 newline 是任何其他合法值，则写入的任何 ‘n’ 字符将被转换为给定的字符串。
如果 closefd 是 False 并且给出了文件描述符而不是文件名，那么当文件关闭时，底层文件描述符将保持打开状态。如果给出文件名则 closefd 必须为 True （默认值），否则将引发错误。

可以通过传递可调用的 opener 来使用自定义开启器。然后通过使用参数（ file，flags ）调用 opener 获得文件对象的基础文件描述符。 opener 必须返回一个打开的文件描述符（使用 os.open as opener 时与传递 None 的效果相同）。

print(*objects, sep=" ", end=" ", file=sys.stdout, flush=False)
打印objects到文本流file，以分隔符sep分隔多个对象，并以end结尾。

breakpoint(*args, **kwargs)
此函数会在调用时将你陷入调试器中。具体来说，它调用 sys.breakpointhook()，直接传递 args 和 kws 。默认情况下， sys.breakpointhook() 调用 pdb.set_trace()且没有参数。在这种情况下，它纯粹是一个便利函数，因此您不必显式导入 pdb 且键入尽可能少的代码即可进入调试器。但是， sys.breakpointhook() 可以设置为其他一些函数并被 breakpoint() 自动调用，以允许进入你想用的调试器。

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
将 source 编译成代码或 AST 对象。代码对象可以被 exec() 或 eval() 执行。source 可以是常规的字符串、字节字符串，或者 AST 对象。

ascii(object)
返回一个只用ASCII码表示的对象。类似函数repr()返回一个对象的可打印字符串表示，但是会把其中非ASCII的字符用x, u, U进行转义。比如：

In [23]: ascii([1,2,3])
Out[23]: "[1, 2, 3]"

In [24]: ascii("编程")
Out[24]: ""u7f16u7a0b""

In [25]: ascii("a
b")
Out[25]: ""a
b""

repr(object)
返回包含对象的可打印表示的字符串。对于许多类型，此函数尝试返回一个字符串，该字符串在传递给eval()时会产生具有相同值的对象，否则表示形式是一个用尖括号括起来的字符串，它包含对象类型的名称附加信息通常包括对象的名称和地址。 类可以通过定义repr()方法来控制此函数为其实例返回的内容。

In [54]: repr({"a": 1, "b":2, "c":3})
Out[54]: "{"a": 1, "b": 2, "c": 3}"

In [55]: s = repr({"a": 1, "b":2, "c":3})

In [56]: eval(s)
Out[56]: {"a": 1, "b": 2, "c": 3}

eval(expression, globals=None, locals=None)
实参是一个字符串，以及可选的 globals 和 locals。globals 实参必须是一个字典。locals 可以是任何映射对象。
这个函数也可以用来执行任何代码对象（如 compile() 创建的）。这种情况下，参数是代码对象，而不是字符串。如果编译该对象时的 mode 实参是 ‘exec’ 那么 eval() 返回值为 None 。

In [17]: a = 2

In [18]: eval("a+2")
Out[18]: 4

In [19]: eval("3*3")
Out[19]: 9

In [20]: d = ascii({"a":1, "b":2})

In [21]: d
Out[21]: "{"a": 1, "b": 2}"

In [22]: eval(d)
Out[22]: {"a": 1, "b": 2}

提示： exec() 函数支持动态执行语句。 globals() 和 locals() 函数各自返回当前的全局和本地字典，因此您可以将它们传递给 eval() 或 exec() 来使用。

exec(object[, globals[, locals]])
这个函数支持动态执行 Python 代码。object 必须是字符串或者代码对象。如果是字符串，那么该字符串将被解析为一系列 Python 语句并执行（除非发生语法错误）。[1] 如果是代码对象，它将被直接执行。在任何情况下，被执行的代码都需要和文件输入一样是有效的（见参考手册中关于文件输入的章节）。请注意即使在传递给 exec() 函数的代码的上下文中，return 和 yield 语句也不能在函数定义之外使用。该函数返回值是 None 。

In [24]: exec("a=2;x=a*3;print(x)")
6

globals()
返回表示当前全局符号表的字典。这总是当前模块的字典（在函数或方法中，不是调用它的模块，而是定义它的模块）。

locals()
更新并返回表示当前本地符号表的字典。在函数块而不是类块中调用 locals() 时会返回自由变量。

注解 不要更改此字典的内容；更改不会影响解释器使用的局部变量或自由变量的值。

help([object])
启动内置的帮助系统（此函数主要在交互式中使用）。如果没有实参，解释器控制台里会启动交互式帮助系统。如果实参是一个字符串，则在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。如果实参是其他任意对象，则会生成该对象的帮助页。

该函数通过 site 模块加入到内置命名空间。

memoryview(obj)
返回由给定实参创建的“内存视图”对象。有关详细信息，请参阅 Memory Views。

@classmethod
把一个方法封装成类方法。

一个类方法把类自己作为第一个实参，就像一个实例方法把实例自己作为第一个实参。请用以下习惯来声明类方法:

class A:
    @classmethod
    def func(cls, arg1, ...): ...

@classmethod形式是函数装饰器。
它可以同时在类（如 C.f()）和实例（如 C().f()）上调用。实例除了它的类信息，其他都会被忽略。如果一个类方法在子类上调用，子类会作为第一个实参传入。

类方法和 C++ 和 Java 的静态方法是有区别的。如果你想要静态方法，请看 staticmethod()。

@staticmethod

将方法转换为静态方法。
静态方法不会接收隐式的第一个参数。要声明一个静态方法，请使用此语法

class A:
    @staticmethod
    def func(arg1, arg2, ...): ...

@staticmethod 形式函数是一个 decorator 函数。它可以在类（例如 C.f() ）或实例（例如 C().f() ）上调用。实例会被忽略，只需要类本身。

Python中的静态方法与Java或C ++中的静态方法类似。另请参阅 classmethod() ，用于创建备用类构造函数的变体。

像所有装饰器一样，也可以像常规函数一样调用 staticmethod ，并对其结果执行某些操作。比如某些情况下需要从类主体引用函数并且您希望避免自动转换为实例方法。对于这些情况，请使用此语法:

class A:
    buildin_open = staticmethod(open)

issubclass(class, classinfo)
如果 class 是 classinfo 的子类（直接、间接或 虚拟 的），则返回 true。classinfo 可以是类对象的元组，此时 classinfo 中的每个元素都会被检查。其他情况，会触发 TypeError 异常。

class property(fget=None, fset=None, fdel=None, doc=None)
返回 property 属性。

fget 是获取属性值的函数。 fset 是用于设置属性值的函数。 fdel 是用于删除属性值的函数。并且 doc 为属性对象创建文档字符串。

一个典型的用法是定义一个托管属性 x:

class A:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I"m the "x" property.")

如果 a 是 A 的实例，a.x 将调用getter，a.x = value 将调用setter， del a.x 将调用deleter。

如果提供了doc参数，则它就是这个属性的docstring。否则，这个属性会拷贝fget的docstring。

通过装饰器可以轻松实现可读属性：

class Point:
    def __init__(self):
        self._x = 0
        self._y = 0

    @property
    def x(self):
        """Get the current x"""
        return self._x

装饰器@property把方法x()变为一个“getter”只读的同名属性，并把x的docstring“Get the current x”作为属性的docstring。

属性对象具有可用作装饰器的getter，setter和deleter方法，这些方法创建属性的副本，并将相应的访问器函数设置为装饰函数。参考下面的例子：

class A:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I"m the "x" property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

这段代码与第一个示例完全等效。 要保证其他函数指定与原始属性相同的名称（在本例中为x）。

返回的属性对象还具有与构造函数参数对应的属性fget，fset和fdel。

Python 3.5版更改：属性对象的docstring现在可写了。

super([type[, object-or-type]])

返回将方法调用委托给父类或兄弟类类型的代理对象。这对于访问已在类中重写的继承方法很有用。搜索顺序与getattr()使用的搜索顺序相同，只是跳过了类型本身。

该类型的mro属性列出了getattr()和super()使用的方法解析搜索顺序。该属性是动态的，只要更新继承层次结构，就可以更改该属性。

如果省略第二个参数，则返回的超级对象是未绑定的。如果第二个参数是一个对象，则isinstance(obj,type)必须为true。如果第二个参数是一个类型，则issubclass(type2,type)必须为true（这对于classmethods很有用）。

super有两个典型的用例。在具有单继承的类层次结构中，super可用于引用父类而不显式命名它们，从而使代码更易于维护。这种用法与其他编程语言中super的使用密切相关。

第二个用例是在动态执行环境中支持协作多重继承。此用例是Python独有的，在静态编译语言或仅支持单继承的语言中找不到。这使得实现“菱形图”成为可能，其中多个基类实现相同的方法。好的设计要求此方法在每种情况下都具有相同的调用签名（因为调用的顺序是在运行时确定的，因为该顺序适应类层次结构中的更改，并且因为该顺序可以包括在运行时之前未知的兄弟类）。

对于这两种用例，典型的超类调用如下所示：

class B(A):
    def method(self, arg):
        super().method(arg) # 相当于：super(B, self).method(arg)

注意，super()是作为显式点状属性查找的绑定过程的一部分实现的，例如super().getitem(name)。它通过实现自己的getattribute()方法来实现，它以可预测的顺序搜索类，支持协作多重继承。 因此，对于使用语句或运算符（如super()[name]）进行隐式查找，未定义super()。

另外请注意，除零参数形式外，super()不限于使用内部方法。 两个参数形式完全指定参数并进行适当的引用。零参数形式仅适用于类定义，因为编译器填写必要的细节以正确检索正在定义的类，以及访问普通方法的当前实例。

callable(object)
如果实参 object 是可调用的，返回 True，否则返回 False。如果返回真，调用仍可能会失败；但如果返回假，则调用 object 肯定会失败。注意类是可调用的（调用类会返回一个新的实例）。如果实例的类有 call() 方法，则它是可调用。

delattr(object, name)
setattr() 相关的函数。实参是一个对象和一个字符串。该字符串必须是对象的某个属性。如果对象允许，该函数将删除指定的属性。例如 delattr(x, ‘foobar’) 等价于 del x.foobar 。

dir([object])
如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表。

如果对象有一个名为 dir() 的方法，那么该方法将被调用，并且必须返回一个属性列表。这允许实现自定义 getattr() 或 getattribute() 函数的对象能够自定义 dir() 来报告它们的属性。

如果对象不提供 dir()，这个函数会尝试从对象已定义的 dict 属性和类型对象收集信息。结果列表并不总是完整的，如果对象有自定义 getattr()，那结果可能不准确。

默认的 dir() 机制对不同类型的对象行为不同，它会试图返回最相关而不是最全的信息：

如果对象是模块对象，则列表包含模块的属性名称。

如果对象是类型或类对象，则列表包含它们的属性名称，并且递归查找所有基类的属性。

否则，列表包含对象的属性名称，它的类属性名称，并且递归查找它的类的所有基类的属性。

返回的列表按字母表排序。

getattr(object, name[, default])
返回对象命名属性的值。name 必须是字符串。如果该字符串是对象的属性之一，则返回该属性的值。例如， getattr(x, ‘foobar’) 等同于 x.foobar。如果指定的属性不存在，且提供了 default 值，则返回它，否则触发 AttributeError。

setattr(object, name, value)
它是getattr()的对应函数。实参是对象，字符串和任意值。字符串可能是已存在或新增属性的名称。该函数把value赋值给属性。例如，setattr(x, "foobar", 123)相当于x.foobar = 123。

hasattr(object, name)
该实参是一个对象和一个字符串。如果字符串是对象的属性之一的名称，则返回 True，否则返回 False。（此功能是通过调用 getattr(object, name) 看是否有 AttributeError 异常来实现的。）

hash(object)
返回该对象的哈希值（如果它有的话）。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1 和 1.0）。

注释： 如果对象实现了自己的 hash() 方法，请注意，hash() 根据机器的字长来截断返回值。另请参阅 hash()。

id(object)
返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的 id() 值。

isinstance(object, classinfo)
如果 object 实参是 classinfo 实参的实例，或者是（直接、间接或 虚拟）子类的实例，则返回 true。如果 object 不是给定类型的对象，函数始终返回 false。如果 classinfo 是对象类型（或多个递归元组）的元组，如果 object 是其中的任何一个的实例则返回 true。 如果 classinfo 既不是类型，也不是类型元组或类型的递归元组，那么会触发 TypeError 异常。

len(s)
返回对象的长度（元素个数）。实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）。

vars([object])

返回具有dict属性的模块，类，实例或任何其他对象的dict属性。

模块和实例等对象具有可更新的dict属性; 但是，其他对象可能对其dict属性具有写入限制（例如，类使用types.MappingProxyType来防止直接字典更新）。

没有参数，vars()就像locals()一样。 请注意，locals字典仅对读取有用，因为忽略了对locals字典的更新。

Python的内置函数提供了常用的功能，熟练使用这些内置函数对编程有很大帮助。