Learn What the # Hashtag Is Used for in Python: Absolute Beginners Tutorial

If you have opened a Python file and noticed lines starting with the # symbol, you were looking at comments. The # character — commonly called a hash, number sign, or pound sign — is Python's single mechanism for marking text that the interpreter should skip entirely. This tutorial walks through every way the # symbol is used in Python, from simple notes to special directives the interpreter reads before running your code.

When the Python interpreter reads a .py file, it processes each line from top to bottom. The moment it encounters a # character that is not inside a string literal, it discards everything from that # to the end of the line. The discarded text never becomes part of the compiled bytecode, so comments cost nothing at runtime. They exist only in your source code for humans to read.

The # Symbol Creates a Comment

A comment is a piece of text that exists in source code solely for the benefit of the person reading it. Python's interpreter pretends the text is not there. Other programming languages use symbols like // or /* */ for comments, but Python relies exclusively on the # character. There is no alternative comment syntax built into the language.

# This entire line is a comment
print("Hello, world")  # This part after the code is also a comment

When you run the code above, the output is simply Hello, world. Python ignores the # text on both lines. The first line is skipped entirely, and on the second line, only the print() call is executed.

Comments serve several practical purposes. They explain why a particular approach was chosen, mark sections of code that need future revision, temporarily disable lines during debugging, and provide context that variable names alone cannot convey. Well-written comments make a codebase easier to maintain, especially when you return to your own code after weeks or months away from it.

Three Kinds of # Comments

Python programmers use the # symbol in three distinct patterns. Each follows the same core rule — everything after # on a line is ignored — but the placement and intent differ.

Single-line comments

A single-line comment occupies an entire line by itself. The # appears at the beginning of the line (after any indentation), and the rest of the line contains your explanatory text. This is the form you will write and read more than any other.

# Calculate the total price including sales tax
tax_rate = 0.0825
total = price + (price * tax_rate)

Inline comments

An inline comment appears on the same line as a statement, separated by at least two spaces. PEP 8, the official Python style guide, recommends using inline comments sparingly and only when the statement needs clarification that is not obvious from the code itself.

timeout = 30  # seconds before the connection drops
retries = 3  # max attempts before raising an error

Block comments

A block comment is a group of consecutive single-line comments that together explain a section of code. Each line begins with # followed by a single space. If the explanation has multiple paragraphs, separate them with a line containing only a #.

# Validate the user's input before processing.
# If the value is not a positive integer, the
# function returns None and logs a warning.
#
# This check was added after ticket #4821
# exposed a crash when negative values reached
# the database layer.
def validate_input(value):
    if not isinstance(value, int) or value < 0:
        return None
    return value

Block comments are the PEP 8-recommended way to write multi-line explanations. Python does not have a dedicated multi-line comment syntax like the /* */ found in C or Java. While triple-quoted strings (''' or """) are sometimes used as a shortcut, they are string literals, not true comments. PEP 8 recommends consecutive # lines for block comments.

Special Uses of the # Symbol

Beyond regular comments, the # character appears in two specialized directives that Python's parser treats differently from normal code. Both look like comments to the human eye, but they carry functional significance.

The shebang line

A shebang line begins with #! and must appear on the very first line of a script. It tells Unix-like operating systems (Linux and macOS) which interpreter to use when the script is executed directly from the terminal. The name "shebang" comes from combining the words "hash" and "bang" (the exclamation mark).

#!/usr/bin/env python3

# The shebang above lets you run this file with: ./script.py
# instead of: python3 script.py

print("Running directly from the terminal")

The operating system's kernel reads the #! sequence and uses the path that follows it to locate the interpreter. Python itself treats the shebang as an ordinary comment and ignores it. On Windows, the shebang has no effect because the OS uses file associations to determine the interpreter. PEP 394 recommends using #!/usr/bin/env python3 because env searches the system's PATH, which works correctly inside virtual environments.

The encoding declaration

An encoding declaration is a specially formatted comment placed on the first or second line of a file. It was introduced by PEP 263 and tells the Python parser which character encoding the source file uses.

# -*- coding: utf-8 -*-

# This declaration was common in Python 2 files.
# Python 3 defaults to UTF-8, so it is rarely
# needed in modern projects.

In Python 2, the default encoding was ASCII, and files containing non-ASCII characters (such as accented letters or CJK characters) would fail to parse without an explicit declaration. Python 3 changed the default to UTF-8, which can represent virtually every character in use worldwide. You will still see encoding declarations in older codebases, but new Python 3 projects almost never need them.

Python Learning Summary Points

1. The # symbol is Python's only comment character. Everything from # to the end of the line is ignored by the interpreter and never becomes part of the compiled bytecode.
2. Python supports three comment patterns: single-line comments on their own line, inline comments after a statement (with at least two spaces of separation), and block comments made of consecutive # lines.
3. The # also appears in the shebang line (#!/usr/bin/env python3) that tells Unix-like operating systems which interpreter to run, and in the PEP 263 encoding declaration (# -*- coding: utf-8 -*-) that specifies a file's character encoding.
4. PEP 8 recommends a maximum of 72 characters per comment line, always placing a single space after the #, and using block comments (consecutive # lines) instead of triple-quoted strings for multi-line explanations.
5. Comments should explain why code exists or how a tricky piece of logic works. Avoid restating what the code already says. Write comments as you code rather than trying to add them later.

The # symbol is one of the first things you will use in Python, and it remains one of the most important throughout your entire career writing Python code. Good commenting habits established early will save time and reduce frustration whenever you revisit old projects or collaborate with other developers. Practice writing comments that explain the reasoning behind your decisions, and your future self will be grateful.