python 数字类型相关(int, float, complex)

运算

公式	结果
x + y	x 和 y 的和
x - y	x 和 y 的差
x * y	x 和 y 的乘积
x / y	x 和 y 的商
x // y	x 和 y 的商数
x % y	x / y 的余数
-x	x 取反
+x	x 不变
abs(x)	x 的绝对值或大小
int(x)	将 x 转换为整数
float(x)	将 x 转换为浮点数
complex(re, im)	一个带有实部 re 和虚部 im 的复数。im 默认为0。
c.conjugate()	复数 c 的共轭
divmod(x, y)	(x // y, x % y)
pow(x, y)	x 的 y 次幂
x ** y	x 的 y 次幂

---

按位运算

公式	结果
x	y	x 和 y 按位 或
x ^ y	x 和 y 按位 异或
x & y	x 和 y 按位 与
x << n	x 左移 n 位
x >> n	x 右移 n 位
~x	x 逐位取反

---

Number数据类型转换

方法	描述
int(x [,base ])	将x转换为一个整数
long(x [,base ])	将x转换为一个长整数
float(x )	将x转换到一个浮点数
complex(real [,imag ])	创建一个复数
str(x )	将对象 x 转换为字符串
repr(x )	将对象 x 转换为表达式字符串
eval(str )	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s )	将序列 s 转换为一个元组
list(s )	将序列 s 转换为一个列表
chr(x )	将一个整数转换为一个字符
unichr(x )	将一个整数转换为Unicode字符
ord(x )	将一个字符转换为它的整数值
hex(x )	将一个整数转换为一个十六进制字符串
oct(x )	将一个整数转换为一个八进制字符串

---

附加方法

int.bit_length()

返回以二进制表示一个整数所需要的位数，不包括符号位和前面的零:

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

等价于:

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6

---

int.to_bytes(length, byteorder, *, signed=false)

返回表示一个整数的字节数组。

• length — 长度
• byteorder — 确定用于表示整数的字节顺序
  • big: 最高位字节放在字节数组的开头;
  • little: 最高位字节放在字节数组的末尾;
• signed 参数确定是否使用二的补码来表示整数。

>>> (1).to_bytes(1, byteorder='big')
b'\x01'

>>> (1).to_bytes(3, byteorder='big')
b'\x00\x00\x01'

>>> (1).to_bytes(3, byteorder='little')
b'\x01\x00\x00'

---

classmethod int.from_bytes(bytes, byteorder, *, signed=False)

返回由给定字节数组所表示的整数。

>>> int.from_bytes(b'\x01', byteorder='big')
1

>>> int.from_bytes(b'\x00\x00\x01', byteorder='big')
1

>>> int.from_bytes(b'\x00\x00\x01', byteorder='little')
65536

---

float.as_integer_ratio()

返回一对整数，其比率正好等于原浮点数并且分母为正数。 无穷大会引发 OverflowError 而 NaN 则会引发 ValueError。

>>> (1.0).as_integer_ratio()
(1, 1)

>>> (1.1).as_integer_ratio()
(2476979795053773, 2251799813685248)

>>> (1.2).as_integer_ratio()
(5404319552844595, 4503599627370496)

---

float.is_integer()

如果 float 实例可用有限位整数表示则返回 True，否则返回 False:

>>> (1.0).is_integer()
True

>>> (1.1).is_integer()
False

---

float.hex()

以十六进制字符串的形式返回一个浮点数表示。 对于有限浮点数，这种表示法将总是包含前导的 0x 和尾随的 p 加指数。

>>> (1.0).hex()
'0x1.0000000000000p+0'

>>> (1.1).hex()
'0x1.199999999999ap+0'

---

classmethod float.fromhex(s)

返回以十六进制字符串 s 表示的浮点数的类方法。 字符串 s 可以带有前导和尾随的空格。
注意 float.hex() 是实例方法，而 float.fromhex() 是类方法。

>>> float.fromhex('0x1.0000000000000p+0')
1.0

>>> float.fromhex('0x1.199999999999ap+0')
1.1

---

math — 数学函数

该模块提供了对C标准定义的数学函数的访问。

# 使用数学函数需要导入 math 模块
import math

