pythonint函数使用技巧_python数字处理技巧

0、处理技巧

1. 数字的四舍五入

当我们需要对整数 或者 浮点数进行四舍五入的时候。

round(value, ndigits)  /// 内置函数

对浮点数进行四舍五入(传入的ndigit应该是正值，作用于十分位、百分位...)：

print( round(1.23, 1) ) # 1.2

print( round(1.27, 1) ) # 1.3

print( round(-1.27, 1) ) #-1.3

print( round(1.25361, 3)) #1.254

print( round(2.5, 0) ) #2.0 近似到最近的偶数

对整数进行四舍五入(传入的ndigit应该是自然数，作用于个位、十位、百位...)

print( round(314159, -1)) #314160

print( round(314159, -2)) #314200

print( round(314159, -3)) #314000

Comment：

不要将舍入round和格式化format输出搞混淆了。 如果我们目的只是简单的输出一定宽度的数，不需要使用 round() 函数。 而仅仅只需要在格式化的时候指定精度即可。

pi = 3.1415926

print( format(pi, '0.2f')) #3.14

print( format(pi, '0.3f')) #3.142

print( 'the value is {:0.4f}'.format(pi) ) #the value is 3.1416

2. 执行精确的浮点数运算

有的时候我们需要对浮点数进行精度运算，并不希望出现小的误差。但是由于浮点数并不能精确的表示十进制数。 并且，即使是最简单的数学运算也会产生小的误差，比如：

a = 4.2

b = 2.1

print( a + b ) # 6.300000000000001

print( a+b == 6.3 ) #False

这些错误是由底层CPU和IEEE 754标准通过自己的浮点单位去执行算术时的特征。 由于Python的浮点数据类型使用底层表示存储数据，因此没办法去避免这样的误差。

decimal模块  耗时但是精确

如果想更加精确(并能容忍一定的性能损耗)，我们可以使用 decimal 模块：

from decimal import Decimal

a = Decimal('4.2')

b = Decimal('2.1')

print(a+b) # 6.3

其实呢，这段代码看起来好像有点奇怪，比如用字符串来表示数字。 然而，Decimal对象会像普通浮点数一样的工作。 我们打印它们时，看起来却跟普通数字没什么两样。

decimal 模块的一个主要特征是允许控制计算的每一方面，包括数字位数和四舍五入运算。 为了这样做，我们需要创建一个本地上下文并更改它的设置。

from decimal import localcontext

a = Decimal('1.3')

b = Decimal('1.7')

print(a / b) # 0.7647058823529411764705882353

with localcontext() as ctx:

ctx.prec = 3

print(a / b) # 0.765

with localcontext() as ctx:

ctx.prec = 50

print(a / b) #0.76470588235294117647058823529411764705882352941176

3. 数字的格式化输出

需要将数字格式化后输出，并控制数字的位数、对齐、千位分隔符和其他的细节。格式化输出单个数字的时候，可以使用内置的 format() 函数，比如：

x = 1234.56789

print(format(x, '0.2f')) #'1234.57'

print(format(x, '>10.1f')) #' 1234.6'

print(format(x, '<10.10f')) #'1234.5678900000'

print(format(x, '^10.1f')) #' 1234.6 '

print(format(x, ',')) #1,234.56789

print(format(x, 'e')) #1.234568e+03

print('The value is {:0,.2f}'.format(x)) # The value is 1,234.57

4. 二八十六进制整数

为了将整数转换为二进制、八进制或十六进制的文本串， 可以分别使用 bin() , oct() 或 hex()函数。

x = 1234

print( bin(x) ) # 0b10011010010

print( oct(x) ) # 0o2322

print( hex(x) ) # 0x4d2

# 如果不想输出0b,0o或者0x的,使用 format() 函数

print( format(x, 'b') ) # 10011010010

print( format(x, 'o') ) # 2322

print( format(x, 'x') ) # 4d2

#使用int从16进制转回10进制

print(int(hex(x), 16)) #1234

5. 字节到大整数的打包和解包

这里涉及到的是:如何将大整数利用字节进行处理。

int.from_bytes() & int.to_bytes()

data = b'\x00\x124V\x00x\x90\xab\x00\xcd\xef\x01\x00#\x004'

# 将bytes解析为整数，使用 int.from_bytes() 方法

print( len(data) )

print( int.from_bytes(data, 'little') )

print( int.from_bytes(data,'big') )

# 将大整数保存为字节格式使用 int.to_bytes()方法

x = 94522842520747284487117727783387188

print( x.to_bytes(16, 'big') ) # b'\x00\x124V\x00x\x90\xab\x00\xcd\xef\x01\x00#\x004'

