Как узнать env python

How to setup .env in Python

A .env is a simple file that you can create that can store and host environment variables. Environment variables offer a way for your application to store and access variables relating to the environment of your application. This could be anything from API keys to login credentials and passwords or special flags that you pass to your application to indicate production or development builds. .env files should never be committed to your project and should remain local only. As long as your system is not compromised, your API keys will not be compromised either.

Why use a .env file?

.env are used to store sensitive environment variables locally. This means you can store variables pertaining to the environment, such as production or development variables needed across your application. These types of variables include API keys and login credentials for database connections and other application sensitive information.

How to setup a .env file

1.To start using a .env simply create a file called .env in the root of your project. 2.Add the .env file to your .gitignore file. If you do not have a .gitignore you can download a default Python .gitignore. .gitignore should be located in the root of your project (same place as .env). The purpose of a .gitignore file is to prevent git from committing specific files that are listed in this file, hence the name .gitignore since it ignores any file or directory listed in this file. 3.Set your environment variables, API keys, and any sensitive information such as login credentials inside the .env file using the following format:

DISCORD_API_TOKEN= DISCORD_USERNAME= DISCORD_PASSWORD=

Note the < and >delimiter just means you replace the contents of that with the actual API_KEY you desire to hide. An example of a .env file is listed below:

DISCORD_API_TOKEN=1234-1234-1234-1234 DISCORD_USERNAME=TotallyFakeUserName DISCORD_PASSWORD=Passw0rd! 

4.Before accessing the environment variable in our application we need to install a package that lets us locate and load the .env file. For this, we’ll use Python’s package installer to retrieve the package python-dotenv for us, which will allow us to load our .env and access our variables within our application. Simply install python-dotenv by using the following command in the terminal:

If this command does not work, you can try alternatively using python -m pip install python-dotenv to install the package. 5.Now that we have the correct package installed we can load the .env file into our application. Normally we would have to hardcode the location of our .env file, but luckily there is a package to automatically locate the .env file included in python-dotenv , this function is called find_dotenv() which attempts to find our .env within our project.

from dotenv import load_dotenv, find_dotenv # find the .env file and load it load_dotenv(find_dotenv()) 

6.At this point, we have our .env file loaded in memory, but we have no way of accessing the variables just yet. Python has a built-in method for this. We’ll be using the os package which is already included in Python. The os package offers us a function called getenv() which will allow us to get our environment variables.

from os import getenv from dotenv import load_dotenv, find_dotenv # find the .env file and load it load_dotenv(find_dotenv() # access environment variable token = getenv("DISCORD_BOT_TOKEN") 

What if you are creating an open source application that needs a .env file?

If you intend on making your project public but don’t want to expose your API keys .env is still the solution. A good practice is creating a .env.example file that you commit to your code base. This file should only be a template of the environment variables the user is required to input and should not actually contain any keys or sensitive data. So for our example, we would create a .env.example file with the following contents:

DISCORD_BOT_TOKEN= DISCORD_USERNAME= DISCORD_PASSWORD=

This can be safely committed to our project without exposing any sensitive information. In your applications README you can indicate that a user needs to correctly set this file up and they can use the following command to create their own .env file from this template:

This command simply copies the example .env file and creates an actual .env file, here the user can modify the .env file and add their credentials, API keys, etc without exposing it to the world since the .gitignore is set to ignore the .env file.

.env Naming Conventions

1. .env should have variables capitalized. This allows for better code readability, this convention is common when it comes to naming constant variables. An example is: Incorrect:

discord_bot_token=1234-1234-1234 

DISCORD_BOT_TOKEN=1234-1234-1234 

2. .env should be as explicit as possible when it comes to its variables. For instance, the variable TOKEN= can indicate any type of token, however, if we name the variable DISCORD_API_TOKEN= it becomes clear what exactly we are describing. 3. .env does not need quotes for variables unless the variable contains special characters or spaces. An example of this is as follows:

DISCORD_BOT_TOKEN=1234-1345-5345-3453 

However, the following below needs quotations surrounding the variable since it has special characters towards the end or it has a space.

DISCORD_BOT_TOKEN="c2RmZ2FmZ2FnYWRmZ2FkZ2RmZ2FkZg==" USERNAME="Bob Doll" 

If we do not surround the items in quotes for these instances, the DISCORD_BOT_TOKEN string has double == sign towards the end, which may confuse parsers for your .env similarly, spaces between items will get ignored and only the first characters will be printed, so if we do not include the quotes for the USERNAME variable, we will only get back the value Bob when trying to access the username instead of the full name Bob Doll.

Full discord bot code example

👍 If you found this article helpful please drop a like on this.
❔If you have any other questions please comment below. Source:
Stop hardcoding API keys: how to secure your code from attackers

Источник

12. Virtual Environments and Packages¶

Python applications will often use packages and modules that don’t come as part of the standard library. Applications will sometimes need a specific version of a library, because the application may require that a particular bug has been fixed or the application may be written using an obsolete version of the library’s interface.

