包括性能,可维护性,开发耗时的具体比较
我想知道.如果使用django+python+c扩展来开发一套web系统.能否在性能,可维护性和开发耗时上能否全面压过java.系统大概10w代码行规模
谢谢
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://python.cn/pipermail/python-chinese/attachments/20070309/b689bbb0/attachment-0001.html 

一般认为JAVA在性能上是没有优势的，
而Python号称易用性和性能上的完美结合，
然而事实不近如此：
第一映象容易给人错觉，大多数初学者从command Line 写 Python版本的Hello World ,
而JAVA 从 GUI版的窗口程序映象深刻：就像我们使用IDLE(python GUI)一样的体验，不灵敏。
如果你使用过Jython,也许有所改观：至少我认为 C版Python并不比Java版Python快多少。
而Java vs Python 早有前人测试过：
http://www.twistedmatrix.com/users/glyph/rant/python-vs-java.html
Every inexperienced programme's first question when they start to pick up a
new language: *how fast does it go*? ...
times are measured in real ("wall clock") seconds, since this is a practical
analysis. YMWV. Test Java Python Comparison  Standard Output 138.85
30.58 Python
4.5X Faster than Java  Hashtable  17.0  8.22 Python 2X Faster than Java  I/O
 56.72  47.36 Python 1.2X Faster than Java  List  5.94  14.32 Java
2.4XFaster than Python  Native
Methods  2.475  7.92 Java 3.2X Faster than Python  Interpreter
Initialisation  0.25  0.04 *Python 6.3X Faster than Java*  Object Allocation
 23.65  211.11 *Java 8X Faster than Python*  Interpreter Speed  0.43  2.29 Java
5.3X Faster than Python
...my Java version (JDK 1.1.7B, blackdown), my operating system (Debian GNU
Linux 2.2), my python version (Python 1.5.2)

对比他的例子我重新做了试验：
JDK (java.runtime.name=Java(TM) SE Runtime Environment
java.runtime.version=1.6.0-b105)
Python(Python 2.5)

而重新测试的结果将让大家大吃一惊：～_～

 Test Java Python Comparison  Standard Output 1.921999931335449
4.14100003242 Java 2.1X Faster than Python  Hashtable 2.6410000324249268
4.21799993515
Java 1.5X Faster than Python  I/O 0.5309998989105225 1.85899996758
Java 3.4XFaster than Python  List
0.18700003623962402 0.469000101089 Java 2.5X Faster than Python  Native
Methods


  Interpreter Initialisation

*
*  Object Allocation 0.9060001373291016  74.6880002022
Java 82X Faster than Python  Interpreter Speed 0.016000032424926758
0.953000068665 Java 59X Faster than Python
注：Native Methods Test 没有做（麻烦 ^_^）

下面我附有完整的测试程序，（重做次测试目的不在于无聊的程序性能比较，而在于希望能够真正了解事实与真相）

在CSDN上前段时间有个 Intel的多线程优化比赛，那个 C 程序 ，翻译称原始的Java 程序 ，在我的机器上 C 是JAVA性能（速度）的
2~2.5倍 ，
而JAVA 很容易利用Thread 技术将其运行速度优化至逼近C性能，而C似乎不是那么容易优化－－现在多核技术与虚拟机技术的来临与成熟，
对JAVA这种内置多线程处理技术的程序设计语言简直如虎添翼。

所以可以肯定的讲
Java来开发整套系统和使用django+python+c来开发整套系统的对比，目前应该是JAVA占绝对优势
（也无觉得内存耗用上Python永远占绝对优势～）
JAVA现在如此之快了 ，JIT 与 hotspot之类的技术魅力不小：什么时间才能够看到对Python解释器优化（Psyco就对多循环优化效果不错），
不只是仅仅打C的旗号 …………^_^希望不是个梦

Test-By-Test  ConsoleTest Python  Java

from time import time

start =time()
for x in xrange(100000):
    print x
print time()-start

public class ConsoleTest {
    public static void main(String[] args) {
    	
    	double start = 1.0*System.currentTimeMillis()/1000;
    	
        for (int i = 0; i < 100000; i++) {
            System.out.println(i);
        }

        System.out.println(start-1.0*System.currentTimeMillis()/1000);
    }
}


  Hashtest Python  Java

for i in xrange(1000):
    x={}
    for j in xrange(1000):
        x[j]=i
        x[j]

import java.util.Hashtable;

public class HashTest {
    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            Hashtable x = new Hashtable();
            for (int j = 0; j < 1000; j++) {

                x.put(new Integer(i), new Integer(j));
                x.get(new Integer(i));
            }
        }
    }
}


   IOTest Python  Java

from time import time

start =time()
f =open('scratch','wb')
for i in xrange(1000000):
    f.write(str(i))
f.close()
print time()-start

import java.io.*;

public class IOTest
{
    public static void main(String[] args) {

        double start = 1.0*System.currentTimeMillis()/1000;
        try {
            File f = new File("scratch");
            PrintWriter ps = new PrintWriter(new OutputStreamWriter
                                             (new FileOutputStream(f)));
            for (int i = 0; i < 1000000; i++) {
                ps.print(String.valueOf(i));
            }
            ps.close();
        }
        catch(IOException ioe) {
            ioe.printStackTrace();
        }

        System.out.println(start-1.0*System.currentTimeMillis ()/1000);
    }
}
  ListTest Python  Java

from time import time

start =time()
for i in xrange(1000):
    v=['a','b','c','d','e','f','g']
    for j in xrange(1000):
        v.append(j)
        v[j]
print time()-start

import java.util.Vector;

public class ListTest {
    public static void main(String[] args) {
    	
    	double start = 1.0*System.currentTimeMillis()/1000;
    	
        for (int i = 0; i < 1000; i++) {
            Vector v = new Vector();
            v.addElement("a");
            v.addElement("b");
            v.addElement("c");
            v.addElement("d");
            v.addElement("e");
            v.addElement("f");

            v.addElement("g");
            for (int j = 0; j < 1000; j++) {
                v.addElement(new Integer(j));
                v.elementAt(j);
            }
        }

        System.out.println(start-1.0*System.currentTimeMillis()/1000);
    }

}



  NativeTest Python  Java



 Python C ModuleJava C Module




  NoTest Python  Java



  ObjectTest Python  Java

from time import time

start =time()
class ObjectTest: pass

for i in xrange(10000):
    root=ObjectTest()
    for j in xrange(10000):
        root.next=ObjectTest()
        root=root.next

print time()-start

    public class ObjectTest {
    public ObjectTest next;
    public static void main(String[] args) {
    	
    	double start = 1.0*System.currentTimeMillis()/1000;
    	
        for (int i = 0; i < 10000; i++) {
            ObjectTest root = new ObjectTest();
            for (int j = 0; j < 10000; j++) {

                root.next=new ObjectTest();
                root=root.next;
            }
        }

        System.out.println(start-1.0*System.currentTimeMillis()/1000);

    }
}


  SpeedTest Python  Java

from time import time

start =time()
for x in xrange(10000000):
    pass

print time()-start

public class SpeedTest {
    public static void main(String[] args) {
    	double start = 1.0*System.currentTimeMillis()/1000;
    	
        for (int i = 0; i < 10000000; i++);

        System.out.println(start-1.0*System.currentTimeMillis()/1000);
    }
}








在07-3-9，Kula <kulasama at gmail.com > 写道：
>
> 包括性能,可维护性,开发耗时的具体比较
> 我想知道.如果使用django+python+c扩展来开发一套web系统.能否在性能,
> 可维护性和开发耗时上能否全面压过java.系统大概10w代码行规模
> 谢谢
>
> _______________________________________________
> python-chinese
> Post: send python-chinese at lists.python.cn
> Subscribe: send subscribe to python-chinese-request at lists.python.cn
> Unsubscribe: send unsubscribe to   python-chinese-request at lists.python.cn
> Detail Info: http://python.cn/mailman/listinfo/python-chinese
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://python.cn/pipermail/python-chinese/attachments/20070310/475f78d8/attachment.html 

对于大规模系统，不仅仅从语言的性能、开发效率方面考虑。从技术角度讲，还包
括内存的使用，硬盘的io、平台系统（linux windows...)等等
从开发者角度讲过往的开发经验，对某种架构的可控度，系统需求和具备的现状等等

相对于亿万级的web应用，比如搜索，无论是google的还是baidu的，它们的系统都
是unix(linux) + apache + c语言开发（或其他开放语言）的应用层+自己的数据
存储系统。
这中间的每个环节，对开发者都是可控的，比如可以根据实际情况修改每一部分的
代码进行调优。所以根本不用ms那一套，因为那些东西都不知道内部机制也无法修改。


