依赖倒置原则对保证调用方与被调用方解耦是否必要？

我通过一份Python教程的代码示例学习依赖倒置原则（DIP），下面是整理的内容和我的疑问：我们要构建一个货币转换应用，目标是分离主应用逻辑与货币转换逻辑。

代码片段1 #

#!/usr/bin/env python3
# encoding: utf-8

"""Currency converter application using some exchange API."""
class FXConverter:
    """The converter class."""
    def convert(self, from_currency, to_currency, amount):
        """
        Core method of the class. Assume the magic number 1.2 is from some API like 
        Oanda
        """
        print(f'{amount} {from_currency} = {amount * 1.2} {to_currency}')
        return amount * 1.2


class App:
    """The Application"""
    def start(self):
        """The main method to create and invoke the converter object."""
        converter = FXConverter()
        converter.convert('EUR', 'USD', 100)


if __name__ == '__main__':
    app = App()
    app.start()

教程指出：

未来若FX的API变更，会导致代码崩溃；若更换其他API，需修改App类。

因此教程提出了以下实现：

代码片段2 #

#!/usr/bin/env python3
# encoding: utf-8

"""Currency converter application using dependency inversion."""
from abc import ABC


class CurrencyConverter(ABC):
    def convert(self, from_currency, to_currency, amount) -> float:
        pass

class FXConverter(CurrencyConverter):
    def convert(self, from_currency, to_currency, amount) -> float:
        print('Converting currency using FX API')
        print(f'{amount} {from_currency} = {amount * 1.2} {to_currency}')
        return amount * 1.2 # The tutorial seems to have a typo here. 

class App:
    def __init__(self, converter: CurrencyConverter):
        self.converter = converter

    def start(self):
        self.converter.convert('EUR', 'USD', 100)

if __name__ == '__main__':
    converter = FXConverter()
    app = App(converter)
    app.start()

疑问 #

我对教程的说法存疑，这也是我无法理解DIP核心价值的原因：即使FXConverter更换其他API（比如彭博而非Oanda），变更也仅局限于convert方法内部，只要该方法保持签名convert(str, str, float)->float（字符串需为有效的货币名称），App.start就能正常运行。而保持有效方法签名的要求：

• 在DIP实现版本中同样存在；
• 在Rust或C++等类型安全语言中会被自动强制执行，甚至可通过枚举限定货币范围避免无效字符串。

因此我无法理解DIP对提升解耦性的作用——毕竟我们真正需要的是像静态类型语言那样遵守函数/方法签名。

另外，我想确认：一般情况下，当A调用B（对象方法或函数等）时，是否可以默认假设：

• A不知道B的内部实现；
• B不知道A如何处理返回结果；
  从而自动实现所需的解耦？

内容的提问来源于stack exchange，提问作者Della