标签归档：python-3.x

如何在Python 3中使用raw_input

2021年7月25日 Python实用宝典

问题：如何在Python 3中使用raw_input

import sys
print(sys.platform)
print(2**100)
raw_input()

我正在使用Python 3.1，无法raw_input“冻结” dos弹出窗口。我正在阅读的书是针对Python 2.5的，而我正在使用Python 3.1

我应该怎么做才能解决这个问题？

import sys
print(sys.platform)
print(2**100)
raw_input()

I am using Python 3.1 and can’t get the raw_input to “freeze” the dos pop-up. The book I’m reading is for Python 2.5 and I’m using Python 3.1

What should I do to fix this?

回答 0

从Python 3开始，raw_input()已重命名为input()。

摘自Python 3.0的新增功能，“内置”部分的第二项。

Starting with Python 3, raw_input() was renamed to input().

From What’s New In Python 3.0, Builtins section second item.

回答 1

这适用于Python 3.x和2.x：

# Fix Python 2.x.
try: input = raw_input
except NameError: pass
print("Hi " + input("Say something: "))

This works in Python 3.x and 2.x:

# Fix Python 2.x.
try: input = raw_input
except NameError: pass
print("Hi " + input("Say something: "))

回答 2

解决此问题的可靠方法是

from six.moves import input

六是一个模块，可修补许多2/3通用代码基础痛点。

A reliable way to address this is

from six.moves import input

six is a module which patches over many of the 2/3 common code base pain points.

回答 3

正如其他人所指出的那样，该raw_input函数已input在Python 3.0中重命名为，确实可以得到一本更新的书来更好地服务，但我想指出的是，有更好的方法可以查看脚本的输出。

根据您的描述，我认为您正在使用Windows，已经保存了一个.py文件，然后双击它来运行它。程序结束后，弹出的终端窗口将立即关闭，因此您看不到程序的结果是什么。为了解决这个问题，您的书建议添加raw_input/input语句，直到用户按下Enter键。但是，正如您所看到的，如果出现问题（例如程序中的错误），则该语句将不会执行，并且在您看不到问题出在哪里之前，该窗口将关闭。您可能会发现使用命令提示符或IDLE更容易。

使用命令提示符

当您查看包含Python程序的文件夹窗口时，请按住shift键并右键单击窗口白色背景区域中的任意位置。弹出的菜单应包含“此处打开命令窗口”条目。（我认为这适用于Windows Vista和Windows7。）这将打开一个命令提示符窗口，如下所示：

    Microsoft Windows [Version 6.1.7601]
    Copyright (c) 2009 Microsoft Corporation.  All rights reserved.

    C:\Users\Weeble\My Python Program>_

要运行您的程序，请键入以下内容（替换您的脚本名称）：

    python myscript.py

…然后按Enter。（如果收到“ python”不是可识别的命令的错误，请参阅http://showmedo.com/videotutorials/video?name=960000&fromSeriesID=96）当程序完成运行时，无论是否成功完成，该窗口将保持打开状态，并且命令提示符将再次出现，以供您键入其他命令。如果要再次运行程序，则可以按向上箭头以调出您输入的上一个命令，然后按Enter键再次运行它，而不必每次都键入文件名。

使用IDLE

IDLE是随Python一起安装的简单程序编辑器。除其他功能外，它还可以在窗口中运行程序。右键单击您的.py文件，然后选择“在IDLE中编辑”。当您的程序出现在编辑器中时，按F5或从“运行”菜单中选择“运行模块”。程序将在程序结束后的窗口中运行，您可以在其中输入Python命令以立即运行。

As others have indicated, the raw_input function has been renamed to input in Python 3.0, and you really would be better served by a more up-to-date book, but I want to point out that there are better ways to see the output of your script.

From your description, I think you’re using Windows, you’ve saved a .py file and then you’re double-clicking on it to run it. The terminal window that pops up closes as soon as your program ends, so you can’t see what the result of your program was. To solve this, your book recommends adding a raw_input / input statement to wait until the user presses enter. However, as you’ve seen, if something goes wrong, such as an error in your program, that statement won’t be executed and the window will close without you being able to see what went wrong. You might find it easier to use a command-prompt or IDLE.

Use a command-prompt

When you’re looking at the folder window that contains your Python program, hold down shift and right-click anywhere in the white background area of the window. The menu that pops up should contain an entry “Open command window here”. (I think this works on Windows Vista and Windows 7.) This will open a command-prompt window that looks something like this:

    Microsoft Windows [Version 6.1.7601]
    Copyright (c) 2009 Microsoft Corporation.  All rights reserved.

    C:\Users\Weeble\My Python Program>_

To run your program, type the following (substituting your script name):

    python myscript.py

