Quy tắc cú pháp để có dấu phẩy trong định nghĩa tuple là gì?

Trong trường hợp một phần tử đơn lẻ, dấu phẩy được yêu cầu.

a = ('foo',)

Điều gì về một tuple với nhiều yếu tố? Dường như dấu phẩy có tồn tại hay không, cả hai đều hợp lệ. Điều này có đúng không? Theo tôi, có một dấu phẩy dễ dàng hơn để chỉnh sửa. Đó có phải là một phong cách mã hóa xấu?

a = ('foo1', 'foo2')
b = ('foo1', 'foo2',)

Trong tất cả các trường hợp ngoại trừ tuple trống, dấu phẩy là điều quan trọng. Dấu ngoặc đơn chỉ được yêu cầu khi được yêu cầu vì các lý do cú pháp khác: để phân biệt một bộ dữ liệu với một tập hợp các đối số hàm, quyền ưu tiên của toán tử hoặc để cho phép ngắt dòng.

Dấu phẩy cho các bộ dữ liệu, danh sách hoặc đối số hàm là kiểu tốt đặc biệt là khi bạn có một khởi tạo dài được chia thành nhiều dòng. Nếu bạn luôn bao gồm một dấu phẩy kéo dài thì bạn sẽ không thêm một dòng khác vào cuối mong muốn thêm một phần tử khác và thay vào đó chỉ tạo một biểu thức hợp lệ:

a = [
   "a",
   "b"
   "c"
]

Giả sử bắt đầu như một danh sách 2 yếu tố mà sau đó được mở rộng, nó đã sai theo một cách có lẽ không rõ ràng ngay lập tức. Luôn luôn bao gồm dấu phẩy và bạn tránh bẫy đó.

Nó chỉ được yêu cầu cho các bộ dữ liệu một mục để phân định định nghĩa một bộ dữ liệu hoặc một biểu thức được bao quanh bởi dấu ngoặc đơn.

(1)  # the number 1 (the parentheses are wrapping the expression `1`)
(1,) # a 1-tuple holding a number 1

Đối với nhiều hơn một mục, nó không còn cần thiết vì nó hoàn toàn rõ ràng nó là một tuple. Tuy nhiên, dấu phẩy được phép để xác định chúng bằng cách sử dụng nhiều dòng dễ dàng hơn. Bạn có thể thêm vào cuối hoặc sắp xếp lại các mục mà không vi phạm cú pháp vì bạn đã để lại dấu phẩy do tai nạn.

ví dụ,

someBigTuple = (
                   0,
                   1,
                   2,
                   3,
                   4,
                   5,
                   6,
                   7,
                   8,
                   9,
                   10,
                   #...
                   10000000000,
               )

Lưu ý rằng điều này cũng áp dụng cho các bộ sưu tập khác (ví dụ: danh sách và từ điển) và không chỉ bộ dữ liệu.

Một ưu điểm khác của dấu phẩy là nó làm cho diffs trông đẹp hơn. Nếu bạn bắt đầu với

a = [
    1,
    2,
    3
]

và đổi nó thành

a = [
    1,
    2,
    3,
    4
]

Khác biệt sẽ giống như

 a = [
     1,
     2,
-    3
+    3,
+    4
 ]

Trong khi đó, nếu bạn đã bắt đầu bằng dấu phẩy, như

a = [
    1,
    2,
    3,
]

Sau đó, diff sẽ chỉ là

 a = [
     1,
     2,
     3,
+    4,
 ]

Đó là tùy chọn: xem wiki Python .

Tóm tắt: các bộ dữ liệu một phần tử cần một dấu phẩy , nhưng nó là tùy chọn cho các bộ dữ liệu nhiều phần tử.

Ngoài ra, hãy xem xét tình huống mà bạn muốn:

>>> (('x','y'))*4                         # same as ('x','y')*4
('x', 'y', 'x', 'y', 'x', 'y', 'x', 'y')
#Expected = (('x', 'y'), ('x', 'y'), ('x', 'y'), ('x', 'y'))

