转Python 和C#的交互

http://www.cnblogs.com/wilber2013/category/708919.html

IronPython和C#交互

 

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#

首先我们看下如何在IronPython中使用C#的简单例子。

使用标准.NET库

在.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库

在.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应用

在IronPython项目中，也可以引入WPF相关的.NET库，这样就可以方便的创建图形界面应用。

安装过PTVS之后，里面有个"IronPython WPF Application"的模板，通过这个模板，可以直接创建WPF应用。

在新建的项目中，VS会帮我们自动引用WPF相关的库，同时会有一个.py和.xaml文件。

下面看一个简单的例子，通过IrpnPython实现的一个简单计算器，界面的代码如下：

<Grid>
    <Grid.RowDefinitions>
        <RowDefinition></RowDefinition>
        <RowDefinition></RowDefinition>
        <RowDefinition></RowDefinition>
        <RowDefinition></RowDefinition>
        <RowDefinition></RowDefinition>
        <RowDefinition></RowDefinition>
    </Grid.RowDefinitions>
    <Grid.ColumnDefinitions>
        <ColumnDefinition></ColumnDefinition>
        <ColumnDefinition></ColumnDefinition>
        <ColumnDefinition></ColumnDefinition>
        <ColumnDefinition></ColumnDefinition>
    </Grid.ColumnDefinitions>

    <TextBlock Name="InputTb" Grid.Row="0" Grid.ColumnSpan="4"/>
    <TextBlock Name="ResultTb" Grid.Row="1" Grid.ColumnSpan="3"/>

    <Button Content="1" Grid.Row="2" Grid.Column="0" Click="Input_Button_Click"/>
    <Button Content="2" Grid.Row="2" Grid.Column="1" Click="Input_Button_Click"/>
    <Button Content="3" Grid.Row="2" Grid.Column="2" Click="Input_Button_Click"/>
    <Button Content="4" Grid.Row="3" Grid.Column="0" Click="Input_Button_Click"/>
    <Button Content="5" Grid.Row="3" Grid.Column="1" Click="Input_Button_Click"/>
    <Button Content="6" Grid.Row="3" Grid.Column="2" Click="Input_Button_Click"/>
    <Button Content="7" Grid.Row="4" Grid.Column="0" Click="Input_Button_Click"/>
    <Button Content="8" Grid.Row="4" Grid.Column="1" Click="Input_Button_Click"/>
    <Button Content="9" Grid.Row="4" Grid.Column="2" Click="Input_Button_Click"/>
    <Button Content="0" Grid.Row="5" Grid.Column="0" Click="Input_Button_Click"/>
    <Button Content="+" Grid.Row="2" Grid.Column="3" Click="Input_Button_Click"/>
    <Button Content="-" Grid.Row="3" Grid.Column="3" Click="Input_Button_Click"/>
    <Button Content="*" Grid.Row="4" Grid.Column="3" Click="Input_Button_Click"/>
    <Button Content="/" Grid.Row="5" Grid.Column="3" Click="Input_Button_Click"/>
    <Button Content="." Grid.Row="5" Grid.Column="1" Click="Input_Button_Click"/>

    <Button Content="C" Grid.Row="5" Grid.Column="2" Click="Clear_Button_Click"/>

    <Button Content="=" Grid.Row="1" Grid.Column="3" Click="Calc_Button_Click"/>
</Grid>

对应的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())

代码运行效果如下：

C#调用IronPython

前面介绍了在IronPython中如何使用.NET库，下面看看通过C#代码执行IronPython脚本。在.NET framework中，包含了IronPython的编译器和执行引擎，所以我们可以通过C#代码创建一个引擎实例，然后执行脚本。

先看看我们需要使用的类型：

• ScriptEngine： 动态语言（IronPython）执行类，可于解析和执行动态语言代码。
• ScriptScope：构建一个执行上下文，其中保存了环境及全局变量；宿主(Host)可以通过创建不同的 ScriptScope 来提供多个数据隔离的执行上下文。
• ScriptSource：操控动态语言代码的类型，可以编译（Compile）、运行（Execute）代码。

现在我们有一个简单的打印当前时间的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();
}

给IronPython传递参数

在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迭代器和生成器

 

在Python中，很多对象都是可以通过for语句来直接遍历的，例如list、string、dict等等，这些对象都可以被称为可迭代对象。至于说哪些对象是可以被迭代访问的，就要了解一下迭代器相关的知识了。

迭代器

迭代器对象要求支持迭代器协议的对象，在Python中，支持迭代器协议就是实现对象的__iter__()和next()方法。其中__iter__()方法返回迭代器对象本身；next()方法返回容器的下一个元素，在结尾时引发StopIteration异常。

__iter__()和next()方法

这两个方法是迭代器最基本的方法，一个用来获得迭代器对象，一个用来获取容器中的下一个元素。

对于可迭代对象，可以使用内建函数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语句处停止
  • next()方法的返回值就是yield语句处的参数（yielded value）
• 当继续调用next()方法的时候，函数将接着上一次停止的yield语句处继续执行，并到下一个yield处停止；如果后面没有yield就抛出StopIteration异常

生成器表达式

在开始介绍生成器表达式之前，先看看我们比较熟悉的列表解析( 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()和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迭代器和生成器的相关内容。

• 通过实现迭代器协议对应的__iter__()和next()方法，可以自定义迭代器类型。对于可迭代对象，for语句可以通过iter()方法获取迭代器，并且通过next()方法获得容器的下一个元素。
• 像列表这种序列类型的对象，可迭代对象和迭代器对象是相互独立存在的，在迭代的过程中各个迭代器相互独立；但是，有的可迭代对象本身又是迭代器对象，那么迭代器就没法独立使用。
• itertools模块提供了一系列迭代器，能够帮助用户轻松地使用排列、组合、笛卡尔积或其他组合结构。

• 生成器是一种特殊的迭代器，内部支持了生成器协议，不需要明确定义__iter__()和next()方法。
• 生成器通过生成器函数产生，生成器函数可以通过常规的def语句来定义，但是不用return返回，而是用yield一次返回一个结果。

]

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内置装饰器

在Python中有三个内置的装饰器，都是跟class相关的：staticmethod、classmethod 和property。

• staticmethod 是类静态方法，其跟成员方法的区别是没有 self 参数，并且可以在类不进行实例化的情况下调用
• classmethod 与成员方法的区别在于所接收的第一个参数不是 self （类实例的指针），而是cls（当前类的具体类型）
• property 是属性的意思，表示可以通过通过类实例直接访问的信息

对于staticmethod和classmethod这里就不介绍了，通过一个例子看看property。

注意，对于Python新式类（new-style class），如果将上面的 "@var.setter" 装饰器所装饰的成员函数去掉，则Foo.var 属性为只读属性，使用 "foo.var = 'var 2'" 进行赋值时会抛出异常。但是，对于Python classic class，所声明的属性不是 read-only的，所以即使去掉"@var.setter"装饰器也不会报错。

总结

本文介绍了Python装饰器的一些使用，装饰器的代码还是比较容易理解的。只要通过一些例子进行实际操作一下，就很容易理解了。

---

http://www.cnblogs.com/wilber2013/category/708919.html