This guide walks you through every step of writing, saving, and running a Python script on Windows, including multiple methods, common mistakes beginners make, and where to go from here. Whether you are a student, a curious hobbyist, or someone switching careers into tech, this tutorial is written with you in mind.

Before You Begin: What You Need

You will need Python installed on your Windows computer. If you have not done this yet, head over to python.org/downloads and grab the latest stable version. During installation, make sure to check the box that says “Add Python to PATH” — this is the most common setup mistake beginners make, and skipping it causes problems we will cover in the troubleshooting section below.

If you haven’t installed Python, follow  our Complete Python Installation Guide

You also need a text editor. Here are your three best options:

• Notepad — Already on your PC, no installation required. Fine for a quick start.
• VS Code (Visual Studio Code) — Free, powerful, and what most professional developers use. Recommended for anyone serious about learning Python.
• IDLE — Comes bundled with Python automatically. Simple and beginner-friendly.

There is no wrong choice here. Pick whichever one feels most comfortable and get started.

Step 1: Write Your First Python Program

Open your text editor and type the following two lines exactly as shown:

print("Hello, World!")
print("Your first Python script is running!")

That is your entire first program. Two lines. Simple — but do not underestimate it.

What is print() and why does it matter?

The print() function is one of the most used tools in Python. It tells Python to display whatever is inside the parentheses on the screen. The text inside the quotation marks is called a string — a sequence of characters Python treats as plain text.

When you run this script, Python reads line 1, prints the first message, then reads line 2, prints the second message, and stops. Python executes code from top to bottom, one line at a time. This is called sequential execution, and it is one of the fundamental concepts behind all programming.

If you want, try adding a third line:

print("I am learning Python!")

Python will print all three messages in order. This is your first experience with how programs actually work.

Step 2: Save the File Correctly

This step trips up more beginners than any other. Pay close attention.

Go to File > Save As in your text editor and follow these rules:

1. Name the file hello.py — the .py extension tells Windows (and Python) that this is a Python script.
2. Save it somewhere you can easily find. A folder called PythonProjects inside your Documents folder is a great habit to start early. You could also save to the Desktop for now.
3. In Notepad specifically, change “Save as type” from Text Documents (*.txt) to All Files (*.*) before saving. Otherwise Notepad silently saves it as hello.py.txt, which will not run as a Python script.

How to check your file was saved correctly

Open File Explorer and navigate to where you saved the file. If you see hello.py with a Python logo icon, you are good. If you see hello.py.txt, you need to rename it.

Quick fix for hidden extensions: Windows hides file extensions by default. To turn this off, open File Explorer, click the View tab at the top, and check the box labeled “File name extensions”. Now you can see the real name of every file on your computer — a useful habit for any developer.

Step 3: Open Command Prompt or PowerShell

The command line is where you actually run Python scripts. It looks intimidating at first, but you will be comfortable with it after a few minutes.

How to open Command Prompt:

• Press the Windows key, type cmd, and press Enter.
• Or press Windows key + R, type cmd, and press Enter.

How to open PowerShell:

• Press the Windows key, type PowerShell, and press Enter.

Both work fine for running Python scripts. Command Prompt is slightly simpler; PowerShell is more powerful. Either is fine for what we are doing here.

You will see a black window with a blinking cursor. This is the terminal — a text-based interface for talking directly to your computer. It is the same kind of tool that developers all over the world use every day.

Step 4: Navigate to Your Script’s Folder

The terminal starts in a default location, usually your user folder (something like C:\Users\YourName). You need to navigate to the folder where you saved hello.py.

The command you use is cd, which stands for change directory. Here are examples:

If you saved your file on the Desktop:

cd Desktop

If you saved it in a PythonProjects folder inside Documents:

cd Documents\PythonProjects

If you ever get lost, you can always type cd %USERPROFILE% to return to your home folder and start again.

Confirm you are in the right place

Once you navigate to the folder, type this command and press Enter:

dir

This lists every file in the current folder. If you see hello.py in the list, you are in exactly the right place. If you do not see it, you are in the wrong folder — use cd again to find it.

Step 5: Run the Script

This is the moment everything comes together. Type the following command and press Enter:

python hello.py

Your terminal should display:

Hello, World!
Your first Python script is running!

Congratulations. You just ran your first Python program. Your setup is working correctly, and you have taken a real step into software development.

Alternative Ways to Run Python Scripts

The command line is not the only option. Here are three other methods, each with its own advantages.

Method 1: Using IDLE (Best for Beginners)

IDLE is Python’s built-in editor and is perfect if you want a simple, distraction-free environment.

1. Press the Windows key and search for IDLE.
2. Open it. You will see the Python Shell — a place where you can type Python code directly.
3. Go to File > Open and select your hello.py file.
4. Press F5 (or go to Run > Run Module).

