正心全栈编程-文档站

Appearance

数据操作 ​

数据类型 ​

int ​

python
class int(x=0)
class int(x, base=10)

返回一个由数字或字符串 x 构造的整数对象，如果没有给出参数，则返回 0。如果 x 不是数字，则返回 x.__int__()。

python
>>> class A:
...     def __int__(self):
...         return 10
...
>>> a = A()
>>> int(a)
10

如果 x 不是数字或给定了 base，那么 x 必须是一个 string， bytes 或 bytearray 实例，它表示以 base 为基数的整数文字。或者，文字可以在前面加上 +或 - （两者之间没有空格）。

python
>>> int('-10')
-10
>>> int('+10')
10

>>> int('1000',2)
8
>>> int('ff',16)
255

float ​

返回一个由数字或字符串 x 构造的浮点数。

在删除前后空白字符后，输入必须符合以下语法：

python
sign           ::=  "+" | "-"
infinity       ::=  "Infinity" | "inf"
nan            ::=  "nan"
numeric_value  ::=  floatnumber | infinity | nan
numeric_string ::=  [sign] numeric_value

对于一般的 Python 对象 x，float(x) 委托给 x.__float__()。

如果没有给出参数，则返回 0.0。

例子：

python
>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

bool ​

返回一个布尔值，即 True 或 False 中的一个。 x 使用标准真值测试方式 进行转换。如果 x 为 false 或省略，则返回 False; 否则返回 True。 bool 类是 int 的子类。它不能进一步子类化。它唯一的实例是 False 和 True。

str ​

python
class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')

返回一个字符串对象

list ​

python
list([iterable])

list 不是一个函数，它实际上是一个可变的序列类型。

tuple ​

tuple 不是一个函数，它实际上是一个不可变的序列类型

set ​

python
set([iterable])

返回一个新的集合对象，可选地使用来自 iterable 的元素。 set 是一个内置的类。

dict ​

python
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

创建一个新的字典

python
>>> dict(name='jack',age=18)
{'name': 'jack', 'age': 18}
>>> dict({'name': 'jack'}, age=18)
{'name': 'jack', 'age': 18}
>>> dict([('name', 'jack'),('age', 18)])
{'name': 'jack', 'age': 18}

object ​

返回一个新的无特征的对象。object 是所有类的基类。它具有所有 Python 类实例通用的方法。这个函数不接受任何参数。

object 没有 __dict__，所以不能为 object 类的实例指定任意属性。

bytes ​

python
bytes([source[, encoding[, errors]]])

返回一个新的 bytes 对象，它是一个在 0 <= x <256 范围内的不可变整数序列。bytes 是 bytearray 的不可变版本 - 它具有相同的非变异方法和相同的索引和切片行为。

因此，构造函数参数解释请参考 bytearray()。

字节对象也可以使用文字创建。请参阅字符串和字节文字。

bytearray ​

python
bytearray([source[, encoding[, errors]]])

返回一个新的字节数组。 bytearray 类是一个在 0 <= x < 256 范围内的可变整数序列。

可选的 source 参数可以用几种不同的方式初始化数组：

  • 如果它是一个字符串，则还必须给出 encoding（以及可选的 errors）参数; 然后 bytearray() 使用 str.encode() 将字符串转换为字节。
  • 如果它是一个整数，则将其作为数组的长度，并将用空字节进行初始化。
  • 如果它是符合缓冲区接口的对象，则将使用该对象的只读缓冲区来初始化字节数组。
  • 如果它是一个 iterable，必须是 0 <= x <256 范围内的可迭代对象，它们将被用作数组的初始内容。

没有参数，就会创建一个大小为 0 的数组。

python
>>> bytearray(5)
bytearray(b'\x00\x00\x00\x00\x00')
>>> bytearray([23, 32, 4, 67, 9, 96, 123])
bytearray(b'\x17 \x04C\t`{')
>>> bytearray()
bytearray(b'')

complex ​

python
complex([real[, imag]])

返回值为 real + imag*1j 的复数或者将字符串或数字转换为复数。

  • 如果第一个参数是一个字符串，它将被解释为一个复数，并且该函数必须在没有第二个参数的情况下被调用。
  • 第二个参数不能是一个字符串。每个参数可以是任何数字类型（包括复数）。如果省略了 imag ，它将默认为零，并且构造函数用作像 int 和 float 这样的数字转换。如果两个参数均被省略，则返回 0j。

进制转化 ​

bin(x) ​

将整数转换为以 0b 为前缀的二进制字符串。结果是一个有效的 Python 表达式。如果 x 不是 Python int 对象，则必须定义返回整数的 __index __() 方法。一些例子：

python
>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

可以使用以下任意方式，控制是否需要前缀 '0b'：

python
>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

有关更多信息，另请参阅 format()。

当 x 不是 int 类型时

python
>>> class Test:                    
...     def __init__(self, n):
...         self.n = n        
...     def __index__(self):
...         return self.n
... 
>>> t = Test(10)
>>> bin(t)
'0b1010'

oct(x) ​

将整数转换为以 0o 为前缀的八进制字符串。结果是一个有效的 Python 表达式。如果 x 不是 Python int 对象，则必须定义返回整数的 __index__() 方法。例如：

python
>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'

