Python论坛的帖子： - 哲思

Python论坛 - 讨论区

返回群组主页

标题：[python-chinese] 请教一种设计模式。

分享

徐继哲

楼主 2005年07月28日星期四 21:50

flyaflya flyaflyaa at gmail.com
Thu Jul 28 21:50:36 HKT 2005

忘记叫什么名字了，就是用几组函数处理同一组数据。可以在这几组函数间切换。
我的实现是这样：
class data:
    def __init__(self):
        self.d = 10
    def dfunc(self):
        print(self.d)

class imp1:
    def __init__(self, data):
        self.__data = data

    def fun(self):
        self.__data.d += 10
        self.__data.dfunc()


class imp2:
    def __init__(self, data):
        self.__data = data

    def fun(self):
        self.__data.d -= 10
        self.__data.dfunc()


class foo:
    def __init__(self):
        self.__data = data()
        self.imp = []
        self.imp.append(imp1(self.__data))
        self.imp.append(imp2(self.__data))
        self.curImp = 0
        
    def fun(self):
        self.imp[self.curImp].fun()
        
    def setType(self, type):
        self.curImp = type
#测试
a = foo()
a.fun()
a.setType(1)
a.fun()
我希望类foo可以通过setType在imp1和imp2的函数间切换，操作同一组数据data,data中也有一些函数。
我试了很多各方法，用多重继承，用__getattr__等，都失败了，只有用这种笨办法了，但这样，我在imp1和imp2中每次要操作data中的数据，都很麻烦，大家有什么好方法没

-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.exoweb.net/pipermail/python-chinese/attachments/20050728/893036a2/attachment.htm

