保留三位有效数字python python保留3位有效数字

1：%用法

1.1：整数的输出：

%o —— oct 八进制
%d —— dec 十进制 ；%nd：至少输出n位，不足n位就在其左边补空格
%x —— hex 十六进制

a = 123
print('%o' % (a) )
print('%3d' % (a) )
print('%5d' % (a) )
print('%-5d' % (a) )
print('%x' % (a) )

1.2：浮点数的输出：

1.2.1 格式化输出

%f ——保留小数点后面六位有效数字（会对第7位进行四舍五入处理）
　　%.3f，保留3位小数位（会对第4位进行四舍五入处理）
%e ——保留小数点后面六位有效数字，指数形式输出
　　%.3e，保留3位小数位，使用科学计数法
%g ——在保证六位有效数字的前提下，使用小数方式，否则使用科学计数法
　　%.3g，保留3位有效数字，使用小数或科学计数法

# %f
a = 12.123456789
print("%f" % (a))    #  12.123457
print("%.7f" % (a))  #  12.1234568

a = 12.123456
print("%f" % (a))    #  12.123456
print("%.7f" % (a))  #  12.1234560

# %e
a = 12.123456789
print("%e" % (a))    #  1.212346e+01
print("%.7e" % (a))  #  1.2123457e+01

# %g
a = 12345.123456789
print("%g" % (a))    # 12345.1
print("%.7g" % (a))  # 12345.12
print("%.3g" % (a))  # 1.23e+04

1.2.2 内置round()

　　round(number[, ndigits])
　　参数：
　　number - 这是一个数字表达式。
　　ndigits - 表示从小数点到最后四舍五入的位数。默认值为0。
　　返回值
　　该方法返回x的小数点舍入为n位数后的值。

　　round()函数只有一个参数，不指定位数的时候，返回一个整数，而且是最靠近的整数，类似于四舍五入，当指定取舍的小数点位数的时候，一般情况也是使用四舍五入的规则，但是碰到.5的情况时，如果要取舍的位数前的小数是奇数，则直接舍弃，如果是偶数则向上取舍。

　　注：“.5”这个是一个“坑”，且python2和python3出来的接口有时候是不一样的，尽量避免使用round()函数吧

print(round(1.1235))    # 1
print(round(1.1236,3))  # 1.124
print(round(1.1235,3))  # 1.123  ?? 不应该是1.124吗？？
print(round(1.1245,3))  # 1.125

print(round(0.5))  # 0  ?? 不应该是1 吗
print(round(1.5))  # 2
print(round(2.5))  # 2  ?? 不应该是3 吗

print(round(1.475,2))  # 1.48
print(round(2.475,2))  # 2.48

print(round(1.575,2))  # 1.57  ????
print(round(2.575,2))  # 2.58  ????

print(round(1.675,2))  # 1.68  ????
print(round(2.675,2))  # 2.67  ????

1.3：字符串输出：

'''
%s
%10s   ——右对齐，占位符10位
%-10s  ——左对齐，占位符10位
%.2s   ——截取2位字符串
%10.2s ——10位占位符，截取两位字符串

'''
s = 'abcdef'
print('[%s]' % s)
print('[%10s]' % s)
print('[%-10s]' % s)
print('[%.2s]' % s)
print('[%10.2s]' % s)
print('[%-10.2s]' % s)

输出结果：

1.4：其他：

 1.4.1:字符串格式代码

序号	符号	说明
1	%s	字符串
2	%c	字符
3	%d	十进制整数
4	%i	整数
5	%u	无符号整数
6	%o	八进制整数
7	%x	十六进制整数
8	%X	十六进制整数大写
9	%e	浮点数格式1
10	%E	浮点数格式2
11	%f	浮点数格式3
12	%g	浮点数格式4
13	%G	浮点数格式5
14	%%	字符%

 

a = 255
print('%s' % ('hello'))
print('%c' % ('h'))
print('%d' % (a))  # 255
print('%i' % (a))  # 255
print('%u' % (-1)) # -1  ??? 为什么不是把 -1 转换为正数？？
print('%o' % (a))  # 377
print('%x' % (a))  # ff
print('%X' % (a))  # FF

f = 12378921.123456789
print('%e' % f)
print('%E' % f)
print('%f' % f)
print('%g' % f)
print('%G' % f)

print('%d%%' % (89))  # 输出 89%

 1.4.2:常用转义字符

