Re: [python-chinese] 哪位大哥知道type 与class 的区别？

[yi huang]

没区别。

--
http://codeplayer.blogspot.com/

[shhgs]

class和type的区别

打一个比方。在学OO的时候，老师会说，class就是一个模子，往里面浇铁水之后，就有了对象了。

OK，这里就有问题了。你写的代码，相当于工程师设计的图纸，而图纸是没有办法往里面浇铁水的，你得把图纸变成模子，才能往里面浇东西。

于是，你写的代码，定义了一个算法。这个算法别称为class。

你的class，交给type，type根据你的class，加工出一个模子，然后你就可以往里面浇铁水生成instance了。这个type就类似于工厂的生产能力，工艺流程，或者。。。在编程的时候，这个type是语言的一种机制，能把你用代码定义的算法，也就是class，解释成能生成object，或者说instance(其实这个术语更好)的一种object(在解释meta
programming的时候，一定要区分instance和object。这也是为什么，我曾经宣称，OOP应该是面向客体的编程。)。

OK，Py的type有很多，你import
types然后dir(types)可以看到很多。具体而言，每种type都是一种组织内存的方式。比如说，Python内部表示类的对象，同表示instance的对象，其内部构造是不同的。那么这个内部构造是怎么定义的呢？就是这个type定义的。比如，每个instance都应该有一个dict，有表示其parent的tuple，此外还有初始化的时候，生成的parent类的对象(这部分具体应该问Robert
Chen，我菜了)。而class里面可能就没有这么些东西。反正这就是type定义的。

接下来的东西，你可以去看Py in a
nutshell了。Alex把福尔摩斯推理的最重要的一页给撕了。我也是琢磨了半天，最后在看Programming
Ruby的时候搞懂的。现在给你补齐，应该能看懂了。

On 3/7/07, Alex Cheng <chengx...@gmail.com> wrote:
> 谢谢了。
>
> --
> powered by python
> _______________________________________________
> python-chinese
> Post: send python-...@lists.python.cn
> Subscribe: send subscribe to
> python-chin...@lists.python.cn
> Unsubscribe: send unsubscribe to
> python-chin...@lists.python.cn
> Detail Info:
> http://python.cn/mailman/listinfo/python-chinese
>
_______________________________________________
python-chinese
Post: send python-...@lists.python.cn
Subscribe: send subscribe to python-chin...@lists.python.cn
Unsubscribe: send unsubscribe to python-chin...@lists.python.cn
Detail Info: http://python.cn/mailman/listinfo/python-chinese

[yi huang]

你的class，交给type，type根据你的class

，加工出一个模子，然后你就可以往里面浇铁水生成instance了。这个type就类似于工厂的生产能力，工艺流程，或者。。。在编程的时候，这个type是语言的一种机制，能把你用代码定义的算法，也就是class，解释成能生成object，或者说instance(其实这个术语更好)的一种object(在解释meta
programming的时候，一定要区分instance和object。这也是为什么，我曾经宣称，OOP应该是面向客体的编程。)。

我觉得你搞混了，或者就是我没读懂你说的话。
把 class 比喻成 模子 在c++这样的语言里面比较合适，因为那里 class 确实只是编译时用来创建对象的一个模子，在运行时没有任何作用。
但是 python 里面 class 也是一个实实在在的对象，他还也有他的类型。
我们应该把所有东西都理解成为对象，对象之间有一种关系叫实例化。
所谓类型是相对而言的，一个对象可以其他对象的类型，同时又是另一个对象的实例。

OK，Py的type有很多，你import
types然后dir(types)可以看到很多。具体而言，每种type都是一种组织内存的方式。比如说，Python内部表示类的对象，同表示instance的对象，其内部构造是不同的。那么这个内部构造是怎么定义的呢？就是这个type定义的。比如，每个instance都应该有一个dict，有表示其parent的tuple，此外还有初始化的时候，生成的parent类的对象(这部分具体应该问Robert
Chen，我菜了)。而class里面可能就没有这么些东西。反正这就是type定义的。

types 里面只是一些内置的类型而已。

