Wat is __pycache__?

Voor zover ik heb begrepen, is een cache een versleuteld bestand met vergelijkbare bestanden.

Wat doen we met de map __pycache__? Is het wat we aan mensen geven in plaats van onze broncode? Zijn het alleen mijn invoergegevens? Deze map wordt steeds aangemaakt, waar dient deze voor?

Antwoord 1, autoriteit 100%

Als je een programma in python uitvoert, compileert de interpreter het eerst naar bytecode (dit is een te grote vereenvoudiging) en slaat het op in de map __pycache__. Als je daar kijkt, zul je een heleboel bestanden vinden die de namen van de .py-bestanden in de map van je project delen, alleen hun extensies zullen .pyc of .pyo zijn. Dit zijn respectievelijk bytecode-gecompileerde en geoptimaliseerde bytecode-gecompileerde versies van de bestanden van uw programma.

Als programmeur kun je het grotendeels negeren… Het enige wat het doet is je programma een beetje sneller laten starten. Wanneer uw scripts veranderen, worden ze opnieuw gecompileerd en als u de bestanden of de hele map verwijdert en uw programma opnieuw uitvoert, verschijnen ze opnieuw (tenzij u dat gedrag specifiek onderdrukt).

Als je je code naar andere mensen stuurt, is het gebruikelijk om die map te verwijderen, maar het maakt niet echt uit of je dat doet of niet. Als je versiebeheer (git) gebruikt, wordt deze map meestal vermeld in het negeerbestand (.gitignore) en dus niet opgenomen.

Als u cpython gebruikt (wat het meest gebruikelijk is, omdat het de referentie-implementatie is) en u wilt die map niet, dan kunt u deze onderdrukken door bijvoorbeeld de interpreter te starten met de vlag -B

python -B foo.py

Een andere optie, zoals opgemerkt door tcaswell, is om de omgevingsvariabele PYTHONDONTWRITEBYTECODEin te stellen op een willekeurige waarde (volgens de man-pagina van Python, elke “niet-lege tekenreeks”).

Antwoord 2, autoriteit 30%

__pycache__is een map met Python 3-bytecode gecompileerd en klaar om te worden uitgevoerd.

Ik raad niet aan om deze bestanden routinematig moeizaam te verwijderen of het maken ervan te onderdrukken tijdens de ontwikkeling, omdat het je tijd verspilt. Houd gewoon een recursief commando bij de hand (zie hieronder) om op te ruimen wanneer dat nodig is, aangezien bytecode in randgevallen oud kan worden (zie opmerkingen).

Python-programmeurs negeren bytecode meestal. Inderdaad zijn __pycache__en *.pycveelvoorkomende regels om te zien in .gitignore-bestanden. Bytecode is niet bedoeld voor distributie en kan worden gedemonteerd met behulp van de dismodule.

Als u OS X gebruikt, kunt u gemakkelijk al deze mappen in uw project verbergen door het volgende commando uit te voeren vanuit de hoofdmap van uw project.

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

Vervang __pycache__door *.pycvoor Python 2.

Dit stelt een vlag in op al die mappen (.pyc-bestanden) die Finder/Textmate 2 vertellen om ze uit te sluiten van lijsten. Belangrijk is dat de bytecode er is, deze is alleen verborgen.

Voer de opdracht opnieuw uit als u nieuwe modules maakt en nieuwe bytecode wilt verbergen of als u de verborgen bytecode-bestanden verwijdert.

In Windows kan het equivalente commando zijn (niet getest, batchscript welkom):

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

Dit is hetzelfde als door de mappen voor het verbergen van het project gaan met de rechtermuisknop op > verberg…

Het uitvoeren van unit-tests is een scenario (meer in opmerkingen) waarbij het verwijderen van de *.pyc-bestanden en __pycache__-mappen inderdaad nuttig is. Ik gebruik de volgende regels in mijn ~/.bash_profileen voer gewoon cluit om op te schonen wanneer dat nodig is.

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