于业平 写道:
> 一般认为JAVA在性能上是没有优势的，
> 而Python号称易用性和性能上的完美结合，
> 然而事实不近如此：
> 第一映象容易给人错觉，大多数初学者从command Line 写 Python版本的Hello
> World ,
> 而JAVA 从 GUI版的窗口程序映象深刻：就像我们使用IDLE(python GUI)一样的
> 体验，不灵敏。
> 如果你使用过Jython,也许有所改观：至少我认为 C版Python并不比Java版
> Python快多少。
> 而Java vs Python 早有前人测试过：
> http://www.twistedmatrix.com/users/glyph/rant/python-vs-java.html
> <http://www.twistedmatrix.com/users/glyph/rant/python-vs-java.html>
> Every inexperienced programme's first question when they start to pick
> up a new language: /how fast does it go/? ...
> times are measured in real ("wall clock") seconds, since this is a
> practical analysis. YMWV.
> Test 	Java 	Python 	Comparison
> Standard Output 	138.85 	30.58 	Python 4.5X Faster than Java
> Hashtable 	17.0 	8.22 	Python 2X Faster than Java
> I/O 	56.72 	47.36 	Python 1.2X Faster than Java
> List 	5.94 	14.32 	Java 2.4X Faster than Python
> Native Methods 	2.475 	7.92 	Java 3.2X Faster than Python
> Interpreter Initialisation 	0.25 	0.04 	*Python 6.3X Faster than Java*
> Object Allocation 	23.65 	211.11 	*Java 8X Faster than Python*
> Interpreter Speed 	0.43 	2.29 	Java 5.3X Faster than Python
>
>
> ...my Java version (JDK 1.1.7B, blackdown), my operating system
> (Debian GNU Linux 2.2), my python version (Python 1.5.2)
>
> 对比他的例子我重新做了试验：
> JDK (java.runtime.name=Java(TM) SE Runtime Environment
> java.runtime.version=1.6.0-b105)
> Python(Python 2.5)
>
> 而重新测试的结果将让大家大吃一惊：～_～
>
> Test 	Java 	Python 	Comparison
> Standard Output 	1.921999931335449 	4.14100003242 	Java 2.1X Faster
> than Python
> Hashtable 	2.6410000324249268 	4.21799993515
> 	Java 1.5X Faster than Python
> I/O 	0.5309998989105225 	1.85899996758 	Java 3.4X Faster than Python
> List 	0.18700003623962402 	0.469000101089 	Java 2.5X Faster than Python
> Native Methods 	
> 	
> 	
> Interpreter Initialisation 	
> 	
> 	*
> *
> Object Allocation 	0.9060001373291016 	74.6880002022
> 	Java 82X Faster than Python
> Interpreter Speed 	0.016000032424926758 	0.953000068665 	Java 59X
> Faster than Python
>
>
> 注：Native Methods Test 没有做（麻烦 ^_^）
>
> 下面我附有完整的测试程序，（ 重做次测试目的不在于无聊的程序性能比较，
> 而在于希望能够真正了解事实与真相）
>
> 在CSDN上前段时间有个 Intel的多线程优化比赛，那个 C 程序 ，翻译称原始的
> Java 程序 ，在我的机器上 C 是JAVA性能（速度）的 2~2.5倍 ，
> 而JAVA 很容易利用Thread 技术将其运行速度优化至逼近C性能，而C似乎不是那
> 么容易优化－－现在多核技术与虚拟机技术的来临与成熟，
> 对JAVA这种内置多线程处理技术的程序设计语言简直如虎添翼。
>
> 所以可以肯定的讲
> Java来开发整套系统和使用django+python+c来开发整套系统的对比，目前应该
> 是JAVA占绝对优势（也无觉得内存耗用上Python永远占绝对优势～）
> JAVA现在如此之快了 ，JIT 与 hotspot之类的技术魅力不小：什么时间才能够
> 看到对Python解释器优化（Psyco就对多循环优化效果不错），
> 不只是仅仅打C的旗号 …………^_^希望不是个梦
>
>
>     Test-By-Test
>
> ConsoleTest
> Python 	Java
> from time import time
>
> start =time()
> for x in xrange(100000):
>     print x
> print time()-start
>     
> 	
> public class ConsoleTest {
>     public static void main(String[] args) {
>     	
>     	double start = 1.0*System.currentTimeMillis()/1000;
>     	
>         for (int i = 0; i < 100000; i++) {
>             
> System.out.println(i);
>         }
>         
>         System.out.println(start-1.0*System.currentTimeMillis()/1000);
>     }
> }
>
>     
>
> Hashtest
> Python 	Java
> for i in xrange(1000):
>     x={}
>     for j in xrange(1000):
>         x[j]=i
>         x[j]
>     
> 	
> import java.util.Hashtable;
>
> public class HashTest {
>     public static void main(String[] args) {
>         for (int i = 0; i < 1000; i++) {
>             Hashtable x = new Hashtable();
>             for (int j = 0; j < 1000; j++) {
>
>
>                 x.put(new Integer(i), new Integer(j));
>                 x.get(new Integer(i));
>             }
>         }
>     }
> }
>     
>
> IOTest
> Python 	Java
> from time import time
>
> start =time()
> f =open('scratch','wb')
> for i in xrange(1000000):
>     f.write(str(i))
> f.close()        
> print time()-start
>     
> 	import java.io.*;
>
> public class IOTest
> {
> public static void main(String[] args) {
>
> double start = 1.0*System.currentTimeMillis()/1000;
> try {
> File f = new File("scratch");
> PrintWriter ps = new PrintWriter(new OutputStreamWriter
> (new FileOutputStream(f)));
> for (int i = 0; i < 1000000; i++) {
> ps.print(String.valueOf(i));
> }
> ps.close();
> }
> catch(IOException ioe) {
> ioe.printStackTrace();
> }
>
> System.out.println(start-1.0*System.currentTimeMillis ()/1000);
> }
> }
>
> ListTest
> Python 	Java
> from time import time
>
> start =time()
> for i in xrange(1000):
>     v=['a','b','c','d','e','f','g']
>     for j in xrange(1000):
>         
> v.append(j)
>         v[j]
> print time()-start
>     
> 	
> import java.util.Vector;
>
> public class ListTest {
>     public static void main(String[] args) {
>     	
>     	double start = 1.0*System.currentTimeMillis()/1000;
>     	
>         for (int i = 0; i < 1000; i++) {
>
>             Vector v = new Vector();
>             v.addElement("a");
>             v.addElement("b");
>             v.addElement("c");
>             v.addElement("d");
>             
> v.addElement("e");
>             v.addElement("f");
>
>             v.addElement("g");
>             for (int j = 0; j < 1000; j++) {
>                 v.addElement(new Integer(j));
>
>                 v.elementAt(j);
>             }
>         }
>         
>         System.out.println(start-1.0*System.currentTimeMillis()/1000);
>     }
>
> }
>     
>
>     
>
> NativeTest
> Python 	Java
>     
> 	
>         
> Python C Module 	Java C Module
>     
> 	
>
> NoTest
> Python 	Java
>     
> 	
>     
>
> ObjectTest
> Python 	Java
> from time import time
>
> start =time()
> class ObjectTest: pass
>
> for i in xrange(10000):
>     root=ObjectTest()
>     for j in xrange(10000):
>         root.next=ObjectTest()
>         root=
> root.next
>         
> print time()-start
>
>     
> 	
> public class ObjectTest {
>     public ObjectTest next;
>     public static void main(String[] args) {
>     	
>     	double start = 1.0*System.currentTimeMillis()/1000;
>     	
>         for (int i = 0; i < 10000; i++) {
>
>             ObjectTest root = new ObjectTest();
>             for (int j = 0; j < 10000; j++) {
>
>                 root.next=new ObjectTest();
>                 root=root.next;
>             }
>         }
>
>         
>         System.out.println(start-1.0*System.currentTimeMillis()/1000);
>         
>     }
> }
>     
>
> SpeedTest
> Python 	Java
> from time import time
>
> start =time()
> for x in xrange(10000000):
>     pass
>         
> print time()-start
>     
> 	
> public class SpeedTest {
>     public static void main(String[] args) {
>     	double start = 1.0*System.currentTimeMillis()/1000;
>     	
>         for (int i = 0; i < 10000000; i++);
>         
>         
> System.out.println(start-1.0*System.currentTimeMillis()/1000);
>     }
> }
>
>
>     
>
>
>
>
>
>
> 在07-3-9，*Kula* < kulasama在gmail.com kulasama在gmail.com>> 写道：
>
>     包括性能,可维护性,开发耗时的具体比较
>     我想知道.如果使用django+python+c扩展来开发一套web系统.能否在性能,
>     可维护性和开发耗时上能否全面压过 java.系统大概10w代码行规模
>     谢谢
>
>     _______________________________________________
>     python-chinese
>     Post: send python-chinese在lists.python.cn
>     python-chinese在lists.python.cn>
>     Subscribe: send subscribe to
>     python-chinese-request在lists.python.cn
>     python-chinese-request在lists.python.cn>
>     Unsubscribe: send unsubscribe to
>     python-chinese-request在lists.python.cn
>     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

>
> 在CSDN上前段时间有个 Intel的多线程优化比赛，那个 C 程序 ，翻译称原始的Java 程序 ，在我的机器上 C 是JAVA性能（速度）的
> 2~2.5倍 ，
> 而JAVA 很容易利用Thread 技术将其运行速度优化至逼近C性能，而C似乎不是那么容易优化－－

cpu和内存的峰值，这些是动态改变的，是要考虑的。速度在这个意义上比较才有意义。


现在多核技术与虚拟机技术的来临与成熟，
> 对JAVA这种内置多线程处理技术的程序设计语言简直如虎添翼。
>
> 所以可以肯定的讲
> Java来开发整套系统和使用django+python+c来开发整套系统的对比，目前应该是JAVA占绝对优势
> （也无觉得内存耗用上Python永远占绝对优势～）
> JAVA现在如此之快了 ，JIT 与
> hotspot之类的技术魅力不小：什么时间才能够看到对Python解释器优化（Psyco就对多循环优化效果不错），
> 不只是仅仅打C的旗号 …………^_^希望不是个梦
>
> Test-By-Test   ConsoleTest Python Java
>
> from time import time
>
> start =time()
> for x in xrange(100000):
>     print x
> print time()-start
>
> public class ConsoleTest {
>     public static void main(String[] args) {
>     	
>     	double start = 1.0*System.currentTimeMillis()/1000;
>     	
>         for (int i = 0; i < 100000; i++) {
>             System.out.println(i);
>         }
>
>         System.out.println(start-1.0*System.currentTimeMillis()/1000);
>     }
> }
>
>
>   Hashtest Python Java
>
> for i in xrange(1000):
>     x={}
>     for j in xrange(1000):
>         x[j]=i
>         x[j]
>
> import java.util.Hashtable;
>
> public class HashTest {
>     public static void main(String[] args) {
>         for (int i = 0; i < 1000; i++) {
>             Hashtable x = new Hashtable();
>             for (int j = 0; j < 1000; j++) {
>
>                 x.put(new Integer(i), new Integer(j));
>                 x.get(new Integer(i));
>             }
>         }
>     }
> }
>
>
>   IOTest Python Java
>
> from time import time
>
> start =time()
> f =open('scratch','wb')
> for i in xrange(1000000):
>     f.write(str(i))
> f.close()
> print time()-start
>
> import java.io.*;
>
> public class IOTest
> {
>     public static void main(String[] args) {
>
>         double start = 1.0*System.currentTimeMillis()/1000;
>         try {
>             File f = new File("scratch");
>             PrintWriter ps = new PrintWriter(new OutputStreamWriter
>                                              (new FileOutputStream(f)));
>             for (int i = 0; i < 1000000; i++) {
>                 ps.print(String.valueOf(i));
>             }
>             ps.close();
>         }
>         catch(IOException ioe) {
>             ioe.printStackTrace();
>         }
>
>         System.out.println(start-1.0*System.currentTimeMillis ()/1000);
>     }
> }
>   ListTest Python Java
>
> from time import time
>
> start =time()
> for i in xrange(1000):
>     v=['a','b','c','d','e','f','g']
>     for j in xrange(1000):
>         v.append(j)
>         v[j]
> print time()-start
>
> import java.util.Vector;
>
> public class ListTest {
>     public static void main(String[] args) {
>     	
>     	double start = 1.0*System.currentTimeMillis()/1000;
>     	
>         for (int i = 0; i < 1000; i++) {
>             Vector v = new Vector();
>             v.addElement("a");
>             v.addElement("b");
>             v.addElement("c");
>             v.addElement("d");
>             v.addElement("e");
>             v.addElement("f");
>
>             v.addElement("g");
>             for (int j = 0; j < 1000; j++) {
>                 v.addElement(new Integer(j));
>
>                 v.elementAt(j);
>             }
>         }
>
>         System.out.println(start-1.0*System.currentTimeMillis()/1000);
>     }
>
> }
>
>
>
>   NativeTest Python Java
>
>
>
>  Python C Module Java C Module
>
>
>
>
>   NoTest Python Java
>
>
>
>   ObjectTest Python Java
>
> from time import time
>
> start =time()
> class ObjectTest: pass
>
> for i in xrange(10000):
>     root=ObjectTest()
>     for j in xrange(10000):
>         root.next=ObjectTest()
>         root=root.next
>
> print time()-start
>
>     public class ObjectTest {
>     public ObjectTest next;
>     public static void main(String[] args) {
>     	
>     	double start = 1.0*System.currentTimeMillis()/1000;
>     	
>         for (int i = 0; i < 10000; i++) {
>             ObjectTest root = new ObjectTest();
>             for (int j = 0; j < 10000; j++) {
>
>                 root.next=new ObjectTest();
>                 root=root.next;
>             }
>         }
>
>
>         System.out.println(start-1.0*System.currentTimeMillis()/1000);
>
>     }
> }
>
>
>   SpeedTest Python Java
>
> from time import time
>
> start =time()
> for x in xrange(10000000):
>     pass
>
> print time()-start
>
> public class SpeedTest {
>     public static void main(String[] args) {
>     	double start = 1.0*System.currentTimeMillis()/1000;
>     	
>         for (int i = 0; i < 10000000; i++);
>
>         System.out.println(start-1.0*System.currentTimeMillis()/1000);
>     }
> }
>
>
>
>
>
>
>
>
> 在07-3-9，Kula < kulasama在gmail.com > 写道：
> >
> > 包括性能,可维护性,开发耗时的具体比较
> > 我想知道.如果使用django+python+c扩展来开发一套web系统.能否在性能,
> > 可维护性和开发耗时上能否全面压过java.系统大概10w代码行规模
> > 谢谢
> >
> > _______________________________________________
> > 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
>



