Elegantere Art, mehrere Variablen gleichzeitig zu deklarieren

Um mehrere Variablen gleichzeitig zu deklarieren, würde ich Folgendes tun:

a, b = True, False

Aber wenn ich viel mehr Variablen deklarieren musste, wird es immer weniger elegant:

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

Gibt es eine bessere / elegante / bequeme Möglichkeit, dies zu tun?

Dies muss sehr einfach sein, aber wenn ich eine Liste oder ein Tupel zum Speichern der Variablen verwenden würde, wie müsste ich vorgehen, damit ich hilfreich wäre, da:

aList = [a,b]

Ist nicht gültig, müsste ich tun:

a, b = True, True

Oder was fehlt mir?

Wie andere vorgeschlagen haben, ist es unwahrscheinlich, dass die Verwendung von 10 verschiedenen lokalen Variablen mit Booleschen Werten der beste Weg ist, um Ihre Routine zu schreiben (insbesondere wenn sie wirklich Ein-Buchstaben-Namen haben :)

Je nachdem, was Sie tun, kann es sinnvoll sein, stattdessen ein Wörterbuch zu verwenden. Wenn Sie beispielsweise boolesche voreingestellte Werte für eine Reihe von Ein-Buchstaben-Flags einrichten möchten, können Sie Folgendes tun:

>>> 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}

Wenn Sie möchten, können Sie dies auch mit einer einzelnen Zuweisungsanweisung tun:

>>> 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}

Der zweite Parameter dictist nicht vollständig dafür ausgelegt: Er soll es Ihnen wirklich ermöglichen, einzelne Elemente des Wörterbuchs mit Schlüsselwortargumenten wie zu überschreiben d=False. Der obige Code sprengt das Ergebnis des folgenden Ausdrucks **in eine Reihe von Schlüsselwortargumenten, die an die aufgerufene Funktion übergeben werden. Dies ist sicherlich ein zuverlässiger Weg, um Wörterbücher zu erstellen, und die Leute scheinen diese Redewendung zumindest zu akzeptieren, aber ich vermute, dass einige sie für unpythonisch halten. </disclaimer>

Ein weiterer Ansatz, der wahrscheinlich am intuitivsten ist, wenn Sie dieses Muster häufig verwenden, besteht darin, Ihre Daten als eine Liste von Flag-Werten ( True, False) zu definieren, die Flag-Namen (Einzelzeichenfolgen) zugeordnet sind. Anschließend transformieren Sie diese Datendefinition in ein invertiertes Wörterbuch, das Flaggennamen Flaggenwerten zuordnet. Dies kann mit einem verschachtelten Listenverständnis recht prägnant durchgeführt werden, aber hier ist eine sehr lesbare Implementierung:

>>> 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}

Die Funktion invert_dictist eine Generatorfunktion . Es generiert oder liefert - was bedeutet, dass es wiederholt Werte von - Schlüssel-Wert-Paaren zurückgibt . Diese Schlüssel-Wert-Paare sind die Umkehrung des Inhalts der beiden Elemente des ursprünglichen flagsWörterbuchs. Sie werden in den dictKonstruktor eingespeist . In diesem Fall dictfunktioniert der Konstruktor anders als oben, da ihm als Argument eher ein Iterator als ein Wörterbuch zugeführt wird .

Gestützt auf den Kommentar von @Chris Lutz: Wenn Sie dies wirklich für Einzelzeichenwerte verwenden, können Sie dies tatsächlich tun

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

Dies funktioniert, weil Python-Zeichenfolgen iterierbar sind , was bedeutet, dass sie Wert für Wert verschoben werden können. Bei einer Zeichenfolge sind die Werte die einzelnen Zeichen in der Zeichenfolge. Wenn sie also als iterable interpretiert werden, wie in diesem Fall, wenn sie in einer for-Schleife verwendet werden, ['a', 'b', 'c']und 'abc'effektiv äquivalent sind. Ein anderes Beispiel wäre, wenn sie an eine Funktion übergeben werden, die eine iterierbare Funktion wie z tuple.

