Как очистить кэш питона

Обновлено: 06.07.2024

Пока читаю документацию по Python re Модуль я решил посмотреть на re.py исходный код.

Когда я открыл его, я нашел это:

Почему кеш очищается с помощью _cache.clear() когда он достигает _MAXCACHE записей?

Является ли обычным подходом полностью очистить кеш и начать все с нуля?

Почему просто не использовалось самое долгое время назад обналиченное значение удаляется?

3 ответа

Если бы мне пришлось угадывать, я бы сказал, что это было сделано таким образом, чтобы избежать необходимости отслеживать, когда и как долго отдельные значения были сохранены в кэше, что создаст как память, так и нагрузку на обработку. Поскольку используемый объект кэширования - это словарь, который по своей природе неупорядочен, нет никакого хорошего способа узнать, какие элементы порядка были добавлены к нему без какого-либо другого объекта кэширования. Эту проблему можно решить с помощью OrderedDict вместо стандартного словаря, предполагая, что вы работаете с Python >= 2.7, но в противном случае вам потребуется значительно изменить дизайн кэширования, чтобы исключить необходимость clear() ,

Вот цитата одного из разработчиков нового regex Модуль запланирован на 3.3 в отношении кэширования, это часть списка функций, который отделяет новый модуль от текущего re модуль.

7) Измените скомпилированный кэш выражений, чтобы лучше справляться с условиями обмолота. В настоящее время, когда регулярные выражения компилируются, результат кэшируется так, что, если то же самое выражение компилируется снова, оно извлекается из кэша и никакой дополнительной работы не требуется. Этот кеш поддерживает до 100 записей. По достижении 100-й записи кэш очищается и должна произойти новая компиляция. Опасность, пусть и редкая, состоит в том, что можно скомпилировать сотое выражение только для того, чтобы обнаружить, что он перекомпилирует его и должен выполнить ту же самую работу снова, когда это могло быть сделано 3 выражения назад. Слегка изменив эту логику, можно установить произвольный счетчик, который присваивает метку времени каждой скомпилированной записи, и вместо очистки всего кэша, когда он достигает емкости, удаляется только самая старая половина кэша, сохраняя половину, которая больше недавно. Это должно ограничить возможность перебора в случаях, когда очень большое количество регулярных выражений постоянно перекомпилируется. В дополнение к этому я обновлю ограничение до 256 записей, что означает, что 128 последних сохранены.

Похоже, это указывает на то, что лень разработчика или "акцент на удобочитаемости" объясняет текущее поведение кэширования.

Смысл кэширования - уменьшить среднее время вызова функции. Накладные расходы, связанные с хранением дополнительной информации в _cache и сокращение его вместо очистки увеличило бы это среднее время вызова. _cache.clear() вызов завершится быстро, и даже если вы потеряете кеш, это предпочтительнее, чем поддерживать состояние кеша и иметь дополнительные издержки на удаление отдельных элементов из кеша при достижении предела.

При расчете эффективности кэширования следует учитывать несколько моментов:

Среднее время вызова при попадании в кэш (очень короткое)
Среднее время звонка при отсутствии кеша (дольше)
Частота попаданий в кэш (довольно редко)
Время вызова, когда кэш очищается или удаляется (довольно редко)

Есть много способов сделать приложения быстрыми. Кэширование — это один из подходов, который при правильном использовании значительно ускоряет работу и снижает нагрузку на вычислительные ресурсы. Модуль Python functools поставляется с декоратором @lru_cache, который позволяет кэшировать результаты выполнения ваших функций, используя стратегию Least Recently Used (LRU). Это простой, но мощный метод, который вы можете использовать, чтобы использовать возможности кэширования в вашем коде.

В этом уроке вы узнаете:

Какие стратегии кеширования доступны и как их реализовать с помощью декораторов Python.
Что такое стратегия LRU и как она работает.
Как повысить производительность за счет кеширования с помощью декоратора @lru_cache .
Как расширить функциональность декоратора @lru_cache и сделать так, чтобы срок его действия истек через определенное время.

