Python·.·.print()函数格式化输出

print()函数格式为：

print(objects, sep=' ', end='\n', file=sys.stdout)

文章目录

Python·.·.print()函数格式化输出
1 简易输出
- 1.1 sep间隔
- 1.2 end结尾
- 1.3 写入file
2 %方式
- 2.1 打印浮点数
- 2.2 打印浮点数(指定保留小数点位数)
- 2.3 指定占位符宽度
- 2.4 指定占位符宽度(左对齐、右对齐)
- 2.5 指定占位符
- 2.6 用词典来传递真实值
3 format函数
- 3.1 带数字编号-关键字
- 3.2 内嵌式
- 3.3 对齐控制
- 3.4 进制转化
- 3.5 千位分隔符
4 eval()函数
5 lambda匿名函数
- 5.1 定义加法函数
- 5.2 使用if判断奇偶性
- 5.3 无参数表达式
- 5.4 列表排序
6 round()函数(不推荐使用)
7 decimal模块

1 简易输出

1.1 sep间隔

sep为对象的间隔，默认为一个空格

print(1,2,3)
#1 2 3print(1,2,3,sep = 't')
#1t2t3

1.2 end结尾

end为结尾，默认为\n换行字符

print(1,2,3,end = '2')
#1 2 32

1.3 写入file

file = 后为要写入文件的文件名

fp = open('D:/hello.txt','a+')
#a+的意思是如果d盘没有这个文件就创建这个文件，如果有就在文件内容后追加
print(1,2,3,file = fp)   #fp是一个变量
fp.close()            #关闭这个文件

向helloxd.txt文本文件，写入“1 2 3”。

2 %方式

格式符为真实值预留位置，并控制显示的格式。格式符可以包含有一个类型码，用以控制显示的类型。

