Python 如何跟踪不同编程语言中的等效函数？

我正在开发一个源代码到源代码的编译器，用于在不同的编程语言之间翻译程序。现在，我正试图找到一种方法来跟踪不同编程语言中的等价函数，这样我就可以找出一种语言中的哪个函数等价于另一种语言中的相同函数

给定这样一个数组，是否可以编写一个函数以另一种语言返回相应的函数（例如，使用诸如

print（getCorrespondingValue（“Python”），[[[“Java”，“System.out.println”]]）

，它将以Python返回对应于Java中

System.out.println

的函数）?

---

是的，这绝对是可能的。我已经用Python编写了一个完整的工作解决方案

首先，我用不同的编程语言创建了一系列相应的函数：

correspondingFunctionDatabase = [
    [
        ["Java", "System.out.println"], ["JavaScript", "console.log"], ["Python", "print"],
    ],
    [
        ["Java", "s1.replaceAll(str1, str2);"], ["JavaScript", "str.replace(str1, str2)"], ["Python", "str.replace(str1, str2)"], ["Haxe", "replace(str, str1, str2)"]
    ],
    [
        ["JavaScript", "str.split(separator)"], ["Java", "str.split(separator)"], ["Python", "re.split(separator, string)"]
    ],
    [
        ["JavaScript", "eval(statement)"], ["Python", "eval(statement)"] 
    ]
]

接下来，我编写了一个名为

getCorrespondingValue

的函数，该函数将返回一种语言的函数，该语言对应于另一种语言的函数：

def containsAll(containingArray, containsAllOfThese):
    i = 0
    while(i < len(containsAllOfThese)):
        if((containsAllOfThese[i] in containingArray) == False):
            return False
        i += 1
    return True

def getCorrespondingValue(valueToRetrieve, valueCorrespondsTo, mainArray=correspondingFunctionDatabase, printMessages=False):
    i = 0
    correspondingValues = []
    while(i < len(mainArray)):
        if(containsAll(containsAllOfThese=valueCorrespondsTo, containingArray = mainArray[i])):
            if(printMessages == True):
                print("The elements of the array:\n", valueCorrespondsTo)
                print("Are contained in the array:\n", str(mainArray[i])+"\n")
            j = 0
            while(j < len(mainArray[i])):
                if(mainArray[i][j][0] == valueToRetrieve):

                    print(mainArray[i][j])

                    correspondingValues += [mainArray[i][j][1]]
                j += 1
        i += 1
    print("The retrieved values for", valueToRetrieve, "from", valueCorrespondsTo, "are", correspondingValues)
    return correspondingValues

---

首先构建查找，然后访问：

from itertools import permutations
from collections import defaultdict

dd = defaultdict(dict)
for row in correspondingFunctionDatabase:
    for fst, snd in permutations(row, 2):
        dd[tuple(fst)][snd[0]] = snd[1]

print dd['Java', 'System.out.println']['Python']
# print
print dd['JavaScript', 'eval(statement)']['Python']
# eval(statement)
print dd['JavaScript', 'eval(statement)'].get('FakeLanguage', 'No Matching Function')
# No Matching Function

请注意，这也意味着您可以获得语句可以翻译成的语言，例如：

print list(dd["Java", "s1.replaceAll(str1, str2);"])
# ['Python', 'Haxe', 'JavaScript']

---

根据评论中的要求，这可能是我通常执行此操作的方式。事实上，我会使用Mongo数据库，但为了简洁起见，我没有使用它

DB = [
{"Java": "System.out.println", "JavaScript": "console.log", "Python", "print"},
{"Java": "s1.replaceAll(str1, str2);", "JavaScript": "str.replace(str1, str2)", "Python": "str.replace(str1, str2)", "Haxe": "replace(str, str1, str2)"},
{"JavaScript": "str.split(separator)", "Java": "str.split(separator)", "Python": "re.split(separator, string)"}
{"JavaScript": "eval(statement)", "Python": "eval(statement)"}]

def get_corresponding_value(language, entry):
    try:
        index = [value for key,value in DB if key == entry[0]].index(entry[1])
        return DB[index].get(language, "No equivalent found")
    except ValueError:
        print "Could not find function: %s " % entry[1]
        raise

或者恋物癖者的一句话：

get_equiv = lambda language,entry: DB[[value for key,value in DB if key==entry[0]].index(entry[1])][language]

---

我知道“尝试除外”有点过分，但未处理的错误是我最讨厌的。

我认为有一种更简单的解决方法：

# Build a list of dicts. Each dict maps language names
# to function names.
cfDicts = [dict(x) for x in correspondingFunctionDatabase]

def getCorrespondingValue(lang, construct):
    # Select all dicts that have an entry for lang and for
    # the given construct. A construct is a tuple of the
    # form (language, function).
    ds = [d for d in cfDicts if lang in d and
                                construct[0] in d and
                                d[construct[0]] == construct[1]]
    if len(ds) == 0:
        # There is no equivalent for `lang` to `construct`.
        return None
    else:
        # There should be only one match.
        assert len(ds) == 1, 'Multiple entries for' + str(construct)
        # Return the first match.
        return ds[0][lang]

请注意，我已将第二个参数更改为仅包含一个构造。修改它以接受多个构造很容易（而且毫无意义）

示例：

In [117]: getCorrespondingValue("Python", ["Java", "System.out.println"])
print

---

给你，用两条格言：

equivalenceclasses = {n: dict(map(tuple,klass)) for n,klass in enumerate(correspondingFunctionDatabase)}
bypair = {tuple(pair):n for n,klass in enumerate(correspondingFunctionDatabase) for pair in klass}

#note pep8 style name
def get_corresponding_function(targetlang, pair):
    # you could catch exceptions here
    return equivalenceclasses.get(bypair.get(tuple(pair))).get(targetlang)

print get_corresponding_function("Python", ["Java", "System.out.println"])

“数据库”中的每一行代表一个类；每个这样的类都可以用一个整数来标识，这个整数可以用来连接两个dict。当然，您可以只使用

sqlite

（或其他sql）或freeform数据库

---

在这里看到它的实际作用：

是的，这是可能的，但如果你坚持列表，它不会很快。老实说，这是关系数据库擅长解决的问题。我觉得这对于一个自我回答的问题来说是极不令人信服的。这不会暴露任何新的东西，也没有太多的实际用途。是否可以打印列表中的项目？对当然。你在打印一个列表中的项目。如果你使用字典会容易得多，但是你只有一个列表。我并不想贬低你，但你甚至有未使用的运算符和大量无用的代码对你没有任何帮助。我不想说我早就告诉过你了。。。但我完全告诉过你，伙计。@AndersonGreen匹配等价函数可能是你这么做的原因；但是你要做的是存储一对串，实际上这是一个更简单的解决方案。“比这还要简单。”斯莱特泰拉诺斯同意了，看起来你、乔恩和我同时提交了。你和我的解决方案似乎差不多。嘿，结果真有趣。我真的很喜欢乔恩的解决方案。不过我添加了一行代码来增加天赋。我的解决方案有什么问题吗？为什么会被否决？（我猜这是因为我的解决方案比它需要的复杂得多。）我没有投反对票，但可能是因为你的问题/答案似乎归结为“我如何存储成对的字符串”，这不是一个不公平的问题，而是为什么要打扮成这样事实上，我根本不明白为什么有人会投反对票。您的问题本身相当琐碎，显示出对数据结构的肤浅理解；您的答案可能是我这周看到的最糟糕的python代码。没有一行我没有问题（好吧，返回语句没问题）。您对python的了解似乎来自于对其他语言的了解和对python语法的略读，感觉就像是在用python编写php代码。因此，我不能否决这一点，以确保接触它的人不会误认为这是一个好的解决方案……这是相当令人印象深刻的。这比我自己的解决方案要好得多——难怪我的问题得到这么多反对票。直到现在我才意识到我是多么无知。（也许我看起来如此无知永远都不会被原谅，但至少我可以从所有比我无知的人身上学到一些东西。）@AndersonGreen正在重温我的旧答案，以防我需要更新任何东西——很高兴看到你仍然很活跃，而且这个问题并没有让你如此失望

In [117]: getCorrespondingValue("Python", ["Java", "System.out.println"])
print

equivalenceclasses = {n: dict(map(tuple,klass)) for n,klass in enumerate(correspondingFunctionDatabase)}
bypair = {tuple(pair):n for n,klass in enumerate(correspondingFunctionDatabase) for pair in klass}

#note pep8 style name
def get_corresponding_function(targetlang, pair):
    # you could catch exceptions here
    return equivalenceclasses.get(bypair.get(tuple(pair))).get(targetlang)

print get_corresponding_function("Python", ["Java", "System.out.println"])