精华内容
下载资源
问答
  • python 创建类cell数组

    千次阅读 2019-05-09 19:08:48
    When you do this: a = np.array([[np.array([[2, 2]]), np.array([[3, 3]])]]) 1 the final call to np.array actually concatenates the inner two, so you get one array at the end: >...

     

    When you do this:

    a = np.array([[np.array([[2, 2]]), np.array([[3, 3]])]])
    • 1

    the final call to np.array actually concatenates the inner two, so you get one array at the end:

    >>> a
    array([[[[2, 2]],
    
            [[3, 3]]]])
    
    >>> a.shape
    (1, 2, 1, 2)

    But to mimic a cell array you want to basically have an array of arrays. You can acheive this by setting dtype=object, but you must create the array and set the elements separately to avoid the automatic merging.

    three = array([[array([[2, 2, 2]]), array([[3, 3]])]])
    two = np.empty(three.shape, dtype=object)
    two[0,0,0] = np.array([[2,2]])
    two[0,1,0] = np.array([[3,3]])
    •  

    Then:

    sio.savemat('two.mat', {'two': two})
    •  

    to see what they look like:

    >>> two
    array([[[array([[2, 2]])],
            [array([[3, 3]])]]], dtype=object)
    
    >>> two.shape
    (1, 2, 1)
    •  

    Note that I may have gotten confused about your desired shape, since you have so many nested brackets, so you might have to reshape some of this, but the idea should hold regardless.

    例如:

    npose = 5
    nsmile = 2
    
    poseSmile_cell = np.empty((npose,nsmile),dtype=object)
    
    for i in range(5):
        for k in range(2):
            poseSmile_cell[i,k] = np.zeros((4,4))
    
    
    print poseSmile_cell.shape
    展开全文
  • 关于python创建类的深入理解

    千次阅读 2018-01-25 15:45:07
    我们知道在python中一切皆为对象的概念,那我们们来看一段程序 class Foo(object): def __init__(self, name): self.name = name f = Foo("sty") print(type(f)) print(type(Foo)) #output: # # 如果按照...

    背景

    我们知道在python中一切皆为对象的概念,那我们们来看一段程序

    class Foo(object):
        def __init__(self, name):
            self.name = name
    
    
    f = Foo("sty")
    print(type(f))
    print(type(Foo))
    
    #output:
    # <class '__main__.Foo'>
    # <class 'type'>

    如果按照一切事物都是对象的理论:f对象是通过执行Foo类的构造方法创建,那么Foo类对象应该也是通过执行某个类的 构造方法 创建.
    通过打印我们可以知道:f对象是Foo类的一个实例,Foo类对象是 type 类的一个实例,即:Foo类对象 是通过type类的构造方法创建。

    创建类的深入

    那么我们可以知道将可以有两种方法来在python中创建类了
    普通方法

    class Foo(object):
        def talk(self):
            print 'hello sty'
    
    f = Foo()
    f.talk()

    特殊方式

    def func(self):
        print('hello sty')
    
    Foo = type('Foo', (object,), {'talk': func}) #创建Foo类
    
    f = Foo()
    f.talk()
    #type第一个参数:类名
    #type第二个参数:当前类的基类
    #type第三个参数:类的成员

    上面的第一种方法是我们常用而且熟悉的,而第二种方法也和第一种方法有着同样的效果。
    我们还可以在第二种方法的基础上加上构造函数:

    def func(self):
        print('hello %s' % self.name)
    
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    
    Foo = type('Foo', (object,), {'talk': func, '__init__': __init__})
    
    f = Foo("jack", 22)
    f.talk()
    #output:
    #hello jack

    所以我们可以得到一个结论:类默认是由 type 类实例化产生的
    你可以看到, 在Python中, 类也是对象, 你可以动态的创建类。 这就是当你使用关键字class时Python在幕后做的事情, 而这就是通过元类来实现的。

    什么是元类?

    元类就是创建类的东西.
    你是为了创建对象才定义类的,对吧?
    但是我们已经知道了Python的类是对象.
    这里,元类创建类.它们是类的类,你可以把它们想象成这样:

    MyClass = MetaClass()
    MyObject = MyClass()

    我们可以通过type来实现这样的效果:

    MyClass = type('MyClass', (), {})

    这是因为 type 就是一个元类. type 是Python中创建所有类的元类
    现在你可能纳闷为啥子 type 用小写而不写成 Type ?
    我想是因为要跟 str 保持一致, str 创建字符串对象, int 创建整数对象. type 正好创建类对象.
    你可以通过检查 class 属性来看到这一点.
    Python中所有的东西都是对象.包括整数,字符串,函数还有类.所有这些都是对象.所有这些也都是从类中创建
    的:

    >>> age = 35
    >>> age.__class__
    <type 'int'>
    >>> name = 'bob'
    >>> name.__class__
    <type 'str'>
    >>> def foo(): pass
    >>> foo.__class__
    <type 'function'>
    >>> class Bar(object): pass
    >>> b = Bar()
    >>> b.__class__
    <class '__main__.Bar'>

    那么,classclass属性是什么?

    >>> age.__class__.__class__
    <type 'type'>
    >>> name.__class__.__class__
    <type 'type'>
    >>> foo.__class__.__class__
    <type 'type'>
    >>> b.__class__.__class__
    <type 'type'>

    所以,元类就是创建类对象的东西.
    如果你愿意你也可以把它叫做’类工厂’. type 是Python的内建元类,当然,你也可以创建你自己的元类

    那么问题来了
    类默认是由 type 类实例化产生,type类中如何实现的创建类?类又是如何创建对象?
    答:类中有一个属性 metaclass,其用来表示该类由 谁 来实例化创建,所以,我们可以为 metaclass 设置一个type类的派生类,从而查看 类 创建的过程。

    metaclass属性

    当你创建一个函数的时候,你可以添加 metaclass 属性:

    class Foo(object):
        __metaclass__ = something
        ...

    如果这么做了,python就会用元类来创建类Foo
    你首先写下 class Foo(object), 但是类对象 Foo 还没有在内存中创建.
    Python将会在类定义中寻找 metaclass .如果找到了就用它来创建类对象 Foo .如果没找到,就会默认
    用 type 创建类.
    把下面这段话反复读几次。
    当你写下如下代码时候:

    class Foo(Bar):
        pass

    Python将会这样运行:
    在 Foo 中有没有 _metaclass_ 属性?
    如果有,Python会在内存中通过 metaclass 创建一个名字为 Foo 的类对象(我说的是类对象,跟紧我的思
    路).
    如果Python没有找到 metaclass , 它会继续在Bar(父类) 中寻找 metaclass属性 , 并尝试做和前面
    同样的操作.
    如果Python在任何父类中都找不到 metaclass , 它就会在模块层次中去寻找 metaclass , 并尝试做
    同样的操作。
    如果还是找不到 metaclass ,Python就会用内置的 type 来创建这个类对象。
    现在的问题就是, 你可以在 metaclass 中放置些什么代码呢?
    答案就是:可以创建一个类的东西。
    那么什么可以用来创建一个类呢? type , 或者任何使用到 type 或者子类化 type 的东东都可以。
    自定义元类
    元类的主要目的就是为了当创建类时能够自动地改变类.
    通常, 你会为API做这样的事情, 你希望可以创建符合当前上下文的类.
    假想一个很傻的例子, 你决定在你的模块里所有的类的属性都应该是大写形式。 有好几种方法可以办到,
    但其中一种就是通过在模块级别设定 metaclass .
    采用这种方法, 这个模块中的所有类都会通过这个元类来创建, 我们只需要告诉元类把所有的属性都改成
    大写形式就万事大吉了。

    def upper_attr(future_class_name, future_class_parents, future_class_attr):
        uppercase_attr = {}
        for name, val in future_class_attr.items():
            if not name.startswith('__'):
                uppercase_attr[name.upper()] = val
            else:
                uppercase_attr[name] = val
        return type(future_class_name, future_class_parents, uppercase_attr)
    
    # __metaclass__ = upper_attr
    
    # class Foo():
    #     bar1 = 'bip'
    class Foo(object, metaclass=upper_attr):
        bar='bip'
    
    # False
    print(hasattr(Foo, 'bar'))
    
    # True
    print(hasattr(Foo, 'BAR'))
    
    f = Foo()
    # bip
    print(f.BAR)
    

    继续深入

    先来看一段代码,我们来了解一下__new__

    class Foo(object):
        def __init__(self,name):
            self.name = name
            print("Foo __init__")
    
        def __new__(cls, *args, **kwargs):
            print("Foo __new__",cls, *args, **kwargs)
            return object.__new__(cls)    #继承父亲的__new__方法,如果注释改行,类没法实例化
    
    f = Foo("Alex")
    print("f",f)
    print("fname",f.name)
    
    # output
    # Foo __new__ <class '__main__.Foo'> sty
    # Foo __init__
    # f <__main__.Foo object at 0x000001EF9AB7B518>
    # fname sty

    我们可以知道__new__是在__init__之前执行的,并且我们在把

    return object.__new__(cls) 

    注释掉之后,类是没办法实例化的,所以我们可以知道,类其实是通过__new__来实例化的,并且是在__new__中调用的__init__,所以在实例化的时候是先执行的__new__,然后再执行的__init__,一般情况下是不用写的,父类是有的。

    再看段代码,了解下__call__的执行顺序:

    class MyType(type):
        def __init__(self,*args,**kwargs):
    
            print("Mytype __init__",*args,**kwargs)
    
        def __call__(self, *args, **kwargs):
            print("Mytype __call__", *args, **kwargs)
            obj = self.__new__(self)
            print("obj ",obj,*args, **kwargs)
            print(self)
            self.__init__(obj,*args, **kwargs)
            return obj
    
        def __new__(cls, *args, **kwargs):
            print("Mytype __new__",*args,**kwargs)
            return type.__new__(cls, *args, **kwargs)
    
    print('here...')
    class Foo(object, metaclass = MyType):
    
        def __init__(self,name):
            self.name = name
            print("Foo __init__")
    
        def __new__(cls, *args, **kwargs):
            print("Foo __new__",cls, *args, **kwargs)
            return object.__new__(cls)    #如果注释改行,类没法实例化
    
    f = Foo("sty")
    print("f",f)
    print("fname",f.name)
    
    #output:
    #here...
    # Mytype __new__ Foo (<class 'object'>,) {'__module__': '__main__', '__qualname__': 'Foo', '__init__': <function Foo.__init__ at 0x0000014DBE6A4950>, '__new__': <function Foo.__new__ at 0x0000014DBE6A49D8>}
    # Mytype __init__ Foo (<class 'object'>,) {'__module__': '__main__', '__qualname__': 'Foo', '__init__': <function Foo.__init__ at 0x0000014DBE6A4950>, '__new__': <function Foo.__new__ at 0x0000014DBE6A49D8>}
    # Mytype __call__ sty
    # Foo __new__ <class '__main__.Foo'>
    # obj  <__main__.Foo object at 0x0000014DBE6BB5C0> sty
    # <class '__main__.Foo'>
    # Foo __init__
    # f <__main__.Foo object at 0x0000014DBE6BB5C0>
    # fname sty

    通过执行结果我们可以知道:
    类的生成 调用 顺序依次是 __new__ --> __init__ --> __call__

    结语

    这有什么卵用?
    大多数情况下是没什么卵用的,

    “元类就是深度的魔法, 99%的用户应该根本不必为此操心。 如果你想搞清楚究竟是否需要用到元类, 那么你就不需要它。
    那些实际用到元类的人都非常清楚地知道他们需要做什么, 而且根本不需要解释 为什么要用元类。 ” —— Python界的领袖 Tim Peters

    元类的主要用途是创建API。 一个典型的例子是Django ORM。

    如果想更加深入的了解:
    可以查看:
    https://stackoverflow.com/questions/100003/what-are-metaclasses-in-python#

    参考文献

    https://stackoverflow.com/questions/100003/what-are-metaclasses-in-python#
    http://www.cnblogs.com/alex3714/articles/5213184.html

    转载请注明出处:
    CSDN:楼上小宇_home:http://blog.csdn.net/sty945
    简书:楼上小宇:http://www.jianshu.com/u/1621b29625df

    展开全文
  • 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 ,实例化 Traceback (most recent call last):  File "E:/PythonDemo/com/song/python_demo_class.py", line 72, in &lt;module&gt;  my_car = Car('audi', 'a4', 2019)...

    在创建python 类,实例化

    Traceback (most recent call last):
      File "E:/PythonDemo/com/song/python_demo_class.py", line 72, in <module>
        my_car = Car('audi', 'a4', 2019)

    TypeError: Car() takes no arguments

     最后发现问题是:   def __init__定义时出问题了,推荐IDEA 或 pyCharm 自动提示输入,避免不必要的错误

     

    展开全文
  • python中,创建类可以这样: class A: pass 也可以这样: class A(object): pass 那么二者有什么区别和联系呢? 看下面的这个图: 这是新式类和旧式类的区别。
  • python动态创建类

    千次阅读 2017-02-08 19:44:07
    python动态创建类 Dynamically create a type with Python
  • 为了让更多的人看到本文,请各位读者动动小手,点击右上角【...】,将本文分享到朋友圈,thanks!Python类的定义再简单不过了。不过你有想过动态定义一个Python类吗?What...
  • python创建空元组_用Python创建空元组

    千次阅读 2020-07-28 22:01:19
    python创建空元组 Python | 空元组 (Python | empty tuple) In python, we can also create a tuple without having any element. An empty tuple is created using a pair of round brackets, (). 在python中,...
  • Python创建类和使用类

    千次阅读 2017-11-10 12:22:27
    作为初学者,也不清楚python跟java中的有哪些区别,在此就简单总结一下自己近期学习python的时候一些应该注意的点。 以下面一段代码为例 class Dog(): #“一次模拟小狗的简单尝试” def _init_(self,name,age)...
  • python创建类的两种方法

    千次阅读 2018-08-22 19:33:21
    创建类第一种普遍方式可能都清楚,用class关键字: #第一种方法创建类 class A(object): def __init__(self, name): self.name = name f = A("lkk") 这样就简单完成了一个A类的创建,我们尝试打印...
  • Python中动态创建类实例

    万次阅读 2017-03-24 09:15:43
    Python中动态创建类实例简介在Java中我们可以通过反射来根据类名创建类实例,那么在Python我们怎么实现类似功能呢?其实在Python有一个builtin函数import,我们可以使用这个函数来在运行时动态加载一些模块。如下:def...
  • Python中子创建

    千次阅读 2016-10-14 12:10:38
    靠继承来进行子类化是创建和定制新类型的一种方式,新的将保持已存在所有的特性, 而不会改动原来的定义(指对新的改动不会影响到原来的,译者注)。对于新的类型来说, 这个新的子类可以定制只属于...
  • python创建neo4j图库节点及节点之间的关系

    万次阅读 多人点赞 2020-08-07 11:29:30
    python创建neo4j节点及节点之间的关系(连接)打开neo4j本地服务器,python连接。(数据加载)需要创建的节点及其关系重点(neo4j与python代码演示)①创建节点函数②查询节点函数③节点之间创建关系函数④加载进...
  • 一、用Python创建一个新文件,内容是从0到9的整数, 每个数字占一行:#python>>>f=open('f.txt','w') # r只读,w可写,a追加>>>for i in range(0,10):f.write(str(i)+' '). . .>>> f.close()二、文件内容追加,从0到9...
  • Python创建压缩文件

    千次阅读 2019-01-17 10:59:10
    -----转载国外课栈网 Python允许您快速创建zip / tar存档。 以下命令将压缩整个目录 shutil.make_archive(output_filename,“zip”,DIR_NAME) ...步骤1) 要从Python创建存档文件,确保您的import语句正...
  • Python创建和使用方法

    千次阅读 2019-03-13 06:56:31
    面向对象编程(OOP)是最有效的软件编写方法之一,我们会使用到类(CLASS)来定义出一大类对象都有的行为,当我们基于类来创建对象时,...1. 创建类 简单来说我们定义的类应该包含两部分:属性+功能。 我们来定义一...
  • Python 创建XML

    万次阅读 多人点赞 2015-10-31 18:40:16
    xml.dom.minidom模块实现创建一个XML文档。创建XML的过程1、内存数据产生 2、产生xml内存对象(也就是DOM树) 3、产生根对象 4、往根对象里加数据 5、把xml内存对象写到文件 下面是一个创建xml文档的简单实例:...
  • python创建和实例化

    万次阅读 2018-07-27 09:24:15
    python中同样使用关键字class创建一个名称第一个字母大写,可以带括号也可以不带括号; python中实例化不需要使用关键字new(也没有这个关键字),的实例化类似函数调用方式; # coding: utf-8 # 创建...
  • '123456789101112131415161718192021222324252627282930123456789101112131415161718192021222324252627282930 比较常用MODE 不清空连续写入 没有文件时候会自动创建的,但是!如果我重新对此进行写入,那么会先清空...
  • python创建二维数组

    万次阅读 多人点赞 2018-08-17 18:07:25
    写代码的时候需要使用python创建二维数组: num_list = [ [0]*5 ]*2 print(num_list) 输出:[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0]] 看输出觉得这种方法是对的,结果程序出现了错误,经过分析,这种创建二维数组的...
  • 使用python创建学生管理系统

    万次阅读 多人点赞 2019-11-17 11:36:05
    使用python创建学生管理系统 创建学生管理系统,可谓是学习编程最基础的一小步。 主要是分为以下几个思路: 接下来直接上源码 #!/usr/bin/python3 # coding=utf-8 # 导入包 import random # 全局变量 # 函数 # #...
  • python中的数据都是以对象的方法存在,对象就是一个既有属性也有方法的,比如list一个列表,列表有append,切片的方法。我也可以同样创建属于自己的,然后可以直接初始化性,调用里面的方法,及属性。 1、的...
  • python创建一个txt文件

    万次阅读 多人点赞 2018-11-12 23:41:41
    创建一个txt文件,文件名为mytxtfile,并向文件写入msg 注意文件的路径不要错,还有文件的格式 # 创建一个txt文件,文件名为mytxtfile,并向文件写入msg def text_create(name, msg): desktop_path = "C:\\...
  • python创建虚拟环境合集

    千次阅读 2020-05-09 14:54:49
    python创建虚拟环境合集前言vitrtualenv和virtualenvwrapper安装配置环境变量验证基本使用参考: 前言 该博客用于记录python虚拟环境的使用,将会持续更新。 vitrtualenv和virtualenvwrapper 1、安装 2、配置path...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,231,326
精华内容 492,530
关键字:

python创建类

python 订阅