Hướng dẫn python format html string - chuỗi html định dạng python

Mô -đun

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

6 chứa một số hằng số và lớp hữu ích, cũng như một số hàm di sản không dùng nữa cũng có sẵn dưới dạng phương thức trên chuỗi. Ngoài ra, các lớp chuỗi tích hợp Python, hỗ trợ các phương thức loại trình tự được mô tả trong các loại trình tự-str, unicode, list, tuple, bytearray, bộ đệm, phần xrange và cả các phương thức cụ thể theo chuỗi được mô tả trong phần Phương thức chuỗi. Để đầu ra các chuỗi được định dạng, sử dụng chuỗi mẫu hoặc toán 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

7 được mô tả trong phần Hoạt động định dạng chuỗi. Ngoài ra, xem mô -đun

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

8 cho các hàm chuỗi dựa trên các biểu thức thông thường.Sequence Types — str, unicode, list, tuple, bytearray, buffer, xrange section, and also the string-specific methods described in the String Methods section. To output formatted strings use template strings or the

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

7 operator described in the String Formatting Operations section. Also, see the

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

8 module for string functions based on regular expressions.

________ 19 ________ 362 (s, chiều rộng) ¶String constants¶

Pad Một chuỗi số S ở bên trái với các chữ số bằng không cho đến khi đạt được chiều rộng đã cho. Chuỗi bắt đầu bằng một dấu hiệu được xử lý chính xác.

________ 19 ________ 364 (S, cũ, mới [, MaxReplace]) ¶

Trả về một bản sao của chuỗi s với tất cả các lần xuất hiện của phần phụ cũ được thay thế bằng mới. Nếu đối số tùy chọn MaxReplace được đưa ra, các lần xuất hiện MaxReplace đầu tiên được thay thế.

7.1.1. Chuỗi hằng số lor

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

________ 19 ________ 20¶

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

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

1 và

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

2 được mô tả dưới đây. Giá trị này không phụ thuộc vào địa phương.

________ 19 ________ 24¶

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

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

5. Giá trị này không phụ thuộc vào địa phương và sẽ không thay đổi.

________ 19 ________ 27¶

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

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

8. Giá trị này không phụ thuộc vào địa phương và sẽ không thay đổi.

________ 19 ________ 30¶

Chuỗi

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

1.

________ 19 ________ 33¶

Chuỗi

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

4.

________ 19 ________ 36¶

Sự kết hợp của các chuỗi

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

7 và

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

8 được mô tả dưới đây. Giá trị cụ thể phụ thuộc vào ngôn ngữ và sẽ được cập nhật khi

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

9 được gọi.

________ 19 ________ 41¶

Một chuỗi chứa tất cả các ký tự được coi là chữ thường. Trên hầu hết các hệ thống, đây là chuỗi

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

5. Giá trị cụ thể phụ thuộc vào ngôn ngữ và sẽ được cập nhật khi

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

9 được gọi.

________ 19 ________ 51¶

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

>>> 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(object):
...     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)'

2,

>>> 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(object):
...     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)'

3,

>>> 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(object):
...     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 và

>>> 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(object):
...     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)'

5.

________ 19 ________ 57¶

Một chuỗi chứa tất cả các ký tự được coi là chữ hoa. Trên hầu hết các hệ thống, đây là chuỗi

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

8. Giá trị cụ thể phụ thuộc vào ngôn ngữ và sẽ được cập nhật khi

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

9 được gọi.

________ 19 ________ 61¶

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

7.1.2. Định dạng chuỗi tùy chỉnhCustom String Formatting¶

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

Các lớp STR và Unicode 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 pháp

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

2 được mô tả trong PEP 3101. Lớp

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

3 trong mô-đun

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

6 cho phép bạn tạo và tùy chỉnh các hành vi định dạng chuỗi của riêng bạn như phương pháp

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

5 tích hợp.PEP 3101. The

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

3 class in the

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

6 module allows you to create and customize your own string formatting behaviors using the same implementation as the built-in

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

5 method.

Lớp ________ 19 ________ 67¶

Lớp

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

3 có các phương thức công khai sau:

________ 69 (format_string, *args, ** kwargs) ¶(format_string, *args, **kwargs)¶

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

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

0.

________ 71 (format_string, args, kwargs) ¶(format_string, args, kwargs)¶

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

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

2 và

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

3.

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

0 thực hiện công việc phá vỡ chuỗi định dạng thành dữ liệu ký tự và các trường thay thế. Nó gọi các phương pháp khác nhau được mô tả dưới đây.

Ngoài ra,

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

3 xác định một số phương thức được dự định sẽ được thay thế bằng các lớp con:

________ 76 (Format_String) ¶(format_string)¶

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

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

0 để chia chuỗi thành văn bản theo nghĩa đen hoặc các trường thay thế.

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à

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

8.

________ 79 (field_name, args, kwargs) ¶(field_name, args, kwargs)¶

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

>>> '{:<30}'.format('left aligned')
'left aligned                  '
>>> '{:>30}'.format('right aligned')
'                 right aligned'
>>> '{:^30}'.format('centered')
'           centered           '
>>> '{:*^30}'.format('centered')  # use '*' as a fill char
'***********centered***********'

0 (xem ở trên), chuyển đổi nó thành một đối tượng được định dạng. Trả về một tuple (obj, used_key). Phiên bản mặc định có các chuỗi của biểu mẫu được xác định trong PEP 3101, chẳng hạn như là 0 [tên] Args và kwargs được truyền vào

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