如果要将整数转换为八进制字符串，控制是否显示前缀 0o，则可以使用以下任一方式。

python
>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

hex(x) ​

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

python
>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

如果要将整数转换为带有前缀或不带前缀的大写或小写十六进制字符串，可以使用以下任一方式：

python
>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')

要获取浮点数的十六进制字符串表示形式，请使用 float.hex() 方法。

chr(i) ​

返回表示 Unicode 代码点为整数 i 的字符的字符串。例如，chr(97) 返回字符串 'a'，而 chr(8364) 返回字符串 '€' 。这是 ord() 的逆过程。

参数的有效范围是从 0 到 1,114,111（基于 16 的 0x10FFFF）。如果超出这个范围，将会抛出 ValueError。

python
>>> ord('a') 
97
>>> ord('!') 
33

ord(c) ​

给定一个代表一个Unicode字符的字符串，返回一个表示该字符的 Unicode code 点的整数。例如，ord('a') 返回整数 97，ord('€') （欧元符号）返回 8364。这是 chr() 的逆过程

python
>>> chr(97) 
'a'
>>> chr(33) 
'!'

ascii ​

python
ascii(object)

类似 repr()，返回一个包含对象的可打印表示的字符串，但使用 \x，\u 或 \U 转义符转义由 repr() 返回的字符串中的非 ASCII 字符。这会生成一个类似于 Python2 中 repr() 返回的字符串。

python
>>> s = 'python \n 中文'
>>> ascii(s)
"'python \\n \\u4e2d\\u6587'"
>>> repr(s)
"'python \\n 中文'"
>>>

聚类操作 ​

max ​

python
max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])

返回 iterable 中的最大项或两个或更多个参数中最大的项。

如果提供了一个位置参数，它应该是一个 iterable。iterable 中最大的 item 被返回。如果提供了两个或多个位置参数，则返回最大的位置参数。

有两个可选的关键字参数。 key 参数指定一个像 list.sort() 那样的单参数排序函数。如果提供的迭代器为空，则 default 参数指定要返回的对象。如果迭代器为空且未提供缺省值，则会引发 ValueError。

如果最大值包含多个 item，则该函数返回遇到的第一个 item。这与 sorted(iterable, key=keyfunc, reverse=True)[0] 和 heapq.nlargest(1, iterable, key=keyfunc) 等其他排序工具稳定性保持一致。

python
>>> arr = [4, 3, 7, 1, 9]
>>> max(arr)
9
>>> max(arr, key=lambda x: -x)
1

min ​

python
min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])

返回 iterable 中的最小项或两个或更多个参数中的最小项。

如果提供了一个位置参数，它应该是一个 iterable。iterable 中的最小项被返回。如果提供两个或多个位置参数，则返回最小的位置参数。

有两个可选的关键字参数。 key 参数指定一个像 list.sort() 那样的单参数排序函数。如果提供的迭代器为空，则 default 参数指定要返回的对象。如果迭代器为空且未提供缺省值，则会引发 ValueError。

如果最小值包含多个 item，则该函数返回遇到的第一个 item。这与 sorted(iterable, key=keyfunc, reverse=True)[0] 和 heapq.nlargest(1, iterable, key=keyfunc) 等其他排序工具稳定性保持一致。

sum ​

python
sum(iterable[, start])

从 start 开始，从左到右对 iterable 中的元素求和。 start 默认是 0，迭代的 item 通常是数字，并且不允许 start 的值为字符串。

abs(x) ​

返回一个数字的绝对值。参数可以是整数或浮点数。如果参数是一个复数，则返回它的模。

pow ​

python
pow(x, y[, z])

返回 x 的 y 次方；返回 x 的 y 次方再除以 z 的余数（计算效率比 pow(x, y) % z 更高）。双参数形式 pow(x, y) 等价于使用幂运算符：x**y。

round ​

round(number[, ndigits])

返回在小数点后舍入到精度 ndigits 的 number 。如果 ndigits 被省略或者是 None，它将返回最接近的整数表示。

对于支持 round() 的内建类型，值舍入到 10 的最接近的负 ndigits 次幂的倍数；如果离两个倍数的距离相等，则舍入选择偶数（因此，round(0.5) 和 round(-0.5) 都是 0，而 round(1.5) 是 2 ）。ndigits 可以是任何整数值（正数，零或负数）。如果使用一个参数调用则返回值是一个 integer，否则与 number 的类型相同。

python
>>> round(10.9)
11

>>> round(10.9, 2)
10.9

对于一般的 Python 对象 xxx，round(xxx, ndigits) 委托给 xxx.__round__(ndigits)。

round() 对于浮点数的行为可能会令人惊讶：例如，round(2.675, 2) 给出 2.67，而不是预期的 2.68。这不是一个 bug：这是由于大多数小数不能完全表示为浮点数的结果。

all ​

python
all(*iterable*)

如果 iterable 的所有元素均为 True（或 iterable 为空），则返回 True。相当于：

python
def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

any ​

python
any(*iterable*)

如果 iterable 中有任何一个元素为 True，则返回 True。如果 iterable 为空，则返回 False。相当于：

python
def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

divmod ​

python
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)。

python
>>> divmod(10, 3)
(3, 1)
>>> divmod(10.1, 3)
(3.0, 1.0999999999999996)