第五章 Python格式化输出（% ，str.format，f-string ）

一、简单介绍

字符串的格式化输出目前有两种方式

• % 方式(陈旧)
• str.format() 方式(新式,官方推荐)
• f-string 方式 (Python3.6 及以上推荐使用)

---

---

二、 % 方式

常用示例

tpl = "i am %s" % "yangge"
print(tpl)

tpl = "i am %s age %d" % ("yangge", 18)
print(tpl)

tpl = "i am %(name)s age %(age)d" % {"name": "yangge", "age": 18}
print(tpl)

tpl = "percent %.2f" % 99.97623
print(tpl)

tpl = "i am %(pp).2f" % {"pp": 123.425556, }
print(tpl)

tpl = "i am %.2f%%" % 123.425556
print(tpl)

更多语法格式

%[(name)][flags][width].[precision]typecode
"""
(name)     可选，用于选择指定的key
Flags      可选，可供选择的值有:
   +        右对齐；正数前加正号，负数前加负号；
   -        左对齐；正数前无符号，负数前加负号；
   空格      右对齐；正数前加空格，负数前加负号；
   0        右对齐；正数前无符号，负数前加负号；
            用0填充空白处;
width       可选，占有宽度
.precision  可选，小数点后保留的位数
typecode    必选
"""

# typecode 有以下这些：
"""
s  获取传入对象的__str__方法的返回值，并将其格式化到指定位置
d  将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置
f  将整数、浮点数转换成浮点数表示，并将其格式化到指定位置
   （默认保留小数点后6位）
o  将整数转换成 八  进制表示，并将其格式化到指定位置
x  将整数转换成十六进制表示，并将其格式化到指定位置
%  当字符串中存在格式化标志时，需要用 %%表示一个百分号
"""

---

str.format() 方式

常用示例

tpl = "i am {}, age {}, {}"
r = tpl.format("yangge", 18, 'yangge')
print(r)

tpl = "i am {}, age {}, {}"
r = tpl.format(*["yangge", 18, 'yangge'])
print(r)

a, *b = ["yangge", 18, 'yangge']
print(a)
print(b)
*b, a = ["yangge", 18, 'ge']
print(a)
print(b)

tpl = "i am {0}, age {1}, really {0}"
print(tpl.format("xiguatian", 18))

tpl = "i am {0}, age {1}, really {0}"
tpl.format(*["xiguatian", 18])

tpl = "i am {name}, age {age}, really {name}"
print(tpl.format(name="xiguatian", age=18))
#
tpl = "i am {name}, age {age}, really {name}"
print(tpl.format(**{"name": "xiguatian", "age": 18}))

tpl = "i am {0[0]}, age {0[1]}, really {1[2]}"
print(tpl.format([1, 2, 3], [11, 22, 33]))

tpl = "i am {:s}, age {:d}, money {:f}"
print(tpl.format("seven", 18, 88888.1))

tpl = "i am {:s}, age {:d}".format(*["seven", 18])
print(tpl)

tpl = "i am {name:s}, age {age:d}"
tpl.format(name="xiguatian", age=18)

tpl = "i am {name:s}, age {age:d}"
tpl.format(**{"name": "xiguatian", "age": 18})

tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}"
print(tpl.format(15, 15, 15, 15, 15, 15.87623, 2))

tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X},\
      {0:.2%}"
print(tpl.format(15))

tpl = "numbers: {num:b},{num:o},{num:d},{num:x},\
       {num:X}, {num:.2%}"
print(tpl.format(num=15))
print("{0:.3%}".format(0.15))

tpl = "{0:<6}---{0:<8}---{0:>13}"
print(tpl.format('123'))

更多语法格式

