Python格式化字符串f-string的使用教程

更新時間：2022年07月19日 09:56:24 作者：古明地覺

這篇文章主要為大家詳細介紹了Python中格式化字符串f-string的使用教程，文中通過示例為大家進行了詳細的介紹，需要的可以參考一下

楔子

在 Python3.6 之前，格式化字符串一般會使用百分號占位符或者 format 函數(shù)，舉個例子：

name?=?"古明地覺"
address?=?"地靈殿"

#?使用百分號占位符格式化字符串
print(
????"我是?%s,?來自?%s"?%?(name,?address)
)??#?我是?古明地覺,?來自?地靈殿

#?使用format函數(shù)格式化字符串
print(
????"我是?{},?來自?{}".format(name,?address)
)??#?我是?古明地覺,?來自?地靈殿

#?format?函數(shù)還支持關(guān)鍵字參數(shù)
print(
????"我是?{name},?來自?{address}".format(
????????address=address,?name=name)
)??#?我是?古明地覺,?來自?地靈殿

但是從 3.6 開始，Python 新增了一個格式化字符串的方法，稱之為 f-string。f-string 的功能非常強大，可以說是一把 "瑞士軍刀"。

name?=?"古明地覺"
address?=?"地靈殿"

print(
????f"我是?{name},?來自?{address}"
)??#?我是?古明地覺,?來自?地靈殿

使用 f-string 需要給字符串增加一個前綴 f，此時 {} 和它里面的內(nèi)容則不再表示字符串，而是整體作為一個需要單獨計算的值或者表達式、或者變量。我們再舉個例子：

print(f"1?+?1?=?{1?+?1}")??#?1?+?1?=?2
print(
????f"sum([1,?2,?3])?=?{sum([1,?2,?3])}"
)??#?sum([1,?2,?3])?=?6
print(
????f"{'--'.join(['a',?'b',?'c',?'d'])}"
)??#?a--b--c--d

try:
????print(f"{a}")
except?Exception?as?e:
????print(e)??#?name?'a'?is?not?defined

#?在f-string中，{}?里面的內(nèi)容是需要單獨計算的
#?可以是常量，比如?{123}、{'hello'}?等等
#?可以是表達式，比如?{1?+?1}、{2?>?1}?等等
#?可以是變量，比如?{a}、{name}，但是變量要定義好
#?而我們上面的?a?沒有定義，所以報錯


#?或者定義一個變量
a?=?lambda?x:?x?+?100
print(f"{a}")??#?<function?<lambda>?at?0x000...>
print(f"{a(1)}")??#?101

我們看到 f-string 還是很方便的，并且和 format 功能類似，但是性能要優(yōu)于 format 函數(shù)。

當(dāng)然 f-string 的功能遠沒有我們介紹的這么簡單，它支持的操作非常多，下面就來逐一介紹。

實現(xiàn) repr 打印

有時候我們在打印的時候需要帶上引號。

name?=?"古明地覺"

print(name)??#?古明地覺
print("%s"?%?name)??#?古明地覺
#?如果使用?%r?打印，會帶上單引號
print("%r"?%?name)??#?'古明地覺'

#?上面類似于?str?和?repr?的區(qū)別
print(str(name))??#?古明地覺
print(repr(name))??#?'古明地覺'

#?等價于調(diào)用?__str__?和?__repr__
print(name.__str__())??#?古明地覺
print(name.__repr__())??#?'古明地覺'

當(dāng)我們在交互式環(huán)境下，不使用 print，而是直接輸入變量 name、然后回車，那么會調(diào)用 __repr__ 方法。如果使用 print(name)，那么不管在什么環(huán)境，都會調(diào)用 __str__ 方法。

那么在字符串周圍帶上一層單引號，有什么意義呢？

birthday?=?"1995-07-05"
print("select?name?from?where?birthday?>?%s"?%?birthday)??
print("select?name?from?where?birthday?>?%r"?%?birthday)??
"""
select?name?from?where?birthday?>?1995-07-05
select?name?from?where?birthday?>?'1995-07-05'
"""

