标签归档：pypi

知识问答

使用pip安装特定的软件包版本

问题：使用pip安装特定的软件包版本

我正在尝试使用通过该--no-site-packages选项创建的新virtualenv安装MySQL_python适配器的1.2.2版本。PyPi中显示的当前版本是1.2.3。有没有办法安装旧版本？我发现有一篇文章指出应该这样做：

pip install MySQL_python==1.2.2

但是，安装后，它仍显示MySQL_python-1.2.3-py2.6.egg-info在站点包中。这是此软件包专用的问题，还是我做错了什么？

点击查看英文原文

I’m trying to install version 1.2.2 of the MySQL_python adaptor, using a fresh virtualenv created with the --no-site-packages option. The current version shown in PyPi is 1.2.3. Is there a way to install the older version? I found an article stating that this should do it:

pip install MySQL_python==1.2.2

When installed, however, it still shows MySQL_python-1.2.3-py2.6.egg-info in the site packages. Is this a problem specific to this package, or am I doing something wrong?

回答 0

TL; DR：

  • pip install -Iv（即pip install -Iv MySQL_python==1.2.2）

首先，我发现您要执行的操作有两个问题。由于您已经安装了版本，因此应该卸载当前的现有驱动程序或使用pip install -I MySQL_python==1.2.2

但是，您很快就会发现这不起作用。如果您查看pip的安装日志，或者执行pip的安装日志，pip install -Iv MySQL_python==1.2.2则会发现PyPI URL链接不适用于MySQL_python v1.2.2。您可以在这里验证：http : //pypi.python.org/pypi/MySQL-python/1.2.2

由于sourceforge.net的最新升级和PyPI的过时URL，下载链接404s和后备URL链接正在无限重定向。

因此，要正确安装驱动程序，可以按照以下步骤操作：

pip uninstall MySQL_python
pip install -Iv http://sourceforge.net/projects/mysql-python/files/mysql-python/1.2.2/MySQL-python-1.2.2.tar.gz/download
点击查看英文原文

TL;DR:

  • pip install -Iv (i.e. pip install -Iv MySQL_python==1.2.2)

First, I see two issues with what you’re trying to do. Since you already have an installed version, you should either uninstall the current existing driver or use pip install -I MySQL_python==1.2.2

However, you’ll soon find out that this doesn’t work. If you look at pip’s installation log, or if you do a pip install -Iv MySQL_python==1.2.2 you’ll find that the PyPI URL link does not work for MySQL_python v1.2.2. You can verify this here: http://pypi.python.org/pypi/MySQL-python/1.2.2

The download link 404s and the fallback URL links are re-directing infinitely due to sourceforge.net’s recent upgrade and PyPI’s stale URL.

So to properly install the driver, you can follow these steps:

pip uninstall MySQL_python
pip install -Iv http://sourceforge.net/projects/mysql-python/files/mysql-python/1.2.2/MySQL-python-1.2.2.tar.gz/download

回答 1

您甚至可以在pip install命令中使用版本范围。像这样：

pip install 'stevedore>=1.3.0,<1.4.0'

如果该软件包已经安装，并且您想降级，请添加--force-reinstall以下内容：

pip install 'stevedore>=1.3.0,<1.4.0' --force-reinstall
点击查看英文原文

You can even use a version range with pip install command. Something like this:

pip install 'stevedore>=1.3.0,<1.4.0'

And if the package is already installed and you want to downgrade it add --force-reinstall like this:

pip install 'stevedore>=1.3.0,<1.4.0' --force-reinstall

回答 2

一种方法，在提出这个职位，是提版本pip为：

pip install -Iv MySQL_python==1.2.2

即使用==并提及版本号以仅安装该版本。-I, --ignore-installed忽略已经安装的软件包。

点击查看英文原文

One way, as suggested in this post, is to mention version in pip as:

pip install -Iv MySQL_python==1.2.2

i.e. Use == and mention the version number to install only that version. -I, --ignore-installed ignores already installed packages.

回答 3

要安装特定的python软件包版本，无论是第一次，升级还是降级，请使用： 

pip install --force-reinstall MySQL_python==1.2.4

MySQL_python版本1.2.2不可用，因此我使用了其他版本。要从索引查看所有可用的软件包版本，请排除该版本： 

pip install MySQL_python==
点击查看英文原文

To install a specific python package version whether it is the first time, an upgrade or a downgrade use: 

