Hướng dẫn why do we print f in python? - tại sao chúng ta in f trong python?

Tùy chọn số 1: %-Formatting

Đây là OG của định dạng Python và đã có trong ngôn ngữ kể từ khi bắt đầu. Bạn có thể đọc thêm trong các tài liệu Python. Hãy nhớ rằng %-formatting không được khuyến nghị bởi các tài liệu, trong đó có lưu ý sau:

Các hoạt động định dạng được mô tả ở đây thể hiện một loạt các kỳ quặc dẫn đến một số lỗi phổ biến [chẳng hạn như không hiển thị chính xác các bộ dữ liệu và từ điển].

Sử dụng các chuỗi chữ được định dạng mới hơn hoặc giao diện

tax = 1234

print[f'{tax:,}'] # separate 1k \w comma
# 1,234

print[f'{tax:,.2f}'] # all two decimals 
# 1,234.00

print[f'{tax:~>8}'] # pad left with ~ to fill eight characters or < other direction
# ~~~~1234

print[f'{tax:~^20}'] # centre and pad
# ~~~~~~~~1234~~~~~~~~

4 giúp tránh các lỗi này. Những lựa chọn thay thế này cũng cung cấp các phương pháp tiếp cận mạnh mẽ, linh hoạt và mở rộng hơn để định dạng văn bản. [Nguồn]

tax = 1234

print[f'{tax:,}'] # separate 1k \w comma
# 1,234

print[f'{tax:,.2f}'] # all two decimals 
# 1,234.00

print[f'{tax:~>8}'] # pad left with ~ to fill eight characters or < other direction
# ~~~~1234

print[f'{tax:~^20}'] # centre and pad
# ~~~~~~~~1234~~~~~~~~

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

>>> name = "Eric"
>>> age = 74
>>> "Hello, %s. You are %s." % [name, age]
'Hello Eric. You are 74.'

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

Tùy chọn #2: str.format []

Cách hoàn thành công việc mới hơn này đã được giới thiệu trong Python 2.6. Bạn có thể kiểm tra hướng dẫn về các kỹ thuật định dạng chuỗi Python mới hơn để biết thêm thông tin.

tax = 1234

print[f'{tax:,}'] # separate 1k \w comma
# 1,234

print[f'{tax:,.2f}'] # all two decimals 
# 1,234.00

print[f'{tax:~>8}'] # pad left with ~ to fill eight characters or < other direction
# ~~~~1234

print[f'{tax:~^20}'] # centre and pad
# ~~~~~~~~1234~~~~~~~~

tax = 1234

print[f'{tax:,}'] # separate 1k \w comma
# 1,234

print[f'{tax:,.2f}'] # all two decimals 
# 1,234.00

print[f'{tax:~>8}'] # pad left with ~ to fill eight characters or < other direction
# ~~~~1234

print[f'{tax:~^20}'] # centre and pad
# ~~~~~~~~1234~~~~~~~~

tax = 1234

print[f'{tax:,}'] # separate 1k \w comma
# 1,234

print[f'{tax:,.2f}'] # all two decimals 
# 1,234.00

print[f'{tax:~>8}'] # pad left with ~ to fill eight characters or < other direction
# ~~~~1234

print[f'{tax:~^20}'] # centre and pad
# ~~~~~~~~1234~~~~~~~~

>>> "Hello, {}. You are {}.".format[name, age]
'Hello, Eric. You are 74.'

print[f'the {agent_name=}.']
# the agent_name='James Bond'

print[f'the {agent_name=}.']
# the agent_name='James Bond'

class Money:
    
    def __init__[self, currency='€']:
        self.currency = currency
        
    def __format__[self, value]:
        
        return f"{self.currency} {float[value]:.2f}"
        
        
tax = 12.34
money = Money[currency='$']
print[f'{money: {tax}}']
# $ 12.34

print[f'the {agent_name=}.']
# the agent_name='James Bond'

tax = 1234

print[f'{tax:,}'] # separate 1k \w comma
# 1,234

print[f'{tax:,.2f}'] # all two decimals 
# 1,234.00

print[f'{tax:~>8}'] # pad left with ~ to fill eight characters or < other direction
# ~~~~1234

print[f'{tax:~^20}'] # centre and pad
# ~~~~~~~~1234~~~~~~~~

tax = 1234

print[f'{tax:,}'] # separate 1k \w comma
# 1,234

print[f'{tax:,.2f}'] # all two decimals 
# 1,234.00

print[f'{tax:~>8}'] # pad left with ~ to fill eight characters or < other direction
# ~~~~1234

print[f'{tax:~^20}'] # centre and pad
# ~~~~~~~~1234~~~~~~~~

tax = 1234

