Python Interpreter & Its Environment (Source Code Encoding)

By default, Python source files use UTF-8 encoding, which is a Unicode Standard capable of representing over a million code points using up to four 8-bit bytes.

Thanks to this encoding, Python allows you to use a wide range of characters from different languages in string literals, comments, and identifiers.

Since the standard library mainly uses ASCII, it’s important to explicitly declare your encoding at the start of your file so your editor can render all characters correctly. You can do this using:

# -*- coding: encoding -*- 

For example, if using Windows-1252 encoding:

# -*- coding: cp1252 -*- 

If you're also using a UNIX shebang line at the top, place the encoding comment below it:

#!/usr/bin/env python3 # -*- coding: cp1252 -*- 

How to Invoke the Python Interpreter?

After installing Python, you can find the interpreter in a directory like:

C:\Python36 

If not already in your system path, add it with:

set path=%path%;C:\python36

To start the Python interpreter on Windows, open the shell and type:

To exit the interpreter, you can use:

>>> quit()

Or use an EOF (End-of-File) character. Python interpreter can also be used as a REPL (Read-Evaluate-Print Loop).

You can also save your code in a script (e.g., demo.py) and run it:

$ python demo.py

To run the script and then enter interactive mode:

$ python -i demo.py

To execute Python commands directly from the command line:

$ python -c "print('Hello')" 

Or execute a module directly:

$ python -m module_name

Features of the Python Interpreter

Python’s interpreter comes with:

Interactive editing

History substitution

Code completion (if readline support is available)

To check if command-line editing is supported, press Ctrl+P. If the interpreter beeps, it's supported. If it echoes ^P, it’s not.

Passing Arguments in Python

When running a Python script with additional arguments, these are stored as strings in the sys.argv list:

import sys print(sys.argv)

If no script is provided, sys.argv[0] is an empty string.

Using -c, sys.argv[0] becomes -c.

Using -m, it becomes the module's name.

Python Interactive Mode

Python enters interactive mode when commands are read from a terminal (tty).

Primary prompt:

>>> 

Secondary prompt (for multi-line statements):

... 

Example:

>>> it_rains = True >>> if it_rains: ...     print("The produce will be good")

Output:

The produce will be good

You can also use it like a calculator:

>>> 2 * 7 14 >>> 4 / 2 2.0 

How Does the Python Interpreter Work?

Internally, the interpreter processes your code in these four steps:

Lexing – Breaks the code into tokens.

Parsing – Converts tokens into an Abstract Syntax Tree (AST).

Compiling – Translates the AST into bytecode (code objects).

Interpreting – Executes the bytecode.

Function & Code Objects in Python

In Python, functions are first-class objects:

>>> def bar(a): ...     x = 3 ...     return x + a >>> bar <function bar at 0x107ef7aa2>

Every function has a __code__ attribute containing the code object:

>>> bar.__code__ <code object bar at 0x107eeccb2, file "<stdin>", line 1>

Use dir() to explore more:

>>> dir(bar.__code__)

Examples:

>>> bar.__code__.co_varnames ('a', 'x') >>> bar.__code__.co_consts (None, 3) >>> bar.__code__.co_argcount 1 

Bytecode in Python

To view the bytecode:

>>> bar.__code__.co_code b'd\x01\x00}\x01\x00|\x01\x00|\x00\x00\x17S' 

This sequence is what the interpreter loops through to execute your code.

Disassembling the Bytecode

Use the dis module to understand how Python executes bytecode:

import dis dis.dis(bar.__code__)

Output:

  2           0 LOAD_CONST               1 (3)              2 STORE_FAST               1 (x)  3           4 LOAD_FAST                1 (x)              6 LOAD_FAST                0 (a)              8 BINARY_ADD             10 RETURN_VALUE

This gives insights into what each bytecode instruction does.

>>> bar.__code__.co_consts[1] 3 >>> bar.__code__.co_varnames[1] 'x' 

Conclusion

To summarize, Python code is first converted to bytecode by the compiler. This bytecode is then executed by the Python interpreter within a virtual machine. Understanding the interpreter gives you more control and insight into how Python runs your code.