-- 
※※※※※※※※※※※※※※※※※※※※※※※※
My blog:  http://blog.donews.com/ygao
Forum    http://groups.google.com/group/python_study
※※※※※※※※※※※※※※※※※※※※※※※※
-------------- 下一部分 --------------
一个HTML附件被移除...
URL: http://python.cn/pipermail/python-chinese/attachments/20070310/cfe13e6b/attachment.html 

这种单纯的速度比较，明显python不占优势，python就是以慢著称，号称最慢的脚本语言。
但是慢是慢在纯python的部分，根据80/20原则,与系统性能瓶颈无关的代码应该部分应该占80%，也就是说你可以用python来实现80%，剩下的20%可以用c来实现。
这样做的好处是明显的。现在你实际是用python来搭建系统的架构，你可以享受python带来的快捷和灵活；性能上不谈超过java，但是决不会比纯java实现来得慢，这里比较的是系统整体的性能而不是程序细节的比较。
我坚信，python+c是构建大系统的最好选择之一。

在07-3-10，ygao <ygao2004 at gmail.com> 写道：
>
>
>
> > 在CSDN上前段时间有个 Intel的多线程优化比赛，那个 C 程序 ，翻译称原始的Java 程序 ，在我的机器上 C 是JAVA性能（速度）的
> > 2~2.5倍 ，
> > 而JAVA 很容易利用Thread 技术将其运行速度优化至逼近C性能，而C似乎不是那么容易优化－－
>
> cpu和内存的峰值，这些是动态改变的，是要考虑的。速度在这个意义上比较才有意义。
>
>
> 现在多核技术与虚拟机技术的来临与成熟，
> > 对JAVA这种内置多线程处理技术的程序设计语言简直如虎添翼。
> >
> > 所以可以肯定的讲
> > Java来开发整套系统和使用django+python+c来开发整套系统的对比，目前应该是JAVA占绝对优势
> > （也无觉得内存耗用上Python永远占绝对优势～）
> > JAVA现在如此之快了 ，JIT 与
> > hotspot之类的技术魅力不小：什么时间才能够看到对Python解释器优化（Psyco就对多循环优化效果不错），
> > 不只是仅仅打C的旗号 …………^_^希望不是个梦
> >
> > Test-By-Test   ConsoleTest Python Java
> >
> > from time import time
> >
> > start =time()
> > for x in xrange(100000):
> >     print x
> > print time()-start
> >
> > public class ConsoleTest {
> >     public static void main(String[] args) {
> >     	
> >     	double start = 1.0*System.currentTimeMillis()/1000;
> >     	
> >         for (int i = 0; i < 100000; i++) {
> >
> > System.out.println(i);
> >         }
> >
> >         System.out.println(start-1.0*System.currentTimeMillis()/1000);
> >     }
> > }
> >
> >
> >   Hashtest Python Java
> >
> > for i in xrange(1000):
> >     x={}
> >     for j in xrange(1000):
> >         x[j]=i
> >         x[j]
> >
> > import java.util.Hashtable;
> >
> > public class HashTest {
> >     public static void main(String[] args) {
> >         for (int i = 0; i < 1000; i++) {
> >             Hashtable x = new Hashtable();
> >             for (int j = 0; j < 1000; j++) {
> >
> >
> >                 x.put(new Integer(i), new Integer(j));
> >                 x.get(new Integer(i));
> >             }
> >         }
> >     }
> > }
> >
> >
> >   IOTest Python Java
> >
> > from time import time
> >
> > start =time()
> > f =open('scratch','wb')
> > for i in xrange(1000000):
> >     f.write(str(i))
> > f.close()
> > print time()-start
> >
> > import java.io.*;
> >
> > public class IOTest
> > {
> >     public static void main(String[] args) {
> >
> >         double start = 1.0*System.currentTimeMillis()/1000;
> >         try {
> >             File f = new File("scratch");
> >             PrintWriter ps = new PrintWriter(new OutputStreamWriter
> >                                              (new FileOutputStream(f)));
> >             for (int i = 0; i < 1000000; i++) {
> >                 ps.print(String.valueOf(i));
> >             }
> >             ps.close();
> >         }
> >         catch(IOException ioe) {
> >             ioe.printStackTrace();
> >         }
> >
> >         System.out.println(start-1.0*System.currentTimeMillis ()/1000);
> >     }
> > }
> >   ListTest Python Java
> >
> > from time import time
> >
> > start =time()
> > for i in xrange(1000):
> >     v=['a','b','c','d','e','f','g']
> >     for j in xrange(1000):
> >
> > v.append(j)
> >         v[j]
> > print time()-start
> >
> > import java.util.Vector;
> >
> > public class ListTest {
> >     public static void main(String[] args) {
> >     	
> >     	double start = 1.0*System.currentTimeMillis()/1000;
> >     	
> >         for (int i = 0; i < 1000; i++) {
> >
> >             Vector v = new Vector();
> >             v.addElement("a");
> >             v.addElement("b");
> >             v.addElement("c");
> >             v.addElement("d");
> >
> >             v.addElement("e");
> >             v.addElement("f");
> >
> >             v.addElement("g");
> >             for (int j = 0; j < 1000; j++) {
> >                 v.addElement(new Integer(j));
> >
> >
> >                 v.elementAt(j);
> >             }
> >         }
> >
> >         System.out.println(start-1.0*System.currentTimeMillis()/1000);
> >     }
> >
> > }
> >
> >
> >
> >   NativeTest Python Java
> >
> >
> >
> >  Python C Module Java C Module
> >
> >
> >
> >
> >   NoTest Python Java
> >
> >
> >
> >   ObjectTest Python Java
> >
> > from time import time
> >
> > start =time()
> > class ObjectTest: pass
> >
> > for i in xrange(10000):
> >     root=ObjectTest()
> >     for j in xrange(10000):
> >         root.next=ObjectTest()
> >         root=
> > root.next
> >
> > print time()-start
> >
> >     public class ObjectTest {
> >     public ObjectTest next;
> >     public static void main(String[] args) {
> >     	
> >     	double start = 1.0*System.currentTimeMillis()/1000;
> >     	
> >         for (int i = 0; i < 10000; i++) {
> >
> >             ObjectTest root = new ObjectTest();
> >             for (int j = 0; j < 10000; j++) {
> >
> >                 root.next=new ObjectTest();
> >                 root=root.next;
> >             }
> >         }
> >
> >
> >
> >         System.out.println(start-1.0*System.currentTimeMillis()/1000);
> >
> >     }
> > }
> >
> >
> >   SpeedTest Python Java
> >
> > from time import time
> >
> > start =time()
> > for x in xrange(10000000):
> >     pass
> >
> > print time()-start
> >
> > public class SpeedTest {
> >     public static void main(String[] args) {
> >     	double start = 1.0*System.currentTimeMillis()/1000;
> >     	
> >         for (int i = 0; i < 10000000; i++);
> >
> >
> > System.out.println(start-1.0*System.currentTimeMillis()/1000);
> >     }
> > }
> >
> >
> >
> >
> >
> >
> >
> >
> > 在07-3-9，Kula < kulasama at gmail.com > 写道：
> > >
> > > 包括性能,可维护性,开发耗时的具体比较
> > > 我想知道.如果使用django+python+c扩展来开发一套web系统.能否在性能,
> > > 可维护性和开发耗时上能否全面压过java.系统大概10w代码行规模
> > > 谢谢
> > >
> > > _______________________________________________
> > > python-chinese
> > > Post: send python-chinese at lists.python.cn
> > > Subscribe: send subscribe to python-chinese-request at lists.python.cn
> > > Unsubscribe: send unsubscribe to
> > > python-chinese-request at lists.python.cn
> > > Detail Info: http://python.cn/mailman/listinfo/python-chinese
> > >
> >
> >
> > _______________________________________________
> > python-chinese
> > Post: send python-chinese at lists.python.cn
> > Subscribe: send subscribe to python-chinese-request at lists.python.cn
> > Unsubscribe: send unsubscribe to  python-chinese-request at 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
> ※※※※※※※※※※※※※※※※※※※※※※※※
> _______________________________________________
> python-chinese
> Post: send python-chinese at lists.python.cn
> Subscribe: send subscribe to python-chinese-request at lists.python.cn
> Unsubscribe: send unsubscribe to  python-chinese-request at lists.python.cn
> Detail Info: http://python.cn/mailman/listinfo/python-chinese
>



-- 
devdoer
devdoer at gmail.com
http://devdoer.blog.sohu.com/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://python.cn/pipermail/python-chinese/attachments/20070310/72b0595b/attachment-0001.htm 

不太清楚你的测试环境，我在我的笔记本下用ubuntu 6.10 下测的第一个测试的结
果：
Python 2.4.4	1.0749630928
JDK1.5.08	-1.5320000648498535 (负数应该是你程序写错了一个地方)
python快一点，所以我建议你在和原作者在一样的环境下测试再来看看。

我的笔记本是Intel Core 2 Due 双核T5500, 1G内存，应该运行java是很快的了
吧。