print( x.to_bytes(16, 'little') ) # b'4\x00#\x00\x01\xef\xcd\x00\xab\x90x\x00V4\x12\x00'

大整数和字节字符串之间的转换操作并不常见。 然而，在一些应用领域有时候也会出现，比如密码学或者网络。 例如，IPv6网络地址使用一个128位的整数表示。 如果要从一个数据记录中提取这样的值的时候。

6. 复数的数学运算

complex(real, imag) 或者是带有后缀j的浮点数来指定

a = complex(2, 4)

b = 3 - 5j

print(a) # (2+4j)

print(b) # (3-5j)

print(a.real, a.imag, b.real, b.imag) # 2.0 4.0 3.0 -5.0

7. 无穷大与NaN

Python并没有特殊的语法来表示这些特殊的浮点值，但是可以使用 float() 来创建它们。

import math

print( float('inf') ) # inf

print( float('-inf') ) # -inf

print( float('nan') ) # nan

a = float('inf')

print( math.isinf(a) ) # true

# 无穷大数在执行数学计算的时候会传播

print( a+45 ) # inf

8. 分数运算

fractions

fractions 模块可以被用来执行包含分数的数学运算。

from fractions import Fraction

a = Fraction(5, 4)

print( a ) # 5/4

print( a.numerator, a.denominator) # 5 4

print( float(a) ) # 1.25

在大多数程序中一般不会出现分数的计算问题，但是有时候还是需要用到的。 比如，在一个允许接受分数形式的测试单位并以分数形式执行运算的程序中， 直接使用分数可以减少手动转换为小数或浮点数的工作。

9、日期与时间转换 datatime

当我们的应用程序接受字符串格式输入，可以将它转换为 datetime 对象并执行非字符串操作

from datetime import datetime

text = '2018-10-28'

y = datetime.strptime(text, '%Y-%m-%d')

z = datetime.now()

diff = z - y

print( diff )

# >>> 1 day, 11:00:32.970036

datetime.strptime() 方法支持很多的格式化代码， 比如 %Y 代表4位数年份， %m 代表两位数月份。 还有一点值得注意的是这些格式化占位符也可以反过来使用，将日期输出为指定的格式字符串形式。

1、python运算符

Python 语言支持以下类型的运算符:

算术运算符

比较(关系)运算符

赋值运算符

逻辑运算符

位运算符

成员运算符

身份运算符

运算符优先级

1、算术运算符

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

运算符描述实例

+

加 - 两个对象相加

a + b 输出结果 31

-

减 - 得到负数或是一个数减去另一个数

a - b 输出结果 -11

*

乘 - 两个数相乘或是返回一个被重复若干次的字符串

a * b 输出结果 210

/

除 - x 除以 y

b / a 输出结果 2.1

%

取模 - 返回除法的余数

b % a 输出结果 1

**

幂 - 返回x的y次幂

a**b 为10的21次方

//

取整除 - 向下取接近商的整数

>>>9//24>>>-9//2-5

以下实例演示了Python所有算术运算符的操作：

a = 21

b = 10

c = 0

c = a + b

print ("1 - c 的值为：", c)

c = a - b

print ("2 - c 的值为：", c)

c = a * b

print ("3 - c 的值为：", c)

c = a / b

print ("4 - c 的值为：", c)

c = a % b

print ("5 - c 的值为：", c)

# 修改变量 a 、b 、c

a = 2

b = 3

c = a**b

print ("6 - c 的值为：", c)

a = 10

b = 5

c = a//b

print ("7 - c 的值为：", c)

结果为：

1 - c 的值为： 31

2 - c 的值为： 11

3 - c 的值为： 210

4 - c 的值为： 2.1

5 - c 的值为： 1

6 - c 的值为： 8

7 - c 的值为： 2

2、Python比较运算符

以下假设变量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。

以下实例演示了Python所有比较运算符的操作：

#!/usr/bin/python3

a = 21

b = 10

c = 0

if ( a == b ):

print ("1 - a 等于 b")

else:

print ("1 - a 不等于 b")

if ( a != b ):

print ("2 - a 不等于 b")

else:

print ("2 - a 等于 b")

if ( a < b ):

print ("3 - a 小于 b")

else:

print ("3 - a 大于等于 b")

if ( a > b ):

print ("4 - a 大于 b")

else:

print ("4 - a 小于等于 b")

# 修改变量 a 和 b 的值

a = 5

b = 20

if ( a <= b ):

print ("5 - a 小于等于 b")

else:

