python123子字符串输出_Python字符串格式化方法1

类C语言格式化

使用print或printf输出，比较接近C语言的输出方式，基本格式如下：

"%格式符 %格式符....%格式符" % (对象1, 对象2,....对象n)

类C语言格式化使用%号来分隔左边的字符串模版和右边要被格式化的对象，就像是在左边挖了很多个坑，然后用右边的对象填进去。但是左边的坑有多大，能填什么类型的对象。都是由格式符号来决定的。常见的格式符号有：

d,i 带符号的十进制数

o 不带符号的八进制数

u 不带符号的十进制数

x 不带符号的十六进制(小写)

X 不带符号的十六进制(大写)

e 科学计数法表示的浮点数(小写)

E 科学计数法表示的浮点数(大写)

f,F 十进制浮点数

g 如果指数大于-4或者小于精度值则和e相同，其他情况与f相同

G 如果指数大于-4或者小于精度值则和E相同，其他情况与F相

c 单字符(接收整数或单字符字符串)

r 字符串(使用repr转换任意Python对象)

s 字符串(使用str转换任意Python对象)

a ASCII字符

看起来很多，但是常用的基本上只有d, i, e, f, s这几个。我们在表里看一下它们的作用是什么，把直接给常用的记住就行，其他特殊类型的格式符号都是在使用的时候才去查询。

看完用法以后，我们来简单看几个示例：

整数和字符串输出

>>> "My name is %s, my age is %d years old" % ('afei', 30)

'My name is afei, my age is 30 years old'

# 浮点数输出

>>> import math

>>> "π 的值是：%f" % (math.pi)

'π 的值是：3.141593'

# 八进制和十六进制输出

>>> "%d translate to oct is %o" % (255, 255)

'255 translate to oct is 377'

>>> "%d translate to hex is %x" % (255, 255)

'255 translate to hex is ff'

# 十六进制大写

>>> "%d translate to hex is %X" % (255, 255)

'255 translate to hex is FF'

# 科学计数法

>>> "%f 对应的科学计数法的值是：%e " % (314.15926, 314.15926)

'314.159260 对应的科学计数法的值是：3.141593e+02 '

# 输出对象

>>> class Demo:

... def __str__(self):

... return "This is a demo class"

... def __repr__(self):

... return "This is a demo info for machine, not for human"

...

>>> demo = Demo()

>>> "demo is %s" % (demo)

'demo is This is a demo class'

>>> "demo is %r" % (demo)

'demo is This is a demo info for machine, not for human'

上面的示例中简单的演示了常见的几种格式符号的用法。但是在实际的项目中，还会遇到很多其他的需求，例如

字符串对齐怎么处理

每一列怎么设置宽度

怎么设置小数后面的输出精度

而想要解决这些问题，就需要用到更高级的格式，像下面这样的格式，就是更高级的用法：

"%[(name)][flags][width][.precision] typecode" % (对象,)

这个复杂格式化里面的字段含义如下：

(name) 表示根据名称自动解析后面的对象，一般是字典(不需要解包)。

flags 转换标志，默认是右对齐，- 表示左对齐，+ 表示在转换值前面加上正负号，0表示转换值宽度不够时用0填充。

width 输出字符串的宽度，一般是一个数字表示的值，例如20。

precision 设置小数点后有效数字位数，当precision为*号时，由后面的值给出。

typecode：即上面列出来的格式符号类型

同样的，通过示例来演示更为直观：

# 演示name的用法

>>> "My name is %(name)s, and my age is %(age)d" % ({'name':'afei', 'age':30})

'My name is afei, and my age is 30'

# 演示flags和width的用法

# 单个左对齐和15的宽度

>>> dict = {'name':['zhangsan', 'lisi', 'wangwu', 'afei'], 'age':[25, 26, 27, 28, 30]}

>>> for name, age in zip(dict['name'], dict['age']):

... print("%-15s %15d" % (name, age))

...

zhangsan 25

lisi 26

wangwu 27

afei 28

