精华内容
下载资源
问答
  • python的类方法(@classmethod)

    千次阅读 多人点赞 2019-09-11 19:01:49
    python做面向对象编程时候,经常需要使用classmethod的描述。方法特别容易弄混淆,因为听起来就好像“的方法”一样。 方法也算一种实用的技巧,简单描述之:“方法让模板具有记忆力”。 模板就是...

    python做面向对象编程时候,经常需要使用classmethod的描述。类方法特别容易弄混淆,因为听起来就好像“类中的方法”一样。

    类方法也算一种实用的技巧,简单描述之:“类方法让类模板具有记忆力”。

    类模板就是我们所定义的类。在普通情况下,不使用类方法对类进行实例化,类本身是不具有记忆性的只是当一个静态模板被套用多次而已。如果我们想让类在每一次实例化之后,都能记载一些记忆,是否会对很多操作很有用?

    我们来看一个栗子:

    class Man:
        id = 0 # 类变量
        def __init__(self, name):
            self.name = name
            self.id = self.id_number()
    
        @classmethod
        def id_number(cls):
            cls.id += 1
            return cls.id
    
    a = Man('A')
    print(a.id)
    b = Man('B')
    print(b.id)

    上面的输出为:

    1
    2

    我对Man这个类进行实例化2次,每个实例的id都不一样。这就依靠类方法来实现了:首先,用@classmethod描述类方法,然后用"cls"代表本类类方法对类属性进行的处理是有记忆性的

    需要注意的是,类方法处理的变量一定要是类变量。因为在类方法里你用不了self来寻址实例变量,所以需要把类变量放到最前面描述,如上面的"id=0"所示。类变量是可以被self访问的,所以,在类变量定义好了以后,不需要在_init_函数里对类变量再一次描述。所以,上面代码里self.id不一定需要。

    对于研究深度学习的朋友,可以有效利用这个trick,来进行模型的加载。比如,把模型封装成一个类,把初始化网络和加载模型用类方法来描述,这样一次load之后,可以一直实用模型。

    展开全文
  • Python类的专用方法

    2019-09-29 13:31:46
    Python 可以定义专用方法,专用方法是在特殊情况下或当使用特别语法时由 Python 替你调用的,而不是在代码中直接调用(象普通的方法那样)。.1 __init__类似于构造函数#!/usr/local/bin/pythonclass Study: def __...

    Python 类可以定义专用方法,专用方法是在特殊情况下或当使用特别语法时由 Python 替你调用的,而不是在代码中直接调用(象普通的方法那样)。
    .1    __init__
    类似于构造函数
    #!/usr/local/bin/python
    class Study:
            def __init__(self,name=None):
                    self.name = name
            def say(self):
                    print self.name
    study = Study("Badboy")
    study.say()
    .2    __del__
    类似于析构函数
    #!/usr/local/bin/python
    class Study:
            def __init__(self,name=None):
                    self.name = name
            def __del__(self):
                    print "Iamaway,baby!"
            def say(self):
                    print self.name
    study = Study("zhuzhengjun")
    study.say()
    .3__repr__
    使用repr(obj)的时候,会自动调用__repr__函数,该函数返回对象字符串表达式,
    用于重建对象,如果eval_r(repr(obj))会得到一个对象的拷贝。
    #!/usr/local/bin/python
    class Study:
            def __init__(self,name=None):
                    self.name = name
            def __del__(self):
                    print "Iamaway,baby!"
            def say(self):
                    print self.name
            def __repr__(self):
                    return "Study('jacky')"
    study = Study("zhuzhengjun")
    study.say()
    print type(repr(Study("zhuzhengjun"))) # str
    print type(eval_r(repr(Study("zhuzhengjun")))) # instance
    study = eval_r(repr(Study("zhuzhengjun")))
    study.say()
    .4__str__
    Python能用print语句输出内建数据类型。有时,程序员希望定义一个类,要求它的对象也能用print语句输出。Python类可定义特殊方法__str__,为类的对象提供一个不正式的字符串表示。如果类的客户程序包含以下语句:
    print objectOfClass
    那么Python会调用对象的__str__方法,并输出那个方法所返回的字符串。
    #!/usr/local/bin/python
    class PhoneNumber:
            def __init__(self,number):
                     self.areaCode=number[1:4]
                     self.exchange=number[6:9]
                     self.line=number[10:14]
            def __str__(self):
                    return "(%s) %s-%s"%(self.areaCode,self.exchange,self.line)
    def test():
             newNumber=raw_input("Enter phone number in the form. (123) 456-7890: \n")
             phone=PhoneNumber(newNumber)
             print "The phone number is:"
             print phone
    if__name__=="__main__":
             test()
    方法__init__接收一个形如"(xxx) xxx-xxxx"的字符串。字符串中的每个x都是电话号码的一个位数。方法对字符串进行分解,并将电话号码的不同部分作为属性存储。
    方法__str__是一个特殊方法,它构造并返回PhoneNumber类的一个对象的字符串表示。解析器一旦遇到如下语句:
    print phone
    就会执行以下语句:
    print phone.__str__()
    程序如果将PhoneNumber对象传给内建函数str(如str(phone)),或者为PhoneNumber对象使用字符串格式化运算符%(例如"%s"%phone),Python也会调用__str__方法。
    .5__cmp __
    比较运算符,0:等于 1:大于 -1:小于
    class Study: 
         def __cmp__(self, other): 
             if other > 0 : 
                 return 1 
             elif other < 0: 
                 return - 1 
             else: 
                 return 0 
    study = Study() 
    if study > -10:print 'ok1' 
    if study < -10:print 'ok2' 
    if study == 0:print 'ok3'
    打印:ok2 ok3
    说明:在对类进行比较时,python自动调用__cmp__方法,如-10 < 0 返回 -1,也就是说study 应该小与 -10,估打印ok2
    .6__getitem__
    __getitem__ 专用方法很简单。象普通的方法 clear,keys 和 values 一样,它只是重定向到字典,返回字典的值。
    class Zoo: 
         def __getitem__(self, key): 
             if key == 'dog':return 'dog' 
             elif key == 'pig':return  'pig' 
             elif key == 'wolf':return 'wolf' 
             else:return 'unknown' 
    zoo = Zoo() 
    print zoo['dog'] 
    print zoo['pig'] 
    print zoo['wolf']
    打印 dog pig wolf
    .7__setitem__
    __setitem__ 简单地重定向到真正的字典 self.data ,让它来进行工作。 
    class Zoo: 
         def __setitem__(self, key, value): 
             print 'key=%s,value=%s' % (key, value) 
    zoo = Zoo() 
    zoo['a'] = 'a' 
    zoo['b'] = 'b' 
    zoo['c'] = 'c'
    打印:
    key=a,value=a
    key=b,value=b
    key=c,value=c
    .8 __delitem__
    __delitem__ 在调用 del instance[key] 时调用 ,你可能记得它作为从字典中删除单个元素的方法。当你在类实例中使用 del 时,Python 替你调用 __delitem__ 专用方法。
    class A: 
         def __delitem__(self, key): 
             print 'delete item:%s' %key 
    a = A() 
    del a['key']

    转载于:https://www.cnblogs.com/ToddZhou/p/5230522.html

    展开全文
  • Python 可以定义专用方法,专用方法是在特殊情况下或当使用特别语法时由 Python 替你调用的,而不是在代码中直接调用(象普通的方法那样)。 1. __init__ 类似于构造函数 复制代码 代码如下:#!/usr/local/bin/...
  • python类魔方方法

    2020-12-20 20:18:53
    python中有些方法名比较特别,在名称的前后各有两个下划线,这样的方法往往具有特殊的意义,一般情况下我们不会直接用到所以称之为“隐藏方法”也有一些人称之为“魔法方法”。下面划分这些隐藏方法,分类解析。 ...

    在python中有些方法名比较特别,在名称的前后各有两个下划线,这样的方法往往具有特殊的意义,一般情况下我们不会直接用到所以称之为“隐藏方法”也有一些人称之为“魔法方法”。下面划分这些隐藏方法,分类解析。

    模块属性

    1. __ name__
      当python文件被直接运行时,__ name__的值为__main__,而当python文件以模块的形式被导入时,__name__的值为模块名
    2. __ file__
      在python模块中使用__file__来获取脚本所在的路径,但得到的是相对路径,若希望得到绝对路径可使用
    os.path.realpath(__file__)
    
    1. __ all__
      __all__指定的是当包被import * 的时候, 哪些模块会被import进来(不建议使用import *的方式)
      eg.
    #test1.py
    import os, sys
    __all__ = [os]
    
    #test2.py
    from test1 import *
    sys.path
    
    
    1. __ path__
      __ path__用于指定包的搜索路径,默认情况下只有一个元素, 就是当前包的路径, 修改__ path__, 可以修改此包内的搜索路径,修改该属性类似于修改sys.path
    2. __ module__
      __ module__ 表示当前操作的对象在属于哪个模块

    类和实例属性

    1. __ doc__
      说明性文档和信息,Python自建,无需自定义。
    """ 描述类信息,可被自动收集 """
    
    def func(self):
        pass
    
    # 打印类的说明文档 
    print(Foo.__doc__)
    
    
    1. __ class__
      __ class__属于实例的属性,直接指向该实例的类对象
    class A(object):
    	pass
    
    a = A()
    a.__class__等同于A
    
    
    1. __ dict__
      对象的属性字典,key为属性名,value为该属性的值
      注:__ dict__若被实例对象引用则列出实例对象的属性,若被类引用则列出类属性
      eg.
    class A():  
        def __init__(self):  
            self.x=1   #定义一个实例属性  
        y = 2          #定义一个类属性  
    
    
    a = A()
    a.__dict__
    {'x': 1}
    A.__dict__
    {'__doc__': None,
     '__init__': function __main__.__init__
     '__module__': '__main__',
     'y': 2}
    
    
    1. __ init__and __ new__
      继承自object的新式类拥有__ new__隐藏方法
      __ new__在实例被创建时调用,__ init__在实例创建后的初始化时调用,所以先调用__ new__,然后调用__ init__
    class A(object):    
        def __init__(self):
            print init
        def __new__(cls,*args, **kwargs):
            print new %s%cls
            return object.__new__(cls, *args, **kwargs)
     
    A()
    
    # 输出
    new class '__main__.A'
    init
    
    

    __ new__方法返回一个实例对象
    5. __ slots__
    Python作为一种动态语言,可以在类定义完成和实例化后,给类或者对象继续添加随意个数或者任意类型的变量或方法,这是动态语言的特性。例如:

    def print_doc(self):
        print("haha")
        
    class Foo:
        pass
    
    obj1 = Foo()
    obj2 = Foo()
    # 动态添加实例变量
    obj1.name = "jack"
    obj2.age = 18
    # 动态的给类添加实例方法
    Foo.show = print_doc
    obj1.show()
    obj2.show()
    
    

    果我想限制实例可以添加的变量怎么办?可以使用__ slots__
    __ slots__限制类中只能定义某些属性
    例如:

        print("haha")
    
    class Foo:
        __slots__ = ("name", "age")
        pass
    
    
    obj1 = Foo()
    obj2 = Foo()
    # 动态添加实例变量
    obj1.name = "jack"
    obj2.age = 18
    obj1.sex = "male"       # 这一句会弹出错误
    # 但是无法限制给类添加方法
    Foo.show = print_doc
    obj1.show()
    obj2.show()
    
    

    由于’sex’不在__ slots__的列表中,所以不能绑定sex属性,试图绑定sex将得到AttributeError的错误
    obj1.sex = “male”, AttributeError: ‘Foo’ object has no attribute ‘sex’
    注意: __ slots__定义的属性仅对当前类的实例起作用,对继承了它的子类是不起作用的,如果子类也被限制,可以在子类中也定义__ slots__

    1. __ del__
      析构方法,当对象在内存中被释放时,自动触发此方法。
      此方法一般无须自定义,因为Python自带内存分配和释放机制,除非你需要在释放的时候指定做一些动作。析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
    2. __ call__
      如果一个类编写了该方法,那么在该类的实例后面加括号,可会调用这个方法。
      注:构造方法的执行是由类加括号执行的,即:对象 = 类名(),而对于__call__() 方法,是由对象后加括号触发的,即:对象() 或者 类()()
      eg.
    class Foo:
    
        def __init__(self):
            pass
    
        def __call__(self, *args, **kwargs):
    
            print('__call__')
    
    
    obj = Foo()     # 执行 __init__
    obj()       # 执行 __call__
    
    

    怎么判断一个对象是否可以被执行呢?能被执行的对象就是一个Callable对象,可以用Python内建的callable()函数进行测试。
    eg.

    >>> callable(max)
    True
    
    

    操作符类属性

    1. __ str__
      当将一个对象进行格式化字符串时,调用的是对象的__ str__方法,如果一个类中定义了__ str__()方法,那么在打印对象时,默认输出该方法的返回值。
      下面的类,没有定义__ str__()方法,打印结果是:<__ main__.Foo object at 0x000000000210A358>
    class Foo:
        pass
    
    obj = Foo()
    print(obj)
    
    

    定义了__ str__()方法后,打印结果是:jack

    class Foo:
    
        def __str__(self):
            return 'jack'
    
    obj = Foo()
    print(obj)
    
    
    1. __ repr__
      这个方法的作用和__str__()很像,两者的区别是__str__()返回用户看到的字符串,而__repr__()返回程序开发者看到的字符串,也就是说,repr()是为调试服务的。通常两者代码一样。
    2. __ len__
      在Python中,调用内置的len()函数获取一个对象的长度,在后台其实是去调用该对象的__len__()方法,所以下面的代码是等价的:
      Python的list、dict、str等内置数据类型都实现了该方法,但是你自定义的类要实现len方法需要自己设计。
    class Foo:
        def __init__(self):
            pass
    
        def __iter__(self):
            yield 1
            yield 2
            yield 3
    
    obj = Foo()
    for i in obj:
        print(i)
    
    >>> 1
    >>> 2
    >>> 3
    
    
    1. __ iter__
      列表、字典、元组之所以可以进行for循环,是因为其内部定义了 __ iter__()这个方法。用户也可以在自定类中定义这个方法,在利用for循环遍历对象时就可以调用这个__ iter__()方法。
      eg.
    class Foo:
        def __init__(self):
            pass
    
        def __iter__(self):
            yield 1
            yield 2
            yield 3
    
    obj = Foo()
    for i in obj:
        print(i)
    
    >>> 1
    >>> 2
    >>> 3
    
    
    1. __ getitem__, __ setitem__, __ delitem__
      Python设计了__ getitem__()、__ setitem__()、__ delitem__()这三个特殊成员,用于执行与中括号有关的动作。它们分别表示取值、赋值、删除数据。
    a = 标识符[] :   执行__getitem__方法
    标识符[] = a  :   执行__setitem__方法
    del 标识符[] :   执行__delitem__方法
    
    

    eg.

    class Foo:
    
        def __getitem__(self, key):
            print('__getitem__',key)
    
        def __setitem__(self, key, value):
            print('__setitem__',key,value)
    
        def __delitem__(self, key):
            print('__delitem__',key)
    
    
    obj = Foo()
    
    result = obj['k1']      # 自动触发执行 __getitem__
    obj['k2'] = 'jack'      # 自动触发执行 __setitem__
    del obj['k1']             # 自动触发执行 __delitem__
    
    
    展开全文
  • 基本的魔法方法 __new__(cls[, ...]) ... __new__ 决定是否要使用该 __init__ 方法,因为 __new__ 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例,如果 __new__ 没有返回实例...

    基本的魔法方法

    __new__(cls[, ...])	
    
    	1. __new__ 是在一个对象实例化的时候所调用的第一个方法
    	2. 它的第一个参数是这个类,其他的参数是用来直接传递给 __init__ 方法
    	3. __new__ 决定是否要使用该 __init__ 方法,因为 __new__ 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例,如果 __new__ 没有返回实例对象,则 __init__ 不会被调用
    	4. __new__ 主要是用于继承一个不可变的类型比如一个 tuple 或者 string
    __init__(self[, ...])	
    	构造器,当一个实例被创建的时候调用的初始化方法
    __del__(self)	
    	析构器,当一个实例被销毁的时候调用的方法
    __call__(self[, args...])	
    	允许一个类的实例像函数一样被调用:x(a, b) 调用 x.__call__(a, b)
    __len__(self)	
    	定义当被 len() 调用时的行为
    __repr__(self)	
    	定义当被 repr() 调用或者直接执行对象时的行为
    __str__(self)	
    	定义当被 str() 调用或者打印对象时的行为
    __bytes__(self)	
    	定义当被 bytes() 调用时的行为
    __hash__(self)	
    	定义当被 hash() 调用时的行为
    __bool__(self)	
    	定义当被 bool() 调用时的行为,应该返回 True 或 False
    __format__(self, format_spec)	
    	定义当被 format() 调用时的行为
    

    有关属性

    __getattr__(self, name)	定义当用户试图获取一个不存在的属性时的行为
    __getattribute__(self, name)	定义当该类的属性被访问时的行为
    __setattr__(self, name, value)	定义当一个属性被设置时的行为
    __delattr__(self, name)	定义当一个属性被删除时的行为
    __dir__(self)	定义当 dir() 被调用时的行为
    __get__(self, instance, owner)	定义当描述符的值被取得时的行为
    __set__(self, instance, value)	定义当描述符的值被改变时的行为
    __delete__(self, instance)	定义当描述符的值被删除时的行为
    

    比较操作符

    __lt__(self, other)	定义小于号的行为:x < y 调用 x.__lt__(y)
    __le__(self, other)	定义小于等于号的行为:x <= y 调用 x.__le__(y)
    __eq__(self, other)	定义等于号的行为:x == y 调用 x.__eq__(y)
    __ne__(self, other)	定义不等号的行为:x != y 调用 x.__ne__(y)
    __gt__(self, other)	定义大于号的行为:x > y 调用 x.__gt__(y)
    __ge__(self, other)	定义大于等于号的行为:x >= y 调用 x.__ge__(y)
    

    算数运算符

    __add__(self, other)	定义加法的行为:+
    __sub__(self, other)	定义减法的行为:-
    __mul__(self, other)	定义乘法的行为:*
    __truediv__(self, other)	定义真除法的行为:/
    __floordiv__(self, other)	定义整数除法的行为://
    __mod__(self, other)	定义取模算法的行为:%
    __divmod__(self, other)	定义当被 divmod() 调用时的行为
    __pow__(self, other[, modulo])	定义当被 power() 调用或 ** 运算时的行为
    __lshift__(self, other)	定义按位左移位的行为:<<
    __rshift__(self, other)	定义按位右移位的行为:>>
    __and__(self, other)	定义按位与操作的行为:&
    __xor__(self, other)	定义按位异或操作的行为:^
    __or__(self, other)	定义按位或操作的行为:|
    

    反运算

    __radd__(self, other)	(与上方相同,当左操作数不支持相应的操作时被调用)
    __rsub__(self, other)	(与上方相同,当左操作数不支持相应的操作时被调用)
    __rmul__(self, other)	(与上方相同,当左操作数不支持相应的操作时被调用)
    __rtruediv__(self, other)	(与上方相同,当左操作数不支持相应的操作时被调用)
    __rfloordiv__(self, other)	(与上方相同,当左操作数不支持相应的操作时被调用)
    __rmod__(self, other)	(与上方相同,当左操作数不支持相应的操作时被调用)
    __rdivmod__(self, other)	(与上方相同,当左操作数不支持相应的操作时被调用)
    __rpow__(self, other)	(与上方相同,当左操作数不支持相应的操作时被调用)
    __rlshift__(self, other)	(与上方相同,当左操作数不支持相应的操作时被调用)
    __rrshift__(self, other)	(与上方相同,当左操作数不支持相应的操作时被调用)
    __rand__(self, other)	(与上方相同,当左操作数不支持相应的操作时被调用)
    __rxor__(self, other)	(与上方相同,当左操作数不支持相应的操作时被调用)
    __ror__(self, other)	(与上方相同,当左操作数不支持相应的操作时被调用)
    

    增量赋值运算

    __iadd__(self, other)	定义赋值加法的行为:+=
    __isub__(self, other)	定义赋值减法的行为:-=
    __imul__(self, other)	定义赋值乘法的行为:*=
    __itruediv__(self, other)	定义赋值真除法的行为:/=
    __ifloordiv__(self, other)	定义赋值整数除法的行为://=
    __imod__(self, other)	定义赋值取模算法的行为:%=
    __ipow__(self, other[, modulo])	定义赋值幂运算的行为:**=
    __ilshift__(self, other)	定义赋值按位左移位的行为:<<=
    __irshift__(self, other)	定义赋值按位右移位的行为:>>=
    __iand__(self, other)	定义赋值按位与操作的行为:&=
    __ixor__(self, other)	定义赋值按位异或操作的行为:^=
    __ior__(self, other)	定义赋值按位或操作的行为:|=
    

    一元操作符

    __pos__(self)	定义正号的行为:+x
    __neg__(self)	定义负号的行为:-x
    __abs__(self)	定义当被 abs() 调用时的行为
    __invert__(self)	定义按位求反的行为:~x
    

    类型转换

    __complex__(self)	定义当被 complex() 调用时的行为(需要返回恰当的值)
    __int__(self)	定义当被 int() 调用时的行为(需要返回恰当的值)
    __float__(self)	定义当被 float() 调用时的行为(需要返回恰当的值)
    __round__(self[, n])	定义当被 round() 调用时的行为(需要返回恰当的值)
    __index__(self)	
    	1. 当对象是被应用在切片表达式中时,实现整形强制转换
    	2. 如果你定义了一个可能在切片时用到的定制的数值型,你应该定义 __index__
    	3. 如果 __index__ 被定义,则 __int__ 也需要被定义,且返回相同的值
    

    上下文管理(with 语句)

    __enter__(self)	
    	1. 定义当使用 with 语句时的初始化行为
    	2. __enter__ 的返回值被 with 语句的目标或者 as 后的名字绑定
    __exit__(self, exc_type, exc_value, traceback)	
    	1. 定义当一个代码块被执行或者终止后上下文管理器应该做什么
    	2. 一般被用来处理异常,清除工作或者做一些代码块执行完毕之后的日常工作
    

    容器类型

    __len__(self)	定义当被 len() 调用时的行为(返回容器中元素的个数)
    __getitem__(self, key)	定义获取容器中指定元素的行为,相当于 self[key]
    __setitem__(self, key, value)	定义设置容器中指定元素的行为,相当于 self[key] = value
    __delitem__(self, key)	定义删除容器中指定元素的行为,相当于 del self[key]
    __iter__(self)	定义当迭代容器中的元素的行为
    __reversed__(self)	定义当被 reversed() 调用时的行为
    __contains__(self, item)	定义当使用成员测试运算符(in 或 not in)时的行为
    
    
    展开全文
  • python类方法的重载

    万次阅读 2015-04-29 15:23:17
    Python 可以定义专用方法,专用方法是在特殊情况下或当使用特别语法时由 Python 替你调用的,而不是在代码中直接调用(象普通的方法那样)。 .1 __init__ 类似于构造函数 #!/usr/local/bin/python class Study...
  • 基本的魔法方法 ...3. __new__ 决定是否要使用该 __init__ 方法,因为 __new__ 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例,如果 __new__ 没有返回实例对象,则 __init...
  • python-定义类的方法

    千次阅读 2019-01-12 16:09:31
    #定义类的方法 ''' 函数和方法 函数:直接调用函数名来调用 方法:必须和对象结合在一起使用(方法是类的一部分,由别的程序来调用) 常用的方法定义 class Example(object): def add(self): pass def _minus...
  • Python 类的专用方法

    2012-12-03 11:41:11
    Python 可以定义专用方法,专用方法是在特殊情况下或当使用特别语法时由 Python 替你调用的,而不是在代码中直接调用(象普通的方法那样)。 .1 __init__ 类似于构造函数 #!/usr/local/bin/python class Study:...
  • Python类的方法要加self的理由

    千次阅读 2018-10-30 18:30:04
    Python的类的方法和普通的函数有一个很明显的区别,在类的方法必须有个额外的第一个参数 (self ),但在调用这个方法的时候不必为这个参数赋值 (显胜于隐 的引发)。Python的类的方法的这个特别的参数指代的是...
  • 3. new 决定是否要使用该 init 方法,因为 new 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例,如果 new 没有返回实例对象,则 init 不会被调用 4. new 主要是用于继承一个不可...
  • Python类的特性方法

    2012-12-10 09:33:41
    专用方法产生的原因:它们提供了一种,可以将非调语法映射到方调用上。...专用方法是在特殊情况下或当使用特别语法时由 Python 替你调用的,而不是在代码中直接调用(象普通的方法那样)。 6.5.1 __init__ 类似
  • Python_类的魔术方法

    2019-01-03 22:27:46
    基本的魔法方法 __new__(cls[, ...]) ... __new__ 决定是否要使用该 __init__ 方法,因为 __new__ 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例,如果 __new__ 没有返回实例...
  • Python导入类的三种方法

    千次阅读 2020-05-27 21:38:22
    导入模块就是为了使用模块中的类 当我们在写代码时,经常会遇到一种情况:我们要用到的一些功能已经在别的模块里定义过了,如果...通常这个模块就是要导入的那个类所在的文件*.py,所以调用类的方法为: object =...
  • property是python于其它语言所特有的类,该类实现把函数名变为属性名使用。 property类有3个方法getter、setter、deleter, 分别把对应的操作绑定到指定的函数实现。 因此: 1) 对property类对象的读操作就是...
  • 基本的魔法方法 __new__(cls[, ...]) ... __new__ 决定是否要使用该 __init__ 方法,因为 __new__ 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例,如果 __new__ 没有返回实例...
  • 这个类的当前实例,一个类有多个实例,那么它属于自己所属于的实例,不会存在实例宁缺的self会指向实例陈皮皮。 这里比价特别的是,可以把一个普通函数绑定到方法使用,普通函数是没有self的,看下面代码, ...
  • ​这是我在使用PyQt5(一个很方便好用的制作小软件的,可以说是Python的一个包吧,pip就可以使用)做一个小软件的时候,遇到的一个问题,因为如果是作为一个敢...这问题就来了,我在主窗口里的功能设计中,需要使用别的
  • Python 专用类方法

    千次阅读 2013-07-05 16:42:28
    专用方法是在特殊情况下或当使用特别语法时由 Python 替你调用的,而不是在代码中直接调用 (像普通的方法那样)。 就像你在上一节所看到的,普通的方法对在中封装字典很有帮助。但是只有普通方法是不够的,因为...
  • 在数据分析领域,最热门莫过于Python和R语言,此前有一篇文章《老扯什么Hadoop了,你数据根本不够大》指出:只有在超过5TB数据量规模下,Hadoop才是一个合理技术选择。这次拿到近亿条日志数据,千万级数据...
  • 基本的魔法方法 __new__(cls[, ...]) ... __new__ 决定是否要使用该 __init__ 方法,因为 __new__ 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例,如果 __new__ 没有返回实例...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 580
精华内容 232
关键字:

python使用别的类的方法

python 订阅