cmake发现了错误的python库

Question

我是CMake的新手，无法理解一些使用概念。

我正在用c ++程序调用python脚本：

#include <Python.h>
...
Py_Initialize();
PyRun_SimpleFile(...);
Py_Finalize();

我的cmake文件中相应的cmake条目是：

FIND_PACKAGE(PythonLibs REQUIRED)
...
TARGET_LINK_LIBRARIES(MyApplication ${PYTHON_LIBRARIES})

只要我的python脚本没有使用安装在site-packages目录中的任何模块，这就可以工作，否则我会得到一个ImportError。 This question显示了如何使用CMake查找site-packages目录的位置，但是我应该告诉CMake如何处理它呢？

编辑：问题解决了。事实证明，FIND_PACKAGE（PythonLibs）从我正常使用的版本中找到了不同的python安装（/usr/local/lib/libpython2.7.dylib而不是/Library/Frameworks/Python.framework/Versions/2.7/lib/libpython2。 7.dylib - 我在Mac上），这是我如何获得标准的python模块，但没有我自己安装。为了将PYTHONPATH恢复正常，我添加了

try:
  import some_package
except ImportError:
  if "my_python_path" in sys.path: raise
  sys.path.append("my_python_path")

在我的python脚本的顶部。

Answer 1

解决找到错误版本的问题的最佳方法（例如3.0而不是2.7）是指定find_package的最小版本（这将选择任何版本＆gt; = 2.7）：

FIND_PACKAGE(PythonLibs 2.7 REQUIRED)

或获得确切的版本：

FIND_PACKAGE(PythonLibs 2.7.5 EXACT REQUIRED)

Answer 2

你可以通过指定python库的路径来告诉cmake在哪里找到这个PythonLibs：

cmake -DPYTHON_LIBRARIES=/Library/Frameworks/Python.framework/Versions/2.7/lib/libpython2.7.dylib .

然后将cmake中的$ {PYTHON_LIBRARIES}设置为正确的路径。

要找出哪些其他可能的选项（除了PYTHON_LIBRARIES）你可以给cmake（使用-DARG选项）试试运行

ccmake .

然后按c进行配置，然后按t进行高级选项。

例如，您可能还想设置

-DPYTHON_LIBRARY='/softwarepath/Python/Python2.7/lib/libpython2.7.so'
-DPYTHON_INCLUDE='/softwarepath/Python/Python2.7/include'

Answer 3

您可以在cmake libs \usr\share\cmake-3.2.3\Modules\FindPythonLibs.cmake上手动设置：

set(PYTHON_LIBRARY "\\usr\\lib\\python2.7")
set(PYTHON_INCLUDE_DIR "\\usr\\include\\python2.7")

Answer 4

执行此操作时，您实际上是在程序中嵌入python。你有没有在PyRun_SimpleFile之前调用Py_Initialize（）？看看Embedding Python in Another Application。

Py_Initialize（）将设置sys.path并且需要设置python环境。

如果你能找到python的安装位置，可以设置python home来覆盖python路径计算。在Py_Initialize（）之前使用Py_SetPythonHome（）。

在posix类型操作系统上，这里是getpath.c中的注释（路径解析的cpython实现）：

/* Search in some common locations for the associated Python libraries.
 *
 * Two directories must be found, the platform independent directory
 * (prefix), containing the common .py and .pyc files, and the platform
 * dependent directory (exec_prefix), containing the shared library
 * modules.  Note that prefix and exec_prefix can be the same directory,
 * but for some installations, they are different.
 *
 * Py_GetPath() carries out separate searches for prefix and exec_prefix.
 * Each search tries a number of different locations until a ``landmark''
 * file or directory is found.  If no prefix or exec_prefix is found, a
 * warning message is issued and the preprocessor defined PREFIX and
 * EXEC_PREFIX are used (even though they will not work); python carries on
 * as best as is possible, but most imports will fail.
 *
 * Before any searches are done, the location of the executable is
 * determined.  If argv[0] has one or more slashes in it, it is used
 * unchanged.  Otherwise, it must have been invoked from the shell's path,
 * so we search $PATH for the named executable and use that.  If the
 * executable was not found on $PATH (or there was no $PATH environment
 * variable), the original argv[0] string is used.
 *
 * Next, the executable location is examined to see if it is a symbolic
 * link.  If so, the link is chased (correctly interpreting a relative
 * pathname if one is found) and the directory of the link target is used.
 *
 * Finally, argv0_path is set to the directory containing the executable
 * (i.e. the last component is stripped).
 *
 * With argv0_path in hand, we perform a number of steps.  The same steps
 * are performed for prefix and for exec_prefix, but with a different
 * landmark.
 *
 * Step 1. Are we running python out of the build directory?  This is
 * checked by looking for a different kind of landmark relative to
 * argv0_path.  For prefix, the landmark's path is derived from the VPATH
 * preprocessor variable (taking into account that its value is almost, but
 * not quite, what we need).  For exec_prefix, the landmark is
 * Modules/Setup.  If the landmark is found, we're done.
 *
 * For the remaining steps, the prefix landmark will always be
 * lib/python$VERSION/os.py and the exec_prefix will always be
 * lib/python$VERSION/lib-dynload, where $VERSION is Python's version
 * number as supplied by the Makefile.  Note that this means that no more
 * build directory checking is performed; if the first step did not find
 * the landmarks, the assumption is that python is running from an
 * installed setup.
 *
 * Step 2. See if the $PYTHONHOME environment variable points to the
 * installed location of the Python libraries.  If $PYTHONHOME is set, then
 * it points to prefix and exec_prefix.  $PYTHONHOME can be a single
 * directory, which is used for both, or the prefix and exec_prefix
 * directories separated by a colon.
 *
 * Step 3. Try to find prefix and exec_prefix relative to argv0_path,
 * backtracking up the path until it is exhausted.  This is the most common
 * step to succeed.  Note that if prefix and exec_prefix are different,
 * exec_prefix is more likely to be found; however if exec_prefix is a
 * subdirectory of prefix, both will be found.
 *
 * Step 4. Search the directories pointed to by the preprocessor variables
 * PREFIX and EXEC_PREFIX.  These are supplied by the Makefile but can be
 * passed in as options to the configure script.
 *
 * That's it!
 *
 * Well, almost.  Once we have determined prefix and exec_prefix, the
 * preprocessor variable PYTHONPATH is used to construct a path.  Each
 * relative path on PYTHONPATH is prefixed with prefix.  Then the directory
 * containing the shared library modules is appended.  The environment
 * variable $PYTHONPATH is inserted in front of it all.  Finally, the
 * prefix and exec_prefix globals are tweaked so they reflect the values
 * expected by other code, by stripping the "lib/python$VERSION/..." stuff
 * off.  If either points to the build directory, the globals are reset to
 * the corresponding preprocessor variables (so sys.prefix will reflect the
 * installation location, even though sys.path points into the build
 * directory).  This seems to make more sense given that currently the only
 * known use of sys.prefix and sys.exec_prefix is for the ILU installation
 * process to find the installed Python tree.
 */