print[f'{tax:,}'] # separate 1k \w comma
# 1,234

print[f'{tax:,.2f}'] # all two decimals 
# 1,234.00

print[f'{tax:~>8}'] # pad left with ~ to fill eight characters or < other direction
# ~~~~1234

print[f'{tax:~^20}'] # centre and pad
# ~~~~~~~~1234~~~~~~~~

print[f'the {agent_name=}.']
# the agent_name='James Bond'

class Money:
    
    def __init__[self, currency='€']:
        self.currency = currency
        
    def __format__[self, value]:
        
        return f"{self.currency} {float[value]:.2f}"
        
        
tax = 12.34
money = Money[currency='$']
print[f'{money: {tax}}']
# $ 12.34

class Money:
    
    def __init__[self, currency='€']:
        self.currency = currency
        
    def __format__[self, value]:
        
        return f"{self.currency} {float[value]:.2f}"
        
        
tax = 12.34
money = Money[currency='$']
print[f'{money: {tax}}']
# $ 12.34

Cú pháp đơn giản

Cú pháp tương tự như cái bạn đã sử dụng với

tax = 1234

print[f'{tax:,}'] # separate 1k \w comma
# 1,234

print[f'{tax:,.2f}'] # all two decimals 
# 1,234.00

print[f'{tax:~>8}'] # pad left with ~ to fill eight characters or < other direction
# ~~~~1234

print[f'{tax:~^20}'] # centre and pad
# ~~~~~~~~1234~~~~~~~~

>>>

print[f'the {agent_name=}.']
# the agent_name='James Bond'

Nó cũng sẽ có hiệu lực khi sử dụng một chữ cái viết hoa

tax = 1234

print[f'{tax:,}'] # separate 1k \w comma
# 1,234

print[f'{tax:,.2f}'] # all two decimals 
# 1,234.00

print[f'{tax:~>8}'] # pad left with ~ to fill eight characters or < other direction
# ~~~~1234

print[f'{tax:~^20}'] # centre and pad
# ~~~~~~~~1234~~~~~~~~

>>>

print[f'the {agent_name=}.']
# the agent_name='James Bond'

Bạn có yêu F-String chưa? Tôi hy vọng rằng, vào cuối bài viết này, bạn sẽ trả lời

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

Biểu thức tùy ý

Bởi vì các 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ệ trong chúng. Điều này cho phép bạn làm một số điều tiện lợi.

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

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

>>>

print[f'the {agent_name=}.']
# the agent_name='James Bond'

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

>>>

print[f'the {agent_name=}.']
# the agent_name='James Bond'

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

print[f'the {agent_name=}.']
# the agent_name='James Bond'

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

>>>

print[f'the {agent_name=}.']
# the agent_name='James Bond'

Các phương thức

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

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

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

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

Chuỗi được trả về bởi

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

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

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

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

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

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

Theo mặc định, các chuỗi F sẽ sử dụng

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

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

>>> name = "Eric"
>>> age = 74
>>> "Hello, %s. You are %s." % [name, age]
'Hello Eric. You are 74.'

>>>

print[f'{agent_name} shoot with {9/11 : .2f} or {9/11: .1%} accuracy']
# James Bond shoot with  0.82 or  81.8% accuracy 

Nếu bạn muốn đọc một số cuộc trò chuyện dẫn đến các chuỗi F hỗ trợ các biểu thức python đầy đủ, bạn có thể làm như vậy ở đây.

Multiline F-String

Bạn có thể có chuỗi đa dòng:

>>>

print[f'{agent_name} shoot with {9/11 : .2f} or {9/11: .1%} accuracy']
# James Bond shoot with  0.82 or  81.8% accuracy 

Nhưng hãy nhớ rằng bạn cần đặt một

tax = 1234

print[f'{tax:,}'] # separate 1k \w comma
# 1,234

print[f'{tax:,.2f}'] # all two decimals 
# 1,234.00

print[f'{tax:~>8}'] # pad left with ~ to fill eight characters or < other direction
# ~~~~1234

print[f'{tax:~^20}'] # centre and pad
# ~~~~~~~~1234~~~~~~~~

>>>

print[f'{agent_name} shoot with {9/11 : .2f} or {9/11: .1%} accuracy']
# James Bond shoot with  0.82 or  81.8% accuracy 

Nếu bạn không đặt một

tax = 1234

print[f'{tax:,}'] # separate 1k \w comma
# 1,234

print[f'{tax:,.2f}'] # all two decimals 
# 1,234.00

print[f'{tax:~>8}'] # pad left with ~ to fill eight characters or < other direction
# ~~~~1234

print[f'{tax:~^20}'] # centre and pad
# ~~~~~~~~1234~~~~~~~~

