Apa aturan sintaks untuk memiliki tanda koma dalam definisi tupel?

Dalam kasus tupel elemen tunggal, diperlukan tanda koma.

a = ('foo',)

Bagaimana dengan tupel dengan banyak elemen? Tampaknya ada atau tidak tanda koma di belakangnya, keduanya valid. Apakah ini benar? Menurut saya, memiliki tanda koma lebih mudah untuk diedit. Apakah itu gaya pengkodean yang buruk?

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

Dalam semua kasus kecuali tupel kosong koma adalah hal yang penting. Tanda kurung hanya diperlukan bila diperlukan untuk alasan sintaksis lainnya: untuk membedakan tupel dari sekumpulan argumen fungsi, prioritas operator, atau untuk mengizinkan jeda baris.

Tanda koma untuk tupel, daftar, atau argumen fungsi adalah gaya yang bagus terutama jika Anda memiliki inisialisasi panjang yang terbagi menjadi beberapa baris. Jika Anda selalu menyertakan tanda koma maka Anda tidak akan menambahkan baris lain di akhir berharap untuk menambahkan elemen lain dan sebaliknya hanya membuat ekspresi yang valid:

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

Dengan asumsi bahwa dimulai sebagai daftar 2 elemen yang kemudian diperpanjang, itu menjadi salah dengan cara yang mungkin tidak segera jelas. Selalu sertakan koma di belakangnya dan Anda menghindari jebakan itu.

Hal ini hanya diperlukan untuk tupel item tunggal untuk membedakan definisi tupel atau ekspresi yang dikelilingi oleh tanda kurung.

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

Untuk lebih dari satu item, itu tidak lagi diperlukan karena sangat jelas itu adalah tupel. Namun, tanda koma diizinkan untuk mempermudah penentuannya menggunakan beberapa baris. Anda dapat menambahkan ke bagian akhir atau mengatur ulang item tanpa merusak sintaks karena Anda tidak sengaja meninggalkan koma.

misalnya,

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

Perhatikan bahwa ini berlaku untuk koleksi lain (misalnya, daftar dan kamus) juga dan tidak hanya tupel.

Keuntungan lain dari membuntuti koma adalah membuat diff terlihat lebih bagus. Jika Anda mulai dengan

a = [
    1,
    2,
    3
]

dan mengubahnya menjadi

a = [
    1,
    2,
    3,
    4
]

Perbedaannya akan terlihat seperti ini

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

Sedangkan jika Anda memulai dengan tanda koma, seperti

a = [
    1,
    2,
    3,
]

Maka perbedaannya hanya akan terjadi

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

Ini opsional: lihat wiki Python .

Ringkasan: tupel elemen tunggal membutuhkan tanda koma , tetapi ini opsional untuk tupel multi-elemen.

Juga, pertimbangkan situasi yang Anda inginkan:

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

Jadi dalam hal ini tanda kurung luar tidak lebih dari mengelompokkan tanda kurung. Untuk membuatnya menjadi tuple, Anda perlu menambahkan tanda koma. yaitu

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

Tanda koma diperlukan untuk tupel satu elemen saja. Memiliki tanda koma untuk tupel yang lebih besar adalah masalah gaya dan tidak diperlukan. Keuntungan terbesarnya adalah clean diff pada file dengan tupel besar multi-baris yang sering dimodifikasi (misalnya tupel konfigurasi).

Itu jawaban yang sederhana.

a = ("s") adalah string

dan

a = ("s",) adalah tupel dengan satu elemen.

Python membutuhkan koma tambahan jika ada satu elemen tupel untuk, membedakan antara string dan tupel.

Misalnya coba ini di konsol python:

a = ("s")

a = a + (1,2,3)

Traceback (panggilan terakhir terakhir):

File stdin, baris 1, di modul

TypeError: tidak dapat menggabungkan objek 'str' dan 'tuple'

Alasan lain mengapa ini ada adalah membuat pembuatan kode dan __repr__fungsi lebih mudah untuk ditulis. Misalnya, jika Anda memiliki beberapa objek yang dibangun seperti obj(arg1, arg2, ..., argn), maka Anda dapat menulis obj.__repr__sebagai

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)

Jika tanda koma tidak diizinkan, Anda harus menggunakan kasus khusus pada argumen terakhir. Sebenarnya, Anda bisa menulis di atas dalam satu baris menggunakan pemahaman daftar (saya telah menuliskannya lebih panjang agar lebih mudah dibaca). Tidak akan mudah melakukannya jika Anda harus menghadapi kasus khusus pada semester terakhir.

PEP 8 - Panduan Gaya untuk Kode Python - Kapan Menggunakan Trailing Comma

Tanda koma biasanya opsional, kecuali koma tersebut wajib saat membuat tupel dari satu elemen (dan dalam Python 2, koma memiliki semantik untuk pernyataan cetak). Untuk kejelasan, disarankan untuk mengapit tanda kurung (secara teknis berlebihan).

Iya:

FILES = ('setup.cfg',)

Oke, tapi membingungkan:

FILES = 'setup.cfg',

Jika tanda koma berlebihan, tanda koma sering kali berguna saat sistem kontrol versi digunakan, saat daftar nilai, argumen, atau item yang diimpor diharapkan diperpanjang seiring waktu. Polanya adalah menempatkan setiap nilai (dll.) Pada baris dengan sendirinya, selalu menambahkan tanda koma, dan menambahkan tanda kurung tutup / tanda kurung / kurung kurawal pada baris berikutnya. Namun tidak masuk akal untuk memiliki tanda koma pada baris yang sama dengan pembatas penutup (kecuali dalam kasus tupel tunggal di atas).

Iya:

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

Tidak:

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

Gaya pengkodean adalah selera Anda, Jika menurut Anda pengkodean itu penting, ada PEP-8 yang dapat memandu Anda.

Apa pendapat Anda tentang hasil ekspresi berikut?

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

Ya, x hanyalah sebuah angka.