Your First Python Program: Syntax Rules, Comments, and Print Formatting

Write your first Python program. Learn syntax rules, indentation conventions, single/multi-line comments, and advanced print function formatting.

Table of Contents

  1. Introduction
  2. Learning Objectives
  3. Prerequisites
  4. Writing Hello World in Python
  5. The Print Function (print()) Deep-Dive
  6. Python Comments & Documenting Code
  7. Core Python Syntax Rules
  8. Mermaid Indentation Flowchart
  9. Real-World and Production Examples
  10. Best Practices & Common Mistakes
  11. Performance & Security Notes
  12. Interview Insights
  13. Frequently Asked Questions (FAQs)
  14. Summary
  15. Related Tutorials

Introduction

In programming, the traditional way to start learning a new language is to write a script that prints "Hello, World!" to the screen. In Python, this requires a single line of code.

However, behind this simple line of code lies a set of syntax rules that are fundamental to how the language executes. Python does not use curly braces {} or semicolons ; to define structure; instead, it uses whitespace indentation and newlines. Understanding these core syntax rules, how to write clean code comments, and how to format outputs using the print() function is essential to building solid programming foundations.

Learning Objectives

By the end of this tutorial, you will be able to:

  • Write and execute a basic Python script.
  • Customize the output of the print() function using sep, end, and flush parameters.
  • Differentiate between single-line comments, block comments, and docstrings.
  • Apply Python's indentation rules to avoid IndentationError syntax bugs.
  • Manage physical vs. logical lines using implicit and explicit line continuations.

Prerequisites

Writing Hello World in Python

In languages like Java or C++, printing a simple message requires declaring a class and a main execution function:

// Java Hello World
public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

In Python, you do not need any wrapping boilerplate code. You call the built-in print() function directly at the top level of your script:

# hello.py
print("Hello, World!")

Running the Program:

  1. Save the code in a file named hello.py.
  2. Open your terminal or Command Prompt, navigate to the folder containing your file, and run: 
    python hello.py

The interpreter compiles the script to bytecode, runs it in the virtual machine, and prints Hello, World! to your terminal.

The Print Function (print()) Deep-Dive

The print() function prints data to the standard output device (usually your monitor). Let's examine the full signature of the print() function:

$$\text{print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)}$$

Let's break down each parameter:

1. Printing Multiple Objects (*objects)

You can pass multiple items into the print() function, separated by commas. The function will print them sequentially in a single line:

print("Welcome", "to", "VSNEXOS", 2026) # Prints: Welcome to VSNEXOS 2026

2. Custom Separators (sep)

By default, the browser prints multiple objects separated by a single space. You can customize this separator using the sep parameter:

# Prints: Python-is-awesome
print("Python", "is", "awesome", sep="-")

# Prints: Path: /usr/bin/python
print("Path: ", "usr", "bin", "python", sep="/")

3. Custom Line Ends (end)

By default, the print() function appends a newline character (\n) to the end of its output, forcing the next print statement onto a new line. You can customize this behavior using the end parameter:

# Keeps the next print statement on the same line
print("Hello", end=" ")
print("World!") # Prints: Hello World!

4. Buffered Output Control (flush)

By default, Python buffers output writing for performance, holding text in memory before writing it to the screen. Setting flush=True forces the browser to write the output to the screen immediately. This is useful for building real-time loading bars or console animations.

import time

# Prints loading dots one-by-one with a delay
for i in range(5):
    print(".", end="", flush=True)
    time.sleep(0.5)

Python Comments & Documenting Code

Comments are notes in your code that are ignored by the interpreter. They are used to explain the logic of your program to other developers (and your future self).

