python format用法

发表于 分类于 ，

作用

str.format() 方法通过字符串中的花括号 {} 来识别替换字段 replacement field，从而完成字符串的格式化。

用法

  • 省略字段名

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    # 花括号内省略字段名，传递位置参数。

    >>> 'name {}, age {}'.format('Lucy', 20)
    'name Lucy, age 20'

    >>> 'name {}, age {}'.format('Lucy', 20, 'blue')			
    'name Lucy, age 20'

    >>> 'name {}, age {}'.format('Lucy')			
    Traceback (most recent call last):
      File "<pyshell#86>", line 1, in <module>
        'name {}, age {}'.format('Lucy')
    IndexError: tuple index out of range

    注：花括号个数不多于位置参数的个数。

  • 下标索引传参

    可以通过数字形式的简单字段名传递位置参数。
    数字必须是大于等于 0 的整数。
    带数字的替换字段可以重复使用。
    数字形式的简单字段名相当于把 format 中的所有位置参数整体当作一个元组，通过字段名中的数字进行取值。
    即 {0} 等价于 tuple[0]，所以花括号内的数字不能越界。

    1
    2
    >>> 'name {0}, color {2}, age {1}'.format('Lucy', 20, 'Bule')
    'name Lucy, color Bule, age 20'

  • 关键字传参

    使用变量名形式的简单字段名传递关键字参数。

    关键字参数的位置可以随意调换。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    # 用法一
    >>> 'name {name}, color {color}, age {age}'.format(name='Lucy', color='Bule', age=20)
    'name Lucy, color Bule, age 20'

    # 用法二
    >>> d = dict(name='Lucy', color='Bule', age=20)	
    >>> 'name {name}, color {color}, age {age}'.format(**d)
    'name Lucy, color Bule, age 20'

    # 用法三
    >>> d = dict(name='Lucy', color='Bule', age=20)	
    >>> 'name {name}, color {color}, age {age}'.format_map(d)
    'name Lucy, color Bule, age 20'

  • 简单字段名的混合使用

    混合使用数字形式和变量名形式的字段名，可以同时传递位置参数和关键字参数。

    关键字参数必须位于位置参数之后。

    混合使用时可以省略数字。

    省略字段名 {} 不能和数字形式的字段名 {非负整数} 同时使用。 

    1
    2
    3
    4
    5
    6
    7
    8
    >>> 'name {1}, color {0}, age {age}'.format('Bule', 'Lucy', age=20)		
    'name Lucy, color Bule, age 20'

    # 使用元组和字典传参
    >>> tup = ('Bule', 'Lucy')	
    >>> dt = dict(age=20)		
    >>> 'name {1}, color {0}, age {age}'.format(*tup, **dt)	
    'name Lucy, color Bule, age 20'

  • 复合字段名的使用

    同时使用了数字和变量名两种形式的字段名就是复合字段名。

    复合字段名支持两种操作符：

    • [] 方括号
      • 传递位置参数
      • 传递关键字参数
    • . 点号
      • 传递位置参数
        • 替换字段形式：{数字.属性名}
        • 只有一个替换字段的时候可以省略数字
      • 传递关键字参数
        • 替换字段形式：{关键字参数名.属性名}

    方括号替换

    1
    2
    3
    >>> lst = ['Bule', 20, 'Lucy']
    >>> 'name {0[2]}, color {0[0]}, age {0[1]}'.format(lst)
    'name Lucy, color Bule, age 20'
    1
    2
    >>> 'name {0[name]}, color {0[color]}, age {0[age]}'.format(d)
    'name Lucy, color Bule, age 20'

    点号替换

    1
    2
    >>> 'name {per.name}, color {per.color}, age {per.age}'.format(per=p)	
    'name Lucy, color Bule, age 20'
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    # 方法一
    >>> 'name {0.name}, color {0.color}, age {0.age}'.format(p)
    'name Lucy, color Bule, age 20'

    # 方法二
    >>> 'name {name}, color {color}, age {age}'.format(**vars(p))	
    'name Lucy, color Bule, age 20'

    # 方法三
    >>> 'name {name}, color {color}, age {age}'.format_map(vars(p))			
    'name Lucy, color Bule, age 20'