print ("5 - a 大于 b")

if ( b >= a ):

print ("6 - b 大于等于 a")

else:

print ("6 - b 小于 a")

以上实例输出结果：

1 - a 不等于 b

2 - a 不等于 b

3 - a 大于等于 b

4 - a 大于 b

5 - a 小于等于 b

6 - b 大于等于 a

3、Python赋值运算符

以下假设变量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

:=

海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。

在这个示例中，赋值表达式可以避免调用 len() 两次:

if(n :=len(a))>10:print(f"List is too long ({n} elements, expected <= 10)")

以下实例演示了Python所有赋值运算符的操作：

#!/usr/bin/python3

a = 21

b = 10

c = 0

c = a + b

print ("1 - c 的值为：", c)

c += a

print ("2 - c 的值为：", c)

c *= a

print ("3 - c 的值为：", c)

c /= a

print ("4 - c 的值为：", c)

c = 2

c %= a

print ("5 - c 的值为：", c)

c **= a

print ("6 - c 的值为：", c)

c //= a

print ("7 - c 的值为：", c)

以上实例输出结果：

1 - c 的值为： 31

2 - c 的值为： 52

3 - c 的值为： 1092

4 - c 的值为： 52.0

5 - c 的值为： 2

6 - c 的值为： 2097152

7 - c 的值为： 99864

4、Python位运算符

按位运算符是把数字看作二进制来进行计算的。

运算符描述实例

&

按位与运算符：参与运算的两个值,如果两个相应位都为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。~x 类似于 -x-1

(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。

<<

左移动运算符：运算数的各二进位全部左移若干位，由"<

a << 2 输出结果 240 ，二进制解释： 1111 0000

>>

右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数

a >> 2 输出结果 15 ，二进制解

以下实例演示了Python所有位运算符的操作：

#!/usr/bin/python3

a = 60 # 60 = 0011 1100

b = 13 # 13 = 0000 1101

c = 0

c = a & b # 12 = 0000 1100

print ("1 - c 的值为：", c)

c = a | b # 61 = 0011 1101

print ("2 - c 的值为：", c)

c = a ^ b # 49 = 0011 0001

print ("3 - c 的值为：", c)

c = ~a # -61 = 1100 0011

print ("4 - c 的值为：", c)

c = a << 2 # 240 = 1111 0000

print ("5 - c 的值为：", c)

c = a >> 2 # 15 = 0000 1111

print ("6 - c 的值为：", c)

以上实例输出结果：

1 - c 的值为： 12

2 - c 的值为： 61

3 - c 的值为： 49

4 - c 的值为： -61

5 - c 的值为： 240

6 - c 的值为： 15

5、Python逻辑运算符

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

运算符逻辑表达式描述实例

and

x and y

布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。

(a and b) 返回 20。

or

x or y

布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。

(a or b) 返回 10。

not

not x

布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

not(a and b) 返回 False

#!/usr/bin/python3

a = 10

b = 20

if ( a and b ):

print ("1 - 变量 a 和 b 都为 true")

else:

print ("1 - 变量 a 和 b 有一个不为 true")

if ( a or b ):

print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")

else:

print ("2 - 变量 a 和 b 都不为 true")

# 修改变量 a 的值

a = 0

if ( a and b ):

print ("3 - 变量 a 和 b 都为 true")

else:

print ("3 - 变量 a 和 b 有一个不为 true")

if ( a or b ):

print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")

else:

print ("4 - 变量 a 和 b 都不为 true")

if not( a and b ):

print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")

else:

print ("5 - 变量 a 和 b 都为 true")

以上实例输出结果：

1 - 变量 a 和 b 都为 true

2 - 变量 a 和 b 都为 true，或其中一个变量为 true

3 - 变量 a 和 b 有一个不为 true

4 - 变量 a 和 b 都为 true，或其中一个变量为 true

5 - 变量 a 和 b 都为 false，或其中一个变量为 false

6、Python成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符描述实例

in

如果在指定的序列中找到值返回 True，否则返回 False。

x 在 y 序列中 , 如果 x 在 y 序列中返回 True。

not in

如果在指定的序列中没有找到值返回 True，否则返回 False。

x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

以下实例演示了Python所有成员运算符的操作：

#!/usr/bin/python3

a = 10

b = 20

list = [1, 2, 3, 4, 5 ]

if ( a in list ):

print ("1 - 变量 a 在给定的列表中 list 中")

else:

print ("1 - 变量 a 不在给定的列表中 list 中")

if ( b not in list ):

print ("2 - 变量 b 不在给定的列表中 list 中")

else:

print ("2 - 变量 b 在给定的列表中 list 中")

# 修改变量 a 的值

a = 2

if ( a in list ):

print ("3 - 变量 a 在给定的列表中 list 中")

else:

print ("3 - 变量 a 不在给定的列表中 list 中")

以上实例输出结果：

1 - 变量 a 不在给定的列表中 list 中

2 - 变量 b 不在给定的列表中 list 中

3 - 变量 a 在给定的列表中 list 中

7、Python身份运算符

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

运算符描述实例

is

is 是判断两个标识符是不是引用自一个对象

x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False

is not

is not 是判断两个标识符是不是引用自不同对象

x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

注： id() 函数用于获取对象内存地址。

以下实例演示了Python所有身份运算符的操作：

#!/usr/bin/python3

a = 20

b = 20

if ( a is b ):

print ("1 - a 和 b 有相同的标识")

else:

print ("1 - a 和 b 没有相同的标识")

if ( id(a) == id(b) ):

print ("2 - a 和 b 有相同的标识")

else:

print ("2 - a 和 b 没有相同的标识")

# 修改变量 b 的值

b = 30

if ( a is b ):

print ("3 - a 和 b 有相同的标识")

else:

print ("3 - a 和 b 没有相同的标识")

if ( a is not b ):

print ("4 - a 和 b 没有相同的标识")

else:

print ("4 - a 和 b 有相同的标识")

以上实例输出结果：

1 - a 和 b 有相同的标识

2 - a 和 b 有相同的标识

3 - a 和 b 没有相同的标识

4 - a 和 b 没有相同的标识

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

>>>a = [1, 2, 3]

>>> b = a

>>> b is a

True

>>> b == a

True

>>> b = a[:]

>>> b is a

False

>>> b == a

True

8、Python运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

运算符描述

**

指数 (最高优先级)

~ + -

按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)

