数据类型是不允许改变的,这就意味着如果改变 Number 数据类型的值，将重新分配内存空间

数值类型

• 整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。
• 浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
• 复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型

整型(int)

在32位机器上，整数的位数为32位，取值范围为-231～231-1，即-2147483648～2147483647

在64位系统上，整数的位数为64位，取值范围为-263～263-1，-9223372036854775808～9223372036854775807

var1 = 1
var2 = 10
var3 = 6

del语句删除一些 Number 对象引用

del var1
del var2, var3

long（长整型）

跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。

注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。

199**200

5896784843701866315830202306247774762972638982405042480372238189012365044783448228280875028875684277127088378956152713197320945688565673304729984010537727226637040943165593052367979000124463424161858464934947067680269075228341562695042312463815883441507512003942871781958205145461989665812045325106145074842960481661294209203262577314061569045152694421556602495323466256365196176516277494056642637786305854049111948156579863012416891273717889898672613595960001

浮点数

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。

整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。

0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1

0.7999999999999999

复数

复数是指能写成如下形式的数a+bi,这里a和b是实数，i是虚数单位(即-1开根)。在复数a+bi中，a称为复数的实部，b称为复数的虚部，i称为虚数单位。当虚部等于零时，这个复数就是实数；当虚部不等于零时，这个复数称为虚数

#复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

complex(1,5)

(1+5j)

有理数

数学上，有理数是一个整数a和一个非零整数b的比，例如3/8，通则为a/b，又称作分数。0也是有理数。有理数是整数和分数的集合，整数也可看做是分母为一的分数。有理数的小数部分是有限或为无限循环的数。不是有理数的实数称为无理数，即无理数的小数部分是无限不循环的数。

无理数

无理数，也称为无限不循环小数，不能写作两整数之比。若将它写成小数形式，小数点之后的数字有无限多个，并且不会循环。 常见的无理数有非完全平方数的平方根、圆周率（Pi）和e

实数

实数，是有理数（有限或为无限循环的数）和无理数（无限不循环小数）的总称。

科学记数法

把一个绝对值大于10的实数记为a×10n的形式(1≤|a|<10，n为整数),这种记数法叫做科学记数法。这是一种记数的方法。例如19971400000000=1.99714×10^13。计算器或电脑表达10的的幂是一般是用E或e，也就是1.99714E13=19971400000000

不同进制表示

• 0o数字 0O数字 表示八进制整数 0o24
• 0x数字 0X数字 表示十六进制整数 0x3F ,0X3F
• 0b数字 0B数字 表示二进制整数 0b101 ， 0B101

数值类型转换

• bin()将整数x转换为二进制字符串
• chr(i) 返回整数i对应的ASCII字符。与ord()作用相反。i取值[0,255]之间的正数
• ord() 一个字符串表示的字符转换为字符相对应的整数
• int() 将一个数转化为整数
• long(x [,base ]) 将x转换为一个长整数
• float(x ) 将x转换到一个浮点数
• complex(real [,imag ]) 创建一个复数
• str() 一般是将数值转成字符串

r = bin(10)
print('将整数10转换为二进制字符串:%s'%r)

c = chr(66)
print('整数66对应的ASCII字符:%s'%c)

i = ord("t")
print('字符t转换对应的整数%s'%i)

r= int(12.0)
print("浮点数12.0转换为整数%s"%r)
print("浮点数12.0转换为整数%d"%r)

print("将0xb用十进制数表示%s"%int("0xb",16))
print("将八进制10用十进制数表示%s"%int("10",8))
print("将字符10用十进制数表示%s"%int("10",16))
print("将字符10用十进制数表示%s"%int("10",10))

a = 1.524464444444444444
b = float('%.4f'%a)
print("控制精度，保留4位小数，结果为：%s"%b)

print('字符37.21转换为浮点数：%s'%float('37.21'))
print('整数234转换为浮点数：%s'%float(234))

print('整数234转换为字符：%s'%str(234))

将整数10转换为二进制字符串:0b1010
整数66对应的ASCII字符:B
字符t转换对应的整数116
浮点数12.0转换为整数12
浮点数12.0转换为整数12
将0xb用十进制数表示11
将八进制10用十进制数表示8
将字符10用十进制数表示16
将字符10用十进制数表示10
控制精度，保留4位小数，结果为：1.5245
字符37.21转换为浮点数：37.21
整数234转换为浮点数：234.0
整数234转换为字符：234

• hex(x) 将一个整数转换为一个十六进制字符串
• oct(x ) 将一个整数转换为一个八进制字符串

print("将整数12转换为十六进制为%s"%hex(2))
print("将整数12转换为八进制为%s"%oct(12))
print("将0xb用十进制数表示%s"%int("82d1",16))

将整数12转换为十六进制为0x2
将整数12转换为八进制为0o14
将0xb用十进制数表示33489

数据类型信息获取

#函数type()，直接给出数的数据类型
print(type(12.0))
print(type(False))
print(type(1000))

<class 'float'>
<class 'bool'>
<class 'int'>

#函数isinstance()需要给出需要判断的数和一个数据类型
print(isinstance('I love u',float))
print(isinstance('I love u',str))

False
True

isinstance 和 type 的区别在于：

• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类型。

class A:
    pass

class B(A):
    pass

print(isinstance(A(), A))

print(type(A()) == A )

print(isinstance(B(), A))
print(type(B()) == A)

print(type(A()))
print(type(B()))

