Có cách nào tốt hơn để viết lồng nhau nếu các câu lệnh trong python? [đóng cửa]

Có cách nào khác để thực hiện lồng nhau nếu các câu lệnh khác hơn cách này không:

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

Kịch bản này là một phần của một trình chuyển đổi đơn giản.

Trong khi câu trả lời của @Aryerez và @ SencerH. hoạt động, mỗi giá trị numeral_sys_1có thể phải được ghi lại cho mỗi giá trị có thể numeral_sys_2khi liệt kê các cặp giá trị, làm cho cấu trúc dữ liệu khó duy trì hơn khi số lượng giá trị có thể tăng lên. Thay vào đó, bạn có thể sử dụng một lệnh đọc lồng nhau thay cho các câu lệnh if lồng nhau của bạn thay vào đó:

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)

Ngoài ra, bạn có thể tạo các cặp giá trị cho ánh xạ với itertools.permutationsphương thức, thứ tự theo sau của chuỗi đầu vào:

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)

Chèn tất cả các kết hợp hợp lệ vào a dictionarycủa tuples và nếu kết hợp không có ở đó, trả về 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)

Nếu bạn đang dự định sử dụng hàm trong một vòng lặp, có thể nên xác định từ điển bên ngoài hàm, vì vậy nó sẽ không được tạo lại trên mỗi lệnh gọi hàm.

Nếu bạn chắc chắn rằng không có giá trị nào khác có thể được đặt thành các biến num num_sys_1 và numeral_sys_2 thì đây là giải pháp đơn giản và sạch nhất.

Mặt khác, bạn phải mở rộng từ điển với các kết hợp của nó với các giá trị khả dụng, nếu bạn có bất kỳ giá trị nào khác ngoài "Hệ thập lục phân", "Số thập phân" và "Nhị phân"

Logic ở đây là; nếu các tuple biến trong các khóa từ điển không bằng tuple biến đã cho, phương thức .get () trả về "0". Nếu tuple biến được đưa ra khớp với bất kỳ khóa nào trong từ điển, do đó trả về giá trị của khóa khớp.

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)

Ngoài ra còn sử dụng máy phát điện có thể là một giải pháp. Trông thông minh hơn nhiều, nhưng tôi nghĩ rằng từ điển mã hóa cứng sẽ nhanh hơn sử dụng một trình tạo cho yêu cầu đơn giản này.

Một cách khác để sử dụng danh sách lồng nhau. Hy vọng nó giúp!!

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

Theo tôi, convert_whatchức năng này tự nó không phải là rất pythonic. Tôi đoán mã gọi mã này cũng có một loạt các câu lệnh if và thực hiện chuyển đổi tùy thuộc vào giá trị trả về của convert_what(). Tôi đề nghị một cái gì đó như thế này:

Bước đầu tiên, tạo một chức năng cho mọi kết hợp:

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

Bước thứ hai, đặt các đối tượng chức năng trong một dict. Lưu ý rằng không có () sau tên hàm, vì chúng tôi muốn lưu trữ đối tượng hàm và chưa gọi nó:

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

Bước thứ ba và cuối cùng, thực hiện chức năng chuyển đổi. Câu lệnh if kiểm tra nếu cả hai hệ thống giống nhau. Sau đó, chúng tôi nhận được chức năng đúng từ dict của chúng tôi và gọi nó:

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)

Điều này được thực hiện bằng các câu lệnh chuyển đổi trong hầu hết các ngôn ngữ khác. Trong python, tôi sử dụng một hàm đơn giản với một từ điển biểu thức.

Mã số:

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)

Đầu ra:

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

Nói chung tôi sẽ chạy với giải pháp từ điển cho lồng nhau nếu tác vụ. Một số trường hợp cụ thể có thể mang đến một cách tiếp cận khác. Như cái này:

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

Làm thế nào về một cái gì đó như:

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 

Một ý tưởng đang sử dụng một danh sách và nhận chỉ số kết quả, tức là.

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

Như @Sadap đã nói,

Theo tôi, convert_whatchức năng này tự nó không phải là rất pythonic. Tôi đoán mã gọi mã này cũng có một loạt các câu lệnh if và thực hiện chuyển đổi tùy thuộc vào giá trị trả về của convert_what(). Tôi đề nghị một cái gì đó như thế này:

Nếu bạn đang thực hiện chuyển đổi cơ sở cho số nguyên, có lẽ bạn cũng sẽ trải qua một đại diện chung : int. Một chức năng riêng biệt cho mỗi cặp căn cứ là không cần thiết và hai cơ sở liên quan thậm chí không cần biết về nhau.

Đầu vào

Tạo ánh xạ từ tên của một hệ thống số đến cơ sở của nó:

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

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

cho phép bạn đọc đầu vào với int(text, BASES[numeral_sys_1]).

Đầu ra

Tạo ánh xạ từ tên của một hệ thống số sang một bộ xác định định dạng :

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

cho phép bạn viết kết quả đầu ra với format(n, FORMATTERS[numeral_sys_2]).

Ví dụ sử dụng

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

Thay vào đó, dict cũng có thể được tạo ra tổng quát hơn bằng cách tạo các hàm giá trị, nếu bạn cần hỗ trợ một bộ định dạng khác hơn int(x, base)hoặc nhiều cơ sở đầu ra hơn các hỗ trợ định dạng số nguyên tích hợp.

Tôi thích giữ mã khô:

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

Sử dụng một số kỹ thuật mà các câu trả lời khác cung cấp và kết hợp chúng:

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

Mặc dù không chắc cách tiếp cận này có nhanh hơn không, nhưng cũng có thể được thực hiện bằng cách sử dụng numpy:

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

và có thể được sử dụng như:

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