Using thepython Command

To run Python scripts with thepython command, you need to open a command-line window and type in the wordpython followed by the path to your target script:

• Windows
• Linux + macOS

PS>python.\hello.pyHello, World!PS>py.\hello.pyHello, World!

$python./hello.pyHello, World!

After you pressEnter, you’ll see the phraseHello, World! on your screen. If the previous command doesn’t work right, then you may need to check if Python is in your system’sPATH. You can also check where you savedhello.py.

That’s it! You’ve run your first script! Note that on Windows, you also have the option of using thepy launcher, which triggers thepy.exe launcher for console applications. This is the most basic and practical way to run Python scripts.

A useful feature of a terminal orshell application is that you can redirect the output of your commands using a straightforward syntax. This feature may be useful in those situations where you have a Python program that can generate a long output, and you’d like to save it to a file for later analysis.

In these scenarios, you can do something like the following:

$pythonhello.py>output.txt

In this command, the> symbol tells the shell to redirect the output of your command to theoutput.txt file, rather than to the standard system output, your screen. This process is commonly known asredirection, and it works on both Windows andUnix-like systems, such as Linux and macOS.

If the output file doesn’t exist, then the shell automatically creates it. On the other hand, if the file already exists, then the shell overwrites its old content with the new output.

Finally, if you want to add the output of consecutive executions to the end ofoutput.txt, then you can use two angle brackets (>>) instead of one:

$pythonhello.py>>output.txt

Now, the shell app will append the current output to the end ofoutput.txt. You’ll end up with a file containing the phrase"Hello, World!" twice.

Using the Script’s Filename Directly

On Windows, you can also run Python scripts by entering the name of the file containing the executable code at the command line:

PS> .\hello.py

Once you’ve written the path to your script and pressedEnter, you’ll note that a new terminal window appears on your screen for a few seconds, showing the script output. This is possible because Windows associates.py and.pyw files topython.exe andpythonw.exe, respectively.

This way of running Python scripts on Windows may be annoying because the code runs in a new terminal window that automatically closes after the execution ends. In most cases, you won’t be able to check the program’s output.

On Linux and macOS, you can also run your scripts directly. However, things are a bit different, and you need some additional setup steps. Go ahead and run the following command:

• Linux
• macOS

$./hello.pybash: ./hello.py: Permission denied

$./hello.pyzsh: permission denied: ./hello.py

Unix systems prioritize security, which means that you can’t go around executing any file as a program. So, you get a permission denied error when you try to runhello.py directly. To fix this issue, you need to explicitly tell the system that the file is executable. To do this, you can use thechmod command:

$chmod+xhello.py

After running this command, yourhello.py file will be executable. However, that’s not enough for the script to run properly:

$./hello.py./hello.py: line 1: syntax error near unexpected token `"Hello, World!"'./hello.py: line 1: `print("Hello, World!")'

Why are you getting another error now? The problem is that your operating system (OS) doesn’t know which program to use for running your script and is trying to run it with the shell itself. You can fix that by making a small addition to yourhello.py file:

#!/usr/bin/env python3print("Hello, World!")

You’ve added a new line at the beginning ofhello.py. It now starts with a Unix-styleshebang, which is a special kind ofcomment that you can include in your scripts to tell the operating system which program to use for running the content of this file. In this case, you tell the OS to use Python.

Now you can run the script directly from your command line:

$./hello.pyHello, World!

Wow! That was a long road! However, the effort was worth it. Now when you create a Python script to automate tasks in a Unix operating system, you know how to make it executable and run it from your command line.

Running Modules With the-m Option

Thepython command has a series ofcommand-line options that can be useful in specific situations. For example, if you want to run a Python module, then you can use the commandpython -m <module-name>. The-m option searches Python’smodule search path,sys.path, for the module name and runs its content:

$python-mhelloHello, World!

In this example, you run thehello.py file as a module. This is possible because Python automatically adds the current directory to itssys.pathlist. Note that themodule-name argument needs to be the name of a module object, not a file name. In other words, you don’t include the.py suffix.

If the target module isn’t insys.path, then you get an error:

$python-mmissing.../python: No module named missing

In this example, themissing name isn’t in thesys.path list, so Python isn’t able to execute it, and therefore it returns an error.

Getting to Know the Python Interpreter

Python is a high-level programming language with a clean and readable syntax. Python and its wide ecosystem ofpackages and libraries can boost your productivity in avariety of fields. The name Python also refers to a piece of software called theinterpreter, which is the program that allows you to run Python code.

The interpreter is a layer of software that works between your program and your computer hardware to get your code running. Depending on the Pythonimplementation that you use, the interpreter can be a program written in:

• C, likeCPython, which is the core implementation of the language
• Python itself, likePyPy, which is afast implementation with ajust-in-time (JIT) compiler
• Java, likeJython, which can take advantage of the Java ecosystem
• .NET, likeIronPython, which uses the .NET ecosystem

Whatever interpreter you use, the code that you write will run in this program. Therefore, the first condition to be able to run scripts and code is to have the interpreter correctlyinstalled on your operating system.

The Python interpreter can run code in two different modes:

1. Script, or program
2. Interactive, or REPL

Inscript mode, you use the interpreter to run a source file as an executable program, as you learned in the previous section. In this case, Python loads the file content and runs the code line by line, following the program’s execution flow.

