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 3
print(1,2,3,sep = 't')
#1t2t31.2 end结尾
end为结尾，默认为\n换行字符
print(1,2,3,end = '2')
#1 2 321.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 m2.2 打印浮点数(指定保留小数点位数)
print ("His height is %.2f m"%(1.83))
#His height is 1.83 m2.3 指定占位符宽度
print ("Name:%10s Age:%8d Height:%8.2f"%("Aviad",25,1.83))
#Name: Aviad Age: 25 Height: 1.832.4 指定占位符宽度(左对齐、右对齐)
print ("Name:%-10s Age:%-8d Height:%-8.2f"%("Aviad",25,1.83))
#Name:Aviad Age:25 Height:1.83
print("%+10x" % 10)
print("%04d" % 5)
print("%6.3f" % 2.3)
# +a
#0005
# 2.3002.5 指定占位符
print ("Name:%-10s Age:%08d Height:%08.2f"%("Aviad",25,1.83))
#Name:Aviad Age:00000025 Height:00001.832.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 world3.2 内嵌式
time='2020-11-14'
age = 20
print(f'时间是：{time},年龄是：{age}')
#时间是：2020-11-14,年龄是：20f = 2.3456789
print('{:.2f}'.format(f))
#2.35
print('{:.3f}'.format(f))
#2.346
print('{:.4f}'.format(f))
#2.34573.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.140003.4 进制转化
b o d x 分别表示二、八、十、十六进制
print('{:b}'.format(20))
#10100
print('{:o}'.format(20))
#24
print('{:d}'.format(20))
#20
print('{:x}'.format(20))
#143.5 千位分隔符
print('{:,}'.format(100000000)) #插入千分号分隔符
#100,000,000
print('{:,}'.format(123456.123456)) #插入千分号分隔符
#123,456.1234564 eval（)函数
将字符串当成有效表达式来求值并返回计算结果。
eval函数的作用是去掉字符串最外面的一对引号，然后把去掉最外侧引号的字符串通过python语句的方式进行操作
变量是为了获取去掉引号后的值，以便进行操作，可同input()函数一起使用，获得用户输入的数值，使用方式为变量=eval（input())
x = 7
y = eval（'3 * x')
print(y)
#21m = 3
n = 5
r = eval（'m + n')
print(r)
#85 lambda匿名函数
lambda 匿名函数一般形式
lambda arguments: expression写成函数形式
def <lambda>(arguments):
return expressionlambda函数与 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))
#305.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.23
print(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)
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
