Hướng dẫn string function in python 3 - hàm chuỗi trong python 3

Chuỗi hằng số lor

Các hằng số được xác định trong mô -đun này là:

Sự kết hợp của hằng số

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

Các chữ cái chữ thường

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

Các chữ cái viết hoa

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

Chuỗi

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

Chuỗi

format_spec     ::=  [[fill]align][sign][#][0][width][grouping_option][.precision][type]
fill            ::=  
align           ::=  "" | "=" | "^"
sign            ::=  "+" | "-" | " "
width           ::=  digit+
grouping_option ::=  "_" | ","
precision       ::=  digit+
type            ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"

Chuỗi

format_spec     ::=  [[fill]align][sign][#][0][width][grouping_option][.precision][type]
fill            ::=  
align           ::=  "" | "=" | "^"
sign            ::=  "+" | "-" | " "
width           ::=  digit+
grouping_option ::=  "_" | ","
precision       ::=  digit+
type            ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"

Chuỗi các ký tự ASCII được coi là ký tự chấm câu trong ngôn ngữ

format_spec     ::=  [[fill]align][sign][#][0][width][grouping_option][.precision][type]
fill            ::=  
align           ::=  "" | "=" | "^"
sign            ::=  "+" | "-" | " "
width           ::=  digit+
grouping_option ::=  "_" | ","
precision       ::=  digit+
type            ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"

format_spec     ::=  [[fill]align][sign][#][0][width][grouping_option][.precision][type]
fill            ::=  
align           ::=  "" | "=" | "^"
sign            ::=  "+" | "-" | " "
width           ::=  digit+
grouping_option ::=  "_" | ","
precision       ::=  digit+
type            ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"

Chuỗi các ký tự ASCII được coi là có thể in. Đây là sự kết hợp của

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

Một chuỗi chứa tất cả các ký tự ASCII được coi là khoảng trắng. Điều này bao gồm không gian ký tự, tab, linefeed, return, formFeed và tab dọc.

Định dạng chuỗi tùy chỉnh

Lớp chuỗi tích hợp cung cấp khả năng thực hiện các thay thế biến đổi phức tạp và định dạng giá trị thông qua phương thức

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

>>> 'Coordinates: {latitude}, {longitude}'.format[latitude='37.24N', longitude='-115.81W']
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format[**coord]
'Coordinates: 37.24N, -115.81W'

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

>>> 'Coordinates: {latitude}, {longitude}'.format[latitude='37.24N', longitude='-115.81W']
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format[**coord]
'Coordinates: 37.24N, -115.81W'

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

Lớp

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

Phương pháp API chính. Nó lấy một chuỗi định dạng và một tập hợp các đối số từ khóa và vị trí tùy ý. Nó chỉ là một trình bao bọc mà gọi

>>> 'Coordinates: {latitude}, {longitude}'.format[latitude='37.24N', longitude='-115.81W']
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format[**coord]
'Coordinates: 37.24N, -115.81W'

Đã thay đổi trong phiên bản 3.7: Đối số chuỗi định dạng hiện chỉ có vị trí.A format string argument is now positional-only.

Chức năng này thực hiện công việc thực tế của định dạng. Nó được phơi bày như một chức năng riêng biệt cho các trường hợp bạn muốn truyền trong một từ điển được xác định trước về các đối số, thay vì giải nén và đóng gói từ điển làm đối số riêng lẻ bằng cách sử dụng cú pháp

>>> 'Coordinates: {latitude}, {longitude}'.format[latitude='37.24N', longitude='-115.81W']
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format[**coord]
'Coordinates: 37.24N, -115.81W'

>>> 'Coordinates: {latitude}, {longitude}'.format[latitude='37.24N', longitude='-115.81W']
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format[**coord]
'Coordinates: 37.24N, -115.81W'

>>> 'Coordinates: {latitude}, {longitude}'.format[latitude='37.24N', longitude='-115.81W']
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format[**coord]
'Coordinates: 37.24N, -115.81W'

Ngoài ra,

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

Vòng lặp qua định dạng_string và trả về một bộ dữ liệu [literal_text, field_name, format_spec, chuyển đổi]. Điều này được sử dụng bởi

>>> 'Coordinates: {latitude}, {longitude}'.format[latitude='37.24N', longitude='-115.81W']
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format[**coord]
'Coordinates: 37.24N, -115.81W'

Các giá trị trong tuple về mặt khái niệm đại diện cho một nhịp của văn bản theo nghĩa đen theo sau là một trường thay thế duy nhất. Nếu không có văn bản theo nghĩa đen [có thể xảy ra nếu hai trường thay thế xảy ra liên tiếp], thì literal_text sẽ là một chuỗi có độ dài bằng không. Nếu không có trường thay thế, thì các giá trị của field_name, format_spec và chuyển đổi sẽ là

>>> c = 3-5j
>>> ['The complex number {0} is formed from the real part {0.real} '
...  'and the imaginary part {0.imag}.'].format[c]
'The complex number [3-5j] is formed from the real part 3.0 and the imaginary part -5.0.'
>>> class Point:
...     def __init__[self, x, y]:
...         self.x, self.y = x, y
...     def __str__[self]:
...         return 'Point[{self.x}, {self.y}]'.format[self=self]
...
>>> str[Point[4, 2]]
'Point[4, 2]'

Cho field_name được trả về bởi

>>> c = 3-5j
>>> ['The complex number {0} is formed from the real part {0.real} '
...  'and the imaginary part {0.imag}.'].format[c]
'The complex number [3-5j] is formed from the real part 3.0 and the imaginary part -5.0.'
>>> class Point:
...     def __init__[self, x, y]:
...         self.x, self.y = x, y
...     def __str__[self]:
...         return 'Point[{self.x}, {self.y}]'.format[self=self]
...
>>> str[Point[4, 2]]
'Point[4, 2]'

>>> 'Coordinates: {latitude}, {longitude}'.format[latitude='37.24N', longitude='-115.81W']
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format[**coord]
'Coordinates: 37.24N, -115.81W'

>>> c = 3-5j
>>> ['The complex number {0} is formed from the real part {0.real} '
...  'and the imaginary part {0.imag}.'].format[c]
'The complex number [3-5j] is formed from the real part 3.0 and the imaginary part -5.0.'
>>> class Point:
...     def __init__[self, x, y]:
...         self.x, self.y = x, y
...     def __str__[self]:
...         return 'Point[{self.x}, {self.y}]'.format[self=self]
...
>>> str[Point[4, 2]]
'Point[4, 2]'

>>> 'Coordinates: {latitude}, {longitude}'.format[latitude='37.24N', longitude='-115.81W']
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format[**coord]
'Coordinates: 37.24N, -115.81W'

>>> c = 3-5j
>>> ['The complex number {0} is formed from the real part {0.real} '
...  'and the imaginary part {0.imag}.'].format[c]
'The complex number [3-5j] is formed from the real part 3.0 and the imaginary part -5.0.'
>>> class Point:
...     def __init__[self, x, y]:
...         self.x, self.y = x, y
...     def __str__[self]:
...         return 'Point[{self.x}, {self.y}]'.format[self=self]
...
>>> str[Point[4, 2]]
'Point[4, 2]'

Lấy một giá trị trường đã cho. Đối số chính sẽ là một số nguyên hoặc một chuỗi. Nếu nó là một số nguyên, nó đại diện cho chỉ số của đối số vị trí trong Args; Nếu đó là một chuỗi, thì nó đại diện cho một đối số được đặt tên trong kwargs.

Tham số ARGS được đặt thành danh sách các đối số vị trí thành

>>> 'Coordinates: {latitude}, {longitude}'.format[latitude='37.24N', longitude='-115.81W']
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format[**coord]
'Coordinates: 37.24N, -115.81W'

Đối với tên trường ghép, các chức năng này chỉ được gọi cho thành phần đầu tiên của tên trường; Các thành phần tiếp theo được xử lý thông qua các hoạt động thuộc tính và lập chỉ mục thông thường.

Vì vậy, ví dụ, biểu thức trường ‘0.Name, sẽ khiến

>>> c = 3-5j
>>> ['The complex number {0} is formed from the real part {0.real} '
...  'and the imaginary part {0.imag}.'].format[c]
'The complex number [3-5j] is formed from the real part 3.0 and the imaginary part -5.0.'
>>> class Point:
...     def __init__[self, x, y]:
...         self.x, self.y = x, y
...     def __str__[self]:
...         return 'Point[{self.x}, {self.y}]'.format[self=self]
...
>>> str[Point[4, 2]]
'Point[4, 2]'

>>> coord = [3, 5]
>>> 'X: {0[0]};  Y: {0[1]}'.format[coord]
'X: 3;  Y: 5'

>>> c = 3-5j
>>> ['The complex number {0} is formed from the real part {0.real} '
...  'and the imaginary part {0.imag}.'].format[c]
'The complex number [3-5j] is formed from the real part 3.0 and the imaginary part -5.0.'
>>> class Point:
...     def __init__[self, x, y]:
...         self.x, self.y = x, y
...     def __str__[self]:
...         return 'Point[{self.x}, {self.y}]'.format[self=self]
...
>>> str[Point[4, 2]]
'Point[4, 2]'

>>> coord = [3, 5]
>>> 'X: {0[0]};  Y: {0[1]}'.format[coord]
'X: 3;  Y: 5'

Nếu chỉ mục hoặc từ khóa đề cập đến một mục không tồn tại, thì nên nâng cao

>>> coord = [3, 5]
>>> 'X: {0[0]};  Y: {0[1]}'.format[coord]
'X: 3;  Y: 5'

>>> coord = [3, 5]
>>> 'X: {0[0]};  Y: {0[1]}'.format[coord]
'X: 3;  Y: 5'

Thực hiện kiểm tra các đối số không sử dụng nếu muốn. Các đối số cho hàm này là tập hợp tất cả các khóa đối số thực sự được đề cập trong chuỗi định dạng [số nguyên cho các đối số vị trí và các chuỗi cho các đối số được đặt tên] và tham chiếu đến ARGS và KWARGS được truyền cho VFormat. Tập hợp các arg không sử dụng có thể được tính từ các tham số này.

>>> coord = [3, 5]
>>> 'X: {0[0]};  Y: {0[1]}'.format[coord]
'X: 3;  Y: 5'

>>> "repr[] shows quotes: {!r}; str[] doesn't: {!s}".format['test1', 'test2']
"repr[] shows quotes: 'test1'; str[] doesn't: test2"

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

Chuyển đổi giá trị [được trả về bởi

>>> "repr[] shows quotes: {!r}; str[] doesn't: {!s}".format['test1', 'test2']
"repr[] shows quotes: 'test1'; str[] doesn't: test2"

>>> c = 3-5j
>>> ['The complex number {0} is formed from the real part {0.real} '
...  'and the imaginary part {0.imag}.'].format[c]
'The complex number [3-5j] is formed from the real part 3.0 and the imaginary part -5.0.'
>>> class Point:
...     def __init__[self, x, y]:
...         self.x, self.y = x, y
...     def __str__[self]:
...         return 'Point[{self.x}, {self.y}]'.format[self=self]
...
>>> str[Point[4, 2]]
'Point[4, 2]'

Định dạng Chuỗi Cú pháp

Phương pháp

>>> "repr[] shows quotes: {!r}; str[] doesn't: {!s}".format['test1', 'test2']
"repr[] shows quotes: 'test1'; str[] doesn't: test2"

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

Các chuỗi định dạng có chứa các trường thay thế trên mạng, được bao quanh bởi niềng răng xoăn

>>> "repr[] shows quotes: {!r}; str[] doesn't: {!s}".format['test1', 'test2']
"repr[] shows quotes: 'test1'; str[] doesn't: test2"

>>> "repr[] shows quotes: {!r}; str[] doesn't: {!s}".format['test1', 'test2']
"repr[] shows quotes: 'test1'; str[] doesn't: test2"

>>> '{:30}'.format['right aligned']
'                 right aligned'
>>> '{:^30}'.format['centered']
'           centered           '
>>> '{:*^30}'.format['centered']  # use '*' as a fill char
'***********centered***********'

Ngữ pháp cho một trường thay thế như sau:

replacement_field ::=  "{" [field_name] ["!" conversion] [":" format_spec] "}"
field_name        ::=  arg_name ["." attribute_name | "[" element_index "]"]*
arg_name          ::=  [identifier | digit+]
attribute_name    ::=  identifier
element_index     ::=  digit+ | index_string
index_string      ::=   +
conversion        ::=  "r" | "s" | "a"
format_spec       ::=  

Trong các thuật ngữ ít chính thức hơn, trường thay thế có thể bắt đầu bằng một field_name chỉ định đối tượng có giá trị được định dạng và chèn vào đầu ra thay vì trường thay thế. Field_name được tùy chọn theo sau bởi một trường chuyển đổi, được đi trước bởi một dấu chấm than

>>> '{:30}'.format['right aligned']
'                 right aligned'
>>> '{:^30}'.format['centered']
'           centered           '
>>> '{:*^30}'.format['centered']  # use '*' as a fill char
'***********centered***********'

>>> '{:30}'.format['right aligned']
'                 right aligned'
>>> '{:^30}'.format['centered']
'           centered           '
>>> '{:*^30}'.format['centered']  # use '*' as a fill char
'***********centered***********'

Xem thêm phần Đặc tả định dạng Mini-Language.Format Specification Mini-Language section.

Field_name bắt đầu bằng một arg_name là số hoặc từ khóa. Nếu nó có một số, nó đề cập đến một đối số vị trí và nếu nó là một từ khóa, nó sẽ đề cập đến một đối số từ khóa được đặt tên. Nếu arg_names số trong chuỗi định dạng là 0, 1, 2, theo trình tự, tất cả chúng đều có thể bị bỏ qua [không chỉ một số] và các số 0, 1, 2, sẽ được tự động chèn theo thứ tự đó. Vì arg_name không được trích dẫn, nên không thể chỉ định các khóa từ điển tùy ý [ví dụ: chuỗi

>>> '{:30}'.format['right aligned']
'                 right aligned'
>>> '{:^30}'.format['centered']
'           centered           '
>>> '{:*^30}'.format['centered']  # use '*' as a fill char
'***********centered***********'

>>> '{:30}'.format['right aligned']
'                 right aligned'
>>> '{:^30}'.format['centered']
'           centered           '
>>> '{:*^30}'.format['centered']  # use '*' as a fill char
'***********centered***********'

>>> '{:30}'.format['right aligned']
'                 right aligned'
>>> '{:^30}'.format['centered']
'           centered           '
>>> '{:*^30}'.format['centered']  # use '*' as a fill char
'***********centered***********'

>>> coord = [3, 5]
>>> 'X: {0[0]};  Y: {0[1]}'.format[coord]
'X: 3;  Y: 5'

>>> '{:30}'.format['right aligned']
'                 right aligned'
>>> '{:^30}'.format['centered']
'           centered           '
>>> '{:*^30}'.format['centered']  # use '*' as a fill char
'***********centered***********'

>>> '{:30}'.format['right aligned']
'                 right aligned'
>>> '{:^30}'.format['centered']
'           centered           '
>>> '{:*^30}'.format['centered']  # use '*' as a fill char
'***********centered***********'

Đã thay đổi trong phiên bản 3.1: Các nhà xác định đối số vị trí có thể được bỏ qua cho

>>> "repr[] shows quotes: {!r}; str[] doesn't: {!s}".format['test1', 'test2']
"repr[] shows quotes: 'test1'; str[] doesn't: test2"

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

>>> "repr[] shows quotes: {!r}; str[] doesn't: {!s}".format['test1', 'test2']
"repr[] shows quotes: 'test1'; str[] doesn't: test2"

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

Đã thay đổi trong phiên bản 3.4: Các nhà xác định đối số vị trí có thể được bỏ qua cho

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

Một số ví dụ chuỗi định dạng đơn giản:

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

Trường chuyển đổi gây ra sự ép buộc loại trước khi định dạng. Thông thường, công việc định dạng một giá trị được thực hiện bằng phương thức

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

Ba cờ chuyển đổi hiện đang được hỗ trợ:

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

Vài ví dụ:

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

Trường định dạng_spec chứa một đặc điểm kỹ thuật về cách trình bày giá trị, bao gồm các chi tiết như chiều rộng trường, căn chỉnh, đệm, độ chính xác thập phân, v.v. Mỗi loại giá trị có thể xác định định dạng ngôn ngữ nhỏ của riêng mình hoặc giải thích định dạng_spec.

Hầu hết các loại tích hợp hỗ trợ một ngôn ngữ mini định dạng phổ biến, được mô tả trong phần tiếp theo.

Trường định dạng_spec cũng có thể bao gồm các trường thay thế lồng nhau trong đó. Các trường thay thế lồng nhau này có thể chứa một tên trường, cờ chuyển đổi và đặc tả định dạng, nhưng không được phép làm tổ sâu hơn. Các trường thay thế trong định dạng_spec được thay thế trước khi chuỗi định dạng_spec được giải thích. Điều này cho phép định dạng của một giá trị được chỉ định động.

Xem phần Ví dụ định dạng cho một số ví dụ.Format examples section for some examples.

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

format_spec     ::=  [[fill]align][sign][#][0][width][grouping_option][.precision][type]
fill            ::=  
align           ::=  "" | "=" | "^"
sign            ::=  "+" | "-" | " "
width           ::=  digit+
grouping_option ::=  "_" | ","
precision       ::=  digit+
type            ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"

>>> "repr[] shows quotes: {!r}; str[] doesn't: {!s}".format['test1', 'test2']
"repr[] shows quotes: 'test1'; str[] doesn't: test2"

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

>>> "repr[] shows quotes: {!r}; str[] doesn't: {!s}".format['test1', 'test2']
"repr[] shows quotes: 'test1'; str[] doesn't: test2"

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

>>> "repr[] shows quotes: {!r}; str[] doesn't: {!s}".format['test1', 'test2']
"repr[] shows quotes: 'test1'; str[] doesn't: test2"

>>> "repr[] shows quotes: {!r}; str[] doesn't: {!s}".format['test1', 'test2']
"repr[] shows quotes: 'test1'; str[] doesn't: test2"

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

>>> '{0}, {1}, {2}'.format['a', 'b', 'c']
'a, b, c'
>>> '{}, {}, {}'.format['a', 'b', 'c']  # 3.1+ only
'a, b, c'
>>> '{2}, {1}, {0}'.format['a', 'b', 'c']
'c, b, a'
>>> '{2}, {1}, {0}'.format[*'abc']      # unpacking argument sequence
'c, b, a'
>>> '{0}{1}{0}'.format['abra', 'cad']   # arguments' indices can be repeated
'abracadabra'

>>> 'Coordinates: {latitude}, {longitude}'.format[latitude='37.24N', longitude='-115.81W']
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format[**coord]
'Coordinates: 37.24N, -115.81W'

>>> c = 3-5j
>>> ['The complex number {0} is formed from the real part {0.real} '
...  'and the imaginary part {0.imag}.'].format[c]
'The complex number [3-5j] is formed from the real part 3.0 and the imaginary part -5.0.'
>>> class Point:
...     def __init__[self, x, y]:
...         self.x, self.y = x, y
...     def __str__[self]:
...         return 'Point[{self.x}, {self.y}]'.format[self=self]
...
>>> str[Point[4, 2]]
'Point[4, 2]'

>>> coord = [3, 5]
>>> 'X: {0[0]};  Y: {0[1]}'.format[coord]
'X: 3;  Y: 5'

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

>>> "repr[] shows quotes: {!r}; str[] doesn't: {!s}".format['test1', 'test2']
"repr[] shows quotes: 'test1'; str[] doesn't: test2"

>>> '{:30}'.format['right aligned']
'                 right aligned'
>>> '{:^30}'.format['centered']
'           centered           '
>>> '{:*^30}'.format['centered']  # use '*' as a fill char
'***********centered***********'

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

Chuỗi mẫu

Các chuỗi mẫu cung cấp các thay thế chuỗi đơn giản hơn như được mô tả trong PEP 292. Một trường hợp sử dụng chính cho chuỗi mẫu là để quốc tế hóa [I18N] vì trong bối cảnh đó, cú pháp và chức năng đơn giản hơn giúp dịch dễ dàng hơn các cơ sở định dạng chuỗi tích hợp khác trong Python . Như một ví dụ về thư viện được xây dựng trên chuỗi mẫu cho i18n, hãy xem gói flufl.i18n.PEP 292. A primary use case for template strings is for internationalization [i18n] since in that context, the simpler syntax and functionality makes it easier to translate than other built-in string formatting facilities in Python. As an example of a library built on template strings for i18n, see the flufl.i18n package.

Chuỗi mẫu hỗ trợ thay thế dựa trên 244, sử dụng các quy tắc sau:

• "Harold's a clever {0!s}"        # Calls str[] on the argument first
  "Bring out the holy {name!r}"    # Calls repr[] on the argument first
  "More {!a}"                      # Calls ascii[] on the argument first
  

  45 là một lối thoát; Nó được thay thế bằng một

  "Harold's a clever {0!s}"        # Calls str[] on the argument first
  "Bring out the holy {name!r}"    # Calls repr[] on the argument first
  "More {!a}"                      # Calls ascii[] on the argument first
  

  44.

• "Harold's a clever {0!s}"        # Calls str[] on the argument first
  "Bring out the holy {name!r}"    # Calls repr[] on the argument first
  "More {!a}"                      # Calls ascii[] on the argument first
  

  47 đặt tên cho một trình giữ chỗ thay thế phù hợp với khóa ánh xạ của

  "Harold's a clever {0!s}"        # Calls str[] on the argument first
  "Bring out the holy {name!r}"    # Calls repr[] on the argument first
  "More {!a}"                      # Calls ascii[] on the argument first
  

  48. Theo mặc định,

  "Harold's a clever {0!s}"        # Calls str[] on the argument first
  "Bring out the holy {name!r}"    # Calls repr[] on the argument first
  "More {!a}"                      # Calls ascii[] on the argument first
  

  48 bị giới hạn trong bất kỳ chuỗi chữ và số khác không nhạy cảm với trường hợp [bao gồm cả dấu gạch dưới] bắt đầu bằng chữ cái dấu gạch dưới hoặc ASCII. Nhân vật không nhận dạng đầu tiên sau ký tự

  "Harold's a clever {0!s}"        # Calls str[] on the argument first
  "Bring out the holy {name!r}"    # Calls repr[] on the argument first
  "More {!a}"                      # Calls ascii[] on the argument first
  

  44 chấm dứt đặc tả của người giữ chỗ này.

• "Harold's a clever {0!s}"        # Calls str[] on the argument first
  "Bring out the holy {name!r}"    # Calls repr[] on the argument first
  "More {!a}"                      # Calls ascii[] on the argument first
  

  51 tương đương với

  "Harold's a clever {0!s}"        # Calls str[] on the argument first
  "Bring out the holy {name!r}"    # Calls repr[] on the argument first
  "More {!a}"                      # Calls ascii[] on the argument first
  

  47. Nó được yêu cầu khi các ký tự định danh hợp lệ tuân theo trình giữ chỗ nhưng không phải là một phần của trình giữ chỗ, chẳng hạn như

  "Harold's a clever {0!s}"        # Calls str[] on the argument first
  "Bring out the holy {name!r}"    # Calls repr[] on the argument first
  "More {!a}"                      # Calls ascii[] on the argument first
  

  53.

Bất kỳ sự xuất hiện nào khác của

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

Mô -đun

>>> 'Coordinates: {latitude}, {longitude}'.format[latitude='37.24N', longitude='-115.81W']
'Coordinates: 37.24N, -115.81W'
>>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
>>> 'Coordinates: {latitude}, {longitude}'.format[**coord]
'Coordinates: 37.24N, -115.81W'

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

Trình xây dựng lấy một đối số duy nhất là chuỗi mẫu.

Thực hiện thay thế mẫu, trả về một chuỗi mới. Ánh xạ là bất kỳ đối tượng giống như từ điển nào với các khóa phù hợp với trình giữ chỗ trong mẫu. Ngoài ra, bạn có thể cung cấp các đối số từ khóa, trong đó các từ khóa là người giữ chỗ. Khi cả bản đồ và KWD được đưa ra và có những bản sao, các giữ chỗ từ KWD được ưu tiên.

Giống như

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

>>> coord = [3, 5]
>>> 'X: {0[0]};  Y: {0[1]}'.format[coord]
'X: 3;  Y: 5'

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

Mặc dù các trường hợp ngoại lệ khác vẫn có thể xảy ra, phương pháp này được gọi là an toàn vì nó luôn cố gắng trả về một chuỗi có thể sử dụng thay vì tăng ngoại lệ. Theo một nghĩa khác,

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

Các phiên bản

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

Đây là đối tượng được truyền đến đối số mẫu của Constructor. Nói chung, bạn không nên thay đổi nó, nhưng quyền truy cập chỉ đọc không được thực thi.

Dưới đây là một ví dụ về cách sử dụng một mẫu:

"First, thou shalt count to {0}"  # References first positional argument
"Bring me a {}"                   # Implicitly references the first positional argument
"From {} to {}"                   # Same as "From {0} to {1}"
"My quest is {name}"              # References keyword argument 'name'
"Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
"Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

Sử dụng nâng cao: Bạn có thể lấy các lớp con của

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

• DELIMITER - Đây là chuỗi theo nghĩa đen mô tả một trình giữ chỗ giới thiệu Delimiter. Giá trị mặc định là

  "Harold's a clever {0!s}"        # Calls str[] on the argument first
  "Bring out the holy {name!r}"    # Calls repr[] on the argument first
  "More {!a}"                      # Calls ascii[] on the argument first
  

  44. Lưu ý rằng đây không phải là một biểu thức thông thường, vì việc triển khai sẽ gọi

  "Harold's a clever {0!s}"        # Calls str[] on the argument first
  "Bring out the holy {name!r}"    # Calls repr[] on the argument first
  "More {!a}"                      # Calls ascii[] on the argument first
  

  74 trên chuỗi này khi cần. Lưu ý thêm rằng bạn không thể thay đổi dấu phân cách sau khi tạo lớp [nghĩa là một dấu phân cách khác phải được đặt trong không gian tên lớp con lớp con].

• IDPOTYN-Đây là biểu thức chính quy mô tả mẫu cho người giữ chỗ không thuận tay. Giá trị mặc định là biểu thức thông thường

  "Harold's a clever {0!s}"        # Calls str[] on the argument first
  "Bring out the holy {name!r}"    # Calls repr[] on the argument first
  "More {!a}"                      # Calls ascii[] on the argument first
  

  75. Nếu điều này được đưa ra và BraceIdPotype là

  >>> c = 3-5j
  >>> ['The complex number {0} is formed from the real part {0.real} '
  ...  'and the imaginary part {0.imag}.'].format[c]
  'The complex number [3-5j] is formed from the real part 3.0 and the imaginary part -5.0.'
  >>> class Point:
  ...     def __init__[self, x, y]:
  ...         self.x, self.y = x, y
  ...     def __str__[self]:
  ...         return 'Point[{self.x}, {self.y}]'.format[self=self]
  ...
  >>> str[Point[4, 2]]
  'Point[4, 2]'
  

  4, mô hình này cũng sẽ áp dụng cho các trình giữ chỗ giằng.

  Ghi chú

  Vì các cờ mặc định là

  "Harold's a clever {0!s}"        # Calls str[] on the argument first
  "Bring out the holy {name!r}"    # Calls repr[] on the argument first
  "More {!a}"                      # Calls ascii[] on the argument first
  

  77, mẫu

  "Harold's a clever {0!s}"        # Calls str[] on the argument first
  "Bring out the holy {name!r}"    # Calls repr[] on the argument first
  "More {!a}"                      # Calls ascii[] on the argument first
  

  78 có thể khớp với một số ký tự không phải ASCII. Đó là lý do tại sao chúng tôi sử dụng cờ

  "Harold's a clever {0!s}"        # Calls str[] on the argument first
  "Bring out the holy {name!r}"    # Calls repr[] on the argument first
  "More {!a}"                      # Calls ascii[] on the argument first
  

  79 địa phương ở đây.

  Đã thay đổi trong phiên bản 3.7: BraceIdPattern có thể được sử dụng để xác định các mẫu riêng biệt được sử dụng bên trong và bên ngoài niềng răng.braceidpattern can be used to define separate patterns used inside and outside the braces.

• BraceIdPotype - Điều này giống như idpattern nhưng mô tả mô hình cho các trình giữ chỗ giằng. Mặc định là

  >>> c = 3-5j
  >>> ['The complex number {0} is formed from the real part {0.real} '
  ...  'and the imaginary part {0.imag}.'].format[c]
  'The complex number [3-5j] is formed from the real part 3.0 and the imaginary part -5.0.'
  >>> class Point:
  ...     def __init__[self, x, y]:
  ...         self.x, self.y = x, y
  ...     def __str__[self]:
  ...         return 'Point[{self.x}, {self.y}]'.format[self=self]
  ...
  >>> str[Point[4, 2]]
  'Point[4, 2]'
  

  4 có nghĩa là rơi trở lại idpattern [nghĩa là cùng một mẫu được sử dụng cả niềng răng bên trong và bên ngoài]. Nếu được đưa ra, điều này cho phép bạn xác định các mẫu khác nhau cho các chỗ giữ chỗ giằng và không thay đổi.

  Mới trong phiên bản 3.7.

• Cờ - Các cờ biểu thức chính quy sẽ được áp dụng khi biên dịch biểu thức chính quy được sử dụng để nhận biết các thay thế. Giá trị mặc định là

  "Harold's a clever {0!s}"        # Calls str[] on the argument first
  "Bring out the holy {name!r}"    # Calls repr[] on the argument first
  "More {!a}"                      # Calls ascii[] on the argument first
  

  77. Lưu ý rằng

  "Harold's a clever {0!s}"        # Calls str[] on the argument first
  "Bring out the holy {name!r}"    # Calls repr[] on the argument first
  "More {!a}"                      # Calls ascii[] on the argument first
  

  82 sẽ luôn được thêm vào các lá cờ, vì vậy các idpattern tùy chỉnh phải tuân theo các quy ước cho các biểu thức chính quy verbose.

  Mới trong phiên bản 3.2.

Ngoài ra, bạn có thể cung cấp toàn bộ mẫu biểu thức chính quy bằng cách ghi đè mẫu thuộc tính lớp. Nếu bạn làm điều này, giá trị phải là một đối tượng biểu thức chính quy với bốn nhóm chụp được đặt tên. Các nhóm bắt giữ tương ứng với các quy tắc được đưa ra ở trên, cùng với quy tắc giữ chỗ không hợp lệ:

• Thoát khỏi - Nhóm này phù hợp với chuỗi thoát, ví dụ:

  "Harold's a clever {0!s}"        # Calls str[] on the argument first
  "Bring out the holy {name!r}"    # Calls repr[] on the argument first
  "More {!a}"                      # Calls ascii[] on the argument first
  

  45, trong mẫu mặc định.

• Được đặt tên - Nhóm này phù hợp với tên giữ chỗ không có mặt; Nó không nên bao gồm các dấu phân cách trong nhóm chụp.

• BRACED - Nhóm này phù hợp với tên giữ chỗ kín nẹp; Nó không nên bao gồm các dấu phân cách hoặc niềng răng trong nhóm bắt giữ.

• Không hợp lệ - Nhóm này phù hợp với bất kỳ mẫu phân cách nào khác [thường là một dấu phân cách duy nhất] và nó sẽ xuất hiện cuối cùng trong biểu thức chính quy.

Chức năng của người trợ giúp

Chia đối số thành các từ bằng cách sử dụng

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

"Harold's a clever {0!s}"        # Calls str[] on the argument first
"Bring out the holy {name!r}"    # Calls repr[] on the argument first
"More {!a}"                      # Calls ascii[] on the argument first

>>> c = 3-5j
>>> ['The complex number {0} is formed from the real part {0.real} '
...  'and the imaginary part {0.imag}.'].format[c]
'The complex number [3-5j] is formed from the real part 3.0 and the imaginary part -5.0.'
>>> class Point:
...     def __init__[self, x, y]:
...         self.x, self.y = x, y
...     def __str__[self]:
...         return 'Point[{self.x}, {self.y}]'.format[self=self]
...
>>> str[Point[4, 2]]
'Point[4, 2]'