Czy istnieje lepszy sposób na pisanie zagnieżdżonych instrukcji w Pythonie? [Zamknięte]

Czy istnieje bardziej pythonowy sposób wykonywania zagnieżdżonych instrukcji if if else niż ten:

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

Ten skrypt jest częścią prostego konwertera.

Podczas gdy odpowiedzi @Aryerez i @ SencerH. Działają, każda możliwa wartość numeral_sys_1musi być wielokrotnie zapisywana dla każdej możliwej wartości numeral_sys_2przy zestawianiu par wartości, co utrudnia utrzymanie struktury danych, gdy rośnie liczba możliwych wartości. Zamiast tego możesz użyć zagnieżdżonego słownika zamiast zagnieżdżonego, jeśli instrukcje:

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)

Alternatywnie możesz wygenerować pary wartości dla mapowania za pomocą itertools.permutationsmetody, której kolejność jest zgodna z kolejnością wejściową:

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)

Włóż wszystkie poprawne kombinacje dictionaryod tuples, a jeżeli połączenie nie istnieje, zwraca 0:

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)

Jeśli planujesz używać funkcji w pętli, lepszym pomysłem może być zdefiniowanie słownika poza funkcją, aby nie była odtwarzana przy każdym wywołaniu funkcji.

Jeśli masz pewność, że nie ma innej wartości, którą można ustawić na zmienną numeral_sys_1 i zmienne numeral_sys_2, jest to najprostsze i najczystsze rozwiązanie.

Z drugiej strony, musisz rozszerzyć słownik o jego kombinacje o dostępne wartości, jeśli masz inną wartość niż „Szesnastkowy”, „Dziesiętny” i „Binarny”

Oto logika; jeśli krotki zmienne w kluczach słownika nie są równe danej krotce zmiennej, metoda .get () zwraca „0”. Jeśli dana zmienna krotka pasuje do dowolnego klucza w słowniku, zwraca wartość pasującego klucza.

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)

Istnieje również użycie generatora może być rozwiązaniem. Wygląda o wiele mądrzej, ale myślę, że słownik z kodowaniem na sztywno byłby szybszy niż użycie generatora do tego prostego wymagania.

Alternatywny sposób przy użyciu listy zagnieżdżonej. Mam nadzieję, że to pomoże!!

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

Moim zdaniem ta convert_whatfunkcja sama w sobie nie jest bardzo pytoniczna. Domyślam się, że kod, który wywołuje ten kod, ma również kilka instrukcji if i konwertuje w zależności od zwracanej wartości convert_what(). Sugeruję coś takiego:

Pierwszy krok, wykonaj jedną funkcję dla każdej kombinacji:

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

Drugi krok, umieść obiekty funkcyjne w dyktando. Zauważ, że po nazwach funkcji nie ma znaku (), ponieważ chcemy zapisać obiekt funkcji i nie wywoływać go jeszcze:

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

Trzeci i ostatni krok, zaimplementuj funkcję konwersji. Instrukcja if sprawdza, czy oba systemy są takie same. Następnie otrzymujemy właściwą funkcję z naszego słownika i nazywamy ją:

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)

Odbywa się to za pomocą instrukcji przełączania wielkości liter w większości innych języków. W Pythonie używam prostej funkcji ze słownikiem wyrażeń.

Kod:

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)

Wynik:

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

Ogólnie działałbym z rozwiązaniem słownikowym dla zagnieżdżonego, jeśli zadanie. Niektóre szczególne przypadki mogą przynieść inne podejście. Jak ten:

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

Co powiesz na coś takiego:

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 

Pomysł korzysta z listy i uzyskuje indeks wyników, tj.

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

Jak powiedział @Sadap,

Moim zdaniem ta convert_whatfunkcja sama w sobie nie jest bardzo pytoniczna. Domyślam się, że kod, który wywołuje ten kod, ma również kilka instrukcji if i konwertuje w zależności od zwracanej wartości convert_what(). Sugeruję coś takiego:

Jeśli realizacji konwersji bazowy dla liczb całkowitych, jesteś prawdopodobnie przeżywa wspólnej reprezentacji i tak: int. Oddzielna funkcja dla każdej pary baz nie jest konieczna, a dwie zaangażowane bazy nie muszą nawet wiedzieć o sobie.

Wejście

Utwórz odwzorowanie z nazwy systemu liczbowego na jego podstawę:

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

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

pozwalając na odczyt danych wejściowych za pomocą int(text, BASES[numeral_sys_1]).

Wynik

Utwórz odwzorowanie z nazwy systemu liczbowego na specyfikator formatu :

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

umożliwiając pisanie wyników za pomocą format(n, FORMATTERS[numeral_sys_2]).

Przykładowe użycie

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

Każdy dykt można również uogólnić, wprowadzając funkcje wartości zamiast tego, jeśli trzeba obsługiwać inny zestaw formatów int(x, base)lub więcej baz wyjściowych niż obsługa wbudowanego formatowania liczb całkowitych.

Lubię dbać o to, aby kod był suchy:

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

Używając niektórych technik, które zapewniają inne odpowiedzi i łącz je:

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

Chociaż nie jestem pewien, czy to podejście jest szybsze, ale można to zrobić również za pomocą numpy:

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

i może być używany jako:

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