1. Single-Line Comments (#)

Start a comment with a hash symbol (#). Anything written after the hash on that line is treated as a comment:

# Calculate the area of a circle
radius = 5
area = 3.14 * (radius ** 2) # Formula: pi * r^2

2. Block Comments

To write a comment that spans multiple lines, place a hash symbol (#) at the start of each line:

# This is a block comment
# that explains the logic of the
# following code block.

3. Docstrings (Documentation Strings)

A Docstring is a string literal written inside triple quotes (""" or ''') that is used to document modules, classes, or functions.

Unlike standard comments, docstrings are not ignored by the interpreter. They are parsed and stored in the element's __doc__ attribute, making them accessible to documentation generators and IDE helpers:

def add(a, b):
    """
    Calculates and returns the sum of two numbers.
    
    Parameters:
    a (int): First number
    b (int): Second number
    
    Returns:
    int: The sum of a and b
    """
    return a + b

# Access the docstring programmatically
print(add.__doc__)

Core Python Syntax Rules

Python's syntax is clean and readable, but it has strict rules that you must follow:

1. Indentation defines Blocks

In languages like Java, C++, and JavaScript, you group blocks of code (like functions or loops) inside curly braces {}:

// JavaScript block grouping
if (true) {
    console.log("True");
}

In Python, indentation defines blocks. You must indent all lines of code within a block by the same number of spaces (standard is 4 spaces). Mixing spaces and tabs, or using inconsistent indentation, will cause an IndentationError:

# Correct Indentation
if True:
    print("This is indented")
    print("This is also indented")

# Incorrect Indentation (Causes IndentationError)
if True:
    print("Indented 4 spaces")
      print("Indented 6 spaces! Error!")

2. Semicolons are Optional

In Python, a newline character represents the end of a statement. You do not need to add a semicolon ; at the end of each line:

x = 5  # Standard syntax
y = 10; # Valid, but not recommended by style guides

3. Line Continuations

If a line of code is too long, you can break it into multiple physical lines. Python supports two continuation methods:

  • Implicit Continuation: Automatically occurs inside parentheses (), brackets [], or braces {}. This is the preferred way to write long statements: 
    total = (item_one_price +
         item_two_price +
         item_three_price)
  • Explicit Continuation: Use a backslash (\) at the end of a line to continue the statement on the next line: 
    total = item_one_price + \
        item_two_price + \
        item_three_price

Mermaid Indentation Flowchart

graph TD
    CodeBlock[Start of Conditional / Loop / Function] --> Colon[:]
    Colon --> NextLine[Go to next line]
    NextLine --> Indent[Indent by 4 spaces]
    Indent --> Exec{Are all statements in block indented equally?}
    Exec -->|Yes| RunBlock[Execute block successfully]
    Exec -->|No| IndentErr[Raise IndentationError syntax bug]
    style IndentErr fill:#EF4444,stroke:#fff,color:#fff

Real-World and Production Examples

Example 1: An Interactive Greeting CLI Program

Let's build a simple command-line program that reads user input, processes it, and prints a formatted response:

# interactive_cli.py

# Read user input from the console
username = input("Enter your username: ")
role = input("Enter your job role: ")

# Print a formatted greeting using an f-string
print(f"Hello, {username}!", end=" ")
print(f"Your role is set to: {role}.", sep=" ")

# Print a success status using custom separators
print("System", "status", "active", sep=" :: ")

Example 2: Simple Arithmetic Calculator (with Type Casting)

Build a calculator program that reads two numbers from the user and calculates their sum, converting the input strings to integers:

# calculator.py

print("--- Simple Addition Calculator ---")

# Read inputs (input() always returns data as a string)
num1_str = input("Enter first number: ")
num2_str = input("Enter second number: ")

# Convert string inputs to integers (type casting)
num1 = int(num1_str)
num2 = int(num2_str)

# Calculate sum
result = num1 + num2

# Print the formatted result
print(f"The sum of {num1} and {num2} is: {result}")

Best Practices & Common Mistakes

Best Practices

  • Use Spaces over Tabs: Always use 4 spaces for indentation. Configure your code editor to automatically convert tabs to spaces to prevent indentation errors.
  • Limit Line Length: Keep your physical lines of code under 79 characters (as recommended by PEP 8) to make your code easy to read on small monitors or side-by-side splits.
  • Write Clear Docstrings: Always document your functions and classes using triple-quoted docstrings.

Common Mistakes

  • Mixing Tabs and Spaces: Mixing tabs and spaces inside the same code block is a common cause of TabError bugs in Python 3.
  • Incorrect Case: Python is case-sensitive. Calling Print("Hello") instead of print("Hello") will cause a NameError.

Performance & Security Notes

  • The Danger of input() in Python 2: In legacy Python 2, the input() function evaluated input strings as live code, which was a security vulnerability. Python 3 resolved this by having input() always return data as a safe string. If you are converting code from Python 2 to Python 3, verify that your inputs are cast to numeric types explicitly.
  • Efficient String Concatenation: Avoid joining multiple strings inside a loop using the + operator, which creates a new string object in memory on every iteration. Instead, print objects using comma separators or use the .join() method.

Interview Insights

Typical Interview Questions:

  1. How does Python define code blocks? How does it differ from languages like Java? Answer Key: Python uses whitespace indentation to define code blocks, whereas Java uses curly braces {}. Consistent indentation is syntactically mandatory in Python.
  2. What is the difference between standard comments (#) and docstrings? Answer Key: Comments are ignored by the interpreter and are used to explain code logic to developers. Docstrings are string literals in triple quotes that document functions or classes, and they are parsed and stored in the __doc__ attribute.
  3. What do the sep and end parameters do in the print() function? Answer Key: sep defines the separator string printed between multiple objects (defaults to a space). end defines the character printed at the end of the statement (defaults to a newline \n).

Frequently Asked Questions (FAQs)

Q: Can I use single quotes for docstrings? A: Yes. You can use triple single quotes (''') or triple double quotes (""") to write docstrings, but PEP 8 recommends using triple double quotes (""") for consistency.

Q: Why does Python use indentation instead of braces? A: Indentation was chosen to make Python code clean, readable, and consistent. It forces developers to write indented code, preventing poorly formatted code blocks.

Summary

In Python, your first program is written by calling the built-in print() function. Python has strict syntax rules, requiring consistent whitespace indentation to define blocks and newlines to represent the end of statements. Developers explain code using single-line comments (#) and document components using triple-quoted docstrings.

Related Tutorials

← Back to Syllabus