從python3.6開始,引入了新的字符串格式化方式,f-字符串. 這使得格式化字符串變得可讀性更高,更簡潔,更不容易出現(xiàn)錯誤而且速度也更快.

在Python 3.6之前，有兩種將Python表達式嵌入到字符串文本中進行格式化的主要方法：％-formatting和str.format（）。

在本文后面,會詳細介紹f-字符串的用法. 在此之前,讓我們先來復(fù)習一下python中字符串格式化的方法.

python中傳統(tǒng)的字符串格式化方法.

在python3.6之前,我們有兩種方式可以用來格式化字符串.

• 占位符+%的方式
• str.format()方法

首先復(fù)習一下這兩種方式的使用方法以及其短板.

占位符+%的方式

這種方式算是第0代字符串格式化的方法,很多語言都支持類似的字符串格式化方法. 在python的文檔中,我們也經(jīng)?？吹竭@種方式.

但是!!! BUT!!!

占位符+%的方式并不是python推薦的方式.

Note The formatting operations described here exhibit a variety of quirks that lead to a number of common errors (such as failing to display tuples and dictionaries correctly). Using the newer formatted string literals, the str.format() interface, or template strings may help avoid these errors. Each of these alternatives provides their own trade-offs and benefits of simplicity, flexibility, and/or extensibility.(Python3 doc)

文檔中也說了,這種方式對于元組等的顯示支持的不夠好. 而且很容易產(chǎn)生錯誤.

而且不符合python代碼簡潔優(yōu)雅的人設(shè)...

「如何使用占位符+%的方式」

如果你接觸過其他的語言,這種方式使用起來會有一種詭異的親切感,這種親切感會讓你抓狂,內(nèi)心會暗暗的罵上一句,艸,又是這德行...(這句不是翻譯,是我的個人感覺,從來都記不住那么多數(shù)據(jù)類型的關(guān)鍵字...)

In [1]: name='Eric'

In [2]: 'Hello,%s'%name

Out[2]: 'Hello,Eric'

如果要插入多個變量的話,就必須使用元組.像這樣

In [3]: name='Eric'

In [4]: age=18

In [5]: 'Hello %s,you are %d.'%(name,age)

Out[5]: 'Hello Eric,you are 18.'

「為什么說占位符+%的方式不是最好的辦法(個人認為是這種方式是一種最操蛋的操作)」

上面有少量的變量需要插入到字符串的時候,這種辦法還行. 但是一旦有很多變量需要插入到一個長字符串中...比如...

In [6]: first_name = "Eric"
 ...: last_name = "Idle"
 ...: age = 74
 ...: profession = "comedian"
 ...: affiliation = "Monty Python"


In [7]: "Hello, %s %s. You are %s. You are a %s. You were a member of %s." % (first_name, last_name, age, profession, affiliation)

Out[7]: 'Hello, Eric Idle. You are 74. You are a comedian. You were a member of Monty Python.'

像上面這個例子,代碼可讀性就很差了.(對讀和寫的人都是一種折磨...)

使用str.format()的方式

在python2.6之后,引入了str.format()函數(shù),可以用來進行字符串的格式化. 它通過調(diào)用對象的__format__()方法(PEP3101中定義)來將對象轉(zhuǎn)化成字符串.

在str.format()方法中,通過花括號占位的方式來實現(xiàn)變量插入.

In [8]: 'hello,{}. You are {}.'.format(name,age)

Out[8]: 'hello,Eric. You are 74.'

甚至可以給占位符加索引.

In [9]: 'hello,{1}. You are {0}.'.format(age,name)

Out[9]: 'hello,Eric. You are 74.'

如果要在占位符中使用變量名的話,可以像下面這樣

In [10]: person={'name':'Eric','age':74}

In [11]: 'hello,{name}. you are {age}'.format(name=person['name'],age=person['age'])

Out[11]: 'hello,Eric. you are 74'

當然對于字典來說的話,我們可以使用**的小技巧.

In [15]: 'hello,{name}. you are {age}'.format(**person)

Out[15]: 'hello,Eric. you are 74'

