Python: f-Strings của Python 3: Cú pháp định dạng chuỗi được cải thiện

Mục lục bài viết:

Kể từ Python 3.6, f-string là một cách mới tuyệt vời để định dạng chuỗi. Chúng không chỉ dễ đọc hơn, ngắn gọn hơn và ít bị lỗi hơn so với các cách định dạng khác mà còn nhanh hơn!

Đến cuối bài viết này, bạn sẽ học cách làm thế nào và tại sao nên bắt đầu sử dụng f-strings ngay hôm nay.

Nhưng trước hết ta sẽ xem phải định dạng chuỗi thế nào khi chưa có f-strings.

Định dạng chuỗi cũ trong Python

Trước Python 3.6, bạn có hai cách chính để nhúng các biểu thức Python vào bên trong chuỗi ký tự để định dạng: %-formatting và str.format().

Lựa chọn #1: %-format

Đây là OG của định dạng Python và đã được sử dụng trong ngôn ngữ này ngay từ đầu.

Cách sử dụng %-formatting

Các đối tượng chuỗi có một hoạt động tích hợp bằng cách sử dụng toán tử % mà bạn có thể sử dụng để định dạng chuỗi. Đây là những gì trông giống như trong thực tế:

>>> name = "Eric"
>>> "Hello, %s." % name
'Hello, Eric.'

Để chèn nhiều biến bạn có thể làm như sau:

>>> name = "Eric"
>>> age = 74
>>> "Hello, %s. You are %s." % (name, age)
'Hello Eric. You are 74.'

Tại sao %-format không phải là tuyệt vời

Các ví dụ mã mà bạn vừa thấy ở trên là đủ để đọc. Tuy nhiên, một khi bạn bắt đầu sử dụng một số tham số và chuỗi dài hơn, mã của bạn sẽ nhanh chóng trở nên khó đọc hơn nhiều. Mọi thứ bắt đầu có vẻ hơi lộn xộn rồi:

>>> first_name = "Eric"
>>> last_name = "Idle"
>>> age = 74
>>> profession = "comedian"
>>> affiliation = "Monty Python"
>>> "Hello, %s %s. You are %s. You are a %s. You were a member of %s." % (first_name, last_name, age, profession, affiliation)
'Hello, Eric Idle. You are 74. You are a comedian. You were a member of Monty Python.'

Thật không may, loại định dạng này không tuyệt vời vì nó dài dòng và dẫn đến lỗi, chẳng hạn như không hiển thị các bộ giá trị hoặc từ điển một cách chính xác. May mắn thay, có những ngày tươi sáng hơn ở phía trước. Ta xem tùy chọn #2 xem sao.

Tùy chọn #2: str.format()

Cách mới hơn này để hoàn thành công việc đã được giới thiệu trong Python 2.6.

Cách sử dụng str.format()

str.format()  là một cải tiến về định dạng %. Nó sử dụng cú pháp gọi hàm bình thường và có thể mở rộng thông qua phương thức __format__() trên đối tượng được chuyển đổi thành chuỗi.

Với str.format(), các trường thay thế được đánh dấu bằng dấu ngoặc nhọn:

>>> "Hello, {}. You are {}.".format(name, age)
'Hello, Eric. You are 74.'

Bạn có thể tham chiếu các biến theo bất kỳ thứ tự nào bằng cách tham chiếu chỉ mục của chúng:

>>> "Hello, {1}. You are {0}.".format(age, name)
'Hello, Eric. You are 74.'

Nhưng nếu bạn chèn tên biến, bạn sẽ nhận được đặc quyền bổ sung là có thể truyền các đối tượng và sau đó tham chiếu các tham số và phương thức ở giữa các dấu ngoặc nhọn:

>>> person = {'name': 'Eric', 'age': 74}
>>> "Hello, {name}. You are {age}.".format(name=person['name'], age=person['age'])
'Hello, Eric. You are 74.'

Bạn cũng có thể sử dụng thủ thuật ** nhỏ gọn này với từ điển:

>>> person = {'name': 'Eric', 'age': 74}
>>> "Hello, {name}. You are {age}.".format(**person)
'Hello, Eric. You are 74.'

str.format() chắc chắn là một bản nâng cấp khi so sánh với %-formatting, nhưng nó có những điều chưa ổn.

Tại sao str.format() chưa ổn

Sử dụng mã str.format() dễ đọc hơn nhiều so với mã sử dụng %-format, nhưng str.format() vẫn có thể khá dài khi bạn xử lý nhiều tham số và chuỗi dài hơn:

>>> 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.'

Nếu bạn có các biến mà bạn muốn chuyển đến .format() trong từ điển, thì bạn có thể giải nén nó với .format(**some_dict) và tham chiếu các giá trị bằng khóa trong chuỗi, nhưng phải có một cách tốt hơn để làm điều này.

f-string: Một cách mới và cải tiến để định dạng chuỗi trong Python

f-string được đề xuất từ phiên bản Python 3.6. Bạn có thể đọc tất cả về nó trong PEP 498, được viết bởi Eric V. Smith vào tháng 8 năm 2015.

