目录
suibi

divmod函数(python中divmod函数是什么意思)


Python69个内置函数介绍

内置函数就是Python预先定义的函数,这些内置函数使用方便,无需导入,直接调用,大大提高使用者的工作效率,也更便于程序的阅读。截止到Python版本3.9.1,Python一共提供了69个内置函数。

如果你还没入门,或刚刚入门Python,那么,这篇文章非常适合你。为了方便记忆,木木老师会将这些内置函数分类介绍给大家。

  • 数学运算(7个)
  • 类型转换(24个)
  • 序列操作(8个)
  • 对象操作(9个)
  • 反射操作(8个)
  • 变量操作(2个)
  • 交互操作(2个)
  • 文件操作(1个)
  • 编译执行(5个)
  • 装饰器(3个)

数学运算(7个)

abs:求数值的绝对值

print(abs(-2)) # 绝对值:2

divmod:返回两个数值的商和余数

print(divmod(20,3)) # 求商和余数:(6,2)

max:返回可迭代对象中的元素中的最大值或者所有参数的最大值

print(max(7,3,15,9,4,13)) #求最大值:15

min:返回可迭代对象中的元素中的最小值或者所有参数的最小值

print(min(5,3,9,12,7,2)) #求最小值:2

pow:返回两个数值的幂运算值或其与指定整数的模值

print(pow(10,2,3)) # 如果给了第三个参数. 表示最后取余:1

round:对浮点数进行四舍五入求值

print(round(2.675, 2)) # 五舍六入:2.67

sum:对元素类型是数值的可迭代对象中的每个元素求和

print(sum([1,2,3,4,5,6,7,8,9,10])) # 求和:55

类型转换(24个)

bool:根据传入的参数的逻辑值创建一个新的布尔值

print(bool(0)) # 数值0、空序列等值为:False

int:根据传入的参数创建一个新的整数

print(int(3.6)) # 整数:3

float:根据传入的参数创建一个新的浮点数

print(float (3)) # 浮点数:3.0

complex:根据传入参数创建一个新的复数

print(complex (1,2)) # 复数:1+2j

str:将数据转化为字符串

print(str(123)+'456') #123456

bytearray:根据传入的参数创建一个新的字节数组

ret = bytearray("alex" ,encoding ='utf-8')
print(ret[0]) #97
print(ret) #bytearray(b'alex')
ret[0] = 65 #把65的位置A赋值给ret[0]
print(str(ret)) #bytearray(b'Alex')

bytes:根据传入的参数创建一个新的不可变字节数组

bs = bytes("今天吃饭了吗", encoding="utf-8")
print(bs) #b'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\x90\x83\xe9\xa5\xad\xe4\xba\x86\xe5\x90\x97'

memoryview:根据传入的参数创建一个新的内存查看对象

v = memoryview(b'abcefg')
print(v[1]) # 98

ord:返回Unicode字符对应的整数

print(ord('中')) # '中'字在编码表中的位置:20013

chr:返回整数所对应的Unicode字符

print(chr(65)) # 已知码位求字符:A

bin:将整数转换成2进制字符串

print(bin(10)) # 二进制:0b1010

oct:将整数转化成8进制数字符串

print(oct(10)) # 八进制:0o12

hex:将整数转换成16进制字符串

print(hex(10)) # 十六进制:0xa

tuple:根据传入的参数创建一个新的元组

print(tuple([1,2,3,4,5,6])) # (1, 2, 3, 4, 5, 6)

list:根据传入的参数创建一个新的列表

print(list((1,2,3,4,5,6))) # [1, 2, 3, 4, 5, 6]

dict:根据传入的参数创建一个新的字典

print(dict(a = 1,b = 2)) # 创建字典: {'b': 2, 'a': 1}

range:根据传入的参数创建一个新的range对象

for i in range(15,-1,-5):
print(i)
# 15
# 10
# 5
# 0

set:根据传入的参数创建一个新的集合

a = set(range(10))
print(a) # 创建集合:{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

frozenset:根据传入的参数创建一个新的不可变集合

a = frozenset(range(10))
print(a) #frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

enumerate:根据可迭代对象创建枚举对象

lst = ['one','two','three','four','five']
for index, el in enumerate(lst,1): # 把索引和元素一起获取,索引默认从0开始. 可以更改
print(index)
print(el)
# 1
# one
# 2
# two
# 3
# three
# 4
# four
# 5
# five