str.format()方法對于%的方式來說已經(jīng)是一種很大的提升了. 但是這并不是最好的方式.

「為什么format()方法不是最好的方式」 相比使用占位符+%的方式,format()方法的可讀性已經(jīng)很高了. 但是同樣的,如果處理含有很多變量的字符串的時候,代碼會變得很冗長.

>>> first_name = "Eric"

>>> last_name = "Idle"

>>> age = 74

>>> profession = "comedian"

>>> affiliation = "Monty Python"

>>> print(("Hello, {first_name} {last_name}. You are {age}. " +

>>>  "You are a {profession}. You were a member of {affiliation}.") \

>>>  .format(first_name=first_name, last_name=last_name, age=age, \

>>>    profession=profession, affiliation=affiliation))
'Hello, Eric Idle. You are 74. You are a comedian. You were a member of Monty Python.'

當然,我們也可以通過字典的方式直接傳入一個字典來解決代碼過長的問題. 但是,python3.6給我們提供了更便利的方式.

f-字符串,一種新的增強型字符串格式化方式

這種新的方式在PEP498中定義.(原文寫到這里的時候,作者可能瘋了,balabla說了一長串,冷靜的我并沒有翻譯這些廢話...) 這種方式也被叫做formatted string literals.格式化的字符串常亮...ummm...應(yīng)該是這么翻譯吧...

這種方式在字符串開頭的時候,以f標識,然后通過占位符{}+變量名的方式來自動解析對象的__format__方法. 如果想了解的更加詳細,可以參考python文檔

一些簡單的例子

「使用變量名作為占位符」

In [16]: name = 'Eric'

In [17]: age=74

In [18]: f'hello {name}, you are {age}'

Out[18]: 'hello Eric, you are 74'

「這里甚至可以使用大寫的F」

In [19]: F'hello {name}, you are {age}'

Out[19]: 'hello Eric, you are 74'

你以為這就完了嗎?

不!

事情遠不止想象的那么簡單...

在花括號里甚至可以執(zhí)行算數(shù)表達式

In [20]: f'{2*37}'

Out[20]: '74'

如果數(shù)學(xué)表達式都可以的話,那么在里面執(zhí)行一個函數(shù)應(yīng)該不算太過分吧...

In [22]: def to_lowercase(input):
 ...:  return input.lower()
 ...:

In [23]: name = 'ERIC IDLE'

In [24]: f'{to_lowercase(name)} is funny'

Out[24]: 'eric idle is funny'

你以為這就完了嗎?

不!

事情遠不止想象的那么簡單...

這玩意兒甚至可以用于重寫__str__()和__repr__()方法.

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!"


>>> new_comedian = Comedian("Eric", "Idle", "74")

>>> f"{new_comedian}"'Eric Idle is 74.'

關(guān)于__str__()方法和__repr__()方法. 這是對象的兩個內(nèi)置方法.__str()__方法用于返回一個便于人類閱讀的字符串. 而__repr__()方法返回的是一個對象的準確釋義. 這里暫時不做過多介紹. 如有必要,請關(guān)注公眾號吾碼2016(公眾號:wmcoding)并發(fā)送str_And_repr

默認情況下,f-關(guān)鍵字會調(diào)用對象的__str__()方法. 如果我們想調(diào)用對象的__repr__()方法的話,可以使用!r

>>> f"{new_comedian}"
'Eric Idle is 74.'

>>> f"{new_comedian!r}"
'Eric Idle is 74. Surprise!'

更多詳細內(nèi)容可以參考這里

多個f-字符串占位符

同樣的,我們可以使用多個f-字符串占位符.

>>> name = "Eric"

>>> profession = "comedian"

>>> affiliation = "Monty Python"

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

>>> message
'Hi Eric. You are a comedian. You were in Monty Python.'

但是別忘了,在每一個字符串前面都要寫上f

同樣的,在字符串換行的時候,每一行也要寫上f.

>>> message = f"Hi {name}. " \
...   f"You are a {profession}. " \
...   f"You were in {affiliation}."...

>>> message
'Hi Eric. You are a comedian. You were in Monty Python.'