看到區(qū)別了嗎？如果是第一個查詢，那么肯定是會報錯的。重點來了，如何通過 f-string 實現(xiàn)這種效果呢？

birthday?=?"1995-07-05"

#?我們只需要在打印的內(nèi)容后面加上一個!r即可
print(f"{birthday!r}")??#?'1995-07-05'
print(f"{birthday}")??#?1995-07-05

#?"{name}"?<==>?str(name)?<==>?name.__str__()
#?"{name!r}"?<==>?repr(name)?<==>?name.__repr__()

print(f"{'.'.join(['a',?'b',?'c'])}")??#?a.b.c
print(f"{'.'.join(['a',?'b',?'c'])!r}")??#?'a.b.c'

#?注意：!r針對的是字符串
#?雖然也可以作用于其它對象，不過沒有效果
print(f"{123!r}")??#?123
print(f"{3.14!r}")??#?3.14

#?另外除了?!r，還有?!s?和?!a，只有這三種
#?!a?和?!r?類似，!s是默認選擇、加不加均可
print(f"{birthday}")??#?1995-07-05
print(f"{birthday!s}")??#?1995-07-05
print(f"{birthday!a}")??#?'1995-07-05'
print(f"{birthday!r}")??#?'1995-07-05'

以上就是字符串的 repr 打印。

整數(shù)的進制轉(zhuǎn)換

我們在打印整數(shù)的時候，有時候需要轉(zhuǎn)成某個進制之后再打印。

i?=?123
#?打印?2?進制
print(f"{i:b}")??#?1111011
#?打印?8?進制
print(f"{i:o}")??#?173
#?打印?10?進制
#?默認是?10?進制，也可以直接使用?{i}
print(f"{i:d}")??#?123
#?打印?16?進制
print(f"{i:x}")??#?7b

#?類似于內(nèi)置函數(shù)?bin、oct、hex
#?但是這些內(nèi)置函數(shù)調(diào)用之后會帶上一個前綴
print(bin(i))??#?0b1111011
print(oct(i))??#?0o173
print(hex(i))??#?0x7b

# f-string 可不可以實現(xiàn)呢？
#?答案是可以的
print(f"{i:#b}")??#?0b1111011
print(f"{i:#o}")??#?0o173
print(f"{i:#x}")??#?0x7b
#?對于表示?16?進制的?x，我們還可以將?x?大寫
#?此時輸出的內(nèi)容也是大寫格式的
print(f"{i:#X}")??#?0X7B

另外除了 # 號，我們還可以使用 +、-、以及空格，功能如下：

+：顯示正負號；
-：負數(shù)顯示符號、正數(shù)不顯示；
空格：正數(shù)顯示空格、負數(shù)不顯示，只能是一個空格；
#：顯示前綴，比如 0b、0o、0x

注意：這幾個符號不可混用，并且最多只能出現(xiàn)一次。

print(f"{123:+x},?{-123:+x}")??#?+7b,?-7b
print(f"{123:-x},?{-123:-x}")??#?7b,?-7b
print(f"{123:?x},?{-123:?x}")??#??7b,?-7b
print(f"{123:#x},?{-123:#x}")??#?0x7b,?-0x7b

另外，Python 在創(chuàng)建整數(shù)的時候，還支持使用 _ 進行分隔，但是打印的時候不會將 _ 顯示出來。

num?=?100_000_000
print(num)??#?100000000

#?但如果是?f-string?的話
print(f"{num:_d}")
"""
100_000_000
"""
print(f"{num:_b}")
print(f"{num:#_b}")
"""
101_1111_0101_1110_0001_0000_0000
0b101_1111_0101_1110_0001_0000_0000
"""
print(f"{num:_o}")
print(f"{num:#_o}")
"""
5_7536_0400
0o5_7536_0400
"""
print(f"{num:_x}")
print(f"{num:#_x}")
"""
5f5_e100
0x5f5_e100
"""

