python3 数字的基本方法用法
Python3 数字（Number)
python 数字数据类型用于存储数值。
数据类型是不允许改变的，这就意味着如果改变数字数据类型的值，将重新分配内存空间。
以下实例在变量赋值时 Number 对象将被创建：
var1 = 1
var2 = 10
您也可以使用del 语句删除一些数字对象的引用。
del 语句的语法是：
del var1[,var2[,var3[....,varN]]]
您可以通过使用del 语句删除单个或多个对象的引用，例如：
del var
del var_a, var_b
Python 支持三种不同的数值类型：
- 整型(Int) - 通常被称为是整型或者整数，是正或负整数，不带小数点。Python3 整型是没有限制大小 的，可以当作Long类型使用，所以Python3 没有 Python2 的Long类型。
- 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学技术法标识（2.5e2 = 2.2 x 10** = 250）
- 复数(complex) - 复数由实数部分和虚数部分构成，可以用a + bj，或者complex(a,b)表示，复数的实部a和虚部b都是浮点型。
我们可以使用十六进制和八进制来代表整数：
>>> number = 0xA0F # 十六进制
>>> number
2575
>>> number=0o37 # 八进制
>>> number
31
| int | float | complex |
|---|---|---|
| 10 | 0.0 | 3.14j |
| 100 | 15.20 | 45.j |
| -786 | -21.9 | 9.322e-36j |
| 080 | 32.3e+18 | .876j |
| -0490 | -90. | -.6545+0J |
| -0x260 | -32.54e100 | 3e+26J |
| 0x69 | 70.2E-12 | 4.53e-7j |
- Python 支持复数，复数由实数部分和虚数部分构成，可以用a + bj，或者complex(a,b)表示是，复数的实部a和虚部b都是浮点型。
Python 数字类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
- int(x) 将x转换成一个整数
- float(x) 将x转换成一个浮点数。
- complex(x) 将x转换到一个复数，实数部分为x， 虚数部分为0。
- complex(x, y) 将x和 y 转换到一个复数，实数部分为x， 虚数部分为 y 。 x 和 y 是数字 表达式。
以下实例将浮点数变量a 转换为整数：
>>> a = 1.0
>>> int(a)
1
Python 数字运算
Python 解释器可以作为一个简单的计算器，您可以在解释器里输入一个表达式，它将输出表达式的 值。
表达式的语法和指标：+，-，* 和 / ，和其它语言（如Pascal或c）里一样。例如：
>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5 # 总是返回一个浮点数
1.6
**注意：**在不同的机器上浮点运算的结果可能会不一样。
在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符//:
>>> 17 / 3 # 整数除法返回浮点型
5.666666666666667
>>>
>>> 17 // 3 # 整数除法返回向下取整后的结果
5
>>> 17 % 3 # ％操作符返回除法的余数
2
>>> 5 * 3 + 2
17
注意：//得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。
>>> 7//2
3
>>> 7.0//2
3.0
>>> 7//2.0
3.0
>>>
等号=用于给变量赋值。赋值之后，除了下一个提示符，解释器不会显示任何结果。
>>> width = 20
>>> height = 5*9
>>> width * height
900
Python可以使用**操作来进行幂运算：
>>> 5 ** 2 # 5 的平方
25
>>> 2 ** 7 # 2的7次方
128
变量在使用前必须先”定义“（即赋予变量一个值），否则会出现错误：
>>> n # 尝试访问一个未定义的变量
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined
不同类型的数混合运算时会将整数转换为浮点数：
>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5
在交互模式中，最后被输出的表达式结果被赋值给变量_。例如：
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
此处，_变量应被用户视为变量
数字函数
abs(x)
描述
abs()函数返回数字的绝对值。
语法
以下是abs()方法的语法：
abs(x)参数
- x – 数值表达式，可以是整数，浮点数，复数。
返回值
函数返回x (数字)的绝对值，如果参数是一个复数，则返回它的大小。
实例
以下展示了使用abs()方法的实例：
print ("abs(-40) : ", abs(-40)) print ("abs(100.10) : ", abs(100.10))以上实例运行后输出结果为：
abs(-40) : 40 abs(100.10) : 100.1Python fabs() 与 abs() 区别
Python 中 fabs(x) 方法返回X的绝对值。虽然类似于abs()函数，但是两个函数之间存在以下差异：
- abs() 是一个内置函数，而fabs() 在 math 模块中定义的。
- fabs() 函数只适用于float 和 integer 类型，而abs()也适用于复数。
实例：
#!/usr/bin/python # -*- coding: UTF-8 -*- import math a = -1 b = -1.3232 c = b d = 1+1.0j e = 3+4.0j print "a的绝对值是:", abs(a) print "b的绝对值是:", abs(b) print "c的绝对值是:", math.fabs(c) print "d的的绝对值是:", abs(d) """print "e的绝对值是:", math.fabs(e) """最后一行代码如果去掉注释就会编译报错：
TypeError: can't convert complex to float // fabs 无法将复数转换为浮点型Python3.x 测试代码：
import math a = -1 b = -1.3232 c = b d = 1+1.0j e = 3+4.0j print "a的绝对值是:",abs(a)) print("b的绝对值是:",abs(b)) print("c的绝对值是:",math.fabs(c)) print("d的的绝对值是:",abs(d)) """print("e的绝对值是:",math.fabs(e))"""
ceil(x)
描述
ceil(x)函数返回一个大于或等于 x 的最小整数。
语法
以下是ceil()方法的语法：
import math math.ceil( x )注意：ceil()是不能直接访问的，需要导入math模块，通过静态对象调用该方法。
参数
x – 数值表达式。
返回值
函数返回一个大于或等于 X 的最小整数。
实例
以下展示了使用ceil()方法的实例:
import math # 导入 math 模块 print ("math.ceil(-45.17) : ", math.ceil(-45.17)) print ("math.ceil(100.12) : ", math.ceil(100.12)) print ("math.ceil(100.72) : ", math.ceil(100.72)) print ("math.ceil(math.pi) : ", math.ceil(math.pi))以上实例运行后输出结果为：
math.ceil(-45.17) : -45 math.ceil(100.12) : 101 math.ceil(100.72) : 101 math.ceil(math.pi) : 4
cmp(x, y)
如果 x < y 返回-1，如果 x == y 返回 0，如果 x > y 返回 1。Python 3 已废弃，使用(x>y)-(x<y)替换。
exp(x)
描述
exp() 方法返回x 的指数,e的x次方。
语法
以下是exp() 方法的语法：
import math math.exp( x )注意：exp() 是不能直接访问的，需要导入math模块，通过静态对象调用该方法。
参数
- x – 数值表达式。
返回值
返回 x 的指数，ex。
返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
实例
以下展示了使用exp()方法的实例：
import math # 导入 math 模块 print ("math.exp(-45.17) : ", math.exp(-45.17)) print ("math.exp(100.12) : ", math.exp(100.12)) print ("math.exp(100.72) : ", math.exp(100.72)) print ("math.exp(math.pi) : ", math.exp(math.pi))以上实例运行后输出结果为：
math.exp(-45.17) : 2.4150062132629406e-20 math.exp(100.12) : 3.0308436140742566e+43 math.exp(100.72) : 5.522557130248187e+43 math.exp(math.pi) : 23.140692632779267
fabs(x)
描述
fabs() 方法返回数字的绝对值，如 math.fabs(-10) 返回 10.0。
fabs()函数类似于abs()函数，但是他有两点区别：
- abs()是内置函数。fabs() 函数在math模块中定义。
- fabs() 函数只对浮点型跟整型数值有效。abs()还可以运行在复数中。
语法
以下是fabs()方法的语法：
import math math.fabs( x )注意：fabs()是不能直接访问的，需要导入math 模块，通过静态对象调用该方法。
参数
- x – 数值表达式。
返回值
返回数字的绝对值。
实例
以下展示了使用fabs()方法的实例：
import math # 导入 math 模块 print ("math.fabs(-45.17) : ", math.fabs(-45.17)) print ("math.fabs(100.12) : ", math.fabs(100.12)) print ("math.fabs(100.72) : ", math.fabs(100.72)) print ("math.fabs(math.pi) : ", math.fabs(math.pi))以上实例运行后输出结果为：
math.fabs(-45.17) : 45.17 math.fabs(100.12) : 100.12 math.fabs(100.72) : 100.72 math.fabs(math.pi) : 3.141592653589793
floor(x)
描述
floor(x) 返回数字的下舍整数，小于或等于x。
语法
以下是floor()方法的语法：
import math math.floor( x )注意：floor()是不能直接访问的，需要导入math模块，通过静态对象调用该方法。
参数
- x – 数值表达式。
返回值
返回小于或等于x的整数。
实例
以下展示了使用floor()方法的实例：
import math # 导入 math 模块 print ("math.floor(-45.17) : ", math.floor(-45.17)) print ("math.floor(100.12) : ", math.floor(100.12)) print ("math.floor(100.72) : ", math.floor(100.72)) print ("math.floor(math.pi) : ", math.floor(math.pi))以上实例运行后输出结果为：
math.floor(-45.17) : -46 math.floor(100.12) : 100 math.floor(100.72) : 100 math.floor(math.pi) : 3
log(x)
描述
log() 方法返回x 的自然对数，x>0。
语法
以下是log()方法的语法：
import math math.log( x )注意：log()是不能直接访问的，需要导入math模块，通过静态对象调用该方法。
参数
- x – 数值表达式。
返回值
返回x的自然对数，x>0.
实例
以下展示了使用log()方法的实例：
import math # 导入 math 模块 print ("math.log(100.12) : ", math.log(100.12)) print ("math.log(100.72) : ", math.log(100.72)) print ("math.log(math.pi) : ", math.log(math.pi))以上实例运行后输出结果为：
math.log(100.12) : 4.6063694665635735 math.log(100.72) : 4.612344389736092 math.log(math.pi) : 1.1447298858494002
log10(x)
描述
log10()方法返回以10为基数的x对数，x>0。
语法
以下是log10()方法的语法：
import math math.log10( x )注意：log10()是不能直接访问的，需要导入math 模块，通过静态对象调用该方法。
参数
- x – 数值表达式。
返回值
返回以10为基数的x对数，x>0。
实例
以下展示了使用log10()方法的实例：
import math # 导入 math 模块 print ("math.log10(100.12) : ", math.log10(100.12)) print ("math.log10(100.72) : ", math.log10(100.72)) print ("math.log10(119) : ", math.log10(119)) print ("math.log10(math.pi) : ", math.log10(math.pi))以下实例运行后输出结果为：
math.log10(100.12) : 2.0005208409361854 math.log10(100.72) : 2.003115717099806 math.log10(119) : 2.075546961392531 math.log10(math.pi) : 0.4971498726941338
max(x1, x2, …)
描述
max()方法返回给定参数的最大值，参数可以为序列。
语法
以下是max()方法的语法：
max( x, y, z, .... )参数
- x – 数值表达式。
- y – 数值表达式。
- z – 数值表达式。
返回值
返回给定参数的最大值。
实例
以下展示了使用max()方法的实例：
print ("max(80, 100, 1000) : ", max(80, 100, 1000)) print ("max(-20, 100, 400) : ", max(-20, 100, 400)) print ("max(-80, -20, -10) : ", max(-80, -20, -10)) print ("max(0, 100, -400) : ", max(0, 100, -400))以上实例运行后输出结果为：
max(80, 100, 1000) : 1000 max(-20, 100, 400) : 400 max(-80, -20, -10) : -10 max(0, 100, -400) : 100
min(x1,x2,…)
描述
min()方法返回给定参数 的最小值，参数可以为序列。
语法
以下 是min()方法的 语法：
min( x, y, z, .... )参数
- x – 数值表达式。
- y – 数值表达式。
- z – 数值表达式。
返回值
返回给定参数的最小值。
实例
以下展示了使用min()方法的实例：
print ("min(80, 100, 1000) : ", min(80, 100, 1000)) print ("min(-20, 100, 400) : ", min(-20, 100, 400)) print ("min(-80, -20, -10) : ", min(-80, -20, -10)) print ("min(0, 100, -400) : ", min(0, 100, -400))以上实例运行后输出结果为：
min(80, 100, 1000) : 80 min(-20, 100, 400) : -20 min(-80, -20, -10) : -80 min(0, 100, -400) : -400
modf(x)
描述
modf()方法返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
语法
以下是modf()方法的语法：
import math math.modf( x )注意：modf()是不能直接访问的，需要导入math模块，通过静态对象调用该方法。
参数
- x – 数值表达式。
返回值
返回x的整数部分与小数部分，
实例
以下展示了使用modf()方法的实例：
import math # 导入 math 模块 print ("math.modf(100.12) : ", math.modf(100.12)) print ("math.modf(100.72) : ", math.modf(100.72)) print ("math.modf(119) : ", math.modf(119)) print ("math.modf(math.pi) : ", math.modf(math.pi))以上实例运行后输出结果为：
math.modf(100.12) : (0.12000000000000455, 100.0) math.modf(100.72) : (0.7199999999999989, 100.0) math.modf(119) : (0.0, 119.0) math.modf(math.pi) : (0.14159265358979312, 3.0)
pow(x, y)
描述
pow()方法返回 x^y (x的y次方) 的值。
语法
以下是math模块pow()方法的语法：
import math math.pow( x, y )内置的pow()方法
pow(x, y[, z])函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y)%z
注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而math模块则会把参数转换为float。
参数
- x – 数值表达式。
- y – 数值表达式。
- z – 数值表达式。
返回值
返回x^y（x的y次方）的值。
实例
以下展示了使用pow()方法的实例：
import math # 导入 math 模块 print ("math.pow(100, 2) : ", math.pow(100, 2)) # 使用内置，查看输出结果区别 print ("pow(100, 2) : ", pow(100, 2)) print ("math.pow(100, -2) : ", math.pow(100, -2)) print ("math.pow(2, 4) : ", math.pow(2, 4)) print ("math.pow(3, 0) : ", math.pow(3, 0))以上实例运行后输出结果为：
math.pow(100, 2) : 10000.0 pow(100, 2) : 10000 math.pow(100, -2) : 0.0001 math.pow(2, 4) : 16.0 math.pow(3, 0) : 1.0
round(x[,n])
描述
round()方法返回浮点数x的四舍五入值，准确的说保留值将保留到离上一位更近的一端（四舍六入）。
语法
以下是round()方法的语法:
round( x [, n] )参数
- x – 数字表达式。
- n – 表示从小数点位数，其中x需要四舍五入，默认值为0。
返回值
返回浮点数x的四舍五入值。
实例
以下展示了使用round()方法的实例：
print ("round(70.23456) : ", round(70.23456)) print ("round(56.659,1) : ", round(56.659,1)) print ("round(80.264, 2) : ", round(80.264, 2)) print ("round(100.000056, 3) : ", round(100.000056, 3)) print ("round(-100.000056, 3) : ", round(-100.000056, 3))以上实例运行后输出结果为：
round(70.23456) : 70 round(56.659,1) : 56.7 round(80.264, 2) : 80.26 round(100.000056, 3) : 100.0 round(-100.000056, 3) : -100.0看下官网给的一个例子：
>>> round(2.675, 2) 2.67按我们的想法返回结果应该是2.68，可结果却是2.67，为什么？
这跟浮点数的精度有关。我们知道在机器中浮点数不一定能精确表达，因为换算成一串 1 和 0 后可能是无限位数的，机器已经做出了截断处理。那么在机器中保存的2.675这个数字就比实际数字要小那么一点点。这一点点就导致了它离2.67要更近一点点，所以保留两位小数时就近似到了2.67。
sqrt(x)
描述
sqrt()方法发那会数字x的平方根。
语法
以下是sqrt()方法的语法：
import math math.sqrt( x )注意：sqrt()是不能直接访问的，需要导入math模块，通过静态对象调用该方法。
参数
- x – 数值表达式。
返回值
返回数字x 的平方根。
实例
以下展示了使用sqrt()方法的实例：
import math # 导入 math 模块 print ("math.sqrt(100) : ", math.sqrt(100)) print ("math.sqrt(7) : ", math.sqrt(7)) print ("math.sqrt(math.pi) : ", math.sqrt(math.pi))以上实例运行后输出结果为：
math.sqrt(100) : 10.0 math.sqrt(7) : 2.6457513110645907 math.sqrt(math.pi) : 1.7724538509055159
随机数函数
随机数可以用于数字，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序 的安全性。
Python 包含以下常用随机数函数：
choice(seq)
描述
choice()方法返回一个列表，元组或字符串的随机想项。
语法
以下是choice()方法的语法:
import random random.choice( seq )注意：choice()是不能直接访问的，需要导入random模块，然后通过random静态对象调用该方法。
参数
- seq – 可以是一个列表，元组或字符串。
返回值
返回随机项 。
实例
以下展示了使用choice()方法的实例：
import random print ("从 range(100) 返回一个随机数 : ",random.choice(range(100))) print ("从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 : ", random.choice([1, 2, 3, 5, 9])) print ("从字符串中 'Runoob' 返回一个随机字符 : ", random.choice('Runoob'))以上实例运行后输出结果为：
从 range(100) 返回一个随机数 : 68 从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 : 2 从字符串中 'Runoob' 返回一个随机字符 : u
randrange([start,]stop[,step])
描述
randrange()方法返回指定递增基数集合中的一个随机数，基数默认值为1。
语法
以下是randrange()方法的语法：
import random random.randrange ([start,] stop [,step])注意：randrange()是不能直接访问的，需要导入random模块，然后通过random静态对象调用该方法。
参数
- start – 指定范围内的开始值，包含在范围内。
- stop – 指定范围内的结束值，不包含在范围内。
- step – 指定递增基数。
返回值
从给定的范围返回随机项。
实例
以下展示了使用randrange()方法的实例：
import random # 从 1-100 中选取一个奇数 print ("randrange(1,100, 2) : ", random.randrange(1, 100, 2)) # 从 0-99 选取一个随机数 print ("randrange(100) : ", random.randrange(100))以上实例运行后输出结果为：
randrange(1,100, 2) : 97 randrange(100) : 42
random()
描述
random()方法返回随机生成的一个实数，它在[0,1]范围内。
语法
以下是random()方法的语法：
import random random.random()注意：random()是不能直接访问的，需要导入random模块，然后通过random静态对象调用该方法。
参数
- 无
返回值
返回随机生成的一个实数，它在[0,1]范围内。
实例
以下展示了使用random()方法的实例：
import random # 第一个随机数 print ("random() : ", random.random()) # 第二个随机数 print ("random() : ", random.random())以上实例运行后输出结果为：
random() : 0.09690599908884856 random() : 0.8732120512570916
seed([x])
描述
seed()方法改变随机数生成器的种子，可以在调用其他随机模块函数之前调用此函数。
语法
以下是seed()方法的语法：
import random random.seed ( [x] )我们调用random.random()生成随机数时，每一次生成的数都是随机的。但是，当我们预先使用random.seed(x)设定好种子之后，其中的x可以是任意数字，如10，这个时候，先调用它的情况下，使用random()生成的对技术将会是同一个。
注意：seed()是不能直接访问的，需要导入random模块，然后通过random静态对象调用该方法。
参数
- x – 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
返回值
本函数没有返回值。
实例
以下展示了使用seed()方法的实例：
import random random.seed() print ("使用默认种子生成随机数：", random.random()) print ("使用默认种子生成随机数：", random.random()) random.seed(10) print ("使用整数 10 种子生成随机数：", random.random()) random.seed(10) print ("使用整数 10 种子生成随机数：", random.random()) random.seed("hello",2) print ("使用字符串种子生成随机数：", random.random())以上实例运行后输出结果为：
使用默认种子生成随机数： 0.7908102856355441 使用默认种子生成随机数： 0.81038961519195 使用整数 10 种子生成随机数： 0.5714025946899135 使用整数 10 种子生成随机数： 0.5714025946899135 使用字符串种子生成随机数： 0.3537754404730722
shuffle(lst)
描述
shuffle() 方法将序列的所有元素随机排序。
语法
以下是shuffle()方法的语法：
import random random.shuffle (lst )注意：shuffle()是不能直接访问的，需要导入random模块，然后通过random静态对象调用该方法。
参数
- lst – 列表
返回值
返回None。
实例
以下展示了使用shuffle()方法的实例：
import random list = [20, 16, 10, 5]; random.shuffle(list) print ("随机排序列表 : ", list) random.shuffle(list) print ("随机排序列表 : ", list)以上实例运行后输出结果为：
随机排序列表 : [20, 5, 16, 10] 随机排序列表 : [5, 20, 10, 16]
uniform(x, y)
描述
uniform() 方法将随机生成下一个实数，它在
[x,y]范围内。语法
以下是uniform()方法的语法：
import random random.uniform(x, y)注意：uniform()是不能直接访问的，需要导入random模块，然后通过random静态对象调用该方法。
参数
- x – 随机数的最小值。
- y – 随机数的最大值。
返回值
返回一个浮点数N，取值范围为如果x<y 则 x <= N <= y, 如果y<x 则 y <= N <= x。
实例
以下展示了使用uniform()方法的实例：
import random print ("uniform(5, 10) 的随机浮点数 : ", random.uniform(5, 10)) print ("uniform(7, 14) 的随机浮点数 : ", random.uniform(7, 14))以上实例运行后输出结果为：
uniform(5, 10) 的随机浮点数 : 7.054602800254241 uniform(7, 14) 的随机浮点数 : 12.552229882744296
三角函数
Python包括以下三角函数：
acos(x)
描述
acos()返回x的反余弦弧度值。
语法
以下是acos()方法的语法：
import math math.acos(x)注意：acos()是不能直接访问的，需要导入math模块，然后通过math静态对象调用该方法。
参数
- x – 1到1之间的数值。如果x是大于1，会产生一个错误。
返回值
返回x的反余弦弧度值。
实例
以下展示了使用acos()方法的实例：
import math print ("acos(0.64) : ", math.acos(0.64)) print ("acos(0) : ", math.acos(0)) print ("acos(-1) : ", math.acos(-1)) print ("acos(1) : ", math.acos(1))以上实例运行后输出结果为：
acos(0.64) : 0.8762980611683406 acos(0) : 1.5707963267948966 acos(-1) : 3.141592653589793 acos(1) : 0.0
asin(x)
描述
asin()返回x的反正弦弧度值。
语法
以下是asin()方法的语法：
import math math.asin(x)注意：asin()是不能直接访问的，需要导入math模块，然后通过math静态对象调用该方法。
参数
- x – 1到1之间的数值。如果x是大于1，会产生一个错误。
返回值
返回x的反正弦弧度值。
**实例 **
以下展示了使用asin() 方法的实例：
imp ort math print ("asin(0.64) : ", math.asin(0.64)) print ("asin(0) : ", math.asin(0)) print ("asin(-1) : ", math.asin(-1)) print ("asin(1) : ", math.asin(1))以上实例运行后输出结果为：
asin(0.64) : 0.694498265626556 asin(0) : 0.0 asin(-1) : -1.5707963267948966 asin(1) : 1.5707963267948966
atan(x)
描述
atan() 返回x的反正弦 弧度值。
语法
以下是atan()方法的语法：
import math math.atan(x)注意：atan()是不能直接访问的，需要导入math模块，然后通过math静态对象调用该方法。
参数
- x – 一个数值。
返回值
返回x的反正切弧度值。
实例
以下展示了使用atan()方法 的实例：
import math print ("atan(0.64) : ", math.atan(0.64)) print ("atan(0) : ", math.atan(0)) print ("atan(10) : ", math.atan(10)) print ("atan(-1) : ", math.atan(-1)) print ("atan(1) : ", math.atan(1))以上实例运行后输出结果为：
atan(0.64) : 0.5693131911006619 atan(0) : 0.0 atan(10) : 1.4711276743037347 atan(-1) : -0.7853981633974483 atan(1) : 0.7853981633974483
atan2(y, x)
描述
atan2()返回给定的x及y坐标值的反正切值。
**语法 **
以下是atan2()方法的语法：
import math math.atan2(y, x)注意：atan2()是不能直 访问的，需要导入math模块，然后通过math静态对象调用该方法。
参数
- x – 一个数值
- y – 一个数值
返回值
返回给定的x及y坐标 值的反正切值。
实例
以下展示了使用atan2()方法的实例:
import math print ("atan2(-0.50,-0.50) : ", math.atan2(-0.50,-0.50)) print ("atan2(0.50,0.50) : ", math.atan2(0.50,0.50)) print ("atan2(5,5) : ", math.atan2(5,5)) print ("atan2(-10,10) : ", math.atan2(-10,10)) print ("atan2(10,20) : ", math.atan2(10,20))以上实例运行后输出去结果为：
atan2(-0.50,-0.50) : -2.356194490192345 atan2(0.50,0.50) : 0.7853981633974483 atan2(5,5) : 0.7853981633974483 atan2(-10,10) : -0.7853981633974483 atan2(10,20) : 0.4636476090008061
cos(x)
描述
cos()返回x的弧度的余弦值。
语法
以下是cos()方法的语法:
import math math.cos(x)注意：cos()是不能直接访问的，需要导入math模块，然后通过math 静态对象调用该方法。
参数
- x – 一个数值
返回值
返回x的弧度的余弦值，-1到1之间。
实例
以下展示了使用cos()方法的实例：
import math print ("cos(3) : ", math.cos(3)) print ("cos(-3) : ", math.cos(-3)) print ("cos(0) : ", math.cos(0)) print ("cos(math.pi) : ", math.cos(math.pi)) print ("cos(2*math.pi) : ", math.cos(2*math.pi))以上实例运行后输出结果为：
cos(3) : -0.9899924966004454 cos(-3) : -0.9899924966004454 cos(0) : 1.0 cos(math.pi) : -1.0 cos(2*math.pi) : 1.0
hypot(x, y)
描述
hypot()返回欧几里德范数 sqrt(x * x + y * y )。
语法
以下是hypot()方法的语法：
import math math.hypot(x, y)注意：hypot()是不能直接访问的，需要导入math模块，然后通过math静态对象调用该方法。
参数
- x – 一个数值
- y – 一个数值
返回值
返回欧几里德范数 sqrt(x * x + y * y)。
实例
以下展示了使用hypot()方法的 实例：
import math print ("hypot(3, 2) : ", math.hypot(3, 2)) print ("hypot(-3, 3) : ", math.hypot(-3, 3)) print ("hypot(0, 2) : ", math.hypot(0, 2))以上实例运行后输出结果为：
hypot(3, 2) : 3.605551275463989 hypot(-3, 3) : 4.242640687119285 hypot(0, 2) : 2.0
sin(x)
描述
sin() 返回的x弧度的正弦值。
语法
以下是sin()方法的语法：
import math math.sin(x)注意：sin()是不能直接访问的，需要导入math模块，然后通过math静态对象调用该方法。
参数：
- x – 一个数值
返回值
返回的x弧度的正弦值，数值在-1 到 1 之间。
实例
以下展示了使用sin()方法的实例：
import math print ("sin(3) : ", math.sin(3)) print ("sin(-3) : ", math.sin(-3)) print ("sin(0) : ", math.sin(0)) print ("sin(math.pi) : ", math.sin(math.pi)) print ("sin(math.pi/2) : ", math.sin(math.pi/2))以上实例运行后输出结果为：
sin(3) : 0.1411200080598672 sin(-3) : -0.1411200080598672 sin(0) : 0.0 sin(math.pi) : 1.2246467991473532e-16 sin(math.pi/2) : 1.0
tan(x)
描述
tan() 返回 x 弧度的正切值。
语法
以下是tan() 方法的语法：
import math math.tan(x)注意：tan()是不能直接访问的，需要导入math模块，然后通过math静态对象调用该方法。
参数
- x – 一个数值。
返回值
返回x 弧度的正切值，数值在-1到1之间。
实例
以下展示了使用tan()方法的实例：
import math print ("(tan(3) : ", math.tan(3)) print ("tan(-3) : ", math.tan(-3)) print ("tan(0) : ", math.tan(0)) print ("tan(math.pi) : ", math.tan(math.pi)) print ("tan(math.pi/2) : ", math.tan(math.pi/2)) print ("tan(math.pi/4) : ", math.tan(math.pi/4))以上实例运行后输出结果为：
(tan(3) : -0.1425465430742778 tan(-3) : 0.1425465430742778 tan(0) : 0.0 tan(math.pi) : -1.2246467991473532e-16 tan(math.pi/2) : 1.633123935319537e+16 tan(math.pi/4) : 0.9999999999999999
degrees(x)
描述
degrees() 将弧度转换为角度。
语法
以下是degrees()方法的语法：
import math math.degrees(x)注意：degrees()是不能直接访问的，需要导入math模块，然后通过math静态对象调用该方法。
参数
- x – 一个数值。
返回值
返回一个角度值。
实例
以下展示了使用degrees()方法的实例:
import math print ("degrees(3) : ", math.degrees(3)) print ("degrees(-3) : ", math.degrees(-3)) print ("degrees(0) : ", math.degrees(0)) print ("degrees(math.pi) : ", math.degrees(math.pi)) print ("degrees(math.pi/2) : ", math.degrees(math.pi/2)) print ("degrees(math.pi/4) : ", math.degrees(math.pi/4))以上实例运行后输出结果为：
degrees(3) : 171.88733853924697 degrees(-3) : -171.88733853924697 degrees(0) : 0.0 degrees(math.pi) : 180.0 degrees(math.pi/2) : 90.0 degrees(math.pi/4) : 45.0
radians(x)
描述
randians()方法阿静角度转换为弧度。
角度和弧度关系是：2π 弧度 = 360°。从而 1°≈0.0174533 弧度，1 弧度≈57.29578°。
- 角度转换为弧度公式：弧度=角度÷180×π
- 2)弧度转换为角度公式： 角度=弧度×180÷π
语法
以下是radians()方法的语法：
import math math.radians(x)**注意：**radians()是不能直接访问的，需要导入 math 模块，然后通过 math 静态对象调用该方法。
参数
- x – 一个角度数值，默认单位是角度°。
返回值
返回一个角度的弧度值。
实例
以下展示了使用radians()方法的实例：
import math print ("radians(90) : ", math.radians(90)) # 1 弧度等于大概 57.3° print ("radians(45) : ", math.radians(45)) print ("radians(30) : ", math.radians(30)) print ("radians(180) : ", math.radians(180)) # 180 度的弧度为 π print("180 / pi : ", end ="") print (math.radians(180 / math.pi))以上实例运行后输出结果为：
radians(90) : 1.5707963267948966 radians(45) : 0.7853981633974483 radians(30) : 0.5235987755982988 radians(180) : 3.141592653589793 180 / pi : 1.0
数字常量
pi
数字常量 pi （圆周率，一般以TT来表示）
e
数字常量 e ，e 即自然常数（自然常数）。
365
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