The output appears in the Shell window at the bottom. IDLE also highlights your code in different colors (called syntax highlighting), making it easier to read and spot mistakes.

Method 2: Using VS Code (Best for Serious Learning)

VS Code is the industry-standard editor for Python development. It is more complex than IDLE but far more powerful, and learning it now will pay off later.

1. Download VS Code from code.visualstudio.com.
2. Install the Python extension (you will be prompted on first launch, or search for “Python” in the Extensions panel).
3. Open your project folder: File > Open Folder and select your PythonProjects folder.
4. Click on hello.py in the sidebar to open it.
5. Press Ctrl+F5 or click the Run Python File button (the play icon in the top-right corner).

VS Code runs the script and shows the output in a built-in terminal panel at the bottom. You also get autocomplete suggestions, error highlighting, and a debugger — tools that become invaluable as your programs grow.

Method 3: Double-Clicking the File

You can right-click hello.py in File Explorer and choose Open with > Python. A terminal window will open, run the script, and then close immediately — often too fast to read.

To keep the window open long enough to see the output, add this line at the very end of your script:

input("Press Enter to close...")

This pauses the program and waits for you to press Enter before the window closes. It is a quick fix, but for most learning purposes, using the terminal or VS Code is a better habit to develop.

Troubleshooting Common Problems

“Python is not recognized as an internal or external command.”

This means Python is not in your system’s PATH — Windows does not know where Python is installed.

Quick fix: Try using py instead of python:

py hello.py

Permanent fix: Reinstall Python from python.org and make sure to check “Add Python to PATH” during installation. After reinstalling, restart Command Prompt and try again.

“No module named…”

This error usually means one of two things. Either you are in the wrong folder (so Python cannot find your file), or you are trying to use an external library that has not been installed yet.

For our simplehello.py, this should not happen. If it does, type dir to list the files in your current folder and confirm hello.py if it’s there. If not, use cd to navigate to the correct location.

The terminal window opens and closes instantly

This happens when you double-click a .py file. The script runs and finishes in a fraction of a second, and Windows closes the terminal. Add input("Press Enter to close...") to the end of your script to pause it, or use the command line method instead — which gives you full control.

The output shows an error in red text

Red text means Python found a problem in your code. Read the error message carefully — Python error messages are actually quite informative once you learn to read them. Common causes include:

• A missing closing quote: print("Hello, World! — notice no closing "
• Wrong capitalization: Print("Hello") instead of print("Hello") — Python is case-sensitive
• Missing parentheses: print "Hello" — valid in older Python 2, but not in Python 3

Understanding What Just Happened (The Bigger Picture)

When you typed python hello.py and pressed Enter, several things happened behind the scenes:

1. Windows found the Python program installed on your computer.
2. Python opened and read your hello.py file.
3. Python translated your human-readable code into instructions the computer can execute.
4. The computer executed those instructions and sent the output to your screen.

This process is called interpretation — Python reads and runs your code line by line, without first compiling it into a separate file the way some other programming languages do (like C++ or Java). This is one reason Python is so beginner-friendly: the feedback loop between writing code and seeing results is almost instant.

What to Do Next

Now that your setup is confirmed and you understand how running a script works, here are five things to try immediately:

1. Change the message. Edit hello.py, change the text inside the quotes, save, and run again. Get comfortable with the edit-save-run loop.

2. Add more print lines. Try printing your name, your age, your favorite movie — anything. See how each line appears in order.

3. Use the input() function. Replace your second print line with:

name = input("What is your name? ")
print("Hello, " + name + "!")

This makes your program interactive. The user types a name, and Python greets them by name. You have just written your first program with user input.

4. Experiment with math. Python is a calculator too. Try:

print(2 + 2)
print(10 * 5)
print(100 / 4)

No quotes needed for numbers — Python handles them differently from text.

5. Make your first mistake on purpose. Delete a closing quote or misspell print. Run the script. Read the error message. Getting comfortable with Python’s error messages is one of the fastest ways to become a better programmer.

Final Thoughts

Writing and running your first Python script is a simple act with a significant meaning. It proves your environment is set up correctly, teaches you how the terminal works, and gives you a concrete foundation to build on.

From here, every Python concept you learn — variables, loops, functions, libraries, web scraping, data analysis, automation — will be built on top of this exact workflow: write code, save the file, run the script, see the result.

The gap between a beginner and a confident Python developer is just practice. And practice starts with python hello.py.

The good news is that this problem is almost never serious. In most cases, it happens because Windows cannot locate the pip command, not because pip is broken or missing forever. Once you understand why the error appears, fixing it becomes a logical and repeatable process.

This guide explains what the error actually means, why it happens, and how to fix it step by step, even if you are completely new to Python and Windows command-line tools.

What “pip Is Not Recognized” Actually Means

When Windows displays this error, it is not saying that pip does not exist. Instead, it is saying:

“I don’t know where pip is located.”

On Windows, commands like pip, python, or git only work when their locations are listed in something called the PATH environment variable. PATH is simply a list of folders that Windows checks when you type a command in Command Prompt or PowerShell.

If the folder containing pip.exe is not listed in PATH, Windows will fail to find it—even if pip is correctly installed.

This is why the error is so common:

• Python may be installed
• pip may be installed
• but Windows does not know where to look

Understanding this concept makes the rest of the fixes much easier to follow.

Why This Problem Happens So Often on Windows

Unlike some operating systems where tools are automatically available, Windows relies heavily on PATH configuration. During Python installation, there is a small checkbox called “Add Python to PATH”. If this is skipped—even once—pip commands may stop working.

Other common reasons include:

• Python was installed from a custom location
• More than one Python version is installed
• The terminal was opened before PATH was updated
• Python was partially installed or upgraded incorrectly

None of these mean your system is broken. They simply mean Windows needs clearer instructions.

Step 1: Confirm That Python Is Installed

Before fixing pip, make sure Python itself is working.

Open Command Prompt or PowerShell, then type:

python --version

What the result means:

• Version number appears → Python is installed and responding
• Command not found → Python is missing or not added to PATH

If Python itself is not recognized, reinstall Python first and make sure PATH is enabled during setup. Fixing pip without Python working correctly is not possible.

Step 2: Try Using pip Through Python Directly

Even if the pip Command fails, pip may still exist and work internally.

Try this command instead:

python -m pip --version

If this prints a version number, pip is installed and functional. The issue is only with the shortcut command, not pip itself.

This method works because:

• Python directly loads pip as a module
• PATH is bypassed
• Windows does not need to find pip.exe

You can also install packages this way:

python -m pip install requests

Many experienced developers prefer this approach because it is more reliable when multiple Python versions exist.

Step 3: Understand Where pip Lives on Windows

On Windows, pip is stored inside a folder called Scripts, which lives inside the main Python directory.

Typical locations look like this:

C:\Users\YourName\AppData\Local\Programs\Python\Python3xx\Scripts

or

C:\Python3xx\Scripts

Inside this folder, you should see:

• pip.exe
• pip3.exe
• other related tools

If Windows does not know about this folder, it cannot run pip—even though the file exists.

Step 4: Add Python and Scripts to the PATH Variable

This is the most common and most effective fix.

How to add PATH correctly on Windows

1. Open the Start Menu
2. Search for Environment Variables
3. Click Edit the system environment variables
4. Select Environment Variables
5. Under System variables, find Path
6. Click Edit
7. Add:
   • The main Python folder
   • The Python Scripts folder
8. Click OK on all windows
9. Close all terminals

After doing this, Windows will know where to find both Python and pip.

Important note

Always open a new terminal window after changing PATH. Existing terminals will not see the update.

Step 5: Test pip Again After Updating PATH

Open a new Command Prompt and type:

pip --version

If PATH is set correctly, Windows should now find pip and display its version.

If it still does not work, do not panic. There are still reliable fixes available.

Step 6: Reinstall Python the Right Way (Recommended Fix)

If your setup feels messy or inconsistent, reinstalling Python is often faster than troubleshooting every detail.

During installation, make sure you:

• Check Add Python to PATH
• Ensure pip is selected in optional features
• Use the default installation location unless you have a reason not to

After installation:

• Restart your computer (recommended)
• Open a new terminal
• Test both python --version and pip --version

A clean reinstall resolves most PATH-related issues in minutes.

Step 7: Use the Python Launcher on Windows

Windows often installs a tool called the Python launcher, which helps manage multiple versions.

Try:

py --version

If it works, you can also use:

py -m pip install numpy

This approach avoids confusion when:

• Multiple Python versions exist
• PATH points to the wrong interpreter
• pip commands behave inconsistently

It is especially helpful on systems used for learning or experimentation.

Step 8: Check whether pip Is Actually Installed

In rare cases, pip may not be installed at all.

You can check by navigating to your Python folder and opening the Scripts directory. If pip.exe is missing, pip was not installed correctly.

To fix this:

• Rerun the Python installer
• Choose Modify
• Enable pip
• Complete the setup

Once installed, repeat the PATH check and restart the terminal.

Quick Fix Checklist (For Fast Troubleshooting)

If you want the shortest solution path, follow this order:

1. Check python --version
2. Try python -m pip --version
3. Add Python and Scripts to PATH
4. Restart terminal
5. Reinstall Python if needed

This sequence fixes most systems without advanced steps.

Common Mistakes That Cause This Error

Many users run into the same problems repeatedly. Avoid these mistakes:

• Installing Python from unofficial websites
• Skipping “Add Python to PATH”
• Installing packages without activating a virtual environment
• Using old terminal windows after changing settings
• Mixing multiple Python versions without knowing which one is active

Being aware of these issues prevents future errors and saves time.

How Virtual Environments Affect pip

When using virtual environments, pip behaves differently.

If your virtual environment is not activated, pip installs packages globally.
If it is activated, pip installs packages inside that environment only.

This is normal behavior and not an error.

If pip suddenly “disappears,” check whether:

• The environment is activated
• The terminal is using the correct interpreter

Understanding this avoids confusion when switching between projects.

Final Thoughts

Seeing “pip is not recognized” on Windows can feel intimidating, but it is almost always a configuration issue—not a failure. Once PATH is set correctly or Python is reinstalled properly, pip becomes stable and predictable.

The most important takeaway is this:

• pip is rarely broken
• Windows just needs clear instructions

After fixing this issue once, you will rarely face it again. And once pip works properly, installing libraries, building projects, and learning Python becomes much smoother and more enjoyable.

A virtual environment gives each Python project its own isolated space for packages and dependencies. This prevents one project from interfering with another and helps you avoid many common problems beginners face when installing libraries.

According to Python Software Foundation documentation, virtual environments are a standard part of modern Python development. The Python Packaging Authority (PyPA) also recommends using them for clean, predictable project setups.

In this guide, you will learn:

• What a virtual environment is
• Why beginners should use one
• How to create and activate a virtual environment on Windows
• How to install packages safely
• Common mistakes to avoid
• How virtual environments work with VS Code

No advanced knowledge is required. If Python is already installed, you’re ready to begin.

What Is a Virtual Environment in Python?

A virtual environment is a self-contained directory that includes:

• A Python interpreter
• Its own pip tool
• A private folder for installed packages

This environment is separate from your system Python installation. Any packages you install inside it are only available to that specific project.

Why does this matter?

Without virtual environments, Python installs packages globally. This can quickly lead to problems when:

• Two projects require different versions of the same library
• Updating one package breaks another project
• You forget which packages belong to which project

A virtual environment solves this by keeping everything isolated. Each project gets exactly what it needs—nothing more, nothing less.

This isolation is the reason virtual environments are considered best practice, even for beginners.

Why Beginners Should Use Virtual Environments

Many beginners skip virtual environments at first. The problems usually appear later.

Here’s what often happens without one:

• You install a package globally
• A different project stops working
• You don’t remember what changed
• Debugging becomes frustrating

Using a virtual environment from the start helps you avoid:

• Dependency conflicts
• Broken projects
• Hard-to-trace errors
• Messy system Python installations

It also teaches you real-world Python workflow habits early, making it much easier to work on larger projects later.

Even for simple learning scripts, virtual environments are worth using.

Before You Start

Before creating a virtual environment, make sure:

• Python is installed on your system
• You can open a terminal
• You know where your project folder is located

Modern Python versions include the built-in venv module, so you do not need to install anything extra.

You can use:

• Command Prompt
• PowerShell
• Windows Terminal
• The integrated terminal in Visual Studio Code

Step 1: Open or Create Your Project Folder

First, create or open the folder where your Python project will live.

Example:

mkdir myproject
cd myproject

Now open a terminal inside this folder. This is important because the virtual environment should live inside the project, not somewhere else on your system.

Why name the folder .venv?

A commonly recommended name for virtual environments is .venv.

Python’s own tutorial mentions .venv as a popular choice because:

• It stays out of the way
• It avoids confusion with .env files
• Many tools automatically detect it

Using .venv is a clean, modern default.

Step 2: Create the Virtual Environment

Run the following command inside your project folder:

python -m venv .venv

This command tells Python:

• Use the built-in venv module
• Create a virtual environment
• Store it in a folder named .venv

The Python Packaging Authority uses this exact pattern in its examples, making it a widely accepted standard.

Alternative command on Windows

If your system uses the Python launcher, this also works:

py -m venv .venv

Python’s documentation explains that the virtual environment is created using the Python version that runs the command. That’s why python -m venv (or py -m venv) matters.

Step 3: Activate the Virtual Environment

Creating the environment is not enough—you must activate it.

Activation tells your terminal:

“Use the Python inside this project, not the system Python.”

Activation commands on Windows

Command Prompt:

.venv\Scripts\activate.bat

PowerShell:

.venv\Scripts\Activate.ps1

On Windows, activation scripts live inside the Scripts folder of the environment.

How do you know it worked?

Once activated, your terminal prompt usually changes to show:

(.venv)

This means the virtual environment is active.

Step 4: Verify the Virtual Environment Is Working

Now confirm that your terminal is using the correct Python.

Run:

python --version

Then check the Python path:

where python

While the environment is active, the path should point to something like:

...\myproject\.venv\Scripts\python.exe

The packaging guide explains that this confirms Python is being loaded from the virtual environment, not the global installation.

Step 5: Install Packages Safely Inside the Environment

Once the environment is active, any package you install with pip goes only into that environment.

Example:

pip install requests

Now the requests library is available to this project only.

This is the main benefit of virtual environments:

• No global pollution
• No accidental conflicts
• Cleaner project dependencies

If you deactivate the environment and open another project, that package will not appear there.

Step 6: Deactivate the Virtual Environment

When you are done working, you can exit the environment by typing:

deactivate

This returns your terminal to the normal system Python.

The standard workflow is:

1. Create the environment
2. Activate it
3. Work on the project
4. Deactivate when finished

This cycle becomes second nature very quickly.

Using Virtual Environments in VS Code

If you use Visual Studio Code, virtual environments integrate smoothly.

Steps:

1. Open the project folder in VS Code
2. Open the command palette
3. Select Python: Select Interpreter
4. Choose the interpreter inside .venv

According to guides from Real Python, VS Code can automatically detect environments and display paths like:

.venv\Scripts\python

Once selected:

• VS Code uses the correct packages
• Linting works properly
• Debugging becomes more reliable

Common Mistakes Beginners Make

Most virtual environment issues come from a few simple mistakes:

• Creating the environment outside the project folder
• Forgetting to activate the environment before installing packages
• Using the wrong activation command
• Installing packages globally by accident
• Deleting .venv without understanding what it does
• Committing .venv to Git

The Python Packaging Authority specifically recommends excluding virtual environments from version control.

Add this to .gitignore:

.venv/

Should You Use .venv or venv?

Both names work, but .venv is often the better choice.

Reasons .venv is recommended:

• Mentioned in Python’s tutorial
• Hidden in many file explorers
• Avoids confusion with .env
• Recognized by many tools

If you are just starting out, .venv is a safe and modern default.

Quick Example: Start to Finish

Here’s the full basic workflow:

mkdir myproject
cd myproject
python -m venv .venv
.venv\Scripts\activate.bat
pip install requests
python --version
deactivate

This sequence:

• Creates a project
• Creates a virtual environment
• Activates it
• Installs a package
• Verifies Python
• Exits the environment

This matches the workflow described in official Python and PyPA guides.

Final Thoughts

Creating a virtual environment in Python is one of the simplest and most valuable habits you can develop early.

It keeps projects isolated, avoids dependency conflicts, and makes your development workflow cleaner and more professional—even as a beginner.

This is not an advanced trick. It is a basic foundation skill that will save you time, confusion, and frustration as you learn Python.

Once you get used to:

python -m venv .venv

project setup becomes faster, cleaner, and far less stressful.

If you have ever searched for “Python is not recognized as an internal or external command” after installing Python, you are not alone. This is one of the most common beginner problems—and it usually comes from a small setup mistake.

This guide walks you through the entire Python installation process on Windows, step by step, using clear explanations and beginner-friendly language. By the end of this article, you will not only have Python installed correctly, but you will also understand why each step matters so that you can avoid problems later.

The goal is simple:
  Install Python once, install it correctly, and start coding without frustration.

What You Need Before Starting

Before installing Python, make sure you have a few basic things ready. You do not need advanced technical knowledge or special tools.

You will need:

• A Windows computer (Windows 10 or Windows 11 recommended)
• A stable internet connection
• Permission to install software on your system
• A modern web browser such as Chrome, Edge, or Firefox
• About 5–10 minutes of uninterrupted time

That’s it. You do not need to create an account, pay for anything, or download additional software at this stage.

For most beginners, the official Python installer from python.org is the safest and most reliable option. This is the source recommended by Python itself and supported by Microsoft for Windows users.

Step 1: Download Python for Windows

The first step is to download Python from the official source.

Open your browser and go to the Python Downloads for Windows page on python.org. This page always shows the latest stable release, which is what beginners should use. Avoid beta or pre-release versions unless you know exactly why you need them.

Which version should you download?

• Choose Windows installer (64-bit)
• This is the correct option for almost all modern computers
• Only use 32-bit if you are certain your system requires it

Most Windows systems today are 64-bit, so if you are unsure, go with the 64-bit installer. This version offers better performance and compatibility with modern libraries.

Important warning:
Avoid downloading Python from third-party websites. Unofficial installers can be outdated, incomplete, or bundled with unwanted software. Always use python.org.

Step 2: Run the Python Installer (Very Important Step)

Once the download finishes, locate the installer file (usually in your Downloads folder) and double-click it to begin the setup.

This screen is where many beginners feel nervous—but don’t worry. You only need to focus on one critical option.

Check “Add python.exe to PATH.”

On the first installer screen, you will see a checkbox that says:

“Add python.exe to PATH.”

Make sure this box is checked before clicking anything else.

This step is extremely important.

Why does PATH matter?

PATH allows Windows to find Python when you type python in Command Prompt or Terminal.
If you skip this step, Python will still install, but Windows won’t know where it is—leading to errors later.

Most Python installation problems come from forgetting this one checkbox.

** The latest installer may set the Path Variable without asking, so read the instructions carefully.

Step 3: Choose the Right Install Option

After checking “Add python.exe to PATH,” you will see two main options:

• Install Now
• Customize installation

Which one should beginners choose?

Choose “Install Now.”

This option installs:

• Python itself
• pip (Python’s package manager)
• Standard libraries
• Required system tools

It is more than enough for:

• Learning Python basics
• Writing scripts
• Beginner projects
• Web development
• Automation
• Data analysis learning

Should you use “Customize installation”?

Only use this if:

• You already understand Python environments
• You need Python in a specific folder
• You are following an advanced setup guide

For first-time users, customizing options often causes unnecessary confusion. Stick with the default installation path.

Step 4: Wait for Installation to Finish

After clicking Install Now, Python will begin copying files and configuring your system.

This usually takes less than a minute on most computers.

During installation:

• Windows may ask for administrator permission
• Click Yes if prompted
• Do not close the installer window early

Once completed, you should see a success message confirming that Python was installed successfully.

At this point, Python is installed—but we still need to verify it works correctly.

Step 5: Verify Python Installation Using Terminal

Verification is the step many beginners skip—and later regret. Let’s do it properly.

Open Command Prompt or Windows Terminal

• Press Win + R, type cmd, and press Enter
  OR
• Open Windows Terminal from the Start menu

Check Python version

Type the following command and press Enter:

 python --version

 Python 3.x.x

• Python is installed
• PATH is working correctly
• The terminal can access Python

Both Python’s official Windows documentation and Microsoft’s guidance recommend verifying Python this way.

Open the Python interpreter

Now type:

python

If everything is working, you will see the Python interactive prompt (>>>).
This means Python is ready to accept commands.

To exit, type:

exit()

Step 6: Test Python with a Small Program

Testing Python with an actual file ensures that everything works end-to-end.

Create a test file

1. Open Notepad, VS Code, or any text editor
2. Type the following:

print("Hello, Python!")

3. Save the file as hello.py
   (Make sure it does not become hello.py.txt)

Run the file

Open Command Prompt in the folder where the file is saved and run:

python hello.py

If you see:

Hello, Python!

Congratulations!
Your Python installation is working perfectly.

Common Python Installation Mistakes to Avoid

Most installation problems come from a few small but common mistakes. Knowing them in advance can save hours of frustration.

Most common beginner mistakes

• Forgetting to check Add python.exe to PATH
• Downloading Python from unofficial websites
• Installing Python, but not verifying it in the terminal
• Using the wrong installer type
• Closing the installer before it finishes
• Typing python before restarting the terminal
• Confusing python with py (they behave differently)

Python not recognized?

If you see an error like:

python is not recognized as an internal or external command

The fastest fix is:

1. Reinstall Python
2. Make sure PATH is checked
3. Restart Command Prompt

Microsoft Store Python Option (Should You Use It?)

Windows sometimes suggests installing Python through the Microsoft Store. While this option works, it can behave differently from the official installer.

Pros

• Easy installation
• No admin permissions needed

Cons

• Less control over Python location
• Can cause confusion with PATH
• Not ideal for tutorials or development guides

For learning, blogging, and teaching, the official python.org installer is the clearer and safer choice.

What to Do After Installing Python

Once Python is installed, you are ready to move forward.

Recommended next steps:

• Install Visual Studio Code for Python development
• Learn how to run scripts properly
• Create your first project folder
• Understand packages and pip
• Learn virtual environments

If you are building a Python learning path, you should also read these:

• 25 Common Python Errors Beginners Face and How to Fix Them
• How to Create a Virtual Environment in Python
• How to Install VS Code for Python Development
• Python vs JavaScript for Beginners

Final Thoughts

Installing Python on Windows need not be confusing or overwhelming.

If you:

• Download Python from the official source
• Check Add python.exe to PATH
• Use the default installer
• Verify installation from the terminal

You will have a clean, reliable Python setup that works exactly as expected.

Once Python is installed correctly, learning becomes much easier. You can stop worrying about setup problems and focus on what really matters—writing code, solving problems, and building projects.

Python is beginner-friendly, powerful, and widely used. A proper installation is your first confident step into that world.

Still, errors are unavoidable—especially in the early stages.

Python errors are not signs of failure. Instead, they are built-in guidance messages that help you understand exactly what went wrong. Learning to read and interpret these messages is a key programming skill.

This article explains 25 common Python errors beginners face, what causes them, and how to fix them using easy-to-understand examples.

1. SyntaxError

A SyntaxError occurs when Python cannot understand the structure or grammar of your code.

Example

if x == 10
    print("Hello")

Here, Python expects a colon (:) after the condition, but does not find one.

Fix

if x == 10:
    print("Hello")

Adding the colon tells Python that the next indented block belongs to the if statement.

2. IndentationError

Python uses indentation to define which lines belong to a block of code. Incorrect indentation breaks this structure.

Example

if True:
print("Hello")

Python expects the print statement to be indented under the if condition.

Fix

if True:
    print("Hello")

Using consistent indentation makes your code readable and prevents unexpected execution errors.

3. TabError

A TabError happens when tabs and spaces are mixed in the same file, confusing Python’s indentation rules.

Fix

Use only spaces, preferably 4 spaces per indentation level, and configure your editor to replace tabs automatically.

4. NameError

A NameError occurs when Python encounters a variable or function name that hasn’t been defined yet.

Example

print(username)

Python does not know what username it refers to at this point in the program.

Fix

username = "CyboGeek"
print(username)

Always define variables before using them, and double-check spelling and capitalization.

5. TypeError

A TypeError happens when Python tries to combine or operate on incompatible data types.

Example

age = "25"
print("Age: " + age + 5)

Here, Python cannot add a number to a string, which causes the error.

Fix

age = 25
print("Age:", age + 5)

Keeping data types consistent avoids unexpected crashes during calculations.

6. ValueError

A ValueError occurs when the type is correct, but the value itself cannot be processed.

Example

int("abc")

Python knows you want an integer, but the text "abc" cannot be converted into one.

Fix

int("123")

This error commonly occurs when converting user input into numbers.

7. IndexError

An IndexError happens when you try to access a list element that doesn’t exist.

Example

numbers = [10, 20, 30]
print(numbers[5])

The list only has three items, so the index 5 is out of range.

Fix

print(numbers[2])

Remember that Python lists start counting from the index 0, not 1.

8. KeyError

A KeyError occurs when a dictionary key does not exist.

Example

person = {"name": "Aman"}
print(person["age"])

The dictionary does not contain an "age" key, so Python raises an error.

Fix

print(person.get("age", "Not found"))

Using .get() safely handles missing keys without crashing the program.

9. AttributeError

An AttributeError occurs when you try to use a method that doesn’t belong to the object.

Example

numbers = [1, 2, 3]
numbers.push(4)

Lists in Python do not have a push() method.

Fix

numbers.append(4)

Always check the correct methods available for each data type.

10. ImportError

An ImportError means Python cannot load the requested module.

Example

import notamodule

Python searches for the module but cannot find it.

Fix

Ensure the module exists, is spelled correctly, and is accessible in your environment.

11. ModuleNotFoundError

This error usually means the module is not installed.

Fix

pip install requests

Also, confirm that you are installing the module in the same Python environment you’re running.

12. ZeroDivisionError

Occurs when attempting to divide a number by zero.

Example

print(10 / 0)

Division by zero is mathematically undefined, so Python prevents it.

Fix

number = 0
if number != 0:
    print(10 / number)

Always validate values before performing division.

13. UnboundLocalError

Occurs when a variable is referenced before assignment inside a function.

Example

def test():
    print(x)
    x = 5

Python treats x as local, but it hasn’t been assigned yet.

Fix

def test():
    x = 5
    print(x)

Assign values before using them inside functions.

14. EOFError

An EOFError occurs when input() expects data but receives none.

Fix

Run your program in a proper interactive terminal that supports user input.

15. FileNotFoundError

Occurs when Python cannot find the specified file.

Example

open("data.txt")

The file does not exist in the current working directory.

Fix

open("files/data.txt")

Always verify file paths and file names carefully.

16. OSError

An OSError usually indicates a system-level issue like permissions or unavailable resources.

Fix

Check file permissions, disk access, and whether the file is already open elsewhere.

17. RecursionError

Occurs when a function calls itself too many times without stopping.

Example

def count():
    return count()

This function has no exit condition, causing infinite recursion.

Fix

def count(n):
    if n == 0:
        return
    count(n - 1)

Always include a base condition when using recursion.

18. AssertionError

Occurs when an assert statement evaluates to false.

Example

assert 2 + 2 == 5

Python stops execution because the condition is incorrect.

Fix

assert 2 + 2 == 4

Assertions are useful for catching logic mistakes during development.

19. FloatingPointError

Floating-point numbers can behave imprecisely due to internal representation.

Fix

Instead of checking exact equality, compare values within a small tolerance range.

20. OverflowError

Occurs when a calculation exceeds allowed numeric limits.

Fix

Break large calculations into smaller steps or use specialized numeric libraries.

21. MemoryError

Occurs when your program tries to use more memory than is available.

Fix

Process large data in chunks and avoid loading entire datasets at once.

22. Type Confusion in Loops

Occurs when attempting to loop over a non-iterable object.

Example

for item in 5:
    print(item)

An integer cannot be looped over directly.

Fix

for item in range(5):
    print(item)

Always loop over sequences like lists, strings, or ranges.

23. Confusing = and ==

Occurs when an assignment is mistakenly used instead of a comparison.

Example

if x = 10:

Python does not allow assignment inside condition checks.

Fix

if x == 10:

Use == for comparisons and = for assignments.

24. Forgetting to Convert Input

input() always returns a string, even when numbers are entered.

Example

age = input("Enter age: ")
print(age + 5)

Python cannot add a number to a string directly.

Fix

age = int(input("Enter age: "))
print(age + 5)

Convert input values before performing calculations.

25. Poor Variable Naming & Shadowing Built-ins

Using names that conflict with built-in functions confuses.

Example

list = [1, 2, 3]

This overrides Python’s built-in list() function.

Fix

numbers = [1, 2, 3]

Clear, descriptive variable names reduce bugs and improve readability.

Final Thoughts

Every Python beginner encounters errors—it’s a natural part of learning to code.

Once you understand these 25 common Python errors, debugging becomes less frustrating and far more productive. With practice, you’ll start recognizing issues instantly and fixing them confidently.

Keep learning, keep experimenting, and most importantly—keep coding.

I’m the creator behind CyboGeek, a full-stack developer with over 8 years of experience building web and software solutions, exploring AI, and staying sharp in cybersecurity. I created this blog to turn that experience into useful content that helps people solve real tech problems, learn modern tools, and become more confident with technology.

What you’ll find on CyboGeek

CyboGeek is being built as a practical, no-fluff technology blog. The goal is simple: help you fix problems, learn useful skills, and make better use of the tools and platforms you rely on every day.

Here, you can expect content around:

• Programming tutorials, especially beginner-friendly and real-world topics.
• Python, JavaScript, Flutter, and web development guides.
• Fixes for common software, browser, Windows, Android, and coding issues.
• Tips and tricks to save time and work smarter.
• Easy explanations of technical concepts.
• Cybersecurity basics, privacy tips, and safer digital habits.
• Honest tool recommendations, comparisons, and productivity ideas.

Problems this blog will help you solve

A lot of tech content online is either too shallow or too advanced. CyboGeek is being built to sit in the middle — practical enough for beginners, useful enough for working developers, and clear enough for anyone trying to solve a problem quickly.

Some of the questions this blog will help answer include:

• Why is Python not working on my computer?
• How do I fix a common coding error?
• Which framework should I learn first?
• Why is my browser, app, or laptop behaving strangely?
• What tools are actually worth using?
• How can I improve productivity as a developer or tech user?
• How can I stay safer online without becoming a cybersecurity expert?

Who this blog is for

CyboGeek is for:

• Beginners who want easy-to-follow tutorials.
• Students learning programming and development.
• Developers looking for quick fixes and practical guides.
• Every day, users are trying to troubleshoot common tech problems.
• Readers who want useful tech content without jargon-heavy explanations.

If you like content that gets to the point, explains things clearly, and focuses on real usefulness, you’ll feel at home here.

What will make CyboGeek different?

This blog is not being built as a content farm or a copy-and-paste tutorial archive. The focus is on helpful, reliable, people-first content that solves real problems, reflects actual hands-on experience, and makes technology easier to use.

That means the articles here will aim to be:

• Clear and beginner-friendly.
• Based on practical use cases.
• Updated as tools and platforms change.
• Focused on solving one problem well.
• Written for humans first, not just search engines.

This is just the beginning

Right now, CyboGeek is at the beginning of a fresh new phase. The site is evolving from old demo content into a full technology blog with tutorials, troubleshooting guides, coding resources, and practical tech insights designed to grow into a daily destination for readers.

If that sounds useful to you, stick around. More helpful content is on the way — from coding tips and beginner tutorials to real fixes for the frustrating tech problems we all run into.