#?只需要在?b、d、o、x?前面加上一個?_?即可
#?這樣打印出來的字符串也會帶上?_?分隔符
#?另外分隔符還可以使用逗號
print(f"{num:,d}")
"""
100,000,000
"""

注意：b、o、d、x 這些只能用于整數(shù)，不能是其它類型的對象。

print(f"{'aaa':b}")
"""
????print(f"{'aaa':b}")
ValueError:?Unknown?format?code?'b'?for?object?of?type?'str'
"""

最后再來補充一個字符，整數(shù)除了可以使用 b、o、d、x 之外，還可以使用一個字符，也就是 c。

num?=?97

print(chr(num))??#?a
print(f"{num:c}")??#?a

以上就是整數(shù)的進制轉(zhuǎn)換。

整數(shù)的填充

很多時候，打印出來的整數(shù)都會進行位數(shù)的填充，比如 1 的話，就打印 001，18 則打印 018，123 則打印本身的 123。這種需求，要怎么去處理它呢？

num?=?1
#?還記得這個 d 嗎？
#?我們說直接打印的話，有它沒它無影響
#?但是對于填充的話，它就派上用場了
print(f"{num:03d}")??#?001
print(f"{num:013d}")??#?0000000000001

填充只能用 0 或者空格來填充，比如 0123d，表示打印出來要占 123 個字符，夠的話不管了，不夠則使用 0 在左邊填充。

如果是 123d，它代表的可不是占 23 個字符、不夠用 1 填充，它代表的還是占 123 個字符，但是由于我們沒有指定 0，所以默認使用空格在左邊填充。

#?長度?23，不夠使用空格填充
print(f"{1:23d}")???#???????????????????????1
#?長度?23，不夠使用?0?填充
print(f"{1:023d}")??#?00000000000000000000001

#?當(dāng)然我們同樣可以結(jié)合?+、-、空格、#
print(f"{1:+08d}")??#?+0000001
#?可以的話，再將分隔符包含進來
print(f"{1:+023_d}")??#?+00_000_000_000_000_001
print(f"{1:+023,d}")??#?+00,000,000,000,000,001

當(dāng)然，以上規(guī)則除了適用于十進制的 d，也同樣適用于二進制的 b、八進制的 o、十六進制的 x。

print(f"{123:x}")
print(f"{123:016x}")
"""
7b
000000000000007b
"""

#?打印顯示正負號，然后占?8?個字符
print(f"{123:+08d}")
print(f"{123:+8d}")
"""
+0000123
????+123
"""

#?打印的時候帶上前綴，占?18?個字符
print(f"{123:#018b}")
print(f"{123:#18b}")
#?打印的時候帶上前綴和分隔符，占?18?個字符
print(f"{123:#18_b}")
"""
0b0000000001111011
?????????0b1111011
????????0b111_1011
"""

我們看到填充的時候，如果用 0 填充，那么會填充在 0b、+ 等前綴的后面；如果用空格填充，那么會填充在前綴的前面。當(dāng)然這也符合我們正常人的思維：

如果是 "+ 123" 或者 "00000+123"，明顯覺得別扭；
如果是 " +123" 或者 "+00000123"，則明顯順眼多了；

當(dāng)然工作中我們不會用的這么復(fù)雜，知道整數(shù)如何填充即可。

浮點數(shù)的小數(shù)保留

浮點數(shù)的小數(shù)比較長的話，我們打印的時候一般會只打印前兩位或前三位，這在 f-string 里面如何實現(xiàn)呢？

num?=?123.13421

#?f?是保留小數(shù)，但是我們沒有指定精度
#?所以默認保留后?6?位，不夠用?0?補齊
print(f"{num:f}")
"""
123.134210
"""

#?.2f?則是保留兩位小數(shù)
print(f"{num:.2f}")
"""
123.13
"""

