Python&Toy

Python绝对是最有前途的脚本语言！ - 看到Python for S60有感

jzhang — Tue, 30 Jan 2007 07:33:00 GMT

作为一个开源项目的产物，Python所登上的舞台之广泛前所未有。
他不仅如一般的脚本语言一样运行于Linux,Windows等主流平台，
而且成为了微软.Net家族的一员。最近学习Symbian系统的编程，
发现Python竟然也已经进入了这个移动世界的大舞台,而且发布者
就是移动世界的老大：Nokia. Python已经成为Symbian系统除
C++(原生语言），Java之后的第三个编程语言和唯一的脚本语言。

佩服啊佩服。

统计指定目录下包含指定函数的行数总和

jzhang — Mon, 11 Dec 2006 08:21:00 GMT

比如说，有一些类都实现了一个原型为OnInitDialog()的函数，需要统计出这种函数的
代码行数的总和，不知道有什么最简单的方法？简单的正则表达式估计干不了
这个。不知道Linux下的工具行不行.

可恶的viking病毒 (杀毒工具)

jzhang — Fri, 27 Oct 2006 07:31:00 GMT

出差的时候，笔记本竟然中毒了。是viking病毒，上网一查，中国制造，非常厉害。
笔记本被完全感染了，安装的卡巴司机都不能起来。
下了一个民间版专杀工具，内存，注册表什么的都恢复了，也作了免疫。可是很多被
感染的文件没有恢复。看了几份病毒报告，用vc写了个程序杀毒，终于清净了。

下载
1. 只能查找内存和磁盘，没处理注册表，也没有免疫。建议使用其他工具
2. 对其可靠性安全性不负责任

一小段Python程序

jzhang — Mon, 14 Aug 2006 15:28:00 GMT

刚才敲得，先放这，学数学的也许知道这段程序是穷举Kaprekar Number的,呵呵.

def check(a,b,c,d):
    n = a*1000 + b * 100  + c * 10 + d - (d*1000+c*100+b*10+a)
    i = 0
    oldresult = 0
    while True:
        i = i + 1
        s = [(n%1000%100%10),(n/10%100%10),(n/100%10),n/1000]
        s.sort()
        n = s[0] + s[1]*10 + s[2]*100+s[3]*1000
        r = s[3] + s[2]*10 + s[1]*100+s[0]*1000
        nn = n - r
        if nn == oldresult:
            #print "the result for ",a,b,c,d,"is ",nn
            break
        elif i > 9999:
            print a,b,c,d,"failed"
            break
        n = nn
        oldresult = nn

for a in range(10):
    for b in range(10):
        for c in range(10):
            for d in range(10):
                if a == b and b == c and c == d:
                    continue
                elif a < b or b < c or c < d:
                    continue
                else:
                    check(a,b,c,d)
print "Done"

正如java在企业开发领域推倒C++一样。脚本或称为动态语言成为主流的时刻不远了

jzhang — Thu, 20 Jul 2006 09:20:00 GMT

这句话说得好。掌握一门脚本语言已经成为程序员必要的技能了。
强烈推荐Python。

Lua 真是太帅了！

jzhang — Thu, 08 Jun 2006 10:13:00 GMT

以前只听人说过。在我上次写那个Python和C对比的帖子的时候，全局变量演示了用Lua
实现的版本。当时我还觉得没有必要再学另外一个脚本，反正已经学了Python了。
今天学习了一下，发现Lua 跟Python根本不是一回事， Lua 天生就是为嵌入应用程序设计的：
1. C可以调用Lua的脚本函数
2. Lua脚本可以调用应用程序中定义的C函数
3. Lua也支持用C写Dll，导出API供Lua调用。
实在太强悍了，而且Lua的Library编译后才200k，小巧玲珑，根据需要，还可以加入需要的扩展库。

嗯，以前考虑过用Python作为嵌入脚本，上一家公司的脚本还是自己实现的，现在发现了Lua，再也
没有必要了，哈哈！绝妙，绝妙阿。

推荐大家看看，如果你的程序中需要支持脚本，Lua 是最好的选择：
http://www.lua.org
Lua 本身也可以作为独立的解释器运行，不过这个时候跟Python比就不行了，
它的库太少，用来在通用开发吃力。Lua 的end语法虽然在我看来罗嗦，但是
对于我们的客户可能会很喜欢，:)