This means it may not be possible for one Python installation to meet the requirements of every application. If application A needs version 1.0 of a particular module but application B needs version 2.0, then the requirements are in conflict and installing either version 1.0 or 2.0 will leave one application unable to run.

The solution for this problem is to create a virtual environment , a self-contained directory tree that contains a Python installation for a particular version of Python, plus a number of additional packages.

Different applications can then use different virtual environments. To resolve the earlier example of conflicting requirements, application A can have its own virtual environment with version 1.0 installed while application B has another virtual environment with version 2.0. If application B requires a library be upgraded to version 3.0, this will not affect application A’s environment.

12.2. Creating Virtual Environments¶

The module used to create and manage virtual environments is called venv . venv will usually install the most recent version of Python that you have available. If you have multiple versions of Python on your system, you can select a specific Python version by running python3 or whichever version you want.

To create a virtual environment, decide upon a directory where you want to place it, and run the venv module as a script with the directory path:

python -m venv tutorial-env 

This will create the tutorial-env directory if it doesn’t exist, and also create directories inside it containing a copy of the Python interpreter and various supporting files.

A common directory location for a virtual environment is .venv . This name keeps the directory typically hidden in your shell and thus out of the way while giving it a name that explains why the directory exists. It also prevents clashing with .env environment variable definition files that some tooling supports.

Once you’ve created a virtual environment, you may activate it.

tutorial-env\Scripts\activate.bat 

source tutorial-env/bin/activate 

(This script is written for the bash shell. If you use the csh or fish shells, there are alternate activate.csh and activate.fish scripts you should use instead.)

Activating the virtual environment will change your shell’s prompt to show what virtual environment you’re using, and modify the environment so that running python will get you that particular version and installation of Python. For example:

$ source ~/envs/tutorial-env/bin/activate (tutorial-env) $ python Python 3.5.1 (default, May 6 2016, 10:59:36) . >>> import sys >>> sys.path ['', '/usr/local/lib/python35.zip', . '~/envs/tutorial-env/lib/python3.5/site-packages'] >>>

To deactivate a virtual environment, type:

12.3. Managing Packages with pip¶

You can install, upgrade, and remove packages using a program called pip. By default pip will install packages from the Python Package Index. You can browse the Python Package Index by going to it in your web browser.

pip has a number of subcommands: “install”, “uninstall”, “freeze”, etc. (Consult the Installing Python Modules guide for complete documentation for pip .)

You can install the latest version of a package by specifying a package’s name:

(tutorial-env) $ python -m pip install novas Collecting novas Downloading novas-3.1.1.3.tar.gz (136kB) Installing collected packages: novas Running setup.py install for novas Successfully installed novas-3.1.1.3

You can also install a specific version of a package by giving the package name followed by == and the version number:

(tutorial-env) $ python -m pip install requests==2.6.0 Collecting requests==2.6.0 Using cached requests-2.6.0-py2.py3-none-any.whl Installing collected packages: requests Successfully installed requests-2.6.0

If you re-run this command, pip will notice that the requested version is already installed and do nothing. You can supply a different version number to get that version, or you can run python -m pip install —upgrade to upgrade the package to the latest version:

(tutorial-env) $ python -m pip install --upgrade requests Collecting requests Installing collected packages: requests Found existing installation: requests 2.6.0 Uninstalling requests-2.6.0: Successfully uninstalled requests-2.6.0 Successfully installed requests-2.7.0

python -m pip uninstall followed by one or more package names will remove the packages from the virtual environment.

python -m pip show will display information about a particular package:

(tutorial-env) $ python -m pip show requests --- Metadata-Version: 2.0 Name: requests Version: 2.7.0 Summary: Python HTTP for Humans. Home-page: http://python-requests.org Author: Kenneth Reitz Author-email: me@kennethreitz.com License: Apache 2.0 Location: /Users/akuchling/envs/tutorial-env/lib/python3.4/site-packages Requires:

python -m pip list will display all of the packages installed in the virtual environment:

(tutorial-env) $ python -m pip list novas (3.1.1.3) numpy (1.9.2) pip (7.0.3) requests (2.7.0) setuptools (16.0) 

python -m pip freeze will produce a similar list of the installed packages, but the output uses the format that python -m pip install expects. A common convention is to put this list in a requirements.txt file:

(tutorial-env) $ python -m pip freeze > requirements.txt (tutorial-env) $ cat requirements.txt novas==3.1.1.3 numpy==1.9.2 requests==2.7.0

The requirements.txt can then be committed to version control and shipped as part of an application. Users can then install all the necessary packages with install -r :

(tutorial-env) $ python -m pip install -r requirements.txt Collecting novas==3.1.1.3 (from -r requirements.txt (line 1)) . Collecting numpy==1.9.2 (from -r requirements.txt (line 2)) . Collecting requests==2.7.0 (from -r requirements.txt (line 3)) . Installing collected packages: novas, numpy, requests Running setup.py install for novas Successfully installed novas-3.1.1.3 numpy-1.9.2 requests-2.7.0

pip has many more options. Consult the Installing Python Modules guide for complete documentation for pip . When you’ve written a package and want to make it available on the Python Package Index, consult the Distributing Python Modules guide.

Источник