math.ceil(x)

返回 x 的上限，即大于或者等于 x 的最小整数。如果 x 不是一个浮点数，则委托 x.ceil(), 返回一个 Integral 类的值。

>>> math.ceil(1.1)
2

---

math.copysign(x, y)

返回一个基于 x 的绝对值和 y 的符号的浮点数。在支持带符号零的平台上，copysign(1.0, -0.0) 返回 -1.0.

>>> math.copysign(1, 1)
1.0

>>> math.copysign(1, -0.0)
-1.0

---

math.fabs(x)

返回 x 的绝对值。

>>> math.fabs(1)
1.0
>>> math.fabs(-1)
1.0

---

math.factorial(x)

以一个整数返回 x 的阶乘。 如果 x 不是整数或为负数时则将引发 ValueError。

# x = 5 : 1 * 2 * 3 * 4 * 5
>>> math.factorial(5)
120

---

math.floor(x)

返回 x 的向下取整，小于或等于 x 的最大整数。如果 x 不是浮点数，则委托 x.floor() ，它应返回 Integral 值。

>>> math.ceil(1.1)
1

---

math.fmod(x, y)

返回 fmod(x, y) ，由平台C库定义。请注意，Python表达式 x % y 可能不会返回相同的结果。C标准的目的是 fmod(x, y) 完全（数学上；到无限精度）等于 x - n*y 对于某个整数 n ，使得结果具有 与 x 相同的符号和小于 abs(y) 的幅度。Python的 x % y 返回带有 y 符号的结果，并且可能不能完全计算浮点参数。 例如， fmod(-1e-100, 1e100) 是 -1e-100 ，但Python的 -1e-100 % 1e100 的结果是 1e100-1e-100 ，它不能完全表示为浮点数，并且取整为令人惊讶的 1e100 。 出于这个原因，函数 fmod() 在使用浮点数时通常是首选，而Python的 x % y 在使用整数时是首选。

---

math.frexp(x)

返回 x 的尾数和指数作为对``(m, e)``。 m 是一个浮点数， e 是一个整数，正好是 x == m * 2**e 。 如果 x 为零，则返回 (0.0, 0) ，否则返回 0.5 <= abs(m) < 1 。这用于以可移植方式“分离”浮点数的内部表示。

---

math.fsum(iterable)

返回迭代中的精确浮点值。通过跟踪多个中间部分和来避免精度损失:

>>> sum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
0.9999999999999999
>>> math.fsum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
1.0

该算法的准确性取决于IEEE-754算术保证和舍入模式为半偶的典型情况。在某些非Windows版本中，底层C库使用扩展精度添加，并且有时可能会使中间和加倍，导致它在最低有效位中关闭。

---

math.gcd(a, b)

返回整数 a 和 b 的最大公约数。如果 a 或 b 之一非零，则 gcd(a, b) 的值是能同时整除 a 和 b 的最大正整数。gcd(0, 0) 返回 0。

>>> math.gcd(6, 13)
1
>>> math.gcd(6, 14)
2

3.5 新版功能.

---

math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)

若 a 和 b 的值比较接近则返回 True，否则返回 False。

• rel_tol 是相对容差 —— 它是 a 和 b 之间允许的最大差值，相对于 a 或 b 的较大绝对值。例如，要设置5％的容差，请传递 rel_tol=0.05 。默认容差为 1e-09，确保两个值在大约9位十进制数字内相同。 rel_tol 必须大于零。
• abs_tol 是最小绝对容差 —— 对于接近零的比较很有用。 abs_tol 必须至少为零。

>>> math.isclose(1,2)
False
>>> math.isclose(1,2, rel_tol=1)
True

根据给定的绝对和相对容差确定两个值是否被认为是接近的。

如果没有错误发生，结果将是： abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol) 。

IEEE 754特殊值 NaN ， inf 和 -inf 将根据IEEE规则处理。具体来说， NaN 不被认为接近任何其他值，包括 NaN 。 inf 和 -inf 只被认为接近自己。

3.5 新版功能.

参见 PEP 485 —— 用于测试近似相等的函数

---

math.isfinite(x)

