Python数据类型一：数字与运算符

数字

一、数值类型

python中支持的数值类型有以下几种：

1、整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。

#!/usr/bin/python

# 10进制

print(12345000000000000000000000000000000000000000000000000000000000000000000000000000000000);

# 16进制

print(0x1232423435646576879796)

# 8进制

print(0o123456134563163564)

# 2进制

print(0b10101010010011111)

# 结果如下，发现在print后，所有整数都被处理为了10进制数：

12345000000000000000000000000000000000000000000000000000000000000000000000000000000000

21998004324339122916792214

2941068610692980

87199

注意16进制、8进制、2进制的默认类型，并不是想象中的16进制、8进制、2进制的类型，而是"int"类型，而使用hex、oct、bin函数转化后同样不是相应类型，而是str类型，
因此可以推测，python内部对于16、8、2进制都是按照字符串来存储的，计算时再统一转化为10进制：

 print(type(0x10))

 print(type(10))

 print(type(0o7))

 print(type(0b10))

 print(type(hex(0x10)))

 print(type(oct(0x7)))

 print(type(bin(0xb1)))

2、浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 10² = 250）

 # 注意浮点型数据，只能是整数表示，不能是浮点数：

 print(0x1.0)

 print(0o4.0)

 print(0b0.1)

 # 第一个print报错：

   File "/usercode/file.py", line 4

     print(0x1.0)

               ^

 SyntaxError: invalid syntax

 # 第二个print报错：

   File "/usercode/file.py", line 3

     print(0o4.0)

               ^

 SyntaxError: invalid syntax

 # 第三个print报错：

   File "/usercode/file.py", line 4

     print(0b0.1)

               ^

 SyntaxError: invalid syntax

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

总结如下：

int	float	complex
10	0.0	3.14j
100	15.20	45.j
-786	-21.9	9.322e-36j
080	32.3+e18	.876j
-0490	-90.	-.6545+0J
-0x260	-32.54e100	3e+26J
0x69	70.2-E12	4.53e-7j

4、强制数字类型转换：

int(x) 将x转换为一个整数。
float(x) 将x转换到一个浮点数。-----只能接受一个参数，仅仅能转化为小数点后1位的浮点数
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

 #!/usr/bin/python

 # 10进制

 print(int(105.021561030000))

 print(float(12345674864561))

 print(complex(5))

 print(complex(5.00))

 print(complex(5e+6j))

 # 不能转化复数到int和float型数据

 print(int(5e+6j))

 print(float(5e+6j))

 # 结果如下

 105

 12345674864561.0

 (5+0j)

 (5+0j)

 5000000j

 # 可以看到结果中，不能将复数转化为int和float型

 Traceback (most recent call last): File "/usercode/file3.py", line 9, in print(int(5e+6j)) TypeError: can't convert complex to int

 Traceback (most recent call last): File "/usercode/file3.py", line 10, in print(float(5e+6j)) TypeError: can't convert complex to float

5、进制数转换

 # 将其它进制数数转换为16进制：

 >>> hex(16)

 0x10

 >>> hex(0o7)

 0x7

 >>> hex(0b1)

 0x1

 # 将其它进制数转换为10进制：

 >>> int(0x10)

 16

 >>> int(0o7)

 7

 >>> int(0b1)

 1

 # 将其它进制数转换为8进制：

 >>> oct(0x10)

 0o20

 >>> oct(10)

 0o12

 >>> oct(0b1)

 0o1

 # 将其它进制数转换为2进制：

 >>> bin(0x10)

 0b10000

 >>> bin(10)

 0b1010

 >>> bin(0o7)

 0b111

运算符

一、算数运算符

1、加法

  1 +  2      //直接输入，回车直接输出结果

 3

 >>> sum = 1 + 2 //计算结果保存在sum中

 >>> print(sum)      //输出sum

 3

 >>> a = 1       //变量

 >>> b = 2

 >>> sum = a + b     //变量相加

 >>> print(sum)

 3