ps.我现在越来越喜欢C了，代码干净，好移植。
上次看到一个shttpd，也是让我觉得帅呆了,只有一个.c文件.

一张mindmap图

jzhang — Sat, 20 May 2006 01:16:00 GMT

呵呵，不知道这里用Mind Map的人多吗？我已经越来越喜欢它了。
这张图是一个例子，关于我正在写的小游戏的。在公司的项目里，我也常用。
推荐大家看看介绍: http://jason.rocklv.net/freesoftware/ar01s04.html

用LPC写一个小游戏

jzhang — Wed, 17 May 2006 02:10:00 GMT

这是在水木清华的sanguo版玩的一个小游戏，好像一直是手动玩的。每方有几个人参加，有一个人做裁判。双方每个回合把指令发给裁判，裁判进行计算得到结果...
很自然的，这个游戏可以做成程序。这里有游戏的规则。
我是用LPC写的。考虑到大多数人可能都不知道LPC是什么，我简单的介绍下：
MUD -- Mutli-User Dungeons。直译是多用户网络游戏，特指远古时期基于telnet的文字网络游戏。这些游戏有一定的剧情，很多人登陆进去，扮演各自的角色，比如侠客，乞丐等等。这个概念跟今天的网游是一模一样的。实际上最初网游出现的时候，有一些还是基于原始的MUD扩展开发的。
LPC -- 一个MUD程序由两部分组成：MudOS和MudLib。 MudOS是一个内核，提供游戏最重要的一些功能，比如网络连接，用户管理等等。而MudLib则是基于MudOS开发的特定的游戏内容。基于同一个MudOS，可以开发出截然不同的游戏。而MudLib的开发语言是MudOS提供的脚本:LPC。
从我今天的认识来看，MudOS+MudLib是一套非常漂亮的二次开发框架，用流行的话说，是LOP(面向语言编程)。
用LPC开发游戏，可以不必处理各种基本的问题，一上来就直奔游戏内容本身。非常方便。

下面是游戏的技术描述：

平台	MudOS on Linux and Windows
语言	LPC
访问方式	Telnet. 将来可以支持Web访问，因为最新的MudOS内建Web Server，可以用LPC写页面
功能	创建，加入，退出三国战术游戏战术游戏战斗系统用户评分系统聊天系统 (现成的)
发布方式	MudOS的发布方式没有找到官方的说法，反正不是GPL。但是是开源的，商用好像是不可以的。MudLib继承的ES2,这个也不可以商用。所以这个游戏完成后，我会提供下载。反正也不会有商用的可能。:)

目前进度：

架子已经搭好了,目前可以创建游戏，加入，退出游戏。战斗系统还没开始。2006-05-16

另一个Python和C程序的对比

jzhang — Tue, 28 Mar 2006 07:31:00 GMT

需求是这样的:

有大量名字以序列号排序 内容如下面内容的文本文件

姓名:aaaa
性别:bbb
年龄:ccc
籍贯:ddd

冒号和内容中间有数量不等的空格,如何能批量导入这些文件进入一个数据库，比如access

形如下面的形式

姓名    性别    年龄    籍贯
aaaa1   bbb1    ccc1    ddd1
aaaa2   bbb2    ccc2    ddd2


其中某项空缺的时候，比如有一个文本文件里年龄空缺，怎么保证列表还能正确






下面是测试用的数据文件: http://dhxy.info/upload/CS/1134036281_1.rar

方案是生成一个csv文件,然后直接导入access,下面是Python实现:

# -*- coding: cp936 -*-
#convert txt data file into csv file
import sys
import os.path

