[CPyUG:68243] python的源码写得好奇怪啊。

classic Classic list List threaded Threaded
66 messages Options
1234
Reply | Threaded
Open this post in threaded view
|

[CPyUG:68243] python的源码写得好奇怪啊。

soldier-2
这是那段Int对象获取内存的函数,相信看过都清楚。
static PyIntObject *
fill_free_list(void)
{
        PyIntObject *p, *q;
        /* Python's object allocator isn't appropriate for large blocks. */
        p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
        if (p == NULL)
                return (PyIntObject *) PyErr_NoMemory();
        ((PyIntBlock *)p)->next = block_list;
        block_list = (PyIntBlock *)p;
        /* Link the int objects together, from rear to front, then return
           the address of the last int object in the block. */
        p = &((PyIntBlock *)p)->objects[0];
        q = p + N_INTOBJECTS;
        while (--q > p)
                q->ob_type = (struct _typeobject *)(q-1);
        q->ob_type = NULL;
        return p + N_INTOBJECTS - 1;
}

p指针声明为PyIntObject* ,但是malloc时为了使用这个指针而用强制转换使用他,虽然说都是指针,这样运行没问题,但看起来费劲。
更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
有朋友有同感没有,还是我理解有问题。
--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68253] Re: python的源码写得好奇怪啊。

heroboy
>p指针声明为PyIntObject* ,但是malloc时为了使用这个指针而用强制转换使用他,虽然说都是指针,这样运行没问题,但看起来费劲。
malloc前面都有强制转换的,因为malloc返回的是void*。否则在C里应该是warning,c++是编译错误。

>更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,
这算是hack。前面肯定有注释的。

On Oct 15, 8:53 am, hhuai <[hidden email]> wrote:

> 这是那段Int对象获取内存的函数,相信看过都清楚。
> static PyIntObject *
> fill_free_list(void)
> {
>         PyIntObject *p, *q;
>         /* Python's object allocator isn't appropriate for large blocks. */
>         p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
>         if (p == NULL)
>                 return (PyIntObject *) PyErr_NoMemory();
>         ((PyIntBlock *)p)->next = block_list;
>         block_list = (PyIntBlock *)p;
>         /* Link the int objects together, from rear to front, then return
>            the address of the last int object in the block. */
>         p = &((PyIntBlock *)p)->objects[0];
>         q = p + N_INTOBJECTS;
>         while (--q > p)
>                 q->ob_type = (struct _typeobject *)(q-1);
>         q->ob_type = NULL;
>         return p + N_INTOBJECTS - 1;
>
> }
>
> p指针声明为PyIntObject* ,但是malloc时为了使用这个指针而用强制转换使用他,虽然说都是指针,这样运行没问题,但看起来费劲。
> 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> 有朋友有同感没有,还是我理解有问题。
--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68255] Re: python的源码写得好奇怪啊。

yi gong
In reply to this post by soldier-2


更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
有朋友有同感没有,还是我理解有问题。
 
C中的池的常规做法,看多了就熟了。为了节省内存。在池里,这几个字节当指针用,在池外就是其他有意义的东东。
有时候也会用一个union,一个是池里linknode,另一个就是足够长度的char[]。池里的时候当作linknode用,丢出去就char[]给别人初始化。


 


2008/10/15 hhuai <[hidden email]>
这是那段Int对象获取内存的函数,相信看过都清楚。
static PyIntObject *
fill_free_list(void)
{
       PyIntObject *p, *q;
       /* Python's object allocator isn't appropriate for large blocks. */
       p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
       if (p == NULL)
               return (PyIntObject *) PyErr_NoMemory();
       ((PyIntBlock *)p)->next = block_list;
       block_list = (PyIntBlock *)p;
       /* Link the int objects together, from rear to front, then return
          the address of the last int object in the block. */
       p = &((PyIntBlock *)p)->objects[0];
       q = p + N_INTOBJECTS;
       while (--q > p)
               q->ob_type = (struct _typeobject *)(q-1);
       q->ob_type = NULL;
       return p + N_INTOBJECTS - 1;
}

p指针声明为PyIntObject* ,但是malloc时为了使用这个指针而用强制转换使用他,虽然说都是指针,这样运行没问题,但看起来费劲。
更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
有朋友有同感没有,还是我理解有问题。



--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68257] Re: python的源码写得好奇怪啊。

刘鑫
要钻研Python源码,老陈的《python源码剖析》是必读的。

2008/10/15 yi gong <[hidden email]>


更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
有朋友有同感没有,还是我理解有问题。
 
C中的池的常规做法,看多了就熟了。为了节省内存。在池里,这几个字节当指针用,在池外就是其他有意义的东东。
有时候也会用一个union,一个是池里linknode,另一个就是足够长度的char[]。池里的时候当作linknode用,丢出去就char[]给别人初始化。


 


2008/10/15 hhuai <[hidden email]>

这是那段Int对象获取内存的函数,相信看过都清楚。
static PyIntObject *
fill_free_list(void)
{
       PyIntObject *p, *q;
       /* Python's object allocator isn't appropriate for large blocks. */
       p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
       if (p == NULL)
               return (PyIntObject *) PyErr_NoMemory();
       ((PyIntBlock *)p)->next = block_list;
       block_list = (PyIntBlock *)p;
       /* Link the int objects together, from rear to front, then return
          the address of the last int object in the block. */
       p = &((PyIntBlock *)p)->objects[0];
       q = p + N_INTOBJECTS;
       while (--q > p)
               q->ob_type = (struct _typeobject *)(q-1);
       q->ob_type = NULL;
       return p + N_INTOBJECTS - 1;
}

p指针声明为PyIntObject* ,但是malloc时为了使用这个指针而用强制转换使用他,虽然说都是指针,这样运行没问题,但看起来费劲。
更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
有朋友有同感没有,还是我理解有问题。







--
Python 官方入门文档:Python Tutorial 简体中文版

http://wiki.woodpecker.org.cn/moin/March_Liu/PyTutorial

在这个剪刀党的时代,有多少人能像陈儒写Python源码剖析一样,用三四年去雕琢一本书?

http://blog.chinaunix.net/u/29309/showart_1300421.html

……

劉鑫
March.Liu

--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68260] Re: python的源码写得好奇怪啊。

soldier-2
In reply to this post by yi gong
两位这么一讲解,我算是明白了,
不过我觉得作者为啥不写得更清晰点,这样弄,有点浪费读者的时间。

p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
这里这个p,完全可以再声明一个出来,像这样
PyIntBlock pp = (PyIntBlock *)PyMem_MALLOC(sizeof(PyIntBlock));
因为这里p的作用本来是作PyIntObject链表的,没必要拿作他用。
不会连这几个字节都要节省吧。

q->ob_type = (struct _typeobject *)(q-1);
可以用个union
union{
 ob_type
 mem_link};
再池里用q->mem_link,在外用q->ob_type,意义就明了了,


On 10月15日, 上午11时05分, "yi gong" <[hidden email]> wrote:

> > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> > 有朋友有同感没有,还是我理解有问题。
>
> C中的池的常规做法,看多了就熟了。为了节省内存。在池里,这几个字节当指针用,在池外就是其他有意义的东东。
> 有时候也会用一个union,一个是池里linknode,另一个就是足够长度的char[]。池里的时候当作linknode用,丢出去就char[]给别人初始化。
>
> 2008/10/15 hhuai <[hidden email]>
>
> > 这是那段Int对象获取内存的函数,相信看过都清楚。
> > static PyIntObject *
> > fill_free_list(void)
> > {
> >        PyIntObject *p, *q;
> >        /* Python's object allocator isn't appropriate for large blocks. */
> >        p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
> >        if (p == NULL)
> >                return (PyIntObject *) PyErr_NoMemory();
> >        ((PyIntBlock *)p)->next = block_list;
> >        block_list = (PyIntBlock *)p;
> >        /* Link the int objects together, from rear to front, then return
> >           the address of the last int object in the block. */
> >        p = &((PyIntBlock *)p)->objects[0];
> >        q = p + N_INTOBJECTS;
> >        while (--q > p)
> >                q->ob_type = (struct _typeobject *)(q-1);
> >        q->ob_type = NULL;
> >        return p + N_INTOBJECTS - 1;
> > }
>
> > p指针声明为PyIntObject* ,但是malloc时为了使用这个指针而用强制转换使用他,虽然说都是指针,这样运行没问题,但看起来费劲。
> > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> > 有朋友有同感没有,还是我理解有问题。
>
>
--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68261] Re: python的源码写得好奇怪啊。