在 2007-03-10六的 12:19 +0800，于业平写道：
> 对比他的例子我重新做了试验：
> JDK (java.runtime.name=Java(TM) SE Runtime Environment
> java.runtime.version=1.6.0-b105)
> Python(Python 2.5)
> 
> 而重新测试的结果将让大家大吃一惊：～_～
> 
>       Test 
>       Java 
>      Python 
>    Comparison 
> Standard Output 
> 1.921999931335449
> 4.14100003242
> Java 2.1X Faster
> than Python
> Hashtable 
> 2.6410000324249268 
> 4.21799993515 
> 
> Java 1.5X Faster
> than Python
> I/O 
> 0.5309998989105225 
> 1.85899996758 
> Java 3.4X Faster
> than Python
> List 
> 0.18700003623962402 
> 0.469000101089 
> Java 2.5X Faster
> than Python
> Native Methods 
> 
> 
> 
> 
> 
> 
> Interpreter
> Initialisation 
> 
> 
> 
> 
> 
> 
> Object
> Allocation 
> 0.9060001373291016 
> 74.6880002022 
> 
> Java 82X Faster
> than Python
> Interpreter
> Speed 
> 0.016000032424926758 
> 0.953000068665 
> Java 59X Faster
> than Python
> 
> 注：Native Methods Test 没有做（麻烦 ^_^）
> 
> 下面我附有完整的测试程序，（重做次测试目的不在于无聊的程序性能比较，而
> 在于希望能够真正了解事实与真相）
> 
> 在CSDN上前段时间有个 Intel的多线程优化比赛，那个 C 程序 ，翻译称原始的
> Java 程序 ，在我的机器上 C 是JAVA性能（速度）的 2~2.5倍 ，
> 而JAVA 很容易利用Thread 技术将其运行速度优化至逼近C性能，而C似乎不是那
> 么容易优化－－现在多核技术与虚拟机技术的来临与成熟，
> 对JAVA这种内置多线程处理技术的程序设计语言简直如虎添翼。 
> 
> 所以可以肯定的讲
> Java来开发整套系统和使用django+python+c来开发整套系统的对比，目前应该
> 是JAVA占绝对优势 （也无觉得内存耗用上Python永远占绝对优势～）
> JAVA现在如此之快了 ，JIT 与 hotspot之类的技术魅力不小：什么时间才能够
> 看到对Python解释器优化（Psyco就对多循环优化效果不错），
> 不只是仅仅打C的旗号 …………^_^希望不是个梦 
> 
> 
> Test-By-Test 
>                                    ConsoleTest
>                                       Python 
>                                         Java 
>                         from time import time
>                                    
>                             start =time()
>                        for x in xrange(100000):
>                                  print x
>                           print time()-start
>                                      
>                       public class ConsoleTest {
>                  public static void main(String[] args) {
>                                     	
>            	double start = 1.0*System.currentTimeMillis()/1000;
>                                     	
>                       for (int i = 0; i < 100000; i++) {
>                                          
>                         System.out.println(i);
>                                       }
>                                        
>         System.out.println(start-1.0*System.currentTimeMillis()/1000);
>                                     }
>                                   }
>                                    
>                                      
>                                    
>                                    
>                                      Hashtest
>                                       Python 
>                                         Java 
>                         for i in xrange(1000):
>                                    x={}
>                           for j in xrange(1000):
>                                     x[j]=i
>                                      x[j]
>                                      
>                      import java.util.Hashtable;
>                                    
>                        public class HashTest {
>                  public static void main(String[] args) {
>                        for (int i = 0; i < 1000; i++) {
>                           Hashtable x = new Hashtable();
>                          for (int j = 0; j < 1000; j++) {
>                                    
>                                    
>                         x.put(new Integer(i), new Integer(j));
>                                 x.get(new Integer(i));
>                                         }
>                                       }
>                                     }
>                                   }
>                                      
>                                    
>                                    
>                                        IOTest
>                                       Python 
>                                         Java 
>                         from time import time
>                                    
>                             start =time()
>                        f =open('scratch','wb')
>                       for i in xrange(1000000):
>                              f.write(str(i))
>                           f.close()        
>                           print time()-start
>                                      
>                           import java.io.*;
>                                    
>                          public class IOTest
>                                   {
>                             public static void
>                         main(String[] args) {
>                                        
>                                 double start =
>                  1.0*System.currentTimeMillis()/1000;
>                                     try {
>                                    File f = new
>                           File("scratch"); 
>                                PrintWriter ps = new
>                   PrintWriter(new OutputStreamWriter
>                                    
>                      (new FileOutputStream(f)));
>                                for (int i = 0; i <
>                            1000000; i++) {
>                                    
>                      ps.print(String.valueOf(i));
>                                         }
>                                    ps.close();
>                                       }
>                            catch(IOException ioe) {
>                               ioe.printStackTrace();
>                                       }
>                                        
>                                    
>    System.out.println(start-1.0*System.currentTimeMillis ()/1000);
>                                     }
>                                   }
>                                    
>                                    
>                                      ListTest
>                                       Python 
>                                         Java 
>                         from time import time
>                                    
>                             start =time()
>                         for i in xrange(1000):
>                      v=['a','b','c','d','e','f','g']
>                           for j in xrange(1000):
>                                        
>                              v.append(j)
>                                      v[j]
>                           print time()-start
>                                      
>                        import java.util.Vector;
>                                    
>                        public class ListTest {
>                  public static void main(String[] args) {
>                                     	
>            	double start = 1.0*System.currentTimeMillis()/1000;
>                                     	
>                        for (int i = 0; i < 1000; i++) {
>                                    
>                              Vector v = new Vector();
>                                 v.addElement("a");
>                                 v.addElement("b");
>                                 v.addElement("c");
>                                 v.addElement("d");
>                                          
>                           v.addElement("e");
>                                 v.addElement("f");
>                                    
>                                 v.addElement("g");
>                          for (int j = 0; j < 1000; j++) {
>                             v.addElement(new Integer(j));
>                                    
>                                    v.elementAt(j);
>                                         }
>                                       }
>                                        
>         System.out.println(start-1.0*System.currentTimeMillis()/1000);
>                                     }
>                                    
>                                   }
>                                      
>                                    
>                                      
>                                    
>                                    
>                                     NativeTest
>                                       Python 
>                                         Java 
>                                    
>                                      
>                                    
>                                    
>                                 Python C Module
>                                   Java C Module
>                                    
>                                      
>                                    
>                                    
>                                    
>                                    
>                                        NoTest
>                                       Python 
>                                         Java 
>                                      
>                                    
>                                      
>                                    
>                                    
>                                     ObjectTest
>                                       Python 
>                                         Java 
>                         from time import time
>                                    
>                             start =time()
>                         class ObjectTest: pass
>                                    
>                        for i in xrange(10000):
>                             root=ObjectTest()
>                          for j in xrange(10000):
>                             root.next=ObjectTest()
>                                     root=
>                               root.next
>                                        
>                           print time()-start
>                                    
>                                      
>                       public class ObjectTest {
>                          public ObjectTest next;
>                  public static void main(String[] args) {
>                                     	
>            	double start = 1.0*System.currentTimeMillis()/1000;
>                                     	
>                       for (int i = 0; i < 10000; i++) {
>                                    
>                        ObjectTest root = new ObjectTest();
>                         for (int j = 0; j < 10000; j++) {
>                                    
>                              root.next=new ObjectTest();
>                                    root=root.next;
>                                         }
>                                       }
>                                    
>                                        
>         System.out.println(start-1.0*System.currentTimeMillis()/1000);
>                                        
>                                     }
>                                   }
>                                      
>                                    
>                                    
>                                      SpeedTest
>                                       Python 
>                                         Java 
>                         from time import time
>                                    
>                             start =time()
>                       for x in xrange(10000000):
>                                    pass
>                                        
>                           print time()-start
>                                      
>                        public class SpeedTest {
>                  public static void main(String[] args) {
>            	double start = 1.0*System.currentTimeMillis()/1000;
>                                     	
>                      for (int i = 0; i < 10000000; i++);
>                                        
>                                        
>     System.out.println(start-1.0*System.currentTimeMillis()/1000);
>                                     }
>                                   }
>                                    
>                                    
>                                      
>                                    
>                                    
> 
> 
> 
> 
> 
> 在07-3-9，Kula <kulasama at gmail.com> 写道：
>         包括性能,可维护性,开发耗时的具体比较
>         我想知道.如果使用django+python+c扩展来开发一套web系统.能否在性
>         能,可维护性和开发耗时上能否全面压过java.系统大概10w代码行规模
>         谢谢
>         
>         _______________________________________________
>         python-chinese
>         Post: send python-chinese at lists.python.cn 
>         Subscribe: send subscribe to
>         python-chinese-request at lists.python.cn
>         Unsubscribe: send unsubscribe to
>         python-chinese-request at lists.python.cn
>         Detail Info: http://python.cn/mailman/listinfo/python-chinese
> 
> _______________________________________________
> python-chinese
> Post: send python-chinese at lists.python.cn
> Subscribe: send subscribe to python-chinese-request at lists.python.cn
> Unsubscribe: send unsubscribe to  python-chinese-request at lists.python.cn
> Detail Info: http://python.cn/mailman/listinfo/python-chinese

^_^
Python 是一门设计漂亮的语言，(me虽然工作中不用，但是很多简易的Tool还是用Python 编写)
做此前后对比只是个人觉得Python应该需要在运行速度上有所努力，


关于cpu和内存的峰值：java只是由于本身的运行机制加之一代代的优化导致启动瞬间高峰，其它时间我想应该不是个问题。

Thread ：已经是多核时代了，怎样利用Thread模型榨取CPU性能应该是今后编程技术中的一个重点，java
较之python确实要容易些（也许仅适用于客户端程序）


20％de的C优化：大项目似乎都是这样做吧，pure xxx  是废话。

Python / java都一样，有着完美的分工与协作 ，Python虚拟机有理由让Python跑得更快－－难道要跟一个C programmer
讲不能自由访问其它源文件是为了面向对象的私有封装设计。






