Falldog的程式戰場

[Python] Lazy initialization

noreply@blogger.com (Falldog) — Thu, 04 Aug 2011 02:53:00 +0000

在寫大型的Project時，應該都會遇到一種痛，就是AP開起來的速度"操級慢"，很多人習慣在一開始就把一些用不到的變數initial起來，不但影響到AP launch的速度，也會讓memory吃得肥茲茲的。

所以就有人嘗試在一開始將變數initial成None，等到要用時再判斷是不是None，是的話再真正的initial這個變數。

不過這種作法，可能會讓code變得稍微複雜一點，參考一下別人的作法，其實有更好的方法來實作這種Lazy Initialization，就是用到Python的decorator+property！

def lazyproperty(func):
    ''' 
    Lazy initialization - Design Pattern
    Implement it by property
    
    Usage - 
        class Foo(object):
            def __init__(self):
                super(Object,self).__init__()
            @lazyproperty
            def sum(self):
                _sum = 0
                for i in range(100):
                    _sum += i
                return _sum
        o = Foo()
        print o.sum
    
    Information -
        the setter raise exception only if the class inhert from object!
    '''
    attr = '_lazy'.join( func.__name__ )
    def get_lazyval(self):
        if not hasattr(self, attr):
            setattr(self, attr, func(self))
        return getattr(self, attr)
    def set_lazyval(self, v):
        raise AttributeError('The lazy property is read-only')
    return property(get_lazyval, set_lazyval)

透過這個方式，等到get這個instance的變數時，才會執行init function裡的事，只是，如果希望set有exception的話，必須要讓class繼承object才有基本property的功能。

Reference :

StackOverflow - Python lazy property decorator
Design Pattern - Wiki - Lazy initialization

[Python] 取得Python object的reference count

noreply@blogger.com (Falldog) — Tue, 12 Apr 2011 02:13:00 +0000

在Python的世界裡，每個變數都是一個object，而且每個object會有一個reference count去記錄被reference幾次，一但這個值變0時，這個object才會真正被delete掉。

在Python的sys module裡，提供了一個API getrefcount()可以取得一個object的reference count是多少，回傳值是數字，而且回傳值應該會比你預期的值還要高，這是因為object在傳進getreference()時，reference count就會偷偷加一了。

看到下面的範例，a是一個Test的instance，reference count跟預期一樣是2(一個link到a，一個link到getrefcount的temporarily的變數)，而b是一個list的instance，結果跟a一樣。

不過c跟d是一個string object，Python底層將c跟d link到同一個instance，所以在d='a'之後，c的reference count再加1。不過數字為何這麼地高，猜測應該是Python底層有自己去cache這些string object吧。

import sys

class Test:
    def __init__(self, v):
        self.v = v
a = Test(0)
print id(a), sys.getrefcount(a)
#>>> 19119440 2

b = list()
print id(b), sys.getrefcount(b)
#>>> 19135064 2

c = 'a'
print id(c), sys.getrefcount(c)
#>>> 18765728 18
d = 'a'
print id(c), sys.getrefcount(c)
#>>> 18765728 19
print id(d), sys.getrefcount(d)
#>>> 18765728 19

---
題外話，研究一下Python的source code，
在CPython裡，每個PyObject都有一個記reference count的變數，此變數為ob_refcnt。所以可以自己寫一個get reference count的function。寫在c/c++ code裡，然後用SWIG轉成python module，取得Python object正確的reference count。

int GetReferenceCount(PyObject *obj)
{
    return obj ?  obj->ob_refcnt : 0;
}

[Python] 實作一個PriorityQueue 與有pause, resume 功能的PriorityTaskThread

noreply@blogger.com (Falldog) — Tue, 12 Apr 2011 01:33:00 +0000

由於project是用Python2.5，要用到PriorityQueue，但是Python2.6以後才支援PriorityQueue，所以就想說寫個來試試。主要是改寫自Python原有的Queue class，繼承了原有的access blocking的feature，將原本的put改用insert與append，讓有相同priority的task能有先後之分。

PriorityQueue

from __future__ import with_statement

from Queue import Queue
import bisect
from time import time as _time

_DefaultCheckDup = lambda x,y: bool(x==y)

class PQTask(object):
    """ Data structure of task, for PriorityQueue internal use. """
    def __init__(self, pri=0, item=None):
        object.__init__(self)
        self.pri = pri
        self.item = item
    def __cmp__(self, b):
        return cmp(self.pri, getattr(b, 'pri', 0))
    
class PriorityQueue(Queue):
    """
    PriorityQueue, support reorder the task in queue with priority.
    
    insert() : the task will be processed first in the same priority
    append() : the task will be processed later in the same priority
    - checkdup specified
        1. True : check by _DefaultCheckDup()
        2. callable function : check by this function
    If checkdup is specified,
    _put() will try to kill original task in queue then add new task(with last priority)
    """
    def __init__(self, maxsize=0):
        Queue.__init__(self, maxsize)
    
    # remove the default put function, replace it by _append(), _insert()
    def put(self, item, block=True, timeout=None):
        raise NotImplementedError
    def put_nowait(self, item):
        raise NotImplementedError
    
    def clear(self):
        """ clear all task in queue """
        with self.mutex:
            self.queue = list()
    
    def insert(self, priority, item, checkdup=None, block=True, timeout=None):
        """insert into the queue in the same priority."""
        self.__put(False, priority, item, checkdup, block, timeout)
    def insert_nowait(self, priority, item, checkdup=None):
        """insert item into the queue without blocking."""
        self.__put(False, priority, item, checkdup, False)
        
    def append(self, priority, item, checkdup=None, block=True, timeout=None):
        """append item into the queue in the same priority."""
        self.__put(True, priority, item, checkdup, block, timeout)
    def append_nowait(self, priority, item, checkdup=None):
        """append item into the queue without blocking."""
        self.__put(True, priority, item, checkdup, False)
    
    def __put(self, append, priority, item, checkdup=None, block=True, timeout=None):
        """ reference & modify from Queue::put(), 
            for add custom parameter into _put() """
        self.not_full.acquire()
        try:
            if not block:
                if self._full():
                    raise Full
            elif timeout is None:
                while self._full():
                    self.not_full.wait()
            else:
                if timeout < 0:
                    raise ValueError("'timeout' must be a positive number")
                endtime = _time() + timeout
                while self._full():
                    remaining = endtime - _time()
                    if remaining <= 0.0:
                        raise Full
                    self.not_full.wait(remaining)
            
            #add into queue
            self._put(append, priority, item, checkdup)
            
            self.unfinished_tasks += 1
            self.not_empty.notify()
        finally:
            self.not_full.release()
            
    # Initialize the queue representation
    def _init(self, maxsize):
        self.maxsize = maxsize
        
        #the last item is highest priority
        # queue : [ low priority -> high priority ]
        # get() will try to get last item to process
        self.queue = list()
    
    # put task into queue
    def _put(self, append, p, item, checkdup):
        """ if checkdup is set, check the task is duplicate in queue before add """
        if checkdup:
            if not callable(checkdup):
                checkdup = _DefaultCheckDup
            for idx, qt in enumerate(self.queue):
                if checkdup(qt.item, item):
                    # remove original and add new task in new priority
                    del self.queue[idx]
                    break
        t = PQTask(p, item)
        if append:
            bisect.insort_left(self.queue, t)
        else:
            bisect.insort_right(self.queue, t)
    
    # Get an item from the queue
    def _get(self):
        return self.queue.pop() #get the last(priority largest) task

