duck-typing

Here is some Ruby code: class Duck def help puts "Quaaaaaack!" end end class Person def help puts "Heeeelp!" end end def InTheForest x x.help end donald = Duck.new john = Person.new print "Donald in the forest: " InTheForest donald print "John in the forest: " InTheForest john And, I translated it to Python: import sys class Duck: def help(): print("Quaaaaaack!") class Person: def help(): print("Heeeelp!") def InTheForest(x): x.help() donald = Duck() john = Person() sys.stdout.write("Donald in the forest: ") InTheForest(donald) sys.stdout.write("John in the forest: ") InTheForest(john) The

Wikipedia used to say* about duck-typing : In computer programming with object-oriented programming languages, duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface. (* Ed. note: Since this question was posted, the Wikipedia article has been edited to remove the word "dynamic".) It says about structural typing : A structural type system (or property-based type system) is a major class of type system, in which type

I'm a little confused with the two terms, here's what I know: Polymorphism is the ability of object of different types to be handled by a common interface. While duck typing, is a kind of dynamic typing that allows objects of different types to respond to the same methods. From what I understand, polymorphism is more about creating an interface that can be shared across different classes. And duck typing is about loose typing that will allow methods to be called as long as it is found on the receiver of the message. Is this correct? I'm pretty confused on the two, they seem related but I do

I usually want to keep my code as generic as possible. I'm currently writing a simple library and being able to use different types with my library feels extra important this time. One way to go is to force people to subclass an "interface" class. To me, this feels more like Java than Python and using issubclass in each method doesn't sound very tempting either. My preferred way is to use the object in good faith, but this will raise some AttributeErrors . I could wrap each dangerous call in a try/except block. This, too, seems kind of cumbersome: def foo(obj): ... # it should be able to sleep

I have 2 classes: public class Articles { private string name; public Articles(string name) { this.name = name; } public void Output() { Console.WriteLine("The class is: " + this.GetType()); Console.WriteLine("The name is: " + name); } } And public class Questionnaire { private string name; public Questionnaire(string name) { this.name = name; } public void Output() { Console.WriteLine("The class is: " + this.GetType()); Console.WriteLine("The name is: " + name); } } I want to write a method, that takes an integer (1 meaning Articles should be returned, 2 meaning Questionnaire ) and a name.