精华内容
下载资源
问答
  • python的新式类是2.2版本引进来的,我们可以将之前的叫做经典或者旧式类。 为什么要在2.2中引进new style class呢?官方给的解释是: 为了统一(class)类型(type)。 在2.2之前,比如2.1版本中,类和类型是...
  • 从定义形式上看,新式类和旧式类的区别:新式类在创建时继承了内置的object对象,而旧式类没有。 # 旧式类 class a: pass # 旧式类 class a1(): pass # 新式类 class a2(object): pass print dir(a) print.....

    1.介绍

      Python2.1之前,只存在旧式类,从Python2.2开始,Python引入了新式类。

    从定义形式上看,新式类和旧式类的区别:新式类在创建时继承了内置的object对象,而旧式类没有。

    # 旧式类
    class a:
    	pass
    	
    # 旧式类
    class a1():
    	pass
    	
    # 新式类
    class a2(object):
    	pass
    
    print dir(a)
    print dir(a1)
    print dir(a2)
    

    结果:

    [’__doc__’, ‘__module__’]
    [’__doc__’, ‘__module__’]
    [’__class__’, ‘__delattr__’, ‘__dict__’, ‘__doc__’, ‘__format__’, ‘__getattribute__’, ‘__hash__’, ‘__init__’, ‘__module__’, ‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’, ‘__weakref__’]

    从结果中可以看出,旧式类只有两个方法,而新式类则从object继承了很多的属性和方法。

    • Python2中默认都是经典类,只有显式的继承了object才是新式类
    • Python3中将经典类移除,默认都是新式类,不必显式的继承object类

    2.区别

    2.1 类实例类型的区别
    • 在旧式类中class和type是不同的概念,例如x是一个类A的实例,则x.__class__的输出指向的是类A,而type(x)的输出是<type ‘instance’>.
    • 在新式类中,class和type是统一的概念,x.__class__和type(x)指向的都是类A

    例子:

    # 旧式类
    class a:
        pass
    
    # 旧式类
    class a1():
        pass
    
    
    x = a()
    print type(x)
    print x.__class__
    print '\n'
    
    x1 = a1()
    print type(x1)
    print x1.__class__
    print '\n'
    
    # 新式类
    class b(object):
        pass
    
    
    y = b()
    print type(y)
    print y.__class__
    print '\n'
    
    # 旧式类
    class c(a):
        pass
    
    
    z = c()
    print type(z)
    print z.__class__
    print '\n'
    
    # 新式类
    class d(b):
        pass
    
    
    w = d()
    print type(w)
    print w.__class__
    print '\n'
    

    结果:

    <type ‘instance’>
    __main__.a


    <type ‘instance’>
    __main__.a1


    <class ‘__main__.b’>
    <class ‘__main__.b’>


    <type ‘instance’>
    __main__.c


    <class ‘__main__.d’>
    <class ‘__main__.d’>

    2.2 继承顺序的区别
    • 旧式类的多继承属性搜索顺序:继承树上从左到右,深度优先的搜索方式
    • 新式类多继承属性搜索顺序:从左到右,广度优先的方式

    例子:

    # 新式类
    class A(object):
        def foo(self):
            print "class A"
    
    
    # 旧式类
    class A1():
        def foo(self):
            print "class A1"
    
    
    # 继承自新式类
    class C(A):
        pass
    
    
    # 继承自旧式类
    class C1(A1):
        pass
    
    
    # 继承自新式类
    class D(A):
        def foo(self):
            print "class D"
    
    
    # 继承自旧式类
    class D1(A1):
        def foo(self):
            print "class D1"
    
    
    class E(C, D):
        pass
    
    
    class E1(C1, D1):
        pass
    
    
    e = E()
    e.foo()
    
    e1 = E1()
    e1.foo()
    

    结果:

    class D
    class A1

    对于新式类的继承树而言,寻找foo方法的顺序是:E–>C–>D–>A,所以输出的是class D;对于旧式类的继承树而言,寻找foo方法的顺序是:E1–>C1–>A1–>D1,所以,输出的是class A1.

    2.3 新式类增加了__slots__属性

      通常每一个实例x都会有一个__dict__属性,用来记录实例中所有的属性和方法,也是通过这个字典,可以让实例绑定任意的属性。

      而__slots__属性作用就是,当类C有比较少的变量,而且拥有__slots__属性时,类C的实例就没有__dict__属性,而是把变量的值存在一个固定的地方。如果试图访问一个__slots__中没有的属性,实例就会报错。

    这样操作有什么好处呢?
    好处: __slots__属性虽然令实例失去了绑定任意属性的便利,但是因为每一个实例没有__dict__属性,却能有效节省每一个实例的内存消耗,有利于生成小而精干的实例。

    定义__slots__属性:
    __slots__是一个类变量,slots__属性可以赋值一个包含类属性名的字符串元组,或者是可迭代变量,或者是一个字符串,只要在类定义的时候,使用__slots=a Tuple来定义该属性就可以了:

    import time
    
    
    class A1(object):
        def __init__(self):
            self.x = 1
            self.y = 2
    
    
    a1 = A1()
    print dir(a1)
    a1.z = 3
    print a1.x, a1.y, a1.z
    time.sleep(1)
    
    
    class A(object):
        def __init__(self):
            self.x = 1
            self.y = 2
        __slots__ = 'x', 'y'
    
    
    a = A()
    print dir(a)
    time.sleep(1)
    a.z = 3
    

    结果:

    [‘doc’, ‘init’, ‘module’, ‘x’, ‘y’]
    1 2 3
    [‘class’, ‘delattr’, ‘doc’, ‘format’, ‘getattribute’, ‘hash’, ‘init’, ‘module’, ‘new’, ‘reduce’, ‘reduce_ex’, ‘repr’, ‘setattr’, ‘sizeof’, ‘slots’, ‘str’, ‘subclasshook’, ‘x’, ‘y’]
    Traceback (most recent call last):
    File “/home/maqian/network_pruning/mixed_pruning/hashed_nets-master/ttttt.py”, line 35, in
    a.z = 3
    AttributeError: ‘A’ object has no attribute ‘z’

    可以看出,当新式类定义__slots__后,实例中就没有了__dict__属性,且不能再随意的绑定任意属性了。

    另外:
    使用时__slots__时需要注意的几点:

    1. 当一个类的父类没有定义__slots__属性,父类中的__dict__属性总是可以访问到的,所以只在子类中定义__slots__属性,而不在父类中定义是没有意义的。
    2. 如果定义了__slots__属性,还是想在之后添加新的变量,就需要把’__dict__'字符串添加到__slots__的元组里。
    3. 定义了__slots__属性,还会消失的一个属性是__weakref__,这样就不支持实例的weak reference,如果还是想用这个功能,同样,可以把’__weakref__'字符串添加到元组里。
    4. __slots__功能是通过descriptor实现的,会为每一个变量创建一个descriptor。
    5. __slots__的功能只影响定义它的类,因此,子类需要重新定义__slots__才能有它的功能。
    2.4 新式类新增了__getattribute__方法

    对新式类的实例来说,所有属性和方法的访问操作都是通过__getattribute__完成,这是由object基类实现的。如果有特殊的要求,可以重载__getattribute__方法,下面实现一个不能使用append方法的list:

    import time
    
    
    class ListNoAppend(list):
        def __getattribute__(self, name):
            if name == 'append':
                raise AttributeError, name
            return list.__getattribute__(self, name)
    
    
    a = ListNoAppend()
    print type(a)
    print dir(a)
    a.extend([2, 3, 4, 5])
    print a
    print a.index(4)
    time.sleep(1)
    a.append(6)
    
    
    

    结果:

    <class ‘main.ListNoAppend’>
    [‘add’, ‘class’, ‘contains’, ‘delattr’, ‘delitem’, ‘delslice’, ‘dict’, ‘doc’, ‘eq’, ‘format’, ‘ge’, ‘getattribute’, ‘getitem’, ‘getslice’, ‘gt’, ‘hash’, ‘iadd’, ‘imul’, ‘init’, ‘iter’, ‘le’, ‘len’, ‘lt’, ‘module’, ‘mul’, ‘ne’, ‘new’, ‘reduce’, ‘reduce_ex’, ‘repr’, ‘reversed’, ‘rmul’, ‘setattr’, ‘setitem’, ‘setslice’, ‘sizeof’, ‘str’, ‘subclasshook’, ‘weakref’, ‘append’, ‘count’, ‘extend’, ‘index’, ‘insert’, ‘pop’, ‘remove’, ‘reverse’, ‘sort’]
    [2, 3, 4, 5]
    2
    Traceback (most recent call last):
    File “/home/maqian/network_pruning/mixed_pruning/hashed_nets-master/ttttt.py”, line 26, in
    a.append(6)
    File “/home/maqian/network_pruning/mixed_pruning/hashed_nets-master/ttttt.py”, line 15, in getattribute
    raise AttributeError, name
    AttributeError: append

    2.5 实例的方法

    相同: 旧式类和新式类的对象模型都允许一个实例拥有私有的属性和方法(可以通过绑定和重绑定),实例的私有属性会覆盖掉类中定义的同名属性。
    例子:

    class oldClass:
        def getItem(self, index):
            return index
    
    
    def fakeGetItem(index):
        return index + 1
    
    
    old = oldClass()
    old.getItem = fakeGetItem
    print old.getItem(1)
    
    
    class newClass(object):
        def getItem(self, index):
            return index
    
    
    new = newClass()
    new.getItem = fakeGetItem
    print new.getItem(2)
    

    结果:

    2
    3

    **不同:**然而在python中,隐式调用实例的私有特殊方法时,心事咧的对象模型和旧式类的对象模型表现上不太一样。

    • 在旧式类的对象模型中,无论是显示调用还是隐式调用特殊方法,都会调用实例中后绑定的特殊方法。
    • 而在新式类的对象模型中,除非显式地调用实例的特殊方法,否则python总是会去调用类中定义的特殊方法,如果没有定义的话,就报错。代码如下:

    例子:

    # 旧式类
    class oldClass:
        pass
    
    
    def fakeGetItem(index):
        return index*index
    
    
    old = oldClass()
    old.__getitem__ = fakeGetItem
    print old[3]
    
    
    # 新式类
    class newClass(object):
        pass
    
    
    new = newClass()
    new.__getitem__ = fakeGetItem
    print new.__getitem__(2)
    print new[4]
    

    结果:

    9
    4
    Traceback (most recent call last):
    File “/home/maqian/network_pruning/mixed_pruning/hashed_nets-master/ttttt.py”, line 33, in
    print new[4]
    TypeError: ‘newClass’ object does not support indexing

    调用old[3],将产生一个隐式的__getitem__方法的调用,在新式类中,因为类中没有定义这个方法,也不是object基类有的方法,所以报错。需要显示地调用才可以运行。

    参考:

    1.https://blog.csdn.net/u010066807/article/details/46896835
    2.https://stackoverflow.com/questions/54867/what-is-the-difference-between-old-style-and-new-style-classes-in-python
    3.https://www.cnblogs.com/btchenguang/archive/2012/09/17/2689146.html

    展开全文
  • 答:Python中分两种:旧式类和新式类 。python的新式类是从2.2版本引进来的,可以将之前的叫做经典或者旧式类新式类是官方为了统一类和实例引入的 。在2.2之前,比如2.1版本中,类和类型是不同的,如a是...


    公众号新增加了一个栏目,就是每天给大家解答一道Python常见的面试题,反正每天不贪多,一天一题,正好合适,只希望这个面试栏目,给那些正在准备面试的同学,提供一点点帮助!

    小猿会从最基础的面试题开始,每天一题。如果参考答案不够好,或者有错误的话,麻烦大家可以在留言区给出自己的意见和讨论,大家是要一起学习的 。

    废话不多说,开始今天的题目:

    问:说说Python新式类和旧式类的区别?

    答:Python中类分两种:旧式类和新式类 。python的新式类是从2.2版本引进来的,可以将之前的类叫做经典类或者旧式类。

    新式类是官方为了统一类和实例引入的 。在2.2之前,比如2.1版本中,类和类型是不同的,如a是ClassA的一个实例,那么a.__class__返回 ‘ class    __main__.ClassA‘ ,type(a)返回总是<type 'instance'>。而引入新类后,比如ClassB是个新类,b是ClassB的实例,b.__class__和type(b)都是返回‘class '__main__.ClassB' ,这样就统一了。

    说说新式类和旧式类的区别?

    1、新式类都从object继承,经典类不需要。

    2、新式类的MRO(method resolution order 基类搜索顺序)算法采用C3算法广度优先搜索,而旧式类的MRO算法是采用深度优先搜索

    3、新式类相同父类只执行一次构造函数,经典类重复执行多次。

    说说Python2和Python3中的区别?

    在Python 3.x中取消了经典类,默认都是新式类,并且不必显式的继承object:
    class Person(object):pass
    class Person():pass
    class Person:pass
    三种写法并无区别,推荐第一种
    
    但是在Python2.x中,默认都是经典类,只有显式继承了object才是新式类,即:
    class Person(object):pass 新式类写法
    class Person():pass 经典类写法
    class Person:pass 经典类写法
    


    为了确保在Python2.x中使用的是新式类,有两种以下方法:

    1. 元类,在类模块代码的最前面加入如下代码 __metaclass__ = classname(自定义的某个新式类)。

    2. 类都从内建类object直接或者间接地继承。

    在Python3里面,不存在这些问题了,默认都是新式类了。

    如果对于参考答案有不认同的,大家可以在评论区指出和补充,欢迎留言!

    1-50、Python面试1-50题汇总

    51、说说Python中闭包是什么?

    52、read、readline和readlines的区别?

    53、说说Python中with的用法?

    54、Python中连接字符串用join还是+?

    55、Python中search和match的区别?

    56、说说Python中字符串大小写转换?

    57、Python反转三位整数有几种方法?

    58、说说Python中贪婪和非贪婪匹配?

    59、说说Python中正负索引?

    60、说说Python中切片是什么?

    关注小猿公众号,每天学习一道题

    展开全文
  • python旧式类和新式类

    2019-05-05 14:08:48
    python2有经典类和新式类并存,...有无object是判断旧式类和新式类的最大区别,新式类继承了object新式类的MRO(method resolution order基类搜索顺序)算法采用C3算法广度优先搜索,而旧式类的MRO算法是采...

    python2有经典类和新式类并存,具体写法分为:

    class A(object):新式类

    class A():旧式类

    class A:旧式类

    python3默认是新式类

    有无object是判断旧式类和新式类的最大区别,新式类继承了object类。

     

    新式类的MRO(method resolution order 基类搜索顺序)算法采用C3算法广度优先搜索,而旧式类的MRO算法是采用深度优先搜索。

    在python2和python3定义类,测试他的类型时是这样:

    #Python2
    
    class A:
    
        pass
    
    print(type(A))
    
    output:
    <type 'classobj'>
    
    
    
    #Python3
    
    class A(object):
    
        pass
    
    print(type(A))
    
    output:
    
    <type 'type'>

     

    另外旧式类的深度优先示例:

    class A():
    
        def foo1(self):
    
              print("A")
    
    class B(A):
    
        def foo2(self):
              pass
    
    class C(A):
         def foo1(self):
    
              print("C")
    
    class D(B, C):
    
        pass
    
    d =D()
    
    d.foo1()
    
    output:
    
    A

    按照经典类的查找顺序从左到右深度优先的规则,在访问d.foo1()的时候,D这个类是没有的..那么往上查找,先找到B,里面没有,深度优先,访问A,找到了foo1(),所以这时候调用的是A的foo1(),从而导致C重写的foo1()被绕过

     

    新式类是广度优先

    class A(object):
    
        def foo1(self):
    
              print("A")
    
    class B(object):
    
        def foo2(self):
    
              pass
    
    class C(object):     #或者是class C(A):只要A是新式类的定义,那么继承类都是新式类
    
        def foo1(self):
    
              print("C")
    
    class D(B, C):
    
        pass
    
    d = D()
    
    d.foo1()
    
    output:
    
    C

    新式类和旧式类的不同还包括:

    #举例
    class A(object):
        pass
    
    class B():
        pass
    
    print(dir(A))
    print(dir(B))
    #查看旧式类和新式类都有哪些魔术方法
    
    output:
    新式类有:
    ['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
    旧式类有:
    ['__doc__', '__module__']

    对于各种魔术方法的意义,附上参考链接:

    https://blog.csdn.net/NightCharm/article/details/79357559

    展开全文
  • 新式类和旧式类

    2018-07-09 16:50:51
    首先来了解一下新式类与经典的区别,从创建方法上可以明显的看出:#新式类class C(object): ...使用dir()方法也可以看出新式类中定义很多新的属性方法,而经典好像就2个: 这些新的属性方法都是从object...
    首先来了解一下新式类与经典类的区别,从创建方法上可以明显的看出:
    #新式类
    class C(object) :
         pass
    #经典类
    class B :
         pass
    简单的说,新式类是在创建的时候继承内置object对象(或者是从内置类型,如list,dict等),而经典类是直
    接声明的。使用dir()方法也可以看出新式类中定义很多新的属性和方法,而经典类好像就2个:
     

    这些新的属性和方法都是从object对象中继承过来的。



    一个旧式类的深度优先的例子

    class A():
        def foo1(self):
            print "A"
    class B(A):
        def foo2(self):
            pass
    class C(A):
        def foo1(self):
            print "C"
    class D(B, C):
        pass
    
    d = D()
    d.foo1()
    
    # A

    按照经典类的查找顺序从左到右深度优先的规则,在访问d.foo1()的时候,D这个类是没有的..那么往上查找,先找到B,里面没有,深度优先,访问A,找到了foo1(),所以这时候调用的是A的foo1(),从而导致C重写的foo1()被绕过


    展开全文
  • 新式类和旧式类的区别 很多文章中都提到新式类和旧式类这两个字眼,处于好奇,查了一下。 旧式类:在早期的Python版本中,程序员在定义的时候必须要指明继承了object,不会默认继承object,这些没有继承...
  • Python新式类和旧式类的区别

    万次阅读 2013-03-06 22:08:01
    新式类是为了统一**而在2.2中开始引入的。 我使用的是2.6。 上面的例子比较明白的说明了...另外,新式类和旧式类还有一个区别就是再多继承的时候,查找要调用的方法。 新式类是广度优先的查找算法。 旧式类的查
  • 新式类和旧式(经典):object是Python为所有对象提供的基类,提供有一些内置的属性方法,可以使用dir函数查看新式类:以object为基类的,推荐使用经典:不以object为基类的,不推荐使用 在python3.X中定义...
  • Python新式类与经典(旧式类)的区别

    万次阅读 2016-11-06 12:15:03
    Python中分两种:旧式类和新式类: ➤新式类都从object继承,经典不需要。 ➤新式类的MRO(method resolution order 基类搜索顺序)算法采用C3算法广度优先搜索,而旧式类的MRO算法是采用深度优先搜索 ➤新式类...
  • python 新式类和旧式类; Python新式类和经典的区别; python新式类和经典的区别?
  • Python中分两种:旧式类和新式类: ➤新式类都从object继承,经典不需要。 ➤新式类的MRO(method resolution order 基类搜索顺序)算法采用C3算法广度优先搜索,而旧式类的MRO算法是采用深度优先搜索 ➤新式类...
  • object 是python 为所有对象提供的基类, 提供有一些内置的属性方法,可以使用dir函数查看 python 2.x 中定义时,如果没有指定, 则不会以object作为基类class 类名(object): passprint(dir(A())) ['__doc__',...
  • 概述: Python中支持多继承,也就是一个子类...尤其是当众多父类中都包含有同名的属性,这就涉及到新式类 经典的区别。 多继承: class Food(object): 2 3 def __init__(self, name, color): 4 self.na...
  • 新式类很早在2.2就出现了,所以旧式类完全是兼容的问题,Python3里的全部都是新式类.这里有一个MRO问题可以了解下(新式类继承是根据C3算法,旧式类是深度优先),<Python核心编程>里讲的也很多. 一个旧式类的深度...
  • python 新式类和旧式类

    2017-02-14 14:37:59
    python的新式类是2.2版本引进来的,我们可以将之前的叫做经典或者旧。  为什么要在2.2中引进new style class呢?官方给的解释是:  为了统一(class)类型(type)。  在2.2之前,比如2.1版本中,类和...
  • 这里要涉及一个名词:MRO(基类...python2默认,显示继承object就是新式类,否则就是经典,MRO采用深度优先搜索。 至于优先级搜索可以参考本篇博客的例子进行理解:https://blog.csdn.net/mrlevo520/article/deta...
  • python 新式类 旧式类区别
  • Python2.x中,默认都是经典,只有显式继承了object的才是新式类,即: class Person(object):pass 新式类 class Person():pass 经典 在Python 3.x中取消了经典,默认都是新式类,并且不必显式的继承object,...
  • 这里有个重要概念呢在下面那个链接 http://blog.csdn.net/zimou5581/article/details/53053775 ... 1、新式类都从object继承,经典不需要。 2、新式类的MRO(method ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,587
精华内容 1,834
关键字:

新式类和旧式类