soldier-2
In reply to this post by 刘鑫
我有在网上搜集了他19篇blog,然后加以研习,在此严重感谢。
至于书嘛,我在当当看过了,单从价格方面来看,我感觉有点贵,所以没买。(我并不是讲书不值这么多钱,而是从价格单方面看)

On 10月15日, 上午11时13分, "刘鑫" <[hidden email]> wrote:

> 要钻研Python源码,老陈的《python源码剖析》是必读的。
>
> 2008/10/15 yi gong <[hidden email]>
>
>
>
>
>
> >> 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> >> 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> >> 有朋友有同感没有,还是我理解有问题。
>
> > C中的池的常规做法,看多了就熟了。为了节省内存。在池里,这几个字节当指针用,在池外就是其他有意义的东东。
>
> > 有时候也会用一个union,一个是池里linknode,另一个就是足够长度的char[]。池里的时候当作linknode用,丢出去就char[]给别人初始化。
>
> > 2008/10/15 hhuai <[hidden email]>
>
> > 这是那段Int对象获取内存的函数,相信看过都清楚。
> >> static PyIntObject *
> >> fill_free_list(void)
> >> {
> >>        PyIntObject *p, *q;
> >>        /* Python's object allocator isn't appropriate for large blocks. */
> >>        p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
> >>        if (p == NULL)
> >>                return (PyIntObject *) PyErr_NoMemory();
> >>        ((PyIntBlock *)p)->next = block_list;
> >>        block_list = (PyIntBlock *)p;
> >>        /* Link the int objects together, from rear to front, then return
> >>           the address of the last int object in the block. */
> >>        p = &((PyIntBlock *)p)->objects[0];
> >>        q = p + N_INTOBJECTS;
> >>        while (--q > p)
> >>                q->ob_type = (struct _typeobject *)(q-1);
> >>        q->ob_type = NULL;
> >>        return p + N_INTOBJECTS - 1;
> >> }
>
> >> p指针声明为PyIntObject* ,但是malloc时为了使用这个指针而用强制转换使用他,虽然说都是指针,这样运行没问题,但看起来费劲。
> >> 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> >> 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> >> 有朋友有同感没有,还是我理解有问题。
>
> --
> Python 官方入门文档:Python Tutorial 简体中文版
>
> http://wiki.woodpecker.org.cn/moin/March_Liu/PyTutorial
>
> 在这个剪刀党的时代,有多少人能像陈儒写Python源码剖析一样,用三四年去雕琢一本书?
>
> http://blog.chinaunix.net/u/29309/showart_1300421.html
>
> ......
>
> 劉鑫
> March.Liu
--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68263] Re: python的源码写得好奇怪啊。

yi gong
In reply to this post by soldier-2
--!
这个怎么说呢。说实话,这些真的是难者不会,会者不难的东东,而且源码作者没有义务解释这点东西。整个cpython里的tricky的东东太多了,要是全都解释了,估计要比源码还长。

就是要省这几个字节啊,兄弟。你要想想你一个hello world,后面要帮你生成多少个PyObject.对于库作者来说,这些都是致命的硬伤。

union的用法看来这位兄弟是入门了。用union还是作一次类型转换就看当初作者的个人喜好了,在我看来就是一路货,把宝押在系统内存的字节排列上了,所以这招在c++有时候就玩不转了。

想起一句笑话,作java的看不起作html,c++看不起作java的,c看不起作c++的,汇编看不起用c的,公司小妹看不起所有写代码的。 是这样说的么?  :)

推荐一本好书,侯捷的 《STL源码剖析》,不过挺贵,能借就借。看了之后c/c++功底大有长进(吹牛的功底 ^^)。

2008/10/15 hhuai <[hidden email]>
两位这么一讲解,我算是明白了,
不过我觉得作者为啥不写得更清晰点,这样弄,有点浪费读者的时间。

p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
这里这个p,完全可以再声明一个出来,像这样
PyIntBlock pp = (PyIntBlock *)PyMem_MALLOC(sizeof(PyIntBlock));
因为这里p的作用本来是作PyIntObject链表的,没必要拿作他用。
不会连这几个字节都要节省吧。

q->ob_type = (struct _typeobject *)(q-1);
可以用个union
union{
 ob_type
 mem_link};
再池里用q->mem_link,在外用q->ob_type,意义就明了了,


On 10月15日, 上午11时05分, "yi gong" <[hidden email]> wrote:
> > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> > 有朋友有同感没有,还是我理解有问题。
>
> C中的池的常规做法,看多了就熟了。为了节省内存。在池里,这几个字节当指针用,在池外就是其他有意义的东东。
> 有时候也会用一个union,一个是池里linknode,另一个就是足够长度的char[]。池里的时候当作linknode用,丢出去就char[]给别人初始化。
>
> 2008/10/15 hhuai <[hidden email]>
>
> > 这是那段Int对象获取内存的函数,相信看过都清楚。
> > static PyIntObject *
> > fill_free_list(void)
> > {
> >        PyIntObject *p, *q;
> >        /* Python's object allocator isn't appropriate for large blocks. */
> >        p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
> >        if (p == NULL)
> >                return (PyIntObject *) PyErr_NoMemory();
> >        ((PyIntBlock *)p)->next = block_list;
> >        block_list = (PyIntBlock *)p;
> >        /* Link the int objects together, from rear to front, then return
> >           the address of the last int object in the block. */
> >        p = &((PyIntBlock *)p)->objects[0];
> >        q = p + N_INTOBJECTS;
> >        while (--q > p)
> >                q->ob_type = (struct _typeobject *)(q-1);
> >        q->ob_type = NULL;
> >        return p + N_INTOBJECTS - 1;
> > }
>
> > p指针声明为PyIntObject* ,但是malloc时为了使用这个指针而用强制转换使用他,虽然说都是指针,这样运行没问题,但看起来费劲。
> > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> > 有朋友有同感没有,还是我理解有问题。
>
>



--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68266] Re: python的源码写得好奇怪啊。

soldier-2
谢谢,我想继续把这个源码给看下去。
或许是按规范写代码养成习惯了,不太习惯看这种代码了。
我们那时有个要求是,公司所有人写出来的代码风格要一模一样,严格按照公司制定的编码标准。
虽然已离开那个公司,但现在都养成了那个习惯了,不让我那样写,我心里还真别扭。真不知是好还是坏。


On 10月15日, 上午11时36分, "yi gong" <[hidden email]> wrote:

> --!
> 这个怎么说呢。说实话,这些真的是难者不会,会者不难的东东,而且源码作者没有义务解释这点东西。整个cpython里的tricky的东东太多了,要是全都解释了,估计要比源码还长。
>
> 就是要省这几个字节啊,兄弟。你要想想你一个hello world,后面要帮你生成多少个PyObject.对于库作者来说,这些都是致命的硬伤。
>
> union的用法看来这位兄弟是入门了。用union还是作一次类型转换就看当初作者的个人喜好了,在我看来就是一路货,把宝押在系统内存的字节排列上了,所以这招在c++有时候就玩不转了。
>
> 想起一句笑话,作java的看不起作html,c++看不起作java的,c看不起作c++的,汇编看不起用c的,公司小妹看不起所有写代码的。
> 是这样说的么?  :)
>
> 推荐一本好书,侯捷的 《STL源码剖析》,不过挺贵,能借就借。看了之后c/c++功底大有长进(吹牛的功底 ^^)。
>
> 2008/10/15 hhuai <[hidden email]>
>
> > 两位这么一讲解,我算是明白了,
> > 不过我觉得作者为啥不写得更清晰点,这样弄,有点浪费读者的时间。
>
> > p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
> > 这里这个p,完全可以再声明一个出来,像这样
> > PyIntBlock pp = (PyIntBlock *)PyMem_MALLOC(sizeof(PyIntBlock));
> > 因为这里p的作用本来是作PyIntObject链表的,没必要拿作他用。
> > 不会连这几个字节都要节省吧。
>
> > q->ob_type = (struct _typeobject *)(q-1);
> > 可以用个union
> > union{
> >  ob_type
> >  mem_link};
> > 再池里用q->mem_link,在外用q->ob_type,意义就明了了,
>
> > On 10月15日, 上午11时05分, "yi gong" <[hidden email]> wrote:
> > > > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> > > > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> > > > 有朋友有同感没有,还是我理解有问题。
>
> > > C中的池的常规做法,看多了就熟了。为了节省内存。在池里,这几个字节当指针用,在池外就是其他有意义的东东。
>
> > 有时候也会用一个union,一个是池里linknode,另一个就是足够长度的char[]。池里的时候当作linknode用,丢出去就char[]给别人初始化。
>
> > > 2008/10/15 hhuai <[hidden email]>
>
> > > > 这是那段Int对象获取内存的函数,相信看过都清楚。
> > > > static PyIntObject *
> > > > fill_free_list(void)
> > > > {
> > > >        PyIntObject *p, *q;
> > > >        /* Python's object allocator isn't appropriate for large blocks.
> > */
> > > >        p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
> > > >        if (p == NULL)
> > > >                return (PyIntObject *) PyErr_NoMemory();
> > > >        ((PyIntBlock *)p)->next = block_list;
> > > >        block_list = (PyIntBlock *)p;
> > > >        /* Link the int objects together, from rear to front, then
> > return
> > > >           the address of the last int object in the block. */
> > > >        p = &((PyIntBlock *)p)->objects[0];
> > > >        q = p + N_INTOBJECTS;
> > > >        while (--q > p)
> > > >                q->ob_type = (struct _typeobject *)(q-1);
> > > >        q->ob_type = NULL;
> > > >        return p + N_INTOBJECTS - 1;
> > > > }
>
> > > > p指针声明为PyIntObject* ,但是malloc时为了使用这个指针而用强制转换使用他,虽然说都是指针,这样运行没问题,但看起来费劲。
> > > > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> > > > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> > > > 有朋友有同感没有,还是我理解有问题。
>
>
--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68267] Re: python的源码写得好奇怪啊。

LaiYonghao

干嘛老有人动不动就看源码?

2008/10/15 hhuai <[hidden email]>
谢谢,我想继续把这个源码给看下去。
或许是按规范写代码养成习惯了,不太习惯看这种代码了。
我们那时有个要求是,公司所有人写出来的代码风格要一模一样,严格按照公司制定的编码标准。
虽然已离开那个公司,但现在都养成了那个习惯了,不让我那样写,我心里还真别扭。真不知是好还是坏。


On 10月15日, 上午11时36分, "yi gong" <[hidden email]> wrote:
> --!
> 这个怎么说呢。说实话,这些真的是难者不会,会者不难的东东,而且源码作者没有义务解释这点东西。整个cpython里的tricky的东东太多了,要是全都解释了,估计要比源码还长。
>
> 就是要省这几个字节啊,兄弟。你要想想你一个hello world,后面要帮你生成多少个PyObject.对于库作者来说,这些都是致命的硬伤。
>
> union的用法看来这位兄弟是入门了。用union还是作一次类型转换就看当初作者的个人喜好了,在我看来就是一路货,把宝押在系统内存的字节排列上了,所以这招在c++有时候就玩不转了。
>
> 想起一句笑话,作java的看不起作html,c++看不起作java的,c看不起作c++的,汇编看不起用c的,公司小妹看不起所有写代码的。
> 是这样说的么?  :)
>
> 推荐一本好书,侯捷的 《STL源码剖析》,不过挺贵,能借就借。看了之后c/c++功底大有长进(吹牛的功底 ^^)。
>
> 2008/10/15 hhuai <[hidden email]>
>
> > 两位这么一讲解,我算是明白了,
> > 不过我觉得作者为啥不写得更清晰点,这样弄,有点浪费读者的时间。
>
> > p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
> > 这里这个p,完全可以再声明一个出来,像这样
> > PyIntBlock pp = (PyIntBlock *)PyMem_MALLOC(sizeof(PyIntBlock));
> > 因为这里p的作用本来是作PyIntObject链表的,没必要拿作他用。
> > 不会连这几个字节都要节省吧。
>
> > q->ob_type = (struct _typeobject *)(q-1);
> > 可以用个union
> > union{
> >  ob_type
> >  mem_link};
> > 再池里用q->mem_link,在外用q->ob_type,意义就明了了,
>
> > On 10月15日, 上午11时05分, "yi gong" <[hidden email]> wrote:
> > > > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> > > > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> > > > 有朋友有同感没有,还是我理解有问题。
>
> > > C中的池的常规做法,看多了就熟了。为了节省内存。在池里,这几个字节当指针用,在池外就是其他有意义的东东。
>
> > 有时候也会用一个union,一个是池里linknode,另一个就是足够长度的char[]。池里的时候当作linknode用,丢出去就char[]给别人初始化。
>
> > > 2008/10/15 hhuai <[hidden email]>
>
> > > > 这是那段Int对象获取内存的函数,相信看过都清楚。
> > > > static PyIntObject *
> > > > fill_free_list(void)
> > > > {
> > > >        PyIntObject *p, *q;
> > > >        /* Python's object allocator isn't appropriate for large blocks.
> > */
> > > >        p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
> > > >        if (p == NULL)
> > > >                return (PyIntObject *) PyErr_NoMemory();
> > > >        ((PyIntBlock *)p)->next = block_list;
> > > >        block_list = (PyIntBlock *)p;
> > > >        /* Link the int objects together, from rear to front, then
> > return
> > > >           the address of the last int object in the block. */
> > > >        p = &((PyIntBlock *)p)->objects[0];
> > > >        q = p + N_INTOBJECTS;
> > > >        while (--q > p)
> > > >                q->ob_type = (struct _typeobject *)(q-1);
> > > >        q->ob_type = NULL;
> > > >        return p + N_INTOBJECTS - 1;
> > > > }
>
> > > > p指针声明为PyIntObject* ,但是malloc时为了使用这个指针而用强制转换使用他,虽然说都是指针,这样运行没问题,但看起来费劲。
> > > > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> > > > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> > > > 有朋友有同感没有,还是我理解有问题。
>
>




--
http://blog.csdn.net/lanphaday
-------------------------------------------
用 C++ 的时候盯着 python,用 python 的时候盯着 C++。

--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68268] Re: python的源码写得好奇怪啊。

soldier-2
哈哈,这个问题就得问Robert Chen了。

On 10月15日, 下午12时22分, LaiYonghao <[hidden email]> wrote:
> 干嘛老有人动不动就看源码?
>

--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68269] Re: python的源码写得好奇怪啊。

yi gong
In reply to this post by LaiYonghao
写代码的不看别人的源码,还真学不到最好的东西。



2008/10/15 LaiYonghao <[hidden email]>

干嘛老有人动不动就看源码?

2008/10/15 hhuai <[hidden email]>
谢谢,我想继续把这个源码给看下去。

或许是按规范写代码养成习惯了,不太习惯看这种代码了。
我们那时有个要求是,公司所有人写出来的代码风格要一模一样,严格按照公司制定的编码标准。
虽然已离开那个公司,但现在都养成了那个习惯了,不让我那样写,我心里还真别扭。真不知是好还是坏。


