L-JH博客

python 提高效率的几个小技巧

L-JH — Sat, 24 Dec 2011 08:56:03 +0000

python 提高效率的几个小技巧 1.1. 最常见一个最常见的速度陷坑(至少是俺在没看到网上这篇介绍时陷进去过好些次的) 是: 许多短字串并成长字串时, 大家通常会用: Toggle line numbers 1 shortStrs = [ str0, str1, ..., strN] 2 #N+1个字串所组成的数列 3 longStr = ” 4 for s in shortStrs: longStr += s 因为Python里字串是不可变的, 所以每次 longStr += s 都是将原来的 longStr 与 str 拷贝成一个新字串, 再赋给longStr. 随着 longStr的不断增长, 所要拷贝的内容越来越长. 最后导至str0被拷贝N+1次, str1是N次, … . 那咋办呢 ? 咱们来看看Skip Montanaro先生的解说: http://musi-cal.mojam.com/~skip/python/fastpython.html 及可参考一下Guido van Rossum本人的:http://www.python.org/doc/essays/list2str.html 1.1.1. 找出速度瓶颈 1)首先在大家应先学会怎么去找出速度瓶颈: Python自带有profile 模块: Toggle line numbers 1 import profile 2 profile.run (’想要检查的函数名()’) 就会打印出那个函数里调用了几次其它函数, 各用了多少时间, 总共用了多少时间等信息 — Nice ? 详请参阅<<库参考>>中的 profile模块的论述. 当然脑袋笨一点或是聪明一点的, 也可以用time模块中的time() 来显示系统时间, 减去上次的time()就是与它的间隔秒数了. 1.1.2. 字串相并就头上的例子而言, 用 : Toggle line numbers 1 longStr =”.join(shortStrs) 立马搞定, 但如果shortStrs里面不都是字串, 而包含了些数字呢 ? 直接用join就会出错. 不怕, 这样来: Toggle line numbers 1 shortStrs = [str(s) for s in shortStrs[i]] 2 longStr = ”.join(shortStrs) 也即先将数列中所有内容都转化为字串, 再用join. 对少数几个字串相并, 应避免用: all = str0 + str1 + str2 + str3 而用: all = ‘%s%s%s%s’ % (str0, str1, str2, str3) 1.1.3. 数列排序 list.sort () 你可以按特定的函数来: list.sort( 函数 ), 只要这个函数接受两参数, 并按特定规则返回1, 0, -1就可以. — 很方便吧? 但会大大减慢运行速度. 下面的方法, 俺举例子来说明可能更容易明白. 比方说你的数列是 l = ['az', 'by'], 你想以第二个字母来排序. 先取出你的关键词, 并与每个字串组成一个元组: new = map (lambda s: (s[1], s), l ) 于是new变成[('z', 'az'), ('y', 'by')], 再把new排一下序: new.sort() 则new就变成 [('y', 'by'), ('z', 'az')], 再返回每个元组中的第二个字串: sorted = map (lambda t: t[1], new) 于是sorted 就是: ['by', 'az']了. 这里的lambda与map用得很好. Python2.4以后, sort和sorted的使用可以参考这片 Wiki: HowToSort 1.1.4. 循环比如for循环. 当循环体很简单时, 则循环的调用前头(overhead) 会显得很臃肿, 此时map又可以帮忙了. 比如你想把一个长数列 l=['a', 'b', ...]中的每个字串变成大写, 可能会用: Toggle line numbers 1 import string 2 newL = [] 3 for s in l: newL.append( string.upper(s) ) 用map就可以省去for循环的前头: Toggle line numbers 1 import string 2 newL = map (string.upper, l) Guido的文章讲得很详细. 1.1.5. 局域变量及 ‘.’ 象上面, 若用 append = newL.append, 及换种import方法: Toggle line numbers 1 import string 2 append = newL.append 3 for s in l: append (string.upper(s)) 会比在for中运行newL.append快一些, 为啥? 局域变量容易寻找. 俺自己就不比较时间了, Skip Montanaro的结果是: 基本循环: 3.47秒去点用局域变量: 1.79秒使用map: 0.54秒 1.1.6. try的使用比如你想计算一个字串数列: l = ['I', 'You', 'Python', 'Perl', ...] 中每个词出现的次数, 你可能会: Toggle line numbers 1 count = {} 2 for s in l: 3 if not count.has_key(s): count[s] = 0 4 else: count[s] += 1 由于每次都得在count中寻找是否已有同名关键词, 会很费时间. 而用try: Toggle line numbers 1 count ={} 2 for s in l: 3 try: count[s] += 1 4 except KeyError: count[s] = 0 就好得多. 当然若经常出现例外时, 就不要用try了. 1.1.7. import语句这好理解. 就是避免在函数定义中来import一个模块, 应全在全局块中来import 1.1.8. 大量数据处理由于Python中的函数调用前头(overhead)比较重, 所以处理大量数据时, 应: Toggle line numbers 1 def f(): 2 for d in hugeData: … 3 f() 而不要: Toggle line numbers 1 def f(d): … 2 for d in hugeData: f(d) 这点好象对其它语言也适用, 差不多是放之四海而皆准, 不过对解释性语言就更重要了. 1.1.9. 减少周期性检查这是Python的本征功能: 周期性检查有没有其它绪(thread)或系统信号(signal)等要处理. 可以用sys模块中的setcheckinterval 来设置每次检查的时间间隔. 缺省是10, 即每10个虚拟指令 (virtual instruction)检查一次. 当你不用绪并且也懒得搭理系统信号时, 将检查周期设长会增加速度, 有时还会很显著. —编/译完毕. 看来Python是易学难精了, 象围棋? 2. 我们自个儿的体悟请有心得者分享! 在“大量数据处理”小节里，是不是说，不要再循环体内部调用函数，应该把函数放到外面？从Python2.2开始,”找出速度瓶颈”,已经可以使用hotshot模块了.据说对程序运行效率的影响要比profile小. — jacobfan “由于Python中的函数调用前头(overhead)比较重, 所以处理大量数据时, 应: ” 这句译文中,overhead翻译成”前头”好象不妥.翻译成”由于Python中函数调用的开销比较大,…”要好些 — jacobfan 数组排序中讲的方法真的会快点吗? 真的快到我们值得放弃直接用sort得到得可读性吗?值得怀疑 — hoxide Python2.4以后 sort和sorted的使用更加灵活，link已经加到文中，我没有比较过效率。-yichun 关于 “try的使用”：其实setdefault方法就是为这个目的设的： Toggle line numbers 1 count = {} 2 for s in l: 3 count.setdefault(s, 0) += 1 这个其实能做更多。通常遇到的问题是要把类似的东西group起来，所以你可能想用： Toggle line numbers 1 count = {} 2 for s in l: 3 count.setdefault(s, []).append(s) 但是这样你只能把同样的东西hash起来，而不是一类东西。比如说你有一个dict构成的list叫sequence，需要按这些dict的某个key value分类，你还要对分类后的每个类别里面的这些dict各作一定的操作，你就需要用到Raymond实现的这个groupby，你就可以写: totals = dict((key, group) for key, group in groupby(sequence, lambda x: x.get(’Age’)))

