C/C++ Python Parsing Engine

1. Python语言简介
2. Python模块
3. 嵌入式Python解析引擎: C++调用Python
4. Python 调用 C (base)
5. 扩展Python语法解析器功能: Python中调用C++
6. Python 调用 C++ (Boost.Python)
7. python 调用 c++ (ctypes)
8. 脚本语言扩展性

1. 我们可以自由地从 Python官方点: http://www.python.org，以源代码或二进制形式获取 Python 解释器及其标准扩展库，并可以自由的分发。此站点同时也提供了大量的第三方 Python 模块、程序和工具，及其附加文档
2. 我们可以很容易的使用 C 或 C++(其他可以通过 C 调用的语言)为 Python 解释器扩展新函数和数据类型。Python 还可以被用作定制应用程序的一门扩展语言，这点和Lua是一致的

1. Python 解释器通常被安装在目标机器的 /usr/local/bin/pythonXXX 目录下。将 /usr/local/bin 目录包含进 Unix shell 的搜索路径里，以确保可以通过输入: pythonXX 命令来启动，进入交互模式
2. 第二种启动 Python 解释器的方法是 python -c command [arg] ...，这种方法可以在 命令行 执行 Python 语句，类似于 shell 中的 -c 选项。由于 Python 语句通常会包含空格或其他特殊 shell 字符，一般建议将 命令 用单引号包裹起来 
3. 有一些 Python 模块也可以当作脚本使用。你可以使用 python -m module [arg] ... 命令调用它们，这类似在命令行中键入完整的路径名执行 模块 源文件一样
4. 使用脚本文件时，经常会运行脚本然后进入交互模式。这也可以通过在脚本之前加上 -i 参数来实现

1. 调用解释器时，脚本名和附加参数传入一个名为 sys.argv 的字符串列表。你能够获取这个列表通过执行 import sys，列表的长度大于等于1
2. 没有给定脚本和参数时，它至少也有一个元素：sys.argv[0] 此时为空字符串
    1) 脚本名指定为 ‘-‘ (表示标准输入)时，sys.argv[0] 被设定为 ‘-‘
    2) 使用 -c 指令 时，sys.argv[0] 被设定为 ‘-c‘
    3) 使用 -m 模块参数时，sys.argv[0] 被设定为指定模块的全名
    4) -c 指令 或者 -m 模块 之后的参数不会被 Python 解释器的选项处理机制所截获，而是留在 sys.argv 中，供脚本命令操作

1. 从 tty 读取命令时，我们称解释器工作于 交互模式。这种模式下它根据主提示符来执行，主提示符通常标识为三个大于号(>>>)
2. 继续的部分被称为 从属提示符，由三个点标识(...)。在第一行之前，解释器打印欢迎信息、版本号和授权提示 

# -*- coding: encoding -*-
# -*- coding: cp-1252 -*-

1. 解释器表现得就像一个简单的计算器：可以向其录入一些表达式，它会给出返回值。表达式语法很直白：运算符 +，-，* 和 / 与其它语言一样(例如：Pascal 或 C)；括号 (()) 用于分组
2. 整数(例如，2， 4， 20 )的类型是 int，带有小数部分的数字(例如，5.0， 1.6)的类型是 float
3. 除法(/)永远返回一个浮点数。如要使用 floor 除法 并且得到整数结果（丢掉任何小数部分），你可以使用 // 运算符；要计算余数你可以使用 %
4. 可以使用 ** 运算符计算幂乘方
5. 号( ‘=‘ )用于给变量赋值。赋值之后，在下一个提示符之前不会有任何结果显示
6. 变量在使用前必须 “定义”(赋值)，否则会出错
7. 浮点数有完整的支持；整数和浮点数的混合计算中，整数会被转换为浮点数
8. 交互模式中，最近一个表达式的值赋给变量 _。这样我们就可以把它当作一个桌面计算器，很方便的用于连续计算，此变量对于用户是只读的。不要尝试给它赋值 —— 你只会创建一个独立的同名局部变量，它屏蔽了系统内置变量的魔术效果
9. 除了 int 和 float，Python 还支持其它数字类型，例如 Decimal 和 Fraction。Python 还内建支持 复数 ，使用后缀 j 或 J 表示虚数部分(例如，3+5j)

1. 如果字符串中只有单引号而没有双引号，就用双引号引用
2. 否则用单引号引用
3. print() 函数生成可读性更好的输出, 它会省去引号并且打印出转义后的特殊字符 

1. 第一行包括了一个 多重赋值：变量 a 和 b 同时获得了新的值 0 和 1 最后一行又使用了一次，这点和Lua是类似的
2. 变量赋值前，右边首先完成计算。右边的表达式从左到右计算。
条件（这里是 b < 10 ）为 true 时， while 循环执行。在 Python 中，类似于 C，任何非零整数都是 true；0 是 false 条件也可以是字符串或列表，实际上可以是任何序列 