On 10月15日, 上午11时36分, "yi gong" <[hidden email]> wrote:
> --!
> 这个怎么说呢。说实话,这些真的是难者不会,会者不难的东东,而且源码作者没有义务解释这点东西。整个cpython里的tricky的东东太多了,要是全都解释了,估计要比源码还长。
>
> 就是要省这几个字节啊,兄弟。你要想想你一个hello world,后面要帮你生成多少个PyObject.对于库作者来说,这些都是致命的硬伤。
>
> union的用法看来这位兄弟是入门了。用union还是作一次类型转换就看当初作者的个人喜好了,在我看来就是一路货,把宝押在系统内存的字节排列上了,所以这招在c++有时候就玩不转了。
>
> 想起一句笑话,作java的看不起作html,c++看不起作java的,c看不起作c++的,汇编看不起用c的,公司小妹看不起所有写代码的。
> 是这样说的么?  :)
>
> 推荐一本好书,侯捷的 《STL源码剖析》,不过挺贵,能借就借。看了之后c/c++功底大有长进(吹牛的功底 ^^)。
>
> 2008/10/15 hhuai <[hidden email]>
>
> > 两位这么一讲解,我算是明白了,
> > 不过我觉得作者为啥不写得更清晰点,这样弄,有点浪费读者的时间。
>
> > p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
> > 这里这个p,完全可以再声明一个出来,像这样
> > PyIntBlock pp = (PyIntBlock *)PyMem_MALLOC(sizeof(PyIntBlock));
> > 因为这里p的作用本来是作PyIntObject链表的,没必要拿作他用。
> > 不会连这几个字节都要节省吧。
>
> > q->ob_type = (struct _typeobject *)(q-1);
> > 可以用个union
> > union{
> >  ob_type
> >  mem_link};
> > 再池里用q->mem_link,在外用q->ob_type,意义就明了了,
>
> > On 10月15日, 上午11时05分, "yi gong" <[hidden email]> wrote:
> > > > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> > > > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> > > > 有朋友有同感没有,还是我理解有问题。
>
> > > C中的池的常规做法,看多了就熟了。为了节省内存。在池里,这几个字节当指针用,在池外就是其他有意义的东东。
>
> > 有时候也会用一个union,一个是池里linknode,另一个就是足够长度的char[]。池里的时候当作linknode用,丢出去就char[]给别人初始化。
>
> > > 2008/10/15 hhuai <[hidden email]>
>
> > > > 这是那段Int对象获取内存的函数,相信看过都清楚。
> > > > static PyIntObject *
> > > > fill_free_list(void)
> > > > {
> > > >        PyIntObject *p, *q;
> > > >        /* Python's object allocator isn't appropriate for large blocks.
> > */
> > > >        p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
> > > >        if (p == NULL)
> > > >                return (PyIntObject *) PyErr_NoMemory();
> > > >        ((PyIntBlock *)p)->next = block_list;
> > > >        block_list = (PyIntBlock *)p;
> > > >        /* Link the int objects together, from rear to front, then
> > return
> > > >           the address of the last int object in the block. */
> > > >        p = &((PyIntBlock *)p)->objects[0];
> > > >        q = p + N_INTOBJECTS;
> > > >        while (--q > p)
> > > >                q->ob_type = (struct _typeobject *)(q-1);
> > > >        q->ob_type = NULL;
> > > >        return p + N_INTOBJECTS - 1;
> > > > }
>
> > > > p指针声明为PyIntObject* ,但是malloc时为了使用这个指针而用强制转换使用他,虽然说都是指针,这样运行没问题,但看起来费劲。
> > > > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> > > > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> > > > 有朋友有同感没有,还是我理解有问题。
>
>




--
http://blog.csdn.net/lanphaday
-------------------------------------------
用 C++ 的时候盯着 python,用 python 的时候盯着 C++。




--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68272] Re: python的源码写得好奇怪啊。

LaiYonghao
从学习的角度来看,是个理由。
从商业的角度来看,去看源码跟"重复发明轮子"相当。
不然封装的思想就没啥意义了。
公司招个人,要看以前的源码,然后才能开始工作,成本太高。
还有什么机密之类的,本来就不可能看到源码的。
所以,有时间去推敲源码的,还不如静下心来读一下 manuals,事半功倍。
也许有人说手册不见得什么都有讲;其实大部分成功工具的手册真的是什么都有讲的,如果真有什么非常 hack 的东西没有讲,那肯定是因为这个实现不怎么好,套用一句 python 箴言:好方案易于描述,不易于描述的方案不是好方案;由此可见,手册不讲的东西就是不需要知道的东西,你硬要通过读源码去知道,那就是用劲用错了地方,而且可能学坏了自己(比如在日常项目中应用非常 hack 的手段实现需求),最后被上级或老板痛骂,侥幸躲过了,也绝躲不过后续维护人员对自己祖宗十八代的问候。
综上所述,敬请珍爱生命,远离源码。

2008/10/15 yi gong <[hidden email]>
写代码的不看别人的源码,还真学不到最好的东西。



2008/10/15 LaiYonghao <[hidden email]>

干嘛老有人动不动就看源码?

2008/10/15 hhuai <[hidden email]>
谢谢,我想继续把这个源码给看下去。

或许是按规范写代码养成习惯了,不太习惯看这种代码了。
我们那时有个要求是,公司所有人写出来的代码风格要一模一样,严格按照公司制定的编码标准。
虽然已离开那个公司,但现在都养成了那个习惯了,不让我那样写,我心里还真别扭。真不知是好还是坏。


On 10月15日, 上午11时36分, "yi gong" <[hidden email]> wrote:
> --!
> 这个怎么说呢。说实话,这些真的是难者不会,会者不难的东东,而且源码作者没有义务解释这点东西。整个cpython里的tricky的东东太多了,要是全都解释了,估计要比源码还长。
>
> 就是要省这几个字节啊,兄弟。你要想想你一个hello world,后面要帮你生成多少个PyObject.对于库作者来说,这些都是致命的硬伤。
>
> union的用法看来这位兄弟是入门了。用union还是作一次类型转换就看当初作者的个人喜好了,在我看来就是一路货,把宝押在系统内存的字节排列上了,所以这招在c++有时候就玩不转了。
>
> 想起一句笑话,作java的看不起作html,c++看不起作java的,c看不起作c++的,汇编看不起用c的,公司小妹看不起所有写代码的。
> 是这样说的么?  :)
>
> 推荐一本好书,侯捷的 《STL源码剖析》,不过挺贵,能借就借。看了之后c/c++功底大有长进(吹牛的功底 ^^)。
>
> 2008/10/15 hhuai <[hidden email]>
>
> > 两位这么一讲解,我算是明白了,
> > 不过我觉得作者为啥不写得更清晰点,这样弄,有点浪费读者的时间。
>
> > p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
> > 这里这个p,完全可以再声明一个出来,像这样
> > PyIntBlock pp = (PyIntBlock *)PyMem_MALLOC(sizeof(PyIntBlock));
> > 因为这里p的作用本来是作PyIntObject链表的,没必要拿作他用。
> > 不会连这几个字节都要节省吧。
>
> > q->ob_type = (struct _typeobject *)(q-1);
> > 可以用个union
> > union{
> >  ob_type
> >  mem_link};
> > 再池里用q->mem_link,在外用q->ob_type,意义就明了了,
>
> > On 10月15日, 上午11时05分, "yi gong" <[hidden email]> wrote:
> > > > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> > > > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> > > > 有朋友有同感没有,还是我理解有问题。
>
> > > C中的池的常规做法,看多了就熟了。为了节省内存。在池里,这几个字节当指针用,在池外就是其他有意义的东东。
>
> > 有时候也会用一个union,一个是池里linknode,另一个就是足够长度的char[]。池里的时候当作linknode用,丢出去就char[]给别人初始化。
>
> > > 2008/10/15 hhuai <[hidden email]>
>
> > > > 这是那段Int对象获取内存的函数,相信看过都清楚。
> > > > static PyIntObject *
> > > > fill_free_list(void)
> > > > {
> > > >        PyIntObject *p, *q;
> > > >        /* Python's object allocator isn't appropriate for large blocks.
> > */
> > > >        p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
> > > >        if (p == NULL)
> > > >                return (PyIntObject *) PyErr_NoMemory();
> > > >        ((PyIntBlock *)p)->next = block_list;
> > > >        block_list = (PyIntBlock *)p;
> > > >        /* Link the int objects together, from rear to front, then
> > return
> > > >           the address of the last int object in the block. */
> > > >        p = &((PyIntBlock *)p)->objects[0];
> > > >        q = p + N_INTOBJECTS;
> > > >        while (--q > p)
> > > >                q->ob_type = (struct _typeobject *)(q-1);
> > > >        q->ob_type = NULL;
> > > >        return p + N_INTOBJECTS - 1;
> > > > }
>
> > > > p指针声明为PyIntObject* ,但是malloc时为了使用这个指针而用强制转换使用他,虽然说都是指针,这样运行没问题,但看起来费劲。
> > > > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> > > > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> > > > 有朋友有同感没有,还是我理解有问题。
>
>