0. Giá trị trả về đã sử dụng_key có cùng ý nghĩa với tham số chính với

>>> '{:<30}'.format('left aligned')
'left aligned                  '
>>> '{:>30}'.format('right aligned')
'                 right aligned'
>>> '{:^30}'.format('centered')
'           centered           '
>>> '{:*^30}'.format('centered')  # use '*' as a fill char
'***********centered***********'

2.PEP 3101, such as “0[name]” or “label.title”. args and kwargs are as passed in to

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

0. The return value used_key has the same meaning as the key parameter to

>>> '{:<30}'.format('left aligned')
'left aligned                  '
>>> '{:>30}'.format('right aligned')
'                 right aligned'
>>> '{:^30}'.format('centered')
'           centered           '
>>> '{:*^30}'.format('centered')  # use '*' as a fill char
'***********centered***********'

2.

________ 83 (khóa, args, kwargs) ¶(key, args, kwargs)¶

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

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

0 và tham số KWARGS được đặt thành từ điển của các đối số từ khóa.

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

>>> '{:<30}'.format('left aligned')
'left aligned                  '
>>> '{:>30}'.format('right aligned')
'                 right aligned'
>>> '{:^30}'.format('centered')
'           centered           '
>>> '{:*^30}'.format('centered')  # use '*' as a fill char
'***********centered***********'

2 được gọi bằng đối số chính là 0. Thuộc tính

>>> '{:<30}'.format('left aligned')
'left aligned                  '
>>> '{:>30}'.format('right aligned')
'                 right aligned'
>>> '{:^30}'.format('centered')
'           centered           '
>>> '{:*^30}'.format('centered')  # use '*' as a fill char
'***********centered***********'

6 sẽ được tra cứu sau khi trả về

>>> '{:<30}'.format('left aligned')
'left aligned                  '
>>> '{:>30}'.format('right aligned')
'                 right aligned'
>>> '{:^30}'.format('centered')
'           centered           '
>>> '{:*^30}'.format('centered')  # use '*' as a fill char
'***********centered***********'

2 bằng cách gọi hàm

>>> '{:<30}'.format('left aligned')
'left aligned                  '
>>> '{:>30}'.format('right aligned')
'                 right aligned'
>>> '{:^30}'.format('centered')
'           centered           '
>>> '{:*^30}'.format('centered')  # use '*' as a fill char
'***********centered***********'

8 tích hợp.

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 tăng

>>> '{:<30}'.format('left aligned')
'left aligned                  '
>>> '{:>30}'.format('right aligned')
'                 right aligned'
>>> '{:^30}'.format('centered')
'           centered           '
>>> '{:*^30}'.format('centered')  # use '*' as a fill char
'***********centered***********'

9 hoặc

>>> '{:+f}; {:+f}'.format(3.14, -3.14)  # show it always
'+3.140000; -3.140000'
>>> '{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers
' 3.140000; -3.140000'
>>> '{:-f}; {:-f}'.format(3.14, -3.14)  # show only the minus -- same as '{:f}; {:f}'
'3.140000; -3.140000'

0.

________ 91 (used_args, args, kwargs) ¶(used_args, args, kwargs)¶

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.

>>> '{:+f}; {:+f}'.format(3.14, -3.14)  # show it always
'+3.140000; -3.140000'
>>> '{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers
' 3.140000; -3.140000'
>>> '{:-f}; {:-f}'.format(3.14, -3.14)  # show only the minus -- same as '{:f}; {:f}'
'3.140000; -3.140000'

2 được giả định để tăng một ngoại lệ nếu kiểm tra không thành công.

________ 93 (giá trị, format_spec) ¶(value, format_spec)¶

>>> '{:+f}; {:+f}'.format(3.14, -3.14)  # show it always
'+3.140000; -3.140000'
>>> '{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers
' 3.140000; -3.140000'
>>> '{:-f}; {:-f}'.format(3.14, -3.14)  # show only the minus -- same as '{:f}; {:f}'
'3.140000; -3.140000'

4 chỉ đơn giản gọi là toàn cầu

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

5 tích hợp. Phương pháp được cung cấp để các lớp con có thể ghi đè nó.

________ 96 (giá trị, chuyển đổi) ¶(value, conversion)¶

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

>>> '{:+f}; {:+f}'.format(3.14, -3.14)  # show it always
'+3.140000; -3.140000'
>>> '{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers
' 3.140000; -3.140000'
>>> '{:-f}; {:-f}'.format(3.14, -3.14)  # show only the minus -- same as '{:f}; {:f}'
'3.140000; -3.140000'

7) được đưa ra một loại chuyển đổi (như trong bộ tuple được trả về bằng phương pháp

>>> '{:<30}'.format('left aligned')
'left aligned                  '
>>> '{:>30}'.format('right aligned')
'                 right aligned'
>>> '{:^30}'.format('centered')
'           centered           '
>>> '{:*^30}'.format('centered')  # use '*' as a fill char
'***********centered***********'

0). Phiên bản mặc định hiểu các loại chuyển đổi (STR), ‘R, (repr) và‘ A (ASCII).

________ 19 ________ 362 (s, chiều rộng) ¶Format String Syntax¶