[导入自Mailman归档：http://www.zeuux.org/pipermail/zeuux-python]

徐继哲

0楼 2005年07月28日星期四 22:38

flyaflya flyaflyaa at gmail.com
Thu Jul 28 22:38:16 HKT 2005

我的意思是每一个imp类都有一组函数，不至fun一个。我希望foo通过调用setType在两种状态切换，比如setType(0)时，调用foo函数时就会调用imp1中的函数，setType(1)时，调用foo函数就转向imp2。我开始想imp1和imp2都继承自data,然后foo再多重继承于imp1和imp2。不行，用__setattr__和__getattr__也不行，试了半天，头都晕了。

----- Original Message ----- 
From: "limodou" <limodou at gmail.com>
To: <python-chinese at lists.python.cn>
Sent: Friday, July 29, 2005 10:12 PM
Subject: Re: [python-chinese] 请教一种设计模式。


> 既然是个函数，可以不写成类的形式啊，我还是不太懂你想怎 么省事。不过为什么不直接使用函数来处理呢？我改造了一下如下：
> 
> class data:
>     def __init__(self):
>         self.d = 10
>     def dfunc(self):
>         print(self.d)
>  
> def fun1(data):
>     data.d += 10
>     data.dfunc()
>  
> 
> def fun2(data):
>     data.d -= 10
>     data.dfunc()
>  
> 
> class foo:
>     def __init__(self):
>         self.__data = data()
>         self.imp = []
>         self.imp.append(fun1)
>         self.imp.append(fun2)
>         self.curImp = 0
>        
>     def fun(self):
>         self.imp[self.curImp](self.__data)
>        
>     def setType(self, type):
>         self.curImp = type
>         
> if __name__ == '__main__':        
>     #Testing
>     a = foo()
>     a.fun()
>     a.setType(1)
>     a.fun()
> 
> 因为fun1, fun2它们只是函数，只是对参数进行处理的，没必要再保留数据的复本。由调度类foo来保存就好了，它们只是进行即定的处理就行了。
> 
> 不太明白你到底想如何简化。
> 
> 
> 在 05-7-28，flyaflya<flyaflyaa at gmail.com> 写道：
> >  
> > 忘记叫什么名字了，就是用几组函数处理同一组数据。可以在这几组函数间切换。 
> > 我的实现是这样： 
> > class data:
> >     def __init__(self):
> >         self.d = 10
> >     def dfunc(self):
> >         print(self.d) 
> >   
> > class imp1:
> >     def __init__(self, data):
> >         self.__data = data 
> >   
> >     def fun(self):
> >         self.__data.d += 10
> >         self.__data.dfunc() 
> >   
> > 
> > class imp2:
> >     def __init__(self, data):
> >         self.__data = data 
> >   
> >     def fun(self):
> >         self.__data.d -= 10
> >         self.__data.dfunc() 
> >   
> > 
> > class foo:
> >     def __init__(self):
> >         self.__data = data()
> >         self.imp = []
> >         self.imp.append(imp1(self.__data))
> >         self.imp.append(imp2(self.__data))
> >         self.curImp = 0
> >         
> >     def fun(self):
> >         self.imp[self.curImp].fun()
> >         
> >     def setType(self, type):
> >         self.curImp = type 
> > #测试 
> > a = foo()
> > a.fun()
> > a.setType(1)
> > a.fun() 
> > 我希望类foo可以通过setType在imp1和imp2的函数间切换，操作同一组数据data,data中也有一些函数。
> > 我试了很多各方法，用多重继承，用__getattr__等，都失败了，只有用这种笨办法了，但这样，我在imp1和imp2中每次要操作data中的数据，都很麻烦，大家有什么好方法没
> >   
> >   
> > _______________________________________________
> > python-chinese list
> > python-chinese at lists.python.cn
> > http://python.cn/mailman/listinfo/python-chinese
> > 
> > 
> > 
> 
> 
> -- 
> I like python! 
> My Donews Blog: http://www.donews.net/limodou
> New Google Maillist: http://groups-beta.google.com/group/python-cn
> 


--------------------------------------------------------------------------------


> _______________________________________________
> python-chinese list
> python-chinese at lists.python.cn
> http://python.cn/mailman/listinfo/python-chinese
>

[导入自Mailman归档：http://www.zeuux.org/pipermail/zeuux-python]

徐继哲

0楼 2005年07月28日星期四 23:20

flyaflya flyaflyaa at gmail.com
Thu Jul 28 23:20:40 HKT 2005

我想也只有这样了，想用一下PY的高级功能，呵呵，水平有限，搞不定。
----- Original Message ----- 
From: "limodou" <limodou at gmail.com>
To: <python-chinese at lists.python.cn>
Sent: Friday, July 29, 2005 10:54 PM
Subject: Re: [python-chinese] 请教一种设计模式。


> 感觉你的问题还是没有描述清啊。
> 
> 在 05-7-28，flyaflya<flyaflyaa at gmail.com> 写道：
> > 我的意思是每一个imp类都有一组函数，不至fun一个。我希望foo通过调用setType在两种状态切换，比如setType(0)时，调用foo函数时就会调用imp1中的函数，setType(1)时，调用foo函数就转向imp2。
> 
> 这与前面所说"每一个imp类都有一组函数"好象没什么关系呀。
> 
> > 我开始想imp1和imp2都继承自data,
> 
> 为什么把数据和处理混在一起呢？
> 
> > 然后foo再多重继承于imp1和imp2。不行，用__setattr__和__getattr__也不行，试了半天，头都晕了。
> 
> 当然会有问题了。如果imp1和imp2有同名函数就有问题，但也不是不能解决，可以imp1.func(self,...)和imp2.func(self,
> ...)。imp1和imp2都是类名
> 
> 但你为了这个不知道的什么模式却忽略了controller模式。把调度与真正的处理，与数据(MVC)混在了一起，不是更不好吗？
> > 
> > ----- Original Message -----
> > From: "limodou" <limodou at gmail.com>
> > To: <python-chinese at lists.python.cn>
> > Sent: Friday, July 29, 2005 10:12 PM
> > Subject: Re: [python-chinese] 请教一种设计模式。
> > 
> > 
> > > 既然是个函数，可以不写成类的形式啊，我还是不太懂你想怎 么省事。不过为什么不直接使用函数来处理呢？我改造了一下如下：
> > >
> > > class data:
> > >     def __init__(self):
> > >         self.d = 10
> > >     def dfunc(self):
> > >         print(self.d)
> > >
> > > def fun1(data):
> > >     data.d += 10
> > >     data.dfunc()
> > >
> > >
> > > def fun2(data):
> > >     data.d -= 10
> > >     data.dfunc()
> > >
> > >
> > > class foo:
> > >     def __init__(self):
> > >         self.__data = data()
> > >         self.imp = []
> > >         self.imp.append(fun1)
> > >         self.imp.append(fun2)
> > >         self.curImp = 0
> > >
> > >     def fun(self):
> > >         self.imp[self.curImp](self.__data)
> > >
> > >     def setType(self, type):
> > >         self.curImp = type
> > >
> > > if __name__ == '__main__':
> > >     #Testing
> > >     a = foo()
> > >     a.fun()
> > >     a.setType(1)
> > >     a.fun()
> > >
> > > 因为fun1, fun2它们只是函数，只是对参数进行处理的，没必要再保留数据的复本。由调度类foo来保存就好了，它们只是进行即定的处理就行了。
> > >
> > > 不太明白你到底想如何简化。
> > >
> > >
> > > 在 05-7-28，flyaflya<flyaflyaa at gmail.com> 写道：
> > > >
> > > > 忘记叫什么名字了，就是用几组函数处理同一组数据。可以在这几组函数间切换。
> > > > 我的实现是这样：
> > > > class data:
> > > >     def __init__(self):
> > > >         self.d = 10
> > > >     def dfunc(self):
> > > >         print(self.d)
> > > >
> > > > class imp1:
> > > >     def __init__(self, data):
> > > >         self.__data = data
> > > >
> > > >     def fun(self):
> > > >         self.__data.d += 10
> > > >         self.__data.dfunc()
> > > >
> > > >
> > > > class imp2:
> > > >     def __init__(self, data):
> > > >         self.__data = data
> > > >
> > > >     def fun(self):
> > > >         self.__data.d -= 10
> > > >         self.__data.dfunc()
> > > >
> > > >
> > > > class foo:
> > > >     def __init__(self):
> > > >         self.__data = data()
> > > >         self.imp = []
> > > >         self.imp.append(imp1(self.__data))
> > > >         self.imp.append(imp2(self.__data))
> > > >         self.curImp = 0
> > > >
> > > >     def fun(self):
> > > >         self.imp[self.curImp].fun()
> > > >
> > > >     def setType(self, type):
> > > >         self.curImp = type
> > > > #测试
> > > > a = foo()
> > > > a.fun()
> > > > a.setType(1)
> > > > a.fun()
> > > > 我希望类foo可以通过setType在imp1和imp2的函数间切换，操作同一组数据data,data中也有一些函数。
> > > > 我试了很多各方法，用多重继承，用__getattr__等，都失败了，只有用这种笨办法了，但这样，我在imp1和imp2中每次要操作data中的数据，都很麻烦，大家有什么好方法没
> > > >
> > > >
> > > > _______________________________________________
> > > > python-chinese list
> > > > python-chinese at lists.python.cn
> > > > http://python.cn/mailman/listinfo/python-chinese
> > > >
> > > >
> > > >
> > >
> > >
> > > --
> > > I like python!
> > > My Donews Blog: http://www.donews.net/limodou
> > > New Google Maillist: http://groups-beta.google.com/group/python-cn
> > >
> > 
> > 
> > --------------------------------------------------------------------------------
> > 
> > 
> > > _______________________________________________
> > > python-chinese list
> > > python-chinese at lists.python.cn
> > > http://python.cn/mailman/listinfo/python-chinese
> > > 
> 
> 
> -- 
> I like python! 
> My Donews Blog: http://www.donews.net/limodou
> New Google Maillist: http://groups-beta.google.com/group/python-cn
> 


--------------------------------------------------------------------------------


> _______________________________________________
> python-chinese list
> python-chinese at lists.python.cn
> http://python.cn/mailman/listinfo/python-chinese
>

[导入自Mailman归档：http://www.zeuux.org/pipermail/zeuux-python]

徐继哲

0楼 2005年07月28日星期四 23:50

flyaflya flyaflyaa at gmail.com
Thu Jul 28 23:50:40 HKT 2005

这种模式不方便，也没有用到继承，元什么的。不优雅，呵呵。先这样用吧，什么时候把PY的模式整理一下，用起来就方便了。现在只会很少的几种。

----- Original Message ----- 
From: "张骏" <zhangj at foreseen-info.com>
To: <python-chinese at lists.python.cn>
Sent: Friday, July 29, 2005 10:44 PM
Subject: Re: [python-chinese] 请教一种设计模式。


> 你的这个实现不就可以吗?
> 难道一定要用已知的模式实现才是好的吗?
> 
> ----------------------- Original Message -----------------------
> From:    "flyaflya" <flyaflyaa at gmail.com>
> To:      "limodou" <limodou at gmail.com>, <python-chinese at lists.python.cn>
> Date:    Thu, 28 Jul 2005 22:38:16 +0800
> Subject: Re: [python-chinese] 请教一种设计模式。
> ----------------------------------------------------------------
> > 我的意思是每一个imp类都有一组函数，不至fun一个。我希望foo通过调用setType在两种状态切换，比如setType(0)时，调用foo函数时就会调用imp1中的函数，setType(1)时，调用foo函数就转向imp2。我开始想imp1和imp2都继承自data,然后foo再多重继承于imp1和imp2。不行，用__setattr__和__getattr__也不行，试了半天，头都晕了。
> > 
> > ----- Original Message ----- 
> > From: "limodou" <limodou at gmail.com>
> > To: <python-chinese at lists.python.cn>
> > Sent: Friday, July 29, 2005 10:12 PM
> > Subject: Re: [python-chinese] 请教一种设计模式。
> > 
> > 
> > > 既然是个函数，可以不写成类的形式啊，我还是不太懂你想怎 么省事。不过为什么不直接使用函数来处理呢？我改造了一下如下：
> > > 
> > > class data:
> > >     def __init__(self):
> > >         self.d = 10
> > >     def dfunc(self):
> > >         print(self.d)
> > >  
> > > def fun1(data):
> > >     data.d += 10
> > >     data.dfunc()
> > >  
> > > 
> > > def fun2(data):
> > >     data.d -= 10
> > >     data.dfunc()
> > >  
> > > 
> > > class foo:
> > >     def __init__(self):
> > >         self.__data = data()
> > >         self.imp = []
> > >         self.imp.append(fun1)
> > >         self.imp.append(fun2)
> > >         self.curImp = 0
> > >        
> > >     def fun(self):
> > >         self.imp[self.curImp](self.__data)
> > >        
> > >     def setType(self, type):
> > >         self.curImp = type
> > >         
> > > if __name__ == '__main__':        
> > >     #Testing
> > >     a = foo()
> > >     a.fun()
> > >     a.setType(1)
> > >     a.fun()
> > > 
> > > 因为fun1, fun2它们只是函数，只是对参数进行处理的，没必要再保留数据的复本。由调度类foo来保存就好了，它们只是进行即定的处理就行了。
> > > 
> > > 不太明白你到底想如何简化。
> > > 
> > > 
> > > 在 05-7-28，flyaflya<flyaflyaa at gmail.com> 写道：
> > > >  
> > > > 忘记叫什么名字了，就是用几组函数处理同一组数据。可以在这几组函数间切换。 
> > > > 我的实现是这样： 
> > > > class data:
> > > >     def __init__(self):
> > > >         self.d = 10
> > > >     def dfunc(self):
> > > >         print(self.d) 
> > > >   
> > > > class imp1:
> > > >     def __init__(self, data):
> > > >         self.__data = data 
> > > >   
> > > >     def fun(self):
> > > >         self.__data.d += 10
> > > >         self.__data.dfunc() 
> > > >   
> > > > 
> > > > class imp2:
> > > >     def __init__(self, data):
> > > >         self.__data = data 
> > > >   
> > > >     def fun(self):
> > > >         self.__data.d -= 10
> > > >         self.__data.dfunc() 
> > > >   
> > > > 
> > > > class foo:
> > > >     def __init__(self):
> > > >         self.__data = data()
> > > >         self.imp = []
> > > >         self.imp.append(imp1(self.__data))
> > > >         self.imp.append(imp2(self.__data))
> > > >         self.curImp = 0
> > > >         
> > > >     def fun(self):
> > > >         self.imp[self.curImp].fun()
> > > >         
> > > >     def setType(self, type):
> > > >         self.curImp = type 
> > > > #测试 
> > > > a = foo()
> > > > a.fun()
> > > > a.setType(1)
> > > > a.fun() 
> > > > 我希望类foo可以通过setType在imp1和imp2的函数间切换，操作同一组数据data,data中也有一些函数。
> > > > 我试了很多各方法，用多重继承，用__getattr__等，都失败了，只有用这种笨办法了，但这样，我在imp1和imp2中每次要操作data中的数据，都很麻烦，大家有什么好方法没
> > > >   
> > > >   
> > > > _______________________________________________
> > > > python-chinese list
> > > > python-chinese at lists.python.cn
> > > > http://python.cn/mailman/listinfo/python-chinese
> > > > 
> > > > 
> > > > 
> > > 
> > > 
> > > -- 
> > > I like python! 
> > > My Donews Blog: http://www.donews.net/limodou
> > > New Google Maillist: http://groups-beta.google.com/group/python-cn
> > > 
> > 
> > 
> > --------------------------------------------------------------------------------
> > 
> > 
> > > _______________________________________________
> > > python-chinese list
> > > python-chinese at lists.python.cn
> > > http://python.cn/mailman/listinfo/python-chinese
> > > 
> 
> --------------------- Original Message Ends --------------------
> _______________________________________________
> python-chinese list
> python-chinese at lists.python.cn
> http://python.cn/mailman/listinfo/python-chinese

[导入自Mailman归档：http://www.zeuux.org/pipermail/zeuux-python]

徐继哲

0楼 2005年07月29日星期五 08:19

flyaflya flyaflyaa at gmail.com
Fri Jul 29 08:19:46 HKT 2005

对，对，算法模式，叫策略（strategy)，政策（policy），我看了一下C++的实现和我的代码基本一样。呵呵，好像我现在常用的设计模式都是C++的，根本没有用到PY的强大能力，像metaclass什么的。是在用C++的思想写PY程序。我常用的模式有模板方法（template method），观察都（observe），别的可能在不知不觉中用过。我希望能把PY的模式好好的总结一下，写代码不至于太 乱。
还有PY不用写抽相类的，我从来不写，除非有公共的函数，才写一个基类，没什么问题呀。


----- Original Message ----- 
  From: Hou Ming Yuan 
  To: python-chinese at lists.python.cn 
  Sent: Friday, July 29, 2005 11:06 PM
  Subject: Re: [python-chinese] 请教一种设计模式。


  如果是用C++会定义一个借口类。
  我认为呢，这种情况呢，刚好符合设计模式里的算法模式。算法模式要把算法的接口抽象出来，每个具体的算法都从抽象接口继承，我想算法模式看起来会比较清晰一点，虽说要用到继承，从可维护性上来讲也个好一些，接口相当于定了一个协议，如果其他人也要实现另一个算法，他至要遵循这个协议就可以了。
   
  在05-7-29，张骏 <zhangj at foreseen-info.com> 写道： 
    你的这个实现不就可以吗?
    难道一定要用已知的模式实现才是好的吗?

    ----------------------- Original Message ----------------------- 
    From:    "flyaflya" <flyaflyaa at gmail.com>
    To:      "limodou" <limodou at gmail.com>, < python-chinese at lists.python.cn>
    Date:    Thu, 28 Jul 2005 22:38:16 +0800
    Subject: Re: [python-chinese] 请教一种设计模式。
    ----------------------------------------------------------------
    > 我的意思是每一个imp类都有一组函数，不至fun一个。我希望foo通过调用setType在两种状态切换，比如setType(0)时，调用foo函数时就会调用imp1中的函数，setType(1)时，调用foo函数就转向imp2。我开始想imp1和imp2都继承自data,然后foo再多重继承于imp1和imp2。不行，用__setattr__和__getattr__也不行，试了半天，头都晕了。 
    >
    > ----- Original Message -----
    > From: "limodou" <limodou at gmail.com>
    > To: <python-chinese at lists.python.cn >
    > Sent: Friday, July 29, 2005 10:12 PM
    > Subject: Re: [python-chinese] 请教一种设计模式。
    >
    >
    > > 既然是个函数，可以不写成类的形式啊，我还是不太懂你想怎 么省事。不过为什么不直接使用函数来处理呢？我改造了一下如下：
    > >
    > > class data: 
    > >     def __init__(self):
    > >         self.d = 10
    > >     def dfunc(self):
    > >         print(self.d)
    > >
    > > def fun1(data):
    > >     data.d += 10
    > >     data.dfunc()
    > >
    > >
    > > def fun2(data):
    > >     data.d -= 10
    > >     data.dfunc()
    > >
    > >
    > > class foo:
    > >     def __init__(self):
    > >         self.__data = data() 
    > >         self.imp = []
    > >         self.imp.append(fun1)
    > >         self.imp.append(fun2)
    > >         self.curImp = 0
    > >
    > >     def fun(self):
    > >         self.imp[self.curImp](self.__data)
    > >
    > >     def setType(self, type):
    > >         self.curImp = type
    > >
    > > if __name__ == '__main__':
    > >     #Testing
    > >     a = foo() 
    > >     a.fun()
    > >     a.setType(1)
    > >     a.fun()
    > >
    > > 因为fun1, fun2它们只是函数，只是对参数进行处理的，没必要再保留数据的复本。由调度类foo来保存就好了，它们只是进行即定的处理就行了。
    > >
    > > 不太明白你到底想如何简化。
    > >
    > >
    > > 在 05-7-28，flyaflya<flyaflyaa at gmail.com> 写道：
    > > >
    > > > 忘记叫什么名字了，就是用几组函数处理同一组数据。可以在这几组函数间切换。
    > > > 我的实现是这样： 
    > > > class data:
    > > >     def __init__(self):
    > > >         self.d = 10
    > > >     def dfunc(self):
    > > >         print(self.d)
    > > >
    > > > class imp1: 
    > > >     def __init__(self, data):
    > > >         self.__data = data
    > > >
    > > >     def fun(self):
    > > >         self.__data.d += 10
    > > >         self.__data.dfunc() 
    > > >
    > > >
    > > > class imp2:
    > > >     def __init__(self, data):
    > > >         self.__data = data
    > > >
    > > >     def fun(self):
    > > >         self.__data.d -= 10 
    > > >         self.__data.dfunc()
    > > >
    > > >
    > > > class foo:
    > > >     def __init__(self):
    > > >         self.__data = data()
    > > >         self.imp = []
    > > >         self.imp.append(imp1(self.__data))
    > > >         self.imp.append(imp2(self.__data))
    > > >         self.curImp = 0
    > > >
    > > >     def fun(self): 
    > > >         self.imp[self.curImp].fun()
    > > >
    > > >     def setType(self, type):
    > > >         self.curImp = type
    > > > #测试
    > > > a = foo()
    > > > a.fun()
    > > > a.setType(1)
    > > > a.fun()
    > > > 我希望类foo可以通过setType在imp1和imp2的函数间切换，操作同一组数据data,data中也有一些函数。
    > > > 我试了很多各方法，用多重继承，用__getattr__等，都失败了，只有用这种笨办法了，但这样，我在imp1和imp2中每次要操作data中的数据，都很麻烦，大家有什么好方法没 
    > > >
    > > >
    > > > _______________________________________________
    > > > python-chinese list
    > > > python-chinese at lists.python.cn 
    > > > http://python.cn/mailman/listinfo/python-chinese
    > > >
    > > >
    > > >
    > >
    > >
    > > -- 
    > > I like python!
    > > My Donews Blog: http://www.donews.net/limodou
    > > New Google Maillist: http://groups-beta.google.com/group/python-cn
    > >
    >
    >
    > --------------------------------------------------------------------------------
    >
    >
    > > _______________________________________________ 
    > > python-chinese list
    > > python-chinese at lists.python.cn
    > > http://python.cn/mailman/listinfo/python-chinese 
    > >

    --------------------- Original Message Ends --------------------
    _______________________________________________
    python-chinese list
    python-chinese at lists.python.cn 
    http://python.cn/mailman/listinfo/python-chinese





------------------------------------------------------------------------------


  _______________________________________________
  python-chinese list
  python-chinese at lists.python.cn
  http://python.cn/mailman/listinfo/python-chinese
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.exoweb.net/pipermail/python-chinese/attachments/20050729/a1ee9ad6/attachment-0001.htm

[导入自Mailman归档：http://www.zeuux.org/pipermail/zeuux-python]

徐继哲

0楼 2005年07月29日星期五 08:27

flyaflya flyaflyaa at gmail.com
Fri Jul 29 08:27:09 HKT 2005

关键不是在两个函数间切换，是在两组函数间切换，是完完全全的Strategy模式。在impl中不仅要有fun1，还要有fun2.....许多需要的函数。

----- Original Message ----- 
From: "Qiangning Hong" <hongqn at gmail.com>
To: <python-chinese at lists.python.cn>
Sent: Saturday, July 30, 2005 8:07 AM
Subject: Re: [python-chinese] 请教一种设计模式。


> 我倒是觉得limodou给出的那种方式很pythonic。
> 在python里，函数是first-class objects. 用来表示算法最合适不过了。
> 不是说非要用到继承、元类才叫优雅的。可读性、可维护性第一。
> 
> 你看看GoF书里Strategy模式(第315y页)，不也只是用了一个简单的接口类吗。在python里，由于是动态语言，连接口类都不需要定义，那就连继承也不需要了。
> 你的这个模式其实就是Strategy模式的变种，给它增加了动态切换算法的功能而已。
> 
> On 7/28/05, flyaflya <flyaflyaa at gmail.com> wrote:
> > 这种模式不方便，也没有用到继承，元什么的。不优雅，呵呵。先这样用吧，什么时候把PY的模式整理一下，用起来就方便了。现在只会很少的几种。
> > 
> > ----- Original Message -----
> > From: "张骏" <zhangj at foreseen-info.com>
> > To: <python-chinese at lists.python.cn>
> > Sent: Friday, July 29, 2005 10:44 PM
> > Subject: Re: [python-chinese] 请教一种设计模式。
> > 
> > 
> > > 你的这个实现不就可以吗?
> > > 难道一定要用已知的模式实现才是好的吗?
> > >
> > > ----------------------- Original Message -----------------------
> > > From:    "flyaflya" <flyaflyaa at gmail.com>
> > > To:      "limodou" <limodou at gmail.com>, <python-chinese at lists.python.cn>
> > > Date:    Thu, 28 Jul 2005 22:38:16 +0800
> > > Subject: Re: [python-chinese] 请教一种设计模式。
> > > ----------------------------------------------------------------
> > > > 我的意思是每一个imp类都有一组函数，不至fun一个。我希望foo通过调用setType在两种状态切换，比如setType(0)时，调用foo函数时就会调用imp1中的函数，setType(1)时，调用foo函数就转向imp2。我开始想imp1和imp2都继承自data,然后foo再多重继承于imp1和imp2。不行，用__setattr__和__getattr__也不行，试了半天，头都晕了。
> > > >
> > > > ----- Original Message -----
> > > > From: "limodou" <limodou at gmail.com>
> > > > To: <python-chinese at lists.python.cn>
> > > > Sent: Friday, July 29, 2005 10:12 PM
> > > > Subject: Re: [python-chinese] 请教一种设计模式。
> > > >
> > > >
> > > > > 既然是个函数，可以不写成类的形式啊，我还是不太懂你想怎 么省事。不过为什么不直接使用函数来处理呢？我改造了一下如下：
> > > > >
> > > > > class data:
> > > > >     def __init__(self):
> > > > >         self.d = 10
> > > > >     def dfunc(self):
> > > > >         print(self.d)
> > > > >
> > > > > def fun1(data):
> > > > >     data.d += 10
> > > > >     data.dfunc()
> > > > >
> > > > >
> > > > > def fun2(data):
> > > > >     data.d -= 10
> > > > >     data.dfunc()
> > > > >
> > > > >
> > > > > class foo:
> > > > >     def __init__(self):
> > > > >         self.__data = data()
> > > > >         self.imp = []
> > > > >         self.imp.append(fun1)
> > > > >         self.imp.append(fun2)
> > > > >         self.curImp = 0
> > > > >
> > > > >     def fun(self):
> > > > >         self.imp[self.curImp](self.__data)
> > > > >
> > > > >     def setType(self, type):
> > > > >         self.curImp = type
> > > > >
> > > > > if __name__ == '__main__':
> > > > >     #Testing
> > > > >     a = foo()
> > > > >     a.fun()
> > > > >     a.setType(1)
> > > > >     a.fun()
> > > > >
> > > > > 因为fun1, fun2它们只是函数，只是对参数进行处理的，没必要再保留数据的复本。由调度类foo来保存就好了，它们只是进行即定的处理就行了。
> > > > >
> > > > > 不太明白你到底想如何简化。
> > > > >
> > > > >
> > > > > 在 05-7-28，flyaflya<flyaflyaa at gmail.com> 写道：
> > > > > >
> > > > > > 忘记叫什么名字了，就是用几组函数处理同一组数据。可以在这几组函数间切换。
> > > > > > 我的实现是这样：
> > > > > > class data:
> > > > > >     def __init__(self):
> > > > > >         self.d = 10
> > > > > >     def dfunc(self):
> > > > > >         print(self.d)
> > > > > >
> > > > > > class imp1:
> > > > > >     def __init__(self, data):
> > > > > >         self.__data = data
> > > > > >
> > > > > >     def fun(self):
> > > > > >         self.__data.d += 10
> > > > > >         self.__data.dfunc()
> > > > > >
> > > > > >
> > > > > > class imp2:
> > > > > >     def __init__(self, data):
> > > > > >         self.__data = data
> > > > > >
> > > > > >     def fun(self):
> > > > > >         self.__data.d -= 10
> > > > > >         self.__data.dfunc()
> > > > > >
> > > > > >
> > > > > > class foo:
> > > > > >     def __init__(self):
> > > > > >         self.__data = data()
> > > > > >         self.imp = []
> > > > > >         self.imp.append(imp1(self.__data))
> > > > > >         self.imp.append(imp2(self.__data))
> > > > > >         self.curImp = 0
> > > > > >
> > > > > >     def fun(self):
> > > > > >         self.imp[self.curImp].fun()
> > > > > >
> > > > > >     def setType(self, type):
> > > > > >         self.curImp = type
> > > > > > #测试
> > > > > > a = foo()
> > > > > > a.fun()
> > > > > > a.setType(1)
> > > > > > a.fun()
> > > > > > 我希望类foo可以通过setType在imp1和imp2的函数间切换，操作同一组数据data,data中也有一些函数。
> > > > > > 我试了很多各方法，用多重继承，用__getattr__等，都失败了，只有用这种笨办法了，但这样，我在imp1和imp2中每次要操作data中的数据，都很麻烦，大家有什么好方法没
> > > > > >
> > > > > >
> > > > > > _______________________________________________
> > > > > > python-chinese list
> > > > > > python-chinese at lists.python.cn
> > > > > > http://python.cn/mailman/listinfo/python-chinese
> > > > > >
> > > > > >
> > > > > >
> > > > >
> > > > >
> > > > > --
> > > > > I like python!
> > > > > My Donews Blog: http://www.donews.net/limodou
> > > > > New Google Maillist: http://groups-beta.google.com/group/python-cn
> > > > >
> > > >
> > > >
> > > > --------------------------------------------------------------------------------
> > > >
> > > >
> > > > > _______________________________________________
> > > > > python-chinese list
> > > > > python-chinese at lists.python.cn
> > > > > http://python.cn/mailman/listinfo/python-chinese
> > > > >
> > >
> > > --------------------- Original Message Ends --------------------
> > > _______________________________________________
> > > python-chinese list
> > > python-chinese at lists.python.cn
> > > http://python.cn/mailman/listinfo/python-chinese
> > _______________________________________________
> > python-chinese list
> > python-chinese at lists.python.cn
> > http://python.cn/mailman/listinfo/python-chinese
> > 
> > 
> > 
> 
> 
> -- 
> Qiangning Hong
> 
> I'm usually annoyed by IDEs because, for instance, they don't use VIM
> as an editor. Since I'm hooked to that, all IDEs I've used so far have
> failed to impress me.
>    -- Sybren Stuvel @ c.l.python
> 
> Get Firefox! <http://www.spreadfirefox.com/?q=affiliates&id=67907&t=1>
> 


--------------------------------------------------------------------------------


> _______________________________________________
> python-chinese list
> python-chinese at lists.python.cn
> http://python.cn/mailman/listinfo/python-chinese
>

[导入自Mailman归档：http://www.zeuux.org/pipermail/zeuux-python]

徐继哲

0楼 2005年07月29日星期五 22:12

limodou limodou at gmail.com
Fri Jul 29 22:12:40 HKT 2005

既然是个函数，可以不写成类的形式啊，我还是不太懂你想怎 么省事。不过为什么不直接使用函数来处理呢？我改造了一下如下：

class data:
    def __init__(self):
        self.d = 10
    def dfunc(self):
        print(self.d)
 
def fun1(data):
    data.d += 10
    data.dfunc()
 

def fun2(data):
    data.d -= 10
    data.dfunc()
 

class foo:
    def __init__(self):
        self.__data = data()
        self.imp = []
        self.imp.append(fun1)
        self.imp.append(fun2)
        self.curImp = 0
       
    def fun(self):
        self.imp[self.curImp](self.__data)
       
    def setType(self, type):
        self.curImp = type
        
if __name__ == '__main__':        
    #Testing
    a = foo()
    a.fun()
    a.setType(1)
    a.fun()

因为fun1, fun2它们只是函数，只是对参数进行处理的，没必要再保留数据的复本。由调度类foo来保存就好了，它们只是进行即定的处理就行了。

不太明白你到底想如何简化。


在 05-7-28，flyaflya<flyaflyaa at gmail.com> 写道：
>  
> 忘记叫什么名字了，就是用几组函数处理同一组数据。可以在这几组函数间切换。 
> 我的实现是这样： 
> class data:
>     def __init__(self):
>         self.d = 10
>     def dfunc(self):
>         print(self.d) 
>   
> class imp1:
>     def __init__(self, data):
>         self.__data = data 
>   
>     def fun(self):
>         self.__data.d += 10
>         self.__data.dfunc() 
>   
> 
> class imp2:
>     def __init__(self, data):
>         self.__data = data 
>   
>     def fun(self):
>         self.__data.d -= 10
>         self.__data.dfunc() 
>   
> 
> class foo:
>     def __init__(self):
>         self.__data = data()
>         self.imp = []
>         self.imp.append(imp1(self.__data))
>         self.imp.append(imp2(self.__data))
>         self.curImp = 0
>         
>     def fun(self):
>         self.imp[self.curImp].fun()
>         
>     def setType(self, type):
>         self.curImp = type 
> #测试 
> a = foo()
> a.fun()
> a.setType(1)
> a.fun() 
> 我希望类foo可以通过setType在imp1和imp2的函数间切换，操作同一组数据data,data中也有一些函数。
> 我试了很多各方法，用多重继承，用__getattr__等，都失败了，只有用这种笨办法了，但这样，我在imp1和imp2中每次要操作data中的数据，都很麻烦，大家有什么好方法没
>   
>   
> _______________________________________________
> python-chinese list
> python-chinese at lists.python.cn
> http://python.cn/mailman/listinfo/python-chinese
> 
> 
> 


-- 
I like python! 
My Donews Blog: http://www.donews.net/limodou
New Google Maillist: http://groups-beta.google.com/group/python-cn

[导入自Mailman归档：http://www.zeuux.org/pipermail/zeuux-python]

徐继哲

0楼 2005年07月29日星期五 22:44

张骏 zhangj at foreseen-info.com
Fri Jul 29 22:44:01 HKT 2005

你的这个实现不就可以吗?
难道一定要用已知的模式实现才是好的吗?

----------------------- Original Message -----------------------
From:    "flyaflya" <flyaflyaa at gmail.com>
To:      "limodou" <limodou at gmail.com>, <python-chinese at lists.python.cn>
Date:    Thu, 28 Jul 2005 22:38:16 +0800
Subject: Re: [python-chinese] 请教一种设计模式。
----------------------------------------------------------------
> 我的意思是每一个imp类都有一组函数，不至fun一个。我希望foo通过调用setType在两种状态切换，比如setType(0)时，调用foo函数时就会调用imp1中的函数，setType(1)时，调用foo函数就转向imp2。我开始想imp1和imp2都继承自data,然后foo再多重继承于imp1和imp2。不行，用__setattr__和__getattr__也不行，试了半天，头都晕了。
> 
> ----- Original Message ----- 
> From: "limodou" <limodou at gmail.com>
> To: <python-chinese at lists.python.cn>
> Sent: Friday, July 29, 2005 10:12 PM
> Subject: Re: [python-chinese] 请教一种设计模式。
> 
> 
> > 既然是个函数，可以不写成类的形式啊，我还是不太懂你想怎 么省事。不过为什么不直接使用函数来处理呢？我改造了一下如下：
> > 
> > class data:
> >     def __init__(self):
> >         self.d = 10
> >     def dfunc(self):
> >         print(self.d)
> >  
> > def fun1(data):
> >     data.d += 10
> >     data.dfunc()
> >  
> > 
> > def fun2(data):
> >     data.d -= 10
> >     data.dfunc()
> >  
> > 
> > class foo:
> >     def __init__(self):
> >         self.__data = data()
> >         self.imp = []
> >         self.imp.append(fun1)
> >         self.imp.append(fun2)
> >         self.curImp = 0
> >        
> >     def fun(self):
> >         self.imp[self.curImp](self.__data)
> >        
> >     def setType(self, type):
> >         self.curImp = type
> >         
> > if __name__ == '__main__':        
> >     #Testing
> >     a = foo()
> >     a.fun()
> >     a.setType(1)
> >     a.fun()
> > 
> > 因为fun1, fun2它们只是函数，只是对参数进行处理的，没必要再保留数据的复本。由调度类foo来保存就好了，它们只是进行即定的处理就行了。
> > 
> > 不太明白你到底想如何简化。
> > 
> > 
> > 在 05-7-28，flyaflya<flyaflyaa at gmail.com> 写道：
> > >  
> > > 忘记叫什么名字了，就是用几组函数处理同一组数据。可以在这几组函数间切换。 
> > > 我的实现是这样： 
> > > class data:
> > >     def __init__(self):
> > >         self.d = 10
> > >     def dfunc(self):
> > >         print(self.d) 
> > >   
> > > class imp1:
> > >     def __init__(self, data):
> > >         self.__data = data 
> > >   
> > >     def fun(self):
> > >         self.__data.d += 10
> > >         self.__data.dfunc() 
> > >   
> > > 
> > > class imp2:
> > >     def __init__(self, data):
> > >         self.__data = data 
> > >   
> > >     def fun(self):
> > >         self.__data.d -= 10
> > >         self.__data.dfunc() 
> > >   
> > > 
> > > class foo:
> > >     def __init__(self):
> > >         self.__data = data()
> > >         self.imp = []
> > >         self.imp.append(imp1(self.__data))
> > >         self.imp.append(imp2(self.__data))
> > >         self.curImp = 0
> > >         
> > >     def fun(self):
> > >         self.imp[self.curImp].fun()
> > >         
> > >     def setType(self, type):
> > >         self.curImp = type 
> > > #测试 
> > > a = foo()
> > > a.fun()
> > > a.setType(1)
> > > a.fun() 
> > > 我希望类foo可以通过setType在imp1和imp2的函数间切换，操作同一组数据data,data中也有一些函数。
> > > 我试了很多各方法，用多重继承，用__getattr__等，都失败了，只有用这种笨办法了，但这样，我在imp1和imp2中每次要操作data中的数据，都很麻烦，大家有什么好方法没
> > >   
> > >   
> > > _______________________________________________
> > > python-chinese list
> > > python-chinese at lists.python.cn
> > > http://python.cn/mailman/listinfo/python-chinese
> > > 
> > > 
> > > 
> > 
> > 
> > -- 
> > I like python! 
> > My Donews Blog: http://www.donews.net/limodou
> > New Google Maillist: http://groups-beta.google.com/group/python-cn
> > 
> 
> 
> --------------------------------------------------------------------------------
> 
> 
> > _______________________________________________
> > python-chinese list
> > python-chinese at lists.python.cn
> > http://python.cn/mailman/listinfo/python-chinese
> > 

--------------------- Original Message Ends --------------------

[导入自Mailman归档：http://www.zeuux.org/pipermail/zeuux-python]

徐继哲

0楼 2005年07月29日星期五 22:54

limodou limodou at gmail.com
Fri Jul 29 22:54:41 HKT 2005

感觉你的问题还是没有描述清啊。

在 05-7-28，flyaflya<flyaflyaa at gmail.com> 写道：
> 我的意思是每一个imp类都有一组函数，不至fun一个。我希望foo通过调用setType在两种状态切换，比如setType(0)时，调用foo函数时就会调用imp1中的函数，setType(1)时，调用foo函数就转向imp2。

这与前面所说"每一个imp类都有一组函数"好象没什么关系呀。

> 我开始想imp1和imp2都继承自data,

为什么把数据和处理混在一起呢？

> 然后foo再多重继承于imp1和imp2。不行，用__setattr__和__getattr__也不行，试了半天，头都晕了。

当然会有问题了。如果imp1和imp2有同名函数就有问题，但也不是不能解决，可以imp1.func(self,...)和imp2.func(self,
...)。imp1和imp2都是类名

但你为了这个不知道的什么模式却忽略了controller模式。把调度与真正的处理，与数据(MVC)混在了一起，不是更不好吗？
> 
> ----- Original Message -----
> From: "limodou" <limodou at gmail.com>
> To: <python-chinese at lists.python.cn>
> Sent: Friday, July 29, 2005 10:12 PM
> Subject: Re: [python-chinese] 请教一种设计模式。
> 
> 
> > 既然是个函数，可以不写成类的形式啊，我还是不太懂你想怎 么省事。不过为什么不直接使用函数来处理呢？我改造了一下如下：
> >
> > class data:
> >     def __init__(self):
> >         self.d = 10
> >     def dfunc(self):
> >         print(self.d)
> >
> > def fun1(data):
> >     data.d += 10
> >     data.dfunc()
> >
> >
> > def fun2(data):
> >     data.d -= 10
> >     data.dfunc()
> >
> >
> > class foo:
> >     def __init__(self):
> >         self.__data = data()
> >         self.imp = []
> >         self.imp.append(fun1)
> >         self.imp.append(fun2)
> >         self.curImp = 0
> >
> >     def fun(self):
> >         self.imp[self.curImp](self.__data)
> >
> >     def setType(self, type):
> >         self.curImp = type
> >
> > if __name__ == '__main__':
> >     #Testing
> >     a = foo()
> >     a.fun()
> >     a.setType(1)
> >     a.fun()
> >
> > 因为fun1, fun2它们只是函数，只是对参数进行处理的，没必要再保留数据的复本。由调度类foo来保存就好了，它们只是进行即定的处理就行了。
> >
> > 不太明白你到底想如何简化。
> >
> >
> > 在 05-7-28，flyaflya<flyaflyaa at gmail.com> 写道：
> > >
> > > 忘记叫什么名字了，就是用几组函数处理同一组数据。可以在这几组函数间切换。
> > > 我的实现是这样：
> > > class data:
> > >     def __init__(self):
> > >         self.d = 10
> > >     def dfunc(self):
> > >         print(self.d)
> > >
> > > class imp1:
> > >     def __init__(self, data):
> > >         self.__data = data
> > >
> > >     def fun(self):
> > >         self.__data.d += 10
> > >         self.__data.dfunc()
> > >
> > >
> > > class imp2:
> > >     def __init__(self, data):
> > >         self.__data = data
> > >
> > >     def fun(self):
> > >         self.__data.d -= 10
> > >         self.__data.dfunc()
> > >
> > >
> > > class foo:
> > >     def __init__(self):
> > >         self.__data = data()
> > >         self.imp = []
> > >         self.imp.append(imp1(self.__data))
> > >         self.imp.append(imp2(self.__data))
> > >         self.curImp = 0
> > >
> > >     def fun(self):
> > >         self.imp[self.curImp].fun()
> > >
> > >     def setType(self, type):
> > >         self.curImp = type
> > > #测试
> > > a = foo()
> > > a.fun()
> > > a.setType(1)
> > > a.fun()
> > > 我希望类foo可以通过setType在imp1和imp2的函数间切换，操作同一组数据data,data中也有一些函数。
> > > 我试了很多各方法，用多重继承，用__getattr__等，都失败了，只有用这种笨办法了，但这样，我在imp1和imp2中每次要操作data中的数据，都很麻烦，大家有什么好方法没
> > >
> > >
> > > _______________________________________________
> > > python-chinese list
> > > python-chinese at lists.python.cn
> > > http://python.cn/mailman/listinfo/python-chinese
> > >
> > >
> > >
> >
> >
> > --
> > I like python!
> > My Donews Blog: http://www.donews.net/limodou
> > New Google Maillist: http://groups-beta.google.com/group/python-cn
> >
> 
> 
> --------------------------------------------------------------------------------
> 
> 
> > _______________________________________________
> > python-chinese list
> > python-chinese at lists.python.cn
> > http://python.cn/mailman/listinfo/python-chinese
> > 


-- 
I like python! 
My Donews Blog: http://www.donews.net/limodou
New Google Maillist: http://groups-beta.google.com/group/python-cn

[导入自Mailman归档：http://www.zeuux.org/pipermail/zeuux-python]

徐继哲

0楼 2005年07月29日星期五 23:06

Hou Ming Yuan houmingyuan at gmail.com
Fri Jul 29 23:06:44 HKT 2005

如果是用C++会定义一个借口类。
我认为呢，这种情况呢，刚好符合设计模式里的算法模式。算法模式要把算法的接口抽象出来，每个具体的算法都从抽象接口继承，我想算法模式看起来会比较清晰一点，虽说要用到继承，从可维护性上来讲也个好一些，接口相当于定了一个协议，如果其他人也要实现另一个算法，他至要遵循这个协议就可以了。
 在05-7-29，张骏 <zhangj at foreseen-info.com> 写道： 
> 
> 你的这个实现不就可以吗?
> 难道一定要用已知的模式实现才是好的吗?
> 
> ----------------------- Original Message -----------------------
> From: "flyaflya" <flyaflyaa at gmail.com>
> To: "limodou" <limodou at gmail.com>, <python-chinese at lists.python.cn>
> Date: Thu, 28 Jul 2005 22:38:16 +0800
> Subject: Re: [python-chinese] 请教一种设计模式。
> ----------------------------------------------------------------
> > 
> 我的意思是每一个imp类都有一组函数，不至fun一个。我希望foo通过调用setType在两种状态切换，比如setType(0)时，调用foo函数时就会调用imp1中的函数，setType(1)时，调用foo函数就转向imp2。我开始想imp1和imp2都继承自data,然后foo再多重继承于imp1和imp2。不行，用__setattr__和__getattr__也不行，试了半天，头都晕了。
> >
> > ----- Original Message -----
> > From: "limodou" <limodou at gmail.com>
> > To: <python-chinese at lists.python.cn>
> > Sent: Friday, July 29, 2005 10:12 PM
> > Subject: Re: [python-chinese] 请教一种设计模式。
> >
> >
> > > 既然是个函数，可以不写成类的形式啊，我还是不太懂你想怎 么省事。不过为什么不直接使用函数来处理呢？我改造了一下如下：
> > >
> > > class data:
> > > def __init__(self):
> > > self.d = 10
> > > def dfunc(self):
> > > print(self.d)
> > >
> > > def fun1(data):
> > > data.d += 10
> > > data.dfunc()
> > >
> > >
> > > def fun2(data):
> > > data.d -= 10
> > > data.dfunc()
> > >
> > >
> > > class foo:
> > > def __init__(self):
> > > self.__data = data()
> > > self.imp = []
> > > self.imp.append(fun1)
> > > self.imp.append(fun2)
> > > self.curImp = 0
> > >
> > > def fun(self):
> > > self.imp[self.curImp](self.__data)
> > >
> > > def setType(self, type):
> > > self.curImp = type
> > >
> > > if __name__ == '__main__':
> > > #Testing
> > > a = foo()
> > > a.fun()
> > > a.setType(1)
> > > a.fun()
> > >
> > > 因为fun1, 
> fun2它们只是函数，只是对参数进行处理的，没必要再保留数据的复本。由调度类foo来保存就好了，它们只是进行即定的处理就行了。
> > >
> > > 不太明白你到底想如何简化。
> > >
> > >
> > > 在 05-7-28，flyaflya<flyaflyaa at gmail.com> 写道：
> > > >
> > > > 忘记叫什么名字了，就是用几组函数处理同一组数据。可以在这几组函数间切换。
> > > > 我的实现是这样：
> > > > class data:
> > > > def __init__(self):
> > > > self.d = 10
> > > > def dfunc(self):
> > > > print(self.d)
> > > >
> > > > class imp1:
> > > > def __init__(self, data):
> > > > self.__data = data
> > > >
> > > > def fun(self):
> > > > self.__data.d += 10
> > > > self.__data.dfunc()
> > > >
> > > >
> > > > class imp2:
> > > > def __init__(self, data):
> > > > self.__data = data
> > > >
> > > > def fun(self):
> > > > self.__data.d -= 10
> > > > self.__data.dfunc()
> > > >
> > > >
> > > > class foo:
> > > > def __init__(self):
> > > > self.__data = data()
> > > > self.imp = []
> > > > self.imp.append(imp1(self.__data))
> > > > self.imp.append(imp2(self.__data))
> > > > self.curImp = 0
> > > >
> > > > def fun(self):
> > > > self.imp[self.curImp].fun()
> > > >
> > > > def setType(self, type):
> > > > self.curImp = type
> > > > #测试
> > > > a = foo()
> > > > a.fun()
> > > > a.setType(1)
> > > > a.fun()
> > > > 我希望类foo可以通过setType在imp1和imp2的函数间切换，操作同一组数据data,data中也有一些函数。
> > > > 
> 我试了很多各方法，用多重继承，用__getattr__等，都失败了，只有用这种笨办法了，但这样，我在imp1和imp2中每次要操作data中的数据，都很麻烦，大家有什么好方法没
> > > >
> > > >
> > > > _______________________________________________
> > > > python-chinese list
> > > > python-chinese at lists.python.cn
> > > > http://python.cn/mailman/listinfo/python-chinese
> > > >
> > > >
> > > >
> > >
> > >
> > > --
> > > I like python!
> > > My Donews Blog: http://www.donews.net/limodou
> > > New Google Maillist: http://groups-beta.google.com/group/python-cn
> > >
> >
> >
> > 
> --------------------------------------------------------------------------------
> >
> >
> > > _______________________________________________
> > > python-chinese list
> > > python-chinese at lists.python.cn
> > > http://python.cn/mailman/listinfo/python-chinese
> > >
> 
> --------------------- Original Message Ends --------------------
> _______________________________________________
> python-chinese list
> python-chinese at lists.python.cn
> http://python.cn/mailman/listinfo/python-chinese
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.exoweb.net/pipermail/python-chinese/attachments/20050729/8553c1bd/attachment.html

[导入自Mailman归档：http://www.zeuux.org/pipermail/zeuux-python]

徐继哲

0楼 2005年07月29日星期五 23:27

He Jinbo hezhihuang at 263.net
Fri Jul 29 23:27:57 HKT 2005

呵呵，我也犯迷糊，不过应该跟以下几种有点关系，关键看你：

抽象工厂                                -〉 主要是负责创建；
状态（或者策略？好像是类似的一个名字）   -〉 根据不同状态/策略采用不同的实现。

区别是其应用目的是为了创建对象还是仅仅关注不同功能的实现（根据策略/状态），根据你所说的，我倾向于后者。

----- Original Message ----- 
From: "flyaflya" <flyaflyaa at gmail.com>
To: "limodou" <limodou at gmail.com>; <python-chinese at lists.python.cn>
Sent: Thursday, July 28, 2005 11:20 PM
Subject: Re: [python-chinese] 请教一种设计模式。


> 我想也只有这样了，想用一下PY的高级功能，呵呵，水平有限，搞不定。
> ----- Original Message ----- 
> From: "limodou" <limodou at gmail.com>
> To: <python-chinese at lists.python.cn>
> Sent: Friday, July 29, 2005 10:54 PM
> Subject: Re: [python-chinese] 请教一种设计模式。
> 
> 
> > 感觉你的问题还是没有描述清啊。
> > 
> > 在 05-7-28，flyaflya<flyaflyaa at gmail.com> 写道：
> > > 我的意思是每一个imp类都有一组函数，不至fun一个。我希望foo通过调用setType在两种状态切换，比如setType(0)时，调用foo函数时就会调用imp1中的函数，setType(1)时，调用foo函数就转向imp2。
> > 
> > 这与前面所说"每一个imp类都有一组函数"好象没什么关系呀。
> > 
> > > 我开始想imp1和imp2都继承自data,
> > 
> > 为什么把数据和处理混在一起呢？
> > 
> > > 然后foo再多重继承于imp1和imp2。不行，用__setattr__和__getattr__也不行，试了半天，头都晕了。
> > 
> > 当然会有问题了。如果imp1和imp2有同名函数就有问题，但也不是不能解决，可以imp1.func(self,...)和imp2.func(self,
> > ...)。imp1和imp2都是类名
> > 
> > 但你为了这个不知道的什么模式却忽略了controller模式。把调度与真正的处理，与数据(MVC)混在了一起，不是更不好吗？
> > > 
> > > ----- Original Message -----
> > > From: "limodou" <limodou at gmail.com>
> > > To: <python-chinese at lists.python.cn>
> > > Sent: Friday, July 29, 2005 10:12 PM
> > > Subject: Re: [python-chinese] 请教一种设计模式。
> > > 
> > > 
> > > > 既然是个函数，可以不写成类的形式啊，我还是不太懂你想怎 么省事。不过为什么不直接使用函数来处理呢？我改造了一下如下：
> > > >
> > > > class data:
> > > >     def __init__(self):
> > > >         self.d = 10
> > > >     def dfunc(self):
> > > >         print(self.d)
> > > >
> > > > def fun1(data):
> > > >     data.d += 10
> > > >     data.dfunc()
> > > >
> > > >
> > > > def fun2(data):
> > > >     data.d -= 10
> > > >     data.dfunc()
> > > >
> > > >
> > > > class foo:
> > > >     def __init__(self):
> > > >         self.__data = data()
> > > >         self.imp = []
> > > >         self.imp.append(fun1)
> > > >         self.imp.append(fun2)
> > > >         self.curImp = 0
> > > >
> > > >     def fun(self):
> > > >         self.imp[self.curImp](self.__data)
> > > >
> > > >     def setType(self, type):
> > > >         self.curImp = type
> > > >
> > > > if __name__ == '__main__':
> > > >     #Testing
> > > >     a = foo()
> > > >     a.fun()
> > > >     a.setType(1)
> > > >     a.fun()
> > > >
> > > > 因为fun1, fun2它们只是函数，只是对参数进行处理的，没必要再保留数据的复本。由调度类foo来保存就好了，它们只是进行即定的处理就行了。
> > > >
> > > > 不太明白你到底想如何简化。
> > > >
> > > >
> > > > 在 05-7-28，flyaflya<flyaflyaa at gmail.com> 写道：
> > > > >
> > > > > 忘记叫什么名字了，就是用几组函数处理同一组数据。可以在这几组函数间切换。
> > > > > 我的实现是这样：
> > > > > class data:
> > > > >     def __init__(self):
> > > > >         self.d = 10
> > > > >     def dfunc(self):
> > > > >         print(self.d)
> > > > >
> > > > > class imp1:
> > > > >     def __init__(self, data):
> > > > >         self.__data = data
> > > > >
> > > > >     def fun(self):
> > > > >         self.__data.d += 10
> > > > >         self.__data.dfunc()
> > > > >
> > > > >
> > > > > class imp2:
> > > > >     def __init__(self, data):
> > > > >         self.__data = data
> > > > >
> > > > >     def fun(self):
> > > > >         self.__data.d -= 10
> > > > >         self.__data.dfunc()
> > > > >
> > > > >
> > > > > class foo:
> > > > >     def __init__(self):
> > > > >         self.__data = data()
> > > > >         self.imp = []
> > > > >         self.imp.append(imp1(self.__data))
> > > > >         self.imp.append(imp2(self.__data))
> > > > >         self.curImp = 0
> > > > >
> > > > >     def fun(self):
> > > > >         self.imp[self.curImp].fun()
> > > > >
> > > > >     def setType(self, type):
> > > > >         self.curImp = type
> > > > > #测试
> > > > > a = foo()
> > > > > a.fun()
> > > > > a.setType(1)
> > > > > a.fun()
> > > > > 我希望类foo可以通过setType在imp1和imp2的函数间切换，操作同一组数据data,data中也有一些函数。
> > > > > 我试了很多各方法，用多重继承，用__getattr__等，都失败了，只有用这种笨办法了，但这样，我在imp1和imp2中每次要操作data中的数据，都很麻烦，大家有什么好方法没
> > > > >
> > > > >
> > > > > _______________________________________________
> > > > > python-chinese list
> > > > > python-chinese at lists.python.cn
> > > > > http://python.cn/mailman/listinfo/python-chinese
> > > > >
> > > > >
> > > > >
> > > >
> > > >
> > > > --
> > > > I like python!
> > > > My Donews Blog: http://www.donews.net/limodou
> > > > New Google Maillist: http://groups-beta.google.com/group/python-cn
> > > >
> > > 
> > > 
> > > --------------------------------------------------------------------------------
> > > 
> > > 
> > > > _______________________________________________
> > > > python-chinese list
> > > > python-chinese at lists.python.cn
> > > > http://python.cn/mailman/listinfo/python-chinese
> > > > 
> > 
> > 
> > -- 
> > I like python! 
> > My Donews Blog: http://www.donews.net/limodou
> > New Google Maillist: http://groups-beta.google.com/group/python-cn
> > 
> 
> 
> --------------------------------------------------------------------------------
> 
> 
> > _______________________________________________
> > python-chinese list
> > python-chinese at lists.python.cn
> > http://python.cn/mailman/listinfo/python-chinese
> >


--------------------------------------------------------------------------------


> _______________________________________________
> python-chinese list
> python-chinese at lists.python.cn
> http://python.cn/mailman/listinfo/python-chinese
>

[导入自Mailman归档：http://www.zeuux.org/pipermail/zeuux-python]

徐继哲

0楼 2005年07月30日星期六 08:07

Qiangning Hong hongqn at gmail.com
Sat Jul 30 08:07:41 HKT 2005

我倒是觉得limodou给出的那种方式很pythonic。
在python里，函数是first-class objects. 用来表示算法最合适不过了。
不是说非要用到继承、元类才叫优雅的。可读性、可维护性第一。

你看看GoF书里Strategy模式(第315y页)，不也只是用了一个简单的接口类吗。在python里，由于是动态语言，连接口类都不需要定义，那就连继承也不需要了。
你的这个模式其实就是Strategy模式的变种，给它增加了动态切换算法的功能而已。

On 7/28/05, flyaflya <flyaflyaa at gmail.com> wrote:
> 这种模式不方便，也没有用到继承，元什么的。不优雅，呵呵。先这样用吧，什么时候把PY的模式整理一下，用起来就方便了。现在只会很少的几种。
> 
> ----- Original Message -----
> From: "张骏" <zhangj at foreseen-info.com>
> To: <python-chinese at lists.python.cn>
> Sent: Friday, July 29, 2005 10:44 PM
> Subject: Re: [python-chinese] 请教一种设计模式。
> 
> 
> > 你的这个实现不就可以吗?
> > 难道一定要用已知的模式实现才是好的吗?
> >
> > ----------------------- Original Message -----------------------
> > From:    "flyaflya" <flyaflyaa at gmail.com>
> > To:      "limodou" <limodou at gmail.com>, <python-chinese at lists.python.cn>
> > Date:    Thu, 28 Jul 2005 22:38:16 +0800
> > Subject: Re: [python-chinese] 请教一种设计模式。
> > ----------------------------------------------------------------
> > > 我的意思是每一个imp类都有一组函数，不至fun一个。我希望foo通过调用setType在两种状态切换，比如setType(0)时，调用foo函数时就会调用imp1中的函数，setType(1)时，调用foo函数就转向imp2。我开始想imp1和imp2都继承自data,然后foo再多重继承于imp1和imp2。不行，用__setattr__和__getattr__也不行，试了半天，头都晕了。
> > >
> > > ----- Original Message -----
> > > From: "limodou" <limodou at gmail.com>
> > > To: <python-chinese at lists.python.cn>
> > > Sent: Friday, July 29, 2005 10:12 PM
> > > Subject: Re: [python-chinese] 请教一种设计模式。
> > >
> > >
> > > > 既然是个函数，可以不写成类的形式啊，我还是不太懂你想怎 么省事。不过为什么不直接使用函数来处理呢？我改造了一下如下：
> > > >
> > > > class data:
> > > >     def __init__(self):
> > > >         self.d = 10
> > > >     def dfunc(self):
> > > >         print(self.d)
> > > >
> > > > def fun1(data):
> > > >     data.d += 10
> > > >     data.dfunc()
> > > >
> > > >
> > > > def fun2(data):
> > > >     data.d -= 10
> > > >     data.dfunc()
> > > >
> > > >
> > > > class foo:
> > > >     def __init__(self):
> > > >         self.__data = data()
> > > >         self.imp = []
> > > >         self.imp.append(fun1)
> > > >         self.imp.append(fun2)
> > > >         self.curImp = 0
> > > >
> > > >     def fun(self):
> > > >         self.imp[self.curImp](self.__data)
> > > >
> > > >     def setType(self, type):
> > > >         self.curImp = type
> > > >
> > > > if __name__ == '__main__':
> > > >     #Testing
> > > >     a = foo()
> > > >     a.fun()
> > > >     a.setType(1)
> > > >     a.fun()
> > > >
> > > > 因为fun1, fun2它们只是函数，只是对参数进行处理的，没必要再保留数据的复本。由调度类foo来保存就好了，它们只是进行即定的处理就行了。
> > > >
> > > > 不太明白你到底想如何简化。
> > > >
> > > >
> > > > 在 05-7-28，flyaflya<flyaflyaa at gmail.com> 写道：
> > > > >
> > > > > 忘记叫什么名字了，就是用几组函数处理同一组数据。可以在这几组函数间切换。
> > > > > 我的实现是这样：
> > > > > class data:
> > > > >     def __init__(self):
> > > > >         self.d = 10
> > > > >     def dfunc(self):
> > > > >         print(self.d)
> > > > >
> > > > > class imp1:
> > > > >     def __init__(self, data):
> > > > >         self.__data = data
> > > > >
> > > > >     def fun(self):
> > > > >         self.__data.d += 10
> > > > >         self.__data.dfunc()
> > > > >
> > > > >
> > > > > class imp2:
> > > > >     def __init__(self, data):
> > > > >         self.__data = data
> > > > >
> > > > >     def fun(self):
> > > > >         self.__data.d -= 10
> > > > >         self.__data.dfunc()
> > > > >
> > > > >
> > > > > class foo:
> > > > >     def __init__(self):
> > > > >         self.__data = data()
> > > > >         self.imp = []
> > > > >         self.imp.append(imp1(self.__data))
> > > > >         self.imp.append(imp2(self.__data))
> > > > >         self.curImp = 0
> > > > >
> > > > >     def fun(self):
> > > > >         self.imp[self.curImp].fun()
> > > > >
> > > > >     def setType(self, type):
> > > > >         self.curImp = type
> > > > > #测试
> > > > > a = foo()
> > > > > a.fun()
> > > > > a.setType(1)
> > > > > a.fun()
> > > > > 我希望类foo可以通过setType在imp1和imp2的函数间切换，操作同一组数据data,data中也有一些函数。
> > > > > 我试了很多各方法，用多重继承，用__getattr__等，都失败了，只有用这种笨办法了，但这样，我在imp1和imp2中每次要操作data中的数据，都很麻烦，大家有什么好方法没
> > > > >
> > > > >
> > > > > _______________________________________________
> > > > > python-chinese list
> > > > > python-chinese at lists.python.cn
> > > > > http://python.cn/mailman/listinfo/python-chinese
> > > > >
> > > > >
> > > > >
> > > >
> > > >
> > > > --
> > > > I like python!
> > > > My Donews Blog: http://www.donews.net/limodou
> > > > New Google Maillist: http://groups-beta.google.com/group/python-cn
> > > >
> > >
> > >
> > > --------------------------------------------------------------------------------
> > >
> > >
> > > > _______________________________________________
> > > > python-chinese list
> > > > python-chinese at lists.python.cn
> > > > http://python.cn/mailman/listinfo/python-chinese
> > > >
> >
> > --------------------- Original Message Ends --------------------
> > _______________________________________________
> > python-chinese list
> > python-chinese at lists.python.cn
> > http://python.cn/mailman/listinfo/python-chinese
> _______________________________________________
> python-chinese list
> python-chinese at lists.python.cn
> http://python.cn/mailman/listinfo/python-chinese
> 
> 
> 


-- 
Qiangning Hong

I'm usually annoyed by IDEs because, for instance, they don't use VIM
as an editor. Since I'm hooked to that, all IDEs I've used so far have
failed to impress me.
   -- Sybren Stuvel @ c.l.python

Get Firefox! <http://www.spreadfirefox.com/?q=affiliates&id=67907&t=1>

[导入自Mailman归档：http://www.zeuux.org/pipermail/zeuux-python]

徐继哲

0楼 2005年07月30日星期六 08:39

nEO gentoo.cn at gmail.com
Sat Jul 30 08:39:46 HKT 2005

关于python和设计模式
介绍几片文章
http://www-128.ibm.com/developerworks/cn/linux/l-pypt/part1/
http://www-128.ibm.com/developerworks/cn/linux/l-pypt/part2/
http://www-128.ibm.com/developerworks/cn/linux/l-pypt/part3/
http://www-128.ibm.com/developerworks/cn/linux/l-pypt/part4/

不知道xiaowenpeng订阅了这个列表没有


在05-7-29，flyaflya <flyaflyaa at gmail.com> 写道：
> 
> 
> 关键不是在两个函数间切换，是在两组函数间切换，是完完全全的Strategy模式。在impl中不仅要有fun1，还要有fun2.....许多需要的函数。
> 
> ----- Original Message -----
> From: "Qiangning Hong" <hongqn at gmail.com>
> To: <python-chinese at lists.python.cn>
> Sent: Saturday, July 30, 2005 8:07 AM
> Subject: Re: [python-chinese] 请教一种设计模式。
> 
> 
> > 我倒是觉得limodou给出的那种方式很pythonic。
> > 在python里，函数是first-class objects. 用来表示算法最合适不过了。
> > 不是说非要用到继承、元类才叫优雅的。可读性、可维护性第一。
> >
> > 
> 你看看GoF书里Strategy模式(第315y页)，不也只是用了一个简单的接口类吗。在python里，由于是动态语言，连接口类都不需要定义，那就连继承也不需要了。
> > 你的这个模式其实就是Strategy模式的变种，给它增加了动态切换算法的功能而已。
> >
> > On 7/28/05, flyaflya <flyaflyaa at gmail.com> wrote:
> > > 这种模式不方便，也没有用到继承，元什么的。不优雅，呵呵。先这样用吧，什么时候把PY的模式整理一下，用起来就方便了。现在只会很少的几种。
> > >
> > > ----- Original Message -----
> > > From: "张骏" <zhangj at foreseen-info.com>
> > > To: <python-chinese at lists.python.cn>
> > > Sent: Friday, July 29, 2005 10:44 PM
> > > Subject: Re: [python-chinese] 请教一种设计模式。
> > >
> > >
> > > > 你的这个实现不就可以吗?
> > > > 难道一定要用已知的模式实现才是好的吗?
> > > >
> > > > ----------------------- Original Message -----------------------
> > > > From: "flyaflya" <flyaflyaa at gmail.com>
> > > > To: "limodou" <limodou at gmail.com>, <python-chinese at lists.python.cn>
> > > > Date: Thu, 28 Jul 2005 22:38:16 +0800
> > > > Subject: Re: [python-chinese] 请教一种设计模式。
> > > > ----------------------------------------------------------------
> > > > > 
> 我的意思是每一个imp类都有一组函数，不至fun一个。我希望foo通过调用setType在两种状态切换，比如setType(0)时，调用foo函数时就会调用imp1中的函数，setType(1)时，调用foo函数就转向imp2。我开始想imp1和imp2都继承自data,然后foo再多重继承于imp1和imp2。不行，用__setattr__和__getattr__也不行，试了半天，头都晕了。
> > > > >
> > > > > ----- Original Message -----
> > > > > From: "limodou" <limodou at gmail.com>
> > > > > To: <python-chinese at lists.python.cn>
> > > > > Sent: Friday, July 29, 2005 10:12 PM
> > > > > Subject: Re: [python-chinese] 请教一种设计模式。
> > > > >
> > > > >
> > > > > > 既然是个函数，可以不写成类的形式啊，我还是不太懂你想怎 么省事。不过为什么不直接使用函数来处理呢？我改造了一下如下：
> > > > > >
> > > > > > class data:
> > > > > > def __init__(self):
> > > > > > self.d = 10
> > > > > > def dfunc(self):
> > > > > > print(self.d)
> > > > > >
> > > > > > def fun1(data):
> > > > > > data.d += 10
> > > > > > data.dfunc()
> > > > > >
> > > > > >
> > > > > > def fun2(data):
> > > > > > data.d -= 10
> > > > > > data.dfunc()
> > > > > >
> > > > > >
> > > > > > class foo:
> > > > > > def __init__(self):
> > > > > > self.__data = data()
> > > > > > self.imp = []
> > > > > > self.imp.append(fun1)
> > > > > > self.imp.append(fun2)
> > > > > > self.curImp = 0
> > > > > >
> > > > > > def fun(self):
> > > > > > self.imp[self.curImp](self.__data)
> > > > > >
> > > > > > def setType(self, type):
> > > > > > self.curImp = type
> > > > > >
> > > > > > if __name__ == '__main__':
> > > > > > #Testing
> > > > > > a = foo()
> > > > > > a.fun()
> > > > > > a.setType(1)
> > > > > > a.fun()
> > > > > >
> > > > > > 因为fun1, 
> fun2它们只是函数，只是对参数进行处理的，没必要再保留数据的复本。由调度类foo来保存就好了，它们只是进行即定的处理就行了。
> > > > > >
> > > > > > 不太明白你到底想如何简化。
> > > > > >
> > > > > >
> > > > > > 在 05-7-28，flyaflya<flyaflyaa at gmail.com> 写道：
> > > > > > >
> > > > > > > 忘记叫什么名字了，就是用几组函数处理同一组数据。可以在这几组函数间切换。
> > > > > > > 我的实现是这样：
> > > > > > > class data:
> > > > > > > def __init__(self):
> > > > > > > self.d = 10
> > > > > > > def dfunc(self):
> > > > > > > print(self.d)
> > > > > > >
> > > > > > > class imp1:
> > > > > > > def __init__(self, data):
> > > > > > > self.__data = data
> > > > > > >
> > > > > > > def fun(self):
> > > > > > > self.__data.d += 10
> > > > > > > self.__data.dfunc()
> > > > > > >
> > > > > > >
> > > > > > > class imp2:
> > > > > > > def __init__(self, data):
> > > > > > > self.__data = data
> > > > > > >
> > > > > > > def fun(self):
> > > > > > > self.__data.d -= 10
> > > > > > > self.__data.dfunc()
> > > > > > >
> > > > > > >
> > > > > > > class foo:
> > > > > > > def __init__(self):
> > > > > > > self.__data = data()
> > > > > > > self.imp = []
> > > > > > > self.imp.append(imp1(self.__data))
> > > > > > > self.imp.append(imp2(self.__data))
> > > > > > > self.curImp = 0
> > > > > > >
> > > > > > > def fun(self):
> > > > > > > self.imp[self.curImp].fun()
> > > > > > >
> > > > > > > def setType(self, type):
> > > > > > > self.curImp = type
> > > > > > > #测试
> > > > > > > a = foo()
> > > > > > > a.fun()
> > > > > > > a.setType(1)
> > > > > > > a.fun()
> > > > > > > 我希望类foo可以通过setType在imp1和imp2的函数间切换，操作同一组数据data,data中也有一些函数。
> > > > > > > 
> 我试了很多各方法，用多重继承，用__getattr__等，都失败了，只有用这种笨办法了，但这样，我在imp1和imp2中每次要操作data中的数据，都很麻烦，大家有什么好方法没
> > > > > > >
> > > > > > >
> > > > > > > _______________________________________________
> > > > > > > python-chinese list
> > > > > > > python-chinese at lists.python.cn
> > > > > > > http://python.cn/mailman/listinfo/python-chinese
> > > > > > >
> > > > > > >
> > > > > > >
> > > > > >
> > > > > >
> > > > > > --
> > > > > > I like python!
> > > > > > My Donews Blog: http://www.donews.net/limodou
> > > > > > New Google Maillist: 
> http://groups-beta.google.com/group/python-cn
> > > > > >
> > > > >
> > > > >
> > > > > 
> --------------------------------------------------------------------------------
> > > > >
> > > > >
> > > > > > _______________________________________________
> > > > > > python-chinese list
> > > > > > python-chinese at lists.python.cn
> > > > > > http://python.cn/mailman/listinfo/python-chinese
> > > > > >
> > > >
> > > > --------------------- Original Message Ends --------------------
> > > > _______________________________________________
> > > > python-chinese list
> > > > python-chinese at lists.python.cn
> > > > http://python.cn/mailman/listinfo/python-chinese
> > > _______________________________________________
> > > python-chinese list
> > > python-chinese at lists.python.cn
> > > http://python.cn/mailman/listinfo/python-chinese
> > >
> > >
> > >
> >
> >
> > --
> > Qiangning Hong
> >
> > I'm usually annoyed by IDEs because, for instance, they don't use VIM
> > as an editor. Since I'm hooked to that, all IDEs I've used so far have
> > failed to impress me.
> > -- Sybren Stuvel @ c.l.python
> >
> > Get Firefox! <
> http://www.spreadfirefox.com/?q=affiliates&id=67907&t=1>
> >
> 
> 
> 
> --------------------------------------------------------------------------------
> 
> 
> > _______________________________________________
> > python-chinese list
> > python-chinese at lists.python.cn
> > http://python.cn/mailman/listinfo/python-chinese
> > 
> _______________________________________________
> python-chinese list
> python-chinese at lists.python.cn
> http://python.cn/mailman/listinfo/python-chinese
> 
> 
> 


-- 
I'm the one, powered by nEO
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.exoweb.net/pipermail/python-chinese/attachments/20050730/4a8ea352/attachment-0001.html

[导入自Mailman归档：http://www.zeuux.org/pipermail/zeuux-python]

徐继哲

0楼 2005年07月30日星期六 08:48

Qiangning Hong hongqn at gmail.com
Sat Jul 30 08:48:55 HKT 2005

那也只需要使用类把相关函数包装即可，不用把数据作为算法类的成员。

class Imp1(object):
    def fun1(self, data):
        ...

    def fun2(self, data):
        ...

class Foo(object):
    def __init__(self):
        self.__data = Data()
        self.imps = [Imp1(), Imp2()]
        self.type = 0

   def fun1(self):
        self.imps[self.type].fun1(self.__data)

   def fun2(self):
        self.imps[self.type].fun2(self.__data)


另外，如果你的这个Foo的作用仅仅是在几个Imp中间选择一个作代理的话，那就不是Strategy模式了。可以用Proxy模式来实现：

[Imp1, Imp2... 定义同上]

class ImpChooser(object):
    def __init__(self):
        self.imps = [Imp1(), Imp2()]
        self.cur_imp = 0

    def choose(self, type):
        self.cur_imp = type

    def __getattr__(self, attr):
        if attr == 'choose':
            return self.choose
        else:
            return getattr(self.imps[self.cur_imp], attr)

因为仅仅是包装了算法,所以就不保存data了。

使用方法：

data = Data()
imp = ImpChooser()
imp.fun1(data)
imp.choose(1)
imp.fun2(data)


On 7/29/05, flyaflya <flyaflyaa at gmail.com> wrote:
> 关键不是在两个函数间切换，是在两组函数间切换，是完完全全的Strategy模式。在impl中不仅要有fun1，还要有fun2.....许多需要的函数。
> 
> ----- Original Message -----
> From: "Qiangning Hong" <hongqn at gmail.com>
> To: <python-chinese at lists.python.cn>
> Sent: Saturday, July 30, 2005 8:07 AM
> Subject: Re: [python-chinese] 请教一种设计模式。
> 
> 
> > 我倒是觉得limodou给出的那种方式很pythonic。
> > 在python里，函数是first-class objects. 用来表示算法最合适不过了。
> > 不是说非要用到继承、元类才叫优雅的。可读性、可维护性第一。
> >
> > 你看看GoF书里Strategy模式(第315y页)，不也只是用了一个简单的接口类吗。在python里，由于是动态语言，连接口类都不需要定义，那就连继承也不需要了。
> > 你的这个模式其实就是Strategy模式的变种，给它增加了动态切换算法的功能而已。
> >
> > On 7/28/05, flyaflya <flyaflyaa at gmail.com> wrote:
> > > 这种模式不方便，也没有用到继承，元什么的。不优雅，呵呵。先这样用吧，什么时候把PY的模式整理一下，用起来就方便了。现在只会很少的几种。
> > >
> > > ----- Original Message -----
> > > From: "张骏" <zhangj at foreseen-info.com>
> > > To: <python-chinese at lists.python.cn>
> > > Sent: Friday, July 29, 2005 10:44 PM
> > > Subject: Re: [python-chinese] 请教一种设计模式。
> > >
> > >
> > > > 你的这个实现不就可以吗?
> > > > 难道一定要用已知的模式实现才是好的吗?
> > > >
> > > > ----------------------- Original Message -----------------------
> > > > From:    "flyaflya" <flyaflyaa at gmail.com>
> > > > To:      "limodou" <limodou at gmail.com>, <python-chinese at lists.python.cn>
> > > > Date:    Thu, 28 Jul 2005 22:38:16 +0800
> > > > Subject: Re: [python-chinese] 请教一种设计模式。
> > > > ----------------------------------------------------------------
> > > > > 我的意思是每一个imp类都有一组函数，不至fun一个。我希望foo通过调用setType在两种状态切换，比如setType(0)时，调用foo函数时就会调用imp1中的函数，setType(1)时，调用foo函数就转向imp2。我开始想imp1和imp2都继承自data,然后foo再多重继承于imp1和imp2。不行，用__setattr__和__getattr__也不行，试了半天，头都晕了。
> > > > >
> > > > > ----- Original Message -----
> > > > > From: "limodou" <limodou at gmail.com>
> > > > > To: <python-chinese at lists.python.cn>
> > > > > Sent: Friday, July 29, 2005 10:12 PM
> > > > > Subject: Re: [python-chinese] 请教一种设计模式。
> > > > >
> > > > >
> > > > > > 既然是个函数，可以不写成类的形式啊，我还是不太懂你想怎 么省事。不过为什么不直接使用函数来处理呢？我改造了一下如下：
> > > > > >
> > > > > > class data:
> > > > > >     def __init__(self):
> > > > > >         self.d = 10
> > > > > >     def dfunc(self):
> > > > > >         print(self.d)
> > > > > >
> > > > > > def fun1(data):
> > > > > >     data.d += 10
> > > > > >     data.dfunc()
> > > > > >
> > > > > >
> > > > > > def fun2(data):
> > > > > >     data.d -= 10
> > > > > >     data.dfunc()
> > > > > >
> > > > > >
> > > > > > class foo:
> > > > > >     def __init__(self):
> > > > > >         self.__data = data()
> > > > > >         self.imp = []
> > > > > >         self.imp.append(fun1)
> > > > > >         self.imp.append(fun2)
> > > > > >         self.curImp = 0
> > > > > >
> > > > > >     def fun(self):
> > > > > >         self.imp[self.curImp](self.__data)
> > > > > >
> > > > > >     def setType(self, type):
> > > > > >         self.curImp = type
> > > > > >
> > > > > > if __name__ == '__main__':
> > > > > >     #Testing
> > > > > >     a = foo()
> > > > > >     a.fun()
> > > > > >     a.setType(1)
> > > > > >     a.fun()
> > > > > >
> > > > > > 因为fun1, fun2它们只是函数，只是对参数进行处理的，没必要再保留数据的复本。由调度类foo来保存就好了，它们只是进行即定的处理就行了。
> > > > > >
> > > > > > 不太明白你到底想如何简化。
> > > > > >
> > > > > >
> > > > > > 在 05-7-28，flyaflya<flyaflyaa at gmail.com> 写道：
> > > > > > >
> > > > > > > 忘记叫什么名字了，就是用几组函数处理同一组数据。可以在这几组函数间切换。
> > > > > > > 我的实现是这样：
> > > > > > > class data:
> > > > > > >     def __init__(self):
> > > > > > >         self.d = 10
> > > > > > >     def dfunc(self):
> > > > > > >         print(self.d)
> > > > > > >
> > > > > > > class imp1:
> > > > > > >     def __init__(self, data):
> > > > > > >         self.__data = data
> > > > > > >
> > > > > > >     def fun(self):
> > > > > > >         self.__data.d += 10
> > > > > > >         self.__data.dfunc()
> > > > > > >
> > > > > > >
> > > > > > > class imp2:
> > > > > > >     def __init__(self, data):
> > > > > > >         self.__data = data
> > > > > > >
> > > > > > >     def fun(self):
> > > > > > >         self.__data.d -= 10
> > > > > > >         self.__data.dfunc()
> > > > > > >
> > > > > > >
> > > > > > > class foo:
> > > > > > >     def __init__(self):
> > > > > > >         self.__data = data()
> > > > > > >         self.imp = []
> > > > > > >         self.imp.append(imp1(self.__data))
> > > > > > >         self.imp.append(imp2(self.__data))
> > > > > > >         self.curImp = 0
> > > > > > >
> > > > > > >     def fun(self):
> > > > > > >         self.imp[self.curImp].fun()
> > > > > > >
> > > > > > >     def setType(self, type):
> > > > > > >         self.curImp = type
> > > > > > > #测试
> > > > > > > a = foo()
> > > > > > > a.fun()
> > > > > > > a.setType(1)
> > > > > > > a.fun()
> > > > > > > 我希望类foo可以通过setType在imp1和imp2的函数间切换，操作同一组数据data,data中也有一些函数。
> > > > > > > 我试了很多各方法，用多重继承，用__getattr__等，都失败了，只有用这种笨办法了，但这样，我在imp1和imp2中每次要操作data中的数据，都很麻烦，大家有什么好方法没
> > > > > > >
> > > > > > >
> > > > > > > _______________________________________________
> > > > > > > python-chinese list
> > > > > > > python-chinese at lists.python.cn
> > > > > > > http://python.cn/mailman/listinfo/python-chinese
> > > > > > >
> > > > > > >
> > > > > > >
> > > > > >
> > > > > >
> > > > > > --
> > > > > > I like python!
> > > > > > My Donews Blog: http://www.donews.net/limodou
> > > > > > New Google Maillist: http://groups-beta.google.com/group/python-cn
> > > > > >
> > > > >
> > > > >
> > > > > --------------------------------------------------------------------------------
> > > > >
> > > > >
> > > > > > _______________________________________________
> > > > > > python-chinese list
> > > > > > python-chinese at lists.python.cn
> > > > > > http://python.cn/mailman/listinfo/python-chinese
> > > > > >
> > > >
> > > > --------------------- Original Message Ends --------------------
> > > > _______________________________________________
> > > > python-chinese list
> > > > python-chinese at lists.python.cn
> > > > http://python.cn/mailman/listinfo/python-chinese
> > > _______________________________________________
> > > python-chinese list
> > > python-chinese at lists.python.cn
> > > http://python.cn/mailman/listinfo/python-chinese
> > >
> > >
> > >
> >
> >
> > --
> > Qiangning Hong
> >
> > I'm usually annoyed by IDEs because, for instance, they don't use VIM
> > as an editor. Since I'm hooked to that, all IDEs I've used so far have
> > failed to impress me.
> >    -- Sybren Stuvel @ c.l.python
> >
> > Get Firefox! <http://www.spreadfirefox.com/?q=affiliates&id=67907&t=1>
> >
> 
> 
> --------------------------------------------------------------------------------
> 
> 
> > _______________________________________________
> > python-chinese list
> > python-chinese at lists.python.cn
> > http://python.cn/mailman/listinfo/python-chinese
> > 
> _______________________________________________
> python-chinese list
> python-chinese at lists.python.cn
> http://python.cn/mailman/listinfo/python-chinese
> 
> 
> 


-- 
Qiangning Hong

I'm usually annoyed by IDEs because, for instance, they don't use VIM
as an editor. Since I'm hooked to that, all IDEs I've used so far have
failed to impress me.
   -- Sybren Stuvel @ c.l.python

Get Firefox! <http://www.spreadfirefox.com/?q=affiliates&id=67907&t=1>

[导入自Mailman归档：http://www.zeuux.org/pipermail/zeuux-python]

徐继哲

0楼 2005年07月31日星期日 14:16

flyaflya flyaflyaa at gmail.com
Sun Jul 31 14:16:37 HKT 2005

已经想到了方法，proxy和state模式结合使用可以完美的解决。是在整理wiki上设计模式页面时想到的。已经整理了8各设计模式，收获很大啊。
----- Original Message ----- 
From: "Qiangning Hong" <hongqn at gmail.com>
To: <python-chinese at lists.python.cn>
Sent: Saturday, July 30, 2005 8:48 AM
Subject: Re: [python-chinese] 请教一种设计模式。


> 那也只需要使用类把相关函数包装即可，不用把数据作为算法类的成员。
> 
> class Imp1(object):
>     def fun1(self, data):
>         ...
> 
>     def fun2(self, data):
>         ...
> 
> class Foo(object):
>     def __init__(self):
>         self.__data = Data()
>         self.imps = [Imp1(), Imp2()]
>         self.type = 0
> 
>    def fun1(self):
>         self.imps[self.type].fun1(self.__data)
> 
>    def fun2(self):
>         self.imps[self.type].fun2(self.__data)
> 
> 
> 另外，如果你的这个Foo的作用仅仅是在几个Imp中间选择一个作代理的话，那就不是Strategy模式了。可以用Proxy模式来实现：
> 
> [Imp1, Imp2... 定义同上]
> 
> class ImpChooser(object):
>     def __init__(self):
>         self.imps = [Imp1(), Imp2()]
>         self.cur_imp = 0
> 
>     def choose(self, type):
>         self.cur_imp = type
> 
>     def __getattr__(self, attr):
>         if attr == 'choose':
>             return self.choose
>         else:
>             return getattr(self.imps[self.cur_imp], attr)
> 
> 因为仅仅是包装了算法,所以就不保存data了。
> 
> 使用方法：
> 
> data = Data()
> imp = ImpChooser()
> imp.fun1(data)
> imp.choose(1)
> imp.fun2(data)
> 
> 
> On 7/29/05, flyaflya <flyaflyaa at gmail.com> wrote:
> > 关键不是在两个函数间切换，是在两组函数间切换，是完完全全的Strategy模式。在impl中不仅要有fun1，还要有fun2.....许多需要的函数。
> > 
> > ----- Original Message -----
> > From: "Qiangning Hong" <hongqn at gmail.com>
> > To: <python-chinese at lists.python.cn>
> > Sent: Saturday, July 30, 2005 8:07 AM
> > Subject: Re: [python-chinese] 请教一种设计模式。
> > 
> > 
> > > 我倒是觉得limodou给出的那种方式很pythonic。
> > > 在python里，函数是first-class objects. 用来表示算法最合适不过了。
> > > 不是说非要用到继承、元类才叫优雅的。可读性、可维护性第一。
> > >
> > > 你看看GoF书里Strategy模式(第315y页)，不也只是用了一个简单的接口类吗。在python里，由于是动态语言，连接口类都不需要定义，那就连继承也不需要了。
> > > 你的这个模式其实就是Strategy模式的变种，给它增加了动态切换算法的功能而已。
> > >
> > > On 7/28/05, flyaflya <flyaflyaa at gmail.com> wrote:
> > > > 这种模式不方便，也没有用到继承，元什么的。不优雅，呵呵。先这样用吧，什么时候把PY的模式整理一下，用起来就方便了。现在只会很少的几种。
> > > >
> > > > ----- Original Message -----
> > > > From: "张骏" <zhangj at foreseen-info.com>
> > > > To: <python-chinese at lists.python.cn>
> > > > Sent: Friday, July 29, 2005 10:44 PM
> > > > Subject: Re: [python-chinese] 请教一种设计模式。
> > > >
> > > >
> > > > > 你的这个实现不就可以吗?
> > > > > 难道一定要用已知的模式实现才是好的吗?
> > > > >
> > > > > ----------------------- Original Message -----------------------
> > > > > From:    "flyaflya" <flyaflyaa at gmail.com>
> > > > > To:      "limodou" <limodou at gmail.com>, <python-chinese at lists.python.cn>
> > > > > Date:    Thu, 28 Jul 2005 22:38:16 +0800
> > > > > Subject: Re: [python-chinese] 请教一种设计模式。
> > > > > ----------------------------------------------------------------
> > > > > > 我的意思是每一个imp类都有一组函数，不至fun一个。我希望foo通过调用setType在两种状态切换，比如setType(0)时，调用foo函数时就会调用imp1中的函数，setType(1)时，调用foo函数就转向imp2。我开始想imp1和imp2都继承自data,然后foo再多重继承于imp1和imp2。不行，用__setattr__和__getattr__也不行，试了半天，头都晕了。
> > > > > >
> > > > > > ----- Original Message -----
> > > > > > From: "limodou" <limodou at gmail.com>
> > > > > > To: <python-chinese at lists.python.cn>
> > > > > > Sent: Friday, July 29, 2005 10:12 PM
> > > > > > Subject: Re: [python-chinese] 请教一种设计模式。
> > > > > >
> > > > > >
> > > > > > > 既然是个函数，可以不写成类的形式啊，我还是不太懂你想怎 么省事。不过为什么不直接使用函数来处理呢？我改造了一下如下：
> > > > > > >
> > > > > > > class data:
> > > > > > >     def __init__(self):
> > > > > > >         self.d = 10
> > > > > > >     def dfunc(self):
> > > > > > >         print(self.d)
> > > > > > >
> > > > > > > def fun1(data):
> > > > > > >     data.d += 10
> > > > > > >     data.dfunc()
> > > > > > >
> > > > > > >
> > > > > > > def fun2(data):
> > > > > > >     data.d -= 10
> > > > > > >     data.dfunc()
> > > > > > >
> > > > > > >
> > > > > > > class foo:
> > > > > > >     def __init__(self):
> > > > > > >         self.__data = data()
> > > > > > >         self.imp = []
> > > > > > >         self.imp.append(fun1)
> > > > > > >         self.imp.append(fun2)
> > > > > > >         self.curImp = 0
> > > > > > >
> > > > > > >     def fun(self):
> > > > > > >         self.imp[self.curImp](self.__data)
> > > > > > >
> > > > > > >     def setType(self, type):
> > > > > > >         self.curImp = type
> > > > > > >
> > > > > > > if __name__ == '__main__':
> > > > > > >     #Testing
> > > > > > >     a = foo()
> > > > > > >     a.fun()
> > > > > > >     a.setType(1)
> > > > > > >     a.fun()
> > > > > > >
> > > > > > > 因为fun1, fun2它们只是函数，只是对参数进行处理的，没必要再保留数据的复本。由调度类foo来保存就好了，它们只是进行即定的处理就行了。
> > > > > > >
> > > > > > > 不太明白你到底想如何简化。
> > > > > > >
> > > > > > >
> > > > > > > 在 05-7-28，flyaflya<flyaflyaa at gmail.com> 写道：
> > > > > > > >
> > > > > > > > 忘记叫什么名字了，就是用几组函数处理同一组数据。可以在这几组函数间切换。
> > > > > > > > 我的实现是这样：
> > > > > > > > class data:
> > > > > > > >     def __init__(self):
> > > > > > > >         self.d = 10
> > > > > > > >     def dfunc(self):
> > > > > > > >         print(self.d)
> > > > > > > >
> > > > > > > > class imp1:
> > > > > > > >     def __init__(self, data):
> > > > > > > >         self.__data = data
> > > > > > > >
> > > > > > > >     def fun(self):
> > > > > > > >         self.__data.d += 10
> > > > > > > >         self.__data.dfunc()
> > > > > > > >
> > > > > > > >
> > > > > > > > class imp2:
> > > > > > > >     def __init__(self, data):
> > > > > > > >         self.__data = data
> > > > > > > >
> > > > > > > >     def fun(self):
> > > > > > > >         self.__data.d -= 10
> > > > > > > >         self.__data.dfunc()
> > > > > > > >
> > > > > > > >
> > > > > > > > class foo:
> > > > > > > >     def __init__(self):
> > > > > > > >         self.__data = data()
> > > > > > > >         self.imp = []
> > > > > > > >         self.imp.append(imp1(self.__data))
> > > > > > > >         self.imp.append(imp2(self.__data))
> > > > > > > >         self.curImp = 0
> > > > > > > >
> > > > > > > >     def fun(self):
> > > > > > > >         self.imp[self.curImp].fun()
> > > > > > > >
> > > > > > > >     def setType(self, type):
> > > > > > > >         self.curImp = type
> > > > > > > > #测试
> > > > > > > > a = foo()
> > > > > > > > a.fun()
> > > > > > > > a.setType(1)
> > > > > > > > a.fun()
> > > > > > > > 我希望类foo可以通过setType在imp1和imp2的函数间切换，操作同一组数据data,data中也有一些函数。
> > > > > > > > 我试了很多各方法，用多重继承，用__getattr__等，都失败了，只有用这种笨办法了，但这样，我在imp1和imp2中每次要操作data中的数据，都很麻烦，大家有什么好方法没
> > > > > > > >
> > > > > > > >
> > > > > > > > _______________________________________________
> > > > > > > > python-chinese list
> > > > > > > > python-chinese at lists.python.cn
> > > > > > > > http://python.cn/mailman/listinfo/python-chinese
> > > > > > > >
> > > > > > > >
> > > > > > > >
> > > > > > >
> > > > > > >
> > > > > > > --
> > > > > > > I like python!
> > > > > > > My Donews Blog: http://www.donews.net/limodou
> > > > > > > New Google Maillist: http://groups-beta.google.com/group/python-cn
> > > > > > >
> > > > > >
> > > > > >
> > > > > > --------------------------------------------------------------------------------
> > > > > >
> > > > > >
> > > > > > > _______________________________________________
> > > > > > > python-chinese list
> > > > > > > python-chinese at lists.python.cn
> > > > > > > http://python.cn/mailman/listinfo/python-chinese
> > > > > > >
> > > > >
> > > > > --------------------- Original Message Ends --------------------
> > > > > _______________________________________________
> > > > > python-chinese list
> > > > > python-chinese at lists.python.cn
> > > > > http://python.cn/mailman/listinfo/python-chinese
> > > > _______________________________________________
> > > > python-chinese list
> > > > python-chinese at lists.python.cn
> > > > http://python.cn/mailman/listinfo/python-chinese
> > > >
> > > >
> > > >
> > >
> > >
> > > --
> > > Qiangning Hong
> > >
> > > I'm usually annoyed by IDEs because, for instance, they don't use VIM
> > > as an editor. Since I'm hooked to that, all IDEs I've used so far have
> > > failed to impress me.
> > >    -- Sybren Stuvel @ c.l.python
> > >
> > > Get Firefox! <http://www.spreadfirefox.com/?q=affiliates&id=67907&t=1>
> > >
> > 
> > 
> > --------------------------------------------------------------------------------
> > 
> > 
> > > _______________________________________________
> > > python-chinese list
> > > python-chinese at lists.python.cn
> > > http://python.cn/mailman/listinfo/python-chinese
> > > 
> > _______________________________________________
> > python-chinese list
> > python-chinese at lists.python.cn
> > http://python.cn/mailman/listinfo/python-chinese
> > 
> > 
> > 
> 
> 
> -- 
> Qiangning Hong
> 
> I'm usually annoyed by IDEs because, for instance, they don't use VIM
> as an editor. Since I'm hooked to that, all IDEs I've used so far have
> failed to impress me.
>    -- Sybren Stuvel @ c.l.python
> 
> Get Firefox! <http://www.spreadfirefox.com/?q=affiliates&id=67907&t=1>
> 


--------------------------------------------------------------------------------


> _______________________________________________
> python-chinese list
> python-chinese at lists.python.cn
> http://python.cn/mailman/listinfo/python-chinese
>

[导入自Mailman归档：http://www.zeuux.org/pipermail/zeuux-python]

请登录后回复。还没有在Zeuux哲思注册吗？现在注册！

Zeuux © 2025

京ICP备05028076号