Python: Basics

Python is a popular high-level programming language that is easy to learn and widely used in data analysis, machine learning, web development, and many other fields.

Defining Variables

In Python, we can define a variable and assign a value to it using the “=” operator. For example:

x = 10

Here, we’ve defined a variable x and assigned it the value of 10.

Performing Operations

We can also perform mathematical operations on variables:

y = 5
z = x + y

Here, we’ve defined a variable y and added it to x to create a new variable z.

Expressions

Expressions are combinations of operators and operands that can be evaluated to produce a value.

Python allows us to use expressions to perform operations on variables. For example:

a = 2
b = 3
c = a * b + 1

Here, we’ve defined three variables: a, b, and c. We’ve used the * operator to multiply a and b, and then added 1 to the result.

Expressions can also include functions:

import math
d = math.sqrt(a**2 + b**2)

Here, we’ve imported the math module and used the sqrt() function to calculate the square root of a^2 + b^2.

product = x * y
quotient = x / y

# Print statements
print("x =", x)
print("y =", y)
print("x + y =", sum)
print("x - y =", difference)
print("x * y =", product)
print("x / y =", quotient)

x = 10
y = 5
z = x + y
print(z)

This code will create two variables, x and y, assign them the values 10 and 5, respectively, and then add them together to create a new variable z with the value 15. Finally, the code prints the value of z.

Statements

In Python, a statement is a line of code that performs an action or task.

Statements are the smallest unit of code that can be executed and they represent an action or command. Each statement performs a specific task, such as defining a variable, calling a function, or creating a loop.

x = 10
print("Hello, world!")
def add_numbers(a, b):
    return a + b

In the above example, the first line (x = 10) is a statement that assigns the value 10 to the variable x. The second line (print(“Hello, world!”)) is a statement that prints the message “Hello, world!” to the console. The third line defines a function add_numbers that takes two arguments and returns their sum.

Statements vs Expressions

Some expressions can be statements, such as an assignment expression, which assigns a value to a variable.

However, not all statements are expressions. For example, a print statement does not evaluate to a value and cannot be used as part of an expression.

Script

A Python script is simply a collection of statements executed in order to achieve a desired outcome.

Python: Installation

Python is a high-level programming language used for a wide range of applications, from data analysis to web development.

Mac/Linux Users

• Option 1: Official installation instructions. Follow instructions on the official Python website. This is the most up-to-date and comprehensive guide to installing Python on your system.

• Option 2: Step-by-step installation guide. Check out our installation instructions for a step-by-step guide.

Windows Users

• Option 1: Official installation instructions. Follow instructions on the official Python website. This is the most up-to-date and comprehensive guide to installing Python on your system.

• Option 2: Step-by-step installation guide. Check out our detailed installation instructions for a step-by-step guide.

Python Libraries

Python libraries are collections of pre-written code that can be imported and used in your own programs, saving time and effort when developing complex applications.

Python Standard Library

Any installation of Python will include the standard library which includes a rich set of modules providing access to various system functionalities such as operating system interfaces, file I/O, network programming, data manipulation, and much more.

External Libraries

In addition, Python has a vast ecosystem of external libraries for various purposes, including data analysis, scientific computing, web development, machine learning, artificial intelligence, and more.

Python Tools

When you first install Python, you have access to the Standard Library.

However, to expand your capabilities and work with various Python projects, you want to install additional packages and dependencies.

Python offers a range of tools that make it easy to install, manage, and maintain these packages and dependencies.

We introduce just some of the popular tools along with recommendations for new personal projects.

Recommanded Approach

Since our goal is to get you started quickly, here’s the recommended way to help maximize these benefits from the beginning.

In each new project, create a pyproject.toml file that’s configured to use the following tools. We provide an example file that you can customize.

Don’t get too attached to preferences - each workplace will likely have their own standard set of preferred tools and processes.

⭐ Configure with pyproject.toml ⭐

Use Pyproject.toml for configuration. It can help remind us to set our virtual environment, install our dependencies, and format and lint our files for correctness and ease of use.

The pyproject.toml file can be used to configure these recommended tools.

• build-system: Hatch is a dependency management tool that can be used to publish Python packages to PyPI. Hatchling is a build backend for Hatch that is used to build packages. Both tools use the pyproject.toml file to configure the package’s metadata and dependencies.

• tool.black: Black is a Python code formatter that uses a pyproject.toml file to configure its behavior. You can specify options such as line length and whether to use single or double quotes in the pyproject.toml file.

