Hướng dẫn dùng strformat python

Thứ sáu, 14/10/2016 | 00:00 GMT+7

Phương thức str.format() của lớp chuỗi trong Python cho phép bạn thực hiện các thay thế biến và định dạng giá trị. Điều này cho phép bạn nối các phần tử với nhau trong một chuỗi thông qua định dạng vị trí.

Hướng dẫn này sẽ hướng dẫn bạn một số cách sử dụng phổ biến của trình định dạng trong Python, có thể giúp mã và chương trình của bạn dễ đọc và thân thiện với user hơn.

Sử dụng bộ định dạng

Bộ định dạng hoạt động bằng cách đặt một hoặc nhiều trường thay thế hoặc trình giữ chỗ - được xác định bởi một cặp dấu ngoặc nhọn {} - vào một chuỗi và gọi phương thức str.format() . Bạn sẽ chuyển vào phương thức giá trị mà bạn muốn nối với chuỗi. Giá trị này sẽ được chuyển qua cùng một nơi mà trình giữ chỗ của bạn được định vị khi bạn chạy chương trình.

Hãy in ra một chuỗi sử dụng trình định dạng:

print("Sammy has {} balloons.".format(5)) 

Output
Sammy has 5 balloons. 

Trong ví dụ trên, ta đã xây dựng một chuỗi với một cặp dấu ngoặc nhọn làm trình giữ chỗ:

"Sammy has {} balloons." 

Sau đó, ta đã thêm phương thức str.format() và chuyển giá trị của số nguyên 5 vào phương thức đó. Điều này đặt giá trị của 5 vào chuỗi có dấu ngoặc nhọn:

Sammy has 5 balloons. 

Ta cũng có thể gán một biến bằng giá trị của một chuỗi có trình giữ chỗ định dạng:

open_string = "Sammy loves {}." print(open_string.format("open source")) 

Output
Sammy loves open source. 

Trong ví dụ thứ hai này, ta nối chuỗi "open source" với chuỗi lớn hơn, thay thế dấu ngoặc nhọn trong chuỗi ban đầu.

Các trình định dạng trong Python cho phép bạn sử dụng dấu ngoặc nhọn làm trình giữ chỗ cho các giá trị mà bạn sẽ chuyển qua bằng phương thức str.format() .

Sử dụng Định dạng với Nhiều Trình giữ chỗ

Bạn có thể sử dụng nhiều cặp dấu ngoặc nhọn khi sử dụng bộ định dạng. Nếu ta muốn thêm một thay thế biến khác vào câu trên, ta có thể thực hiện bằng cách thêm cặp dấu ngoặc nhọn thứ hai và chuyển giá trị thứ hai vào phương thức:

new_open_string = "Sammy loves {} {}."                      #2 {} placeholders print(new_open_string.format("open-source", "software"))    #Pass 2 strings into method, separated by a comma 

Output
Sammy loves open-source software. 

Để thêm một thay thế khác, ta đã thêm một cặp dấu ngoặc nhọn thứ hai vào chuỗi ban đầu. Sau đó, ta chuyển hai chuỗi vào phương thức str.format() , phân tách chúng bằng dấu phẩy.

Theo cùng một cú pháp, ta có thể thêm các thay thế bổ sung:

sammy_string = "Sammy loves {} {}, and has {} {}."                      #4 {} placeholders print(sammy_string.format("open-source", "software", 5, "balloons"))    #Pass 4 strings into method 

Output
Sammy loves open-source software, and has 5 balloons. 

Trong sammy_string ta đã thêm 4 cặp dấu ngoặc nhọn làm trình giữ chỗ để thay thế biến. Sau đó, ta đã chuyển 4 giá trị vào phương thức str.format() , trộn các kiểu dữ liệu chuỗi và số nguyên. Mỗi giá trị này được phân tách bằng dấu phẩy.

Sắp xếp lại thứ tự các định dạng với các đối số vị trí và từ khóa

Khi ta để trống dấu ngoặc nhọn mà không có bất kỳ tham số nào, Python sẽ thay thế các giá trị được truyền qua phương thức str.format() theo thứ tự. Như ta đã thấy, cho đến nay, một cấu trúc định dạng với hai dấu ngoặc nhọn trống với hai giá trị được truyền qua sẽ trông như thế này:

print("Sammy the {} has a pet {}!".format("shark", "pilot fish")) 

Output
Sammy the shark has a pet pilot fish! 

Cặp dấu ngoặc nhọn đầu tiên được thay thế bằng giá trị chuỗi của "shark" và cặp thứ hai được thay thế bằng giá trị chuỗi của "pilot fish" .

Các giá trị tồn tại trong phương thức trông giống như sau:

("shark", "pilot fish") 

Về cơ bản, chúng là kiểu dữ liệu tuple và mỗi giá trị riêng lẻ chứa trong tuple có thể được gọi bằng số index của nó, bắt đầu bằng số index 0.

Ta có thể chuyển các số index này vào dấu ngoặc nhọn đóng role là trình giữ chỗ trong chuỗi root :

print("Sammy the {0} has a pet {1}!".format("shark", "pilot fish")) 

Trong ví dụ trên, kết quả sẽ là những gì ta nhận được mà không cần chuyển các số index vào dấu ngoặc nhọn vì ta đang gọi các giá trị trong bộ theo thứ tự:

Output
Sammy the shark has a pet pilot fish! 

Nhưng, nếu ta đảo ngược số index với các tham số của trình giữ chỗ, ta có thể đảo ngược các giá trị đang được chuyển vào chuỗi:

print("Sammy the {1} has a pet {0}!".format("shark", "pilot fish")) 

Output
Sammy the pilot fish has a pet shark! 

Nếu bạn gọi một số index là 2 trong một bộ có giá trị ở vị trí index 0 và 1, thì bạn đang gọi một giá trị nằm ngoài phạm vi. Khi bạn gọi một số index nằm ngoài phạm vi, bạn sẽ nhận được thông báo lỗi:

print("Sammy the {2} has a pet {1}!".format("shark", "pilot fish")) 

Output
IndexError: tuple index out of range 

Thông báo lỗi mà ta thấy đề cập đến bộ tuple chỉ có các giá trị ở số index 0 và 1, do đó đặt số index 2 ngoài phạm vi.

Hãy thêm một vài trình giữ chỗ và một vài giá trị khác để chuyển cho chúng, để ta có thể hiểu cách ta có thể sắp xếp lại các bộ định dạng tốt hơn một chút. Đầu tiên, đây là một chuỗi mới với bốn trình giữ chỗ:

print("Sammy is a {}, {}, and {} {}!".format("happy", "smiling", "blue", "shark")) 

Output
Sammy is a happy, smiling and blue shark! 

Không có tham số, các giá trị được truyền vào phương thức str.format() được nối vào chuỗi theo thứ tự.

Các giá trị chuỗi chứa trong bộ giá trị tương ứng với các số index sau:

Hãy sử dụng số index của các giá trị để thay đổi thứ tự mà chúng xuất hiện trong chuỗi:

print("Sammy is a {3}, {2}, and {1} {0}!".format("happy", "smiling", "blue", "shark")) 

Output
Sammy is a shark, blue, and smiling happy! 

Vì ta bắt đầu với chỉ số số 3, ta đã gọi giá trị cuối cùng là "shark" trước. Các số index khác được bao gồm dưới dạng tham số thay đổi thứ tự cách các từ xuất hiện trong chuỗi ban đầu.

Ngoài các đối số vị trí, ta cũng có thể giới thiệu các đối số từ khóa được gọi bằng tên từ khóa của chúng:

print("Sammy the {0} {1} a {pr}.".format("shark", "made", pr = "pull request")) 

Output
Sammy the shark made a pull request. 

Ví dụ này cho thấy việc sử dụng đối số từ khóa đang được sử dụng với đối số vị trí. Ta có thể điền đối số từ khóa pr cùng với đối số vị trí và có thể di chuyển các đối số này xung quanh để thay đổi chuỗi kết quả:

print("Sammy the {pr} {1} a {0}.".format("shark", "made", pr = "pull request")) 

Output
Sammy the pull request made a shark. 

Các đối số vị trí và từ khóa được sử dụng với trình định dạng chuỗi cho phép ta kiểm soát nhiều hơn việc thao tác các chuỗi ban đầu của ta thông qua việc sắp xếp lại thứ tự.

Chỉ định loại

Ta có thể bao gồm nhiều tham số hơn trong dấu ngoặc nhọn của cú pháp của ta . Ta sẽ sử dụng cú pháp mã định dạng {field_name:conversion} , trong đó field_name chỉ định số index của đối số cho phương thức str.format() mà ta đã xem qua trong phần sắp xếp lại thứ tự và conversion đề cập đến mã chuyển đổi của dữ liệu loại mà bạn đang sử dụng với trình định dạng.

Loại chuyển đổi đề cập đến mã loại ký tự đơn mà Python sử dụng. Các mã mà ta sẽ sử dụng ở đây là s cho chuỗi, d để hiển thị số nguyên thập phân (cơ số 10) và f mà ta sẽ sử dụng để hiển thị số thực với vị trí thập phân. Bạn có thể đọc thêm về Ngôn ngữ nhỏ đặc tả định dạng thông qua tài liệu chính thức của Python 3.

Hãy xem một ví dụ trong đó ta có một số nguyên được truyền qua phương thức, nhưng muốn hiển thị nó dưới dạng số thực bằng cách thêm đối số kiểu chuyển đổi f :

print("Sammy ate {0:f} percent of a {1}!".format(75, "pizza")) 

Output
Sammy ate 75.000000 percent of a pizza! 

Ta đã sử dụng cú pháp của {field_name:conversion} cho trường thay thế dấu ngoặc nhọn đầu tiên để xuất ra một float. Dấu ngoặc nhọn thứ hai chỉ sử dụng tham số đầu tiên {field_name} .

Trong ví dụ trên, có rất nhiều số hiển thị sau dấu thập phân, nhưng bạn có thể giới hạn số đó. Khi bạn chỉ định f cho các giá trị float, bạn có thể chỉ định thêm độ chính xác của giá trị đó bằng cách bao gồm một dấu dừng đầy đủ . tiếp theo là số chữ số sau số thập phân mà bạn muốn thêm vào.

Nếu Sammy đã ăn 75,765367% chiếc bánh pizza, nhưng ta không cần có mức độ chính xác cao, ta có thể giới hạn các vị trí sau số thập phân thành 3 bằng cách thêm .3 trước loại chuyển đổi f :

print("Sammy ate {0:.3f} percent of a pizza!".format(75.765367)) 

Output
Sammy ate 75.765 percent of a pizza! 

Nếu ta chỉ muốn một chữ số thập phân, ta có thể viết lại chuỗi và phương thức như sau:

print("Sammy ate {0:.1f} percent of a pizza!".format(75.765367)) 

Output
Sammy ate 75.8 percent of a pizza! 

Lưu ý việc sửa đổi độ chính xác sẽ làm cho số được làm tròn.

Mặc dù ta hiển thị một số không có chữ số thập phân dưới dạng số thực, nhưng nếu ta cố gắng thay đổi số thực thành số nguyên bằng cách sử dụng kiểu chuyển đổi d , ta sẽ nhận được lỗi:

print("Sammy ate {0:d} percent of a pizza!".format(75.765367)) 

Output
ValueError: Unknown format code 'd' for object of type 'float' 

Nếu bạn không muốn hiển thị số thập phân, bạn có thể viết định dạng của bạn như sau:

print("Sammy ate {0:.0f} percent of a pizza!".format(75.765367)) 

Output
Sammy ate 76 percent of a pizza! 

Điều này sẽ không chuyển đổi số thực của bạn thành số nguyên , nhưng thay vào đó, giới hạn số vị trí được hiển thị sau dấu thập phân.

Thay thế biến đệm

Vì trình giữ chỗ là trường thay thế, bạn có thể đệm hoặc tạo khoảng trống xung quanh phần tử bằng cách tăng kích thước trường thông qua các tham số bổ sung. Điều này có thể hữu ích khi ta cần tổ chức nhiều dữ liệu một cách trực quan.

Ta có thể thêm một số để biểu thị kích thước trường (tính theo ký tự) sau dấu hai chấm : trong dấu ngoặc nhọn của cú pháp:

print("Sammy has {0:4} red {1:16}!".format(5, "balloons")) 

Output
Sammy has    5 red balloons        ! 

Trong ví dụ trên, ta đã cho số 5 có kích thước trường ký tự là 4 và chuỗi balloons có kích thước trường ký tự là 16 (vì nó là một chuỗi dài).

Như ta thấy, theo mặc định, các chuỗi được căn trái trong trường và các số được căn phải. Bạn có thể sửa đổi điều này bằng cách đặt một mã căn chỉnh ngay sau dấu hai chấm. < sẽ căn trái văn bản trong một trường, ^ sẽ căn giữa văn bản trong trường và > sẽ căn phải nó.

Hãy căn trái số và căn giữa chuỗi:

print("Sammy has {0:<4} red {1:^16}!".format(5, "balloons")) 

Output
Sammy has 5    red     balloons    ! 

Bây giờ ta thấy rằng số 5 được căn trái, cung cấp khoảng trống trong trường trước red và balloons được căn giữa trong trường của nó với khoảng trống ở bên trái và bên phải của nó.

Theo mặc định, khi ta tạo một trường lớn hơn bằng bộ định dạng, Python sẽ điền vào trường bằng các ký tự khoảng trắng. Ta có thể sửa đổi ký tự đó thành một ký tự khác bằng cách chỉ định ký tự mà ta muốn nó nằm ngay sau dấu hai chấm:

print("{:*^20s}".format("Sammy")) 

Output



*******Sammy******** 

Ta chấp nhận chuỗi được chuyển tới str.format() ở vị trí index 0 vì ta không chỉ định khác, bao gồm cả dấu hai chấm và chỉ định rằng ta sẽ sử dụng * thay vì dấu cách để điền vào trường. Ta đang căn giữa chuỗi bằng ^ , chỉ định rằng trường có kích thước 20 ký tự và cũng cho biết rằng ta đang làm việc với kiểu chuyển đổi chuỗi bằng cách bao gồm s .

Ta có thể kết hợp các thông số này với các thông số khác mà ta đã sử dụng trước đây:

print("Sammy ate {0:5.0f} percent of a pizza!".format(75.765367)) 

Output
Sammy ate    76 percent of a pizza! 

Trong các tham số bên trong dấu ngoặc nhọn, ta đã chỉ định số trường index của dấu phẩy và bao gồm dấu hai chấm, cho biết kích thước của số trường và bao gồm dấu chấm đầy đủ, được viết bằng số vị trí sau vị trí thập phân, rồi chỉ định kiểu chuyển đổi của f .

Sử dụng các biến

Lúc này, ta đã truyền các số nguyên, float và string vào phương thức str.format() , nhưng ta cũng có thể chuyển các biến thông qua phương thức này. Điều này hoạt động giống như bất kỳ biến nào khác.

nBalloons = 8 print("Sammy has {} balloons today!".format(nBalloons)) 

Output
Sammy has 8 balloons today! 

Ta có thể sử dụng các biến cho cả chuỗi root và những gì được truyền vào phương thức:

sammy = "Sammy has {} balloons today!" nBalloons = 8 print(sammy.format(nBalloons)) 

Output
Sammy has 8 balloons today! 

Có thể dễ dàng thay thế các biến cho từng phần của cấu trúc cú pháp định dạng của ta . Điều này giúp làm việc dễ dàng hơn khi ta lấy đầu vào do user tạo và gán các giá trị đó cho các biến.

Sử dụng bộ định dạng để sắp xếp dữ liệu

Các định dạng có thể được nhìn thấy dưới ánh sáng tốt nhất của chúng khi chúng được sử dụng để tổ chức nhiều dữ liệu theo cách trực quan. Nếu ta đang hiển thị database cho user , việc sử dụng bộ định dạng để tăng kích thước trường và sửa đổi căn chỉnh có thể giúp kết quả của bạn dễ đọc hơn.

Hãy xem một vòng lặp for điển hình trong Python sẽ in ra i , i*i và i*i*i trong phạm vi từ 3 đến 12:

for i in range(3,13):     print(i, i*i, i*i*i) 

Output
3 9 27 4 16 64 5 25 125 6 36 216 7 49 343 8 64 512 9 81 729 10 100 1000 11 121 1331 12 144 1728 

Trong khi kết quả được tổ chức theo cách, các con số tràn vào các cột của nhau, làm cho phần dưới cùng của kết quả khó đọc hơn. Nếu bạn đang làm việc với một tập dữ liệu lớn hơn với nhiều con số lớn nhỏ, điều này có thể gây ra vấn đề.

Hãy sử dụng bộ định dạng để cung cấp thêm không gian cho những con số này:

for i in range(3,13):     print("{:3d} {:4d} {:5d}".format(i, i*i, i*i*i)) 

Ở đây, trong dấu ngoặc nhọn, ta đã không thêm tên trường cho số index và bắt đầu bằng dấu hai chấm, theo sau là số cho kích thước trường và một loại chuyển đổi d vì ta đang làm việc với số nguyên. Trong ví dụ này, ta đã điều chỉnh kích thước của mỗi kết quả dự kiến, cung cấp thêm 2 khoảng trắng ký tự cho mỗi kết quả , tùy thuộc vào kích thước số tối đa có thể, vì vậy kết quả của ta trông giống như sau:

Output
  3    9    27   4   16    64   5   25   125   6   36   216   7   49   343   8   64   512   9   81   729  10  100  1000  11  121  1331  12  144  1728 

Ta có thể chỉ định một số kích thước trường nhất quán để có các cột chẵn, đảm bảo ta đáp ứng các số lớn hơn:

for i in range(3,13):     print("{:6d} {:6d} {:6d}".format(i, i*i, i*i*i)) 

Output
     3      9     27      4     16     64      5     25    125      6     36    216      7     49    343      8     64    512      9     81    729     10    100   1000     11    121   1331     12    144   1728 

Ta cũng có thể thao tác căn chỉnh của các cột bằng cách thêm < , ^ và > để căn chỉnh văn bản, thay đổi d thành f để thêm các vị trí thập phân, thay đổi số index của tên trường, v.v. đảm bảo rằng ta đang hiển thị dữ liệu như mong muốn .

Kết luận

Sử dụng bộ định dạng để thay thế biến có thể là cách hiệu quả để nối các chuỗi và tổ chức các giá trị và dữ liệu. Bộ định dạng biểu thị một cách đơn giản nhưng không mang tính mô tả để chuyển các thay thế biến thành một chuỗi và rất hữu ích đảm bảo kết quả có thể đọc được và thân thiện với user .

Tags:

Các tin liên quan

Cách xử lý tệp văn bản thuần túy trong Python 3
2016-10-13
Cách sử dụng các biến trong Python 3
2016-10-12
Cách lập chỉ mục và cắt chuỗi trong Python 3
2016-09-28
Cách định dạng văn bản trong Python 3
2016-09-15
Giới thiệu về cách làm việc với chuỗi trong Python 3
2016-09-15
Hiểu các kiểu dữ liệu trong Python 3
2016-09-14
Python 2 và Python 3: Cân nhắc thực tế
2016-08-17
Cách triển khai các ứng dụng web Python với Khung Micro Chai trên Ubuntu 14.04
2015-10-19
Cách triển khai các ứng dụng web Python với Framework Micro Chai trên CentOS 7
2015-10-19
Cách triển khai ứng dụng Python Web2py với uWSGI và Nginx trên Ubuntu 14.04
2015-03-17