我试着用自己的方式去理解这句名言: “Python并不关心对象是否是真正的鸭子。 它只关心这个物体，首先‘呱呱’，其次‘像鸭子一样’。”

有一个很好的网站。http://www.voidspace.org.uk/python/articles/duck_typing.shtml#id14

作者指出，鸭子类型允许您创建自己的类 它们自己的内部数据结构-但使用正常的Python语法访问。

假设您正在设计一个简单的函数，该函数获取一个Bird类型的对象并调用它的walk()方法。你可以考虑两种方法:

这是我的函数，我必须确保它只接受Bird类型，否则代码将无法编译。如果有人想使用我的功能，他们必须知道我只接受鸟类。 我的函数获取任何对象，我只调用对象的walk()方法。因此，如果对象可以walk()，那么它是正确的。如果不能，我的函数就会失败。所以，这里的对象是鸟还是其他东西并不重要，重要的是它能走路()(这是鸭子类型)。

必须考虑到鸭子类型在某些情况下可能是有用的。例如，Python经常使用duck类型。

读有用的书

在Java、Python和JavaScript中都有很好的鸭子类型的例子 https://en.wikipedia.org/wiki/Duck_typing等。 这里也有一个很好的答案，它描述了动态的优点 动态类型及其缺点:动态类型所能带来的生产力提升是什么?

我试着用自己的方式去理解这句名言: “Python并不关心对象是否是真正的鸭子。 它只关心这个物体，首先‘呱呱’，其次‘像鸭子一样’。”

有一个很好的网站。http://www.voidspace.org.uk/python/articles/duck_typing.shtml#id14

作者指出，鸭子类型允许您创建自己的类 它们自己的内部数据结构-但使用正常的Python语法访问。

我知道我没有给出一个笼统的答案。在Ruby中，我们不声明变量或方法的类型——所有东西都是某种类型的对象。 规则是"类不是类型"

在Ruby中，类从来都不是(好吧，几乎从来都不是)类型。相反，对象的类型更多地由该对象可以做什么来定义。在Ruby中，我们称之为duck typing。如果一个对象像鸭子一样走路，像鸭子一样说话，那么解释器很乐意把它当作鸭子来对待。

例如，您可能正在编写一个例程，将歌曲信息添加到字符串中。如果你有c#或Java背景，你可能会这样写:

def append_song(result, song)
    # test we're given the right parameters 
    unless result.kind_of?(String)
        fail TypeError.new("String expected") end
    unless song.kind_of?(Song)
        fail TypeError.new("Song expected")
end

result << song.title << " (" << song.artist << ")" end
result = ""

append_song(result, song) # => "I Got Rhythm (Gene Kelly)"

采用Ruby的鸭子输入，您可以编写一些简单得多的东西:

def append_song(result, song)
    result << song.title << " (" << song.artist << ")"
end

result = ""
append_song(result, song) # => "I Got Rhythm (Gene Kelly)"

你不需要检查参数的类型。如果它们支持<<(在结果的情况下)或标题和艺术家(在歌曲的情况下)，一切都会正常工作。如果没有，你的方法无论如何都会抛出一个异常(就像你检查了类型一样)。但如果没有检查，你的方法突然变得灵活多了。你可以向它传递一个数组、一个字符串、一个文件或任何其他使用<<追加的对象，它就可以工作了。

用鸭子打字技术的树遍历

def traverse(t):
    try:
        t.label()
    except AttributeError:
        print(t, end=" ")
    else:
        # Now we know that t.node is defined
        print('(', t.label(), end=" ")
        for child in t:
            traverse(child)
        print(')', end=" ")

鸭子打字不是类型提示!

基本上，为了使用“duck typing”，你不会针对特定的类型，而是通过使用公共接口来针对更广泛的子类型(不是谈论继承，当我指的子类型时，我指的是适合相同配置文件的“事物”)。

你可以想象一个存储信息的系统。为了读写信息，你需要某种存储空间和信息。

存储类型可以是:文件、数据库、会话等。

无论存储类型是什么，该接口都会让您知道可用的选项(方法)，这意味着在这一点上什么都没有实现!换句话说，接口不知道如何存储信息。

每个存储系统都必须通过实现接口的相同方法来知道接口的存在。

interface StorageInterface
{
   public function write(string $key, array $value): bool;
   public function read(string $key): array;
}


class File implements StorageInterface
{
    public function read(string $key): array {
        //reading from a file
    }

    public function write(string $key, array $value): bool {
         //writing in a file implementation
    }
}


class Session implements StorageInterface
{
    public function read(string $key): array {
        //reading from a session
    }

    public function write(string $key, array $value): bool {
         //writing in a session implementation
    }
}


class Storage implements StorageInterface
{
    private $_storage = null;

    function __construct(StorageInterface $storage) {
        $this->_storage = $storage;
    }

    public function read(string $key): array {
        return $this->_storage->read($key);
    }

    public function write(string $key, array $value): bool {
        return ($this->_storage->write($key, $value)) ? true : false;
    }
}

所以现在，每次你需要写/读信息时:

$file = new Storage(new File());
$file->write('filename', ['information'] );
echo $file->read('filename');

$session = new Storage(new Session());
$session->write('filename', ['information'] );
echo $session->read('filename');

在这个例子中，你最终在存储构造函数中使用Duck Typing:

function __construct(StorageInterface $storage) ...

希望能有所帮助;)