pip install --force-reinstall MySQL_python==1.2.4

MySQL_python version 1.2.2 is not available so I used a different version. To view all available package versions from an index exclude the version: 

pip install MySQL_python==

回答 4

我相信，如果您已经安装了软件包，pip不会用其他版本覆盖它。使用-I忽略以前的版本。

点击查看英文原文

I believe that if you already have a package it installed, pip will not overwrite it with another version. Use -I to ignore previous versions.

回答 5

有时，先前安装的版本会被缓存。 

~$ pip install pillow==5.2.0

它返回以下内容：
已满足要求：/home/ubuntu/anaconda3/lib/python3.6/site-packages（5.2.0）中的pillow == 5.2.0

我们可以将–no-cache-dir与-I一起使用来覆盖它

~$ pip install --no-cache-dir -I pillow==5.2.0
点击查看英文原文

Sometimes, the previously installed version is cached. 

~$ pip install pillow==5.2.0

It returns the followings:
Requirement already satisfied: pillow==5.2.0 in /home/ubuntu/anaconda3/lib/python3.6/site-packages (5.2.0)

We can use –no-cache-dir together with -I to overwrite this

~$ pip install --no-cache-dir -I pillow==5.2.0

回答 6

由于这似乎是pip版本10中引入的重大更改，因此我降级为兼容版本：

pip install 'pip<10'

该命令告诉pip安装低于版本10的模块版本。在virutalenv中执行此操作，这样就不会增加Python站点安装的麻烦。

点击查看英文原文

Since this appeared to be a breaking change introduced in version 10 of pip, I downgraded to a compatible version:

pip install 'pip<10'

This command tells pip to install a version of the module lower than version 10. Do this in a virutalenv so you don’t screw up your site installation of Python.

回答 7

我最近在使用想要记录到某处pip的-I标志时遇到问题：

-I将不卸载继续之前的现有的包; 它将仅安装在旧版本的顶部。这意味着应将两个版本之间应删除的所有文件保留在原处。如果这些文件与其他已安装模块共享名称，则可能导致奇怪的行为。

例如，假设有一个名为的软件包package。在的一个package文件中，他们使用import datetime。现在，在中package@2.0.0，它指向标准库datetime模块，但是在中package@3.0.0，他们添加了本地语言datetime.py以替代标准库版本（无论出于何种原因）。

现在说我跑步pip install package==3.0.0，但后来意识到我实际上想要版本2.0.0。如果我现在运行pip install -I package==2.0.0，旧datetime.py文件将不会被删除，因此任何调用import datetime都会导入错误的模块。

就我而言，这表现为奇怪的语法错误，因为该软件包的较新版本添加了仅与Python 3兼容的文件，并且当我将软件包版本降级以支持Python 2时，我继续导入仅Python-3模块。

基于此，我认为-I在更新已安装的软件包版本时，总是比使用旧软件包更可取。

点击查看英文原文

I recently ran into an issue when using pip‘s -I flag that I wanted to document somewhere:

-I will not uninstall the existing package before proceeding; it will just install it on top of the old one. This means that any files that should be deleted between versions will instead be left in place. This can cause weird behavior if those files share names with other installed modules.

For example, let’s say there’s a package named package. In one of packages files, they use import datetime. Now, in package@2.0.0, this points to the standard library datetime module, but in package@3.0.0, they added a local datetime.py as a replacement for the standard library version (for whatever reason).

Now lets say I run pip install package==3.0.0, but then later realize that I actually wanted version 2.0.0. If I now run pip install -I package==2.0.0, the old datetime.py file will not be removed, so any calls to import datetime will import the wrong module.

In my case, this manifested with strange syntax errors because the newer version of the package added a file that was only compatible with Python 3, and when I downgraded package versions to support Python 2, I continued importing the Python-3-only module.

Based on this, I would argue that uninstalling the old package is always preferable to using -I when updating installed package versions.

回答 8

下面的命令对我有用

Python版本-2.7

包-python-jenkins

命令- $ pip install 'python-jenkins>=1.1.1'

点击查看英文原文

This below command worked for me

Python version – 2.7

package – python-jenkins

command – $ pip install 'python-jenkins>=1.1.1'

回答 9

您可以通过两种方式安装任何版本的软件包： -A）。pip install -Iv软件包名称==版本 B）。pip install -v软件包名称==版本

为一个