--
http://blog.csdn.net/lanphaday
-------------------------------------------
用 C++ 的时候盯着 python,用 python 的时候盯着 C++。








--
http://blog.csdn.net/lanphaday
-------------------------------------------
用 C++ 的时候盯着 python,用 python 的时候盯着 C++。

--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68273] Re: python的源码写得好奇怪啊。

eric-347
珍爱生命,远离源码,欣赏这句哈

----- Original Message -----
From: "LaiYonghao" <[hidden email]>
To: <[hidden email]>
Sent: Wednesday, October 15, 2008 1:18 PM
Subject: [CPyUG:68272] Re: python的源码写得好奇怪啊。


> 从学习的角度来看,是个理由。从商业的角度来看,去看源码跟"重复发明轮子"相当。
> 不然封装的思想就没啥意义了。
> 公司招个人,要看以前的源码,然后才能开始工作,成本太高。
> 还有什么机密之类的,本来就不可能看到源码的。
> 所以,有时间去推敲源码的,还不如静下心来读一下 manuals,事半功倍。
> 也许有人说手册不见得什么都有讲;其实大部分成功工具的手册真的是什么都有讲的,如果真有什么非常 hack
> 的东西没有讲,那肯定是因为这个实现不怎么好,套用一句 python
> 箴言:好方案易于描述,不易于描述的方案不是好方案;由此可见,手册不讲的东西就是不需要知道的东西,你硬要通过读源码去知道,那就是用劲用错了地方,而且可能学坏了自己(比如在日常项目中应用非常
> hack 的手段实现需求),最后被上级或老板痛骂,侥幸躲过了,也绝躲不过后续维护人员对自己祖宗十八代的问候。
> 综上所述,敬请珍爱生命,远离源码。
>
> 2008/10/15 yi gong <[hidden email]>
>
>> 写代码的不看别人的源码,还真学不到最好的东西。
>>
>>
>>
>> 2008/10/15 LaiYonghao <[hidden email]>
>>
>>>
>>> 干嘛老有人动不动就看源码?
>>>
>>> 2008/10/15 hhuai <[hidden email]>
>>>
>>>> 谢谢,我想继续把这个源码给看下去。
>>>>
>>>> 或许是按规范写代码养成习惯了,不太习惯看这种代码了。
>>>> 我们那时有个要求是,公司所有人写出来的代码风格要一模一样,严格按照公司制定的编码标准。
>>>> 虽然已离开那个公司,但现在都养成了那个习惯了,不让我那样写,我心里还真别扭。真不知是好还是坏。
>>>>
>>>>
>>>> On 10月15日, 上午11时36分, "yi gong" <[hidden email]> wrote:
>>>> > --!
>>>> >
>>>> 这个怎么说呢。说实话,这些真的是难者不会,会者不难的东东,而且源码作者没有义务解释这点东西。整个cpython里的tricky的东东太多了,要是全都解释了,估计要比源码还长。
>>>> >
>>>> > 就是要省这几个字节啊,兄弟。你要想想你一个hello world,后面要帮你生成多少个PyObject.对于库作者来说,这些都是致命的硬伤。
>>>> >
>>>> >
>>>> union的用法看来这位兄弟是入门了。用union还是作一次类型转换就看当初作者的个人喜好了,在我看来就是一路货,把宝押在系统内存的字节排列上了,所以这招在c++有时候就玩不转了。
>>>> >
>>>> > 想起一句笑话,作java的看不起作html,c++看不起作java的,c看不起作c++的,汇编看不起用c的,公司小妹看不起所有写代码的。
>>>> > 是这样说的么?  :)
>>>> >
>>>> > 推荐一本好书,侯捷的 《STL源码剖析》,不过挺贵,能借就借。看了之后c/c++功底大有长进(吹牛的功底 ^^)。
>>>> >
>>>> > 2008/10/15 hhuai <[hidden email]>
>>>> >
>>>> > > 两位这么一讲解,我算是明白了,
>>>> > > 不过我觉得作者为啥不写得更清晰点,这样弄,有点浪费读者的时间。
>>>> >
>>>> > > p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
>>>> > > 这里这个p,完全可以再声明一个出来,像这样
>>>> > > PyIntBlock pp = (PyIntBlock *)PyMem_MALLOC(sizeof(PyIntBlock));
>>>> > > 因为这里p的作用本来是作PyIntObject链表的,没必要拿作他用。
>>>> > > 不会连这几个字节都要节省吧。
>>>> >
>>>> > > q->ob_type = (struct _typeobject *)(q-1);
>>>> > > 可以用个union
>>>> > > union{
>>>> > >  ob_type
>>>> > >  mem_link};
>>>> > > 再池里用q->mem_link,在外用q->ob_type,意义就明了了,
>>>> >
>>>> > > On 10月15日, 上午11时05分, "yi gong" <[hidden email]> wrote:
>>>> > > > > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject
>>>> *,为了这里用ob_type将这个链表连起来,让我
>>>> > > > > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
>>>> > > > > 有朋友有同感没有,还是我理解有问题。
>>>> >
>>>> > > > C中的池的常规做法,看多了就熟了。为了节省内存。在池里,这几个字节当指针用,在池外就是其他有意义的东东。
>>>> >
>>>> > >
>>>> 有时候也会用一个union,一个是池里linknode,另一个就是足够长度的char[]。池里的时候当作linknode用,丢出去就char[]给别人初始化。
>>>> >
>>>> > > > 2008/10/15 hhuai <[hidden email]>
>>>> >
>>>> > > > > 这是那段Int对象获取内存的函数,相信看过都清楚。
>>>> > > > > static PyIntObject *
>>>> > > > > fill_free_list(void)
>>>> > > > > {
>>>> > > > >        PyIntObject *p, *q;
>>>> > > > >        /* Python's object allocator isn't appropriate for large
>>>> blocks.
>>>> > > */
>>>> > > > >        p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
>>>> > > > >        if (p == NULL)
>>>> > > > >                return (PyIntObject *) PyErr_NoMemory();
>>>> > > > >        ((PyIntBlock *)p)->next = block_list;
>>>> > > > >        block_list = (PyIntBlock *)p;
>>>> > > > >        /* Link the int objects together, from rear to front, then
>>>> > > return
>>>> > > > >           the address of the last int object in the block. */
>>>> > > > >        p = &((PyIntBlock *)p)->objects[0];
>>>> > > > >        q = p + N_INTOBJECTS;
>>>> > > > >        while (--q > p)
>>>> > > > >                q->ob_type = (struct _typeobject *)(q-1);
>>>> > > > >        q->ob_type = NULL;
>>>> > > > >        return p + N_INTOBJECTS - 1;
>>>> > > > > }
>>>> >
>>>> > > > > p指针声明为PyIntObject*
>>>> ,但是malloc时为了使用这个指针而用强制转换使用他,虽然说都是指针,这样运行没问题,但看起来费劲。
>>>> > > > > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject
>>>> *,为了这里用ob_type将这个链表连起来,让我
>>>> > > > > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
>>>> > > > > 有朋友有同感没有,还是我理解有问题。
>>>> >
>>>> >
>>>>
>>>>
>>>
>>>
>>> --
>>> http://blog.csdn.net/lanphaday
>>> -------------------------------------------
>>> 用 C++ 的时候盯着 python,用 python 的时候盯着 C++。
>>>
>>>
>>>
>>
>> >
>>
>
>
> --
> http://blog.csdn.net/lanphaday
> -------------------------------------------
> 用 C++ 的时候盯着 python,用 python 的时候盯着 C++。
>
> >
>
--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68274] Re: python的源码写得好奇怪啊。

yi gong
In reply to this post by LaiYonghao
反对
知其然而不知其所以然在现在的it业绝对是大忌讳。如果有条件,有时间,有动力看源码,我绝对赞成。而且我认为,不但但只看现在工作有关的,有精力的还可以去看看和工作无关的。

