什么是__pycache__?

问题:什么是__pycache__?

据我了解,缓存是类似文件的加密文件。

__pycache__文件夹怎么办?是我们提供给人们的,而不是我们提供的源代码吗?只是我的输入数据吗?这个文件夹不断创建,它是做什么用的?

From what I understand, a cache is an encrypted file of similar files.

What do we do with the __pycache__ folder? Is it what we give to people instead of our source code? Is it just my input data? This folder keeps getting created, what it is for?


回答 0

当您在python中运行程序时,解释器首先将其编译为字节码(这过于简化),并将其存储在__pycache__文件夹中。如果在其中查看,则会在项目文件夹中找到一堆共享.py文件名的文件,只有它们的扩展名是.pyc或.pyo。它们分别是程序文件的字节码编译版本和优化的字节码编译版本。

作为程序员,您基本上可以忽略它……它所做的只是使您的程序启动更快。脚本更改时,将重新编译它们,如果删除文件或整个文件夹并再次运行程序,它们将重新出现(除非您明确禁止这种行为)

如果您使用的是cpython(这是最常见的实现,因为它是参考实现),并且您不想要该文件夹,则可以通过使用-B标志启动解释器来取消显示该文件夹。

python -B foo.py

如tcaswell所述,另一种选择是将环境变量设置PYTHONDONTWRITEBYTECODE为任何值(根据python的手册页,任何“非空字符串”)。

When you run a program in python, the interpreter compiles it to bytecode first (this is an oversimplification) and stores it in the __pycache__ folder. If you look in there you will find a bunch of files sharing the names of the .py files in your project’s folder, only their extensions will be either .pyc or .pyo. These are bytecode-compiled and optimized bytecode-compiled versions of your program’s files, respectively.

As a programmer, you can largely just ignore it… All it does is make your program start a little faster. When your scripts change, they will be recompiled, and if you delete the files or the whole folder and run your program again, they will reappear (unless you specifically suppress that behavior)

If you are using cpython (which is the most common, as it’s the reference implementation) and you don’t want that folder, then you can suppress it by starting the interpreter with the -B flag, for example

python -B foo.py

Another option, as noted by tcaswell, is to set the environment variable PYTHONDONTWRITEBYTECODE to any value (according to python’s man page, any “non-empty string”).


回答 1

__pycache__是一个包含已编译并准备执行的Python 3字节码的文件夹。

我不建议您定期删除这些文件或在开发过程中禁止创建文件,因为这可能会影响性能。只需准备好一个递归命令(请参见下文)即可在需要时进行清理,因为在极端情况下字节码可能会变得过时(请参见注释)。

Python程序员通常忽略字节码。事实上,__pycache__*.pyc有共同线看.gitignore文件。字节码不用于分发,可以使用dismodule进行反汇编。


如果使用的是OS X,则可以通过从项目的根文件夹运行以下命令来轻松地将所有这些文件夹隐藏在项目中。

find . -name '__pycache__' -exec chflags hidden {} \;

更换__pycache__*.pyc的Python 2。

这会在所有这些目录(.pyc文件)上设置一个标志,告诉Finder / Textmate 2将其从列表中排除。重要的是字节码在那里,它只是隐藏的。

如果创建新模块并希望隐藏新的字节码或删除隐藏的字节码文件,请重新运行该命令。


在Windows上,可以使用等效命令(未经测试,欢迎使用批处理脚本):

dir * /s/b | findstr __pycache__ | attrib +h +s +r

这与使用右键单击>隐藏…浏览项目隐藏文件夹相同。


运行单元测试是一种方案(在注释中更多),在该方案中删除*.pyc文件和__pycache__文件夹确实很有用。我在我的代码中使用以下几行,~/.bash_profilecl在需要时进行清理。

alias cpy='find . -name "__pycache__" -delete'
alias cpc='find . -name "*.pyc"       -delete'
...
alias cl='cpy && cpc && ...'

__pycache__ is a folder containing Python 3 bytecode compiled and ready to be executed.

I don’t recommend routinely deleting these files or suppressing creation during development as it may hurt performance. Just have a recursive command ready (see below) to clean up when needed as bytecode can become stale in edge cases (see comments).

Python programmers usually ignore bytecode. Indeed __pycache__ and *.pyc are common lines to see in .gitignore files. Bytecode is not meant for distribution and can be disassembled using dis module.


If you are using OS X you can easily hide all of these folders in your project by running following command from the root folder of your project.

