Python FAQ: Top Questions

8. What is the difference between `.py` and `.pyc` files?

The `.py` and `.pyc` files are two common file types encountered in Python development, representing different stages of Python code execution. Understanding their roles helps in comprehending Python's internal workings and managing project files.

`.py` files (Python Source Code):
- A `.py` file contains the **source code** written by a developer in human-readable Python syntax.
- This is the file you write, edit, and read. It's plain text.
- When you run a Python script, you typically execute the `.py` file (e.g., `python my_script.py`).
- These files are essential for development, version control, and sharing your code.
`.pyc` files (Python Compiled Bytecode):
- A `.pyc` file contains the **bytecode** generated by the Python interpreter after it compiles a `.py` source file.
- As discussed in Q3, when a Python interpreter executes a `.py` file, it first compiles the source code into bytecode. This bytecode is an intermediate, platform-independent representation of your Python code.
- The interpreter then executes this bytecode on the Python Virtual Machine (PVM).
- For modules that are imported (or sometimes even for top-level scripts run multiple times), Python **caches** this generated bytecode in `.pyc` files.
- These `.pyc` files are typically stored in a subdirectory named `__pycache__` within the directory of the original `.py` file (e.g., `my_module.cpython-310.pyc` for `my_module.py` on Python 3.10).
- The main purpose of `.pyc` files is to **speed up the startup time** of Python programs. If the interpreter finds an existing `.pyc` file that is newer than its corresponding `.py` file, it can load and execute the bytecode directly, skipping the initial compilation step from source code to bytecode.
- They are not meant to be human-readable or edited directly.

In summary, `.py` files are what you write, and `.pyc` files are optimized, intermediate versions of your code that Python generates for faster execution. You generally commit `.py` files to version control (like Git) but usually exclude `.pyc` files (and the `__pycache__` directory) because they can be regenerated by the interpreter as needed.


# --- Example: Lifecycle of .py and .pyc files ---

# 1. Create a Python source file (e.g., my_module.py) in a directory:
#    # my_module.py
#    def greet(name):
#        """A simple greeting function."""
#        return f"Hello, {name} from my_module!"
#
#    if __name__ == "__main__":
#        print(greet("Developer"))

# 2. Run this module or import it from another script:
#    # main_script.py (in the same directory)
#    import my_module
#    print(my_module.greet("Pythonista"))
#    print("---")

# 3. Steps to observe the files:
#    a. Save the content of 'my_module.py' into a file named 'my_module.py'.
#    b. Save the content of 'main_script.py' into a file named 'main_script.py'.
#    c. Open your terminal or command prompt and navigate to the directory where
#       you saved these files.
#    d. Run 'main_script.py':
#       > python main_script.py
#
# Expected output on console:
# Hello, Pythonista from my_module!
# ---

# 4. Observe the files in your directory after running the script:
#    You will find a new directory named '__pycache__'.
#    Inside '__pycache__', you will see a file like:
#    'my_module.cpython-3xx.pyc' (e.g., my_module.cpython-310.pyc)

# Explanation of what happened:
#    - When 'main_script.py' was run, it imported 'my_module'.
#    - During the import process, the Python interpreter:
#        1. Read 'my_module.py'.
#        2. Compiled its source code into bytecode.
#        3. Executed the bytecode.
#        4. Saved this bytecode to 'my_module.cpython-3xx.pyc' inside '__pycache__'
#           for faster loading next time.
#    - If you run 'python my_module.py' directly, it will also generate
#      the .pyc file for that module, although the primary purpose of .pyc is
#      for imported modules.

print("This is a conceptual example for observing file creation. Please follow the instructions to run it in your environment.")
print("The key takeaway: .py is your source code, .pyc is the cached, optimized bytecode generated by Python.")

Explanation of the Example Code:

The example describes a common scenario where a Python module (`my_module.py`) is imported by another script (`main_script.py`).
When `main_script.py` is executed, the Python interpreter processes `my_module.py`. This processing involves the implicit compilation of `my_module.py` into bytecode.
This bytecode is then executed. Crucially, the interpreter also saves a copy of this bytecode as `my_module.cpython-3xx.pyc` within the `__pycache__` directory.
The detailed steps guide the user to manually create these files and then run the `main_script.py` to physically observe the `__pycache__` directory and the `.pyc` file being generated in their file system.
This practical demonstration reinforces that `.py` files are the human-written source code, while `.pyc` files are automatically generated binary bytecode used by Python for execution optimization.

Understanding this distinction is vital for managing Python projects, especially concerning what files to include in version control (always `.py`, never `.pyc` or `__pycache__`).

←→