%s 字符串 (采用str()的显示)
%r 字符串 (采用repr()的显示)
%c 单个字符
%b 二进制整数
%d 十进制整数
%i 十进制整数
%o 八进制整数
%x 十六进制整数%% 字符”%”`%e 用科学计数法格式化浮点数
%E 作用同%e，用科学计数法格式化浮点数%g, %f和%e的简写%G %f 和 %E 的简写%p 用十六进制数格式化变量的地址%f ——保留小数点后面六位有效数字%.3f，保留3位小数位%e ——保留小数点后面六位有效数字，指数形式输出%.3e，保留3位小数位，使用科学计数法%g ——在保证六位有效数字的前提下，使用小数方式，否则使用科学计数法%.3g，保留3位有效数字，使用小数或科学计数法

可以用如下的方式，对格式进行进一步的控制：

%[(name)][flags][width].[precision]typecode
(name)为命名flags可以有+,-,’ ‘或0。
+表示右对齐。
-表示左对齐。
’ ‘为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。
0表示使用0填充。
width表示显示宽度, precision表示小数点后精度

示例：

a=14
b="LOVE"
print('今年是%d岁，喜欢%s学校'%(a,b))<
#今年是14岁，喜欢LOVE学校
nHex = 0xABC
print("nHex = %x,nDec = %d,nOct = %o" %(nHex,nHex,nHex))
#nHex = abc,nDec = 2748,nOct = 5274

顺序位置：{} 占位符

2.1 打印浮点数

print ("His height is %f m"%(1.83))
#His height is 1.830000 m

2.2 打印浮点数(指定保留小数点位数)

print ("His height is %.2f m"%(1.83))
#His height is 1.83 m

2.3 指定占位符宽度

print ("Name:%10s Age:%8d Height:%8.2f"%("Aviad",25,1.83))
#Name:     Aviad Age:      25 Height:    1.83

2.4 指定占位符宽度(左对齐、右对齐)

print ("Name:%-10s Age:%-8d Height:%-8.2f"%("Aviad",25,1.83))
#Name:Aviad      Age:25       Height:1.83print("%+10x" % 10)
print("%04d" % 5)
print("%6.3f" % 2.3)
#        +a
#0005
# 2.300

2.5 指定占位符

print ("Name:%-10s Age:%08d Height:%08.2f"%("Aviad",25,1.83))
#Name:Aviad      Age:00000025 Height:00001.83

2.6 用词典来传递真实值

print ("I'm %(c)s. I have %(l)d yuan." % {'c':'hungry','l':22})
#I'm hungry. I have 22 yuan.

3 format函数

该方法亦会进行四舍五入

print('中国诗人{}，他的称号{}'.format('李白','诗仙'))
#中国诗人李白，他的称号诗仙
print('中国诗人{0}，他的称号{1}'.format('李白','诗仙'))
#中国诗人李白，他的称号诗仙

（1）不带编号，即“{}”
（2）带数字编号，可调换顺序，即“{1}”、“{2}”
（3）带关键字，即“{a}”、“{tom}”

3.1 带数字编号-关键字

>>> print('{} {}'.format('hello','world'))
#hello world
>>> print('{0} {1}'.format('hello','world'))
#hello world
>>> print('{0} {1} {0}'.format('hello','world'))
#hello world hello
>>> print('{1} {1} {0}'.format('hello','world'))
#world world hello
>>> print('{a} {tom} {a}'.format(tom='hello',a='world'))
#world hello world

3.2 内嵌式

time='2020-11-14'
age = 20
print(f'时间是：{time},年龄是：{age}')
#时间是：2020-11-14,年龄是：20

f = 2.3456789print('{:.2f}'.format(f))
#2.35
print('{:.3f}'.format(f))
#2.346
print('{:.4f}'.format(f))
#2.3457

3.3 对齐控制

填充和对齐^<>分别表示居中、左对齐、右对齐，后面带宽度

print('{关键字1}{关键字2}'.format(关键字1="x",关键字2=56))
#通过关键字
#x56
print('{0}在{1}'.format('某某人','写代码'))
#通过位置
#某某人在写代码print('{:^30}'.format("zhangsan"))
#居中对齐
#            zhangsan
print('{:>30}'.format("zhangsan"))
#右对齐
#                       zhangsan
print('{:<30}'.format("zhangsan"))
#zhangsan
#左对齐print('{:.2f}'.format(3.14159))
#保留两位小数，两位后四舍五入
#3.14
print('{:.5f}'.format(3.14))
#保留5位小数，不足补0.
#3.14000

3.4 进制转化

b o d x 分别表示二、八、十、十六进制

print('{:b}'.format(20))
#10100
print('{:o}'.format(20))
#24
print('{:d}'.format(20))
#20
print('{:x}'.format(20))
#14

3.5 千位分隔符

print('{:,}'.format(100000000)) #插入千分号分隔符
#100,000,000
print('{:,}'.format(123456.123456)) #插入千分号分隔符
#123,456.123456

4 eval()函数

将字符串当成有效表达式来求值并返回计算结果。

eval函数的作用是去掉字符串最外面的一对引号，然后把去掉最外侧引号的字符串通过python语句的方式进行操作

变量是为了获取去掉引号后的值，以便进行操作，可同input()函数一起使用，获得用户输入的数值，使用方式为变量=eval(input())

x = 7
y = eval('3 * x')
print(y)
#21

m = 3
n = 5
r = eval('m + n')
print(r)
#8

5 lambda匿名函数

lambda 匿名函数一般形式

lambda arguments: expression

写成函数形式

def <lambda>(arguments):return expression

lambda函数与 def 函数的区别：

lambda可以立刻传递(无需变量) ，自动返回结果;
lambda在内部只能包含一行代码 ;
lambda是一个为编写简单的函数而设计的，而 def 用来处理更大的任务;
lambda可以定义一个匿名函数，而 def 定义的函数必须有一个名字。

对于单行函数,使用 lambda表达式可以省去定义函数的过程，让代码更加简洁；
对于不需要多次复用的函数，使用lambda表达式可以在用完之后立即释放，提高程序执行的性能。这里是引用

5.1 定义加法函数

#def函数写法
def add(a, b):
return a + b
print(add(10, 20))
#30

#lambda函数写法
add_lambda = lambda a, b: a + b
print(add_lambda(10, 20))
#30

5.2 使用if判断奇偶性

# ef函数写法
def get_odd_even(x):
if x % 2 == 0:return "偶数"
else:return "奇数"
print(get_odd_even(10))
#偶数#lambda函数写法
get_odd_even1 = lambda x: "偶数" if x % 2 == 0 else "奇数"
print(get_odd_even1(10))
#偶数
print(get_odd_even1(9))
#奇数

5.3 无参数表达式

#def函数写法
def test1():return "Python YYDS!!!"
print(test1())
#Python YYDS!!!#lambda函数写法
test2 = lambda: "Python YYDS!!!"
print(test2())
#Python YYDS!!!

5.4 列表排序

map方法混搭(常用)：(遍历序列，对序列中每个元素进行操作，最终获得新的序列)

dict = {'c': 1, 'b': 2, 'a': 3}
print(sorted(dict))
#['a', 'b', 'c']
print(sorted(dict, reverse=True))
#['c', 'b', 'a']

list = [[4, 2, 9], [1, 5, 6], [7, 8, 3]]
# 以列表中列表的第一个数排序
print(sorted(list, key=lambda k: k[0]))
# [[1, 5, 6], [4, 2, 9], [7, 8, 3]]
# 以列表中列表的第二个数排序
print(sorted(list, key=lambda k: k[1]))
# [[4, 2, 9], [1, 5, 6], [7, 8, 3]]
# 以列表中列表的第一个数排序，且降序
print(sorted(list, key=lambda k: k[0], reverse=True))
# [[7, 8, 3], [4, 2, 9], [1, 5, 6]]

dic = {'a': [1, 2, 3],'b': [2, 1, 3],'c': [3, 1, 2],
}
print(sorted(dic, key=lambda k: dic[k][0]))
# ['a', 'b', 'c']
print(sorted(dic, key=lambda k: dic[k][1]))
# ['b', 'c', 'a']
print(sorted(dic, key=lambda k: dic[k][2]))
# ['c', 'b', 'a']
print(sorted(dic, key=lambda k: dic[k][0], reverse=True))
# ['c', 'b', 'a']

6 round()函数(不推荐使用)

round函数的进位规则为“四舍六入五凑偶”。

round函数带有一点点的小坑，不推荐使用。

print(round(2.25,1))
#2.2
print(round(2.35,1))
#2.4
print(round(2.125,2))
#2.12
print(round(2.875,2))
#2.88

但更换数据，再看一下结果

print(round(2.335,2))
#2.33
print(round(2.325,2))
#2.23print(round(6.785,2))
#6.79

此时，与结论不一致，原因在于机器中浮点数不一定被精确的表达，在转换成01后可能为无限位，机器会进行截断处理，所以会和浮点数的精确值有一定的出入，从而无法达到预期目标。

如果对浮点数没有精度要求时，可以使用round函数。
如果对浮点数的精度要求较高，推荐使用decimal模块。

7 decimal模块

python原生数据类型在进行浮点运算时，可能会由于精度问题导致计算结果不准确，尤其是浮点数和较大的数据进行运算，所以如果对数据精度有要求，比如说金额，就需要使用decimal库。

decimal的精度默认是28位，可自定义。通过getcontext获取线程上下文，然后修改prec属性即可。

from decimal import Decimal, getcontext
print(getcontext().prec)  # 计算精度，默认是28
#28
getcontext().prec = 100  # 可修改

可以通过实例化Decimal对象时传入value参数，把其他的数据类型转换成Decimal类型。

注意，尽量传入整数和字符串，如果传入float,会导致结果不准确（float本身就存在精度问题）

a = Decimal("5632569878.6514126")
print(a)
# Decimal(5632569878.6514126)
b = Decimal("7")
print(b)
# Decimal(7)
c = Decimal(63)
print(c)
# Decimal(63)
d = Decimal.from_float(6.325)
print(d)
#Decimal(6.32500000000000017763568394002504646778106689453125), 28位不准确

Decimal类型也仿照python基本数据类型，进行加减乘除等运算。

a = Decimal("8.651")  # Decimal(8.651)
b = Decimal("7")  # Decimal(7)
print(type(a + b), a + b)
#<class 'decimal.Decimal'> 15.651
print(a - b, )
#Decimal(1.651)
print(a * b, )
#Decimal(60.557)
print(a / b, )
#Decimal(1.235857142857142857142857143)
print(a // b, )
#Decimal(1)
print(a ** 2, )
#Decimal(74.839801)