Pad Một chuỗi số S ở bên trái với các chữ số bằng không cho đến khi đạt được chiều rộng đã cho. Chuỗi bắt đầu bằng một dấu hiệu được xử lý chính xác.

________ 19 ________ 364 (S, cũ, mới [, MaxReplace]) ¶

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

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

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

05 và một định dạng_spec, được đi trước bởi một đại trà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

06. Chúng chỉ định một định dạng không mặc định cho giá trị thay thế.

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

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

07 hoặ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

08) trong chuỗi định dạng. ARG_NAME có thể được theo sau bởi bất kỳ số lượng biểu thức chỉ mục hoặc thuộc tính nào. Một biểu thức của 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

09 chọn thuộc tính được đặt tên bằng cách sử dụng

>>> '{:<30}'.format('left aligned')
'left aligned                  '
>>> '{:>30}'.format('right aligned')
'                 right aligned'
>>> '{:^30}'.format('centered')
'           centered           '
>>> '{:*^30}'.format('centered')  # use '*' as a fill char
'***********centered***********'

8, trong khi biểu thức của 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

11 thực hiện tra cứu chỉ mục 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

12.

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

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

2 và

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

14, do đó

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

15 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

16,

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

17 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

18.The positional argument specifiers can be omitted for

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

2 and

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

14, so

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

15 is equivalent to

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

16,

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

17 is equivalent to

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

18.

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

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

19 của chính giá trị. Tuy nhiên, trong một số trường hợp, mong muốn buộc một loại được định dạng thành một chuỗi, ghi đè lên định nghĩa của chính nó về định dạng. Bằng cách chuyển đổi giá trị thành một chuỗi trước khi 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

19, logic định dạng thông thường được bỏ qua.

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

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

21 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

22 về giá trị và

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

23 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

24.

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

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.

7.1.3.1. Đặc điểm kỹ thuật về định dạng Mini-Language¶Format Specification Mini-Language¶

Thông số kỹ thuật định dạng của Nhật Bản được sử dụng trong các trường thay thế có trong một chuỗi định dạng để xác định cách trình bày các giá trị riêng lẻ (xem Cú pháp chuỗi định dạng). Chúng cũng có thể được chuyển trực tiếp đến chức năng

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

5 tích hợp. Mỗi loại có thể tạo thành có thể xác định cách giải thích đặc tả định dạng.Format String Syntax). They can also be passed directly to the built-in

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

5 function. Each formattable type may define how the format specification is to be interpreted.

Hầu hết các loại tích hợp thực hiện các tùy chọn sau đây cho các thông số kỹ thuật định dạng, mặc dù một số tùy chọn định dạng chỉ được hỗ trợ bởi các loại số.

Một quy ước chung là một chuỗi định dạng trố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

26) tạo ra kết quả tương tự như khi bạn đã 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

22 trên giá trị. Một chuỗi định dạng không trống thường sửa đổi kết quả.

Hình thức chung của trình xác định định dạng tiêu chuẩn là:

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

Nếu một giá trị căn chỉnh hợp lệ được chỉ định, nó có thể được đi trước bởi một ký tự điền có thể là bất kỳ ký tự và mặc định nào đối với một không gian nếu bị bỏ qua. Không thể sử dụng một nẹp xoăn theo nghĩa đen (____ ____128, hoặc ____ ____129) làm ký tự điền khi sử dụng phương pháp

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

2. Tuy nhiên, có thể chèn một nẹp xoăn với một trường thay thế lồng nhau. Giới hạn này không ảnh hưởng đến chức năng

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

5.

Ý nghĩa của các tùy chọn căn chỉnh khác nhau như sau:

Quyền mua	Nghĩ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 32	Buộc trường phải được liên kết trái trong không gian có sẵn (đây là mặc định cho hầu hết các đối tượ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 33	Buộc trường phải được liên kết đúng trong không gian có sẵn (đây là mặc định cho các số).
"Harold's a clever {0!s}" # Calls str() on the argument first "Bring out the holy {name!r}" # Calls repr() on the argument first 34	Buộc các phần đệm được đặt sau dấu hiệu (nếu có) nhưng trước các chữ số. Điều này được sử dụng để in các trường trong mẫu ‘+000000120. Tùy chọn căn chỉnh này chỉ có giá trị cho các loại số. Nó trở thành mặc định khi ‘0 ngay lập tức đi trước chiều rộng trườ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 35	Buộc các lĩnh vực phải được tập trung trong không gian có sẵn.

Lưu ý rằng trừ khi chiều rộng trường tối thiểu được xác định, chiều rộng trường sẽ luôn có cùng kích thước với dữ liệu để điền vào nó, do đó tùy chọn căn chỉnh không có ý nghĩa trong trường hợp này.

Tùy chọn dấu hiệu chỉ hợp lệ cho các loại số và có thể là một trong những điều sau đây:

Quyền mua	Nghĩ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 36	chỉ ra rằng một dấu hiệu nên được sử dụng cho cả số dương cũng như số âm.
"Harold's a clever {0!s}" # Calls str() on the argument first "Bring out the holy {name!r}" # Calls repr() on the argument first 37	chỉ ra rằng một dấu hiệu chỉ nên được sử dụng cho các số âm (đây là hành vi mặc định).
không gian	chỉ ra rằng một không gian hàng đầu nên được sử dụng trên các số dương và dấu trừ trên các số âm.

Tùy chọ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

38 chỉ có giá trị đối với các số nguyên và chỉ cho đầu ra nhị phân, bát phân hoặc thập lục phân. Nếu có, nó chỉ định rằng đầu ra sẽ được tiền tố bở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

39,

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

40 hoặ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

41, tương ứng.

Tùy chọ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

42 báo hiệu việc sử dụng dấu phẩy cho một dấu phân cách hàng ngàn. Đối với một dấu phân cách nhận biết địa phương, thay vào đó hãy sử dụng loại trình bày số nguyê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

43.

Đã thay đổi trong phiên bản 2.7: Đã thêm tùy chọ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

42 (xem thêm PEP 378).Added the

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

42 option (see also PEP 378).

Chiều rộng là một số nguyên thập phân xác định chiều rộng trường tối thiểu. Nếu không được chỉ định, thì chiều rộng trường sẽ được xác định bởi nội dung.

Khi không có sự liên kết rõ ràng được đưa ra, trước trường chiều rộng bằng ký tự bằng 0 (

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

45) cho phép nhận biết số không nhận được cho các loại số. Điều này tương đương với ký tự điền 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

45 với loại căn chỉ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

34.

Độ chính xác là một số thập phân cho biết có bao nhiêu chữ số sẽ được hiển thị sau điểm thập phân cho giá trị điểm nổi được định dạ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

48 và

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

49, hoặc trước và sau điểm thập phân cho giá trị điểm nổi được định dạ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

50 hoặ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

51. Đối với các loại không số, trường cho biết kích thước trường tối đa - nói cách khác, có bao nhiêu ký tự sẽ được sử dụng từ nội dung trường. Độ chính xác không được phép cho các giá trị số nguyên.

Cuối cùng, loại xác định cách trình bày dữ liệu.

Các loại trình bày chuỗi có sẵn là:

Loại hình	Nghĩ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 52	chỉ ra rằng một dấu hiệu nên được sử dụng cho cả số dương cũng như số âm.
chỉ ra rằng một dấu hiệu chỉ nên được sử dụng cho các số âm (đây là hành vi mặc định).	không gian

chỉ ra rằng một không gian hàng đầu nên được sử dụng trên các số dương và dấu trừ trên các số âm.

Loại hình	Nghĩ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 54	chỉ ra rằng một dấu hiệu nên được sử dụng cho cả số dương cũng như số âm.
"Harold's a clever {0!s}" # Calls str() on the argument first "Bring out the holy {name!r}" # Calls repr() on the argument first 55	chỉ ra rằng một dấu hiệu chỉ nên được sử dụng cho các số âm (đây là hành vi 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 56	không gian
"Harold's a clever {0!s}" # Calls str() on the argument first "Bring out the holy {name!r}" # Calls repr() on the argument first 57	chỉ ra rằng một không gian hàng đầu nên được sử dụng trên các số dương và dấu trừ trên các số âm.
"Harold's a clever {0!s}" # Calls str() on the argument first "Bring out the holy {name!r}" # Calls repr() on the argument first 58	Tùy chọ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 38 chỉ có giá trị đối với các số nguyên và chỉ cho đầu ra nhị phân, bát phân hoặc thập lục phân. Nếu có, nó chỉ định rằng đầu ra sẽ được tiền tố bở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 39, "Harold's a clever {0!s}" # Calls str() on the argument first "Bring out the holy {name!r}" # Calls repr() on the argument first 40 hoặ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 41, tương ứ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 59	Tùy chọ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 42 báo hiệu việc sử dụng dấu phẩy cho một dấu phân cách hàng ngàn. Đối với một dấu phân cách nhận biết địa phương, thay vào đó hãy sử dụng loại trình bày số nguyê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 43.
"Harold's a clever {0!s}" # Calls str() on the argument first "Bring out the holy {name!r}" # Calls repr() on the argument first 43	Đã thay đổi trong phiên bản 2.7: Đã thêm tùy chọ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 42 (xem thêm PEP 378).
chỉ ra rằng một dấu hiệu chỉ nên được sử dụng cho các số âm (đây là hành vi mặc định).	không gian

chỉ ra rằng một không gian hàng đầu nên được sử dụng trên các số dương và dấu trừ trên các số âm.

Tùy chọ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

38 chỉ có giá trị đối với các số nguyên và chỉ cho đầu ra nhị phân, bát phân hoặc thập lục phân. Nếu có, nó chỉ định rằng đầu ra sẽ được tiền tố bở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

39,

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

40 hoặ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

41, tương ứng.

Loại hình	Nghĩ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 66	chỉ ra rằng một dấu hiệu nên được sử dụng cho cả số dương cũng như số âm.
"Harold's a clever {0!s}" # Calls str() on the argument first "Bring out the holy {name!r}" # Calls repr() on the argument first 68	chỉ ra rằng một dấu hiệu chỉ nên được sử dụng cho các số âm (đây là hành vi 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 48	không gian
"Harold's a clever {0!s}" # Calls str() on the argument first "Bring out the holy {name!r}" # Calls repr() on the argument first 49	chỉ ra rằng một không gian hàng đầu nên được sử dụng trên các số dương và dấu trừ trên các số âm.
"Harold's a clever {0!s}" # Calls str() on the argument first "Bring out the holy {name!r}" # Calls repr() on the argument first 50	Tùy chọ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 38 chỉ có giá trị đối với các số nguyên và chỉ cho đầu ra nhị phân, bát phân hoặc thập lục phân. Nếu có, nó chỉ định rằng đầu ra sẽ được tiền tố bở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 39, "Harold's a clever {0!s}" # Calls str() on the argument first "Bring out the holy {name!r}" # Calls repr() on the argument first 40 hoặ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 41, tương ứng. Tùy chọ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 42 báo hiệu việc sử dụng dấu phẩy cho một dấu phân cách hàng ngàn. Đối với một dấu phân cách nhận biết địa phương, thay vào đó hãy sử dụng loại trình bày số nguyê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 43. Đã thay đổi trong phiên bản 2.7: Đã thêm tùy chọ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 42 (xem thêm PEP 378). Độ chính xá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 87 được coi là tương đương với độ chính xá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 91. Độ chính xá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 67.
"Harold's a clever {0!s}" # Calls str() on the argument first "Bring out the holy {name!r}" # Calls repr() on the argument first 51	Định dạng chung. 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 50 ngoại trừ chuyển sang "Harold's a clever {0!s}" # Calls str() on the argument first "Bring out the holy {name!r}" # Calls repr() on the argument first 68 nếu số lượng quá lớn. Các đại diện của Infinity và Nan cũng được 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 43	Con số. Điều này 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 50, ngoại trừ việc nó sử dụng cài đặt ngôn ngữ hiện tại để chèn các ký tự phân tách số thích hợp.
"Harold's a clever {0!s}" # Calls str() on the argument first "Bring out the holy {name!r}" # Calls repr() on the argument first 98	Tỷ lệ phần trăm. Nhân số lượng với 100 và hiển thị ở định dạng 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 48), theo sau là dấu phần trăm.
Không có	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 50.

7.1.3.2. Ví dụ định dạng ¶Format examples¶

Phần này chứa các ví dụ về cú pháp

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

2 và so sánh với định dạng ____ 17 cũ.

Trong hầu hết các trường hợp, cú pháp tương tự như định dạng ____ 17 cũ, với việc bổ sung

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

02 và với

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

05 được sử dụng thay vì

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

7. Ví dụ,

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

07 có thể được dịch thành

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

08.

Cú pháp định dạng mới cũng hỗ trợ các tùy chọn mới và khác nhau, được hiển thị trong các ví dụ sau.

Truy cập các đối số theo vị trí:

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

Truy cập các đối số theo tên:

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

Truy cập các thuộc tính của đối số:

>>> 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(object):
...     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)'

