数字
一、数值类型
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进制：
1 print(type(0x10)) 2 print(type(10)) 3 print(type(0o7)) 4 print(type(0b10)) 5 print(type(hex(0x10))) 6 print(type(oct(0x7))) 7 print(type(bin(0xb1)))
<class 'int'>
<class 'int'>
<class 'int'>
<class 'int'>
<class 'str'>
<class 'str'>
<class 'str'>
2、浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
1 # 注意浮点型数据，只能是整数表示，不能是浮点数： 2 print(0x1.0) 3 print(0o4.0) 4 print(0b0.1) 5 6 # 第一个print报错： 7 File "/usercode/file.py", line 4 8 print(0x1.0) 9 ^ 10 SyntaxError: invalid syntax 11 12 # 第二个print报错： 13 File "/usercode/file.py", line 3 14 print(0o4.0) 15 ^ 16 SyntaxError: invalid syntax 17 18 # 第三个print报错： 19 File "/usercode/file.py", line 4 20 print(0b0.1) 21 ^ 22 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 是数字表达式。
1 #!/usr/bin/python 2 # 10进制 3 print(int(105.021561030000)) 4 print(float(12345674864561)) 5 print(complex(5)) 6 print(complex(5.00)) 7 print(complex(5e+6j)) 8 # 不能转化复数到int和float型数据 9 print(int(5e+6j)) 10 print(float(5e+6j)) 11 12 13 # 结果如下 14 105 15 12345674864561.0 16 (5+0j) 17 (5+0j) 18 5000000j 19 20 # 可以看到结果中，不能将复数转化为int和float型 21 Traceback (most recent call last): File "/usercode/file3.py", line 9, in print(int(5e+6j)) TypeError: can't convert complex to int 22 Traceback (most recent call last): File "/usercode/file3.py", line 10, in print(float(5e+6j)) TypeError: can't convert complex to float
5、进制数转换
1 # 将其它进制数数转换为16进制： 2 >>> hex(16) 3 0x10 4 >>> hex(0o7) 5 0x7 6 >>> hex(0b1) 7 0x1 8 9 # 将其它进制数转换为10进制： 10 >>> int(0x10) 11 16 12 >>> int(0o7) 13 7 14 >>> int(0b1) 15 1 16 17 # 将其它进制数转换为8进制： 18 >>> oct(0x10) 19 0o20 20 >>> oct(10) 21 0o12 22 >>> oct(0b1) 23 0o1 24 25 # 将其它进制数转换为2进制： 26 >>> bin(0x10) 27 0b10000 28 >>> bin(10) 29 0b1010 30 >>> bin(0o7) 31 0b111
运算符
一、算数运算符
1、加法
1 1 + 2 //直接输入，回车直接输出结果 2 3 3 >>> sum = 1 + 2 //计算结果保存在sum中 4 >>> print(sum) //输出sum 5 3 6 >>> a = 1 //变量 7 >>> b = 2 8 >>> sum = a + b //变量相加 9 >>> print(sum) 10 3
2、减法
1 >>> a = 1 2 >>> b = 2 3 >>> 2 - 1 4 1 5 >>> a - b 6 -1 7 >>> b - a 8 1
3、乘法
1 >>> 1 * 2 2 2 3 >>> 1.5 * 3 4 4.5 5 >>> a * b 6 2 7 >>>
4、除法
1 # 以下代码在python3中表现如此，在python2中是以整除进行的，除不尽时小数点后默认保留16位 2 >>> 1 / 3 3 0.3333333333333333 4 >>> 5 / 2 5 2.5 6 >>> 1.0 / 3 7 0.3333333333333333 8 >>> 5.0 / 2.0 9 2.5 10 11 # 特殊点，注意看，在python3中，默认整数相除，其结果也是浮点数，这个就与传统的整数相除得整数得结论有点相悖了，在python2的基础上修改的用力过猛了： 12 >>> 4/2 13 2.0
5、整除
1 >>> 1 // 3 2 0 3 >>> 5 // 2 4 2 5 >>> 1.0 // 3 6 0.0 7 >>> 5.0 // 2.0 8 2.0 9 10 # 当使用整除时，整数相除的结果也是整数了： 11 >>> 4//2 12 2
6、取余
1 >>> 1 % 3 2 1 3 >>> 5 % 2 4 1 5 >>> 5.0 % 2.0 6 1.0
7、幂运算
1 >>> 2 ** 3 2 8 3 >>> 2.5 ** 5 4 97.65625 5 # 负数幂实际是1/4** 6 >>> 4 ** -1 7 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。 |
1 # ==和!=运算符在比较时，等式两端的值不必是同一类，如： 2 >>> a,b = "1",1 3 >>> print(a == b) 4 False 5 6 >>> print(a != b) 7 True 8 9 # 但是其它的比较运算符，等式两端必须是同一类型值，否则会有报错： 10 >>> print(a <= b) 11 Traceback (most recent call last): 12 File "/usercode/file.py", line 4, in <module> 13 print(a <= b) 14 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 |
1 # 按位与运算符，想到一个在网络界很常用的应用，使用IP地址和子网掩码相与，得到这个IP地址所在的子网，比如192.168.1.1/16，其子网广播地址为："192.168.1.1" & "255.255.0.0"，结果应该是"192.168.0.0"，当然这里只是做个例子，并不能通过字符串类型进行与操作，只能是数字类： 2 3 >>> IP,Mask = [192,168,1,1],[255,255,0,0] 4 >>>print(".".join(map(str[IP[0]&Mask[0],int(IP[1])&int(Mask[1]),IP[2] & Mask[2],IP[3] & Mask[3]] ) )) 5 6 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运算符：
1 # 逻辑运算符中，and比较奇葩，最终结果可能不是True或者False，而是and右边的值： 2 3 # 10在右边时，返回10： 4 >>> print(True and 10) 5 10 6 7 # True在右边时，返回True： 8 >>> print(10 and True) 9 True 10 11 # 当然False或者0不论在左边还是右边返回值都是False，这里如果左边的值是Flase类的话，则and不会再计算后边的值，这个成为短路运算符： 12 >>> print(False and 10) 13 False 14 >>> print(10 and False) 15 False
奇葩的or运算符：
1 # or运算符在左边的值为非False时，返回值就只是左边的值： 2 >>> print(True or 10) 3 True 4 >>> print(10 or True) 5 10 6 7 # 当左边为False或0时，才会计算右边的值，且返回值和右边值相同： 8 >>> print(False or 10) 9 10 10 >>> print(False or 0) 11 0 12 >>> print(False or False) 13 False
六、成员运算符
包含了一系列的成员，包括字符串，列表或元组。
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
1 # 在字符串中取成员 2 >>> strA = "abcd" 3 >>> print("a" in strA) 4 True 5 6 >>> print("e" in strA) 7 False 8 9 10 # 在列表中取成员 11 >>> listA = [1,2,3,4] 12 >>> print(1 in listA) 13 True 14 15 >>> print(5 in listA) 16 False 17 18 # 在元组中取成员 19 >>> tupleA = (1,2,3,4) 20 >>> print(1 in tupleA) 21 True 22 >>> print(5 in tupleA) 23 False 24 25 # 字典中取成员 26 >>> dictA = {"a":1,"b":2} 27 >>> print("a" in dictA) 28 True 29 30 31 # 以上取成员运算都是基于静态数据，如果成员本身是动态呢？也是可以的： 32 33 >>> listB = ([1,2,3],("a","b"),{"c":4},5) 34 >>> print([1,2,3] in listB) 35 True 36 37 >>> print(("a","b") in listB) 38 True 39 40 >>> print( {"c":4} in listB ) 41 True 42 43 44 # 上面动态数据只是一层嵌套，我们再次多层嵌套，同样可以的，只不过动态结构内部的结构是不会被当做成员的，但是它是成员的内部成员： 45 >>> listC = [[1,2,3,[4,5]],{"c":6,"b":[7,8,9]}] 46 >>> print( [1,2,3,[4,5]] in listC ) 47 True 48 49 >>> print( [4,5] in listC ) 50 False 51 52 >>> print( [4,5] in listC[0] ) 53 True 54 55 >>> print( {"c":6,"b":[7,8,9]} in listC ) 56 True 57 58 >>> print("b" in listC ) 59 False 60 61 >>> print("b" in listC[1] ) 62 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 |
1 # 数字、字符串、元组等不可变的数据类型，由于都是静态存储，因此同一个变量存储在内存中的位置都是相同的，用is运算符会返回True： 2 3 >>> a,b = 1,1 4 >>> print(a is b) 5 True 6 7 >>> a,b = "c","c" 8 >>> print(a is b) 9 True 10 11 >>> a,b = "c","c" 12 >>> print(a is b) 13 True 14 15 # 列表等可变序列的数据类型，即使值相等，但是is运算符会返回False： 16 >>> a,b = [],[] 17 >>> print(a == b) 18 True 19 20 >>> a,b = [],[] 21 >>> print(a is b) 22 False 23 24 # 可以看出两个空列表所在的内存单元不同： 25 >>> print(id(a)) 26 139942755666120 27 >>> print(id(b)) 28 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次幂(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 |
| 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(x*x + y*y) |
| 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 |