#?10.2f?也是保留兩位小數(shù)
#?然后整體占滿?10?個字符長度
#?不夠的話使用空格在左邊填充
print(f"{num:10.2f}")
"""
????123.13
"""

#?如果我們不想使用空格填充的話
#?那么也可以使用(也只能使用)?0?來進行填充
#?規(guī)則和整數(shù)是類似的
print(f"{num:010.2f}")
"""
0000123.13
"""

當(dāng)然 +、-、空格同樣可以適用于浮點數(shù)，規(guī)則也和整數(shù)類似，同樣的，下面這些在工作中也不常用，所以我們知道怎么保留指定位數(shù)的小數(shù)即可。

num?=?123.13421

print(f"{num:+10.2f}")???
print(f"{num:+010.2f}")??
"""
???+123.13
+000123.13
"""

#?同理，浮點數(shù)也支持使用下劃線或者逗號進行分隔
print(f"{num:+10_.2f}")??
print(f"{num:+10,.2f}")?
"""
???+123.13
???+123.13
"""

#?上面由于有效字符比較少，所以沒有分隔符
#?我們用?0?填充一下
print(f"{num:+010_.2f}")
print(f"{num:+010,.2f}")
"""
+00_123.13
+00,123.13
"""

以上就是浮點數(shù)的小數(shù)保留。

任意字符的填充

我們上面介紹的還只是 f-string 的一部分，接下來就是 f-string 的殺手锏。

name?=?"古明地覺"

print(f"~{name:>10}~")
print(f"~{name:^10}~")
print(f"~{name:<10}~")
"""
~??????古明地覺~
~???古明地覺???~
~古明地覺??????~
"""

>n: 輸出的字符串占 n 個字符，原始的內(nèi)容右對齊，長度不夠則在左邊用空格填充；
^n: 輸出的字符串占 n 個字符，原始的內(nèi)容居中對齊，長度不夠則在左右兩端用空格填充；
<n: 輸出的字符串占 n 個字符，原始的內(nèi)容左對齊，長度不夠則在右邊用空格填充；

還可以將 !r、!s、!a 結(jié)合起來使用。

print(f"{'abc'!s:>10}")?
print(f"{'abc'!r:>10}")?
print(f"{'abc'!a:>10}")?
"""
???????abc
?????'abc'
?????'abc'
"""

這些規(guī)則也適用于數(shù)值：

print(f"{3:>10}")
print(f"{3.14:>10}")
"""
?????????3
??????3.14
"""

另外默認是使用空格填充的，那么可不可以使用指定字符填充呢？答案是可以的, 直接在 >、<、^ 的左邊寫上用來填充的字符即可，但是只能寫一個字符，多了報錯。

print(f"~{'a':1>10}~")??#?~111111111a~
print(f"~{'a':1^10}~")??#?~1111a11111~
#?使用空格填充，'a':?>10?等價于?'a':>10
print(f"~{'a':?>10}~")??#?~?????????a~

#?這里我們實現(xiàn)了?{1:03d}?的效果
print(f"{1:0>3}")??#?001

print(f"{123:b}")??#?1111011
print(f"{123:b<}")??#?123
"""
對于?f"{123:b}"，里面的?b?表示整數(shù)的進制轉(zhuǎn)換
此時只能作用于整數(shù)，不能是字符串

但是對于?f"{123:b<}，由于里面出現(xiàn)了<
那么此時的?b?就不再代表進制了，而是代表填充字符

只不過 <?后面沒有指定個數(shù)
所以解釋器不知道要填充多少個，因此就原本輸出了
"""

#?但是?f"{'aaa':b}"?報錯
#?因為此時?b?代表進制，無法作用于字符串
print(f"{'aaa':b<}")??#?aaa
print(f"{'aaa':b<4}")??#?aaab

問題來了，如果我們希望整數(shù)在填充的時候，還能進制轉(zhuǎn)化，該怎么做呢？

