Gibt es ein Python-Äquivalent zum C # -Null-Coalescing-Operator?

In C # gibt es einen Null-Koaleszenz-Operator (geschrieben als ??), der eine einfache (kurze) Nullprüfung während der Zuweisung ermöglicht:

string s = null;
var other = s ?? "some default value";

Gibt es ein Python-Äquivalent?

Ich weiß, dass ich tun kann:

s = None
other = s if s else "some default value"

Aber gibt es einen noch kürzeren Weg (wo ich nicht wiederholen muss s)?

other = s or "some default value"

Ok, es muss geklärt werden, wie der orBediener arbeitet. Es ist ein boolescher Operator und funktioniert daher in einem booleschen Kontext. Wenn die Werte nicht boolesch sind, werden sie für den Operator in boolesche Werte konvertiert.

Beachten Sie, dass der orOperator nicht nur Trueoder zurückgibt False. Stattdessen wird der erste Operand zurückgegeben, wenn der erste Operand als wahr ausgewertet wird, und der zweite Operand, wenn der erste Operand als falsch ausgewertet wird.

In diesem Fall wird der Ausdruck x or yzurückgegeben, xwenn er Truebei der Konvertierung in einen Booleschen Wert true ist oder als true ausgewertet wird. Andernfalls wird es zurückgegeben y. In den meisten Fällen dient dies dem gleichen Zweck wie der Null-Koaleszenz-Operator von C♯. Beachten Sie jedoch Folgendes:

42    or "something"    # returns 42
0     or "something"    # returns "something"
None  or "something"    # returns "something"
False or "something"    # returns "something"
""    or "something"    # returns "something"

Wenn Sie Ihre Variable verwenden s, um etwas zu speichern, das entweder auf die Instanz einer Klasse verweist oder None(solange Ihre Klasse keine Mitglieder definiert __nonzero__()und __len__()), ist es sicher, dieselbe Semantik wie der Null-Koaleszenz-Operator zu verwenden.

In der Tat kann es sogar nützlich sein, diese Nebenwirkung von Python zu haben. Da Sie wissen, welche Werte als falsch ausgewertet werden, können Sie damit den Standardwert auslösen, ohne ihn Nonespeziell zu verwenden (z. B. ein Fehlerobjekt).

In einigen Sprachen wird dieses Verhalten als Elvis-Operator bezeichnet .

Streng,

other = s if s is not None else "default value"

Andernfalls s = Falsewird "default value", was möglicherweise nicht das ist, was beabsichtigt war.

Wenn Sie dies verkürzen möchten, versuchen Sie:

def notNone(s,d):
    if s is None:
        return d
    else:
        return s

other = notNone(s, "default value")

Hier ist eine Funktion, die das erste Argument zurückgibt, das nicht ist None:

def coalesce(*arg):
  return reduce(lambda x, y: x if x is not None else y, arg)

# Prints "banana"
print coalesce(None, "banana", "phone", None)

reduce()Möglicherweise werden alle Argumente unnötig durchlaufen, auch wenn das erste Argument nicht vorhanden Noneist. Sie können also auch diese Version verwenden:

def coalesce(*arg):
  for el in arg:
    if el is not None:
      return el
  return None

Mir ist klar, dass dies beantwortet wird, aber es gibt eine andere Option, wenn Sie mit Objekten arbeiten.

Wenn Sie ein Objekt haben, könnte dies sein:

{
   name: {
      first: "John",
      last: "Doe"
   }
}

Sie können verwenden:

obj.get(property_name, value_if_null)

Mögen:

obj.get("name", {}).get("first", "Name is missing") 

Durch Hinzufügen {}als Standardwert wird, wenn "Name" fehlt, ein leeres Objekt zurückgegeben und an den nächsten get übergeben. Dies ähnelt der null-sicheren Navigation in C # obj?.name?.first.

Zusätzlich zu Julianos Antwort zum Verhalten von "oder": Es ist "schnell".

>>> 1 or 5/0
1

Manchmal ist es also eine nützliche Abkürzung für Dinge wie

object = getCachedVersion() or getFromDB()

Zusätzlich zur Antwort von @Bothwells (die ich bevorzuge) für einzelne Werte können Sie den neuen Walross-Operator (seit Python3.8) verwenden, um die Zuordnung von Funktionsrückgabewerten auf Null zu überprüfen:

def test():
    return

a = 2 if (x:= test()) is None else x

Daher muss die testFunktion nicht zweimal bewertet werden (wie in a = 2 if test() is None else test()).

Falls Sie mehr als eine Null-Koaleszenzoperation verschachteln müssen, z.

model?.data()?.first()

Dies ist kein leicht zu lösendes Problem or. Es kann auch nicht gelöst werden, .get()was einen Wörterbuchtyp oder ähnliches erfordert (und sowieso nicht verschachtelt werden kann) odergetattr() werden, wenn wenn eine Ausnahme ausgelöst wird, wenn NoneType das Attribut nicht hat.

Der relevante Pip, der erwägt, der Sprache eine Null-Koaleszenz hinzuzufügen, ist PEP 505, und die für das Dokument relevante Diskussion befindet sich im Python-Ideen- Thread.

Zu den Antworten von @Hugh Bothwell, @mortehu und @glglgl.

Setup-Datensatz zum Testen

import random

dataset = [random.randint(0,15) if random.random() > .6 else None for i in range(1000)]

Implementierungen definieren

def not_none(x, y=None):
    if x is None:
        return y
    return x

def coalesce1(*arg):
  return reduce(lambda x, y: x if x is not None else y, arg)

def coalesce2(*args):
    return next((i for i in args if i is not None), None)

Testfunktion machen

def test_func(dataset, func):
    default = 1
    for i in dataset:
        func(i, default)

Ergebnisse auf Mac i7 @ 2.7Ghz mit Python 2.7

>>> %timeit test_func(dataset, not_none)
1000 loops, best of 3: 224 µs per loop

>>> %timeit test_func(dataset, coalesce1)
1000 loops, best of 3: 471 µs per loop

>>> %timeit test_func(dataset, coalesce2)
1000 loops, best of 3: 782 µs per loop

Klar die not_none Funktion beantwortet die Frage des OP eindeutig richtig und behandelt das "Falsy" -Problem. Es ist auch am schnellsten und am einfachsten zu lesen. Wenn Sie die Logik an vielen Stellen anwenden, ist dies eindeutig der beste Weg.

Wenn Sie ein Problem haben, bei dem Sie den ersten Wert ungleich Null in einer Iterable finden möchten, ist die Antwort von @ mortehu der richtige Weg. Es ist jedoch eine Lösung für ein anderes Problem als OP, obwohl es diesen Fall teilweise behandeln kann. Es kann kein iterierbares UND ein Standardwert annehmen. Das letzte Argument wäre der zurückgegebene Standardwert, aber dann würden Sie in diesem Fall kein iterables übergeben, und es ist nicht explizit, dass das letzte Argument ein Standardwert ist.

Sie könnten dann unten tun, aber ich würde immer noch not_nullfür den Einzelwert-Anwendungsfall verwenden.

def coalesce(*args, **kwargs):
    default = kwargs.get('default')
    return next((a for a in arg if a is not None), default)

Für diejenigen wie mich, die hier gestolpert sind und nach einer praktikablen Lösung für dieses Problem gesucht haben, wenn die Variable undefiniert sein könnte, ist die nächste, die ich bekommen habe:

if 'variablename' in globals() and ((variablename or False) == True):
  print('variable exists and it\'s true')
else:
  print('variable doesn\'t exist, or it\'s false')

Beachten Sie, dass beim Einchecken von Globals eine Zeichenfolge benötigt wird, danach jedoch die tatsächliche Variable beim Überprüfen auf Werte verwendet wird.

Weitere Informationen zur Existenz von Variablen: Wie überprüfe ich, ob eine Variable vorhanden ist?

Python has a get function that its very useful to return a value of an existent key, if the key exist;
if not it will return a default value.

def main():
    names = ['Jack','Maria','Betsy','James','Jack']
    names_repeated = dict()
    default_value = 0

    for find_name in names:
        names_repeated[find_name] = names_repeated.get(find_name, default_value) + 1

Wenn Sie den Namen im Wörterbuch nicht finden können, wird der Standardwert zurückgegeben. Wenn der Name vorhanden ist, wird ein vorhandener Wert mit 1 hinzugefügt.

hoffe das kann helfen

Die beiden folgenden Funktionen haben sich bei vielen variablen Testfällen als sehr nützlich erwiesen.

def nz(value, none_value, strict=True):
    ''' This function is named after an old VBA function. It returns a default
        value if the passed in value is None. If strict is False it will
        treat an empty string as None as well.

        example:
        x = None
        nz(x,"hello")
        --> "hello"
        nz(x,"")
        --> ""
        y = ""   
        nz(y,"hello")
        --> ""
        nz(y,"hello", False)
        --> "hello" '''

    if value is None and strict:
        return_val = none_value
    elif strict and value is not None:
        return_val = value
    elif not strict and not is_not_null(value):
        return_val = none_value
    else:
        return_val = value
    return return_val 

def is_not_null(value):
    ''' test for None and empty string '''
    return value is not None and len(str(value)) > 0