en meer de laatste tijd

# pip install pyclean
pyclean .

Antwoord 3, autoriteit 8%

Er wordt een map __pycache__gemaakt wanneer u de regel gebruikt:

import file_name

of probeer informatie op te halen uit een ander bestand dat je hebt gemaakt. Dit maakt het een beetje sneller wanneer je je programma voor de tweede keer uitvoert om het andere bestand te openen.

4

Vanaf de officiële Python-tutorial modules

Om het laden van modules te versnellen, slaat Python de gecompileerde versie van elke module op in de __pycache__directory onder de naam module.version.pyc, waar de versie het formaat codeert van het gecompileerde bestand; het bevat over het algemeen het versienummer van Python. In CPython release 3.6 zou de gecompileerde versie van spam.py bijvoorbeeld in de cache worden opgeslagen als __pycache__/spam.cpython-36.pyc.

uit Python-document Veelgestelde vragen over programmeren

Wanneer een module voor de eerste keer wordt geïmporteerd (of wanneer het bronbestand is gewijzigd sinds het huidige gecompileerde bestand is gemaakt), moet een .pyc-bestand met de gecompileerde code worden gemaakt in een submap __pycache__van de map die het bestand .pybevat. Het bestand .pycheeft een bestandsnaam die begint met dezelfde naam als het bestand .pyen eindigt met .pyc, met een middelste component die afhangt van het specifieke python-binaire bestand dat het heeft gemaakt.

Antwoord 5

Als u een module importeert,

import file_name

Python slaat de gecompileerde bytecode op in de map __pycache__zodat toekomstige imports deze direct kunnen gebruiken, in plaats van de broncode opnieuw te moeten ontleden en compileren.

Het doet dat niet alleen voor het uitvoeren van een script, alleen wanneer een bestand wordt geïmporteerd.

(Vorige versies werden gebruikt om de bytecode in de cache op te slaan als .pyc-bestanden die in dezelfde map stonden als de .py-bestanden, maar vanaf Python 3 werden ze verplaatst naar een submap om de zaken overzichtelijker te maken.)

PythondontwwritebyTecode — & GT; Als dit is ingesteld op een niet-lege string, probeert Python niet te schrijven. PYC-bestanden over de invoer van bronmodules. Dit is gelijk aan het opgeven van de optie -B.

6

Uitvoering van een python-script zou ervoor zorgen dat de bytecode in het geheugen wordt gegenereerd en wordt bewaard totdat het programma wordt afgesloten.
In het geval dat een module wordt geïmporteerd, voor snellere herbruikbaarheid, zou Python een cache-.pyc maken (PYC is ‘Python’ ‘gecompileerd’) -bestand waarbij de bytecode van de geïmporteerde module in de cache is opgeslagen.
Idee is om het laden van Python-modules te versnellen door hercompilatie te vermijden (eenmaal compileren, meerdere keren beleid uitvoeren) wanneer ze opnieuw worden geïmporteerd.

De naam van het bestand is hetzelfde als de naam van de module. Het deel nadat de initiële punt aangeeft dat Python-implementatie die de cache heeft gemaakt (kan CPYTHON), gevolgd door zijn versienummer.

7

De Python-tolk compileert het * .Y-scriptbestand en slaat de resultaten op van de compilatie op de __pycache__Directory.

Wanneer het project opnieuw wordt uitgevoerd, als de tolk identificeert dat het * .py-script niet is gewijzigd, slaat het de compilatiestap over en voert het eerder gegenereerde *. PYC-bestand op dat is opgeslagen in de __pycache__map.

Wanneer het project complex is, kunt u de voorbereidingstijd maken voordat het project korter is. Als het programma te klein is, kunt u dat negeren met behulp van python -B abc.pymet de optie B.

8

Python-versie 2.X heeft .pyc wanneer de interpreter de code compileert.

Python-versie 3.x heeft __ pycache __ wanneer de interpreter de code compileert.

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