Còn được gọi là "các ký tự chuỗi được định dạng", f-string là các ký tự chuỗi có một ký tự f ở đầu cặp nháy và dấu ngoặc nhọn chứa các biểu thức sẽ được thay thế bằng các giá trị của chúng. Các biểu thức được đánh giá trong thời gian chạy và sau đó được định dạng bằng giao thức __format__. Như mọi khi, tài liệu Python là người bạn của bạn khi bạn muốn tìm hiểu thêm.

Dưới đây là một số cách f-string có thể giúp cuộc sống của bạn dễ dàng hơn.

Cú pháp đơn giản

Cú pháp tương tự như cú pháp bạn đã sử dụng str.format() nhưng ít dài dòng hơn. Hãy xem nó dễ đọc như thế nào:

>>> name = "Eric"
>>> age = 74
>>> f"Hello, {name}. You are {age}."
'Hello, Eric. You are 74.'

Nó cũng sẽ hợp lệ nếu bạn sử dụng một chữ cái viết hoa F:

>>> F"Hello, {name}. You are {age}."
'Hello, Eric. You are 74.'

Bạn yêu thích f-string chưa? Tôi hy vọng rằng, đến cuối bài viết này, bạn sẽ trả lời: >>> F"Yes!".

Biểu thức tùy ý

Vì chuỗi f được đánh giá trong thời gian chạy, bạn có thể đặt bất kỳ và tất cả các biểu thức Python hợp lệ nào vào chúng. Điều này cho phép bạn làm một số việc tiện lợi.

Bạn có thể làm điều gì đó khá đơn giản, như thế này:

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

Nhưng bạn cũng có thể gọi các hàm. Đây là một ví dụ:

>>> def to_lowercase(input):
...     return input.lower()

>>> name = "Eric Idle"
>>> f"{to_lowercase(name)} is funny."
'eric idle is funny.'

Bạn cũng có tùy chọn gọi một phương thức trực tiếp:

>>> f"{name.lower()} is funny."
'eric idle is funny.'

Bạn thậm chí có thể sử dụng các đối tượng được tạo từ các lớp với f-string. Hãy tưởng tượng bạn có lớp sau:

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

Bạn có thể làm điều này:

>>> new_comedian = Comedian("Eric", "Idle", "74")
>>> f"{new_comedian}"
'Eric Idle is 74.'

Các phương thức __str__() và __repr__() xử lý cách các đối tượng được trình bày dưới dạng chuỗi, vì vậy bạn sẽ cần đảm bảo rằng bạn đưa vào ít nhất một trong những phương thức đó trong định nghĩa lớp của mình. Nếu bạn phải chọn một phương thức, hãy chọn __repr__() vì nó có thể được sử dụng thay thế __str__().

Chuỗi được trả về __str__() là chuỗi biểu diễn không chính thức của một đối tượng và phải có thể đọc được. Chuỗi được trả về __repr__() là đại diện chính thức và phải rõ ràng. Lời gọi đến str() và repr() lại thích sử dụng __str__() và __repr__() một cách trực tiếp.

Theo mặc định, f-string sẽ sử dụng __str__(), nhưng bạn có thể đảm bảo rằng chúng sử dụng __repr__() nếu bạn đưa vào cờ chuyển đổi !r:

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

Đa dòng trong f-string

Bạn có thể có các chuỗi nhiều dòng như sau:

>>> 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.'

Nhưng hãy nhớ rằng bạn cần phải đặt một f phía trước mỗi dòng của một chuỗi nhiều dòng. Đoạn mã sau sẽ không hoạt động:

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

Nếu bạn không đặt f trước từng dòng riêng lẻ, thì bạn sẽ chỉ có những dòng hiển thị thông thường.

Nếu bạn muốn trải rộng các chuỗi trên nhiều dòng, bạn cũng có tùy chọn là thêm \ như sau:

>>> 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.'