iter:根据传入的参数创建一个新的可迭代对象

lst = [1, 2, 3]
for i in iter(lst):
print(i)
# 1
# 2
# 3

slice:根据传入的参数创建一个新的切片对象

lst = "你好啊"
it = reversed(lst) # 不会改变原列表. 返回一个迭代器, 设计上的一个规则
print(list(it)) #['啊', '好', '你']
lst = [1, 2, 3, 4, 5, 6, 7]
print(lst[1:3:1]) #[2,3]
s = slice(1, 3, 1) # 切片用的
print(lst[s]) #[2,3]

super:根据传入的参数创建一个新的子类和父类关系的代理对象

class A:
def add(self, x):
y = x+1
print(y)
class B(A):
def add(self, x):
super().add(x)
b = B()
b.add(2) # 3

object:创建一个新的object对象

class A:
pass
print(issubclass(A,object)) #默认继承object类 # True

print(dir(object))
# ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

序列操作(8个)

all:判断可迭代对象的每个元素是否都为True值

print(all([1,'hello',True,9])) #True

any:判断可迭代对象的元素是否有为True值的元素

print(any([0,0,0,False,1,'good'])) #True

filter:使用指定方法过滤可迭代对象的元素

def is_odd(n):
return n % 2 == 1

newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist) # [1, 3, 5, 7, 9]

map:使用指定方法去作用传入的每个可迭代对象的元素,生成新的可迭代对象

def f(i):
return i
lst = [1,2,3,4,5,6,7,]
it = map(f, lst) # 把可迭代对象中的每一个元素传递给前面的函数进行处理. 处理的结果会返回成迭代器
print(list(it)) #[1, 2, 3, 4, 5, 6, 7]

next:返回可迭代对象中的下一个元素值

it = iter([1, 2, 3, 4, 5])
while True:
try:
x = next(it)
print(x)
except StopIteration:
break
# 1
# 2
# 3
# 4
# 5

reversed:反转序列生成新的可迭代对象

print(list(reversed([1,2,3,4,5]))) # [5, 4, 3, 2, 1]

sorted:对可迭代对象进行排序,返回一个新的列表

a = [5,3,4,2,1]
print(sorted(a,reverse=True)) # [5, 4, 3, 2, 1]

zip:聚合传入的每个迭代器中相同位置的元素,返回一个新的元组类型迭代器

my_list = [11,12,13]
my_tuple = (21,22,23)

print(list(zip(my_list,my_tuple))) # [(11, 21), (12, 22), (13, 23)]

对象操作(9个)

help:返回对象的帮助信息

print(help(str)) #查看字符串的用途

dir:返回对象或者当前作用域内的属性列表

print(dir(tuple)) #查看元组的方法

id:返回对象的唯一标识符

s = 'alex'
print(id(s)) # 139783780730608

hash:获取对象的哈希值

s = 'alex'
print(hash(s)) #-168324845050430382
lst = [1, 2, 3, 4, 5]
print(hash(lst)) #报错,列表是不可哈希的

type:返回对象的类型,或者根据传入的参数创建一个新的类型

dict = {'Name': 'Zara', 'Age': 7}
print("Variable Type : %s" % type (dict)) # Variable Type : <type 'dict'>

len:返回对象的长度

mylist = ["apple", "orange", "cherry"]
x = len(mylist)
print(x) # 3

ascii:返回对象的可打印表字符串表现方式

s = 5
print(ascii(s)) # 5
format:格式化显示值
s = "hello world!"
print(format(s, "^20")) #居中
print(format(s, "<20")) #左对齐
print(format(s, ">20")) #右对齐
# hello world!
# hello world!
# hello world!

vars:返回当前作用域内的局部变量和其值组成的字典,或者返回对象的属性列表

class Person:
name = "John"
age = 36
country = "norway"
x = vars(Person)
print(x)
# {'__module__': '__main__', 'name': 'Bill', 'age': 63, 'country': 'USA', '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

反射操作(8个)

__import__:动态导入模块

import os
name = input("请输入你要导入的模块:")
__import__(name) # 可以动态导入模块

isinstance:判断对象是否是类或者类型元组中任意类元素的实例

arg=123
print(isinstance(arg, int)) # 输出True