print(type(A()))
print(type(B()))

True
True
True
False
<class '__main__.A'>
<class '__main__.B'>
<class '__main__.A'>
<class '__main__.B'>

math 模块、cmath 模块

Python 中数学运算常用的函数基本都在 math 模块、cmath 模块中。

Python math 模块提供了许多对浮点数的数学运算函数。

Python cmath 模块包含了一些用于复数运算的函数。

cmath 模块的函数跟 math 模块函数基本一致，区别是 cmath 模块运算的是复数，math 模块运算的是数学运算。

import math
# 查看 math 查看包中的内容:
# dir(math)

python数学函数

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1(python3中不存在)
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,…)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,…)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
round(x [,n])	返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x)	返回数字x的平方根

abs(x)

print("abs(-45) : ", abs(-45)) 
print("abs(100.12) : ", abs(100.12))
print("abs(119) : ", abs(119)) 

abs(-45) :  45
abs(100.12) :  100.12
abs(119) :  119

ceil()

import math   # This will import math module

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(119) : ", math.ceil(119)) 
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(119) :  119
math.ceil(math.pi) :  4

cmp()

Python 3.X 的版本中已经没有 cmp 函数，如果你需要实现比较功能，需要引入 operator 模块，适合任何对象，包含的方法有：

• operator.lt(a, b)
• operator.le(a, b)
• operator.eq(a, b)
• operator.ne(a, b)
• operator.ge(a, b)
• operator.gt(a, b)
• operator._lt_(a, b)
• operator._le_(a, b)
• operator._eq_(a, b)
• operator._ne_(a, b)
• operator._ge_(a, b)
• operator._gt_(a, b)

#print("cmp(80, 100) : ", cmp(80, 100))
import operator
print(operator.eq('hello', 'name'))
print(operator.lt(80,100))
print(operator.__lt__(80,100))

False
True
True

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

fabs() 函数类似于 abs() 函数，但是他有两点区别:

• abs() 是内置函数。 fabs() 函数在 math 模块中定义。
• fabs() 函数只对浮点型跟整型数值有效。 abs() 还可以运用在复数中。

import 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()

import 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()

import 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.exp(math.log(100.12))

math.log(100.12) :  4.6063694665635735
math.log(100.72) :  4.612344389736092
math.log(math.pi) :  1.1447298858494002





100.12

log10()

import 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()

print ("max(80, 100, 1000) : ", max(80, 100, 1000))
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([80, 100, 1000]) :  1000
max(-20, 100, 400) :  400
max(-80, -20, -10) :  -10
max(0, 100, -400) :  100

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

import 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()

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

import math  

print ("math.pow(100, 2) : ", math.pow(100, 2))
print("使用内置，查看输出结果区别")
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()

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

sqrt()

import 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)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange	([start,] stop [,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
random()	生成一个0到1的随机浮点数，0<=n<1.0
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	生成一个指定范围的随机浮点数，它在[x,y]范围内
randint(x, y)	生成一个指定范围内的整数，它在[x,y]范围内
sample	从指定序列中随机获取指定长度的片断

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) 返回一个随机数 :  28
从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 :  5
从字符串中 'Runoob' 返回一个随机字符 :  n

randrange()

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

#从[10,12,14,16,...,96,98]序列中获取一个随机数
print("random.randrange(10,100,2):",random.randrange(10,100,2))

randrange(1,100, 2) :  25
randrange(100) :  7
random.randrange(10,100,2): 62

random()

import random

# 第一个随机数
print ("random() : ", random.random())

# 第二个随机数
print ("random() : ", random.random())


# 实现 100-120 随机小数
print((random.random()*20)+100)

random() :  0.1605165979964044
random() :  0.4380019858706685
115.4696868547905

seed()

import random

random.seed()
print ("使用默认种子生成随机数：", random.random())
random.seed()
print ("使用默认种子生成随机数：", random.random())

random.seed(10)
print ("使用整数种子生成随机数：", random.random())
random.seed(10)
print ("使用整数种子生成随机数：", random.random())
random.seed(10)
print ("使用整数种子生成随机数：", random.random())

random.seed("hello",2)
print ("使用字符串种子生成随机数：", random.random())
random.seed("hello",2)
print ("使用字符串种子生成随机数：", random.random())

使用默认种子生成随机数： 0.25150521765106926
使用默认种子生成随机数： 0.5832851080848803
使用整数种子生成随机数： 0.5714025946899135
使用整数种子生成随机数： 0.5714025946899135
使用整数种子生成随机数： 0.5714025946899135
使用字符串种子生成随机数： 0.3537754404730722
使用字符串种子生成随机数： 0.3537754404730722

shuffle()

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

随机排序列表 :  [10, 16, 5, 20]
随机排序列表 :  [20, 16, 5, 10]

uniform()

import random

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

print ("uniform(7, 14) 的随机浮点数 : ",  random.uniform(7, 14))

uniform(5, 10) 的随机浮点数 :  8.32548129941273
uniform(7, 14) 的随机浮点数 :  11.50216637642797

sample()

#从指定序列中随机获取指定长度的片断
list2 = [i**2 for i in range(0,10)]
print(random.sample(list2,3))

#sample函数不会修改原有序列
print(list2)

[4, 0, 16]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

三角函数

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

数学常量

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

pi

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-33-f84ab820532c> in <module>
----> 1 pi


NameError: name 'pi' is not defined

import math
math.pi

3.141592653589793

import math
math.e

2.718281828459045