没有合适的资源?快使用搜索试试~ 我知道了~
首页Python学习手册:标准库详解与应用
Python学习手册:标准库详解与应用
需积分: 9 1 下载量 168 浏览量
更新于2024-07-30
收藏 3.76MB PDF 举报
"《Python学习手册》是一本详尽介绍Python编程语言的权威指南,由Guido van Rossum编写,首次发行于2006年9月19日,由Python Software Foundation出版。该手册主要关注Python语言的详细语法和语义,强调了其作为一种动态、可扩展、面向对象的语言特性。Python不仅适用于简单的文本处理脚本,还能支持交互式Web开发等广泛的应用场景。 不同于一般的参考手册,本书的核心内容是标准库的深度解析,这是随Python语言分发的,对提高程序员工作效率起着至关重要的作用。标准库包含了一系列用C编写的内置模块,这些模块提供了对系统功能的访问,例如文件I/O操作,这些都是原本可能对Python开发者难以触及的功能。此外,还有其他模块,如网络通信、数据结构、数学运算、图形界面编程等,它们极大地丰富了Python的功能集和应用范围。 学习这本手册,读者不仅能掌握Python的基础语法,还能深入理解如何利用标准库进行高效、灵活的编程。版权方面,2001年至2006年由Python Software Foundation持有,而1995年至2000年由BeOpen.com、1991年至1995年由Corporation for National Research Initiatives以及1991年至1995年由Stichting Mathematisch Centrum分别拥有部分权利。在手册的末尾,提供了完整的许可和权限信息,确保用户在合法范围内使用和学习Python语言。对于想要深入学习或从事Python开发的人来说,这本书是不可或缺的重要参考资料。"
资源详情
资源推荐
level specifies whether to use absolute or relative imports. The default is -1 which indicates both absolute
and relative imports will be attempted. 0 means only perform absolute imports. Positive values for level
indicate the number of parent directories to search relative to the directory of the module calling __-
import__. Changed in version 2.5: The level parameter was added. Changed in version 2.5: Keyword
support for parameters was added.
abs(x)
Return the absolute value of a number. The argument may be a plain or long integer or a floating point
number. If the argument is a complex number, its magnitude is returned.
all(iterable)
Return True if all elements of the iterable are true. Equivalent to:
def all(iterable):
for element in iterable:
if not element:
return False
return True
New in version 2.5.
any(iterable)
Return True if any element of the iterable is true. Equivalent to:
def any(iterable):
for element in iterable:
if element:
return True
return False
New in version 2.5.
basestring()
This abstract type is the superclass for str and unicode. It cannot be called or instantiated, but it can be
used to test whether an object is an instance of str or unicode. isinstance(obj, basestring)
is equivalent to isinstance(obj, (str, unicode)). New in version 2.3.
bool([x ])
Convert a value to a Boolean, using the standard truth testing procedure. If x is false or omitted, this returns
False; otherwise it returns True. bool is also a class, which is a subclass of int. Class bool cannot
be subclassed further. Its only instances are False and True.
New in version 2.2.1. Changed in version 2.3: If no argument is given, this function returns False.
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); class instances are callable if they have a __call__() method.
chr(i)
Return a string of one character whose ASCII code is the integer i. For example, chr(97) returns the string
’a’. This is the inverse of ord(). The argument must be in the range [0..255], inclusive; ValueError
will be raised if i is outside that range.
classmethod(function)
Return a class method for function.
A class method receives the class as implicit first argument, just like an instance method receives the in-
stance. To declare a class method, use this idiom:
class C:
@classmethod
def f(cls, arg1, arg2, ...): ...
4 Chapter 2. Built-in Objects
The @classmethod form is a function decorator – see the description of function definitions in chapter 7
of the Python Reference Manual 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 first argument.
Class methods are different 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 chapter
3 of the Python Reference Manual (at the bottom). New in version 2.2. Changed in version 2.4: Function
decorator syntax added.
cmp(x, y)
Compare the two objects x and y and return an integer according to the outcome. The return value is negative
if x < y, zero if x == y and strictly positive if x > y.
compile(string, filename, kind[, flags[, dont inherit ]])
Compile the string into a code object. Code objects can be executed by an exec statement or evaluated by
a call to eval(). The filename argument should give the file from which the code was read; pass some
recognizable value if it wasn’t read from a file (’<string>’ is commonly used). The kind argument spec-
ifies what kind of code must be compiled; it can be ’exec’ if string 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 else than None will be printed).
When compiling multi-line statements, two caveats apply: line endings must be represented by a single
newline character (’\n’), and the input must be terminated by at least one newline character. If line
endings are represented by ’\r\n’, use the string replace() method to change them into ’\n’.
The optional arguments flags and dont inherit (which are new in Python 2.2) control which future statements
(see PEP 236) affect the compilation of string. If neither is present (or both are zero) the code is compiled
with those future statements that are in effect in the code that is calling compile. If the flags argument is
given and dont inherit is not (or is zero) then the future statements specified by the flags argument are used
in addition to those that would be used anyway. If dont inherit is a non-zero integer then the flags argument
is it – the future statements in effect around the call to compile are ignored.
Future statements are specified by bits which can be bitwise or-ed together to specify multiple statements.
The bitfield required to specify a given feature can be found as the compiler_flag attribute on the
_Feature instance in the __future__ module.
complex([real[, imag ]])
Create a complex number with the value real + imag*j or convert a string or number to a complex number.
If the first 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 function serves as a
numeric conversion function like int(), long() and float(). If both arguments are omitted, returns
0j.
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.
dict([mapping-or-sequence ])
Return a new dictionary initialized from an optional positional argument or from a set of keyword argu-
ments. If no arguments are given, return a new empty dictionary. If the positional argument is a mapping
object, return a dictionary mapping the same keys to the same values as does the mapping object. Otherwise
the positional argument must be a sequence, a container that supports iteration, or an iterator object. The
elements of the argument must each also be of one of those kinds, and each must in turn contain exactly two
objects. The first is used as a key in the new dictionary, and the second as the key’s value. If a given key is
seen more than once, the last value associated with it is retained in the new dictionary.
If keyword arguments are given, the keywords themselves with their associated values are added as items
to the dictionary. If a key is specified both in the positional argument and as a keyword argument, the value
2.1. Built-in Functions 5
associated with the keyword is retained in the dictionary. For example, these all return a dictionary equal to
{"one": 2, "two": 3}:
dict({’one’: 2, ’two’: 3})
dict({’one’: 2, ’two’: 3}.items())
dict({’one’: 2, ’two’: 3}.iteritems())
dict(zip((’one’, ’two’), (2, 3)))
dict([[’two’, 3], [’one’, 2]])
dict(one=2, two=3)
dict([([’one’, ’two’][i-2], i) for i in (2, 3)])
New in version 2.2. Changed in version 2.3: Support for building a dictionary from keyword arguments
added.
dir([object ])
Without arguments, return the list of names in the current local symbol table. With an argument, attempts
to return a list of valid attributes for that object. This information is gleaned from the object’s __dict__-
attribute, if defined, and from the class or type object. The list is not necessarily complete. 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()
[’__builtins__’, ’__doc__’, ’__name__’, ’struct’]
>>> dir(struct)
[’__doc__’, ’__name__’, ’calcsize’, ’error’, ’pack’, ’unpack’]
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 defined set of
names, and its detailed behavior may change across releases.
divmod(a, b)
Take two (non complex) numbers as arguments and return a pair of numbers consisting of their quotient and
remainder when using long division. With mixed operand types, the rules for binary arithmetic operators
apply. For plain and long integers, the result is the same as (a // b, a % b). For floating point numbers
the result is (q, a % b), where q is usually math.floor(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).
Changed in version 2.3: Using divmod() with complex numbers is deprecated.
enumerate(iterable)
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 zero) and the corresponding value obtained from iterating over iterable. enumerate() is
useful for obtaining an indexed series: (0, seq[0]), (1, seq[1]), (2, seq[2]), . . . . New in
version 2.3.
eval(expression[, globals[, locals ]])
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. Changed in version 2.4: formerly locals was required to be a
dictionary.
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 name space. 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
__builtin__ module and restricted
environments are propagated. If the locals dictionary is omitted it defaults to the globals dictionary. If both
6 Chapter 2. Built-in Objects
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
>>> print eval(’x+1’)
2
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. The code object must have been compiled passing ’eval’
as the kind argument.
Hints: dynamic execution of statements is supported by the exec statement. Execution of statements from
a file is supported by the execfile() 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
execfile().
execfile(filename[, globals[, locals ]])
This function is similar to the exec statement, but parses a file instead of a string. It is different from the
import statement in that it does not use the module administration — it reads the file unconditionally and
does not create a new module.
2
The arguments are a file name and two optional dictionaries. The file is parsed and evaluated as a sequence
of Python statements (similarly to a module) using the globals and locals dictionaries as global and local
namespace. If provided, locals can be any mapping object. Changed in version 2.4: formerly locals was
required to be a dictionary. 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 execfile() is called. The
return value is None.
Warning: The default locals act as described for function locals() below: modifications to the default
locals dictionary should not be attempted. Pass an explicit locals dictionary if you need to see effects of
the code on locals after function execfile() returns. execfile() cannot be used reliably to modify
a function’s locals.
file(filename[, mode[, bufsize ]])
Constructor function for the file type, described further in section 3.9, “
File Objects”. The constructor’s
arguments are the same as those of the open() built-in function described below.
When opening a file, it’s preferable to use open() instead of invoking this constructor directly. file is
more suited to type testing (for example, writing ‘isinstance(f, file)’).
New in version 2.2.
filter(function, list)
Construct a list from those elements of list for which function returns true. list may be either a sequence,
a container which supports iteration, or an iterator, If list is a string or a tuple, the result also has that type;
otherwise it is always a list. If function is None, the identity function is assumed, that is, all elements of list
that are false are removed.
Note that filter(function, list) is equivalent to [item for item in list if
function(item)] if function is not None and [item for item in list if item] if
function is None.
float([x ])
Convert a string or a number to floating point. If the argument is a string, it must contain a possibly signed
decimal or floating point number, possibly embedded in whitespace. Otherwise, the argument may be a
plain or long integer or a floating point number, and a floating point number with the same value (within
Python’s floating point precision) is returned. If no argument is given, returns 0.0.
Note: When passing in a string, values for NaN and Infinity may be returned, depending on the underlying
C library. The specific set of strings accepted which cause these values to be returned depends entirely on
the C library and is known to vary.
frozenset([iterable ])
Return a frozenset object whose elements are taken from iterable. Frozensets are sets that have no up-
date methods but can be hashed and used as members of other sets or as dictionary keys. The elements
2
It is used relatively rarely so does not warrant being made into a statement.
2.1. Built-in Functions 7
of a frozenset must be immutable themselves. To represent sets of sets, the inner sets should also be
frozenset objects. If iterable is not specified, returns a new empty set, frozenset([]). New
in version 2.4.
getattr(object, name[, default ])
Return the value of the named attributed of object. name must be a string. If the string is the name of one
of the object’s attributes, the result is the value of that attribute. For example, getattr(x, ’foobar’)
is equivalent to x.foobar. If the named attribute does not exist, default is returned if provided, otherwise
AttributeError is raised.
globals()
Return a dictionary representing the current global symbol table. This is always the dictionary of the current
module (inside a function or method, this is the module where it is defined, not the module from which it is
called).
hasattr(object, name)
The arguments are an object and a string. The result is True if the string is the name of one of the object’s
attributes, False if not. (This is implemented by calling getattr(object, name) and seeing whether
it raises an exception or not.)
hash(object)
Return the hash value of the object (if it has one). Hash values are integers. They are used to quickly
compare dictionary keys during a dictionary lookup. Numeric values that compare equal have the same
hash value (even if they are of different types, as is the case for 1 and 1.0).
help([object ])
Invoke the built-in help system. (This function is intended for interactive use.) If no argument is given, the
interactive help system starts on the interpreter console. If the argument is a string, then the string is looked
up as the name of a module, function, class, method, keyword, or documentation topic, and a help page is
printed on the console. If the argument is any other kind of object, a help page on the object is generated.
New in version 2.2.
hex(x)
Convert an integer number (of any size) to a hexadecimal string. The result is a valid Python expression.
Changed in version 2.4: Formerly only returned an unsigned literal.
id(object)
Return the “identity” of an object. This is an integer (or long integer) which is guaranteed to be unique and
constant for this object during its lifetime. Two objects with non-overlapping lifetimes may have the same
id() value. (Implementation note: this is the address of the object.)
input([prompt ])
Equivalent to eval(raw_input(prompt)). Warning: This function is not safe from user errors! It
expects a valid Python expression as input; if the input is not syntactically valid, a SyntaxError will be
raised. Other exceptions may be raised if there is an error during evaluation. (On the other hand, sometimes
this is exactly what you need when writing a quick script for expert use.)
If the readline module was loaded, then input() will use it to provide elaborate line editing and
history features.
Consider using the raw_input() function for general input from users.
int([x[, radix ]])
Convert a string or number to a plain integer. If the argument is a string, it must contain a possibly signed
decimal number representable as a Python integer, possibly embedded in whitespace. The radix parameter
gives the base for the conversion and may be any integer in the range [2, 36], or zero. If radix is zero, the
proper radix is guessed based on the contents of string; the interpretation is the same as for integer literals.
If radix is specified and x is not a string, TypeError is raised. Otherwise, the argument may be a plain or
long integer or a floating point number. Conversion of floating point numbers to integers truncates (towards
zero). If the argument is outside the integer range a long object will be returned instead. If no arguments
are given, returns 0.
isinstance(object, classinfo)
Return true if the object argument is an instance of the classinfo argument, or of a (direct or indirect)
subclass thereof. Also return true if classinfo is a type object and object is an object of that type. If object
8 Chapter 2. Built-in Objects
剩余985页未读,继续阅读
tangxuletian
- 粉丝: 0
- 资源: 2
上传资源 快速赚钱
- 我的内容管理 展开
- 我的资源 快来上传第一个资源
- 我的收益 登录查看自己的收益
- 我的积分 登录查看自己的积分
- 我的C币 登录后查看C币余额
- 我的收藏
- 我的下载
- 下载帮助
最新资源
- Ansys Comsol实现力磁耦合仿真及其在电磁无损检测中的应用
- 西门子数控系统调试与配置实战案例教程
- ELM多输出拟合预测模型:简易Matlab实现指南
- 一维光子晶体的Comsol能带拓扑分析研究
- Borland-5技术资料压缩包分享
- Borland 6 技术资料分享包
- UE5压缩包处理技巧与D文件介绍
- 机器学习笔记:深入探讨中心极限定理
- ProE使用技巧及文件管理方法分享
- 增量式百度图片爬虫程序修复版发布
- Emlog屏蔽用户IP黑名单插件:自定义跳转与评论限制
- 安装Prometheus 2.2.1所需镜像及配置指南
- WinRARChan主题包:个性化你的压缩软件
- Neo4j关系数据映射转换测试样例集
- 安装heapster-grafana-amd64-v5-0-4所需镜像介绍
- DVB-C语言深度解析TS流
资源上传下载、课程学习等过程中有任何疑问或建议,欢迎提出宝贵意见哦~我们会及时处理!
点击此处反馈
安全验证
文档复制为VIP权益,开通VIP直接复制
信息提交成功