3 способа локального хранения и чтения учетных данных в Python
Хранение учетных данных в качестве глобальных переменных среды
Если учетные данные хранятся в виде глобальных переменных среды, к ним можно получить доступ с помощью любого сценария, запущенного в любой среде на вашем компьютере.
Чтобы создать глобальную переменную среды, запустите в терминале эту команду:
Убедитесь, что знак равенства ‘ = ’ не отделен пробелами. Появление ошибки “ zsh: Bad Assignment ” часто связано с пробельным отступом до или после “ = ”.
Давайте создадим пару глобальных переменных среды:
В Windows нужно использовать “ set ” вместо “ export ”.
Приведенный выше сценарий необходимо запустить в терминале. Теперь давайте попробуем получить доступ к переменным, которые мы создали ранее:
Мы можем использовать способы доступа к словарю для чтения переменных среды, например, сделать это с помощью .get() или [ ] :
Чтобы обновить переменные среды, просто снова запустите оператор export :
Давайте попробуем снова получить доступ к переменной в Python:
Чтобы удалить переменную среды, используем ключевое слово unset :
При попытке получить доступ к переменной в Python, у вас либо выйдет ошибка KeyError , либо None , в зависимости от метода, используемого для доступа к значениям в словаре.
Хранение учетных данных в качестве переменных в вашей виртуальной среде
Эти переменные среды будут доступны только сценариям, выполняемым в виртуальной среде, в которой создаются переменные. Будем считать их “локальными” переменными среды.
Прежде всего нам придется создать виртуальную среду.
Это создаст виртуальную среду в вашем текущем каталоге. В папке bin должен быть файл с именем activate. Если вы работаете в Windows, он должен находиться в папке Scripts. Этот сценарий запускается каждый раз, когда мы активируем виртуальную среду.
Мы будем добавлять переменные в этот сценарий. Поэтому каждый раз, когда мы активируем виртуальную среду, будут создаваться переменные. Откройте файл.
Прежде чем мы создадим переменные, нужно будет добавить определенный код, чтобы убедиться, что переменные не остаются после деактивации виртуальной среды.
Мы будем использовать ключевое слово unset , перейдем к функции deactivate() внутри выбранного сценария и сбросим переменные в начале функции:
Теперь мы будем использовать ключевое слово export для определения переменных. Этот код должен выходить за рамки функции деактивации в конце выбранного сценария
В Windows вам, возможно, придется использовать set вместо export .
Теперь нам нужно будет активировать виртуальную среду. Если вы уже активировали виртуальную среду, можете использовать ключевое слово deactivate для ее деактивации:
Теперь давайте активируем виртуальную среду.
Вы можете перечислить переменные текущей среды, используя команду printenv .
Теперь давайте попробуем получить доступ к переменным, которые мы только что создали. Это будет похоже на то, как мы получили доступ к глобальным переменным среды:
Теперь отключим виртуальную среду и попробуем снова запустить сценарий Python:
Должен быть возврат значения None .
Хранение учетных данных в файле .env
Внутри вашей корневой папки, папки с вашей виртуальной средой, создайте файл с именем .env. Добавьте переменные внутри файла:
Нам нужно будет установить библиотеку Python для чтения переменных:
Давайте прочитаем переменные в Python:
Не забудьте добавить файл .env в файл .gitignore. Это не позволит вашим учетным данным отправиться в репозиторий git.
Самый удобный способ
На мой взгляд, самый удобный способ — хранить учетные данные в файле .env по следующим причинам:
- они являются локальными для вашего проекта;
- вам не нужно беспокоиться о том, чтобы “сбрасывать” их;
- если вы добавите их в файл .gitignore, он будет защищен от внешнего мира;
- если вы осуществляете сценарий как внесерверную функцию, вам нужно будет использовать load_dotenve() для чтения переменных среды, хранящихся в файле конфигурации вашей среды Azure/AWS.
Хотя у этого способа есть много плюсов, минус выявился бы в том случае, если бы у нас была переменная внутри файла .env с тем же именем, что и глобальная переменная среды. Доступ к переменной в Python вернет глобальное значение, так как мы не используем unset для сброса значения переменной или export для присвоения переменной нового значения.
Сохранить значение переменной в python
Есть ли способ СОХРАНИТЬ значение переменной (скажем, целое число) в python? Моя проблема связана с многократным вызовом (входом и выходом) одного и того же скрипта Python (файла Python, а не функции Python), который в конце концов создает текстовый файл. Я хотел бы назвать файлы txt в зависимости от того, сколько раз вызывался код Python: например, txt1.txt. txt100.txt.
РЕДАКТИРОВАТЬ: вопрос не связан с параметром SAVE в фортране. Виноват.
задан 02 мая ’13, 16:05
что ты уже испробовал? попробуйте, возможно, попробуйте поискать в Google «составить строки python» (чтобы создать имя файла), а затем «создать файл с помощью python», и это должно быть довольно легко понять 🙂 — Samuele Mattiuzzo
Компания pickle и shelf оба модуля предоставляют некоторый интерфейс для хранения некоторых постоянных значений в файлах, которые сохраняются между выполнениями программы. Я бы посмотрел на них для начала. — g.d.d.c
Вы можете сообщить пользователям, что Fortran save работает как C static чтобы уточнить, что вы имеете в виду. Здесь больше пользователей C, чем пользователей Fortran. — Mr Fooz
post edit: так вам интересно, как написать текстовый файл, или вы хотите знать, как сохранить значение переменной при вызовах функции? — Mr Fooz
Ваше разъяснение здесь хорошее . Но вам все же нужно лучше объяснить, что вы подразумеваете под «входом и выходом из одного и того же кода Python». это можно легко интерпретировать как вход и выход из одной и той же функции в сценарии или вызов сценария несколько раз. — mgilson
3 ответы
Не совсем. Лучшее, что вы можете сделать, это использовать глобальную переменную:
Альтернативой, которая обходит необходимость в глобальном операторе, может быть что-то вроде:
В окончательной версии используется преимущество того факта, что функции являются объектами первого класса и к ним можно добавлять атрибуты в любое время:
Однако похоже, что вы действительно хотите сохранить счет в файле или что-то в этом роде. Это тоже не слишком сложно. Вам просто нужно выбрать имя файла:
ответ дан 02 мая ’13, 17:05
@HenryKeiter — Вы знаете фортран? (Я делаю — довольно хорошо). Я считаю, что это прекрасно отвечает на вопрос. когда вы выходите из функции, в питоне все исчезает. Здесь нет save . — мгильсон
@HenryKeiter: как ты думаешь, в чем именно вопрос is? — DSM
@HenryKeiter — это не то, что save делает на фортране. save ничего не делает между вызовами программы. — мгильсон
@jpcgandre — Подожди. Ты имеешь в виду python myscript дает file1 становятся python myscript дает file2 и так далее? Потому что вы не получите этого с фортраном save . вам нужно уточнить, что вы спрашиваете здесь . — мгильсон
@jpcgandre: подожди, что? Итак, под словом «сохранение на фортране» вы подразумеваете «совсем ничего похожего на сохранение на фортране»? Сохранение Фортрана не сериализуется. — DSM
ПРИМЕЧАНИЕ: Я предполагаю, что вы имеете в виду:
вызов (вход и выход) несколько раз одного и того же кода Python
заключается в том, что вы хотите вызвать весь скрипт Python несколько раз, и в этом случае вам нужно сериализовать свой счетчик каким-то образом, внешним по отношению к интерпретатору Python, чтобы сделать его доступным в следующий раз. Если вы просто спрашиваете о вызове одной и той же функции или метода несколько раз в течение одного сеанса Python, вы можете сделать это разными способами, и я бы указал вам на ответ мгилсона.
Существует множество способов сериализации вещей, но ваша реализация на самом деле не имеет ничего общего с языком. Вы хотите сохранить его в базе данных? Записать значение в файл? Или достаточно просто получить соответствующее значение из контекста? Например, этот код будет получать новый файл при каждом его вызове на основе содержимого output_dir . Это, очевидно, грубо, но вы поняли:
Глобальные переменные в Python: сохранить локальную переменную от вызова к вызову функции
У меня есть функция, которой необходимо сохранять значение от вызова к вызову, при этом это значение используется только в этой функции. Как правильно использовать глобальные переменные в Python? Я пробовал написать нечто подобное:
Но данный код не работает. Может есть другие способы решения данной задачи?
Есть несколько способов реализовать подобное поведение.
Глобальные переменные
Первое, что может прийти в голову, это использовать глобальные переменные.
Важно учитывать то, что глобальные переменные доступы на чтение
но простое использование на запись не разрешается:
Более того, при попытке обратиться к переменной сначала на чтение, потом на запись, мы получим ошибку:
Это происходит из-за того, что использование присваивания переменной z обозначает её, как локальную (как в случае 2). Попытка вывести значение локальной переменной, у которой ещё не задано значение, как раз и порождает возникновение этой ошибки.
Аналогичный пример как раз приведён в вашем вопросе. Там тоже переменная someGlobalVar определяется, как локальная, потому что выполняется присваивание. Так как в этом присваивании используется сначала чтение значения ещё не инициализированной переменной someGlobalVar , мы получаем ту же ошибку.
Для того, чтобы этот пример работал, необходимо предварительно пометить переменную, как global :
Аналогично будет работать и в вашем случае.
Использование поля функции
Второй способ, который может прийти в голову, это использование объекта функции для хранения состояния функции.
В этом способе удобно то, что значение ассоциировано с самой функцией.
Стоит быть осторожным, давая имена подобным полям функции, так как в Python 2 у функции есть стандартные поля с названиями, не начинающимися с двух подчёркиваний, например, func_closure , func_code и т.п. Все они начинаются с func_ , поэтому главное не использовать этот префикс и не начинать название поля с __ , в остальных случаях шанс коллизии имён практически равен нулю.
Использование класса с поведением функции
Третий способ заключается в создании класса с поведением функции. Это наиболее удобный и безопасный, по моему мнению, способ реализации подобного поведения. Просто создайте класс и перегрузите его метод __call__ :
Это увеличивает объём кода, но добавляет удобств от использования функциональности класса.
Использование изменяемого объекта, как значение по умолчанию для параметра
Четвёртый способ заключается в том, чтобы создать функцию, у которой будет необязательный параметр, использующий изменяемое значение в качестве состояния:
В качестве объекта состояния можно использовать любой изменяемый объект. Это использует то, что все значения по умолчанию присваиваются один раз.
Использование декоратора, выполняющего необходимые вычисления
Если вернуться к исходному примеру, то для подсчёта числа вызовов функции будет также может быть удобно использовать декораторы. Это позволит в том числе и переиспользовать код.
Для Python 3 код может выглядеть, например, так:
В Python 2 нет nonlocal , но можно использовать изменяемые переменные:
Использоваться это будет следующим образом:
При желании вы можете скомбинировать этот способ с каким-нибудь из описанных ранее.
Из всех выше упомянутых способов я бы рекомендовал использовать классы (так как функция с изменяющимся состоянием уже больше похожа на класс, чем на функцию) или поле функции, в случае необходимости быстрого добавления функциональности в код.
Глава #2.1 Сохранение значений выражений в переменных.
Этот раздел получился несколько больше, чем я рассчитывал, поэтому было решено вынести его в отдельную главу.
После вычисления выражения, вы можете сохранить полученное значение в переменной, чтобы использовать его в дальнейшем.
Переменная — поименованный участок памяти компьютера, который может содержать некоторое значение. Но такое определение, думаю, не очень понятно. Особенно если вы только делаете первые шаги в программировании. Для меня намного проще представлять переменную в виде ящика. То что вы напишете на ящике — будет именем переменной. А то, что вы в него положите — её значением:
Рисунок 2-5. Образное представление переменной
На рисунке 2-5 именем переменной будет spam, а значением — число 15. Каждая переменная в программе должна иметь уникальный идентификатор — имя — по которому Python будет отыскивать нужное значение. Создать переменную в Python и присвоить ей значение очень просто. Для этого, в командной строке нужно сначала написать имя будущей переменной (например «spam»), поставить оператор присваивания «=» и указать, какое значение будет хранится в переменной.
Все. Переменная создана. Следует отметить, что команда «spam=15» не является выражением. Это объявление. Поэтому после выполнения этой инструкции компьютер ничего не выводит в командную строку. Он вас понял — создал переменную с указанным именем и внес туда значение 15. Если вам не понятно, какие инструкции являются выражениями, а какие объявлениями, пока исходите из того, что результатом выражения является какое-то одно вычисляемое значение. Любые другие инструкции являются объявлениями.
Переменные сохраняют значения, а не выражения. Если вы попытаетесь присвоить переменной у качестве значения какое-либо выражение, то оно сначала будет вычислено, а потом его результат помещен в переменную.
Когда вы в первый раз объявляете переменную в интерпретаторе Python, он создает её и помещает в неё значение. Чтобы проверить, какое значение хранится в переменной, нужно просто ввести её имя:
Рисунок 2-6. Вывод содержимого переменной.
Выражение «spam» было вычислено интерпретатором Python как число 15 (значение переменной). Эта позволяет производить математические операции с переменными напрямую, подставляя их имена в качестве значений операторов:
Рисунок 2-7. Операция сложения с переменной.
Вы не сможете использовать переменную в выражениях до тех пор, пока не объявите её с помощью оператора «=». Опечатка в имени переменной так же приведет к сообщению об ошибке:
Рисунок 2-8. Сообщение об ошибке в случае опечатки в имени переменной.
Ошибка произошла потому, что в памяти компьютера есть переменная с именем «spam», но нет переменной с именем «psam», о чем компьютер и сообщает.
Присвоение существующей переменной нового значения также выполняется с помощью оператора «=». Взгляните на следующий пример:
Рисунок 2-8. Изменение значения переменной.
В результате первого выражения мы получили 20 потому, что перед этим поместили в переменную «spam» число 15. Следующей командой мы заменили значение переменной spam на число 3. Старое значение переменной было уничтожено. И результатом последнего выражения является число 8, которое стало результатом сложения числа 5 и нового значения переменной «spam».
Вы можете использовать имя переменной в выражении присвоения нового значения этой же переменной:
Повторите эту операцию несколько раз последовательно вводя в интерактивную оболочку выражение «spam=spam+5»:
Рисунок 2-9. Использование имени переменной при новом объявлении её значения.
Использование более одной переменной в программе.
В программах можно создавать столько переменных, сколько вам нужно. Для примера создадим две переменные с именами яйца («eggs») и бекон («bacon»). В переменную «eggs» поместим значение 15, а в переменную «bacon» значение 10 и попробуем с ними что нибудь сделать:
Рисунок 2-10. Операции с переменными.
Как мы видим, у объявленной переменной «spam» значение 25. Это произошло потому, что в переменных хранятся не выражения, а значения. При объявлении переменной «spam», компьютер сначала определил значения переменных «eggs» и «bacon», а после вычислил значение выражения и сохранил его результат в переменной.
Заключение.
В этой главе мы познакомились с базовыми инструкциями Python. К сожалению Pyton не обладает хоть каплей здравомыслия, поэтому нуждается в точных инструкциях, что и как он должен делать.
Выражениями являются значения (2 и более) связанных между собой математическими операторами. Python будет автоматически вычислять эти выражения по мере необходимости. Их результат может быть сохранен в переменной для дальнейшего использования.
В Python существуют и другие операторы и значения. С некоторыми из них вы познакомитесь в следующей главе. В ней мы напишем первую программу и узнаем, как Python работает с текстом.