# 两个元素全部左对齐和15的宽度

>>> for name, age in zip(dict['name'], dict['age']):

... print("%-15s %-15d" % (name, age))

...

zhangsan 25

lisi 26

wangwu 27

afei 28

# 小数点的用法，3、4、2位小数

>>> "%-15.3f %-15.4f %15.2f" % (1/3, 1/4, 1/6)

'0.333 0.2500 0.17'

>>> "%-15.*f" % (3, 1234.56789)

'1234.568 '

这里要注意的是：

格式符号和后面的对象类型要匹配，不匹配的时候会出现一些问题，小数点是用来分隔宽度和小数点位数的，别忘了带上。不匹配的时候会出现什么问题呢？来看一下示例：

# 精度丢失

>>> "%-15.3d" % (1/3)

'000 '

# 类型不匹配异常

>>> "%-15.3d" % ('0537')

Traceback (most recent call last):

File "", line 1, in

TypeError: %d format: a number is required, not str

这两个问题是最常见的，大家在使用的时候一定要注意。

格式化调用方法——format方法

因为类C格式化方法的用法和python的哲学并不匹配，Python的哲学是简单，就是要让学习难度更低。于是Python发展出了自己的格式化方法format。format格式化方法使用起来语法相对更加简单，不需要记忆各种格式化符号，基本用法只需要一个花括号就可以了，像下面这样：

"{} {}.... {}".format(对象1, 对象2, ....对象n)

就像是字符串的一个内置方法调用，左边准备格式化的字符串中使用花括号设置待格式化对象的位置，然后format方法里传入对应个数的变量即可。同时，它还支持以下特性

根据format方法的参数位置来指定对象的位置

支持序列解包

支持关键字

支持对象属性访问

下面我们来看一下基本用法的几个示例：

# 位置自动匹配

>>> "My name is {}, age is {}".format('afei', 30)

'My name is afei, age is 30'

# 位置精确匹配

>>> "My name is {1}, age is {0}".format(30, 'afei')

'My name is afei, age is 30'

# 关键字匹配

>>> "My name is {name}, age is {age}".format(age=30, name='afei')

'My name is afei, age is 30'

# 序列解包

>>> "My name is {}, age is {}".format(*['afei', 30])

'My name is afei, age is 30'

# 字典键值对应，这里的字典对象也需要解包后才能匹配，和关键字匹配类似

>>> "My name is {name}, age is {age}".format(**{'name': 'afei', 'age':30})

'My name is afei, age is 30'

# 位置匹配和关键字匹配混用，这里要注意，位置参数要在关键字参数之前

>>> "My name is {name}, age is {0}".format(19, name='afei')

'My name is afei, age is 19'

# 点号访问属性

>>> class Person:

... def __init__(self, name, age):

... self.name = name

... self.age = age

...

>>> p = Person('afei', 30)

>>> "My name is {0.name}, age is {0.age}".format(p)

'My name is afei, age is 30'

但是在使用过程中，format格式化也会遇到和类C格式化相同的问题，例如对齐、小数位数等。format方法也因此提供了和类C格式化同样的高级用法，高级用法的基本格式是：

{[field_name]!conversion:formatspec}

但是这里面的formatspec又可以划分为更细致的格式化类型，如下所示：

