Detailed explanation of duck typing duck type programming and Python implementation

In programming, duck typing (English: duck typing) is a style of dynamic typing. In this style, the effective semantics of an object are determined not by inheriting from a specific class or implementing a specific interface, but by the current set of methods and properties.

The name of this concept comes from the duck test proposed by James Whitcomb Riley. The "duck test" can be expressed like this:
"When you see a bird walking like a duck and swimming like a If a duck quacks and sounds like a duck, then the bird can be called a duck. "
In the duck type, the focus is not on the type of the object itself, but on how it is used. For example, in a language that doesn't use duck typing, we could write a function that takes an object of type duck and calls its walk and bark methods. In a language that uses duck typing, such a function can accept an object of any type and call its walk and call methods. If the methods that need to be called do not exist, a runtime error will be raised. The fact that any object with the correct walk and call methods can be accepted by a function leads to the above statement, hence the name of this way of determining types.
Duck typing often benefits from not testing the types of parameters in methods and functions, but instead relying on documentation, clear code, and testing to ensure correct usage. Users moving from statically to dynamically typed languages ​​often attempt to add some static (before runtime) type checking, thus compromising the benefits and scalability of duck typing and constraining the dynamic nature of the language.

Python code example
The above statement may be too empty. For example, in Python, there are many file-like things, such as StringIO, GzipFile, and socket. They have many of the same methods, and we use them as files.
For example, in the list.extend() method, we don't care whether its parameter is a list, as long as it is iterable, so its parameters can be list/tuple/dict/string/generator, etc.
Duck typing is often used in dynamic languages ​​and is very flexible, which makes python not like Java to have a lot of design patterns.

The following example uses duck typing to achieve polymorphism.

#coding=utf-8 
class Duck: 
  def quack(self): 
    print "Quaaaaaack!" 
 
class Bird: 
  def quack(self): 
    print "bird imitate duck." 
 
class Doge: 
  def quack(self): 
    print "doge imitate duck." 
 
def in_the_forest(duck): 
  duck.quack() 
 
duck = Duck() 
bird = Bird() 
doge = Doge() 
for x in [duck, bird, doge]: 
  in_the_forest(x)

As another example,
let’s hack the output stream.

import sys 
 
sys.stdout = open('stdout.log', 'a') #只要是file-like,不管是什么类型 
print 'foo' 
 
sys.stdout = sys.__stdout__ #恢复 
print 'bar'

This will write the output stream to the file.

For more detailed explanations of duck typing duck typing programming and Python implementation related articles, please pay attention to the PHP Chinese website!