如果 x 既不是无穷大也不是NaN，则返回 True ，否则返回 False 。 （注意 0.0 被认为 是 有限的。）

>>> math.isfinite(1)
True
>>> math.isfinite(0.0)
True

3.2 新版功能.

---

math.isinf(x)

如果 x 是正或负无穷大，则返回 True ，否则返回 False 。

---

math.isnan(x)

如果 x 是 NaN（不是数字），则返回 True ，否则返回 False 。

---

math.ldexp(x, i)

返回 x * (2**i) 。 这基本上是函数 frexp() 的反函数。

---

math.modf(x)

返回 x 的小数和整数部分。两个结果都带有 x 的符号并且是浮点数。

---

math.remainder(x, y)

返回 IEEE 754 风格的 x 相对于 y 的余数。对于有限 x 和有限非零 y ，这是差异 x - ny ，其中 n 是与商 x / y 的精确值最接近的整数。如果 x / y 恰好位于两个连续整数之间，则最近的 even 整数用于 n 。 余数 r = remainder(x, y) 因此总是满足 abs(r) <= 0.5 abs(y) 。

特殊情况遵循IEEE 754：特别是 remainder(x, math.inf) 对于任何有限 x 都是 x ，而 remainder(x, 0) 和 remainder(math.inf, x) 引发 ValueError 适用于任何非NaN的 x 。如果余数运算的结果为零，则该零将具有与 x 相同的符号。

在使用IEEE 754二进制浮点的平台上，此操作的结果始终可以完全表示：不会引入舍入错误。

3.7 新版功能.

---

math.trunc(x)

返回 Real 值 x 截断为 Integral （通常是整数）。 委托给 x.trunc()。

注意 frexp() 和 modf() 具有与它们的C等价函数不同的调用/返回模式：它们采用单个参数并返回一对值，而不是通过 ‘输出形参’ 返回它们的第二个返回参数（Python中没有这样的东西）。

对于 ceil() ， floor() 和 modf() 函数，请注意 所有 足够大的浮点数都是精确整数。Python浮点数通常不超过53位的精度（与平台C double类型相同），在这种情况下，任何浮点 x 与 abs(x) >= 2**52 必然没有小数位。

---

幂函数与对数函数

math.exp(x)

返回 e 次 x 幂，其中 e = 2.718281… 是自然对数的基数。这通常比 math.e ** x 或 pow(math.e, x) 更精确。

---

math.expm1(x)

返回 e 的 x 次幂，减1。这里 e 是自然对数的基数。对于小浮点数 x ， exp(x) - 1 中的减法可能导致 significant loss of precision； expm1() 函数提供了一种将此数量计算为全精度的方法:

>>>
>>> from math import exp, expm1
>>> exp(1e-5) - 1  # gives result accurate to 11 places
1.0000050000069649e-05
>>> expm1(1e-5)    # result accurate to full precision
1.0000050000166668e-05

3.2 新版功能.

---

math.log(x[, base])

使用一个参数，返回 x 的自然对数（底为 e ）。

使用两个参数，返回给定的 base 的对数 x ，计算为 log(x)/log(base) 。

---

math.log1p(x)

返回 1+x (base e) 的自然对数。以对于接近零的 x 精确的方式计算结果。

---

math.log2(x)

返回 x 以2为底的对数。这通常比 log(x, 2) 更准确。

3.3 新版功能.

参见 int.bit_length() 返回表示二进制整数所需的位数，不包括符号和前导零。
math.log10(x)
返回 x 底为10的对数。这通常比 log(x, 10) 更准确。

---

math.pow(x, y)

将返回 x 的 y 次幂。特殊情况尽可能遵循C99标准的附录’F’。特别是， pow(1.0, x) 和 pow(x, 0.0) 总是返回 1.0 ，即使 x 是零或NaN。 如果 x 和 y 都是有限的， x 是负数， y 不是整数那么 pow(x, y) 是未定义的，并且引发 ValueError 。

与内置的 运算符不同， math.pow() 将其参数转换为 float 类型。使用 或内置的 pow() 函数来计算精确的整数幂。

---

math.sqrt(x)

返回 x 的平方根。

---

三角函数

