Python基本数据类型（一）——Number(数字)

Number(数字)

数据类型不允许改变，如果改变数字数据类型的值，将重新分配内存空间

一、 四种基本类型

类型
int (整数)	整数类型只有一种 int，不带小数点，没有大小限制，也可以用8进制（0o）或16进制（0x）表示
bool (布尔)	是 int 的子类，True 和 False 可以和数字相加，True = 1，False = 0
float (浮点数)	如 1.23、3E-2
complex (复数)	由实部和虚部构成，可以用a + bj,或者complex(a,b)表示，实部a和虚部b都是浮点型，如 1 + 2j、 1.1 + 2.2j

代码示例：

a1,a2,a3,a4 = 1,-1,0o37,-0x080      #0o代表8进制，0x代表16进制
b1,b2,b3,b4 = 0.0,90.,12.0E-2,1.2e+2
c1,c2,c3,c4 = 3.14j,1.2e+2j,-.1+0J,1.2e-2j
d1,d2 = True,False
print(a1,a2,a3,a4)
print(b1,b2,b3,b4)
print(c1,c2,c3,c4)
print(d1,d2)



"""
输出结果：
1 -1 31 -128
0.0 90.0 0.12 120.0
3.14j 120j (-0.1+0j) 0.012j
True False
"""

---

二、 数值运算

运算符号：

符号	意义
+	加
-	减
*	乘
\	除，得到浮点数
\ \	除，向下取整，但是得到的并不一定是整数类型，它与分母分子的数据类型有关系
%	取余
**	乘方

代码示例：