К концу этого урока вы получите более глубокое понимание того, как работает кеширование и как использовать его преимущества в Python.

Что такое кэширование и как его использовать

Кэширование — это метод оптимизации, который вы можете использовать в своих приложениях, чтобы хранить недавние или часто используемые данные в тех местах памяти, которые быстрее или дешевле с точки зрения вычислений, чем их источник.

Что произойдет, если пользователь решит многократно перемещаться между парой новостных статей? Если вы не кэшировали данные, ваше приложение должно будет каждый раз получать одно и то же содержимое! Это сделает систему вашего пользователя вялой и создаст дополнительную нагрузку на сервер, на котором размещены статьи.

Лучшим подходом было бы хранить контент локально после получения каждой статьи. Затем, когда пользователь в следующий раз решит открыть статью, ваше приложение может открывать контент из локально сохраненной копии вместо того, чтобы возвращаться к источнику. В информатике этот метод называется кэшированием.

Реализация кеша с использованием словаря Python

Вы можете реализовать решение для кеширования в Python, используя словарь.

Оставаясь с примером программы чтения новостей, вместо того, чтобы обращаться непосредственно к серверу каждый раз, когда вам нужно загрузить статью, вы можете проверить, есть ли у вас контент в кэше, и вернуться на сервер только в том случае, если вы этого не сделаете.Вы можете использовать URL статьи в качестве ключа, а ее содержание — в качестве значения.

Вот пример того, как может выглядеть этот метод кеширования:

Сохраните этот код в файле caching.py, установите библиотеку запросов и запустите скрипт:

Стратегии кеширования

Есть одна большая проблема с этой реализацией кеширования: содержимое словаря будет неограниченно расти! По мере того, как пользователь загружает больше статей, приложение будет сохранять их в памяти, что в конечном итоге приведет к сбою приложения.

Чтобы обойти эту проблему, нужна стратегия, которая позволит понять, какие статьи должны оставаться в памяти, а какие — удаляться. Эти стратегии кэширования представляют собой алгоритмы, которые сосредоточены на управлении кэшированной информацией и выборе элементов, которые следует удалить, чтобы освободить место для новых. Существует несколько различных стратегий, которые можно использовать для удаления элементов из кеша и предотвращения его превышения максимального размера. Вот пять самых популярных из них с объяснением, когда каждый из них наиболее полезен:

Новые записи, скорее всего, будут использованы повторно Более старые записи, скорее всего, будут использованы повторно Недавно использованные записи, скорее всего, будут использованы повторно Наиболее вероятно, что будут повторно использованы наименее используемые записи Записи с большим количеством совпадений с большей вероятностью будут использоваться повторно

В следующих разделах вы более подробно рассмотрите стратегию LRU и то, как ее реализовать с помощью декоратора @lru_cache из модуля functools.

Стратегия кэширования недавно использованного (LRU)

Кэш, реализованный с использованием стратегии LRU, упорядочивает свои элементы в порядке использования. Каждый раз, когда вы обращаетесь к записи, алгоритм LRU перемещает ее в верхнюю часть кеша. Таким образом, алгоритм может быстро определить запись, которая дольше всех не использовалась, посмотрев на конец списка. На следующем рисунке показано гипотетическое представление кеша после того, как ваш пользователь запросит статью из сети:

Обратите внимание, как кеш хранит статью в самом последнем слоте перед тем, как передать ее пользователю. На следующем рисунке показано, что происходит, когда пользователь запрашивает вторую статью:

Вторая статья занимает самый последний слот, перемещая первую статью вниз по списку.

Стратегия LRU предполагает, что чем позже использовался объект, тем больше вероятность, что он понадобится в будущем, поэтому она пытается сохранить этот объект в кэше в течение максимально длительного времени.

Заглянем за кулисы кэша LRU