在07-3-10，bird devdoer <devdoer at gmail.com> 写道：
>
>
> 这种单纯的速度比较，明显python不占优势，python就是以慢著称，号称最慢的脚本语言。
>
> 但是慢是慢在纯python的部分，根据80/20原则,与系统性能瓶颈无关的代码应该部分应该占80%，也就是说你可以用python来实现80%，剩下的20%可以用c来实现。
> 这样做的好处是明显的。现在你实际是用python来搭建系统的架构，你可以享受python带来的快捷和灵活；性能上不谈超过java，但是决不会比纯java实现来得慢，这里比较的是系统整体的性能而不是程序细节的比较。
>
> 我坚信，python+c是构建大系统的最好选择之一。
>
> 在07-3-10，ygao <ygao2004 at gmail.com> 写道：
> >
> >
> >
> > > 在CSDN上前段时间有个 Intel的多线程优化比赛，那个 C 程序 ，翻译称原始的Java 程序 ，在我的机器上 C
> > > 是JAVA性能（速度）的 2~2.5倍 ，
> > > 而JAVA 很容易利用Thread 技术将其运行速度优化至逼近C性能，而C似乎不是那么容易优化－－
> >
> > cpu和内存的峰值，这些是动态改变的，是要考虑的。速度在这个意义上比较才有意义。
> >
> >
> > 现在多核技术与虚拟机技术的来临与成熟，
> > > 对JAVA这种内置多线程处理技术的程序设计语言简直如虎添翼。
> > >
> > > 所以可以肯定的讲
> > > Java来开发整套系统和使用django+python+c来开发整套系统的对比，目前应该是JAVA占绝对优势
> > > （也无觉得内存耗用上Python永远占绝对优势～）
> > > JAVA现在如此之快了 ，JIT 与
> > > hotspot之类的技术魅力不小：什么时间才能够看到对Python解释器优化（Psyco就对多循环优化效果不错），
> > > 不只是仅仅打C的旗号 …………^_^希望不是个梦
> > >
> > > Test-By-Test   ConsoleTest Python Java
> > >
> > > from time import time
> > >
> > > start =time()
> > > for x in xrange(100000):
> > >     print x
> > > print time()-start
> > >
> > > public class ConsoleTest {
> > >     public static void main(String[] args) {
> > >     	
> > >     	double start = 1.0*System.currentTimeMillis()/1000;
> > >     	
> > >         for (int i = 0; i < 100000; i++) {
> > >
> > >
> > > System.out.println(i);
> > >         }
> > >
> > >         System.out.println(start-1.0*System.currentTimeMillis()/1000);
> > >     }
> > > }
> > >
> > >
> > >   Hashtest Python Java
> > >
> > > for i in xrange(1000):
> > >     x={}
> > >     for j in xrange(1000):
> > >         x[j]=i
> > >         x[j]
> > >
> > > import java.util.Hashtable;
> > >
> > > public class HashTest {
> > >     public static void main(String[] args) {
> > >         for (int i = 0; i < 1000; i++) {
> > >             Hashtable x = new Hashtable();
> > >             for (int j = 0; j < 1000; j++) {
> > >
> > >
> > >
> > >                 x.put(new Integer(i), new Integer(j));
> > >                 x.get(new Integer(i));
> > >             }
> > >         }
> > >     }
> > > }
> > >
> > >
> > >   IOTest Python Java
> > >
> > > from time import time
> > >
> > > start =time()
> > > f =open('scratch','wb')
> > > for i in xrange(1000000):
> > >     f.write(str(i))
> > > f.close()
> > > print time()-start
> > >
> > > import java.io.*;
> > >
> > > public class IOTest
> > > {
> > >     public static void main(String[] args) {
> > >
> > >         double start = 1.0*System.currentTimeMillis()/1000;
> > >         try {
> > >             File f = new File("scratch");
> > >             PrintWriter ps = new PrintWriter(new OutputStreamWriter
> > >                                              (new
> > > FileOutputStream(f)));
> > >             for (int i = 0; i < 1000000; i++) {
> > >                 ps.print(String.valueOf(i));
> > >             }
> > >             ps.close();
> > >         }
> > >         catch(IOException ioe) {
> > >             ioe.printStackTrace();
> > >         }
> > >
> > >         System.out.println(start-1.0*System.currentTimeMillis()/1000);
> > >     }
> > > }
> > >   ListTest Python Java
> > >
> > > from time import time
> > >
> > > start =time()
> > > for i in xrange(1000):
> > >     v=['a','b','c','d','e','f','g']
> > >     for j in xrange(1000):
> > >
> > > v.append
> > > (j)
> > >         v[j]
> > > print time()-start
> > >
> > > import java.util.Vector;
> > >
> > > public class ListTest {
> > >     public static void main(String[] args) {
> > >     	
> > >     	double start = 1.0*System.currentTimeMillis()/1000;
> > >     	
> > >         for (int i = 0; i < 1000; i++) {
> > >
> > >
> > >             Vector v = new Vector();
> > >             v.addElement("a");
> > >             v.addElement("b");
> > >             v.addElement("c");
> > >             v.addElement("d");
> > >
> > >
> > >             v.addElement("e");
> > >             v.addElement("f");
> > >
> > >             v.addElement("g");
> > >             for (int j = 0; j < 1000; j++) {
> > >                 v.addElement(new Integer(j));
> > >
> > >
> > >
> > >                 v.elementAt(j);
> > >             }
> > >         }
> > >
> > >         System.out.println(start-1.0*System.currentTimeMillis()/1000);
> > >     }
> > >
> > > }
> > >
> > >
> > >
> > >   NativeTest Python Java
> > >
> > >
> > >
> > >  Python C Module Java C Module
> > >
> > >
> > >
> > >
> > >   NoTest Python Java
> > >
> > >
> > >
> > >   ObjectTest Python Java
> > >
> > > from time import time
> > >
> > > start =time()
> > > class ObjectTest: pass
> > >
> > > for i in xrange(10000):
> > >     root=ObjectTest()
> > >     for j in xrange(10000):
> > >         root.next=ObjectTest()
> > >         root=
> > > root.next
> > >
> > >
> > > print time()-start
> > >
> > >     public class ObjectTest {
> > >     public ObjectTest next;
> > >     public static void main(String[] args) {
> > >     	
> > >     	double start = 1.0*System.currentTimeMillis()/1000;
> > >     	
> > >         for (int i = 0; i < 10000; i++) {
> > >
> > >
> > >             ObjectTest root = new ObjectTest();
> > >             for (int j = 0; j < 10000; j++) {
> > >
> > >                 root.next=new ObjectTest();
> > >                 root=root.next;
> > >             }
> > >         }
> > >
> > >
> > >
> > >
> > >         System.out.println(start-1.0*System.currentTimeMillis()/1000);
> > >
> > >     }
> > > }
> > >
> > >
> > >   SpeedTest Python Java
> > >
> > > from time import time
> > >
> > > start =time()
> > > for x in xrange(10000000):
> > >     pass
> > >
> > > print time()-start
> > >
> > > public class SpeedTest {
> > >     public static void main(String[] args) {
> > >     	double start = 1.0*System.currentTimeMillis()/1000;
> > >     	
> > >         for (int i = 0; i < 10000000; i++);
> > >
> > >
> > >
> > > System.out.println(start-1.0*System.currentTimeMillis()/1000);
> > >     }
> > > }
> > >
> > >
> > >
> > >
> > >
> > >
> > >
> > >
> > > 在07-3-9，Kula < kulasama at gmail.com > 写道：
> > > >
> > > > 包括性能,可维护性,开发耗时的具体比较
> > > > 我想知道.如果使用django+python+c扩展来开发一套web系统.能否在性能,
> > > > 可维护性和开发耗时上能否全面压过java.系统大概10w代码行规模
> > > > 谢谢
> > > >
> > > > _______________________________________________
> > > > python-chinese
> > > > Post: send python-chinese at lists.python.cn
> > > > Subscribe: send subscribe to python-chinese-request at lists.python.cn
> > > > Unsubscribe: send unsubscribe to
> > > > python-chinese-request at lists.python.cn
> > > > Detail Info: http://python.cn/mailman/listinfo/python-chinese
> > > >
> > >
> > >
> > > _______________________________________________
> > > python-chinese
> > > Post: send python-chinese at lists.python.cn
> > > Subscribe: send subscribe to python-chinese-request at lists.python.cn
> > > Unsubscribe: send unsubscribe to  python-chinese-request at 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
> > ※※※※※※※※※※※※※※※※※※※※※※※※
> > _______________________________________________
> > python-chinese
> > Post: send python-chinese at lists.python.cn
> > Subscribe: send subscribe to python-chinese-request at lists.python.cn
> > Unsubscribe: send unsubscribe to
> > python-chinese-request at lists.python.cn
> > Detail Info: http://python.cn/mailman/listinfo/python-chinese
> >
>
>
>
> --
> devdoer
> devdoer at gmail.com
> http://devdoer.blog.sohu.com/
> _______________________________________________
> python-chinese
> Post: send python-chinese at lists.python.cn
> Subscribe: send subscribe to python-chinese-request at lists.python.cn
> Unsubscribe: send unsubscribe to  python-chinese-request at lists.python.cn
> Detail Info: http://python.cn/mailman/listinfo/python-chinese
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://python.cn/pipermail/python-chinese/attachments/20070310/370b75fa/attachment-0001.html 

ËäÈ»´Ó±àÒëÆ÷µÄ½Ç¶È½²£¬javaµÄËٶȿ϶¨±È½âÊÍÐ͵ÄPythonÒª¿ì£¬µ«ÊÇ£¬×¢Ò⣬´úÂëʵÏÖÊÇÒ»¸öºÜÖØÒªµÄÒòËØ£¡ÊµÏÖºÜÀõÄCÒ²ÊÇÂýµÄÒªËÀ£¡

»¹ÓÐpythonµÄÌصãÊÇÔÚÓÃÔËÐÐËٶȻ»È¡¿ª·¢Ð§ÂʵÄÌá¸ß£¬´Ó¶ø½µµÍ¿ª·¢³É±¾¡£¿ª·¢Ð§ÂʵÄÓÅÊƺÜÃ÷ÏÔ¡£

