Das deutsche Python-Forum

Hallo zusammen,

>>> d=dict(1=eins)
SyntaxError: keyword can't be an expression
>>> d=dict(eins=1)
>>> d
{'eins': 1}
>>>

Wieso geht #1 nicht und #2 schon?

LG

rolgal_reloaded

Code: Alles auswählen

>>> dict = {1:'fuenf'}
>>> dict
{1: 'fuenf'}
>>> dict2= dict(1=fuenf)
SyntaxError: keyword can't be an expression

Dürfte eigentlich auch einiges Sagen

Warum genau das nicht geht... keine Ahnung. Aber ich habs auch mal gehabt. Die Funktion '' dict() '' macht ja soweit ich das verstanden habe mehr als nur das ganze in ein Dictionary umzuwandeln... oder macht dies zumindest anders

Mfg EnTeQuAk

Weil 1 kein gültiger Bezeichner ist!?

beim ersten Beispiel macht er aus eins - "eins".

Deshalb ist mir das nicht klar, egal was mir in dem Fall der SyntaxError sagt.

Übrigens: gibt es eine Möglichkeit mit dict(bla bla bla) ein Dictionary zu bekommen. Und zwar auch für die Möglichkeit die gescheitert ist?

rolgal_reloaded

Du kannst in Python bei jedem Funktionsaufruf explizit den Namen des Parameters übergeben.
Wenn du z.B. eine Funktion foo(a, b) definiert hast, sind die Aufrufe foo("Hallo", 42), foo(a="Hallo", b=42) und foo(b=42, a="Hallo") vollkommen identisch.

Nun kannst du auch eine Funktion so definieren, dass sie beliebig viele benannte Parameter nimmt, und diese bekommt sie dann in einem Dictionary übergeben. Der Konstruktor von dict() nutzt dieses aus, damit du eine nette Syntax hast.

Dies geht aber nur, wenn die Schlüssel gültige Bezeichner sind, was 1 nicht ist. In diesem Falle musst du das Dictionary so initialiseren, wie es "eigentlich" eh geht; die Methode über keyword parameter ist nur Convenience.

Und wie das geht, hat Entequack schon geschrieben

Code: Alles auswählen

mein_tolles_dict = { 1:"eins",
"sieben": 7}

BlackJack hat geschrieben:Weil 1 kein gültiger Bezeichner ist!?

Stimmt nicht bzw. nur fast:

Code: Alles auswählen

>>> foo = {1: "eins"}
>>> foo
{1: 'eins'}
>>> bar = dict(1 = eins)
>>> bar
SyntaxError: keyword can't be an expression

Es geht also doch bloß man muss das dicht nicht mit ``dict`` sondern mit ``{}`` erzeugen

EDIT: OK bin zu Spät , wurde ein post über mir schon gesagt.

rolgal_reloaded hat geschrieben:beim ersten Beispiel macht er aus eins - "eins".

Deshalb ist mir das nicht klar, egal was mir in dem Fall der SyntaxError sagt.

`dict()` ist eine ganz normale Funktion in Python und damit gelten auch dafür die normalen Regeln, und die besagen, dass Schlüsselwortargumente gültige Bezeichner sein müssen. Wäre dem nicht so, wäre folgendes "möglich":

Code: Alles auswählen

def spam(1=2, 2=None, 3='foo'):
    # keine Ahnung wie man hier jetzt auf die
    # Argumente Bezug nehmen sollte...

# und nun ein Aufruf
spam(2=7)

Das sieht doch wohl arg komisch aus, oder!?

Übrigens: gibt es eine Möglichkeit mit dict(bla bla bla) ein Dictionary zu bekommen. Und zwar auch für die Möglichkeit die gescheitert ist?

Du kannst ein Dictionary übergeben, oder ein "iterable" das Schlüssel/Wert-Paare liefert:

Code: Alles auswählen

In [4]: dict({42: 'answer'})
Out[4]: {42: 'answer'}

In [5]: dict([(42, 'answer')])
Out[5]: {42: 'answer'}

@alle,

danke, hat mir schon weitergeholfen!

Dass mit den Funktionen und Bezeichnern war mir schon klar BlackJack, ich dachte nur bei dict() geht es vielleicht trotzdem, weil es ja statt d = {} benutzt werden kann.

Code: Alles auswählen

dict({42: 'answer'})

Das ist wohl was ich brauche, denke ich.

rolgal_reloaded

Was ist den eigentlich der vorteil statt ``x = {}`` dann ``x = dict()`` zu schreiben? Ist das zweite Pythonischer? Ist ``dict()'`` nicht langsamer als ``{}``? Mir wahr so als ob ``dict()`` nicht bultine wahr.

lg

XtraNine hat geschrieben:Was ist den eigentlich der vorteil statt ``x = {}`` dann ``x = dict()`` zu schreiben? Ist das zweite Pythonischer? Ist ``dict()'`` nicht langsamer als ``{}``? Mir wahr so als ob ``dict()`` nicht bultine wahr.

Aj, da könnte die Rechtschreibwoche wieder aufleben

"dict" ist builtin, genauso wie z.B. "min" oder "isinstance".

"dict()" ist langsamer als "{}", weil der Name "dict" erst in den Globals aufgelöst werden muss, während aus "{}" direkt ein Opcode BUILD_MAP wird.

Letztendlich ist das eine Stilfrage.

birkenfeld hat geschrieben:Letztendlich ist das eine Stilfrage.

Über die wir hier schon mal gesprochen haben.

Hmm, ich gehe davon aus, dass für [] analoges gilt (d.h. dass dann ein Opcode verwendeet wird), oder?

Leonidas hat geschrieben:Hmm, ich gehe davon aus, dass für [] analoges gilt (d.h. dass dann ein Opcode verwendeet wird), oder?

Ja, BUILD_LIST.

Bevor jemand fragt: Ja für Tupel gibt's auch auch einen Opcode:

Code: Alles auswählen

In [11]: import dis

In [12]: def f():
   ....:     return ()
   ....:

In [13]: dis.dis(f)
  2           0 BUILD_TUPLE              0
              3 RETURN_VALUE

Und wie man sieht, auch einen einfachen Weg so etwas herauszufinden. Ich liebe Python.

Cool

einfach mit dis, hmm, gleich mal über alle möglichen Sachen jagen ^^ xD

lg

BlackJack hat geschrieben:Ich liebe Python.

Tun wir alle

Das deutsche Python-Forum

Frage zu dict()

Frage zu dict()