Python 3.6 内置函数详解与类型大全

内置函数

3星 · 超过75%的资源需积分: 48 148 浏览量更新于2024-07-19 3 收藏 6.32MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

本资源是一份详尽的Python 3.6内置函数大全，由Guido van Rossum和Python开发团队编写，发布日期为2017年10月14日。Python Software Foundation提供支持，文档的目的是为开发者提供清晰的指导，理解并熟练运用Python的内置功能。该文档分为多个部分，首先介绍了Python的基础概念和介绍（第1章），然后深入探讨了Python的内置函数。这些内置函数涵盖多种类型，包括但不限于： 1. **真理值测试**（4.2节）：介绍了Python如何通过`and`, `or`, 和 `not` 进行布尔操作，用于条件判断。 2. **比较运算**（4.3节）：涵盖了基本的比较操作符如`==`, `!=`, `<`, `>`, `<=`, 和 `>=`，以及它们在不同类型数据（如整数、浮点数和复数）中的应用。 3. **数值类型**（4.4节）：详细解释了`int`, `float`, 和 `complex`类型，以及它们之间的转换和操作。 4. **迭代器和序列类型**（4.5和4.6节）：`list`, `tuple`, 和 `range`等序列类型的使用方法，以及如何创建和遍历迭代器。 5. **文本序列类型**（4.7节）：重点介绍了字符串处理，包括字符串操作、编码解码以及`str`对象的方法。 6. **二进制序列类型**（4.8节）：`bytes`, `bytearray`, 和 `memoryview` 的使用，涉及数据的内存管理和操作。 7. **集合类型**（4.9节）：`set`和`frozenset`的定义，以及集合操作如并集、交集和差集。 8. **映射类型**（4.10节）：`dict`类的使用，包括键值对的存储和查询，以及常用方法。 9. **上下文管理器类型**（4.11节）：讨论了如何使用`with`语句处理资源管理。 10. **其他内置类型**（4.12节）：列举了其他如元组、字节串等不太常见的内置类型及其用法。 11. **异常处理**（5章）：解释了Python的基本异常结构，包括基类、具体异常、警告以及异常继承关系。 12. **文本处理服务**（6章）：介绍了`string`模块提供的字符串操作，正则表达式操作（通过`re`模块）、文本差异计算（`difflib`）、文本格式化（`textwrap`）以及字符串解码和编码。这些章节提供了大量的实例和用法说明，使得Python初学者和高级开发者都能从中受益，更好地理解和掌握Python语言的核心功能。无论是进行基础编程还是进行复杂的数据处理和文本分析，这份文档都是不可或缺的参考资料。

资源详情

资源推荐

The Python Library Reference, Release 3.6.3

ascii(object)

As repr(), return a string containing a printable representation of an object, but escape the non-ASCII

characters in the string returned by repr() using \x, \u or \U escapes. This generates a string similar

to that returned by repr() in Python 2.

bin(x)

Convert an integer number to a binary string prexed with “0b”. The result is a valid Python

expression. If x is not a Python int object, it has to dene an __index__() method that

returns an integer. Some examples:

>>> bin(3)

0b11

>>> bin(-10)

-0b1010

If prex “0b” is desired or not, you can use either of the following ways.

>>> format(14,

), format(14,

)

(

0b1110

1110

)

>>> f