>>> x = int(input("Please enter an integer: "))
Please enter an integer: 42
>>> if x < 0:
...      x = 0
...      print(‘Negative changed to zero‘)
... elif x == 0:
...      print(‘Zero‘)
... elif x == 1:
...      print(‘Single‘)
... else:
...      print(‘More‘)
...
More

>>> for w in words[:]:  # Loop over a slice copy of the entire list.
...     if len(w) > 6:
...         words.insert(0, w)
...
>>> words
[‘defenestrate‘, ‘cat‘, ‘window‘, ‘defenestrate‘]

range(5, 10)
   5 through 9

range(0, 10, 3)
   0, 3, 6, 9

range(-10, -100, -30)
  -10, -40, -70

>>> while True:
...     pass  # Busy-wait for keyboard interrupt (Ctrl+C)
...

def fib(n):    # write Fibonacci series up to n
    """Print a Fibonacci series up to n."""
    a, b = 0, 1
    while a < n:
        print a, 
        a, b = b, a+b
    print 

# Now call the function we just defined:
fib(2000)

1. 关键字 def 引入了一个函数 定义。在其后必须跟有函数名和包括形式参数的圆括号。函数体语句从下一行开始，必须是缩进的 
2. 函数体的第一行语句可以是可选的字符串文本，这个字符串是函数的文档字符串，或者称为 docstring 
3. 函数 调用 会为函数局部变量生成一个新的符号表。确切的说，所有函数中的变量赋值都是将值存储在局部符号表。变量引用首先在局部符号表中查找，然后是包含函数的局部符号表，然后是全局符号表，最后是内置名字表。因此，全局变量不能在函数中直接赋值(除非用 global 语句命名)，尽管他们可以被引用
//这点和PHP是类似的

4. 函数引用的实际参数在函数调用时引入局部符号表，因此，实参总是 传值调用(这里的 值 总是一个对象 引用 ，而不是该对象的值)(可以理解为指针传递)。一个函数被另一个函数调用时，一个新的局部符号表在调用过程中被创建。
5. 一个函数定义会在当前符号表内引入函数名。函数名指代的值(即函数体)有一个被 Python 解释器认定为 用户自定义函数 的类型。 这个值可以赋予其他的名字(即变量名)，然后它也可以被当做函数使用。这可以作为通用的重命名机制 

1. 使用 4 空格缩进，而非 TAB
2. 在小缩进(可以嵌套更深)和大缩进(更易读)之间，4空格是一个很好的折中。TAB 引发了一些混乱，最好弃用折行以确保其不会超过 79 个字符
3.使用空行分隔函数和类，以及函数中的大块代码
4. 可能的话，注释独占一行
5. 使用文档字符串
6. 把空格放到操作符两边，以及逗号后面，但是括号里侧不加空格：a = f(1, 2) + g(3, 4)
7. 统一函数和类命名
8. 推荐类名用 驼峰命名， 函数和方法名用 小写_和_下划线。总是用 self 作为方法的第一个参数 
9. 不要使用花哨的编码，如果你的代码的目的是要在国际化环境。Python 的默认情况下，UTF-8，甚至普通的 ASCII 总是工作的最好
10. 同样，也不要使用非 ASCII 字符的标识符，除非是不同语种的会阅读或者维护代码 

http://www.pythondoc.com/pythontutorial3/introduction.html
http://www.pythondoc.com/pythontutorial3/controlflow.html

# Fibonacci numbers module

def fib(n):    # write Fibonacci series up to n
    a, b = 0, 1
    while b < n:
        print b, 
        a, b = b, a+b
    print

def fib2(n): # return Fibonacci series up to n
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result

1. 除了包含函数定义外，模块也可以包含可执行语句。这些语句一般用来初始化模块。他们仅在 第一次 被导入的地方执行一次 
2. 每个模块都有自己私有的符号表(符号表是模块独立的)，被模块内所有的函数定义作为全局符号表使用。因此，模块的作者可以在模块内部使用全局变量，而无需担心它与某个用户的全局变量意外冲突 
3. 模块可以导入其他的模块。一个(好的)习惯是将所有的 import 语句放在模块的开始(或者是脚本)，这并非强制。被导入的模块名会放入当前模块的全局符号表中 
4. import 语句的一个变体直接从被导入的模块中导入命名到本模块的语义表中。例如:
/*
>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
这样不会从局域语义表中导入模块名(如上所示，fibo没有定义)
*/

5. 甚至有种方式可以导入模块中的所有定义
/*
>>> from fibo import *
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
这样可以导入所有除了以下划线( _ )开头的命名
*/

