Cara yang lebih elegan untuk mendeklarasikan beberapa variabel secara bersamaan

Untuk mendeklarasikan beberapa variabel pada "waktu yang sama" saya akan lakukan:

a, b = True, False

Tetapi jika saya harus mendeklarasikan lebih banyak variabel, ternyata semakin tidak elegan:

a, b, c, d, e, f, g, h, i, j = True, True, True, True, True, False, True ,True , True, True

Apakah ada cara yang lebih baik / elegan / nyaman untuk melakukan ini?

Ini harus sangat mendasar, tetapi jika saya menggunakan daftar atau tuple untuk menyimpan variabel, bagaimana saya harus mendekati sehingga saya akan sangat membantu karena:

aList = [a,b]

Tidak valid, saya harus melakukan:

a, b = True, True

Atau apa yang saya lewatkan?

Seperti yang disarankan orang lain, tidak mungkin menggunakan 10 variabel lokal yang berbeda dengan nilai Boolean adalah cara terbaik untuk menulis rutinitas Anda (terutama jika mereka benar-benar memiliki nama satu huruf :)

Bergantung pada apa yang Anda lakukan, mungkin masuk akal untuk menggunakan kamus saja. Misalnya, jika Anda ingin mengatur nilai preset Boolean untuk satu set flag satu huruf, Anda bisa melakukan ini:

>>> flags = dict.fromkeys(["a", "b", "c"], True)
>>> flags.update(dict.fromkeys(["d", "e"], False))
>>> print flags
{'a': True, 'c': True, 'b': True, 'e': False, 'd': False}

Jika Anda suka, Anda juga bisa melakukannya dengan satu pernyataan tugas:

>>> flags = dict(dict.fromkeys(["a", "b", "c"], True),
...              **dict.fromkeys(["d", "e"], False))
>>> print flags
{'a': True, 'c': True, 'b': True, 'e': False, 'd': False}

Parameter kedua untuk dicttidak sepenuhnya dirancang untuk ini: itu benar-benar dimaksudkan untuk memungkinkan Anda untuk menimpa setiap elemen kamus menggunakan argumen kata kunci sepertid=False . Kode di atas meledakkan hasil ekspresi berikut **ke dalam serangkaian argumen kata kunci yang diteruskan ke fungsi yang dipanggil. Ini tentu saja merupakan cara yang andal untuk membuat kamus, dan orang-orang tampaknya paling tidak menerima idiom ini, tetapi saya curiga bahwa beberapa orang mungkin menganggapnya Unpythonic. </disclaimer>

Namun pendekatan lain, yang mungkin paling intuitif jika Anda akan sering menggunakan pola ini, adalah mendefinisikan data Anda sebagai daftar nilai bendera ( True, False) yang dipetakan ke nama bendera (string karakter tunggal). Anda kemudian mengubah definisi data ini menjadi kamus terbalik yang memetakan nama bendera ke nilai bendera. Ini dapat dilakukan dengan cukup ringkas dengan pemahaman daftar bersarang, tetapi inilah implementasi yang sangat mudah dibaca:

>>> def invert_dict(inverted_dict):
...     elements = inverted_dict.iteritems()
...     for flag_value, flag_names in elements:
...         for flag_name in flag_names:
...             yield flag_name, flag_value
... 
>>> flags = {True: ["a", "b", "c"], False: ["d", "e"]}
>>> flags = dict(invert_dict(flags))
>>> print flags
{'a': True, 'c': True, 'b': True, 'e': False, 'd': False}

Fungsi tersebut invert_dictadalah fungsi generator . Ini menghasilkan , atau menghasilkan - yang berarti berulang kali mengembalikan nilai - pasangan kunci-nilai. Pasangan kunci-nilai tersebut adalah kebalikan dari isi dari dua elemen flagskamus awal . Mereka dimasukkan ke dictkonstruktor. Dalam hal inidict konstruktor bekerja secara berbeda dari atas karena diberi makan iterator daripada kamus sebagai argumennya.

Menggambar pada komentar @Chris Lutz: Jika Anda benar-benar akan menggunakan ini untuk nilai-nilai karakter tunggal, Anda dapat melakukannya

>>> flags = {True: 'abc', False: 'de'}
>>> flags = dict(invert_dict(flags))
>>> print flags
{'a': True, 'c': True, 'b': True, 'e': False, 'd': False}

Ini bekerja karena Python string adalah iterable , yang berarti bahwa mereka dapat dipindahkan melalui nilai dengan nilai. Dalam kasus string, nilainya adalah karakter individu dalam string. Jadi ketika mereka ditafsirkan sebagai iterables, seperti dalam kasus ini di mana mereka digunakan dalam for for loop, ['a', 'b', 'c']dan 'abc'secara efektif setara. Contoh lain adalah ketika mereka diteruskan ke fungsi yang membutuhkan iterable, seperti tuple.

