A. 如何实现 C/C++ 与 python 的通信
属于混合编程的问题。较全面的介绍一下，不仅限于题主提出的问题。
以下讨论中，Python指它的标准实现，即CPython（虽然不是很严格）
本文分4个部分
C/C++ 调用 Python （基础篇）— 仅讨论Python官方提供的实现方式
Python 调用 C/C++ （基础篇）— 仅讨论Python官方提供的实现方式
C/C++ 调用 Python （高级篇）— 使用 Cython
Python 调用 C/C++ （高级篇）— 使用 SWIG
练习本文中的例子，需要搭建Python扩展开发环境。具体细节见搭建Python扩展开发环境 - 蛇之魅惑 - 知乎专栏
1 C/C++ 调用 Python（基础篇）
Python 本身就是一个C库。你所看到的可执行体python只不过是个stub。真正的python实体在动态链接库里实现，在Windows平台上，这个文件位于 %SystemRoot%\System32\python27.dll。
你也可以在自己的程序中调用Python，看起来非常容易：
//my_python.c
#include <Python.h>
int main(int argc, char *argv[])
{
Py_SetProgramName(argv[0]);
Py_Initialize();
PyRun_SimpleString("print 'Hello Python!'\n");
Py_Finalize();
return 0;
}
在Windows平台下，打开Visual Studio命令提示符，编译命令为
cl my_python.c -IC:\Python27\include C:\Python27\libs\python27.lib
在linux下编译命令为
gcc my_python.c -o my_python -I/usr/include/python2.7/ -lpython2.7
在Mac OS X 下的编译命令同上
产生可执行文件后，直接运行，结果为输出
Hello Python!
Python库函数PyRun_SimpleString可以执行字符串形式的Python代码。
虽然非常简单，但这段代码除了能用C语言动态生成一些Python代码之外，并没有什么用处。我们需要的是C语言的数据结构能够和Python交互。
下面举个例子，比如说，有一天我们用Python写了一个功能特别强大的函数：
def great_function(a):
return a + 1
接下来要把它包装成C语言的函数。我们期待的C语言的对应函数应该是这样的：
int great_function_from_python(int a) {
int res;
// some magic
return res;
}
首先，复用Python模块得做‘import’，这里也不例外。所以我们把great_function放到一个mole里，比如说，这个mole名字叫 great_mole.py
接下来就要用C来调用Python了，完整的代码如下：
#include <Python.h>
int great_function_from_python(int a) {
int res;
PyObject *pMole,*pFunc;
PyObject *pArgs, *pValue;
/* import */
pMole = PyImport_Import(PyString_FromString("great_mole"));
/* great_mole.great_function */
pFunc = PyObject_GetAttrString(pMole, "great_function");
/* build args */
pArgs = PyTuple_New(1);
PyTuple_SetItem(pArgs,0, PyInt_FromLong(a));
/* call */
pValue = PyObject_CallObject(pFunc, pArgs);
res = PyInt_AsLong(pValue);
return res;
}
从上述代码可以窥见Python内部运行的方式：
所有Python元素，mole、function、tuple、string等等，实际上都是PyObject。C语言里操纵它们，一律使用PyObject *。
Python的类型与C语言类型可以相互转换。Python类型XXX转换为C语言类型YYY要使用PyXXX_AsYYY函数；C类型YYY转换为Python类型XXX要使用PyXXX_FromYYY函数。
也可以创建Python类型的变量，使用PyXXX_New可以创建类型为XXX的变量。
若a是Tuple，则a[i] = b对应于 PyTuple_SetItem(a,i,b)，有理由相信还有一个函数PyTuple_GetItem完成取得某一项的值。
不仅Python语言很优雅，Python的库函数API也非常优雅。
现在我们得到了一个C语言的函数了，可以写一个main测试它
#include <Python.h>
int great_function_from_python(int a);
int main(int argc, char *argv[]) {
Py_Initialize();
printf("%d",great_function_from_python(2));
Py_Finalize();
}
编译的方式就用本节开头使用的方法。
在Linux/Mac OSX运行此示例之前，可能先需要设置环境变量：
bash:
export PYTHONPATH=.:$PYTHONPATH
csh:
setenv PYTHONPATH .:$PYTHONPATH
2 Python 调用 C/C++（基础篇）
这种做法称为Python扩展。
比如说，我们有一个功能强大的C函数：
int great_function(int a) {
return a + 1;
}
期望在Python里这样使用：
>>> from great_mole import great_function
>>> great_function(2)
3
考虑最简单的情况。我们把功能强大的函数放入C文件 great_mole.c 中。
#include <Python.h>
int great_function(int a) {
return a + 1;
}
static PyObject * _great_function(PyObject *self, PyObject *args)
{
int _a;
int res;
if (!PyArg_ParseTuple(args, "i", &_a))
return NULL;
res = great_function(_a);
return PyLong_FromLong(res);
}
static PyMethodDef GreateMoleMethods[] = {
{
"great_function",
_great_function,
METH_VARARGS,
""
},
{NULL, NULL, 0, NULL}
};
PyMODINIT_FUNC initgreat_mole(void) {
(void) Py_InitMole("great_mole", GreateMoleMethods);
}
除了功能强大的函数great_function外，这个文件中还有以下部分：
包裹函数_great_function。它负责将Python的参数转化为C的参数（PyArg_ParseTuple），调用实际的great_function，并处理great_function的返回值，最终返回给Python环境。
导
出表GreateMoleMethods。它负责告诉Python这个模块里有哪些函数可以被Python调用。导出表的名字可以随便起，每一项有4
个参数：第一个参数是提供给Python环境的函数名称，第二个参数是_great_function，即包裹函数。第三个参数的含义是参数变长，第四个
参数是一个说明性的字符串。导出表总是以{NULL, NULL, 0, NULL}结束。
导出函数initgreat_mole。这个的名字不是任取的，是你的mole名称添加前缀init。导出函数中将模块名称与导出表进行连接。
在Windows下面，在Visual Studio命令提示符下编译这个文件的命令是
cl /LD great_mole.c /o great_mole.pyd -IC:\Python27\include C:\Python27\libs\python27.lib
/LD 即生成动态链接库。编译成功后在当前目录可以得到 great_mole.pyd（实际上是dll）。这个pyd可以在Python环境下直接当作mole使用。
在Linux下面，则用gcc编译：
gcc -fPIC -shared great_mole.c -o great_mole.so -I/usr/include/python2.7/ -lpython2.7
在当前目录下得到great_mole.so，同理可以在Python中直接使用。
本部分参考资料
《Python源码剖析-深度探索动态语言核心技术》是系统介绍CPython实现以及运行原理的优秀教程。
Python 官方文档的这一章详细介绍了C/C++与Python的双向互动Extending and Embedding the Python Interpreter
关于编译环境，本文所述方法仅为出示原理所用。规范的方式如下：3. Building C and C++ Extensions with distutils
作为字典使用的官方参考文档 Python/C API Reference Manual
用以上的方法实现C/C++与Python的混合编程，需要对Python的内部实现有相当的了解。接下来介绍当前较为成熟的技术Cython和SWIG。
3 C/C++ 调用 Python（使用Cython）
在
前面的小节中谈到，Python的数据类型和C的数据类型貌似是有某种“一一对应”的关系的，此外，由于Python（确切的说是CPython）本身是
由C语言实现的，故Python数据类型之间的函数运算也必然与C语言有对应关系。那么，有没有可能“自动”的做替换，把Python代码直接变成C代码
呢？答案是肯定的，这就是Cython主要解决的问题。
安装Cython非常简单。Python 2.7.9以上的版本已经自带easy_install：
easy_install -U cython
在Windows环境下依然需要Visual
Studio，由于安装的过程需要编译Cython的源代码，故上述命令需要在Visual
Studio命令提示符下完成。一会儿使用Cython的时候，也需要在Visual
Studio命令提示符下进行操作，这一点和第一部分的要求是一样的。
继续以例子说明：
#great_mole.pyx
cdef public great_function(a,index):
return a[index]
这其中有非Python关键字cdef和public。这些关键字属于Cython。由于我们需要在C语言中使用
“编译好的Python代码”，所以得让great_function从外面变得可见，方法就是以“public”修饰。而cdef类似于Python的
def，只有使用cdef才可以使用Cython的关键字public。
这个函数中其他的部分与正常的Python代码是一样的。
接下来编译 great_mole.pyx
cython great_mole.pyx
得到great_mole.h和great_mole.c。打开great_mole.h可以找到这样一句声明：
__PYX_EXTERN_C DL_IMPORT(PyObject) *great_function(PyObject *, PyObject *)
写一个main使用great_function。注意great_function并不规定a是何种类型，它的
功能只是提取a的第index的成员而已，故使用great_function的时候，a可以传入Python
String，也可以传入tuple之类的其他可迭代类型。仍然使用之前提到的类型转换函数PyXXX_FromYYY和PyXXX_AsYYY。
//main.c
#include <Python.h>
#include "great_mole.h"
int main(int argc, char *argv[]) {
PyObject *tuple;
Py_Initialize();
initgreat_mole();
printf("%s\n",PyString_AsString(
great_function(
PyString_FromString("hello"),
PyInt_FromLong(1)
)
));
tuple = Py_BuildValue("(iis)", 1, 2, "three");
printf("%d\n",PyInt_AsLong(
great_function(
tuple,
PyInt_FromLong(1)
)
));
printf("%s\n",PyString_AsString(
great_function(
tuple,
PyInt_FromLong(2)
)
));
Py_Finalize();
}
编译命令和第一部分相同：
在Windows下编译命令为
cl main.c great_mole.c -IC:\Python27\include C:\Python27\libs\python27.lib
在Linux下编译命令为
gcc main.c great_mole.c -o main -I/usr/include/python2.7/ -lpython2.7
这个例子中我们使用了Python的动态类型特性。如果你想指定类型，可以利用Cython的静态类型关键字。例子如下：
#great_mole.pyx
cdef public char great_function(const char * a,int index):
return a[index]
cython编译后得到的.h里，great_function的声明是这样的：
__PYX_EXTERN_C DL_IMPORT(char) great_function(char const *, int);
很开心对不对！
这样的话，我们的main函数已经几乎看不到Python的痕迹了：
//main.c
#include <Python.h>
#include "great_mole.h"
int main(int argc, char *argv[]) {
Py_Initialize();
initgreat_mole();
printf("%c",great_function("Hello",2));
Py_Finalize();
}
在这一部分的最后我们给一个看似实用的应用（仅限于Windows）：
还是利用刚才的great_mole.pyx，准备一个dllmain.c：
#include <Python.h>
#include <Windows.h>
#include "great_mole.h"
extern __declspec(dllexport) int __stdcall _great_function(const char * a, int b) {
return great_function(a,b);
}
BOOL WINAPI DllMain(HINSTANCE hinstDLL,DWORD fdwReason,LPVOID lpReserved) {
switch( fdwReason ) {
case DLL_PROCESS_ATTACH:
Py_Initialize();
initgreat_mole();
break;
case DLL_PROCESS_DETACH:
Py_Finalize();
break;
}
return TRUE;
}
在Visual Studio命令提示符下编译：
cl /LD dllmain.c great_mole.c -IC:\Python27\include C:\Python27\libs\python27.lib
会得到一个dllmain.dll。我们在Excel里面使用它，没错，传说中的Excel与Python混合编程：
参考资料：Cython的官方文档，质量非常高：
Welcome to Cython’s Documentation
4 Python调用C/C++（使用SWIG）
用
C/C++对脚本语言的功能扩展是非常常见的事情，Python也不例外。除了SWIG，市面上还有若干用于Python扩展的工具包，比较知名的还有
Boost.Python、SIP等，此外，Cython由于可以直接集成C/C++代码，并方便的生成Python模块，故也可以完成扩展Python
的任务。
答主在这里选用SWIG的一个重要原因是，它不仅可以用于Python，也可以用于其他语言。如今SWIG已经支持C/C++的
好基友Java，主流脚本语言Python、Perl、Ruby、PHP、JavaScript、tcl、Lua，还有Go、C#，以及R。SWIG是基
于配置的，也就是说，原则上一套配置改变不同的编译方法就能适用各种语言（当然，这是理想情况了……）
SWIG的安装方便，有Windows的预编译包，解压即用，绿色健康。主流Linux通常集成swig的包，也可以下载源代码自己编译，SWIG非常小巧，通常安装不会出什么问题。
用SWIG扩展Python，你需要有一个待扩展的C/C++库。这个库有可能是你自己写的，也有可能是某个项目提供的。这里举一个不浮夸的例子：希望在Python中用到SSE4指令集的CRC32指令。
首先打开指令集的文档：https://software.intel.com/en-us/node/514245
可以看到有6个函数。分析6个函数的原型，其参数和返回值都是简单的整数。于是书写SWIG的配置文件（为了简化起见，未包含2个64位函数）：
/* File: mymole.i */
%mole mymole
%{
#include "nmmintrin.h"
%}
int _mm_popcnt_u32(unsigned int v);
unsigned int _mm_crc32_u8 (unsigned int crc, unsigned char v);
unsigned int _mm_crc32_u16(unsigned int crc, unsigned short v);
unsigned int _mm_crc32_u32(unsigned int crc, unsigned int v);
接下来使用SWIG将这个配置文件编译为所谓Python Mole Wrapper
swig -python mymole.i
得到一个 mymole_wrap.c和一个mymole.py。把它编译为Python扩展：
Windows：
cl /LD mymole_wrap.c /o _mymole.pyd -IC:\Python27\include C:\Python27\libs\python27.lib
Linux：
gcc -fPIC -shared mymole_wrap.c -o _mymole.so -I/usr/include/python2.7/ -lpython2.7
注意输出文件名前面要加一个下划线。
现在可以立即在Python下使用这个mole了：
>>> import mymole
>>> mymole._mm_popcnt_u32(10)
B. python和c++之间使用管道建立通信连接
你这个做法呢。 表面上看没有问题。实际执行中会因为操作系统对于标准输入输出的设计不同而出现问题。
简单的说。在linux可能是对的。在windows下不稳定。
通常使用标准输入输出的情形是，都是单向的。一方输入 ，另一方输出。 或者是建立两个管道，一个管道输入，一个管道输出。
你要想明白这是怎么回事，可以单独做一个管道测试。 性能与稳定性，传输速率都可以。 以前我试过，在linux下管道的速度与网卡的速度基本相当，略慢。很稳定。 但是只限于单向传输。
如果你要使用python与C++通讯。 通常会有几个办法：
文件方式 （简易，稳定）
SOCKET方式（麻烦）
单向的管道，最好在shell状态下，用|来实现。
信号方式（简易）
共享内存方式（复杂些，主要是数据结构由C++提供，PYTHON用ctype, pack等解析。
直接将C++封装，然后用python调用（建议用cython方式）
python与C和C++有良好的融合性。这方面从来不是障碍。
C. python跟c语言的区别
1.C语言是编译语言，Python是脚本语言。说是C语言会比Python快
2.list和数组
C语言中的数组，里面的都是数字，而list中可以包含很多不同的数据元素。
2.import和include
在C语言中使用那个库函数，需要引入头文件用include引入，而在python中需要引入别的模块或者函数时需要用import引入。
两者的不同机制是，C语言中include是告诉预处理器，这个include指定的文件的内容，要当作本地源文件出现过，而python中的import可以通过简单的import
导入，或者是 import numpy as np
3.全局变量方面
在C语言中，声明全局变量，如果值是恒定的，那么可以直接用#define声明，如果只是声明全局，并且变量的值是可变的，那么直接类似int a
就可以了，在python中，声明全局变量时，需要加上global，类似global a，在函数里面使用的时候需要先声明global a
，否则直接用a那么python会重新创建一个新的本地对象并将新的值赋值给他，原来的全局变量的值并不变化
D. python怎么和C或者C++混合编程
不难的，就是一个套路，主要是3步：
1.把Python的数据类型转换为C/C++支持的数据类型；
2.调用C/C++函数，得到结果；
3.将结果转换为Python支持的数据类型，返回。
相当于写个中间层。
E. 用python 去和c++程序交互，该看哪些知识点
从开始看Python到现在也有半个多月了，前后看了Python核心编程和Dive into
Python两本书。话说半个月看两本，是个人都知道有多囫囵吞枣，这也是因为我暂时没有需求拿这个做大型开发，主要是平时的小程序test用一用。所以
我的策略是，整体浏览，用到时候现查。话说这核心编程第一版太古老了，老在讲2.2之前的东西，我看的翻译电子版，翻译得也不好，很晦涩。看完这个后还有
点云里雾里，看网上人家说DIP好，啄木鸟还有电子文档，就找来看这个。怎么说呢，讲的比核心编程好，但不适合第一次看的初学者。我之所以觉得讲得
好，是因为看核心编程，有些概念还有些模糊，看了这本书就明白不少了。要是初学者上来就看这本，保证不好理解。
下面就是在学习的过程中，在翻阅资料的过程中，总结的一些C和python比较明显的不同之处，有大方向的，也有细节的。肯定没有总结完，比如动态
函数，lambda这些，我都懒得往上写了。实际上，作为两种完全不同的语言，下面这些差异只是冰山一角而已。权当抛砖引玉吧，至少应该对和我有相同研究
兴趣，正在考虑是否学习另一门语言的朋友有点帮助。此文也算是DIP的学习笔记吧。顺带说一句，要是有朋友了解，可以帮忙推荐一下实战性强的Python
教材，语言这东西，不多练手，光比划，是不可能学好的。
学习目的
我的以后的研究方向是嵌入式，显然，C语言是我的主要语言。我不是一个语言爱好者，我以前觉得，对于做研究而不是应用的人来说，了解多门语言，不如
精通一门语言。之所以去看python，主要还是因为python更有利于快速开发一些程序，也是因为现在认识到，研究和应用是不能分离的。个人以为，要
想在计算机工程的竞争中立足，必须懂C语言。因为真正要做高性能编程,
不可能将机器的体系架构抛到脑后让Python虚拟机（或Java虚拟机等）帮你搞定所有底层。越来越多的CPU
core，越来越恐怖的内存性能瓶颈，对于上层开发人员来说，无所谓，但是对高性能程序开发人员来说，这些是无法透明的。很多应用，还是自己掌控比较有
效。这些场合中，汇编和C还是不可替代的。但是，光知道C是不够的，掌握一门面向对象语言，相对更高层的语言，不仅对以后的个人发展有利，也会对自己的技
术认识产生帮助。
如果要问对我来说谁更重要，我觉得还是C更重要。C的学习曲线更陡，貌似简单，实际上到处都是陷阱，看上去比较简单低效的程序，也不是学1，2个月
就能搞定的。谈到优化的深层次和难度嘛，需要的功底是按年算的。但是一旦你C语言的基础打好了，对计算机的理解，对其他语言的理解都是大有裨益的。比如，
如果你有C基础，可以说，学过1天python，就能写的出来一些不短的程序。后面的优化也不是什么大不了的算法，都是非常基本的语句换来换去。当然这里
不是说 Python不好，实际上，上层应用，Python比C方便的不是一个层次。
很多人觉得，既然懂C了，那么进一步掌握C＋＋应该是水到渠成，但C++不是C的超集，而我又不喜欢C＋＋的繁琐和巨大，所以才决定看一看Python。我很喜欢Python的优雅与快捷。
语言类型
和C不一样，Python是一种动态类型语言，又是强类型语言。这个分类怎么理解呢？大概是可以按照下列说明来分类的：
静态类型语言
一种在编译期间就确定数据类型的语言。大多数静态类型语言是通过要求在使用任一变量之前声明其数据类型来保证这一点的。Java和 C 是静态类型语言。
动态类型语言
一种在运行期间才去确定数据类型的语言，与静态类型相反。Python 是动态类型的，因为它们确定一个变量的类型是在您第一次给它赋值的时候。
强类型语言
一种总是强制类型定义的语言。Java 和 Python 是强制类型定义的。您有一个整数，如果不明确地进行转换 ，不能将把它当成一个字符串。
弱类型语言
一种类型可以被忽略的语言，与强类型相反。VBScript 是弱类型的。在 VBScript 中，您可以将字符串 ‘12′ 和整数 3 进行连接得到字符串’123′，然后可以把它看成整数 123 ，所有这些都不需要任何的显示转换。
对象机制
具体怎么来理解这个“动态确定变量类型”，就要从Python的Object对象机制说起了。Objects（以下称对象）是Python对于数据
的抽象，Python中所有的数据，都是由对象或者对象之间的关系表示的，函数是对象，字符串是对象，每个东西都是对象的概念。每一个对象都有三种属性：
实体，类型和值。理解实体是理解对象中很重要的一步，实体一旦被创建，那么就一直不会改变，也不会被显式摧毁，同时通常意义来讲，决定对象所支持的操作方
式的类型（type，包括number，string，tuple及其他）也不会改变，改变的只可能是它的值。如果要找一个具体点的说明，实体就相当于对
象在内存中的地址，是本质存在。而类型和值都只是实体的外在呈现。然后Python提供一些接口让使用者和对象交互，比如id(）函数用来获得对象实体的
整形表示（实际在这里就是地址），type()函数获取其类型。
这个object机制，就是c所不具备的，主要体现在下面几点：
1 刚才说了，c是一个静态类型语言，我们可以定义int a, char
b等等，但必须是在源代码里面事先规定。比如我们可以在Python里面任意一处直接规定a =
“lk”，这样，a的类型就是string，这是在其赋值的时候才决定的，我们无须在代码中明确写出。而在C里面，我们必须显式规定char *a =
“lk”，也就是人工事先规定好a的类型
2 由于在C中，没有对象这个概念，只有“数据的表示”，比如说，如果有两个int变量a和b，我们想比较大小，可以用a ＝＝
b来判断，但是如果是两个字符串变量a和b，我们就不得不用strcmp来比较了，因为此时，a和b本质上是指向字符串的指针，如果直接还是用＝＝比较，
那比较的实际是指针中存储的值——地址。
在Java中呢，我们通过使用 str1 == str2 可以确定两个字符串变量是否指向同一块物理内存位置，这叫做“对象同一性”。在 Java 中要比较两个字符串值，你要使用 str1.equals(str2)。
然后在Python中，和前两者都不一样，由于对象的引入，我们可以用“is”这个运算符来比较两个对象的实体，和具体对象的type就没有关系
了，比如你的对象是tuple也好，string也好，甚至class也好，都可以用”is”来比较，本质上就是“对象同一性”的比较，和Java中
的＝＝类似，和 C中的pointer比较类似。Python中也有＝＝比较，这个就是值比较了。
3
由于对象机制的引入，让Python的使用非常灵活，比如我们可以用自省方法来查看内存中以对象形式存在的其它模块和函数，获取它们的信息，并对它们进行
操作。用这种方法，你可以定义没有名称的函数，不按函数声明的参数顺序调用函数，甚至引用事先并不知道名称的函数。 这些操作在C中都是不可想象的。
4 还有一个很有意思的细节，就是类型对对象行为的影响是各方面的，比如说，a = 1; b =
1这个语句中，在Python里面引发的，可能是a，b同时指向一个值为1的对象，也可能是分别指向两个值为1的对象。而例如这个语句，c = []; d
= []，那么c和d是肯定指向不同的，新创建的空list的。没完，如果是”c = d =
[]“这个语句呢？此时，c和d又指向了相同的list对象了。这些区别，都是在c中没有的。
最后，我们来说说为什么python慢。主要原因就是function call
overhead比较大。因为所有东西现在都是对象了，contruct 和destroy 花费也大。连1 + 1 都是 function
call，像’12′+’45′ 这样的要 create a third string object, then calls the string
obj’s __add。可想而知，速度如何能快起来？
列表和数组
分析Python中的list和C中的数组总是很有趣的。相信可能一些朋友和一样，初学列表的时候，都是把它当作是数组来学的。最初对于list和数组区别的定性，主要是集中在两点。首先，list可以包含很多不同的数据类型，比如
["this", 1, "is", "an", "array"]
这个List，如果放在C中，其实是一个字符串数组，相当于二维的了。
其次呢，list有很多方法，其本身就是一个对象，这个和C的单纯数组是不同的。对于List的操作很多样，因为有方法也有重载的运算符。也带来一些问题，比如下面这个例子：
加入我们要产生一个多维列表，用下面这个语句
A = [[None] * 2] * 3
结果，A的值会是
[[None, None], [None, None], [None, None]]
初一看没问题，典型的二维数组形式的列表。好，现在我们想修改第一个None的值，用语句
A[0][0] = 5
现在我们再来看看A的值：
[[5, None], [5, None], [5, None]]
发现问题没有？这是因为用 * 来复制时，只是创建了对这个对象的引用，而不是真正的创建了它。 *3 创建了一个包含三个引用的列表，这三个引用都指向同一个长度为2的列表。其中一个行的改变会显示在所有行中，这当然不是你想要的。解决方法当然有，我们这样来创建
A = [None]*3
for i in range(3):
A[i] = [None] * 2
这样创建了一个包含三个不同的长度为2的列表。
所以，还是一直强调的，越复杂的东西，越灵活，也越容易出错。
代码优化
C是一个很简单的语言，当我们考虑优化的时候，通常想得也很简单，比如系统级调用越少越好（缓冲区机制），消除循环的低效率和不必要的系统引用，等
等，其实主要都是基于系统和硬件细节考虑的。而Python就完全不一样了，当然上面说的这些优化形式，对于Python仍然是实用的，但由于
Python的语法形式千差万别，库和模块多种多样，所以对于语言本身而言，就有很多值得注意的优化要点，举几个例子吧。
比如我们有一个list L1，想要构建一个新的list L2，L2包括L1的头4个元素。按照最直接的想法，代码应该是
L2 = []
for i in range[3]:
L2.append(L1[i])
而更加优化和优美的版本是
L2 = L1[:3]
再比如，如果s1..s7是大字符串(10K+)，那么join([s1,s2,s3,s4,s5,s6,s7])就会比
s1+s2+s3+s4+s5+s6+s7快得多,因为后者会计算很多次子表达式，而join()则在一次过程中完成所有的复制。还有，对于字符串操作，
对字符串对象使用replace()方法。仅当在没有固定字符串模式时才使用正则表达式。
所以说，以优化为评判标准，如果说C是短小精悍，Python就是博大精深。
include和import
在C语言中的include非常简单，因为形式单一，意义明确，当你需要用到外部函数等资源时，就用include。而Python中有一个相似的
机制，就是import。乍一看，这两个家伙挺像的，不都是我们要用外部资源（最常见的就是函数或者模块（Python））时就用这个来指明么？其实不
然，两者的处理机制本质区别在于，C中的include是用于告诉预处理器，这个include指定的文件的内容，你都给我当作在本地源文件中出现过。而
import呢，不是简单的将后面的内容*直接*插入到本地里面去，这玩意更加灵活。事实上，几乎所有类似的机制，Python都比C灵活。这里不是说C
不好，C很简练，我其实更喜欢C。
简单说说这个灵活性。import在python中有三种形式，import X, from X import *( or a,b,c……),
X = __import__(’x')。最常用的是第二种，因为比较方便，不像第一种那样老是用X.mole来调用模块。from X
import *只是import那些public的mole(一般都是不以__命名的模块)，也可以指定a,b,c来import。
什么时候用哪一种形式呢？应该说，在大多数的模块文档里，都会明确告诉你应该用哪种形式。如果需要用到很多对象，那么from X import
*可能更合适一些，但是，就目前来看，大多数第三方Python库都不推荐使用from molename import *
这种格式。这样做会使引入者的namespace混乱。很多人甚至对于那些专门设计用于这种模式的模块（包括Tkinter,
threading和matplot）都不采用这种方式。而如果你仅仅需要某个对象类a，那么用from X import a比用import
X.a更好，因为以后你调用a的函数直接用a.function()既可以了，不用加X。
如果你连自己希望import的模块都不知道怎么办？请注意，此时Python的优势就体现出来了，我们可以用
__import__(mole)来调用mole，其中这个mole是字符串，这样，可以在运行时再决定，你到底要调用什么mole。举
个例子：
def classFromMole (mole, Name):
mod = __import__ (mole)
return getattr (mod, Name)
这里，定义了一个函数classFromMole，你可以在代码的任何时候调用它，
o = classFromMole (MoleOfTheClass, NameOfTheAttribute)()
只需要传入字符串形式的你希望import的模块MoleOfTheClass和其中属性的名字NameOfTheAttribute（当然可以是数据也可以是方法），就能调用了，这个名字字符串不用事先指定，而是根据当时运行的情况来判断。
顺带说一句，Python中import的顺序也有默认规定，这个和C中的include有点类似，因为我们一般都是先include系统文件，再
include自己的头文件（而且还有<>和“”的区别）。Python中呢，一般应该按照以下顺序import模块：
1. 标准库模块 — 如 sys, os, getopt 等
2. 第三方模块
3. 本地实现的模块。
全局变量
这里谈全局变量呢，倒不是说Python和c的全局变量概念不同，他们的概念是相同的。只是在使用机制上，是有一些差异的。举个例子：
– mole.py –
globalvar = 1
def func():
print globalvar
# This makes someglobal readonly,
# any attempt to write to someglobal
# would create a new local variable.
def func2():
global globalvar
globalvar = 2
# this allows you to manipulate the global
# variable
在 func这个函数中，globalvar是只读的。如果你使用了globalvar =
xxx这种赋值语句，Python会重新创造一个新的本地对象并将新值赋给它，原来的对象值不变。而在func2函数中，由于我们事先申明了
globalvar是global的，那么此时的更改就直接在全局变量上生效。
F. 怎样让Python脚本与C++程序互相调用
二、Python调用C/C++
1、Python调用C动态链接库
Python调用C库比较简单，不经过任何封装打包成so，再使用python的ctypes调用即可。
（1）C语言文件：pycall.c
[html] view plain
/***gcc -o libpycall.so -shared -fPIC pycall.c*/
#include <stdio.h>
#include <stdlib.h>
int foo(int a, int b)
{
printf("you input %d and %d\n", a, b);
return a+b;
}
（2）gcc编译生成动态库libpycall.so：gcc -o libpycall.so -shared -fPIC pycall.c。使用g++编译生成C动态库的代码中的函数或者方法时，需要使用extern "C"来进行编译。
（3）Python调用动态库的文件：pycall.py
[html] view plain
import ctypes
ll = ctypes.cdll.LoadLibrary
lib = ll("./libpycall.so")
lib.foo(1, 3)
print '***finish***'
（4）运行结果：
2、Python调用C++(类)动态链接库
需要extern "C"来辅助，也就是说还是只能调用C函数，不能直接调用方法，但是能解析C++方法。不是用extern "C"，构建后的动态链接库没有这些函数的符号表。
（1）C++类文件：pycallclass.cpp
[html] view plain
#include <iostream>
using namespace std;
class TestLib
{
public:
void display();
void display(int a);
};
void TestLib::display() {
cout<<"First display"<<endl;
}
void TestLib::display(int a) {
cout<<"Second display:"<<a<<endl;
}
extern "C" {
TestLib obj;
void display() {
obj.display();
}
void display_int() {
obj.display(2);
}
}
（2）g++编译生成动态库libpycall.so：g++ -o libpycallclass.so -shared -fPIC pycallclass.cpp。
（3）Python调用动态库的文件：pycallclass.py
[html] view plain
import ctypes
so = ctypes.cdll.LoadLibrary
lib = so("./libpycallclass.so")
print 'display()'
lib.display()
print 'display(100)'
lib.display_int(100)
（4）运行结果：
3、Python调用C/C++可执行程序
（1）C/C++程序：main.cpp
[html] view plain
#include <iostream>
using namespace std;
int test()
{
int a = 10, b = 5;
return a+b;
}
int main()
{
cout<<"---begin---"<<endl;
int num = test();
cout<<"num="<<num<<endl;
cout<<"---end---"<<endl;
}
（2）编译成二进制可执行文件：g++ -o testmain main.cpp。
（3）Python调用程序：main.py
[html] view plain
import commands
import os
main = "./testmain"
if os.path.exists(main):
rc, out = commands.getstatusoutput(main)
print 'rc = %d, \nout = %s' % (rc, out)
print '*'*10
f = os.popen(main)
data = f.readlines()
f.close()
print data
print '*'*10
os.system(main)
（4）运行结果：
4、扩展Python（C++为Python编写扩展模块）
所有能被整合或导入到其它python脚本的代码，都可以被称为扩展。可以用Python来写扩展，也可以用C和C++之类的编译型的语言来写扩展。Python在设计之初就考虑到要让模块的导入机制足够抽象。抽象到让使用模块的代码无法了解到模块的具体实现细节。Python的可扩展性具有的优点：方便为语言增加新功能、具有可定制性、代码可以实现复用等。
为 Python 创建扩展需要三个主要的步骤：创建应用程序代码、利用样板来包装代码和编译与测试。
（1）创建应用程序代码
[html] view plain
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int fac(int n)
{
if (n < 2) return(1); /* 0! == 1! == 1 */
return (n)*fac(n-1); /* n! == n*(n-1)! */
}
char *reverse(char *s)
{
register char t, /* tmp */
*p = s, /* fwd */
*q = (s + (strlen(s) - 1)); /* bwd */
while (p < q) /* if p < q */
{
t = *p; /* swap & move ptrs */
*p++ = *q;
*q-- = t;
}
return(s);
}
int main()
{
char s[BUFSIZ];
printf("4! == %d\n", fac(4));
printf("8! == %d\n", fac(8));
printf("12! == %d\n", fac(12));
strcpy(s, "abcdef");
printf("reversing 'abcdef', we get '%s'\n", \
reverse(s));
strcpy(s, "madam");
printf("reversing 'madam', we get '%s'\n", \
reverse(s));
return 0;
}
上述代码中有两个函数，一个是递归求阶乘的函数fac()；另一个reverse()函数实现了一个简单的字符串反转算法，其主要目的是修改传入的字符串，使其内容完全反转，但不需要申请内存后反着复制的方法。
（2）用样板来包装代码
接口的代码被称为“样板”代码，它是应用程序代码与Python解释器之间进行交互所必不可少的一部分。样板主要分为4步：a、包含Python的头文件；b、为每个模块的每一个函数增加一个型如PyObject* Mole_func()的包装函数；c、为每个模块增加一个型如PyMethodDef MoleMethods[]的数组；d、增加模块初始化函数void initMole()。
G. python和c语言的区别是什么
Python可以说是目前最火的语言之一了，人工智能的兴起让Python一夜之间变得家喻户晓，Python号称目前最最简单易学的语言，现在有不少高校开始将Python作为大一新生的入门语言。本萌新也刚开始接触Python，发现Python与其他语言确实有很大的区别。Python是由C语言实现的，因此想把Python与C语言做一个简单的比较。
1、语言类型
Python是一种基于解释器的语言，解释器会逐行读取代码；首先将Python编译为字节码，然后由大型C程序解释。
C是一种编译语言，完整的源代码将直接编译为机器代码，由CPU直接执行。
2、内存管理
Python使用自动垃圾收集器进行内存管理。
在C语言中，程序员必须自己进行内存管理。
3、应用
Python是一种通用编程语言，一个多范式。它主要支持面向对象编程，程序编程，函数编程。
C是结构化编程语言。允许使用函数，选择（if / else等），迭代（循环）。它主要用于硬件相关的应用程序。
4、速度
Python编程语言因为历史原因，有一个GIL锁，导致其对多线程支持不够好，运行速度较慢；而C语言很快，C语言是比较底层的语言，运行效率上要优于Python。
5、复杂度不一样
在Python中，不需要声明变量类型。而在C中，必须声明变量类型。
Python程序更易于学习，编写和阅读。而C程序语法比Python更难。
Python中的测试和调试更容易；而在C中测试和调试更难。
相关推荐：《Python教程》
知识点扩展
大的区别。Python是由C语言实现的，因此想把Python与C语言做一个简单的比较。
一、C语言是编译型语言，经过编译后，生成机器码，然后再运行，执行速度快，不能跨平台，一般用于操作系统，驱动等底层开发。
Python是编译型还是解释型这个界限并不明显，但大致上可以理解为解释型语言，执行速度慢，由于Python虚拟机，Python是可以跨平台的，Python高度集成适合于软件的快速开发。
二、
C语言中需要事先定义变量类型，以int类型为例，当定义一个int型变量后，就会在内存中开辟4个字节，再来进行初始化，由于长度是指定的，在运算过程中需要考虑，溢出，精度等问题。
Python中的数据类型：
1.Number：数字
·Int
·Float
·Bool
·Complex
2.String：字符串
3.List：列表
4.Tupel：元组
5.Sets：集合
6.Dictionary：字典
Python不需要事先定义变量类型，以a=3为例，在内存中存放一个整数3，然后再用变量a指向3，变量a是没有类型的，我们所说的类型是指变量所指的内存中对象的类型。
从数据类型上就可以看出Python的友好性，基本数据类型变少了，没有烦人的指针，不需要考虑数据溢出和精度的问题，当在程序中需要使用某个变量时，就能够直接使用，而不需要在程序开头定义变量。除此之外，Python还提供了str,list,dict这些强大的数据类型，让程序开发变的更为简单。
三、Python还提供了一个交互界面，输入python进入交互界面，输入exit()退出交互界面，类似于Linux终端，输入一行命令，执行一行，为学习Python提供了很大的便利。
四、在运算符和优先级上面，两者并没有大的区别，但在python中没有自加和自减运算符，在逻辑运算符上Python也区别于C语言，Python中是and，or，not ，而C语言中则是&&，||，！
五、Python中通过缩进来表示语句体，C语言通过{}来表示语句体，并且在Python中每一条语句结尾后没有分号，判断语句if else，这两者没有区别，循环语句while也没有，只是for循环，Python通过for in来表示。
六、Python有很多内置函数（build in function）,不需要写头文件，Python还有很多强大的模块，需要时导入便可。C语言在这一点上远不及Python,大多时候都需要自己手动实现。
七、C语言中的函数，有着严格的顺序限制，如果要调用函数，该函数需要在本次调用之前就需要被实现，或者在程序开头事先声明，而Python中则没有这个限制，Python中还有高阶函数这一概念，即函数名也可当作函数参数，函数名也是一种变量，指向内存中的某个函数，这种写法可以大大减少代码长度。
python中还提供了可变参数和关键字参数，这样使得函数的功能大大提高，原来需要写多个函数，现在只需要一个函数就可以实现这些功能。
八、C语言是面向过程的语言，很多时候都需要自己手动实现函数来完成某一功能。Python中引入了类和对象，是面向对象编程的语言，面向对象使得代码的可重用性大大提高，数据的封装性也更好。面向对象与面向过程的具体比较就不多说了，但有两句非常重要的话：类是抽象的，而对象是具体的。
九、python中既有函数也有方法，常常让人疑惑，我个人觉得也没有必要区分的非常清楚，但是两者还是有较大的区别：函数是自由的，而方法是受限的。在编程的时候需要分清楚调用的是方法还是函数。
总结：Python可以说是非常“简单”的语言，高度集成，代码量少，简单是相对其他语言而言。但编程从来都不是一个简单活，需要我们不断学习，掌握底层实现原理，才是正道。
H. 如何让python调用C和C++代码
要搞明白如何让python调用C/C++代码(也就是写python的extension)，你需要征服手册中的<<Extending && embedding>>厚厚的一章。在昨天花了一个小时看地头晕脑胀，仍然不知道如何写python的extension后，查阅了一些其他书籍，最终在<<Python Programming On Win32>>书中找到了教程。 1. 首先要明白的是，所谓的python扩展（也就是你提供给python的c/c++代码，不一定是c/c++代码，可以是其他语言写的代码)是一个dll,并且这个dll放在本机python安装目录下的DLLs目录下（譬如我机器上的路径是：F:/Program Files/Python25/DLLs)，假如我们接下来要写的扩展mole名为mb,python调用的代码为：import mbmb.showMsg("Python's really amazing, I kindda love it!") 2. 搭建环境，我们要使用python提供的c头文件和lib库来进行扩展的开发。 在vs 2005下点击菜单 "工具"->"选项", 打开选项对话框，选择"项目和解决方案->VC++目录", 然后在右边"显示以下内容的目录"得comboBox上选择"包含文件”，添加python的include目录(我的机器上是"F:/Program Files/Python25/include"),然后选择库文件,添加python的libs目录(我的机器上是"F:/Program Files/Python25/libs")。 既然扩展是一个dll,接下来我们要建立一个“动态链接库”工程，然后开始写代码： #include <python.h> //python.h是包含python一些定义的头文件，在python的include目录下/*我的python版本是2.5, 因为安装python后它没提供debug下的lib库文件，因此你必须生成release版的dll， 想要生成dll版本的，你要到python官网上自己去下载python源代码,当然你可以继续生成release版本的dll,但dll中包含调试信息*/#pragma comment(lib, "python25.lib")//先不管static PyObject* mb_showMsg(PyObject* self, PyObject *args);/*如果你的扩展是mb,那么必须实现一个initmb函数，并且从dll中导出这个函数，但我们在python中调用import mb时，python会去dll里去调用 extern "C" __declspec(dllexport) void initmb(){/*当调用mb.showMsg("Python's really amazing, I kindda love it!")时， 相当于你告诉python我有一个showMsg函数，我们怎么告诉python去调用我们dll里的mb_showMsg函数呢？技巧就是下面的方式，定义一个字典数据结构，key => showMsg, value =>mb_showMsg,METH_VARARGS是函数调用方式，仔细查手册吧*/static PyMethodDef mbMethods[] = { {"showMsg", mb_showMsg, METH_VARARGS}, {NULL, NULL, NULL} /*sentinel，哨兵，用来标识结束*/};//告诉python我们的模块名叫mb, 模块包含的函数都在mbMethods字典里 PyObject *m = Py_InitMole("mb", mbMethods);}/*接下来实现核心功能showMsg*///第一个self参数我们用不着，具体查手册，第二个参数是python传给我们的参数,它是一个python的参数tuple static PyObject* mb_showMsg(PyObject* self, PyObject *args){//我们的showMsg函数需要的是一个字符串参数 const char* msg = NULL;/*调用特殊参数解码python传递给我们的参数,s是string,我们传递接收参数的变量地址, 如果你的功能函数需要两个参数，在PyArg_parseTuple后面继续添加接受参数的变量地址， 这个函数的原型是类似printf的不定参数的形式 PyAPI_FUNC(int) PyArg_ParseTuple(PyObject *, const char *, ...);*/if (!PyArg_ParseTuple(args, "s", &msg)) return NULL;//调用MBint r = ::MessageBox(NULL, "hello", "Caption:Form C mole", MB_ICONINFORMATION | MB_OK);//返回值return Py_BuildValue("i", r);}将上面这段混杂着大量注释的代码拷贝到你的编辑器里，然后编译生成mb.dll,修改后缀成mb.pyd,然后拷贝到python的DLLs目录下，打开idle(python的交互程序）,写入代码：import mbmb.showMsg("Python's really amazing, I kindda love it!")
I. python怎么调用c的动态链接库
Python调用C/C++动态链接库的需求
在自动化测试过程中，难免会遇到语言混合使用的情况，这不，我们也遇到了。初步决定采用Robot Framework作为自动化测试框架后，其支持Java和Python，而Python作为主流的语言，怎么能放弃使用它的机会^_^。 然而产品采用是古老90年代开发的C/S结构，因为古老，当时也没有考虑到对产品的测试进行自动化，Client端并没有预留CLI(Command Line interface)形式的接口，真是雪上加霜啊。
那怎么自动化？采用AutoIT来对客户端界面进行自动化测试？可惜AutoIT对当初开发采用的控件识别不是很好，如果采用控件所在位置来进行控制的方式，又会导致自动化测试并不是很稳定。那么！！！只有自己开发接口了，目前在Client端开发出CLI形式的接口，将其封装为DLL，然后在Robot FrameWork框架中采用Python对DLL进行调用。任务艰巨哪！
Python调用DLL例子
示例一
首先，在创建一个DLL工程(本人是在VS 2005中创建)，头文件：
[cpp] view plain 在CODE上查看代码片派生到我的代码片//hello.h
#ifdef EXPORT_HELLO_DLL
#define HELLO_API __declspec(dllexport)
#else
#define HELLO_API __declspec(dllimport)
#endif
extern "C"
{
HELLO_API int IntAdd(int , int);
}
CPP文件：
[cpp] view plain 在CODE上查看代码片派生到我的代码片//hello.cpp
#define EXPORT_HELLO_DLL
#include "hello.h"
HELLO_API int IntAdd(int a, int b)
{
return a + b;
}
这里有两个注意点：
（1）弄清楚编译的时候函数的调用约定采用的__cdecl还是__stdcall，因为根据DLL中函数调用约定方式，Python将使用相应的函数加载DLL。
（2）如果采用C++的工程，那么导出的接口需要extern "C"，这样python中才能识别导出的函数。
我的工程中采用__cdecl函数调用约定方式进行编译链接产生hello.dll，然后Python中采用ctypes库对hello.dll进行加载和函数调用：
[python] view plain 在CODE上查看代码片派生到我的代码片from ctypes import *
dll = cdll.LoadLibrary('hello.dll');
ret = dll.IntAdd(2, 4);
print ret;
OK，一个小例子已经完成了，如果你感兴趣，但还没试过，那就尝试一下吧。
示例二
示例一只是一个"hello world"级别的程序，实际运用中更多的需要传递数据结构、字符串等，才能满足我们的需求。那么这个示例将展示，如何传递数据结构参数，以及如何通过数据结构获取返回值。
首先编写DLL工程中的头文件：
[cpp] view plain 在CODE上查看代码片派生到我的代码片//hello.h
#ifdef EXPORT_HELLO_DLL
#define HELLO_API __declspec(dllexport)
#else
#define HELLO_API __declspec(dllimport)
#endif
#define ARRAY_NUMBER 20
#define STR_LEN 20
struct StructTest
{
int number;
char* pChar;
char str[STR_LEN];
int iArray[ARRAY_NUMBER];
};
extern "C"
{
//HELLO_API int IntAdd(int , int);
HELLO_API char* GetStructInfo(struct StructTest* pStruct);}
CPP文件如下：
[cpp] view plain 在CODE上查看代码片派生到我的代码片//hello.cpp
#include <string.h>
#define EXPORT_HELLO_DLL
#include "hello.h"
HELLO_API char* GetStructInfo(struct StructTest* pStruct){
for (int i = 0; i < ARRAY_NUMBER; i++)
pStruct->iArray[i] = i;
pStruct->pChar = "hello python!";
strcpy (pStruct->str, "hello world!");
pStruct->number = 100;
return "just OK";
}
GetStructInfo这个函数通过传递一个StructTest类型的指针，然后对对象中的属性进行赋值，最后返回"just OK".
编写Python调用代码如下，首先在Python中继承Structure构造一个和C DLL中一致的数据结构StructTest，然后设置函数GetStructInfo的参数类型和返回值类型，最后创建一个StructTest对象，并将其转化为指针作为参数，调用函数GetStrcutInfo，最后通过输出数据结构的值来检查是否调用成功：
[python] view plain 在CODE上查看代码片派生到我的代码片from ctypes import *
ARRAY_NUMBER = 20;
STR_LEN = 20;
#define type
INTARRAY20 = c_int * ARRAY_NUMBER;
CHARARRAY20 = c_char * STR_LEN;
#define struct
class StructTest(Structure):
_fields_ = [
("number", c_int),
("pChar", c_char_p),
("str", CHARARRAY20),
("iArray", INTARRAY20)
]
#load dll and get the function object
dll = cdll.LoadLibrary('hello.dll');
GetStructInfo = dll.GetStructInfo;
#set the return type
GetStructInfo.restype = c_char_p;
#set the argtypes
GetStructInfo.argtypes = [POINTER(StructTest)];objectStruct = StructTest();
#invoke api GetStructInfo
retStr = GetStructInfo(byref(objectStruct));#check result
print "number: ", objectStruct.number;
print "pChar: ", objectStruct.pChar;
print "str: ", objectStruct.str;
for i,val in enumerate(objectStruct.iArray):
print 'Array[i]: ', val;
print retStr;
总结
1. 用64位的Python去加载32位的DLL会出错
2. 以上只是些测试程序，在编写Python过程中尽可能的使用"try Except"来处理异常3. 注意在Python与C DLL交互的时候字节对齐问题4. ctypes库的功能还有待继续探索
J. 初学python，感受和C的不同
从开始看Python到现在也有半个多月了，前后看了Python核心编程和Dive into
Python两本书。话说半个月看两本，是个人都知道有多囫囵吞枣，这也是因为我暂时没有需求拿这个做大型开发，主要是平时的小程序test用一用。所以
我的策略是，整体浏览，用到时候现查。话说这核心编程第一版太古老了，老在讲2.2之前的东西，我看的翻译电子版，翻译得也不好，很晦涩。看完这个后还有
点云里雾里，看网上人家说DIP好，啄木鸟还有免费电子文档，就找来看这个。怎么说呢，讲的比核心编程好，但不适合第一次看的初学者。我之所以觉得讲得
好，是因为看核心编程，有些概念还有些模糊，看了这本书就明白不少了。要是初学者上来就看这本，保证不好理解。
下面就是在学习的过程中，在翻阅资料的过程中，总结的一些C和python比较明显的不同之处，有大方向的，也有细节的。肯定没有总结完，比如动态
函数，lambda这些，我都懒得往上写了。实际上，作为两种完全不同的语言，下面这些差异只是冰山一角而已。权当抛砖引玉吧，至少应该对和我有相同研究
兴趣，正在考虑是否学习另一门语言的朋友有点帮助。此文也算是DIP的学习笔记吧。顺带说一句，要是有朋友了解，可以帮忙推荐一下实战性强的Python
教材，语言这东西，不多练手，光比划，是不可能学好的。
学习目的
我的以后的研究方向是嵌入式，显然，C语言是我的主要语言。我不是一个语言爱好者，我以前觉得，对于做研究而不是应用的人来说，了解多门语言，不如
精通一门语言。之所以去看python，主要还是因为python更有利于快速开发一些程序，也是因为现在认识到，研究和应用是不能分离的。个人以为，要
想在计算机工程的竞争中立足，必须懂C语言。因为真正要做高性能编程,
不可能将机器的体系架构抛到脑后让Python虚拟机（或Java虚拟机等）帮你搞定所有底层。越来越多的CPU
core，越来越恐怖的内存性能瓶颈，对于上层开发人员来说，无所谓，但是对高性能程序开发人员来说，这些是无法透明的。很多应用，还是自己掌控比较有
效。这些场合中，汇编和C还是不可替代的。但是，光知道C是不够的，掌握一门面向对象语言，相对更高层的语言，不仅对以后的个人发展有利，也会对自己的技
术认识产生帮助。
如果要问对我来说谁更重要，我觉得还是C更重要。C的学习曲线更陡，貌似简单，实际上到处都是陷阱，看上去比较简单低效的程序，也不是学1，2个月
就能搞定的。谈到优化的深层次和难度嘛，需要的功底是按年算的。但是一旦你C语言的基础打好了，对计算机的理解，对其他语言的理解都是大有裨益的。比如，
如果你有C基础，可以说，学过1天python，就能写的出来一些不短的程序。后面的优化也不是什么大不了的算法，都是非常基本的语句换来换去。当然这里
不是说 Python不好，实际上，上层应用，Python比C方便的不是一个层次。
很多人觉得，既然懂C了，那么进一步掌握C＋＋应该是水到渠成，但C++不是C的超集，而我又不喜欢C＋＋的繁琐和巨大，所以才决定看一看Python。我很喜欢Python的优雅与快捷。
语言类型
和C不一样，Python是一种动态类型语言，又是强类型语言。这个分类怎么理解呢？大概是可以按照下列说明来分类的：
静态类型语言
一种在编译期间就确定数据类型的语言。大多数静态类型语言是通过要求在使用任一变量之前声明其数据类型来保证这一点的。Java和 C 是静态类型语言。
动态类型语言
一种在运行期间才去确定数据类型的语言，与静态类型相反。Python 是动态类型的，因为它们确定一个变量的类型是在您第一次给它赋值的时候。
强类型语言
一种总是强制类型定义的语言。Java 和 Python 是强制类型定义的。您有一个整数，如果不明确地进行转换 ，不能将把它当成一个字符串。
弱类型语言
一种类型可以被忽略的语言，与强类型相反。VBScript 是弱类型的。在 VBScript 中，您可以将字符串 ‘12′ 和整数 3 进行连接得到字符串’123′，然后可以把它看成整数 123 ，所有这些都不需要任何的显示转换。
对象机制
具体怎么来理解这个“动态确定变量类型”，就要从Python的Object对象机制说起了。Objects（以下称对象）是Python对于数据
的抽象，Python中所有的数据，都是由对象或者对象之间的关系表示的，函数是对象，字符串是对象，每个东西都是对象的概念。每一个对象都有三种属性：
实体，类型和值。理解实体是理解对象中很重要的一步，实体一旦被创建，那么就一直不会改变，也不会被显式摧毁，同时通常意义来讲，决定对象所支持的操作方
式的类型（type，包括number，string，tuple及其他）也不会改变，改变的只可能是它的值。如果要找一个具体点的说明，实体就相当于对
象在内存中的地址，是本质存在。而类型和值都只是实体的外在呈现。然后Python提供一些接口让使用者和对象交互，比如id(）函数用来获得对象实体的
整形表示（实际在这里就是地址），type()函数获取其类型。
这个object机制，就是c所不具备的，主要体现在下面几点：
1 刚才说了，c是一个静态类型语言，我们可以定义int a, char
b等等，但必须是在源代码里面事先规定。比如我们可以在Python里面任意一处直接规定a =
“lk”，这样，a的类型就是string，这是在其赋值的时候才决定的，我们无须在代码中明确写出。而在C里面，我们必须显式规定char *a =
“lk”，也就是人工事先规定好a的类型
2 由于在C中，没有对象这个概念，只有“数据的表示”，比如说，如果有两个int变量a和b，我们想比较大小，可以用a ＝＝
b来判断，但是如果是两个字符串变量a和b，我们就不得不用strcmp来比较了，因为此时，a和b本质上是指向字符串的指针，如果直接还是用＝＝比较，
那比较的实际是指针中存储的值——地址。
在Java中呢，我们通过使用 str1 == str2 可以确定两个字符串变量是否指向同一块物理内存位置，这叫做“对象同一性”。在 Java 中要比较两个字符串值，你要使用 str1.equals(str2)。
然后在Python中，和前两者都不一样，由于对象的引入，我们可以用“is”这个运算符来比较两个对象的实体，和具体对象的type就没有关系
了，比如你的对象是tuple也好，string也好，甚至class也好，都可以用”is”来比较，本质上就是“对象同一性”的比较，和Java中
的＝＝类似，和 C中的pointer比较类似。Python中也有＝＝比较，这个就是值比较了。
3
由于对象机制的引入，让Python的使用非常灵活，比如我们可以用自省方法来查看内存中以对象形式存在的其它模块和函数，获取它们的信息，并对它们进行
操作。用这种方法，你可以定义没有名称的函数，不按函数声明的参数顺序调用函数，甚至引用事先并不知道名称的函数。 这些操作在C中都是不可想象的。
4 还有一个很有意思的细节，就是类型对对象行为的影响是各方面的，比如说，a = 1; b =
1这个语句中，在Python里面引发的，可能是a，b同时指向一个值为1的对象，也可能是分别指向两个值为1的对象。而例如这个语句，c = []; d
= []，那么c和d是肯定指向不同的，新创建的空list的。没完，如果是”c = d =
[]“这个语句呢？此时，c和d又指向了相同的list对象了。这些区别，都是在c中没有的。
最后，我们来说说为什么python慢。主要原因就是function call
overhead比较大。因为所有东西现在都是对象了，contruct 和destroy 花费也大。连1 + 1 都是 function
call，像’12′+’45′ 这样的要 create a third string object, then calls the string
obj’s __add。可想而知，速度如何能快起来？
列表和数组
分析Python中的list和C中的数组总是很有趣的。相信可能一些朋友和一样，初学列表的时候，都是把它当作是数组来学的。最初对于list和数组区别的定性，主要是集中在两点。首先，list可以包含很多不同的数据类型，比如
["this", 1, "is", "an", "array"]
这个List，如果放在C中，其实是一个字符串数组，相当于二维的了。
其次呢，list有很多方法，其本身就是一个对象，这个和C的单纯数组是不同的。对于List的操作很多样，因为有方法也有重载的运算符。也带来一些问题，比如下面这个例子：
加入我们要产生一个多维列表，用下面这个语句
A = [[None] * 2] * 3
结果，A的值会是
[[None, None], [None, None], [None, None]]
初一看没问题，典型的二维数组形式的列表。好，现在我们想修改第一个None的值，用语句
A[0][0] = 5
现在我们再来看看A的值：
[[5, None], [5, None], [5, None]]
发现问题没有？这是因为用 * 来复制时，只是创建了对这个对象的引用，而不是真正的创建了它。 *3 创建了一个包含三个引用的列表，这三个引用都指向同一个长度为2的列表。其中一个行的改变会显示在所有行中，这当然不是你想要的。解决方法当然有，我们这样来创建
A = [None]*3
for i in range(3):
A[i] = [None] * 2
这样创建了一个包含三个不同的长度为2的列表。
所以，还是一直强调的，越复杂的东西，越灵活，也越容易出错。
代码优化
C是一个很简单的语言，当我们考虑优化的时候，通常想得也很简单，比如系统级调用越少越好（缓冲区机制），消除循环的低效率和不必要的系统引用，等
等，其实主要都是基于系统和硬件细节考虑的。而Python就完全不一样了，当然上面说的这些优化形式，对于Python仍然是实用的，但由于
Python的语法形式千差万别，库和模块多种多样，所以对于语言本身而言，就有很多值得注意的优化要点，举几个例子吧。
比如我们有一个list L1，想要构建一个新的list L2，L2包括L1的头4个元素。按照最直接的想法，代码应该是
L2 = []
for i in range[3]:
L2.append(L1[i])
而更加优化和优美的版本是
L2 = L1[:3]
再比如，如果s1..s7是大字符串(10K+)，那么join([s1,s2,s3,s4,s5,s6,s7])就会比
s1+s2+s3+s4+s5+s6+s7快得多,因为后者会计算很多次子表达式，而join()则在一次过程中完成所有的复制。还有，对于字符串操作，
对字符串对象使用replace()方法。仅当在没有固定字符串模式时才使用正则表达式。
所以说，以优化为评判标准，如果说C是短小精悍，Python就是博大精深。
include和import
在C语言中的include非常简单，因为形式单一，意义明确，当你需要用到外部函数等资源时，就用include。而Python中有一个相似的
机制，就是import。乍一看，这两个家伙挺像的，不都是我们要用外部资源（最常见的就是函数或者模块（Python））时就用这个来指明么？其实不
然，两者的处理机制本质区别在于，C中的include是用于告诉预处理器，这个include指定的文件的内容，你都给我当作在本地源文件中出现过。而
import呢，不是简单的将后面的内容*直接*插入到本地里面去，这玩意更加灵活。事实上，几乎所有类似的机制，Python都比C灵活。这里不是说C
不好，C很简练，我其实更喜欢C。
简单说说这个灵活性。import在python中有三种形式，import X, from X import *( or a,b,c……),
X = __import__(’x')。最常用的是第二种，因为比较方便，不像第一种那样老是用X.mole来调用模块。from X
import *只是import那些public的mole(一般都是不以__命名的模块)，也可以指定a,b,c来import。
什么时候用哪一种形式呢？应该说，在大多数的模块文档里，都会明确告诉你应该用哪种形式。如果需要用到很多对象，那么from X import
*可能更合适一些，但是，就目前来看，大多数第三方Python库都不推荐使用from molename import *
这种格式。这样做会使引入者的namespace混乱。很多人甚至对于那些专门设计用于这种模式的模块（包括Tkinter,
threading和matplot）都不采用这种方式。而如果你仅仅需要某个对象类a，那么用from X import a比用import
X.a更好，因为以后你调用a的函数直接用a.function()既可以了，不用加X。
如果你连自己希望import的模块都不知道怎么办？请注意，此时Python的优势就体现出来了，我们可以用
__import__(mole)来调用mole，其中这个mole是字符串，这样，可以在运行时再决定，你到底要调用什么mole。举
个例子：
def classFromMole (mole, Name):
mod = __import__ (mole)
return getattr (mod, Name)
这里，定义了一个函数classFromMole，你可以在代码的任何时候调用它，
o = classFromMole (MoleOfTheClass, NameOfTheAttribute)()
只需要传入字符串形式的你希望import的模块MoleOfTheClass和其中属性的名字NameOfTheAttribute（当然可以是数据也可以是方法），就能调用了，这个名字字符串不用事先指定，而是根据当时运行的情况来判断。
顺带说一句，Python中import的顺序也有默认规定，这个和C中的include有点类似，因为我们一般都是先include系统文件，再
include自己的头文件（而且还有<>和“”的区别）。Python中呢，一般应该按照以下顺序import模块：
1. 标准库模块 — 如 sys, os, getopt 等
2. 第三方模块
3. 本地实现的模块。
全局变量
这里谈全局变量呢，倒不是说Python和c的全局变量概念不同，他们的概念是相同的。只是在使用机制上，是有一些差异的。举个例子：
– mole.py –
globalvar = 1
def func():
print globalvar
# This makes someglobal readonly,
# any attempt to write to someglobal
# would create a new local variable.
def func2():
global globalvar
globalvar = 2
# this allows you to manipulate the global
# variable
在 func这个函数中，globalvar是只读的。如果你使用了globalvar =
xxx这种赋值语句，Python会重新创造一个新的本地对象并将新值赋给它，原来的对象值不变。而在func2函数中，由于我们事先申明了
globalvar是global的，那么此时的更改就直接在全局变量上生效。