序号	转义字符	说明
1	\ (在行尾时)	续行符
2	\\	代表一个反斜线字符''\'
3	\'	代表一个单引号（撇号）字符
4	\"	代表一个双引号字符
5	\a	响铃(BEL)
6	\b	退格(BS) ，将当前位置移到前一列
7	\e	转义
8	\000	空
9	\n	换行(LF) ，将当前位置移到下一行开头
10	\v	垂直制表(VT)
11	\t	水平制表(HT) （跳到下一个TAB位置）
12	\r	回车(CR) ，将当前位置移到本行开头
13	\f	换页(FF)，将当前位置移到下页开头
14	\oyy	八进制数yy代表的字符，如：\o12代表换行符
15	\xyy	十六进制yy代表的字符，如：\x0a代表换行符
16	\other	其它的字符以普通格式输出

 

2：format用法

 　　相对基本格式化输出采用‘%’的方法，format()功能更强大，该函数把字符串当成一个模板，通过传入的参数进行格式化，并且使用大括号‘{}’作为特殊字符代替‘%’

 2.1：位置匹配:

a:不带编号，即"{}"
b:带数字编号,可调换顺序,即"{1}","{2}"
c:带关键字,即"{name}","{age}"

'''
a:不带编号，即"{}"
b:带数字编号,可调换顺序,即"{1}","{2}"
c:带关键字,即"{name}","{age}"
'''

print('{} {}'.format('come on','baby')) # 不带字段
print('{0} {1}'.format('come on','baby')) # 带数字编号
print('{0} {1} {0}'.format('come on','baby')) # 带数字编号，打乱顺序
print('{1} {1} {0}'.format('come on','baby')) # 带数字编号，打乱顺序
print('{come} {b}'.format(b = 'baby',come = 'come on')) # 带关键字

# 通过位置匹配：
print('通过位置匹配：')
print('{0},{1},{2}'.format('a','b','c'))
print('{},{},{}'.format('a','b','c'))
print('{2},{1},{0}'.format('a','b','c'))  # 打乱顺序
print('{2},{1},{0}'.format(*'1234'))      # 打乱顺序
print('{2},{0},{0}'.format('a','b','c'))  # 可重复

# 通过下标或key匹配参数
print('通过下标或key匹配参数：')
point = (5,9)
print('x:{0[0]},y:{0[1]}'.format(point)) # x:5,y:9
dic = {'key1':'value1','key2':'value2'}
print('x:{0[key1]},y:{0[key2]}'.format(dic))  # x:value1,y:value2
s = 'hello'
print('{0[0]},{0[1]},{0[0]}'.format(s))  # h,e,h

 2.2：格式转换:

'''
格式转换
'b' - 二进制。将数字以2为基数进行输出。
'c' - 字符。在打印之前将整数转换成对应的Unicode字符串。
'd' - 十进制整数。将数字以10为基数进行输出。
'o' - 八进制。将数字以8为基数进行输出。
'x' - 十六进制。将数字以16为基数进行输出，9以上的位数用小写字母。
'e' - 幂符号。用科学计数法打印数字。用'e'表示幂。
'g' - 一般格式。将数值以fixed-point格式输出。当数值特别大的时候，用幂形式打印。
'n' - 数字。当值为整数时和'd'相同，值为浮点数时和'g'相同。不同的是它会根据区域设置插入数字分隔符。
'%' - 百分数。将数值乘以100然后以fixed-point('f')格式打印，值后面会有一个百分号。
'''

a = 65
b = 66
c = 67
print(chr(a),chr(b),chr(c))
print('{:b}'.format(a))             # 不带编号
print('{2:b}'.format(c,b,a))        # 带编号
print('{name:b}'.format(name = a))  # 带关键字

b = 66
print('{:b}'.format(b))   # 二进制形式输出
print('{0:c}'.format(b))  # 字符形式输出
print('{0:d}'.format(b))  # 十进制数形式输出
print('{0:o}'.format(b))  # 八进制数形式输出
print('{0:x}'.format(b))  # 十六进制数形式输出
print('{0:e}'.format(b))  # 用科学计数法打印数字。用'e'表示幂。
print('{0:g}'.format(b))  # 一般格式。将数值以fixed-point格式输出。当数值特别大的时候，用幂形式打印。
print('{0:n}'.format(b))  # 当值为整数时和'd'相同，值为浮点数时和'g'相同。不同的是它会根据区域设置插入数字分隔符。
print('{0:%}'.format(b))  # 将数值乘以100然后以fixed-point('f')格式打印，值后面会有一个百分号。

 2.3：进阶用法:

2.3.1：进制转换

a = 66
b = '{:#x}'.format(a)
print(a,b)
print('int:{0:d},hex:{0:x},oct:{0:o},bin:{0:b}'.format(a))
print('int:{0:d},hex:{0:#x},oct:{0:#o},bin:{0:#b}'.format(a)) # 在前面加'#'，则带进制前缀

2.3.2：左中右对齐及位数补全

a): <: (默认)左对齐; >:右对齐; ^:中间对齐;=:(只用于数字)在小数点后进行补齐
b): 取位数“{:4s}”、"{:.2f}"等