在这里，如果您在安装时使用-I选项（当您不知道该软件包是否已安装时）（例如’pip install -Iv pyreadline == 2. *’之类的东西），则您将在安装新的单独的程序包，而相同的现有程序包具有不同的版本。

对于B

  1. 首先，您可能要检查是否有违反要求的情况。 点子检查

2.然后查看点子列表已经安装了什么

3.如果软件包列表中包含您要安装的特定版本的软件包，那么更好的选择是先通过pip uninstall package-name卸载该版本的软件包。

4.现在，您可以继续通过pip install -v package-name == version重新安装具有特定版本的相同软件包， 例如pip install -v pyreadline == 2. *

点击查看英文原文

There are 2 ways you may install any package with version:- A). pip install -Iv package-name == version B). pip install -v package-name == version

For A

Here, if you’re using -I option while installing(when you don’t know if the package is already installed) (like ‘pip install -Iv pyreadline == 2.* ‘or something), you would be installing a new separate package with the same existing package having some different version.

For B

  1. At first, you may want to check for no broken requirements. pip check

2.and then see what’s already installed by pip list

3.if the list of the packages contain any package that you wish to install with specific version then the better option is to uninstall the package of this version first, by pip uninstall package-name

4.And now you can go ahead to reinstall the same package with a specific version, by pip install -v package-name==version e.g. pip install -v pyreadline == 2.*

回答 10

如果要更新为最新版本，但您不知道可以输入的是最新版本。

pip安装MySQL_python –upgrade

这将更新可用的最新版本的MySQL_python，您可以将其用于任何其他软件包版本。

点击查看英文原文

If you want to update to latest version and you don’t know what is the latest version you can type.

pip install MySQL_python –upgrade

This will update the MySQL_python for latest version available, you can use for any other package version.

知识问答

什么是setup.py？

问题：什么是setup.py？

谁能解释一下setup.py它是什么以及如何进行配置或使用？

点击查看英文原文

Can anyone please explain what setup.py is and how it can be configured or used?

回答 0

setup.py 是一个python文件，通常会告诉您要安装的模块/软件包已与Distutils打包并分发，Distutils是分发Python模块的标准。

这使您可以轻松安装Python软件包。通常写就足够了：

$ pip install .

pip将使用setup.py安装模块。避免setup.py直接调用。

https://docs.python.org/3/installing/index.html#installing-index

点击查看英文原文

setup.py is a python file, which usually tells you that the module/package you are about to install has been packaged and distributed with Distutils, which is the standard for distributing Python Modules.

This allows you to easily install Python packages. Often it’s enough to write:

$ pip install .

pip will use setup.py to install your module. Avoid calling setup.py directly.

https://docs.python.org/3/installing/index.html#installing-index

回答 1

它有助于foo在您的计算机上安装python软件包（也可以位于中virtualenv），以便您可以foo从其他项目以及[I] Python提示符中导入该软件包。

它完成pip，easy_install等的类似工作，

使用 setup.py

让我们从一些定义开始：

包 -包含__init__.py文件的文件夹/目录。
模块 -具有.py扩展名的有效python文件。
分发 -一个软件包与其他软件包和模块的关系。

假设您要安装名为的软件包foo。那你做 

$ git clone https://github.com/user/foo  
$ cd foo
$ python setup.py install

相反，如果您不想实际安装它，但仍然想使用它。然后做， 

$ python setup.py develop

此命令将在站点包内创建到源目录的符号链接，而不是复制内容。因此，它非常快（特别是对于大包装）。

创造 setup.py

如果您有类似的打包树， 

foo
├── foo
│   ├── data_struct.py
│   ├── __init__.py
│   └── internals.py
├── README
├── requirements.txt
└── setup.py

然后，在setup.py脚本中执行以下操作，以便可以将其安装在某些计算机上： 

from setuptools import setup

setup(
   name='foo',
   version='1.0',
   description='A useful module',
   author='Man Foo',
   author_email='foomail@foo.com',
   packages=['foo'],  #same as name
   install_requires=['bar', 'greek'], #external packages as dependencies
)

相反，如果您的程序包树更复杂，如以下所示： 

foo
├── foo
│   ├── data_struct.py
│   ├── __init__.py
│   └── internals.py
├── README
├── requirements.txt
├── scripts
│   ├── cool
│   └── skype
└── setup.py

然后，setup.py在这种情况下，您将像：

from setuptools import setup