On 3/10/07, ÓÚҵƽ <yyp226在gmail.com> wrote:
>
> ^_^
> Python ÊÇÒ»ÃÅÉè¼ÆƯÁÁµÄÓïÑÔ£¬(meËäÈ»¹¤×÷Öв»Ó㬵«ÊǺܶà¼òÒ×µÄTool»¹ÊÇÓÃPython ±àд)
> ×ö´ËÇ°ºó¶Ô±ÈÖ»ÊǸöÈ˾õµÃPythonÓ¦¸ÃÐèÒªÔÚÔËÐÐËÙ¶ÈÉÏÓÐËùŬÁ¦£¬
>
>
> ¹ØÓÚcpuºÍÄÚ´æµÄ·åÖµ£ºjavaÖ»ÊÇÓÉÓÚ±¾ÉíµÄÔËÐлúÖƼÓÖ®Ò»´ú´úµÄÓÅ»¯µ¼ÖÂÆô¶¯Ë²¼ä¸ß·å£¬ÆäËüʱ¼äÎÒÏëÓ¦¸Ã²»ÊǸöÎÊÌâ¡£
>
> Thread £ºÒѾ­ÊǶàºËʱ´úÁË£¬ÔõÑùÀûÓÃThreadÄ£ÐÍեȡCPUÐÔÄÜÓ¦¸ÃÊǽñºó±à³Ì¼¼ÊõÖеÄÒ»¸öÖص㣬java
> ½ÏÖ®pythonȷʵҪÈÝÒ×Щ£¨Ò²Ðí½öÊÊÓÃÓÚ¿Í»§¶Ë³ÌÐò£©
>
>
> 20£¥deµÄCÓÅ»¯£º´óÏîÄ¿Ëƺõ¶¼ÊÇÕâÑù×ö°É£¬pure xxx  ÊÇ·Ï»°¡£
>
> Python / java¶¼Ò»Ñù£¬ÓÐ×ÅÍêÃÀµÄ·Ö¹¤ÓëЭ×÷ £¬PythonÐéÄâ»úÓÐÀíÓÉÈÃPythonÅܵøü¿ì£­£­ÄѵÀÒª¸úÒ»¸öC programmer
> ½²²»ÄÜ×ÔÓÉ·ÃÎÊÆäËüÔ´ÎļþÊÇΪÁËÃæÏò¶ÔÏóµÄ˽Óзâ×°Éè¼Æ¡£
>
>
>
>
>
>
> ÔÚ07-3-10£¬ bird devdoer <devdoer在gmail.com> дµÀ£º
> >
> >
> > ÕâÖÖµ¥´¿µÄËٶȱȽϣ¬Ã÷ÏÔpython²»Õ¼ÓÅÊÆ£¬python¾ÍÊÇÒÔÂýÖø³Æ£¬ºÅ³Æ×îÂýµÄ½Å±¾ÓïÑÔ¡£
> >
> > µ«ÊÇÂýÊÇÂýÔÚ´¿pythonµÄ²¿·Ö£¬¸ù¾Ý80/20Ô­Ôò,ÓëϵͳÐÔÄÜÆ¿¾±Î޹صĴúÂëÓ¦¸Ã²¿·ÖÓ¦¸ÃÕ¼80%£¬Ò²¾ÍÊÇ˵Äã¿ÉÒÔÓÃpythonÀ´ÊµÏÖ80%£¬Ê£ÏµÄ20%¿ÉÒÔÓÃcÀ´ÊµÏÖ¡£
> > ÕâÑù×öµÄºÃ´¦ÊÇÃ÷ÏԵġ£ÏÖÔÚÄãʵ¼ÊÊÇÓÃpythonÀ´´î½¨ÏµÍ³µÄ¼Ü¹¹£¬Äã¿ÉÒÔÏíÊÜpython´øÀ´µÄ¿ì½ÝºÍÁé»î£»ÐÔÄÜÉϲ»Ì¸³¬¹ýjava£¬µ«ÊǾö²»»á±È´¿javaʵÏÖÀ´µÃÂý£¬ÕâÀï±È½ÏµÄÊÇϵͳÕûÌåµÄÐÔÄܶø²»ÊdzÌÐòϸ½ÚµÄ±È½Ï¡£
> >
> > ÎÒ¼áÐÅ£¬python+cÊǹ¹½¨´óϵͳµÄ×îºÃÑ¡ÔñÖ®Ò»¡£
> >
> > ÔÚ07-3-10£¬ygao < ygao2004在gmail.com> дµÀ£º
> > >
> > >
> > >
> > > > ÔÚCSDNÉÏÇ°¶Îʱ¼äÓиö IntelµÄ¶àÏß³ÌÓÅ»¯±ÈÈü£¬ÄǸö C ³ÌÐò £¬·­Òë³ÆԭʼµÄJava ³ÌÐò £¬ÔÚÎҵĻúÆ÷ÉÏ C
> > > > ÊÇJAVAÐÔÄÜ£¨Ëٶȣ©µÄ 2~2.5±¶ £¬
> > > > ¶øJAVA ºÜÈÝÒ×ÀûÓÃThread ¼¼Êõ½«ÆäÔËÐÐËÙ¶ÈÓÅ»¯ÖÁ±Æ½üCÐÔÄÜ£¬¶øCËƺõ²»ÊÇÄÇôÈÝÒ×ÓÅ»¯£­£­
> > >
> > > cpuºÍÄÚ´æµÄ·åÖµ£¬ÕâЩÊǶ¯Ì¬¸Ä±äµÄ£¬ÊÇÒª¿¼Âǵġ£ËÙ¶ÈÔÚÕâ¸öÒâÒåÉϱȽϲÅÓÐÒâÒå¡£
> > >
> > >
> > > ÏÖÔÚ¶àºË¼¼ÊõÓëÐéÄâ»ú¼¼ÊõµÄÀ´ÁÙÓë³ÉÊ죬
> > > > ¶ÔJAVAÕâÖÖÄÚÖöàÏ̴߳¦Àí¼¼ÊõµÄ³ÌÐòÉè¼ÆÓïÑÔ¼òÖ±È绢ÌíÒí¡£
> > > >
> > > > ËùÒÔ¿ÉÒԿ϶¨µÄ½²
> > > > JavaÀ´¿ª·¢ÕûÌ×ϵͳºÍʹÓÃdjango+python+cÀ´¿ª·¢ÕûÌ×ϵͳµÄ¶Ô±È£¬Ä¿Ç°Ó¦¸ÃÊÇJAVAÕ¼¾ø¶ÔÓÅÊÆ
> > > > £¨Ò²ÎÞ¾õµÃÄÚ´æºÄÓÃÉÏPythonÓÀÔ¶Õ¼¾ø¶ÔÓÅÊÆ¡«£©
> > > > JAVAÏÖÔÚÈç´ËÖ®¿ìÁË £¬JIT Óë
> > > > hotspotÖ®ÀàµÄ¼¼Êõ÷ÈÁ¦²»Ð¡£ºÊ²Ã´Ê±¼ä²ÅÄܹ»¿´µ½¶ÔPython½âÊÍÆ÷ÓÅ»¯£¨Psyco¾Í¶Ô¶àÑ­»·ÓÅ»¯Ð§¹û²»´í£©£¬
> > > > ²»Ö»Êǽö½ö´òCµÄÆìºÅ ¡­¡­¡­¡­^_^Ï£Íû²»ÊǸöÃÎ
> > > >
> > > > Test-By-Test   ConsoleTest Python Java
> > > >
> > > > from time import time
> > > >
> > > > start =time()
> > > > for x in xrange(100000):
> > > >     print x
> > > > print time()-start
> > > >
> > > > public class ConsoleTest {
> > > >     public static void main(String[] args) {
> > > >     	
> > > >     	double start = 1.0*System.currentTimeMillis()/1000;
> > > >     	
> > > >         for (int i = 0; i < 100000; i++) {
> > > >
> > > >
> > > >
> > > > System.out.println(i);
> > > >         }
> > > >
> > > >         System.out.println(start-1.0*System.currentTimeMillis()/1000);
> > > >     }
> > > > }
> > > >
> > > >
> > > >   Hashtest Python Java
> > > >
> > > > for i in xrange(1000):
> > > >     x={}
> > > >     for j in xrange(1000):
> > > >         x[j]=i
> > > >         x[j]
> > > >
> > > > import java.util.Hashtable;
> > > >
> > > > public class HashTest {
> > > >     public static void main(String[] args) {
> > > >         for (int i = 0; i < 1000; i++) {
> > > >             Hashtable x = new Hashtable();
> > > >             for (int j = 0; j < 1000; j++) {
> > > >
> > > >
> > > >
> > > >
> > > >                 x.put(new Integer(i), new Integer(j));
> > > >                 x.get(new Integer(i));
> > > >             }
> > > >         }
> > > >     }
> > > > }
> > > >
> > > >
> > > >   IOTest Python Java
> > > >
> > > > from time import time
> > > >
> > > > start =time()
> > > > f =open('scratch','wb')
> > > > for i in xrange(1000000):
> > > >     f.write(str(i))
> > > > f.close()
> > > > print time()-start
> > > >
> > > > import java.io.*;
> > > >
> > > > public class IOTest
> > > > {
> > > >     public static void main(String[] args) {
> > > >
> > > >         double start = 1.0*System.currentTimeMillis()/1000;
> > > >         try {
> > > >             File f = new File("scratch");
> > > >             PrintWriter ps = new PrintWriter(new OutputStreamWriter
> > > >                                              (new
> > > > FileOutputStream(f)));
> > > >             for (int i = 0; i < 1000000; i++) {
> > > >                 ps.print(String.valueOf(i));
> > > >             }
> > > >             ps.close();
> > > >         }
> > > >         catch(IOException ioe) {
> > > >             ioe.printStackTrace();
> > > >         }
> > > >
> > > >         System.out.println(start-1.0*System.currentTimeMillis()/1000);
> > > >     }
> > > > }
> > > >   ListTest Python Java
> > > >
> > > > from time import time
> > > >
> > > > start =time()
> > > > for i in xrange(1000):
> > > >     v=['a','b','c','d','e','f','g']
> > > >     for j in xrange(1000):
> > > >
> > > > v.append
> > > >
> > > > (j)
> > > >         v[j]
> > > > print time()-start
> > > >
> > > > import java.util.Vector;
> > > >
> > > > public class ListTest {
> > > >     public static void main(String[] args) {
> > > >     	
> > > >     	double start = 1.0*System.currentTimeMillis()/1000;
> > > >     	
> > > >         for (int i = 0; i < 1000; i++) {
> > > >
> > > >
> > > >
> > > >             Vector v = new Vector();
> > > >             v.addElement("a");
> > > >             v.addElement("b");
> > > >             v.addElement("c");
> > > >             v.addElement("d");
> > > >
> > > >
> > > >
> > > >             v.addElement("e");
> > > >             v.addElement("f");
> > > >
> > > >             v.addElement("g");
> > > >             for (int j = 0; j < 1000; j++) {
> > > >                 v.addElement(new Integer(j));
> > > >
> > > >
> > > >
> > > >
> > > >                 v.elementAt(j);
> > > >             }
> > > >         }
> > > >
> > > >         System.out.println(start-1.0*System.currentTimeMillis()/1000);
> > > >     }
> > > >
> > > > }
> > > >
> > > >
> > > >
> > > >   NativeTest Python Java
> > > >
> > > >
> > > >
> > > >  Python C Module Java C Module
> > > >
> > > >
> > > >
> > > >
> > > >   NoTest Python Java
> > > >
> > > >
> > > >
> > > >   ObjectTest Python Java
> > > >
> > > > from time import time
> > > >
> > > > start =time()
> > > > class ObjectTest: pass
> > > >
> > > > for i in xrange(10000):
> > > >     root=ObjectTest()
> > > >     for j in xrange(10000):
> > > >         root.next=ObjectTest()
> > > >         root=
> > > > root.next
> > > >
> > > >
> > > >
> > > > print time()-start
> > > >
> > > >     public class ObjectTest {
> > > >     public ObjectTest next;
> > > >     public static void main(String[] args) {
> > > >     	
> > > >     	double start = 1.0*System.currentTimeMillis()/1000;
> > > >     	
> > > >         for (int i = 0; i < 10000; i++) {
> > > >
> > > >
> > > >
> > > >             ObjectTest root = new ObjectTest();
> > > >             for (int j = 0; j < 10000; j++) {
> > > >
> > > >                 root.next=new ObjectTest();
> > > >                 root=root.next;
> > > >             }
> > > >         }
> > > >
> > > >
> > > >
> > > >
> > > >
> > > >         System.out.println(start-1.0*System.currentTimeMillis()/1000);
> > > >
> > > >     }
> > > > }
> > > >
> > > >
> > > >   SpeedTest Python Java
> > > >
> > > > from time import time
> > > >
> > > > start =time()
> > > > for x in xrange(10000000):
> > > >     pass
> > > >
> > > > print time()-start
> > > >
> > > > public class SpeedTest {
> > > >     public static void main(String[] args) {
> > > >     	double start = 1.0*System.currentTimeMillis()/1000;
> > > >     	
> > > >         for (int i = 0; i < 10000000; i++);
> > > >
> > > >
> > > >
> > > >
> > > > System.out.println(start-1.0*System.currentTimeMillis()/1000);
> > > >     }
> > > > }
> > > >
> > > >
> > > >
> > > >
> > > >
> > > >
> > > >
> > > >
> > > > ÔÚ07-3-9£¬Kula < kulasama在gmail.com > дµÀ£º
> > > > >
> > > > > °üÀ¨ÐÔÄÜ,¿Éά»¤ÐÔ,¿ª·¢ºÄʱµÄ¾ßÌå±È½Ï
> > > > > ÎÒÏëÖªµÀ.Èç¹ûʹÓÃdjango+python+cÀ©Õ¹À´¿ª·¢Ò»Ì×webϵͳ.ÄÜ·ñÔÚÐÔÄÜ,
> > > > > ¿Éά»¤ÐԺͿª·¢ºÄʱÉÏÄÜ·ñÈ«Ãæѹ¹ýjava.ϵͳ´ó¸Å10w´úÂëÐйæÄ£
> > > > > лл
> > > > >
> > > > > _______________________________________________
> > > > > 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
> > > >
> > >
> > >
> > >
> > > --
> > > ¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù
> > > My blog:  http://blog.donews.com/ygao
> > > Forum     http://groups.google.com/group/python_study
> > > ¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù¡ù
> > > _______________________________________________
> > > 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
> > >
> >
> >
> >
> > --
> > devdoer
> > devdoer在gmail.com
> > http://devdoer.blog.sohu.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
> >
>
>
> _______________________________________________
> 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
>