Один из способов реализовать кеш LRU в Python — использовать комбинацию двусвязного списка и хэш-карты. Элемент головы двусвязного списка будет указывать на последнюю использованную запись, а хвост будет указывать на наименее недавно использованную запись. На рисунке ниже показана потенциальная структура реализации кэша LRU за кулисами:

Используя хэш-карту, вы можете обеспечить доступ к каждому элементу в кэше, сопоставив каждую запись с определенным местом в двусвязном списке.

Эта стратегия очень быстрая. Доступ к наименее недавно использовавшемуся элементу и обновление кеша — это операции со временем выполнения O(1).

Начиная с версии 3.2, Python включает декоратор @lru_cache для реализации стратегии LRU. Вы можете использовать этот декоратор, чтобы обернуть функции и кэшировать их результаты до максимального количества записей.

Использование @lru_cache для реализации кэша LRU в Python

Как и решение для кеширования, которое вы реализовали ранее, @lru_cache использует словарь за кулисами. Он кэширует результат функции под ключом, который состоит из вызова функции, включая предоставленные аргументы. Это важно и означает, что для того, чтобы декоратор работал, аргументы должны быть хешируемыми.

Игра с лестницей

Представьте, что вы хотите определить все способы, которыми вы можете добраться до определенной ступени на лестнице, перепрыгивая через одну, две или три ступени за раз. Сколько способов приводят к четвертой ступеньке? Вот все разные комбинации:

Вы можете сформулировать решение этой проблемы, заявив, что для достижения текущей ступеньки вы можете прыгнуть с одной, двух или трех ступеней ниже. Суммирование количества комбинаций прыжков, которые вы можете использовать для достижения каждой из этих точек, должно дать вам общее количество возможных способов достижения вашей текущей позиции.

Например, количество комбинаций до четвертой ступени будет равно общему количеству различных способов, которыми вы можете добраться до третьей, второй и первой ступеньки:

Как показано на рисунке, есть семь разных способов добраться до четвертой ступени. Обратите внимание, как решение для заданной лестницы основывается на ответах для более мелких подзадач. В этом случае, чтобы определить различные пути к четвертой ступеньке, вы можете сложить три способа достижения третьей ступени, два способа достижения второй ступени и один способ добраться до первой ступеньки.

Такой подход называется рекурсией. Если вы хотите узнать больше, ознакомьтесь с разделом «Рекурсивное мышление в Python».

Вот функция, реализующая эту рекурсию:

Сохраните этот код в файл с именем stairs.py и запустите его с помощью следующей команды:

Великолепно! Код работает для 4 ступенек, но если ступенек будет больше? Измените количество ступенек в строке 33 на 30 и перезапустите скрипт:

Ух ты, более 53 миллионов комбинаций! Можно с ума сойти!

Время исполнения кода

Когда мы искали решение для тридцатой ступеньки, сценарий выполнялся довольно долго. Чтобы получить базовый план, вы можете измерить, сколько времени требуется для выполнения кода.

Для этого вы можете использовать модуль Python timeit. Добавьте следующие строки после строки 33 —

Вам также необходимо импортировать модуль timeit в начале кода:

Вот построчное объяснение этих дополнений:

Строка 1 импортирует имя steps_to() , чтобы timeit.repeat() знал, как его вызвать.
Строка 2 подготавливает вызов функции с номером лестницы, который вы хотите достичь, который в данном случае равен 30. Это оператор, который будет выполнен и рассчитан по времени.
Линия 3 звонит timeit.repeat() с кодом настройки и оператором. Это вызовет функцию 10 раз, возвращая количество секунд, которое заняло каждое выполнение.
Строка 4 определяет и печатает самое короткое возвращенное время.

Примечание. Распространенное заблуждение состоит в том, что вы должны найти среднее время каждого запуска функции, а не выбирать самое короткое время.