既然有了PriorityQueue了，就可以用這個class去實作一個PriorityThread了。
並實作了pause, resume與stop的功能，在測試了很多次後，應該是不會有deadlock啦，有的話請告訴我...XD
PriorityThread

from __future__ import with_statement

import threading
import time

SUPER_PRIORITY = 9999

class PriorityThread(threading.Thread):
    """
    PriorityThread, support pause, resume and blocking priority queue
    
    Please overwrite processTask() to do sometime when get task
    follow the feature of PriorityQueue, insertTask() & appendTask()
    should pass the correct priority into queue
    """
    def __init__(self, daemon=None):
        threading.Thread.__init__(self)
        
        self.queue = PriorityQueue()
        
        self.wait     = threading.Condition(threading.Lock()) #wait when pauseEvt is set
        self.pauseEvt = threading.Event()
        self.stopEvt  = threading.Event()
        
        if daemon is not None:
            self.setDaemon(daemon)
        
    def pause(self):
        with self.wait:
            self.pauseEvt.set()
            if self.queue.empty():
                #thread is bolcing in queue.get(), put a None task
                self.insertTask(SUPER_PRIORITY, None)
                
    def resume(self):
        with self.wait:
            self.pauseEvt.clear()
            self.wait.notify()
            
    def stop(self, timeout=None):
        self.stopEvt.set()
        with self.wait:
            self.pauseEvt.clear()
            self.wait.notify()
            if self.queue.empty():
                #thread is bolcing in queue.get(), put a None task
                self.insertTask(SUPER_PRIORITY, None)
        self.join(timeout)
        
    def insertTask(self, priority, item, *argv, **argd):
        self.queue.insert(priority, item, *argv, **argd)
        
    def appendTask(self, priority, item, *argv, **argd):
        self.queue.append(priority, item, *argv, **argd)
    
    def clearTask(self):
        self.queue.clear()
    
    def lenTask(self):
        return self.queue.qsize()
    
    def emptyTask(self):
        return self.queue.empty()
    
    def run(self):
        print '[PriorityThread] %s run()' % (type(self).__name__)
        self.onThreadBegin()
        
        while not self.stopEvt.isSet():
            with self.wait:
                if self.pauseEvt.isSet():
                    self.wait.wait()
                    continue
                    
            t = self.queue.get()
            if t.item:
                self.processTask(t.pri, t.item)
            
            time.sleep(0.01)
            
        self.onThreadEnd()
        print '[PriorityThread] %s end of run()' % (type(self).__name__)
    
    ##############################################
    # Overwriteable function
    ##############################################
    def onThreadBegin(self):
        """ overwrite this function for process something before thread.run() """
        pass
        
    def onThreadEnd(self):
        """ overwrite this function for process something after thread.run() """
        pass
    
    def processTask(self, priority, item):
        """ overwrite this function for process task """
        pass

以下是我的TestCase

if __name__ == '__main__':
    ####################################
    #        Test PriorityQueue        #
    ####################################
    def TestQueue():
        print '@TestQueue'
        q = PriorityQueue()
        q.insert(0, 'a')
        q.insert(1, 'b')
        q.insert(2, 'c')
        q.insert(3, 'd')
        q.append(3, 'e')
        q.insert(3, 'f')
        q.insert(1, 'b')
        q.insert(0, 'a')
        while not q.empty():
            print q.get().item
    
    def TestQueue_CheckDup():
        print '@TestQueue_CheckDup'
        q = PriorityQueue()
        q.insert(0, 'a', checkdup=True)
        q.insert(1, 'a', checkdup=True)
        q.insert(2, 'a', checkdup=True)
        q.insert(0, 'b', checkdup=True)
        q.insert(1, 'b', checkdup=True)
        #>>> the queue result : [ (1, b), (2, a) ]
        while not q.empty():
            t = q.get()
            print t.pri, t.item
            
    def TestQueue_CheckDupCustomTask():
        ''' Custom _Item, and custom checkdup function '''
        print '@TestQueue_CheckDupCustomTask'
        class _Item:
            def __init__(self, v):
                self.val = v
        def _checkdup(x,y):
            return bool(x.val == y.val)
        q = PriorityQueue()
        q.insert(0, _Item('a'), checkdup=_checkdup)
        q.insert(1, _Item('a'), checkdup=_checkdup)
        q.insert(2, _Item('a'), checkdup=_checkdup)
        q.insert(0, _Item('b'), checkdup=_checkdup)
        q.insert(1, _Item('b'), checkdup=_checkdup)
        #>>> the queue result : [ (1, b), (2, a) ]
        while not q.empty():
            t = q.get()
            print t.pri, t.item.val
    
    TestQueue()
    TestQueue_CheckDup()
    TestQueue_CheckDupCustomTask()
    
    
    ###################################
    #       Test PriorityThread       #
    ###################################
    class MyPriorityThread(PriorityThread):
        def processTask(self, pri, item):
            print item
    
    def TestThread_PauseFirst(t):
        t.pause()
        for v in xrange(100):
            t.appendTask(0, v)
        time.sleep(3)
        t.resume()
        time.sleep(10)
        
    def TestThread_Normal(t):
        for v in xrange(100):
            t.appendTask(0, v)
        time.sleep(0.1)
        t.pause()
        for v in xrange(100, 200):
            t.appendTask(0, v)
        time.sleep(0.1)
        t.resume()
        
        for v in xrange(200, 30000):
            t.appendTask(0, v)
        time.sleep(0.1)
        
    def TestThread_PauseResume(t):
        for v in xrange(10000):
            t.appendTask(0,v)
        time.sleep(0)
        
        while not t.emptyTask():
            import thread
            thread.start_new_thread(lambda t:t.pause(), (t,))
            thread.start_new_thread(lambda t:t.resume(), (t,))
            time.sleep(1)
            
    def TestThread_Control(t):
        print '\n\n=== Command control thread ===\ni:initial and add large task \np:pause, \nr:resume \ns:stop \na:add tasks '
        t.pause()
        
        count = 0
        while not t.emptyTask():
            cmd = raw_input()
            cmd = cmd.strip()
            if cmd == 'i':
                t.resume()
                [ t.appendTask(0,c) for c in range(count, count+5000) ]
                count += 5000
            if cmd == 'p':
                t.pause()
            elif cmd == 'r':
                t.resume()
            elif cmd == 'a':
                [ t.appendTask(0,c) for c in range(count, count+100) ]
                count += 100
                print 'current task count = %d, largets task = %d' % (t.lenTask(), count)
            elif cmd == 's':
                t.stop()
                break
        
    t = MyPriorityThread()
    t.start()
    
    #TestThread_Normal(t)
    #TestThread_PauseFirst(t)
    #TestThread_PauseResume(t)
    TestThread_Control(t)
    
    t.stop()
    
    print 'Please press enter to continue...'
    raw_input()