看着不错，转载来得

Python这货果然不是编程语言，这是艺术

L-JH — Sat, 17 Dec 2011 17:24:29 +0000

网上看到的一篇文章，挺有意思的...

看到生成树表达式一章，我几乎惊呼出来，这货果然是艺术。若说C是大气滂泊的“九阳神功”，那Python就是优雅潇洒的“独孤九剑”。 OK，看看一步步缩减，步入精深的代码吧：程序实现寻找文件中的最长行。 First：这是一板一眼的代码行，先是打开文件，对比行的长度判断，最后返回最长行。 next：对程序操作的内存进行优化，打开文件，将文件内容存储到临时字符串，关闭对文件的操作，优化了内存。 next；对代码进行优化，用for循环对得到数据前进行了strip()方法处理行内容。 next: 代码优化+内存优化，直接去除了readline()操作，因为文件本身就成为了自己的迭代器，就不需要readline()函数。 next: 代码+内存优化。用生成器表达式代替列表解析。 next: 内存+代码优化，取消了打开文件的处理，直接读取调用文件，并用for循环和max()函数实现选取操作。 Python实现了从9行代码简化到1行。而且其中编程的思路可谓精巧至极，乔某唯有望而生谈焉。

原帖地址：http://hi.baidu.com/%C7%C73%C9%D9/blog/item/832d84f9e41ab41ed9f9fdb7.html

