而代理类的，则包含一整套有继承关系的类。

所以，我突发奇想，不如用继承来实现菜单。

思路是，有个menu类，然后派生，

一个用以放子菜单，

另一个用以实现绑定函数的菜单。

代码如下：

# -*- coding:utf-8 -*-

class Menu(object):
    def __init__(self,label):
        self.label=label

    def click(self):
        pass

class callbackMenu(Menu):
    def __init__(self,label,callback,father=None):
        self.label=label
        self.rcallback=callback
        self.rfather=father

    def click(self,*args,**kwds):
        print "currentClick",self.label
        print
        if callable(self.rcallback):
            self.rcallback(*args,**kwds)
        else:
            return None

class subMenu(Menu):
    def __init__(self,label,submenu,father=None):
        self.label=label
        self.rsubmenu=submenu
        self.rfather=father

    def show(self):
        for i,sub in enumerate(self.rsubmenu):
            print "[%d] %s"%(i,sub.label)
       

    def click(self):
        print "currentMenu",self.label
        self.show()

def showfather(p):
    if(hasattr(p,"rfather") and p.rfather==None):
        print p.label
        return
    print p.label,'<-',
    showfather(p.rfather)

def showfather2(p,symbol='->'):
    if p.rfather==None:
        print p.label,
        return
    showfather2(p.rfather,symbol)
    print symbol,p.label,

def handle(p):
    while True:
        print '-'*40
        showfather2(p)
        print
        p.click()
        try:
            get=raw_input("Input:")
            if get in ['q','Q']:
                break
            get=int(get)
            if get==100:
                if hasattr(p,"rfather") and p.rfather!=None:
                    p=p.rfather
                continue
            if isinstance(p.rsubmenu[get],callbackMenu):
                p.rsubmenu[get].click()
            elif isinstance(p.rsubmenu[get],subMenu):
                fp=p
                p=p.rsubmenu[get]
                p.rfather=fp
        except:
            print "Wrong Input"

if __name__=='__main__':
    sub=subMenu("sub",[callbackMenu("cb1",None),
            callbackMenu("cb2",None)])
    sub2=subMenu("sub2",[callbackMenu("cb2_1",None),
            callbackMenu("cb2_2",None)])
    sub3=subMenu(
            "sub3",
            [subMenu("subsub1",
                [callbackMenu("subcb1",None),
                    callbackMenu("subcb2",None)]),
            subMenu("subsub2",
                            [callbackMenu("sub2cb1",None),
                                callbackMenu("sub2cb2",None)])])
    main=subMenu("Main",[sub,sub2,sub3])
    handle(main)
在这里，我用输入100来返回上一级菜单。

现在想想，面向对象的设计真够难的。

第一步抽象就被卡住了。

在沉思录中，作者常常提示“用类来表示概念”。

但是，现在很犹豫，我的python版本的需不需要继承呢。

另外，引一句在C++编程规范里的，

“继承，不是为了重用，而是为了被重用”。

我觉得非常有道理，因为我需要一个指针样的东西，

来处理各级菜单，如果提供的接口不一样，就很难用这个

指针了。

这里是关于函数对象的默认值func_defaults。

我们知道，如果默认值是不变类型的，那么这个默认值是不会变的。

而我现在要做的，就是让默认值能够变化，记录上次的值。

IDLE 2.6.5     
>>> def f(x=10):
 f.func_defaults=x,
 print x

 
>>> f()
10
>>> f(2)
2
>>> f()
2
>>>

可以看到，这样默认值就被改变了。

其实我们可以对f.func_defaults进行赋值。

from itertools import zip_longest

def str_split(str, n):
    "str_split('aabbcc', 2) --> ['aa', 'bb', 'cc']"
    args = [iter(str)] * n
    return [''.join(i) for i in zip_longest(*args, fillvalue='')]

我改进了一下，使其也具有set方法，当然就是增加了几行代码。

IDLE 2.6.5     
>>> class M(type):
    def __new__(cls, name, bases, classdict):
        for attr in classdict.get('__slots__', ( )):
            if attr.startswith('_'):
                def getter(self, attr=attr):
                    return getattr(self, attr)
                def setter(self, val=0, attr=attr):
                    return setattr(self, attr, val)
                classdict['get' + attr[1:]] = getter
                classdict['set' + attr[1:]] = setter
        return type.__new__(cls, name, bases, classdict)

>>> class Point(object):
    __metaclass__ = M
    __slots__ = ['_x', '_y' ,'_z']

>>> p=Point()
>>> dir(p)
['__class__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__metaclass__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__slots__', '__str__', '__subclasshook__', '_x', '_y', '_z', 'getx', 'gety', 'getz', 'setx', 'sety', 'setz']
>>> p.setx(10)
>>> p.getx()
10
>>>

可以看到，Point 的 __slot__ 中放入x，y，z三个名字，然后就自动生成类似getx，setx的方法。

metaclass 真是强大啊。

这个函数接受一个参数。然后根据需求，返回应该替换的字符串。
IDLE 2.6.5     
>>> import re
>>> r=re.compile(r'a{1,2}')
>>> def myrepl(m):
 s=m.group(0)
 if s=='a':
  return 'one a'
 else:
  return 'two a'

 
>>> r.sub(myrepl,'a aa aaa')
'one a two a two aone a'
>>>

下面是摘自python文档（The Python Standard Library 8.2. re — Regular expression operations）：

Ifrepl is a function, it is called for every non-overlapping occurrence ofpattern. The function takes a single match object argument, and returns the replacement string. For example:

>>> defdashrepl(matchobj):

... ifmatchobj.group(0)=='-':return' '

... else:return'-'

>>> re.sub('-{1,2}',dashrepl,'pro----gram-files')

'pro--gram files'

 

阅读全文
类别：Python 查看评论
文章来源:http://hi.baidu.com/mirguest/blog/item/42411d14ae7fcf0b972b43fc.html

mirguest 2011-02-02 12:01 发表评论

]]>

就是像 (-3)*(3+3)的树就是：

‍

然后，我就用python实现了一下。因为python与C++不同，（作者使用了句柄类），我这里就没考虑这么多。

下面是实现：

# -*- coding:utf-8 -*-
class One_node(object):
    def __init__(self,n):
        self.n=n
    def __str__(self):
        return str(self.n)

class Unary_node(object):
    def __init__(self,op,n):
        self.op=op
        self.n=n
    def __str__(self):
        return "("+self.op+str(self.n)+")"
class Binary_node(object):
    def __init__(self,op,left,right):
        self.op=op
        self.left=left
        self.right=right
    def __str__(self):
        return "("+str(self.left)+self.op+str(self.right)+")"
class Ternary_node(object):
    def __init__(self,left,middle,right):
        self.left=left
        self.middle=middle
        self.right=right
    def __str__(self):
        return "("+str(self.left)+"?"+str(self.middle)+":"+str(self.right)+")"

def Expr(*argc):
    if len(argc)==1:
        return One_node(*argc)
    elif len(argc)==2:
        return Unary_node(*argc)
    elif len(argc)==3:
        return Binary_node(*argc)

if __name__=="__main__":
    x=Expr(10)
    print x
    x=Expr("-",10)
    print x
    x=Expr("*",2,10)
    print x
    x=Expr("*",Expr(10),Expr("-",3))
    print x
    x=Expr("*",x,x)
    print x
    x=Ternary_node(x,x,x)
    print x