Python is a fantastic ability. Particularly in the day when great platforms like Pinterest and Instagram are working with this language.
One of the most important skills to have when working with Python is the ability to run Python’s codes and scripts. This is the only way to know for certain whether or not the code is running.
Fortunately, there are a number of ways to run Python scripts that rely on the developer and the client’s platform, environment, skills and needs.
Here, we will be discussing how to run the Python scripts using the following four methods:
(i) The terminal or command-line of the operating system.
(ii) The IDE or text editor
(iii) The Python Interactive mode
(iv) The system’s file manager
But let’s first understand the difference between the modules and the scripts. A script can be called a file containing either a batch processing file or a logical order string.
It’s basically a text file that stores a simple program. You need an interpreter to process a script that executes every single command sequentially. Another script term is the program file at the top level and it contains the code that the user directly executes.
One of the most important skills to have when working with Python is the ability to run Python’s keys and scripts. This is the only way to know for certain whether or not the code works.
Download Detailed Brochure and Get Complimentary access to Live Online Demo Class with Industry Expert.
Fortunately, there are a number of ways for running Python scripts dependent on the platform, environment, skills, and needs of the programmer and the client. Here, we will be discussing how to run the Python scripts using the following four methods:
(i) The terminal or command-line of the operating system
(ii) The IDE or text editor
(iii) The Python Interactive mode
(iv) The system’s file manager.
But first, let’s understand the difference between scripts and modules. A script can be referred to as a file that contains a batch processing file or a logical sequence of orders. Basically, it is a text file storing a simple program. To process a script, you need an interpreter that sequentially executes every single command. Another term for script is top-level program file and it contains the code that the user executes directly.
Now, a module is also a plain text file that contains code that the user imports and uses from another Python file. So, the key difference between a script and a module is that a script is executed directly whereas modules are imported.
Python Interpreter
Python is one of the most popular programming languages used today. It has several characteristics like flexibility, object-orientation, etc. that makes it productive in a number of fields. Now, to run Python code and scripts, a piece of software named interpreter is used. It is a software layer working between the computer hardware and the program that gets your code running. The interpreter that you are using depends on the Python implementation you are working on. For example:
(i) Program written in C such as CPython. This is the language’s core implementation
(ii) Program written in Python such as PyPy
(iii) Program written in Java such as Jython
(iv) Program implemented in .NET such as IronPython
You code will always be run by this program no matter what form of the implementation you take. So, if you want to correctly run Python scripts on your system, the first and the most important condition is correctly installing the interpreter. With the help of an interpreter, there are two ways of running Python code- as a code directly typed in the interactive session or as a script/module.
Before you can get started with Python, you need to figure out which text editors and IDEs you will be using. You also need to take a look at the books and code samples that can help make the Python editing easy. There are several online tutorials available that can help a beginner as well as an experienced programmer. Also, you can try these tutorials in your native language as well. For all the definitive information, you need to check out the online documentation of Python. In this tutorial, you will get all the required information related to the language. For a thorough description of the Python libraries, you need to study the library reference.
Now, if you are looking for an application or a library with a specific function, there are a number of sources you can use such as the Python Package Index, available on the Python web site. If everything fails and you can’t get the right solution to your problem, you can post your query on the python newsgroup.
Using the File Manager for running Python Scripts
You can also run a Python script by just double-clicking on its icon present in the file manager. Though it is not used commonly during the development stage, it is used for releasing the code for production. To achieve this, you need to fulfill some conditions depending on the operating system that you are working on.
In windows, the programs Pythonw.exe and Python.exe are associated with the extensions .pyw and .py respectively. This allows running the scripts by simply double-clicking the icon.
Now, if you have a command-line interface on the script, you will see a black window on the screen as a flash. To avoid this, you need to add input(‘Press Enter to Continue…’) at the end of the script. This will end the program as soon as you hit Enter. This method has its drawbacks. Suppose your script has an error. The execution will be stopped even before it reaches the above-mentioned statement. So, you won’t be able to see the results.
If you are working on Unix-like systems and want to run the scripts by just double-clicking the icon present in the file manager, you need to provide execution permissions in the script. You will also have to use the hash band trick mentioned earlier. As in the case of Windows, you might not be able to see the results in the case of command-line interface scripts.
This method is only recommended for scripts that are already debugged and are completely ready for production. This is because running the scripts by double-clicking has its limitations and is dependent on a number of factors including file manager, operating system, file association, execution permissions, etc.
Running Python Code Interactively
The most common method of running a Python code is interactively. All you need to do is start the interactive session for Python. For this, fire up the terminal or the command line and type Python or Python3, depending on the version of Python installed on your system and presses Enter. If you are working on Linux, this is how you can do this:
$ Python3 Python 3.6.7 (default, Oct 22 2018, 11:32:17) [GCC 8.2.0] on linux Type "help", "copyright", "credits" or "license" for more information. >>>
The >>> is the interactive mode’s standard prompt. So, it shows that you are in the command line and can now start writing and running Python code.
The drawback to this method is that all your code will be gone once you close the session. Every statement and expression that you type will be executed and evaluated immediately. For example:
>>> >>> print('Hello World!') Hello World! >>> 2 + 5 7 >>> print('Welcome to Real Python!')
Welcome to Real Python!
This interactive session works best when you have to test every single piece of code that you have written making it the best tool for development and experimenting with the language. Also, you don’t have to wait to finish you code to test it. You can just test it on the fly. So, whenever you are working on Python and have doubts on what a given block of code does, all you need to do is launch the interactive session, paste the code, and see what happens. Once you are done with all the testing, you can just use one of the following options for exiting the interactive mode.
(i) Use the built-in functions, Exit() or quit().
(ii) For windows, use the combination of Ctrl+Z and Enter. For Unix-like systems, use Ctrl+D.
Now, if you have no experience with the terminal or the command line, you need to try this:
(a) For windows, the common name of the command line is the MS-DOS console or the command prompt and it is in the form of a program known as cmd.exe. The program’s path is dependent on the system and can significantly vary according to the version of the system. If you want to access it, all you need to do is press Win+R. You will see the Run dialog box. IN this box, type cmd and hit Enter.
(b) For Linux/GNU, the access to the command line of the system can be gained through several applications such as Konsole, Gnome Terminal, and xterm. These tools are used for running the terminal or shell like csh, ksh, Bash, and so on. The path to these applications can vary depending on the desktop environment and the distribution you are using. Read the documentation of the system to get all the information.
(c) For Mac OS X, the system terminal can be accessed through Applications ? Utilities ?Terminal.
Now, the question is, how are the Python scripts run by the interpreter. There are 2 major steps in using the interpreter for executing Python scripts:
(i) Sequentially processing the script’s statements.
(ii) Compiling the source code to bytecode, and intermediate format. The byte code is a lower-level translation of the code that is independent of the platform. This optimized the process of code execution. This is done to remove the compilation step for the next time the same code is run on the interpreter. However, the optimization only works for modules and not for scripts.
The whole process of running the Python scripts is named Python Execution Model. To understand the whole process, you need to be familiar with Python Virtual Machine (PVM). It is Python’s runtime engine. Basically, you can consider it a cycle responsible for iterating the bytecode’s instructions for running them one by one. It is not some isolated component of Python. Instead, it is just a part of the system installed on your machine. It is also the last step of the Python interpreter.
Now, for importing a module, you need to load its contents which are used for accessing later. The import is run at the final step of the code.
If the module only contains variables, constants, functions, and classes, you won’t be able to see the execution. However, if the module is making calls to methods, functions, and other statements, you will be able to witness its execution. This also gives you another method for running Python scripts. For example:
>>> >>> import hello Hello World!
However, this method works just once per session. Once you have made the first import, the next import executions won’t do anything even if you change the module’s content. This is because the import operations can be run only once as they are expensive. Take a look at this example:
>>> >>> import hello # Do nothing >>> import hello # Do nothing again
Both of these operations do nothing because hello has already been imported.
To make this method work, you need to have the following requirements:
(i) The Python file is present in the current working directory.
(ii) The Python file must be in the Python Module Search Path (PMSP). All the packages and modules that you import in your file are searched by Python in the PMSP. For knowing what is in your PMSP, you can use the following code:
>>> >>> import sys >>> for path in sys.path: ... print(path) ... /usr/lib/Python36.zip /usr/lib/Python3.6 /usr/lib/Python3.6/lib-dynload /usr/local/lib/Python3.6/dist-packages /usr/lib/Python3/dist-packages
This will give you a list of .zip files and directories where Python looks for the imported modules.
The importlib and imp
The importlib is a module present in the Python Standard Library that has import_module(). This is used for emulating an import operation and executing and script or module. Here is an example:
>>> >>> import importlib >>> importlib.import_module('hello') Hello World! <module 'hello' from '/home/username/hello.py'>
As we discussed before, you can’t continue to use import for importing a module for the second time. In such cases, you can use importlib.reload() that forces the interpreter for re-importing the module. You can use the following code for that:
>>> >>> import hello # First import Hello World! >>> import hello # Second import, which does nothing >>> import importlib >>> importlib.reload(hello) Hello World! <module 'hello' from '/home/username/hello.py'>
The name of the module object is used as an argument of reload(). If you use string as an argument of reload(), it will give a TypeError exception.
Take a look at this:
>>> >>> importlib.reload('hello') Traceback (most recent call last): ... TypeError: reload() argument must be a module
Importlib.reload() can be used when you have to modify a module and test it to see if the changes work without exiting the current interactive session.
If you are using 2.x version of Python, you have to use imp, a module containing the reload() function. It works similarly to the importlib.reload().
>>> >>> import hello # First import Hello World! >>> import hello # Second import, which does nothing >>> import imp >>> imp.reload(hello) Hello World! <module 'hello' from '/home/username/hello.py'>
Runpy.run_path() and runpy.run_module()
A module named runpy present in the standard library has a function called run_ module() that allows running the module without importing them. The executed module’s globals dictionary is returned by the function.
Take a look at this example that will explain how to use it:
>>> >>> runpy.run_module(mod_name='hello') Hello World! {'__name__': 'hello', ... '_': None}}
A standard import mechanism is used for locating and executing the model on a new module namespace. The string with the name of the module is used as a first argument of run_module().
runpy also contains run_path() that allows running of the module after providing its location in the system. Here is an example:
>>> >>> import runpy >>> runpy.run_path(file_path='hello.py') Hello World! {'__name__': '<run_path>', ... '_': None}}
The run_path() also returns the executed module’s globals dictionary. The parameter of the file_path has to be string and must refer to one of the following:
(i) Python source file’s location
(ii) Compiled bytecode file’s location
(iii) Valid entry of the value in the sys.path that contains a _main_ module
Exec()
Exec() is a built-in function supporting the Python code’s dynamic execution that can also be used for running Python scripts.
>>> >>> exec(open('hello.py').read()) 'Hello World!'
The file help.py is opened and read. Then, it is sent to exec() where the code is run. This is a fine example of flexibility and versatility that Python offers.
If you are using 2.x version of Python, you can used execfile(), a built-in function for running the Python script. The string containing the location of the file is used as the first argument of the function. Here is an example displaying how to implement execfile():
>>> >>> execfile('hello.py') Hello World!
In this case, the file is first parsed and then evaluated sequentially.
Running Python scripts through Command-Line
The downside of using a Python interactive session is that as soon as you close the session, all the lines of code that you have written will be lost. This is why the preferred method of writing programs in Python is through a text file.
All these text files are stored using the .py extension to let the system know that it is a Python executable file. .pyw is another extension used for Python files in Windows.
Any plain text editor can be used for creating Python code files. Try Sublime Text, an easy-to-use and powerful text editor, created especially for beginners. To learn how to use the command line to run Python scripts, you have to create a test script. Write the following lines of code in any text editor:
1 #!/usr/bin/env Python3 2 3 print('Hello World!')
Save this file with the name hello.py in your working directory. Now, open up the command line and type in Python or Python3, depending on the Python’s version you have installed on your system. No, go to the location of your working directory where you have stored the Python file. Here is an example:
>> C:\Users\y\hello.py - For Windows $ /usr/bin/hello.py - For Linux (Ubuntu)
If everything in your file and the command-line is okay, you will see ‘Hello World’ on the screen. If you don’t see it, this means either there is an issue with the script, Python installation or system PATH.
In some cases, you might need to save the script’s output for future use. To do this, type in the following command:
$ Python3 hello.py > output.txt
rd system output. It is available for Windows as well as Unix-like systems and is commonly referred to as stream redirection. If there is no output.txt file present, the system will create one automatically. And if there is one, the contents of the original text file will be replaced with the output of the Python file. For adding the output of next executions to the output.txt file, you need to add >> instead of >. For example.
in the line is called shebang or hash bang. Here are two methods for specifying the interpreter’s path:
(i) #!/usr/bin/Python: Absolute path
(ii) #!/usr/bin/env Python: The env command is used for locating and executing Python that searched the environment variable of the PATH. This is especially used in Unix-like systems where the interpreter is not located in the same place.
For executing scripts like theses, execution permissions need to be assigned. After this, you can just type in the name of the file to execute it. Here is an example to show you how:
$ # Assign execution permissions $ chmod +x hello.py $ # Run the script by using its filename $ ./hello.py Hello World!
Once you have your hash bang line and execution permissions configured properly, all you need to do is type the name of the file at the command line to run it. Remember that if the script isn’t present at the current working directory, file path is used for executing the script.
Using a Text Editor or an IDE for running Python Scripts
An advanced text editor or an Integrated Development Environment (IDE) is used to develop large and complex applications. These programs give an option to run the Python scripts in the environment itself. There is usually a build or run command present in the main menu or the tool bar that you can use for running the scripts.
The standard distribution of Python contains IDLE as the default IDE. You can use it for writing, debugging, running, and modifying your scripts and modules. There are some other IDEs also available that allows running
Python scripts and modules in the environment itself like NetBeans, Eclipse-PyDev, Eric, and PyCharm. Advanced text editor like Visual Studio Code and Sublime Text also provide the option of running the scripts.
Now, a module is also a plain text file that contains code that the user imports and uses from another Python file. So, the key difference between a script and a module is that a script is executed directly whereas modules are imported.
Python Interpreter
Python is one of the most popular programming languages used today. It has several characteristics like flexibility, object-orientation, etc. that makes it productive in a number of fields. Now, to run Python code and scripts, a piece of software named interpreter is used.
It is a software layer working between the computer hardware and the program that gets your code running. The interpreter that you are using depends on the Python implementation you are working on. For example:
⇒ Program is written in C such as CPython. This is the language’s core implementation
⇒ Program is written in Python such as PyPy
⇒ Program is written in Java such as Jython
⇒ The program implemented in .NET such as IronPython
Your code will always be run by this program no matter what form of the implementation you take. So, if you want to correctly run Python scripts on your system, the first and the most important condition is correctly installing the interpreter. With the help of an interpreter, there are two ways of running Python code- as a code directly typed in the interactive session or as a script/module.
Running Python Code Interactively
The most common method of running a Python code is interactive. All you need to do is start the interactive session for Python.
For this, fire up the terminal or the command line and type Python or Python3, depending on the version of Python installed on your system and presses Enter. If you are working on Linux, this is how you can do this:
$ Python3 Python 3.6.7 (default, Oct 22 2018, 11:32:17) [GCC 8.2.0] on Linux Type "help", "copyright", "credits" or "license" for more information. >>>
The >>> is the interactive mode’s standard prompt. So, it shows that you are in the command line and can now start writing and running Python code.
The drawback to this method is that all your code will be gone once you close the session. Every statement and expression that you type will be executed and evaluated immediately. For example:
>>> >>> print('Hello World!') Hello World! >>> 2 + 5 7 >>> print('Welcome to Real Python!') Welcome to Real Python!
This interactive session works best when you have to test every single piece of code that you have written making it the best tool for development and experimenting with the language. Also, you don’t have to wait to finish your code to test it. You can just test it on the fly.
So, whenever you are working on Python and have doubts on what a given block of code does, all you need to do is launch the interactive session, paste the code, and seeinterpreter for executing Python scripts:
(i)Sequentially processing the script’s statements.
(ii) Compiling the source code to bytecode, and intermediate format. The byte code is a lower-level translation of the code that is independent of the platform. This optimized the process of code execution. This is done to remove the compilation step for the next time the same code is run on the interpreter. However, the optimization only works for modules and not for scripts.
The whole process of running the Python scripts is named Python Execution Model. To understand the whole process, you need to be familiar with Python Virtual Machine (PVM).
It is Python’s runtime engine. Basically, you can consider it a cycle responsible for iterating the bytecode’s instructions for running them one by one.
It is not some isolated component of Python. Instead, it is just a part of the system installed on your machine. It is also the last step of the Python interpreter.
Now, for importing a module, you need to load its contents which are used for accessing later. The import is run at the final step of the code.
If the module only contains variables, constants, functions, and classes, you won’t be able to see the execution. However, if the module is making calls to methods, functions, and other statements, you will be able to witness its execution. This also gives you another method for running Python scripts. For example:
>>> >>> import hello Hello World!
However, this method works just once per session. Once you have made the first import, the next import executions won’t do anything even if you change the module’s content. This is because the import operations can be run only once as they are expensive. Take a look at this example:
>>> >>> import hello # Do nothing >>> import hello # Do nothing again
Both of these operations do nothing because hello has already been imported.
To make this method work, you need to have the following requirements:
⇒ The Python file is present in the current working directory.
⇒ The Python file must be in the Python Module Search Path (PMSP). All the packages and modules that you import in your file are searched by Python in the PMSP. For knowing what is in your PMSP, you can use the following code:
>>> >>> import sys >>> for path in sys.path: ... print(path) ... /usr/lib/Python36.zip /usr/lib/Python3.6 /usr/lib/Python3.6/lib-dynload /usr/local/lib/Python3.6/dist-packages /usr/lib/Python3/dist-packages
This will give you a list of .zip files and directories where Python looks for the imported modules.
The importlib and imp
The importlib is a module present in the Python Standard Library that has import_module(). This is used for emulating an import operation and executing and script or module. Here is an example:
>>> >>> import importlib >>> importlib.import_module('hello') Hello World! <module 'hello' from '/home/username/hello.py'>
As we discussed before, you can’t continue to use import for importing a module for the second time. In such cases, you can use importlib.reload() that forces the interpreter for re-importing the module. You can use the following code for that:
>>> >>> import hello # First import Hello World! >>> import hello # Second import, which does nothing >>> import importlib >>> importlib.reload(hello) Hello World! <module 'hello' from '/home/username/hello.py'>
The name of the module object is used as an argument of reload(). If you use string as an argument of reload(), it will give a TypeError exception.
Take a look at this:
>>> >>> importlib.reload('hello') Traceback (most recent call last): ...
TypeError: reload() argument must be a module
Importlib.reload() can be used when you have to modify a module and test it to see if the changes work without exiting the current interactive session.
If you are using 2.x version of Python, you have to use imp, a module containing the reload() function. It works similarly to the importlib.reload().
>>> >>> import hello # First import Hello World! >>> import hello # Second import, which does nothing >>> import imp >>> imp.reload(hello) Hello World! <module 'hello' from '/home/username/hello.py'>
Runpy.run_path() and runpy.run_module()
A module named runpy present in the standard library has a function called run_ module() that allows running the module without importing them. The executed module’s globals dictionary is returned by the function.
Take a look at this example that will explain how to use it:
>>> >>> runpy.run_module(mod_name='hello') Hello World! {'__name__': 'hello', ... '_': None}}
A standard import mechanism is used for locating and executing the model on a new module namespace. The string with the name of the module is used as a first argument of run_module().
runpy also contains run_path() that allows running of the module after providing its location in the system. Here is an example:
>>> >>> import runpy >>> runpy.run_path(file_path='hello.py') Hello World! {'__name__': '<run_path>', ... '_': None}}
The run_path() also returns the executed module’s globals dictionary. The parameter of the file_path has to be a string and must refer to one of the following:
(i) Python source file’s location
(ii) Compiled bytecode file’s location
(iii) The valid entry of the value in the sys.path that contains a _main_ module
Exec()
Exec() is a built-in function supporting the Python code’s dynamic execution that can also be used for running Python scripts.
>>> >>> exec(open('hello.py').read()) 'Hello World!'
The file help.py is opened and read. Then, it is sent to exec() where the code is run. This is a fine example of flexibility and versatility that Python offers.
If you are using 2.x version of Python, you can use execfile(), a built-in function for running the Python script. The string containing the location of the file is used as the first argument of the function. Here is an example displaying how to implement execfile():
>>> >>> execfile('hello.py') Hello World!
In this case, the file is first parsed and then evaluated sequentially.
Running Python Scripts Through Command-Line
Running Python Scripts Through Command-Line Source – Stack Overflow
The downside of using a Python interactive session is that as soon as you close the session, all the lines of code that you have written will be lost. This is why the preferred method of writing programs in Python is through a text file.
All these text files are stored using the .py extension to let the system know that it is a Python executable file. .pyw is another extension used for Python files in Windows.
Any plain text editor can be used for creating Python code files. Try Sublime Text, an easy-to-use and powerful text editor, created especially for beginners. To learn how to use the command line to run Python scripts, you have to create a test script. Write the following lines of code in any text editor:
1 #!/usr/bin/env Python3 2 3 print('Hello World!')
Save this file with the name hello.py in your working directory. Now, open up the command line and type in Python or Python3, depending on the Python’s version you have installed on your system. No, go to the location of your working directory where you have stored the Python file. Here is an example:
>> C:\Users\y\hello.py - For Windows $ /usr/bin/hello.py - For Linux (Ubuntu)
If everything in your file and the command-line is okay, you will see ‘Hello World’ on the screen. If you don’t see it, this means either there is an issue with the script, Python installation or system PATH.
In some cases, you might need to save the script’s output for future use. To do this, type in the following command:
$ Python3 hello.py > output.txt
This will save the script’s output to a text file named output.txt instead of the standard system output. It is available for Windows as well as Unix-like systems and is commonly referred to as stream redirection. If there is no output.txt file present, the system will create one automatically. And if there is one, the contents of the original text file will be replaced with the output of the Python file. For adding the output of next executions to the output.txt file, you need to add >> instead of >. For example.
$ Python3 hello.py >> output.txt
This will append the output to the end of the output.txt file.
When you are working with Python on the command-line, there are a series of options that you can use as per your needs. For example, for running a Python module, you can type in the following command:
Python -m <module-name>.
The –m option is used for searching the sys.path for the module and running its content as _main_. For example:
$ Python3 -m hello Hello World!
In Windows, you can just enter the file’s name with the code in the command prompt for running the Python script. For example:
C:\devspace> hello.py Hello World!
Windows uses the file association and system registry for determining what program should be used to run a particular file. To do the same on Unix-like systems, you have to add #!/usr/bin/env Python to the first line of the text. This line helps the operating system know which program to use for running the file. The #! character used in the line is called shebang or hashbang. Here are two methods for specifying the interpreter’s path:
⇒ #!/usr/bin/Python: Absolute path
⇒ #!/usr/bin/env Python: The env command is used for locating and executing Python that searched the environment variable of the PATH. This is especially used in Unix-like systems where the interpreter is not located in the same place.
For executing scripts like theses, execution permissions need to be assigned. After this, you can just type in the name of the file to execute it. Here is an example to show you how:
$ # Assign execution permissions $ chmod +x hello.py $ # Run the script by using its filename $ ./hello.py Hello World!
Once you have your hashbang line and execution permissions configured properly, all you need to do is type the name of the file at the command line to run it. Remember that if the script isn’t present at the current working directory, the file path is used for executing the script.
Using a Text Editor or an IDE for running Python Scripts
An advanced text editor or an Integrated Development Environment (IDE) is used to develop large and complex applications. These programs give an option to run the Python scripts in the environment itself. There is usually a build or run command present in the main menu or the toolbar that you can use for running the scripts.
The standard distribution of Python contains IDLE as the default IDE. You can use it for writing, debugging, running, and modifying your scripts and modules. There are some other IDEs also available that allows running Python scripts and modules in the environment itself like NetBeans, Eclipse-PyDev, Eric, and PyCharm. An advanced text editor like Visual Studio Code and Sublime Text also provide the option of running the scripts.
Using the File Manager for running Python Scripts
You can also run a Python script by just double-clicking on its icon present in the file manager. Though it is not used commonly during the development stage, it is used for releasing the code for production.
Final Thoughts
Python language is one of the most common programming languages that has seen a sharp rise in the number of users. It is the Data Science Industry’s leading language. By taking a course on Python Programming, you’ll pave a way for much bigger career possibilities than you have ever had.