Saya pribadi tidak akan melakukan ini karena tidak membaca secara intuitif: ketika saya melihat string, saya berharap itu akan digunakan sebagai nilai tunggal daripada sebagai daftar. Jadi saya melihat baris pertama dan berpikir, "Oke, jadi ada bendera Benar dan bendera Salah." Jadi, meskipun itu suatu kemungkinan, saya pikir itu bukan jalan yang harus ditempuh. Sisi baiknya, mungkin membantu menjelaskan konsep iterables dan iterator dengan lebih jelas.

Menentukan fungsi invert_dict sedemikian rupa sehingga benar-benar mengembalikan kamus juga bukan ide yang buruk; Saya kebanyakan hanya tidak melakukan itu karena tidak benar-benar membantu menjelaskan cara kerja rutin.

Tampaknya Python 2.7 memiliki pemahaman kamus, yang akan membuat cara yang sangat ringkas untuk mengimplementasikan fungsi itu. Ini dibiarkan sebagai latihan untuk pembaca, karena saya tidak menginstal Python 2.7 :)

Anda juga dapat menggabungkan beberapa fungsi dari modul itertools yang selalu serbaguna . Seperti yang mereka katakan, Ada Lebih dari Satu Cara Untuk Melakukannya . Tunggu, orang Python tidak mengatakan itu. Ya, memang benar dalam beberapa kasus. Saya kira Guido telah memberikan kepada kami pemahaman kamus sehingga akan ada Satu Cara Jelas untuk melakukan ini.

a, b, c, d, e, g, h, i, j = (True,)*9
f = False

Gunakan daftar / kamus atau tentukan kelas Anda sendiri untuk merangkum hal-hal yang Anda tetapkan, tetapi jika Anda membutuhkan semua variabel itu, Anda dapat melakukannya:

a = b = c = d = e = g = h = i = j = True
f = False

Ini adalah penjabaran dari @ Jeff M dan komentar saya.

Ketika Anda melakukan ini:

a, b = c, d

Ini bekerja dengan pengemasan dan pembongkaran tuple. Anda dapat memisahkan langkah-langkah pengemasan dan pembongkaran:

_ = c, d
a, b = _

Baris pertama menciptakan tuple yang disebut _yang memiliki dua elemen, yang pertama dengan nilai cdan yang kedua dengan nilai d. Baris kedua membongkar _tuple ke dalam variabel adan b. Ini memecah satu garis besar Anda:

a, b, c, d, e, f, g, h, i, j = True, True, True, True, True, False, True, True, True, True

Ke dalam dua baris yang lebih kecil:

_ = True, True, True, True, True, False, True, True, True, True
a, b, c, d, e, f, g, h, i, j = _

Ini akan memberi Anda hasil yang sama persis seperti baris pertama (termasuk pengecualian yang sama jika Anda menambahkan nilai atau variabel ke satu bagian tetapi lupa untuk memperbarui yang lain). Namun, dalam kasus khusus ini, jawaban yan mungkin adalah yang terbaik.

Jika Anda memiliki daftar nilai, Anda masih dapat membukanya. Anda hanya perlu mengubahnya menjadi tuple terlebih dahulu. Misalnya, berikut ini akan menetapkan nilai antara 0 dan 9 untuk masing-masing amelalui j, masing-masing:

a, b, c, d, e, f, g, h, i, j = tuple(range(10))

EDIT: Trik rapi untuk menetapkan semuanya sebagai true kecuali elemen 5 (variabel f):

a, b, c, d, e, f, g, h, i, j = tuple(x != 5 for x in range(10))

Ketika orang-orang menyarankan "gunakan daftar atau tuple atau struktur data lainnya", apa yang mereka katakan adalah bahwa, ketika Anda memiliki banyak nilai berbeda yang Anda pedulikan, menamai semuanya secara terpisah sebagai variabel lokal mungkin bukan cara terbaik untuk melakukan sesuatu.

Sebagai gantinya, Anda mungkin ingin mengumpulkan mereka bersama-sama menjadi struktur data yang lebih besar yang dapat disimpan dalam satu variabel lokal.

intuited menunjukkan bagaimana Anda dapat menggunakan kamus untuk ini, dan Chris Lutz menunjukkan bagaimana menggunakan tuple untuk penyimpanan sementara sebelum membongkar ke dalam variabel yang terpisah, tetapi opsi lain untuk dipertimbangkan adalah menggunakan collections.namedtuple untuk menggabungkan nilai-nilai lebih permanen.

Jadi, Anda mungkin melakukan sesuatu seperti:

# Define the attributes of our named tuple
from collections import namedtuple
DataHolder = namedtuple("DataHolder", "a b c d e f g")

# Store our data
data = DataHolder(True, True, True, True, True, False, True)

# Retrieve our data
print(data)
print(data.a, data.f)

Kode asli semoga akan menggunakan nama yang lebih bermakna daripada "DataHolder" dan huruf-huruf alfabet, tentu saja.

Sebenarnya apa masalahnya?

