IronPython是一个.NET平台上的Python实现,包括了完整的编译器、执行引擎与运行时支持,能够与.NET已有的库无缝整合到一起。
IronPython已经很好的集成到了.NET framework中,所以Ironpython和C#的交互也就变得很简单了。下面就通过一些简单的例子来看看IronPython和C#之间的交互。
工欲善其事,必先利其器,所以在开始IronPython的开发之前,我们先找到一个方便的开发环境。
PTVS(Python tools for Visual Studio)是一个免费开源的VisualStudio的插件,支持 VisualStudio 2010/2012/2013,安装好这个插件之后,我们就可以直接通过VS进行IronPython的开发了。
下面一个截图显示了我们可以新建的项目模板:
首先我们看下如何在IronPython中使用C#的简单例子。
在.NET中,有很多标准库,在IronPython中,就可以使用import来引入这些标准库来直接使用。看一个简单的例子,我们使用.NET中的String和DateTime
from System import DateTime, String formatStr = String.Format("{0} {1}", "Hello World! The current date and time is ", DateTime.Now) print formatStr print dir(String) raw_input("press Enter to exit!")
代码输出如下,可以看到在IronPython代码中,可以通过String的Format方法进行字符串格式化的输出。
在.NET开发中,会经常通过References来引用一些.NET库,当然在IronPython项目中,也可以引用并使用.NET库。
例如,现在我们有一个Calc的计算类型,里面有一个Add和Sub方法。通过这个类型,生成了一个CalcLib.dll。
namespace CalcLib { public class Calc { public int Add(int a, int b) { return a + b; } public int Sub(int a, int b) { return a - b; } } }
下面看看如何在IronPython项目中使用这个dll,在IronPython中,可以使用"clr"模块来添加.NET引用:
import clr clr.AddReference('CalcLib') #clr.AddReferenceToFile('CalcLib.dll') from CalcLib import Calc print dir(Calc) calcObj = Calc() print "result of 3+4 is:", calcObj.Add(3,4) print "result of 10+2 is:", calcObj.Sub(10,2) raw_input("press Enter to exit!")
代码输出如下,当引用了CalcLib.dll之后,我们就可以使用Calc类型创建实例,并且使用实例的C#方法。
在IronPython项目中,也可以引入WPF相关的.NET库,这样就可以方便的创建图形界面应用。
安装过PTVS之后,里面有个"IronPython WPF Application"的模板,通过这个模板,可以直接创建WPF应用。
在新建的项目中,VS会帮我们自动引用WPF相关的库,同时会有一个.py和.xaml文件。
下面看一个简单的例子,通过IrpnPython实现的一个简单计算器,界面的代码如下:
对应的IronPython代码如下:
from __future__ import division import traceback import wpf from System.Windows import Application, Window, MessageBox class MyWindow(Window): def __init__(self): wpf.LoadComponent(self, 'IronPythonWPF.xaml') def Calc_Button_Click(self, sender, e): try: result = eval(self.InputTb.Text) self.ResultTb.Text = str(result) except Exception, e: tracelog = traceback.format_exc() MessageBox.Show(str(e)) pass def Clear_Button_Click(self, sender, e): self.InputTb.Text = "" self.ResultTb.Text = "" pass def Input_Button_Click(self, sender, e): self.InputTb.Text += sender.Content pass if __name__ == '__main__': Application().Run(MyWindow())
代码运行效果如下:
前面介绍了在IronPython中如何使用.NET库,下面看看通过C#代码执行IronPython脚本。在.NET framework中,包含了IronPython的编译器和执行引擎,所以我们可以通过C#代码创建一个引擎实例,然后执行脚本。
先看看我们需要使用的类型:
现在我们有一个简单的打印当前时间的IronPython脚本:
import datetime print "current datetiem is:", datetime.datetime.now()
然后就可以使用下面的方式执行脚本:
static void Main(string[] args) { try { ScriptEngine engine = Python.CreateEngine(); ScriptScope scope = engine.CreateScope(); ScriptSource script = engine.CreateScriptSourceFromFile(@"Script.py"); var result = script.Execute(scope); } catch (Exception e) { Console.WriteLine(e.Message); } Console.Read(); }
在ScriptScope类型中,有一个SetVariable方法,我们可以通过这个方法给脚本传递参数。
public void SetVariable(string name, object value)
这样,我们就可以把一个C#实例传递给IronPython,然后脚本就可以使用C#实例的成员。看一个例子:
public class Student { public int Age { get; set; } public string Name { get; set; } public override string ToString() { return string.Format("{0} is {1} years old", this.Name, this.Age); } } class Program { static void Main(string[] args) { try { ScriptEngine engine = Python.CreateEngine(); ScriptScope scope = engine.CreateScope(); Student stu = new Student { Name = "Wilber", Age = 28 }; scope.SetVariable("stuObj", stu); ScriptSource script = engine.CreateScriptSourceFromFile(@"PrintStuInfo.py"); var result = script.Execute(scope); } catch (Exception e) { Console.WriteLine(e.Message); } Console.Read(); } }
在这个例子中,C#代码中创建了一个Student类型的实例,并把这个实例传递给了PrintStuInfo.py脚本。
print "Student name:", stuObj.Name print "Student age:", stuObj.Age print stuObj.ToString()
通过输出可以看到,IronPython脚本可以方便的访问C#实例的成员。
本篇文章通过一些例子演示了IronPython与C#的交互,感觉有几个例子还是很有意思的。
有时候使用C#调用IronPython可以使程序变得更加灵活,通过一个C#类型提供一组封装好的操作,每次构建类型实例然后传递给脚本;这样,用户就可以编写IronPython脚本,然后使用C#类型中提供的操作方法,从而实现不同的自定义操作。
在Python中,很多对象都是可以通过for语句来直接遍历的,例如list、string、dict等等,这些对象都可以被称为可迭代对象。至于说哪些对象是可以被迭代访问的,就要了解一下迭代器相关的知识了。
迭代器对象要求支持迭代器协议的对象,在Python中,支持迭代器协议就是实现对象的__iter__()和next()方法。其中__iter__()方法返回迭代器对象本身;next()方法返回容器的下一个元素,在结尾时引发StopIteration异常。
这两个方法是迭代器最基本的方法,一个用来获得迭代器对象,一个用来获取容器中的下一个元素。
对于可迭代对象,可以使用内建函数iter()来获取它的迭代器对象:
例子中,通过iter()方法获得了list的迭代器对象,然后就可以通过next()方法来访问list中的元素了。当容器中没有可访问的元素后,next()方法将会抛出一个StopIteration异常终止迭代器。
其实,当我们使用for语句的时候,for语句就会自动的通过__iter__()方法来获得迭代器对象,并且通过next()方法来获取下一个元素。
了解了迭代器协议之后,就可以自定义迭代器了。
下面例子中实现了一个MyRange的类型,这个类型中实现了__iter__()方法,通过这个方法返回对象本身作为迭代器对象;同时,实现了next()方法用来获取容器中的下一个元素,当没有可访问元素后,就抛出StopIteration异常。
class MyRange(object): def __init__(self, n): self.idx = 0 self.n = n def __iter__(self): return self def next(self): if self.idx < self.n: val = self.idx self.idx += 1 return val else: raise StopIteration()
这个自定义类型跟内建函数xrange很类似,看一下运行结果:
myRange = MyRange(3) for i in myRange: print i
在上面的例子中,myRange这个对象就是一个可迭代对象,同时它本身也是一个迭代器对象。
看下面的代码,对于一个可迭代对象,如果它本身又是一个迭代器对象,就会有下面的 问题,就没有办法支持多次迭代。
为了解决上面的问题,可以分别定义可迭代类型对象和迭代器类型对象;然后可迭代类型对象的__iter__()方法可以获得一个迭代器类型的对象。看下面的实现:
class Zrange: def __init__(self, n): self.n = n def __iter__(self): return ZrangeIterator(self.n) class ZrangeIterator: def __init__(self, n): self.i = 0 self.n = n def __iter__(self): return self def next(self): if self.i < self.n: i = self.i self.i += 1 return i else: raise StopIteration() zrange = Zrange(3) print zrange is iter(zrange) print [i for i in zrange] print [i for i in zrange]
代码的运行结果为:
其实,通过下面代码可以看出,list类型也是按照上面的方式,list本身是一个可迭代对象,通过iter()方法可以获得list的迭代器对象:
在Python中,使用生成器可以很方便的支持迭代器协议。生成器通过生成器函数产生,生成器函数可以通过常规的def语句来定义,但是不用return返回,而是用yield一次返回一个结果,在每个结果之间挂起和继续它们的状态,来自动实现迭代协议。
也就是说,yield是一个语法糖,内部实现支持了迭代器协议,同时yield内部是一个状态机,维护着挂起和继续的状态。
下面看看生成器的使用:
在这个例子中,定义了一个生成器函数,函数返回一个生成器对象,然后就可以通过for语句进行迭代访问了。
其实,生成器函数返回生成器的迭代器。 "生成器的迭代器"这个术语通常被称作"生成器"。要注意的是生成器就是一类特殊的迭代器。作为一个迭代器,生成器必须要定义一些方法,其中一个就是next()。如同迭代器一样,我们可以使用next()函数来获取下一个值。
下面就仔细看看生成器是怎么工作的。
从上面的例子也可以看到,生成器函数跟普通的函数是有很大差别的。
结合上面的例子我们加入一些打印信息,进一步看看生成器的执行流程:
通过结果可以看到:
当next()方法第一次被调用的时候,生成器函数才开始执行,执行到yield语句处停止
在开始介绍生成器表达式之前,先看看我们比较熟悉的列表解析( List comprehensions),列表解析一般都是下面的形式。
[expr for iter_var in iterable if cond_expr]
迭代iterable里所有内容,每一次迭代后,把iterable里满足cond_expr条件的内容放到iter_var中,再在表达式expr中应该iter_var的内容,最后用表达式的计算值生成一个列表。
例如,生成一个list来保护50以内的所以奇数:
[i for i in range(50) if i%2]
生成器表达式是在python2.4中引入的,当序列过长, 而每次只需要获取一个元素时,应当考虑使用生成器表达式而不是列表解析。生成器表达式的语法和列表解析一样,只不过生成器表达式是被()括起来的,而不是[],如下:
(expr for iter_var in iterable if cond_expr)
看一个例子:
生成器表达式并不是创建一个列表, 而是返回一个生成器,这个生成器在每次计算出一个条目后,把这个条目"产生"(yield)出来。 生成器表达式使用了"惰性计算"(lazy evaluation),只有在检索时才被赋值(evaluated),所以在列表比较长的情况下使用内存上更有效。
继续看一个例子:
从这个例子中可以看到,生成器表达式产生的生成器,它自身是一个可迭代对象,同时也是迭代器本身。
生成器可以向函数一样进行递归使用的,下面看一个简单的例子,对一个序列进行全排列:
def permutations(li): if len(li) == 0: yield li else: for i in range(len(li)): li[0], li[i] = li[i], li[0] for item in permutations(li[1:]): yield [li[0]] + item for item in permutations(range(3)): print item
代码的结果为:
生成器中还有两个很重要的方法:send()和close()。
send(value):
从前面了解到,next()方法可以恢复生成器状态并继续执行,其实send()是除next()外另一个恢复生成器的方法。
Python 2.5中,yield语句变成了yield表达式,也就是说yield可以有一个值,而这个值就是send()方法的参数,所以send(None)和next()是等效的。同样,next()和send()的返回值都是yield语句处的参数(yielded value)
关于send()方法需要注意的是:调用send传入非None值前,生成器必须处于挂起状态,否则将抛出异常。也就是说,第一次调用时,要使用next()语句或send(None),因为没有yield语句来接收这个值。
close():
这个方法用于关闭生成器,对关闭的生成器后再次调用next或send将抛出StopIteration异常。
下面看看这两个方法的使用:
本文介绍了Python迭代器和生成器的相关内容。
]
装饰模式有很多经典的使用场景,例如插入日志、性能测试、事务处理等等,有了装饰器,就可以提取大量函数中与本身功能无关的类似代码,从而达到代码重用的目的。下面就一步步看看Python中的装饰器。
现在有一个简单的函数"myfunc",想通过代码得到这个函数的大概执行时间。
我们可以直接把计时逻辑方法"myfunc"内部,但是这样的话,如果要给另一个函数计时,就需要重复计时的逻辑。所以比较好的做法是把计时逻辑放到另一个函数中("deco"),如下:
但是,上面的做法也有一个问题,就是所有的"myfunc"调用处都要改为"deco(myfunc)"。
下面,做一些改动,来避免计时功能对"myfunc"函数调用代码的影响:
经过了上面的改动后,一个比较完整的装饰器(deco)就实现了,装饰器没有影响原来的函数,以及函数调用的代码。例子中值得注意的地方是,Python中一切都是对象,函数也是,所以代码中改变了"myfunc"对应的函数对象。
在Python中,可以使用"@"语法糖来精简装饰器的代码:
使用了"@"语法糖后,我们就不需要额外代码来给"myfunc"重新赋值了,其实"@deco"的本质就是"myfunc = deco(myfunc)",当认清了这一点后,后面看带参数的装饰器就简单了。
前面的例子中,被装饰函数的本身是没有参数的,下面看一个被装饰函数有参数的例子:
从例子中可以看到,对于被装饰函数需要支持参数的情况,我们只要使装饰器的内嵌函数支持同样的签名即可。
也就是说这时,"addFunc(3, 8) = deco(addFunc(3, 8))"。
这里还有一个问题,如果多个函数拥有不同的参数形式,怎么共用同样的装饰器?在Python中,函数可以支持(*args, **kwargs)可变参数,所以装饰器可以通过可变参数形式来实现内嵌函数的签名。
装饰器本身也可以支持参数,例如说可以通过装饰器的参数来禁止计时功能:
通过例子可以看到,如果装饰器本身需要支持参数,那么装饰器就需要多一层的内嵌函数。
这时候,"addFunc(3, 8) = deco(True)( addFunc(3, 8))","myFunc() = deco(False)( myFunc ())"。
装饰器是可以叠加使用的,那么这是就涉及到装饰器调用顺序了。对于Python中的"@"语法糖,装饰器的调用顺序与使用 @ 语法糖声明的顺序相反。
在这个例子中,"addFunc(3, 8) = deco_1(deco_2(addFunc(3, 8)))"。
在Python中有三个内置的装饰器,都是跟class相关的:staticmethod、classmethod 和property。
对于staticmethod和classmethod这里就不介绍了,通过一个例子看看property。
注意,对于Python新式类(new-style class),如果将上面的 "@var.setter" 装饰器所装饰的成员函数去掉,则Foo.var 属性为只读属性,使用 "foo.var = 'var 2'" 进行赋值时会抛出异常。但是,对于Python classic class,所声明的属性不是 read-only的,所以即使去掉"@var.setter"装饰器也不会报错。
本文介绍了Python装饰器的一些使用,装饰器的代码还是比较容易理解的。只要通过一些例子进行实际操作一下,就很容易理解了。