python中的有趣用法

本文给除了python中几个有趣的用法，可以给我们不一样的启发

　　

1： Python中模拟使用C++ 中的   cout <<

1. import sys 

2. class ostream:
3. def __init__(self,file):
4. self.file = file
5. def __lshift__(self,obj):
6. self.file.write(str(obj));
7. return self
8. cout = ostream(sys.stdout)
9. cerr = ostream(sys.stderr)
10. endl = 'n'
11. age = 23
12. name = 'albert'
13. cout << 'Name:' << name << endl << 'Age:' << age << endl

2. 如何在一个函数中确定调用者？！

在一个函数中

1. def fun():pass  

这个函数如何知道是谁调用了它呢？   在C类语言中好像是很难的。但在 Python中却很简单

1. import traceback 

2. def fun():
3. s =   traceback.extract_stack()
4. print '%s Invoked me!'%s[-2][2]

这个 fun 函数就可以知道是谁调用了它，并打印出来， 我们来试一下：

1. >>> def a():fun() 

2. >>> def b():fun()
3. >>> a()
4. a Invoked me!
5. >>> b()
6. b Invoked me!
7. >>>

traceback 还有很多其他用途

ok! 怎么应用这个特性呢？ 发挥各位的想象力了。 有趣用法　３　：隐藏和显示　Windows 状态条　使用Windows API （ 使用　C swig　扩展　Python 示例）

使用示例：

1. >>> import hidewin 

2. >>> hidewin.hide(1)   # 隐藏 状态条
3. 0
4. >>> hidewin.hide(0)   # 显示状态条
5. 0
6. >>>

Ｃ　语言源程序：　hidewin.c

1. #include <windows.h> 

2. int hide(int flag)
3. {
4. HWND hShellTray = FindWindow("Shell_TrayWnd",NULL);
5. if(flag == 1)
6. {
7. ShowWindow(hShellTray,SW_HIDE);
8. }
9. else
10. {
11. ShowWindow(hShellTray,SW_SHOW);
12. }
13. return 0;
14. }

swig 配置文件　 hidewin.i

%module hidewin %{ %}

extern int hide(int flag);

编译与安装步骤：　 １。安装 ｓｗｉｇ（请看其他文档）

2。 swig.exe -python hidewin.i    (生成 hidewin_wrap.c hidewin.py 两个文件）

3. 在 VC 中建立 Win32 DLL 工程，把 hidewin_wrap.c 以及 hidewin.c 加入工程， 设置 Python 头文件，及库文件目录

4。编译 生成   _hidewin.dll

ok， 在这个目录中可以执行 python解释器 使用了，使用见上面的例子 或者把   hidewin.py _hidewin.dll 两个文件放到Python安装目录的lib目录下，就可以了。

有趣用法 4 ： 读入一个字符串，并执行 这是动态语言比 C 类型语言强大的地方：　程序可以自己生成程序来执行！

简单例子：

1. import parser 

2. src = """
3. def fact(n):
4. if n == 1:return 1
5. return n * fact(n - 1)
6. """
7. ast = parser.suite(src)
8. eval(ast.compile())
9. print fact(5)

fact　函数是放在一个字符串　src 中的，通过　ast = parser.suite(src) 生成了一个　ＡＳＴ　对象（具体见Ｐｙｔｈｏｎ随机文档　Library Refference 18 eval(ast.compile()) 执行了这个　ＡＳＴ对象，　于是，　fact 函数被声明　

我们还可以从　文本文件或者网络上　得到源代码，通过　AST 在　Ｐｙｔｈｏｎ程序执行期间动态执行，这种特性给了软件开发非常大的灵活性（当然安全性也需要考虑）　 有趣用法5： MixIn 技术   （感谢 limdou 的介绍）

1. def MixIn(pyClass, mixInClass): 

2. print "Mix class:",mixInClass, " into: ",pyClass,'n'
3. pyClass.__bases__ += (mixInClass,)
4. class A:
5. def __init__(self):
6. self.name = "Class A"
7. def fun(self):
8. print self.name
9. class B:
10. def __init__(self):
11. self.name = "Class B"
12. def add(self, a,b):
13. print 'function defined in B'
14. return a + b
15. obj_a = A()
16. print obj_a
17. print dir(obj_a),'n'
18. MixIn(A,B)
19. print obj_a
20. print dir(obj_a),'n'
21. print obj_a.add(3,5)

执行结果：

>>> <__main__.A instance at 0x00BB7F80> ['__doc__', '__init__', '__module__', 'fun', 'name']

Mix class: __main__.B   into:   __main__.A

<__main__.A instance at 0x00BB7F80> ['__doc__', '__init__', '__module__', 'add', 'fun', 'name']

function defined in B 8

解释一下 MixIn 技术，就是使 一个类成为另一个类的基类， 这样会使 被 MixIn 的那个类具有了新的特性。 在例子程序中， 我们将 B 类 MixIn 进 A 类， 成为 A 的基类，于是， A 类的实例便具有了 B 类的方法（add)

obj_a = A()                   obj_a   是 类 A   的一个实例

print obj_a                 <__main__.A instance at 0x00BB7F80> print dir(obj_a),'n'       ['__doc__', '__init__', '__module__', 'fun', 'name']

MixIn(A,B)                 将B MixIn 进 A

print obj_a              <__main__.A instance at 0x00BB7F80>

print dir(obj_a),'n'     ['__doc__', '__init__', '__module__', 'add', 'fun', 'name']  注意，这时候，多了一个 add 方法（类B 中定义）

print obj_a.add(3,5)         现在 A 的实例可以使用 B 中的方法了

转自：http://www.starming.com/index.php?action=plugin&v=wave&tpl=t&nav=6&pg=14&gid=73&tid=3995