The following code works:

    class Foo(tuple):
    
        def __init__(self, b):
            super(Foo, self).__init__(tuple(b))
    
    if __name__ == &#39;__main__&#39;:
        print Foo([3, 4])
    
    $ python play.py 

Result:

&lt;!-- language: lang-none --&gt;

    play.py:4: DeprecationWarning: object.__init__() takes no parameters
      super(Foo, self).__init__(tuple(b))
    (3, 4)

But not the following:

    class Foo(tuple):
    
        def __init__(self, a, b):
            super(Foo, self).__init__(tuple(b))
    
    if __name__ == &#39;__main__&#39;:
        print Foo(None, [3, 4])
    
    $ python play.py 

Result:

&lt;!-- language: lang-none --&gt;

    Traceback (most recent call last):
      File &quot;play.py&quot;, line 7, in &lt;module&gt;
        print Foo(None, [3, 4])
    TypeError: tuple() takes at most 1 argument (2 given)

Why?




Subclassing tuple with multiple __init__ arguments

Please consider the following code:

    struct A
    {
    	void f()
    	{
    	}
    };
    
    struct B1 : A
    {
    };
    
    struct B2 : A
    {
    };
    
    struct C : B1, B2
    {
    	void f() // works
    	{
    		B1::f();
    	}
    	//using B1::f; // does not work
    	//using B1::A::f; // does not work as well
    };
    
    int main()
    {
    	C c;
    	c.f();
    	
    	return 0;
    }

I kindly ask you not to copy paste a standard reply on how to solve the diamond problem (&quot;use virtual inheritance&quot;). What I am asking here is why doesn&#39;t a using-declaration work in this case. The exact compiler error is:

    In function &#39;int main()&#39;:
    prog.cpp:31:6: error: &#39;A&#39; is an ambiguous base of &#39;C&#39;
      c.f();

I got the impression a using-declaration should work from this example:

   
    struct A
    {
    	void f()
    	{
    	}
    };
    
    struct B
    {
    	void f()
    	{
    	}
    };
    
    struct C : A, B
    {
    	using A::f;
    };
    
    int main()
    {
    	C c;
    	c.f(); // will call A::f
    	
    	return 0;
    }

Why doesn&#39;t a using-declaration work to solve the diamond problem?

What&#39;s the difference between `UserDict`, `dict` and `ABC` and which one is recommended? The docs seem to deprecate `UserDict`?

Also it seems UserDict&#39;s `update()` would use my `setitem` method whereas `dict` doesn&#39;t? Which methods are really essential to override given I want custom `setitem` and `getitem` function?

With `ABC`s I&#39;d have to implement absolutely all methods since it provides no default implementation?

I want to make a `dict` that does two things:

  - `intern()` all keys and values
  - store some of the values in an SQLite database

So which of `UserDict`, `dict` and `ABC` would best allow me to do this?

Subclass dict: UserDict, dict or ABC?

I have a coredata entity named Record and has a property dateUpdated. I noticed that the generated NSManagedObject subclass has no optional mark (?)

**CoreData Editor:**

![enter image description here][1]


**Generated Subclass:**

![enter image description here][2]

**Expected:**

![enter image description here][3]


  [1]: http://i.stack.imgur.com/mDD3a.png
  [2]: http://i.stack.imgur.com/L1YYw.png
  [3]: http://i.stack.imgur.com/9PwaM.png

**UPDATED:** 
It&#39;s **tedious** in my part, because each time I want to regenerate the subclasses, it means I also need to update all optional values manually. Having a non-optional (without &#39;?&#39;) in subclass lead me to check evalue before assigning, like example below:
   
    // sample value:
    // serverDateFormatter = &quot;yyyy/MM/dd&quot;
    // dateString = &quot;&quot;    

    // Branch is a subclass of Record (see above images)

    var date = self.coreData.serverDateFormatter.dateFromString(dateString)
    if date != nil
    {
       branch.dateUpdated = date 
    }

But if xcode can automatically set optional value in subclass with (?) I just need to do like this:

    branch.dateUpdated = self.coreData.serverUTCDateFormatter.dateFromString(dateString)
   
In my case, I have bunch of properties I need to mark as optional manually.

Swift + CoreData: Cannot Automatically Set Optional Attribute On Generated NSManagedObject Subclass

I am building a class which subclasses &lt;code&gt;dict&lt;/code&gt;, and overrides &lt;code&gt;\__setitem__&lt;/code&gt;. I would like to be certain that my method will be called in all instances where dictionary items could possibly be set.