[Python] Hook stdout後 print會出現 UnicodeDecodeError

noreply@blogger.com (Falldog) — Thu, 07 Apr 2011 07:28:00 +0000

在Python裡，字串的表達方式分為兩種，一種是常見的ansi string："abc"，另一種則是unicode：u"abc"，而OS在秀出文字到window上時，其實都會轉換到使用者設定的code page後才秀出來的。簡單來說，繁體中文有一個對應的code page(cp950)，簡體中文也有個對應的code page(cp936)，如果一個unicode的字串參考錯誤的code page轉換出來的字串就有可能會變成亂碼了。

如果有hook stdout的需求的話，通常會把sys.stdout指向自行定義的objecct身上，以下這個範例是實作一個HookStdOut，將output string重新導向stdout與debug message

import sys
class HookStdOut(object):
    def __init__(self, *argv, **argd):
        object.__init__(self)
        
    def write(self, s):
        import ctypes
        if isinstance(s, unicode):
            ctypes.windll.kernel32.OutputDebugStringW(s)
        else:
            ctypes.windll.kernel32.OutputDebugStringA(s)
        sys.__stdout__.write(s)

sys.stdout = HookStdOut()
s = unichr(0x5927) + unichr(0x5BB6) + unichr(0x597D) #in cp950 (大, 家, 好)
try:
    print s
except:
    import traceback
    traceback.print_exc()

但是這個方法如果在print unicode時，就會有exception出現 UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-2: ordinal not in range(128)
這是因為Python在print unicode到stdout前，會試著把unicode以console code page做encode的動作，再write到stdout。而現在stdout是我們自行定義的HookStdOut，最後write到stdout時，只會以ascii的方式encode，然後就會出現UnicodeEncodeError了。

研究了一下Python的source code...
Python\sysmodule.c

PyObject *
_PySys_Init(void)
{
    //...
    sysout = PyFile_FromFile(stdout, "<stdout>", "w", _check_and_flush);
    //...
    if(isatty(_fileno(stdout)) && PyFile_Check(sysout)) {
        sprintf(buf, "cp%d", GetConsoleOutputCP());
        if (!PyFile_SetEncoding(sysout, buf))
            return NULL;
    }
    //...
}

Objects\fileobject.c

int
PyFile_WriteObject(PyObject *v, PyObject *f, int flags)
{
    PyObject *writer, *value, *args, *result;
    if (f == NULL) {
        PyErr_SetString(PyExc_TypeError, "writeobject with NULL file");
        return -1;
    }
    else if (PyFile_Check(f)) {
        FILE *fp = PyFile_AsFile(f);
#ifdef Py_USING_UNICODE
        PyObject *enc = ((PyFileObject*)f)->f_encoding;
        int result;
#endif
        if (fp == NULL) {
            err_closed();
            return -1;
        }
#ifdef Py_USING_UNICODE
                if ((flags & Py_PRINT_RAW) &&
            PyUnicode_Check(v) && enc != Py_None) {
            char *cenc = PyString_AS_STRING(enc);
            value = PyUnicode_AsEncodedString(v, cenc, "strict");
            if (value == NULL)
                return -1;
        } else {
            value = v;
            Py_INCREF(value);
        }
        result = PyObject_Print(value, fp, flags);
        Py_DECREF(value);
        return result;
#else
        return PyObject_Print(v, fp, flags);
#endif
    }
    //...
}

在Python default的sys.stdout，其實是一個FileObject，會以Windows API GetConsoleCP()將console code page 記錄在f_encoding這個變數裡，等到print時會call進PyFile_WriteObject()，如果要print的PyObject *v是PyUnicode的話，會先將PyUnicode以f_encoding做encode，然後再print出去。

而我們實作了一個HookStdOut，但是我們並沒有指定它的encoding是什麼，所以default是ascii，在嘗試print unicode時，就會出現exception了。所以，我們必須要在write()裡自己encode到正確的code page才不會有這個exception出現。
正確版的範例：

import sys
class HookStdOut(object):
    def __init__(self, *argv, **argd):
        object.__init__(self)
        self.encoding = sys.getfilesystemencoding()
    def write(self, s):
        import ctypes
        if isinstance(s, unicode):
            ctypes.windll.kernel32.OutputDebugStringW(s)
            sys.__stdout__.write(s.encode(self.encoding)) #try to encode the unicode to default file system encoding
        else:
            ctypes.windll.kernel32.OutputDebugStringA(s)
            sys.__stdout__.write(s)

sys.stdout = HookStdOut()
s = unichr(0x5927) + unichr(0x5BB6) + unichr(0x597D) #in cp950 (大, 家, 好)
try:
    print s
except:
    import traceback
    traceback.print_exc()

其實還有另一個方法可以避掉UnicodeEncodeError的exception，但是並不建議這麼做。

class HookStdOut(object):
    def __init__(self, *argv, **argd):
        object.__init__(self)
        
    def write(self, s):
        import ctypes
        if isinstance(s, unicode):
            ctypes.windll.kernel32.OutputDebugStringW(s)
        else:
            ctypes.windll.kernel32.OutputDebugStringA(s)
        sys.__stdout__.write(s)

#reset default encoding!!!
reload(sys)
sys.setdefaultencoding(sys.getfilesystemencoding())

sys.stdout = HookStdOut()
s = unichr(0x5927) + unichr(0x5BB6) + unichr(0x597D) #in cp950 (大, 家, 好)
try:
    print s
except:
    import traceback
    traceback.print_exc()

由於在Python2.5的site.py將sys.setdefaultencoding remove掉了，所以必須要reload sys module，然後再setdefaultencoding一次才行。
但是參考一下這篇文章，setdefaultencoding is evil，我想，在小程式裡可能可以用setdefaultencoding的方式解掉，但如果是大型的project的話，並非所有的unicode會用相同的encoding，所以還是避免用這樣的方式比較好。