find . -name '__pycache__' -exec chflags hidden {} \;

Replace __pycache__ with *.pyc for Python 2.

This sets a flag on all those directories (.pyc files) telling Finder/Textmate 2 to exclude them from listings. Importantly the bytecode is there, it’s just hidden.

Rerun the command if you create new modules and wish to hide new bytecode or if you delete the hidden bytecode files.


On Windows the equivalent command might be (not tested, batch script welcome):

dir * /s/b | findstr __pycache__ | attrib +h +s +r

Which is same as going through the project hiding folders using right-click > hide…


Running unit tests is one scenario (more in comments) where deleting the *.pyc files and __pycache__ folders is indeed useful. I use the following lines in my ~/.bash_profile and just run cl to clean up when needed.

alias cpy='find . -name "__pycache__" -delete'
alias cpc='find . -name "*.pyc"       -delete'
...
alias cl='cpy && cpc && ...'

回答 2

__pycache__使用以下行时将创建一个文件夹:

import file_name

或尝试从您创建的另一个文件中获取信息。这使得第二次运行程序打开另一个文件时速度更快。

A __pycache__ folder is created when you use the line:

import file_name

or try to get information from another file you have created. This makes it a little faster when running your program the second time to open the other file.


回答 3

更新了3.7+文档中的答案:

为了加快模块的加载速度,Python将每个模块的编译版本都缓存在__pycache__名称下的 目录中module.version.pyc,该版本对编译文件的格式进行编码;它通常包含Python版本号。例如,在CPython版本3.3中,spam.py的编译版本将被缓存为__pycache__/spam.cpython-33.pyc。此命名约定允许来自不同发行版和不同版本的Python的编译模块共存。

来源:https : //docs.python.org/3/tutorial/modules.html#compiled-python-files

也就是说,该目录由Python生成,并且存在以使您的程序运行更快。它不应致力于源代码控制,而应与本地源代码共存。


__pycache__是一个目录,其中包含由python自动生成的字节码缓存文件,即已编译的python或.pyc文件。您可能想知道为什么Python(一种“解释”语言)根本没有任何编译文件。这个SO问题解决了这个问题(绝对值得阅读此答案)。

python文档更深入地介绍了它的确切工作方式及其存在的原因:

  • 它是在python 3.2中添加的,因为现有的将.pyc文件保存在同一目录中的系统会引起各种问题,例如,使用不同版本的Python解释器运行程序时。有关完整功能的规范,请参阅PEP 3174

Updated answer from 3.7+ docs:

To speed up loading modules, Python caches the compiled version of each module in the __pycache__ directory under the name module.version.pyc, where the version encodes the format of the compiled file; it generally contains the Python version number. For example, in CPython release 3.3 the compiled version of spam.py would be cached as __pycache__/spam.cpython-33.pyc. This naming convention allows compiled modules from different releases and different versions of Python to coexist.

Source: https://docs.python.org/3/tutorial/modules.html#compiled-python-files

That is, this directory is generated by Python and exists to make your programs run faster. It shouldn’t be committed to source control, and should coexist in peace with your local source code.


__pycache__ is a directory that contains bytecode cache files that are automatically generated by python, namely compiled python, or .pyc, files. You might be wondering why Python, an “interpreted” language, has any compiled files at all. This SO question addresses that (and it’s definitely worth reading this answer).

The python docs go into more depth about exactly how it works and why it exists:

  • It was added in python 3.2 because the existing system of maintaining .pyc files in the same directory caused various problems, such as when a program was run with Python interpreters of different versions. For the full feature spec, see PEP 3174.

回答 4

来自官方python教程模块

为了加快模块的加载速度,Python将每个模块的编译版本都缓存在__pycache__名称下的目录中module.version.pyc,该版本对编译文件的格式进行编码;它通常包含Python版本号。例如,在CPython版本3.6中,spam.py的编译版本将被缓存为__pycache__/spam.cpython-36.pyc

来自Python doc 编程常见问题解答

首次导入模块时(或自创建当前编译文件以来源文件已更改),应在__pycache__包含该.py文件的目录的子目录中创建一个包含编译代码的.pyc 文件。该.pyc文件的文件名以与该.py文件相同的名称开头,以结尾.pyc,其中间部分取决于创建该文件的特定python二进制文件。

from the official python tutorial Modules