总之 type 和 class 之间到底有没有区别首先得定义这两个概念先，如果说内置类型为 type ，通过 class 语句定义自定义类型为 class 的话，他们当然是有区别的，但这样的定义没有什么意义，因为自定义的类型也可以继承内置的类型，比如：
class MyList(list):pass
难道 MyList 是 class，list 就是 type 吗？我想这种区分没有什么意义。

总之把所有东西都当做对象来看就好了，而类型是个相对的概念，类型对于它实例来说是类型，对于他的类型来说是实例！

--
http://codeplayer.blogspot.com/

[yi huang]

另外：
type(...type(a)...)
实际上就是
a.__class__...__class__

从这个角度来看，python 里面 type 和 class 两个词语的意思是一样的。

--
http://codeplayer.blogspot.com/

[Nick Cen]

我同意yi huang说的type是内置类型的概念。在OO里面不管你类怎么定义，类的所有属性最终都是指向一些系统的内置类型。这些类型的名字就叫做type。
我觉得这跟数学里面数的定义一样。1是最基本的，其他的数字都可以通过对1进行加法来定义，而1本身则无法通过加法这个法则来定义。
面向对象也是这样，所有的对象，都可以通过组合其他对象和一些内置属性进行定义。而这些内置属性则是无法通过语言本身提供的面向对象机制定义的。

在 07-3-7，yi huang<yi.cod...@gmail.com> 写道：

[shhgs]

type和class绝对不同。

Python里面的所有对象，都是由type制造的。相应的type制造一个blanket的对象，然后解释器再根据你的源代码，往这个blanket的对象里面塞东西。

空白的class object是由types.ClassType或者types.TypeType创建的。而你写的代码，会先在一个dict里面运行，然后塞进这个blanket的class
object里面。

>>> code = """
def func(self) :
print "blah, blah, blah"
"""
>>> d = dict()
>>> exec(code, d)

>>> import types
>>> old_class = types.ClassType("OldClass", (), d)
>>> o = old_class()
>>> o.func()
blah, blah, blah

>>> new_class = types.TypeType("NewClass", (), d)
>>> o = new_class()
>>> o.func()
blah, blah, blah

instance一一样。先由types.InstanceType创建一个blanket的instance。在new
class里面，这一步可以通过__new__控制。而所谓的meta
programming正是在这个__new__里面搞花样。blanket的instance创建完毕，再把dict绑定过去。这样，一个instance就有了。

On 3/7/07, Leira Hua <lh...@altigen.com.cn> wrote:
> 关于type和class的差别，"Python Types and Objects"
> (http://www.cafepy.com/article/python_types_and_objects/)这篇文章讲得非常详
> 细，推荐阅读。
>
>
> On Wed, 07 Mar 2007 14:38:35 +0800, Alex Cheng
> <chengx...@gmail.com> wrote:
>
> > 小弟才疏学浅，可不可以这样理解：
> > Type 描述了instance 的内存结构， class 是type 的一种instance, 而class 的
> > object 也是由一个特殊的type(ObjectType)构成。
> >
> > 也就是说Python 世界是由对象组成的： 有对象工厂 (Type 及其继承), 有类对象
> > (由ClassType), 有方法对象(由FunctionType 创建, function 关键字定义), ...
>
>
>
> --
> Leira Hua
> http://my.opera.com/Leira

[刘鑫]

受教了，果然经典。

在07-3-7，shhgs <shhgs....@gmail.com> 写道：

type和class绝对不同。

Python里面的所有对象，都是由type制造的。相应的type制造一个blanket的对象，然后解释器再根据你的源代码，往这个blanket的对象里面塞东西。

空白的class object是由types.ClassType或者types.TypeType创建的。而你写的代码，会先在一个dict里面运行，然后塞进这个blanket的class
object里面。

>>> code = """
def func(self) :
        print "blah, blah, blah"
"""
>>> d = dict()
>>> exec(code, d)

>>> import types
>>> old_class = types.ClassType("OldClass", (), d)
>>> o = old_class()
>>> o.func()
blah, blah, blah

>>> new_class = types.TypeType("NewClass", (), d)
>>> o = new_class()
>>> o.func()
blah, blah, blah

instance一一样。先由types.InstanceType创建一个blanket的instance。在new
class里面，这一步可以通过__new__控制。而所谓的meta
programming正是在这个__new__里面搞花样。blanket的instance创建完毕，再把dict绑定过去。这样，一个instance就有了。



On 3/7/07, Leira Hua <lh...@altigen.com.cn> wrote:
> 关于type和class的差别，"Python Types and Objects"

> ( http://www.cafepy.com/article/python_types_and_objects/)这篇文章讲得非常详

> 细，推荐阅读。
>
>
> On Wed, 07 Mar 2007 14:38:35 +0800, Alex Cheng
> <chengx...@gmail.com > wrote:
>
> > 小弟才疏学浅，可不可以这样理解：
> > Type 描述了instance 的内存结构， class 是type 的一种instance, 而class 的
> > object 也是由一个特殊的type(ObjectType)构成。
> >
> > 也就是说Python 世界是由对象组成的： 有对象工厂 (Type 及其继承),  有类对象
> > (由ClassType), 有方法对象(由FunctionType 创建, function 关键字定义), ...
>
>
>
> --
> Leira Hua
> http://my.opera.com/Leira
>
> _______________________________________________
> python-chinese
> Post: send python-...@lists.python.cn
> Subscribe: send subscribe to python-chin...@lists.python.cn
> Unsubscribe: send unsubscribe to  python-chin...@lists.python.cn
> Detail Info: http://python.cn/mailman/listinfo/python-chinese
_______________________________________________
python-chinese
Post: send python-...@lists.python.cn
Subscribe: send subscribe to python-chin...@lists.python.cn
Unsubscribe: send unsubscribe to   python-chin...@lists.python.cn
Detail Info: http://python.cn/mailman/listinfo/python-chinese

--
Blog搬家了

刘鑫
March.Liu

[shhgs]

OK, class和type有不同的理解。我这里先解释一下我的定义。

class是指你源代码里面

----------------------------------
class MyClass :
def blah() :
........
----------------------------------

用这种语法定义的类。

而type是指

-------------------------------------
>>> import types
>>> dir(types)
..................
-------------------------------------

你看到的这些东西。

这两者截然不同。他们之间的关系，我用如下一个比喻解释。

你是一个工程师。你现在设计一个很复杂的系统，里面用到了OOP的解决方案。你定义了各种对象，然后让他们相互传消息解决问题。

但是你只是在图纸上设计了这些对象，定义了它们的接口。你不能直接往图纸里浇铁水，你得有模子。

OK，你拿着图纸，找到一家叫Py的工厂。这个工厂拿到图纸之后说，没问题，我给你造。于是它根据图纸造一个模子(class
object)。制造模子的时候，工厂用的是自己的生产工具(types.ClassType，或者tpyes.TypeType，看你用new
class还是old class)。

但是光有模子没用，你要的是解决问题，你得让工厂再按照你的图纸生产处一些能收发消息的对象。

Py工厂说，没问题，有了模子还愁instance吗。只是我们的模子只能我们自己用。于是它再备料。这次出场的是InstanceType。你可以把InstanceType想成一种类似塑料一样的东西。原本你以为工厂是会往模子里浇铁水的，结果它的模子只能浇这种塑料。Anyway，东西做出来了，也能收发消息了，你就能让程序跑起来解决问题了。

[yi huang]

type和class绝对不同。

Python里面的所有对象，都是由type制造的

。相应的type制造一个blanket的对象，然后解释器再根据你的源代码，往这个blanket的对象里面塞东西。

空白的class object是由types.ClassType或者types.TypeType创建的。而你写的代码，会先在一个dict里面运行，然后塞进这个blanket的class
object里面。

>>> code = """
def func(self) :
       print "blah, blah, blah"
"""
>>> d = dict()
>>> exec(code, d)

>>> import types
>>> old_class = types.ClassType("OldClass", (), d)
>>> o = old_class()
>>> o.func()
blah, blah, blah

>>> new_class = types.TypeType("NewClass", (), d)
>>> o = new_class()
>>> o.func()
blah, blah, blah

instance一一样。先由types.InstanceType创建一个blanket的instance 。在new
class里面，这一步可以通过__new__控制。而所谓的meta
programming正是在这个__new__里面搞花样。blanket的instance创建完毕，再把dict绑定过去。这样，一个instance就有了。

你看下 types.py 的内容就知道 types 里面的东西是怎么来的了。

>>> import types
>>> class A:pass
...
>>> type(A) == types.ClassType
True
>>> a = A()
>>> type(a) == types.InstanceType
True
>>> class A(object):pass
...
>>> type(A) == type == types.TypeType
True
>>> a = A()
>>> type(a) == A
True

我不知道这里你对 type 的定义是什么，如果是指 types 模块里面的那些内置的类型的话，那他们和用户自己定义的类型当然是不同的。不过 python2.2 之后内置类型与自定义类型之间已经没有什么区别，内置类型也可以被继承等。

>>> class MetaClass(type):pass
...
>>> class Klass(object):
...     __metaclass__ = MetaClass
...
>>> obj = Klass()
>>> type(obj) == Klass
True
>>> type(Klass) == MetaClass
True

这里 Klass 的 metaclass 不是 type 而是 MetaClass，Klass 实际上等于 MetaClass('Klass', (object, ), {}) ，你说这里的 MetaClass 算 class 还是 type 呢？

__new__ 是用来生成 class 的实例的时候被调用，而 metaclass 是用来生成 class 。
meta programming 范围很广，似乎一般定义是说编写把代码当数据操纵的代码。

--
http://codeplayer.blogspot.com/

[shhgs]

type和class是两个空间的东西。

class是用户空间的概念。当然这个用户是Py的程序员。

type是在实现Py解释器的过程当中，其OO设计的一个层次。

这两个空间在99.99%的情况下是没有交集的，只是在meta programming的时候碰了头。

你举的这个例子确实有些两难。这个meta
class对程序员来说，是一个class，对Py解释器来说，又可以当作type来用。Anyway，能写出这种代码的人，还在乎这种区别吗？

现在不是解答问题吗。要解答问题，就得给一个内恰的，明确的，清晰的解释。而这个解释，很大程度上又取决于如何定义type和class。我觉得你的分类标准并不适合初学者。你所说的，type和class没有区别，实际上在写Py代码的时候并不实用。用户使用class就能自定义class，但是他们为什么不能自定义type？如果两者完全没有差别，为什么又要有type，而且还无处不在。这些问题都很实际，而且也不是你所说的"两者没有区别"所能解释的。相反我的划分方式，把class归到用户空间，把type归到Py解释器的实现，我觉得还是比较清楚的，也是能自圆其说的。

我无意在这个地方和你辩论。读者要听谁的，请自己选择。

[yi huang]

OK，你拿着图纸，找到一家叫Py的工厂。这个工厂拿到图纸之后

说，没问题，我给你造。于是它根据图纸造一个模子(class
object)。制造模子的时候，工厂用的是自己的生产工具( types.ClassType，或者tpyes.TypeType，看你用new

class还是old class)。

但是光有模子没用，你要的是解决问题，你得让工厂再按照你的图纸生产处一些能收发消息的对象。

Py工厂说，没问题，有了模子还愁instance吗。只是我们的模子只能我们自己用。于是它再备料。这次出场的是InstanceType。你可以把InstanceType想成一种类似塑料一样的东西。原本你以为工厂是会往模子里浇铁水的，结果它的模子只能浇这种塑料。Anyway，东西做出来了，也能收发消息了，你就能让程序跑起来解决问题了。

我想你是在拿 old-style class 说事，types.ClassType 和 types.InstanceType 都是以前的东西了。

class A(object):
    pass
a = A()

这里 A 是 new-style class，type(a) 是 A， 而不是 types.InstanceType 。

按照你这里对 type 和 class 的定义，实际上 python2.2 所做的巨大努力，就是为了统一 type 和 class 。

--
http://codeplayer.blogspot.com/

[shhgs]

new class object的type是object。

反正不管是new还是old，type都是Py解释器内部的东西，class都是用户空间的东西。而知道type之间的相互关系，只是在meta
programming的时候有用。

On 3/7/07, yi huang <yi.cod...@gmail.com> wrote:

[yi huang]

现在不是解答问题吗。要解答问题，就得给一个内恰的，明确的

，清晰的解释。而这个解释，很大程度上又取决于如何定义type和class。我觉得你的分类标准并不适合初学者。你所说的，type和class没有区别，实际上在写Py代码的时候并不实用。用户使用class就能自定义class，但是他们为什么不能自定义type？如果两者完全没有差别，为什么又要有type，而且还无处不在。这些问题都很实际，而且也不是你所说的"两者没有区别"所能解释的。相反我的划分方式，把class归到用户空间，把type归到Py解释器的实现，我觉得还是比较清楚的，也是能自圆其说的。

当然可以自定义 type 了，你可以继承那些内置类型。
我说 type 和 class 没有差别是站在 new-style class 角度来说的。
我觉得对于初学者，更应该在一开始就拥有正确的观念。
前面就有人列出了经典文章： http://www.cafepy.com/article/python_types_and_objects/

其实根据:

>>> issubclass(int, object)
True
>>> isinstance(int, type)
True

我们完全可以想象 int 类型的实现：

class int(object):
    ...

而且 int 也可以被继承，实在看不出和普通 class 有什么区别。

另外，types 模块和 new 模块在 py3k 中都将被废弃 (见 pep-0249)，那时候内置类型就更没有什么特殊之处了。

--
http://codeplayer.blogspot.com/

[yi huang]

总之还是看听众愿意如何理解了，不争了。

new class object的type是object。

不过这话还有点问题，object 是所有类型最终的基类，type 是所有对象最终的类型。

--
http://codeplayer.blogspot.com/

[shhgs]

class int(object):
............

这个我极感兴趣。写一个能运行的代码，然后提供一个times方法，能返回一个iterator，像ruby的Fixnum#times那样就行了。

On 3/7/07, yi huang <yi.cod...@gmail.com> wrote:

[yi huang]

class int(object):
    ............

这个我极感兴趣。写一个能运行的代码，然后提供一个times方

法，能返回一个iterator，像ruby的Fixnum#times那样就行了。

>>> class MyInt(int):
...   def times(self, func):
...     for i in range(self):
...        func()
...
>>> def test():print 'hello'
...
>>> a = MyInt(3)
>>> a.times(test)
hello
hello
hello

只不过不能直接给内置类型加属性(等于是内置类型使用了 __slots__)，所以并不能达到 3.times(test) 的效果。

--
http://codeplayer.blogspot.com/

[shhgs]

Py的type是不能自定义的。你只能继承已有的types里面的type。要想自定义一个type，比如像Perl,
Ruby那样，用1..3表示一个Range，你就得用C。从这个角度来讲，不管new还是old的class，都不是type。

你前面写的，class int(object)是笔误。我还以为可以这样继承int了。MyInt虽然继承了int，但是看不出有什么用。其实Python的meta
programming也就type有用。

new class object的type其实还是object。这个肯定是不错的。object是所有object的base
type。其实new class object在初始化的时候，采用的方式同old class的大同小异。都是调用
一个方法，生成一个blanket的instance，然后往里面塞东西。所不同的是，old class用的是InstanceType，而new
class用的是class object的__new__方法。

Python 2.2之前的OO实现还是很清楚的，现在这个实现，思路很混乱。主要是为了要过渡到Py
3000。这个type和object之间的鸡和蛋的关系实在同Py的优雅不沾边。Py 3000取消了type之后，meta
programming应该更容易了。

On 3/7/07, yi huang <yi.cod...@gmail.com> wrote:

[Zoom.Quiet]

好哪！道理不辨不明的，看的精彩，整理到维基中:
http://wiki.woodpecker.org.cn/moin/PyClassAndType

题外思考: http://www.nirvanastudio.org/category/scheme/
如同此文展示的，非语法自定义的语言本身，是受设计者思想限制的，
我们必须深入理解其特性，以便 Think in XXX 才可能晋升大家，
而不是象Lisp 等等古老的原语化的语言，是Make XXX Think like XXX

嗬嗬嗬………………

--
'''Time is unimportant, only life important!
http://zoomquiet.org
blog@http://blog.zoomquiet.org/pyblosxom/
wiki@http://wiki.woodpecker.org.cn/moin/ZoomQuiet
scrap@http://floss.zoomquiet.org
douban@http://www.douban.com/people/zoomq/
____________________________________
Pls. use OpenOffice.org to replace M$ Office.
http://zh.openoffice.org
Pls. use 7-zip to replace WinRAR/WinZip.
http://7-zip.org/zh-cn/
You can get the truely Freedom 4 software.
'''

[沈崴]

想必 Shhgs 想表达的意思是这个吧 http://www.ibm.com/developerworks/cn/linux/l-pymeta/index.html
:)
和 HuangYi 说的不是一个东西呵。

你们的探讨看得我都晕了, 是不是太复杂了点啊 ~~` 依我看 Python 里面有 dict 就够了, OO 太麻烦。

---
沈崴 (努力学习 Python 中 ...)
http://blog.163.com/eishn

[yi huang]

Py的type是不能自定义的。你只能继承已有的types里面

的type。要想自定义一个type，比如像Perl,
Ruby那样，用1..3表示一个Range，你就得用C。从这个角度来讲，不管new还是old的class，都不是type。

所有类型，不管内置的类型还是自定义的类型，都是继承自object。
要用 1..3 来表示一个 Range，这只是个语法而已，并不是一个新类型，我想这除非修改python的实现。

其实new class object在初始化的时候，采用的方式同old class的大同小异。都是调用
一个方法，生成一个blanket的instance

，然后往里面塞东西。

可以说所有语言都是如此，包括 c++ 也是，先分配一片内存空间，然后初始化这片内存。

--
http://codeplayer.blogspot.com/

[yi huang]

Python 2.2之前的OO实现还是很清楚的，现在这个实现，思路很混乱。主要是为了要过渡到Py
3000。这个type和object之间的鸡和蛋的关系实在同

Py的优雅不沾边。Py 3000取消了type之后，meta
programming应该更容易了。

现在只是同时存在着 old-style class 和 new-style class 两种，而我说的话基本上都只站在 new-style class 的立场讲的。
至于 type 于 object 之间的关系：

>>> issubclass(type, object)
True
>>> issubclass(object, object)
True
>>> isinstance(object, type)
True
>>> isinstance(type, type)
True

另外 1, [], {'a':1,'b':2} 这些只是语法，他们分别产生 int, list, dict 的实例。
语言的语法对基本类型提供直接的支持，我像这是让这些基本类型显得特殊的原因。

--
http://codeplayer.blogspot.com/

[Jalen]

说的够深刻，形象，受教了！

对于我们来说，Class是我们可以看到的文本；当经过Python解析、载入内存后，它就是Type了。

On 3月7日, 下午2时07分, shhgs <shhgs.efh...@gmail.com> wrote:
> class和type的区别
>
> 打一个比方。在学OO的时候，老师会说，class就是一个模子，往里面浇铁水之后，就有了对象了。
>
> OK，这里就有问题了。你写的代码，相当于工程师设计的图纸，而图纸是没有办法往里面浇铁水的，你得把图纸变成模子，才能往里面浇东西。
>
> 于是，你写的代码，定义了一个算法。这个算法别称为class。
>

> 你的class，交给type，type根据你的class，加工出一个模子，然后你就可以往里面浇铁水生成instance了。这个type就类似于工厂的生-产能力，工艺流程，或者。。。在编程的时候，这个type是语言的一种机制，能把你用代码定义的算法，也就是class，解释成能生成object，或者说in-stance(其实这个术语更好)的一种object(在解释meta

> programming的时候，一定要区分instance和object。这也是为什么，我曾经宣称，OOP应该是面向客体的编程。)。
>
> OK，Py的type有很多，你import

> types然后dir(types)可以看到很多。具体而言，每种type都是一种组织内存的方式。比如说，Python内部表示类的对象，同表示instan-ce的对象，其内部构造是不同的。那么这个内部构造是怎么定义的呢？就是这个type定义的。比如，每个instance都应该有一个dict，有表示其par-ent的tuple，此外还有初始化的时候，生成的parent类的对象(这部分具体应该问Robert

> Chen，我菜了)。而class里面可能就没有这么些东西。反正这就是type定义的。
>
> 接下来的东西，你可以去看Py in a
> nutshell了。Alex把福尔摩斯推理的最重要的一页给撕了。我也是琢磨了半天，最后在看Programming
> Ruby的时候搞懂的。现在给你补齐，应该能看懂了。
>

> On 3/7/07, Alex Cheng <chengxin1...@gmail.com> wrote:> 谢谢了。

>
> > --
> > powered by python
> > _______________________________________________
> > python-chinese

> > Post: send python-chin...@lists.python.cn
> > Subscribe: send subscribe to
> > python-chinese-requ...@lists.python.cn
> > Unsubscribe: send unsubscribe to
> > python-chinese-requ...@lists.python.cn

> > Detail Info:
> >http://python.cn/mailman/listinfo/python-chinese
>
> _______________________________________________
> python-chinese

> Post: send python-chin...@lists.python.cn
> Subscribe: send subscribe to python-chinese-requ...@lists.python.cn
> Unsubscribe: send unsubscribe to python-chinese-requ...@lists.python.cn
> Detail Info:http://python.cn/mailman/listinfo/python-chinese

[ygao]

On 3/7/07, yi huang <yi.cod...@gmail.com> wrote:

没区别。

 

太极端！

>>> type(object) is type(type)
True

>>> object is type
False

 

任何class都得从type承继。

 

 

--
http://codeplayer.blogspot.com/
_______________________________________________
python-chinese
Post: send python-...@lists.python.cn
Subscribe: send subscribe to python-chin...@lists.python.cn
Unsubscribe: send unsubscribe to  python-chin...@lists.python.cn
Detail Info: http://python.cn/mailman/listinfo/python-chinese

--
※※※※※※※※※※※※※※※※※※※※※※※※
My blog:  http://blog.donews.com/ygao
Forum     http://groups.google.com/group/python_study
※※※※※※※※※※※※※※※※※※※※※※※※

[ygao]

On 3/8/07, ygao <ygao...@gmail.com> wrote:

On 3/7/07, yi huang <yi.cod...@gmail.com > wrote:

没区别。

 

太极端！

>>> type(object) is type(type)
True

>>> object is type
False

 

 

 

误：

任何class都得从object继承。

 

 

--
http://codeplayer.blogspot.com/
_______________________________________________
python-chinese
Post: send python-...@lists.python.cn
Subscribe: send subscribe to python-chin...@lists.python.cn
Unsubscribe: send unsubscribe to  python-chin...@lists.python.cn
Detail Info: http://python.cn/mailman/listinfo/python-chinese

--
※※※※※※※※※※※※※※※※※※※※※※※※
My blog:  http://blog.donews.com/ygao
Forum     http://groups.google.com/group/python_study
※※※※※※※※※※※※※※※※※※※※※※※※

[shhgs]

-----------------------------------------

-----------------------------------------

但是 class是可以自己定义的。所以class和type还是不一样的。

On 3/7/07, yi huang <yi.cod...@gmail.com> wrote:
>

[limodou]

On 3/9/07, Marco <ma...@waven.com> wrote:
> 能不能告诉我彻底理解这个东西对 使用python有啥好处吗？ 谢谢！
>
目前来说没有什么用，我看只是纯学术研究，知不知道，清楚不清楚对开发影响不大。

--
I like python!
UliPad <<The Python Editor>>: http://wiki.woodpecker.org.cn/moin/UliPad
My Blog: http://www.donews.net/limodou

[yi huang]

能不能告诉我彻底理解这个东西对 使用python有啥好处吗？ 谢谢！

我想会用就够了，而怎么理解对于应用来说可能不是特别重要，不过不同的理解在交流的时候会造成许多障碍。比如我和 shhgs ，呵呵。
这问题本来就太抽象，我也觉得争得没啥意思。
要说清楚 type 和 class 是不是一样，不光要先定义 type 和 class，还得定义什么叫做"一样"先。
区别肯定是有的，区别到什么程度算不一样呢？
在某些方面一样，在其他方面又不一样，我想在本质的某些方面一样，就可以算是一样了，但哪些方面算是本质，哪些方面又只是表面呢。。。

--
http://codeplayer.blogspot.com/

[yi huang]

能不能告诉我彻底理解这个东西对 使用python有啥好处吗？ 谢谢！

总滴来说，我觉得会用 metaclass 了就行了。

--
http://codeplayer.blogspot.com/

[limodou]

On 3/9/07, yi huang <yi.cod...@gmail.com> wrote:
> > 能不能告诉我彻底理解这个东西对 使用python有啥好处吗？ 谢谢！
> >
>
> 总滴来说，我觉得会用 metaclass 了就行了。
>

metaclass也不一定需要会用，至少对于初学者不需要，基本的日常编程用到的也不多，对于开发框架功能的用处大一些。

--
I like python!
UliPad <<The Python Editor>>: http://wiki.woodpecker.org.cn/moin/UliPad
My Blog: http://www.donews.net/limodou

[Linker Lin]

我觉得在微词大意上做文章会让Python陷入C++的尴尬境地。
希望Py3000能统一对象模型。
最近看了看Lua，对meta programming有些理解，我认为，

python /lua 等脚本没有new 、delete, 因此凡是可以通过  xxx() 获得引用的东西，我们都可以看作是
对象。而不要局限于有类生成的才是对象。
比如用 yield生成的生成器。

def it():
    i=0
    while(i<10):
        i+=1
        yield i

iter=it()
iter2=it()
print iter.next()
print iter.next()
print iter.next()
print "*"*10
print iter2.next()
print iter2.next ()
print iter2.next()
输出：
1
2
3
**********
1
2
3

iter和iter2都表现出对象的性质，保存了自己的状态。
这个迭代器是没有类的，但是可以像对象一样保存自己的状态。
如果从C++传统OO思想里面跳出来看，其实只要能够保存私有状态的函数就是对象。
（当然，在C++里面通过仿函数可以模拟yield的部分效果。）
而生成这种东西的东西就叫类。
在更加彻底的meta progamming语言Lua中，设计者根本没有设计类/对像模型，用户通过改写table的特定方法可以更加灵活的实现。

我觉得 C++ 把对象的模具限制死--用类来描述，大大限制了C++类语言的能力，并且不得不引入创建类设计模式来补丁。

对于Python等动态语言，我们大可不必像C++标准委员会的老者们那样在微词大意上做文章。
在我看来，
1. 所有的引用能指引的东西都是对象（广义）
2. 能够生成广义对象的那个东西就是类（广义）

比如，一个对象通过 clone()方法可以得到另一个对象，那么我们为什么不把这个对象看作是类？

在现实世界中模具本身也是对象啊！

所以，有的时候，在分析问题的时候，分类法不如标签法，正如我们用的GMail一样。

On 3/9/07, Marco <ma...@waven.com> wrote:

我想也是，除非去开发Python本身，而如果真的参与到了python本身的开发，通过阅读python源代码，自然也就知道两者的意思了。

--
LinuX Power

_______________________________________________
python-chinese
Post: send python-...@lists.python.cn
Subscribe: send subscribe to python-chin...@lists.python.cn
Unsubscribe: send unsubscribe to  python-chin...@lists.python.cn
Detail Info: http://python.cn/mailman/listinfo/python-chinese

--
Linker M Lin
linker...@gmail.com

[yi huang]

python中任何东西都是对象，任何对象都有他的"类"，或者说类型。generator 当然也有他的类。
>>> def test():
...   yield 1
...
>>> g = test()
>>> g
<generator object at 0x00C14DC8>
>>> g.__class__

<type 'generator'>

至于 c++ 这种语言，和 python/lua 这种语言还是有太大的区别的。

 

好晚了，要睡觉去了。

--
http://codeplayer.blogspot.com/