Alternatively,interactive mode is when you launch the interpreter and use it as a platform to run code that you type in directly. This mode is pretty useful for learning Python as well as for developing, testing, anddebugging your applications.

Running Python Code Interactively

Interactive sessions are a widely used tool for running Python code. To start a Python interactive session, or REPL, open a command-line window, type in thepython command, and then pressEnter.

These steps will take you into the Python interpreter, which looks something like the following:

• Windows
• Linux
• macOS

PS>pythonPython 3.14.3 (tags/v3.14.3:323c59a, Feb  3 2026, 16:04:56) ... on win32Type "help", "copyright", "credits" or "license" for more information.>>>

$pythonPython 3.14.3 (main, Feb  3 2026, 13:58:44) ... on linuxType "help", "copyright", "credits" or "license" for more information.>>>

$pythonPython 3.14.3 (v3.14.3:323c59a5e34, Feb  3 2026, 11:41:37) ... on darwinType "help", "copyright", "credits" or "license" for more information.>>>

The standard primary prompt for the interactive mode consists of three right angle brackets,>>>. So, as soon as you see these characters, you’ll know that you’re in.

The Python interpreter is an interactive way to talk to your computer using the language. It’s like live chat. It’s also known as the REPL because it goes through four steps that run under the hood:

1. Reading your input, which consists of Python code asexpressions andstatements
2. Evaluating your Python code, which generates a result or causesside effects
3. Printing any output so that you can check your code’s results and get immediate feedback
4. Looping back to step one to continue the interaction

This Python feature is a powerful tool that you’ll wind up needing in your coding adventure, especially when you’re learning the language or when you’re in the early stages of a development process.

Once you’ve started a REPL session, you can write and run Python code as you wish. The only drawback is that when you close the session, your code will be gone. This is another difference between the script and interactive modes:scripts are persistent.

When you work interactively, Python evaluates and executes every expression and statement immediately:

>>>print("Hello, World!")Hello, World!>>>2+57>>>print("Welcome to Real Python!")Welcome to Real Python!

An interactive session allows you to test every piece of code immediately. That’s why this tool is an awesome development helper and an excellent space to experiment with the language and test ideas on the fly.

To leave interactive mode and jump back to the system shell, you can use one of the following options:

• Executing the built-inquit() orexit() functions, which are plain commands (quit andexit) inPython 3.13 or later
• Pressing theCtrl+Z andEnter key combination on Windows, or theCtrl+D combination on Unix systems, such as Linux and macOS

Go ahead and give the Python REPL a try. You’ll see that it’s a great development tool that you must keep in your tool kit.

Taking Advantage ofimport Statements

When youimport a module from another module, script, or interactive session, what really happens is that Python loads its contents for later access and use. The interesting point is that theimport statement runs any executable code in the imported module.

When the module contains onlyclass, function,variable, andconstant definitions, you probably won’t be aware that the code was run. However, when the module includes calls to functions,methods, or otherstatements that generate visible results, then you’ll witness its execution.

This provides you with another approach to run scripts:

>>>importhelloHello, World!

You’ll note thatimport runs the code only once per session. After you first import a module, successive imports do nothing, even if you modify the content of the module. This is becauseimport operations are expensive, and Python takes some extra steps to optimize overall performance:

>>>importhello# Do nothing>>>importhello# Do nothing again

These two imports do nothing because Python knows that thehello module was already imported. Therefore, Python skips the import. This behavior may seem annoying, especially when you’re working on a module and trying to test your changes in an interactive session. However, it’s an intentional optimization.

Using theimportlib Standard-Library Module

In the Pythonstandard library, you can find theimportlib module. This module provides theimport_module() function, which allows you to programmatically import modules.

Withimport_module(), you can emulate animport operation and, therefore, execute any module or script. Take a look at this example:

>>>importimportlib>>>importlib.import_module("hello")Hello, World!<module 'hello' from '/Users/username/hello.py'>

Theimport_module() function imports a module programmatically using its name. This action runs any executable code in the target module. That’s why you getHello, World! on your screen.

You already know that once you’ve imported a module for the first time, you won’t be able to import it again using anotherimport statement. If you want to reload the module and run it once again, then you can use thereload() function, which forces the interpreter to import the module again:

>>>importhelloHello, World!>>>importimportlib>>>importlib.reload(hello)Hello, World!<module 'hello' from '/Users/username/hello.py'>

An important point to note here is that the argument ofreload() has to be the name of a module object, not astring. So, to usereload() successfully, you need to provide a module that’s already imported.

Leveraging the Power of the Built-inexec() Function

So far, you’ve learned about some handy ways to run Python scripts. In this section, you’ll learn how to do that by using the built-inexec() function, which supports the dynamic execution of Python code.

Theexec() function provides an alternative way to run your scripts from inside your code:

>>>withopen("hello.py")ashello:...exec(hello.read())...Hello, World!

In this example, you use thewith statement to open thehello.py file for reading. Then, you read the file’s content with the.read() method. This method returns astring that you pass toexec() for execution.

You must be careful when using theexec() function because it implies some important security risks, especially if you’re using it for executing external code from untrusted sources. To learn more about this function, check outPython’sexec(): Execute Dynamically Generated Code.