Truy cập các mục đối số của các mục:

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

Thay thế

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

09 và

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

10:

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

Căn chỉnh văn bản và chỉ định chiều rộng:

>>> '{:<30}'.format('left aligned')
'left aligned                  '
>>> '{:>30}'.format('right aligned')
'                 right aligned'
>>> '{:^30}'.format('centered')
'           centered           '
>>> '{:*^30}'.format('centered')  # use '*' as a fill char
'***********centered***********'

Thay thế

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

11,

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

12 và

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

13 và chỉ định một dấu hiệu:

>>> '{:+f}; {:+f}'.format(3.14, -3.14)  # show it always
'+3.140000; -3.140000'
>>> '{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers
' 3.140000; -3.140000'
>>> '{:-f}; {:-f}'.format(3.14, -3.14)  # show only the minus -- same as '{:f}; {:f}'
'3.140000; -3.140000'

Thay thế

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

14 và

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

15 và chuyển đổi giá trị thành các cơ sở khác nhau:

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

0

Sử dụng dấu phẩy làm dấu phân cách hàng ngà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

1

Thể hiện tỷ lệ phần trăm:

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

2

Sử dụng định dạng cụ thể loạ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

3

Đối số làm tổ và các ví dụ phức tạp hơ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

4

7.1.4. Chuỗi mẫuTemplate strings¶

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

Các mẫu cung cấp các thay thế chuỗi đơn giản hơn như được mô tả trong PEP 292. Thay vì các thay thế dựa trên ____ 17 bình thường, các mẫu hỗ trợ thay thế dựa trên ____ 217, sử dụng các quy tắc sau:PEP 292. Instead of the normal

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

7-based substitutions, Templates support

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

17-based substitutions, using the following rules:

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

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

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

  17.

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

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

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

  21. Theo mặc định,

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

  21 phải đánh vần một định danh Python. Nhân vật không nhận dạng đầu tiên sau khi ký tự

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

  17 chấm dứt đặc điểm kỹ thuật giữ chỗ này.

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

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

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

  20. 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ư

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

  26.

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

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

17 trong chuỗi sẽ dẫn đến một

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

28 được nâng lên.

Mô -đun

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

6 cung cấp một lớp

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

30 thực hiện các quy tắc này. Các phương pháp của

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

30 là:

Lớp ________ 19 ________ 233 (mẫu) ¶(template)¶

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

________ 234 (ánh xạ [, ** kws]) ¶(mapping[, **kws])¶

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ả hai bản đồ và KW được đưa ra và có những bản sao, các giữ chỗ từ KWS được ưu tiên.

________ 235 (ánh xạ [, ** kws]) ¶(mapping[, **kws])¶

Giống như

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

36, ngoại trừ nếu người giữ chỗ bị thiếu từ ánh xạ và KWS, thay vì tăng ngoại lệ

