前言:

Python在2.2和3.0之間，把繼承了object的類叫做新式類，如果我們定義了一個類，他沒有繼承object，則不是新式類，則沒有__class__,__bases__等屬性，而用type()函數查看他的類型，不是type類，而是classobj類。在py3後，默認所有的類都繼承object. 我們接下來討論的，是新式類

1 對象就是實例，實例就是對象

2.查看對象屬於哪個類，用它的__class__屬性查看，或者用內置函數type()

3.查看類的父類是什麽，用它的__bases__屬性查看

2.a = ‘sss‘,那麽a是str類的實例，或者說對象，python一切皆對象，那麽str類也是一個對象，只是他不是普通的像a一樣的對象，而是類對象。那麽他又是哪個類的實例呢？回答：他是type類的實例。而type類又是屬於哪個類的實例那？答案是，他是他自己的實例。

>>> a = ‘sss‘
>>> type(a)
<type ‘str‘>
>>> type(str)
<type ‘type‘>
>>> str.__class__
<type ‘type‘>
>>> type(type)
<type ‘type‘>

我們把type類稱之為元類（MetaClass），即類的類。他是所有類的類，包括他自己。

5。str類的父類是basestring,basestring的父類是object，object的父類是什麽？答案是沒有。object是除他自己的一切類的最終父類（包括type類）。

新式類，經典類

以下轉載自http://www.cnblogs.com/limuyuan/p/why-python-extend-object-class.html

自學Learn Python The Hard Way看到了這個問題，樓上各位回答講真我是看的一頭霧水。。

然後去stackoverflow搜索了一下，結合官方文檔，說一下我自己的理解：

2 PEPs 252 and 253: Type and Class Changes

First, you should know that Python 2.2 really has two kinds of classes: classic or old-style classes, and new-style classes. The old-style class model is exactly the same as the class model in earlier versions of Python. All the new features described in this section apply only to new-style classes. This divergence isn‘t intended to last forever; eventually old-style classes will be dropped, possibly in Python 3.0.
So how do you define a new-style class? You do it by subclassing an existing new-style class. Most of Python‘s built-in types, such as integers, lists, dictionaries, and even files, are new-style classes now. A new-style class named object, the base class for all built-in types, has also been added so if no built-in type is suitable, you can just subclass object:

其實這裏已經說得很清楚，Python 2.2有兩種類：舊式類、新式類。舊式類是什麽樣的暫時不用管，只要記住，以後都用並且只用新式類，就對了。

那麽怎麽來聲明或定義(define)一個新式類呢？做法就是，從現有的新式類中創建子類。

大多數的Python的內建類型(built-in type)，比如整型(integers)，列表(lists)，字典(dictionaries)，甚至文件(files)，現在都是新式類了。我們也添加了一個叫object的新式類，作為所有內建類型的基類(base class)，所以如果沒有適合的內建類型，從object創建子類就好了：

class C(object):
    def __init__ (self):
        ...
    ...

所以現在明白了嗎？object只是從Python 2.2開始被引入的一個新式類(new-style class)，作用是所有內建類型(built-in types)的基類(base class)

以下引用知乎：

在 Python 2.7 裏面新式類和經典類在多繼承方面會有差異：

class A:
    def foo(self):
        print(‘called A.foo()‘)

class B(A):
    pass

class C(A):
    def foo(self):
        print(‘called C.foo()‘)

class D(B, C): 
    pass

if __name__ == ‘__main__‘:
    d = D() 
    d.foo()

B、C 是 A 的子類，D 多繼承了 B、C 兩個類，其中 C 重寫了 A 中的 foo() 方法。

如果 A 是經典類（如上代碼），當調用 D 的實例的 foo() 方法時，Python 會按照深度優先的方法去搜索 foo() ，路徑是 B-A-C ，執行的是 A 中的 foo() ；

如果 A 是新式類，當調用 D 的實例的 foo() 方法時，Python 會按照廣度優先的方法去搜索 foo() ，路徑是 B-C-A ，執行的是 C 中的 foo() 。

因為 D 是直接繼承 C 的，從邏輯上說，執行 C 中的 foo() 更加合理，因此新式類對多繼承的處理更為合乎邏輯。

在 Python 3.x 中 所有類都是新式類， D 實例中的 foo() 都會執行 C 中的 foo() 。但是在 Python 2.7 中這種差異仍然存在，因此還是推薦使用新式類，要繼承 object 類。

Python2的object和type