前言:
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 类。