2、减法

 >>> a = 1

 >>> b = 2

 >>> 2 - 1

 1

 >>> a - b

 -1

 >>> b - a

 1

3、乘法

 >>> 1 * 2

 2

 >>> 1.5 * 3

 4.5

 >>> a * b

 2

 >>>

4、除法

 # 以下代码在python3中表现如此，在python2中是以整除进行的，除不尽时小数点后默认保留16位

 >>> 1 / 3

 0.3333333333333333

 >>> 5 / 2

 2.5

 >>> 1.0 / 3

 0.3333333333333333

 >>> 5.0 / 2.0

 2.5

 # 特殊点，注意看，在python3中，默认整数相除，其结果也是浮点数，这个就与传统的整数相除得整数得结论有点相悖了，在python2的基础上修改的用力过猛了：

 >>> 4/2

 2.0

5、整除

 >>> 1 // 3

 0

 >>> 5 // 2

 2

 >>> 1.0 // 3

 0.0

 >>> 5.0 // 2.0

 2.0

 # 当使用整除时，整数相除的结果也是整数了：

 >>> 4//2

 2

6、取余

 >>> 1 % 3

 1

 >>> 5 % 2

 1

 >>> 5.0 % 2.0

 1.0

7、幂运算

 >>> 2 ** 3

 8

 >>> 2.5 ** 5

 97.65625

 # 负数幂实际是1/4**

 >>> 4 ** -1

 0.25

二、比较运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 true.
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。	(a < b) 返回 true。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 true。

 # ==和!=运算符在比较时，等式两端的值不必是同一类，如：

 >>> a,b = "",1

 >>> print(a == b)

 False

 >>> print(a != b)

 True

 # 但是其它的比较运算符，等式两端必须是同一类型值，否则会有报错：

 >>> print(a <= b)

 Traceback (most recent call last):

   File "/usercode/file.py", line 4, in <module>

     print(a <= b)

 TypeError: unorderable types: str() <= int()

三、赋值运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c = a 等效于 c = c a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

四、位运算符

下表中变量 a 为 60，b 为 13。

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
\|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a \| b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

 # 按位与运算符，想到一个在网络界很常用的应用，使用IP地址和子网掩码相与，得到这个IP地址所在的子网，比如192.168.1.1/16，其子网广播地址为："192.168.1.1" & "255.255.0.0"，结果应该是"192.168.0.0"，当然这里只是做个例子，并不能通过字符串类型进行与操作，只能是数字类：

 >>> IP,Mask = [192,168,1,1],[255,255,0,0]

 >>>print(".".join(map(str[IP[0]&Mask[0],int(IP[1])&int(Mask[1]),IP[2] & Mask[2],IP[3] & Mask[3]] ) ))

 192.168.0.0

五、逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是 True，它返回 True，否则它返回 x 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

由于and和or运算符规则比较奇葩，因此下面举例说明一下，且最后给一个结论，不要将True、False与数值类进行与、或运算，最终结果可能不是False、True。

奇葩的and运算符：

 # 逻辑运算符中，and比较奇葩，最终结果可能不是True或者False，而是and右边的值：

 # 10在右边时，返回10：

 >>> print(True and 10)

 10

 # True在右边时，返回True：

 >>> print(10 and True)

 True

 # 当然False或者0不论在左边还是右边返回值都是False，这里如果左边的值是Flase类的话，则and不会再计算后边的值，这个成为短路运算符：

 >>> print(False and 10)

 False

 >>> print(10 and False)

 False

奇葩的or运算符：

 # or运算符在左边的值为非False时，返回值就只是左边的值：

 >>> print(True or 10)

 True

 >>> print(10 or True)

 10

 # 当左边为False或0时，才会计算右边的值，且返回值和右边值相同：

 >>> print(False or 10)

 10

 >>> print(False or 0)

 0

 >>> print(False or False)

 False