math.acos(x)

以弧度为单位返回 x 的反余弦值。

---

math.asin(x)

以弧度为单位返回 x 的反正弦值。

---

math.atan(x)

以弧度为单位返回 x 的反正切值。

---

math.atan2(y, x)

以弧度为单位返回 atan(y / x) 。结果是在 -pi 和 pi 之间。从原点到点 (x, y) 的平面矢量使该角度与正X轴成正比。 atan2() 的点的两个输入的符号都是已知的，因此它可以计算角度的正确象限。 例如， atan(1) 和 atan2(1, 1) 都是 pi/4 ，但 atan2(-1, -1) 是 -3*pi/4 。

---

math.cos(x)

返回 x 弧度的余弦值。

---

math.hypot(x, y)

Return the Euclidean norm, sqrt(xx + yy). This is the length of the vector from the origin to point (x, y).

---

math.sin(x)

返回 x 弧度的正弦值。

---

math.tan(x)

返回 x 弧度的正切值。

---

角度转换

math.degrees(x)

将角度 x 从弧度转换为度数。

---

math.radians(x)

将角度 x 从度数转换为弧度。

---

双曲函数

双曲函数 是基于双曲线而非圆来对三角函数进行模拟。

math.acosh(x)

返回 x 的反双曲余弦值。

---

math.asinh(x)

返回 x 的反双曲正弦值。

---

math.atanh(x)

返回 x 的反双曲正切值。

---

math.cosh(x)

返回 x 的双曲余弦值。

---

math.sinh(x)

返回 x 的双曲正弦值。

---

math.tanh(x)

返回 x 的双曲正切值。

---

特殊函数

math.erf(x)

返回 x 处的 error function 。

erf() 函数可用于计算传统的统计函数，如 累积标准正态分布

def phi(x):
    'Cumulative distribution function for the standard normal distribution'
    return (1.0 + erf(x / sqrt(2.0))) / 2.0

3.2 新版功能.

---

math.erfc(x)

返回 x 处的互补误差函数。 互补错误函数 定义为 1.0 - erf(x)。 它用于 x 的大值，从其中减去一个会导致 有效位数损失。

3.2 新版功能.

---

math.gamma(x)

返回 x 处的 伽马函数 值。

3.2 新版功能.

---

math.lgamma(x)

返回Gamma函数在 x 绝对值的自然对数。

3.2 新版功能.

---

常数

math.pi

数学常数 π = 3.141592…，精确到可用精度。

>>> math.pi
3.141592653589793

---

math.e

数学常数 e = 2.718281…，精确到可用精度。

>>> math.e
2.718281828459045

---

math.tau

数学常数 τ = 6.283185…，精确到可用精度。Tau 是一个圆周常数，等于 2π，圆的周长与半径之比。更多关于 Tau 的信息可参考 Vi Hart 的视频 Pi is (still) Wrong。吃两倍多的派来庆祝 Tau 日 吧！

>>> math.tau
6.283185307179586

3.6 新版功能.

---

math.inf

浮点正无穷大。 （对于负无穷大，使用 -math.inf 。）相当于``float(‘inf’)`` 的输出。

3.5 新版功能.

---

math.nan

浮点“非数字”（NaN）值。 相当于 float(‘nan’) 的输出。

3.5 新版功能.

---

复数的数学函数

这一模块提供了一些关于复数的数学函数。 该模块的函数的参数为整数、浮点数或复数。

# 使用复数的数学函数需要导入 cmath 模块
import cmath

到极坐标和从极坐标的转换

cmath.phase(x)

将 x 的相位 (也称为 x 的 参数) 返回为一个浮点数。phase(x) 相当于 math.atan2(x.imag, x.real)。 结果处于 [-π, π] 之间，以及这个操作的分支切断处于负实轴上，从上方连续。 在支持有符号零的系统上（这包涵大多数当前的常用系统），这意味着结果的符号与 x.imag 的符号相同，即使 x.imag 的值是 0:

>>> phase(complex(-1.0, 0.0))
3.141592653589793
>>> phase(complex(-1.0, -0.0))
-3.141592653589793

---

cmath.polar(x)