issubclass:判断类是否是另外一个类或者类型元组中任意类元素的子类

class A:
pass
class B(A):
pass

print(issubclass(B,A)) # 返回 True

hasattr:检查对象是否含有属性

class Coordinate:
x = 10
y = -5
z = 0

point1 = Coordinate()
print(hasattr(point1, 'x'))
print(hasattr(point1, 'y'))
print(hasattr(point1, 'z'))
print(hasattr(point1, 'no')) # 没有该属性
# True
# True
# True
# False

getattr:获取对象的属性值

class Person():
age = 14

Tom = Person()
print(getattr(Tom,'age')) # 14

setattr:设置对象的属性值

class A():
name = "吊车尾"

a = A()
setattr(a, "age", 24)
print(a.age) # 24

delattr:删除对象的属性

class Person:
def __init__(self, name, age):
self.name = name
self.age = age
tom = Person("Tom", 35)
print(dir(tom)) # ['__doc__', '__init__', '__module__', 'age', 'name']
delattr(tom, "age")
print(dir(tom)) # ['__doc__', '__init__', '__module__', 'name']s

callable:检测对象是否可被调用

a = 10
print(callable(a)) #False 变量a不能被调用

变量操作(2个)

globals:返回当前作用域内的全局变量和其值组成的字典

x = 'hello'
a = 8888888
print(globals()) #返回一个全局变量的字典,包括所有导入的变量x,a
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000000000212C2B0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/Pythonproject/111/global.py', '__cached__': None, 'x': 'hello', 'a': 8888888}

locals:返回当前作用域内的局部变量和其值组成的字典

print(locals())
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x10ab79358>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/pankaj/Documents/github/journaldev/Python-3/basic_examples/python_locals_example.py', '__cached__': None}

交互操作(2个)

print:向标准输出对象打印输出

print(1,2,3) # 1 2 3

input:读取用户输入值

a = input('请输入你的姓名') #输入:张三
print(a) # 张三

文件操作(1个)

open:使用指定的模式和编码打开文件,返回文件读写对象

f = open('file',mode='r',encoding='utf-8')
f.read()
f.close()

编译执行(5个)

compile:将字符串编译为代码或者AST对象,使之能够通过exec语句来执行或者eval进行求值

code = "for i in range(3): print(i)"
com = compile(code, "", mode="exec")
exec(com)
# 0
# 1
# 2

eval:执行动态表达式求值

code = "5+6+7"
com = compile(code, "", mode="eval")
print(eval(com)) # 18

exec:执行动态语句块

s = "for i in range(5): print(i)"
a = exec(s)
# 0
# 1
# 2
# 3
# 4

repr:返回一个对象的字符串表现形式(给解释器)

class test:
def __init__(self,name,age):
self.age = age
self.name = name
def __repr__(self):
return "Class_Test[name="+self.name+",age="+str(self.age)+"]"
t = test("Zhou",30)

print(t) # Class_Test[name=Zhou,age=30]

breakpoint:暂停脚本的执行,允许在程序的内部手动浏览

装饰器(3个)

property:标示属性的装饰器

class C:
def __init__(self):
self._name = ''
@property
def name(self):
"""i'm the 'name' property."""
return self._name
@name.setter
def name(self,value):
if value is None:
raise RuntimeError('name can not be None')
else:
self._name = value

classmethod:标示方法为类方法的装饰器

class C:
@classmethod
def f(cls,arg1):
print(cls)
print(arg1)

staticmethod:标示方法为静态方法的装饰器

class Student(object):
def __init__(self,name):
self.name = name
@staticmethod
def sayHello(lang):
print(lang)
if lang == 'en':
print('Welcome!')
else:
print('你好!')

另附数学math模块55个函数详解

Python math 模块提供了许多对浮点数的数学运算函数。主要框架包括

  • 数论与表示函数
  • 幂函数与对数函数
  • 三角函数
  • 角度转换
  • 双曲函数
  • 特殊函数
  • 常量