def output(cur):
 s = ""
 keys = ["名字","性别","年龄","籍贯"]
 for key in keys:
  if(cur.has_key(key)):
   s += cur[key]
  s += ","
 s+="\n"
 return s

def convertFile(filename):
 try:
  f = file(filename,'r')
  fout = file("result.csv",'a')
  #fout.writelines("name,sex,age,birthplace\n")
  cur = {}
  s=f.readline()
  tokens = ["名字","性别","年龄","籍贯"]
  
  while len(s) > 0:
   lv = s.split(":",2)
   if(len(lv)!=2):
    s=f.readline()
    continue
   token = lv[0].lower()
   value = lv[1]
   if cur.has_key(token) or len(cur)==len(tokens):
    result = output(cur)
    fout.writelines(result)
    cur = {}
   if token in tokens:
    cur[token] = value.lstrip().rstrip("\n")
   else:
    print "error line"
   s=f.readline()
  if len(cur) > 0:
   result = output(cur)
   fout.writelines(result)
  fout.close();
  f.close()  
 except IOError:
  print "data file not found!"

#main program
if len(sys.argv) != 2:
 print "Usage:python convert.py directory"   
 sys.exit()
  
dirname = sys.argv[1]
try:
 entryList = os.listdir(dirname)
 #remove the result file first and write the header
 fout = file("result.csv",'w+')
 fout.writelines("名字,性别,年龄,籍贯\n")
 fout.close()
 for entry in entryList:
  if os.path.isdir(dirname + "\\" + entry):
   pass
  else:
   convertFile(dirname + "\\" + entry) 
except WindowsError:
 print "Dir not found!" + dirname

测试了一下，发现python干这个效率还不赖，6个数据文件，每个5M，P4 2.8G,大概30s跑完。下面是我的同学实现的C代码(跟上一个例子里同一个人:))

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

#define OUT_FILE  "result.csv"
#define RECORD_MAX_LEN  256
struct _record {
    char name[RECORD_MAX_LEN];
    char sex[RECORD_MAX_LEN];
    char age[RECORD_MAX_LEN];
    char birth[RECORD_MAX_LEN];
    int name_len;
    int sex_len;
    int age_len;
    int birth_len;
};
struct _record record;

static char *token[] = {
    "名字:",
    "性别:",
    "年龄:",
    "籍贯:"
};

static inline int out_record(FILE *out)
{
    //fprintf(stdout, "%s,%s,%s,%s ", record.name, record.sex, record.age, re
cord.birth);
    fwrite(record.name, 1, record.name_len, out);
    fwrite(",", 1, 1, out);
    fwrite(record.sex, 1, record.sex_len, out);
    fwrite(",", 1, 1, out);
    fwrite(record.age, 1, record.age_len, out);
    fwrite(",", 1, 1, out);
    fwrite(record.birth, 1, record.birth_len, out);
    fwrite(" ", 1, 1, out);
    record.name[0] = '

测试结果,比Python快11倍....

所以,Python的速度的确比C要慢得多,这些开销主要来自他的动态类型. 在上一个例子中,体现不明显,
性能就不相上下了.

一段Python程序和C程序的对比

jzhang — Tue, 28 Mar 2006 01:40:00 GMT

VCKbase的论坛上有人提了一个问题：
遇到的问题是，我把E-mail地址收集在txt文件中（每行一个E-mail地址，共78000行），要求是把其中重复的E-mail地址全部去掉。考虑编程方便，我用了CString类，但似乎效率不高。我写出来的整理78000份E-mail地址的需要近7分钟的时间

我给他用Python实现了一个(这个版本是修改过的，当时我随手实现的一个版本做错了，呵呵)
这里算法的主要内容就是利用hash_table来判断email是否已经重复出现，这比字符串的查找要快的多。