Измерения времени зашумлены, потому что система одновременно выполняет другие процессы. Самое короткое время всегда наименее шумно, что делает его наилучшим представлением времени выполнения функции.

Теперь снова запустим скрипт:

Количество секунд, которое вы увидите, зависит от вашего конкретного оборудования. В моей системе сценарий занял сорок секунд, что довольно медленно для всего тридцати ступенек!

Решение, на которое уходит так много времени, представляет собой проблему, но вы можете улучшить ее с помощью мемоизации.

Мемоизация для улучшения решения

Рекурсивная реализация решает проблему, разбивая ее на более мелкие шаги, которые дополняют друг друга. На следующем рисунке показано дерево, в котором каждый узел представляет определенный вызов steps_to() :

Обратите внимание, что вам нужно вызывать steps_to() с одним и тем же аргументом несколько раз. Например, steps_to(5) вычисляется два раза, steps_to(4) вычисляется четыре раза, steps_to(3) семь раз и steps_to(2) шесть раз. Вызов одной и той же функции несколько раз добавляет циклы вычислений, в которых нет необходимости — результат всегда будет одним и тем же. Чтобы решить эту проблему, вы можете использовать метод, называемый мемоизацией. Такой подход гарантирует, что функция не запускается для одних и тех же входных данных более одного раза, сохраняя ее результат в памяти, а затем ссылаясь на него позже, когда это необходимо. Этот сценарий звучит как прекрасная возможность использовать декоратор Python @lru_cache !

Примечание. Дополнительная информация о мемоизации и использовании @lru_cache для ее реализации в «Мемоизация в Python».

С помощью всего двух изменений вы можете значительно улучшить время работы алгоритма:

Импортируйте декоратор @lru_cache из модуля functools .
Используйте @lru_cache для украшения steps_to() .

Вот как будет выглядеть верхняя часть скрипта с двумя обновлениями:

Запуск обновленного скрипта дает следующий результат:

В результате кеширование время выполнения функции с 40 секунд уменьшилось до 0,0008 миллисекунд! Это фантастическое улучшение!

Примечание. В Python 3.8 и более поздних версиях вы можете использовать декоратор @lru_cache без скобок, если вы не указываете никаких параметров. В предыдущих версиях вам может потребоваться включить круглые скобки: @lru_cache() .

Помните, что за кулисами декоратор @lru_cache для каждого отдельного ввода сохраняет результат steps_to() . Каждый раз, когда код вызывает функцию с теми же параметрами, вместо того, чтобы заново вычислять ответ, он возвращает правильный результат прямо из памяти. Это объясняет значительное улучшение производительности при использовании @lru_cache .

Распаковка функциональности @lru_cache

С помощью декоратора @lru_cache вы сохраняете каждый вызов и ответ в памяти, чтобы получить к ним доступ позже, если потребуется снова. Но сколько вызовов вы можете сохранить, прежде чем иссякнет память?

Декоратор Python @lru_cache предлагает атрибут maxsize , который определяет максимальное количество записей до того, как кеш начнет удалять старые элементы. По умолчанию, maxsize установлен на 128. Если вы установите maxsize на None , то кеш будет расти бесконечно, и никакие записи не будут удалены. Это может стать проблемой, если вы храните в памяти большое количество различных вызовов.

Вот пример @lru_cache с использованием атрибута maxsize:

В этом случае вы ограничиваете кеш до 16 записей. Когда поступает новый вызов, реализация декоратора вытесняет наименее недавно использовавшуюся из существующих 16 записей, чтобы освободить место для нового элемента.

Чтобы увидеть, что происходит с этим новым дополнением к коду, вы можете использовать cache_info() , предоставляемый декоратором @lru_cache , для проверки количества попаданий и промахов и текущего размера кеша. Для наглядности удалите код, который определяет время выполнения функции. Вот как выглядит окончательный сценарий после всех изменений:

Если вы вызовете скрипт еще раз, то увидите следующий результат:

Вы можете использовать информацию, возвращаемую cache_info() , чтобы понять, как работает кеш, и настроить его, чтобы найти подходящий баланс между скоростью и объемом памяти.

Вот разбивка свойств, предоставляемых cache_info() :

hits = 52 — это количество вызовов, которые @lru_cache вернул непосредственно из памяти, поскольку они существовали в кеше.
misses = 30 — это количество вызовов, которые не поступили из памяти и были рассчитаны. Поскольку вы пытаетесь найти количество шагов, чтобы достичь тридцатой ступени, имеет смысл, что каждый из этих вызовов пропускал кэш при первом выполнении.
maxsize = 16 — это размер кеша, который вы определили с помощью атрибута maxsize декоратора.
currsize = 16 — текущий размер кеша. В этом случае это показывает, что ваш кеш заполнен.

Если вам нужно удалить все записи из кеша, вы можете использовать cache_clear() , предоставленный @lru_cache .

Добавление срока действия кеша

Сохраните этот сценарий в файл с именем monitor.py, установите анализатор каналов и библиотеки запросов и запустите сценарий. Он будет работать непрерывно, пока вы не остановите его, нажав Ctrl + C в окне терминала:

Вот пошаговое объяснение кода:

Это отличная возможность кэшировать содержание статьи и избегать попадания в сеть каждые пять секунд. Вы можете использовать декоратор @lru_cache , но что произойдет, если содержание статьи обновится?

Удаление записей кэша на основе времени и пространства

Декоратор @lru_cache удаляет существующие записи только тогда, когда больше нет места для хранения новых списков. При наличии достаточного места записи в кеше будут жить вечно и никогда не будут обновляться.

Это создает проблему для вашего сценария мониторинга, поскольку вы никогда не получите обновления, опубликованные для ранее сохраненных в кэше статей. Чтобы обойти эту проблему,вы можете обновить реализацию кеша, чтобы срок его действия истек через определенное время.

Вы можете реализовать эту идею в новом декораторе, который расширяет @lru_cache . Если вызывающий пытается получить доступ к элементу, срок действия которого истек, кеш не вернет его содержимое, вынуждая вызывающего абонента получить статью из сети.

Вот возможная реализация этого нового декоратора:

Вот разбивка этой реализации:

Строка 4 — Декоратор @timed_lru_cache будет поддерживать время жизни записей в кеше (в секундах) и максимальный размер кеша.
Строка 6: Код завершает декорированную функцию декоратором lru_cache . Это позволяет вам использовать функциональность кеширования, уже предоставленную lru_cache .
Строки 7 и 8 — Эти две строки инструментируют декорированную функцию с двумя атрибутами, представляющими время жизни кеша и фактическую дату истечения срока его действия.
Строки с 12 по 14 — Перед доступом к записи в кэше декоратор проверяет, не истекла ли текущая дата по истечении срока действия. Если это так,затем он очищает кеш и повторно вычисляет время жизни и дату истечения срока действия.

Обратите внимание на то, как по истечении срока действия записи этот декоратор очищает весь кеш, связанный с функцией. Время жизни распространяется на кеш в целом, а не на отдельные статьи. Более сложная реализация этой стратегии приведет к удалению записей на основе их индивидуального времени жизни.

Кэширование статей с помощью нового декоратора

Теперь вы можете использовать свой новый декоратор @timed_lru_cache со сценарием монитора, чтобы предотвратить получение содержимого статьи при каждом доступе к ней.

Собрав для простоты код в один сценарий, вы получите следующее:

Обратите внимание, как строка 30 украшает get_article_from_server() с помощью @timed_lru_cache и указывает срок действия 10 секунд. Любая попытка получить доступ к той же статье с сервера в течение 10 секунд после ее загрузки вернет содержимое из кеша и никогда не попадет в сеть.

Запустите скрипт и посмотрите на результат:

Заключение

