Gibt es eine bessere Möglichkeit, verschachtelte if-Anweisungen in Python zu schreiben? [geschlossen]

Gibt es eine pythonischere Möglichkeit, verschachtelte if else-Anweisungen als diese auszuführen:

def convert_what(numeral_sys_1, numeral_sys_2):

    if numeral_sys_1 == numeral_sys_2:      
        return 0
    elif numeral_sys_1 == "Hexadecimal":
        if numeral_sys_2 == "Decimal":
            return 1
        elif numeral_sys_2 == "Binary":
            return 2
    elif numeral_sys_1 == "Decimal":
        if numeral_sys_2 == "Hexadecimal":
            return 4
        elif numeral_sys_2 == "Binary":
            return 6
    elif numeral_sys_1 == "Binary":
        if numeral_sys_2 == "Hexadecimal":
            return 5
        elif numeral_sys_2 == "Decimal":
            return 3
    else:
        return 0

Dieses Skript ist Teil eines einfachen Konverters.

Während die Antworten von @Aryerez und @ SencerH. funktionieren, muss jeder mögliche Wert von numeral_sys_1wiederholt für jeden möglichen Wert von numeral_sys_2bei der Auflistung der Wertepaare geschrieben werden, was es schwieriger macht, die Datenstruktur beizubehalten, wenn die Anzahl der möglichen Werte zunimmt. Sie können stattdessen ein verschachteltes Diktat anstelle Ihrer verschachtelten if-Anweisungen verwenden:

mapping = {
    'Hexadecimal': {'Decimal': 1, 'Binary': 2},
    'Binary': {'Decimal': 3, 'Hexadecimal': 5},
    'Decimal': {'Hexadecimal': 4, 'Binary': 6}
}
def convert_what(numeral_sys_1, numeral_sys_2):
    return mapping.get(numeral_sys_1, {}).get(numeral_sys_2, 0)

Alternativ können Sie die Wertepaare für das Mapping mit der itertools.permutationsMethode generieren , deren Reihenfolge der der Eingabesequenz folgt:

mapping = dict(zip(permutations(('Hexadecimal', 'Decimal', 'Binary'), r=2), (1, 2, 4, 6, 3, 5)))
def convert_what(numeral_sys_1, numeral_sys_2):
    return mapping.get((numeral_sys_1, numeral_sys_2), 0)

Fügen Sie alle gültigen Kombinationen in a dictionaryvon tuples ein. Wenn die Kombination nicht vorhanden ist, geben Sie 0 zurück:

def convert_what(numeral_sys_1, numeral_sys_2):
    numeral_dict = {
        ("Hexadecimal", "Decimal"    ) : 1,
        ("Hexadecimal", "Binary"     ) : 2,
        ("Decimal",     "Hexadecimal") : 4, 
        ("Decimal",     "Binary"     ) : 6,
        ("Binary",      "Hexadecimal") : 5,
        ("Binary",      "Decimal"    ) : 3
    }
    return numeral_dict.get((numeral_sys_1, numeral_sys_2), 0)

Wenn Sie die Funktion in einer Schleife verwenden möchten, ist es möglicherweise besser, das Wörterbuch außerhalb der Funktion zu definieren, damit es nicht bei jedem Aufruf der Funktion neu erstellt wird.

Wenn Sie sicher sind, dass kein anderer Wert auf die Variablen numeral_sys_1 und numeral_sys_2 festgelegt wurde, ist dies die einfachste und sauberste Lösung.

Andererseits müssen Sie das Wörterbuch mit seinen Kombinationen mit verfügbaren Werten erweitern, wenn Sie einen anderen Wert als "Hexadezimal", "Dezimal" und "Binär" haben.

Die Logik hier ist; Wenn variable Tupel in Wörterbuchschlüsseln nicht dem angegebenen variablen Tupel entsprechen, gibt die Methode .get () "0" zurück. Wenn ein variables Tupel mit einem beliebigen Schlüssel im Wörterbuch übereinstimmt, wird der Wert des übereinstimmenden Schlüssels zurückgegeben.

def convert_what(numeral_sys_1, numeral_sys_2):
    return {
        ("Hexadecimal", "Decimal") : 1, 
        ("Hexadecimal", "Binary") : 2, 
        ("Binary", "Decimal") : 3,
        ("Decimal", "Hexadecimal") : 4,
        ("Binary", "Hexadecimal") : 5, 
        ("Decimal", "Binary") : 6, 
     }.get((numeral_sys_1, numeral_sys_2), 0)

Es könnte auch die Verwendung eines Generators eine Lösung sein. Sieht viel schlauer aus, aber ich denke, ein hartcodiertes Wörterbuch wäre schneller als die Verwendung eines Generators für diese einfache Anforderung.

Eine alternative Möglichkeit, verschachtelte Listen zu verwenden. Ich hoffe es hilft!!

def convert_what(numeral_sys_1, numeral_sys_2):

    l1 = [["Hexadecimal","Decimal"],["Hexadecimal","Binary"],
            ["Decimal","Hexadecimal"],["Decimal","Binary"],
            ["Binary","Hexadecimal"],["Binary","Decimal"]]

    return l1.index([numeral_sys_1, numeral_sys_2]) + 1 if [numeral_sys_1,numeral_sys_2] in l1 else 0

Meiner Meinung nach ist diese convert_whatFunktion selbst nicht sehr pythonisch. Ich denke, der Code, der diesen Code aufruft, hat auch eine Reihe von if-Anweisungen und konvertiert abhängig vom Rückgabewert von convert_what(). Ich schlage so etwas vor:

Machen Sie im ersten Schritt eine Funktion für jede Kombination:

def hex_dec(inp):
    return 1234  # todo implement
# do the same for hex_bin, bin_dec, dec_hex, bin_hex, dec_bin

Im zweiten Schritt setzen Sie die Funktionsobjekte in ein Diktat. Beachten Sie, dass nach den Funktionsnamen kein () steht, da das Funktionsobjekt gespeichert und noch nicht aufgerufen werden soll:

converter_funcs = {
    ("Hexadecimal", "Decimal"): hex_dec,
    ("Hexadecimal", "Binary"): hex_bin,
    ("Binary", "Decimal"): bin_dec,
    ("Decimal", "Hexadecimal"): dec_hex,
    ("Binary", "Hexadecimal"): bin_hex,
    ("Decimal", "Binary"): dec_bin,
}

Im dritten und letzten Schritt implementieren Sie eine Konvertierungsfunktion. Die if-Anweisung prüft, ob beide Systeme identisch sind. Dann bekommen wir die richtige Funktion aus unserem Diktat und nennen es:

def convert(input_number, from_sys, to_sys):
    if from_sys == to_sys:
        return input_number
    func = converter_funcs[(from_sys, to_sys)]
    return func(input_number)

Dies erfolgt durch switch-case-Anweisungen in den meisten anderen Sprachen. In Python verwende ich eine einfache Funktion mit einem Ausdruckswörterbuch.

Code:

def convert_what(numeral_sys_1, numeral_sys_2):
    myExpressions = {"Hexadecimal" : {"Decimal" : 1, "Binary" : 2},
                    "Decimal" : {"Hexadecimal" : 4, "Binary" : 6}, 
                    "Binary" : {"Hexadecimal" : 5, "Decimal" : 3}}
    return (myExpressions.get(numeral_sys_1, {})).get(numeral_sys_2, 0)

Ausgabe:

> convert_what("Hexadecimal", "Decimal")
> 1
> convert_what("Binary", "Binary")
> 0
> convert_what("Invalid", "Hexadecimal")
> 0

Im Allgemeinen würde ich mit Wörterbuchlösung für verschachtelte if-Aufgabe ausführen. Einige besondere Fälle können zu einem anderen Ansatz führen. Wie dieser:

def convert_what(numeral_sys_1, numeral_sys_2):

    num = ['Hexadecimal','Decimal','Binary']
    tbl = [[0,1,2],
           [4,0,6],
           [5,3,0]]
    try:
        return tbl[num.index(numeral_sys_1)][num.index(numeral_sys_2)]
    except ValueError:
        return 0

Wie wäre es mit so etwas wie:

def convert_what(numeral_sys_1, numeral_sys_2):
    src = numeral_sys_1, numeral_sys_2
    if src == "Hexadecimal", "Decimal":
        return 1
    if src == "Hexadecimal", "Binary"
        return 2
    # You get the gist.... 
    if src == "Decimal", "Binary":
        return 6
    return 0 

Eine Idee verwendet eine Liste und erhält einen Index des Ergebnisses, dh.

def convert_what(numeral_sys_1, numeral_sys_2):
    if numeral_sys_1 == numeral_sys_2:      
        return 0
    return ["HexadecimalDecimal", "HexadecimalBinary", "BinaryDecimal", "DecimalHexadecimal", "BinaryHexadecimal", "DecimalBinary" ].index(numeral_sys_1 + numeral_sys_2) + 1

Wie @Sadap sagte,

Meiner Meinung nach ist diese convert_whatFunktion selbst nicht sehr pythonisch. Ich denke, der Code, der diesen Code aufruft, hat auch eine Reihe von if-Anweisungen und konvertiert abhängig vom Rückgabewert von convert_what(). Ich schlage so etwas vor:

Wenn Sie die Basiskonvertierung für Ganzzahlen implementieren, werden Sie wahrscheinlich trotzdem eine allgemeine Darstellung durchlaufen : int. Eine separate Funktion für jedes Basenpaar ist nicht erforderlich, und die beiden beteiligten Basen müssen nicht einmal voneinander wissen.

Eingang

Erstellen Sie eine Zuordnung vom Namen eines Zahlensystems zu seiner Basis:

BINARY = "Binary"
DECIMAL = "Decimal"
HEXADECIMAL = "Hexadecimal"

BASES = {
    BINARY: 2,
    DECIMAL: 10,
    HEXADECIMAL: 16,
}

So können Sie Eingaben mit lesen int(text, BASES[numeral_sys_1]).

Ausgabe

Erstellen Sie eine Zuordnung vom Namen eines Zahlensystems zu einem Formatbezeichner :

FORMATTERS = {
    BINARY: "b",
    DECIMAL: "d",
    HEXADECIMAL: "x",
}

So können Sie Ausgaben mit schreiben format(n, FORMATTERS[numeral_sys_2]).

Beispiel Verwendung

def convert(text, numeral_sys_1, numeral_sys_2):
    n = int(text, BASES[numeral_sys_1])
    return format(n, FORMATTERS[numeral_sys_2])

Jedes Diktat kann auch allgemeiner gestaltet werden, indem stattdessen die Wertefunktionen verwendet werden, wenn Sie einen anderen Satz von Formaten als int(x, base)oder mehr Ausgabebasen als die integrierte Ganzzahlformatierung unterstützen müssen.

Ich mag es, Code trocken zu halten:

def convert_what_2(numeral_sys_1, numeral_sys_2):
    num_sys = ["Hexadecimal", "Decimal", "Binary"]
    r_value = {0: {1: 1, 2: 2},
               1: {0: 4, 2: 6},
               2: {0: 5, 1: 3} }
    try:
        value = r_value[num_sys.index(numeral_sys_1)][num_sys.index(numeral_sys_2)]
    except KeyError: # Catches when they are equal or undefined
        value = 0
    return value

Verwenden Sie einige Techniken, die die anderen Antworten bieten, und kombinieren Sie sie:

def convert(key1, key2):
    keys = ["Hexadecimal", "Decimal", "Binary"]
    combinations = {(0, 1): 1, (0, 2): 2, (1, 0): 4, (1, 2): 6, (2, 0): 5, (2, 1): 3} # use keys indexes to map to combinations
    try:
        return combinations[(keys.index(key1), keys.index(key2))]
    except (KeyError, ValueError): # if value is not in list, return as 0
        return 0

Ich bin mir zwar nicht sicher, ob dieser Ansatz schneller ist, könnte aber auch mit numpy durchgeführt werden:

conditions = [
    ("Hexadecimal", "Decimal"), ("Hexadecimal", "Binary"),
    ("Binary", "Decimal"), ("Decimal", "Hexadecimal"), ("Binary", "Hexadecimal"), ("Decimal", "Binary")]
choices = [1,2,3,4,5,6]

und kann verwendet werden als:

 np.select(conditions, choices, default=0)