#remove duplicated email address from file
import datetime
if __name__ == "__main__":
 t = datetime.datetime(2000,1,1)
 print str(t.today())
 hashtable = {}
 f = file("email.txt","r")
 f2 = file("email_new.txt","w")
 line = f.readline();
 while len(line)>0:
  if not hashtable.has_key(line): 
   hashtable[line] = 1
   f2.write(line)
  line = f.readline();
 f.close()
 f2.close()
 t2 = datetime.datetime(2000,1,1)
 print str(t2.today())

上面的算法在我的机器上：P4 2.8G,512M 内存，耗时大约300ms，跟他的7分钟差了天了。而我当时错误的算法，需要2分半钟，所以我贴到我们内部的BBS上，我的一个同学实现了如下算法(C):

#include 
#include 
#include 
#include "list.h"
#define HASH_SIZE 262157
#define LINE_MAX_LEN 1024
struct list_node {
 struct list_head head;
 int len;
 char *str;
};
struct list_head hash_table[HASH_SIZE];
static inline int
hash_string (const char *ptr, int len)
{
 unsigned int hash = 0;
 
 for (hash = 0; len; len--, ptr++) {
  /* (31 * hash) will probably be optimized to ((hash << 5) - hash). */
  hash = 31 * hash + *ptr;
 }
 
 return (hash % HASH_SIZE);
}
static inline int
cmpfn(const struct list_node *node, int len, char *str)
{
 return ((node->len == len) && (memcmp(node->str, str, len) == 0));
}
int main(int argc, char **argv)
{
 int i, hash, len;
 struct list_node *node;
 char buf[LINE_MAX_LEN];
 FILE *fp_in, *fp_out;
 
 if(argc != 3) {
  printf("error: \nplease use eml as:\n eml infile outfile\n");
  return -1;
 }
 fp_in = fopen(argv[1], "r");
 if(!fp_in) {
  printf("error: could not open infile %s\n", argv[1]);
  return -1;
 }
 fp_out = fopen(argv[2], "w");
 if(!fp_out) {
  printf("error: could not open infile %s\n", argv[2]);
  return -1;
 }
 for(i=0; istr = (char *)malloc(len + 1);
   node->len = len;
   memcpy(node->str, buf, len);
   node->str[len] = '\0';
   list_append(&(hash_table[hash]), node);
  }
 }
 return 0;
}

还有.h文件：

#ifndef _LINUX_LIST_H
#define _LINUX_LIST_H
extern inline void prefetch(const void *x)
{
 return;
}
/*
 * Simple doubly linked list implementation.
 *
 * Some of the internal functions ("__xxx") are useful when
 * manipulating whole lists rather than single entries, as
 * sometimes we already know the next/prev entries and we can
 * generate better code by using them directly rather than
 * using the generic single-entry routines.
 */
struct list_head {
 struct list_head *next, *prev;
};
#define LIST_HEAD_INIT(name) { &(name), &(name) }
#define LIST_HEAD(name) \
 struct list_head name = LIST_HEAD_INIT(name)
#define INIT_LIST_HEAD(ptr) do { \
 (ptr)->next = (ptr); (ptr)->prev = (ptr); \
} while (0)
/*
 * Insert a new entry between two known consecutive entries. 
 *
 * This is only for internal list manipulation where we know
 * the prev/next entries already!
 */
static inline void
__list_add(struct list_head *new,
    struct list_head *prev, struct list_head *next)
{
 next->prev = new;
 new->next = next;
 new->prev = prev;
 prev->next = new;
}
/**
 * list_add - add a new entry
 * @new: new entry to be added
 * @head: list head to add it after
 *
 * Insert a new entry after the specified head.
 * This is good for implementing stacks.
 */
static inline void
list_add(struct list_head *new, struct list_head *head)
{
 __list_add(new, head, head->next);
}
/**
 * list_add_tail - add a new entry
 * @new: new entry to be added
 * @head: list head to add it before
 *
 * Insert a new entry before the specified head.
 * This is useful for implementing queues.
 */
static inline void
list_add_tail(struct list_head *new, struct list_head *head)
{
 __list_add(new, head->prev, head);
}
/*
 * Delete a list entry by making the prev/next entries
 * point to each other.
 *
 * This is only for internal list manipulation where we know
 * the prev/next entries already!
 */