'''
a): <: (默认)左对齐; >:右对齐; ^:中间对齐;=:(只用于数字)在小数点后进行补齐
b): 取位数“{:4s}”、"{:.2f}"等
'''

s1 = 'hello'
s2 = 'world'
print('1:[{}] and [{}]'.format(s1,s2)) # 默认默认左对齐
print('2:[{:10s}] and [{:>10s}]'.format(s1,s2)) # 取10位左对齐，取10位右对齐
print('3:[{:^10s}] and [{:^10s}]'.format(s1,s2)) # 取10位中间对齐

f1 = 3.145123456
f2 = 3.143
print('4:[{}],[{:.2f}]'.format(f1,f1)) # 原样输出,取2位小数
print('5:[{}],[{:>10.2f}]'.format(f1,f1)) # 原样输出,右对齐，取10位，其中取2位小数

s1 = 'HelloWorld'
print('6:[{:<30}]'.format(s1))  # 左对齐
print('7:[{:>30}]'.format(s1))  # 右对齐
print('8:[{:^30}]'.format(s1))  # 中间对齐
# 填充
print('9:[{:*^30}]'.format(s1))
print('10:[{:0^30}]'.format(s1))

print('11:[{:0=30}]'.format(11))
print('12:[{:0>30}]'.format(11))

运行结果：

2.3.3：正负符号显示

f1 = 3.158
f2 = -3.158
print('1:[{}];[{}]'.format(f1,f2))
print('2:[{:+f}];[{:+f}]'.format(f1,f2)) # 总是显示符号
print('3:[{:f}];[{:f}]'.format(f1,f2)) #
print('4:[{: f}];[{: f}]'.format(f1,f2)) # f前面有空格,若是+数，则在前面留空格
print('5:[{:-f}];[{:-f}]'.format(f1,f2)) # -数时显示-，与'{:f}; {:f}'一致

运行结果：

2.3.4：百分数 %

# 百分数%
print('{:.2f}'.format(1 / 3))  # 0.33
print('{:.2%}'.format(1 / 3))  # 33.33%

2.3.5：时间

import datetime
d = datetime.datetime(2018,12,12,11,29,56)
print('{:%Y-%m-%d %H:%M:%S}'.format(d)) # 2018-12-12 11:29:56

2.3.6：逗号","分隔金钱，没以前进位

# 逗号","分隔金钱，没以前进位
print('{:,}'.format(1234567890123456789)) # 1,234,567,890,123,456,789

2.3.7：占位符嵌套

print('--1:' + '-'*30)
for align, text in zip('<^>', ['left', 'center', 'right']):
    print(align,text)
print('--2:' + '-'*30)
for align, text in zip('<^>', ['left', 'center', 'right']):
    print('{0:{fill}{align}16}'.format(text, fill=align, align=align))
    # print('{0:<<16}'.format(text))
    # print('{0:^^16}'.format(text))
    # print('{0:>>16}'.format(text))
print('--3:' + '-'*30)
octets = [192, 168, 0, 1]
print('{:02X}{:02X}{:02X}{:02X}'.format(*octets))
print('{:0>2X}{:0>2X}{:0>2X}{:0>2X}'.format(*octets))
print('{:0<2X}{:0<2X}{:0<2X}{:0<2X}'.format(*octets))
print('--4:' + '-'*30)
width = 5
for num in range(5,12):
    for base in 'dXob':
        print('{0:{width}{base}}'.format(num,base = base,width = width),end = ' ')
    print('')

运行结果：

2.3.8：占位符%s和%r

"""
replacement_field ::= "{" [field_name] ["!" conversion] [":" format_spec] "}"
conversion ::= "r" | "s" | "a"
这里只有三个转换符号，用"!"开头。
"!r"对应 repr()；"!s"对应 str(); "!a"对应ascii()。
"""

print("repr() shows quotes: {!r}; str() doesn't: {!s};{!a}".format('1234', '1235', '23'))
print(repr('1234'))
print(str('1234'))
s = repr('234')
print(s,type(s))
print(ascii('65'))

 2.4：format的用法变形:

# 1: a.format(b)
s1 = 'Hello'
s2 = 'World'
print('{0} {1}'.format(s1,s2))

# 2: f'xxxxxx'
# 可以在字符串前加f以达到格式化的目的，在{}里加入对象，此为format的另一种形式：
s1 = 'Hello'
s2 = 'World'
print(f'{s1} {s2}')
print(f'{len(s1)} {s2.count("o")} {s2.upper()}') # 还可以使用函数


name = '你大爷'
age = 18
sex = 'Man'
job = "IT"
salary = 8888.9868

print(f'my name is {name.capitalize()}. the len of {name} is {len(name)}')
print(f'I am {age:*^10} years old.')
print(f'I am a {sex}')
print(f'My salary is {salary:10.3f}')