六、成员运算符

包含了一系列的成员，包括字符串，列表或元组。

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

 # 在字符串中取成员

 >>> strA = "abcd"

 >>> print("a" in strA)

 True

 >>> print("e" in strA)

 False

 # 在列表中取成员

 >>> listA = [1,2,3,4]

 >>> print(1 in listA)

 True

 >>> print(5 in listA)

 False

 # 在元组中取成员

 >>> tupleA = (1,2,3,4)

 >>> print(1 in tupleA)

 True

 >>> print(5 in tupleA)

 False

 # 字典中取成员

 >>> dictA = {"a":1,"b":2}

 >>> print("a" in dictA)

 True

 # 以上取成员运算都是基于静态数据，如果成员本身是动态呢？也是可以的：

 >>> listB = ([1,2,3],("a","b"),{"c":4},5)

 >>> print([1,2,3] in listB)

 True

 >>> print(("a","b") in listB)

 True

 >>> print( {"c":4} in listB )

 True

 # 上面动态数据只是一层嵌套，我们再次多层嵌套，同样可以的，只不过动态结构内部的结构是不会被当做成员的，但是它是成员的内部成员：

 >>> listC = [[1,2,3,[4,5]],{"c":6,"b":[7,8,9]}]

 >>> print( [1,2,3,[4,5]] in listC )

 True

 >>> print( [4,5] in listC )

 False

 >>> print( [4,5] in listC[0] )

 True

 >>> print( {"c":6,"b":[7,8,9]} in listC )

 True

 >>> print("b" in listC )

 False

 >>> print("b" in listC[1] )

 True

七、身份运算符：等同于用id()函数作用

身份运算符用于比较两个对象的存储单元

运算符	描述	实例
is	is是判断两个标识符是不是引用自一个对象	x is y, 如果 id(x) 等于 id(y) , is 返回结果 1
is not	is not是判断两个标识符是不是引用自不同对象	x is not y, 如果 id(x) 不等于 id(y). is not 返回结果 1

 # 数字、字符串、元组等不可变的数据类型，由于都是静态存储，因此同一个变量存储在内存中的位置都是相同的，用is运算符会返回True：

 >>> a,b = 1,1

 >>> print(a is b)

 True

 >>> a,b = "c","c"

 >>> print(a is b)

 True

 >>> a,b = "c","c"

 >>> print(a is b)

 True

 # 列表等可变序列的数据类型，即使值相等，但是is运算符会返回False：

 >>> a,b = [],[]

 >>> print(a == b)

 True

 >>> a,b = [],[]

 >>> print(a is b)

 False

 # 可以看出两个空列表所在的内存单元不同：

 >>> print(id(a))

 139942755666120

 >>> print(id(b))

 139942755665736

八、运算符的优先级

以下表格列出了从最高到最低优先级的所有运算符，在有多个运算符时，最好使用()将单元括起来计算，避免混淆。

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ \|	位运算符
<= < > >=	比较运算符
== !=	等于运算符
= %= /= //= -= += = *=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not or and	逻辑运算符

一些数学函数和方法总结

一、全局基础函数

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃。
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列。
pow(x, y)	x**y 运算后的值。
round(x [,n])	返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。

二、math库

 1 # 需要在使用前先import导入math标准库

 2 >>> import math

 3

 4 # 两个常数math.pi和math.e

 5 >>> math.pi             //圆周率pi

 6 3.141592653589793

 7 >>> math.e

 8 2.718281828459045       //自然常数e

 9

10 # math.ceil()，向上取整：返回最小的大于或等于x的值

11 >>> math.ceil(2)

12 2

13 >>> math.ceil(2.2)

14 3

15 >>> math.ceil(2.9)

16 3

17 >>> math.ceil(3.0)

18 3

19

20 # math.floor()，向下取整，返回最大的小于或等于x的整数。

21 >>> math.floor(2)

22 2