• tool.pyright: Pyright is a static type checker for Python that can use a pyproject.toml file to configure its behavior. You can specify options such as which files to include or exclude from type checking, and which Python version to use in the pyproject.toml file.

• tool.ruff: Ruff is a Python build tool that uses a pyproject.toml file to specify tasks and dependencies for your project. You can define tasks such as building documentation or running tests, and specify the dependencies required for each task in the tools.ruff section of the pyproject.toml file.

Package Managers

Package managers allow you to fetch and install packages from the internet into your Python environment. Two widely used package managers in Python are pip and conda.

⭐ pip ⭐

pip is the default package manager for Python and makes it easy to install, update, and manage Python packages and dependencies. It is an essential tool for working with Python projects.

conda

conda is another popular package manager for Python, often used with the Anaconda or Miniconda distributions. It can be used alongside or as an alternative to pip.

Environment Managers

Python projects often require different versions of Python and different packages, making it essential to maintain and activate different environments as we work. Python offers two environment managers: venv and conda.

⭐ venv ⭐

venv is the default environment manager for Python and allows you to create and manage virtual environments within a Python project.

conda

conda can also be used as an environment manager in addition to its role as a package manager. It automatically activates a base environment upon installation and allows you to create and manage other environments as needed.

Python Formatters

Formatters are tools that help ensure consistent and readable code by automatically formatting Python code according to predefined styles and standards.

Many work environments will specify the tools and formats they prefer. Some may automatically apply formatting rules when code is pushed to a repository. The following recommendations are for personal projects.

⭐ Format with black ⭐

Black is a popular and highly-regarded Python formatter that aims to provide a simple and opinionated approach to code formatting. It reformats entire files in place, making it easy to integrate into automated workflows.

isort

Isort is a Python library and command-line tool that helps e nsure Python imports are properly sorted and formatted. It can automatically group imports by type and optimize the order of imports to reduce conflicts and improve readability. The Ruff linter includes isort functionality.

Python Linters

Linters are tools that analyze code and report on potential errors, style violations, and other issues. These tools help ensure that code is well-written, maintainable, and conforms to best practices.

⭐ Lint with Ruff ⭐

A new Python linter, Ruff, is gaining popularity. Ruff is a Rust-powered linter that aims to be faster and more reliable than traditional linters like Pylint and Flake8. It uses a Rust library called syntect for syntax highlighting and parsing, and leverages Rust’s memory safety and concurrency features to provide a faster and more reliable analysis.

Ruff offers several features that make it a promising option for Python developers, including integration with editors like VS Code, support for custom rule sets, and an easy-to-use command-line interface.

Ruff is configured using the standard pyproject.toml file and includes isort functionality.

Python Type Checkers

Type checkers are tools that analyze your code and attempt to find type-related errors before code runs. This helps catch errors earlier in the development process and can improve the overall quality of your code.

⭐ Typecheck with Pyright ⭐

Pyright is a popular type-checking tool for Python that uses static analysis to identify type-related errors in your code. Pyright supports Python 3.6 and above, and can be used in a variety of development environments, including VS Code and other editors.

When used in VS Code, Pyright provides real-time feedback and suggestions as you code, helping you catch errors and improve the overall quality of your code. Pyright also supports type annotations, allowing you to provide additional information about the types of variables and function arguments in your code.

Package Development and Distribution

⭐ Hatch and Hatchling ⭐

Hatch is a command-line tool for managing dependencies and environment isolation for Python developers. It allows developers to easily configure, version, specify dependencies for, and publish packages to PyPI. Hatch can be used to create new Python packages, add dependencies, and manage virtual environments.

Hatchling is a build backend for Hatch that is used to build Python packages. It provides a simple, declarative configuration file format that allows developers to specify the dependencies, entry points, and other package metadata. Hatchling can be used to build packages in different formats, including source distributions and wheels, and to upload them to PyPI or other package repositories.

Setuptools

Setuptools is a package development and distribution tool for Python that provides features such as package metadata, package installation, and dependency management. Setuptools is widely used and integrates with many other Python tools and frameworks, making it a popular choice for package development and distribution.

Flit

Flit is a lightweight tool for building and publishing Python packages. Flit provides features such as dependency management, virtual environments, and metadata management, and is designed to be simple and easy to use. Flit also supports building wheels for distribution, making it a good choice for creating packages that can be easily installed on different systems.

Python Build Tools