延伸閱讀

[emomeDDSMS] 下載emome上的備份簡訊更新0.73

noreply@blogger.com (Falldog) — Tue, 21 Dec 2010 17:22:00 +0000

應觀眾要求，新增功能，輸出傳送簡訊的號碼與通訊錄的暱稱。
下載連結(按右鍵另存新檔)：emomeDDSMS 0.73 (2010/12/22)
Change Log：
1. Add output phone number and nick name function - GetPhoneBook() and ConvertPhonelist()

使用說明，請參考前一篇文章。

[emomeDDSMS] 下載emome上的備份簡訊更新0.72

noreply@blogger.com (Falldog) — Tue, 28 Sep 2010 14:50:00 +0000

因應emome網頁些許的更新與問題，emomeDDSMS也要稍作修改。
下載連結(按右鍵另存新檔)：emomeDDSMS 0.72 (2010/9/28)
Change Log：
1. emome browse sms page changed, 'from' action changed to 'POST', modify related url actions.
2. Add ResetPage() mechanism for emome website issue, sometimes can't browse normal
3. Add description, suggest to download file to D disk

使用說明，請參考前一篇文章。

[SudokuBoxer] Project 轉移至 SourceForge

noreply@blogger.com (Falldog) — Tue, 11 May 2010 17:14:00 +0000

一開始將 Project 放在Google code，連線至SVN的速度還不錯，介面操作很陽春，但是也很方便。不過使用了一陣子後，發現放在上面供人下載的檔案，下載次數有著砂鍋大的問題，不管下載幾次，次數都不會增加，這樣子的結果實在令人傷心…到Google code的論壇發問，才知道原來這個 issue 已經 create 出來很久了，早在2009/12時就已經存在了，但是到現在還沒修好，這效率著實令人吃驚。

所以，才將 Project 轉移至 SourceForge，應該是之前有開過 Project 的關係，開新 Project 時也不需要審核，而且開新 Project 的步驟與介面也不像之前讓人退避三舍。上傳檔案的部分也有很大的進步(以前一定要在command line底下上傳才行)，現在只要在網頁上東按西按就可以上傳了。重點是 Download 次數的統計實在比Google code來得好多了。

有興趣的人可以下載來玩玩，更新了不少東西 :)

[SudokuBoxer] wxPython 實作Sudoku GUI Game

noreply@blogger.com (Falldog) — Thu, 25 Mar 2010 12:05:00 +0000

前一陣子利用空閒時間練習了一下wxPython，順便寫了一個Sudoku的小遊戲，想說完成的話，可以給我媽玩一下。

目前的功能還很陽春，不過至少題目的難易度滿正確的，在產生正確的題目上費了不少功夫，曾經嘗試過連到某Sudoku網頁去解析題目網頁的html語法，然後再儲存到DB裡，可是這招實在是太sucks了，抓不到50題，就被擋IP了 XD (看來是sleep的間隔時間不夠長.... ) 後來還找了一些tool來產生題庫，但是效果都不盡理想，不是題目有問題，就是題目難易度不均。

後來終於找到一個 Sudoku 產生題庫的 tool，跟一個可以幫題目打分數的 tool。雙管其下的結果還算讓人滿意。

Sudoku Importer - 以挖洞法產生sudoku題庫，所以必須餵入題目挖洞的template
Sudoku Explainer - 一個強大的Java GUI Sudoku軟體，可以教你怎麼一步步解題，以及解題所需要的技巧，最重要的是可以餵給它題目，然後產生該sudoku的難度分數以及解題所需要的技巧。
改天再寫一篇介紹怎麼用這兩個 tool 吧。

SudokuBoxer遊戲畫面

SudokuBoxer是用wxPython實作的，可惜的就是執行檔大了一點，壓縮完後竟然還要5MB，沒壓縮也要15MB，真是誇張。

這也是我第一次用wxPython，第一次自己動手用 gettext 作 Multi-Language，程式還有很多功能沒完成，不過應該是不會輕易當掉啦，呵。想說弄到一個段落就放上來Share給大家一下。Python上手後，真的是快速開發的好物啊！

可惜 wxPython(wxWidgets) 在繪圖上的功能過於陽春，連 Texture 之間的 Alpha Blending 功能都沒有，不過wxWidgets可以貼OpenGL的Canvas上去，應該可以補足這一塊，但還要花時間學OpenGL就是了，大學學過都還給老師了....

[emomeDDSMS] 下載emome上的備份簡訊更新0.71

noreply@blogger.com (Falldog) — Sun, 21 Mar 2010 16:02:00 +0000

因應emome網頁些許的更新，emomeDDSMS也要稍作修改。
下載連結：emomeDDSMS 0.71 (2010/3/21)
Change Log：
1. Modify login.js path in Login()
2. Modify @name to @user_name, because unknow Chickenfoot issue to use parameter @name.

使用說明，請參考前一篇文章。

[wxPython] 實作多國語言MUI by GetText

noreply@blogger.com (Falldog) — Fri, 26 Feb 2010 09:38:00 +0000

wxPython提供了方便的支援多國語言API，結合GNU GetText project，使用上很是方便。
由GetText parse 檔案後，建出PO檔然後轉成MO檔，就可以給wxPython讀取使用。

首先，先撰寫wxPython的code

#!/usr/bin/python

import wx
_ = wx.GetTranslation

class Translation(wx.Frame):
    def __init__(self, parent, id, title):
        wx.Frame.__init__(self, parent, id, title, size=(220, 100))

        panel = wx.Panel(self, -1)

        wx.StaticText(panel, -1, _("Hello"), (10, 10))
        
        self.Centre()
        self.Show(True)

app = wx.App()

mylocale = wx.Locale()
mylocale.AddCatalogLookupPathPrefix('.')
mylocale.AddCatalog('CHT') #Use CHT.mo

Translation(None, -1, 'Translation')
app.MainLoop()

執行畫面

使用 wx.Locale 的 AddCatalog()，wxPython就會去搜尋目前的目錄、系統目錄，或是透過AddCatalogLookupPathPrefix()指定的路徑。
然後將 wx.GetTranslation 指定成 _ ，這樣子我們只要對想翻譯的字串"Hello"改成_("Hello")就可以了。
Tip: GetText建立PO檔時，只會針對_("")裡面的字串做處理。

接下來必須下載 GetText 的 Tool 才能建立翻譯字串所需的PO檔跟MO檔。

GNU GetText home page
GNU GetText for Windows下載連結，選擇Complete package, except sources，下載後安裝，就會幫你把一切的 dependency 搞定了。

安裝完GetText之後，就有一些執行檔可以使用了，以下介紹幾個最需要用到的：

xgettext.exe