Nếu bạn muốn lan truyền các chuỗi trên nhiều dòng, bạn cũng có tùy chọn thoát khỏi sự trở lại với

>>> name = "Eric"
>>> age = 74
>>> "Hello, %s. You are %s." % [name, age]
'Hello Eric. You are 74.'

>>>

print[f'{agent_name} shoot with {9/11 : .2f} or {9/11: .1%} accuracy']
# James Bond shoot with  0.82 or  81.8% accuracy 

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

>>> name = "Eric"
>>> age = 74
>>> "Hello, %s. You are %s." % [name, age]
'Hello Eric. You are 74.'

>>>

print[f'{agent_name} shoot with {9/11 : .2f} or {9/11: .1%} accuracy']
# James Bond shoot with  0.82 or  81.8% accuracy 

Đọc về hướng dẫn thụt vào trong PEP 8.

Tốc độ, vận tốc

tax = 1234

print[f'{tax:,}'] # separate 1k \w comma
# 1,234

print[f'{tax:,.2f}'] # all two decimals 
# 1,234.00

print[f'{tax:~>8}'] # pad left with ~ to fill eight characters or < other direction
# ~~~~1234

print[f'{tax:~^20}'] # centre and pad
# ~~~~~~~~1234~~~~~~~~

Các chuỗi F nhanh hơn cả %-formatting và

tax = 1234

print[f'{tax:,}'] # separate 1k \w comma
# 1,234

print[f'{tax:,.2f}'] # all two decimals 
# 1,234.00

print[f'{tax:~>8}'] # pad left with ~ to fill eight characters or < other direction
# ~~~~1234

print[f'{tax:~^20}'] # centre and pad
# ~~~~~~~~1234~~~~~~~~

Các dây F F cung cấp một cách để nhúng các biểu thức bên trong các chữ viết, sử dụng 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 điểm chạy, không phải là một giá trị không đổi. Trong mã nguồn Python, một chuỗi F là một chuỗi theo nghĩa đen, có tiền tố với

tax = 1234

print[f'{tax:,}'] # separate 1k \w comma
# 1,234

print[f'{tax:,.2f}'] # all two decimals 
# 1,234.00

print[f'{tax:~>8}'] # pad left with ~ to fill eight characters or < other direction
# ~~~~1234

print[f'{tax:~^20}'] # centre and pad
# ~~~~~~~~1234~~~~~~~~

0, chứa các biểu thức bên trong niềng răng. 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 niềng răng xoăn được đánh giá trong phạm vi riêng của nó và sau đó đặt cùng với phần theo nghĩa đen của chuỗi F. Chuỗi kết quả sau đó được trả về. Đó là tất cả những gì nó cần.

Ở đây, một so sánh tốc độ:

>>>

print[f'{agent_name} shoot with {9/11 : .2f} or {9/11: .1%} accuracy']
# James Bond shoot with  0.82 or  81.8% accuracy 

>>>

print[f'{agent_name} shoot with {9/11 : .2f} or {9/11: .1%} accuracy']
# James Bond shoot with  0.82 or  81.8% accuracy 

>>>

print[f'{agent_name} shoot with {9/11 : .2f} or {9/11: .1%} accuracy']
# James Bond shoot with  0.82 or  81.8% accuracy 

Như bạn có thể thấy, F-String xuất hiện trên đầu.

Tuy nhiên, đó không phải là trường hợp luôn như vậy. Khi chúng được thực hiện lần đầu tiên, họ có một số vấn đề về tốc độ và cần được thực hiện nhanh hơn

tax = 1234

print[f'{tax:,}'] # separate 1k \w comma
# 1,234

print[f'{tax:,.2f}'] # all two decimals 
# 1,234.00

print[f'{tax:~>8}'] # pad left with ~ to fill eight characters or < other direction
# ~~~~1234

print[f'{tax:~^20}'] # centre and pad
# ~~~~~~~~1234~~~~~~~~

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

Dấu ngoặc kép

Bạn có thể sử dụng các 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ã này sẽ hoạt động:

>>>

print[f'{agent_name} shoot with {9/11 : .2f} or {9/11: .1%} accuracy']
# James Bond shoot with  0.82 or  81.8% accuracy 

Như bạn có thể thấy, F-String xuất hiện trên đầu.

>>>

print[f'{agent_name} shoot with {9/11 : .2f} or {9/11: .1%} accuracy']
# James Bond shoot with  0.82 or  81.8% accuracy 

Tuy nhiên, đó không phải là trường hợp luôn như vậy. Khi chúng được thực hiện lần đầu tiên, họ có một số vấn đề về tốc độ và cần được thực hiện nhanh hơn

tax = 1234