作java的看看c#的代码,作c的看看python代码。作框架的看看实现的代码。作应用的看看虚拟机的代码。不无益处!!




2008/10/15 LaiYonghao <[hidden email]>
从学习的角度来看,是个理由。
从商业的角度来看,去看源码跟"重复发明轮子"相当。
不然封装的思想就没啥意义了。
公司招个人,要看以前的源码,然后才能开始工作,成本太高。
还有什么机密之类的,本来就不可能看到源码的。
所以,有时间去推敲源码的,还不如静下心来读一下 manuals,事半功倍。
也许有人说手册不见得什么都有讲;其实大部分成功工具的手册真的是什么都有讲的,如果真有什么非常 hack 的东西没有讲,那肯定是因为这个实现不怎么好,套用一句 python 箴言:好方案易于描述,不易于描述的方案不是好方案;由此可见,手册不讲的东西就是不需要知道的东西,你硬要通过读源码去知道,那就是用劲用错了地方,而且可能学坏了自己(比如在日常项目中应用非常 hack 的手段实现需求),最后被上级或老板痛骂,侥幸躲过了,也绝躲不过后续维护人员对自己祖宗十八代的问候。
综上所述,敬请珍爱生命,远离源码。

2008/10/15 yi gong <[hidden email]>

写代码的不看别人的源码,还真学不到最好的东西。



2008/10/15 LaiYonghao <[hidden email]>

干嘛老有人动不动就看源码?

2008/10/15 hhuai <[hidden email]>
谢谢,我想继续把这个源码给看下去。

或许是按规范写代码养成习惯了,不太习惯看这种代码了。
我们那时有个要求是,公司所有人写出来的代码风格要一模一样,严格按照公司制定的编码标准。
虽然已离开那个公司,但现在都养成了那个习惯了,不让我那样写,我心里还真别扭。真不知是好还是坏。


On 10月15日, 上午11时36分, "yi gong" <[hidden email]> wrote:
> --!
> 这个怎么说呢。说实话,这些真的是难者不会,会者不难的东东,而且源码作者没有义务解释这点东西。整个cpython里的tricky的东东太多了,要是全都解释了,估计要比源码还长。
>
> 就是要省这几个字节啊,兄弟。你要想想你一个hello world,后面要帮你生成多少个PyObject.对于库作者来说,这些都是致命的硬伤。
>
> union的用法看来这位兄弟是入门了。用union还是作一次类型转换就看当初作者的个人喜好了,在我看来就是一路货,把宝押在系统内存的字节排列上了,所以这招在c++有时候就玩不转了。
>
> 想起一句笑话,作java的看不起作html,c++看不起作java的,c看不起作c++的,汇编看不起用c的,公司小妹看不起所有写代码的。
> 是这样说的么?  :)
>
> 推荐一本好书,侯捷的 《STL源码剖析》,不过挺贵,能借就借。看了之后c/c++功底大有长进(吹牛的功底 ^^)。
>
> 2008/10/15 hhuai <[hidden email]>
>
> > 两位这么一讲解,我算是明白了,
> > 不过我觉得作者为啥不写得更清晰点,这样弄,有点浪费读者的时间。
>
> > p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
> > 这里这个p,完全可以再声明一个出来,像这样
> > PyIntBlock pp = (PyIntBlock *)PyMem_MALLOC(sizeof(PyIntBlock));
> > 因为这里p的作用本来是作PyIntObject链表的,没必要拿作他用。
> > 不会连这几个字节都要节省吧。
>
> > q->ob_type = (struct _typeobject *)(q-1);
> > 可以用个union
> > union{
> >  ob_type
> >  mem_link};
> > 再池里用q->mem_link,在外用q->ob_type,意义就明了了,
>
> > On 10月15日, 上午11时05分, "yi gong" <[hidden email]> wrote:
> > > > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> > > > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> > > > 有朋友有同感没有,还是我理解有问题。
>
> > > C中的池的常规做法,看多了就熟了。为了节省内存。在池里,这几个字节当指针用,在池外就是其他有意义的东东。
>
> > 有时候也会用一个union,一个是池里linknode,另一个就是足够长度的char[]。池里的时候当作linknode用,丢出去就char[]给别人初始化。
>
> > > 2008/10/15 hhuai <[hidden email]>
>
> > > > 这是那段Int对象获取内存的函数,相信看过都清楚。
> > > > static PyIntObject *
> > > > fill_free_list(void)
> > > > {
> > > >        PyIntObject *p, *q;
> > > >        /* Python's object allocator isn't appropriate for large blocks.
> > */
> > > >        p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
> > > >        if (p == NULL)
> > > >                return (PyIntObject *) PyErr_NoMemory();
> > > >        ((PyIntBlock *)p)->next = block_list;
> > > >        block_list = (PyIntBlock *)p;
> > > >        /* Link the int objects together, from rear to front, then
> > return
> > > >           the address of the last int object in the block. */
> > > >        p = &((PyIntBlock *)p)->objects[0];
> > > >        q = p + N_INTOBJECTS;
> > > >        while (--q > p)
> > > >                q->ob_type = (struct _typeobject *)(q-1);
> > > >        q->ob_type = NULL;
> > > >        return p + N_INTOBJECTS - 1;
> > > > }
>
> > > > p指针声明为PyIntObject* ,但是malloc时为了使用这个指针而用强制转换使用他,虽然说都是指针,这样运行没问题,但看起来费劲。
> > > > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> > > > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> > > > 有朋友有同感没有,还是我理解有问题。
>
>




--
http://blog.csdn.net/lanphaday
-------------------------------------------
用 C++ 的时候盯着 python,用 python 的时候盯着 C++。








--
http://blog.csdn.net/lanphaday
-------------------------------------------
用 C++ 的时候盯着 python,用 python 的时候盯着 C++。




--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68275] Re: python的源码写得好奇怪啊。

James liu-2
如果看代码能看出点tips和设计思路,那还是有价值的

反之浪费时间~,还不如看手册


--
regards
j.L

--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68276] Re: python的源码写得好奇怪啊。

LaiYonghao
In reply to this post by yi gong
你是理想主义者,我不是。
去读源码要成本的,当付出成本得到的收益较小,甚至是负值的时候,为什么要去看源码?
做 java 的一定要看 C# 才能了解 C# ?看 C# 的帮助文档就不可以?做 C 的就一定要看 python 代码?这份代码真的权威吗、完美吗?

lift is short,you need python。
为什么?
因为 python 可以把你从沉重的技术细节(内存分配、数据结构、算法、网络、数据库等)中解放出来,解放生产力,创造更大的经济效益。
这时候还去看源码,那就是把解放出来的生产力完全浪费了。支持封装吧,有些事情我们不必知道为什么。你看,某党也是这样的政策,比如现在的十七届三中全会,你看发布出来的公告就可以了,非要去看全程会议记录,那就是"天堂有路你不走,地狱无门偏要来"。两千年来的儒家思想也是:穷则独善其身,达则兼济天下。意思就是说自己水平菜的时候努力去看 manuals,等牛逼了就用 python 写个牛逼的程序给大家用用。

2008/10/15 yi gong <[hidden email]>
反对
知其然而不知其所以然在现在的it业绝对是大忌讳。如果有条件,有时间,有动力看源码,我绝对赞成。而且我认为,不但但只看现在工作有关的,有精力的还可以去看看和工作无关的。

作java的看看c#的代码,作c的看看python代码。作框架的看看实现的代码。作应用的看看虚拟机的代码。不无益处!!





2008/10/15 LaiYonghao <[hidden email]>
从学习的角度来看,是个理由。
从商业的角度来看,去看源码跟"重复发明轮子"相当。
不然封装的思想就没啥意义了。
公司招个人,要看以前的源码,然后才能开始工作,成本太高。
还有什么机密之类的,本来就不可能看到源码的。
所以,有时间去推敲源码的,还不如静下心来读一下 manuals,事半功倍。
也许有人说手册不见得什么都有讲;其实大部分成功工具的手册真的是什么都有讲的,如果真有什么非常 hack 的东西没有讲,那肯定是因为这个实现不怎么好,套用一句 python 箴言:好方案易于描述,不易于描述的方案不是好方案;由此可见,手册不讲的东西就是不需要知道的东西,你硬要通过读源码去知道,那就是用劲用错了地方,而且可能学坏了自己(比如在日常项目中应用非常 hack 的手段实现需求),最后被上级或老板痛骂,侥幸躲过了,也绝躲不过后续维护人员对自己祖宗十八代的问候。
综上所述,敬请珍爱生命,远离源码。