static inline void
__list_del(struct list_head *prev, struct list_head *next)
{
 next->prev = prev;
 prev->next = next;
}
/**
 * list_del - deletes entry from list.
 * @entry: the element to delete from the list.
 * Note: list_empty on entry does not return true after this, the entry is in an undefined state.
 */
static inline void
list_del(struct list_head *entry)
{
 __list_del(entry->prev, entry->next);
 entry->next = (void *) 0;
 entry->prev = (void *) 0;
}
/**
 * list_del_init - deletes entry from list and reinitialize it.
 * @entry: the element to delete from the list.
 */
static inline void
list_del_init(struct list_head *entry)
{
 __list_del(entry->prev, entry->next);
 INIT_LIST_HEAD(entry);
}
/**
 * list_move - delete from one list and add as another's head
 * @list: the entry to move
 * @head: the head that will precede our entry
 */
static inline void
list_move(struct list_head *list, struct list_head *head)
{
 __list_del(list->prev, list->next);
 list_add(list, head);
}
/**
 * list_move_tail - delete from one list and add as another's tail
 * @list: the entry to move
 * @head: the head that will follow our entry
 */
static inline void
list_move_tail(struct list_head *list, struct list_head *head)
{
 __list_del(list->prev, list->next);
 list_add_tail(list, head);
}
/**
 * list_empty - tests whether a list is empty
 * @head: the list to test.
 */
static inline int
list_empty(struct list_head *head)
{
 return head->next == head;
}
static inline void
__list_splice(struct list_head *list, struct list_head *head)
{
 struct list_head *first = list->next;
 struct list_head *last = list->prev;
 struct list_head *at = head->next;
 first->prev = head;
 head->next = first;
 last->next = at;
 at->prev = last;
}
/**
 * list_splice - join two lists
 * @list: the new list to add.
 * @head: the place to add it in the first list.
 */
static inline void
list_splice(struct list_head *list, struct list_head *head)
{
 if (!list_empty(list))
  __list_splice(list, head);
}
/**
 * list_splice_init - join two lists and reinitialise the emptied list.
 * @list: the new list to add.
 * @head: the place to add it in the first list.
 *
 * The list at @list is reinitialised
 */
static inline void
list_splice_init(struct list_head *list, struct list_head *head)
{
 if (!list_empty(list)) {
  __list_splice(list, head);
  INIT_LIST_HEAD(list);
 }
}
/**
 * list_entry - get the struct for this entry
 * @ptr: the &struct list_head pointer.
 * @type: the type of the struct this is embedded in.
 * @member: the name of the list_struct within the struct.
 */
#define list_entry(ptr, type, member) \
 ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
/**
 * list_for_each - iterate over a list
 * @pos: the &struct list_head to use as a loop counter.
 * @head: the head for your list.
 */
#define list_for_each(pos, head) \
 for (pos = (head)->next, prefetch(pos->next); pos != (head); \
         pos = pos->next, prefetch(pos->next))
/**
 * list_for_each_safe - iterate over a list safe against removal of list entry
 * @pos: the &struct list_head to use as a loop counter.
 * @n:  another &struct list_head to use as temporary storage
 * @head: the head for your list.
 */
#define list_for_each_safe(pos, n, head) \
 for (pos = (head)->next, n = pos->next; pos != (head); \
  pos = n, n = pos->next)
/**
 * list_for_each_entry - iterate over list of given type
 * @pos: the type * to use as a loop counter.
 * @head: the head for your list.
 * @member: the name of the list_struct within the struct.
 */
#define list_for_each_entry(pos, head, member)    \
 for (pos = list_entry((head)->next, typeof(*pos), member), \
       prefetch(pos->member.next);   \
      &pos->member != (head);      \
      pos = list_entry(pos->member.next, typeof(*pos), member), \
       prefetch(pos->member.next))