Vì vậy, trong trường hợp này, dấu ngoặc đơn bên ngoài không có gì khác hơn là nhóm dấu ngoặc đơn. Để làm cho chúng tuple bạn cần thêm dấu phẩy. I E

>>> (('x','y'),)*4 
(('x', 'y'), ('x', 'y'), ('x', 'y'), ('x', 'y'))

Dấu phẩy chỉ được yêu cầu cho các bộ dữ liệu một phần tử. Có một dấu phẩy dấu cho các bộ lớn hơn là một vấn đề về phong cách và không bắt buộc. Ưu điểm lớn nhất của nó là làm sạch khác biệt trên các tệp có bộ dữ liệu lớn nhiều dòng thường được sửa đổi (ví dụ: bộ cấu hình).

Đó là một câu trả lời đơn giản.

a = ("s") là một chuỗi

và

a = ("s",) là một tuple với một phần tử.

Python cần một dấu phẩy bổ sung trong trường hợp một phần tử tuple đến, phân biệt giữa chuỗi và tuple.

Ví dụ: thử điều này trên bảng điều khiển python:

a = ("s")

a = a + (1,2,3)

TracBack (cuộc gọi gần đây nhất vừa qua):

Tệp stdin, dòng 1, trong mô-đun

LoạiError: không thể ghép các đối tượng 'str' và 'tuple'

Một lý do khác mà điều này tồn tại là nó làm cho việc tạo mã và các __repr__chức năng dễ viết hơn. Ví dụ: nếu bạn có một số đối tượng được xây dựng như thế obj(arg1, arg2, ..., argn), thì bạn chỉ có thể viếtobj.__repr__ dưới dạng

def __repr__(self):
    l = ['obj(']
    for arg in obj.args: # Suppose obj.args == (arg1, arg2, ..., argn)
        l.append(repr(arg))
        l.append(', ')
    l.append(')')
    return ''.join(l)

Nếu dấu phẩy không được phép, bạn sẽ phải xử lý trường hợp đặc biệt cuối cùng. Trên thực tế, bạn có thể viết phần trên trong một dòng bằng cách hiểu danh sách (tôi đã viết nó dài hơn để dễ đọc hơn). Sẽ không dễ để làm điều đó nếu bạn phải đặc biệt trong nhiệm kỳ vừa qua.

PEP 8 - Hướng dẫn về Phong cách cho Mã Python - Khi nào nên sử dụng Dấu phẩy

Dấu phẩy dấu phẩy thường là tùy chọn, ngoại trừ chúng là bắt buộc khi tạo một tuple của một phần tử (và trong Python 2, chúng có ngữ nghĩa cho câu lệnh in). Để rõ ràng, nên bao quanh dấu ngoặc đơn trong dấu ngoặc đơn (dự phòng về mặt kỹ thuật).

Đúng:

FILES = ('setup.cfg',)

OK, nhưng khó hiểu:

FILES = 'setup.cfg',

Khi dấu phẩy dấu là dư thừa, chúng thường hữu ích khi sử dụng hệ thống kiểm soát phiên bản, khi danh sách các giá trị, đối số hoặc mục nhập được dự kiến ​​sẽ được kéo dài theo thời gian. Mẫu là để tự đặt từng giá trị (v.v.) trên một dòng, luôn luôn thêm dấu phẩy và thêm dấu ngoặc đơn / ngoặc / dấu ngoặc kép trên dòng tiếp theo. Tuy nhiên, không có nghĩa là có một dấu phẩy trên cùng một dòng với dấu phân cách đóng (ngoại trừ trong trường hợp trên của các bộ dữ liệu đơn lẻ).

Đúng:

FILES = [
    'setup.cfg',
    'tox.ini',
    ]
initialize(FILES,
           error=True,
           )

Không:

FILES = ['setup.cfg', 'tox.ini',]
initialize(FILES, error=True,)

Phong cách mã hóa là sở thích của bạn, Nếu bạn nghĩ rằng vấn đề tiêu chuẩn mã hóa có PEP-8 có thể hướng dẫn bạn.

Bạn nghĩ gì về kết quả của biểu hiện sau đây?

x = (3)
x = (3+2)
x = 2*(3+2)

Đúng, x chỉ là một con số.