Python'da iç içe if ifadeleri yazmanın daha iyi bir yolu var mı? [kapalı]

Bu ifadeden başka ifadeler iç içe yerleştirmenin daha pythonic bir yolu var mı:

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

Bu komut dosyası basit bir dönüştürücünün bir parçasıdır.

@Aryerez ve @ SencerH.'nin cevapları çalışırken, olası değerlerin sayısı arttığında veri yapısının korunmasını zorlaştırarak, değer çiftlerini listelemenin numeral_sys_1olası her değeri için tekrar tekrar yazılması gerekir numeral_sys_2. Bunun yerine, iç içe if ifadelerinizin yerine iç içe geçmiş bir dikte kullanabilirsiniz:

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)

Alternatif olarak, itertools.permutationssırası ile giriş sırasının sırasını izleyen yöntemle eşleştirme için değer çiftleri oluşturabilirsiniz :

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)

Bir üzere tüm geçerli kombinasyonları yerleştirin dictionaryve tuples, ve kombinasyon yoksa return 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)

İşlevi bir döngüde kullanmayı planlıyorsanız, sözlüğü işlevin dışında tanımlamak daha iyi bir fikir olabilir, bu nedenle işleve yapılan her çağrıda yeniden oluşturulmaz.

Numeral_sys_1 ve numeral_sys_2 değişkenlerine ayarlanmış başka bir değer olmadığından eminseniz, bu en basit ve en temiz çözümdür.

Öte yandan, "Onaltılık", "Ondalık" ve "İkili" dışında bir değeriniz varsa sözlüğü kullanılabilir değerlerle kombinasyonlarıyla genişletmeniz gerekir.

Buradaki mantık; sözlük anahtarlarındaki değişken tuples verilen değişken tuple ile eşit değilse, .get () yöntemi "0" değerini döndürür. Verilen değişken tuple sözlükteki herhangi bir anahtarla eşleşirse, eşleşen anahtarın değerini döndürün.

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)

Jeneratör kullanmak da bir çözüm olabilir. Çok daha akıllıca görünüyor, ancak sabit kodlu sözlüğün bu basit gereksinim için bir jeneratör kullanmaktan daha hızlı olacağını düşünüyorum.

İç içe liste kullanarak alternatif bir yol. Umarım yardımcı olur!!

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

Bence bu convert_whatfonksiyonun kendisi çok pitonik değil. Bu kod çağıran kodu if ifadeleri bir sürü var ve dönüş değerine bağlı olarak dönüştürme yapar sanırım convert_what(). Böyle bir şey öneririm:

İlk adım, her kombinasyon için bir işlev yapın:

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

İkinci adım, fonksiyon nesnelerini bir dikteye koyun. İşlev adlarından sonra no () olmadığını unutmayın, çünkü işlev nesnesini saklamak ve henüz çağırmamak istiyoruz:

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

Üçüncü ve son adım, bir dönüştürme işlevi uygulayın. İf ifadesi her iki sistemin de aynı olup olmadığını kontrol eder. Ardından, doğru işlevi diktemizden alıyoruz ve çağırıyoruz:

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)

Bu, diğer dillerin çoğunda anahtar durum ifadeleriyle yapılır. Python'da, bir ifade sözlüğü ile basit bir işlev kullanıyorum.

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)

Çıktı:

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

Genel olarak ben görev iç içe için sözlük çözüm ile çalışır. Bazı özel durumlar başka bir yaklaşıma yol açabilir. Bunun gibi:

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

Nasıl bir şey hakkında:

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 

Bir Fikir bir liste kullanır ve sonuç dizini almak, yani.

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

@Sadap'ın dediği gibi,

Bence bu convert_whatfonksiyonun kendisi çok pitonik değil. Bu kod çağıran kodu if ifadeleri bir sürü var ve dönüş değerine bağlı olarak dönüştürme yapar sanırım convert_what(). Böyle bir şey öneririm:

Eğer tamsayılar için taban dönüşümünü uyguluyorsanız, muhtemelen yine ortak bir temsil yoluyla gidiyoruz: int. Her baz çifti için ayrı bir fonksiyon gerekli değildir ve dahil olan iki bazın birbirlerini bilmesine bile gerek yoktur.

Giriş

Bir sayı sisteminin adından tabanına bir eşleme oluşturun:

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

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

ile girişleri okumanıza izin verir int(text, BASES[numeral_sys_1]).

Çıktı

Sayı sisteminin adından format belirleyicisine eşleme oluşturun :

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

ile çıktılar yazmanıza izin verir format(n, FORMATTERS[numeral_sys_2]).

Örnek kullanım

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

Bunun yerine, farklı bir biçim kümesini desteklemeniz gerekiyorsa int(x, base)ya da yerleşik tamsayı biçimlendirme desteklerinden daha fazla çıkış temelleri gerekiyorsa, her iki değer de daha genel değerler yapılabilir .

Kodu kuru tutmak istiyorum:

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

Diğer cevapların sağladığı bazı teknikleri kullanarak bunları birleştirin:

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

Bu yaklaşımın daha hızlı olup olmadığından emin olmasa da, numpy kullanılarak da yapılabilir:

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

ve şu şekilde kullanılabilir:

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