#?轉(zhuǎn)成十六進制
print(f"{255:x}")
"""
ff
"""
#?轉(zhuǎn)成十六進制，帶前綴
print(f"{123:#x}")
"""
0x7b
"""
#?轉(zhuǎn)成十六進制，占滿10位
#?不夠使用字符?s?來左填充
print(f"{123:s>#10x}")
"""
ssssss0x7b
"""

浮點數(shù)也是類似的，在保留指定位數(shù)的同時，也可以進行填充。

num?=?123.1234

#?保留一位小數(shù)
print(f"{num:.1f}")
"""
123.1
"""

#?保留一位小數(shù)，同時占滿?10?位
#?此時只能用?0?或?空格填充
print(f"{num:10.1f}")
print(f"{num:010.1f}")
"""
?????123.1
00000123.1
"""

#?如果想使用其它字符填充
print(f"{num:s<10.1f}")
print(f"{num:s>10.1f}")
print(f"{num:s^10.1f}")
"""
123.1sssss
sssss123.1
ss123.1sss
"""

#?填充的時候帶上正負號
print(f"{num:s<+10.1f}")
print(f"{num:s>+10.1f}")
print(f"{num:s^+10.1f}")
"""
+123.1ssss
ssss+123.1
ss+123.1ss
"""

#?填充的時候帶上正負號和分隔符
num?=?123123123.1234
print(f"{num:s<+20_.1f}")
print(f"{num:s>+20_.1f}")
print(f"{num:s^+20_.1f}")
"""
+123_123_123.1ssssss
ssssss+123_123_123.1
sss+123_123_123.1sss
"""

總的來說，f-string 還是非常強大的，但說實話，工作中不會用到這么多花里胡哨的功能。常用的就以下幾種：

雖然 f-string 可以寫的很復(fù)雜，但是工作上幾乎不會用到，基本上就是簡單的填充、進制轉(zhuǎn)換、保留小數(shù)。

很少會有 f"{num:s<+20_.1f}" 這種，保留小數(shù)的同時，還要帶正負號、以及填充位數(shù)的情況出現(xiàn)。

日期的截取

很多小伙伴應(yīng)該沒想到 f-string 還可以操作日期，這也算是一大亮點吧。我們在格式化或者截取日期的時候，一般會使用 datetime 模塊，這些也是可以使用 f-string 來實現(xiàn)的。

import?datetime

dt?=?datetime.datetime(
????1995,?7,?5,?13,?30,?45,?100000)
print(dt)
"""
1995-07-05?13:30:45.100000
"""

#?%F:?返回年月日(使用-連接)
print(f"{dt:%F}")
"""
1995-07-05
"""
#?%D:?返回日月年(使用/連接)，但是年是兩位的
#?并且也不符合中國人的日期表達習(xí)慣，建議只用?%F
print(f"{dt:%D}")
"""
07/05/95
"""

#?%X:?返回時間，精確到秒(小數(shù)點后面的會截斷)
#?這里注意的?X?要大寫，如果是?%x?那么等價于?%D
print(f"{dt:%X}")
"""
13:30:45
"""

#?所以返回字符串格式的完整日期就可以這么寫
print(f"{dt:%F?%X}")
"""
1995-07-05?13:30:45
"""

#?%Y:?返回年(四位)
#?%y:?返回年(兩位)
print(f"{dt:%Y}")
print(f"{dt:%y}")
"""
1995
95
"""

#?%m:?返回月
#?%d:?返回天
#?注意：會占滿兩位，不夠補0
print(f"{dt:%m}")
print(f"{dt:%d}")
"""
07
05
"""

#?所以?%F，我們還可以這么做
#?這些符號是可以連用的
print(f"{dt:%Y-%m-%d}")
"""
1995-07-05
"""

#?%H:?返回小時(24小時制度)
#?%I:?返回小時(12小時制度)
#?注意：會占滿兩位，不夠補0
print(f"{dt:%H}")
print(f"{dt:%I}")
"""
13
01
"""