>>> '{:+f}; {:+f}'.format(3.14, -3.14)  # show it always
'+3.140000; -3.140000'
>>> '{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers
' 3.140000; -3.140000'
>>> '{:-f}; {:-f}'.format(3.14, -3.14)  # show only the minus -- same as '{:f}; {:f}'
'3.140000; -3.140000'

0, trình giữ chỗ ban đầu sẽ xuất hiện trong chuỗi kết quả nguyên vẹn. Ngoài ra, không giống như với

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

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

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

17 sẽ chỉ đơn giản là trả lại

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

17 thay vì tăng

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

28.

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,

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

42 có thể là bất cứ điều gì khác ngoài an toàn, vì nó sẽ âm thầm bỏ qua các mẫu có hình dạng có chứa các phân định lơ lửng, niềng răng chưa từng có hoặc các trình giữ chỗ không phải là định danh python hợp lệ.

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

30 Các trường hợp cũng cung cấp một thuộc tính dữ liệu công khai:

________ 244¶

Đâ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:

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

5

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

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

30 để tùy chỉnh cú pháp giữ chỗ, ký tự phân cách hoặc toàn bộ biểu thức chính quy được sử dụng để phân tích chuỗi mẫu. Để làm điều này, bạn có thể ghi đè các thuộc tính lớp này:

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

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

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

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

  47 trên chuỗi này khi cần.

• IDPattern-Đây là biểu thức chính quy mô tả mẫu dành cho người giữ chỗ không cầm tay (niềng răng sẽ được thêm tự động khi thích hợp). Giá trị mặc định là biểu thức thông thường

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

  48.

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

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

  18, 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.

7.1.5. Chuỗi hàmString functions¶

Các chức năng sau đây có sẵn để hoạt động trên các đối tượng Chuỗi và Unicode. Chúng không có sẵn như các phương thức chuỗi.

________ 19 ________ 251 (s [, sep]) ¶(s[, sep])¶

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

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

52, viết hoa mỗi từ bằng cách sử dụng

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

53 và tham gia các từ được viết hoa bằng cách sử dụng

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

54. Nếu đối số thứ hai tùy chọn SEP không có hoặc

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

8, thì các ký tự khoảng trắng sẽ được thay thế bằng một không gian duy nhất và khoảng trắng dẫn đầu và dấu vết được loại bỏ, nếu không, SEP được sử dụng để chia và tham gia các từ.

________ 19 ________ 257 (từ, đến) ¶(from, to)¶

Trả lại một bảng dịch phù hợp để chuyển đến

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

58, sẽ ánh xạ từng ký tự từ nhân vật ở cùng một vị trí trong; từ và đến phải có cùng chiều dài.

7.1.6. Chuỗi chuỗi không dùng nữaDeprecated string functions¶

Danh sách các chức năng sau đây cũng được định nghĩa là các phương thức của các đối tượng chuỗi và Unicode; Xem Phương thức chuỗi phần để biết thêm thông tin về những phương thức đó. Bạn nên coi các chức năng này là không dùng nữa, mặc dù chúng sẽ không bị xóa cho đến khi Python 3. Các chức năng được xác định trong mô -đun này là:String Methods for more information on those. You should consider these functions as deprecated, although they will not be removed until Python 3. The functions defined in this module are:

________ 19 ________ 260 (s)(s)¶

Không dùng nữa kể từ phiên bản 2.0: Sử dụng chức năng tích hợp

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

65.Use the

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

65 built-in function.

Chuyển đổi một chuỗi thành một số điểm nổi. Chuỗi phải có cú pháp tiêu chuẩn cho một điểm nổi theo nghĩa đen trong Python, tùy chọn đi trước một dấu hiệu (

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

62 hoặc

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

63). Lưu ý rằng điều này hoạt động giống hệt với hàm tích hợp

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

65 khi được truyền một chuỗi.

Ghi chú

Khi truyền trong một chuỗi, các giá trị cho NAN và vô cùng có thể được trả về, tùy thuộc vào thư viện C bên dưới. Tập hợp các chuỗi cụ thể được chấp nhận khiến các giá trị này được trả về hoàn toàn phụ thuộc vào thư viện C và được biết là khác nhau.

________ 19 ________ 266 (s [, cơ sở]) ¶(s[, base])¶

Không dùng nữa kể từ phiên bản 2.0: Sử dụng chức năng tích hợp

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

67.Use the

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

67 built-in function.

Chuyển đổi chuỗi S thành một số nguyên trong cơ sở đã cho. Chuỗi phải bao gồm một hoặc nhiều chữ số, tùy chọn đi trước một dấu hiệu (

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

62 hoặc

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

63). Cơ sở mặc định là 10. Nếu là 0, một cơ sở mặc định được chọn tùy thuộc vào các ký tự hàng đầu của chuỗi (sau khi tước dấu):

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

70 hoặc

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

71 có nghĩa là 16,

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

87 có nghĩa là 8, bất cứ điều gì khác có nghĩa là 10. Nếu cơ sở là 16 , một

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

70 hoặc

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

71 hàng đầu luôn được chấp nhận, mặc dù không cần thiết. Điều này hoạt động giống hệt với chức năng tích hợp

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

67 khi được truyền một chuỗi. (Cũng lưu ý: Để giải thích linh hoạt hơn về các chữ số, hãy sử dụng hàm tích hợp

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

76.)

________ 19 ________ 278 (s [, cơ sở]) ¶(s[, base])¶

Không dùng nữa kể từ phiên bản 2.0: Sử dụng chức năng tích hợp

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