將 input 檔案內的翻譯字串收集後，儲存成PO檔。
xgettext [option] [inputfile] ...
'inputfile ...' : 處理此file
'-f file', '--files-from=file' ：處理file內的儲存的file name
'-d name', '--default-domain=name' ：輸出檔名為name.po

因此，我將上面的wxPython檔案存為test.py

xgettext  --default-domain=test  test.py

之後就會輸出一個test.po的檔案，檔案的內容為下列

# SOME DESCRIPTIVE TITLE.
# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
# This file is distributed under the same license as the PACKAGE package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2010-02-26 16:31+0800\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=CHARSET\n"
"Content-Transfer-Encoding: 8bit\n"

#: ..\test.py:12
msgid "Hello"
msgstr ""

現在就可以修改 test.po 檔，可以在裡面打入想翻譯的字串，比如將"Hello"翻譯成中文，儲存成CHT.po，將"Hello"翻譯成英文，儲存成ENU.po。
通常翻譯成非英文的語言，就要將PO檔的 encoding 方式改成UTF-8的格式儲存，才能正確存取。所以要將檔案轉成UTF-8編碼(可以用Notepad++，轉成UTF-8檔首無BOM)，然後改"Content-Type: text/;lain; charset=CHARSET\n"，將CHARSET改成utf-8。

# SOME DESCRIPTIVE TITLE.
# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
# This file is distributed under the same license as the PACKAGE package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2010-02-26 16:31+0800\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n" #charset
"Content-Transfer-Encoding: 8bit\n"

#: ..\test.py:12
msgid "Hello"
msgstr "哈囉~"

msgmerge.exe

將兩個PO檔，進行Merge的動作，通常是用在PO檔更新時。
msgmerge [option] def.po ref.po
'def.po' ：原本已經翻譯過的PO檔
'ref.po' ：新建立好的PO檔
'-U', '--update' ：如果def.po已經是最新的，就不做事
所以，假如我們在test.py裡，加了一個新字串_("Sudoku")後，先執行xgettext產生新的PO檔，再執行msgmerge做merge的動作

xgettext  --default-domain=test_new  test.py
msgmerge  --update test.po  test_new.po

msgfmt.exe

將PO檔轉成MO檔
msgfmt [option] filename.po
'- o file', '--output-file=file' ：指定輸出的檔名

msgfmt  --output-file=CHT.mo  test.po

最後，就將中文翻譯的CHT.mo放在test.py檔同個目錄下，執行後應該就會顯示中文了。

執行畫面

[Windows] Local time 轉 UTC

noreply@blogger.com (Falldog) — Tue, 22 Dec 2009 02:33:00 +0000

Window提供了 API 可以轉換時間的時區。

TzSpecificLocalTimeToSystemTime：Local time -> UTC
SystemTimeToTzSpecificLocalTime ：UTC -> Local time

第一個參數可指定 TIME_ZONE_INFORMATION，如果傳進 NULL 的話，即代表目前系統使用的Time Zone。

SYSTEMTIME ConvertLocalTime2UTC(UINT year, UINT month, UINT day, UINT hour, UINT minute, UINT second)
{
    SYSTEMTIME local, utc;
    ZeroMemory(&local, sizeof(local));
    local.wYear   = year;
    local.wMonth  = month;
    local.wDay    = day;
    local.wHour   = hour;
    local.wMinute = minute;
    local.wSecond = second;
    TzSpecificLocalTimeToSystemTime( NULL, &local, &utc );
    printf("UTC Time  =%d/%d/%d %d:%d:%d\n", utc.wYear, utc.wMonth, utc.wDay, utc.wHour, utc.wMinute, utc.wSecond);
    printf("Local Time=%d/%d/%d %d:%d:%d\n", local.wYear, local.wMonth, local.wDay, local.wHour, local.wMinute, local.wSecond);
    return utc;
}

SYSTEMTIME ConvertUTC2LocalTime(UINT year, UINT month, UINT day, UINT hour, UINT minute, UINT second)
{
    SYSTEMTIME local, utc;
    ZeroMemory(&utc, sizeof(utc));
    utc.wYear   = year;
    utc.wMonth  = month;
    utc.wDay    = day;
    utc.wHour   = hour;
    utc.wMinute = minute;
    utc.wSecond = second;
    SystemTimeToTzSpecificLocalTime( NULL, &utc, &local );
    printf("UTC Time  =%d/%d/%d %d:%d:%d\n", utc.wYear, utc.wMonth, utc.wDay, utc.wHour, utc.wMinute, utc.wSecond);
    printf("Local Time=%d/%d/%d %d:%d:%d\n", local.wYear, local.wMonth, local.wDay, local.wHour, local.wMinute, local.wSecond);
    return local;
}

Reference：

[Win32 API] String Conversion

noreply@blogger.com (Falldog) — Fri, 11 Dec 2009 17:35:00 +0000

在Windows底下做字串轉換其實還滿簡單的，在MFC的Library裡，提供了一些簡單的Marco可以用，就可以針對wstring, string, CComBSTR, BSTR之間做轉換了。需 Include AtlBase.h, AtlConv.h

以下是 ATL7.0 版 Marco、Class的命名規則

CSourceType2[C]DestinationType[EX]

以下是 ATL3.0 舊版 Marco的命名規則

SourceType2[C]DestinationType[EX]

SourceType or DestinationType包含了A, W, T, OLE可使用，Ex: A2W, W2T, T2OLE...

新舊版的命名規則差異只有開頭有沒有C，結果有沒有EX。新版的C開頭代表跟舊版的Marco不一樣，而是以Class去實作的。Ex: A2W, W2A是Marco，CA2W, CW2A則是Class。
[C] : 中間的C可有可無，代表著DestinationType是否為 const 的字串。
[EX] : 新版的EX表示，可指定Class所使用的Buffer size。Ex: CA2W<64>

既然有新版的，當然是用新的好啊，因為用舊版的在使用前，必須手動加一個Marco : USES_CONVERSION才能正常Work。舊版是吃stack的memory，一定要等function離開後才會release。

範例：
[錯誤!] 將ANSI的字串轉成Unicode字串

LPSTR name = "Falldog"; 
LPWSTR wstr = CA2W(name);
//Use wstr....

這樣子的寫法，在 ATL3.0 使用A2W是可以work的，但是在 ATL7.0 的版本中，CA2W是一個class，所以意義上會變得不太一樣。
將上面的範例做慢動作解析：

LPSTR name = "Falldog"; 
LPWSTR wstr;
{
    CA2W temp(name);
    wstr = temp.operator LPWSTR(); 
}
//Use wstr.... but memory stored in temp is destroyed...

