最新某某《 java架构从0开始学习》

常用的内置函数
abs(x)
返回一个数的绝对值。实参可以是整数或浮点数。如果实参是一个复数，返回它的模。

all(iterable)
如果 iterable 的所有元素为真（或迭代器为空），返回 True 。等价于:

def all(iterable):
for element in iterable:
if not element:
return False
return True
1
2
3
4
5
any(iterable)
如果iterable的任一元素为真则返回True。如果迭代器为空，返回False。等价于:

def any(iterable):
for element in iterable:
if element:
return True
return False
1
2
3
4
5
bin(x)
将一个整数转变为一个前缀为“0b”的二进制字符串。结果是一个合法的 Python 表达式。如果 x 不是 Python 的 int 对象，那它需要定义 index() 方法返回一个整数。一些例子：

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'
1
2
3
4
如果不一定需要前缀“0b”，还可以使用如下的方法。

>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')
1
2
3
4
bool([x])
返回一个布尔值，True 或者 False。 x 使用标准的真值测试过程来转换。如果 x 是假的或者被省略，返回 False；其他情况返回 True。bool 类是 int 的子类（参见数字类型 — int, float, complex）。其他类不能继承自它。它只有 False 和 True 两个实例

chr(i)
返回 Unicode 码位为整数 i 的字符的字符串格式。例如，chr(97) 返回字符串 ‘a’，chr(8364) 返回字符串 ‘€’。这是 ord() 的逆函数。

实参的合法范围是 0 到 1,114,111（16 进制表示是 0x10FFFF）。如果 i 超过这个范围，会触发 ValueError 异常。

complex([real[, imag]])
返回值为 real + imag*1j 的复数，或将字符串或数字转换为复数。如果第一个形参是字符串，则它被解释为一个复数，并且函数调用时必须没有第二个形参。第二个形参不能是字符串。每个实参都可以是任意的数值类型（包括复数）。如果省略了 imag，则默认值为零，构造函数会像 int 和 float 一样进行数值转换。如果两个实参都省略，则返回 0j。
注解当从字符串转换时，字符串在 + 或 - 的周围必须不能有空格。例如 complex(‘1+2j’) 是合法的，但 complex(‘1 + 2j’) 会触发 ValueError 异常。

**class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, kwarg)
创建一个新的字典。dict 对象是一个字典类。参见 dict 和 Mapping Types — dict 了解这个类。
其他容器类型，请参见内置的 list、set 和 tuple 类，以及 collections 模块。

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

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

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

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

如果对象是模块对象，则列表包含模块的属性名称。
如果对象是类型或类对象，则列表包含它们的属性名称，并且递归查找所有基类的属性。
否则，列表包含对象的属性名称，它的类属性名称，并且递归查找它的类的所有基类的属性。
返回的列表按字母表排序。例如：

>>> import struct
>>> dir() # show the names in the module namespace # doctest: +SKIP
['__builtins__', '__name__', 'struct']
>>> dir(struct) # show the names in the struct module # doctest: +SKIP
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
'__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']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
注解因为 dir() 主要是为了便于在交互式时使用，所以它会试图返回人们感兴趣的名字集合，而不是试图保证结果的严格性或一致性，它具体的行为也可能在不同版本之间改变。例如，当实参是一个类时，metaclass 的属性不包含在结果列表中。

