在 python 中卡住定義成分 function

Question

輸入：兩個函數 f 和 g，表示為字典，使得 g ◦ f 存在。 output：表示 function g ◦ f 的字典。 示例：給定 f = {0:'a', 1:'b'} 和 g = {'a':'apple', 'b':'banana'}，返回 {0:'apple', 1:'香蕉'}。

最接近正確答案的是 {i:g[j] for i in f for j in g}，它輸出 {0: 'apple', 1: 'apple'}。 我究竟做錯了什么？

Answer 1

其他答案很好，但它們會創建一個可能很慢的完整字典。 如果你只想要一個只讀作文，那么下面的class就可以解決你的問題：

class Composition_mapping(collections.abc.Mapping):
    
    def __init__(self, f, g):
        self.f = f
        self.g = g
    
    def __iter__(self):
        return iter(self.g)
    
    def __len__(self):
        return len(self.g)
        
    def keys(self):
        return self.g.keys()
    
    def __getitem__(self, item):
        return self.f[self.g[item]]

例如：

a = {1: 5}

b = {5:9, 7 : 8}

c = Composition_mapping(b,a)

print(c[1])

>>> 9

如果你決定讓它成為一個命令，你總是可以這樣做：

c = dict(c)
print(c)
>>> {1: 9}

這是安全的，因為 Composition_mapping 滿足mapping protocol ，這意味着它被認為是一個映射。 映射是只讀類字典結構的接口（協議）。 注意不是必須繼承自collections.abc.Mapping，只需要實現__getitem__, __iter__, __len__ __contains__, keys, items, values, get, __eq__, and __ne__即可成為映射； 畢竟 Python 喜歡鴨子打字。 我的代碼繼承自 collections.abc.Mapping 的原因是它為您實現了除__getitem__, __iter__, __len__之外的所有其他方法。 有關協議的詳細信息，請參閱官方文檔。

無論組合的函數有多大，使用這種方法創建組合的時間成本都是恆定的。 由於雙重查找和額外的 function 調用，查找可能會稍微慢一些，但如果您要在性能關鍵部分進行大量調用，則始終可以使用c = dict(c) 。 更重要的是，如果您在代碼中的任何地方更改 a 和 b，更改將反映在 c 上。

Answer 2

你需要迭代一個dict f ，並在理解中，用g的值替換f的值

f = {0:'a', 1:'b'}
g = {'a':'apple', 'b': 'banana'}
new_dict = {k: g[v] for k, v in f.items()}
# Value of new_dict = {0: 'apple', 1: 'banana'}

Answer 3

正確的字典理解是：

{i:g[f[i]] for i in f}

你做了：

{i:g[j] for i in f for j in g}

這將每個i映射到每個i到g每個值，但然后dict刪除了重復鍵。

要查看發生了什么，請嘗試生成列表：

>>> [(i, g[j]) for i in f for j in g]
[(0, 'apple'), (0, 'banana'), (1, 'apple'), (1, 'banana')]

在正確的情況下：

>>> [(i, g[f[i]]) for i in f]
[(0, 'apple'), (1, 'banana')]