79.Use the

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

79 built-in function.

Chuyển đổi chuỗi S thành một số nguyên dài trong cơ sở đã cho. Chuỗi phải bao gồm một hoặc nhiều chữ số, tùy chọn đi trước một dấu hiệu (

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

62 hoặc

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

63). Đối số cơ sở có ý nghĩa tương tự như đối với

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

82. Trailing

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

83 hoặc

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

84 không được phép, trừ khi cơ sở là 0. Lưu ý rằng khi được gọi không có cơ sở hoặc với cơ sở được đặt thành 10, điều này hoạt động giống hệt với hàm tích hợp

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

79 khi được truyền một chuỗi.

________ 19 ________ 287 (từ)(word)¶

Trả lại một bản sao của Word chỉ với nhân vật đầu tiên được viết hoa.

________ 19 ________ 289 (s [, tabsize]) ¶(s[, tabsize])¶

Mở rộng các tab trong một chuỗi thay thế chúng bằng một hoặc nhiều khoảng trống, tùy thuộc vào cột hiện tại và kích thước tab đã cho. Số cột được đặt lại về 0 sau mỗi dòng mới xảy ra trong chuỗi. Điều này không hiểu các ký tự không in hoặc trình tự thoát khác. Kích thước tab mặc định là 8.

________ 19 ________ 291 (s, sub [, start [, end]]) ¶(s, sub[, start[, end]])¶

Trả về chỉ số thấp nhất trong s nơi tìm thấy phụ con được tìm thấy sao cho phụ được chứa hoàn toàn trong

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

92. Trả lại

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

93 về thất bại. Mặc định cho bắt đầu và kết thúc và giải thích các giá trị âm giống như đối với các lát cắt.

________ 19 ________ 295 (s, sub [, start [, end]]) ¶(s, sub[, start[, end]])¶

Giống như

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

96 nhưng tìm chỉ số cao nhất.

________ 19 ________ 298 (s, sub [, start [, end]]) ¶(s, sub[, start[, end]])¶

Giống như

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

96 nhưng tăng

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

28 khi không tìm thấy chất nền.

________ 19 ________ 302 (s, sub [, start [, end]]) ¶(s, sub[, start[, end]])¶

Giống như

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

03 nhưng tăng

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

28 khi không tìm thấy chất nền.

________ 19 ________ 306 (s, sub [, start [, end]]) ¶(s, sub[, start[, end]])¶

Trả về số lần xuất hiện (không chồng chéo) của Sub Sub trong chuỗi

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

92. Mặc định cho bắt đầu và kết thúc và giải thích các giá trị âm giống như đối với các lát cắt.

________ 19 ________ 309 (s) ¶(s)¶

Trả lại một bản sao của s, nhưng với các chữ cái trên được chuyển đổi thành chữ thường.

________ 19 ________ 311 (S [, SEP [, MaxSplit]])(s[, sep[, maxsplit]])¶

Trả về một danh sách các từ của chuỗi s. Nếu đối số thứ hai tùy chọn không có hoặc

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

8, các từ được phân tách bằng các chuỗi tùy ý của các ký tự khoảng trắng (không gian, tab, newline, return, formFeed). Nếu đối số thứ hai có mặt chứ không phải

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

8, nó chỉ định một chuỗi được sử dụng làm dấu phân cách từ. Danh sách được trả lại sau đó sẽ có thêm một mục so với số lần xuất hiện không chồng chéo của dấu phân cách trong chuỗi. Nếu MAXSplit được đưa ra, tại hầu hết các phân tách MaxSplit xảy ra và phần còn lại của chuỗi được trả về làm yếu tố cuối cùng của danh sách (do đó, danh sách sẽ có nhiều nhất là các phần tử

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

14). Nếu MAXSplit không được chỉ định hoặc

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

93, thì không có giới hạn về số lượng chia tách (tất cả các phân tách có thể được thực hiện).

Hành vi phân tách trên một chuỗi trống phụ thuộc vào giá trị của SEP. Nếu SEP không được chỉ định hoặc được chỉ định là

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

8, kết quả sẽ là một danh sách trống. Nếu SEP được chỉ định là bất kỳ chuỗi nào, kết quả sẽ là một danh sách chứa một phần tử là một chuỗi trống.

________ 19 ________ 318 (S [, SEP [, MaxSplit]])(s[, sep[, maxsplit]])¶

Trả về một danh sách các từ của chuỗi s, quét s từ cuối. Đối với tất cả các ý định và mục đích, danh sách các từ kết quả giống như được trả về bởi

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

19, ngoại trừ khi đối số thứ ba tùy chọn MaxSplit được chỉ định rõ ràng và khác không. Nếu MAXSplit được đưa ra, ở hầu hết các phân tách MaxSplit - các phần ngoài cùng bên phải - xảy ra và phần còn lại của chuỗi được trả về làm phần tử đầu tiên của danh sách (do đó, danh sách sẽ có nhiều nhất là các phần tử

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

14).

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

________ 19 ________ 322 (S [, SEP [, MaxSplit]])(s[, sep[, maxsplit]])¶

Hàm này hoạt động giống hệt với

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

19. (Trước đây,

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

19 chỉ được sử dụng với một đối số, trong khi

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

25 chỉ được sử dụng với hai đối số.)

________ 19 ________ 327 (từ [, sep]) ¶(words[, sep])¶