import math
print(dir(math))
[ 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']

注意:上面的函数是不能直接访问的,需要导入 math 模块,通过静态对象调用该方法。

数论与表示函数

ceil()

描述:向上取整数,返回 x 的上限,即大于或者等于 x 的最小整数

语法:math.ceil(x)

import math#需要导入数学模块
math.ceil(5.1)
6
math.ceil(5.0)
5
math.ceil(5.8)
6

copysign()

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

语法:math.copysign(x, y)

math.copysign(1,-1)
-1.0

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

math.copysign(-1,1)
1.

fabs()

描述:返回数字的绝对值

语法:math.fabs( x )

math.fabs(-45.17)
45.17

math.fabs(100)
100.0

math.fabs(math.pi)
3.14159265358979

factorial()

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

语法:math.factorial( x )

math.factorial(5)#1*2*3*4*5
120
math.factorial(3)#1*2*3
6

floor()

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

语法:math.floor( x )

math.floor(1.2)
1
math.floor(1.99)
1

fmod()

描述:返回余数,函数 fmod() 在使用浮点数时通常是首选,而Python的 x % y 在使用整数时是首选。

语法:math.fmod(x, y)

math.fmod(10, 3)
1.0

math.fmod(8, 3)
2.0

math.fmod(8.2, 3)
2.199999999999999

frexp()

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

语法:math.frexp(x)

math.frexp(32)
(0.5, 6)

fsum()

描述:对迭代器里的每个元素进行求和操作,返回迭代中的精确浮点值。通过跟踪多个中间部分和来避免精度损失

语法:math.fsum( x )

math.fsum((1,2,3,4))
10.0

math.fsum([1,2,3,4])
10.0

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

gcd()

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

语法:math.gcd( x,y)

math.gcd(12,6)
6
math.gcd(15,25)
5

isclose()

描述:若 a 和 b 的值比较接近则返回 True,否则返回 False。根据给定的绝对和相对容差确定两个值是否被认为是接近的。

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

  • 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 只被认为接近自己。

math.isclose(1.0,1.0000000000001)
True

math.isclose(1.0,1.000000001)
False

isfinite()

描述:如果 x 既不是无穷大也不是NaN,则返回 True ,否则返回 False 。 (注意 0.0 被认为 是 有限的。)

语法:math.isfinite(x)

math.isfinite(2)
True
math.isfinite(math.nan)
False
math.isfinite(math.inf)
False

isinf()

描述:如果 x 是正或负无穷大,则返回 True ,否则返回 False 。

语法:math.isinf()

math.isinf(math.inf)
True
math.isinf(-math.inf)
True

isnan()

描述:如果 x 是 NaN(不是数字),则返回 True ,否则返回 False 。

语法:math.isnan(x)

math.isnan(math.nan)
True

ldexp()

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

语法:math.ldexp(x, i)

math.ldexp(5, 3)
40.0

5 * (2**3)
40

modf()

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

语法:math.modf(x)

math.modf(3.71828)
(0.71828, 3.0)

remainder()

描述:返回 IEEE 754 风格的 x 相对于 y 的余数

语法:math.remainder(x, y)

math.remainder(14, 5)
-1.0

math.remainder(13, 5)
-2.0

math.remainder(12, 5)
2.0

math.remainder(11, 5)
1

trunc()

描述:返回 Real 值 x 截断为 Integral (通常是整数)

语法:math.trunc(x)

math.trunc(3.718281828459045)
3

幂函数与对数函数

exp()

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

语法:math.exp( x )

注意:exp()是不能直接访问的,需要导入 math 模块,通过静态对象调用该方法。

math.exp(1)
2.718281828459045

math.exp(0)
1.0

math.exp(3)
20.08553692318766

expm1()

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

语法:math.expm1(x)

math.exp(1e-5) - 1 
1.0000050000069649e-05

math.expm1(1e-5)
1.0000050000166667e-05

math.expm1(1)
1.718281828459045
math.expm1(2)
6.3890560989306

log()

描述:使用一个参数,返回 x 的自然对数(底为 e )。

语法:math.log(x[, base])

参数:

  • x -- 数值表达式。
  • base -- 可选,底数,默认为 e。
math.log(math.e)
1.0

math.log(20)
2.995732273553991

math.log(100,10)#返回以10为底的对数
2.

log1p()

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

语法:math.log1p(x)

math.log1p(1)
0.6931471805599453

log2()

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

语法:math.log2(x)

math.log2(8)
3.0

log10()

描述:返回 x 底为10的对数。这通常比 log(x, 10) 更准确。

语法:math.log10( x )

math.log10(100)
2.0
math.log10(1000)
3.0

pow()

描述:返回 (x的y次方) 的值。与内置的 ** 运算符不同, math.pow() 将其参数转换为 float 类型。使用 ** 或内置的 pow() 函数来计算精确的整数幂。

语法:math.pow( x, y )

math.pow( 2, 4 )
16.0


math.pow( 10, 2 )
100.0

sqrt()

描述:返回数字x的平方根。

语法:math.sqrt( x )

math.sqrt(4) 
2.0


math.sqrt(100) 
10.0


math.sqrt(7) 
2.6457513110645907


math.sqrt(math.pi) 
1.77245385090551

三角函数

acos()

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

语法:math.acos(x)

math.acos(.5)
1.0471975511965979

asin()

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

语法:math.asin(x)

math.asin(.5)
0.5235987755982989

atan()

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

语法:math.atan(x)

math.atan(1)
0.7853981633974483

atan2()

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

语法:math.atan2(y, x)

math.atan2(1, 1)
0.7853981633974483

math.pi/4
0.7853981633974483

cos()

描述:返回 x 弧度的余弦值。

语法:math.cos(x)

math.cos(math.pi/6)
0.8660254037844387

hypot()

描述:返回欧几里德范数, sqrt(x*x + y*y) 。 这是从原点到点 (x, y) 的向量长度。

语法:math.hypot(x, y)

math.hypot(1, 1)
1.4142135623730951

sin()

描述:返回 x 弧度的正弦值。

语法:math.sin(x)

math.sin(math.pi/6)
0.49999999999999994

tan()

描述:返回 x 弧度的正切值。

语法:math.tan(x)

math.tan(math.pi/4)
0.9999999999999999

角度转换

degrees()

描述:将角度 x 从弧度转换为度数。

语法:math.degrees(x)

math.degrees(math.pi)
180.0

math.degrees(3)
171.88733853924697

radians()

描述:将角度 x 从度数转换为弧度。

语法:math.radians(x)

math.radians(180)
3.141592653589793

双曲函数

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

Python69个内置函数介绍

acosh()

描述:返回 x 的反双曲余弦值。

语法:math.acosh(x)

math.acosh(3)
1.762747174039086

asinh()

描述:返回 x 的反双曲正弦值。

语法:math.asinh(x)

math.asinh(1)
0.8813735870195429

atanh()

描述:返回 x 的反双曲正切值。

语法:math.atanh(x)

math.atanh(0.5)
0.5493061443340549

cosh()

描述:返回 x 的双曲余弦值。

语法:math.cosh(x)

math.cosh(2)
3.7621956910836314

sinh()

描述:返回 x 的双曲正弦值。

语法:math.sinh(x)

math.sinh(1)
1.1752011936438014

tanh()

描述:返回 x 的双曲正切值。

语法:math.tanh(x)

math.tanh(3)
0.9950547536867305

特殊函数

erf()

描述:返回 x 处的 error function 。

语法:math.erf(x)

math.erf(1)
0.8427007929497149

erf() 函数可用于计算传统的统计函数,如 累积标准正态分布
def phi(x):
    return (1.0 + erf(x / sqrt(2.0))) / 2.0

erfc()

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

语法:math.erfc(x)

math.erfc(1)
0.1572992070502851

gamma()

描述:返回 x 处的 伽马函数 值。

语法:math.gamma(x)

math.gamma(4)
6.0

lgamma()

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

语法:math.lgamma(x)

math.lgamma(4)
1.7917594692280554

常 量

pi

描述:圆周率。数学常数 π = 3.141592...,精确到可用精度。

语法:math.pi

math.pi
3.141592653589793

e

描述:数学常数 e = 2.718281...,精确到可用精度。

语法:math. e

math.e
2.718281828459045

tau

描述:数学常数 τ = 6.283185...,精确到可用精度。Tau 是一个圆周常数,等于 2π,圆的周长与半径之比

语法:math.tau

math.tau
6.283185307179586

inf

描述:浮点正无穷大。 (对于负无穷大,使用 -math.inf 。)相当于``float('inf')`` 的输出。

语法:math.inf

math.inf
inf

nan

描述:浮点“非数字”(NaN)值。 相当于 float('nan') 的输出。

语法:math.nan

math.nan
nan

写笔记

咨询

您的电子邮箱地址不会被公开。