Python字符串的encode与decode研究心得乱码问题解决方法

L-JH — Wed, 14 Dec 2011 12:45:16 +0000

为什么Python使用过程中会出现各式各样的乱码问题，明明是中文字符却显示成“\xe4\xb8\xad\xe6\x96\x87”的形式？

为什么会报错“UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)”？本文就来研究一下这个问题。

字符串在Python内部的表示是unicode编码，因此，在做编码转换时，通常需要以unicode作为中间编码，即先将其他编码的字符串解码（decode）成unicode，再从unicode编码（encode）成另一种编码。

decode的作用是将其他编码的字符串转换成unicode编码，如str1.decode('gb2312')，表示将gb2312编码的字符串str1转换成unicode编码。 encode的作用是将unicode编码转换成其他编码的字符串，如str2.encode('gb2312')，表示将unicode编码的字符串str2转换成gb2312编码。因此，转码的时候一定要先搞明白，字符串str是什么编码，然后decode成unicode，然后再encode成其他编码

代码中字符串的默认编码与代码文件本身的编码一致。如：s='中文' 如果是在utf8的文件中，该字符串就是utf8编码，如果是在gb2312的文件中，则其编码为gb2312。这种情况下，要进行编码转换，都需要先用decode方法将其转换成unicode编码，再使用encode方法将其转换成其他编码。通常，在没有指定特定的编码方式时，都是使用的系统默认编码创建的代码文件。如果字符串是这样定义：s=u'中文' 则该字符串的编码就被指定为unicode了，即python的内部编码，而与代码文件本身的编码无关。因此，对于这种情况做编码转换，只需要直接使用encode方法将其转换成指定编码即可。

如果一个字符串已经是unicode了，再进行解码则将出错，因此通常要对其编码方式是否为unicode进行判断： isinstance(s, unicode) #用来判断是否为unicode 用非unicode编码形式的str来encode会报错

如何获得系统的默认编码？ #!/usr/bin/env python #coding=utf-8 import sys print sys.getdefaultencoding() 该段程序在英文WindowsXP上输出为：ascii

在某些IDE中，字符串的输出总是出现乱码，甚至错误，其实是由于IDE的结果输出控制台自身不能显示字符串的编码，而不是程序本身的问题。如在UliPad中运行如下代码： s=u"中文" print s 会提示：UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)。这是因为UliPad在英文WindowsXP上的控制台信息输出窗口是按照ascii编码输出的（英文系统的默认编码是ascii），而上面代码中的字符串是Unicode编码的，所以输出时产生了错误。将最后一句改为：print s.encode('gb2312') 则能正确输出“中文”两个字。若最后一句改为：print s.encode('utf8') 则输出：\xe4\xb8\xad\xe6\x96\x87，这是控制台信息输出窗口按照ascii编码输出utf8编码的字符串的结果。

unicode(str,'gb2312')与str.decode('gb2312')是一样的，都是将gb2312编码的str转为unicode编码使用str.__class__可以查看str的编码形式

原理说了半天，最后来个包治百病的吧：）

代码如下:

#!/usr/bin/env python #coding=utf-8 s="中文" if isinstance(s, unicode): #s=u"中文" print s.encode('gb2312') else: #s="中文" print s.decode('utf-8').encode('gb2312')