//再把上面的有問題的地方轉成平常可能看到的畫面
LPWSTR my_func_CA2W( /*LPSTR ansi*/)
{
    WCHAR* temp = L"Falldog";
    return temp;
}
LPWSTR wstr = my_func_CA2W();
//Use wstr....

下半部出現的問題是，當 my_func_CA2W 將 temp return 回來後，其實儲存字串內容的 memory 就已經被 release 掉了，所以當去 access wstr 時，就會有 exception 了。
而上半部跟下半部的問題是一樣的，當你 create 了一個CA2W的object，但是卻把它 assign 給一個 pointer，而 CA2W 的 life scope 在 assign 給 pointer 之後就結束了。當然使用者再使用 wstr 後，會出現 exception。

[正解1] 將ANSI的字串轉成Unicode字串 (可重複使用轉換後字串)

LPSTR name = "Falldog"; 
CA2W wstr(name);
//Use wstr...

[正解2] 將ANSI的字串轉成Unicode字串 (只用一次, ~~射後不理~~)

LPSTR name = "Falldog"; 
wprintf( L"User Unicode Name=%s", CA2W(name) );

Reference : [MSDN] ATL and MFC String Conversion Macros

[Python] 對以Dictionary or Class為item的List做Sort

noreply@blogger.com (Falldog) — Wed, 28 Oct 2009 06:20:00 +0000

Python中的List提供了sort的function，所以可以輕易地對以基本type為item( ex: [5,1,2,6,7] )的List做sort。但是如果List裡的item是Dictionary或是Class type，該如何做sort!?

sort的definition為 sort( [cmp [, key [, reverse ] ] ] )

cmp : User可指定compare的function
key : User可指定compare的key function
reverse: reverse sort

對Dictionary type做sort
以下為範例

d= [ {'id':0, 'value':9}, {'id':1, 'value':100}, {'id':5, 'value':99}, {'id':3, 'value':19}, {'id':2, 'value':59} ]
d.sort(key=lambda x:x['id']) #針對key 'id' 做sort
d.sort(key=lambda x:x['value']) #針對key 'value' 做sort

#以下用cmp，可以達到上面指定key的效果
d.sort(cmp=lambda x,y: cmp(x['id'], y['id']))
d.sort(cmp=lambda x,y: cmp(x['value'], y['value']))

對Class type做sort
以下為範例

class data:
    def __init__(self, _id, _value):
        self.id    = _id
        self.value = _value
c = [ data(0,9), data(1,100), data(5,99), data(3,19), data(2,59) ]
c.sort(key=lambda x:x.id)#針對class member id 做sort
c.sort(key=lambda x:x.value)#針對class member value 做sort

#以下用cmp，可以達到上面指定key的效果
c.sort(cmp=lambda x,y: cmp(x.id, y.id) )
c.sort(cmp=lambda x,y: cmp(x.value, y.value))

[emomeDDSMS] 下載emome上的備份簡訊

noreply@blogger.com (Falldog) — Sun, 16 Aug 2009 01:19:00 +0000

由於個人需求，想把過去emome上傳送的簡訊備份下來，所以寫了這個小程式。

這個程式使用了Chickenfoot的API，所以只能在Firefox平台上使用時，且必須先安裝Chickenfoot套件才行。
Chickenfoot其實就是個在Firefox上，可即時運行script檔的套件，所以使用了Chickentfoot的API再加上了一些Javascript的程式，整個功能瞬時就變得很強大了，可以想對網頁做什麼就做什麼！(很厲害，但是也還沒到無敵啦XD)。簡單來說，就是執行Chickenfoot後，可以代替你的滑鼠+鍵盤處理一些重複的動作。也是之前同事告訴我可以用這個來自動接收開心農場的禮物，很方便滴。(中了開心農場的毒了Orz...)

只是，Chickenfoot只是針對目前的網頁結果作處理而已，如果網頁大改版的話，程式可能也要大改版了.... XD

環境：
由於Chickenfoot尚未支援Firefox 4, 所以請安裝Firefox 3.6的版本
個人平台為Firefox 3.6.1，測試正常

執行步驟：
1. 下載emomeDDSMS.js (version: 0.7)
2. 在Firefox上安裝Chickenfoot套件
3. 按F8，開啟Chickenfoot視窗 (會出現在左手邊 )
4. 按Open鍵，開啟舊檔，點選下載好的emomeDDSMS.js
5. 修改emomeDDSMS裡面的參數(包括：帳號，密碼，輸出檔案路徑，從最新/最舊的開始下載)
5. 按綠色的執行鍵，開始執行！

版本更新：

[Python] range() 與 xrange()的比較

noreply@blogger.com (Falldog) — Thu, 09 Jul 2009 02:03:00 +0000

在Python中提供了range() function，可以建立出一個數字 list 。
Ex:

range(1, 10)
#>>> [1, 2, 3, 4, 5, 6, 7, 8, 9]

range(1, 10, 2)
#>>> [1,  3, 5, 7, 9]

而且range() 可以拿到for loop使用，因為return的值是一個 list，所以是可以被for loop接受的參數。
Ex:

for i in range(1, 10)
    print i,
#>>> 1 2 3 4 5 6 7 8 9

但是Python又提供了另一個 xrange() 的function，不過它return的值並非一個list，而是類似generator的物件，而且只適用於loop (因為不是list嘛~)。
所以xrange跟range最大的差別就是：
1. range 是全部產生完後，return一個 list 回來使用。
2. xrange 是一次產生一個值，並return一個值回來，所以xrange只適用於loop。

所以在效能上，處理完一次的 loop 後，range 跟 xrange 是差不多的，但是如果 loop 裡面有break 的機會，那麼，使用 xrange 是會比較省時的。如果一定要跑完全部的 loop 的話，用range 應該是比較好的。

Ex:

for i in range(1, 10) :
    print i,
#>>> 1 2 3 4 5 6 7 8 9

for i in xrange(1, 10):
    if i == 5 :
        break
    print i,
#>>> 1 2 3 4

[C/C++] switch中的case中，放變數宣告會錯!?

noreply@blogger.com (Falldog) — Wed, 08 Jul 2009 02:36:00 +0000

相信很多寫C/C++的人一定有這樣的經驗，就是在switch的case中寫入變數的宣告，結果compile卻不會過，一定會覺得很莫名奇妙，而且錯誤訊息千奇百怪...

其實，是可以在switch裡的case中宣告變數的，只是要記得在前後加上 { ... }
Ex:

switch( type )
{
 case TYPE1:
 {
     int t = 5;
     printf( "%d", t );
     break;
 }
 default:
     break;
}

以後寫switch要養成良好的習慣，自動加上{ }，不然這種error還滿難抓的。

[Python] lambda簡介

noreply@blogger.com (Falldog) — Tue, 07 Jul 2009 08:36:00 +0000