[[fill]align][#][0][width][,][.precision][type]

fill         【可选】空白处填充的字符
align        【可选】对齐方式（需配合width使用

#            【可选】对于二进制、八进制、十六进制，如果加上#，
              会显示 0b/0o/0x，否则不显示

，           【可选】为数字添加分隔符，如：1,000,000
width        【可选】格式化位所占宽度
.precision   【可选】小数位保留精度
type         【可选】格式化类型

"""

"""
type  【可选】格式化类型
传入" 字符串类型 “的参数
         s，格式化字符串类型数据
        空白，未指定类型，则默认是None，同s
传入“ 整数类型 "的参数  b，将10进制整数自动转换成2进制表示然后格式化
  c，将10进制整数自动转换为其对应的unicode字符
  d，十进制整数
  o，将10进制整数自动转换成8进制表示然后格式化；
  x，将10进制整数自动转换成16进制表示然后格式化（小写x）
  f ， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
  %，显示百分比（默认显示小数点后6位）

---

---

三、模板字符串（标准库）

这是Python中字符串格式化的另一个工具：模板字符串。它是一种更简单，功能更少的机制，但在某些情况下，这可能正是您所需要的。

我们来看一个简单的示例：

from string import Template

name = 'shark'

s = Template("hello $name")

print(s.substitute(name=name))

那么什么时候应该在Python程序中使用模板字符串？在我看来，使用模板字符串的最佳时间是在处理程序用户生成的格式化字符串时。由于复杂性降低，模板字符串是更安全的选择。

---

---

四、 f-string 方式

f-string 也称为 格式化的字符串文字，是以f 或 F 为前缀的字符串文字。

这些字符串可能包含可被替换的字段，这些字段是由大括号 {} 分隔的表达式。

虽然其他字符串文字总是具有常量值，但格式化字符串实际上是在运行时计算的表达式。

1. 简单的语法

语法类似于您使用 str.format() 的语法，但是你发现 str.formate() 方式有时候不是那么简洁。比如在一个有够多的变量需要替换时，就显得非常的臃长且不易读。

看看 f-string 有多么的简洁。

name = '千锋教育云计算'
age = 10

s = f'欢迎来到{name}学习云计算架构师课程，历时{age}年，打造行业领军品牌'

print(s)

# 输出
欢迎来到千锋教育云计算学习云计算架构师课程，历时10年，打造行业领军品牌

任意表达

因为f-strings是在运行时计算的，所以可以在其中放置任何和所有有效的Python表达式。这可以让你做一些漂亮的事情。

你可以做一些非常简单的事情，比如：

>>> f "{2 * 37}" 
'74'

但你也可以调用函数。这是一个例子：

def to_lowercase(inp):
    return inp.lower()

name = "Shark"

s = f"{to_lowercase(name)} is strong."

print(s)

# 打印出
shark is strong.

您甚至可以使用从具有 f 字符串的类创建的对象。想象一下，你有以下课程：

class Comedian:
    def __init__(self, first_name, last_name, age):
        self.first_name = first_name
        self.last_name = last_name
        self.age = age

    def __str__(self):
        return f"{self.first_name} {self.last_name} is {self.age}."

    def __repr__(self):
        return f"{self.first_name} {self.last_name} is {self.age}. Surprise!"

你可以这样做：

me = Comedian('shark', 'xiguatian', 18)

s = f'{me}'

print(s)

# 打印出
shark xiguatian is 18.

该__str__()和__repr__()方法是处理如何呈现对象为字符串的，所以你需要确保你包括你的类定义这些方法的至少一个。如果你必须选择一个，请使用__repr__()它，因为它可以用来代替__str__()。

默认情况下，f-strings将使用__str__()，但__repr__()如果包含转换标志，则可以确保它们使用!r：

多行f字符串

你可以有多行字符串：

name = "Shark"

profession = "porter"

msg = "Even though you like Python very much"

message = (
    f"Hi {name}. "
    f"You are a {profession}. "
    f"You were in {msg}."
)

print(message)

# 打印出
Hi Shark. You are a porter. You were in Even though you like Python very much.

但请记住，您需要f在多行字符串的每一行前面放置一个。以下代码不起作用：

message = (
    f"Hi {name}. "
    "You are a {profession}. "
    "You were in {msg}."
)

print(message)

# 打印出
Hi Shark. You are a {profession}. You were in {msg}.

但如果您使用"""以下情况会发生这种情况：

message = (
    f"""Hi {name}. 
    You are a {profession}. 
    You were in {msg}."""
)
print(message)

# 打印出
Hi Shark. 
    You are a porter. 
    You were in Even though you like Python very much.

阅读PEP 8中的缩进指南。

速度

在运行时，花括号内的表达式在其自己的作用域中计算，然后与 f-string 的字符串文字部分放在一起。然后返回结果字符串。

这是一个速度比较：

>>> import timeit
>>> timeit.timeit("""name = "Eric"
... age = 74
... '%s is %s.' % (name, age)""", number = 10000)
0.003324444866599663

>>> timeit.timeit("""name = "Eric"
... age = 74
... '{} is {}.'.format(name, age)""", number = 10000)
0.004242089427570761

>>> timeit.timeit("""name = "Eric"
... age = 74
... f'{name} is {age}.'""", number = 10000)
0.0024820892040722242

正如你所看到的，f-strings 排在最前面。

然而，情况并非总是如此。当它们首次实施时，它们有一些速度问题，str.format() 需要比它更快。引入了一种特殊的BUILD_STRING操作码。

Python f-Strings： 一些细节

既然你已经了解了为什么f-string很棒的话，我相信你已经迫不及待的想在工作中使用它们，请记住以下几个细节。

引号

您可以在表达式中使用各种类型的引号。只需确保在表达式中使用的字符串外部没有使用相同类型的引号。

此代码将起作用：

>>> f "{'Shark'}"
'Shark'

您还可以使用三引号：

>>> f """{'Shark'}"""
'Shark'

如果您发现需要在字符串的内部和外部使用相同类型的引号，则可以使用\以下命令进行转义：

字典

说到引号，请注意何时使用词典。如果要对字典的键使用单引号，请记住确保对包含键的f字符串使用双引号。

这将有效：

info = {"name": 'shark', 'age': 18}

s = f"My name is {info['name']}, age is {info['age']}"

print(s)

# 打印出

下面的将是一个混乱的语法错误：

info = {"name": 'shark', 'age': 18}

s = f'My name is {info['name']}, age is {info['age']}'

print(s)

# 输出
  File "/Users/yanshunjun/PycharmProjects/code_1808/day4/字符串操作.py", line 95
    s = f'My name is {info['name']}, age is {info['age']}'
                               ^
SyntaxError: invalid syntax

如果在字典键周围使用与f字符串外部相同类型的引号，则第一个字典键开头的引号将被解释为字符串的结尾。

大括号

为了使大括号出现在您的字符串中，您必须使用双括号：

>>> f"{{74}}"
'{74}'

请注意，使用三重括号将导致字符串中只有一个大括号：

>>> f"{{{74}}}"
'{74}'

但是，如果使用三个以上大括号，您可以获得更多大括号：

>>> f"{{{{74}}}}"
'{{74}}'

你应该使用哪种字符串格式化方法？

我完全明白如何在Python中格式化字符串这么多选择会让人感到非常困惑。这是一个很好的提示，可以改变我为您准备的这个方便的流程图：
Python字符串格式经验法则

image

**如果您的格式字符串是用户提供的，请使用模板字符串（＃4）来避免安全问题。否则，如果您使用的是Python 3.6+，则使用Literal String Interpolation / f-Strings（＃3），如果不是，则使用“New Style”str.format（＃2）。