Кэширование — это важный метод оптимизации для повышения производительности любой программной системы. Понимание того, как работает кэширование, является фундаментальным шагом на пути к его эффективному включению в ваши приложения.

В этом уроке вы узнали:

Что такое разные стратегии кеширования и как они работают.
Как использовать декоратор @lru_cache в Python.
Как создать новый декоратор для расширения функциональности @lru_cache .
Как измерить время выполнения вашего кода с помощью модуля timeit .
Что такое рекурсия и как с ее помощью решить задачу.

Как мемоизация улучшает время выполнения, сохраняя промежуточные результаты в памяти. Следующим шагом к реализации различных стратегий кэширования в ваших приложениях является просмотр модуля cachetools . Эта библиотека предоставляет несколько коллекций и декораторов, охватывающих некоторые из самых популярных стратегий кэширования, которые вы можете сразу начать использовать.

при чтении документации на Python re модуль я решил посмотреть на re.py исходный код.

когда я открыл его, я нашел это:

почему кэш очищается с помощью _cache.clear() когда он достигает _MAXCACHE записей?

это общий подход, чтобы очистить кэш полностью и начать с нуля?

почему просто не используется самое долгое время назад обналиченное значение удаляется?

если бы мне пришлось угадать, я бы сказал, что это было сделано таким образом, чтобы избежать необходимости отслеживать, когда / как долго отдельные значения хранились в кэше, что создало бы как память, так и обработку накладных расходов. Поскольку используемый объект кэширования является словарем, который по своей сути неупорядочен, нет хорошего способа узнать, какие элементы порядка были добавлены к нему без какого-либо другого объекта кэширования. Это можно решить с помощью OrderedDict вместо стандартного словаря, предполагая, что вы работаете с Python >= 2.7, но в противном случае вам нужно будет значительно изменить способ кэширования, чтобы устранить необходимость в clear() .

вот цитата от одного из разработчиков нового regex модуль, запланированный на 3.3 что касается кэширования, это часть списка функций, которые отделяют новый модуль от текущего re модуль.

7) измените повторно скомпилированный кэш выражений, чтобы лучше обрабатывать состояние трепки. В настоящее время при компиляции регулярных выражений, результат кэшируется так, что если то же выражение компилируется снова, он извлекается из кэша и нет нужно проделать дополнительную работу. Этот кэш поддерживает до 100 записей. Как только 100-я запись будет достигнута, кэш очищается, и должна произойти новая компиляция. Опасность, всем быть редко, что можно скомпилировать 100-е выражение только для того, чтобы найти это перекомпилирует его и делать ту же работу снова и снова, когда он может было сделано 3 выражения назад. В слегка измененном виде это логика, это можно установить произвольный счетчик, который дает отметку времени каждая составлена запись и вместо того, чтобы очистить весь кэш, когда он достигает емкости, только исключает самую старую половину кэша, держа та половина, что более свежая. Это должно ограничить возможность thrashing к случаям, когда очень большое количество регулярных выражений постоянно перекомпилируется. В дополнение к этому, я обновлю лимит до 256 записей, что означает, что 128 последних сохраняются.

этот кажется, указывает на то, что это, скорее всего, лень разработчика или "акцент на читаемость", который объясняет текущее поведение кэширования.

точка кэширования заключается в уменьшении среднего времени вызова функции. Накладные расходы, связанные с хранением дополнительной информации в _cache и обрезка его вместо очистки увеличит среднее время вызова. The _cache.clear() вызов будет завершен быстро, и даже если вы потеряете кэш, это предпочтительнее, чем поддерживать состояние кэша и иметь накладные расходы на удаление отдельных элементов из кэша при достижении предела.

есть несколько вещей, чтобы подумайте о При расчете эффективности кэша:

среднее время вызова на кэш-хитах (очень короткое)
среднее время вызова на промахи кэша (больше)
частота попадания в кэш (довольно редко)
время вызова, когда кэш очищается или обрезается (довольно редко)

Мне нужно установить psycopg2 v2.4.1 специально. Я случайно сделал:

