ллÁË¡£

-- 
powered by python
-------------- 下一部分 --------------
Ò»¸öHTML¸½¼þ±»ÒƳý...
URL: http://python.cn/pipermail/python-chinese/attachments/20070307/a6f6474d/attachment.htm 

没区别。

-- 
http://codeplayer.blogspot.com/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://python.cn/pipermail/python-chinese/attachments/20070307/834433e7/attachment.htm 

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 <chengxin1985在gmail.com> wrote:
> 谢谢了。
>
> --
> powered by python
> _______________________________________________
> python-chinese
> Post: send python-chinese在lists.python.cn
> Subscribe: send subscribe to
> python-chinese-request在lists.python.cn
> Unsubscribe: send unsubscribe to
> python-chinese-request在lists.python.cn
> Detail Info:
> http://python.cn/mailman/listinfo/python-chinese
>

上面的大哥，我怎么没有读懂您的话呢？

On 3/7/07, shhgs <shhgs.efhilt在gmail.com> wrote:
> 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 <chengxin1985在gmail.com> wrote:
> > 谢谢了。
> >
> > --
> > powered by python
> > _______________________________________________
> > python-chinese
> > Post: send python-chinese在lists.python.cn
> > Subscribe: send subscribe to
> > python-chinese-request在lists.python.cn
> > Unsubscribe: send unsubscribe to
> > python-chinese-request在lists.python.cn
> > Detail Info:
> > http://python.cn/mailman/listinfo/python-chinese
> >
> _______________________________________________
> python-chinese
> Post: send python-chinese在lists.python.cn
> Subscribe: send subscribe to python-chinese-request在lists.python.cn
> Unsubscribe: send unsubscribe to  python-chinese-request在lists.python.cn
> Detail Info: http://python.cn/mailman/listinfo/python-chinese


-- 
LinuX Power

СµÜ²ÅÊèѧdz£¬¿É²»¿ÉÒÔÕâÑùÀí½â£º
Type ÃèÊöÁËinstance µÄÄÚ´æ½á¹¹£¬ class ÊÇtype µÄÒ»ÖÖinstance, ¶øclass µÄobject
Ò²ÊÇÓÉÒ»¸öÌØÊâµÄtype(ObjectType)¹¹³É¡£

Ò²¾ÍÊÇ˵Python ÊÀ½çÊÇÓɶÔÏó×é³ÉµÄ£º ÓжÔÏ󹤳§ (Type ¼°Æä¼Ì³Ð),  ÓÐÀà¶ÔÏó(ÓÉClassType),
Óз½·¨¶ÔÏó(ÓÉFunctionType ´´½¨, function ¹Ø¼ü×Ö¶¨Òå), ...

ÎÒÖ»ÄÜÀí½âÕâôÉîÁË, Ï£ÍûÂ¥ÉϵÄÄܼÌÐøÖ¸µã.

ÔÚ07-3-7£¬shhgs <shhgs.efhilt在gmail.com> дµÀ£º
>
> 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µÄ¶ÔÏó£¬ÆäÄÚ²¿¹¹ÔìÊDz»Í¬µÄ¡£ÄÇôÕâ¸öÄÚ²¿¹¹ÔìÊÇÔõô¶¨ÒåµÄÄØ£¿¾ÍÊÇÕâ¸ötype¶¨ÒåµÄ¡£±ÈÈ磬ÿ¸öinstance¶¼Ó¦¸ÃÓÐÒ»¸ödict£¬ÓбíʾÆäparentµÄtuple£¬´ËÍ⻹Óгõʼ»¯µÄʱºò£¬Éú³ÉµÄparentÀàµÄ¶ÔÏó(Õⲿ·Ö¾ßÌåÓ¦¸ÃÎÊRobert
> Chen£¬ÎÒ²ËÁË)¡£¶øclassÀïÃæ¿ÉÄܾÍûÓÐÕâôЩ¶«Î÷¡£·´ÕýÕâ¾ÍÊÇtype¶¨ÒåµÄ¡£
>
> ½ÓÏÂÀ´µÄ¶«Î÷£¬Äã¿ÉÒÔÈ¥¿´Py in a
> nutshellÁË¡£Alex°Ñ¸£¶ûĦ˹ÍÆÀíµÄ×îÖØÒªµÄÒ»Ò³¸ø˺ÁË¡£ÎÒÒ²ÊÇ×ÁÄ¥ÁË°ëÌ죬×îºóÔÚ¿´Programming
> RubyµÄʱºò¸ã¶®µÄ¡£ÏÖÔÚ¸øÄã²¹Æ룬Ӧ¸ÃÄÜ¿´¶®ÁË¡£
>
>
>
>
> On 3/7/07, Alex Cheng <chengxin1985在gmail.com> wrote:
> > ллÁË¡£
> >
> > --
> > powered by python
> > _______________________________________________
> > python-chinese
> > Post: send python-chinese在lists.python.cn
> > Subscribe: send subscribe to
> > python-chinese-request在lists.python.cn
> > Unsubscribe: send unsubscribe to
> > python-chinese-request在lists.python.cn
> > Detail Info:
> > http://python.cn/mailman/listinfo/python-chinese
> >
> _______________________________________________
> python-chinese
> Post: send python-chinese在lists.python.cn
> Subscribe: send subscribe to python-chinese-request在lists.python.cn
> Unsubscribe: send unsubscribe to  python-chinese-request在lists.python.cn
> Detail Info: http://python.cn/mailman/listinfo/python-chinese




-- 
powered by python
-------------- 下一部分 --------------
Ò»¸öHTML¸½¼þ±»ÒƳý...
URL: http://python.cn/pipermail/python-chinese/attachments/20070307/6d1e3574/attachment-0001.html 

你的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/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://python.cn/pipermail/python-chinese/attachments/20070307/6d9a4520/attachment.htm 

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

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

-- 
http://codeplayer.blogspot.com/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://python.cn/pipermail/python-chinese/attachments/20070307/0d2c3ae5/attachment.htm 

关于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  
<chengxin1985 at gmail.com> wrote:

> 小弟才疏学浅，可不可以这样理解：
> Type 描述了instance 的内存结构， class 是type 的一种instance, 而class 的 
> object 也是由一个特殊的type(ObjectType)构成。
>
> 也就是说Python 世界是由对象组成的： 有对象工厂 (Type 及其继承),  有类对象 
> (由ClassType), 有方法对象(由FunctionType 创建, function 关键字定义), ...



-- 
Leira Hua
http://my.opera.com/Leira

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 <lhua在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
> <chengxin1985在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-chinese在lists.python.cn
> Subscribe: send subscribe to python-chinese-request在lists.python.cn
> Unsubscribe: send unsubscribe to  python-chinese-request在lists.python.cn
> Detail Info: http://python.cn/mailman/listinfo/python-chinese

ÊܽÌÁË£¬¹ûÈ»¾­µä¡£

ÔÚ07-3-7£¬shhgs <shhgs.efhilt在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 <lhua在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
> > <chengxin1985在gmail.com> wrote:
> >
> > > СµÜ²ÅÊèѧdz£¬¿É²»¿ÉÒÔÕâÑùÀí½â£º
> > > 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-chinese在lists.python.cn
> > Subscribe: send subscribe to python-chinese-request在lists.python.cn
> > Unsubscribe: send unsubscribe to  python-chinese-request在lists.python.cn
> > Detail Info: http://python.cn/mailman/listinfo/python-chinese
> _______________________________________________
> python-chinese
> Post: send python-chinese在lists.python.cn
> Subscribe: send subscribe to python-chinese-request在lists.python.cn
> Unsubscribe: send unsubscribe to  python-chinese-request在lists.python.cn
> Detail Info: http://python.cn/mailman/listinfo/python-chinese




-- 
Blog°á¼ÒÁË

ÁõöÎ
March.Liu
-------------- 下一部分 --------------
Ò»¸öHTML¸½¼þ±»ÒƳý...
URL: http://python.cn/pipermail/python-chinese/attachments/20070307/09ee1e7c/attachment.html 

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，东西做出来了，也能收发消息了，你就能让程序跑起来解决问题了。




On 3/7/07, 刘鑫 <march.liu在gmail.com> wrote:
> 受教了，果然经典。
>
> 在07-3-7，shhgs <shhgs.efhilt在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 <lhua在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
> > > <chengxin1985在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-chinese在lists.python.cn
> > > Subscribe: send subscribe to
> python-chinese-request在lists.python.cn
> > > Unsubscribe: send unsubscribe to
> python-chinese-request在lists.python.cn
> > > Detail Info:
> http://python.cn/mailman/listinfo/python-chinese
> > _______________________________________________
> > python-chinese
> > Post: send python-chinese在lists.python.cn
> > Subscribe: send subscribe to
> python-chinese-request在lists.python.cn
> > Unsubscribe: send unsubscribe to
> python-chinese-request在lists.python.cn
> > Detail Info:
> http://python.cn/mailman/listinfo/python-chinese
>
>
>
> --
> Blog搬家了
>
> 刘鑫
> March.Liu
> _______________________________________________
> python-chinese
> Post: send python-chinese在lists.python.cn
> Subscribe: send subscribe to
> python-chinese-request在lists.python.cn
> Unsubscribe: send unsubscribe to
> python-chinese-request在lists.python.cn
> Detail Info:
> http://python.cn/mailman/listinfo/python-chinese
>

简单的说来，type是python内置的一些基本类，用户自定义的类（class）需要由python用基本类（type）来实现，是这个意思吗？

在07-3-7，shhgs <shhgs.efhilt在gmail.com> 写道：
>
> 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，东西做出来了，也能收发消息了，你就能让程序跑起来解决问题了。
>
>
>
>
> On 3/7/07, 刘鑫 <march.liu在gmail.com> wrote:
> > 受教了，果然经典。
> >
> > 在07-3-7，shhgs <shhgs.efhilt在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 <lhua在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
> > > > <chengxin1985在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-chinese在lists.python.cn
> > > > Subscribe: send subscribe to
> > python-chinese-request在lists.python.cn
> > > > Unsubscribe: send unsubscribe to
> > python-chinese-request在lists.python.cn
> > > > Detail Info:
> > http://python.cn/mailman/listinfo/python-chinese
> > > _______________________________________________
> > > python-chinese
> > > Post: send python-chinese在lists.python.cn
> > > Subscribe: send subscribe to
> > python-chinese-request在lists.python.cn
> > > Unsubscribe: send unsubscribe to
> > python-chinese-request在lists.python.cn
> > > Detail Info:
> > http://python.cn/mailman/listinfo/python-chinese
> >
> >
> >
> > --
> > Blog搬家了
> >
> > 刘鑫
> > March.Liu
> > _______________________________________________
> > python-chinese
> > Post: send python-chinese在lists.python.cn
> > Subscribe: send subscribe to
> > python-chinese-request在lists.python.cn
> > Unsubscribe: send unsubscribe to
> > python-chinese-request在lists.python.cn
> > Detail Info:
> > http://python.cn/mailman/listinfo/python-chinese
> >
> _______________________________________________
> python-chinese
> Post: send python-chinese在lists.python.cn
> Subscribe: send subscribe to python-chinese-request在lists.python.cn
> Unsubscribe: send unsubscribe to  python-chinese-request在lists.python.cn
> Detail Info: http://python.cn/mailman/listinfo/python-chinese




-- 
Best Regards！

Ace Strong

==================================================
Nanjing University of Aeronautics and Astronautics.
College of Civil Aviation
Tao Cheng
E-mail: acestrong在gmail.com ;acestrong在nuaa.edu.cn
Tel: 86-025-84892273
==================================================
-------------- 下一部分 --------------
一个HTML附件被移除...
URL: http://python.cn/pipermail/python-chinese/attachments/20070308/ff5f9d2a/attachment.html 

>
> 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/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://python.cn/pipermail/python-chinese/attachments/20070308/9f5a9b76/attachment.html 

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解释器的实现，我觉得还是比较清楚的，也是能自圆其说的。

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




On 3/7/07, yi huang <yi.codeplayer在gmail.com> wrote:
> > 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/
> _______________________________________________
> python-chinese
> Post: send python-chinese在lists.python.cn
> Subscribe: send subscribe to
> python-chinese-request在lists.python.cn
> Unsubscribe: send unsubscribe to
> python-chinese-request在lists.python.cn
> Detail Info:
> http://python.cn/mailman/listinfo/python-chinese
>

>
> 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
所做的巨大努力<http://www.python.org/download/releases/2.2.3/descrintro/>，就是为了统一
type 和 class 。

-- 
http://codeplayer.blogspot.com/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://python.cn/pipermail/python-chinese/attachments/20070308/a2414776/attachment.htm 

new class object的type是object。

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





On 3/7/07, yi huang <yi.codeplayer在gmail.com> wrote:
> > 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/
> _______________________________________________
> python-chinese
> Post: send python-chinese在lists.python.cn
> Subscribe: send subscribe to
> python-chinese-request在lists.python.cn
> Unsubscribe: send unsubscribe to
> python-chinese-request在lists.python.cn
> Detail Info:
> http://python.cn/mailman/listinfo/python-chinese
>

>
> 现在不是解答问题吗。要解答问题，就得给一个内恰的，明确的
> ，清晰的解释。而这个解释，很大程度上又取决于如何定义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://www.python.org/dev/peps/pep-0294/>
)，那时候内置类型就更没有什么特殊之处了。

-- 
http://codeplayer.blogspot.com/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://python.cn/pipermail/python-chinese/attachments/20070308/9f82f315/attachment.htm 

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

new class object的type是object。


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

-- 
http://codeplayer.blogspot.com/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://python.cn/pipermail/python-chinese/attachments/20070308/8c255e81/attachment.html 

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

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



On 3/7/07, yi huang <yi.codeplayer在gmail.com> wrote:
> > 现在不是解答问题吗。要解答问题，就得给一个内恰的，明确的
> >
> ，清晰的解释。而这个解释，很大程度上又取决于如何定义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/
> _______________________________________________
> python-chinese
> Post: send python-chinese在lists.python.cn
> Subscribe: send subscribe to
> python-chinese-request在lists.python.cn
> Unsubscribe: send unsubscribe to
> python-chinese-request在lists.python.cn
> Detail Info:
> http://python.cn/mailman/listinfo/python-chinese
>

>
> 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/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://python.cn/pipermail/python-chinese/attachments/20070308/67431c54/attachment.htm 

лл´ó¼ÒµÄ°ïÖú, ÕæÕýÒªÀí½âtype ºÍclassµÄÇø±ð»¹ÊǺܲ»ÈÝÒ×µÄ, ¿´À´ÎÒ»¹Êǵö࿴¿´×ÊÁÏ. ×î½üÏîÄ¿½ø¶ÈѹµÃ½ô, ûÓм°Ê±»Ø¸´, Õæ¶Ô²»Æð.
ÓÈÆä¸Ðлshhgs ºÍyi huangΪÎÒ»¨·ÑÁ˱¦¹óµÄʱ¼ä. ËäÈ»ÎÒÏÖÔÚ»¹²»ÊÇÈ«Ã÷°×, µ«Êǻᾡ¿ìŪ¶®µÄ.

ÔÚ07-3-8£¬yi huang <yi.codeplayer在gmail.com> дµÀ£º
>
> 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/
> _______________________________________________
> python-chinese
> Post: send python-chinese在lists.python.cn
> Subscribe: send subscribe to python-chinese-request在lists.python.cn
> Unsubscribe: send unsubscribe to  python-chinese-request在lists.python.cn
> Detail Info: http://python.cn/mailman/listinfo/python-chinese
>



-- 
powered by python
-------------- 下一部分 --------------
Ò»¸öHTML¸½¼þ±»ÒƳý...
URL: http://python.cn/pipermail/python-chinese/attachments/20070308/7895f416/attachment-0001.htm