23 >>> math.floor(2.2)

24 2

25 >>> math.floor(2.9)

26 2

27 >>> math.floor(3.0)

28 3

29

30 # math.fabs()，绝对值

31 >>> math.fabs(1.0)

32 1.0

33 >>> math.fabs(-1.0)

34 1.0

35

36

37 # math.factorial()，计算阶乘

38 >>> math.factorial(5)

39 120

40 >>> math.factorial(4)

41 24

42 >>> math.factorial(2.1)     //执行错误

43 Traceback (most recent call last):

44   File "<stdin>", line 1, in <module>

45 ValueError: factorial() only accepts integral values

46 >>>

47

48 # math.exp(x)。返回e ** x。

49 >>> math.exp(2)

50 7.38905609893065

51 >>> math.e ** 2

52 7.3890560989306495  //请忽略后面的不一致，计算机浮点数本身的问题

53

54

55 *****以下运算中默认精确到1位小数点，及时本应该是整数的*****

56 # math.log(x [,base])。求以base为底的对数。

57 >>> math.log(math.e)        //值传一个参数，默认以math.e为底

58 1.0

59 >>> math.log(math.e ** 2)

60 2.0

61 >>> math.log(8, 2)      //两个参数，2为底

62 3.0

63 >>> math.log(100, 10)   //两个参数，10为底s

64 2.0

65

66 # math.pow(x, y)。幂运算，计算xy，相当于x ** y--精度不同。

67 >>> math.pow(2, 3)

68 8.0

69 >>> 2 ** 3

70 8

71

72 # math.sqrt(x)**。求x的平方根。

73 >>> math.sqrt(4)

74 2.0

75 >>> math.sqrt(4.0)

76 2.0

77 >>> math.sqrt(4.00)

78 2.0

79 >>> math.sqrt(9.0)

80 3.0

81

82 # 开根号。Python的math库中只有开平方根，没有立方根和n次方根，不过可以利用math.pow或者**，只需把根号变成分数。

83 >>> math.pow(4, 1.0 / 2)        //平方根，相当于math.sqrt(4)

84 2.0

85 >>> 4 ** (1.0 / 2)          //平方根，相当于math.sqrt(4)

86 2.0

87 >>> 8 ** (1.0 / 3)          //立方根

88 2.0

89 >>> 1024 ** (1.0 / 10)          //10次方根

90 2.0

91

92 ****其它的函数可以使用help(math)来查看，或者查看手册****

常用的一些math库函数

1、数学常量：

math.pi : 元周率

math.e : 自然常数

2、数学计算函数：

函数	返回值 ( 描述 )
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃。使用 (x>y)-(x<y) 替换。
exp(x)	返回e的x次幂(e^x),如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
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值，结果带浮点。
sqrt(x)	返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j

3、三角函数

函数	描述
acos(x)	返回x的反余弦值，以弧度形式表示
asin(x)	返回x的反正弦，以弧度形式表示
atan(x)	返回x的反正切值，以弧度表示形式
atan2(y, x)	返回反正切atan(y / x)，以弧度形式表示
cos(x)	返回x 弧度的余弦
hypot(x, y)	返回欧几里德范数，sqrt(xx + yy)
sin(x)	返回x的弧度的正弦值
tan(x)	返回x的弧度的正切
degrees(x)	从弧度到度角 x 的转换
radians(x)	从角度到弧度角 x 的转换

常用的一些random库函数

可以轻松生成一些想要的随机值，使用前先import random

choice(seq)	从列表，元组或字符串随机项。
randrange ([start,] stop [,step])	从范围随机选择的元素（启动，停止，步骤）
random()	随机浮点数r，使得0是小于或等于r，r小于1
seed([x])	设置生成随机数使用整数开始值。调用任何其他随机模块函数之前调用这个函数。返回None。
shuffle(lst)	随机化代替列表中的项。返回None。
uniform(x, y)	随机浮点数r，大于x小于y