Python提供了一個簡易的function define：lambda，用完即丟，不著痕跡。讓你實作出很簡單的function(只處理一個運算式)。

lambda param1, param2, ... : expression

#其實就等於

def fun( param1, param2, ... ) :
    return expression

其中的expression不能放assignment，也就是這一行指令不能放=等號。因為，它就這麼簡單，別把它搞複雜化嘛~

Ex:

def func(x, y, z):
    return x + y + z
#>>>  func(1, 2, 3)
#>>>  6

func2 = lambda x,y,z : x+y+z
#>>>  func2(1, 2, 3)
#>>>  6

#也可以應用在map上
my_list = [1, 2, 3]
map( lambda i: i * i, my_list )
#>>>  (1, 4, 9)

lambda在某些方面而言確實是很好用，但是也不能濫用，否則可能造成程式的可讀性降低。

[Python] swap

noreply@blogger.com (Falldog) — Fri, 03 Jul 2009 07:18:00 +0000

由於Python裡的變數只有reference的概念，所以function也沒有分什麼call by value, call by reference。所以，一般C/C++的寫法是不work的。

def swap( a, b ):
    t = a
    a = b
    b = t

#>>> a = 1
#>>> b = 2
#>>> swap( a, b)
#>>> a,b
#>>> (1,2)  # 沒變

要怎麼樣才能讓兩個變數做swap的動作呢？其實很簡單：

a = 1
b = 2
a, b = b, a
#>>> a, b
#>>> (2,1)

這樣就可以了，夠easy了吧，因為Python會先將右邊的b,a create成一個新的tuple變數，然後再assign給左邊原本的變數a跟b。

要把它寫成function也行：

def swap( a, b ):
    return b, a

C++ Builder / Delphi 深度歷險電子書下載

noreply@blogger.com (Falldog) — Sat, 02 May 2009 04:01:00 +0000

上次貼出侯捷大師的「深入淺出MFC」電子書下載連結，獲得不少好評，心胸寬大的作者不只侯捷一人，還有陳昇瑋大師的著作C++ Builder 深度歷險、Delphi 深度歷險這兩本書也有免費的電子書可以下載，有興趣的人可以下載來閱讀。(感謝Beavis大大的推薦)

初探Skype4Py

noreply@blogger.com (Falldog) — Sat, 31 Jan 2009 00:57:00 +0000

在Skype API裡，除了之前介紹的Windows Message、Skype4Com的方法之外，還有一個Skype4Py可以使用。

　　Skype4Py是用Python的語法，將Skype API包裝起來，提供一層high-level的介面供使用者使用，用法跟Skype4Com很類似，而且它還有一個特點，就是跨平台！寫出一個Skype4Py的Python程式，可以在Wiindows、Linux和Mac等不同的OS上執行。而這也是Python的特點之一。

　　在我看過Skype4Py的source code後，原來它只是將不同平台上的Skype API底層的做法包裝起來，所以實際上它執行的方法，在Windows上，還是透過Windows Message傳遞的。有興趣的人可以參考看看。

安裝方法：

安裝Python 2.4以上的版本
安裝Skype
安裝Skype4Py

　　就是這麼簡單，在安裝Skype4Py上，也提供了多種選則，在Windows上可以安裝exe執行檔，或是下載source code自行下指令安裝。

　　在安裝完成後，就可以寫個小小的簡單測試程式：

import Skype4Py

# Create Skype instance
skype = Skype4Py.Skype()

# Connect Skype object to Skype client
skype.Attach()

print 'Your full name:', skype.CurrentUser.FullName
print 'Your contacts:'
for user in skype.Friends:
    print '    ', user.FullName

　　寫法相當的簡潔，這樣子就可以取得好友清單了。Skype4Py的另一項特點，就是它的線上Document格式長得很像JavaDoc的格式，個人覺得在使用上是頗為方便。

相關網頁：

Skype API - DTMF介紹

noreply@blogger.com (Falldog) — Thu, 29 Jan 2009 15:53:00 +0000

