Chuyển đổi định dạng bằng Python, định dạng (điền số 0, ký hiệu hàm mũ, hệ thập lục phân, v.v.)

Kinh doanh

Để chuyển đổi (định dạng) một số hoặc chuỗi thành các định dạng khác nhau trong Python, hãy sử dụng hàm tích hợp định dạng () hoặc phương thức chuỗi str.format ().

Trong phần này, chúng tôi sẽ giải thích cách sử dụng các hàm sau.

  • chức năng tích hợp sẵn (ví dụ: trong ngôn ngữ lập trình)format()
  • phương pháp chuỗistr.format()

Ngoài ra, chuỗi đặc tả định dạng để chuyển đổi sang định dạng sau được giải thích bằng mã mẫu.

  • Căn trái, căn giữa, căn phải
  • điền số 0
  • Dấu (cộng hoặc trừ)
  • Dấu phân cách chữ số (dấu phẩy, dấu gạch dưới)
  • Số nhị phân, bát phân và số thập lục phân
  • Chỉ định số chữ số sau dấu thập phân
  • Số liệu quan trọng (số chữ số có nghĩa)
  • ký hiệu mũ
  • Tỷ lệ phần trăm hiển thị

Lưu ý rằng kể từ Python 3.6, f-string (chuỗi f) đã được thêm vào phương thức string str.format () để làm cho nó ngắn gọn hơn.

Hàm tích hợp: format ()

format () được cung cấp dưới dạng một hàm tích hợp sẵn trong Python tiêu chuẩn.

Bản phác thảo như sau.

  • format(value, format_spec)
    • Đối số đầu tiên:value
      Giá trị ban đầu. Chuỗi str, số int, float, v.v.
    • Đối số thứ haiformat_spec
      Định dạng chuỗi đặc tả. Chuỗi str
    • Giá trị trả về: một chuỗi được định dạng str

Ví dụ được hiển thị bên dưới. Các loại chuỗi định dạng và cách viết chúng được mô tả sau.

Trong ví dụ này, chúng tôi đã sử dụng các ký tự số và ký tự chuỗi làm đối số đầu tiên, nhưng tất nhiên bạn có thể sử dụng các biến có chứa các giá trị này.

s = format(255, '04x')
print(s)
print(type(s))
# 00ff
# <class 'str'>

print(format('center', '*^16'))
# *****center*****

Phương thức chuỗi str.format ()

Ngoài ra còn có một phương thức format () cho kiểu chuỗi str.

{} Trong chuỗi str gọi phương thức format () được gọi là trường thay thế và được thay thế bằng đối số của phương thức format ().

Chuỗi đặc tả định dạng phải được viết trong trường thay thế {} theo sau là “:”.

Giá trị trả về là một chuỗi được định dạng str.

Quá trình tương đương với định dạng hàm dựng sẵn () được mô tả ở trên như sau.

s = '{:04x}'.format(255)
print(s)
print(type(s))
# 00ff
# <class 'str'>

print('{:*^16}'.format('center'))
# *****center*****

Một lần nữa, chúng tôi đang sử dụng các ký tự số và ký tự chuỗi làm đối số, nhưng tất nhiên các biến cũng được chấp nhận.

Chỉ định đối số cho các trường thay thế

Chỉ định các đối số theo thứ tự (mặc định)

Có thể có nhiều trường thay thế {} và theo mặc định, các đối số của phương thức được xử lý theo thứ tự. Nếu chuỗi đặc tả định dạng trong {} bị bỏ qua, nó sẽ chỉ được chuyển đổi thành chuỗi bởi str ().

Hữu ích để chèn các giá trị biến trong một chuỗi và in chúng.

print('{}-{}-{}'.format('100', '二百', 300))
# 100-二百-300

Chỉ định một đối số vị trí cho các giá trị số nguyên

Nếu một giá trị số nguyên được chỉ định trong {}, chẳng hạn như {0} hoặc {1}, kết quả đầu ra sẽ phụ thuộc vào thứ tự của các đối số. Số lượng giống nhau có thể được sử dụng nhiều lần. Điều này rất hữu ích khi bạn muốn chèn cùng một giá trị vào một chuỗi.

print('{0}-{1}-{0}'.format('foo', 'bar'))
# foo-bar-foo

Chỉ định các đối số từ khóa cho các tên (chuỗi) tùy ý

Bạn cũng có thể chỉ định bất kỳ tên nào trong {} và nhập tên đó làm đối số từ khóa.

print('{day}/{month}/{year}/'.format(day=11, month=1, year=2018))
# 11/1/2018

Chỉ định danh sách hoặc từ điển làm đối số

Danh sách và từ điển có thể được chỉ định làm đối số.

Sử dụng [] để chỉ định chỉ mục của danh sách hoặc khóa của từ điển trong trường thay thế. Lưu ý rằng dấu ngoặc kép “” và “” không được sử dụng để chỉ định khóa từ điển.

Nếu bạn muốn sử dụng lặp lại cùng một đối số, bạn cần chỉ định một giá trị số nguyên hoặc một chuỗi (tên) như được mô tả ở trên.

l = ['one', 'two', 'three']
print('{0[0]}-{0[1]}-{0[2]}'.format(l))
# one-two-three

d1 = {'name': 'Alice', 'age': 20}
d2 = {'name': 'Bob', 'age': 30}
print('{0[name]} is {0[age]} years old.\n{1[name]} is {1[age]} years old.'.format(d1, d2))
# Alice is 20 years old.
# Bob is 30 years old.

Nó có thể được mở rộng như một đối số vị trí bằng cách thêm * vào danh sách và chỉ định nó làm đối số hoặc như một đối số từ khóa bằng cách thêm ** vào từ điển và chỉ định nó làm đối số.

l = ['one', 'two', 'three']
print('{}-{}-{}'.format(*l))
# one-two-three

d = {'name': 'Alice', 'age': 20}
print('{name} is {age} years old.'.format(**d))
# Alice is 20 years old.

Mô tả của dấu ngoặc nhọn {}

Nếu bạn muốn viết dấu ngoặc nhọn {,} trong phương thức format (), hãy lặp lại hai lần như {{,}}. Lưu ý rằng không thể thoát dấu gạch chéo ngược.

print('{{}}-{num}-{{{num}}}'.format(num=100))
# {}-100-{100}

chuỗi định dạng

Trong cả hai trường hợp, để chỉ định định dạng, hãy viết “: chuỗi định dạng” sau giá trị số nguyên hoặc chuỗi tên trong {}.

print('{num:x}'.format(num=255))
# ff

print('{day}/{month:02}/{year:02}/'.format(day=11, month=1, year=2018))
# 11/01/2018

Trong phần sau, chúng tôi sẽ giải thích cách chỉ định định dạng bằng cách sử dụng chuỗi định dạng. Mã mẫu sử dụng phương thức chuỗi str.format (), nhưng có thể sử dụng cùng một chuỗi định dạng với định dạng hàm dựng sẵn (). Trong định dạng hàm dựng sẵn (), chuỗi đặc tả định dạng được chỉ định làm đối số thứ hai.

Căn trái, căn giữa, căn phải

Bạn có thể căn trái, căn giữa, căn phải, v.v. bên dưới. Chỉ định tổng số ký tự dưới dạng số.

  • <
  • ^
  • >
print('left  : {:<10}'.format(100))
print('center: {:^10}'.format(100))
print('right : {:>10}'.format(100))
# left  : 100       
# center:    100    
# right :        100

Bạn cũng có thể chỉ định một ký tự sẽ được điền vào. Nếu bị bỏ qua, như trong ví dụ trên, nó là một khoảng trắng.

Bạn có thể sử dụng các ký tự 2 byte miễn là nó là một ký tự đơn.

print('left  : {:*<10}'.format(100))
print('center: {:a^10}'.format(100))
print('right : {:鬼>10}'.format(100))
# left  : 100*******
# center: aaa100aaaa
# right : 鬼鬼鬼鬼鬼鬼鬼100

Biện minh đúng đắn với & gt; không tính đến dấu (-, +). Nếu bạn sử dụng =, dấu được theo sau bởi ký tự được chỉ định. Nếu bạn muốn chỉ định +, hãy viết + sau =. Chi tiết về xử lý dấu hiệu được mô tả sau.

print('sign: {:0>10}'.format(-100))
print('sign: {:0=10}'.format(-100))
print('sign: {:0=+10}'.format(100))
# sign: 000000-100
# sign: -000000100
# sign: +000000100

& lt ;, ^ và & gt; có thể được chỉ định cho các chuỗi, nhưng = sẽ dẫn đến lỗi ValueError. Nếu bạn muốn sử dụng = cho một chuỗi, bạn cần chuyển nó thành một số bằng cách sử dụng int ().

# print('sign: {:0=10}'.format('-100'))
# ValueError: '=' alignment not allowed in string format specifier

print('sign: {:0=10}'.format(int('-100')))
# sign: -000000100

Điều tương tự cũng áp dụng cho các số dấu phẩy động. Điểm thập phân cũng được tính là một ký tự.

print('left  : {:*<10}'.format(1.23))
print('center: {:a^10}'.format(1.23))
print('right : {:鬼>10}'.format(1.23))
# left  : 1.23******
# center: aaa1.23aaa
# right : 鬼鬼鬼鬼鬼鬼1.23

print('sign: {:0>10}'.format(-1.23))
print('sign: {:0=10}'.format(-1.23))
print('sign: {:0=+10}'.format(1.23))
# sign: 00000-1.23
# sign: -000001.23
# sign: +000001.23

Danh sách, bộ giá trị, v.v. sẽ gây ra lỗi nếu được chỉ định nguyên trạng và có thể được chuyển đổi thành chuỗi bằng cách sử dụng str ().

l = [0, 1]
print(type(l))
# <class 'list'>

# print('{:*^16}'.format(l))
# TypeError: unsupported format string passed to list.__format__

print(type(str(l)))
# <class 'str'>

print('{:*^16}'.format(str(l)))
# *****[0, 1]*****

Đối với căn trái, căn giữa và căn phải, cũng có các phương thức chuỗi chuyên dụng được gọi là ljust (), center () và rjust ().

0 điền

Nếu bạn muốn điều chỉnh số lượng chữ số bằng cách điền 0, hãy đặt ký tự được điền thành 0 và căn phải nó.

Trong trường hợp điền bằng 0, nếu biểu tượng căn chỉnh bị bỏ qua, nó được xử lý như thể = được chỉ định.

print('zero padding: {:0=10}'.format(100))
print('zero padding: {:010}'.format(100))
# zero padding: 0000000100
# zero padding: 0000000100

print('zero padding: {:0=10}'.format(-100))
print('zero padding: {:010}'.format(-100))
# zero padding: -000000100
# zero padding: -000000100

#LỖI!

# print('zero padding: {:010}'.format('-100'))
# ValueError: '=' alignment not allowed in string format specifier

Để điền bằng không, cũng có một phương thức chuỗi chuyên dụng được gọi là zfill ().

Dấu (cộng hoặc trừ)

Theo mặc định, chỉ các số âm mới được đánh dấu bằng dấu (trừ-).

Khi + được thêm vào chuỗi đặc tả định dạng, một dấu (cộng +) cũng được hiển thị cho các số dương. Nếu một khoảng trắng được thêm vào, một khoảng trắng sẽ được hiển thị ở đầu số dương và số chữ số được căn với số âm.

print('sign: {}'.format(100))
print('sign: {}'.format(-100))
# sign: 100
# sign: -100

print('sign: {:+}'.format(100))
print('sign: {:+}'.format(-100))
# sign: +100
# sign: -100

print('sign: {: }'.format(100))
print('sign: {: }'.format(-100))
# sign:  100
# sign: -100

Hãy cẩn thận khi điền các ký tự tùy ý, chẳng hạn như điền số 0 được đề cập ở trên. Giá trị mặc định, không có + và không có dấu cách, điền vào các số dương bằng một ký tự nữa.

print('sign: {:06}'.format(100))
print('sign: {:06}'.format(-100))
# sign: 000100
# sign: -00100

print('sign: {:+06}'.format(100))
print('sign: {:+06}'.format(-100))
# sign: +00100
# sign: -00100

print('sign: {: 06}'.format(100))
print('sign: {: 06}'.format(-100))
# sign:  00100
# sign: -00100

Nếu sử dụng ký hiệu căn chỉnh thì ký hiệu ký hiệu phải được viết sau ký hiệu căn chỉnh.

print('sign: {:_>6}'.format(100))
print('sign: {:_>6}'.format(-100))
# sign: ___100
# sign: __-100

print('sign: {:_>+6}'.format(100))
print('sign: {:_>+6}'.format(-100))
# sign: __+100
# sign: __-100

print('sign: {:_> 6}'.format(100))
print('sign: {:_> 6}'.format(-100))
# sign: __ 100
# sign: __-100

Dấu phân cách chữ số (dấu phẩy, dấu gạch dưới)

Thêm dấu phẩy hoặc dấu gạch dưới _ dấu phân cách ba chữ số một lần. Điều này làm cho các số lớn dễ đọc hơn. Lưu ý rằng underscore_ là một tùy chọn được thêm vào trong Python 3.6, vì vậy nó không thể được sử dụng trong các phiên bản trước đó.

print('{:,}'.format(100000000))
# 100,000,000

print('{:_}'.format(100000000))
# 100_000_000

Trong trường hợp kiểu số thực dấu phẩy động, chỉ phần nguyên được phân tách.

print('{:,}'.format(1234.56789))
# 1,234.56789

Số nhị phân, bát phân và số thập lục phân

Chuyển đổi các giá trị số thành số nhị phân, bát phân và thập lục phân cho đầu ra.

  • b: Nhị phân
  • o: Bát phân
  • d: Số thập phân
  • x,X: Hệ thập lục phân (chữ hoa được viết hoa)
print('bin: {:b}'.format(255))
print('oct: {:o}'.format(255))
print('dec: {:d}'.format(255))
print('hex: {:x}'.format(255))
print('HEX: {:X}'.format(255))
# bin: 11111111
# oct: 377
# dec: 255
# hex: ff
# HEX: FF

Nó cũng có thể được kết hợp với điền 0 và thường được sử dụng để căn chỉnh các chữ số trong ký hiệu nhị phân và thập lục phân.

print('bin: {:08b}'.format(255))
print('oct: {:08o}'.format(255))
print('dec: {:08d}'.format(255))
print('hex: {:08x}'.format(255))
print('HEX: {:08X}'.format(255))
# bin: 11111111
# oct: 00000377
# dec: 00000255
# hex: 000000ff
# HEX: 000000FF

Lưu ý rằng số lượng ký tự điền bằng 0 phải được chỉ định có tính đến tiền tố.

print('bin: {:#010b}'.format(255))
print('oct: {:#010o}'.format(255))
print('dec: {:#010d}'.format(255))
print('hex: {:#010x}'.format(255))
print('HEX: {:#010X}'.format(255))
# bin: 0b11111111
# oct: 0o00000377
# dec: 0000000255
# hex: 0x000000ff
# HEX: 0X000000FF

Đối với số nhị phân và số thập lục phân, chỉ có thể chèn dấu phân tách chữ số _ dấu gạch dưới (Python 3.6 trở lên). Dấu phân cách 4 chữ số được sử dụng; số lượng các ký tự được điền bằng 0 cũng phải tính đến số lượng dấu gạch dưới.

print('hex: {:08x}'.format(255))
print('hex: {:09_x}'.format(255))
print('hex: {:#011_x}'.format(255))
# hex: 000000ff
# hex: 0000_00ff
# hex: 0x0000_00ff

Chỉ kiểu số nguyên int mới có thể chuyển đổi định dạng sang hệ nhị phân hoặc hệ thập lục phân. Bạn có thể sử dụng int () để chuyển nó thành một số.

# print('hex: {:08x}'.format('255'))
# ValueError: Unknown format code 'X' for object of type 'str'

print('hex: {:08x}'.format(int('255')))
# hex: 000000ff

Chỉ định số chữ số sau dấu thập phân

Để xác định số chữ số sau dấu thập phân, thực hiện như sau: n là số chữ số. Số chữ số sau dấu thập phân trở thành số chữ số xác định không phụ thuộc vào số chữ số ở phần nguyên.
.[n]f

print('{:.2f}'.format(123.456))
print('{:.5f}'.format(123.456))
print('{:.3f}'.format(0.0001234))
# 123.46
# 123.45600
# 0.000

Phía bên trái của dấu thập phân có thể được chỉ định là căn trái, căn giữa, căn phải hoặc điền bằng không như mô tả ở trên. Nếu số chữ số của giá trị đích nhiều hơn số được chỉ định, thì không có gì được thực hiện. Nếu số chữ số trong giá trị mục tiêu lớn hơn số chữ số được chỉ định, thì không có gì được thực hiện.

print('{:>12.5f}'.format(123.456))
print('{:012.5f}'.format(123.456))
print('{:06.5f}'.format(123.456))
#    123.45600
# 000123.45600
# 123.45600

Nếu bạn chỉ định một số chữ số nhỏ hơn số chữ số ban đầu sau dấu thập phân, giá trị sẽ được làm tròn. Lưu ý rằng điều này không làm tròn đến số nguyên gần nhất mà là số chẵn, ví dụ: 0,5 được làm tròn thành 0.

print('{:.0f}'.format(0.4))
print('{:.0f}'.format(0.5))
print('{:.0f}'.format(0.6))
# 0
# 0
# 1

Nếu bạn muốn sử dụng làm tròn tổng quát, bạn có thể sử dụng phương thức quantize () của thư viện tiêu chuẩn thập phân.

ký hiệu mũ

Khi một số thực dấu phẩy động được chuyển đổi thành chuỗi str, nó sẽ tự động được viết dưới dạng ký hiệu hàm mũ tùy thuộc vào số lượng chữ số. Kiểu số nguyên int thì không.

print('{}'.format(0.0001234))
print('{}'.format(0.00001234))
# 0.0001234
# 1.234e-05

print('{}'.format(1234000000000000.0))
print('{}'.format(12340000000000000.0))
print('{}'.format(12340000000000000000000000))
# 1234000000000000.0
# 1.234e+16
# 12340000000000000000000000

Nếu bạn chỉ định e hoặc E trong chuỗi đặc tả định dạng, bạn luôn có thể chuyển đổi sang ký hiệu hàm mũ. Các ký tự được sử dụng trong đầu ra sẽ lần lượt là e và E.

print('{:e}'.format(0.0001234))
print('{:E}'.format(0.0001234))
# 1.234000e-04
# 1.234000E-04

Cũng có thể chỉ định số chữ số sau dấu thập phân. Phần nguyên sẽ luôn là một chữ số và dấu thập phân sẽ là số chữ số được chỉ định.

print('{:.5e}'.format(0.0001234))
print('{:.2E}'.format(0.0001234))
# 1.23400e-04
# 1.23E-04

print('{:.5e}'.format(987.65))
print('{:.2E}'.format(987.65))
# 9.87650e+02
# 9.88E+02

Lưu ý rằng nếu bạn chỉ định căn trái, căn giữa, căn phải hoặc không điền, e-, E +, v.v. cũng sẽ được tính là chữ số (ký tự).

print('{:>12.5e}'.format(987.65))
print('{:012.2E}'.format(987.65))
#  9.87650e+02
# 00009.88E+02

Số liệu quan trọng (số chữ số có nghĩa)

Bạn có thể chỉ định tổng số chữ số bằng cách thực hiện như sau Tùy thuộc vào kết quả, ký hiệu hàm mũ sẽ được sử dụng tự động. Lưu ý rằng các số không ở cuối sau dấu thập phân sẽ bị bỏ qua.
.[n]g

print('{:.2g}'.format(123.456))
print('{:.3g}'.format(123.456))
print('{:.8g}'.format(123.456))
print('{:.3g}'.format(0.0001234))
# 1.2e+02
# 123
# 123.456
# 0.000123

Nếu bạn bỏ qua g, đầu ra sẽ không phải là số nguyên. g giống nhau trong hầu hết các trường hợp, nhưng chỉ trong trường hợp đầu ra là một số nguyên.

print('{:.2}'.format(123.456))
print('{:.3}'.format(123.456))
print('{:.8}'.format(123.456))
print('{:.3}'.format(0.0001234))
# 1.2e+02
# 1.23e+02
# 123.456
# 0.000123

Nếu chúng tôi xử lý cùng một giá trị, chúng tôi nhận được tương ứng như sau.

print('{:.3f}'.format(123.456))
print('{:.3e}'.format(123.456))
print('{:.3g}'.format(123.456))
print('{:.3}'.format(123.456))
# 123.456
# 1.235e+02
# 123
# 1.23e+02

print('{:.8f}'.format(123.456))
print('{:.8e}'.format(123.456))
print('{:.8g}'.format(123.456))
print('{:.8}'.format(123.456))
# 123.45600000
# 1.23456000e+02
# 123.456
# 123.456

Trong trường hợp g hoặc nếu nó bị bỏ qua, các số không ở cuối sau dấu thập phân sẽ bị bỏ qua, vì vậy nếu bạn muốn xuất cùng một số lượng các số có nghĩa (số chữ số có nghĩa), hãy sử dụng ký hiệu hàm mũ của e hoặc E. phần nguyên luôn là một chữ số và dấu thập phân là số chữ số được chỉ định, vì vậy nếu bạn muốn xuất ra n chữ số có nghĩa, chỉ cần chỉ định n-1.

print('{:.4e}'.format(123.456))
print('{:.4e}'.format(0.000012345))
print('{:.4e}'.format(12))
# 1.2346e+02
# 1.2345e-05
# 1.2000e+01

Tỷ lệ phần trăm hiển thị

Nếu% được chỉ định trong chuỗi đặc tả định dạng, giá trị của số float hoặc int sẽ được nhân với 100 và được chuyển đổi thành chuỗi với%.

Cũng có thể chỉ định số chữ số sau dấu thập phân. Giá trị mặc định là sáu chữ số sau dấu thập phân. Căn trái, căn giữa, căn phải và không điền cũng có sẵn. % Cũng được tính là một ký tự.

print('{:%}'.format(0.12345))
print('{:.2%}'.format(0.12345))
# 12.345000%
# 12.35%

print('{:%}'.format(10))
print('{:.2%}'.format(10))
# 1000.000000%
# 1000.00%

print('{:>7.2%}'.format(0.12345))
print('{:07.2%}'.format(0.12345))
#  12.35%
# 012.35%
Copied title and URL