print(5 + 2)
print(5 - 2)
print(5 * 2)
print(5 / 2)
print(5 // 2)
print(5 // 2.0)
print(5 % 2)
print(5 ** 2)		#5的平方



"""
输出结果：
7
3
10
2.5
2
2.0
1
25
"""

tips：

1. 变量在使用前必须先"定义"（即赋予变量一个值）
2. 混合计算时，会把整型转换成为浮点数

---

在交互模式中，最后被输出的表达式结果被赋值给变量 _
此处， _ 变量应被用户视为只读变量

代码示例：

tax = 12.5 / 100
price = 100.50
print(price * tax)
print(price + _)
print(round(_, 2))



'''
输出结果：
12.5625
113.0625
113.06
'''

---

三、 删除操作

使用del语句

1. 删除一些数字对象的引用

del a[,b[,c[…,z]]]

2. 单个或多个对象的引用

del a,b

代码示例：

a = 10
b = 20
c = 30
del b,c		#删除b、c
print(a)
print(b,c)

输出结果：

在输出10（a的值）后会报错：NameError: name ‘b’ is not defined

由上述代码可知，b、c已经被删除

---

四、 数字类型转换

数据类型的转换，将目标数据类型作为函数名即可

函数名	作用
int(x)	将x转换为一个整数
float(x)	将x转换到一个浮点数
complex(x)	将x转换到一个复数，实数部分为 x，虚数部分为 0
complex(x, y)	将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式

int(x [,base])

int() 函数用于将一个字符串或数字转换为整型

class int(x, base=10)

• 参数：
  x：字符串或数字
  base = n：n为进制数，默认n=10，即十进制
• 返回值：
  整型数据

代码示例：

a1 = int()               # 不传入参数时，得到结果0
a2 = int(2)
a3 = int(3.9)           #向下取整
a4 = int('12',16)        # 带参数base,x以字符串的形式进行输入,12为16进制
a5 = int('0xa',16)        # 带参数base,x以字符串的形式进行输入,16为16进制
a6 = int('10',8)        # 带参数base,x以字符串的形式进行输入,10为8进制
print(a1,a2,a3,a4,a5,a6)



'''
输出结果：
0 2 3 18 10 8
'''

---

float(x)

用于将整数和字符串转换成浮点数

class float([x])

• 参数：
  x：整数或字符串
• 返回值：
  返回浮点数

代码示例：

a0 = float()
a1 = float(1)
a2 = float(2)
a3 = float(-3.3)
a4 = float('444')     # 字符串
print(a0,a1,a2,a3,a4)



'''
输出结果：
0.0 1.0 2.0 -3.3 444.0
'''

---

complex(real [,imag])

用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数
如果第一个参数为字符串，则不需要指定第二个参数

class complex([real[, imag]])

• 参数：
  real：int, long, float 或 字符串
  imag ： int, long, float
• 返回值：
  返回一个复数

代码示例：

a0 = complex()
a1 = complex(1,2)
a2 = complex(1.1)  # 数字
a3 = complex("1")  # 当做字符串处理
a4 = complex("12")
a5 = complex("1+2j")# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
print(a0)
print(a1)
print(a2)
print(a3)
print(a4)
print(a5)



'''
输出结果：
0j
(1+2j)
(1.1+0j)
(1+0j)
(12+0j)
(1+2j)
'''

---

五、 数学常量

常量	描述
pi	数学常量 pi（圆周率，一般以π来表示）
e	数学常量 e，e即自然常数（自然常数）

代码示例：

from math import pi			#导入
from math import e

print(pi)
print(e)

'''
输出结果：
3.141592653589793
2.718281828459045
'''

---

六、 数学函数

不能直接访问的函数需要导入 math 模块：import math
除了abs()、round()，都需要导入math模块
pow(x, y) 可根据所需类型选择是否导入math模块（内置把参数作为整型，math将参数作为浮点型）

函数	作用（返回值）
abs(x)	返回数字的绝对值
fabs(x)	返回 x 的绝对值
ceil(x)	返回一个≥ x的的整数，向上取整
floor(x)	返回一个≤x的整数，向下取整
round(x [,n])	四舍五入
cmp(x, y)	x < y返回 -1, x == y 返回 0, x > y 返回 1 （ Python 3 已废弃）用 (x>y)-(x<y) 替换
exp(x)	返回x的指数ex
log(x)	返回x的自然对数，x > 0
log10(x)	返回以10为基数的x的对数
max(x1, x2,…)	返回给定参数的最大值，参数可以为序列
min(x1, x2,…)	返回给定参数的最小值，参数可以为序列
modf(x)	返回 x 的小数部分与整数部分，两部分的数值符号与 x 相同，整数部分以浮点型表示
pow(x, y)	返回 xy 的值
sqrt(x)	返回数字x的平方根

abs()

返回数字的绝对值

abs( x )

• 参数
  x ：数值表达式（整数、浮点数、复数）
• 返回值
  函数返回 x（数字）的绝对值，如果参数是一个复数，则返回它的大小

代码示例：

print("abs(1-2) : ", abs(1-2))
print ("abs(-40) : ", abs(-40))
print ("abs(100.10) : ", abs(100.10))
print("abs(1+2j) : ", abs(1+2j))



'''
输出结果：
abs(1-2) :  1
abs(-40) :  40
abs(100.10) :  100.1
abs(1+2j) :  2.23606797749979
'''

---

fabs(x)

类似于 abs() 函数，fabs(x) 方法也是返回 x 的绝对值

区别：

abs()	fabs()
内置函数	在 math 模块中定义
适用于整数、浮点数、复数	只适用于整数、浮点数

注意：fabs()不能直接访问，需要导入 math 模块，通过静态对象调用

import math
math.fabs( x )

• 参数
  x ：数值表达式（整数、浮点数、复数）
• 返回值
  函数返回 x（数字）的绝对值，如果参数是一个复数，则返回它的大小

代码示例：

import math   # 导入 math 模块

print ("math.fabs(1-2) : ", math.fabs(1-2))
print ("math.fabs(-40) : ", math.fabs(-40))
print ("math.fabs(100.10) : ", math.fabs(100.10))
# print ("math.fabs(1+2j) : ", math.fabs(1+2j))   #区别于abs(),fabs()不支持复数


'''
输出结果：
math.fabs(1-2) :  1.0
math.fabs(-40) :  40.0
math.fabs(100.10) :  100.1
'''

---

ceil(x)

返回一个≥ x的的最小整数，向上取整

注意：ceil()不能直接访问，需要导入 math 模块，通过静态对象调用

import math
math.ceil( x )

• 参数
  x ：数值表达式（整数、浮点数、复数）
• 返回值
  返回一个≥ x 的的最小整数

代码示例：

import math   # 导入 math 模块

print ("math.ceil(-3.4) : ", math.ceil(-3.4))
print ("math.ceil(6.1) : ", math.ceil(6.1))
print ("math.ceil(6.6) : ", math.ceil(6.6))
print ("math.ceil(math.pi) : ", math.ceil(math.pi))



'''
输出结果：
math.ceil(-3.4) :  -3
math.ceil(6.1) :  7
math.ceil(6.6) :  7
math.ceil(math.pi) :  4
'''

floor(x)

返回≤x的整数，向下取整

注意：floor(x) 不能直接访问，需要导入 math 模块，通过静态对象调用

import math
math.floor( x )

• 参数
  x ：数值表达式（整数、浮点数）
• 返回值
  返回≤x的整数，向下取整

代码示例：

import math   # 导入 math 模块

print ("math.floor(-1.1) : ", math.floor(-1.1))
print ("math.floor(3.1) : ", math.floor(3.1))
print ("math.floor(3.9) : ", math.floor(3.9))



'''
输出结果：
math.floor(-1.1) :  -2
math.floor(3.1) :  3
math.floor(3.9) :  3
'''

---

round(x [,n])

四舍五入

机器中浮点数不一定能精确表达，换算成一串 1 和 0 后可能是无限位数的，机器已经做出了截断处理，因此准确度不高

round( x [, n] )

• 参数
  x ：数字表达式。
  n ：四舍五入的小数点位数，默认值为 0
• 返回值
  四舍五入后的值

代码示例：

print ("round(1.1) : ", round(1.1))
print ("round(1.9) : ", round(1.9))
print ("round(1.12345678,3) : ", round(1.12345678,3))
print ("round(1.12345678,5) : ", round(1.12345678,5))



'''
输出结果：
round(1.1) :  1
round(1.9) :  2
round(1.12345678,3) :  1.123
round(1.12345678,5) :  1.12346
'''

---

exp(x)

返回x的指数e^x

注意：exp()不能直接访问，需要导入 math 模块，通过静态对象调用

import math
math.exp( x )

• 参数
  x ：数值表达式（整数、浮点数、复数）
• 返回值
  返回x的指数e^x

代码示例：

import math   # 导入 math 模块

print ("math.exp(-1) : ", math.exp(-1))
print ("math.exp(1) : ", math.exp(1))
print ("math.exp(1.1) : ", math.exp(1.1))
print ("math.exp(100) : ", math.exp(100))
print ("math.exp(math.pi) : ", math.exp(math.pi))



'''
输出结果：
math.exp(-1) :  0.36787944117144233
math.exp(1) :  2.718281828459045
math.exp(1.1) :  3.0041660239464334
math.exp(100) :  2.6881171418161356e+43
math.exp(math.pi) :  23.140692632779267
'''

---

log(x)

返回x的自然对数，x > 0

注意：log(x)不能直接访问，需要导入 math 模块，通过静态对象调用

import math
math.log( x )

• 参数
  x ：数值表达式
• 返回值
  返回x的自然对数，x>0

代码示例：

import math   # 导入 math 模块

print ("math.log(math.exp(5)) : ", math.log(math.exp(5)))
print ("math.log(100.72) : ", math.log(100.72))
print ("math.log(100) : ", math.log(10))



'''
输出结果：
math.log(math.exp(5)) :  5.0
math.log(100.72) :  4.612344389736092
math.log(100) :  2.302585092994046
'''

---

log10(x)

返回以10为基数的x的对数

注意：log10(x)不能直接访问，需要导入 math 模块，通过静态对象调用

import math
math.log10( x )

• 参数
  x ：数值表达式
• 返回值
  返回以10为基数的x的对数，x>0

代码示例：

import math   # 导入 math 模块

print ("math.log10(1000) : ", math.log10(10000))
print ("math.log10(8) : ", math.log10(8))
print ("math.log10(100.2) : ", math.log10(1000.2))



'''
输出结果：
math.log10(1000) :  4.0
math.log10(8) :  0.9030899869919435
math.log10(100.2) :  3.000086850211649
'''

---

max(x1, x2,…)

返回给定参数的最大值，参数可以为序列

max( x, y, z, … )

• 参数
  x ：数值表达式
  y ：数值表达式
  z ：数值表达式

• 返回值
  返回给定参数的最大值

代码示例：

print ("max(80, 100, 1000) : ", max(80, 100, 1000))
print ("max(-20, 100, 400) : ", max(-20, 100, 400))



'''
输出结果：
max(80, 100, 1000) :  1000
max(-20, 100, 400) :  400
'''

---

min(x1, x2,…)

返回给定参数的最小值，参数可以为序列

min( x, y, z, … )

• 参数
  x ：数值表达式
  y ：数值表达式
  z ：数值表达式

• 返回值
  返回给定参数的最小值

代码示例：

print ("min(80, 100, 1000) : ", min(80, 100, 1000))
print ("min(-20, 100, 400) : ", min(-20, 100, 400))



'''
输出结果：
min(80, 100, 1000) :  80
min(-20, 100, 400) :  -20
'''

---

modf(x)

返回 x 的小数部分与整数部分，两部分的数值符号与 x 相同，整数部分以浮点型表示

注意：modf(x) 不能直接访问，需要导入 math 模块，通过静态对象调用

import math
math.modf( x )

• 参数
  x ： 数值表达式
• 返回值
  返回x的小数部分与整数部分

代码示例：

import math

print ("math.modf(100.12) : ", math.modf(100.1))
print ("math.modf(100.72) : ", math.modf(6.6))
print ("math.modf(119) : ", math.modf(1))
print ("math.modf(math.pi) : ", math.modf(math.pi))



'''
输出结果：
math.modf(100.12) :  (0.09999999999999432, 100.0)
math.modf(100.72) :  (0.5999999999999996, 6.0)
math.modf(119) :  (0.0, 1.0)
math.modf(math.pi) :  (0.14159265358979312, 3.0)

'''

---

pow(x, y)

返回 x^y 的值

注意：

1. pow() 通过内置的方法直接调用，内置方法把参数作为整型
2. math 模块把参数转换为 float

• 内置的 pow() 方法
  pow(x, y[, z])
  先计算 x^y，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z
• import math
  math.pow( x, y )

• 参数
  x ：数值表达式
  y ：数值表达式
  z ：数值表达式
• 返回值
  返回 x^y 的值

代码示例：

import math   # 导入 math 模块

print ("pow(100, 2) : ", pow(100, 2))# 使用内置，查看输出结果区别
print ("math.pow(100, 2) : ", math.pow(100, 2))

print ("math.pow(100, -2) : ", math.pow(10, -2))
print ("math.pow(2, 4) : ", math.pow(2, 4))
print ("math.pow(3, 0) : ", math.pow(3, 0))



'''
输出结果：
pow(100, 2) :  10000
math.pow(100, 2) :  10000.0
math.pow(100, -2) :  0.01
math.pow(2, 4) :  16.0
math.pow(3, 0) :  1.0
'''

---

sqrt(x)

返回数字x的平方根

注意：sqrt()不能直接访问，需要导入 math 模块，通过静态对象调用

import math
math.sqrt( x )

• 参数
  x ：数值表达式
• 返回值
  返回数字x的平方根

代码示例：

import math  # 导入 math 模块

print("math.sqrt(100) : ", math.sqrt(100))
print("math.sqrt(7) : ", math.sqrt(4))



'''
输出结果：
math.sqrt(100) :  10.0
math.sqrt(7) :  2.0
'''

---

七、 随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性

函数	描述
choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

choice(seq)

从序列seq的元素中随机挑选一个元素

注意：choice()不能直接访问，需要导入 random 模块，通过 random 静态对象调用

import random
random.choice( seq )

• 参数
  seq ： 可以是一个列表，元组或字符串

• 返回值
  从序列seq的元素中随机挑选一个元素

代码示例：

import random

print ("从 range(100) 返回一个随机数 : ",random.choice(range(100)))
print ("从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 : ", random.choice([1, 2, 3, 5, 9]))
print ("从字符串中 'Hello World' 返回一个随机字符 : ", random.choice('Hello World'))



'''
输出结果：
#第一次运行
从 range(100) 返回一个随机数 :  19
从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 :  3
从字符串中 'Hello World' 返回一个随机字符 :  l

#第二次运行
从 range(100) 返回一个随机数 :  2
从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 :  3
从字符串中 'Hello World' 返回一个随机字符 :  r
'''

---

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

从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1

注意：randrange()不能直接访问，需要导入 random 模块，通过 random 静态对象调用

import random
random.randrange ([start,] stop [,step])
[]参数可以省略

• 参数
  范围：[start,stop)
  start ：指定范围内的开始值，包含在范围内
  stop ：指定范围内的结束值，不包含在范围内
  step ：指定递增基数

• 返回值
  返回指定递增基数集合中的一个随机数

代码示例：

import random

# 从 1-100 中选取一个奇数
print("从 1-100 中选取一个奇数 - randrange(1,100, 2) : ", random.randrange(1, 100, 2))
# 从 1-100 中选取一个偶数
print("从 1-100 中选取一个偶数 - randrange(0,100, 2) : ", random.randrange(0, 100, 2))

# 从 0-100 中选取一个5的倍数
print("从 0-100 中选取一个5的倍数 - randrange(0,100, 5) : ", random.randrange(0, 100, 5))

# 从 0-100 中选取一个10的倍数
print("从 0-100 中选取一个10的倍数 - randrange(0,100, 10) : ", random.randrange(0, 100, 10))

# 从 0-99 选取一个随机数
print("从 0-99 选取一个随机数 - randrange(100) : ", random.randrange(100))



'''
输出结果：
#第一次运行
从 1-100 中选取一个奇数 - randrange(1,100, 2) :  95
从 1-100 中选取一个偶数 - randrange(0,100, 2) :  64
从 0-100 中选取一个5的倍数 - randrange(0,100, 5) :  75
从 0-100 中选取一个10的倍数 - randrange(0,100, 10) :  70
从 0-99 选取一个随机数 - randrange(100) :  59

#第二次运行
从 1-100 中选取一个奇数 - randrange(1,100, 2) :  69
从 1-100 中选取一个偶数 - randrange(0,100, 2) :  86
从 0-100 中选取一个5的倍数 - randrange(0,100, 5) :  15
从 0-100 中选取一个10的倍数 - randrange(0,100, 10) :  30
从 0-99 选取一个随机数 - randrange(100) :  9
'''

---

random()

在[0,1)范围内随机生成一个实数

注意：random()不能直接访问，需要导入 random 模块，通过 random 静态对象调用

import random
random.random()

• 参数
  无参数
• 返回值
  返回[0,1)范围内随机生成的一个实数

代码示例：

import random

# 第一个随机数
print ("[0,1)范围内的随机数 - random() : ", random.random())


# 第二个随机数
print ("[0,100)范围内的随机数 - 100 * random() : ", random.random() * 100)
print ("[0,100)范围内的随机整数 - 100 * random() : ", int(random.random() * 100))
print ("[10,100)范围内的随机整数 - (100 * random() + 10) : ", int(random.random() * 100 + 10 ))



'''
输出结果：
#第一次运行
[0,1)范围内的随机数 - random() :  0.45891700127033763
[0,100)范围内的随机数 - 100 * random() :  43.66635324114735
[0,100)范围内的随机整数 - 100 * random() :  26
[10,100)范围内的随机整数 - (100 * random() + 10) :  52

#第二次运行
[0,1)范围内的随机数 - random() :  0.695584731761969
[0,100)范围内的随机数 - 100 * random() :  12.36738508897739
[0,100)范围内的随机整数 - 100 * random() :  64
[10,100)范围内的随机整数 - (100 * random() + 10) :  35
'''

---

seed([x])

改变随机数生成器的种子seed，可以在调用其他随机模块函数之前调用此函数
（如果不了解其原理，不必特别去设定seed，Python会帮忙选择seed）

我们调用 random.random() 生成随机数时，每一次生成的数都是随机的。但是，当我们预先使用 random.seed(x) 设定好种子之后，其中的 x 可以是任意数字，如10，这个时候，先调用它的情况下，使用 random() 生成的随机数将会是同一个。

注意：seed()不能直接访问，需要导入 random 模块，通过 random 静态对象调用

import random
random.seed ( [x] )

调用 random.random() 生成随机数时，每一次生成的数都是随机的。但是，当预先使用 random.seed(x) 设定好种子之后（x 可以是任意数字），如10，这个时候，先调用它的情况下，使用 random() 生成的随机数将会是同一个

• 参数
  x ： 改变 随机数生成器random() 的种子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.8726260274738153
使用默认种子生成随机数： 0.6264429425808272
使用整数 10 种子生成随机数： 0.5714025946899135
使用整数 10 种子生成随机数： 0.5714025946899135
使用字符串种子生成随机数： 0.3537754404730722

#第二次运行
使用默认种子生成随机数： 0.529689373355667
使用默认种子生成随机数： 0.5102080210309986
使用整数 10 种子生成随机数： 0.5714025946899135
使用整数 10 种子生成随机数： 0.5714025946899135
使用字符串种子生成随机数： 0.3537754404730722
'''

---

shuffle(lst)

将序列的所有元素随机排序

注意：shuffle() 不能直接访问，需要导入 random 模块，通过 random 静态对象调用

import random
random.shuffle (lst )

• 参数
  lst ：列表
• 返回值
  没有返回值

代码示例：

import random

list = [20, 16, 10, 5];
random.shuffle(list)
print("第一次随机排序列表 : ", list)
random.shuffle(list)
print("第二次随机排序列表 : ", list)



'''
输出结果：
#第一次运行
第一次随机排序列表 :  [20, 16, 10, 5]
第二次随机排序列表 :  [10, 5, 16, 20]

#第二次运行
第一次随机排序列表 :  [5, 16, 10, 20]
第二次随机排序列表 :  [20, 5, 10, 16]
'''

---

uniform(x, y)

在[x,y]范围内随机生成下一个实数

注意：uniform()不能直接访问，需要导入 random 模块，通过 random 静态对象调用

import random
random.uniform(x, y)

• 参数
  范围[x,y]
  x ： 随机数的最小值，包含该值
  y ： 随机数的最大值，包含该值

• 返回值
  返回一个[x,y]范围内的浮点数 N

代码示例：

import random

print("uniform(5, 10) 的随机浮点数 : ", random.uniform(5, 10))

print("uniform(1, 3) 的随机浮点数 : ", random.uniform(1, 3))



'''
输出结果：
#第一次运行
uniform(5, 10) 的随机浮点数 :  7.706819723161358
uniform(1, 3) 的随机浮点数 :  2.65807090127158

#第二次运行
uniform(5, 10) 的随机浮点数 :  5.586430560664185
uniform(1, 3) 的随机浮点数 :  2.9197159129977774
'''

---

八、 三角函数

函数	描述
sin(x)	返回的x弧度的正弦值
cos(x)	返回x的弧度的余弦值
tan(x)	返回x弧度的正切值
asin(x)	返回x的反正弦弧度值
acos(x)	返回x的反余弦弧度值
atan(x)	返回x的反正切弧度值
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值
hypot(x, y)	返回欧几里德范数 sqrt(xx + yy)
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)	将角度转换为弧度