在极坐标中返回 x 的表达方式。返回一个数对 (r, phi)，r 是 x 的模数，phi 是 x 的相位角。 polar(x) 相当于 (abs(x), phase(x))。

---

cmath.rect(r, phi)

通过极坐标的 r 和 phi 返回复数 x。相当于 r (math.cos(phi) + math.sin(phi)1j)。

---

幂函数与对数函数

cmath.exp(x)
返回 e 的 x 次方，e 是自然对数的底数。

---

cmath.log(x[, base])

返回给定 base 的 x 的对数。如果没有给定 base，返回 x 的自然对数。 从 0 到 -∞ 存在一个分歧点，沿负实轴之上连续。

---

cmath.log10(x)

返回底数为 10 的 x 的对数。它具有与 log() 相同的分歧点。

---

cmath.sqrt(x)

返回 x 的平方根。 它具有与 log() 相同的分歧点。

---

三角函数

cmath.acos(x)

返回 x 的反余弦。这里有两个分歧点：一个沿着实轴从 1 向右延伸到 ∞，从下面连续延伸。另外一个沿着实轴从 -1 向左延伸到 -∞，从上面连续延伸。

---

cmath.asin(x)

返回 x 的反正弦。它与 acos() 有相同的分歧点。

---

cmath.atan(x)

返回 x 的反正切。它具有两个分歧点：一个沿着虚轴从 1j 延伸到 ∞j，向右持续延伸。另一个是沿着虚轴从 -1j 延伸到 -∞j ，向左持续延伸。

---

cmath.cos(x)

返回 x 的余弦。

---

cmath.sin(x)

返回 x 的正弦。

---

cmath.tan(x)

返回 x 的正切。

---

双曲函数

cmath.acosh(x)

返回 x 的反双曲余弦。它有一个分歧点沿着实轴从 1 到 -∞ 向左延伸，从上方持续延伸。

---

cmath.asinh(x)

返回 x 的反双曲正弦。它有两个分歧点：一个沿着虚轴从 1j 向右持续延伸到 ∞j。另一个是沿着虚轴从 -1j 向左持续延伸到 -∞j。

---

cmath.atanh(x)

返回 x 的反双曲正切。它有两个分歧点：一个是沿着实轴从 1 延展到 ∞，从下面持续延展。另一个是沿着实轴从 -1 延展到 -∞，从上面持续延展。

---

cmath.cosh(x)

返回 x 的双曲余弦值。

---

cmath.sinh(x)

返回 x 的双曲正弦值。

---

cmath.tanh(x)

返回 x 的双曲正切值。

---

分类函数

cmath.isfinite(x)
如果 x 的实部和虚部都是有限的，则返回 True，否则返回 False。

3.2 新版功能.

---

cmath.isinf(x)

如果 x 的实部或者虚部是无穷大的，则返回 True，否则返回 False。

---

cmath.isnan(x)

如果 x 的实部或者虚部是 NaN，则返回 True ，否则返回 False。

---

cmath.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)

若 a 和 b 的值比较接近则返回 True，否则返回 False。

根据给定的绝对和相对容差确定两个值是否被认为是接近的。

• rel_tol 是相对容差 —— 它是 a 和 b 之间允许的最大差值，相对于 a 或 b 的较大绝对值。例如，要设置5％的容差，请传递 rel_tol=0.05 。默认容差为 1e-09，确保两个值在大约9位十进制数字内相同。 rel_tol 必须大于零。

• abs_tol 是最小绝对容差 —— 对于接近零的比较很有用。 abs_tol 必须至少为零。

如果没有错误发生，结果将是： abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol) 。

IEEE 754特殊值 NaN ， inf 和-inf 将根据IEEE规则处理。具体来说， NaN 不被认为接近任何其他值，包括 NaN 。 inf 和 -inf 只被认为接近自己。

3.5 新版功能.

---

常数

cmath.pi
数学常数 π ，作为一个浮点数。

---

cmath.e

数学常数 e ，作为一个浮点数。

---

cmath.tau

数学常数 τ ，作为一个浮点数。

3.6 新版功能.

---

cmath.inf

浮点正无穷大。相当于 float(‘inf’)。

