Okay, here’s a comprehensive article on Learn Miniconda: Setup, Environments, and Packages, aiming for around 5000 words. It will be structured for clarity and easy navigation.
Learn Miniconda: Setup, Environments, and Packages – A Comprehensive Guide
Table of Contents
-
Introduction: What is Miniconda and Why Use It?
- 1.1 The Python Ecosystem and Package Management Challenges
- 1.2 Anaconda vs. Miniconda: Choosing the Right Tool
- 1.3 Benefits of Using Miniconda
- 1.4 Who Should Use Miniconda?
-
Installation and Setup
- 2.1 Downloading Miniconda
- 2.1.1 Choosing the Correct Installer (Python Version, Operating System)
- 2.1.2 Downloading from the Official Website
- 2.2 Installation Process (Step-by-Step for Windows, macOS, and Linux)
- 2.2.1 Windows Installation
- 2.2.2 macOS Installation
- 2.2.3 Linux Installation
- 2.3 Verifying the Installation
- 2.4 Initializing Conda (conda init)
- 2.5 Configuring Conda (Optional but Recommended)
- 2.5.1 Adding Channels (conda-forge)
- 2.5.2 Setting Channel Priority
- 2.5.3 Proxy Settings (If Applicable)
- 2.5.4 Auto activation of base environment
- 2.1 Downloading Miniconda
-
Understanding Conda Environments
- 3.1 What are Conda Environments?
- 3.2 Why Use Environments? (Isolation, Dependency Management, Reproducibility)
- 3.3 The Base Environment (and Why to Generally Avoid It)
- 3.4 Best Practices for Environment Management
-
Creating and Managing Environments
- 4.1 Creating a New Environment (
conda create
)- 4.1.1 Specifying a Python Version
- 4.1.2 Installing Packages During Creation
- 4.1.3 Creating from an environment.yml
- 4.2 Activating and Deactivating Environments (
conda activate
,conda deactivate
) - 4.3 Listing Existing Environments (
conda env list
) - 4.4 Removing Environments (
conda env remove
) - 4.5 Cloning Environments (
conda create --clone
) - 4.6 Exporting and Sharing Environments (environment.yml)
- 4.6.1 Creating an environment.yml File
- 4.6.2 Understanding the environment.yml Structure
- 4.6.3 Recreating the environment
- 4.1 Creating a New Environment (
-
Package Management with Conda
- 5.1 Searching for Packages (
conda search
) - 5.2 Installing Packages (
conda install
)- 5.2.1 Installing Specific Versions
- 5.2.2 Installing from Specific Channels
- 5.2.3 Understanding Dependency Resolution
- 5.3 Updating Packages (
conda update
,conda upgrade
)- 5.3.1 Difference between
conda update
andconda upgrade
- 5.3.2 Updating Conda Itself
- 5.3.3 Updating All Packages in an Environment
- 5.3.4 Updating a Specific Package
- 5.3.1 Difference between
- 5.4 Listing Installed Packages (
conda list
) - 5.5 Removing Packages (
conda remove
,conda uninstall
) - 5.6 Using Pip within Conda Environments
- 5.6.1 When to Use Pip
- 5.6.2 Best Practices for Pip and Conda Coexistence
- 5.6.3 Tracking pip installed packages
- 5.1 Searching for Packages (
-
Advanced Conda Usage
- 6.1 Conda Configuration (
.condarc
)- 6.1.1 Understanding the
.condarc
File - 6.1.2 Common Configuration Options
- 6.1.1 Understanding the
- 6.2 Conda Build (Creating Your Own Packages – Brief Overview)
- 6.3 Conda Clean (Managing Cached Packages)
- 6.4 Offline Installation
- 6.5 Using Conda with Different Shells
- 6.1 Conda Configuration (
-
Troubleshooting and Common Issues
- 7.1 Solving Package Conflicts
- 7.2 Dealing with Slow Downloads
- 7.3 Environment Activation Problems
- 7.4 “Conda Command Not Found” Errors
- 7.5 Finding Help and Resources (Documentation, Forums)
-
Conclusion: Mastering Miniconda for Python Development
1. Introduction: What is Miniconda and Why Use It?
1.1 The Python Ecosystem and Package Management Challenges
Python’s popularity stems from its versatility and the vast ecosystem of libraries and packages available. These packages, ranging from numerical computation tools like NumPy and SciPy to machine learning frameworks like TensorFlow and PyTorch, significantly extend Python’s capabilities. However, managing these packages can become complex:
- Dependencies: Packages often rely on other packages (dependencies), and these dependencies can have their own dependencies, creating a complex web. Installing one package might require installing several others.
- Version Conflicts: Different projects might require different versions of the same package. Installing a new version for one project could break another project that relies on an older version.
- System-Wide vs. Project-Specific Packages: Installing packages system-wide (available to all users and projects) can lead to conflicts and make it difficult to reproduce a specific development environment.
- Reproducibility: Sharing a project with others or deploying it to a different machine requires ensuring that the exact same set of packages and versions are used.
1.2 Anaconda vs. Miniconda: Choosing the Right Tool
Both Anaconda and Miniconda are distributions of Python and package management tools, designed to address the challenges mentioned above. They both use the conda
package and environment manager. The key difference lies in their scope:
- Anaconda: A full-fledged distribution that includes Python,
conda
, and a large collection of pre-installed packages (over 250) commonly used in data science, machine learning, and scientific computing. It also includes a graphical user interface (Anaconda Navigator). Anaconda is convenient for beginners who want a ready-to-use environment, but it can be quite large (several gigabytes). - Miniconda: A minimal installer that includes only Python,
conda
, and a few essential packages. It’s a lightweight alternative to Anaconda, allowing you to install only the packages you need. Miniconda is ideal for users who prefer more control over their environment, want to minimize disk space usage, or are working in environments with limited resources.
This guide focuses on Miniconda because it provides a more flexible and efficient foundation for managing Python environments.
1.3 Benefits of Using Miniconda
- Simplified Package Management:
conda
makes it easy to install, update, and remove packages, automatically handling dependencies. - Isolated Environments: Create separate environments for different projects, preventing version conflicts and ensuring that each project has its own set of dependencies.
- Reproducibility: Easily share or recreate your development environment on different machines using environment files.
- Cross-Platform Compatibility: Miniconda works seamlessly on Windows, macOS, and Linux.
- Open Source and Free: Miniconda is free to use and open source.
- Integration with Pip: While
conda
is the primary package manager, you can still usepip
(Python’s built-in package installer) within Miniconda environments when necessary. - Access to a large ecosystem: Although Miniconda is minimal, Conda’s package repository, and in particular the
conda-forge
channel, give easy access to thousands of packages.
1.4 Who Should Use Miniconda?
Miniconda is an excellent choice for:
- Python Developers: Anyone working on Python projects, especially those involving multiple projects or complex dependencies.
- Data Scientists and Machine Learning Engineers: Provides a robust environment for managing the numerous libraries and tools used in these fields.
- Researchers: Ensures reproducibility of research results by providing a way to define and share the exact software environment used.
- System Administrators: Manages multiple Python installations and environments on servers or shared systems.
- Anyone who wants fine-grained control over their Python environment.
2. Installation and Setup
2.1 Downloading Miniconda
2.1.1 Choosing the Correct Installer (Python Version, Operating System)
Before downloading, you need to choose the right installer for your system:
- Python Version: Miniconda installers are available for different Python versions (e.g., Python 3.8, 3.9, 3.10, 3.11, etc.). Choose the version that best suits your project’s requirements. If you’re starting a new project, using the latest stable Python version is generally recommended.
- Operating System: Select the installer for your operating system (Windows, macOS, or Linux).
- Architecture: Ensure you choose the correct architecture (64-bit or 32-bit). Most modern systems are 64-bit.
2.1.2 Downloading from the Official Website
Always download Miniconda from the official Anaconda website: https://docs.conda.io/en/latest/miniconda.html
This ensures you get the latest, secure version and avoids potential issues with unofficial downloads. The website provides a clear table of available installers.
2.2 Installation Process (Step-by-Step for Windows, macOS, and Linux)
2.2.1 Windows Installation
- Download: Download the appropriate
.exe
installer (e.g.,Miniconda3-latest-Windows-x86_64.exe
). - Run the Installer: Double-click the downloaded
.exe
file to start the installation process. - Follow the prompts:
- Click “Next” on the welcome screen.
- Agree to the license agreement.
- Choose Installation Type: It’s generally recommended to install for “Just Me” (unless you specifically need a system-wide installation). This avoids potential permission issues.
- Choose Installation Location: Accept the default location or choose a different one. Avoid spaces and special characters in the path.
- Advanced Options: Crucially, on the “Advanced Options” screen:
- Do not check “Add Anaconda to my PATH environment variable.” This is generally discouraged as it can interfere with other Python installations. We’ll use
conda init
later. - Check “Register Anaconda as my default Python 3.x”. This makes Miniconda’s Python the default for your user account.
- Do not check “Add Anaconda to my PATH environment variable.” This is generally discouraged as it can interfere with other Python installations. We’ll use
- Click “Install” and wait for the installation to complete.
- Click “Next” and then “Finish”. You can uncheck the boxes to view the tutorials.
2.2.2 macOS Installation
- Download: Download the appropriate
.pkg
installer (e.g.,Miniconda3-latest-MacOSX-x86_64.pkg
) or the.sh
installer (e.g.,Miniconda3-latest-MacOSX-x86_64.sh
). The.pkg
installer provides a graphical installation, while the.sh
installer is used in the terminal. We’ll cover the.sh
method for consistency with Linux. - Open Terminal: Open a terminal window (Applications > Utilities > Terminal).
-
Run the Installer: Navigate to the directory where you downloaded the
.sh
file (e.g.,cd Downloads
). Then, run the installer usingbash
:bash
bash Miniconda3-latest-MacOSX-x86_64.sh -
Follow the prompts:
- Press
Enter
to continue. - Scroll through the license agreement (press
q
to skip to the end). - Type
yes
and pressEnter
to agree to the license. - Choose Installation Location: Accept the default location (usually your home directory) or specify a different one. Avoid spaces and special characters.
- Initialize Miniconda3: The installer will ask if you want to initialize Miniconda3 by running
conda init
. Typeyes
and pressEnter
. This is the recommended approach.
- Press
-
Close and Reopen Terminal: Close the terminal window and open a new one for the changes to take effect.
2.2.3 Linux Installation
- Download: Download the appropriate
.sh
installer (e.g.,Miniconda3-latest-Linux-x86_64.sh
). - Open Terminal: Open a terminal window.
-
Run the Installer: Navigate to the directory where you downloaded the
.sh
file (e.g.,cd Downloads
). Make the script executable and run it:bash
chmod +x Miniconda3-latest-Linux-x86_64.sh
bash Miniconda3-latest-Linux-x86_64.sh -
Follow the prompts: The steps are the same as for macOS (see above). Agree to the license, choose an installation location, and initialize Miniconda3 by running
conda init
(typeyes
when prompted). - Close and Reopen Terminal: Close and reopen your terminal.
2.3 Verifying the Installation
After installation, verify that Miniconda is installed correctly:
- Open a new terminal window (or Command Prompt/Anaconda Prompt on Windows).
-
Run the following command:
bash
conda --versionThis should display the installed version of
conda
. If you see the version number, the installation was successful.
3. Also, check the Python version:bash
python --versionThis should display the Python version you selected during installation.
2.4 Initializing Conda (conda init)
The conda init
command configures your shell to work with Conda. You should have already done this during the installation process (by answering “yes” to the prompt). However, if you skipped that step or are having issues, you can run it manually:
bash
conda init <SHELL_NAME>
Replace <SHELL_NAME>
with the name of your shell. Common shell names include:
- bash: The default shell on many Linux distributions and macOS.
- zsh: A popular alternative shell on macOS and Linux.
- powershell: The default shell on modern Windows systems.
- cmd.exe: The traditional Windows command prompt.
For example, if you’re using bash, you would run:
bash
conda init bash
Important: After running conda init
, you must close and reopen your terminal window (or restart your shell) for the changes to take effect. This is crucial for Conda to function correctly. conda init
modifies your shell’s configuration files (e.g., .bashrc
, .zshrc
, .bash_profile
) to add Conda’s initialization scripts.
2.5 Configuring Conda (Optional but Recommended)
2.5.1 Adding Channels (conda-forge)
Conda channels are the repositories where packages are stored. The default channel provided by Anaconda, Inc. contains a wide range of packages, but the conda-forge
channel is a community-driven collection that often has more up-to-date packages and a wider selection, especially for specialized scientific software. It’s highly recommended to add conda-forge
:
bash
conda config --add channels conda-forge
2.5.2 Setting Channel Priority
When you have multiple channels, Conda needs to know which channel to prioritize when searching for packages. It’s generally best to give conda-forge
higher priority than the default channel. This ensures that you get the latest versions from conda-forge
whenever possible:
bash
conda config --set channel_priority strict
With strict
channel priority, if a package exists on both default channel and conda-forge
, and you do not specify a channel with the install command, conda will check for the highest version number.
2.5.3 Proxy Settings (If Applicable)
If you’re behind a proxy server, you’ll need to configure Conda to use the proxy. You can do this by setting the proxy_servers
option in your .condarc
file (explained in more detail in section 6.1). Here’s how to set it via the command line:
bash
conda config --set proxy_servers.http http://your_proxy_address:port
conda config --set proxy_servers.https https://your_proxy_address:port
Replace http://your_proxy_address:port
and https://your_proxy_address:port
with the actual address and port of your proxy server. You may also need to provide a username and password if your proxy requires authentication.
2.5.4 Auto activation of base environment
By default, Miniconda will activate the base
environment automatically when you open a new terminal. While convenient, it’s generally recommended to disable this behavior and explicitly activate environments only when you need them. This helps prevent accidental modifications to the base
environment. To disable auto-activation:
bash
conda config --set auto_activate_base false
3. Understanding Conda Environments
3.1 What are Conda Environments?
A Conda environment is an isolated, self-contained directory that contains a specific collection of Python packages, their dependencies, and a specific version of Python itself. Think of it as a virtual sandbox for your Python projects. Each environment is independent of other environments and your system-wide Python installation.
3.2 Why Use Environments? (Isolation, Dependency Management, Reproducibility)
- Isolation: Environments prevent conflicts between different projects. If Project A requires version 1.0 of a package and Project B requires version 2.0, you can create separate environments for each project, and they won’t interfere with each other.
- Dependency Management: Conda automatically manages the dependencies within each environment. When you install a package, Conda ensures that all its required dependencies are also installed, and that the versions are compatible.
- Reproducibility: Environments make it easy to recreate the exact same software environment on different machines. This is essential for collaboration, deployment, and ensuring that your code runs consistently. You can create an “environment file” that lists all the packages and their versions, and then use this file to recreate the environment on another system.
3.3 The Base Environment (and Why to Generally Avoid It)
When you install Miniconda, it creates a default environment called base
. This environment contains the core Conda tools and a basic Python installation. While you can install packages directly into the base
environment, it’s generally not recommended.
- Risk of Conflicts: Modifying the
base
environment can make it unstable and lead to conflicts with other projects or with Conda itself. - Difficult to Reproduce: It’s harder to keep track of the packages installed in the
base
environment, making it difficult to reproduce your setup on another machine. - Best Practice: It is best practice to never install anything other than
conda
updates in thebase
environment. Always create new environments for your projects.
3.4 Best Practices for Environment Management
- Create a new environment for each project. This is the most important rule.
- Give your environments descriptive names. Use names that reflect the purpose of the project (e.g.,
my-project-env
,data-analysis-env
,web-app-env
). - Keep your
base
environment clean. Only updateconda
itself in thebase
environment. - Use environment files (environment.yml) to document and share your environments.
- Regularly update your environments. Keep your packages up-to-date to benefit from bug fixes and new features.
- Activate and deactivate. Remember to deactivate environments when you’re finished working on a project.
4. Creating and Managing Environments
4.1 Creating a New Environment (conda create
)
The conda create
command is used to create new environments. Here’s the basic syntax:
bash
conda create --name <environment_name>
Or, using the short form:
bash
conda create -n <environment_name>
Replace <environment_name>
with the desired name for your environment (e.g., my-project
). This command creates an empty environment with the default Python version (the one you installed Miniconda with).
4.1.1 Specifying a Python Version
You can specify a particular Python version when creating an environment:
bash
conda create -n my-project-py39 python=3.9
This creates an environment named my-project-py39
with Python 3.9 installed. You can specify any compatible Python version (e.g., python=3.8
, python=3.10
).
4.1.2 Installing Packages During Creation
You can install packages directly when creating the environment by listing them after the environment name and Python version:
bash
conda create -n data-analysis python=3.10 numpy pandas scikit-learn
This creates an environment named data-analysis
with Python 3.10, NumPy, pandas, and scikit-learn installed. You can list any number of packages.
4.1.3 Creating from an environment.yml
You can create a new environment from an environment.yml
file (described in detail in Section 4.6). This is the best way to ensure reproducibility.
bash
conda env create -f environment.yml
This will create a new environment, using the name and package specifications defined inside the environment.yml
file.
4.2 Activating and Deactivating Environments (conda activate
, conda deactivate
)
Once an environment is created, you need to activate it to use it. Activating an environment modifies your shell’s environment variables (primarily the PATH
) so that the Python interpreter and packages within the environment are used instead of the system-wide ones.
To activate an environment:
bash
conda activate <environment_name>
For example:
bash
conda activate my-project-py39
When an environment is activated, you’ll usually see the environment name in parentheses at the beginning of your shell prompt (e.g., (my-project-py39) $
).
To deactivate the current environment:
bash
conda deactivate
This returns you to your base
environment (or your system’s default Python if you disabled auto-activation of base
).
4.3 Listing Existing Environments (conda env list
)
To see a list of all your Conda environments:
bash
conda env list
Or:
bash
conda info --envs
This will display a list of environments, their locations on your system, and an asterisk (*) next to the currently active environment.
4.4 Removing Environments (conda env remove
)
To remove an environment that you no longer need:
bash
conda env remove -n <environment_name>
For example:
bash
conda env remove -n old-project-env
This will completely delete the environment and all its contents. Be careful, as this action is irreversible.
4.5 Cloning Environments (conda create --clone
)
You can create an exact copy of an existing environment using the --clone
option:
bash
conda create --name <new_environment_name> --clone <existing_environment_name>
For example:
bash
conda create --name my-project-copy --clone my-project
This creates a new environment named my-project-copy
that is an exact duplicate of my-project
.
4.6 Exporting and Sharing Environments (environment.yml)
The best way to share your environments and ensure reproducibility is to use an environment.yml
file. This file contains a list of all the packages and their versions, as well as the environment name and channels used.
4.6.1 Creating an environment.yml File
To create an environment.yml
file from an existing environment, activate the environment and then run:
bash
conda env export > environment.yml
This command redirects the output of conda env export
(which lists the environment’s details) to a file named environment.yml
. You can choose any name for the file, but environment.yml
is the convention.
4.6.2 Understanding the environment.yml Structure
A typical environment.yml
file looks like this:
yaml
name: my-project-env
channels:
- conda-forge
- defaults
dependencies:
- python=3.9
- numpy=1.21.2
- pandas=1.3.3
- scikit-learn=1.0.0
- pip:
- requests==2.26.0
- name: The name of the environment.
- channels: The Conda channels to use when recreating the environment.
- dependencies: A list of packages to install.
- Packages installed with
conda
are listed directly (e.g.,numpy=1.21.2
). The=
sign specifies the version. - Packages installed with
pip
are listed under apip:
section.
- Packages installed with
4.6.3 Recreating the Environment
To create a new environment from the environment.yml
file.
bash
conda env create -f environment.yml
This reads the file and create a new environment exactly as described.
5. Package Management with Conda
5.1 Searching for Packages (conda search
)
Before installing a package, you can search for it to see if it’s available and what versions are available:
bash
conda search <package_name>
For example:
bash
conda search numpy
This will display a list of available NumPy versions and the channels they’re available from. You can also use wildcards:
bash
conda search 'numpy*'
This will search for all packages that start with numpy
.
5.2 Installing Packages (conda install
)
The conda install
command is used to install packages into the currently active environment.
bash
conda install <package_name>
For example:
bash
conda install pandas
This installs the latest version of pandas and its dependencies into the active environment.
5.2.1 Installing Specific Versions
You can specify a particular version of a package:
bash
conda install pandas=1.3.3
This installs pandas version 1.3.3. You can also use version specifiers like >=
(greater than or equal to), <
(less than), etc.
bash
conda install "pandas>=1.2,<1.4"
This will install the highest available version that is greater than or equal to 1.2 and less than 1.4
5.2.2 Installing from Specific Channels
If a package is available from multiple channels, you can specify the channel to use:
bash
conda install -c conda-forge beautifulsoup4
This installs beautifulsoup4
from the conda-forge
channel. The -c
option specifies the channel.
5.2.3 Understanding Dependency Resolution
Conda automatically handles dependency resolution. When you install a package, Conda checks its dependencies and installs them as well. It also ensures that the versions of all installed packages are compatible. If there are conflicts, Conda will try to find a solution or report an error if no solution is possible.
5.3 Updating Packages (conda update
, conda upgrade
)
5.3.1 Difference between conda update
and conda upgrade
There are two main commands to update packages.
* conda update
: Updates the specified packages to the latest compatible version within the environment.
* conda upgrade
: This is an alias for conda update --all
and will attempt to update all packages in the active environment to their latest versions.
5.3.2 Updating Conda Itself
It’s good practice to keep Conda itself updated:
bash
conda update conda
It is best to run this command in the base
environment.
5.3.3 Updating All Packages in an Environment
To update all packages in the currently active environment to their latest versions.
bash
conda update --all
Or
bash
conda upgrade --all
5.3.4 Updating a Specific Package
To update a specific package:
bash
conda update <package_name>
For example:
bash
conda update numpy
This updates NumPy to the latest compatible version within the current environment.
5.4 Listing Installed Packages (conda list
)
To see a list of all packages installed in the currently active environment:
bash
conda list
This displays the package name, version, build, and channel. You can also search within the list:
bash
conda list <package_name>
For instance, conda list numpy
would only show information related to numpy, if it’s installed.
5.5 Removing Packages (conda remove
, conda uninstall
)
To remove a package from the active environment:
bash
conda remove <package_name>
Or:
bash
conda uninstall <package_name>
For example:
bash
conda remove pandas
This removes pandas and any packages that depend only on pandas (i.e., packages that are no longer needed).
5.6 Using Pip within Conda Environments
While conda
is the preferred package manager for Conda environments, sometimes you may need to use pip
(Python’s built-in package installer). This is usually necessary when:
- A package is not available on Conda channels (including
conda-forge
). - You need to install a package directly from a source repository (e.g., GitHub).
- You are working with a project that uses a
requirements.txt
file (a common way to specify dependencies forpip
).
5.6.1 When to Use Pip
Use pip
only when conda
cannot install the package you need.
5.6.2 Best Practices for Pip and Conda Coexistence
-
Install
pip
withconda
: Always installpip
itself usingconda
within your environment. This ensures thatpip
is managed by Conda and uses the correct Python interpreter.bash
conda install pip
* Installconda
packages first: Install as many packages as possible withconda
before usingpip
. This helps avoid dependency conflicts.
* Usepip
afterconda
: After installing all possible packages withconda
, then usepip
to install any remaining packages.
* Documentpip
-installed packages: If you usepip
, make sure to document the packages you installed with it in yourenvironment.yml
file (see Section 4.6.2). This is crucial for reproducibility.
* Be aware of potential conflicts:pip
doesn’t always interact perfectly with Conda’s dependency management. If you encounter problems, try removing and reinstalling packages, or creating a new environment.
5.6.3 Tracking pip installed packages
When you export an environment with conda env export > environment.yml
, packages that were installed via pip will be listed under the pip:
section within the dependencies:
section.
6. Advanced Conda Usage
6.1 Conda Configuration (.condarc
)
Conda’s behavior can be customized through a configuration file called .condarc
. This file is a YAML file that allows you to set various options, such as:
- Default channels
- Channel priority
- Proxy settings
- Environment directories
- And many other options
6.1.1 Understanding the .condarc
File
The .condarc
file is usually located in your home directory (~/.condarc
on Linux/macOS, C:\Users\<your_username>\.condarc
on Windows). If the file doesn’t exist, you can create it. You can also create environment-specific .condarc
files within the environment’s directory.
You can edit the .condarc
file directly with a text editor, or you can use the conda config
command to modify it. Using conda config
is generally recommended as it helps prevent errors in the YAML syntax.
6.1.2 Common Configuration Options
Here are some commonly used configuration options:
- channels: Specifies the default channels to use (see Section 2.5.1).
- channel_priority: Sets the channel priority (see Section 2.5.2).
- proxy_servers: Configures proxy settings (see Section 2.5.3).
-
envs_dirs: Specifies additional directories where Conda should search for environments. By default, Conda environments are created in the
envs
subdirectory of your Miniconda installation. You can add other directories:bash
conda config --add envs_dirs /path/to/your/environments
* auto_activate_base: Controls whether thebase
environment is automatically activated (see Section 2.5.4)
6.2 Conda Build (Creating Your Own Packages – Brief Overview)
conda build
is a powerful tool that allows you to create your own Conda packages. This is useful if you have developed a Python library or application that you want to distribute as a Conda package. This is beyond the scope of this Miniconda guide but more information can be found here: https://docs.conda.io/projects/conda-build/en/latest/
6.3 Conda Clean (Managing Cached Packages)
Conda caches downloaded packages and other data to speed up future installations. Over time, this cache can grow quite large. The conda clean
command helps you manage the cache and remove unnecessary files.
conda clean --all
: Removes all cached packages, indexes, and tarballs. This is the most aggressive cleaning option.conda clean --packages
: Removes unused packages.conda clean --tarballs
: Removes cached package tarballs.conda clean --index-cache
: Clears the index cache.
It’s generally safe to run conda clean --all
periodically to free up disk space.
6.4 Offline Installation
Conda can install packages offline, provided you have previously downloaded the necessary package files (.tar.bz2
or .conda
files). This is useful in environments with limited or no internet access.
- Download Packages: On a machine with internet access, download the required packages using
conda install --download-only <package_name>
. This will download the package files to your Conda’spkgs
directory without installing them. - Transfer Packages: Transfer the downloaded package files (located in the
pkgs
directory of your Miniconda installation) to the offline machine. You can use a USB drive, shared network folder, or any other method.