2008/10/15 yi gong <[hidden email]>

写代码的不看别人的源码,还真学不到最好的东西。



2008/10/15 LaiYonghao <[hidden email]>

干嘛老有人动不动就看源码?

2008/10/15 hhuai <[hidden email]>
谢谢,我想继续把这个源码给看下去。

或许是按规范写代码养成习惯了,不太习惯看这种代码了。
我们那时有个要求是,公司所有人写出来的代码风格要一模一样,严格按照公司制定的编码标准。
虽然已离开那个公司,但现在都养成了那个习惯了,不让我那样写,我心里还真别扭。真不知是好还是坏。


On 10月15日, 上午11时36分, "yi gong" <[hidden email]> wrote:
> --!
> 这个怎么说呢。说实话,这些真的是难者不会,会者不难的东东,而且源码作者没有义务解释这点东西。整个cpython里的tricky的东东太多了,要是全都解释了,估计要比源码还长。
>
> 就是要省这几个字节啊,兄弟。你要想想你一个hello world,后面要帮你生成多少个PyObject.对于库作者来说,这些都是致命的硬伤。
>
> union的用法看来这位兄弟是入门了。用union还是作一次类型转换就看当初作者的个人喜好了,在我看来就是一路货,把宝押在系统内存的字节排列上了,所以这招在c++有时候就玩不转了。
>
> 想起一句笑话,作java的看不起作html,c++看不起作java的,c看不起作c++的,汇编看不起用c的,公司小妹看不起所有写代码的。
> 是这样说的么?  :)
>
> 推荐一本好书,侯捷的 《STL源码剖析》,不过挺贵,能借就借。看了之后c/c++功底大有长进(吹牛的功底 ^^)。
>
> 2008/10/15 hhuai <[hidden email]>
>
> > 两位这么一讲解,我算是明白了,
> > 不过我觉得作者为啥不写得更清晰点,这样弄,有点浪费读者的时间。
>
> > p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
> > 这里这个p,完全可以再声明一个出来,像这样
> > PyIntBlock pp = (PyIntBlock *)PyMem_MALLOC(sizeof(PyIntBlock));
> > 因为这里p的作用本来是作PyIntObject链表的,没必要拿作他用。
> > 不会连这几个字节都要节省吧。
>
> > q->ob_type = (struct _typeobject *)(q-1);
> > 可以用个union
> > union{
> >  ob_type
> >  mem_link};
> > 再池里用q->mem_link,在外用q->ob_type,意义就明了了,
>
> > On 10月15日, 上午11时05分, "yi gong" <[hidden email]> wrote:
> > > > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> > > > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> > > > 有朋友有同感没有,还是我理解有问题。
>
> > > C中的池的常规做法,看多了就熟了。为了节省内存。在池里,这几个字节当指针用,在池外就是其他有意义的东东。
>
> > 有时候也会用一个union,一个是池里linknode,另一个就是足够长度的char[]。池里的时候当作linknode用,丢出去就char[]给别人初始化。
>
> > > 2008/10/15 hhuai <[hidden email]>
>
> > > > 这是那段Int对象获取内存的函数,相信看过都清楚。
> > > > static PyIntObject *
> > > > fill_free_list(void)
> > > > {
> > > >        PyIntObject *p, *q;
> > > >        /* Python's object allocator isn't appropriate for large blocks.
> > */
> > > >        p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
> > > >        if (p == NULL)
> > > >                return (PyIntObject *) PyErr_NoMemory();
> > > >        ((PyIntBlock *)p)->next = block_list;
> > > >        block_list = (PyIntBlock *)p;
> > > >        /* Link the int objects together, from rear to front, then
> > return
> > > >           the address of the last int object in the block. */
> > > >        p = &((PyIntBlock *)p)->objects[0];
> > > >        q = p + N_INTOBJECTS;
> > > >        while (--q > p)
> > > >                q->ob_type = (struct _typeobject *)(q-1);
> > > >        q->ob_type = NULL;
> > > >        return p + N_INTOBJECTS - 1;
> > > > }
>
> > > > p指针声明为PyIntObject* ,但是malloc时为了使用这个指针而用强制转换使用他,虽然说都是指针,这样运行没问题,但看起来费劲。
> > > > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> > > > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> > > > 有朋友有同感没有,还是我理解有问题。
>
>




--
http://blog.csdn.net/lanphaday
-------------------------------------------
用 C++ 的时候盯着 python,用 python 的时候盯着 C++。








--
http://blog.csdn.net/lanphaday
-------------------------------------------
用 C++ 的时候盯着 python,用 python 的时候盯着 C++。








--
http://blog.csdn.net/lanphaday
-------------------------------------------
用 C++ 的时候盯着 python,用 python 的时候盯着 C++。

--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68277] Re: python的源码写得好奇怪啊。

yi gong
In reply to this post by James liu-2
如果看代码能看出来不好的设计思路,同样是有价值的。
于是乎,问题成了,看什么,而不是看不看。
一棍子打死看代码,对大多数想在这个行业提升自己能力的朋友,我看没有什么积极的作用。

你同意么?

2008/10/15 James liu <[hidden email]>
如果看代码能看出点tips和设计思路,那还是有价值的

反之浪费时间~,还不如看手册


--
regards
j.L




--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68280] Re: python的源码写得好奇怪啊。

soldier-2
In reply to this post by James liu-2
至于大家如何想的,我无权左右。
我就是觉得很吸引我,想了解一番,工作之外看一看,没想过是否值得与对错问题。

On 10月15日, 下午1时43分, "James liu" <[hidden email]> wrote:
> 如果看代码能看出点tips和设计思路,那还是有价值的
> 反之浪费时间~,还不如看手册
>
> --
> regards
> j.L
--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68281] Re: python的源码写得好奇怪啊。

James liu-2
In reply to this post by yi gong
呵呵,我说的是有选择的看,而不是学习一样就看一样。

比如我此刻就不会看python源代码剖析。


2008/10/15 yi gong <[hidden email]>
如果看代码能看出来不好的设计思路,同样是有价值的。
于是乎,问题成了,看什么,而不是看不看。
一棍子打死看代码,对大多数想在这个行业提升自己能力的朋友,我看没有什么积极的作用。

你同意么?

2008/10/15 James liu <[hidden email]>

如果看代码能看出点tips和设计思路,那还是有价值的

反之浪费时间~,还不如看手册


--
regards
j.L








--
regards
j.L

--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

Reply | Threaded
Open this post in threaded view
|

[CPyUG:68283] Re: python的源码写得好奇怪啊。

yi gong
In reply to this post by LaiYonghao
第一,我想说,相对于列表里的大牛,出书的大牛,写python的大牛,我还是很弱,很差。我多看看代码认为总有点帮助,我只是想多学学。

第二,成本有很多的定义,收益也有很多定义,即使是只考虑经济学上的含义也很复杂。比如,我一直就没有想通,为什么贷款买了房子,等房价涨了,别人都说资产增值了,跌了就说资产贬值了。反正只要没还清贷款之前,心里还是很虚的。但是有一点我知道,去找工作,如果我说我懂python,我看过手册,我能记住一些库的使用方法,那么我有加分;如果我说我看过python的实现代码,那么我也有加分,如果我同时知道手册和实现,那么我的加分就更多。所以如果我有时间,有精力,我又感兴趣,我就去看看源码。趁现在还年轻多学一点总是没有错的。而且我也相信真正作这一行的,就要有这种耐心和毅力去作一些别人认为不值得,枯燥,没有收益,无意义,很不make sense的事情。比如晚上下班后捧着一本 python源码分析或者tcp/ip协议详解看的津津有味。

第三,个人的水平是积累出来的,而积累的方式有很多。聪明的人可能一眼就能看出正确的做事方法。但是大多数朋友还是要通过刻苦学习才能提高水平。而象我这样的笨人,只好用点笨办法。我认为学习源码确实是一条可行的路。人日常学习的主要途径是模仿。而阅读源码并模仿,符合一般的学习规律。

2008/10/15 LaiYonghao <[hidden email]>
你是理想主义者,我不是。
去读源码要成本的,当付出成本得到的收益较小,甚至是负值的时候,为什么要去看源码?
做 java 的一定要看 C# 才能了解 C# ?看 C# 的帮助文档就不可以?做 C 的就一定要看 python 代码?这份代码真的权威吗、完美吗?

lift is short,you need python。
为什么?
因为 python 可以把你从沉重的技术细节(内存分配、数据结构、算法、网络、数据库等)中解放出来,解放生产力,创造更大的经济效益。
这时候还去看源码,那就是把解放出来的生产力完全浪费了。支持封装吧,有些事情我们不必知道为什么。你看,某党也是这样的政策,比如现在的十七届三中全会,你看发布出来的公告就可以了,非要去看全程会议记录,那就是"天堂有路你不走,地狱无门偏要来"。两千年来的儒家思想也是:穷则独善其身,达则兼济天下。意思就是说自己水平菜的时候努力去看 manuals,等牛逼了就用 python 写个牛逼的程序给大家用用。

2008/10/15 yi gong <[hidden email]>
反对
知其然而不知其所以然在现在的it业绝对是大忌讳。如果有条件,有时间,有动力看源码,我绝对赞成。而且我认为,不但但只看现在工作有关的,有精力的还可以去看看和工作无关的。

作java的看看c#的代码,作c的看看python代码。作框架的看看实现的代码。作应用的看看虚拟机的代码。不无益处!!





2008/10/15 LaiYonghao <[hidden email]>
从学习的角度来看,是个理由。
从商业的角度来看,去看源码跟"重复发明轮子"相当。
不然封装的思想就没啥意义了。
公司招个人,要看以前的源码,然后才能开始工作,成本太高。
还有什么机密之类的,本来就不可能看到源码的。
所以,有时间去推敲源码的,还不如静下心来读一下 manuals,事半功倍。
也许有人说手册不见得什么都有讲;其实大部分成功工具的手册真的是什么都有讲的,如果真有什么非常 hack 的东西没有讲,那肯定是因为这个实现不怎么好,套用一句 python 箴言:好方案易于描述,不易于描述的方案不是好方案;由此可见,手册不讲的东西就是不需要知道的东西,你硬要通过读源码去知道,那就是用劲用错了地方,而且可能学坏了自己(比如在日常项目中应用非常 hack 的手段实现需求),最后被上级或老板痛骂,侥幸躲过了,也绝躲不过后续维护人员对自己祖宗十八代的问候。
综上所述,敬请珍爱生命,远离源码。

2008/10/15 yi gong <[hidden email]>

写代码的不看别人的源码,还真学不到最好的东西。



2008/10/15 LaiYonghao <[hidden email]>

干嘛老有人动不动就看源码?

2008/10/15 hhuai <[hidden email]>
谢谢,我想继续把这个源码给看下去。

或许是按规范写代码养成习惯了,不太习惯看这种代码了。
我们那时有个要求是,公司所有人写出来的代码风格要一模一样,严格按照公司制定的编码标准。
虽然已离开那个公司,但现在都养成了那个习惯了,不让我那样写,我心里还真别扭。真不知是好还是坏。


On 10月15日, 上午11时36分, "yi gong" <[hidden email]> wrote:
> --!
> 这个怎么说呢。说实话,这些真的是难者不会,会者不难的东东,而且源码作者没有义务解释这点东西。整个cpython里的tricky的东东太多了,要是全都解释了,估计要比源码还长。
>
> 就是要省这几个字节啊,兄弟。你要想想你一个hello world,后面要帮你生成多少个PyObject.对于库作者来说,这些都是致命的硬伤。
>
> union的用法看来这位兄弟是入门了。用union还是作一次类型转换就看当初作者的个人喜好了,在我看来就是一路货,把宝押在系统内存的字节排列上了,所以这招在c++有时候就玩不转了。
>
> 想起一句笑话,作java的看不起作html,c++看不起作java的,c看不起作c++的,汇编看不起用c的,公司小妹看不起所有写代码的。
> 是这样说的么?  :)
>
> 推荐一本好书,侯捷的 《STL源码剖析》,不过挺贵,能借就借。看了之后c/c++功底大有长进(吹牛的功底 ^^)。
>
> 2008/10/15 hhuai <[hidden email]>
>
> > 两位这么一讲解,我算是明白了,
> > 不过我觉得作者为啥不写得更清晰点,这样弄,有点浪费读者的时间。
>
> > p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
> > 这里这个p,完全可以再声明一个出来,像这样
> > PyIntBlock pp = (PyIntBlock *)PyMem_MALLOC(sizeof(PyIntBlock));
> > 因为这里p的作用本来是作PyIntObject链表的,没必要拿作他用。
> > 不会连这几个字节都要节省吧。
>
> > q->ob_type = (struct _typeobject *)(q-1);
> > 可以用个union
> > union{
> >  ob_type
> >  mem_link};
> > 再池里用q->mem_link,在外用q->ob_type,意义就明了了,
>
> > On 10月15日, 上午11时05分, "yi gong" <[hidden email]> wrote:
> > > > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> > > > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> > > > 有朋友有同感没有,还是我理解有问题。
>
> > > C中的池的常规做法,看多了就熟了。为了节省内存。在池里,这几个字节当指针用,在池外就是其他有意义的东东。
>
> > 有时候也会用一个union,一个是池里linknode,另一个就是足够长度的char[]。池里的时候当作linknode用,丢出去就char[]给别人初始化。
>
> > > 2008/10/15 hhuai <[hidden email]>
>
> > > > 这是那段Int对象获取内存的函数,相信看过都清楚。
> > > > static PyIntObject *
> > > > fill_free_list(void)
> > > > {
> > > >        PyIntObject *p, *q;
> > > >        /* Python's object allocator isn't appropriate for large blocks.
> > */
> > > >        p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
> > > >        if (p == NULL)
> > > >                return (PyIntObject *) PyErr_NoMemory();
> > > >        ((PyIntBlock *)p)->next = block_list;
> > > >        block_list = (PyIntBlock *)p;
> > > >        /* Link the int objects together, from rear to front, then
> > return
> > > >           the address of the last int object in the block. */
> > > >        p = &((PyIntBlock *)p)->objects[0];
> > > >        q = p + N_INTOBJECTS;
> > > >        while (--q > p)
> > > >                q->ob_type = (struct _typeobject *)(q-1);
> > > >        q->ob_type = NULL;
> > > >        return p + N_INTOBJECTS - 1;
> > > > }
>
> > > > p指针声明为PyIntObject* ,但是malloc时为了使用这个指针而用强制转换使用他,虽然说都是指针,这样运行没问题,但看起来费劲。
> > > > 更绝的是后面,将q指针PyIntObject* 强制为struct _typeobject *,为了这里用ob_type将这个链表连起来,让我
> > > > 匪夷所思所思啊,ob_type定义明明是一个类型对象,这里拿来当链表连接指针用了,我起码在这里看了半个小时才明白他的意图,
> > > > 有朋友有同感没有,还是我理解有问题。
>
>




--
http://blog.csdn.net/lanphaday
-------------------------------------------
用 C++ 的时候盯着 python,用 python 的时候盯着 C++。








--
http://blog.csdn.net/lanphaday
-------------------------------------------
用 C++ 的时候盯着 python,用 python 的时候盯着 C++。








--
http://blog.csdn.net/lanphaday
-------------------------------------------
用 C++ 的时候盯着 python,用 python 的时候盯着 C++。




--~--~---------~--~----~------------~-------~--~----~
来自: `python-cn`:CPyUG ~ 华蟒用户组 | 发言:[hidden email]
退订: http://tinyurl.com/45a9tb /针对163/qq邮箱:http://tinyurl.com/4dg6hc
详情: http://groups.google.com/group/python-cn
严正: 理解列表! 智慧提问! http://wiki.woodpecker.org.cn/moin/AskForHelp
-~----------~----~----~----~------~----~------~--~---

1234