精华内容
下载资源
问答
  • 以上这篇Python 实现引用其他.py文件中的类类的方法就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持软件开发网。 您可能感兴趣的文章:Python中py文件引用另一个py文
  • Python中引用自定义类的方法

    千次阅读 2019-07-26 17:07:00
    自定义如下 from tkinter import * import random import time class Ball: def __init__(self,canvas, color): self.canvas = canvas self.id = canvas.create_oval(10,10,25,25,fill = color...

    自定义类如下

     

    from tkinter import *
    import random
    import time

    class Ball:
        def __init__(self,canvas, color):
            self.canvas = canvas
            self.id = canvas.create_oval(10,10,25,25,fill = color)
            self.canvas.move(self.id, 245,100)
           
        def draw(self):
            pass

     

    类的文件名是Balls.py, 保存在名为playball的包下面

    重要一点:playball包里面要有一个文件__init__.py,  这个文件用来表示一个包,内容为空就可以。

    下面是引用到它的程序:

     

    from playball.Balls import Ball

     

    ball = Ball(canvas,'red')

     

     

    引用的格式应是这样:

    from 包名.文件名 import 类名

     

    展开全文
  • 静态方法和类方法在python2.2中被引用...静态方法主要是用来存放逻辑性的代码,主要是一些逻辑属于类,但是和类本身没有交互,即在静态方法中,不会涉及到类中的方法和属性的操作。可以理解为将静态方法存在此类的名...

    静态方法和类方法在python2.2中被引用,经典类和新式类都可以使用。同时,一对内建函数:staticmethod和classmethod被引入,用来转化类中某一方法为这两种方法之一。

    静态方法:

    静态方法是类中的函数,不需要实例。静态方法主要是用来存放逻辑性的代码,主要是一些逻辑属于类,但是和类本身没有交互,即在静态方法中,不会涉及到类中的方法和属性的操作。可以理解为将静态方法存在此类的名称空间中。事实上,在python引入静态方法之前,通常是在全局名称空间中创建函数。

    例子:

    譬如,我想定义一个关于时间操作的类,其中有一个获得当前时间的函数。

    import time
    class TimeTest(object):
        def __init__(self,hour,minute,second):
            self.hour = hour
            self.minute = minute
            self.second = second
        @staticmethod    
        def showTime():       
            return time.strftime("%H:%M:%S", time.localtime())
    
        
    print TimeTest.showTime()    
    t = TimeTest(2,10,10)
    nowTime = t.showTime()
    print nowTime
    

      如上,使用静态函数,既可以将获得时间的函数功能与实例解绑,我想获得当前时间的字符串时,并不一定需要实例化对象,此时更像是一种名称空间。

    我们可以在类外面写一个简单的方法来做这些,但是这样做就扩散了类代码的关系到类定义的外面,这样写就会导致以后代码维护的困难。

    静态函数可以通过类名以及实例两种方法调用!

    类方法:

    类方法是将类本身作为对象进行操作的方法。他和静态方法的区别在于:不管这个方式是从实例调用还是从类调用,它都用第一个参数把类传递过来

    https://stackoverflow.com/questions/12179271/meaning-of-classmethod-and-staticmethod-for-beginner/12179325#12179325

    @classmethod means: when this method is called, we pass the class as the first argument instead of the instance of that class (as we normally do with methods). This means you can use the class and its properties inside that method rather than a particular instance.

    @staticmethod means: when this method is called, we don't pass an instance of the class to it (as we normally do with methods). This means you can put a function inside a class but you can't access the instance of that class (this is useful when your method does not use the instance).

    应用:

    1、做一个颜色的动态匹配

    class ColorTest(object):
        color = "color"
        @classmethod
        def value(self):
            return self.color
        
    class Red(ColorTest):
        color = "red"
        
    class Green(ColorTest):
        color = "green"
    
    g = Green()
    print g.value()
    print Green.value()
    

      其中,基类做一个抽象共性,对于实际的颜色的值需要结合实际的类进行匹配。

    2、假设我有一个学生类和一个班级类,想要实现的功能为:

    班级类含有类方法:

    执行班级人数增加的操作、获得班级的总人数

    学生类继承自班级类,每实例化一个学生,班级人数都能增加。

    最后,我想定义一些学生,然后获得班级中的总人数。

     

    思考:这个问题用类方法做比较合适,因为我实例化的时学生,但是如果我从学生这一个实例中获得班级总人数是不合理的。

    同时,如果想要获得班级总人数,如果生成一个班级的实例也是没有必要的。

    class ClassTest(object):
        __num = 0
        @classmethod
        def addNum(self):
            self.__num += 1
        @classmethod
        def getNum(self):
            return self.__num
        
        def __new__(self):
            ClassTest.addNum()
            return super(ClassTest,self).__new__(self)
        
    class Student(ClassTest):
        def __init__(self):
            self.name = ''
              
    
    a = Student()
    b = Student()
    ClassTest.getNum()  
    

      这里我用到魔术函数__new__,主要是为了在创建实例的时候调用人数累加的函数。

    类函数可以通过类名以及实例两种方法调用!

    注意:

    python2 中,必须总要把一个方法声明为静态的,从而能够不带一个实例而调用它。

    python3 中,如果方法只通过类调用,而不需要通过实例调用的话,不用非要声明为静态的。

    #!/usr/bin/python
    class test:
      def show():
        print ("show")
    
    test.show()
    

      此时会出现错误:

    [root@localhost home]# ./test.py
    Traceback (most recent call last):
    File "./test.py", line 6, in <module>
    test.show()
    TypeError: unbound method show() must be called with test instance as first argument (got nothing instead)

     

    改到python3即可:

    #!/usr/bin/python3
    class test:
      def show():
        print ("show")
    
    test.show()
    

      

     

     

    转载于:https://www.cnblogs.com/pinking/p/7944376.html

    展开全文
  • python类方法中的self关键字

    万次阅读 2018-08-30 14:55:05
    之前学python爬虫时候要把函数封装到里面,写成类方法,知道在python的类方法中第一个参数应该是self,但对self代表具体意义不甚了了。最近在看Java,对面向对象编程了解更多了一点,终于彻底弄明白self到底...

    之前学python爬虫的时候要把函数封装到类里面,写成类方法,知道在python的类方法中第一个参数应该是self,但对self代表的具体意义不甚了了。最近在看Java,对面向对象编程的了解更多了一点,终于彻底弄明白self到底是什么了。

    Python的类

    在python中,所有的类都直接或间接继承自Object类,定义了类之后就定义了一个命名空间,里面定义的属性可以通过类名来引用。新定义的类中有一些Object中有的属性,可以在其中定义其他变量或者函数。实例化之后会创建一个对象,该对象脱胎于类,并且其中的属性动态地和类中的属性产生关联:

    class A:
        pass
       
    a = A()
    

    这段代码创建了一个类A,并且对它进行了实例化,实例化之后的对象绑定为变量a。我可以看看A里面和a里面分别有什么:

    In [38]: dir(A)
    Out[38]:
    ['__class__',
     '__delattr__',
     '__dict__',
     '__dir__',
     '__doc__',
     '__eq__',
     '__format__',
     '__ge__',
     '__getattribute__',
     '__gt__',
     '__hash__',
     '__init__',
     '__init_subclass__',
     '__le__',
     '__lt__',
     '__module__',
     '__ne__',
     '__new__',
     '__reduce__',
     '__reduce_ex__',
     '__repr__',
     '__setattr__',
     '__sizeof__',
     '__str__',
     '__subclasshook__',
     '__weakref__']
    
    In [39]: dir(a)
    Out[39]:
    ['__class__',
     '__delattr__',
     '__dict__',
     '__dir__',
     '__doc__',
     '__eq__',
     '__format__',
     '__ge__',
     '__getattribute__',
     '__gt__',
     '__hash__',
     '__init__',
     '__init_subclass__',
     '__le__',
     '__lt__',
     '__module__',
     '__ne__',
     '__new__',
     '__reduce__',
     '__reduce_ex__',
     '__repr__',
     '__setattr__',
     '__sizeof__',
     '__str__',
     '__subclasshook__',
     '__weakref__']
    

    用dir函数输出A中和a中的属性后,我们可以看到A和a中的属性是一样的。我们可以向其中添加属性,添加属性时必须初始化:

    In [40]: A.b
    ---------------------------------------------------------------------------
    AttributeError                            Traceback (most recent call last)
    <ipython-input-40-ebcfc7dbf31a> in <module>()
    ----> 1 A.b
    
    AttributeError: type object 'A' has no attribute 'b'
    
    In [41]: A.b = 1
    

    现在我们可以看看A和a中的属性发生了什么变化:

    In [42]: dir(A)
    Out[42]:
    ['__class__',
     '__delattr__',
     '__dict__',
     '__dir__',
     '__doc__',
     '__eq__',
     '__format__',
     '__ge__',
     '__getattribute__',
     '__gt__',
     '__hash__',
     '__init__',
     '__init_subclass__',
     '__le__',
     '__lt__',
     '__module__',
     '__ne__',
     '__new__',
     '__reduce__',
     '__reduce_ex__',
     '__repr__',
     '__setattr__',
     '__sizeof__',
     '__str__',
     '__subclasshook__',
     '__weakref__',
     'b']
    
    In [43]: dir(a)
    Out[43]:
    ['__class__',
     '__delattr__',
     '__dict__',
     '__dir__',
     '__doc__',
     '__eq__',
     '__format__',
     '__ge__',
     '__getattribute__',
     '__gt__',
     '__hash__',
     '__init__',
     '__init_subclass__',
     '__le__',
     '__lt__',
     '__module__',
     '__ne__',
     '__new__',
     '__reduce__',
     '__reduce_ex__',
     '__repr__',
     '__setattr__',
     '__sizeof__',
     '__str__',
     '__subclasshook__',
     '__weakref__',
     'b']
    
    In [74]: A.b
    Out[74]: 1
    
    In [75]: a.b
    Out[75]: 1
    

    我们可以看到,在A中和它的实例化对象中现在都有了属性b,而且它们的值相等。
    如果我们给A的实例化对象中添加属性呢:

    In [44]: a.c = 2
    
    In [45]: hasattr(a, c)
    ---------------------------------------------------------------------------
    NameError                                 Traceback (most recent call last)
    <ipython-input-45-15d927c71e90> in <module>()
    ----> 1 hasattr(a, c)
    
    NameError: name 'c' is not defined
    

    竟然报错了,c没有定义,报错的原因是A的实例化对象a的命名空间中有c,但是公共命名空间中没有c,所以我们再试一次:

    In [58]: c = a.c
    
    In [59]: hasattr(a, 'c')
    Out[59]: True
    
    In [60]: hasattr(A, 'c')
    Out[60]: False
    

    我们可以看到,a中有c,但是A中并没有c。是不是因为c指向的是a.c所以A中没有呢:

    In [61]: b = a.b
    
    In [62]: hasattr(A, 'b')
    Out[62]: True
    

    确实是因为在类的实例化对象中添加的属性不会加入类中。

    我们接着看给A或a中加入函数属性会发生什么:

    In [78]: A.foo = lambda x : x + 1
    
    In [79]: A.foo(1)
    Out[79]: 2
    
    In [80]: a.foo(1)
    ---------------------------------------------------------------------------
    TypeError                                 Traceback (most recent call last)
    <ipython-input-80-7dc85fd7a693> in <module>()
    ----> 1 a.foo(1)
    
    TypeError: <lambda>() takes 1 positional argument but 2 were given
    

    python方法函数中的self关键字

    上面执行"a.foo(1)"语句时有个报错,说只需要一个参数,但是给了两个参数,这第二个参数是怎么来的,为什么A.foo(1)就不会出错。这里我们可以引出python类中的方法函数,方法函数指的是通过类的实例化对象调用的函数,方法函数的第一个形参表示类的实例化对象,通常写成self。执行a.foo(1)时就相当于执行A.foo(a,1),因为A.foo()中只有一个形参,传入的参数多于需要的参数,所以发生类型错误。
    我们在A的定义中重新定义foo:

    class A:
        def foo(self, n):
            print(n+1)
       
    a = A()
    

    现在我们在a中调用foo就不会有问题了:

    In [85]: a.foo(1)
    2
    

    我们也可以试试调用A.foo:

    In [86]: A.foo(a, 1)
    2
    

    总结

    python的类中定义函数时的self关键字跟python的方法函数有关,方法函数由类的实例化对象调用,需要把调用它的实例化对象传入方法函数中,self即是表示实例化对象的形参。

    展开全文
  • Python 引用其他.py文件中的类类的方法 #HelloWorld是文件名称,Hello是 from HelloWorld import Hello 调用,Hello类的方法: >>> h = Hello() >>> h.hello() Hello, world #输出结果 #>>> ...

    Python 引用其他.py文件中的类和类的方法


    #HelloWorld是文件名称,Hello是类

    from HelloWorld import Hello

    调用,Hello类的方法:

    >>> h = Hello()
    >>> h.hello()
    Hello, world    #输出结果
    #>>> Hello().hello()
    #Hello, world

    附:HelloWorld.py文件内容

    #
    class Hello(object):
    	def hello(self,name= 'world'):
    		print('Hello, %s' %name)
    


    展开全文
  • python中的类引用

    2012-06-13 20:07:49
    属性(成员变量)一般私有通过设置Properties或通过对方类的方法调用。Properties有老方法和新方法,建议用新方法property decorator。至于对方类的方法,就是通过对方调用呀。 Python code """Jerry Cool'...
  • 类方法第一个参数为cls cls引用类对象 @classmethod 注意不要通过 对象来对属性进行修改 那么将给对象绑定一个同名实例属性 静态方法 @staticmethod 静态方法的参数 即没有对象 也没有实例对象 作为参数 ...
  • 下面中的属性bg_color和方法blitme()都是别的.py文件中的,为什么可以在这个新的.py文件中直接引用呢?也没有实例, 是因为这些文件在一个项目目录里面吗? 代码来自《python变成到...
  • 一、__init__()方法 如果__init__()方法为 class Cat(): ...当Python通过__init__()方法创建实例时,将自动传入一个实参self,与相关联的方法都会自动传递实参self,它是指向实例本身的引用,实例可...
  • 像函数一样,Python中的类方法也是一种对象。由于既可以通过实例也可以通过来访问方法,所以在Python里有两种风格: 未绑定的方法:没有self 通过引用方法返回一个未绑定方法对象。要调用它,你必须显示地...
  • 方法:是对象的方法,在定义时需要在上方使用“@classmethod”进行装饰,形参为 cls, 表示对象,对象和实例对象都可调用; 实例方法:是实例化对象的方法,只有实例对象可以调用,形参为 self,指代...
  • 三种方法的区别之一,体现在参数上:实例方法隐含参数为实例self,类方法隐含参数为本身cls,静态方法无隐含参数,主要为了实例也可以直接调用静态方法。...Python中实现了一定灵活性使得实例方法
  • python中的super()方法主要用于子类引用父类方法,因为这样做可以提高代码的复用性 #!/usr/bin/env python # -*- coding=utf-8 -*- #用于测试继承的super()方法 class A(object): """ 父...
  • 类变量访问类属性静态方法调用:可以用类、类实例调用静态方法本质:在类中的一个普通函数使面向对象程序中函数归属于类,易于代码管理静态方法的用法:与类相关,但不依赖或改变类与实例创建不同的实例把类相关工具...
  • method:通过实例调用时,可以引用类内部任何属性和方法classmethod:无需实例化,可以调用属性和类方法,无法取到普通成员属性和方法staticmethod:用调用还是实例调用,都无法取到内部属性和方法,...
  •  --在类的方法(即函数)里面定义一个以“self.”开头的变量;2.如何使用该对象变量?--使用“对象名.对象变量名”eg.#!/usr/bin/python # -*- coding: UTF-8 -*- class JustCounter: def count(self): self.num...
  • Python-对象方法实例对象方法

    千次阅读 2018-06-05 13:33:26
    自己总结python类中类对象方法和类实例对象方法,其判断的方法是: (1)首先看方法定义是否引用了self,带了self,肯定为实例对象方法。 (2)其次,看是否带参数,如果不带参数,肯定是类对象方法。 (3)除了...
  • 通常情况下,python的gc 垃圾回收机制,有一套算法,可以用来回收循环引用的对象,避免内存泄露。 不过,有个例外情况:显示重写了__del__方法。此时gc就无法释放资源,因为循环引用导致了引用计数器不可能为0。...
  • 方法就是自己的方法,不需要实例化对象,自己就是对象,直接绑定在上 静态方法就是普通的函数,函数作为对象,不过是封装在的内部,通过.方法引用 从参数上看: 实例方法默认参数是self 方法默认...
  • 但是,我们又不是想在B类中继承A类,那么我们就需要在B类中实例化一个A类引用,然后再调用A类的方法,如下所示: class MyGUI(wx.Frame): def __init__(self, title, size, loader): wx.Frame.__init__(self...
  • 方法链(method chaining)是面向对象的编程语言中的一种常见语法,可以让开发者在只引用对象一次的情况下,对同一个对象进行多次方法调用。举个例子: 假设我们有一个Foo,其中包含有两个方法——bar和baz。 我们...
  • 类中的方法分为: 1.绑定方法 1.1绑定对象方法 1.2绑定类方法 2.非绑定方法(也成为静态方法) ​ 在类中正常定义的函数默认都是绑定到对象的,在函数之上加上语法糖@classmethod之后,该函数就成了绑定类方法 ​ #...
  • Python中 、对象和魔法方法 (class):简单来说就是某一事物,它们具有相同属性,例如猫有各种颜色,各种颜色就属于属性(也被叫做变量)。 对象(object):黑猫,白猫这些都是对象,这个对象就是类的实例...
  • Python中绑定与未绑定的方法 ...像函数一样,Python中的类方法也是一种对象。由于既可以通过实例也可以通过来访问方法,所以在Python里有两种风格: 未绑定的方法:没有self 通过引用方法返回...
  • 像函数一样,Python中的类方法也是一种对象。由于既可以通过实例也可以通过来访问方法,所以在Python里有两种风格: 未绑定的方法:没有self  通过引用方法返回一个未绑定方法对象。要调用它,你必须...

空空如也

空空如也

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

python类中的方法引用方法

python 订阅