Do you think IIT Guwahati certified course can help you in your career?
Introduction
In programming, Python has become one of the most popular & widely used languages. It is known for its simplicity, readability & versatility. If you are a new programmer, it is important to understand the basic building blocks of Python, like statements, indentation & comments. These elements play a crucial role in writing clean, organized & readable code.
In this article, we will discuss what statements are, the different types of statements in Python, the significance of indentation & the purpose of comments.
What is Statement in Python?
In Python, a statement is an instruction that the Python interpreter can execute. It is a single line of code that performs a specific action or task. Statements are the building blocks of a Python program & are used to define variables, perform calculations, make decisions, iterate over data & more.
A statement can be as simple as assigning a value to a variable, such as:
x = 5
In this example, the statement x = 5 assigns the value of 5 to the variable x.
Statements can also be more complex, involving expressions, function calls, or control flow structures. For example:
if x > 10:
print("x is greater than 10")
else:
print("x is less than or equal to 10")
This code demonstrates an if-else statement that checks the value of x & prints a message based on the condition.
Python statements are typically written on separate lines, & the Python interpreter executes them sequentially, from top to bottom. Each statement performs a specific operation, & the combination of these statements forms a complete Python program.
Types of statements in Python
Python supports many types of statements that solve different purposes. Let's see some of the most common types of statements in Python:
Assignment Statements
These statements are used to assign values to variables. They allow you to store data in memory & retrieve it later.
For example:
x = 10
name = "Rekha"
Conditional Statements
Conditional statements, such as if, elif, & else, allow you to make decisions based on certain conditions.
They enable your program to execute different code blocks depending on whether a condition is true or false.
For example:
if age >= 18:
print("You are eligible to vote.")
else:
print("You are not eligible to vote.")
Looping Statements
Looping statements, like for & while are used to repeat a block of code multiple times. They help in iterating over sequences (such as lists or strings) or executing a code block until a specific condition is met.
For example:
for i in range(5):
print(i)
Function Definition Statements:
Function definition statements are used to define reusable blocks of code called functions. They allow you to encapsulate a set of instructions & call them whenever needed.
For example:
def greet(name):
print("Hello, " + name + "!")
Import Statements
Import statements are used to bring external modules or libraries into your Python program. They allow you to access pre-written code & use its functionality in your own program.
Example :
import math
print(math.pi)
Exception Handling Statements
Exception handling statements, such as try, except, & finally, are used to handle errors & exceptions that may occur during the execution of your program. They help in gracefully handling unexpected situations & preventing program crashes.
Example :
try:
result = 10 / 0
except ZeroDivisionError:
print("Cannot divide by zero!")
What is Indentation in Python?
Indentation is a crucial aspect of the Python programming language. Unlike many other programming languages that use braces or keywords to define code blocks, Python uses indentation to determine the grouping of statements.
In Python, indentation refers to the whitespace (spaces or tabs) at the beginning of a line of code. It is used to indicate the level of nesting or the scope of a code block. The statements within the same indentation level are considered to be part of the same block.
For example:
if x > 0:
print("x is positive")
print("This is still inside the if block")
print("This is outside the if block")
In this code snippet, the two print statements that are indented under the if statement belong to the if block. They will only be executed if the condition x > 0 is true. The last print statement, which is not indented, is outside the if block & will be executed regardless of the condition.
The benefits of indentation are
Readability: Indentation makes the code structure visually clear & easy to understand. It helps in identifying the beginning & end of code blocks, making the program more readable.
Consistency: Python enforces consistent indentation throughout the code. This promotes good coding practices & makes the code more maintainable.
Simplicity: By using indentation, Python eliminates the need for explicit delimiters like braces or keywords, resulting in cleaner & more concise code.
It is important to note that Python is strict about indentation. Inconsistent or incorrect indentation will result in an IndentationError. Therefore, it is crucial to maintain proper indentation throughout your Python code.
Role of Indentation in Python:
Indentation plays a significant role in Python programming. It is not just a matter of style but also has a very important role to play. Let's see the role of indentation in Python:
Defining Code Blocks
Indentation is used to define code blocks in Python. Code blocks are groups of statements that are executed together. In Python, code blocks are defined by their indentation level. Statements with the same indentation level are considered part of the same block.
Indentation determines the scope of variables & functions in Python. The scope refers to the visibility & accessibility of variables within a program. Variables defined within a code block (indented region) are only accessible within that block & its nested blocks.
For example:
def my_function():
x = 10 # Local variable within the function
print(x)
print(x) # This will raise an error, as x is not accessible outside the function
Enhancing Readability: Proper indentation makes Python code more readable & easier to understand. It visually separates different levels of nesting & clearly shows the structure of the program. Well-indented code is more intuitive & helps other developers (or yourself in the future) to comprehend the code's flow & purpose.
Ensuring Consistent Structure: Python's indentation rules enforce a consistent structure throughout the codebase. All developers working on a Python project must follow the same indentation conventions. This consistency helps in maintaining code quality, reduces ambiguity & makes collaboration easier.
Avoiding Braces & Delimiters: By using indentation, Python eliminates the need for braces or other delimiters to denote code blocks. This results in cleaner & more concise code compared to languages that rely on explicit delimiters. The absence of braces also encourages developers to write shorter & more focused code blocks.
It's important to note that Python's indentation is not just a stylistic choice but a fundamental part of the language's syntax. Incorrect indentation can lead to syntax errors & unexpected behavior. Therefore, it is crucial to be consistent & precise with indentation in Python code.
Example
Python
Python
def calculate_grade(score):
if score >= 90:
grade = "A"
elif score >= 80:
grade = "B"
elif score >= 70:
grade = "C"
elif score >= 60:
grade = "D"
else:
grade = "F"
return grade
# Test the function
score = 85
result = calculate_grade(score)
print("Score:", score)
print("Grade:", result)
You can also try this code with Online Python Compiler
In this example, we have a function called calculate_grade that takes a score as input & determines the corresponding grade based on the score. The indentation plays a crucial role in defining the structure & flow of the code:
The if, elif, & else statements are indented to indicate that they are part of the calculate_grade function. They form a code block that is executed when the function is called.
The assignments of the grade values ("A", "B", "C", "D", "F") are indented under their respective conditions. This indicates that they belong to the corresponding code block & will only be executed if the condition is true.
The return statement is also indented, indicating that it is part of the function & will be executed after the grade assignment.
Outside the function, we have code that tests the calculate_grade function. The score variable is assigned a value of 85, & the function is called with this score. The resulting grade is stored in the result variable.
Finally, we print the score & the calculated grade using the print statements.
The indentation in this example helps clearly define the structure of the code, making it easy to understand the logic & flow of the program. It visually separates the function definition, the conditional statements, & the test code.
What are Comments in Python?
Comments are an essential part of any programming language, including Python. They are used to add explanatory notes, descriptions, or clarifications within the code without affecting its execution. Comments are intended for human readers & are ignored by the Python interpreter.
In Python, comments are useful for :
Code Documentation
Comments can be used to document the purpose, functionality, or usage of specific code segments. They help other developers (or yourself in the future) understand the code's intent & make it easier to maintain & modify.
For example:
# Calculate the average of a list of numbers
def calculate_average(numbers):
total = sum(numbers)
count = len(numbers)
average = total / count
return average
Explanations & Clarifications:
Comments can provide explanations or clarifications for complex or non-obvious code sections. They can describe the reasoning behind certain decisions, highlight potential issues, or provide additional context.
For example:
# Check if a number is prime
def is_prime(num):
if num < 2:
return False
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
return False
return True
Debugging & Troubleshooting
Comments can be used to temporarily disable certain code lines or to add debugging statements. This can be helpful during the development & troubleshooting process.
Comments can serve as reminders for tasks that need to be completed or future improvements to be made. They can help keep track of pending work or ideas for enhancements.
For example:
# TODO: Implement error handling
# TODO: Optimize performance for large datasets
Types of comments in Python
In Python, there are three main types of comments:
Single-line Comments
Single-line comments are used to add brief explanations or notes on a single line. They start with the hash symbol (#) & extend until the end of the line. Any text following the # symbol on the same line is considered a comment & is ignored by the Python interpreter.
For example
# This is a single-line comment
x = 10 # This is also a single-line comment
Multi-line Comments
Multi-line comments, also known as block comments, are used to add lengthier explanations or documentation that span multiple lines. In Python, there is no specific syntax for multi-line comments like in some other programming languages. However, you can use triple quotes (''' or """) to create multi-line strings that serve as comments.
For example:
'''
This is a multi-line comment.
It can span across multiple lines.
'''
"""
This is another way to create
a multi-line comment in Python.
"""
Docstrings (Documentation Strings):
Docstrings are a special type of comment used to document modules, functions, classes, & methods in Python. They are written as multi-line strings enclosed in triple quotes (''' or """) & appear as the first statement in the respective entity. Docstrings provide a way to document the purpose, parameters, return values, & usage of the code entity.
For example :
def greet(name):
"""
This function greets the person passed in as a parameter.
Parameters
- name (str): The name of the person to greet.
Returns
- str: The greeting message.
"""
return f"Hello, {name}! Welcome!"
Docstrings are not only used for documentation purposes but can also be accessed programmatically using the __doc__ attribute. IDEs & documentation generators often utilize docstrings to provide helpful information to developers.
It's important to note that while single-line comments & multi-line comments are used for general explanations & notes, docstrings have a more specific purpose of documenting code entities & providing structured information.
Single-line comment in Python
As mentioned earlier, single-line comments in Python start with the hash symbol (#) & extend until the end of the line. They are used to provide brief explanations or notes within the code.
Examples of single-line comments:
Python
Python
# This is a single-line comment
# Calculate the sum of two numbers
x = 10
y = 20
sum = x + y # Assigning the sum to a variable
# Print the result
print("The sum is:", sum)
You can also try this code with Online Python Compiler
In this example, we have single-line comments that explain the purpose of different parts of the code. The comments provide clarity & make the code more readable.
Single-line comments are used for:
Explaining the purpose or functionality of a specific line of code
Providing clarifications or additional context
Temporarily disabling a line of code during debugging or testing
Adding TODO or reminder notes for future improvements or tasks
It's good practice to use single-line comments sparingly & only when necessary. Overusing comments can clutter the code & make it harder to read. Comments should be concise, clear & add value to the understanding of the code.
Here's an example that shows the use of single-line comments for debugging purposes:
Python
Python
# Debugging code
x = 10 # print("Value of x:", x) # Temporarily disabled for debugging y = 20 result = x + y print("Result:", result)
You can also try this code with Online Python Compiler
In this case, the print statement that displays the value of x is commented out using a single-line comment. This allows you to disable the line temporarily without deleting it entirely, which can be helpful during the debugging process.
Multiline comment in Python
In Python, there is no specific syntax for multi-line comments like in some other programming languages. However, you can use triple quotes (''' or """) to create multi-line strings that serve as comments. These multi-line strings are not assigned to any variable & are simply ignored by the Python interpreter.
An example of a multi-line comment using triple quotes:
'''
This is a multi-line comment in Python.
It can span across multiple lines & can be used
to provide detailed explanations or documentation.
'''
"""
This is another way to create a multi-line comment.
It uses double quotes instead of single quotes,
but the functionality remains the same.
"""
# The code below will be executed
print("Hello, World!")
In this example, we have two multi-line comments created using triple quotes. The first one uses single quotes ('''), & the second one uses double quotes ("""). Both are valid ways to create multi-line comments.
Multi-line comments are used for:
Providing detailed explanations or documentation for a block of code
Explaining the purpose or functionality of a larger section of code
Temporarily disabling multiple lines of code during debugging or testing
Adding longer notes or instructions for other developers or maintainers
It's important to note that while multi-line strings can be used as comments, they are not the same as docstrings. Docstrings have the specific purpose of documenting modules, functions, classes, & methods & follow certain conventions.
An example that demonstrates the use of a multi-line comment to temporarily disable a block of code:
'''
# Temporarily disabled code block
x = 10
y = 20
result = x + y
print("Result:", result)
'''
# Alternative code block
x = 5
y = 3
result = x * y
print("Result:", result)
In this case, the first block of code is commented out using a multi-line comment. This allows you to disable multiple lines of code at once without deleting them entirely. The alternative code block below will be executed instead.
Docstring in Python
Docstrings, short for documentation strings, are a special type of comment used to document modules, functions, classes, and methods in Python. They are written as multi-line strings enclosed in triple quotes (''' or """) and appear as the first statement in the respective entity.
The purpose of docstrings is to provide a clear and concise description of what the code entity does, its parameters, return values, and any additional information that may be helpful for understanding and using the code.
Example of a function with a docstring:
def calculate_area(length, width):
"""
Calculates the area of a rectangle.
Args
length (float): The length of the rectangle.
width (float): The width of the rectangle.
Returns
float: The area of the rectangle.
"""
area = length * width
return area
In this example, the docstring is placed immediately after the function definition. It starts and ends with triple quotes and provides the following information:
A brief description of what the function does.
The parameters of the function, including their names, types, and descriptions.
The return value of the function, specifying its type and description.
Docstrings follow a specific format and convention. The most common convention is the Python Docstring Convention (PEP 257), which provides guidelines for writing docstrings.
Docstrings can be accessed programmatically using the __doc__ attribute of the code entity. This allows tools and IDEs to extract and display the documentation automatically.
For example:
print(calculate_area.__doc__)
This will output the docstring of the calculate_area function.
Docstrings are not limited to functions; they can also be used for modules, classes, and methods.
Let’s look at an example of a class with a docstring:
class Rectangle:
"""
Represents a rectangle shape.
Attributes
length (float): The length of the rectangle.
width (float): The width of the rectangle.
"""
def __init__(self, length, width):
"""
Initializes a new instance of the Rectangle class.
Args
length (float): The length of the rectangle.
width (float): The width of the rectangle.
"""
self.length = length
self.width = width
def calculate_area(self):
"""
Calculates the area of the rectangle.
Returns
float: The area of the rectangle.
"""
return self.length * self.width
In this example, the class Rectangle has a docstring that describes what the class represents and its attributes. The __init__ method and the calculate_area method also have their own docstrings explaining their purpose, parameters, and return values.
Difference Between 'Docstrings' and 'Multi-line Comments':
Aspect
Docstrings
Multi-line Comments
Purpose
Document modules, functions, classes, and methods
Provide explanations or temporarily disable code
Placement
First statement within a module, function, class, or method
Anywhere in the code
Accessibility
Can be accessed using __doc__ attribute
Not accessible programmatically
Convention
Follows specific formatting conventions (e.g., PEP 257)
No specific formatting conventions
Usage
Used by documentation tools and IDEs for generating docs
Used for human readers to understand the code
Syntax Highlighting
Often highlighted differently by IDEs and text editors
Typically highlighted as comments
Execution
Not executed as code
Not executed as code
Importance
Highly recommended for documenting code entities
Optional, used for clarification and temporary purposes
Frequently Asked Questions
Are comments and docstrings required in Python?
While comments and docstrings are not mandatory, they are highly recommended to enhance code readability and maintainability.
Can comments and docstrings affect the performance of Python code?
No, comments and docstrings do not impact the performance of Python code as they are ignored by the interpreter during execution.
How can I access docstrings programmatically in Python?
Docstrings can be accessed using the __doc__ attribute of modules, functions, classes, or methods in Python.
Conclusion
In this article, we have explained the fundamental concepts of statements, indentation, and comments in Python. We learned about the different types of statements, the importance of indentation in defining code structure, and the role of comments in enhancing code readability and documentation. Understanding and effectively utilizing these concepts is crucial for writing clean, organized, and maintainable Python code.
You can also practice coding questions commonly asked in interviews on Coding Ninjas Code360.
242+ registered 