Concatenate một danh sách hoặc tuple của các từ với các lần xuất hiện của SEP. Giá trị mặc định cho SEP là một ký tự không gian duy nhất. Luôn luôn đúng là

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

28 bằng s.

________ 19 ________ 330 (từ [, sep]) ¶(words[, sep])¶

Hàm này hoạt động giống hệt với

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

31. . sử dụng phương thức

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

31 thay thế.

________ 19 ________ 337 (s [, chars]) ¶(s[, chars])¶

Trả về một bản sao của chuỗi với các ký tự hàng đầu bị xóa. Nếu chars bị bỏ qua hoặc

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

8, các ký tự khoảng trắng sẽ bị xóa. Nếu được đưa ra và không

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

8, chars phải là một chuỗi; Các ký tự trong chuỗi sẽ bị tước từ đầu chuỗi mà phương thức này được gọi là bật.

Đã thay đổi trong phiên bản 2.2.3: Tham số Chars đã được thêm vào. Tham số ký tự không thể được truyền trong phiên bản 2.2 trước đó.The chars parameter was added. The chars parameter cannot be passed in earlier 2.2 versions.

________ 19 ________ 341 (s [, chars]) ¶(s[, chars])¶

Trả về một bản sao của chuỗi với các ký tự dấu vết bị xóa. Nếu chars bị bỏ qua hoặc

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

8, các ký tự khoảng trắng sẽ bị xóa. Nếu được đưa ra và không

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

8, chars phải là một chuỗi; Các ký tự trong chuỗi sẽ bị tước từ cuối chuỗi mà phương thức này được gọi.

Đã thay đổi trong phiên bản 2.2.3: Tham số Chars đã được thêm vào. Tham số ký tự không thể được truyền trong phiên bản 2.2 trước đó.The chars parameter was added. The chars parameter cannot be passed in earlier 2.2 versions.

________ 19 ________ 341 (s [, chars]) ¶(s[, chars])¶

Trả về một bản sao của chuỗi với các ký tự dấu vết bị xóa. Nếu chars bị bỏ qua hoặc

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

8, các ký tự khoảng trắng sẽ bị xóa. Nếu được đưa ra và không

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

8, chars phải là một chuỗi; Các ký tự trong chuỗi sẽ bị tước từ cuối chuỗi mà phương thức này được gọi.

Đã thay đổi trong phiên bản 2.2.3: Tham số Chars đã được thêm vào. Tham số ký tự không thể được truyền trong phiên bản 2.2 trước đó.The chars parameter was added. The chars parameter cannot be passed in earlier 2.2 versions.

________ 19 ________ 341 (s [, chars]) ¶(s)¶

Trả về một bản sao của chuỗi với các ký tự dấu vết bị xóa. Nếu chars bị bỏ qua hoặc

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

8, các ký tự khoảng trắng sẽ bị xóa. Nếu được đưa ra và không

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

8, chars phải là một chuỗi; Các ký tự trong chuỗi sẽ bị tước từ cuối chuỗi mà phương thức này được gọi.

________ 19 ________ 345 (s [, chars]) ¶(s, table[, deletechars])¶

Trả về một bản sao của chuỗi với các ký tự dẫn và dấu vết đã bị xóa. Nếu chars bị bỏ qua hoặc

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

8, các ký tự khoảng trắng sẽ bị xóa. Nếu được đưa ra và không

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

8, chars phải là một chuỗi; Các ký tự trong chuỗi sẽ bị tước từ cả hai đầu của chuỗi Phương thức này được gọi.

________ 19 ________ 349 (s) ¶(s)¶

Trả về một bản sao của s, nhưng với các chữ cái chữ thường được chuyển đổi thành Case trên và ngược lại.

________ 19 ________ 351 (s, bảng [, deletechars]) ¶(s, width[, fillchar])¶

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

9

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

58(s, width[, fillchar])¶

"Harold's a clever {0!s}"        # Calls str() on the argument first
"Bring out the holy {name!r}"    # Calls repr() on the argument first

9

>>> '{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
>>> '{}, {}, {}'.format('a', 'b', 'c')  # 2.7+ 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'

60(s, width[, fillchar])¶

Xóa tất cả các ký tự khỏi s nằm trong deletechar (nếu có), sau đó dịch các ký tự bằng bảng, phải là chuỗi 256 ký tự đưa ra bản dịch cho mỗi giá trị ký tự, được lập chỉ mục theo thứ tự của nó. Nếu bảng là

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

8, thì chỉ có bước xóa ký tự được thực hiện.

________ 19 ________ 354 (s) ¶(s, width)¶

Trả lại một bản sao của s, nhưng với chữ cái chữ thường được chuyển đổi thành vỏ trên.

________ 19 ________ 356 (s, chiều rộng [, fillchar]) ____ ____ 19 ________ 358 (s, chiều rộng [, fillchar])(s, old, new[, maxreplace])¶

Các chức năng này tương ứng là thông minh bên trái, thông minh bên phải và trung tâm một chuỗi trong một trường có chiều rộng nhất định. Chúng trả về một chuỗi có ít nhất các ký tự chiều rộng, được tạo bằng cách đệm chuỗi s với vệt ký tự (mặc định là một không gian) cho đến khi chiều rộng đã cho ở bên phải, trái hoặc cả hai bên. Chuỗi không bao giờ bị cắt ngắn.