…and press enter. (If you get an error that “python” is not a recognized command, see http://showmedo.com/videotutorials/video?name=960000&fromSeriesID=96 ) When your program finishes running, whether it completes successfully or not, the window will remain open and the command-prompt will appear again for you to type another command. If you want to run your program again, you can press the up arrow to recall the previous command you entered and press enter to run it again, rather than having to type out the file name every time.

Use IDLE

IDLE is a simple program editor that comes installed with Python. Among other features it can run your programs in a window. Right-click on your .py file and choose “Edit in IDLE”. When your program appears in the editor, press F5 or choose “Run module” from the “Run” menu. Your program will run in a window that stays open after your program ends, and in which you can enter Python commands to run immediately.

回答 4

Timmerman的解决方案在运行代码时效果很好，但是如果您不想Undefined name在使用pyflakes或类似的linter时出错，则可以使用以下代码：

try:
    import __builtin__
    input = getattr(__builtin__, 'raw_input')
except (ImportError, AttributeError):
    pass

Timmerman’s solution works great when running the code, but if you don’t want to get Undefined name errors when using pyflakes or a similar linter you could use the following instead:

try:
    import __builtin__
    input = getattr(__builtin__, 'raw_input')
except (ImportError, AttributeError):
    pass

回答 5

这是我在脚本中输入的一段代码，我不想在与py2 / 3无关的环境中运行：

# Thank you, python2-3 team, for making such a fantastic mess with
# input/raw_input :-)
real_raw_input = vars(__builtins__).get('raw_input',input)

现在，您可以使用real_raw_input。它相当昂贵，但简短易读。使用原始输入通常很耗时（等待输入），因此并不重要。

从理论上讲，您甚至可以分配raw_input而不是real_raw_input，但是可能会有一些模块检查raw_input的存在并相应地运行。最好保持安全。

Here’s a piece of code I put in my scripts that I wan’t to run in py2/3-agnostic environment:

# Thank you, python2-3 team, for making such a fantastic mess with
# input/raw_input :-)
real_raw_input = vars(__builtins__).get('raw_input',input)

Now you can use real_raw_input. It’s quite expensive but short and readable. Using raw input is usually time expensive (waiting for input), so it’s not important.

In theory, you can even assign raw_input instead of real_raw_input but there might be modules that check existence of raw_input and behave accordingly. It’s better stay on the safe side.

回答 6

可能不是最好的解决方案，但是在我来这里之前，我只是在不停学习的情况下即时进行此操作以保持工作状态。

def raw_input(x):
  input(x)

然后，当我raw_input('Enter your first name: ')在我正在处理的脚本上运行时，它会捕获它input()。

可能有一个原因，我还没有遇到呢！

Probably not the best solution, but before I came here I just made this on the fly to keep working without having a quick break from study.

def raw_input(x):
  input(x)

Then when I run raw_input('Enter your first name: ') on the script I was working on, it captures it as does input() would.

There may be a reason not to do this, that I haven’t come across yet!

知识问答

如何使用Python 3安装pip？

2021年7月25日 Python实用宝典

问题：如何使用Python 3安装pip？

我要安装pip。它应支持Python 3，但需要setuptools，该工具仅适用于Python 2。

如何使用Python 3安装pip？

I want to install pip. It should support Python 3, but it requires setuptools, which is available only for Python 2.

How can I install pip with Python 3?

回答 0

编辑：手动安装和使用setuptools不再是标准过程。

如果您运行的是Python 2.7.9+或Python 3.4+

恭喜，您应该已经pip安装了。如果您不这样做，请继续阅读。

如果您正在运行类似Unix的系统

pip如果您的Python版本低于2.7.9或3.4，或者您的系统出于任何原因未包含该软件包，通常可以通过软件包管理器进行安装。

以下是一些更常见发行版的说明。

在适用于Python 2.x的Debian（Wheezy和更高版本）和Ubuntu（Trusty Tahr和更高版本）上安装

从终端运行以下命令：

sudo apt-get install python-pip

在适用于Python 3.x的Debian（Wheezy和更高版本）和Ubuntu（Trusty Tahr和更高版本）上安装

从终端运行以下命令：

sudo apt-get install python3-pip

注意：

在全新安装的Debian / Ubuntu中，只有在执行以下操作后才能找到该软件包：

sudo apt-get update

`pip`在适用于Python 2.x的CentOS 7上安装

在CentOS 7上，您必须先安装设置工具，然后再使用它来安装pip，因为它没有直接的软件包。

sudo yum install python-setuptools
sudo easy_install pip

`pip`在适用于Python 3.x的CentOS 7上安装

假设您从EPEL安装了Python 3.4 ，则可以安装Python 3的设置工具并使用它进行安装pip。

# First command requires you to have enabled EPEL for CentOS7
sudo yum install python34-setuptools
sudo easy_install pip

如果您的Unix / Linux发行版未在软件包repos中包含它

使用下面详细介绍的手动方法进行安装。

手动方式

如果您想手动进行操作，现在推荐的方法是使用安装说明中的get-pip.py脚本进行pip安装。

安装点子

要安装pip，请安全下载 get-pip.py

然后运行以下命令（可能需要管理员访问权限）：
python get-pip.py 
如果setuptools尚未安装，get-pip.py将为您安装setuptools。

edit: Manual installation and use of setuptools is not the standard process anymore.

If you’re running Python 2.7.9+ or Python 3.4+

Congrats, you should already have pip installed. If you do not, read onward.

If you’re running a Unix-like System

You can usually install the package for pip through your package manager if your version of Python is older than 2.7.9 or 3.4, or if your system did not include it for whatever reason.

Instructions for some of the more common distros follow.

Installing on Debian (Wheezy and newer) and Ubuntu (Trusty Tahr and newer) for Python 2.x

Run the following command from a terminal:

sudo apt-get install python-pip

Installing on Debian (Wheezy and newer) and Ubuntu (Trusty Tahr and newer) for Python 3.x

Run the following command from a terminal:

sudo apt-get install python3-pip

Note:

On a fresh Debian/Ubuntu install, the package may not be found until you do:

sudo apt-get update

Installing `pip` on CentOS 7 for Python 2.x

On CentOS 7, you have to install setup tools first, and then use that to install pip, as there is no direct package for it.

sudo yum install python-setuptools
sudo easy_install pip

Installing `pip` on CentOS 7 for Python 3.x

Assuming you installed Python 3.4 from EPEL, you can install Python 3’s setup tools and use it to install pip.

# First command requires you to have enabled EPEL for CentOS7
sudo yum install python34-setuptools
sudo easy_install pip

If your Unix/Linux distro doesn’t have it in package repos

Install using the manual way detailed below.

The manual way

If you want to do it the manual way, the now-recommended method is to install using the get-pip.py script from pip‘s installation instructions.

Install pip

To install pip, securely download get-pip.py

Then run the following (which may require administrator access):
python get-pip.py 
If setuptools is not already installed, get-pip.py will install setuptools for you.

回答 1

我可以通过运行Ubuntu在python 3上安装pip sudo apt-get install python3-pip。

I was able to install pip for python 3 on Ubuntu just by running sudo apt-get install python3-pip.

回答 2

Python 3.4以上和Python 2.7.9以上

好消息！Pip随附了Python 3.4（2014年3月发布）。这是所有Python版本中的最佳功能。它使每个人都可以访问社区丰富的图书馆。新手不再因安装的困难而被排除在外。在与软件包管理器一起交付时，Python加入了Ruby，Nodejs，Haskell，Perl，Go以及几乎所有其他具有主流开源社区的当代语言。谢谢Python。

当然，这并不意味着Python打包已解决问题。经验仍然令人沮丧。我在Python是否有软件包/模块管理系统中讨论了这一点？

las惜使用早期Python的每个人。遵循手册说明。

Python≤2.7.8和Python≤3.3

按照我的详细说明在 https://stackoverflow.com/a/12476379/284795。实质上

官方指示

根据https://pip.pypa.io/en/stable/installing.html

下载时get-pip.py，请小心保存为.py文件而不是文件.txt。然后，在命令提示符下运行它。

python get-pip.py

您可能需要管理员命令提示符才能执行此操作。遵循http://technet.microsoft.com/en-us/library/cc947813(v=ws.10).aspx

对我来说，此安装点位于C:\Python27\Scripts\pip.exe。pip.exe在您的计算机上查找，然后将其文件夹（例如C:\Python27\Scripts）添加到您的路径（开始/编辑环境变量）。现在，您应该可以从命令行运行pip了。尝试安装软件包：

pip install httpie

你去了（希望）！

Python 3.4+ and Python 2.7.9+

Good news! Python 3.4 (released March 2014) ships with Pip. This is the best feature of any Python release. It makes the community’s wealth of libraries accessible to everyone. Newbies are no longer excluded by the prohibitive difficulty of setup. In shipping with a package manager, Python joins Ruby, Nodejs, Haskell, Perl, Go–almost every other contemporary language with a majority open-source community. Thank you Python.

Of course, that doesn’t mean Python packaging is problem solved. The experience remains frustrating. I discuss this at Does Python have a package/module management system?

Alas for everyone using an earlier Python. Manual instructions follow.

Python ≤ 2.7.8 and Python ≤ 3.3

Follow my detailed instructions at https://stackoverflow.com/a/12476379/284795 . Essentially

Official instructions

Per https://pip.pypa.io/en/stable/installing.html

Download get-pip.py, being careful to save it as a .py file rather than .txt. Then, run it from the command prompt.

python get-pip.py

You possibly need an administrator command prompt to do this. Follow http://technet.microsoft.com/en-us/library/cc947813(v=ws.10).aspx

For me, this installed Pip at C:\Python27\Scripts\pip.exe. Find pip.exe on your computer, then add its folder (eg. C:\Python27\Scripts) to your path (Start / Edit environment variables). Now you should be able to run pip from the command line. Try installing a package:

pip install httpie

There you go (hopefully)!

回答 3

对于Ubuntu 12.04或更旧版本，

sudo apt-get install python3-pip

将无法正常工作。而是使用：

sudo apt-get install python3-setuptools ca-certificates
sudo easy_install3 pip

For Ubuntu 12.04 or older,

sudo apt-get install python3-pip

won’t work. Instead, use:

sudo apt-get install python3-setuptools ca-certificates
sudo easy_install3 pip

回答 4

如果您使用的是python 3.4+

只需输入：

python3 -m pip

if you’re using python 3.4+

just type:

python3 -m pip

回答 5

2015年1月20日更新：

根据https://pip.pypa.io/en/latest/installing.html，当前方式为：

wget https://bootstrap.pypa.io/get-pip.py
python get-pip.py

我认为这适用于任何版本

原始答案：

wget http://python-distribute.org/distribute_setup.py
python distribute_setup.py
easy_install pip

Update 2015-01-20:

As per https://pip.pypa.io/en/latest/installing.html the current way is:

wget https://bootstrap.pypa.io/get-pip.py
python get-pip.py

I think that should work for any version

Original Answer:

wget http://python-distribute.org/distribute_setup.py
python distribute_setup.py
easy_install pip

回答 6

系统中的单个Python

要在Python中安装软件包，请始终遵循以下步骤：

如果包装是用于python 2.x：sudo python -m pip install [package]
如果包装是用于python 3.x：sudo python3 -m pip install [package]

注意：这是假设未为设置别名 python

通过这种方法，将不会混淆哪个Python版本正在接收该软件包。

多个Python

假设你有python3 ↔ python3.6和python3.7 ↔ python3.7

要安装python3.6：sudo python3 -m pip install [package]
要安装python3.7：sudo python3.7 -m pip install [package]

这基本上与前面显示的方法相同。

注1

如何找到您的python3命令产生的python ：

ganesh@Ganesh:~$ python3 # Type in terminal
Python 3.6.6 (default, Sep 12 2018, 18:26:19) # Your python3 version
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

注意第二行中的python 3.6.6。

笔记2

更改python3或python指向以下内容：https : //askubuntu.com/questions/320996/how-to-make-python-program-command-execute-python-3

Single Python in system

To install packages in Python always follow these steps:

If the package is for python 2.x: sudo python -m pip install [package]
If the package is for python 3.x: sudo python3 -m pip install [package]

Note: This is assuming no alias is set for python

Through this method, there will be no confusion regarding which python version is receiving the package.

Multiple Pythons

Say you have python3 ↔ python3.6 and python3.7 ↔ python3.7

To install for python3.6: sudo python3 -m pip install [package]
To instal for python3.7: sudo python3.7 -m pip install [package]

This is essentially the same method as shown previously.

Note 1

How to find which python, your python3 command spawns:

ganesh@Ganesh:~$ python3 # Type in terminal
Python 3.6.6 (default, Sep 12 2018, 18:26:19) # Your python3 version
[GCC 8.0.1 20180414 (experimental) [trunk revision 259383]] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Notice python 3.6.6 in the second line.

Note 2

Change what python3 or python points to: https://askubuntu.com/questions/320996/how-to-make-python-program-command-execute-python-3

回答 7

python3 -m ensurepip

我不确定何时确切引入此功能，但尚不存在时会为我安装pip3。

python3 -m ensurepip

I’m not sure when exactly this was introduced, but it’s installed pip3 for me when it didn’t already exist.

回答 8

旧版的Homebrew

如果您使用的是macOS，请使用homebrew。

brew install python3 # this installs python only
brew postinstall python3 # this command installs pip

另请注意，如果安装成功完成，则应检查控制台。有时没有（例如由于所有权引起的错误），但是人们只是忽略了日志。

更新-1.5之后的自制软件版本

根据官方的Homebrew页面：

在2018年3月1日，python公式将升级到Python 3.x，并且将添加python @ 2公式以安装Python 2.7（尽管这仅是小桶，因此默认情况下，不将python和python2添加到PATH中，而无需手动冲泡链接–force）。我们将维护python2，python3和python @ 3别名。

因此，要安装Python 3，请运行以下命令：

brew install python3

然后，pip会自动安装，您可以通过来安装任何软件包pip install <package>。

Older version of Homebrew

If you are on macOS, use homebrew.

brew install python3 # this installs python only
brew postinstall python3 # this command installs pip

Also note that you should check the console if the install finished successfully. Sometimes it doesn’t (e.g. an error due to ownership), but people simply overlook the log.

UPDATED – Homebrew version after 1.5

According to the official Homebrew page:

On 1st March 2018 the python formula will be upgraded to Python 3.x and a python@2 formula will be added for installing Python 2.7 (although this will be keg-only so neither python nor python2 will be added to the PATH by default without a manual brew link –force). We will maintain python2, python3 and python@3 aliases.

So to install Python 3, run the following command:

brew install python3

Then, the pip is installed automatically, and you can install any package by pip install <package>.

回答 9

如果您使用多个不同版本的python，请尝试使用virtualenv http://www.virtualenv.org/en/latest/virtualenv.html#installation

具有pip针对每个本地环境的优势。

然后通过以下方式在当前目录中安装本地环境：

virtualenv -p /usr/local/bin/python3.3 ENV --verbose

请注意，您指定了系统上已安装的python二进制文件的路径。

然后在该文件夹中有一个本地pythonenvironment。 ./ENV

现在应该有 ./ENV/pip-3.3

用于 ./ENV/pip-3.3 freeze列出本地安装的库。

用于./ENV/pip-3.3 install packagename在本地环境中安装。

用于./ENV/python3.3 pythonfile.py运行您的python脚本。

If you use several different versions of python try using virtualenv http://www.virtualenv.org/en/latest/virtualenv.html#installation

With the advantage of pip for each local environment.

Then install a local environment in the current directory by:

virtualenv -p /usr/local/bin/python3.3 ENV --verbose

Note that you specify the path to a python binary you have installed on your system.

Then there are now an local pythonenvironment in that folder. ./ENV

Now there should be ./ENV/pip-3.3

use ./ENV/pip-3.3 freeze to list the local installed libraries.

use ./ENV/pip-3.3 install packagename to install at the local environment.

use ./ENV/python3.3 pythonfile.py to run your python script.

回答 10

这是我在ubuntu 12.04上解决此问题的方法：

sudo apt-get install build-essential libncursesw5-dev libssl-dev libgdbm-dev libc6-dev libsqlite3-dev tk-dev

然后从源代码安装python3：

wget https://www.python.org/ftp/python/3.4.0/Python-3.4.0.tar.xz
tar xvf Python-3.4.0.tar.xz
cd Python-3.4.0
./configure
make
make test
sudo make install

当您全部安装完后，pip3将自动安装。

Here is my way to solve this problem at ubuntu 12.04:

sudo apt-get install build-essential libncursesw5-dev libssl-dev libgdbm-dev libc6-dev libsqlite3-dev tk-dev

Then install the python3 from source code:

wget https://www.python.org/ftp/python/3.4.0/Python-3.4.0.tar.xz
tar xvf Python-3.4.0.tar.xz
cd Python-3.4.0
./configure
make
make test
sudo make install

When you finished installing all of them, pip3 will get installed automatically.

回答 11

这就是我在OS X Mavericks上所做的工作，以使其正常工作。

首先，冲泡安装了

安装python 3.4

brew install python3

然后，我得到了最新版本的distribution：

wget https://pypi.python.org/packages/source/d/distribute/distribute-0.7.3.zip#md5=c6c59594a7b180af57af8a0cc0cf5b4a

unzip distribute-0.7.3.zip
cd distribute-0.7.3
sudo setup.py install
sudo easy_install-3.4 pip
sudo pip3.4 install virtualenv
sudo pip3.4 install virtualenvwrapper

mkvirtualenv py3 

python --version
Python 3.4.1

我希望这有帮助。

This is what I did on OS X Mavericks to get this to work.

Firstly, have brew installed

Install python 3.4

brew install python3

Then I get the latest version of distribute:

wget https://pypi.python.org/packages/source/d/distribute/distribute-0.7.3.zip#md5=c6c59594a7b180af57af8a0cc0cf5b4a

unzip distribute-0.7.3.zip
cd distribute-0.7.3
sudo setup.py install
sudo easy_install-3.4 pip
sudo pip3.4 install virtualenv
sudo pip3.4 install virtualenvwrapper

mkvirtualenv py3 

python --version
Python 3.4.1

I hope this helps.

回答 12

Python 3.4新增功能

…

点子应该总是可用

…

默认情况下，命令pipX和pipX.Y将连同pip Python软件包及其依赖项一起安装在所有平台上（其中XY代表Python安装的版本）。

https://docs.python.org/3/whatsnew/3.4.html#whatsnew-pep-453

因此，如果您安装了python 3.4，则可以： sudo pip3 install xxx

What’s New In Python 3.4

…

pip should always be available

…

By default, the commands pipX and pipX.Y will be installed on all platforms (where X.Y stands for the version of the Python installation), along with the pip Python package and its dependencies.

https://docs.python.org/3/whatsnew/3.4.html#whatsnew-pep-453

so if you have python 3.4 installed, you can just: sudo pip3 install xxx

回答 13

对于python3，请尝试以下操作：

wget https://bitbucket.org/pypa/setuptools/raw/bootstrap/ez_setup.py -O - | python

好消息是它还将检测您拥有的python版本（即使它是您自定义位置中的python环境）。之后，您可以正常进行操作（例如）

pip install numpy

资源： https //pypi.python.org/pypi/setuptools/1.1.6#upgrading-from-setuptools-0-6

For python3 try this:

wget https://bitbucket.org/pypa/setuptools/raw/bootstrap/ez_setup.py -O - | python

The good thing is that It will also detect what version of python you have (even if it’s an environment of python in your custom location). After this you can proceed normally with (for example)

pip install numpy

source: https://pypi.python.org/pypi/setuptools/1.1.6#upgrading-from-setuptools-0-6

回答 14

假设您处于高度受限的计算机环境中（例如我本人），而没有root访问权限或无法安装软件包…

在发布本文之前，我从未设置过Python / virtualenv的新/独立/原始/非根实例。我已经做了很多谷歌搜索工作。

确定您使用的是python（python2）还是python3，并正确设置PATH。（我严格是python3用户。）如果您是python2用户python3，python则下面的所有命令都可以代替。
wget https://pypi.python.org/packages/source/v/virtualenv/virtualenv-x.y.z.tar.gz
tar -xzvf virtualenv-x.y.z.tar.gz
python3 virtualenv-x.y.z/virtualenv.py --python $(which python3) /path/to/new/virtualenv
source /path/to/new/virtualenv/bin/activate
- 假设您使用的是兼容Bourne的外壳，例如bash
- 出色的是，此virtualenv软件包包括的独立版本，pip并且setuptools会自动神奇地安装到每个新的virtualenv中。这解决了鸡肉和鸡蛋的问题。
- 您可能想为此最终命令创建一个别名（或更新〜/ .bashrc等），以在每次登录时激活python virtualenv。记住所有这些路径和命令可能很痛苦。
现在检查您的python版本：which python3应该给出：/path/to/new/virtualenv/bin/python3
pip也可以通过以下命令在virtualenv中进行检查which pip：应该给出：/path/to/new/virtualenv/bin/pip

然后…点，点，点！

给新手Pythoneers的最后提示：开始时您不需要虚拟环境，但是以后会很高兴的。帮助开源/共享软件包的“假设情况”安装/升级方案。

参考：https : //virtualenv.pypa.io/en/latest/installation.html

Assuming you are in a highly restricted computer env (such as myself) without root access or ability to install packages…

I had never setup a fresh/standalone/raw/non-root instance of Python+virtualenv before this post. I had do quite a bit of Googling to make this work.

Decide if you are using python (python2) or python3 and set your PATH correctly. (I am strictly a python3 user.) All commands below can substitute python3 for python if you are python2 user.
wget https://pypi.python.org/packages/source/v/virtualenv/virtualenv-x.y.z.tar.gz
tar -xzvf virtualenv-x.y.z.tar.gz
python3 virtualenv-x.y.z/virtualenv.py --python $(which python3) /path/to/new/virtualenv
source /path/to/new/virtualenv/bin/activate
- Assumes you are using a Bourne-compatible shell, e.g., bash
- Brilliantly, this virtualenv package includes a standalone version of pip and setuptools that are auto-magically installed into each new virtualenv. This solves the chicken and egg problem.
- You may want to create an alias (or update your ~/.bashrc, etc.) for this final command to activate the python virtualenv during each login. It can be a pain to remember all these paths and commands.
Check your version of python now: which python3 should give: /path/to/new/virtualenv/bin/python3
Check pip is also available in the virtualenv via which pip… should give: /path/to/new/virtualenv/bin/pip

Then… pip, pip, pip!

Final tip to newbie Pythoneers: You don’t think you need virtualenv when you start, but you will be happy to have it later. Helps with “what if” installation / upgrade scenarios for open source / shared packages.

Ref: https://virtualenv.pypa.io/en/latest/installation.html

回答 15

pip在您安装Python时一起安装。您可以使用 sudo pip install (module) 或 python3 -m pip install (module)。

pip is installed together when you install Python. You can use sudo pip install (module) or python3 -m pip install (module).

回答 16

要安装pip，请安全下载get-pip.py。

然后运行以下命令：

python get-pip.py

如果您使用的是由操作系统或其他程序包管理器管理的Python安装，请务必谨慎。get-pip.py与这些工具不协调，可能会使您的系统处于不一致状态。

参考：PIP安装

To install pip, securely download get-pip.py.

Then run the following:

python get-pip.py

Be cautious if you’re using a Python install that’s managed by your operating system or another package manager. get-pip.py does not coordinate with those tools, and may leave your system in an inconsistent state.

Refer: PIP Installation

回答 17

对于Windows 8.1 / 10 OS用户，只需打开 cmd（命令提示符）

写这个： C:\Users\%USERNAME%\AppData\Local\Programs\Python\Python36-32\Scripts

然后

只需这样写：pip3 install{软件包名称}

提示：Python36-32对于新的python 3.x版本，文件夹的位置可能会有所不同

And for Windows 8.1/10 OS Users just open cmd (command prompt)

write this : C:\Users\%USERNAME%\AppData\Local\Programs\Python\Python36-32\Scripts

then

just write this : pip3 install {name of package}

Hint: the location of folder Python36-32 may get different for new python 3.x versions

回答 18

如果您的Linux发行版中已经安装了Python，则应该可以使用系统的软件包管理器来安装PIP。这是可取的，因为系统安装的Python版本无法与Windows和Mac上使用的get-pip.py脚本很好地配合使用。

高级打包工具（Python 2.x）

sudo apt-get install python-pip

进阶套件工具（Python 3.x）

sudo apt-get install python3-pip

pacman软件包管理器（Python 2.x）

sudo pacman -S python2-pip

pacman软件包管理器（Python 3.x）

sudo pacman -S python-pip

Yum软件包管理器（Python 2.x）

sudo yum upgrade python-setuptools
sudo yum install python-pip python-wheel

Yum软件包管理器（Python 3.x）

sudo yum install python3 python3-wheel

Dandified Yum（Python 2.x）

sudo dnf upgrade python-setuptools
sudo dnf install python-pip python-wheel

Dandified Yum（Python 3.x）

sudo dnf install python3 python3-wheel

Zypper软件包管理器（Python 2.x）

sudo zypper install python-pip python-setuptools python-wheel

Zypper软件包管理器（Python 3.x）

sudo zypper install python3-pip python3-setuptools python3-wheel

If your Linux distro came with Python already installed, you should be able to install PIP using your system’s package manager. This is preferable since system-installed versions of Python do not play nicely with the get-pip.py script used on Windows and Mac.

Advanced Package Tool (Python 2.x)

sudo apt-get install python-pip

Advanced Package Tool (Python 3.x)

sudo apt-get install python3-pip

pacman Package Manager (Python 2.x)

sudo pacman -S python2-pip

pacman Package Manager (Python 3.x)

sudo pacman -S python-pip

Yum Package Manager (Python 2.x)

sudo yum upgrade python-setuptools
sudo yum install python-pip python-wheel

Yum Package Manager (Python 3.x)

sudo yum install python3 python3-wheel

Dandified Yum (Python 2.x)

sudo dnf upgrade python-setuptools
sudo dnf install python-pip python-wheel

Dandified Yum (Python 3.x)

sudo dnf install python3 python3-wheel

Zypper Package Manager (Python 2.x)

sudo zypper install python-pip python-setuptools python-wheel

Zypper Package Manager (Python 3.x)

sudo zypper install python3-pip python3-setuptools python3-wheel

回答 19

请按照以下步骤使用pip安装python 3：

步骤1：从此处下载安装Python

步骤2：您需要下载 get-pip.py

步骤3：下载get-pip.py之后，打开命令提示符，然后转到保存get-pip.py文件的目录。

步骤4：输入命令 python get-pip.py在cmd中。

步骤5：Pip安装成功，通过cmd中的type命令验证pip安装 pip --version

Please follow below steps to install python 3 with pip:

Step 1 : Install Python from download here

Step 2 : you’ll need to download get-pip.py

Step 3 : After download get-pip.py , open your commant prompt and go to directory where your get-pip.py file saved .

Step 4 : Enter command python get-pip.py in cmd.

Step 5 : Pip installed successfully , Verify pip installation by type command in cmd pip --version

回答 20

这是我复制粘贴的单线。

curl https://bootstrap.pypa.io/get-pip.py | python3

从使用get-pip.py安装：

要安装pip，请get-pip.py通过以下链接安全下载： get-pip.py。或者，使用curl：
curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
然后在下载了get-pip.py的文件夹中运行以下命令：
python get-pip.py
警告：如果您使用的是由操作系统或其他程序包管理器管理的Python安装，请务必谨慎。get-pip.py与这些工具不协调，可能会使您的系统处于不一致状态。

This is the one-liner I copy-and-paste.

curl https://bootstrap.pypa.io/get-pip.py | python3

From Installing with get-pip.py:

To install pip, securely download get-pip.py by following this link: get-pip.py. Alternatively, use curl:
curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
Then run the following command in the folder where you have downloaded get-pip.py:
python get-pip.py
Warning: Be cautious if you are using a Python install that is managed by your operating system or another package manager. get-pip.py does not coordinate with those tools, and may leave your system in an inconsistent state.

知识问答

在Python中，“ SyntaxError：调用’print’时缺少括号”是什么意思？

2021年7月25日 Python实用宝典

问题：在Python中，“ SyntaxError：调用’print’时缺少括号”是什么意思？

当我尝试print在Python中使用语句时，它给了我这个错误：

>>> print "Hello, World!"
  File "<stdin>", line 1
    print "Hello, World!"
                        ^
SyntaxError: Missing parentheses in call to 'print'

这意味着什么？

When I try to use a print statement in Python, it gives me this error:

>>> print "Hello, World!"
  File "<stdin>", line 1
    print "Hello, World!"
                        ^
SyntaxError: Missing parentheses in call to 'print'

What does that mean?

回答 0

此错误消息表示您尝试使用Python 3遵循示例或运行使用Python 2 print语句的程序：

~~print "Hello, World!"~~

上面的语句在Python 3中不起作用。在Python 3中，您需要在要打印的值周围添加括号：

print("Hello, World!")

“ SyntaxError：对’print’的调用中缺少括号”是Python 3.4.2中新增的一条错误消息，主要是为了帮助试图在运行Python 3时遵循Python 2教程的用户。

在Python 3中，打印值已从一个独特的语句变为一个普通的函数调用，因此现在需要括号：

>>> print("Hello, World!")
Hello, World!

在Python 3的早期版本中，解释器仅报告通用语法错误，而没有提供任何有用的提示来提示可能出了什么问题：

>>> print "Hello, World!"
  File "<stdin>", line 1
    print "Hello, World!"
                        ^
SyntaxError: invalid syntax

至于为什么 print在Python 3中成为普通函数，这与语句的基本形式无关，而是与如何执行更复杂的事情类似，例如将多个项目打印到带有尾部空格的stderr而不是结束行。

在Python 2中：

>>> import sys
>>> print >> sys.stderr, 1, 2, 3,; print >> sys.stderr, 4, 5, 6
1 2 3 4 5 6

在Python 3中：

>>> import sys
>>> print(1, 2, 3, file=sys.stderr, end=" "); print(4, 5, 6, file=sys.stderr)
1 2 3 4 5 6

从2017年9月的Python 3.6.3版本开始，一些与Python 2.x打印语法有关的错误消息已更新，以推荐与之对应的Python 3.x：

>>> print "Hello!"
  File "<stdin>", line 1
    print "Hello!"
                 ^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print("Hello!")?

由于“在打印输出中缺少括号”情况是编译时语法错误，因此可以访问原始源代码，因此可以在建议的替换内容中在行的其余部分包含全文。但是，它目前并未尝试找出适合该表达式的引号（这不是不可能的，只是足够复杂以至于尚未完成）。

该TypeError募投向右移位运算符也被定制：

>>> print >> sys.stderr
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for >>: 'builtin_function_or_method' and '_io.TextIOWrapper'. Did you mean "print(<message>, file=<output_stream>)"?

由于此错误是在代码运行时（而不是在编译时）引发的，因此它无法访问原始源代码，因此在建议的替换表达式中使用元变量（<message>和<output_stream>），而不是用户实际键入的内容。与语法错误的情况不同，在自定义右移错误消息中将引号放在Python表达式周围很简单。

This error message means that you are attempting to use Python 3 to follow an example or run a program that uses the Python 2 print statement:

print "Hello, World!"

The statement above does not work in Python 3. In Python 3 you need to add parentheses around the value to be printed:

print("Hello, World!")

“SyntaxError: Missing parentheses in call to ‘print’” is a new error message that was added in Python 3.4.2 primarily to help users that are trying to follow a Python 2 tutorial while running Python 3.

In Python 3, printing values changed from being a distinct statement to being an ordinary function call, so it now needs parentheses:

>>> print("Hello, World!")
Hello, World!

In earlier versions of Python 3, the interpreter just reports a generic syntax error, without providing any useful hints as to what might be going wrong:

>>> print "Hello, World!"
  File "<stdin>", line 1
    print "Hello, World!"
                        ^
SyntaxError: invalid syntax

As for why print became an ordinary function in Python 3, that didn’t relate to the basic form of the statement, but rather to how you did more complicated things like printing multiple items to stderr with a trailing space rather than ending the line.

In Python 2:

>>> import sys
>>> print >> sys.stderr, 1, 2, 3,; print >> sys.stderr, 4, 5, 6
1 2 3 4 5 6

In Python 3:

>>> import sys
>>> print(1, 2, 3, file=sys.stderr, end=" "); print(4, 5, 6, file=sys.stderr)
1 2 3 4 5 6

Starting with the Python 3.6.3 release in September 2017, some error messages related to the Python 2.x print syntax have been updated to recommend their Python 3.x counterparts:

>>> print "Hello!"
  File "<stdin>", line 1
    print "Hello!"
                 ^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print("Hello!")?

Since the “Missing parentheses in call to print” case is a compile time syntax error and hence has access to the raw source code, it’s able to include the full text on the rest of the line in the suggested replacement. However, it doesn’t currently try to work out the appropriate quotes to place around that expression (that’s not impossible, just sufficiently complicated that it hasn’t been done).

The TypeError raised for the right shift operator has also been customised:

>>> print >> sys.stderr
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for >>: 'builtin_function_or_method' and '_io.TextIOWrapper'. Did you mean "print(<message>, file=<output_stream>)"?

Since this error is raised when the code runs, rather than when it is compiled, it doesn’t have access to the raw source code, and hence uses meta-variables (<message> and <output_stream>) in the suggested replacement expression instead of whatever the user actually typed. Unlike the syntax error case, it’s straightforward to place quotes around the Python expression in the custom right shift error message.

回答 1

不幸的是，旧的xkcd漫画不再完全是最新的。

从Python 3.0开始，您必须编写：

print("Hello, World!")

而且仍然有人要编写该antigravity库:(

Unfortunately, the old xkcd comic isn’t completely up to date anymore.

Since Python 3.0 you have to write:

print("Hello, World!")

And someone has still to write that antigravity library :(

回答 2

语法从Python 2更改为Python3。在Python 2中，

print "Hello, World!"

可以使用，但是在Python 3中，使用括号作为

print("Hello, World!")

这与Scala等效，与Java差不多。

There is a change in syntax from Python 2 to Python 3. In Python 2,

print "Hello, World!"

will work but in Python 3, use parentheses as

print("Hello, World!")

This is equivalent syntax to Scala and near to Java.

回答 3

如果您的代码在Python 2和3中都可以使用，则可以通过在程序开始时加载以下代码来实现：

from __future__ import print_function   # If code has to work in Python 2 and 3!

然后，您可以使用Python 3方式进行打印：

print("python")

如果要打印某些内容而不创建新行，则可以执行以下操作：

for number in range(0, 10):
    print(number, end=', ')

If your code should work in both Python 2 and 3, you can achieve this by loading this at the beginning of your program:

from __future__ import print_function   # If code has to work in Python 2 and 3!

Then you can print in the Python 3 way:

print("python")

If you want to print something without creating a new line – you can do this:

for number in range(0, 10):
    print(number, end=', ')

回答 4

在Python 3中，您只能将其打印为：

print("STRING")

但是在Python 2中，不需要括号。

In Python 3, you can only print as:

print("STRING")

But in Python 2, the parentheses are not necessary.

回答 5

基本上，从Python 3.x开始，您需要使用 print括号。

Python 2.x：打印“指环王”

Python 3.x：print（“指环王”）

讲解

print在2.x中是一个语句，但在3.x中是一个函数。现在，有很多充分的理由。

使用Python 3.x的函数格式，当打印多个用逗号分隔的项目时，灵活性更高。
您不能在语句中使用参数展开。在3.x中，如果有要使用分隔符打印的项目列表，则可以执行以下操作：

>>> items = ['foo', 'bar', 'baz']
>>> print(*items, sep='+') 
foo+bar+baz

您不能覆盖语句。如果要更改print的行为，则可以在它是一个函数时执行此操作，但在声明时不可以。

Basically, since Python 3.x you need to use print with parenthesis.

Python 2.x: print “Lord of the Rings”

Python 3.x: print(“Lord of the Rings”)

Explaination

print was a statement in 2.x, but it’s a function in 3.x. Now, there are a number of good reasons for this.

With function format of Python 3.x, more flexibility comes when printing multiple items with comman separated.
You can’t use argument splatting with a statement. In 3.x if you have a list of items that you want to print with a separator, you can do this:

>>> items = ['foo', 'bar', 'baz']
>>> print(*items, sep='+') 
foo+bar+baz

You can’t override a statement. If you want to change the behavior of print, you can do that when it’s a function but not when it’s a statement.

回答 6

我还可以补充一点，我知道Python2.7和之间有关语法更改的所有知识Python3，并且我的代码正确编写为as print("string")甚至 print(f"string")…

但是经过一段时间的调试后，我意识到我的bash脚本正在像这样调用python：

python file_name.py

这具有默认情况下使用python调用我的python脚本的作用，从而产生python2.7了错误。因此，我将bash脚本更改为：

python3 file_name.py

哪个使用python3来运行修复了错误的脚本。

I could also just add that I knew everything about the syntax change between Python2.7 and Python3, and my code was correctly written as print("string") and even print(f"string")…

But after some time of debugging I realized that my bash script was calling python like:

python file_name.py

which had the effect of calling my python script by default using python2.7 which gave the error. So I changed my bash script to:

python3 file_name.py

which of coarse uses python3 to run the script which fixed the error.

回答 7

除了这里的直接答案外，还应注意python 2和3之间的另一个主要区别。官方python Wiki涵盖了几乎所有主要区别，并着重于何时应使用这两个版本。这篇博客文章也很好地解释了当前的python宇宙以及迁移到python 3时仍未解决的难题。

据我所知，您正在开始学习python语言。在继续进行python 3路由之前，您应该考虑上述文章。您不仅需要更改某些语法，还需要考虑哪些包对您可用（python 2的优点）以及可以在代码中进行的潜在优化（python 3的优点）。

Outside of the direct answers here, one should note the other key difference between python 2 and 3. The official python wiki goes into almost all of the major differences and focuses on when you should use either of the versions. This blog post also does a fine job of explaining the current python universe and the somehow unsolved puzzle of moving to python 3.

As far as I can tell, you are beginning to learn the python language. You should consider the aforementioned articles before you continue down the python 3 route. Not only will you have to change some of your syntax, you will also need to think about which packages will be available to you (an advantage of python 2) and potential optimizations that could be made in your code (an advantage of python 3).

知识问答

获取map（）以在Python 3.x中返回列表

2021年7月25日 Python实用宝典

问题：获取map（）以在Python 3.x中返回列表

我正在尝试将列表映射为十六进制，然后在其他地方使用该列表。在python 2.6中，这很简单：

答： Python 2.6：

>>> map(chr, [66, 53, 0, 94])
['B', '5', '\x00', '^']

但是，在Python 3.1中，以上代码返回一个map对象。

B： Python 3.1：

>>> map(chr, [66, 53, 0, 94])
<map object at 0x00AF5570>

如何在Python 3.x上检索映射列表（如上面的A所示）？

另外，还有更好的方法吗？我的初始列表对象大约有45个项目，并且id喜欢将它们转换为十六进制。

I’m trying to map a list into hex, and then use the list elsewhere. In python 2.6, this was easy:

A: Python 2.6:

>>> map(chr, [66, 53, 0, 94])
['B', '5', '\x00', '^']

However, in Python 3.1, the above returns a map object.

B: Python 3.1:

>>> map(chr, [66, 53, 0, 94])
<map object at 0x00AF5570>

How do I retrieve the mapped list (as in A above) on Python 3.x?

Alternatively, is there a better way of doing this? My initial list object has around 45 items and id like to convert them to hex.

回答 0

做这个：

list(map(chr,[66,53,0,94]))

在Python 3+中，许多迭代可迭代对象的进程本身都会返回迭代器。在大多数情况下，这最终会节省内存，并且应该使处理速度更快。

如果您要做的只是最终遍历此列表，则无需将其转换为列表，因为您仍然可以map像这样遍历该对象：

# Prints "ABCD"
for ch in map(chr,[65,66,67,68]):
    print(ch)

Do this:

list(map(chr,[66,53,0,94]))

In Python 3+, many processes that iterate over iterables return iterators themselves. In most cases, this ends up saving memory, and should make things go faster.

If all you’re going to do is iterate over this list eventually, there’s no need to even convert it to a list, because you can still iterate over the map object like so:

# Prints "ABCD"
for ch in map(chr,[65,66,67,68]):
    print(ch)

回答 1

Python 3.5的新功能：

[*map(chr, [66, 53, 0, 94])]

多亏了其他拆包概述

更新

一直在寻找更短的途径，我发现这也行得通：

*map(chr, [66, 53, 0, 94]),

开箱也适用于元组。注意最后的逗号。这使其成为1个元素的元组。也就是说，它相当于(*map(chr, [66, 53, 0, 94]),)

它比带有方括号的版本短一个字符，但我认为最好写，因为您从星号-扩展语法开始，所以我觉得它比较软。:)

New and neat in Python 3.5:

[*map(chr, [66, 53, 0, 94])]

Thanks to Additional Unpacking Generalizations

UPDATE

Always seeking for shorter ways, I discovered this one also works:

*map(chr, [66, 53, 0, 94]),

Unpacking works in tuples too. Note the comma at the end. This makes it a tuple of 1 element. That is, it’s equivalent to (*map(chr, [66, 53, 0, 94]),)

It’s shorter by only one char from the version with the list-brackets, but, in my opinion, better to write, because you start right ahead with the asterisk – the expansion syntax, so I feel it’s softer on the mind. :)

回答 2

您为什么不这样做：

[chr(x) for x in [66,53,0,94]]

这称为列表理解。您可以在Google上找到很多信息，但是这里是list comprehensions上的Python（2.6）文档的链接。不过，您可能对Python 3文档更感兴趣。

Why aren’t you doing this:

[chr(x) for x in [66,53,0,94]]

It’s called a list comprehension. You can find plenty of information on Google, but here’s the link to the Python (2.6) documentation on list comprehensions. You might be more interested in the Python 3 documenation, though.

回答 3

返回列表的地图功能具有保存键入的优点，尤其是在交互式会话期间。您可以定义返回列表的lmap函数（类似于python2的函数imap）：

lmap = lambda func, *iterable: list(map(func, *iterable))

然后打电话 lmap而不是即可map完成工作：比 lmap(str, x)短5个字符（在这种情况下为30％），list(map(str, x))并且肯定比短[str(v) for v in x]。您也可以创建类似的功能filter。

对原始问题有一条评论：

我建议重命名为Geting map（）以返回Python 3. *中的列表，因为它适用于所有Python3版本。有没有办法做到这一点？– meawoppl 1月24日17:58

这是有可能做到这一点，但它是一个非常糟糕的主意。只是为了好玩，您可以（但不应）执行以下操作：

__global_map = map #keep reference to the original map
lmap = lambda func, *iterable: list(__global_map(func, *iterable)) # using "map" here will cause infinite recursion
map = lmap
x = [1, 2, 3]
map(str, x) #test
map = __global_map #restore the original map and don't do that again
map(str, x) #iterator

List-returning map function has the advantage of saving typing, especially during interactive sessions. You can define lmap function (on the analogy of python2’s imap) that returns list:

lmap = lambda func, *iterable: list(map(func, *iterable))

Then calling lmap instead of map will do the job: lmap(str, x) is shorter by 5 characters (30% in this case) than list(map(str, x)) and is certainly shorter than [str(v) for v in x]. You may create similar functions for filter too.

There was a comment to the original question:

I would suggest a rename to Getting map() to return a list in Python 3.* as it applies to all Python3 versions. Is there a way to do this? – meawoppl Jan 24 at 17:58

It is possible to do that, but it is a very bad idea. Just for fun, here’s how you may (but should not) do it:

__global_map = map #keep reference to the original map
lmap = lambda func, *iterable: list(__global_map(func, *iterable)) # using "map" here will cause infinite recursion
map = lmap
x = [1, 2, 3]
map(str, x) #test
map = __global_map #restore the original map and don't do that again
map(str, x) #iterator

回答 4

将我的旧注释转换为更好的可见性：为了更好地“更好地做到这一点” map，如果您的输入已知为ASCII序数，则通常可以更快地转换为bytesla bytes(list_of_ordinals).decode('ascii')。这样就可以得到一个str值，但是如果您需要a list来实现可变性或类似功能，则可以将其转换（并且转换速度仍然更快）。例如，在微ipython基准中转换45个输入：

>>> %%timeit -r5 ordinals = list(range(45))
... list(map(chr, ordinals))
...
3.91 µs ± 60.2 ns per loop (mean ± std. dev. of 5 runs, 100000 loops each)

>>> %%timeit -r5 ordinals = list(range(45))
... [*map(chr, ordinals)]
...
3.84 µs ± 219 ns per loop (mean ± std. dev. of 5 runs, 100000 loops each)

>>> %%timeit -r5 ordinals = list(range(45))
... [*bytes(ordinals).decode('ascii')]
...
1.43 µs ± 49.7 ns per loop (mean ± std. dev. of 5 runs, 1000000 loops each)

>>> %%timeit -r5 ordinals = list(range(45))
... bytes(ordinals).decode('ascii')
...
781 ns ± 15.9 ns per loop (mean ± std. dev. of 5 runs, 1000000 loops each)

如果您将其保留为str，则最快的map解决方案会花费大约20％的时间；即使转换回列表，它仍然不到最快map解决方案的40％。批量转换通过bytes，bytes.decode然后批量转换回以list节省大量工作，但是如上所述，仅当您所有的输入都是ASCII序号（或每个字符特定于区域设置编码的字节中的序号latin-1）时，该方法才有效。

Converting my old comment for better visibility: For a “better way to do this” without map entirely, if your inputs are known to be ASCII ordinals, it’s generally much faster to convert to bytes and decode, a la bytes(list_of_ordinals).decode('ascii'). That gets you a str of the values, but if you need a list for mutability or the like, you can just convert it (and it’s still faster). For example, in ipython microbenchmarks converting 45 inputs:

>>> %%timeit -r5 ordinals = list(range(45))
... list(map(chr, ordinals))
...
3.91 µs ± 60.2 ns per loop (mean ± std. dev. of 5 runs, 100000 loops each)

>>> %%timeit -r5 ordinals = list(range(45))
... [*map(chr, ordinals)]
...
3.84 µs ± 219 ns per loop (mean ± std. dev. of 5 runs, 100000 loops each)

>>> %%timeit -r5 ordinals = list(range(45))
... [*bytes(ordinals).decode('ascii')]
...
1.43 µs ± 49.7 ns per loop (mean ± std. dev. of 5 runs, 1000000 loops each)

>>> %%timeit -r5 ordinals = list(range(45))
... bytes(ordinals).decode('ascii')
...
781 ns ± 15.9 ns per loop (mean ± std. dev. of 5 runs, 1000000 loops each)

If you leave it as a str, it takes ~20% of the time of the fastest map solutions; even converting back to list it’s still less than 40% of the fastest map solution. Bulk convert via bytes and bytes.decode then bulk converting back to list saves a lot of work, but as noted, only works if all your inputs are ASCII ordinals (or ordinals in some one byte per character locale specific encoding, e.g. latin-1).

回答 5

list(map(chr, [66, 53, 0, 94]))

map（func，* iterables）->地图对象创建一个迭代器，该迭代器使用每个可迭代对象的参数来计算函数。当最短的迭代次数用尽时停止。

“进行迭代”

表示它将返回迭代器。

“使用每个可迭代对象的参数来计算函数”

意味着迭代器的next（）函数将为每个可迭代对象取一个值，并将每个值传递给该函数的一个位置参数。

因此，您可以从map（）函数中获得一个迭代器，然后jsut将其传递给内置函数list（）或使用列表推导。

list(map(chr, [66, 53, 0, 94]))

map(func, *iterables) –> map object Make an iterator that computes the function using arguments from each of the iterables. Stops when the shortest iterable is exhausted.

“Make an iterator”

means it will return an iterator.

“that computes the function using arguments from each of the iterables”

means that the next() function of the iterator will take one value of each iterables and pass each of them to one positional parameter of the function.

So you get an iterator from the map() funtion and jsut pass it to the list() builtin function or use list comprehensions.

回答 6

除了上述答案外Python 3，我们还可以简单地list从mapas中创建结果值a

li = []
for x in map(chr,[66,53,0,94]):
    li.append(x)

print (li)
>>>['B', '5', '\x00', '^']

我们可以通过另一个例子来概括我被打动的情况，对地图的操作也可以像regex问题中一样的方式处理，我们可以编写函数以获取list要映射的项目并同时获取结果集。例如

b = 'Strings: 1,072, Another String: 474 '
li = []
for x in map(int,map(int, re.findall('\d+', b))):
    li.append(x)

print (li)
>>>[1, 72, 474]

In addition to above answers in Python 3, we may simply create a list of result values from a map as

li = []
for x in map(chr,[66,53,0,94]):
    li.append(x)

print (li)
>>>['B', '5', '\x00', '^']

We may generalize by another example where I was struck, operations on map can also be handled in similar fashion like in regex problem, we can write function to obtain list of items to map and get result set at the same time. Ex.

b = 'Strings: 1,072, Another String: 474 '
li = []
for x in map(int,map(int, re.findall('\d+', b))):
    li.append(x)

print (li)
>>>[1, 72, 474]

回答 7

您可以尝试通过仅迭代对象中的每个项目并将其存储在另一个变量中来从地图对象获取列表。

a = map(chr, [66, 53, 0, 94])
b = [item for item in a]
print(b)
>>>['B', '5', '\x00', '^']

You can try getting a list from the map object by just iterating each item in the object and store it in a different variable.

a = map(chr, [66, 53, 0, 94])
b = [item for item in a]
print(b)
>>>['B', '5', '\x00', '^']

回答 8

使用python中的列表理解和基本的地图函数实用程序，还可以做到这一点：

chi = [x for x in map(chr,[66,53,0,94])]

Using list comprehension in python and basic map function utility, one can do this also:

chi = [x for x in map(chr,[66,53,0,94])]

知识问答

移除Python unicode字符串中的重音符号的最佳方法是什么？

2021年7月25日 Python实用宝典

问题：移除Python unicode字符串中的重音符号的最佳方法是什么？

我在Python中有一个Unicode字符串，我想删除所有的重音符号（变音符号）。

我在网上发现了一种用Java实现此目的的优雅方法：

将Unicode字符串转换为长规范化格式（带有单独的字母和变音符号）
删除Unicode类型为“变音符号”的所有字符。

我是否需要安装pyICU之类的库，还是仅使用python标准库就可以？那python 3呢？

重要说明：我想避免使用带有重音符号到非重音符号的显式映射的代码。

I have a Unicode string in Python, and I would like to remove all the accents (diacritics).

I found on the Web an elegant way to do this in Java:

convert the Unicode string to its long normalized form (with a separate character for letters and diacritics)
remove all the characters whose Unicode type is “diacritic”.

Do I need to install a library such as pyICU or is this possible with just the python standard library? And what about python 3?

Important note: I would like to avoid code with an explicit mapping from accented characters to their non-accented counterpart.

回答 0

Unidecode是正确的答案。它将所有unicode字符串音译为ASCII文本中最接近的可能表示形式。

例：

accented_string = u'Málaga'
# accented_string is of type 'unicode'
import unidecode
unaccented_string = unidecode.unidecode(accented_string)
# unaccented_string contains 'Malaga'and is of type 'str'

Unidecode is the correct answer for this. It transliterates any unicode string into the closest possible representation in ascii text.

Example:

accented_string = u'Málaga'
# accented_string is of type 'unicode'
import unidecode
unaccented_string = unidecode.unidecode(accented_string)
# unaccented_string contains 'Malaga'and is of type 'str'

回答 1

这个怎么样：

import unicodedata
def strip_accents(s):
   return ''.join(c for c in unicodedata.normalize('NFD', s)
                  if unicodedata.category(c) != 'Mn')

这也适用于希腊字母：

>>> strip_accents(u"A \u00c0 \u0394 \u038E")
u'A A \u0394 \u03a5'
>>>

该字符类别 “锰”表示Nonspacing_Mark，这是类似于MiniQuark的答案unicodedata.combining（我没想到unicodedata.combining的，但它可能是更好的解决方案，因为它更明确）。

请记住，这些操作可能会大大改变文本的含义。口音，Umlauts等不是“装饰”。

How about this:

import unicodedata
def strip_accents(s):
   return ''.join(c for c in unicodedata.normalize('NFD', s)
                  if unicodedata.category(c) != 'Mn')

This works on greek letters, too:

>>> strip_accents(u"A \u00c0 \u0394 \u038E")
u'A A \u0394 \u03a5'
>>>

The character category “Mn” stands for Nonspacing_Mark, which is similar to unicodedata.combining in MiniQuark’s answer (I didn’t think of unicodedata.combining, but it is probably the better solution, because it’s more explicit).

And keep in mind, these manipulations may significantly alter the meaning of the text. Accents, Umlauts etc. are not “decoration”.

回答 2

我刚刚在网上找到了这个答案：

import unicodedata

def remove_accents(input_str):
    nfkd_form = unicodedata.normalize('NFKD', input_str)
    only_ascii = nfkd_form.encode('ASCII', 'ignore')
    return only_ascii

它可以正常工作（例如，对于法语），但是我认为第二步（删除重音符号）比丢弃非ASCII字符要好，因为这对于某些语言（例如希腊文）会失败。最好的解决方案可能是显式删除标记为变音符号的unicode字符。

编辑：这可以解决问题：

import unicodedata

def remove_accents(input_str):
    nfkd_form = unicodedata.normalize('NFKD', input_str)
    return u"".join([c for c in nfkd_form if not unicodedata.combining(c)])

unicodedata.combining(c)如果该字符c可以与前面的字符组合，则返回true ，这主要是如果它是一个变音符。

编辑2：remove_accents需要一个unicode字符串，而不是字节字符串。如果您有字节字符串，则必须将其解码为一个unicode字符串，如下所示：

encoding = "utf-8" # or iso-8859-15, or cp1252, or whatever encoding you use
byte_string = b"café"  # or simply "café" before python 3.
unicode_string = byte_string.decode(encoding)

I just found this answer on the Web:

import unicodedata

def remove_accents(input_str):
    nfkd_form = unicodedata.normalize('NFKD', input_str)
    only_ascii = nfkd_form.encode('ASCII', 'ignore')
    return only_ascii

It works fine (for French, for example), but I think the second step (removing the accents) could be handled better than dropping the non-ASCII characters, because this will fail for some languages (Greek, for example). The best solution would probably be to explicitly remove the unicode characters that are tagged as being diacritics.

Edit: this does the trick:

import unicodedata

def remove_accents(input_str):
    nfkd_form = unicodedata.normalize('NFKD', input_str)
    return u"".join([c for c in nfkd_form if not unicodedata.combining(c)])

unicodedata.combining(c) will return true if the character c can be combined with the preceding character, that is mainly if it’s a diacritic.

Edit 2: remove_accents expects a unicode string, not a byte string. If you have a byte string, then you must decode it into a unicode string like this:

encoding = "utf-8" # or iso-8859-15, or cp1252, or whatever encoding you use
byte_string = b"café"  # or simply "café" before python 3.
unicode_string = byte_string.decode(encoding)

回答 3

实际上，我正在开发与项目兼容的python 2.6、2.7和3.4，并且必须从免费用户条目中创建ID。

多亏了您，我创建了一个可以实现奇迹的功能。

import re
import unicodedata

def strip_accents(text):
    """
    Strip accents from input String.

    :param text: The input string.
    :type text: String.

    :returns: The processed String.
    :rtype: String.
    """
    try:
        text = unicode(text, 'utf-8')
    except (TypeError, NameError): # unicode is a default on python 3 
        pass
    text = unicodedata.normalize('NFD', text)
    text = text.encode('ascii', 'ignore')
    text = text.decode("utf-8")
    return str(text)

def text_to_id(text):
    """
    Convert input text to id.

    :param text: The input string.
    :type text: String.

    :returns: The processed String.
    :rtype: String.
    """
    text = strip_accents(text.lower())
    text = re.sub('[ ]+', '_', text)
    text = re.sub('[^0-9a-zA-Z_-]', '', text)
    return text

结果：

text_to_id("Montréal, über, 12.89, Mère, Françoise, noël, 889")
>>> 'montreal_uber_1289_mere_francoise_noel_889'

Actually I work on project compatible python 2.6, 2.7 and 3.4 and I have to create IDs from free user entries.

Thanks to you, I have created this function that works wonders.

import re
import unicodedata

def strip_accents(text):
    """
    Strip accents from input String.

    :param text: The input string.
    :type text: String.

    :returns: The processed String.
    :rtype: String.
    """
    try:
        text = unicode(text, 'utf-8')
    except (TypeError, NameError): # unicode is a default on python 3 
        pass
    text = unicodedata.normalize('NFD', text)
    text = text.encode('ascii', 'ignore')
    text = text.decode("utf-8")
    return str(text)

def text_to_id(text):
    """
    Convert input text to id.

    :param text: The input string.
    :type text: String.

    :returns: The processed String.
    :rtype: String.
    """
    text = strip_accents(text.lower())
    text = re.sub('[ ]+', '_', text)
    text = re.sub('[^0-9a-zA-Z_-]', '', text)
    return text

result:

text_to_id("Montréal, über, 12.89, Mère, Françoise, noël, 889")
>>> 'montreal_uber_1289_mere_francoise_noel_889'

回答 4

这不仅处理重音，而且还处理“笔画”（如ø等）：

import unicodedata as ud

def rmdiacritics(char):
    '''
    Return the base character of char, by "removing" any
    diacritics like accents or curls and strokes and the like.
    '''
    desc = ud.name(char)
    cutoff = desc.find(' WITH ')
    if cutoff != -1:
        desc = desc[:cutoff]
        try:
            char = ud.lookup(desc)
        except KeyError:
            pass  # removing "WITH ..." produced an invalid name
    return char

这是我能想到的最优雅的方式（alexis在此页的评论中已经提到），尽管我认为这确实不是很优雅。实际上，正如注释中所指出的那样，这更像是一种黑客，因为Unicode名称是–实际上只是名称，它们不能保证其一致性或任何形式。

由于它们的Unicode名称中不包含“ WITH”，因此仍有一些特殊的字母无法对此进行处理，例如转弯和倒转字母。无论如何，这取决于您想做什么。有时我需要重音符号来实现字典的排序顺序。

编辑说明：

合并了注释中的建议（处理查找错误，Python-3代码）。

This handles not only accents, but also “strokes” (as in ø etc.):

import unicodedata as ud

def rmdiacritics(char):
    '''
    Return the base character of char, by "removing" any
    diacritics like accents or curls and strokes and the like.
    '''
    desc = ud.name(char)
    cutoff = desc.find(' WITH ')
    if cutoff != -1:
        desc = desc[:cutoff]
        try:
            char = ud.lookup(desc)
        except KeyError:
            pass  # removing "WITH ..." produced an invalid name
    return char

This is the most elegant way I can think of (and it has been mentioned by alexis in a comment on this page), although I don’t think it is very elegant indeed. In fact, it’s more of a hack, as pointed out in comments, since Unicode names are – really just names, they give no guarantee to be consistent or anything.

There are still special letters that are not handled by this, such as turned and inverted letters, since their unicode name does not contain ‘WITH’. It depends on what you want to do anyway. I sometimes needed accent stripping for achieving dictionary sort order.

EDIT NOTE:

Incorporated suggestions from the comments (handling lookup errors, Python-3 code).

回答 5

回应@MiniQuark的回答：

我试图读取一个半法语的csv文件（包含重音符号）以及一些最终会变成整数和浮点数的字符串。作为测试，我创建了一个如下所示的test.txt文件：

蒙特利尔，于伯，12.89，梅尔，弗朗索瓦，诺尔，889

我必须包括行2并3使其起作用（在python票证中找到），并包含@Jabba的注释：

import sys 
reload(sys) 
sys.setdefaultencoding("utf-8")
import csv
import unicodedata

def remove_accents(input_str):
    nkfd_form = unicodedata.normalize('NFKD', unicode(input_str))
    return u"".join([c for c in nkfd_form if not unicodedata.combining(c)])

with open('test.txt') as f:
    read = csv.reader(f)
    for row in read:
        for element in row:
            print remove_accents(element)

结果：

Montreal
uber
12.89
Mere
Francoise
noel
889

（注意：我在Mac OS X 10.8.4上并使用Python 2.7.3）

In response to @MiniQuark’s answer:

I was trying to read in a csv file that was half-French (containing accents) and also some strings which would eventually become integers and floats. As a test, I created a test.txt file that looked like this:

Montréal, über, 12.89, Mère, Françoise, noël, 889

I had to include lines 2 and 3 to get it to work (which I found in a python ticket), as well as incorporate @Jabba’s comment:

import sys 
reload(sys) 
sys.setdefaultencoding("utf-8")
import csv
import unicodedata

def remove_accents(input_str):
    nkfd_form = unicodedata.normalize('NFKD', unicode(input_str))
    return u"".join([c for c in nkfd_form if not unicodedata.combining(c)])

with open('test.txt') as f:
    read = csv.reader(f)
    for row in read:
        for element in row:
            print remove_accents(element)

The result:

Montreal
uber
12.89
Mere
Francoise
noel
889

(Note: I am on Mac OS X 10.8.4 and using Python 2.7.3)

回答 6

gensim.utils.deaccent（文本）从Gensim -人类主题建模：

'Sef chomutovskych komunistu dostal postou bily prasek'

另一个解决方案是unidecode。

需要注意的是，用建议的解决方案unicodedata通常只在某些字符去掉口音（例如，它变成'ł'成''，而不是进入'l'）。

gensim.utils.deaccent(text) from Gensim – topic modelling for humans:

'Sef chomutovskych komunistu dostal postou bily prasek'

Another solution is unidecode.

Note that the suggested solution with unicodedata typically removes accents only in some character (e.g. it turns 'ł' into '', rather than into 'l').

回答 7

一些语言结合了变音符号作为语言字母和重音符号来指定重音。

我认为更明确地指定要去除的折光度数更安全：

def strip_accents(string, accents=('COMBINING ACUTE ACCENT', 'COMBINING GRAVE ACCENT', 'COMBINING TILDE')):
    accents = set(map(unicodedata.lookup, accents))
    chars = [c for c in unicodedata.normalize('NFD', string) if c not in accents]
    return unicodedata.normalize('NFC', ''.join(chars))

Some languages have combining diacritics as language letters and accent diacritics to specify accent.

I think it is more safe to specify explicitly what diactrics you want to strip:

def strip_accents(string, accents=('COMBINING ACUTE ACCENT', 'COMBINING GRAVE ACCENT', 'COMBINING TILDE')):
    accents = set(map(unicodedata.lookup, accents))
    chars = [c for c in unicodedata.normalize('NFD', string) if c not in accents]
    return unicodedata.normalize('NFC', ''.join(chars))

知识问答

为什么“ [False，True]中的not（True）”返回False？

2021年7月25日 Python实用宝典

问题：为什么“ [False，True]中的not（True）”返回False？

如果我这样做：

>>> False in [False, True]
True

那又回来了True。仅仅是因为False在列表中。

但是如果我这样做：

>>> not(True) in [False, True]
False

那又回来了False。而not(True)等于False：

>>> not(True)
False

为什么？

If I do this:

>>> False in [False, True]
True

That returns True. Simply because False is in the list.

But if I do:

>>> not(True) in [False, True]
False

That returns False. Whereas not(True) is equal to False:

>>> not(True)
False

Why?

回答 0

运算符优先级 ^2.x，3.x。的优先级not低于的优先级in。因此，它等效于：

>>> not ((True) in [False, True])
False

这就是你想要的：

>>> (not True) in [False, True]
True

正如@Ben指出的：建议从不写not(True)，而不是not True。前者使它看起来像一个函数调用，而它却not是一个运算符，而不是一个函数。

Operator precedence ^{2.x, 3.x}. The precedence of not is lower than that of in. So it is equivalent to:

>>> not ((True) in [False, True])
False

This is what you want:

>>> (not True) in [False, True]
True

As @Ben points out: It’s recommended to never write not(True), prefer not True. The former makes it look like a function call, while not is an operator, not a function.

回答 1

not x in y 被评估为 x not in y

您可以通过反汇编代码来确切了解正在发生的事情。第一种情况按您的预期工作：

>>> x = lambda: False in [False, True]
>>> dis.dis(x)
  1           0 LOAD_GLOBAL              0 (False)
              3 LOAD_GLOBAL              0 (False)
              6 LOAD_GLOBAL              1 (True)
              9 BUILD_LIST               2
             12 COMPARE_OP               6 (in)
             15 RETURN_VALUE

第二种情况计算为True not in [False, True]，False显然是：

>>> x = lambda: not(True) in [False, True]
>>> dis.dis(x)
  1           0 LOAD_GLOBAL              0 (True)
              3 LOAD_GLOBAL              1 (False)
              6 LOAD_GLOBAL              0 (True)
              9 BUILD_LIST               2
             12 COMPARE_OP               7 (not in)
             15 RETURN_VALUE        
>>>

您想要表达的是(not(True)) in [False, True]，正如True您所期望的那样，您可以看到原因：

>>> x = lambda: (not(True)) in [False, True]
>>> dis.dis(x)
  1           0 LOAD_GLOBAL              0 (True)
              3 UNARY_NOT           
              4 LOAD_GLOBAL              1 (False)
              7 LOAD_GLOBAL              0 (True)
             10 BUILD_LIST               2
             13 COMPARE_OP               6 (in)
             16 RETURN_VALUE

not x in y is evaluated as x not in y

You can see exactly what’s happening by disassembling the code. The first case works as you expect:

>>> x = lambda: False in [False, True]
>>> dis.dis(x)
  1           0 LOAD_GLOBAL              0 (False)
              3 LOAD_GLOBAL              0 (False)
              6 LOAD_GLOBAL              1 (True)
              9 BUILD_LIST               2
             12 COMPARE_OP               6 (in)
             15 RETURN_VALUE

The second case, evaluates to True not in [False, True], which is False clearly:

>>> x = lambda: not(True) in [False, True]
>>> dis.dis(x)
  1           0 LOAD_GLOBAL              0 (True)
              3 LOAD_GLOBAL              1 (False)
              6 LOAD_GLOBAL              0 (True)
              9 BUILD_LIST               2
             12 COMPARE_OP               7 (not in)
             15 RETURN_VALUE        
>>>

What you wanted to express instead was (not(True)) in [False, True], which as expected is True, and you can see why:

>>> x = lambda: (not(True)) in [False, True]
>>> dis.dis(x)
  1           0 LOAD_GLOBAL              0 (True)
              3 UNARY_NOT           
              4 LOAD_GLOBAL              1 (False)
              7 LOAD_GLOBAL              0 (True)
             10 BUILD_LIST               2
             13 COMPARE_OP               6 (in)
             16 RETURN_VALUE

回答 2

运算符优先级。in绑定比紧密not，因此您的表达式等效于not((True) in [False, True])。

Operator precedence. in binds more tightly than not, so your expression is equivalent to not((True) in [False, True]).

回答 3

一切都与运算符优先级有关（in比强大not）。但是可以通过在适当的位置添加括号来轻松地纠正它：

(not(True)) in [False, True]  # prints true

写作：

not(True) in [False, True]

就像这样：

not((True) in [False, True])

它看起来是否True在列表中，并返回结果的“ not”。

It’s all about operator precedence (in is stronger than not). But it can be easily corrected by adding parentheses at the right place:

(not(True)) in [False, True]  # prints true

writing:

not(True) in [False, True]

is the same like:

not((True) in [False, True])

which looks if True is in the list and returns the “not” of the result.

回答 4

它的计算结果为not True in [False, True]，False由于True位于中而返回[False, True]

如果你试试

>>>(not(True)) in [False, True]
True

您会得到预期的结果。

It is evaluating as not True in [False, True], which returns False because True is in [False, True]

If you try

>>>(not(True)) in [False, True]
True

You get the expected result.

回答 5

除了提到优先级not低于的其他答案in，实际上您的陈述还等同于：

not (True in [False, True])

但请注意，如果您不将条件与其他条件分开，则python将使用2个角色（precedence或chaining）将其分开，在这种情况下，python使用优先级。另外，请注意，如果要分隔条件，则需要将所有条件放在括号中，而不仅是对象或值：

(not True) in [False, True]

但是如前所述，python对运算符进行了另一种修改，即链接：

基于python 文档：

请注意，比较，成员资格测试和身份测试均具有相同的优先级，并且具有“比较”部分中所述的从左到右的链接功能。

例如，以下语句的结果是False：

>>> True == False in [False, True]
False

因为python将像下面这样链接语句：

(True == False) and (False in [False, True])

确切的False and True是False。

您可以假定中心对象将在2个操作和其他对象之间共享（在这种情况下为False）。

并注意，对于所有比较，包括隶属度测试和身份测试操作（其后为操作数），它也适用：

in, not in, is, is not, <, <=, >, >=, !=, ==

范例：

>>> 1 in [1,2] == True
False

另一个著名的例子是数字范围：

7<x<20

等于：

7<x and x<20

Alongside the other answers that mentioned the precedence of not is lower than in, actually your statement is equivalent to :

not (True in [False, True])

But note that if you don’t separate your condition from the other ones, python will use 2 roles (precedence or chaining) in order to separate that, and in this case python used precedence. Also, note that if you want to separate a condition you need to put all the condition in parenthesis not just the object or value :

(not True) in [False, True]

But as mentioned, there is another modification by python on operators that is chaining:

Based on python documentation :

Note that comparisons, membership tests, and identity tests, all have the same precedence and have a left-to-right chaining feature as described in the Comparisons section.

For example the result of following statement is False:

>>> True == False in [False, True]
False

Because python will chain the statements like following :

(True == False) and (False in [False, True])

Which exactly is False and True that is False.

You can assume that the central object will be shared between 2 operations and other objects (False in this case).

And note that its also true for all Comparisons, including membership tests and identity tests operations which are following operands :

in, not in, is, is not, <, <=, >, >=, !=, ==

Example :

>>> 1 in [1,2] == True
False

Another famous example is number range :

7<x<20

which is equal to :

7<x and x<20

回答 6

让我们将其视为集合包含检查操作：[False, True]是包含一些元素的列表。

表达式True in [False, True]返回True，就像True列表中包含的元素一样。

因此，not True in [False, True]给出not上述表达式的“布尔相反” （没有任何括号可保留优先级，因为in优先级大于not运算符）。因此，not True将导致False。

在另一方面，(not True) in [False, True]是等于False in [False, True]，这是True（False被包含在列表中）。

Let’s see it as a collection containment checking operation: [False, True] is a list containing some elements.

The expression True in [False, True] returns True, as True is an element contained in the list.

Therefore, not True in [False, True] gives the “boolean opposite”, not result of the above expression (without any parentheses to preserve precedence, as in has greater precedence than not operator). Therefore, not True will result False.

On the other hand, (not True) in [False, True], is equal to False in [False, True], which is True (False is contained in the list).

回答 7

为了阐明其他一些答案，在一元运算符后添加括号不会更改其优先级。not(True)不会使not绑定更紧密True。这只是一个多余的括号True。与大致相同(True) in [True, False]。括号不做任何事情。如果要使绑定更紧密，则必须在整个表达式两边加上括号，这意味着运算符和操作数（即）(not True) in [True, False]。

要以另一种方式查看，请考虑

>>> -2**2
-4

**绑定比紧密-，这就是为什么要得到两个平方的负数，而不是两个负数的平方（也就是正四个）的原因。

如果您确实想要负二的平方怎么办？显然，您需要添加括号：

>>> (-2)**2
4

但是，期望以下内容不合理 4

>>> -(2)**2
-4

因为-(2)和一样-2。括号绝对不起作用。not(True)完全一样

To clarify on some of the other answers, adding parentheses after a unary operator does not change its precedence. not(True) does not make not bind more tightly to True. It’s just a redundant set of parentheses around True. It’s much the same as (True) in [True, False]. The parentheses don’t do anything. If you want the binding to be more tight, you have to put the parentheses around the whole expression, meaning both the operator and the operand, i.e., (not True) in [True, False].

To see this another way, consider

>>> -2**2
-4

** binds more tightly than -, which is why you get the negative of two squared, not the square of negative two (which would be positive four).

What if you did want the square of negative two? Obviously, you’d add parentheses:

>>> (-2)**2
4

However, it’s not reasonable to expect the following to give 4

>>> -(2)**2
-4

because -(2) is the same as -2. The parentheses do absolutely nothing. not(True) is exactly the same.

知识问答

->在Python函数定义中是什么意思？

2021年7月25日 Python实用宝典

问题：->在Python函数定义中是什么意思？

我最近在查看Python 3.3语法规范时发现了一些有趣的东西：

funcdef: 'def' NAME parameters ['->' test] ':' suite

Python 2中没有可选的“箭头”块，我在Python 3中找不到有关其含义的任何信息。事实证明这是正确的Python，并且已被解释器接受：

def f(x) -> 123:
    return x

我认为这可能是某种前提语法，但是：

我无法x在此处进行测试，因为它仍未定义，
无论我在箭头后面加什么（例如2 < 1），它都不会影响功能行为。

习惯此语法的任何人都可以解释吗？

I’ve recently noticed something interesting when looking at Python 3.3 grammar specification:

funcdef: 'def' NAME parameters ['->' test] ':' suite

The optional ‘arrow’ block was absent in Python 2 and I couldn’t find any information regarding its meaning in Python 3. It turns out this is correct Python and it’s accepted by the interpreter:

def f(x) -> 123:
    return x

I thought that this might be some kind of a precondition syntax, but:

I cannot test x here, at it is still undefined,
No matter what I put after the arrow (e.g. 2 < 1), it doesn’t affect the function behaviour.

Could anyone accustomed with this syntax explain it?

回答 0

这是一个功能注释。

更详细地讲，Python 2.x具有文档字符串，可用于将元数据字符串附加到各种类型的对象。这非常方便，因此Python 3通过允许您将元数据附加到描述其参数和返回值的函数来扩展了该功能。

没有预想的用例，但是PEP建议了几个。一种非常方便的方法是允许您使用期望的类型注释参数。这样就很容易编写一个装饰器来验证注释或将参数强制为正确的类型。另一个是允许特定于参数的文档，而不是将其编码为文档字符串。

It’s a function annotation.

In more detail, Python 2.x has docstrings, which allow you to attach a metadata string to various types of object. This is amazingly handy, so Python 3 extends the feature by allowing you to attach metadata to functions describing their parameters and return values.

There’s no preconceived use case, but the PEP suggests several. One very handy one is to allow you to annotate parameters with their expected types; it would then be easy to write a decorator that verifies the annotations or coerces the arguments to the right type. Another is to allow parameter-specific documentation instead of encoding it into the docstring.

回答 1

这些是PEP 3107中涵盖的功能注释。具体来说，->标记是返回函数注释。

例子：

>>> def kinetic_energy(m:'in KG', v:'in M/S')->'Joules': 
...    return 1/2*m*v**2
... 
>>> kinetic_energy.__annotations__
{'return': 'Joules', 'v': 'in M/S', 'm': 'in KG'}

注释是字典，因此您可以执行以下操作：

>>> '{:,} {}'.format(kinetic_energy(20,3000),
      kinetic_energy.__annotations__['return'])
'90,000,000.0 Joules'

您还可以拥有一个python数据结构，而不仅仅是一个字符串：

>>> rd={'type':float,'units':'Joules','docstring':'Given mass and velocity returns kinetic energy in Joules'}
>>> def f()->rd:
...    pass
>>> f.__annotations__['return']['type']
<class 'float'>
>>> f.__annotations__['return']['units']
'Joules'
>>> f.__annotations__['return']['docstring']
'Given mass and velocity returns kinetic energy in Joules'

或者，您可以使用函数属性来验证调用的值：

def validate(func, locals):
    for var, test in func.__annotations__.items():
        value = locals[var]
        try: 
            pr=test.__name__+': '+test.__docstring__
        except AttributeError:
            pr=test.__name__   
        msg = '{}=={}; Test: {}'.format(var, value, pr)
        assert test(value), msg

def between(lo, hi):
    def _between(x):
            return lo <= x <= hi
    _between.__docstring__='must be between {} and {}'.format(lo,hi)       
    return _between

def f(x: between(3,10), y:lambda _y: isinstance(_y,int)):
    validate(f, locals())
    print(x,y)

版画

>>> f(2,2) 
AssertionError: x==2; Test: _between: must be between 3 and 10
>>> f(3,2.1)
AssertionError: y==2.1; Test: <lambda>

These are function annotations covered in PEP 3107. Specifically, the -> marks the return function annotation.

Examples:

>>> def kinetic_energy(m:'in KG', v:'in M/S')->'Joules': 
...    return 1/2*m*v**2
... 
>>> kinetic_energy.__annotations__
{'return': 'Joules', 'v': 'in M/S', 'm': 'in KG'}

Annotations are dictionaries, so you can do this:

>>> '{:,} {}'.format(kinetic_energy(20,3000),
      kinetic_energy.__annotations__['return'])
'90,000,000.0 Joules'

You can also have a python data structure rather than just a string:

>>> rd={'type':float,'units':'Joules','docstring':'Given mass and velocity returns kinetic energy in Joules'}
>>> def f()->rd:
...    pass
>>> f.__annotations__['return']['type']
<class 'float'>
>>> f.__annotations__['return']['units']
'Joules'
>>> f.__annotations__['return']['docstring']
'Given mass and velocity returns kinetic energy in Joules'

Or, you can use function attributes to validate called values:

def validate(func, locals):
    for var, test in func.__annotations__.items():
        value = locals[var]
        try: 
            pr=test.__name__+': '+test.__docstring__
        except AttributeError:
            pr=test.__name__   
        msg = '{}=={}; Test: {}'.format(var, value, pr)
        assert test(value), msg

def between(lo, hi):
    def _between(x):
            return lo <= x <= hi
    _between.__docstring__='must be between {} and {}'.format(lo,hi)       
    return _between

def f(x: between(3,10), y:lambda _y: isinstance(_y,int)):
    validate(f, locals())
    print(x,y)

Prints

>>> f(2,2) 
AssertionError: x==2; Test: _between: must be between 3 and 10
>>> f(3,2.1)
AssertionError: y==2.1; Test: <lambda>

回答 2

如其他答案所述，该->符号用作功能注释的一部分。>= 3.5但是，在最新版本的Python中，它具有定义的含义。

PEP 3107-功能注释描述了规范，定义了语法更改，func.__annotations__它们存储在其中的存在以及用例的事实仍然是开放的。

但是在Python中3.5，PEP 484-类型提示对此具有唯一含义：->用于指示函数返回的类型。看起来这将在将来的版本中强制执行，如注释的现有用法如何：

最快的可能方案将在3.6中引入对非类型提示注释的静默弃用，在3.7中引入完全弃用，并将类型提示声明为Python 3.8中唯一允许使用的注释。

^{（强调我的）}

3.6据我所知，实际上尚未真正实现，因此可能会与将来的版本发生冲突。

据此，您提供了示例：

def f(x) -> 123:
    return x

将来会被禁止（并且在当前版本中会令人困惑），因此需要将其更改为：

def f(x) -> int:
    return x

为了有效地描述该函数f返回一个类型的对象int。

Python本身不以任何方式使用这些注释，它几乎填充并忽略了它们。与他们合作的取决于第三方图书馆。

As other answers have stated, the -> symbol is used as part of function annotations. In more recent versions of Python >= 3.5, though, it has a defined meaning.

PEP 3107 — Function Annotations described the specification, defining the grammar changes, the existence of func.__annotations__ in which they are stored and, the fact that it’s use case is still open.

In Python 3.5 though, PEP 484 — Type Hints attaches a single meaning to this: -> is used to indicate the type that the function returns. It also seems like this will be enforced in future versions as described in What about existing uses of annotations:

The fastest conceivable scheme would introduce silent deprecation of non-type-hint annotations in 3.6, full deprecation in 3.7, and declare type hints as the only allowed use of annotations in Python 3.8.

^{(Emphasis mine)}

This hasn’t been actually implemented as of 3.6 as far as I can tell so it might get bumped to future versions.

According to this, the example you’ve supplied:

def f(x) -> 123:
    return x

will be forbidden in the future (and in current versions will be confusing), it would need to be changed to:

def f(x) -> int:
    return x

for it to effectively describe that function f returns an object of type int.

The annotations are not used in any way by Python itself, it pretty much populates and ignores them. It’s up to 3rd party libraries to work with them.

回答 3

在下面的代码中：

def f(x) -> int:
    return int(x)

在-> int刚刚告诉f()返回一个整数（但并不强制函数返回一个整数）。它称为返回注释，可以通过进行访问f.__annotations__['return']。

Python还支持参数注释：

def f(x: float) -> int:
    return int(x)

: float告诉阅读该程序（和某些第三方库/程序，例如pylint）的人员x应为float。它以形式访问f.__annotations__['x']，其本身没有任何意义。请参阅文档以获取更多信息：

https://docs.python.org/3/reference/compound_stmts.html#function-definitions https://www.python.org/dev/peps/pep-3107/

In the following code:

def f(x) -> int:
    return int(x)

the -> int just tells that f() returns an integer (but it doesn’t force the function to return an integer). It is called a return annotation, and can be accessed as f.__annotations__['return'].

Python also supports parameter annotations:

def f(x: float) -> int:
    return int(x)

: float tells people who read the program (and some third-party libraries/programs, e. g. pylint) that x should be a float. It is accessed as f.__annotations__['x'], and doesn’t have any meaning by itself. See the documentation for more information:

https://docs.python.org/3/reference/compound_stmts.html#function-definitions https://www.python.org/dev/peps/pep-3107/

回答 4

这意味着函数返回的结果类型，但可以是None。

它在面向Python 3.x的现代库中很普遍。

例如，在很多地方，库pandas-profiling中都有代码，例如：

def get_description(self) -> dict:

def get_rejected_variables(self, threshold: float = 0.9) -> list:

def to_file(self, output_file: Path or str, silent: bool = True) -> None:
"""Write the report to a file.

This means the type of result the function returns, but it can be None.

It is widespread in modern libraries oriented on Python 3.x.

For example, it there is in code of library pandas-profiling in many places for example:

def get_description(self) -> dict:

def get_rejected_variables(self, threshold: float = 0.9) -> list:

def to_file(self, output_file: Path or str, silent: bool = True) -> None:
"""Write the report to a file.

回答 5

def function(arg)->123:

它只是一个返回类型，在这种情况下，整数与您写入的数字无关紧要。

像Java一样：

public int function(int args){...}

但是对于Python（Jim Fasarakis Hilliard怎么说） ，返回类型只是一个提示，因此建议返回，但是无论如何都允许返回其他类型，例如字符串。

def function(arg)->123:

It’s simply a return type, integer in this case doesn’t matter which number you write.

like Java :

public int function(int args){...}

But for Python (how Jim Fasarakis Hilliard said) the return type it’s just an hint, so it’s suggest the return but allow anyway to return other type like a string..

回答 6

def f(x) -> 123:
    return x

我的总结：

简单->介绍它是为了使开发人员可以选择指定函数的返回类型。请参阅Python增强建议3107
这表明随着Python的广泛采用，事情将来会如何发展-这是强类型化的迹象-这是我个人的观察。
您也可以为参数指定类型。指定函数和参数的返回类型将有助于减少逻辑错误并改进代码增强功能。
您可以将表达式作为返回类型（对于函数和参数级别），并且可以通过注释对象的’return’属性访问表达式的结果。对于lambda内联函数的表达式/返回值，注释将为空。

def f(x) -> 123:
    return x

My summary:

Simply -> is introduced to get developers to optionally specify the return type of the function. See Python Enhancement Proposal 3107
This is an indication of how things may develop in future as Python is adopted extensively – an indication towards strong typing – this is my personal observation.
You can specify types for arguments as well. Specifying return type of the functions and arguments will help in reducing logical errors and improving code enhancements.
You can have expressions as return type (for both at function and parameter level) and the result of the expressions can be accessed via annotations object’s ‘return’ attribute. annotations will be empty for the expression/return value for lambda inline functions.

知识问答

Python3中的StringIO

2021年7月25日 Python实用宝典

问题：Python3中的StringIO

我正在使用Python 3.2.1，但无法导入StringIO模块。我使用 io.StringIO和它的作品，但我不能使用它numpy的genfromtxt是这样的：

x="1 3\n 4.5 8"        
numpy.genfromtxt(io.StringIO(x))

我收到以下错误：

TypeError: Can't convert 'bytes' object to str implicitly

当我写的import StringIO时候说

ImportError: No module named 'StringIO'

I am using Python 3.2.1 and I can’t import the StringIO module. I use io.StringIO and it works, but I can’t use it with numpy‘s genfromtxt like this:

x="1 3\n 4.5 8"        
numpy.genfromtxt(io.StringIO(x))

I get the following error:

TypeError: Can't convert 'bytes' object to str implicitly

and when I write import StringIO it says

ImportError: No module named 'StringIO'

回答 0

当我写导入StringIO时，它说没有这样的模块。

从Python 3.0的新功能开始：

在StringIO和cStringIO模块都没有了。而是导入io 模块，分别将io.StringIO或io.BytesIO用于文本和数据。

。

修复一些Python 2代码以使其在Python 3（caveat emptor）中工作的可能有用的方法：

try:
    from StringIO import StringIO ## for Python 2
except ImportError:
    from io import StringIO ## for Python 3

注意：此示例可能与问题的主要内容相切，仅作为一般性地解决缺失StringIO模块时要考虑的内容。 有关消息的更直接解决方案TypeError: Can't convert 'bytes' object to str implicitly，请参阅此答案。

when i write import StringIO it says there is no such module.

From What’s New In Python 3.0:

The StringIO and cStringIO modules are gone. Instead, import the io module and use io.StringIO or io.BytesIO for text and data respectively.

A possibly useful method of fixing some Python 2 code to also work in Python 3 (caveat emptor):

try:
    from StringIO import StringIO ## for Python 2
except ImportError:
    from io import StringIO ## for Python 3

Note: This example may be tangential to the main issue of the question and is included only as something to consider when generically addressing the missing StringIO module. For a more direct solution the the message TypeError: Can't convert 'bytes' object to str implicitly, see this answer.

回答 1

就我而言，我使用了：

from io import StringIO

In my case I have used:

from io import StringIO

回答 2

在Python 3上，numpy.genfromtxt期望字节流。使用以下内容：

numpy.genfromtxt(io.BytesIO(x.encode()))

On Python 3 numpy.genfromtxt expects a bytes stream. Use the following:

numpy.genfromtxt(io.BytesIO(x.encode()))

回答 3

谢谢OP的问题，以及Roman的回答。我不得不花点时间找到它。希望以下内容对其他人有所帮助。

Python 2.7

请参阅：https：//docs.scipy.org/doc/numpy/user/basics.io.genfromtxt.html

import numpy as np
from StringIO import StringIO

data = "1, abc , 2\n 3, xxx, 4"

print type(data)
"""
<type 'str'>
"""

print '\n', np.genfromtxt(StringIO(data), delimiter=",", dtype="|S3", autostrip=True)
"""
[['1' 'abc' '2']
 ['3' 'xxx' '4']]
"""

print '\n', type(data)
"""
<type 'str'>
"""

print '\n', np.genfromtxt(StringIO(data), delimiter=",", autostrip=True)
"""
[[  1.  nan   2.]
 [  3.  nan   4.]]
"""

Python 3.5：

import numpy as np
from io import StringIO
import io

data = "1, abc , 2\n 3, xxx, 4"
#print(data)
"""
1, abc , 2
 3, xxx, 4
"""

#print(type(data))
"""
<class 'str'>
"""

#np.genfromtxt(StringIO(data), delimiter=",", autostrip=True)
# TypeError: Can't convert 'bytes' object to str implicitly

print('\n')
print(np.genfromtxt(io.BytesIO(data.encode()), delimiter=",", dtype="|S3", autostrip=True))
"""
[[b'1' b'abc' b'2']
 [b'3' b'xxx' b'4']]
"""

print('\n')
print(np.genfromtxt(io.BytesIO(data.encode()), delimiter=",", autostrip=True))
"""
[[  1.  nan   2.]
 [  3.  nan   4.]]
"""

在旁边：

dtype =“ | Sx”，其中x = {1，2，3，…}中的任何一个：

dtypes。Python中S1和S2之间的区别

“ | S1和| S2字符串是数据类型描述符；第一个意味着数组保存长度为1的字符串，第二个长度为2。…”

Thank you OP for your question, and Roman for your answer. I had to search a bit to find this; I hope the following helps others.

Python 2.7

See: https://docs.scipy.org/doc/numpy/user/basics.io.genfromtxt.html

import numpy as np
from StringIO import StringIO

data = "1, abc , 2\n 3, xxx, 4"

print type(data)
"""
<type 'str'>
"""

print '\n', np.genfromtxt(StringIO(data), delimiter=",", dtype="|S3", autostrip=True)
"""
[['1' 'abc' '2']
 ['3' 'xxx' '4']]
"""

print '\n', type(data)
"""
<type 'str'>
"""

print '\n', np.genfromtxt(StringIO(data), delimiter=",", autostrip=True)
"""
[[  1.  nan   2.]
 [  3.  nan   4.]]
"""

Python 3.5:

import numpy as np
from io import StringIO
import io

data = "1, abc , 2\n 3, xxx, 4"
#print(data)
"""
1, abc , 2
 3, xxx, 4
"""

#print(type(data))
"""
<class 'str'>
"""

#np.genfromtxt(StringIO(data), delimiter=",", autostrip=True)
# TypeError: Can't convert 'bytes' object to str implicitly

print('\n')
print(np.genfromtxt(io.BytesIO(data.encode()), delimiter=",", dtype="|S3", autostrip=True))
"""
[[b'1' b'abc' b'2']
 [b'3' b'xxx' b'4']]
"""

print('\n')
print(np.genfromtxt(io.BytesIO(data.encode()), delimiter=",", autostrip=True))
"""
[[  1.  nan   2.]
 [  3.  nan   4.]]
"""

Aside:

dtype=”|Sx”, where x = any of { 1, 2, 3, …}:

dtypes. Difference between S1 and S2 in Python

“The |S1 and |S2 strings are data type descriptors; the first means the array holds strings of length 1, the second of length 2. …”

回答 4

您可以从六个模块中使用StringIO：

import six
import numpy

x = "1 3\n 4.5 8"
numpy.genfromtxt(six.StringIO(x))

You can use the StringIO from the six module:

import six
import numpy

x = "1 3\n 4.5 8"
numpy.genfromtxt(six.StringIO(x))

回答 5

Roman Shapovalov的代码应该在Python 3.x和2.6 / 2.7中都可以使用。这里还是完整的示例：

import io
import numpy
x = "1 3\n 4.5 8"
numpy.genfromtxt(io.BytesIO(x.encode()))

输出：

array([[ 1. ,  3. ],
       [ 4.5,  8. ]])

Python 3.x的说明：

numpy.genfromtxt 接受字节流（将类似文件的对象解释为字节而不是Unicode）。
io.BytesIO 接受字节字符串并返回字节流。 io.StringIO另一方面，将采用Unicode字符串并返回Unicode流。
x 被分配了一个字符串文字，在Python 3.x中是Unicode字符串。
encode()x提取Unicode字符串并从中取出一个字节字符串，从而提供io.BytesIO有效的参数。

Python 2.6 / 2.7的唯一区别是它x是一个字节字符串（假定from __future__ import unicode_literals未使用），然后encode()获取该字节字符串，x并仍然从中提取相同的字节字符串。因此结果是相同的。

由于这是SO最受欢迎的问题之一，因此StringIO，这里有一些有关import语句和不同Python版本的更多说明。

以下是采用字符串并返回流的类：

io.BytesIO（Python 2.6、2.7和3.x）-接收一个字节字符串。返回字节流。
io.StringIO（Python 2.6、2.7和3.x）-采用Unicode字符串。返回Unicode流。
StringIO.StringIO（Python 2.x）-接受字节字符串或Unicode字符串。如果为字节字符串，则返回字节流。如果是Unicode字符串，则返回Unicode流。
cStringIO.StringIO（Python 2.x）-的更快版本StringIO.StringIO，但不能采用包含非ASCII字符的Unicode字符串。

请注意，StringIO.StringIO导入为from StringIO import StringIO，然后用作StringIO(...)。要么这样做，要么您执行import StringIO然后使用StringIO.StringIO(...)。模块名称和类名称恰好是相同的。这类似于datetime这种方式。

使用什么，取决于您支持的Python版本：

如果您仅支持Python 3.x：只需使用io.BytesIO或io.StringIO取决于您使用的是哪种数据。
如果您同时支持Python 2.6 / 2.7和3.x，或者正尝试将代码从2.6 / 2.7转换到3.x：最简单的选择仍然是使用io.BytesIO或io.StringIO。尽管它StringIO.StringIO很灵活，因此在2.6 / 2.7中似乎是首选，但这种灵活性可能会掩盖3.x版本中将出现的错误。例如，我有一些使用StringIO.StringIO或io.StringIO取决于Python版本的代码，但实际上是传递一个字节字符串，因此当我在Python 3.x中进行测试时，它失败了，必须加以修复。

使用的另一个优点io.StringIO是对通用换行符的支持。如果你传递关键字参数newline=''到io.StringIO，这将是能够在任何的分割线\n，\r\n或\r。我发现那StringIO.StringIO会绊倒\r尤其严重。

请注意，如果您导入BytesIO或StringIO从six，你StringIO.StringIO在Python 2.x和相应的类从io在Python 3.x的如果您同意我之前的评估，实际上这是应该避免的一种情况，而应该six从中io引入。
如果您支持Python 2.5或更低版本和3.x：您将需要StringIO.StringIO2.5或更低版本，因此您最好使用six。但是要意识到，同时支持2.5和3.x通常非常困难，因此，如果可能的话，应该考虑将最低支持的版本提高到2.6。

Roman Shapovalov’s code should work in Python 3.x as well as Python 2.6/2.7. Here it is again with the complete example:

import io
import numpy
x = "1 3\n 4.5 8"
numpy.genfromtxt(io.BytesIO(x.encode()))

Output:

array([[ 1. ,  3. ],
       [ 4.5,  8. ]])

Explanation for Python 3.x:

numpy.genfromtxt takes a byte stream (a file-like object interpreted as bytes instead of Unicode).
io.BytesIO takes a byte string and returns a byte stream. io.StringIO, on the other hand, would take a Unicode string and and return a Unicode stream.
x gets assigned a string literal, which in Python 3.x is a Unicode string.
encode() takes the Unicode string x and makes a byte string out of it, thus giving io.BytesIO a valid argument.

The only difference for Python 2.6/2.7 is that x is a byte string (assuming from __future__ import unicode_literals is not used), and then encode() takes the byte string x and still makes the same byte string out of it. So the result is the same.

Since this is one of SO’s most popular questions regarding StringIO, here’s some more explanation on the import statements and different Python versions.

Here are the classes which take a string and return a stream:

io.BytesIO (Python 2.6, 2.7, and 3.x) – Takes a byte string. Returns a byte stream.
io.StringIO (Python 2.6, 2.7, and 3.x) – Takes a Unicode string. Returns a Unicode stream.
StringIO.StringIO (Python 2.x) – Takes a byte string or Unicode string. If byte string, returns a byte stream. If Unicode string, returns a Unicode stream.
cStringIO.StringIO (Python 2.x) – Faster version of StringIO.StringIO, but can’t take Unicode strings which contain non-ASCII characters.

Note that StringIO.StringIO is imported as from StringIO import StringIO, then used as StringIO(...). Either that, or you do import StringIO and then use StringIO.StringIO(...). The module name and class name just happen to be the same. It’s similar to datetime that way.

What to use, depending on your supported Python versions:

If you only support Python 3.x: Just use io.BytesIO or io.StringIO depending on what kind of data you’re working with.
If you support both Python 2.6/2.7 and 3.x, or are trying to transition your code from 2.6/2.7 to 3.x: The easiest option is still to use io.BytesIO or io.StringIO. Although StringIO.StringIO is flexible and thus seems preferred for 2.6/2.7, that flexibility could mask bugs that will manifest in 3.x. For example, I had some code which used StringIO.StringIO or io.StringIO depending on Python version, but I was actually passing a byte string, so when I got around to testing it in Python 3.x it failed and had to be fixed.

Another advantage of using io.StringIO is the support for universal newlines. If you pass the keyword argument newline='' into io.StringIO, it will be able to split lines on any of \n, \r\n, or \r. I found that StringIO.StringIO would trip up on \r in particular.

Note that if you import BytesIO or StringIO from six, you get StringIO.StringIO in Python 2.x and the appropriate class from io in Python 3.x. If you agree with my previous paragraphs’ assessment, this is actually one case where you should avoid six and just import from io instead.
If you support Python 2.5 or lower and 3.x: You’ll need StringIO.StringIO for 2.5 or lower, so you might as well use six. But realize that it’s generally very difficult to support both 2.5 and 3.x, so you should consider bumping your lowest supported version to 2.6 if at all possible.

回答 6

为了使此处的示例可与Python 3.5.2一起使用，可以重写如下：

import io
data =io.BytesIO(b"1, 2, 3\n4, 5, 6") 
import numpy
numpy.genfromtxt(data, delimiter=",")

进行更改的原因可能是文件的内容以数据（字节）为单位，除非经过某种方式解码，否则它们不会生成文本。genfrombytes可能比genfromtxt。

In order to make examples from here work with Python 3.5.2, you can rewrite as follows :

import io
data =io.BytesIO(b"1, 2, 3\n4, 5, 6") 
import numpy
numpy.genfromtxt(data, delimiter=",")

The reason for the change may be that the content of a file is in data (bytes) which do not make text until being decoded somehow. genfrombytes may be a better name than genfromtxt.

回答 7

尝试这个

从StringIO导入StringIO

x =“ 1 3 \ n 4.5 8”

numpy.genfromtxt（StringIO（x））

try this

from StringIO import StringIO

x=”1 3\n 4.5 8″

numpy.genfromtxt(StringIO(x))

知识问答

导入错误：没有模块名称urllib2

2021年7月25日 Python实用宝典

问题：导入错误：没有模块名称urllib2

这是我的代码：

import urllib2.request

response = urllib2.urlopen("http://www.google.com")
html = response.read()
print(html)

有什么帮助吗？

Here’s my code:

import urllib2.request

response = urllib2.urlopen("http://www.google.com")
html = response.read()
print(html)

Any help?

回答 0

如urllib2文档中所述：

该urllib2模块已在Python 3中分为几个名为urllib.request和的模块urllib.error。2to3在将源转换为Python 3时，该工具将自动调整导入。

所以你应该说

from urllib.request import urlopen
html = urlopen("http://www.google.com/").read()
print(html)

您当前正在编辑的代码示例不正确，因为您是在说urllib.urlopen("http://www.google.com/")而不是urlopen("http://www.google.com/")。

As stated in the urllib2 documentation:

The urllib2 module has been split across several modules in Python 3 named urllib.request and urllib.error. The 2to3 tool will automatically adapt imports when converting your sources to Python 3.

So you should instead be saying

from urllib.request import urlopen
html = urlopen("http://www.google.com/").read()
print(html)

Your current, now-edited code sample is incorrect because you are saying urllib.urlopen("http://www.google.com/") instead of just urlopen("http://www.google.com/").

回答 1

对于使用Python 2（测试版2.7.3和2.6.8）和Python 3（3.2.3和3.3.2+）的脚本，请尝试：

#! /usr/bin/env python

try:
    # For Python 3.0 and later
    from urllib.request import urlopen
except ImportError:
    # Fall back to Python 2's urllib2
    from urllib2 import urlopen

html = urlopen("http://www.google.com/")
print(html.read())

For a script working with Python 2 (tested versions 2.7.3 and 2.6.8) and Python 3 (3.2.3 and 3.3.2+) try:

#! /usr/bin/env python

try:
    # For Python 3.0 and later
    from urllib.request import urlopen
except ImportError:
    # Fall back to Python 2's urllib2
    from urllib2 import urlopen

html = urlopen("http://www.google.com/")
print(html.read())

回答 2

上面的内容在3.3中对我不起作用。改试试这个（YMMV等）

import urllib.request
url = "http://www.google.com/"
request = urllib.request.Request(url)
response = urllib.request.urlopen(request)
print (response.read().decode('utf-8'))

The above didn’t work for me in 3.3. Try this instead (YMMV, etc)

import urllib.request
url = "http://www.google.com/"
request = urllib.request.Request(url)
response = urllib.request.urlopen(request)
print (response.read().decode('utf-8'))

回答 3

一些制表符补全显示了Python 2 vs Python 3中软件包的内容。

在Python 2中：

In [1]: import urllib

In [2]: urllib.
urllib.ContentTooShortError      urllib.ftpwrapper                urllib.socket                    urllib.test1
urllib.FancyURLopener            urllib.getproxies                urllib.splitattr                 urllib.thishost
urllib.MAXFTPCACHE               urllib.getproxies_environment    urllib.splithost                 urllib.time
urllib.URLopener                 urllib.i                         urllib.splitnport                urllib.toBytes
urllib.addbase                   urllib.localhost                 urllib.splitpasswd               urllib.unquote
urllib.addclosehook              urllib.noheaders                 urllib.splitport                 urllib.unquote_plus
urllib.addinfo                   urllib.os                        urllib.splitquery                urllib.unwrap
urllib.addinfourl                urllib.pathname2url              urllib.splittag                  urllib.url2pathname
urllib.always_safe               urllib.proxy_bypass              urllib.splittype                 urllib.urlcleanup
urllib.base64                    urllib.proxy_bypass_environment  urllib.splituser                 urllib.urlencode
urllib.basejoin                  urllib.quote                     urllib.splitvalue                urllib.urlopen
urllib.c                         urllib.quote_plus                urllib.ssl                       urllib.urlretrieve
urllib.ftpcache                  urllib.re                        urllib.string                    
urllib.ftperrors                 urllib.reporthook                urllib.sys

在Python 3中：

In [2]: import urllib.
urllib.error        urllib.parse        urllib.request      urllib.response     urllib.robotparser

In [2]: import urllib.error.
urllib.error.ContentTooShortError  urllib.error.HTTPError             urllib.error.URLError

In [2]: import urllib.parse.
urllib.parse.parse_qs          urllib.parse.quote_plus        urllib.parse.urldefrag         urllib.parse.urlsplit
urllib.parse.parse_qsl         urllib.parse.unquote           urllib.parse.urlencode         urllib.parse.urlunparse
urllib.parse.quote             urllib.parse.unquote_plus      urllib.parse.urljoin           urllib.parse.urlunsplit
urllib.parse.quote_from_bytes  urllib.parse.unquote_to_bytes  urllib.parse.urlparse

In [2]: import urllib.request.
urllib.request.AbstractBasicAuthHandler         urllib.request.HTTPSHandler
urllib.request.AbstractDigestAuthHandler        urllib.request.OpenerDirector
urllib.request.BaseHandler                      urllib.request.ProxyBasicAuthHandler
urllib.request.CacheFTPHandler                  urllib.request.ProxyDigestAuthHandler
urllib.request.DataHandler                      urllib.request.ProxyHandler
urllib.request.FTPHandler                       urllib.request.Request
urllib.request.FancyURLopener                   urllib.request.URLopener
urllib.request.FileHandler                      urllib.request.UnknownHandler
urllib.request.HTTPBasicAuthHandler             urllib.request.build_opener
urllib.request.HTTPCookieProcessor              urllib.request.getproxies
urllib.request.HTTPDefaultErrorHandler          urllib.request.install_opener
urllib.request.HTTPDigestAuthHandler            urllib.request.pathname2url
urllib.request.HTTPErrorProcessor               urllib.request.url2pathname
urllib.request.HTTPHandler                      urllib.request.urlcleanup
urllib.request.HTTPPasswordMgr                  urllib.request.urlopen
urllib.request.HTTPPasswordMgrWithDefaultRealm  urllib.request.urlretrieve
urllib.request.HTTPRedirectHandler     


In [2]: import urllib.response.
urllib.response.addbase       urllib.response.addclosehook  urllib.response.addinfo       urllib.response.addinfourl

Some tab completions to show the contents of the packages in Python 2 vs Python 3.

In Python 2:

In [1]: import urllib

In [2]: urllib.
urllib.ContentTooShortError      urllib.ftpwrapper                urllib.socket                    urllib.test1
urllib.FancyURLopener            urllib.getproxies                urllib.splitattr                 urllib.thishost
urllib.MAXFTPCACHE               urllib.getproxies_environment    urllib.splithost                 urllib.time
urllib.URLopener                 urllib.i                         urllib.splitnport                urllib.toBytes
urllib.addbase                   urllib.localhost                 urllib.splitpasswd               urllib.unquote
urllib.addclosehook              urllib.noheaders                 urllib.splitport                 urllib.unquote_plus
urllib.addinfo                   urllib.os                        urllib.splitquery                urllib.unwrap
urllib.addinfourl                urllib.pathname2url              urllib.splittag                  urllib.url2pathname
urllib.always_safe               urllib.proxy_bypass              urllib.splittype                 urllib.urlcleanup
urllib.base64                    urllib.proxy_bypass_environment  urllib.splituser                 urllib.urlencode
urllib.basejoin                  urllib.quote                     urllib.splitvalue                urllib.urlopen
urllib.c                         urllib.quote_plus                urllib.ssl                       urllib.urlretrieve
urllib.ftpcache                  urllib.re                        urllib.string                    
urllib.ftperrors                 urllib.reporthook                urllib.sys

In Python 3:

In [2]: import urllib.
urllib.error        urllib.parse        urllib.request      urllib.response     urllib.robotparser

In [2]: import urllib.error.
urllib.error.ContentTooShortError  urllib.error.HTTPError             urllib.error.URLError

In [2]: import urllib.parse.
urllib.parse.parse_qs          urllib.parse.quote_plus        urllib.parse.urldefrag         urllib.parse.urlsplit
urllib.parse.parse_qsl         urllib.parse.unquote           urllib.parse.urlencode         urllib.parse.urlunparse
urllib.parse.quote             urllib.parse.unquote_plus      urllib.parse.urljoin           urllib.parse.urlunsplit
urllib.parse.quote_from_bytes  urllib.parse.unquote_to_bytes  urllib.parse.urlparse

In [2]: import urllib.request.
urllib.request.AbstractBasicAuthHandler         urllib.request.HTTPSHandler
urllib.request.AbstractDigestAuthHandler        urllib.request.OpenerDirector
urllib.request.BaseHandler                      urllib.request.ProxyBasicAuthHandler
urllib.request.CacheFTPHandler                  urllib.request.ProxyDigestAuthHandler
urllib.request.DataHandler                      urllib.request.ProxyHandler
urllib.request.FTPHandler                       urllib.request.Request
urllib.request.FancyURLopener                   urllib.request.URLopener
urllib.request.FileHandler                      urllib.request.UnknownHandler
urllib.request.HTTPBasicAuthHandler             urllib.request.build_opener
urllib.request.HTTPCookieProcessor              urllib.request.getproxies
urllib.request.HTTPDefaultErrorHandler          urllib.request.install_opener
urllib.request.HTTPDigestAuthHandler            urllib.request.pathname2url
urllib.request.HTTPErrorProcessor               urllib.request.url2pathname
urllib.request.HTTPHandler                      urllib.request.urlcleanup
urllib.request.HTTPPasswordMgr                  urllib.request.urlopen
urllib.request.HTTPPasswordMgrWithDefaultRealm  urllib.request.urlretrieve
urllib.request.HTTPRedirectHandler     


In [2]: import urllib.response.
urllib.response.addbase       urllib.response.addclosehook  urllib.response.addinfo       urllib.response.addinfourl

回答 4

Python 3：

import urllib.request

wp = urllib.request.urlopen("http://google.com")
pw = wp.read()
print(pw)

Python 2：

import urllib
import sys

wp = urllib.urlopen("http://google.com")
for line in wp:
    sys.stdout.write(line)

虽然我已经测试了各自版本中的两个代码。

Python 3:

import urllib.request

wp = urllib.request.urlopen("http://google.com")
pw = wp.read()
print(pw)

Python 2:

import urllib
import sys

wp = urllib.urlopen("http://google.com")
for line in wp:
    sys.stdout.write(line)

While I have tested both the Codes in respective versions.

回答 5

所有解决方案中最简单的：

在Python 3.x中：

import urllib.request
url = "https://api.github.com/users?since=100"
request = urllib.request.Request(url)
response = urllib.request.urlopen(request)
data_content = response.read()
print(data_content)

Simplest of all solutions:

In Python 3.x:

import urllib.request
url = "https://api.github.com/users?since=100"
request = urllib.request.Request(url)
response = urllib.request.urlopen(request)
data_content = response.read()
print(data_content)

回答 6

在python 3中，要获取文本输出：

import io
import urllib.request

response = urllib.request.urlopen("http://google.com")
text = io.TextIOWrapper(response)

In python 3, to get text output:

import io
import urllib.request

response = urllib.request.urlopen("http://google.com")
text = io.TextIOWrapper(response)

回答 7

那在python3中对我有用：

import urllib.request
htmlfile = urllib.request.urlopen("http://google.com")
htmltext = htmlfile.read()
print(htmltext)

That worked for me in python3:

import urllib.request
htmlfile = urllib.request.urlopen("http://google.com")
htmltext = htmlfile.read()
print(htmltext)

知识问答

是否在Python 3.6+中订购了字典？

2021年7月25日 Python实用宝典

问题：是否在Python 3.6+中订购了字典？

与以前的版本不同，字典在Python 3.6中排序（至少在CPython实现下）。这似乎是一个重大更改，但只是文档中的一小段。它被描述为CPython实现细节而不是语言功能，但这也意味着将来可能会成为标准。

在保留元素顺序的同时，新的字典实现如何比旧的实现更好？

以下是文档中的文字：

dict()现在使用PyPy率先提出的“紧凑”表示形式。与Python 3.5相比，新dict（）的内存使用量减少了20％至25％。PEP 468（在函数中保留** kwarg的顺序。）由此实现。此新实现的顺序保留方面被认为是实现细节，因此不应依赖（将来可能会更改，但是希望在更改语言规范之前，先在几个发行版中使用该新dict实现该语言，为所有当前和将来的Python实现强制要求保留顺序的语义；这还有助于保留与仍旧有效的随机迭代顺序的旧版本语言（例如Python 3.5）的向后兼容性。（由INADA Naoki在发行27350。最初由Raymond Hettinger提出的想法。）

2017年12月更新：Python 3.7 保证dict保留插入顺序

Dictionaries are ordered in Python 3.6 (under the CPython implementation at least) unlike in previous incarnations. This seems like a substantial change, but it’s only a short paragraph in the documentation. It is described as a CPython implementation detail rather than a language feature, but also implies this may become standard in the future.

How does the new dictionary implementation perform better than the older one while preserving element order?

Here is the text from the documentation:

dict() now uses a “compact” representation pioneered by PyPy. The memory usage of the new dict() is between 20% and 25% smaller compared to Python 3.5. PEP 468 (Preserving the order of **kwargs in a function.) is implemented by this. The order-preserving aspect of this new implementation is considered an implementation detail and should not be relied upon (this may change in the future, but it is desired to have this new dict implementation in the language for a few releases before changing the language spec to mandate order-preserving semantics for all current and future Python implementations; this also helps preserve backwards-compatibility with older versions of the language where random iteration order is still in effect, e.g. Python 3.5). (Contributed by INADA Naoki in issue 27350. Idea originally suggested by Raymond Hettinger.)

Update December 2017: dicts retaining insertion order is guaranteed for Python 3.7

回答 0

是否在Python 3.6+中订购了字典？

它们是插入顺序^[1]。从Python 3.6开始，对于Python的CPython实现，字典会记住插入项目的顺序。这在Python 3.6中被视为实现细节；你需要使用OrderedDict，如果你想多数民众赞成插入排序保证不同的Python的其它实现（与其他有序行为^[1]）。

从Python 3.7开始，它不再是实现细节，而是成为一种语言功能。从GvR的python-dev消息中：

做到这一点。裁定“裁定保留插入顺序”。谢谢！

这只是意味着您可以依靠它。如果其他Python实现希望成为Python 3.7的一致实现，则还必须提供插入顺序字典。

在保留元素顺序的同时，Python 3.6字典实现如何比旧的实现更好的性能^[2]？

本质上，通过保留两个数组。

第一个数组，按插入顺序dk_entries保存字典的条目（类型PyDictKeyEntry）。保留顺序是通过仅附加数组来实现的，在该数组中始终在末尾插入新项（插入顺序）。
第二个dk_indices保留dk_entries数组的索引（即，指示中相应条目位置的值dk_entries）。该数组充当哈希表。对键进行哈希处理时，它会导致存储在其中的索引之一，dk_indices并且通过indexing获取相应的条目dk_entries。由于只有索引被保留，此数组的类型取决于字典的整体大小（范围从类型int8_t（1字节）到int32_t/ int64_t（4/ 8字节）上32/ 64位构建）

在以前的实现中，必须分配类型PyDictKeyEntry和大小的稀疏数组dk_size。不幸的是，由于性能原因，该阵列不允许2/3 * dk_size满载，这也导致了很多空白。（并且空白区域仍具有大小！）。PyDictKeyEntry

现在不是这种情况，因为仅存储了必需的条目（已插入的条目），并且保留了一个稀疏类型的数组intX_t（X取决于dict的大小）2/3 * dk_size。空格从类型更改PyDictKeyEntry为intX_t。

因此，显然，创建一个类型PyDictKeyEntry稀疏的数组比存储ints 的稀疏数组需要更多的内存。

如果有兴趣，可以在Python-Dev上查看有关此功能的完整对话，这是一本好书。

在Raymond Hettinger提出的原始建议中，可以看到使用的数据结构的可视化效果，该可视化体现了该思想的要旨。

例如，字典：

d = {'timmy': 'red', 'barry': 'green', 'guido': 'blue'}

当前存储为[keyhash，key，value]：

entries = [['--', '--', '--'],
           [-8522787127447073495, 'barry', 'green'],
           ['--', '--', '--'],
           ['--', '--', '--'],
           ['--', '--', '--'],
           [-9092791511155847987, 'timmy', 'red'],
           ['--', '--', '--'],
           [-6480567542315338377, 'guido', 'blue']]

相反，数据应按以下方式组织：

indices =  [None, 1, None, None, None, 0, None, 2]
entries =  [[-9092791511155847987, 'timmy', 'red'],
            [-8522787127447073495, 'barry', 'green'],
            [-6480567542315338377, 'guido', 'blue']]

正如您现在可以从视觉上看到的那样，在原始建议中，很多空间实际上是空的，以减少冲突并加快查找速度。使用新方法，可以通过将稀疏移动到真正需要的索引中来减少所需的内存。

_{[1]：我说“插入有序”而不是“有序”，因为在存在OrderedDict的情况下，“有序”暗示了dict对象不提供的其他行为。OrderedDicts是可逆的，提供顺序敏感的方法，并且主要是，提供一个订单sensive相等测试（==，!=）。dict目前不提供任何这些行为/方法。}

_{[2]：新的字典实现通过更紧凑的设计而在内存方面表现更好；这是这里的主要好处。在速度方面，差异并不那么明显，在某些地方，新的dict可能会引入轻微的回归（例如，关键查找），而在其他地方（会想到迭代和调整大小），应该会提高性能。}

_{总体而言，由于引入的紧凑性，字典的性能（尤其是在现实生活中）得以提高。}

Are dictionaries ordered in Python 3.6+?

They are insertion ordered^[1]. As of Python 3.6, for the CPython implementation of Python, dictionaries remember the order of items inserted. This is considered an implementation detail in Python 3.6; you need to use OrderedDict if you want insertion ordering that’s guaranteed across other implementations of Python (and other ordered behavior^[1]).

As of Python 3.7, this is no longer an implementation detail and instead becomes a language feature. From a python-dev message by GvR:

Make it so. “Dict keeps insertion order” is the ruling. Thanks!

This simply means that you can depend on it. Other implementations of Python must also offer an insertion ordered dictionary if they wish to be a conforming implementation of Python 3.7.

How does the Python 3.6 dictionary implementation perform better^[2] than the older one while preserving element order?

Essentially, by keeping two arrays.

The first array, dk_entries, holds the entries (of type PyDictKeyEntry) for the dictionary in the order that they were inserted. Preserving order is achieved by this being an append only array where new items are always inserted at the end (insertion order).
The second, dk_indices, holds the indices for the dk_entries array (that is, values that indicate the position of the corresponding entry in dk_entries). This array acts as the hash table. When a key is hashed it leads to one of the indices stored in dk_indices and the corresponding entry is fetched by indexing dk_entries. Since only indices are kept, the type of this array depends on the overall size of the dictionary (ranging from type int8_t(1 byte) to int32_t/int64_t (4/8 bytes) on 32/64 bit builds)

In the previous implementation, a sparse array of type PyDictKeyEntry and size dk_size had to be allocated; unfortunately, it also resulted in a lot of empty space since that array was not allowed to be more than 2/3 * dk_size full for performance reasons. (and the empty space still had PyDictKeyEntry size!).

This is not the case now since only the required entries are stored (those that have been inserted) and a sparse array of type intX_t (X depending on dict size) 2/3 * dk_sizes full is kept. The empty space changed from type PyDictKeyEntry to intX_t.

So, obviously, creating a sparse array of type PyDictKeyEntry is much more memory demanding than a sparse array for storing ints.

You can see the full conversation on Python-Dev regarding this feature if interested, it is a good read.

In the original proposal made by Raymond Hettinger, a visualization of the data structures used can be seen which captures the gist of the idea.

For example, the dictionary:

d = {'timmy': 'red', 'barry': 'green', 'guido': 'blue'}

is currently stored as [keyhash, key, value]:

entries = [['--', '--', '--'],
           [-8522787127447073495, 'barry', 'green'],
           ['--', '--', '--'],
           ['--', '--', '--'],
           ['--', '--', '--'],
           [-9092791511155847987, 'timmy', 'red'],
           ['--', '--', '--'],
           [-6480567542315338377, 'guido', 'blue']]

Instead, the data should be organized as follows:

indices =  [None, 1, None, None, None, 0, None, 2]
entries =  [[-9092791511155847987, 'timmy', 'red'],
            [-8522787127447073495, 'barry', 'green'],
            [-6480567542315338377, 'guido', 'blue']]

As you can visually now see, in the original proposal, a lot of space is essentially empty to reduce collisions and make look-ups faster. With the new approach, you reduce the memory required by moving the sparseness where it’s really required, in the indices.

_{[1]: I say “insertion ordered” and not “ordered” since, with the existence of OrderedDict, “ordered” suggests further behavior that the dict object doesn’t provide. OrderedDicts are reversible, provide order sensitive methods and, mainly, provide an order-sensive equality tests (==, !=). dicts currently don’t offer any of those behaviors/methods.}

_{[2]: The new dictionary implementations performs better memory wise by being designed more compactly; that’s the main benefit here. Speed wise, the difference isn’t so drastic, there’s places where the new dict might introduce slight regressions (key-lookups, for example) while in others (iteration and resizing come to mind) a performance boost should be present.}

_{Overall, the performance of the dictionary, especially in real-life situations, improves due to the compactness introduced.}

回答 1

以下是回答最初的第一个问题：

我应该在Python 3.6中使用dict还是OrderedDict在Python 3.6中使用？

我认为文档中的这句话实际上足以回答您的问题

此新实现的顺序保留方面被视为实现细节，不应依赖于此

dict并不明确表示它是有序集合，因此，如果您要保持一致并且不依赖于新实现的副作用，则应坚持使用OrderedDict。

使您的代码成为未来的证明:)