但是如果我們使用"""的時候,不需要每一行都寫.

>>> message = f"""
...  Hi {name}. 
...  You are a {profession}. 
...  You were in {affiliation}.
... """
...

>>> message
'\n Hi Eric.\n You are a comedian.\n You were in Monty Python.\n'

關(guān)于f-字符串的速度

f-字符串的f可能代表的含義是fast,因為f-字符串的速度比占位符+%的方式和format()函數(shù)的方式都要快.因為它是在運行時計算的表達式而不是常量值.(那為啥就快了呢...不太懂啊...)

❝ “F-strings provide a way to embed expressions inside string literals, using a minimal syntax. It should be noted that an f-string is really an expression evaluated at run time, not a constant value. In Python source code, an f-string is a literal string, prefixed with f, which contains expressions inside braces. The expressions are replaced with their values.”(PEP498)

❞

(官方文檔,咱不敢翻,大意就是f-字符串是一個在運行時參與計算的表達式,而不是像常規(guī)字符串那樣是一個常量值)

在運行時,花括號內(nèi)的表達式在其自己的作用域內(nèi)求職,單號和字符串的部分拼接到一起,然后返回.

下面我們來看一個速度的對比.

import timeit

time1 = timeit.timeit("""name = 'Eric'\nage =74\n'%s is %s'%(name,age)""",number=100000)
time2 = timeit.timeit("""name = 'Eric'\nage =74\n'{} is {}'.format(name,age)""",number=100000)
time3 = timeit.timeit("""name = 'Eric'\nage =74\nf'{name} is {age}'""",number=100000)

從結(jié)果上看的話,f-字符串的方式速度要比其他兩種快.

0.030868000000000007
0.03721939999999996
0.0173276

f-字符串的一些細節(jié)問題

「引號的問題」 在f-字符串中,注意成對的引號使用.

f"{'Eric Idle'}"
f'{"Eric Idle"}'
f"""Eric Idle"""
f'''Eric Idle'''

以上這幾種引號方式都是支持的. 如果說我們在雙引號中需要再次使用雙引號的時候,就需要進行轉(zhuǎn)義了. f"The \"comedian\" is {name}, aged {age}."

「字典的注意事項」

在字典使用的時候,還是要注意逗號的問題.

>>> comedian = {'name': 'Eric Idle', 'age': 74}

>>> f"The comedian is {comedian['name']}, aged {comedian['age']}."

>>> f'The comedian is {comedian['name']}, aged {comedian['age']}.'

比如上面兩條語句,第三句就是有問題的,主要還是引號引起的歧義.

「花括號」 如果字符串中想使用花括號的話,就要寫兩個花括號來進行轉(zhuǎn)義. 同理,如果想輸出兩個花括號的話,就要寫四個...

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

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

「反斜杠」 反斜杠可以用于轉(zhuǎn)義. 但是!!!BUT!!!在f-字符串中,不允許使用反斜杠.

>>> f"{\"Eric Idle\"}"
 File "<stdin>", line 1
 f"{\"Eric Idle\"}"
      ^SyntaxError: f-string expression part cannot include a backslash

像上面這個的解決辦法就是

>>> name = "Eric Idle"

>>> f"{name}"'Eric Idle'

「行內(nèi)注釋」 f-字符串表達式中不允許使用#符號.

總結(jié)和參考資料

我們依舊可以使用老的方式進行字符串格式化輸出. 但是通過f-字符串,我們現(xiàn)在有了一種更便捷,更快,可讀性更高的方式. 根據(jù)python教義,Zen of Python:

「there should be one– and preferably only one –obvious way to do it.」 (編程還編出哲理來了...實在不會翻,有一種醍醐灌頂?shù)母杏X,內(nèi)心浮現(xiàn)一個聲音,臥槽!好有道理,仿佛自己升華了,但是仔細想想...這句話到底啥意思呢...)

更多的參考資料(我也只是寫在這里,反正我是沒有閑心看它的...):

PEP502:String Interpolation - Extended Discussion

PEP 536:Final Grammar for Literal String Interpolation

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