print[f'{tax:,}'] # separate 1k \w comma
# 1,234

print[f'{tax:,.2f}'] # all two decimals 
# 1,234.00

print[f'{tax:~>8}'] # pad left with ~ to fill eight characters or < other direction
# ~~~~1234

print[f'{tax:~^20}'] # centre and pad
# ~~~~~~~~1234~~~~~~~~

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

>>>

from datetime import datetime

lookup = {
    '01': 'st',
    '21': 'st',
    '31': 'st',
    '02': 'nd',
    '22': 'nd',
    '03': 'rd',
    '23': 'rd'
}

print[f"{datetime.now[]: %B %d{lookup.get['%B', 'th']} %Y}"]

# April 14th 2022

>>>

from datetime import datetime

lookup = {
    '01': 'st',
    '21': 'st',
    '31': 'st',
    '02': 'nd',
    '22': 'nd',
    '03': 'rd',
    '23': 'rd'
}

print[f"{datetime.now[]: %B %d{lookup.get['%B', 'th']} %Y}"]

# April 14th 2022

Python F-Strings: Các chi tiết phiền phức

>>>

from datetime import datetime

lookup = {
    '01': 'st',
    '21': 'st',
    '31': 'st',
    '02': 'nd',
    '22': 'nd',
    '03': 'rd',
    '23': 'rd'
}

print[f"{datetime.now[]: %B %d{lookup.get['%B', 'th']} %Y}"]

# April 14th 2022

Bây giờ bạn đã học được tất cả về lý do tại sao F-String lại tuyệt vời, tôi chắc chắn bạn muốn ra khỏi đó và bắt đầu sử dụng chúng. Dưới đây là một vài chi tiết cần ghi nhớ khi bạn mạo hiểm vào thế giới mới dũng cảm này.

Dấu ngoặc kép

Bạn có thể sử dụng các 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.

>>>

from datetime import datetime

lookup = {
    '01': 'st',
    '21': 'st',
    '31': 'st',
    '02': 'nd',
    '22': 'nd',
    '03': 'rd',
    '23': 'rd'
}

print[f"{datetime.now[]: %B %d{lookup.get['%B', 'th']} %Y}"]

# April 14th 2022

Mã này sẽ hoạt động:

>>>

from datetime import datetime

lookup = {
    '01': 'st',
    '21': 'st',
    '31': 'st',
    '02': 'nd',
    '22': 'nd',
    '03': 'rd',
    '23': 'rd'
}

print[f"{datetime.now[]: %B %d{lookup.get['%B', 'th']} %Y}"]

# April 14th 2022

Mã này cũng sẽ hoạt động:

Bạn cũng có thể sử dụng Triple Trích dẫn:

Nếu bạn thấy bạn 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 với

>>> name = "Eric"
>>> age = 74
>>> "Hello, %s. You are %s." % [name, age]
'Hello Eric. You are 74.'

>>>

from datetime import datetime

lookup = {
    '01': 'st',
    '21': 'st',
    '31': 'st',
    '02': 'nd',
    '22': 'nd',
    '03': 'rd',
    '23': 'rd'
}

print[f"{datetime.now[]: %B %d{lookup.get['%B', 'th']} %Y}"]

# April 14th 2022

Từ điển

>>>

from datetime import datetime

lookup = {
    '01': 'st',
    '21': 'st',
    '31': 'st',
    '02': 'nd',
    '22': 'nd',
    '03': 'rd',
    '23': 'rd'
}

print[f"{datetime.now[]: %B %d{lookup.get['%B', 'th']} %Y}"]

# April 14th 2022

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

>>>

from datetime import datetime

lookup = {
    '01': 'st',
    '21': 'st',
    '31': 'st',
    '02': 'nd',
    '22': 'nd',
    '03': 'rd',
    '23': 'rd'
}

print[f"{datetime.now[]: %B %d{lookup.get['%B', 'th']} %Y}"]

# April 14th 2022

Điều này sẽ hoạt động:

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

>>>

from datetime import datetime

lookup = {
    '01': 'st',
    '21': 'st',
    '31': 'st',
    '02': 'nd',
    '22': 'nd',
    '03': 'rd',
    '23': 'rd'
}

print[f"{datetime.now[]: %B %d{lookup.get['%B', 'th']} %Y}"]

# April 14th 2022

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ư 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à kết thúc của chuỗi.

>>>

from datetime import datetime

lookup = {
    '01': 'st',
    '21': 'st',
    '31': 'st',
    '02': 'nd',
    '22': 'nd',
    '03': 'rd',
    '23': 'rd'
}

print[f"{datetime.now[]: %B %d{lookup.get['%B', 'th']} %Y}"]

# April 14th 2022