#?%M:?返回分鐘
#?%S:?返回秒
#?注意：會占滿兩位，不夠補0
print(f"{dt:%M}")
print(f"{dt:%S}")
"""
30
45
"""

#?所以完整的?"年-月-日?時:分:秒"
#?就可以這么實現(xiàn)
print(f"{dt:%Y-%m-%d?%H:%M:%S}")
"""
1995-07-05?13:30:45
"""

#?%f:?返回微妙
#?注意：會占滿六位，不夠補0
print(f"{dt:%f}")
"""
100000
"""

#?%p:?早上還是下午(本地時間)
#?早上返回?AM、下午返回?PM
print(f"{dt:%p}")
"""
PM
"""

#?%j:?一年中的第幾天，從?1?開始，1月1號就是?1
#?注意：會占滿三位，不夠補?0
print(f"{dt:%j}")
"""
186
"""

#?%w:?星期幾(0是周日、1 到 6是周一到周六)
#?%u:?星期幾(1 到 7是周一到周日)
#?可以看到兩種格式只有星期天不一樣
print(f"{dt:%w}")
print(f"{dt:%u}")
"""
3
3
"""

#?%U:?一年中的第幾周(以全年首個周日所在的星期為第0周)
#?%W:?一年中的第幾周(以全年首個周一所在的星期為第1周)
#?%V:?一年中的第幾周(以全年首個包含1月4日的星期為第1周)
#?都是占滿兩位，不夠補?0
print(f"{dt:%U}")
print(f"{dt:%W}")
print(f"{dt:%V}")
"""
27
27
27
"""
#?所以如果對應(yīng)的年的第一天恰好是星期一，那么%U會比%W少1。
#?如果不是星期一，那么兩者是相等的
#?比如2007年的1月1號恰好是星期一
dt?=?datetime.datetime(2007,?10,?13)
print(f"{dt:%U}")
print(f"{dt:%W}")
print(f"{dt:%V}")
"""
40
41
41
"""

#?%Z:?返回時區(qū)名，如果沒有則返回空字符串
print(f"'{dt:%Z}'")??#?''
from?pytz?import?timezone
dt?=?datetime.datetime(2007,?10,?13,
???????????????????????tzinfo=timezone("UTC"))
print(f"'{dt:%Z}'")??#?'UTC'

怎么樣，是不是很方便呢？以后在做日期的格式化和解析的時候，不妨使用 f-string 試一下。

f-string 的注意事項

使用 f-string 需要注意單雙引號的問題，如果限定字符串使用的是雙引號，那么 {} 里面出現(xiàn)的必須是單引號，反之亦然。

d?=?{"a":?1}
#?外面是雙引號，{}?里面必須是單引號
#?不能是?d["a"]
print(f"{d['a']?+?1}")??#?2

我們限定字符串的時候使用的是雙引號，{} 里面必須是單引號?？赡苡腥撕闷妫绻锩嫒允褂秒p引號，但通過反斜杠 \ 進行轉(zhuǎn)義的話會怎么樣呢？

答案是不行的，因為f-string的{}里面不可以出現(xiàn) \。注意：{} 是不可以出現(xiàn) \，一個都不可以，所以也不要再想是不是可以使用兩個 \ 進行轉(zhuǎn)義啥的。

try:
????print(f"{\\}")
except?Exception?as?e:
????pass
#?我們即便使用異常捕獲，也是無用的，依舊會拋出 SyntaxError
#?因為 try?except 是捕捉運行時的錯誤
#?而 {} 里面出現(xiàn)反斜杠屬于語法上的錯誤，在編譯成字節(jié)碼階段就會檢測出來
"""
????print(f"{\\}")
??????????^
SyntaxError:?f-string?expression?part?cannot?include?a?backslash
"""

因此：使用 f-string 同樣需要注意單雙引號的問題，并且 {} 里面不可以出現(xiàn)反斜杠。如果真的需要反斜杠，那么可以將反斜杠賦值給一個變量，然后將變量傳遞到 {} 里面去。