字符串中插入变量

Python并没有对在字符串中简单替换变量值提供直接的支持。 但是通过使用字符串的 format() 方法来解决这个问题。比如：

1
2
3
>>> s = '{name} has {n} messages.'
>>> s.format(name='Guido', n=37)
'Guido has 37 messages.'

或者，如果要被替换的变量能在变量域中找到， 那么你可以结合使用 format_map() 和 vars() 。就像下面这样：

1
2
3
4
>>> name = 'Guido'
>>> n = 37
>>> s.format_map(vars())
'Guido has 37 messages.'

vars() 还有一个有意思的特性就是它也适用于对象实例。比如：

1
2
3
4
5
6
7
8
>>> class Info:
...     def __init__(self, name, n):
...         self.name = name
...         self.n = n
...
>>> a = Info('Guido',37)
>>> s.format_map(vars(a))
'Guido has 37 messages.'

format 和 format_map() 的一个缺陷就是它们并不能很好的处理变量缺失的情况，比如：

1
2
3
4
>>> s.format(name='Guido')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'n'

一种避免这种错误的方法是另外定义一个含有 __missing__() 方法的字典对象，就像下面这样：

1
2
3
4
class safesub(dict):
"""防止key找不到"""
def __missing__(self, key):
    return '{' + key + '}'

现在你可以利用这个类包装输入后传递给 format_map() ：

1
2
3
>>> del n # Make sure n is undefined
>>> s.format_map(safesub(vars()))
'Guido has {n} messages.'

如果你发现自己在代码中频繁的执行这些步骤，你可以将变量替换步骤用一个工具函数封装起来。就像下面这样：

1
2
3
4
import sys

def sub(text):
    return text.format_map(safesub(sys._getframe(1).f_locals))

现在你可以像下面这样写了：

1
2
3
4
5
6
7
8
>>> name = 'Guido'
>>> n = 37
>>> print(sub('Hello {name}'))
Hello Guido
>>> print(sub('You have {n} messages.'))
You have 37 messages.
>>> print(sub('Your favorite color is {color}'))
Your favorite color is {color}

多年以来由于Python缺乏对变量替换的内置支持而导致了各种不同的解决方案。 作为本节中展示的一个可能的解决方案，你可以有时候会看到像下面这样的字符串格式化代码：

1
2
3
4
5
>>> name = 'Guido'
>>> n = 37
>>> '%(name) has %(n) messages.' % vars()
'Guido has 37 messages.'
>>>

你可能还会看到字符串模板的使用：

1
2
3
4
5
>>> import string
>>> s = string.Template('$name has $n messages.')
>>> s.substitute(vars())
'Guido has 37 messages.'
>>>

然而， format() 和 format_map() 相比较上面这些方案而已更加先进，因此应该被优先选择。 使用 format() 方法还有一个好处就是你可以获得对字符串格式化的所有支持(对齐，填充，数字格式化等待)， 而这些特性是使用像模板字符串之类的方案不可能获得的。

本机还部分介绍了一些高级特性。映射或者字典类中鲜为人知的 __missing__() 方法可以让你定义如何处理缺失的值。 在 SafeSub 类中，这个方法被定义为对缺失的值返回一个占位符。 你可以发现缺失的值会出现在结果字符串中(在调试的时候可能很有用)，而不是产生一个 KeyError 异常。

sub() 函数使用 sys._getframe(1) 返回调用者的栈帧。可以从中访问属性 f_locals 来获得局部变量。 毫无疑问绝大部分情况下在代码中去直接操作栈帧应该是不推荐的。 但是，对于像字符串替换工具函数而言它是非常有用的。 另外，值得注意的是 f_locals 是一个复制调用函数的本地变量的字典。 尽管你可以改变 f_locals 的内容，但是这个修改对于后面的变量访问没有任何影响。 所以，虽说访问一个栈帧看上去很邪恶，但是对它的任何操作不会覆盖和改变调用者本地变量的值。

Reference

https://blog.csdn.net/jpch89/article/details/84099277

https://python3-cookbook.readthedocs.io/zh_CN/latest/c02/p15_interpolating_variables_in_strings.html

-------------本文结束感谢您的阅读-------------