精华内容
下载资源
问答
  • Python 创建类对象实例的过程

    万次阅读 2018-04-20 16:19:35
    1、问题由来 有一次在的定义时将一个方法外的属性前加上了selfclass Myclass(object): self.test='hello' #错误使用self def __init__(self, x): self.x = x c1 = Myclass(11) 运行时报错:Traceback (most...

    1、问题由来

        有一次在类的定义时将一个方法外的属性前加上了self

    class Myclass(object):
        self.test='hello' #错误使用self
        def __init__(self, x):
            self.x = x
         
    c1 = Myclass(11)

      运行时报错:

    Traceback (most recent call last):
      File "e:\Job\TSC\CodeCloud\classTest.py", line 40, in <module>
        class Myclass(object):
      File "e:\Job\TSC\CodeCloud\classTest.py", line 41, in Myclass
        self.test='hello'
    NameError: name 'self' is not defined

            刚开始分析是因为类在初始化时尚未执行__init__( )函数,实例对象尚未建立起来,因此这么定义会出错。但是发现__init__(self, x )函数中以及传入了self这个变量,说明实例已经创建。那么Python中实例是什么时候创建的呢?

    2、Python中类的实例化过程

         Python中存在着一种静态的__new__()方法,通常在定义类时不会重写__new__()方法,于是Python在调用类时会自动寻找该类的继承对象(本例中为Object),然后返回当前类的实例对象:

    def __new__(cls, *args, **kwargs):
        ...
        return object.__new__(cls)  #执行object的__new__()函数

      执行object的__new__()函数后会返回实例对象(self),然后将self作为第一个参数传给该类的初始化方法__init__()方法。这里self只是实例对象的一个名字,也是Python里约定俗成的一种叫法,可以自定义其名称。

        当运行c1 = Myclass(11)代码时其实做了两个动作:

    class Myclass(object):
        def __init__(self, x):
            self.x = x
         
    c1 = Myclass(11)                   #相当于隐式执行了__new__()和__init()
    c2 = Myclass.__new__(Myclass, 12)  #显式调用__new__(),返回c2对象
    c2.__init__( 12)                   #显示调用__init(),完成c2的初始化
    print c1.x, c2.x
        执行结果为:
    11 12

     3、解决问题

           了解对象的实例化后过程后可知在__init__()方法之前使用self是不允许的,可将test变量定义成类的属性,这样即可通过类也可以通过实例访问test变量。

    class Myclass(object):
        test='hello'
        def __init__(self, x):
            self.x = x
         
    c1 = Myclass(11)   #实例化
    print Myclass.test, c1.test
    
    hello hello    #输出

    4、__init__( )与C++中的构造函数

         C++中构造函数的作用初始化对象的数据成员,该类实例对象被创建时,编译系统为对象分配内存空间,并自动调用该构造函数,由构造函数完成成员的初始化工作。Python解释器先使用类方法__new__( )为类分配空间,返回类实例,之后通过调用该对象的__init__( )方法初始化变量。

     __init__( )构造函数
    功能初始化类变量初始化类变量
    返回值没有没有
    重载可以,子类调使用super.__init__()重载

    可以


    5、单例实现方法

      单例就是说一个class只能有一个instance,实现的方法有很多种。

      a、重新定义__new__方法(经典做法,支持多线程操作)

    class Singleton(object):  
        _instance = None  
        def __new__(cls, *args, **kw):
            '''object将__new__()方法定义为静态方法,并且至少需要传递一个参数cls
               cls表示需要实例化的类,此参数在实例化时由Python解释器自动提供
            '''  
            if not cls._instance:  
                print 'create Singleton instance'  
                cls._instance = super(Singleton, cls).__new__(cls, *args, **kw)  #super函数干啥的。。  
            else:  
                print 'instance Singleton exists'  
            return cls._instance   
    
    class A(Singleton):
        _instance = None
        def __new__(cls,*args,**kw):
            if not cls._instance:    
                print 'create A instance'    
                cls._instance = super(A, cls).__new__(cls, *args, **kw)
    
            else:    
                print 'instance A exists'    
            return cls._instance
    
        def __init__(self):
            print 'A'
    
    A1=A()
    A2=A()

         输出为:

    create A instance          #执行A的__new__函数
    create Singleton instance  #执行Singleton的__new__函数
    A
    instance A exists
    A

    b、使用装饰器

    def Singleton(cls):
        _instance = {}
        
        def _singleton(*args, **kargs):
            if cls not in _instance:
                print 'create instance'
                _instance[cls] = cls(*args, **kargs)
            else:
                print 'instance exits' 
            return _instance[cls]
    
        return _singleton
    
    @Singleton
    class A(object):
        def __init__(self, x=0):
            self.x = x
    
    a1 = A(2)
    a2 = A(3) 

         输出为:

    creat instance
    instance exits

    展开全文
  • Python中的的定义和对象创建

    万次阅读 多人点赞 2018-08-16 17:35:59
    面向对象中两个重要的概念: 1.类 :对一类事物的描述,是抽象的、概念上的定义。...1.创建类创建类对象 1.创建类,类主要由类名,属性,方法组成,当然创建一个类时,属性和方法可以选择的。 cla...

    面向对象中两个重要的概念:

    1.类   :对一类事物的描述,是抽象的、概念上的定义。比如做石膏像的模型
    2.对象:实际存在的该类事物的每个个体,因而也称实例(instance)。比如石膏像

    二者的关系:对象是由类派生的、创建的。一个类可以创建无穷多个对象,每个对象都属于类。

     1.创建类和创建类对象

    1.创建类,类主要由类名,属性,方法组成,当然创建一个类时,属性和方法可以选择的。
    class Person:
        def cry(self):  #类方法:跟函数的定义类似,但是self参数自带的,这也是类的方法和普通方法的区别。
            print("I can cry")
        def speak(self):
            print("I can speak:%s"%(self.word))
    
    ---------创建对象-----------------------------------------------------------------------
    tom =Person()  #创建对象,直接类名(),不用像java中还要new,所以python更加简洁
    tom.cry()     #调用对象的方法
    tom.word="hahah"
    tom.speak()
    tom.age =18  #给对象添加属性 ,属性不用在类定义时声明,但这种方法给对象赋值麻烦,每个对象都要赋值。
    tom.age =19  #上面已经给tom添加过age属性,再次属于调用,重新赋值。
    
    ----------执行结果-------------------------------------------------------------------------
    '''
    I can cry
    I can speak:hahah
    '''
    
    2.给类初始化属性,在对象创建时就给对象设定了一些默认值。这样不用给每个对象都添加属性了,比如每个Person都是china,sex都是male.
     _init_(self)该类的方法有点类似java中类的构造器,可以给类的对象赋初始值。
    ------------------------------------------------------------------------------------------
    class Person1:
        def __init__(self):  #_init_(self),主要给类初始化一些属性,对象创建时自动调用该方法执行
            self.country ="china"
            self.sex = "male"
    
        def speak(self):
            print("I am  from %s  ,wuwuwuwuu"%self.country)
    -------------创建对象----------------------------------------------------------------------
    jack = Person1()
    jack.speak()
    print(jack.country,jack.sex)
    
    tom=Person1()
    tom.speak()
    print(tom.country,tom.sex)
    --------------执行结果如下:----------------------------------------------------------------
    '''
    I am  from china  ,wuwuwuwuu
    china male
    I am  from china  ,wuwuwuwuu
    china male
    '''
    
    3.属性虽然初始化了,但是固定死的,而实际每个对象的属性就不同。
      所以通过初始化时调用参数的形式,给每个对象赋不同的属性值
    
    class Person2:
        def __init__(self,name,age): 
            self.age =age   #这种用法类似java中的this.age=age.self意思可以理解为当前对象
            self.name = name #表示将当前对象传进来的参数name的值赋给当前对象的属性name
            self.country = "china" #还是可以给类的每个对象都赋一个默认值。
    
        def speak(self):
            print("name=%s,age=%d"%(self.name,self.age))
    -----------创建对象------------------------------------------------------------------------
    p1 = Person2("allen",19)
    p2 = Person2("sherry",22)
    p3 = p2  #让p3=p2.对象的赋值
    
    p1.speak()
    p2.speak()
    
    print("p1:",p1)  #直接打印对象 ,打印的是对象在内存中地址。
    print("p2:",p2)
    print("p3:",p3) #发现p3的地址跟p2的地址一样。
    
    '''执行结果如下:
    name=allen,age=19
    name=sherry,age=22
    p1: <__main__.Person2 object at 0x000001CBA3508BE0>
    p2: <__main__.Person2 object at 0x000001CBA3508CF8>
    p3: <__main__.Person2 object at 0x000001CBA3508CF8>
    '''
    

    总结:

    • __init__()方法,在创建一个对象时默认被调用,类似Java中构造器。不需要手动调用
    • __init__(self)中,默认有1个参数名字为self,必须写。如果在创建对象时传递了2个实参,那么__init__(self)中出了self作为第一个形参外还需要2个形参,例如__init__(self,age,name).第一个self不需要手动传参 
    • __init__(self)中的self参数,不需要开发者传递,python解释器会自动把当前的对象引用传递进去
    • python中一个类中只能有一个__init__方法,不支持该方法的重载(类似java中构造器的重载)
    • 每一个对象 都有自己 独立的内存空间保存各自不同的属性
    • 多个对象的方法在内存中只有一份,在调用方法时,需要把对象的引用 传递到方法内部

    2.新式类与旧式(经典)类

    object 是 Python 为所有对象提供的 基类,提供有一些内置的属性和方法,可以使用 dir 函数查看

    • 新式类:以 object 为基类的类,推荐使用
    • 经典类:不以 object 为基类的类,不推荐使用

    • 在 Python 3.x 中定义类时,如果没有指定父类,会 默认使用 object 作为该类的 基类 —— Python 3.x 中定义的类都是 新式类

    • 在 Python 2.x 中定义类时,如果没有指定父类,则不会以 object 作为 基类

    新式类 和 经典类 在多继承时 —— 会影响到方法的搜索顺序

    为了保证编写的代码能够同时在 Python 2.x 和 Python 3.x 运行!
    今后在定义类时,如果没有父类,建议统一继承自 object

    class 类名(object):    
        pass
    
    #尽量不要用下面这种老是写法,虽然不会报错,但是不推荐
    class 类名:    
        pass

    统一声明:关于原创博客内容,可能会有部分内容参考自互联网,如有原创链接会声明引用;如找不到原创链接,在此声明如有侵权请联系删除哈。关于转载博客,如有原创链接会声明;如找不到原创链接,在此声明如有侵权请联系删除哈。 

    展开全文
  • python3 动态创建类对象并调用函数

    千次阅读 2019-11-07 11:16:09
    1. 首先import相关模块`import importlib` 2. 加载你想要加载的模块`model = importlib.import_module(模块名称)` ...4. 创建类对象的实例`api_instance = api_class()` 5. 调用类对象的函数`api_instance.get...

    1. 首先import相关模块`import importlib`

    2. 加载你想要加载的模块`model = importlib.import_module(模块名称)`

    3. 获取类对象`api_class = getattr(model, 类名)`

    4. 创建类对象的实例`api_instance = api_class()`

    5. 调用类对象的函数`api_instance.get_response(data)`

    6. 下面是工程图和完整代码

    def dispatch_api_by_code(code, data):
    try:
    	model = importlib.import_module("api.api_" + str(code))
    	api_class = getattr(model, "Api" + str(code))
    	api_instance = api_class()
    	return api_instance.get_response(data)
    except:
    	return package_error_response(code_dispatch_error, "invaild api code")

     

    展开全文
  • Python定义创建对象

    千次阅读 2019-08-06 18:12:40
    2. 创建与使用对象对象也称为实例) 1)增加或删除实例变量 2)增加实例方法 面向对象编程的三大特征:封装、继承、多态; 1. 定义 语法格式: # 语法格式: class 类名: 执行语句... 变量... 方法....

    目录

    1. 定义类

    2. 创建与使用对象(对象也称为实例)

    1)增加或删除实例变量

    2)增加实例方法


    面向对象编程的三大特征:封装、继承、多态;

    1. 定义类

    语法格式:

    # 语法格式:
    class 类名:
        执行语句...
        类变量...
        方法...

    类名:一个或者多个单词连接而成,每个单词首字母大写,其余字母全部小写,单词与单词之间不使用分隔符;

    类包含的类变量可以动态增加或删除,程序在类定义中为新变量赋值就是增加类变量,程序可以在任何地方为已有的类增加变量,也可以通过del语句删除已有类的类变量;

    对象的变量也可以动态增加或删除,只要对对象的新变量赋值就是增加变量,可通过del语句删除已有对象的变量;

    定义方法与定义函数相同,但类中的方法第一个参数要定义为self,用于自动指向调用该方法的对象;

    特殊的方法:__init__,这个方法叫做构造方法,用于构造该类的对象,Python通过调用构造方法生成对象;如果开发者没有定义构造方法,Python会自动为该类定义一个只包含self参数的默认的构造方法;

    2. 创建与使用对象(对象也称为实例)

    语法格式:

    对象变量 = 类名()
    # 本质是调用类里面的构造方法创建对象

    对象访问方法或者变量的语法格式: 对象.变量|方法(参数)

    class Dog:
        def __init__(self, sex="公", classification="二哈"):
            # 为Dog对象定义了两个实例变量,self表示调用该函数的对象,self.变量就是实例变量
            self.sex = sex
            self.classification = classification
    
    # 创建对象的本质是根据构造函数创建对象,所以参数值要与构造函数的参数相匹配
    # 如果不传入参数,因为有默认参数值,对象将按照默认参数值创建
    # 如果没有默认参数值,并且创建对象不传入参数值,程序将出现错误
    my_dog_1 = Dog()
    print(my_dog_1.sex, my_dog_1.classification)
    # 公 二哈
    my_dog_2 = Dog("母", "斗牛犬")
    print(my_dog_2.sex, my_dog_2.classification)
    # 母 斗牛犬

    1)增加或删除实例变量

    增加实例变量:为新变量赋值即可;

    删除实例变量:del语句;

    my_dog_2.name = "林林"
    print(my_dog_2.name)
    # 林林
    del my_dog_2.sex
    print(my_dog_2.sex)
    # 程序错误:AttributeError: 'Dog' object has no attribute 'sex'

    2)增加实例方法

    !!!为对象动态增加的方法,python不会自动将第一个参数self指向调用的对象;

    # 先定义一个函数
    def feed_food(self, type):
        if type=="breakfast":
            print("1号类型狗粮")
        elif type=="lunch":
            print("2号类型狗粮")
        else:
            print("3号类型狗粮")
    
    # 使用函数feed_food对对象my_dog_2的方法food赋值
    my_dog_2.food = feed_food
    # 手动指定self参数为调用者
    my_dog_2.food(my_dog_2, "lunch")
    # 2号类型狗粮

    使用MethodType可以将动态增加的方法设置为自动将第一个参数指向调用者:可以看到调用该方法时不需要指定第一个参数为调用者了;

    from types import MethodType
    my_dog_2.food = MethodType(feed_food, my_dog_2)
    my_dog_2.food("lunch")
    # 2号类型狗粮

    当Python对象的一个方法调用其他方法时,不可以省略self;

    class Dog:
        def __init__(self, sex="公", classification="二哈"):
            # 为Dog对象定义了三个实例变量
            self.sex = sex
            self.classification = classification
            self.health = 1
        def is_dog_healthy(self):
            if self.health == 1:
                return True
            else:
                return False
    
        def feed_food(self, type):
            # 该方法调用其他方法self不能省略
            if self.is_dog_healthy()==False:
                print("狗狗得病了需要吃好的")
            elif type == "breakfast":
                print("1号类型狗粮")
            elif type == "lunch" :
                print("2号类型狗粮")
            else:
                print("3号类型狗粮")

     

    展开全文
  • Python类对象创建和使用

    千次阅读 2019-07-08 11:29:53
    创建对象的根本途径是构造方法,调用某个的构造方法即可创建这个对象Python 无须使用 new 调用构造方法。 前面章节中,我们已经创建了名为 Python: class Person : '这是一个学习Python定义的一...
  • type还有一种完全不同的功能,动态的创建类。type可以接受一个类的描述作为参数,然后返回一个类。(要知道,根据传入参数的不同,同一个函数拥有两种完全不同的用法是一件很傻的事情,但这在Python中是为了保持向后...
  • 一个类创建对象可以是另一个类创建对象的属性 需求 1. 士兵有一把AK47 2. 士兵可以开火 3. 枪能够发射子弹 4. 枪装填子弹 # coding:utf-8 class Gun: def __init__(self, model): self.model = model ...
  • dlib rectangle类对象创建 (python版)

    千次阅读 2018-08-13 18:43:53
    在使用dlib库时,有时需要自己创建rectangle对象作为某些dlib的函数的输入。 根据dlib.rectangle的定义: __init__(self: dlib.rectangle, left: int, top: int, right: int, bottom: int)  可以使用四个整数...
  • Python 对象

    万次阅读 多人点赞 2019-04-10 16:49:40
    对象的理解与封装特性 面向对象编程语言 - : 一个模板, (人类)---是一个抽象的, 没有实体的 - 对象: (eg: 张三, 李四) - 属性: (表示这东西的特征, 眼睛, 嘴巴, 鼻子) - 方法: (表示这物体可以...
  • Python学习:类对象和实例对象

    千次阅读 2019-01-24 13:01:43
    # 定义C class C: count = 0 # 类对象C() a = C() ...# 实例对象a,b ...可以看出对实例对象a的count属性进行赋值之后,就相当于覆盖了类对象C的count属性。如果没有赋值覆盖,那么引用的是类对象的co...
  • Python-类对象方法和实例对象方法

    千次阅读 2018-06-05 13:33:26
    自己总结python类类对象方法和实例对象方法,其判断的方法是: (1)首先看方法定义是否引用了self,带了self,肯定为实例对象方法。 (2)其次,看是否带参数,如果不带参数,肯定是类对象方法。 (3)除了...
  • Python同时创建多个对象的想法

    千次阅读 2017-10-09 23:58:18
    利用字典创建类的多个对象,从而大大的方便了创建对象。并指出了字典的fromkeys方法的错误。
  • Python-封装对象类

    千次阅读 2018-11-10 19:31:42
    正因为如此,在Python创建一个对象是很容易的,当然如果习惯面向过程或者函数的写法也是可以的,Python并不做硬性的限制。 接下来一步一步的和大家分享一下Python是怎么样封装的。 版本一: 封装一个,最...
  • Python创建对象与赋值

    千次阅读 2017-05-25 23:51:03
    Python是面向对象的语言,在Python在一切皆为对象。函数、属性都可以作为对象赋值给变量,并且规定参数的传递都是传递对象... python与C/C++,java等强类型语言不同,在创建对象的时候不需要指定类型。而是通过对象
  • # 创建士兵 Mak = Solder('makchikin') # 创建枪 AK47 = Gun('AK47') # Mak获得AK47 Mak.gun = AK47 # 开枪60次 for i in range(60): # 查询子弹数量 bulletsNum = Mak.gun.queryBulletsNum() if ...
  • python批量创建对象

    千次阅读 2019-06-18 17:52:51
    1、函数内(locals): class A(): def __init__(self): self.val = 10 for i in range(10): locals()[f'x{i}'] = A() ...2、内: class A(): def __init__(self): self.val = 10 class B(): ...
  • Y14 一、类对象和实例对象 简短理论: 类对象是将具有相似属性和方法的对象总结抽象为类对象,可以定义相似的一些属性和方法,不同的实例对象...首先,要明白,在python中,“万物皆对象”。个人理解:   类对象...
  • Python一个可以创建几个对象

    千次阅读 2020-04-24 14:52:51
    一个可以创建几个对象? 1.一个可以创建多个对象 2.多个对象都调用函数的时候,self地址不相同
  • python对象

    千次阅读 2017-12-09 12:20:28
    python对象 一、 python 可以比作是某种类型集合的描述 把一相同的事物叫做,其拥有相同的属性(其实就是变量)描述,里面封装了相同的方法。比如,汽车是一个,它包括价格、品牌等属性。   二、...
  • 1、self ...通过在属性名前可以加上双下划线可以将其伪私有化,这样只能通过的方法来访问了,为什么是伪呢,因为Python 利用叫name mangling的方式在内部把这些变量的名字改了,在外部通过...
  • Python学习笔记(九):对象

    万次阅读 热门讨论 2021-02-10 01:16:44
    关于对象Python学习笔记(九):和对象一.和对象的定义的实例化对象的使用二.self用法三.方法实例方法方法静态方法静态方法和方法的区别四.命名空间 一.和对象 (class)和对象(object,...
  • 为了让更多的人看到本文,请各位读者动动小手,点击右上角【...】,将本文分享到朋友圈,thanks!Python类的定义再简单不过了。不过你有想过动态定义一个Python类吗?What...
  • 这里写自定义目录标题本次链接全集初衷实现基础动手补充:生成对象的方法、eval()、exec()及其相关函数新的问题 本次链接全集 ...Python进阶-自定义基础5 python 深入理解 赋值、引用、拷贝、...
  • python中从变量到对象的连接称作引用。也就是说,引用是一种关系,以内存中的指针的形式实现。具体而言:变量是一个系统表的元素,拥有指向对象的连接的空间。对象是分配的一块内存,有足够的空间去表示它们所代表的...
  • 学习笔记之——Python对象的理解

    千次阅读 多人点赞 2019-01-16 20:26:13
    学习笔记之——Python对象的理解一、 面向对象的含义和特性二、1. Python的定义、结构、创建1. Python类的定义2. Python类的结构3. 创建4. 的属性5. 的方法三、对象1. 对象创建四、参考资料 ...
  • Python面向对象写Student

    千次阅读 2019-04-25 21:29:49
    直接看代码写法: class Student: "这是Student类的说明" #__doc__ ... def __init__(self, name, age): #构造函数,创建类的实例调用 print("构造方法!") self.name = name #self代表对象 ...
  • python创建类属性

    千次阅读 2016-11-13 20:21:02
    python创建类属性 类是模板,而实例则是根据类创建的对象。 绑定在一个实例上的属性不会影响其他实例,但是,类本身也是一个对象,如果在类上绑定一个属性,则所有实例都可以访问类的属性,并且,所有实例访问...
  • python类与面向对象编程

    千次阅读 2016-07-16 18:44:24
    与面向对象编程(class)是python中的一种内建模块,在许多语言甚至在一些库中都用到了python的标准库也不例外。理解什么是,如何实用,并且怎样用好python是非常重要的,当然这也是此文的目的所在。在...
  • Python学习笔记(十一):对象

    万次阅读 2021-02-11 00:10:46
    关于对象Python学习笔记(十一):和对象一.变量和实例变量变量实例变量二.函数装饰器带参数的函数装饰器函数装饰器的嵌套三.property()四.封装机制五.继承机制 一.变量和实例变量 变量 实例变量 二....
  • 定义一个 Circle,以及相关函数(方法) 、函数定义 语法: class 类名:  体  体分两部分: 变量(静态变量)部分, 方法(函数)部分 import math class Circle: # def __init__(self, radius): ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 986,691
精华内容 394,676
关键字:

如何创建类的对象python

python 订阅