/*this is the begin of listhelp ;-)*/
#define LIST_FIND(head, cmpfn, type, args...)  \
({       \
 const struct list_head *__i = (head);  \
       \
 do {      \
  __i = __i->next;   \
  if (__i == (head)) {   \
   __i = NULL;   \
   break;    \
  }     \
 } while (!cmpfn((const type)__i , ## args)); \
 (type)__i;     \
})
#define LIST_FIND_W(head, cmpfn, type, args...) \
({      \
 const struct list_head *__i = (head); \
      \
 do {     \
  __i = __i->next;  \
  if (__i == (head)) {  \
   __i = NULL;  \
   break;   \
  }    \
 } while (!cmpfn((type)__i , ## args)); \
 (type)__i;    \
})
static inline int
__list_cmp_same(const void *p1, const void *p2)
{
 return p1 == p2;
}
/* Is this entry in the list? */
static inline int
list_inlist(struct list_head *head, const void *entry)
{
 return LIST_FIND(head, __list_cmp_same, void *, entry) !=NULL;
}
/* Delete from list. */
#ifdef CONFIG_NETFILTER_DEBUG
#define LIST_DELETE(head, oldentry)     \
do {         \
 if (!list_inlist(head, oldentry))    \
  printk("LIST_DELETE: %s:%u `%s'(%p) not in %s.\n", \
         __FILE__, __LINE__, #oldentry, oldentry, #head); \
        else list_del((struct list_head *)oldentry);   \
} while(0)
#else
#define LIST_DELETE(head, oldentry) list_del((struct list_head *)oldentry)
#endif
/* Append. */
static inline void
list_append(struct list_head *head, void *new)
{
 list_add((new), (head)->prev);
}
/* Prepend. */
static inline void
list_prepend(struct list_head *head, void *new)
{
 list_add(new, head);
}
/* Insert according to ordering function; insert before first true. */
#define LIST_INSERT(head, new, cmpfn)    \
do {        \
 struct list_head *__i;     \
 for (__i = (head)->next;    \
      !cmpfn((new), (typeof (new))__i) && __i != (head); \
      __i = __i->next);     \
 list_add((struct list_head *)(new), __i->prev);  \
} while(0)
/* If the field after the list_head is a nul-terminated string, you
   can use these functions. */
static inline int
__list_cmp_name(const void *i, const char *name)
{
 return strcmp(name, i + sizeof (struct list_head)) == 0;
}
static inline int
__list_cmp_nameptr(const void *i, const char *name)
{
 return strcmp(name, ((char *)
        *(unsigned long *) (i +
       sizeof (struct list_head)))) ==
     0;
}
/* Returns false if same name already in list, otherwise does insert. */
static inline int
list_named_insert(struct list_head *head, void *new)
{
 if (LIST_FIND(head, __list_cmp_name, void *,
        new + sizeof (struct list_head)))
   return 0;
 list_prepend(head, new);
 return 1;
}
static inline int
list_nameptr_insert(struct list_head *head, void *new)
{
 if (LIST_FIND(head, __list_cmp_nameptr, void *,
        new + sizeof (struct list_head)))
   return 0;
 list_prepend(head, new);
 return 1;
}
/* Find this named element in the list. */
#define list_named_find(head, name)   \
LIST_FIND(head, __list_cmp_name, void *, name)
#define list_nameptr_find(head, name)   \
LIST_FIND(head, __list_cmp_nameptr, void *, name)
#endif

在我的机器上测试(cygwin)：耗时竟然是400ms!
当然，这里包含了Cygwin的间接调用开销。

很难想象吧，Python在这里的性能竟然跟C不相上下！而且Python的代码比C不知道短了多少倍！
所以讲，Python是蛮好用的，:-).
不过，这个例子其实是个特殊情况，以前我们玩过的另外一个程序，C的性能就比Python快得多。不过代码量还是Python简短得多。有兴趣的朋友可以用自己熟悉的语言来测试一下，下面是测试文件(也是我用11行python代码产生的,有1/10的email是重复的)：
这其实是一个rar,下载后请修改扩展名