* / % //

乘，除，求余数和取整除

+ -

加法减法

>> <<

右移，左移运算符

&

位 'AND'

^ |

位运算符

<= < > >=

比较运算符

== !=

等于运算符

= %= /= //= -= += *= **=

赋值运算符

is is not

身份运算符

in not in

成员运算符

not and or

逻辑运算符

以下实例演示了Python所有运算符优先级的操作：

#!/usr/bin/python3

a = 20

b = 10

c = 15

d = 5

e = 0

e = (a + b) * c / d #( 30 * 15 ) / 5

print ("(a + b) * c / d 运算结果为：", e)

e = ((a + b) * c) / d # (30 * 15 ) / 5

print ("((a + b) * c) / d 运算结果为：", e)

e = (a + b) * (c / d) # (30) * (15/5)

print ("(a + b) * (c / d) 运算结果为：", e)

e = a + (b * c) / d # 20 + (150/5)

print ("a + (b * c) / d 运算结果为：", e)

以上实例输出结果：

(a + b) * c / d 运算结果为： 90.0

((a + b) * c) / d 运算结果为： 90.0

(a + b) * (c / d) 运算结果为： 90.0

a + (b * c) / d 运算结果为： 50.0

2、Python3 数字(Number)

1、Python 数字类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

int(x) 将x转换为一个整数。

float(x) 将x转换到一个浮点数。

complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

2、数学函数

函数返回值 ( 描述 )

返回数字的绝对值，如abs(-10) 返回 10

返回数字的上入整数，如math.ceil(4.1) 返回 5

cmp(x, y)

如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃，使用 (x>y)-(x

返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045

返回数字的绝对值，如math.fabs(-10) 返回10.0

返回数字的下舍整数，如math.floor(4.9)返回 4

如math.log(math.e)返回1.0,math.log(100,10)返回2.0

返回以10为基数的x的对数，如math.log10(100)返回 2.0

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

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

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

x**y 运算后的值。

返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。

其实准确的说是保留值将保留到离上一位更近的一端。

返回数字x的平方根。

3、随机数函数

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

Python包含以下常用随机数函数：

函数描述

从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。

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

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

改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。

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

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

4、三角函数

Python包括以下三角函数：

函数描述

返回x的反余弦弧度值。

返回x的反正弦弧度值。

返回x的反正切弧度值。

返回给定的 X 及 Y 坐标值的反正切值。

返回x的弧度的余弦值。

返回欧几里德范数 sqrt(x*x + y*y)。

返回的x弧度的正弦值。

返回x弧度的正切值。

将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0

5、数学常量

常量描述

pi

数学常量 pi(圆周率，一般以π来表示)

e

数学常量 e，e即自然常数(自然常数)。

3、numpy数据操作

参考资料