有关于辩论在这里。

编辑：Python 3.7将保留此功能， 请参阅

Below is answering the original first question:

Should I use dict or OrderedDict in Python 3.6?

I think this sentence from the documentation is actually enough to answer your question

The order-preserving aspect of this new implementation is considered an implementation detail and should not be relied upon

dict is not explicitly meant to be an ordered collection, so if you want to stay consistent and not rely on a side effect of the new implementation you should stick with OrderedDict.

Make your code future proof :)

There’s a debate about that here.

EDIT: Python 3.7 will keep this as a feature see

回答 2

更新：Guido van Rossum 在邮件列表中宣布，从 Python 3.7开始dict，所有Python实现中必须保留插入顺序。

Update: Guido van Rossum announced on the mailing list that as of Python 3.7 dicts in all Python implementations must preserve insertion order.

回答 3

我想添加到上面的讨论中，但没有评论的声誉。

Python 3.8尚未发布，但它甚至将包含reversed()字典上的函数（消除了的另一个区别OrderedDict。）。

现在可以使用reversed（）以反向插入顺序迭代Dict和dictviews。（由RémiLapeyre在bpo-33462中贡献。）查看python 3.8的新增功能

我没有提到相等运算符或的其他功能，OrderedDict因此它们仍然不完全相同。