Jika Anda benar-benar membutuhkan atau menginginkan 10 a , b , c , d , e , f , g , h , i , j , tidak akan ada kemungkinan lain, pada suatu waktu atau lain, untuk menulis a dan menulis b dan menulis c . ....

Jika nilainya berbeda, Anda wajib menulis sebagai contoh

a = 12
b= 'sun'
c = A() #(where A is a class)
d = range(1,102,5)
e = (line in filehandler if line.rstrip())
f = 0,12358
g = True
h = random.choice
i = re.compile('^(!=  ab).+?<span>')
j = [78,89,90,0]

artinya mendefinisikan "variabel" secara individual.

Atau, menggunakan tulisan lain, tidak perlu menggunakan _:

a,b,c,d,e,f,g,h,i,j =\
12,'sun',A(),range(1,102,5),\
(line for line in filehandler if line.rstrip()),\
0.12358,True,random.choice,\
re.compile('^(!=  ab).+?<span>'),[78,89,90,0]

atau

a,b,c,d,e,f,g,h,i,j =\
(12,'sun',A(),range(1,102,5),
 (line for line in filehandler if line.rstrip()),
 0.12358,True,random.choice,
 re.compile('^(!=  ab).+?<span>'),[78,89,90,0])

.

Jika beberapa dari mereka harus memiliki nilai yang sama, adalah masalah yang terlalu lama untuk ditulis

a, b, c, d, e, f, g, h, i, j = True, True, True, True, True, False, True ,True , True, True 

?

Maka Anda dapat menulis:

a=b=c=d=e=g=h=i=k=j=True
f = False

.

Saya tidak mengerti apa sebenarnya masalah Anda. Jika Anda ingin menulis kode, Anda wajib menggunakan karakter yang diperlukan oleh penulisan instruksi dan definisi. Apa lagi ?

Saya ingin tahu apakah pertanyaan Anda bukanlah pertanda bahwa Anda salah memahami sesuatu.

Ketika seseorang menulis a = 10, seseorang tidak membuat variabel dalam arti "potongan memori yang nilainya dapat berubah". Instruksi ini:

• baik memicu penciptaan objek tipe integerdan nilai 10 dan pengikatan nama 'a' dengan objek ini di namespace saat ini

• atau menetapkan ulang nama 'a' di namespace ke objek 10 (karena 'a' sebelumnya diikat ke objek lain)

Saya mengatakan itu karena saya tidak melihat utilitas untuk mendefinisikan 10 pengidentifikasi a, b, c ... menunjuk ke False or True. Jika nilai-nilai ini tidak berubah selama eksekusi, mengapa 10 pengidentifikasi? Dan jika mereka berubah, mengapa mendefinisikan pengidentifikasi terlebih dahulu?, Mereka akan dibuat saat dibutuhkan jika tidak ditentukan sebelumnya

Pertanyaan Anda tampak aneh bagi saya

Sepertinya Anda mendekati masalah Anda dengan cara yang salah dengan saya.

Tulis ulang kode Anda untuk menggunakan tuple atau menulis kelas untuk menyimpan semua data.

Saya suka jawaban terpilih teratas; Namun, ia memiliki masalah dengan daftar seperti yang ditunjukkan.

  >> a, b = ([0]*5,)*2
  >> print b
  [0, 0, 0, 0, 0]
  >> a[0] = 1
  >> print b
  [1, 0, 0, 0, 0]

Ini dibahas dengan sangat terperinci (di sini) , tetapi intinya adalah itu adan bmerupakan objek yang sama dengan a is bpengembalianTrue (sama untuk id(a) == id(b)). Karenanya, jika Anda mengubah indeks, Anda mengubah indeks keduanya adan b, karena keduanya ditautkan. Untuk mengatasi ini Anda dapat melakukan (sumber)

>> a, b = ([0]*5 for i in range(2))
>> print b
[0, 0, 0, 0, 0]
>> a[0] = 1
>> print b
[0, 0, 0, 0, 0]

Ini kemudian dapat digunakan sebagai varian dari jawaban teratas, yang memiliki hasil intuitif "yang diinginkan"

>> a, b, c, d, e, g, h, i = (True for i in range(9))
>> f = (False for i in range(1)) #to be pedantic

Dalam kasus Anda, saya akan menggunakan YAML.

Itu adalah standar yang elegan dan profesional untuk berurusan dengan banyak parameter. Nilai-nilai tersebut diambil dari file terpisah. Anda dapat melihat beberapa info di tautan ini:

https://keleshev.com/yaml-quick-introduction

Tetapi lebih mudah untuk Google itu, karena ini adalah standar, ada ratusan info tentang itu, Anda dapat menemukan apa yang paling cocok dengan pemahaman Anda. ;)

Salam Hormat.

Seperti JavaScript, Anda juga dapat menggunakan banyak pernyataan dalam satu baris dengan pythona = 1; b = "Hello World"; c += 3