a?=?"\\"
print(f"{a}")??#?\

另外，使用 f-string 時一定要注意：{ 和 } 的個數(shù)要匹配。

#?如果不使用?f-string，沒有任何問題
#?但是使用了f-string，那么會報錯
#?因為里面出現(xiàn)了?{?但是卻沒有對應(yīng)的?}
#?這段代碼不會通過編譯
print(f"我永遠喜歡{古明地覺")
"""
????print(f"我永遠喜歡{古明地覺")
??????????^
SyntaxError:?f-string:?expecting?'}'
"""

可能有人好奇了，如果我只是想單純地輸入 { 這個字符呢？答案是用兩個 { 進行轉(zhuǎn)義。

print(f"我永遠喜歡{{古明地覺")
"""
我永遠喜歡{古明地覺
"""

#?}?也是同理，需要使用兩個?}}?進行轉(zhuǎn)義
print(f"我永遠喜歡古明地覺}}")
"""
我永遠喜歡古明地覺}
"""

print(f"我永遠喜歡{{古明地覺}}")
"""
我永遠喜歡{古明地覺}
"""

不過這就又產(chǎn)生了一個問題，如果我希望外面的 {} 表示限定符，里面的 {} 表示集合該怎么辦？

name?=?"古明地覺"

#?打印的不是我們想要的結(jié)果
print(f"{{name}}")
"""
{name}
"""

#?在內(nèi)部的?{}?周圍套上一層小括號即可
print(f"{({name})}")
"""
{'古明地覺'}
"""

#?字典也是同理
print(f"{{'name':?name}}")
print(f"{({'name':?name})}")
"""
{'name':?name}
{'name':?'古明地覺'}
"""

還有字符串的拼接：

#?等價于?"你好世界"
s?=?"你好"?"世界"
print(s)??#?你好世界

name?=?"古明地覺"
address?=?"地靈殿"
#?每一部分都要帶上?f
s?=?f"{name}"?f"{address}"
print(s)??#?古明地覺,地靈殿

s?=?f"{name}"?"{address}"
print(s)??#?古明地覺{address}

#?多行顯示也是同理
s?=?(f"{name}"
?????f"{address}")
print(s)??#?古明地覺地靈殿

最后則是 lambda 表達式的問題。

#?使用lambda表達式的時候一定要使用括號括起來
#?否則會將lambda中的:解釋成表達式與格式描述符之間的分隔符
print(f"{(lambda?x:?x?+?123)(123)}")??#?246

小結(jié)

個人覺得 f-string 算是 Python3.6 新增的一大亮點，雖然有著一些限制，但是這都不是什么問題，畢竟在做分詞解析的時候肯定是有一些限制的，但總體來說 f-string 是非常強大的一個工具了。

因此在格式化字符串的時候，推薦使用f-string，相信它一定可以在格式化字符串的時候給你提供很大的幫助。

對了，再補充一點，在 3.8 的時候給 f-string 增加了一個功能：

num?=?123

print(f"{num=}")
print(f"{num?=}")
print(f"{num?=?}")
"""
num=123
num?=123
num?=?123
"""
#?可以看到加上了?=
#?還會將?{}?里面的內(nèi)容輸出出來
#?像我們之前的例子
print(f"sum([1,?2,?3])?=?{sum([1,?2,?3])}")
"""
sum([1,?2,?3])?=?6
"""
#?加上?=?就會簡潔很多
print(f"{sum([1,?2,?3])?=?}")
"""
sum([1,?2,?3])?=?6
"""

print(f"{1?+?1?=?}")
"""
1?+?1?=?2
"""

print(f"{len('古明地覺')?=?}")
"""
len('古明地覺')?=?4
"""

到此這篇關(guān)于Python格式化字符串f-string的使用教程的文章就介紹到這了,更多相關(guān)Python格式化字符串f-string內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: