Hướng dẫn what is the difference between curly brackets and square brackets in python? - sự khác biệt giữa dấu ngoặc nhọn và dấu ngoặc vuông trong python là gì?

Bạn thường có thể thấy và trải nghiệm điều này khi bạn so sánh cách bạn học một ngôn ngữ như một người bản ngữ, từ cách bạn học như một ngôn ngữ thứ hai. Tôi lớn lên nói tiếng Anh và không bao giờ học được tất cả các loại quy tắc mà những người bạn không nói tiếng bản địa của tôi đã học ở trường. Tương tự, tôi đã học được tất cả các loại quy tắc cho ngữ pháp tiếng Do Thái mà các con tôi không bao giờ học ở trường.

Do đó, nó rất dễ dàng để coi mọi thứ là điều hiển nhiên khi bạn là một chuyên gia. Thật vậy, đó là gần như định nghĩa của một chuyên gia - một người hiểu một chủ đề rất tốt, rằng đối với họ mọi thứ là rõ ràng.

Đối với nhiều nhà phát triển, và đặc biệt là các nhà phát triển Python, rõ ràng không chỉ có các loại dấu ngoặc đơn khác nhau trong Python, mà mỗi loại có nhiều cách sử dụng và làm những việc hoàn toàn khác nhau. Nhưng với những người mới đến, nó khác xa khi sử dụng dấu ngoặc đơn, ngoặc vuông và/hoặc niềng răng xoăn.

Do đó, tôi đã cố gắng tóm tắt từng loại dấu ngoặc đơn này, khi chúng tôi sử dụng chúng và kết quả là bạn có thể nhận được bất ngờ. & NBSP; Nếu bạn mới sử dụng Python, thì tôi hy vọng rằng điều này sẽ giúp cung cấp cho bạn một bức tranh rõ ràng hơn về những gì được sử dụng khi.

Tôi cũng nên lưu ý rằng số lượng lớn dấu ngoặc đơn mà chúng tôi sử dụng trong Python có nghĩa là sử dụng một trình soạn thảo tô màu cho cả dấu ngoặc đơn phù hợp và không khớp thực sự có thể giúp ích. Trong một số lần không nhỏ, tôi đã có thể tìm thấy lỗi nhanh chóng nhờ hệ thống màu paren trong Emacs.

Dấu ngoặc đơn thường xuyên - ()

Thiết bị gọi (chức năng và lớp học)

Có lẽ việc sử dụng rõ ràng nhất cho dấu ngoặc đơn trong Python là để gọi các chức năng và tạo các đối tượng mới. Ví dụ:

x = len('abcd')

i = int('12345')

Nó rất đáng để xem xét những gì xảy ra nếu bạn không sử dụng dấu ngoặc đơn. Ví dụ: tôi thấy mã sau mọi lúc trong các khóa học của mình:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items:
    print(f"{key}: {value}")

Khi bạn cố gắng chạy mã này, bạn có thể một thông báo lỗi là đúng, nhưng ý nghĩa của họ hoàn toàn rõ ràng:

TypeError: 'builtin_function_or_method' object is not iterable

Huh? & Nbsp; cái quái gì này có nghĩa gì?

Nó rất đáng nhớ về cách thức hoạt động của các vòng lặp trong Python:

• "Đối với người" chuyển sang đối tượng ở cuối dòng, và hỏi liệu nó có thể không có được
• Nếu vậy, thì "cho" yêu cầu đối tượng cho giá trị tiếp theo của nó
• Bất cứ khi nào đối tượng nói, thì không còn nữa! Các vòng lặp dừng lại

Trong trường hợp này, người Viking cho người khác chuyển sang phương pháp, thì d.items, và hỏi liệu nó có thể không. Lưu ý rằng chúng tôi không hỏi liệu đầu ra từ của D.

Điều đó bởi vì có một thế giới khác biệt giữa các d.items và và d.items (). Đầu tiên trả về phương thức. Phần thứ hai trả về một chuỗi các cặp giá trị tên từ từ điển Dic Dictionary.

Do đó, giải pháp cho mã không hoạt động này là để thêm dấu ngoặc đơn:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items():
    print(f"{key}: {value}")

Một khi chúng tôi làm điều đó, chúng tôi nhận được kết quả mong muốn.

Tôi nên lưu ý rằng chúng ta cũng cần phải cẩn thận theo hướng khác: đôi khi, chúng ta muốn chuyển một chức năng như một đối số và không thực hiện nó. Một ví dụ là khi chúng tôi ở trong sổ ghi chép Jupyter (hoặc môi trường Python tương tác khác) và yêu cầu trợ giúp về một chức năng hoặc phương pháp:

help(len)

help(str.upper)

Trong cả hai trường hợp trên, chúng tôi không muốn nhận trợ giúp về đầu ra của các chức năng đó; Thay vào đó, chúng tôi muốn nhận được sự giúp đỡ về các chức năng.

Ưu tiên hoạt động

Ở trường tiểu học, có lẽ bạn đã học được thứ tự cơ bản của các hoạt động số học - đầu tiên chúng ta nhân lên và chia rẽ, và chỉ sau khi chúng ta thêm và trừ.

Python rõ ràng cũng đã đi học tiểu học, bởi vì nó tuân theo thứ tự này. & Nbsp; Ví dụ:

In [1]: 2 + 3 * 4
Out[1]: 14

Chúng ta có thể thay đổi mức độ ưu tiên bằng cách sử dụng dấu ngoặc đơn:

In [2]: (2 + 3) * 4
Out[2]: 20

Các nhà phát triển có kinh nghiệm thường quên rằng chúng ta cũng có thể sử dụng dấu ngoặc đơn theo cách này - nhưng theo nhiều cách, đây là cách rõ ràng và tự nhiên nhất để họ được sử dụng bởi các nhà phát triển mới.

Tạo bộ dữ liệu

Tất nhiên, chúng ta cũng có thể sử dụng () để tạo bộ dữ liệu. Ví dụ:

In [8]: t = (10,20,30)

In [9]: type(t)
Out[9]: tuple

Điều mà nhiều nhà phát triển Python bắt đầu không biết là bạn thực sự không cần dấu ngoặc đơn để tạo ra tuple:

In [6]: t = 10,20,30

In [7]: type(t)
Out[7]: tuple

Điều đó có nghĩa là khi bạn trả về nhiều giá trị từ một hàm, bạn thực sự sẽ trả lại một tuple:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items:
    print(f"{key}: {value}")

Điều ngạc nhiên của nhiều người mới đến Python là như sau:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items:
    print(f"{key}: {value}")

Chờ đợi, họ nói, tôi đã sử dụng dấu ngoặc đơn. Có nên là một tuple?

Không, T là một số nguyên. & NBSP; Khi trình phân tích cú pháp Python, nhìn thấy một cái gì đó như là T T = (10), nó có thể biết rằng chúng tôi đã nói về một tuple. & Nbsp; Mặt khác, nó cũng sẽ phải phân tích cú pháp T = (8+2) như một tuple, mà chúng tôi rõ ràng không muốn xảy ra, giả sử rằng chúng tôi muốn sử dụng dấu ngoặc đơn để ưu tiên các hoạt động (xem ở trên). & NBSP; Và vì vậy, nếu bạn muốn xác định một tuple một yếu tố, bạn phải sử dụng dấu phẩy:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items:
    print(f"{key}: {value}")

Biểu thức máy phát

Cuối cùng, chúng ta có thể sử dụng dấu ngoặc đơn để tạo ra các máy phát điện, sử dụng những gì được gọi là biểu thức của máy phát điện. Đây là một chủ đề có phần nâng cao, đòi hỏi kiến ​​thức về cả toàn diện và trình lặp. Nhưng họ là một công cụ thực sự hữu ích, cho phép chúng tôi mô tả một chuỗi dữ liệu mà không thực sự tạo ra từng yếu tố của chuỗi đó cho đến khi nó cần.

Ví dụ, nếu tôi nói:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items:
    print(f"{key}: {value}")

Mã trên xác định các loại g gv là một trình tạo, kết quả của việc thực hiện biểu thức trình tạo của chúng tôi. Một số người khác có thể được đặt bên trong một vòng lặp cho vòng lặp hoặc bối cảnh tương tự. & NBSP; & nbsp; Thực tế là nó là một trình tạo có nghĩa là chúng ta có thể có một chuỗi dữ liệu có khả năng vô hạn mà không thực sự cần phải cài đặt một lượng RAM vô hạn trên máy tính của chúng ta; Miễn là chúng tôi có thể lấy lại các vật phẩm từ một lần lặp đi lặp lại của chúng tôi, chúng tôi đã thiết lập.

Trình tạo ở trên, G G G Go không thực sự trả lại 10 số. Thay vào đó, nó trả về một số tại một thời điểm. Chúng ta có thể lấy tất cả chúng cùng một lúc bằng cách gói nó trong một cuộc gọi đến danh sách của Hồi giáo:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items:
    print(f"{key}: {value}")

Nhưng toàn bộ quan điểm của một máy phát điện là bạn không muốn làm điều đó. Thay vào đó, bạn sẽ nhận được từng yếu tố, từng yếu tố và do đó làm giảm việc sử dụng bộ nhớ.

Một cái gì đó buồn cười xảy ra với dấu ngoặc đơn khi họ sử dụng trên biểu thức máy phát trong một cuộc gọi chức năng. & NBSP; Hãy nói rằng tôi muốn có được một chuỗi chứa các yếu tố của danh sách các số nguyên:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items:
    print(f"{key}: {value}")

Điều này không thành công, bởi vì các yếu tố của Mylist Mylist là số nguyên. & NBSP; Chúng ta có thể sử dụng biểu thức trình tạo để biến từng số nguyên thành một chuỗi:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items:
    print(f"{key}: {value}")

Chú ý các dấu ngoặc kép ở đây; Những cái bên ngoài dành cho cuộc gọi đến str.join, và những cái bên trong là cho biểu thức máy phát. Chà, hóa ra chúng ta có thể xóa tập hợp bên trong:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items:
    print(f"{key}: {value}")

Vì vậy, lần tới khi bạn thấy một cuộc gọi đến một chức năng và một thứ trông hiểu bên trong dấu ngoặc đơn, bạn sẽ biết rằng nó là một biểu thức của trình tạo, chứ không phải là một lỗi.

Gian lận quy tắc thụt Python,

Python nổi tiếng với việc sử dụng thụt lề để đánh dấu các khối mã, thay vì niềng răng xoăn, bắt đầu/kết thúc hoặc tương tự. Theo kinh nghiệm của tôi, việc sử dụng thụt lề có nhiều lợi thế, nhưng có xu hướng gây sốc cho những người mới đối với ngôn ngữ và những người phần nào bị xúc phạm rằng ngôn ngữ sẽ ra lệnh và khi nào nên thụt mã.

Tuy nhiên, có một vài cách để gian lận (ít nhất là một chút) khi nói đến các quy tắc thụt này. Ví dụ, hãy để nói rằng tôi có một từ điển đại diện cho một người và tôi muốn biết liệu chữ cái ’e có trong bất kỳ giá trị nào không. & NBSP; Tôi có thể làm điều gì đó như thế này:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items:
    print(f"{key}: {value}")

Rằng nếu dòng nếu dòng hoạt động, nhưng nó quá dài để có thể đọc được một cách hợp lý. & NBSP; Điều tôi yêu thích làm là thế này:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items:
    print(f"{key}: {value}")

Vấn đề là mã trên đã giành được công việc; Python sẽ đi đến cuối của những người đầu tiên hoặc đầu tiên và phàn nàn rằng nó đã đạt đến cuối dòng (EOL) mà không có tuyên bố hoàn chỉnh.

Giải pháp là sử dụng dấu ngoặc đơn. Đó là vì một khi bạn đã mở dấu ngoặc đơn, Python dễ tha thứ và linh hoạt hơn nhiều về thụt lề. Ví dụ, tôi có thể viết:

TypeError: 'builtin_function_or_method' object is not iterable

Mã của chúng tôi bây giờ (trong suy nghĩ của tôi) dễ đọc hơn nhiều, nhờ vào các dấu ngoặc đơn vô dụng mà tôi đã thêm vào.

Nhân tiện, điều này đúng với tất cả các dấu ngoặc đơn. Vì vậy, nếu tôi muốn xác định chỉ số của mình trên nhiều dòng, tôi có thể nói:

TypeError: 'builtin_function_or_method' object is not iterable

Python nhìn thấy phần mở đầu {và được tha thứ cho đến khi nó tìm thấy sự phù hợp}. Theo cách tương tự, chúng ta có thể mở danh sách hiểu biết trên một dòng và đóng nó trên một dòng khác. & NBSP; Trong nhiều năm, tôi đã viết các bản tóm tắt danh sách của mình trên nhiều dòng, với niềm tin rằng họ dễ đọc, viết và hiểu. Ví dụ:

TypeError: 'builtin_function_or_method' object is not iterable

Dấu ngoặc vuông - []

Tạo danh sách

Chúng tôi có thể tạo danh sách với dấu ngoặc vuông, như sau:

TypeError: 'builtin_function_or_method' object is not iterable

Lưu ý rằng theo PEP 8, bạn nên viết một danh sách trống là [], mà không có bất kỳ khoảng trống nào giữa các giá đỡ. & NBSP; Tôi đã tìm thấy rằng với một số phông chữ nhất định, hai khung cuối cùng trông giống như một hình vuông, và rất khó cho mọi người trong các khóa học của tôi để đọc và hiểu. & NBSP; Vì vậy, tôi luôn đặt một khoảng trống giữa các dấu ngoặc khi tạo một danh sách trống.

(Và vâng, tôi đã nổi loạn trong cuộc sống thực, không chỉ khi lập trình.)

Chúng ta có thể sử dụng dấu ngoặc vuông không chỉ để tạo danh sách với các phần tử được đặt tên rõ ràng, mà còn để tạo danh sách thông qua danh sách toàn diện:

TypeError: 'builtin_function_or_method' object is not iterable

Các dấu ngoặc vuông nói với Python rằng đây là một danh sách hiểu, tạo ra một danh sách. & NBSP; Nếu bạn sử dụng niềng răng xoăn, bạn sẽ nhận được một bộ hoặc một dict trở lại và nếu bạn sử dụng dấu ngoặc đơn thông thường, bạn sẽ nhận được một biểu thức máy phát (xem ở trên).

Yêu cầu các mặt hàng riêng lẻ

Nhiều người ngạc nhiên khi phát hiện ra rằng trong Python, chúng tôi luôn sử dụng dấu ngoặc vuông để lấy từ một chuỗi hoặc từ điển:

TypeError: 'builtin_function_or_method' object is not iterable

Tại sao don lồng chúng tôi sử dụng dấu ngoặc đơn thường xuyên với bộ đếm và niềng răng xoăn với từ điển, khi chúng tôi muốn lấy một yếu tố? Câu trả lời đơn giản là dấu ngoặc vuông, khi được sử dụng theo cách này, gọi một phương thức - phương thức __getItem__.

Đúng vậy, không có sự khác biệt giữa hai dòng mã này:

TypeError: 'builtin_function_or_method' object is not iterable

Điều này có nghĩa là nếu bạn xác định một lớp mới và bạn muốn các phiên bản của lớp này có thể sử dụng dấu ngoặc vuông, bạn chỉ cần xác định __getItem __. & Nbsp; Ví dụ:

TypeError: 'builtin_function_or_method' object is not iterable

Xem? & NBSP; Khi chúng ta nói f [2], mà đã được dịch thành f .__ getitem __ (2), sau đó trả về bản self.x [index].

Thực tế là các dấu ngoặc vuông được khái quát theo cách này có nghĩa là Python có thể tận dụng chúng, ngay cả trên các đối tượng do người dùng tạo.

Yêu cầu lát cắt

Bạn cũng có thể quen thuộc với các lát. Các lát cắt tương tự như các chỉ mục riêng lẻ, ngoại trừ việc chúng mô tả một loạt các chỉ mục. Ví dụ:

TypeError: 'builtin_function_or_method' object is not iterable

Như bạn có thể thấy, các lát cắt là một trong hai biểu mẫu [Bắt đầu: End+1] hoặc [Bắt đầu: End+1: Stepize]. & NBSP; (Nếu bạn không chỉ định các bước, thì nó mặc định là 1.)

Ở đây, một chút tin nhắn đã khiến tôi mất một thời gian dài để khám phá: Bạn có thể có một ngoại lệ IndexError nếu bạn yêu cầu một chỉ mục vượt ra ngoài ranh giới của một chuỗi. Nhưng các lát không có trong những vấn đề như vậy; Họ chỉ dừng lại ở đầu hoặc kết thúc chuỗi của bạn:

TypeError: 'builtin_function_or_method' object is not iterable

Làm thế nào để dấu ngoặc vuông phân biệt giữa một chỉ số riêng lẻ và một lát? Câu trả lời: Họ don. Trong cả hai trường hợp, phương thức __getItem__ đang được gọi. Nó lên tới __getItem__ để kiểm tra xem nó có loại giá trị nào cho tham số chỉ số của nhóm.

Nhưng chờ đã: Nếu chúng ta chuyển một số nguyên hoặc chuỗi (hoặc thậm chí là một tuple) cho dấu ngoặc vuông, chúng ta biết loại nào sẽ được truyền đi cùng. Loại nào được truyền cho phương pháp của chúng tôi nếu chúng tôi sử dụng một lát?

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items():
    print(f"{key}: {value}")

Lưu ý rằng trong trường hợp đầu tiên, như mong đợi, chúng tôi nhận được một số nguyên. Nhưng trong trường hợp thứ hai và thứ ba, chúng ta nhận được một đối tượng lát cắt. Chúng ta có thể tạo ra những điều này theo cách thủ công, nếu chúng ta muốn; Slice Slice là trong không gian tên của người Bulitin, cùng với STR, INT, Dict, và các mục yêu thích khác. Và như bạn có thể thấy từ đại diện được in của nó, chúng ta có thể gọi là Slice Slice nhiều như chúng ta thực hiện phạm vi, với các đối số bắt đầu, dừng và kích thước bước. & NBSP; Tôi thường xuyên cần hoặc muốn tạo các đối tượng lát cắt, nhưng bạn chắc chắn có thể:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items():
    print(f"{key}: {value}")

Dấu ngoặc nhọn - {}

Tạo ra các dicts

Cách cổ điển để tạo từ điển (dicts) trong Python là với niềng răng xoăn. Bạn có thể tạo ra một dict trống với một cặp niềng răng xoăn trống:

Trong [65]: d = {}

Trong [66]: Len (D) Out [66]: 0
Out[66]: 0

Hoặc bạn có thể phổ biến trước một dict với một số cặp giá trị khóa:

Trong [67]: d = {{A,: 1, ’B,: 2,‘ C, 3}

Trong [68]: Len (D) ra [68]: 3
Out[68]: 3

Tất nhiên, bạn có thể tạo ra các dicts theo một vài cách khác. Cụ thể, bạn có thể sử dụng lớp Dict Dictor để tạo từ điển dựa trên chuỗi các chuỗi hai phần tử:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items():
    print(f"{key}: {value}")

Nhưng trừ khi bạn cần tạo ra một lập trình chính thống, tôi đã nói rằng {} là cách tốt nhất và rõ ràng nhất để đi. Tôi nhớ đã đọc bài đăng trên blog của ai đó vài năm trước (mà tôi không thể tìm thấy ngay bây giờ), trong đó người ta thấy rằng {} nhanh hơn là gọi điện tử là - điều này có ý nghĩa, vì {} là một phần của cú pháp của Python, và không ' t yêu cầu một cuộc gọi chức năng.

Tất nhiên, {} cũng có thể được sử dụng để tạo từ điển thông qua sự hiểu biết chính thống:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items():
    print(f"{key}: {value}")

Trong mã trên, chúng tôi tạo ra một lệnh của số 0-9 (các khóa) và giá trị của chúng cho công suất thứ hai (giá trị).

Hãy nhớ rằng một sự hiểu biết di sản tạo ra một từ điển, thay vì một danh sách chứa nhiều từ điển.

Tạo bộ

Tôi đã trở thành người hâm mộ của các bộ Python. Bạn có thể nghĩ về các bộ theo nghĩa kỹ thuật, cụ thể là chúng có thể thay đổi và chứa các giá trị băm độc đáo. Kể từ Python 3.6, chúng được lưu trữ theo thứ tự chèn.

Nhưng thực sự, nó chỉ dễ dàng nhất để nghĩ về các bộ là từ điển mà không có bất kỳ giá trị nào. (Vâng, điều này có nghĩa là các bộ không có gì hơn từ điển vô đạo đức.) & NBSP; Bất cứ điều gì áp dụng cho các khóa Dict cũng áp dụng cho các yếu tố của một bộ.

Chúng ta có thể tạo một tập hợp với niềng răng xoăn:

Trong [75]: s = {10,20,30}

Trong [76]: loại (s) ra [76]: Đặt
Out[76]: set

Như bạn có thể thấy, thực tế là không có dấu hai chấm (:) giữa các cặp giá trị tên cho phép Python phân tích chính xác mã này, xác định ‘Siêu là một tập hợp, thay vì chỉ đạo.

Gần như mỗi lần tôi dạy về các bộ, ai đó cố gắng tạo một bộ trống và thêm vào nó, sử dụng set.add:

Trong [77]: s = {}

Trong [78]: S.ADD (10) 1 S.ADD (10)
—————————————————————————
AttributeError Traceback (most recent call last)
in ()
—-> 1 s.add(10)

Thuộc tínhError: ‘Dict đối tượng không có thuộc tính‘ Thêm vào

Lỗi chỉ ra rằng, S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S S D và. Điều này là tốt, nhưng tôi đã định nghĩa là một bộ?

Không thực sự: Dicts xuất hiện đầu tiên, và do đó {} là một tên độc lực trống rỗng, không phải là một bộ trống. Nếu bạn muốn tạo một bộ trống, bạn sẽ cần sử dụng lớp Set Set của bộ phận:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items():
    print(f"{key}: {value}")

Điều này hoạt động tốt, nhưng hơi khó hiểu với những người bắt đầu ở Python.

Tôi thường sử dụng các bộ để xóa các mục trùng lặp khỏi danh sách. Tôi có thể làm điều này với lớp Set Set (có thể gọi được), nhưng tôi cũng có thể sử dụng cú pháp của đối số** khi gọi một hàm:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items():
    print(f"{key}: {value}")

Lưu ý rằng có một chút khác biệt giữa {*mylist} (tạo ra một tập hợp từ các phần tử của mylist) và {mylist} sẽ cố gắng tạo một tập hợp với một phần tử, danh sách của mylist, và sẽ thất bại vì danh sách không thể .

Giống như chúng ta có toàn bộ danh sách và toàn bộ Dict, chúng ta cũng đã đặt ra các toàn bộ, điều đó có nghĩa là chúng ta cũng có thể nói:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items():
    print(f"{key}: {value}")

str.format

Một nơi khác mà chúng ta có thể sử dụng niềng răng xoăn là định dạng chuỗi. Trong khi các nhà phát triển Python đã sử dụng để sử dụng toán tử PRINTF theo kiểu PRINTF để tạo các chuỗi mới, cách hiện đại để làm như vậy (cho đến khi các chuỗi F, xem bên dưới) là phương thức str.format. Nó hoạt động như thế này:

Trong [86]: name = ‘reuven

Trong [87]: Hello Hello, {0}.
Out[87]: ‘Hello, Reuven’

Lưu ý rằng str.format trả về một chuỗi mới; Về mặt kỹ thuật, nó không liên quan gì đến việc in ấn, mặc dù chúng thường được sử dụng cùng nhau. Bạn có thể gán chuỗi kết quả cho một biến mới, ghi nó vào một tệp hoặc (tất nhiên) in nó lên màn hình.

str.format nhìn vào bên trong chuỗi, tìm kiếm niềng răng xoăn với một số bên trong chúng. Sau đó, nó lấy đối số với chỉ mục đó và nội suy nó vào chuỗi kết quả. & NBSP; Ví dụ:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items():
    print(f"{key}: {value}")

Tất nhiên, bạn có thể trộn lẫn mọi thứ:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items():
    print(f"{key}: {value}")

Bạn cũng có thể lặp lại các giá trị:

d = {'a':1, 'b':2, 'c':3}
for key, value in d.items():
    print(f"{key}: {value}")

Nếu bạn sẽ sử dụng từng đối số một lần và theo thứ tự, bạn thậm chí có thể xóa các số - mặc dù tôi đã nói rằng điều này làm cho mã khó đọc. & NBSP; Và bên cạnh đó, điều đó có nghĩa là bạn không thể lặp lại các giá trị, điều này đôi khi gây khó chịu:

help(len)

help(str.upper)

Bạn không thể chuyển từ tự động sang đánh số thủ công trong niềng răng xoăn (hoặc trở lại):

help(len)

help(str.upper)

Str.Format cũng cho phép bạn sử dụng tên thay vì các giá trị, bằng cách truyền các đối số từ khóa (nghĩa là, các cặp giá trị tên trong định dạng của key = value):

help(len)

help(str.upper)

Bạn có thể trộn các đối số từ khóa và vị trí, nhưng tôi cầu xin rằng bạn không làm điều đó:

help(len)

help(str.upper)

f-strings

Kể từ Python 3.6, chúng ta có một cách thậm chí còn hiện đại hơn để thực hiện phép nội suy chuỗi, sử dụng các chuỗi F F. Đặt F F FHER trước các trích dẫn mở cho phép chúng tôi sử dụng niềng răng xoăn để nội suy về bất kỳ biểu thức python nào chúng tôi muốn - từ tên biến đến hoạt động đến các cuộc gọi chức năng/phương thức - bên trong một chuỗi:

help(len)

help(str.upper)

Tôi yêu F-String, và đã bắt đầu sử dụng chúng trong tất cả các mã của tôi. & NBSP; Bash, Perl, Ruby và PHP đã có khả năng này trong nhiều năm; Tôi cũng rất vui khi (cuối cùng) cũng có nó trong Python!

từ __future__ nhập khẩu niềng răng

Đôi khi bạn có ước rằng bạn có thể sử dụng niềng răng xoăn thay vì thụt vào trong Python không? Vâng, bạn không đơn độc. & NBSP; May mắn thay, mô -đun __future__ là cách cho phép bạn thử các tính năng mới trước khi chúng hoàn toàn nướng vào phiên bản Python hiện tại của bạn. Ví dụ: nếu bạn vẫn đang sử dụng Python 2.7 (và tôi hy vọng bạn không), bạn có thể nói

help(len)

help(str.upper)

Và sự phân chia sẽ luôn trả lại một chiếc phao, thay vì một số nguyên, ngay cả khi hai toán hạng là số nguyên.

Vì vậy, hãy tiếp tục, thử:

help(len)

help(str.upper)

(Vâng, đây là một phần của Python, mặc dù là một phần ngớ ngẩn.