-- 
Steve Chu
http://stvchu.org
-------------- 下一部分 --------------
Ò»¸öHTML¸½¼þ±»ÒƳý...
URL: http://python.cn/pipermail/python-chinese/attachments/20070310/a71ad77d/attachment.html 

Output的测试除和语言有关系，还和操作系统和处理方式有很大关系，例如后面那
个测试，在命令行直接运行的结果是：
$python output_test.py	-> 1.0749630928
$java output_test	-> -1.5320000648498535

而：
$python output_test.py >pr.txt -> 0.167773962021
$java output_test >jr.txt	-> -1.1410000324249268

有点意外吧，python遥遥领先Java。
为什么我会测这个测试，因为凭我的经验，standard output最终都是调用系统函
数，脚本语言和C应该不会有什么特别大的差别，Pyton和java都是解释运行字节
码，明显python的解释器比java的简单，简单就意味着快速；Python的底层是C，
java的IO库不知道是怎么样（我没怎么看java的源代码，因为以前java不是开放源
码的，现在开源了兴趣却不大了），估计最终也是调用C的，但肯定绕了很多弯，
因为要处理异常之类...，熟悉操作系统原理的人都知道异常处理是很耗资源的，
所以我敢肯定java一定慢。

我以前自己写过脚本语言，因为工作的关系对各种语言都有一些研究，可以说字节
码的解释执行对速度的提高还是非常有帮助的，例如tcl 8.0以前没有字节码，8.0
增加了字节码，所以速度有了很大提升，印象中lua是最快的脚本语言，实在是一
个设计非常精巧的语言，有兴趣可以看看lua。

在 2007-03-10六的 18:26 +0800，vcc写道：
> 不太清楚你的测试环境，我在我的笔记本下用ubuntu 6.10 下测的第一个测试的
> 果：
> Python 2.4.4	1.0749630928
> JDK1.5.08	-1.5320000648498535 (负数应该是你程序写错了一个地方)
> python快一点，所以我建议你在和原作者在一样的环境下测试再来看看。
> 
> 我的笔记本是Intel Core 2 Due 双核T5500, 1G内存，应该运行java是很快的了
> 吧。
> 
> 在 2007-03-10六的 12:19 +0800，于业平写道：
> > 对比他的例子我重新做了试验：
> > JDK (java.runtime.name=Java(TM) SE Runtime Environment
> > java.runtime.version=1.6.0-b105)
> > Python(Python 2.5)
> > 
> > 而重新测试的结果将让大家大吃一惊：～_～
> > 
> >       Test 
> >       Java 
> >      Python 
> >    Comparison 
> > Standard Output 
> > 1.921999931335449
> > 4.14100003242
> > Java 2.1X Faster
> > than Python


vcc
_

On 3/10/07, vcc <vcc在163.com> wrote:
> Output的测试除和语言有关系，还和操作系统和处理方式有很大关系，例如后面那
> 个测试，在命令行直接运行的结果是：
> $python output_test.py  -> 1.0749630928
> $java output_test       -> -1.5320000648498535
>
> 而：
> $python output_test.py >pr.txt -> 0.167773962021
> $java output_test >jr.txt       -> -1.1410000324249268
>
> 有点意外吧，python遥遥领先Java。
> 为什么我会测这个测试，因为凭我的经验，standard output最终都是调用系统函
> 数，脚本语言和C应该不会有什么特别大的差别，Pyton和java都是解释运行字节
> 码，明显python的解释器比java的简单，简单就意味着快速；Python的底层是C，
> java的IO库不知道是怎么样（我没怎么看java的源代码，因为以前java不是开放源
> 码的，现在开源了兴趣却不大了），估计最终也是调用C的，但肯定绕了很多弯，
> 因为要处理异常之类...，熟悉操作系统原理的人都知道异常处理是很耗资源的，
> 所以我敢肯定java一定慢。
>
> 我以前自己写过脚本语言，因为工作的关系对各种语言都有一些研究，可以说字节
> 码的解释执行对速度的提高还是非常有帮助的，例如tcl 8.0以前没有字节码，8.0
> 增加了字节码，所以速度有了很大提升，印象中lua是最快的脚本语言，实在是一
> 个设计非常精巧的语言，有兴趣可以看看lua。
>

Python的库有扩展库和源码库，源码库就是python源文件的形式，是要通过编译成字节码来运行。而扩展库是使用C/C++写的，就是以机器码方式运行的，所以可以理解为就是运行的C程序。

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

>
> 虽然从编译器的角度讲，java的速度肯定比解释型的Python


同样是编译成字节码,然后对字节码解释执行,似乎差别不大吧.

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

ÊDz»ÊÇ»¹Òª¿¼ÂÇpythonºÍjvm±¾ÉíµÄ¼ÓÔØʱ¼ä
ÎҵĸоõÊÇpython½âÊÍÆ÷µÄ¼ÓÔØËÙ¶ÈÒª¿ìÓÚsun jvm
cpu 1.6G. 256M RAM

On 3/10/07, vcc <vcc在163.com> wrote:
>
> OutputµÄ²âÊÔ³ýºÍÓïÑÔÓйØϵ£¬»¹ºÍ²Ù×÷ϵͳºÍ´¦Àí·½Ê½Óкܴó¹Øϵ£¬ÀýÈçºóÃæÄÇ
> ¸ö²âÊÔ£¬ÔÚÃüÁîÐÐÖ±½ÓÔËÐеĽá¹ûÊÇ£º
> $python output_test.py  -> 1.0749630928
> $java output_test       -> -1.5320000648498535
>
> ¶ø£º
> $python output_test.py >pr.txt -> 0.167773962021
> $java output_test >jr.txt       -> -1.1410000324249268
>
> ÓеãÒâÍâ°É£¬pythonÒ£Ò£ÁìÏÈJava¡£
> ΪʲôÎÒ»á²âÕâ¸ö²âÊÔ£¬ÒòΪƾÎҵľ­Ñ飬standard output×îÖÕ¶¼Êǵ÷ÓÃϵͳº¯
> Êý£¬½Å±¾ÓïÑÔºÍCÓ¦¸Ã²»»áÓÐʲôÌرð´óµÄ²î±ð£¬PytonºÍjava¶¼ÊǽâÊÍÔËÐÐ×Ö½Ú
> Â룬Ã÷ÏÔpythonµÄ½âÊÍÆ÷±ÈjavaµÄ¼òµ¥£¬¼òµ¥¾ÍÒâζ×Å¿ìËÙ£»PythonµÄµ×²ãÊÇC£¬
> javaµÄIO¿â²»ÖªµÀÊÇÔõôÑù£¨ÎÒûÔõô¿´javaµÄÔ´´úÂ룬ÒòΪÒÔÇ°java²»ÊÇ¿ª·ÅÔ´
> ÂëµÄ£¬ÏÖÔÚ¿ªÔ´ÁËÐËȤȴ²»´óÁË£©£¬¹À¼Æ×îÖÕÒ²Êǵ÷ÓÃCµÄ£¬µ«¿Ï¶¨ÈÆÁ˺ܶàÍ䣬
> ÒòΪҪ´¦ÀíÒì³£Ö®Àà...£¬ÊìϤ²Ù×÷ϵͳԭÀíµÄÈ˶¼ÖªµÀÒì³£´¦ÀíÊǺܺÄ×ÊÔ´µÄ£¬
> ËùÒÔÎҸҿ϶¨javaÒ»¶¨Âý¡£
>
> ÎÒÒÔÇ°×Ô¼ºÐ´¹ý½Å±¾ÓïÑÔ£¬ÒòΪ¹¤×÷µÄ¹Øϵ¶Ô¸÷ÖÖÓïÑÔ¶¼ÓÐһЩÑо¿£¬¿ÉÒÔ˵×Ö½Ú
> ÂëµÄ½âÊÍÖ´ÐжÔËٶȵÄÌá¸ß»¹ÊǷdz£ÓаïÖúµÄ£¬ÀýÈçtcl 8.0ÒÔǰûÓÐ×Ö½ÚÂ룬8.0
> Ôö¼ÓÁË×Ö½ÚÂ룬ËùÒÔËÙ¶ÈÓÐÁ˺ܴóÌáÉý£¬Ó¡ÏóÖÐluaÊÇ×î¿ìµÄ½Å±¾ÓïÑÔ£¬ÊµÔÚÊÇÒ»
> ¸öÉè¼Æ·Ç³£¾«ÇɵÄÓïÑÔ£¬ÓÐÐËȤ¿ÉÒÔ¿´¿´lua¡£
>
> ÔÚ 2007-03-10ÁùµÄ 18:26 +0800£¬vccдµÀ£º
> > ²»Ì«Çå³þÄãµÄ²âÊÔ»·¾³£¬ÎÒÔÚÎҵıʼDZ¾ÏÂÓÃubuntu 6.10 ϲâµÄµÚÒ»¸ö²âÊÔµÄ
> > ¹û£º
> > Python 2.4.4  1.0749630928
> > JDK1.5.08     -1.5320000648498535 (¸ºÊýÓ¦¸ÃÊÇÄã³ÌÐòд´íÁËÒ»¸öµØ·½)
> > python¿ìÒ»µã£¬ËùÒÔÎÒ½¨ÒéÄãÔÚºÍÔ­×÷ÕßÔÚÒ»ÑùµÄ»·¾³Ï²âÊÔÔÙÀ´¿´¿´¡£
> >
> > ÎҵıʼDZ¾ÊÇIntel Core 2 Due Ë«ºËT5500, 1GÄڴ棬Ӧ¸ÃÔËÐÐjavaÊǺܿìµÄÁË
> > °É¡£
> >
> > ÔÚ 2007-03-10ÁùµÄ 12:19 +0800£¬ÓÚҵƽдµÀ£º
> > > ¶Ô±ÈËûµÄÀý×ÓÎÒÖØÐÂ×öÁËÊÔÑ飺
> > > JDK (java.runtime.name=Java(TM) SE Runtime Environment
> > > java.runtime.version=1.6.0-b105)
> > > Python(Python 2.5)
> > >
> > > ¶øÖØвâÊԵĽá¹û½«Èôó¼Ò´ó³ÔÒ»¾ª£º¡«_¡«
> > >
> > >       Test
> > >       Java
> > >      Python
> > >    Comparison
> > > Standard Output
> > > 1.921999931335449
> > > 4.14100003242
> > > Java 2.1X Faster
> > > than Python
>
>
> vcc
> _
>
>
> _______________________________________________
> 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
-------------- 下一部分 --------------
Ò»¸öHTML¸½¼þ±»ÒƳý...
URL: http://python.cn/pipermail/python-chinese/attachments/20070310/afdcb17a/attachment.htm 