3.6 新版功能.

---

cmath.infj

具有零实部和正无穷虚部的复数。相当于 complex(0.0, float(‘inf’))。

3.6 新版功能.

---

cmath.nan

浮点“非数字”（NaN）值。相当于 float(‘nan’)。

3.6 新版功能.

---

cmath.nanj

具有零实部和 NaN 虚部的复数。相当于 complex(0.0, float(‘nan’))。

3.6 新版功能.

---

random — 生成伪随机数

该模块实现了各种分布的伪随机数生成器。

# 使用复数的数学函数需要导入 random 模块
import random

簿记功能

random.seed(a=None, version=2)

初始化随机数生成器。

如果 a 被省略或为 None ，则使用当前系统时间。 如果操作系统提供随机源，则使用它们而不是系统时间（有关可用性的详细信息，请参阅 os.urandom() 函数）。

如果 a 是 int 类型，则直接使用。

对于版本2（默认的），str 、 bytes 或 bytearray 对象转换为 int 并使用它的所有位。

对于版本1（用于从旧版本的Python再现随机序列），用于 str 和 bytes 的算法生成更窄的种子范围。

在 3.2 版更改: 已移至版本2方案，该方案使用字符串种子中的所有位。

---

random.getstate()

返回捕获生成器当前内部状态的对象。 这个对象可以传递给 setstate() 来恢复状态。

---

random.setstate(state)

state 应该是从之前调用 getstate() 获得的，并且 setstate() 将生成器的内部状态恢复到 getstate() 被调用时的状态。

---

random.getrandbits(k)

返回带有 k 位随机的Python整数。 此方法随 MersenneTwister 生成器一起提供，其他一些生成器也可以将其作为API的可选部分提供。 如果可用，getrandbits() 启用 randrange() 来处理任意大范围。

---

整数用函数

random.randrange(stop)

---

random.randrange(start, stop[, step])

从 range(start, stop, step) 返回一个随机选择的元素。 这相当于 choice(range(start, stop, step)) ，但实际上并没有构建一个 range 对象。

位置参数模式匹配 range() 。不应使用关键字参数，因为该函数可能以意外的方式使用它们。

在 3.2 版更改: randrange() 在生成均匀分布的值方面更为复杂。 以前它使用了像int(random()*n)这样的形式，它可以产生稍微不均匀的分布。

---

random.randint(a, b)

返回随机整数 N 满足 a <= N <= b。相当于 randrange(a, b+1)。

>>> random.randint(1, 9)
8
>>> random.randint(1, 9)
2

---

序列用函数

random.choice(seq)

从非空序列 seq 返回一个随机元素。 如果 seq 为空，则引发 IndexError。

>>> a = [1,2,3,4]
>>> random.choice(a)         # 随机选择
2
>>> random.choice(a)
4

---

random.choices(population, weights=None, *, cum_weights=None, k=1)

从population中选择替换，返回大小为 k 的元素列表。 如果 population 为空，则引发 IndexError。

如果指定了 weight 序列，则根据相对权重进行选择。 或者，如果给出 cum_weights 序列，则根据累积权重（可能使用 itertools.accumulate() 计算）进行选择。 例如，相对权重[10, 5, 30, 5]相当于累积权重[10, 15, 45, 50]。 在内部，相对权重在进行选择之前会转换为累积权重，因此提供累积权重可以节省工作量。

如果既未指定 weight 也未指定 cum_weights ，则以相等的概率进行选择。 如果提供了权重序列，则它必须与 population 序列的长度相同。 一个 TypeError 指定了 weights 和cum_weights。

The weights or cum_weights can use any numeric type that interoperates with the float values returned by random() (that includes integers, floats, and fractions but excludes decimals).

对于给定的种子，具有相等加权的 choices() 函数通常产生与重复调用 choice() 不同的序列。 choices() 使用的算法使用浮点运算来实现内部一致性和速度。 choice() 使用的算法默认为重复选择的整数运算，以避免因舍入误差引起的小偏差。

3.6 新版功能.

---

random.shuffle(x[, random])

将序列 x 随机打乱位置。

可选参数 random 是一个0参数函数，在 [0.0, 1.0) 中返回随机浮点数；默认情况下，这是函数 random() 。