sound/                          Top-level package
      __init__.py               Initialize the sound package
      formats/                  Subpackage for file format conversions
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  Subpackage for sound effects
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  Subpackage for filters
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...

http://www.pythondoc.com/pythontutorial3/modules.html

1. 第一种方式: 通过找到Python模块，类，方法，构造参数来调用 
2. 第二中方式: 就是通过构造出一个Python的脚本，用python引擎来执行 

/**
@file test.c
gcc -Wall -O2 -o test test.c -I/usr/include/python2.6 -L/usr/lib64/python2.6 -lpython2.6 -Wl,-R/usr/lib64/python2.6 
*/
#include <stdio.h>
#include <string.h>
#include <Python.h>
 
int main(int argc, char *argv[])
{
    PyObject *pmod  = NULL;
    PyObject *pstr  = NULL;
    PyObject *pfunc = NULL;
    PyObject *pargs = NULL;
 
    char *cstr = NULL;
 
    /* 初始化解释器 */
    Py_Initialize();
 
    /* 构建一个元组保存参数, PyEval_CallObject的第二参数是一个元组 */
    pargs = Py_BuildValue("(s)", argv[1]);
 
    /* 添加Python路径, 包括当前路径, 否则不能导入当前路径下的模块 */
    PyRun_SimpleString("import sys;sys.path.append(‘.‘)");
 
    /* 导入模块名称, 通常为调用的Python脚本程序名 */
    pmod = PyImport_ImportModule("testpy");
    if (pmod == NULL) {
        printf("import module failed!\n");
        return -1;
    }
 
    /* 获得导入模块的函数属性 */
    pfunc = PyObject_GetAttrString(pmod, "testpy");
    if (pfunc == NULL) {
        printf("No such attribute!\n");
        return -1;
    }
 
    /* 调用导入模块的入口函数, 获取返回结果 */
    pstr = PyEval_CallObject(pfunc, pargs);
    if (pstr == NULL) {
        printf("callobject failed!\n");
        return -1;
    }
 
    /* 分析返回的结果 */
    PyArg_Parse(pstr, "s", &cstr);
 
    printf("%s\n", cstr);
 
    /* 关闭解释器 */
    Py_Finalize();
 
    return 0;
}

#!/usr/local/bin/python
 
import sys
 
def testpy(name): 
    if not name:
        return ‘Valid Arguments‘
 
    str = "hello, " + name
 
    return str

http://www.qmailer.net/archives/103.html

/**
@file wrapper.c
gcc -fPIC wrapper.c -o wrapper.so -shared -I/usr/include/python2.6 -I/usr/lib64/python2.6/config
*/ 
#include <Python.h> 

int fact(int n)
{
    if (n <= 1)
        return 1;
    else
        return n * fact(n - 1);
}

PyObject* wrap_fact(PyObject* self, PyObject* args)
{
    int n, result;

    if (! PyArg_ParseTuple(args, "i:fact", &n))
        return NULL;

    result = fact(n);
    return Py_BuildValue("i", result);
}

static PyMethodDef wrapperMethods[] =
{
    {"fact", wrap_fact, METH_VARARGS, "Caculate N!"},
    {NULL, NULL}
};

void initwrapper()
{
    PyObject* m;
    m = Py_InitModule("wrapper", wrapperMethods);
}

http://blog.csdn.net/fxjtoday/article/details/6059874

/*
g++ -fPIC wrapper.cpp -o example.so -shared -I/usr/include/python2.6 -I/usr/lib64/python2.6/config
wrapper.cpp
*/
#include <Python.h>

class TestFact
{
    public:
    TestFact(){};
    ~TestFact(){};
    int fact(int n);
};

int TestFact::fact(int n)
{
    if (n <= 1)
        return 1;
    else
        return n * (n - 1);
}

int fact(int n)
{
    TestFact t;
    return t.fact(n);
}

PyObject* wrap_fact(PyObject* self, PyObject* args)
{
    int n, result;

    if (! PyArg_ParseTuple(args, "i:fact", &n))
        return NULL;

    result = fact(n);
    return Py_BuildValue("i", result);
}

static PyMethodDef exampleMethods[] =
{
    {"fact", wrap_fact, METH_VARARGS, "Caculate N!"},
    {NULL, NULL}
};

extern "C"              //不加会导致找不到initexample
void initexample()
{
    PyObject* m;
    m = Py_InitModule("example", exampleMethods);
}

http://www.oschina.net/question/234345_48628
http://www.yexiwei.com/2013/06/27/python%E8%B0%83%E7%94%A8cc%E5%87%BD%E6%95%B0/ 

http://blog.csdn.net/fxjtoday/article/details/6059874

http://blog.csdn.net/fxjtoday/article/details/6059874

http://swig.org
http://cosc.canterbury.ac.nz/~greg/python/Pyrex
http://blog.csdn.net/pipisorry/article/details/49532341