setup(
   name='foo',
   version='1.0',
   description='A useful module',
   author='Man Foo',
   author_email='foomail@foo.com',
   packages=['foo'],  #same as name
   install_requires=['bar', 'greek'], #external packages as dependencies
   scripts=[
            'scripts/cool',
            'scripts/skype',
           ]
)

向（setup.py）添加更多内容，并使其得体：

from setuptools import setup

with open("README", 'r') as f:
    long_description = f.read()

setup(
   name='foo',
   version='1.0',
   description='A useful module',
   license="MIT",
   long_description=long_description,
   author='Man Foo',
   author_email='foomail@foo.com',
   url="http://www.foopackage.com/",
   packages=['foo'],  #same as name
   install_requires=['bar', 'greek'], #external packages as dependencies
   scripts=[
            'scripts/cool',
            'scripts/skype',
           ]
)

在long_description被使用pypi.org作为你的包的README描述。

最后，您现在可以将软件包上传到PyPi.org，以便其他人可以使用来安装您的软件包pip install yourpackage。

第一步是使用以下方法在pypi中声明您的软件包名称和空间：

$ python setup.py register

注册您的包裹名称后，任何人都无法声明或使用它。成功注册后，您必须通过以下方式将软件包上传到云（到云）：

$ python setup.py upload

您也可以选择GPG通过以下方式对包裹进行签名：

$ python setup.py --sign upload

奖励：setup.py在此处查看来自真实项目的示例：torchvision-setup.py

点击查看英文原文

It helps to install a python package foo on your machine (can also be in virtualenv) so that you can import the package foo from other projects and also from [I]Python prompts.

It does the similar job of pip, easy_install etc.,

Using setup.py

Let’s start with some definitions:

Package – A folder/directory that contains __init__.py file.
Module – A valid python file with .py extension.
Distribution – How one package relates to other packages and modules.

Let’s say you want to install a package named foo. Then you do, 

$ git clone https://github.com/user/foo  
$ cd foo
$ python setup.py install

Instead, if you don’t want to actually install it but still would like to use it. Then do, 

$ python setup.py develop

This command will create symlinks to the source directory within site-packages instead of copying things. Because of this, it is quite fast (particularly for large packages).

Creating setup.py

If you have your package tree like, 

foo
├── foo
│   ├── data_struct.py
│   ├── __init__.py
│   └── internals.py
├── README
├── requirements.txt
└── setup.py

Then, you do the following in your setup.py script so that it can be installed on some machine: 

from setuptools import setup

setup(
   name='foo',
   version='1.0',
   description='A useful module',
   author='Man Foo',
   author_email='foomail@foo.com',
   packages=['foo'],  #same as name
   install_requires=['bar', 'greek'], #external packages as dependencies
)

Instead, if your package tree is more complex like the one below: 

foo
├── foo
│   ├── data_struct.py
│   ├── __init__.py
│   └── internals.py
├── README
├── requirements.txt
├── scripts
│   ├── cool
│   └── skype
└── setup.py

Then, your setup.py in this case would be like:

from setuptools import setup

setup(
   name='foo',
   version='1.0',
   description='A useful module',
   author='Man Foo',
   author_email='foomail@foo.com',
   packages=['foo'],  #same as name
   install_requires=['bar', 'greek'], #external packages as dependencies
   scripts=[
            'scripts/cool',
            'scripts/skype',
           ]
)

Add more stuff to (setup.py) & make it decent:

from setuptools import setup

with open("README", 'r') as f:
    long_description = f.read()

setup(
   name='foo',
   version='1.0',
   description='A useful module',
   license="MIT",
   long_description=long_description,
   author='Man Foo',
   author_email='foomail@foo.com',
   url="http://www.foopackage.com/",
   packages=['foo'],  #same as name
   install_requires=['bar', 'greek'], #external packages as dependencies
   scripts=[
            'scripts/cool',
            'scripts/skype',
           ]
)

The long_description is used in pypi.org as the README description of your package.

And finally, you’re now ready to upload your package to PyPi.org so that others can install your package using pip install yourpackage.

First step is to claim your package name & space in pypi using:

$ python setup.py register

Once your package name is registered, nobody can claim or use it. After successful registration, you have to upload your package there (to the cloud) by,

$ python setup.py upload

Optionally, you can also sign your package with GPG by,

$ python setup.py --sign upload

Bonus: See a sample setup.py from a real project here: torchvision-setup.py

回答 2