Using a build tool or command line runner in Python can help new analysts and developers automate repetitive tasks, streamline their workflow, and avoid having to retype complex commands.

There are several build tools available for Python projects that help automate the build process and manage dependencies.

Make

One such tool is Make, an older and widely used build tool that automates the building and testing of software. It is a powerful and flexible tool that can be used to manage complex build processes with many dependencies.

⭐ Build with Just ⭐

Another popular tool is Just, a newer command runner written in Rust. It uses a simple YAML configuration file called justfile.yaml to define tasks and their dependencies, and is designed to be fast and easy to use. Just is particularly useful for smaller projects that don’t require a full-fledged build system.

Python: AI and ML

Python is a popular programming language that has gained a lot of traction in the fields of artificial intelligence (AI) and machine learning (ML).

Python offers a range of libraries and frameworks that make it easier to develop and deploy AI and ML applications, including:

• NumPy: A library for numerical computing in Python, NumPy provides support for large, multi-dimensional arrays and matrices, as well as a range of mathematical functions for working with this data.

• pandas: A library for data manipulation and analysis in Python, pandas provides support for working with structured data in a variety of formats, including CSV, Excel, SQL databases, and more.

• Scikit-learn: A library for machine learning in Python, Scikit-learn provides a range of algorithms for classification, regression, and clustering, as well as tools for model selection and evaluation.

• TensorFlow: A popular library for machine learning and deep learning in Python, TensorFlow provides support for building and training neural networks, as well as tools for deploying models on a variety of platforms.

• Keras: A high-level neural networks API in Python, Keras provides a simple and intuitive interface for building and training deep learning models, as well as support for a range of backends, including TensorFlow.

Python: Environments

Python environments can be confusing at first, but they are essential for developing and deploying Python applications.

Overview

At a high level, you can think of Python environments as isolated “containers” that provide a controlled environment for your code to run in.

They are similar in some ways to operating systems, in that they provide a layer of abstraction between the code and the underlying system, and allow multiple applications to run independently without interfering with each other.

Python Environments

In the case of Python environments, the “container” is a self-contained installation of the Python interpreter and associated packages and dependencies.

Environments allow you to install and manage different versions of Python and packages without affecting other environments or your system Python installation.

By creating separate environments for each project, you can ensure that each project has access to the correct versions of Python and packages, and that packages do not conflict with each other.

This can help ensure that your code works consistently across different machines and environments, and can make it easier to manage and deploy your code.

Importance

There are several reasons why Python environments are important:

Version management

Different projects may require different versions of Python or packages. By creating separate environments for each project, you can ensure that each project has access to the correct versions of Python and packages.

Dependency management

Python packages often have complex dependencies on other packages. By isolating each project in its own environment, you can avoid conflicts between different packages and ensure that each project has the correct dependencies installed.

Reproducibility

By using environments, you can ensure that your code works consistently across different machines and environments. This is important when collaborating with others or when deploying your code to a production environment.

Tools

There are several tools available for managing Python environments, including:

• virtualenv
• conda
• pipenv

These tools make it easy to create, manage, and switch between environments, and can be integrated with development tools like IDEs and text editors.

Create / Activate / Install

In practice, creating a new environment involves using a tool like virtualenv or conda to create a new environment directory, activating the environment, and then installing the required packages and dependencies using pip or conda.

Using The Active Environment

Once the environment is set up, you can run your code within that environment, and any packages you install will be isolated to that environment.

Python: Fundamentals

Here is a quick summary of some basic concepts to get started programming with Python.

Human Languages

Python introductions are available in many human languages. See https://wiki.python.org/moin/Languages for more.

Syntax

Python has a simple and consistent syntax which makes it easy to learn and read.

Indentation is used to indicate a block of code, as opposed to curly braces or keywords like ‘begin’ and ’end’ in other languages.

Indentation matters! (a tab is not the same as spaces)

Comments