要改变一个不可变的序列并返回一个新的打乱列表，请使用sample(x, k=len(x))。

请注意，即使对于小的 len(x)，x 的排列总数也可以快速增长，大于大多数随机数生成器的周期。 这意味着长序列的大多数排列永远不会产生。 例如，长度为2080的序列是可以在 Mersenne Twister 随机数生成器的周期内拟合的最大序列。

---

random.sample(population, k)

返回从总体序列或集合中选择的唯一元素的 k 长度列表。 用于无重复的随机抽样。

返回包含来自总体的元素的新列表，同时保持原始总体不变。 结果列表按选择顺序排列，因此所有子切片也将是有效的随机样本。 这允许抽奖获奖者（样本）被划分为大奖和第二名获胜者（子切片）。

总体成员不必是 hashable 或 unique 。 如果总体包含重复，则每次出现都是样本中可能的选择。

要从一系列整数中选择样本，请使用 range() 对象作为参数。 对于从大量人群中采样，这种方法特别快速且节省空间：sample(range(10000000), k=60) 。

如果样本大小大于总体大小，则引发 ValueError 。

实值分布
以下函数生成特定的实值分布。如常用数学实践中所使用的那样, 函数参数以分布方程中的相应变量命名;大多数这些方程都可以在任何统计学教材中找到。

---

random.random()

返回 [0.0, 1.0) 范围内的下一个随机浮点数。

>>> random.random()
0.040939188343120714

---

random.uniform(a, b)

返回一个随机浮点数 N ，当 a <= b 时 a <= N <= b ，当 b < a 时 b <= N <= a 。

取决于等式 a + (b-a) * random() 中的浮点舍入，终点 b 可以包括或不包括在该范围内。

---

random.triangular(low, high, mode)

返回一个随机浮点数 N ，使得 low <= N <= high 并在这些边界之间使用指定的 mode 。 low 和 high 边界默认为零和一。 mode 参数默认为边界之间的中点，给出对称分布。

---

random.betavariate(alpha, beta)

Beta 分布。 参数的条件是 alpha > 0 和 beta > 0。 返回值的范围介于 0 和 1 之间。

---

random.expovariate(lambd)

指数分布。 lambd 是 1.0 除以所需的平均值，它应该是非零的。 （该参数本应命名为 “lambda” ，但这是 Python 中的保留字。）如果 lambd 为正，则返回值的范围为 0 到正无穷大；如果 lambd 为负，则返回值从负无穷大到 0。

---

random.gammavariate(alpha, beta)

Gamma 分布。 （ 不是 gamma 函数！ ） 参数的条件是 alpha > 0 和 beta > 0。

概率分布函数是:

          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha

---

random.gauss(mu, sigma)

高斯分布。 mu 是平均值，sigma 是标准差。 这比下面定义的 normalvariate() 函数略快。

---

random.lognormvariate(mu, sigma)

对数正态分布。 如果你采用这个分布的自然对数，你将得到一个正态分布，平均值为 mu 和标准差为 sigma 。 mu 可以是任何值，sigma 必须大于零。

---

random.normalvariate(mu, sigma)

正态分布。 mu 是平均值，sigma 是标准差。

---

random.vonmisesvariate(mu, kappa)

mu 是平均角度，以弧度表示，介于0和 2pi 之间，kappa 是浓度参数，必须大于或等于零。 如果 kappa 等于零，则该分布在0到 2pi 的范围内减小到均匀的随机角度。

---

random.paretovariate(alpha)

帕累托分布。 alpha 是形状参数。

---

random.weibullvariate(alpha, beta)

威布尔分布。 alpha 是比例参数，beta 是形状参数。

---

替代生成器

class random.Random([seed])
。该类实现了 random 模块所用的默认伪随机数生成器。

---

class random.SystemRandom([seed])

使用 os.urandom() 函数的类，用从操作系统提供的源生成随机数。 这并非适用于所有系统。 也不依赖于软件状态，序列不可重现。 因此，seed() 方法没有效果而被忽略。 getstate() 和 setstate() 方法如果被调用则引发 NotImplementedError。