setup.py是Python对多平台安装程序和make文件的解答。

如果您熟悉命令行安装，请make && make install转换为python setup.py build && python setup.py install。

一些软件包是纯Python，并且仅按字节编译。其他可能包含本机代码，这将需要本机编译器（如gcc或cl）和Python接口模块（如swig或pyrex）。

点击查看英文原文

setup.py is Python’s answer to a multi-platform installer and make file.

If you’re familiar with command line installations, then make && make install translates to python setup.py build && python setup.py install.

Some packages are pure Python, and are only byte compiled. Others may contain native code, which will require a native compiler (like gcc or cl) and a Python interfacing module (like swig or pyrex).

回答 3

如果您下载的软件包在根文件夹中具有“ setup.py”，则可以通过运行以下命令进行安装

python setup.py install

如果您正在开发项目，并且想知道此文件的用途，请查看有关编写安装脚本的Python文档。

点击查看英文原文

If you downloaded package that has “setup.py” in root folder, you can install it by running

python setup.py install

If you are developing a project and are wondering what this file is useful for, check Python documentation on writing the Setup Script

回答 4

setup.py是通常用该语言编写的库或程序随附的Python脚本。目的是正确安装软件。

许多软件包将distutils框架与结合使用setup.py。

http://docs.python.org/distutils/

点击查看英文原文

setup.py is a Python script that is usually shipped with libraries or programs, written in that language. It’s purpose is the correct installation of the software.

Many packages use the distutils framework in conjuction with setup.py.

http://docs.python.org/distutils/

回答 5

setup.py可以在两种情况下使用：首先，您要安装Python软件包。其次，您要创建自己的Python包。通常，标准的Python软件包具有几个重要文件，例如setup.py，setup.cfg和Manifest.in。当您创建Python软件包时，这三个文件将确定（egg-info文件夹下PKG-INFO中的内容）名称，版本，描述，其他所需的安装（通常在.txt文件中）以及其他几个参数。创建包时setup.py将读取setup.cfg（可以是tar.gz）。在Manifest.in中，您可以定义应包含在软件包中的内容。无论如何，您都可以使用setup.py做很多事情，例如

python setup.py build
python setup.py install
python setup.py sdist <distname> upload [-r urltorepo]  (to upload package to pypi or local repo)

还有许多其他命令可以与setup.py一起使用。求助

python setup.py --help-commands
点击查看英文原文

setup.py can be used in two scenarios , First, you want to install a Python package. Second, you want to create your own Python package. Usually standard Python package has couple of important files like setup.py, setup.cfg and Manifest.in. When you are creating the Python package, these three files will determine the (content in PKG-INFO under egg-info folder) name, version, description, other required installations (usually in .txt file) and few other parameters. setup.cfg is read by setup.py while package is created (could be tar.gz ). Manifest.in is where you can define what should be included in your package. Anyways you can do bunch of stuff using setup.py like 

python setup.py build
python setup.py install
python setup.py sdist <distname> upload [-r urltorepo]  (to upload package to pypi or local repo)

There are bunch of other commands which could be used with setup.py . for help 

python setup.py --help-commands

回答 6

当您通过setup.py打开终端（Mac，Linux）或命令提示符（Windows）下载软件包时。使用“ cd Tab”按钮并为您提供帮助，将路径设置为已下载文件的文件夹的正确位置，该文​​件夹位于setup.py：

iMac:~ user $ cd path/pakagefolderwithsetupfile/

按Enter键，您应该会看到类似以下内容：

iMac:pakagefolderwithsetupfile user$

然后输入以下内容python setup.py install：

iMac:pakagefolderwithsetupfile user$ python setup.py install

按enter。做完了！

点击查看英文原文

When you download a package with setup.py open your Terminal (Mac,Linux) or Command Prompt (Windows). Using cd and helping you with Tab button set the path right to the folder where you have downloaded the file and where there is setup.py :

iMac:~ user $ cd path/pakagefolderwithsetupfile/

Press enter, you should see something like this:

iMac:pakagefolderwithsetupfile user$

Then type after this python setup.py install :

iMac:pakagefolderwithsetupfile user$ python setup.py install

Press enter. Done!

回答 7

要安装已下载的Python软件包，请提取档案并在其中运行setup.py脚本：

python setup.py install

对我来说，这一直很奇怪。将包管理器指向下载位置会更自然，例如在Ruby和Nodejs中。gem install rails-4.1.1.gem

