Package Management Basics

Hello, Python package management is a crucial topic in the programming field. Package managers allow us to easily install, upgrade, and uninstall third-party code libraries, greatly improving development efficiency. Python's built-in package management tool is called pip, which is the first thing we need to master.

Daily Use of pip

Let's look at the most commonly used pip commands:

pip install package_name


pip uninstall package_name


pip install --upgrade package_name


pip list


pip install package_name==1.2.3

Isn't it simple? Pip is our first choice when installing third-party libraries daily. However, sometimes we may encounter permission issues, such as being unable to write to system directories. In such cases, we can use the --user parameter to install packages in the user directory:

pip install --user package_name

Another common issue is version conflicts. Different projects may have different version requirements for the same library, and global installation can cause confusion. This is where virtual environments come in handy.

Virtual Environments

Virtual environments are a very useful concept in Python. Simply put, it's creating an independent Python runtime environment outside the system, where you can use your own package versions, avoiding pollution of the global environment.

Creating and Using Virtual Environments

Creating a virtual environment is simple, Python 3 already comes with the venv module:

python -m venv myenv


source myenv/bin/activate  # Linux/macOS
myenv\Scripts\activate     # Windows

After activation, running pip will operate within the virtual environment. Installing packages will only affect the current virtual environment, without polluting the system environment.

Additionally, IDEs like PyCharm come with virtual environment management features, making it even more convenient to use.

Managing Virtual Environments

It's best to create a separate virtual environment for each project and record the packages used and their versions in a requirements.txt file:

pip freeze > requirements.txt


pip install -r requirements.txt

This way, when new people join the project, they can restore the entire development environment with just one command, making maintenance and deployment easier.

Creating and Distributing Packages

Besides using packages created by others, we can also create and distribute our own packages. Python's standard library includes a setuptools module that can help us package our code.

Writing setup.py

setuptools requires a setup.py file, which defines the package's metadata, dependencies, and other information. For example:

from setuptools import setup, find_packages

setup(
    name='mypackage',
    version='0.1',
    packages=find_packages(),
    install_requires=[
        'requests>=2.20.0',
        'click>=7.0',
    ]
)

Packaging and Publishing

With setup.py in place, you can use the following command to create distribution files for your package:

python setup.py sdist bdist_wheel

This will generate two types of installation packages in the dist/ directory. We can upload them to PyPI for others to install:

twine register ...


twine upload dist/*

Great job! Now others can install our package using pip install mypackage.

Summary

Today we explained the basic usage of pip, creation and management of virtual environments, and how to create and publish your own Python packages. With these skills mastered, you can navigate the field of Python package management with ease.

However, package management is just a basic part of Python programming. To become an advanced Pythonista, you need to excel in many more areas. But don't worry, we can take it step by step. See you next time, and keep up the good work!