Existe uma maneira melhor de escrever instruções if aninhadas em python? [fechadas]

Existe uma maneira mais pitônica de fazer declarações aninhadas se mais que esta:

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

Este script é parte de um conversor simples.

Enquanto as respostas de @Aryerez e @ SencerH. Funcionam, cada valor possível de numeral_sys_1deve ser escrito repetidamente para cada valor possível numeral_sys_2ao listar os pares de valores, dificultando a manutenção da estrutura de dados quando o número de valores possíveis aumenta. Em vez disso, você pode usar um dict aninhado no lugar das instruções if aninhadas:

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)

Como alternativa, você pode gerar os pares de valores para o mapeamento com o itertools.permutationsmétodo, cuja ordem segue a da sequência de entrada:

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)

Insira todas as combinações válidas em um dictionaryde tuples e, se a combinação não estiver lá, retorne 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)

Se você planeja usar a função em um loop, pode ser uma idéia melhor definir o dicionário fora da função, para que não seja recriado em todas as chamadas para a função.

Se você tiver certeza de que nenhum outro valor poderia ter sido definido para as variáveis ​​numeral_sys_1 e numeral_sys_2, esta é a solução mais simples e limpa.

Por outro lado, você deve estender o dicionário com suas combinações com os valores disponíveis, se tiver outro valor que não seja "Hexadecimal", "Decimal" e "Binário"

A lógica aqui é; se as tuplas variáveis ​​nas chaves do dicionário não forem iguais a determinada tupla variável, o método .get () retornará "0". Se determinada variável tupla corresponder a qualquer chave no dicionário, retornará o valor da chave correspondente.

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)

Há também usando gerador poderia ser uma solução. Parece muito mais inteligente, mas acho que o dicionário codificado seria mais rápido do que usar um gerador para esse requisito simples.

Uma maneira alternativa usando lista aninhada. Espero que ajude!!

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

Na minha opinião, essa convert_whatfunção em si não é muito pitônica. Eu acho que o código que chama esse código também possui várias instruções if e faz a conversão dependendo do valor de retorno de convert_what(). Sugiro algo como isto:

Primeiro passo, faça uma função para cada combinação:

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

Segundo passo, coloque os objetos de função em um ditado. Observe que não há () após os nomes das funções, porque queremos armazenar o objeto da função e ainda não o chamamos:

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

Terceiro e último passo, implemente uma função de conversão. A instrução if verifica se os dois sistemas são iguais. Então, obtemos a função correta de nosso ditado e a chamamos:

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)

Isso é feito por instruções de caso de switch na maioria dos outros idiomas. Em python, eu uso uma função simples com um dicionário de expressão.

Código:

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)

Resultado:

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

Em geral, eu correria com a solução de dicionário para tarefa aninhada se. Alguns casos particulares podem levar a outra abordagem. Como este:

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

Que tal algo como:

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 

Uma idéia está usando uma lista e obtém o índice do resultado, ou seja.

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

Como o @Sadap disse,

Na minha opinião, essa convert_whatfunção em si não é muito pitônica. Eu acho que o código que chama esse código também possui várias instruções if e faz a conversão dependendo do valor de retorno de convert_what(). Sugiro algo como isto:

Se você está implementando conversão base para inteiros, provavelmente você está passando por uma representação comum de qualquer maneira: int. Uma função separada para cada par de bases não é necessária, e as duas bases envolvidas nem precisam saber uma da outra.

Entrada

Crie um mapeamento a partir do nome de um sistema numérico até sua base:

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

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

permitindo ler entradas com int(text, BASES[numeral_sys_1]).

Resultado

Crie um mapeamento a partir do nome de um sistema numérico para um especificador de formato :

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

permitindo escrever saídas com format(n, FORMATTERS[numeral_sys_2]).

Exemplo de uso

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

Qualquer regra também pode ser tornada mais geral, fazendo com que os valores funcionem, se você precisar oferecer suporte a um conjunto diferente de formatos int(x, base)ou mais bases de saída do que a formatação inteira integrada suporta.

Eu gosto de manter o código seco:

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

Usando algumas técnicas fornecidas pelas outras respostas e combiná-las:

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

Embora não tenha certeza se essa abordagem é mais rápida, mas pode ser feita usando o numpy também:

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

e pode ser usado como:

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