I wanted to add to the discussion above but don’t have the reputation to comment.

Python 3.8 is not quite released yet, but it will even include the reversed() function on dictionaries (removing another difference from OrderedDict.

Dict and dictviews are now iterable in reversed insertion order using reversed(). (Contributed by Rémi Lapeyre in bpo-33462.) See what’s new in python 3.8

I don’t see any mention of the equality operator or other features of OrderedDict so they are still not entirely the same.

问题：如何在Python 3中使用raw_input

回答 0

回答 1

回答 2

回答 3

使用命令提示符

使用IDLE

Use a command-prompt

Use IDLE

回答 4

回答 5

回答 6

问题：如何使用Python 3安装pip？

回答 0

如果您运行的是Python 2.7.9+或Python 3.4+

如果您正在运行类似Unix的系统

在适用于Python 2.x的Debian（Wheezy和更高版本）和Ubuntu（Trusty Tahr和更高版本）上安装

在适用于Python 3.x的Debian（Wheezy和更高版本）和Ubuntu（Trusty Tahr和更高版本）上安装

pip在适用于Python 2.x的CentOS 7上安装

pip在适用于Python 3.x的CentOS 7上安装

如果您的Unix / Linux发行版未在软件包repos中包含它

手动方式

If you’re running Python 2.7.9+ or Python 3.4+

If you’re running a Unix-like System

Installing on Debian (Wheezy and newer) and Ubuntu (Trusty Tahr and newer) for Python 2.x

Installing on Debian (Wheezy and newer) and Ubuntu (Trusty Tahr and newer) for Python 3.x

Installing pip on CentOS 7 for Python 2.x

Installing pip on CentOS 7 for Python 3.x

If your Unix/Linux distro doesn’t have it in package repos

The manual way

回答 1

回答 2

Python 3.4以上和Python 2.7.9以上

Python≤2.7.8和Python≤3.3

官方指示

Python 3.4+ and Python 2.7.9+

Python ≤ 2.7.8 and Python ≤ 3.3

Official instructions

回答 3

回答 4

回答 5

2015年1月20日更新：

原始答案：

Update 2015-01-20:

Original Answer:

回答 6

回答 7

回答 8

旧版的Homebrew

更新-1.5之后的自制软件版本

Older version of Homebrew

UPDATED – Homebrew version after 1.5

回答 9

回答 10

回答 11

回答 12

Python 3.4新增功能

What’s New In Python 3.4

回答 13

回答 14

回答 15

回答 16

回答 17

回答 18

回答 19

回答 20

问题：在Python中，“ SyntaxError：调用’print’时缺少括号”是什么意思？

回答 0

回答 1

回答 2

回答 3

回答 4

回答 5

讲解

Explaination

回答 6

回答 7

问题：获取map（）以在Python 3.x中返回列表

回答 0

回答 1

`pip`在适用于Python 2.x的CentOS 7上安装

`pip`在适用于Python 3.x的CentOS 7上安装

Installing `pip` on CentOS 7 for Python 2.x

Installing `pip` on CentOS 7 for Python 3.x