{14:#b}

, f

{14:b}

(

0b1110

1110

)

See also format() for more information.

class bool(

[

]

)

Return a Boolean value, i.e. one of True or False. x is converted using the standard truth testing

procedure. If x is false or omitted, this returns False; otherwise it returns True. The bool class is a

subclass of int (see Numeric Types — int, oat, complex). It cannot be subclassed further. Its only

instances are False and True (see Boolean Values).

class bytearray(

[

source

[

, encoding

[

, errors

]]]

)

Return a new array of bytes. The bytearray class is a mutable sequence of integers in the range 0 <= x

< 256. It has most of the usual methods of mutable sequences, described in Mutable Sequence Types,

as well as most methods that the bytes type has, see Bytes and Bytearray Operations.

The optional source parameter can be used to initialize the array in a few dierent ways:

•

If it is a string, you must also give the encoding (and optionally, errors) parameters; bytearray()

then converts the string to bytes using str.encode().

•

If it is an integer, the array will have that size and will be initialized with null bytes.

•

If it is an object conforming to the buer interface, a read-only buer of the object will be used

to initialize the bytes array.

•

If it is an iterable, it must be an iterable of integers in the range 0 <= x < 256, which are used

as the initial contents of the array.

Without an argument, an array of size 0 is created.

See also Binary Sequence Types — bytes, bytearray, memoryview and Bytearray Objects.

class bytes(

[

source

[

, encoding

[

, errors

]]]

)

Return a new “bytes” object, which is an immutable sequence of integers in the range 0 <= x < 256.

bytes is an immutable version of bytearray – it has the same non-mutating methods and the same

indexing and slicing behavior.

Accordingly, constructor arguments are interpreted as for bytearray().

Bytes objects can also be created with literals, see strings.

6 Chapter 2. Built-in Functions

The Python Library Reference, Release 3.6.3

See also Binary Sequence Types — bytes, bytearray, memoryview, Bytes Objects, and Bytes and

Bytearray Operations.

callable(object)

Return True if the object argument appears callable, False if not. If this returns true, it is still possible

that a call fails, but if it is false, calling object will never succeed. Note that classes are callable (calling

a class returns a new instance); instances are callable if their class has a __call__() method.

New in version 3.2: This function was rst removed in Python 3.0 and then brought back in Python

3.2.

chr(i)

Return the string representing a character whose Unicode code point is the integer i. For example,

chr(97) returns the string

, while chr(8364) returns the string

' C'

. This is the inverse of ord().

The valid range for the argument is from 0 through 1,114,111 (0x10FFFF in base 16). ValueError will

be raised if i is outside that range.

@classmethod

Transform a method into a class method.

A class method receives the class as implicit rst argument, just like an instance method receives the

instance. To declare a class method, use this idiom:

class C:

@classmethod

def f(cls, arg1, arg2, ...): ...

The @classmethod form is a function decorator – see the description of function denitions in function

for details.

It can be called either on the class (such as C.f()) or on an instance (such as C().f()). The instance is

ignored except for its class. If a class method is called for a derived class, the derived class object is

passed as the implied rst argument.

Class methods are dierent than C++ or Java static methods. If you want those, see staticmethod()

in this section.

For more information on class methods, consult the documentation on the standard type hierarchy in

types.

compile(source, lename, mode, ags=0, dont_inherit=False, optimize=-1)

Compile the source into a code or AST object. Code objects can be executed by exec() or eval(). source

can either be a normal string, a byte string, or an AST object. Refer to the ast module documentation

for information on how to work with AST objects.

The lename argument should give the le from which the code was read; pass some recognizable value

if it wasn’t read from a le (

is commonly used).

The mode argument species what kind of code must be compiled; it can be

exec

if source consists

of a sequence of statements,

eval

if it consists of a single expression, or

single

if it consists of a

single interactive statement (in the latter case, expression statements that evaluate to something other

than None will be printed).

The optional arguments ags and dont_inherit control which future statements (see PEP 236) aect

the compilation of source. If neither is present (or both are zero) the code is compiled with those

future statements that are in eect in the code that is calling compile(). If the ags argument is given

and dont_inherit is not (or is zero) then the future statements specied by the ags argument are used

in addition to those that would be used anyway. If dont_inherit is a non-zero integer then the ags

argument is it – the future statements in eect around the call to compile are ignored.

The Python Library Reference, Release 3.6.3

Future statements are specied by bits which can be bitwise ORed together to specify multiple state-

ments. The biteld required to specify a given feature can be found as the compiler_ag attribute on

the _Feature instance in the __future__ module.

The argument optimize species the optimization level of the compiler; the default value of -1 selects

the optimization level of the interpreter as given by -O options. Explicit levels are 0 (no optimization;

__debug__ is true), 1 (asserts are removed, __debug__ is false) or 2 (docstrings are removed too).

This function raises SyntaxError if the compiled source is invalid, and ValueError if the source contains

null bytes.

If you want to parse Python code into its AST representation, see ast.parse().

Note: When compiling a string with multi-line code in

single

eval

mode, input must be

terminated by at least one newline character. This is to facilitate detection of incomplete and complete

statements in the code module.

Changed in version 3.2: Allowed use of Windows and Mac newlines. Also input in

exec

mode does

not have to end in a newline anymore. Added the optimize parameter.

Changed in version 3.5: Previously, TypeError was raised when null bytes were encountered in source.

class complex(

[

real

[

, imag

]]

)

Return a complex number with the value real + imag*1j or convert a string or number to a complex

number. If the rst parameter is a string, it will be interpreted as a complex number and the function

must be called without a second parameter. The second parameter can never be a string. Each

argument may be any numeric type (including complex). If imag is omitted, it defaults to zero and the

constructor serves as a numeric conversion like int and oat. If both arguments are omitted, returns

0j.

Note: When converting from a string, the string must not contain whitespace around the central +

or - operator. For example, complex(

1+2j

) is ne, but complex(

1 + 2j

) raises ValueError.

The complex type is described in Numeric Types — int, oat, complex.

Changed in version 3.6: Grouping digits with underscores as in code literals is allowed.

delattr(object, name)

This is a relative of setattr(). The arguments are an object and a string. The string must be the name

of one of the object’s attributes. The function deletes the named attribute, provided the object allows

it. For example, delattr(x,

foobar

) is equivalent to del x.foobar.

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

Create a new dictionary. The dict object is the dictionary class. See dict and Mapping Types — dict

for documentation about this class.

For other containers see the built-in list, set, and tuple classes, as well as the collections module.

dir(

[

object

]

)

Without arguments, return the list of names in the current local scope. With an argument, attempt

to return a list of valid attributes for that object.

If the object has a method named __dir__(), this method will be called and must return the list

of attributes. This allows objects that implement a custom __getattr__() or __getattribute__()

function to customize the way dir() reports their attributes.

8 Chapter 2. Built-in Functions

The Python Library Reference, Release 3.6.3

If the object does not provide __dir__(), the function tries its best to gather information from the

object’s __dict__ attribute, if dened, and from its type object. The resulting list is not necessarily

complete, and may be inaccurate when the object has a custom __getattr__().

The default dir() mechanism behaves dierently with dierent types of objects, as it attempts to

produce the most relevant, rather than complete, information:

•

If the object is a module object, the list contains the names of the module’s attributes.

•

If the object is a type or class object, the list contains the names of its attributes, and recursively

of the attributes of its bases.

•

Otherwise, the list contains the object’s attributes’ names, the names of its class’s attributes, and

recursively of the attributes of its class’s base classes.

The resulting list is sorted alphabetically. For example:

>>> import struct

>>> dir() # show the names in the module namespace

[

__builtins__

__name__

struct

]

>>> dir(struct) # show the names in the struct module

[

Struct

__all__

__builtins__

__cached__

__doc__

__le__

__initializing__

__loader__

__name__

__package__

_clearcache

calcsize

error

pack

pack_into

unpack

unpack_from

]

>>> class Shape:

... def __dir__(self):

... return [

area

perimeter

location

]

>>> s = Shape()

>>> dir(s)

[

area

location

perimeter

]

Note: Because dir() is supplied primarily as a convenience for use at an interactive prompt, it tries

to supply an interesting set of names more than it tries to supply a rigorously or consistently dened

set of names, and its detailed behavior may change across releases. For example, metaclass attributes

are not in the result list when the argument is a class.

divmod(a, b)

Take two (non complex) numbers as arguments and return a pair of numbers consisting of their quotient

and remainder when using integer division. With mixed operand types, the rules for binary arithmetic

operators apply. For integers, the result is the same as (a // b, a % b). For oating point numbers the

result is (q, a % b), where q is usually math.oor(a / b) but may be 1 less than that. In any case q *

b + a % b is very close to a, if a % b is non-zero it has the same sign as b, and 0 <= abs(a % b) <

abs(b).

enumerate(iterable, start=0)

Return an enumerate object. iterable must be a sequence, an iterator, or some other object which

supports iteration. The __next__() method of the iterator returned by enumerate() returns a tuple

containing a count (from start which defaults to 0) and the values obtained from iterating over iterable.

>>> seasons = [

Spring

Summer

Fall

Winter

]

>>> list(enumerate(seasons))

[(0,

Spring

), (1,

Summer

), (2,

Fall

), (3,

Winter

)]

>>> list(enumerate(seasons, start=1))

[(1,

Spring

), (2,

Summer

), (3,

Fall

), (4,

Winter

)]

Equivalent to:

The Python Library Reference, Release 3.6.3

def enumerate(sequence, start=0):

n = start

for elem in sequence:

yield n, elem

n += 1

eval(expression, globals=None, locals=None)

The arguments are a string and optional globals and locals. If provided, globals must be a dictionary.

If provided, locals can be any mapping object.

The expression argument is parsed and evaluated as a Python expression (technically speaking, a

condition list) using the globals and locals dictionaries as global and local namespace. If the globals

dictionary is present and lacks ‘__builtins__’, the current globals are copied into globals before

expression is parsed. This means that expression normally has full access to the standard builtins

module and restricted environments are propagated. If the locals dictionary is omitted it defaults to

the globals dictionary. If both dictionaries are omitted, the expression is executed in the environment

where eval() is called. The return value is the result of the evaluated expression. Syntax errors are

reported as exceptions. Example:

>>> x = 1

>>> eval(

x+1

)

This function can also be used to execute arbitrary code objects (such as those created by compile()).

In this case pass a code object instead of a string. If the code object has been compiled with

exec

as the mode argument, eval()’s return value will be None.

Hints: dynamic execution of statements is supported by the exec() function. The globals() and locals()

functions returns the current global and local dictionary, respectively, which may be useful to pass

around for use by eval() or exec().

See ast.literal_eval() for a function that can safely evaluate strings with expressions containing only

literals.

exec(object

[

, globals

[

, locals

]]

)

This function supports dynamic execution of Python code. object must be either a string or a code

object. If it is a string, the string is parsed as a suite of Python statements which is then executed

(unless a syntax error occurs).

If it is a code object, it is simply executed. In all cases, the code that’s

executed is expected to be valid as le input (see the section “File input” in the Reference Manual).

Be aware that the return and yield statements may not be used outside of function denitions even

within the context of code passed to the exec() function. The return value is None.

In all cases, if the optional parts are omitted, the code is executed in the current scope. If only globals

is provided, it must be a dictionary, which will be used for both the global and the local variables. If

globals and locals are given, they are used for the global and local variables, respectively. If provided,

locals can be any mapping object. Remember that at module level, globals and locals are the same

dictionary. If exec gets two separate objects as globals and locals, the code will be executed as if it

were embedded in a class denition.

If the globals dictionary does not contain a value for the key __builtins__, a reference to the dictionary

of the built-in module builtins is inserted under that key. That way you can control what builtins are

available to the executed code by inserting your own __builtins__ dictionary into globals before

passing it to exec().

Note that the parser only accepts the Unix-style end of line convention. If you are reading the code from a le, make sure

to use newline conversion mode to convert Windows or Mac-style newlines.

10 Chapter 2. Built-in Functions

剩余1949页未读，继续阅读

ma18309220697

粉丝: 0
资源: 1

Python 3.6 内置函数详解与类型大全

Python字符串操作常用函数

python函数大全

python常用函数

Python内置函数大全：68个核心操作概览

深入理解Python内置函数

Python内置函数中文详解

Python内置函数详解

Python内置函数详解与示例

python内置函数大全表

python内置函数详解

python内置函数 pdf

查看python内置函数的方式

python函数的调用和传参Python匿名函数lambda的使用； Python内置函数的使用； Python递归函数调用。

Python isinstance() 函数 Python 内置函数 Python 内置函数

掌握Python内置函数和Python模块。

python内置函数汇总

python内置函数讲解

python内置函数源码

Python内置函数的介绍

python编写函数模拟内置函数sorted_编写函数,模拟 Python 内置函数 sorted() 。_学小易找答案...

最新资源