Comments are denoted by the hashtag or pound sign (#). Any text that follows the hashtag on the same line is c onsidered a comment and is ignored by the Python interpreter. Comments can be used to provide additional information about the code or to temporarily disable parts of the code during development or testing.

Variables

Variables are used to store values, like numbers or text strings. In Python, you can create a variable by assigning a value to it, like this:

x = 5

Data Types

Python has several built-in data types, including integers (whole numbers), floating point numbers, and strings (text). For example:

x = 5         # an integer
y = 3.14      # a floating-point number
z = "hello"   # a string

Basic Operations

Python supports basic mathematical operations like addition, subtraction, multiplication and division, use the following signs +, - , * , / respectively:

x = 5
y = 3
print(x + y)   # prints 8

Conditional Statements

Conditional statements allow you to check if certain conditions are true, and then run different code depending on the result. In Python, elif is used as the keyword for “else if”. For example:

x = 5
if x > 0:
    print("x is positive")
elif x ==0:
    print("x is zero")
else:
    print("x is negative")

Functions

Functions are blocks of code that can be reused throughout your program. They can take input values called parameters, and return one or more output values. For example:

def double(x):
    return x * 2

result = double(5)
print(result)  # prints 10

Loops

Loops are used to repeat a block of code multiple times. Python has two types of loops: for loops and while loops. For example:

for i in range(5):
    print(i) # will print 0, 1, 2, 3, 4

x = 0
while x < 5:
    print(x)
    x += 1

How To Learn

The best way to learn is by doing - experiment, type code, and build personal projects to gain skills. This is the only course in the program where we work through all the foundational topics. Other courses will jump right in to Python programming by example. It’s best to take this course early in the program and master these basics early.

Big Wins

Reddit comment on suggested “big wins in Python” - when you see these, know they’re considered pretty useful skills.

https://www.reddit.com/r/learnpython/comments/10ka2dm/comment/j5pciik/

• extended libraries (e.g. pandas, NumPy)
• context managers (with open() as file:)
• lambda functions, zip(), map(), filter(), enumerate()
• comprehensions (concise and very impressive/useful)
• regular expressions
• sorting (faker is pretty useful, too)
• type-hinting - easy and recommended! No more wondering if x is a string or an int - make it so! This is pretty new and valuable skill. It looks a lot like Swift.

Python: Organization

This page provides an overview of the fundamental building blocks of Python code organization.

Variable

A variable is a named memory location that holds a value.

Expression

An expression is a combination of operators (e.g. +) and operands (e.g. 1 or age) that resolves to a value.

Statement

A statement is the smallest unit of a Python script. All scripts are made up of statements. Some statements are expressions, while others are not (e.g. print(“hello”)).

Function

A function is a reusable block of code that performs a specific task. Functions help to break up large programs into smaller, more manageable pieces, and can be reused across different parts of a program or across different programs.

Class

A class is a blueprint for creating objects in Python. Classes define the attributes (data fields) and methods (functions) that all objects of a certain type will have. Using classes, we can create multiple instances (objects) of a certain type, each with their own unique attributes.

In Python, classes are optional, but many modules use an object-oriented approach to organizing code.

Object

An object is a specific instance of a class that holds real data. For example, if we have a Dog class, we can create two objects, sam = Dog("Sam", 3) and fido = Dog("Fido", 4), each with their own name and age attributes.

File / Module

In Python, a module is a file containing Python definitions and statements. Each .py file is a Python script and, by definition, a Python file is also a module. The name of the module is the same as the name of the file, without the .py extension.

Package

A package is a way of organizing related modules together. Packages allow us to group together related functionality in a way that is easy to import and use. A package is simply a directory that contains one or more Python modules.

Library

A library is a collection of packages and modules that provides a set of pre-written code for specific tasks. For example, the Python Standard Library is a large collection of libraries that are included with Python and provide a wide range of functionality, f rom file input/output to regular expressions to networking.

Python Distribution Methods

Python also has some special entities related to distributing Python code to users.

Python Distributions

A distribution is a bundle of Python software, which typically includes the Python interpreter, the Python standard library, and various additional packages and tools.

There are several popular Python distributions available, such as Anaconda, which includes many data science packages and tools, and Python(x,y), which is geared towards scientific computing.

Python distributions can make it easier to set up and manage a Python environment, especially for beginners, and come with many pre-installed packages and tools.

Python Wheels

A wheel is a self-contained installation executable that can be used to easily distribute and install Python packages across different systems.

Wheels are different from source distributions or packages, which are typically distributed as source code and must be compiled or built before they can be installed.

A wheel is essentially a ZIP archive that contains the files and dependencies necessary for a Python package to be installed on a system. It makes installation faster and easier, as the package does not need to be built from source code each time it is installed on a new system.

Wheels are platform-specific, meaning that a wheel built on one operating system or architecture may not work on another system with a different operating system or architecture. To address this, Python has a system of tags to identify which platforms a wheel is compatible with, so the correct version of the wheel can be downloaded and installed on each system.

Understanding Organization

Understanding the fundamental building blocks of Python organization and distribution is essential for employing available Python tools and writing clean, well-structured code that is easy to read, maintain, and reuse.

Python: pandas

pandas is a popular open-source library for data analytics in Python. It provides powerful tools for working with tabular data, such as data frames and series. With pandas, you can easily read, manipulate, and analyze data in a variety of formats, including CSV, Excel, SQL databases, and more.

One of the key features of pandas is its ability to handle missing data. pandas provides a number of methods for filling in missing data, interpolating values, and dropping missing data altogether. This is a critical feature for data analytics, as real-world data is often incomplete or inconsistent.

pandas performs complex data transformations and aggregations. With pandas, you can group data by one or more columns, apply functions to subsets of data, and pivot data to reshape it in different ways.

pandas provides tools for merging and joining data from multiple sources, making it easy to combine data from different sources into a single data set.

Being good with pandas is a valuable skill.

Faster Options

pandas can be a bit slow. Options include:

• Moving to the faster pandas 2.0
• Trying Polars

New! Read More about this important 2.0 update

• ⭐ Pandas 2.0 and its Ecosystem (Arrow, Polars, DuckDB) ⭐

pandas 2.0

pandas 2.0 is a significant update the to the beloved pandas.

Learn more at:

• pandas 2.0 (official)
• pandas 2.0 and its Ecosystem (Arrow, Polars, DuckDB)

Polars

Polars is a data manipulation library written with Rust that aims to provide a fast, memory-efficient alternative to pandas for large-scale data processing. It’s still a relatively new library, having been first released in 2019, a nd its user base and ecosystem are still growing.

Polars has a lot of potential as a fast and memory-efficient data manipulation library for large datasets, but it’s still a relatively new library and may not have the same level of maturity and ecosystem as pandas.

Python: Project Management

There are several ways to manage dependencies and project metadata in Python. While they differ in their syntax and capabilities, they can all be used to specify the dependencies required for a Python project.

pyproject.toml

pyproject.toml is a configuration file used in modern Python projects to specify various aspects of the project, including its dependencies, build settings, and package metadata. It is part of the Python Packaging ecosystem, which provides a standardized way to manage Python packages and their distribution.

pyproject.toml is similar to Project.toml, used in Julia projects.

pyproject.toml is used by the Poetry package manager, a popular tool for managing dependencies and building Python projects. Poetry relies on the pyproject.toml file to define the project’s dependencies, and uses this information to create a virtual environment for the project and install the necessary dependencies.

It provides a simple, declarative way to manage project dependencies, without the need for separate requirements.txt or setup.py files. It also allows developers to specify other project metadata, such as its version number, author, and license.

With pep-0621 pyproject.toml is the standard for managing Python projects, and increasingly used by many popular Python packages and tools.

By adopting pyproject.toml and the Python Packaging ecosystem, developers ensure that their projects are well-organized, maintainable, and easily sharable with others in the Python community.

Poetry

Poetry is a modern Python packaging and dependency management tool that helps simplify the process of managing dependencies and building projects. It allows developers to define their project dependencies in a declarative way using a simple pyproject.toml file, rather than relying on separate requirements.txt or setup.py files.

One of the key advantages of using Poetry is that it provides a streamlined workflow for managing dependencies and virtual environments. It can automatically create and manage virtual environments for each project, isolating project dependencies and avoiding conflicts with system-level packages. Poetry also provides powerful tools for managing dependencies, including automatic dependency resolution, dependency locking, and the ability to publish and install packages from both PyPI and private repositories.

Another advantage of using Poetry is that it provides a simple, consistent interface for managing all aspects of a Python project, from dependency management to building and publishing packages. This makes it easier for developers to focus on writing code and building their projects, without getting bogged down in the details of project management.

Legacy Project Management

Although pyproject.toml is the new standard for managing dependencies and metadata in modern Python projects, you may still encounter older projects that use requirements.txt and setup.py.

requirements.txt is a file used to specify a project’s dependencies in a simple, text-based format. Each line in the file lists a package name and version number, separated by an equals sign. This format is easy to read and edit, and is supported by many Python tools and frameworks. However, it lacks some of the advanced features provided by pyproject.toml, such as the ability to specify package metadata and build settings.

setup.py is a script used to build and distribute Python packages. It includes metadata about the package, such as its name, version, and author information, as well as instructions for building and installing the package. Although setup.py is still used in many projects, it has some limitations, such as the inability to specify dependencies with the same level of detail as pyproject.toml.

Recommendations

If you’re starting a new Python project from scratch, it’s generally not recommended to use requirements.txt or setup.py as the primary method for managing dependencies and metadata. Instead, you should use pyproject.toml, which is the modern standard for these tasks.

However, if you’re working with an existing project that uses requirements.txt or setup.py, it’s often necessary to keep these files around for compatibility reasons. For example, if you’re working on a project that is already deployed to production and relies on requirements.txt to specify its dependencies, you may not want to switch to pyproject.toml right away, since this could cause compatibility issues or require a significant amount of testing.

Python: Scripts

A Python script is a file containing Python code that can be executed by the Python interpreter.

Scripts can be used to automate tasks, perform calculations, or interact with other software systems.

Run A Script

To run a Python script, you need to have the Python interpreter installed on your system. Once you have installed Python, you can run a script by opening a terminal or command prompt, navigating to the directory containing the script, and typing python myscript.py (replacing myscript with the name of your script).

For example, if you have a script named myscript.py in a directory called myproject, you can run it by opening a terminal or command prompt, navigating to the myproject directory, and typing python myscript.py.

If your script requires any command-line arguments, you can pass them to the script by including them after the script name. For example, if your script requires a filename as an argument, you could run it like this: python myscript.py myfile.txt.

When you run a Python script, the interpreter reads the code in the file and executes it. Any output produced by the script is printed to the console.

Python: Try/Except

Code Might Fail

It’s important to use try/except/finally whenever your application could fail through no fault of your own.

Why Plan for Errors?

People ask:

• Why plan for errors?
• Shouldn’t we fix all errors in our code before we release it?
• Why do we need try/except/finally?

Perfect Code Can Still Have Exceptions

We should always strive to fix all coding and logic errors. However, sometimes our code can be perfect - but exceptions can still happen. try/except/finally is a way to gracefully handle unexpected errors and prevent our program from crashing.

Example

Suppose you write a script to read baseball_game_results.csv each night at midnight.

It runs fine until someone changes the filename to rslts.csv.

Now, your code terminates with an ugly error because the necessary file can’t be found.

To code professionally, we can use try/except to handle this error gracefully.

try:
    # Attempt to open the file
    with open('baseball_game_results.csv', 'r') as f:
        # Do something with the file
        
except FileNotFoundError:
    # Handle the case where the file is not found
    print('ERROR: File not found. Please name the file to baseball_game_results.csv')
finally:
    # Clean up any resources (e.g. file handles) used by the code
     

Other Programming Languages

Other programming languages use something very similar, but might use the keywords try/catch/finally. As in “try this, and if you catch an exception, do this.”

Throwing Exceptions

Exceptions are thrown by nested functions, up, up, up, until some level “catches” the exception and deals with it, or the program terminates with an ugly error.

It’s important to handle exceptions gracefully and prevent our programs from crashing.

Python: Uninstalling

Python seems to install a bit like a virus and traces can get everywhere.

At times, removing an old version of Python can be challenging.

Cleaning up unneeded Python installations can help avoid conflicts between different Python versions and packages.

Using package managers and virtual environments can help.

Uninstalling

Installations can leave traces on your system that may no longer be needed. Here are some recommendations for cleaning up old Python installations:

1. Uninstall Python from the Control Panel: If you have installed Python using the official installer on a Windows machine, you can uninstall it from the Control Panel. Simply search for “Add or Remove Programs” in the Start menu, then find the Python installation you want to remove and click “Uninstall”.

2. Delete Python folders: Python installations typically create folders on your system that can be deleted to remove the installation. The main folders are typically located in C:\Python or C:\Users\{user}\AppData\Local\Programs\Python. Be careful when deleting folders to ensure you are only deleting the correct installation.

3. Clean up environment variables: Python installations can add environment variables to your system that may no longer be needed. You can clean these up by going to the System Properties window, selecting “Advanced System Settings”, then clicking the “Environment Variables” button. Here you can remove any Python-related environment variables that are no longer needed.

Management Tools

Managing Python well can help avoid issues. The following recommendations can help.

1. Use a package manager: Using a package manager like conda or pipenv can help keep track of Python installations and dependencies. These package managers allow you to create isolated environments for specific projects, so you can avoid installing unnecessary packages and versions of Python.

2. Use virtual environments: Another way to manage multiple Python installations is to use virtual environments. Virtual environments allow you to create isolated environments for specific projects, so you can avoid conflicts between different Python versions and packages. You can create virtual environments using the venv module or third-party tools like virtualenv or conda.