普通格式化方法
(%s%d)生成格式化的字符串, 其中 s 是一个格式化字符串, d 是一个十进制数;
格式化字符串包含两部分: 普通的字符和转换说明符(见下表),
将使用元组或映射中元素的字符串来替换转换说明符;
** 如果 d 是元组的话, 必须与 s 中的转换说明符个数一致;
如果 d 是 dict 的话, 每个转换说明符都必须与 dict 中一个有效的键名相关联.**
转换说明符, 都以 % 开始 | 输出格式 |
---|---|
d,i | 十进制 |
u | 无符号数 |
o | 八进制 |
x | 十六进制或长整数 |
X | 十六进制 |
f,e,E | 浮点数 |
g,G | 指数小于 - 4 时使用 |
s | 字符串或者任意对象, 同 str 生成的字符串 |
r | 同 repr 生成的字符串 |
3. 在 % 字符和转换字符之间, 可以出现以下修饰符, 并且只能按照以下顺序出现,
位于括号中的一个键名, 用于从 dict 中获取这个 key 对应的值, 如果不存在 key, 则引发异常;
下面中的一个或者多个:
-, 左对齐标志, 默认为右对齐;
+, 表示应该包含数字的正负号;
0, 表示用 0 来填充;
指定最小自动宽度的数字. 转换后的值将被打印在至少为这个宽度的字符串中, 并且在左边填充空格至满字段宽(如果指定了 - 标志, 则在右边填充);(如果字符串本身的长度大于指定宽度, 则这个宽度就没用啦).
一个小数点, 用于按照精度分割字段宽度;
一个数字, 指定要打印字符串中最大字符个数, 浮点数中小数点之后的位数或整数的最小位数;
* 用于任意宽度的字段中替换数字. 如果存在, 宽度将从元组的下一项开始读取;(有点晕啊 - -, 结合下面代码看就容易理解了)
- #!/usr/bin/python
- # -*- coding: utf-8 -*-
- a = {"name":'ljs',"age":22,'weight':75}
- print "%(name)s %(age)d %(weight)d;"%a #ljs 22 75;
- # 将已经定义的变量扩展到字符串中
- name = 'ljs'
- age = 22
- weight = 75
- r = "%(name)s %(age)d %(weight)d;"%vars()
- print r #ljs 22 75;
- print vars() #vars()函数包含一个此时已定义的所有变量的字典
- #2 and 3
- a = 'abc'
- b = 100
- c = -100
- print "%d"%(a,b) #error
- print "%10s ;"%a # abc ; 最小宽度为 10, 宽度不足 10, 默认为右对齐, 向左补充空格直至宽度为 10
- print "%-10s ;"%a #abc ; 最小宽度为 10, 宽度不足 10,- 为左对齐标志, 向右补充空格直至宽度为 10
- print "%+10s ;"%a # abc ; 字符串没有符号, so 标志 + 不起作用
- print "%010s ;"%a # abc ; 不是数字, 不用填充 0, 所以标志 0 不起作用
- print "%10d ;"%b # 100 ; 最小宽度为 10, 宽度不足 10, 默认为右对齐, 向左补充空格直至宽度为 10
- print "%-10d ;"%b #100 ; 最小宽度为 10, 宽度不足 10,- 为左对齐标志, 向右补充空格直至宽度为 10
- print "%+10d ;"%b # +100 ; 打印出符号
- print "%+10d ;"%c # -100 ; 打印出符号
- print "%+010d ;"%b #+000000100 ; 填充 0 至宽度为 10
- #4 5
- a = 1.23456
- print "%f"%a #1.234560; 正常打印
- print "%3f"%a #1.234560; 最小宽度为 3, 但是长度已经超过了 3,so 正常打印
- print "%10f"%a # 1.234560; 最小宽度为 10, 宽度不足 10, 默认为右对齐, 向左补充空格直至宽度为 10
- print "%.3f"%a #1.235; 小数点后的数字为精度, 小数点后保留 3 位
- print "%.10f"%a #1.2345600000; 小数点后位数不足 10, 补 0 至位数为 10
- #6
- a = 123456.7890123456
- print "%*.*f;"%(15,5,a) # 123456.78901; 第一个 * 为最小宽度, 第二个 * 为小数点后面的精度
- print "%-*.*f;"%(15,5,a)#123456.78901 ;
高级字符串格式化
字符串的 format()函数, 该方法收集位置参数和关键字参数的任意集合, 并使用它们的值来替换字符串中的占位符;
形式为 {n}(n 为整数) 的占位符将被 format()方法第 n 个参数所代替;
形式为 {name} 的占位符将被参数中为 name 的参数所替代;
如果要用 format()输出{xx}, 必须使用{{xx}}, 否则会因为找不到对应的参数值而报错;
可以指定格式说明符, 对输出进行更加精确地控制.
给每个占位符添加可选的格式说明符号, 如{name:format_spec}. 这种说明符可指定列宽, 小数位和对齐方式.
一般格式[fill,align,sign,0,width,.precision,type], 每一处都是可选的.
fill: 是一个可选的填充字符, 用于填充空白, 默认为空格;
align, 对齐方式.<,>,^ 分别代表左, 右, 居中对齐, 默认为右对齐;
sign, 取值为:
+, 所有数字签名都要加上符号;
-, 默认值, 只在负数签名加符号;
空格, 在正数前面加上一个空格;
0, 在宽度前面加 0 表示用 0 来填充数值前面的空白;
width, 宽度;
.precision, 精度的位数;
type, 数据类型, 如 d(整数),s(字符串)等
某些情况下, 可能只是要格式化对象的 str()或 repr()表示, 需要绕过__format__()方法. 为此, 可以在格式说明符前面添加! r 或! s 说明符, 如果不懂见下面代码.
- #!/usr/bin/python
- # -*- coding: utf-8 -*-
- '''
- help(str.format)
- Help on method_descriptor:
- format(...)
- S.format(*args, **kwargs) -> string
- Return a formatted version of S, using substitutions from args and kwargs.
- The substitutions are identified by braces ('{' and '}').
- '''print"{{a}}".format() #{a}
- print "{a}".format() #error, 里面没有为 a 的参数
- print "{a} - {b}".format(a = 100,b = 200)#100 - 200
- print "{0},{0}".format(11,22) #11,11
- print "{0},{0},{1},{2}".format(11,22,33) # 11,11,22,33 中括号里面的数代表第几个参数
- print "{0:3d},{1:4s},{1:5s},{2}".format(11,"a",33) # '11,a ,a ,33'
- print "{0:=>+011.3f};".format(12.12345) #====+12.123; 用 = 来填充, 右对齐, 因为已经用 = 来填充了, 0 无效, 宽度 11, 小数点精度后精度为 3, 类型为浮点数
- print "{0:>+011.3f};".format(12.12345) #0000+12.123;
- a = "test"
- print "{0:^10}".format(a) #test
- print "{0!s:^10}".format(a) #test
- print "{0!r:^10}".format(a) #'test'
- # 通过下标也行
- a=[1,2]
- print '{0[0]},{0[1]}'.format(a) #1,2
- # 对象属性
- class Test(object):
- def __init__(self,name,age):
- self.name,self.age = name,age
- def __str__(self):
- return 'This boy is {self.name},is {self.age} old'.format(self=self)
- def str(self):
- return self.__str__()
- a = Test('lilei',12)
- print str(a) #This boy is lilei,is 12 old
- print a.str() #This boy is lilei,is 12 old
- #format 函数单独使用
- format('abc',"10s") #'abc'
总而言之, 将 format()里面的参数视为一个正常的参数, 这个对象该有的属性在字符串 (s.format() 中的 s )里面也能使用!!!
它通过 {} 和: 来代替 %.
"映射" 示例
通过位置
- In [1]: '{0},{1}'.format('kzc',18)
- Out[1]: 'kzc,18'
- In [2]: '{},{}'.format('kzc',18)
- Out[2]: 'kzc,18'
- In [3]: '{1},{0},{1}'.format('kzc',18)
- Out[3]: '18,kzc,18'
字符串的 format 函数可以接受不限个参数, 位置可以不按顺序, 可以不用或者用多次, 不过 2.6 不能为空{},2.7 才可以.
通过关键字参数
- In [5]: '{name},{age}'.format(age=18,name='kzc')
- Out[5]: 'kzc,18'
通过对象属性
- class Person:
- def __init__(self,name,age):
- self.name,self.age = name,age
- def __str__(self):
- return 'This guy is {self.name},is {self.age} old'.format(self=self)
- In [2]: str(Person('kzc',18))
- Out[2]: 'This guy is kzc,is 18 old'
通过下标
- In [7]: p=['kzc',18]
- In [8]: '{0[0]},{0[1]}'.format(p)
- Out[8]: 'kzc,18
有了这些便捷的 "映射" 方式, 我们就有了偷懒利器. 基本的 python 知识告诉我们, list 和 tuple 可以通过 "打散" 成普通参数给函数, 而 dict 可以打散成关键字参数给函数(通过和 *). 所以可以轻松的传个 list/tuple/dict 给 format 函数. 非常灵活.
格式限定符
它有着丰富的的 "格式限定符"(语法是 {} 中带: 号), 比如:
填充与对齐
填充常跟对齐一起使用
^,<,>分别是居中, 左对齐, 右对齐, 后面带宽度
: 号后面带填充的字符, 只能是一个字符, 不指定的话默认是用空格填充
比如
- In [15]: '{:>8}'.format('189')
- Out[15]: '189'
- In [16]: '{:0>8}'.format('189')
- Out[16]: '00000189'
- In [17]: '{:a>8}'.format('189')
- Out[17]: 'aaaaa189'
精度与类型 f
精度常跟类型 f 一起使用
- In [44]: '{:.2f}'.format(321.33345)
- Out[44]: '321.33'
其中. 2 表示长度为 2 的精度, f 表示 float 类型.
其他类型
主要就是进制了, b,d,o,x 分别是二进制, 十进制, 八进制, 十六进制.
- In [54]: '{:b}'.format(17)
- Out[54]: '10001'
- In [55]: '{:d}'.format(17)
- Out[55]: '17'
- In [56]: '{:o}'.format(17)
- Out[56]: '21'
- In [57]: '{:x}'.format(17)
- Out[57]: '11'
用, 号还能用来做金额的千位分隔符.
- In [47]: '{:,}'.format(1234567890)
- Out[47]: '1,234,567,890'
来源: http://www.bubuko.com/infodetail-2685786.html