wang boqun wrote:
> ÊDz»ÊÇ»¹Òª¿¼ÂÇpythonºÍjvm±¾ÉíµÄ¼ÓÔØʱ¼ä
> ÎҵĸоõÊÇpython½âÊÍÆ÷µÄ¼ÓÔØËÙ¶ÈÒª¿ìÓÚsun jvm
> cpu 1.6G. 256M RAM

ºÃµÄ³ÌÐòͨ³£²»»á²»Í£µØÆô¶¯£¬Ò»°ãÆÀ¹ÀÐÔÄÜʱ£¬¶¼ÊǼÆËãÔ¤ÈÈÖ®ºóµÄ³ÖÐøÎȶ¨Ö´
ÐеÄÐÔÄÜ¡£ËùÒÔÎÒ¾õµÃÔÚÕâ¸ö²âÊÔÖУ¬Èç¹ûÖ´ÐдÎÊýºÜÉٵĻ°£¬½âÊÍÆ÷/JVMÆô¶¯µÄ
ʱ¼äÊÇÐèÒª¿¼ÂǽøÈ¥µÄ¡£

Cheers,
-- 
Xin LI <delphij在delphij.net>	http://www.delphij.net/
FreeBSD - The Power to Serve!

-------------- 下一部分 --------------
Ò»¸ö·ÇÎı¾¸½¼þ±»Çå³ý...
·¢ÐÅÈË: %(who)s
Ö÷Ìâ: %(subject)s
ÈÕÆÚ: %(date)s
´óС: 249
Url: http://python.cn/pipermail/python-chinese/attachments/20070310/b5f316c6/attachment-0001.pgp 

ÕâÒª¿´ÄãÊÇʲô³ÌÐò£¬Èç¹ûÊÇ¿Í»§¶Ë³ÌÐò£¬¼ÓÔØʱ¼äµ±È»ÒªËãÉÏ£¬Èç¹ûÊÇ·þÎñÆ÷¶ËµÄ³ÌÐò£¬¿ÉÒÔ¼ÓÔØÔÚÒ»¸ö¶ÔÏóµÄ³ØÖУ¬²»±Øÿ´Î¶¼Æô¶¯£¬¾ÍÏñJDBCÁ¬½Ó³Ø
-------------- 下一部分 --------------
Ò»¸öHTML¸½¼þ±»ÒƳý...
URL: http://python.cn/pipermail/python-chinese/attachments/20070310/8a5e3b8d/attachment.html 

把执行的次数再加一个0，使用重定向到文件方式，
python 1.5417599678
java 10.382999897003174

在 2007-03-10六的 22:47 +0900，LI Xin写道：
> wang boqun wrote:
> > 是不是还要考虑python和jvm本身的加载时间
> > 我的感觉是python解释器的加载速度要快于sun jvm
> > cpu 1.6G. 256M RAM
> 
> 好的程序通常不会不停地启动，一般评估性能时，都是计算预热之后的持续稳定执
> 行的性能。所以我觉得在这个测试中，如果执行次数很少的话，解释器/JVM启动的
> 时间是需要考虑进去的。
> 
> Cheers,
> _______________________________________________
> python-chinese
> Post: send python-chinese at lists.python.cn
> Subscribe: send subscribe to python-chinese-request at lists.python.cn
> Unsubscribe: send unsubscribe to  python-chinese-request at lists.python.cn
> Detail Info: http://python.cn/mailman/listinfo/python-chinese

说实话，我也很诧异为什么在>方式python表现那么好呢？难道是stdout缓冲的缘
故？加上强制flush再试一下，结果验证我的判断。
程序改为：
from time import time
import sys

start =time()
for x in xrange(1000000):
    print x
    sys.stdout.flush()
print time()-start
    
执行结果是：
6.31526899338

这下看起来比较正常，比Java快接近一倍。

在 2007-03-10六的 22:28 +0800，vcc写道：
> 把执行的次数再加一个0，使用重定向到文件方式，
> python 1.5417599678
> java 10.382999897003174
> 
> 在 2007-03-10六的 22:47 +0900，LI Xin写道：
> > wang boqun wrote:
> > > 是不是还要考虑python和jvm本身的加载时间
> > > 我的感觉是python解释器的加载速度要快于sun jvm
> > > cpu 1.6G. 256M RAM
> > 
> > 好的程序通常不会不停地启动，一般评估性能时，都是计算预热之后的持续稳定执
> > 行的性能。所以我觉得在这个测试中，如果执行次数很少的话，解释器/JVM启动的
> > 时间是需要考虑进去的。
> > 
> > Cheers,
> > _______________________________________________
> > python-chinese
> > Post: send python-chinese at lists.python.cn
> > Subscribe: send subscribe to python-chinese-request at lists.python.cn
> > Unsubscribe: send unsubscribe to  python-chinese-request at lists.python.cn
> > Detail Info: http://python.cn/mailman/listinfo/python-chinese
> 
> 
> _______________________________________________
> python-chinese
> Post: send python-chinese at lists.python.cn
> Subscribe: send subscribe to python-chinese-request at lists.python.cn
> Unsubscribe: send unsubscribe to  python-chinese-request at lists.python.cn
> Detail Info: http://python.cn/mailman/listinfo/python-chinese

vcc wrote:
> 把执行的次数再加一个0，使用重定向到文件方式，
> python 1.5417599678
> java 10.382999897003174

这个测试有机会我也跑一跑试试看。有几个问题可能需要注意（只是善意的提醒）：
 - 测试开始之前尽量让系统处于静止状态。这一点对microbenchmark非常重要，
*nix系统中可以考虑启动到单用户方式做测试。
 - 测试的模式，两个测试按AABB AAAA BBBB ABAB BABA的模式多跑几次，有助于
减少偶然误差，并避免“预热”导致不公平的影响。
 - 有时，瓶颈也许并不是被测软件本身引起的。出现差距的时候，可以考虑用一
些工具来分析程序到底做了些什么。FreeBSD提供了一个叫ktrace的工具，有时能
揭示出一些我们不太容易注意到的问题。
 - 有时，输入/输出库操作标准输入/输出的方式可能有问题。试试看把输出去
掉，有时能够隔离问题。

以上是一点个人的经验，仅供参考。

Cheers,
-- 
Xin LI <delphij在delphij.net>	http://www.delphij.net/
FreeBSD - The Power to Serve!

-------------- 涓嬩竴閮ㄥ垎 --------------
一个非文本附件被清除...
发信人: %(who)s
主题: %(subject)s
日期: %(date)s
大小: 249
Url: http://python.cn/pipermail/python-chinese/attachments/20070310/d1b6cbc4/attachment-0001.pgp 

On 3/10/07, vcc <vcc在163.com> wrote:
>
> 说实话，我也很诧异为什么在>方式python表现那么好呢？难道是stdout缓冲的缘
> 故？加上强制flush再试一下，结果验证我的判断。
> 程序改为：
> from time import time
> import sys
>
> start =time()
> for x in xrange(1000000):
>     print x
>     sys.stdout.flush()
> print time()-start
>
> 执行结果是：
> 6.31526899338
>
> 这下看起来比较正常，比Java快接近一倍。
>
>
这样的比较有什么意义？





-- 
simple is good
http://brucewang.net
skype: number5
-------------- 下一部分 --------------
一个HTML附件被移除...
URL: http://python.cn/pipermail/python-chinese/attachments/20070310/6d2ba63a/attachment.html 

vcc wrote:
> 说实话，我也很诧异为什么在>方式python表现那么好呢？难道是stdout缓冲的缘
> 故？加上强制flush再试一下，结果验证我的判断。
> 程序改为：
> from time import time
> import sys
> 
> start =time()
> for x in xrange(1000000):
>     print x
>     sys.stdout.flush()
> print time()-start

如果用time(1)命令来计时的话是否会有变化呢？我个人不是很认可在程序中(特别
是脚本程序)计时的方式，有时这会掩盖一些潜在的影响性能的问题。

Cheers,
-- 
Xin LI <delphij在delphij.net>	http://www.delphij.net/
FreeBSD - The Power to Serve!

-------------- 涓嬩竴閮ㄥ垎 --------------
一个非文本附件被清除...
发信人: %(who)s
主题: %(subject)s
日期: %(date)s
大小: 249
Url: http://python.cn/pipermail/python-chinese/attachments/20070310/9d99903f/attachment.pgp 

Bruce Wang wrote:
> On 3/10/07, *vcc* <vcc在163.com vcc在163.com>> wrote:
> 
>     说实话，我也很诧异为什么在>方式python表现那么好呢？难道是stdout缓冲的缘
>     故？加上强制flush再试一下，结果验证我的判断。
>     程序改为：
>     from time import time
>     import sys
> 
>     start =time()
>     for x in xrange(1000000):
>         print x
>         sys.stdout.flush()
>     print time()-start
> 
>     执行结果是：
>     6.31526899338
> 
>     这下看起来比较正常，比Java快接近一倍。
> 
> 这样的比较有什么意义？

我觉得这个比较并不能证明Python vs Java如何，但是至少能够解释某些现象，或
者即使我们没办法修改两种语言之一，至少它能够告诉我们这种语言哪方面性能不
好，写程序的时候可以绕开这些可能引发性能问题的地方。

Cheers,
-- 
Xin LI <delphij在delphij.net>	http://www.delphij.net/
FreeBSD - The Power to Serve!

-------------- 下一部分 --------------
一个非文本附件被清除...
发信人: %(who)s
主题: %(subject)s
日期: %(date)s
大小: 249
Url: http://python.cn/pipermail/python-chinese/attachments/20070311/b6281ac0/attachment.pgp 

在 2007-03-10六的 22:56 +0800，Bruce Wang写道：
> 这样的比较有什么意义？

没有意义， only discovery ;-)