I have discovered three situations where Python (in this case, 2.6.4) does not call my overridden &lt;code&gt;\__setitem__&lt;/code&gt; method when setting values, and instead calls &lt;code&gt;PyDict_SetItem&lt;/code&gt; directly

1. In the constructor
1. In the &lt;code&gt;setdefault&lt;/code&gt; method
1. In the &lt;code&gt;update&lt;/code&gt; method

As a very simple test:

    class MyDict(dict):
        def __setitem__(self, key, value):
            print &quot;Here&quot;
            super(MyDict, self).__setitem__(key, str(value).upper())

    &gt;&gt;&gt; a = MyDict(abc=123)
    &gt;&gt;&gt; a[&#39;def&#39;] = 234
    Here
    &gt;&gt;&gt; a.update({&#39;ghi&#39;: 345})
    &gt;&gt;&gt; a.setdefault(&#39;jkl&#39;, 456)
    456
    &gt;&gt;&gt; print a
    {&#39;jkl&#39;: 456, &#39;abc&#39;: 123, &#39;ghi&#39;: 345, &#39;def&#39;: &#39;234&#39;}

You can see that the overridden method is only called when setting the items explicitly. To get Python to always call my &lt;code&gt;\__setitem__&lt;/code&gt; method, I have had to reimplement those three methods, like this:

    class MyUpdateDict(dict):
        def __init__(self, *args, **kwargs):
            self.update(*args, **kwargs)

        def __setitem__(self, key, value):
            print &quot;Here&quot;
            super(MyUpdateDict, self).__setitem__(key, value)

        def update(self, *args, **kwargs):
            if args:
                if len(args) &gt; 1:
                    raise TypeError(&quot;update expected at most 1 arguments, got %d&quot; % len(args))
                other = dict(args[0])
                for key in other:
                    self[key] = other[key]
            for key in kwargs:
                self[key] = kwargs[key]

        def setdefault(self, key, value=None):
            if key not in self:
                self[key] = value
            return self[key]

Are there any other methods which I need to override, in order to know that Python will *always* call my &lt;code&gt;\__setitem__&lt;/code&gt; method?

**UPDATE**

Per gs&#39;s suggestion, I&#39;ve tried subclassing UserDict (actually, IterableUserDict, since I want to iterate over the keys) like this:

    from UserDict import *;
    class MyUserDict(IterableUserDict):
        def __init__(self, *args, **kwargs):
            UserDict.__init__(self,*args,**kwargs)

        def __setitem__(self, key, value):
            print &quot;Here&quot;
            UserDict.__setitem__(self,key, value)

This class seems to correctly call my &lt;code&gt;\__setitem__&lt;/code&gt; on &lt;code&gt;setdefault&lt;/code&gt;, but it doesn&#39;t call it on &lt;code&gt;update&lt;/code&gt;, or when initial data is provided to the constructor.

**UPDATE 2**

Peter Hansen&#39;s suggestion got me to look more carefully at dictobject.c, and I realised that the update method could be simplified a bit, since the built-in dictionary constructor simply calls the built-in update method anyway. It now looks like this:

    def update(self, *args, **kwargs):
        if len(args) &gt; 1:
            raise TypeError(&quot;update expected at most 1 arguments, got %d&quot; % len(args))
        other = dict(*args, **kwargs)
        for key in other:
            self[key] = other[key]


Subclassing Python dictionary to override __setitem__

I need a working approach of getting all classes that are inherited from a base class in Python.

How to find all the subclasses of a class given its name?

There appears to be a new pragma named [`parent`][1] that does roughly the same thing as [`base`][2].  What does `parent` do that warrants a new (non-core) module?  I am missing something?


  [1]: http://search.cpan.org/dist/parent/lib/parent.pm
  [2]: http://perldoc.perl.org/base.html

What is the difference between parent and base in Perl 5?

Let&#39;s say that I have a class Suit and four subclasses of suit: Heart, Spade, Diamond, Club.

    class Suit:
       ...
    class Heart(Suit):
       ...
    class Spade(Suit):
       ...
    class Diamond(Suit):
       ...
    class Club(Suit):
       ...

I have a method which receives a suit as a parameter, which is a class object, not an instance. More precisely, it may receive only one of the four values: Heart, Spade, Diamond, Club. How can I make an assertion which ensures such a thing? Something like:

    def my_method(suit):
       assert(suit subclass of Suit)
       ...

I&#39;m using Python 3.


How do I check (at runtime) if one class is a subclass of another?

How does one go about and try to find all subclasses of a given class (or all implementors of a given interface) in Java?
As of now, I have a method to do this, but I find it quite inefficient (to say the least).
The method is: 

1. Get a list of all class names that exist on the class path
1. Load each class and test to see if it is a subclass or implementor of the desired class or interface

In Eclipse, there is a nice feature called the Type Hierarchy that manages to show this quite efficiently.
How does one go about and do it programmatically?

How do you find all subclasses of a given class in Java?

I would like to test whether a class inherits from another class, but there doesn&#39;t seem to exist a method for that.

    class A
    end
    
    class B &lt; A
    end
    
    B.is_a? A 
    =&gt; false

    B.superclass == A
    =&gt; true

A trivial implementation of what I want would be:

    class Class
      def is_subclass_of?(clazz)
        return true if superclass == clazz
        return false if self == Object
        superclass.is_subclass_of?(clazz)
      end
    end

but I would expect this to exist already.

Test whether a Ruby class is a subclass of another class

This came up in  [Hidden features of Python][1], but I can&#39;t see good documentation or examples that explain how the feature works.


  [1]: https://stackoverflow.com/questions/101268/hidden-features-of-python

How do you use the ellipsis slicing syntax in Python?

Why did the Python designers decide that subclasses&#39; `__init__()` methods don&#39;t automatically call the `__init__()` methods of their superclasses, as in some other languages? Is the Pythonic and recommended idiom really like the following?

    class Superclass(object):
        def __init__(self):
            print &#39;Do something&#39;

    class Subclass(Superclass):
        def __init__(self):
            super(Subclass, self).__init__()
            print &#39;Do something else&#39;

Why aren&#39;t superclass __init__ methods automatically invoked?

Is there a way to create an abstract class in the Swift Language, or is this a limitation just like Objective-C? I&#39;d like to create a abstract class comparable to what Java defines as an abstract class.

Abstract classes in Swift Language

How to I test if `a` is a subclass of `b`?

    Class&lt;?&gt; a = A.class;
    Class&lt;?&gt; b = B.class;



How to test if one java class extends another at runtime?

I want to allow type hinting using Python 3 to accept sub classes of a certain class. E.g.:

    class A:
        pass

    class B(A):
        pass

    class C(A):
        pass
    
    def process_any_subclass_type_of_A(cls: A):
        if cls == B:
            # do something
        elif cls == C:
            # do something else

Now when typing the following code:

    process_any_subclass_type_of_A(B)

I get an PyCharm IDE hint &#39;Expected type A, got Type[B] instead.&#39;

How can I change type hinting here to accept any subtypes of A?

According to [PEP 484][1] (&quot;Expressions whose type is a subtype of a specific argument type are also accepted for that argument.&quot;), I understand that my solution `(cls: A)` should work?


  [1]: https://www.python.org/dev/peps/pep-0484/#type-definition-syntax

Subclass in type hinting

I was thinking along the lines of using `typeid()` but I don&#39;t know how to ask if that type is a subclass of another class (which, by the way, is abstract)


How do I check if an object&#39;s type is a particular subclass in C++?

So say I have a subclass that extends a superclass. In what scenarios do I need to explicitly type `super()` to get the superclass constructor to run? 

I&#39;m looking at an example in a book about abstract classes and when they extend it with a non-abstract subclass, the subclass&#39;s default constructor is blank and there&#39;s a comment that says the superclass&#39;s default constructor will be called. At the same time I&#39;ve also seen instances on here where someone&#39;s problem was not explicitly calling `super()`. 

Is the distinction from calling the superclass&#39;s default/non-default constructor from the subclass&#39;s default/non-default constructor?

When do you need to explicitly call a superclass constructor?

Let&#39;s say I have a base class named `Entity`.  In that class, I have a static method to retrieve the class name:

    class Entity {
        public static String getClass() {
            return Entity.class.getClass();
        }
    }

Now I have another class extend that.

    class User extends Entity {
    }

I want to get the class name of User:

    System.out.println(User.getClass());

My goal is to see &quot;com.packagename.User&quot; output to the console, but instead I&#39;m going to end up with &quot;com.packagename.Entity&quot; since the Entity class is being referenced directly from the static method.

If this wasn&#39;t a static method, this could easily be solved by using the `this` keyword within the `Entity` class (i.e.: `return this.class.getClass()`).  However, I need this method to remain static.  Any suggestions on how to approach this?

Getting the name of a sub-class from within a super-class

I would like to add some rounded corners to all of the UIImageViews in my project. I have already got the code working, but am having to apply it to every image; should I subclass UIImageView to add this? If so, can someone give me some pointers as to how to do this?

Here is the code

    - (void)viewDidLoad {
        [super viewDidLoad];
    	NSString *mainpath = [[NSBundle mainBundle] bundlePath];
    	welcomeImageView.image = [UIImage imageWithContentsOfFile:[mainpath stringByAppendingString:@&quot;/test.png&quot;]];
    	welcomeImageView.layer.cornerRadius = 9.0;
    	welcomeImageView.layer.masksToBounds = YES;
    	welcomeImageView.layer.borderColor = [UIColor blackColor].CGColor;
    	welcomeImageView.layer.borderWidth = 3.0;
    	CGRect frame = welcomeImageView.frame;
    	frame.size.width = 100;
    	frame.size.height = 100;
    	welcomeImageView.frame = frame;
    }



Add rounded corners to all UIImageViews

In the [Python data model reference section on slots][1] there is a list of notes on using `__slots__`.  I am thoroughly confused by the 1st and 6th items, because they seem to be contradicting each other. 

**First item:**

 - When inheriting from a class without
   `__slots__`, the `__dict__` attribute
   of that class will always be
   accessible, so a `__slots__`
   definition in the subclass is
   meaningless.

**Sixth item:**

 - The action of a `__slots__`
   declaration is limited to the class
   where it is defined. As a result,
   subclasses will have a `__dict__`
   unless they also define `__slots__`
   (which must only contain names of any
   additional slots).

It seems to me these items could be better worded or shown through code, but I have been trying to wrap my head around this and am still coming up confused. I do understand how `__slots__` are [supposed to be used][2], and I am trying to get a better grasp on how they work.

**The Question:**

Can someone please explain to me in plain language what the conditions are for inheritance of slots when subclassing? 

(Simple code examples would be helpful but not necessary.)

  [1]: http://docs.python.org/reference/datamodel.html#slots
  [2]: https://stackoverflow.com/questions/472000/python-slots/472024#472024

How does inheritance of __slots__ in subclasses actually work?

In an android app test suite I have a class like this where `B` is a view:

    public class A extends B {
    ... etc...
    }

now I have a list of view objects which may contain `A` objects but in this case I only care if they&#39;re subclasses or &quot;instances of&quot; `B`. I&#39;d like to do something like:

    ArrayList&lt;View&gt; viewList = getViews();
    Iterator&lt;View&gt; iterator = viewList.iterator();
    while (iterator.hasNext() &amp;&amp; viewList != null) {
    	View view = iterator.next();
    	if (view.getClass().isInstance(B.class)) {
    		// this is an instance of B
    	}
    }

The problem is that when the `if` encounters an `A` object it doesn&#39;t evaluate to an &quot;instance of `B`&quot;. Is there a way to do `isSubclassOf` or something?


How to check if a subclass is an instance of a class at runtime?

To check if a type is a subclass of another type in C#, it&#39;s easy:

    typeof (SubClass).IsSubclassOf(typeof (BaseClass)); // returns true

However, this will fail:

    typeof (BaseClass).IsSubclassOf(typeof (BaseClass)); // returns false

Is there any way to check whether a type is either a subclass OR of the base class itself, without using an `OR` operator or using an extension method?

How do I check if a type is a subtype OR the type of an object?

I&#39;m interested in subclassing the built-in `int` type in Python (I&#39;m using v. 2.5), but having some trouble getting the initialization working.

Here&#39;s some example code, which should be fairly obvious.

    class TestClass(int):
        def __init__(self):
            int.__init__(self, 5)

However, when I try to use this I get:

    &gt;&gt;&gt; a = TestClass()
    &gt;&gt;&gt; a
    0

where I&#39;d expect the result to be `5`.

What am I doing wrong? Google, so far, hasn&#39;t been very helpful, but I&#39;m not really sure what I should be searching for

Subclassing int in Python

I have a class that is provided to me by an external library. I have created a subclass of this class. I also have an instance of the original class.

I now want to turn this instance into an instance of my subclass without changing any properties that the instance already has (except for those that my subclass overrides anyway).

The following solution seems to work.

    # This class comes from an external library. I don&#39;t (want) to control
    # it, and I want to be open to changes that get made to the class
    # by the library provider.
    class Programmer(object):
        def __init__(self,name):
            self._name = name
            
        def greet(self):
            print &quot;Hi, my name is %s.&quot; % self._name
            
        def hard_work(self):
            print &quot;The garbage collector will take care of everything.&quot;
            
    # This is my subclass.
    class C_Programmer(Programmer):
        def __init__(self, *args, **kwargs):
            super(C_Programmer,self).__init__(*args, **kwargs)
            self.learn_C()
            
        def learn_C(self):
            self._knowledge = [&quot;malloc&quot;,&quot;free&quot;,&quot;pointer arithmetic&quot;,&quot;curly braces&quot;]
            
        def hard_work(self):
            print &quot;I&#39;ll have to remember &quot; + &quot; and &quot;.join(self._knowledge) + &quot;.&quot;
    
        # The questionable thing: Reclassing a programmer.
        @classmethod
        def teach_C(cls, programmer):
            programmer.__class__ = cls # &lt;-- do I really want to do this?
            programmer.learn_C()
    
    
    joel = C_Programmer(&quot;Joel&quot;)
    joel.greet()
    joel.hard_work()
    #&gt;Hi, my name is Joel.
    #&gt;I&#39;ll have to remember malloc and free and pointer arithmetic and curly braces.
    
    jeff = Programmer(&quot;Jeff&quot;)
    
    # We (or someone else) makes changes to the instance. The reclassing shouldn&#39;t
    # overwrite these.
    jeff._name = &quot;Jeff A&quot; 
    
    jeff.greet()
    jeff.hard_work()
    #&gt;Hi, my name is Jeff A.
    #&gt;The garbage collector will take care of everything.
    
    # Let magic happen.
    C_Programmer.teach_C(jeff)
    
    jeff.greet()
    jeff.hard_work()
    #&gt;Hi, my name is Jeff A.
    #&gt;I&#39;ll have to remember malloc and free and pointer arithmetic and curly braces.

However, I&#39;m not convinced that this solution doesn&#39;t contain any caveats I haven&#39;t thought of (sorry for the triple negation), especially because reassigning the magical `__class__` just doesn&#39;t feel right. Even if this works, I can&#39;t help the feeling there should be a more pythonic way of doing this.

Is there?

----------

Edit: Thanks everyone for your answers. Here is what I get from them:

* Although the idea of reclassing an instance by assigning to `__class__` is not a widely used idiom, most answers (4 out of 6 at the time of writing) consider it a valid approach. One anwswer (by ojrac) says that it&#39;s &quot;pretty weird at first glance,&quot; with which I agree (it was the reason for asking the question). Only one answer (by Jason Baker; with two positive comments &amp; votes) actively discouraged me from doing this, however doing so based on the example use case moreso than on the technique in general.

* None of the answers, whether positive or not, finds an actual technical problem in this method. A small exception is jls who mentions to beware of old-style classes, which is likely true, and C extensions. I suppose that new-style-class-aware C extensions should be as fine with this method as Python itself (presuming the latter is true), although if you disagree, keep the answers coming.

As to the question of how pythonic this is, there were a few positive answers, but no real reasons given. Looking at the Zen (`import this`), I guess the most important rule in this case is &quot;Explicit is better than implicit.&quot; I&#39;m not sure, though, whether that rule speaks for or against reclassing this way.

* Using `{has,get,set}attr` seems more explicit, as we are explicitly making our changes to the object instead of using magic.

* Using `__class__ = newclass` seems more explicit because we explicitly say &quot;This is now an object of class &#39;newclass,&#39; expect a different behaviour&quot; instead of silently changing attributes but leaving users of the object believing they are dealing with a regular object of the old class.

Summing up: From a technical standpoint, the method seems okay; the pythonicity question remains unanswered with a bias towards &quot;yes.&quot; 

I have accepted Martin Geisler&#39;s answer, because the Mercurial plugin example is a quite strong one (and also because it answered a question I even hadn&#39;t asked myself yet). However, if there are any arguments on the pythonicity question, I&#39;d still like to hear them. Thanks all so far.

P.S. The actual use case is a UI data control object that needs to grow additional functionality *at runtime*. However, the question is meant to be very general.


All Subclass Solutions on Gang of Coders

Total of 24 Subclass Solutions

Subclassing tuple with multiple init arguments

Why doesn't a using-declaration work to solve the diamond problem?