divmod(a, b)
它将两个（非复数）数字作为实参，并在执行整数除法时返回一对商和余数。对于混合操作数类型，适用双目算术运算符的规则。对于整数，结果和 (a // b, a % b) 一致。对于浮点数，结果是 (q, a % b) ，q 通常是 math.floor(a / b) 但可能会比 1 小。在任何情况下， q * b + a % b 和 a 基本相等；如果 a % b 非零，它的符号和 b 一样，并且 0 <= abs(a % b) < abs(b) 。

eval(expression, globals=None, locals=None)
实参是一个字符串，以及可选的 globals 和 locals。globals 实参必须是一个字典。locals 可以是任何映射对象。

expression 参数会作为一个 Python 表达式（从技术上说是一个条件列表）被解析并求值，使用 globals 和 locals 字典作为全局和局部命名空间。如果 globals 字典存在且不包含以 builtins 为键的值，则会在解析 expression 之前插入以此为键的对内置模块 builtins 的字典的引用。这意味着 expression 通常具有对标准 builtins 模块的完全访问权限且受限的环境会被传播。如果省略 locals 字典则其默认值为 globals 字典。如果两个字典同时省略，表达式会在 eval() 被调用的环境中执行。返回值为表达式求值的结果。语法错误将作为异常被报告。例如:

>>> x = 1
>>> eval('x+1')
2
1
2
3
这个函数也可以用来执行任何代码对象（如 compile() 创建的）。这种情况下，参数是代码对象，而不是字符串。如果编译该对象时的 mode 实参是 ‘exec’ 那么 eval() 返回值为 None 。

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

float([x])
返回从数字或字符串 x 生成的浮点数。

如果实参是字符串，则它必须是包含十进制数字的字符串，字符串前面可以有符号，之前也可以有空格。可选的符号有 ‘+’ 和 ‘-’ ； ‘+’ 对创建的值没有影响。实参也可以是 NaN（非数字）、正负无穷大的字符串。确切地说，除去首尾的空格后，输入必须遵循以下语法：

sign ::= “+” | “-”
infinity ::= “Infinity” | “inf”
nan ::= “nan”
numeric_value ::= floatnumber | infinity | nan
numeric_string ::= [sign] numeric_value
这里， floatnumber 是 Python 浮点数的字符串形式，详见浮点数字面值。字母大小写都可以，例如，“inf”、“Inf”、“INFINITY”、“iNfINity” 都可以表示正无穷大。

另一方面，如果实参是整数或浮点数，则返回具有相同值（在 Python 浮点精度范围内）的浮点数。如果实参在 Python 浮点精度范围外，则会触发 OverflowError。

对于一般的 Python 对象 x ， float(x) 指派给 x.float() 。

如果没有实参，则返回 0.0 。

例如:

>>> float('+1.23')
1.23
>>> float(' -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf
1
2
3
4
5
6
7
8
9
10
help([object])
启动内置的帮助系统（此函数主要在交互式中使用）。如果没有实参，解释器控制台里会启动交互式帮助系统。如果实参是一个字符串，则在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。如果实参是其他任意对象，则会生成该对象的帮助页。

hex(x)
将整数转换为以“0x”为前缀的小写十六进制字符串。如果 x 不是 Python int 对象，则必须定义返回整数的 index() 方法。一些例子：

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
1
2
3
4
id(object)
返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的 id() 值。

round(number[, ndigits])
返回 number 舍入到小数点后 ndigits 位精度的值。如果 ndigits 被省略或为 None，则返回最接近输入值的整数。

对于支持 round() 的内置类型，值会被舍入到最接近的 10 的负 ndigits 次幂的倍数；如果与两个倍数的距离相等，则选择偶数 (因此，round(0.5) 和 round(-0.5) 均为 0 而 round(1.5) 为 2)。任何整数值都可作为有效的 ndigits (正数、零或负数)。如果 ndigits 被省略或为 None 则返回值将为整数。否则返回值与 number 的类型相同。

tuple([iterable])
虽然被称为函数，但 tuple 实际上是一个不可变的序列类型，参见在元组与 Sequence Types — list, tuple, range 中的文档说明。

class type(object)
class type(name, bases, dict)
传入一个参数时，返回 object 的类型。返回值是一个 type 对象，通常与 object.class 所返回的对象相同。

推荐使用 isinstance() 内置函数来检测对象的类型，因为它会考虑子类的情况。

传入三个参数时，返回一个新的 type 对象。这在本质上是 class 语句的一种动态形式。 name 字符串即类名并且会成为 name 属性；bases 元组列出基类并且会成为 bases 属性；而 dict 字典为包含类主体定义的命名空间并且会被复制到一个标准字典成为 dict 属性。例如，下面两条语句会创建相同的 type 对象:

>>> class X:
... a = 1
...
>>> X = type('X', (object,), dict(a=1))
1
2
3
4

---------------------
作者：lqz1999
来源：CSDN
原文：https://blog.csdn.net/lqz1999/article/details/88559637
版权声明：本文为博主原创文章，转载请附上博文链接！

最新某某《 java架构从0开始学习》

猜你喜欢