　　在一般的電話對談中，如果我們不小心按到了電話上的按鍵(0~9, #, *)，此時會響起一個嗶嗶聲，這個聲響就是以DTMF的方式編碼傳送，每個按鍵都有各自獨有的頻率，所以照理來說，只要對方可以解析傳來的DTMF頻率，即可知道傳來的按鍵為何，可以讓對方做進一步的處理…(如，撥打分機號碼)

　　而在Skype的AP中，也有著類似的介面供使用者在通話中，按下畫面上虛擬的按鍵，即會發出DTMF Tone了。而 Skype API 也有提供解析DTMF code的方法，很是方便。

　　Skype API 提供了一個Command供使用者送出/接收DTMF code，「SET CALL DTMF」，在Skype4Com裡，也提供了一個Event，當收到DTMF code時，就會觸發「CallDtmfReceived」Event，不過在使用上還是有些限制…

使用者只能接收到對方送來的DTMF code。當自己送出DTMF code時，並不會觸發CallDtmfReceived Event。
在Skype4Com的Document中提到，「This event can be received with P2P calls」，所以似乎只限定在P2P的通話上( Skype AP<->Skype AP )，不支援手機<->Skype AP。

範例程式：
範例程式下載連結

#include <vcl.h>
#include <iostream>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "SKYPE4COMLib_OCX"
#pragma resource "*.dfm"
TForm1 *Form1;
using namespace std;

// 這個程式是用來測試Skype4Com的一些功能
// (1) 要執行這個程式 首先要將$(BCB)/Imports/加入 Include Path
//    #include "SKYPE4COMLib_OCX.h"
// (2) 需要新增以下的元件：
//    TListBox *ListBox1;
//    TMemo *Memo1;
// (3) 需要額外宣告變數：
//    TSkype * mSkype;

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
      : TForm(Owner)
{
      mSkype = new TSkype(Owner);
      mSkype->Attach(5,false);
  
      // test if Skype is running, if not, start it;
      if( !mSkype->Client->IsRunning )
          mSkype->Client->Start(false,false);
          // 1st parameter - start Skype in minimized state
          // 2nd parameter - show splash screen
    
      // Get the count of Friends
      int count = mSkype->Friends->get_Count();

      // Add Friend list to Memo
      for( int i=1 ; i<count ; i++ )// start index from 1 !!!
          this->ListBox1->Items->Add( mSkype->Friends->get_Item(i)->get_Handle() );

      // bind the Skype Event.
      mSkype->OnCallDtmfReceived = OnCallDtmfReceived;
}

// Skype4Com的Event
// 在Skype4Com.chm中定義的 Class : _SkypeEvents 裡面
// HRESULT  CallDtmfReceived ([in] ICall *pCall,[in] BSTR Code)
//  This event is caused by a call DTMF event.
// 經由BCB處理過後的header檔，定義在 $(BCB)/Imports/SKYPE4COMLib_OCX.h 100行
//
// @target : when receive the DTMF code, print on Memo.
void __fastcall TForm1::OnCallDtmfReceived( TObject *Sender, ICall* pCall/*[in]*/, BSTR code/*[in]*/)
{
      this->Memo1->Lines->Add( "OnCallDtmfReceived" );
      if( pCall!=NULL ){
          this->Memo1->Lines->Add( AnsiString("DTMF Code : ")+WideString(code) );
      }
}

補充：
在coding時的測試要透過兩個不同的Skype AP，一般的情況下都得在兩台安裝Skype AP的電腦上測試，建議可以用官網提供的Skype Launcher這個小程式，就能在一台電腦上執行多個Skype AP了。

相關連結：

[Python] 實作出 class中的 virtual function

noreply@blogger.com (Falldog) — Sat, 17 Jan 2009 05:51:00 +0000

　　在Python的世界裡，Class並沒有pure virtual function的概念，所以也沒有所謂的virtual class，但是實際上Python提供了一套機制去模擬virtual function的概念，雖然不像C++嚴謹到無法使用virtual class去宣告出一個實體物件，但是至少在使用此function時，可以丟出一個Error Message出來。

　　Python提供的方法就是，你可以在pure virtual function裡，丟一個Error message NotImplementedError出來，夠簡單了吧… 其實自己隨便丟一個也可以達到相同的目的=_=，只是Python提供了個error type，讓我們用起來更有感覺。不過，沒魚蝦也好啦~

以下是範例程式碼…

class virtualClass:
   def __init__(self):
       pass
   def virtualMethod(self): #virtual function.
       raise NotImplementedError( "virtualMethod is virutal! Must be overwrited." )

class subClass( virtualClass ):
   def __init__(self):
       virtualClass.__init__(self)
       pass
   def virtualMethod(self): #overwrite the virtual function.
       print 'subClass! have overwirted the virtualMethod() success.'

v = virtualClass()
v.virtualMethod()

s = subClass()
s.virtualMethod()

侯捷大師 - 深入淺出MFC 2/e 電子書下載

noreply@blogger.com (Falldog) — Fri, 16 Jan 2009 17:42:00 +0000

最近想看看MFC的書，也不知道什麼書寫得比較好，就搜尋一下別人推薦的，結果就找到這個免費的電子書，而且是全書的章節都有，侯捷大師真是佛心來著的(大心)。真的是太屌了，我只能這麼說，一個作者可以完全開放電子書供人下載，胸襟之大，可以見得。

有興趣的人也可以下載來看看，是繁體中文版的喔~

直接下載PDF檔連結：

做中學 - Skype API Tracer

noreply@blogger.com (Falldog) — Sun, 04 Jan 2009 14:51:00 +0000

第一次接觸Skype API的人，看完上一篇介紹Skype API架構的文章後，可能還是霧煞煞的，不太清楚在講什麼東東，沒關係，在這邊我們可以藉由一個Skype官網提供的 Tool - Skype API Tracer 的幫忙，來更加了解Skype API到底在搞什麼、怎麼搞的!?

首先，必須先到 Skype Download 頁面下載 Skype API Tracer 這個 Tool。

接著，開啟你電腦上的Skype，並啟動 Skype API Tracer，操作介面如下：

操作介面非常的簡潔明瞭，這個Tool就是透過Skype API去操控原本的Skype主程式，比如，在指令輸入欄位輸入「PING」後，就會回傳「PONG」。

也可以輸入指令，取得目前登入Skype帳號的好友清單，輸入「SEARCH FRIENDS」，接著就會回傳「USERS echo123, xxx1, xxx2, xxx3, ....」回傳好友清單中，每個好友的帳號的串列，並以分號「，」為間隔。

當然除了取得帳號相關的資訊外，也可以針對Skype的視窗處理的API，如「MINIMIZE 」，輸入後，Skype主程式的視窗就會自動最小化。輸入「OPEN DIALPAD」後會出現Skype的撥號介面。

當然也可以透過指令，讓Skype撥電話給某位使用者，比如我想打電話給我的朋友SummerDog，就輸入「Call SummerDog」即可，Skype會自動幫你處理接下來撥號的動作。

所以，說穿了，Skype API也不過是個文字遊戲，我們丟給它一些文字指令，它可以選擇吃不吃這些指令，不吃就吐個錯誤訊息給你，吃的下去，就幫你處理一些事情，或是回傳一些有用的訊息給你。
而這些文字訊息都必須透過Windows Message去傳遞，而且必須注意的是，文字訊息的內容，必須用UTF-8的編碼格式才行，不然文字訊息一有中文的內容，而Programmer又不將中文encoding成UTF-8的編碼(在程式裡，預設編碼應該是Big5)，Skype會完全看不懂這訊息，就不會理你了。

以上介紹的這些API指令，都可以在官網找到說明與簡易教學，在這邊列出給大家參考一下：

可以用的API指令還滿多的，有興趣的人，可以先使用Skype API Tracer先與Skype溝通一下後，再試著寫入程式裡面，會更有效率~

以上介紹的API指令，都是屬於Windows Message傳遞去控制Skype，其實還有另一個方法，可以用Function的概念去處理Skype API的架構 - Skype4Com，有興趣的人可以參考一下拙作。

Python IDE - HAP (Python Remote Debugger)

noreply@blogger.com (Falldog) — Fri, 26 Dec 2008 12:27:00 +0000

由於公司專案開發使用的程式語言是Python，所以不能像以前一樣只用Notepad++打天下了。進公司後才知道Python有 HAP (全名是Python Remote Debugger)這個IDE的開發工具，下面是它執行的介面圖。很普通，但是基本應該有的功能都有。

HAP - Python Remote Debugger具備下列幾項優點：

可以儲存Python專案。
可以設中斷點除錯，一般的除錯功能都有，包括Wath、Call Stack、Local視窗，真的還滿方便的。
有類似Noteped++的書籤功能，可以讓改code更方便。
支援Tab、Shift Tab，調整code的range。
支援選取多行程式，自動註解的功能。
自動解析py檔的Class架構，列出檔案中所有的function list。

但是也是有幾個缺點啦：

最新版本是2005.08的版本，已經很久沒有再更新了…
Only for Windows.
預設關閉「顯示Line Number」的功能，沒有Line Number在旁邊，真的很麻煩@_@
程式碼的顏色沒有Template可以選擇，我個人是比較習慣黑底的介面，雖然自己改成黑底的介面，但是由於它是將設定存在Register中，所以不能像Notepad++一樣分享出來。

總體而言，它是目前Python IDE的首選了吧！

相關連結：