[[fill][align]][sign][#][0][width][separate][.precision][typecode]

也就是说，组合起来，变成了下面这个样子

"{[field_name]![conversion]:[[fill][align]][sign][#][0][width][separate][.precision][typecode]}".format('test')

也就是说，这种格式化方法，从简单的使用上，它确实更简单了，就像上面简单用法里的几个示例一样。但是从功能上说，无疑是变得更强大，也更复杂了。你想实现更高级的定制，就得学习它更高级的用法。我们来看一下它对应的参数怎么使用。

格式参数解释：

field_name 两种形式，以0，1，2这样的形式时，表示根据位置来查找变量，以关键字形式时，表示字典格式化，对应字典中的键值。这个在上面简单用法的示例里演示过

conversion 表示转换格式，支持三种类型，分别是s|r|a，即str、repr、ascii三种格式的字符串。一般用于类对象的输出，默认是str。

fill 填充字符，可以是除'{'、'}'外的任意字符，即当你设置字符串的输出宽度时，空白位置用什么东西来填充。

align 字符串对齐方式

'

'>' 右对齐

'=' 仅用于数字对齐，将填充字符放在数字符号和数字之间，而不是数字符号外面或数字后面。

'^' 居中对齐

sign 仅针对数字类型

'+' 表示正负数都要带上符号

'-' 表示只有负数带上符号，正数不需要，默认选项

space 表示正数前面要带一个空格，负数前面带'-'号

用来切换不同进制的数字显示形式，十进制没有区别。

separate 用来分隔数字的符号，例如使用逗号分隔1,234.5，使用_号分隔，1_234.5

width 对齐宽度

.precision 输出小数时，数字的有效位数，当后面带上格式符号 f 时，表示小数点后有效位数，如果不带，则表示整个数字的有效位数。

typecode 输出的格式，和类C语言格式化里的用法一样，有以下值：

·"b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"

看起来格式很多，多练习几次也就熟练了，我们来看一下几个示例：

# 演示conversion用法，-号填充，居中对齐，输出宽度20，

>>> class Demo:

... def __str__(self):

... return 'str format'

... def __repr__(self):

... return 'REPR FORMAT'

...

>>> demo = Demo()

# 对象str格式化

>>> '{!s:-^20}'.format(demo)

'-----str format-----'

# 对象repr格式化

>>> '{!r:-^20}'.format(demo)

'----REPR FORMAT-----'

# 左对齐

>>> '{!s:-<20}'.format(demo)

'str format----------'

# 右对齐

>>> '{!s:->20}'.format(demo)

'----------str format'

# 0填充

>>> '{!s:0>20}'.format(demo)

'0000000000str format'

# =号用于数字对齐，

>>> '{:0>15}'.format(-0.123)

'000000000-0.123' # 填充字符在符号数字外面

>>> '{:0=15}'.format(-0.123)

'-0000000000.123' # 填充字符在负号和数字中间

# 正负数符号示例，这个时候不要和对齐方式混用，会报错。

>>> '{:-f};{:+f}'.format(-0.123, 0.123)

'-0.123000;+0.123000'

>>> '{:-f};{: f}'.format(-0.123, 0.123)

'-0.123000; 0.123000'

# 逗号和下划线分隔符

>>>'{0:<40,.5}'.format(1234.5678)

'1,234.6 '

>>> '{0:<15_.5}'.format(1234.5678)

'1_234.6 '

# 数字位数

>>> '{:.3f} {:.4f}'.format(-0.123, 0.123)

'-0.123 0.1230'

# 二进制、八进制、十进制和十六进制输出，没有#号

>>> "{0} 的二进制值是{0:b}".format(100)

'100 的二进制值是1100100'

>>> "{0} 的八进制值是{0:o}".format(100)

'100 的八进制值是144'

>>> "{0} 的十进制值是{0:d}".format(100)

'100 的十进制值是100'

>>> "{0} 的十六进制值是{0:x}".format(100)

'100 的十六进制值是64'

# 二进制、八进制、十进制和十六进制输出，有#号

>>> "{0} 的二进制值是{0:#b}".format(100)

'100 的二进制值是0b1100100'

>>> "{0} 的八进制值是{0:#o}".format(100)

'100 的八进制值是0o144'

>>> "{0} 的十进制值是{0:#d}".format(100)

'100 的十进制值是100'

>>> "{0} 的八进制值是{0:#x}".format(100)

'100 的八进制值是0x64'

# 变量嵌套

>>>'{0:{fill}{align}{width}}'.format('test',fill='-',align='^',width='40')

'------------------test------------------'

以上就是Python格式化最经典的两种用法，下一节的内容会讲解Python 新引入的格式化方法f-string字符串格式化，看一下这种更灵活的字符串格式化方法。