Это устанавливает 2.4.4 вместо более ранней версии.

Теперь даже после того, как я удалю pip psycopg2 и попытаюсь переустановить с правильной версией, похоже, что pip повторно использует кэш, который он загрузил в первый раз.

Как заставить pip очистить кеш загрузки и использовать конкретную версию, которую я включаю в команду?

Если вы используете pip 6.0 или новее, попробуйте добавить --no-cache-dir опцию .

Если вы используете pip старше pip 6.0, обновите его до pip install -U pip .

/ .pip, но это пустой каталог. Ваш совет по --ignore-installed сделал свое дело!

На OSX мне пришлось удалить связанные с pip каталоги в $TMPDIR Если вы используете virtualenv, вам, возможно, придется удалить envs / / build / dir . В Windows: я видел, что каталог кэширования pip находится в

\ AppData \ Local \ pip \ cache

Вы должны сделать python -m pip install -U pip на Windows. (Он не может обновиться из-за блокировки pip.exe файла в противном случае.)

Очистите каталог кэша, где это необходимо для вашей системы

Это безумие, что первые три ответа на самом деле не отвечают на вопрос, и это первый ответ.

Начиная с версии 6.0, pip предоставляет кеш по умолчанию, который работает так же, как и в веб-браузере. Хотя кеш включен по умолчанию и предназначен для правильной работы по умолчанию, вы можете отключить кеш и всегда получать доступ к PyPI, используя эту --no-cache-dir опцию.

Это правильный ответ . ссылка также показывает, где pip хранит кэш в Linux, Windows и OS X. И, чтобы добавить, если вы хотите удалить «плохой» объект из вашего кэша, взгляните на страницу, чтобы найти расположение файла кэша, и «найдите» нарушающий пакет. Linux -

/ Library / Caches / pip и т. Д. Интересно, что psycopg2 также был моим проблемным пакетом, но это было потому, что существующий пакет был скомпилирован для другой библиотеки Postgresql, которая больше не существует в мой сервер.

pip может установить пакет, игнорируя кеш, вот так

Ответ @ dafeda предоставляет ту же информацию 4 месяца назад

На Ubuntu мне пришлось удалить /tmp/pip-build-root .

На самом деле / tmp / pip-build-% username_that_running_pip% На Ubuntu 14 это было /tmp/pip_build_root/ (примечание подчеркивает)

Так как пип 6.0 (обратно в 2014 году!), pip install , pip download И pip wheel команды можно сказать , чтобы избежать использования кэш - памяти с --no-cache-dir опцией. (например: pip install --no-cache-dir <package> )

Начиная с pip 10.0 (еще в 2018 году!), pip config Была добавлена команда, которую можно использовать для настройки pip на всегда игнорирование кеша - pip config set global.cache-dir false настраивает pip так, чтобы он не использовал кеш «глобально» (т.е. во всех командах).

Начиная с pip 20.1, pip имеет pip cache команду для управления содержимым кеша pip.

pip cache purge удаляет все файлы колеса в кеше.
pip cache remove matplotlib выборочно удаляет файлы, связанные с matplotlib из кеша.

Таким образом, pip предоставляет множество способов настроить использование кэша:

pip install --no-cache-dir <package> : установить пакет без использования кэша, только для этого запуска.
pip config set global.cache-dir false : настроить pip, чтобы не использовать кеш "глобально" (во всех командах)
pip cache remove matplotlib : удаляет все файлы колеса, связанные с matplotlib, из кэша pip.
pip cache purge : очистить все файлы из кэша pip.

Проблема, связанная с «установкой неправильной версии из-за кэширования», упомянутая в вопросе, была исправлена в пипе 1.4 (еще в 2013 году!):

Исправьте ряд проблем, связанных с очисткой и не повторным использованием директорий сборки. (№ 413, № 709, № 634, № 602, № 939, № 865, № 948)

Читайте также: