Fügen Sie einem Diktat nur hinzu, wenn eine Bedingung erfüllt ist

Ich verwende urllib.urlencodezum Erstellen von Web-POST-Parametern, es gibt jedoch einige Werte, die nur hinzugefügt werden sollen, wenn ein anderer Wert als Noneder für sie vorhanden ist.

apple = 'green'
orange = 'orange'
params = urllib.urlencode({
    'apple': apple,
    'orange': orange
})

Das funktioniert gut, aber wenn ich die orangeVariable optional mache , wie kann ich verhindern, dass sie zu den Parametern hinzugefügt wird? So etwas (Pseudocode):

apple = 'green'
orange = None
params = urllib.urlencode({
    'apple': apple,
    if orange: 'orange': orange
})

Ich hoffe das war klar genug, weiß jemand wie man das löst?

Sie müssen den Schlüssel nach dem Erstellen der Initiale separat hinzufügen dict:

params = {'apple': apple}
if orange is not None:
    params['orange'] = orange
params = urllib.urlencode(params)

Python hat keine Syntax, um einen Schlüssel als bedingt zu definieren. Sie könnten ein Diktatverständnis verwenden, wenn Sie bereits alles in einer Sequenz hätten:

params = urllib.urlencode({k: v for k, v in (('orange', orange), ('apple', apple)) if v is not None})

aber das ist nicht sehr lesbar.

Eine andere Möglichkeit ist das Entpacken des Wörterbuchs , aber für einen einzelnen Schlüssel ist das nicht viel besser lesbar:

params = urllib.urlencode({
    'apple': apple,
    **({'orange': orange} if orange is not None else {})
})

Ich persönlich würde dies niemals verwenden, es ist zu hackig und bei weitem nicht so explizit und klar wie die Verwendung einer separaten ifAussage. Wie das Zen von Python sagt: Lesbarkeit zählt.

Um auf die Antwort von sqreept zurückzugreifen dict, verhält sich eine Unterklasse davon wie gewünscht:

class DictNoNone(dict):
    def __setitem__(self, key, value):
        if key in self or value is not None:
            dict.__setitem__(self, key, value)


d = DictNoNone()
d["foo"] = None
assert "foo" not in d

Auf diese Weise kann Werte von vorhandenen Schlüsseln werden geändert zu None, aber die Zuordnung Nonezu einem Schlüssel, der nicht existiert ein no-op ist. Wenn Sie Einstellung ein Element wollte entfernen sie aus dem Wörterbuch , wenn es bereits vorhanden ist , können Sie dies tun:None

def __setitem__(self, key, value):
    if value is None:
        if key in self:
            del self[key]
    else:
        dict.__setitem__(self, key, value)

Werte von None können eintreten, wenn Sie sie während des Baus weitergeben. Wenn Sie dies vermeiden möchten, fügen Sie eine __init__Methode hinzu, um sie herauszufiltern:

def __init__(self, iterable=(), **kwargs):
    for k, v in iterable:
        if v is not None: self[k] = v
    for k, v in kwargs.iteritems():
        if v is not None: self[k] = v

Man könnte es auch generische machen , indem es zu schreiben , so dass Sie kann in passiert den gewünschten Zustand , wenn das Wörterbuch zu erstellen:

class DictConditional(dict):
    def __init__(self, cond=lambda x: x is not None):
        self.cond = cond
    def __setitem__(self, key, value):
        if key in self or self.cond(value):
            dict.__setitem__(self, key, value)

d = DictConditional(lambda x: x != 0)
d["foo"] = 0   # should not create key
assert "foo" not in d

params = urllib.urlencode({
    'apple': apple,
    **({'orange': orange} if orange else {}),
})

Ziemlich alte Frage, aber hier ist eine Alternative, die die Tatsache nutzt, dass das Aktualisieren eines Diktats mit einem leeren Diktat nichts bewirkt.

def urlencode_func(apple, orange=None):
    kwargs = locals().items()
    params = dict()
    for key, value in kwargs:
        params.update({} if value is None else {key: value})
    return urllib.urlencode(params)

Ich tat dies. Ich hoffe das hilft.

apple = 23
orange = 10
a = {
    'apple' : apple,
    'orange' if orange else None : orange
}

Erwartete Ausgabe : {'orange': 10, 'apple': 23}

Wenn ja orange = None, dann gibt es einen einzigen Eintrag für None:None. Betrachten Sie zum Beispiel Folgendes:

apple = 23
orange = None
a = {
    'apple' : apple,
    'orange' if orange else None : orange
}

Erwartete Ausgabe : {None: None, 'apple': 23}

Sie können Keine nach der Zuweisung löschen:

apple = 'green'
orange = None
dictparams = {
    'apple': apple,
    'orange': orange
}
for k in dictparams.keys():
    if not dictparams[k]:
        del dictparams[k]
params = urllib.urlencode(dictparams)

Eine andere gültige Antwort ist, dass Sie einen eigenen diktartigen Container erstellen können, in dem keine None-Werte gespeichert sind.

class MyDict:
    def __init__(self):
        self.container = {}
    def __getitem__(self, key):
        return self.container[key]
    def __setitem__(self, key, value):
        if value != None:
            self.container[key] = value
    def __repr__(self):
        return self.container.__repr__()

a = MyDict()
a['orange'] = 'orange';
a['lemon'] = None

print a

Ausbeuten:

{'orange': 'orange'}

Ich mag den tollen Trick in der Antwort hier wirklich: https://stackoverflow.com/a/50311983/3124256

Aber es hat einige Fallstricke:

1. Doppelte ifTests (wiederholt für Schlüssel und Wert)
2. Lästiger None: NoneEintrag im Ergebnisdict

Um dies zu vermeiden, können Sie Folgendes tun:

apple = 23
orange = None
banana = None
a = {
    'apple' if apple else None: apple,
    'orange' if orange else None : orange,
    'banana' if banana else None: banana,
    None: None,
}
del a[None]

Erwartete Ausgabe : {'apple': 23}

Hinweis: Der None: NoneEintrag stellt zwei Dinge sicher:

1. Der NoneSchlüssel ist immer vorhanden ( delwirft keinen Fehler)
2. Der Inhalt von 'Keine Werte' wird im Diktat niemals existieren (falls Sie es delspäter vergessen )

Wenn Sie sich über diese Dinge keine Sorgen machen, können Sie sie weglassen und das Del in ein einwickeln try...except(oder prüfen, ob der NoneSchlüssel vorhanden ist, bevor Sie delloslegen). Um alternativ Nummer 2 zu adressieren, können Sie den Wert auch zusätzlich zum Schlüssel bedingt prüfen.

fruits = [("apple", get_apple()), ("orange", get_orange()), ...]

params = urllib.urlencode({ fruit: val for fruit, val in fruits if val is not None })

Es gibt einen kontraintuitiven, aber zuverlässigen Hack, um den anderen Requisitennamen, den Sie ausschließen möchten, wiederzuverwenden.

{
    'orange' if orange else 'apple': orange,
    'apple': apple,
}

In diesem Fall überschreibt der letztere "Apfel" den vorherigen "Apfel" und entfernt ihn effektiv. Beachten Sie, dass die bedingten Ausdrücke über die realen hinausgehen sollten.