前言:
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)
以下引用知乎：
链接：https://www.zhihu.com/question/19754936/answer/202650790
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
在 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 类。