包管理器也更舒适，因为它既熟悉又可靠。另一方面，每个setup.py都是新颖的，因为它是特定于包装的。它要求遵守约定“我相信此setup.py会接受与过去使用的命令相同的命令”。这是对精神意志力的遗憾。

我并不是说setup.py工作流的安全性不如包管理器（我知道Pip只是在内部运行setup.py），但是我肯定觉得这很麻烦。将所有命令都发送到同一个程序包管理器应用程序是一种和谐。您甚至可能会喜欢它。

点击查看英文原文

To install a Python package you’ve downloaded, you extract the archive and run the setup.py script inside:

python setup.py install

To me, this has always felt odd. It would be more natural to point a package manager at the download, as one would do in Ruby and Nodejs, eg. gem install rails-4.1.1.gem

A package manager is more comfortable too, because it’s familiar and reliable. On the other hand, each setup.py is novel, because it’s specific to the package. It demands faith in convention “I trust this setup.py takes the same commands as others I have used in the past”. That’s a regrettable tax on mental willpower.

I’m not saying the setup.py workflow is less secure than a package manager (I understand Pip just runs the setup.py inside), but certainly I feel it’s awkard and jarring. There’s a harmony to commands all being to the same package manager application. You might even grow fond it.

回答 8

setup.py是与其他文件一样的Python文件。它可以采用任何名称，除非按惯例命名，否则setup.py每个脚本都没有不同的过程。

最常setup.py用于安装Python模块，但用于服务器其他目的：

模块：

也许这是setup.py模块中最著名的用法。尽管可以使用来安装它们pip，但pip默认情况下不包括旧的Python版本，因此需要单独安装。

如果您想安装模块但不想安装pip，则唯一的选择是从setup.py文件安装模块。这可以通过完成python setup.py install。这将Python模块安装到根字典（不pip，easy_installECT）。

pip失败时通常使用此方法。例如，如果所需软件包的正确Python版本pip由于可能由于不再维护而无法提供，则下载源并运行python setup.py install将执行相同的操作，除非需要编译的二进制文件（但将忽略编译的二进制文件）。 Python版本-除非返回错误）。

的另一种用法setup.py是从源代码安装软件包。如果模块仍在开发中，则将无法使用wheel文件，并且唯一的安装方法是直接从源代码进行安装。

构建Python扩展：

构建模块后，可以使用distutils安装脚本将其转换为可分发的模块。一旦构建完成，就可以使用上面的命令进行安装。

安装脚本易于构建，一旦文件已正确配置并且可以通过运行进行编译python setup.py build（请参阅所有命令的链接）。

再次setup.py按易用性和惯例命名，但可以使用任何名称。

Cython：

setup.py文件的另一种著名用法包括编译后的扩展名。这些需要具有用户定义值的安装脚本。它们允许快速执行（但一旦编译则依赖平台）。这是文档中的一个简单示例：

from distutils.core import setup
from Cython.Build import cythonize

setup(
    name = 'Hello world app',
    ext_modules = cythonize("hello.pyx"),
)

这可以通过编译 python setup.py build

Cx_Freeze：

需要安装脚本的另一个模块是cx_Freeze。这会将Python脚本转换为可执行文件。这允许包括描述，名称，图标，包在内的许多命令包括，排除等，并且一旦运行将产生可分发的应用程序。文档中的示例：

import sys
from cx_Freeze import setup, Executable
build_exe_options = {"packages": ["os"], "excludes": ["tkinter"]} 

base = None
if sys.platform == "win32":
    base = "Win32GUI"

setup(  name = "guifoo",
        version = "0.1",
        description = "My GUI application!",
        options = {"build_exe": build_exe_options},
        executables = [Executable("guifoo.py", base=base)])

可以通过编译python setup.py build。

那么什么是setup.py文件？

很简单，它是一个在Python环境中构建或配置某些东西的脚本。

分发时，程序包应仅包含一个安装脚本，但将多个脚本组合成一个安装脚本并不少见。请注意，这经常涉及distutils但并非总是如此（如我在上一个示例中所示）。要记住的事情是以某种方式配置Python包/脚本。

它使用名称，因此在构建或安装时始终可以使用相同的命令。

点击查看英文原文

setup.py is a Python file like any other. It can take any name, except by convention it is named setup.py so that there is not a different procedure with each script.

Most frequently setup.py is used to install a Python module but server other purposes:

Modules:

Perhaps this is most famous usage of setup.py is in modules. Although they can be installed using pip, old Python versions did not include pip by default and they needed to be installed separately.

If you wanted to install a module but did not want to install pip, just about the only alternative was to install the module from setup.py file. This could be achieved via python setup.py install. This would install the Python module to the root dictionary (without pip, easy_install ect).

This method is often used when pip will fail. For example if the correct Python version of the desired package is not available via pipperhaps because it is no longer maintained, , downloading the source and running python setup.py install would perform the same thing, except in the case of compiled binaries are required, (but will disregard the Python version -unless an error is returned).

Another use of setup.py is to install a package from source. If a module is still under development the wheel files will not be available and the only way to install is to install from the source directly.

Building Python extensions:

When a module has been built it can be converted into module ready for distribution using a distutils setup script. Once built these can be installed using the command above.

A setup script is easy to build and once the file has been properly configured and can be compiled by running python setup.py build (see link for all commands).

Once again it is named setup.py for ease of use and by convention, but can take any name.

Cython:

Another famous use of setup.py files include compiled extensions. These require a setup script with user defined values. They allow fast (but once compiled are platform dependant) execution. Here is a simple example from the documentation:

from distutils.core import setup
from Cython.Build import cythonize

setup(
    name = 'Hello world app',
    ext_modules = cythonize("hello.pyx"),
)

This can be compiled via python setup.py build

Cx_Freeze:

Another module requiring a setup script is cx_Freeze. This converts Python script to executables. This allows many commands such as descriptions, names, icons, packages to include, exclude ect and once run will produce a distributable application. An example from the documentation:

import sys
from cx_Freeze import setup, Executable
build_exe_options = {"packages": ["os"], "excludes": ["tkinter"]} 

base = None
if sys.platform == "win32":
    base = "Win32GUI"

setup(  name = "guifoo",
        version = "0.1",
        description = "My GUI application!",
        options = {"build_exe": build_exe_options},
        executables = [Executable("guifoo.py", base=base)])

This can be compiled via python setup.py build.

So what is a setup.py file?

Quite simply it is a script that builds or configures something in the Python environment.

A package when distributed should contain only one setup script but it is not uncommon to combine several together into a single setup script. Notice this often involves distutils but not always (as I showed in my last example). The thing to remember it just configures Python package/script in some way.

It takes the name so the same command can always be used when building or installing.

回答 9

为简单起见，setup.py的运行就像"__main__"您在调用安装函数时提到的其他答案一样。在setup.py内部，应该放置安装软件包所需的一切。

常用的setup.py功能

以下两节讨论了许多setup.py模块具有的两件事。

setuptools.setup

此功能允许您指定项目属性，例如项目的名称，版本。…最重要的是，如果其他功能打包正确，此功能将允许您安装其他功能。请参阅此网页以获取setuptools.setup的示例。setuptools.setup的

这些属性允许安装以下类型的软件包：

自定义功能

在理想的世界中，setuptools.setup将为您处理所有事情。不幸的是，情况并非总是如此。有时，您需要做一些特定的事情，例如使用subprocess命令安装依赖项，以使要安装的系统处于正确的软件包状态。尝试避免这种情况，这些功能会造成混乱，并且在OS甚至发行版之间通常会有所不同。

点击查看英文原文

To make it simple, setup.py is run as "__main__" when you call the install functions the other answers mentioned. Inside setup.py, you should put everything needed to install your package.

Common setup.py functions

The following two sections discuss two things many setup.py modules have.

setuptools.setup

This function allows you to specify project attributes like the name of the project, the version…. Most importantly, this function allows you to install other functions if they’re packaged properly. See this webpage for an example of setuptools.setup

These attributes of setuptools.setup enable installing these types of packages:

  • Packages that are imported to your project and listed in PyPI using setuptools.findpackages:

    packages=find_packages(exclude=["docs","tests", ".gitignore", "README.rst","DESCRIPTION.rst"])

  • Packages not in PyPI, but can be downloaded from a URL using dependency_links

    dependency_links=["http://peak.telecommunity.com/snapshots/",]

Custom functions

In an ideal world, setuptools.setup would handle everything for you. Unfortunately this isn’t always the case. Sometimes you have to do specific things, like installing dependencies with the subprocess command, to get the system you’re installing on in the right state for your package. Try to avoid this, these functions get confusing and often differ between OS and even distribution.