To speed up loading modules, Python caches the compiled version of each module in the __pycache__ directory under the name module.version.pyc, where the version encodes the format of the compiled file; it generally contains the Python version number. For example, in CPython release 3.6 the compiled version of spam.py would be cached as __pycache__/spam.cpython-36.pyc.

from Python doc Programming FAQs

When a module is imported for the first time (or when the source file has changed since the current compiled file was created) a .pyc file containing the compiled code should be created in a __pycache__ subdirectory of the directory containing the .py file. The .pyc file will have a filename that starts with the same name as the .py file, and ends with .pyc, with a middle component that depends on the particular python binary that created it.


回答 5

执行python脚本将导致字节码在内存中生成并保留直到程序关闭。如果导入了模块,则为了提高重用性,Python会创建一个缓存.pyc(PYC是“ Python”“已编译”)文件,其中将要导入的模块的字节码存储在该文件中。想法是通过避免重新导入时避免重新编译(一次编译,多次运行策略)来加快python模块的加载。

文件名与模块名相同。起始点后面的部分表示创建缓存的Python实现(可以是CPython),其后是版本号。

Execution of a python script would cause the byte code to be generated in memory and kept until the program is shutdown. In case a module is imported, for faster reusability, Python would create a cache .pyc (PYC is ‘Python’ ‘Compiled’) file where the byte code of the module being imported is cached. Idea is to speed up loading of python modules by avoiding re-compilation ( compile once, run multiple times policy ) when they are re-imported.

The name of the file is the same as the module name. The part after the initial dot indicates Python implementation that created the cache (could be CPython) followed by its version number.


回答 6

python解释器编译* .py脚本文件,并将编译结果保存到__pycache__目录中。

当再次执行该项目时,如果解释器识别出* .py脚本尚未被修改,则它将跳过编译步骤并运行存储在该__pycache__文件夹中的先前生成的* .pyc文件。

当项目很复杂时,您可以缩短项目运行的准备时间。如果程序太小,则可以通过python -B abc.pyB选项一起使用来忽略它。

The python interpreter compiles the *.py script file and saves the results of the compilation to the __pycache__ directory.

When the project is executed again, if the interpreter identifies that the *.py script has not been modified, it skips the compile step and runs the previously generated *.pyc file stored in the __pycache__ folder.

When the project is complex, you can make the preparation time before the project is run shorter. If the program is too small, you can ignore that by using python -B abc.py with the B option.


回答 7

解释器编译代码时,Python版本2.x将具有.pyc

当解释器编译代码时,Python版本3.x将具有__pycache__

alok@alok:~$ ls
module.py  module.pyc  __pycache__  test.py
alok@alok:~$

Python Version 2.x will have .pyc when interpreter compiles the code.

Python Version 3.x will have __pycache__ when interpreter compiles the code.

alok@alok:~$ ls
module.py  module.pyc  __pycache__  test.py
alok@alok:~$

回答 8

在3.2及更高版本中,Python将.pyc编译后的字节代码文件保存在一个子目录__pycache__中,该子目录位于源文件所在的目录中,该目录中带有标识创建它们的Python版本的文件名(例如script.cpython-33.pyc)。

In 3.2 and later, Python saves .pyc compiled byte code files in a sub-directory named __pycache__ located in the directory where your source files reside with filenames that identify the Python version that created them (e.g. script.cpython-33.pyc)


回答 9

当您导入模块

import file_name

Python将已编译的字节码存储在__pycache__目录中,以便将来的导入可以直接使用它,而不必再次解析和编译源代码。

仅导入文件时,它不会仅运行脚本就这样做。

(以前的版本用于将缓存的字节码存储为.pyc文件,这些文件与.py文件位于同一目录中,但是从Python 3开始,它们被移到了一个子目录以使内容变得整洁。)

PYTHONDONTWRITEBYTECODE —>如果将其设置为非空字符串,Python将不会尝试在源模块的导入中写入.pyc文件。这等效于指定-B选项。

When you import a module,

import file_name

Python stores the compiled bytecode in __pycache__ directory so that future imports can use it directly, rather than having to parse and compile the source again.

It does not do that for merely running a script, only when a file is imported.

(Previous versions used to store the cached bytecode as .pyc files that littered up the same directory as the .py files, but starting in Python 3 they were moved to a subdirectory to make things tidier.)

PYTHONDONTWRITEBYTECODE —> If this is set to a non-empty string, Python won’t try to write .pyc files on the import of source modules. This is equivalent to specifying the -B option.