Number(数字)

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

一、 四种基本类型

代码示例：

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
"""

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

---

二、 数值运算

运算符号：

代码示例：

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
"""

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22

tips：

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

---

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

代码示例：

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



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

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

---

三、 删除操作

使用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)

• 1
• 2
• 3
• 4
• 5
• 6
• 7

输出结果：

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

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

---

四、 数字类型转换

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

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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

---

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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

---

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)
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24

---

五、 数学常量

代码示例：

from math import pi			#导入
from math import e

print(pi)
print(e)

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

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

---

六、 数学函数

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

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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

---

fabs(x)

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

区别：

注意：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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

---

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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

---

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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

---

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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

---

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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

---

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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

---

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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

---

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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

---

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)

'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

---

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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19

---

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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

---

七、 随机数函数

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

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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20

---

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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34

---

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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27

---

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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32

---

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]
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20

---

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
'''

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

---

八、 三角函数