Ich persönlich würde dies nicht tun, weil es nicht intuitiv zu lesen ist: Wenn ich eine Zeichenfolge sehe, erwarte ich, dass sie als einzelner Wert und nicht als Liste verwendet wird. Also schaue ich in die erste Zeile und denke: "Okay, es gibt also eine wahre und eine falsche Flagge." Obwohl dies eine Möglichkeit ist, denke ich nicht, dass dies der richtige Weg ist. Auf der anderen Seite kann es hilfreich sein, die Konzepte von Iterablen und Iteratoren klarer zu erklären.

invert_dictEs ist auch keine schlechte Idee, die Funktion so zu definieren, dass sie tatsächlich ein Wörterbuch zurückgibt. Ich habe das meistens einfach nicht gemacht, weil es nicht wirklich hilft zu erklären, wie die Routine funktioniert.

Anscheinend verfügt Python 2.7 über Wörterbuchverständnisse, die eine äußerst präzise Implementierung dieser Funktion ermöglichen würden. Dies bleibt dem Leser als Übung überlassen, da ich Python 2.7 nicht installiert habe :)

Sie können auch einige Funktionen des vielseitigen itertools- Moduls kombinieren . Wie sie sagen, gibt es mehr als einen Weg, es zu tun . Warten Sie, die Python-Leute sagen das nicht. Nun, in einigen Fällen ist es sowieso wahr. Ich würde vermuten, dass Guido uns Wörterbuchverständnisse gegeben hat, damit es einen offensichtlichen Weg gibt , dies zu tun.

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

Verwenden Sie eine Liste / ein Wörterbuch oder definieren Sie Ihre eigene Klasse, um die von Ihnen definierten Elemente zu kapseln. Wenn Sie jedoch alle diese Variablen benötigen, können Sie Folgendes tun:

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

Dies ist eine Ausarbeitung von @ Jeff Ms und meinen Kommentaren.

Wenn Sie dies tun:

a, b = c, d

Es funktioniert mit Tupelpacken und -auspacken. Sie können die Schritte zum Ein- und Auspacken trennen:

_ = c, d
a, b = _

In der ersten Zeile wird ein aufgerufenes Tupel erstellt, _das zwei Elemente enthält, das erste mit dem Wert von cund das zweite mit dem Wert von d. Die zweite Zeile entpackt das _Tupel in die Variablen aund b. Dies bricht Ihre eine große Linie zusammen:

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

In zwei kleinere Zeilen:

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

Sie erhalten genau das gleiche Ergebnis wie in der ersten Zeile (einschließlich derselben Ausnahme, wenn Sie einem Teil Werte oder Variablen hinzufügen, den anderen jedoch vergessen, zu aktualisieren). In diesem speziellen Fall ist Yans Antwort jedoch vielleicht die beste.

Wenn Sie eine Liste mit Werten haben, können Sie diese trotzdem entpacken. Sie müssen es nur zuerst in ein Tupel konvertieren. Im Folgenden wird beispielsweise jedem aDurchgang ein Wert zwischen 0 und 9 zugewiesen j:

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

EDIT: Ordentlicher Trick, um alle als wahr zuzuweisen, außer Element 5 (Variable f):

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

Wenn Leute vorschlagen, "eine Liste, ein Tupel oder eine andere Datenstruktur zu verwenden", sagen sie, dass es möglicherweise nicht der beste Weg ist, sie alle separat als lokale Variablen zu benennen, wenn Sie viele verschiedene Werte haben, die Ihnen wichtig sind Sachen machen.

Stattdessen möchten Sie sie möglicherweise zu einer größeren Datenstruktur zusammenfassen, die in einer einzelnen lokalen Variablen gespeichert werden kann.

intuited zeigte, wie Sie ein Wörterbuch dafür verwenden können, und Chris Lutz zeigte, wie Sie ein Tupel für die temporäre Speicherung verwenden, bevor Sie es in separate Variablen entpacken. Eine weitere Option, die Sie in Betracht ziehen sollten, besteht darin collections.namedtuple, die Werte dauerhafter zu bündeln.

Sie könnten also etwas tun wie:

# 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)

Echter Code würde hoffentlich aussagekräftigere Namen verwenden als "DataHolder" und natürlich die Buchstaben des Alphabets.

Was ist eigentlich das Problem?

Wenn Sie wirklich 10 brauchen oder wollen , ein , b , c , d , e , f , g , h , i , j , wird es keine andere Möglichkeit geben, zu einer Zeit oder einem anderen, schreiben ein und schreiben b und Schreib c . ....

Wenn die Werte alle unterschiedlich sind, müssen Sie beispielsweise schreiben

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]

das heißt, die "Variablen" einzeln definieren.

Oder wenn Sie eine andere Schrift verwenden, müssen Sie nicht Folgendes verwenden _:

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]

oder

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])

.

Wenn einige von ihnen den gleichen Wert haben müssen, ist das Problem, dass das Schreiben zu lang ist

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

?

Dann können Sie schreiben:

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

.

Ich verstehe nicht, was genau dein Problem ist. Wenn Sie einen Code schreiben möchten, müssen Sie die Zeichen verwenden, die für das Schreiben der Anweisungen und Definitionen erforderlich sind. Was sonst ?

Ich frage mich, ob Ihre Frage nicht das Zeichen dafür ist, dass Sie etwas falsch verstehen.

Wenn man schreibt a = 10, erstellt man keine Variable im Sinne von "Speicherblock, dessen Wert sich ändern kann". Diese Anweisung:

• Entweder wird die Erstellung eines Objekts vom Typ integerund Wert 10 und die Bindung eines Namens 'a' mit diesem Objekt im aktuellen Namespace ausgelöst

• oder weisen Sie dem Objekt 10 den Namen 'a' im Namespace neu zu (weil 'a' zuvor an ein anderes Objekt gebunden wurde)

Ich sage das, weil ich das Dienstprogramm zum Definieren von 10 Bezeichnern a, b, c ... nicht sehe, die auf False oder True zeigen. Wenn sich diese Werte während der Ausführung nicht ändern, warum 10 Bezeichner? Und wenn sie sich ändern, warum zuerst die Bezeichner definieren? Werden sie bei Bedarf erstellt, wenn sie nicht zuvor definiert wurden

Ihre Frage erscheint mir komisch

Klingt so, als würden Sie sich Ihrem Problem falsch nähern.

Schreiben Sie Ihren Code neu, um ein Tupel zu verwenden, oder schreiben Sie eine Klasse, um alle Daten zu speichern.

Ich mag die Antwort mit der höchsten Abstimmung. Es gibt jedoch Probleme mit der Liste wie gezeigt.

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

Dies wird in großen Details besprochen (hier) , aber das Wesentliche ist , dass aund bdas gleiche Objekt mit der a is bRückkehr True(gleich für id(a) == id(b)). Wenn Sie also einen Index ändern, ändern Sie den Index von beiden aund b, da diese verknüpft sind. Um dies zu lösen, können Sie (Quelle)

>> 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]

Dies kann dann als Variante der Top-Antwort verwendet werden, die die "gewünschten" intuitiven Ergebnisse liefert

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

In Ihrem Fall würde ich YAML verwenden.

Das ist ein eleganter und professioneller Standard für den Umgang mit mehreren Parametern. Die Werte werden aus einer separaten Datei geladen. Sie können einige Informationen in diesem Link sehen:

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

Aber es ist einfacher, es zu googeln, da es ein Standard ist, es gibt Hunderte von Informationen darüber, Sie können herausfinden, was am besten zu Ihrem Verständnis passt. ;)

Freundliche Grüße.

Wie bei JavaScript können Sie auch in Python mehrere Anweisungen in einer Zeile verwendena = 1; b = "Hello World"; c += 3