Python程序员的进化

L-JH — Mon, 12 Dec 2011 11:13:55 +0000

以前本博客发布过一篇《程序员的进化》，以一种幽默的代码展现方式调侃了程序。下面这篇是关于Python程序员的。以阶乘为例，很有意思。

新手程序员

def factorial(x):

if x == 0:

return 1

else:

return x * factorial(x - 1)

print factorial(6)

第一年的刚学完Pascal的新手

def factorial(x):

result = 1

i = 2

while i <= x:

result = result * i

i = i + 1

return result

print factorial(6)

第一年的刚学完C语言的新手

def fact(x): #{

result = i = 1;

while (i <= x): #{

result *= i;

i += 1;

#}

return result;

#}

print(fact(6))

第一年刚学完SICP的新手

@tailcall

def fact(x, acc=1):

if (x > 1): return (fact((x - 1), (acc * x)))

else: return acc

print(fact(6))

第一年刚学完Python的新手

def Factorial(x):

res = 1

for i in xrange(2, x + 1):

res *= i

return res

print Factorial(6)

爱偷懒的程序员

def fact(x):

return x > 1 and x * fact(x - 1) or 1

print fact(6)

更懒的 Python 程序员

1 2	`f` `=` `lambda` `x: x` `and` `x` `*` `f(x` `-` `1)` `or` `1` `print` `f(6)`

Python 专家

import operator as op

import functional as f

fact = lambda x: f.foldl(op.mul, 1, xrange(2, x + 1))

print fact(6)

Python 黑客

import sys

@tailcall

def fact(x, acc=1):

if x: return fact(x.__sub__(1), acc.__mul__(x))

return acc

sys.stdout.write(str(fact(6)) + '\n')

专家级程序员

import c_math

fact = c_math.fact

print fact(6)

英语系的专家级程序员

import c_maths

fact = c_maths.fact

print fact(6)

Web 设计者

def factorial(x):

#-------------------------------------------------

#--- Code snippet from The Math Vault ---

#--- Calculate factorial (C) Arthur Smith 1999 ---

#-------------------------------------------------

result = str(1)

i = 1 #Thanks Adam

while i <= x:

#result = result * i #It's faster to use *=

#result = str(result * result + i)

#result = int(result *= i) #??????

result str(int(result) * i)

#result = int(str(result) * i)

i = i + 1

return result

print factorial(6)

Unix 程序员

import os

def fact(x):

os.system('factorial ' + str(x))

fact(6)

Windows 程序员

NULL = None

def CalculateAndPrintFactorialEx(dwNumber,

hOutputDevice,

lpLparam,

lpWparam,

lpsscSecurity,

*dwReserved):

if lpsscSecurity != NULL:

return NULL #Not implemented

dwResult = dwCounter = 1

while dwCounter <= dwNumber:

dwResult *= dwCounter

dwCounter += 1

hOutputDevice.write(str(dwResult))

hOutputDevice.write('\n')

return 1

import sys

CalculateAndPrintFactorialEx(6, sys.stdout, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL)

公司里的程序员

def new(cls, *args, **kwargs):

return cls(*args, **kwargs)

class Number(object):

pass

class IntegralNumber(int, Number):

def toInt(self):

return new (int, self)

class InternalBase(object):

def __init__(self, base):

self.base = base.toInt()

def getBase(self):

return new (IntegralNumber, self.base)

class MathematicsSystem(object):

def __init__(self, ibase):

Abstract

@classmethod

def getInstance(cls, ibase):

try:

cls.__instance

except AttributeError:

cls.__instance = new (cls, ibase)

return cls.__instance

class StandardMathematicsSystem(MathematicsSystem):

def __init__(self, ibase):

if ibase.getBase() != new (IntegralNumber, 2):

raise NotImplementedError

self.base = ibase.getBase()

def calculateFactorial(self, target):