Nhưng đây là những gì sẽ xảy ra nếu bạn sử dụng """:

>>> 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'

Đọc kỹ hướng dẫn thụt lề trong PEP 8.

Tốc độ

f trong f-string cũng có thể là viết tắt của "fast".

f-string nhanh hơn cả %-format và str.format(). Như bạn đã thấy, chuỗi f là các biểu thức được đánh giá trong thời gian chạy chứ không phải là các giá trị không đổi. Đây là một đoạn trích từ tài liệu:

“F-string cung cấp một cách để nhúng các biểu thức vào bên trong các ký tự chuỗi, sử dụng một cú pháp tối thiểu. Cần lưu ý rằng một chuỗi f thực sự là một biểu thức được đánh giá tại thời gian chạy, không phải là một giá trị hằng số. Trong mã nguồn Python, chuỗi f là một chuỗi chữ, có tiền tố là f, chứa các biểu thức bên trong dấu ngoặc nhọn. Các biểu thức được thay thế bằng các giá trị của chúng. ” (Nguồn)

Trong thời gian chạy, biểu thức bên trong dấu ngoặc nhọn được đánh giá trong phạm vi riêng của nó và sau đó được đặt cùng với phần ký tự của chuỗi f-string. Chuỗi kết quả sau đó được trả về. Đó là tất cả những gì nó cần.

Đây là một so sánh tốc độ:

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

Như bạn có thể thấy, chuỗi f có thời gian thực thi nhỏ nhất.

Tuy nhiên, không phải lúc nào cũng vậy. Khi chúng được triển khai lần đầu tiên, chúng có một số vấn đề về tốc độ và cần phải được thực hiện nhanh hơn str.format(). Một BUILD_STRING opcode đặc biệt đã được giới thiệu đến bạn.

Một số chú ý

Bây giờ bạn đã tìm hiểu tất cả về lý do tại sao f-string lại tuyệt vời, tôi chắc chắn rằng bạn đang rất muốn bắt đầu sử dụng chúng. Dưới đây là một số chi tiết cần ghi nhớ.

Dấu ngoặc kép

Bạn có thể sử dụng nhiều loại dấu ngoặc kép khác nhau bên trong các biểu thức. Chỉ cần đảm bảo rằng bạn không sử dụng cùng một loại dấu ngoặc kép ở bên ngoài chuỗi f như bạn đang sử dụng trong biểu thức.

Mã sau sẽ hoạt động:

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

Mã sau cũng sẽ hoạt động:

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

Bạn cũng có thể sử dụng dấu ngoặc kép:

>>> f"""Eric Idle"""
'Eric Idle'

>>> f'''Eric Idle'''
'Eric Idle'

Nếu bạn thấy mình cần sử dụng cùng một loại dấu ngoặc kép ở cả bên trong và bên ngoài chuỗi, thì bạn có thể thoát bằng \:

>>> f"The \"comedian\" is {name}, aged {age}."
'The "comedian" is Eric Idle, aged 74.'

Từ điển

Nói về dấu ngoặc kép, hãy để ý khi bạn đang làm việc với từ điển. Nếu bạn định sử dụng dấu ngoặc kép đơn cho các khóa của từ điển, thì hãy nhớ đảm bảo rằng bạn đang sử dụng dấu ngoặc kép cho các chuỗi f chứa khóa.

Điều sau sẽ hoạt động:

>>> comedian = {'name': 'Eric Idle', 'age': 74}
>>> f"The comedian is {comedian['name']}, aged {comedian['age']}."
The comedian is Eric Idle, aged 74.

Nhưng đây sẽ là một mớ hỗn độn nóng với một lỗi cú pháp:

>>> comedian = {'name': 'Eric Idle', 'age': 74}
>>> f'The comedian is {comedian['name']}, aged {comedian['age']}.'
  File "<stdin>", line 1
    f'The comedian is {comedian['name']}, aged {comedian['age']}.'
                                    ^
SyntaxError: invalid syntax

Nếu bạn sử dụng cùng một loại dấu ngoặc kép xung quanh các khóa từ điển như khi bạn làm ở bên ngoài chuỗi f, thì dấu ngoặc kép ở đầu khóa từ điển đầu tiên sẽ được hiểu là cuối chuỗi.

Ngoặc xoắn ({})

Để tạo một dấu ngoặc xoắn trong chuỗi của bạn, bạn phải sử dụng dấu ngoặc kép:

>>> f"{{70 + 4}}"
'{70 + 4}'

Lưu ý rằng nếu bạn sử dụng ba dấu ngoặc xoắn sẽ dẫn đến việc chỉ có một dấu ngoặc nhọn trong chuỗi của bạn:

>>> f"{{{70 + 4}}}"
'{74}'

Tuy nhiên, bạn có thể nhận được nhiều ngặc xoắn hơn để hiển thị nếu bạn sử dụng nhiều hơn ba ngoặc xoắn:

>>> f"{{{{70 + 4}}}}"
'{{70 + 4}}'

Dấu gạch chéo ngược (xổ trái)

Như bạn đã thấy trước đó, bạn có thể sử dụng các thoát dấu gạch chéo ngược trong phần chuỗi của một chuỗi f. Tuy nhiên, bạn không thể sử dụng dấu gạch chéo ngược để thoát trong phần biểu thức của chuỗi f:

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

Bạn có thể giải quyết vấn đề này bằng cách đánh giá trước biểu thức và sử dụng kết quả trong chuỗi f:

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

Chú thích (comment) bên trong

Biểu thức không được bao gồm các chú thích sử dụng biểu tượng #. Bạn sẽ gặp lỗi cú pháp:

>>> f"Eric is {2 * 37 #Oh my!}."
  File "<stdin>", line 1
    f"Eric is {2 * 37 #Oh my!}."
                                ^
SyntaxError: f-string expression part cannot include '#'

Đọc thêm

Nếu bạn muốn xem thảo luận mở rộng về nội suy chuỗi, hãy xem PEP 502. Ngoài ra, dự thảo PEP 536 có thêm một số suy nghĩ về tương lai của chuỗi f.

Để có thêm niềm vui với chuỗi, hãy xem các bài viết sau:

• Giới thiệu thực tế về Web Scraping bằng Python