Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/python/multiline-comments-in-python/ below:

Multiline Comments in Python - GeeksforGeeks

Last Updated : 12 Jul, 2025

A multiline comment in Python is a comment that spans multiple lines, used to provide detailed explanations, disable large sections of code, or improve code readability. Python does not have a dedicated syntax for multiline comments, but developers typically use one of the following approaches:

It help to improve code readability, provide documentation, enhance collaboration, Aids in debugging.

Using multiple # symbols on separate lines is the most efficient and Pythonic way to write multiline comments.

# This is a multiline comment
# Each line starts with #
# This method is efficient and preferred

print("Geeks For Geeks")  # Inline comment

Explanation: Here, the first three lines contain a hash character(#) and the interpreter prevents the three lines from execution. Then it prints the "Geeks For Geeks" and finally, it will prevent the # line from execution.

Python allows the use of triple single (''') or triple double (""") quotes to define multi-line strings. Although these are technically string literals and not comments, they can be used as comments if they are not assigned to a variable.

'''
This is a multiline comment using triple single quotes.
It is commonly used as a workaround.
'''

print("Triple Single and Double quotes")

"""
This is another multiline comment
using triple double quotes.
"""

Triple Single and Double quotes

Explanation:

• These triple-quoted strings are ignored by Python if not assigned to a variable.
• This method is widely used for docstrings (described below).

Backslash Method for commenting out multiple lines in Python is an unconventional and lesser-known approach. It involves using the line continuation character (\) to extend a statement across multiple lines, effectively preventing Python from executing the code.

Example: In Python, a backslash (\) is used to indicate that a statement continues on the next line. If you use a backslash at the end of multiple lines without forming a valid statement, Python will treat it as incomplete and ignore it.

# Using backslash for multiline comments
# This is a long comment \
# that spans multiple lines \
# using the backslash continuation method.

# Code continues below
print("geeks for geeks!")

A docstring is a special type of multiline string used to describe a module, function, class, or method. Unlike regular comments, docstrings are stored as metadata and can be accessed using the __doc__ attribute.

Example: Multi-line comments are used to comment on more than one line. The first line is a single-line comment. The second and third lines can be commented on using triple quotes(""" """). This prevents the execution of the above code. Finally, it prints "Mathematics" in the output. However, if these Python multiline comments are placed directly after a function or class signature, then these turn into docstrings. 

def docstring():
    """This is a docstring.
    It describes what the function does.
    """
    print("geeks for geeks tutorial")

print(docstring.__doc__)  # Access the docstring

This is a docstring.
It describes what the function does.

Explanation:

• The function docstring() contains a docstring, which is a multi-line string enclosed in triple double quotes (""").
• The line print(docstring.__doc__) accesses and prints the docstring associated with the function.
• The docstring maintains its indentation as written in the function.

Feature

Multiline Comments

Docstring

Purpose

used to add comment and explain code

used to document function, classes and modules..

Syntax

use # on each line or triple quotes

uses triple quotes at the beginning of a function/class

Execution

ignored by python completely

stored as a string and accessible via .__doc

Usage

anywhere in the code

typically at the start of functions, classes, or modules

Retrieval

cannot be accessed at runtime

can be accessed using help() or .__doc__

Best practice

use # for actual comments

use triple quotes for documentation

A common use of multiline comments is temporarily disabling code for debugging.

# print("This line is executed")
# print("This line is commented out")

"""
print("This block is commented out")
print("No Output Generated)
"""

Explanation:

• Useful for disabling code temporarily.
• # comments are better for debugging (they do not occupy memory).
• Triple-quoted strings should not be used for debugging.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4