result = new (IntegralNumber, 1)

i = new (IntegralNumber, 2)

while i <= target:

result = result * i

i = i + new (IntegralNumber, 1)

return result

print StandardMathematicsSystem.getInstance(new (InternalBase, new (IntegralNumber, 2))).calculateFactorial(new (IntegralNumber, 6))

程序员的进化

L-JH — Mon, 12 Dec 2011 11:10:49 +0000

如果把程序员分级，那么就是： 高中时期

  10 PRINT "HELLO WORLD"
  20 END

大学新生

  program Hello(input, output)
    begin
      writeln(\'Hello World\')
    end.

高年级大学生

#include 

int main(void)
{
   printf("Hello, world!\\n");
   return 0;
}

职业新手

  #include
  void main(void)
  {
    char *message[] = {"Hello ", "World"};
    int i;

    for(i = 0; i < 2; ++i)
      printf("%s", message[i]);
    printf("\\n");
  }

职业老手

  #include
  #include
 using namespace std;

  class string
  {
  private:
    int size;
    char *ptr;

  string() : size(0), ptr(new char[1]) { ptr[0] = 0; }

    string(const string &s) : size(s.size)
    {
      ptr = new char[size + 1];
      strcpy(ptr, s.ptr);
    }

    ~string()
    {
      delete [] ptr;
    }

    friend ostream &operator <<(ostream &, const string &);
    string &operator=(const char *);
  };

  ostream &operator<<(ostream &stream, const string &s)
  {
    return(stream << s.ptr);
  }

  string &string::operator=(const char *chrs)
  {
    if (this != &chrs)
    {
      delete [] ptr;
     size = strlen(chrs);
      ptr = new char[size + 1];
      strcpy(ptr, chrs);
    }
    return(*this);
  }

  int main()
  {
    string str;

    str = "Hello World";
    cout << str << endl;

    return(0);
  }

大师级

  [
  uuid(2573F8F4-CFEE-101A-9A9F-00AA00342820)
  ]
  library LHello
  {
      // bring in the master library
      importlib("actimp.tlb");
      importlib("actexp.tlb");

      // bring in my interfaces
      #include "pshlo.idl"

      [
      uuid(2573F8F5-CFEE-101A-9A9F-00AA00342820)
      ]
      cotype THello
   {
   interface IHello;
   interface IPersistFile;
   };
  };

  [
  exe,
  uuid(2573F890-CFEE-101A-9A9F-00AA00342820)
  ]
  module CHelloLib
  {

      // some code related header files
      importheader();
      importheader(
);
      importheader();
      importheader("pshlo.h");
      importheader("shlo.hxx");
      importheader("mycls.hxx");

      // needed typelibs
      importlib("actimp.tlb");
      importlib("actexp.tlb");
      importlib("thlo.tlb");

      [
      uuid(2573F891-CFEE-101A-9A9F-00AA00342820),
      aggregatable
      ]
      coclass CHello
   {
   cotype THello;
   };
  };

  #include "ipfix.hxx"

  extern HANDLE hEvent;

  class CHello : public CHelloBase
  {
  public:
      IPFIX(CLSID_CHello);

      CHello(IUnknown *pUnk);
      ~CHello();

      HRESULT  __stdcall PrintSz(LPWSTR pwszString);

  private:
      static int cObjRef;
  };

  #include
  #include

  #include
  #include
  #include "thlo.h"
  #include "pshlo.h"
  #include "shlo.hxx"
  #include "mycls.hxx"

  int CHello::cObjRef = 0;

  CHello::CHello(IUnknown *pUnk) : CHelloBase(pUnk)
  {
      cObjRef++;
      return;
  }

  HRESULT  __stdcall  CHello::PrintSz(LPWSTR pwszString)
  {
      printf("%ws
", pwszString);
      return(ResultFromScode(S_OK));
  }

  CHello::~CHello(void)
  {

  // when the object count goes to zero, stop the server
  cObjRef--;
  if( cObjRef == 0 )
      PulseEvent(hEvent);

  return;
  }

  #include
  #include

  #include "pshlo.h"
  #include "shlo.hxx"
  #include "mycls.hxx"

  HANDLE hEvent;

   int _cdecl main(
  int argc,
  char * argv[]
  ) {
  ULONG ulRef;
  DWORD dwRegistration;
  CHelloCF *pCF = new CHelloCF();

  hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

  // Initialize the OLE libraries
  CoInitializeEx(NULL, COINIT_MULTITHREADED);

  CoRegisterClassObject(CLSID_CHello, pCF, CLSCTX_LOCAL_SERVER,
      REGCLS_MULTIPLEUSE, &dwRegistration);

  // wait on an event to stop
  WaitForSingleObject(hEvent, INFINITE);

  // revoke and release the class object
  CoRevokeClassObject(dwRegistration);
  ulRef = pCF->Release();

  // Tell OLE we are going away.
  CoUninitialize();

  return(0); }

  extern CLSID CLSID_CHello;
  extern UUID LIBID_CHelloLib;

  CLSID CLSID_CHello = { /* 2573F891-CFEE-101A-9A9F-00AA00342820 */
      0x2573F891,
      0xCFEE,
      0x101A,
      { 0x9A, 0x9F, 0x00, 0xAA, 0x00, 0x34, 0x28, 0x20 }
  };

  UUID LIBID_CHelloLib = { /* 2573F890-CFEE-101A-9A9F-00AA00342820 */
      0x2573F890,
      0xCFEE,
      0x101A,
      { 0x9A, 0x9F, 0x00, 0xAA, 0x00, 0x34, 0x28, 0x20 }
  };

  #include
  #include

  #include
  #include
  #include
  #include "pshlo.h"
  #include "shlo.hxx"
  #include "clsid.h"

  int _cdecl main(
  int argc,
  char * argv[]
  ) {
  HRESULT  hRslt;
  IHello        *pHello;
  ULONG  ulCnt;
  IMoniker * pmk;
  WCHAR  wcsT[_MAX_PATH];
  WCHAR  wcsPath[2 * _MAX_PATH];

  // get object path
  wcsPath[0] = \'\\0\';
  wcsT[0] = \'\\0\';
  if( argc > 1) {
      mbstowcs(wcsPath, argv[1], strlen(argv[1]) + 1);
      wcsupr(wcsPath);
      }
  else {
      fprintf(stderr, "Object path must be specified\\n");
      return(1);
      }

  // get print string
  if(argc > 2)
      mbstowcs(wcsT, argv[2], strlen(argv[2]) + 1);
  else
      wcscpy(wcsT, L"Hello World");

  printf("Linking to object %ws\\n", wcsPath);
  printf("Text String %ws\\n", wcsT);

  // Initialize the OLE libraries
  hRslt = CoInitializeEx(NULL, COINIT_MULTITHREADED);

  if(SUCCEEDED(hRslt)) {

      hRslt = CreateFileMoniker(wcsPath, &pmk);
      if(SUCCEEDED(hRslt))
   hRslt = BindMoniker(pmk, 0, IID_IHello, (void **)&pHello);

      if(SUCCEEDED(hRslt)) {

   // print a string out
   pHello->PrintSz(wcsT);

   Sleep(2000);
   ulCnt = pHello->Release();
   }
      else
   printf("Failure to connect, status: %lx", hRslt);

      // Tell OLE we are going away.
      CoUninitialize();
      }

  return(0);
  }

黑客学徒

  #!/usr/local/bin/perl
  $msg="Hello, world.\\n";
  if ($#ARGV >= 0) {
    while(defined($arg=shift(@ARGV))) {
      $outfilename = $arg;
      open(FILE, ">" . $outfilename) || die "Can\'t write $arg: $!\\n";
      print (FILE $msg);
      close(FILE) || die "Can\'t close $arg: $!\\n";
    }
  } else {
    print ($msg);
  }
  1;

有经验的黑客

  #include
  #define S "Hello, World\\n"
  main(){exit(printf(S) == strlen(S) ? 0 : 1);}

老练的黑客

  % cc -o a.out ~/src/misc/hw/hw.c
  % a.out

超级黑客

  % echo "Hello, world."

一线经理

  10 PRINT "HELLO WORLD"
  20 END

中层经理

  mail -s "Hello, world." bob@b12
  Bob, could you please write me a program that prints "Hello, world."?
  I need it by tomorrow.
  ^D

高级经理

  % zmail jim
  I need a "Hello, world." program by this afternoon.

首席执行官

  % letter
  letter: Command not found.
  % mail
  To: ^X ^F ^C
  % help mail
  help: Command not found.
  % damn!
  !: Event unrecognized
  % logout

Hello World 大集合

L-JH — Mon, 12 Dec 2011 11:03:13 +0000

编程的人应该都知道什么是Hello World。这是一个最简单的程序，其只在屏幕上输出“Hello World”字样，这通常是初学者的在学习编程时的第一个示例。把打印出 “Hello World” 作为第一个范例程序，现在已经成为编程语言学习的传统。 “Hello World”起源于Brian Kernighan 和Dennis MacAlistair Ritchie写的计算机程序设计教程《C语言程序设计》（The C Programming Language）而广泛流传；但这本书并不是 “hello, world” 的滥觞，虽然这是一个普遍存在的错误认知。这范例程序最早出现于 1972 年，由贝尔实验室成员 Brian Kernighan 撰写的内部技术文件《Introduction to the Language B》之中。不久同作者于 1974 年所撰写的《Programming in C: A Tutorial》，也延用这个范例；而以本文件扩编改写的《C语言程序设计》也保留了这个範例程式。 “hello, world” 程序的标准打印内容必须满足“全小写，无惊叹号，逗点后需空一格”，不过流传至今，完全恪守传统的反而罕见。现在就来看看最全的Hello World集合: http://www.roesler-ac.de/wolfram/hello.htm 这个网站很BT啊，其开始是从1994年10月3日，于1999年12月30日上互联网，2005年7月14日收集到了超过200个不同语言的Hello World，2006年12月6日达到300个，2008年2月27日达到400个。今天这个网站有一共421个不同语言的Hello World，其中有63个来自人类的语言。

S60V3 Python 教程 (修复下载错误)

L-JH — Sat, 10 Dec 2011 13:01:42 +0000

前些日子有不少机友问我是怎么学的，其实就是自学，摸索出来的也有不少机友问我要教程，最近我把整理出来了感兴趣的可以学学，自己编写点小软件玩玩。编程序挺有意思的，我喜欢那过程与结果这些教程为Symbian(塞班)S60V3Python的教程。写的程序只在Symbian(塞班) Python平台上能运行，但不能保证各个平台的兼容。当然，Python语言的根本没变，你学了后，就能在其他系统上的Python平台写些东西了，例如Windous系统上的Python平台，关于这个，以后我会发文章帖出些小脚本，关注本博客啦(订阅本博客获取最新动态) 教程下载(下载后改后缀为zip)：注：下载出错：1.请用其他浏览器尝试 2.设置UC的缩放为适应屏幕 3.关闭或打开WAP压缩中转 [download id="8"] 哇麦论坛系列的 [download id="9"] 米饭系列的，里面分doc文档与txt带源码带图片两种 [download id="10"] 其他人的 [download id="11"] 杂七杂八的单章教程 [download id="12"] 上面这些教程带的编程、教学用到的软件与工具，单独提出来打包 [download id="13"] 我手机里的一些编程软件及工具，其实很多都不常用 [download id="14"] 最后是收集的一大堆实用、实例、示例脚本 ----------------------------------- 上传了我几次，大半天 -_-! 如果你能把上面前三个看完，写个S60V3小程序不成问题了