Understanding Python Syntax Basics

A Python statement typically consists of a keyword or function name, followed by parentheses (if it takes arguments), followed by the arguments themselves. The statement ends at the end of the line—no semicolon required.

Programming

Interactive lab

Try it: Syntax Errors and Indentation

How Python checks a program's structure before running any of it: the tokenizer tracks indentation with a stack (INDENT and DEDENT), the parser groups lines into blocks after each colon, and when something is wrong Python reports the exact SyntaxError, IndentationError or TabError with the line, a caret under the spot and hints like "Did you mean '=='".

How it works

The tokenizer reads each line's leading spaces: deeper than the top of the indentation stack is an INDENT (pushed), shallower pops DEDENTs until it matches, and a width that matches no open level is an IndentationError.
Tabs count as 8 columns and as 1; if the two ways of counting disagree about the block structure, it is a TabError.
Inside ( [ { line breaks and indentation are ignored, so a missing ) swallows the following lines; Python reports "'(' was never closed" when the error is found on a later line.
The parser matches statements: a header such as if, for, while, def or else must end with ':' and be followed by an indented block; = where a condition is expected, or a keyword used as a name, is invalid syntax.
Python stops at the first error and prints File, line, the source line, a caret (^) under the columns it blames, and the error type and message; no line of the program has run.

Default run (4 steps): main.py has 7 lines. Before running any of it, Python compiles the whole file: the tokenizer splits each line into tokens and tracks indentation, and the parser groups the statements into blocks. … Python stops: SyntaxError: expected ':' (line 2). No line of the program has run.

Simplified: The programs are fixed and you break them with one menu choice at a time. The lab's own small Python tokenizer and parser (written for the statements these programs use: assignments, print calls, if / elif / else, for, while, def and return) checks the text; nothing is executed as real Python. Every program the lab can show was compiled by CPython 3.12 and the lab reproduces its exception type, message, line, caret columns and the printed report. Only the error kinds offered in the menu are modelled.

Educational simulation

Loading the simulation…

Why Python Feels Approachable

Python has an extraordinarily simple syntax. This is one of its defining characteristics and one reason it has become so popular for beginners and professionals alike. When you write Python, your code reads more like English instructions than cryptic computer commands. This simplicity does not come from removing power—Python is a fully featured language—but from thoughtful design choices about how statements are written and organized.

The ease of getting started with Python means you can focus on learning programming concepts rather than wrestling with complex syntax rules. This article walks you through the fundamental building blocks of Python syntax so you understand not just what to write, but why Python's approach works.

Python Versus Other Languages

To appreciate Python's simplicity, it helps to see how the same task looks in different languages. Consider a simple program that prints a greeting. In Python, this is direct and readable. In languages like Java or C++, the same task requires more boilerplate—additional syntax that does not directly express your intent but is required by the language's rules.

How does the same simple task—printing a greeting—look across three languages? Notice Python's directness versus the ceremony required in Java and C++.

Python requires no class declaration, no main method signature, no headers, no return statements for a simple script. You write what you mean. This is not accidental—it is a core design philosophy of Python.

The Building Blocks of a Python Statement

Every Python program is made up of statements. A statement is a complete instruction that tells Python to do something. Understanding the anatomy of a statement helps you write correct code and debug problems when they arise.

What are the core parts of a simple Python statement, and what role does each part play?

Key point

Indentation: How Python Defines Code Blocks

One of the most distinctive features of Python is that it uses indentation—whitespace at the beginning of a line—to define code blocks. In many other languages, curly braces or keywords mark where a block begins and ends. Python uses consistent indentation instead. This forces your code to be visually organized, which makes it more readable.

When you write a function, a loop, a conditional statement, or any other block structure, the code inside that block must be indented further than the line that starts the block. All lines at the same indentation level belong to the same block. When indentation decreases, that block ends.

On the left, a function definition with no indentation—this is incorrect Python. On the right, the same function with proper indentation—this is correct. Notice how indentation shows which lines belong inside the function.

Your First Python Program

Let us walk through writing and running a simple Python program. This concrete example shows how the concepts above come together in practice.

Worked example

Writing a Simple Greeting Function

Write a Python program that defines a function called say_hello. This function takes no parameters and prints a greeting message when called. Then call the function to see the output.

1
Define the function
Use the def keyword followed by the function name, parentheses (empty because there are no parameters), and a colon. The colon tells Python that a block is coming next.
2
Indent the function body
The print statement must be indented 4 spaces. This indentation shows that the print statement belongs inside the say_hello function.
3
Call the function
After the function definition, call say_hello() by writing its name followed by parentheses. This executes the function and prints the greeting.

Result

When you run this program, the output is: Hello, World!

python

def say_hello():
    print('Hello, World!')

say_hello()

def say_hello():
    print('Hello, World!')

say_hello()

Output (expected)

Hello, World!

Notes on the code

def keyword starts the function definition
say_hello is the function name
Empty parentheses mean no parameters
Colon signals the start of a block
Indented 4 spaces—this line is inside the function
Empty line separates the definition from the call
Calling the function executes the code inside it

Notice several things in this example. The function definition uses the def keyword, followed by the function name and parentheses. The colon at the end signals that a block is coming. The print statement is indented, showing it belongs inside the function. When you call say_hello(), Python executes the indented code and prints the message.

Common Mistakes with Python Syntax

Common mistake
Forgetting the colon after a function definition or control structure
What it looks like
```
def say_hello()
    print('Hello')
```
Why it fails
Python uses the colon to signal the start of a block. Without it, Python does not know a block is coming and raises a SyntaxError.
Do this instead
```
def say_hello():
    print('Hello')
```
Common mistake
Inconsistent or missing indentation inside a block
What it looks like
```
def say_hello():
print('Hello')
```
Why it fails
The print statement is not indented, so Python thinks it is outside the function. This causes an IndentationError.
Do this instead
```
def say_hello():
    print('Hello')
```
Common mistake
Mixing tabs and spaces for indentation
What it looks like
```
def say_hello():
	print('Hello')
```
Why it fails
Python treats tabs and spaces differently. Mixing them can cause indentation errors or unexpected behavior. Always use spaces (4 per level is standard).
Do this instead
```
def say_hello():
    print('Hello')
```
Common mistake
Using a semicolon at the end of a statement
What it looks like
```
print('Hello');
```
Why it fails
Python does not require semicolons. While they do not always cause an error, they are unnecessary and go against Python style conventions.
Do this instead
```
print('Hello')
```

Syntax Highlighting and Tools

One of the very basic requirements for writing Python is syntax highlighting. Syntax highlighting is a feature in text editors and IDEs that colorizes different parts of your Python program so that you can see your program and visualize its running. Keywords appear in one color, strings in another, comments in a third, and so on.

Syntax highlighting serves two purposes. First, it makes your code easier to read and understand at a glance. Second, it helps you catch mistakes early. If a string is not highlighted the way you expect, you might have forgotten a closing quote. If a keyword is not highlighted, you might have misspelled it.

Practice: Write Your Own Program

EASY

Write a Python program that defines a function called greet_user. The function should print a message like 'Welcome to Python!' When you have written the function, call it to verify it works. Pay attention to the colon after the function definition and the indentation of the print statement.

Hints

Start with the def keyword, followed by the function name and parentheses.
Remember the colon at the end of the def line.
Indent the print statement 4 spaces.
After the function definition, call the function by writing its name followed by parentheses.

Your attempt (not saved)

Summary

1
Python has an extraordinarily simple syntax compared to languages like Java and C++. You write what you mean without unnecessary boilerplate.
2
Python statements consist of keywords or function names, parentheses, and arguments. No semicolons are required.
3
Indentation is mandatory in Python. It defines code blocks and control flow. Use 4 spaces per indentation level.
4
A colon signals the start of a block. Every block must be indented consistently.
5
Syntax highlighting in a good editor helps you write correct code and catch mistakes early. Use an IDE or editor with Python support.
6
Practice writing simple functions to internalize these syntax rules. The more you write, the more natural Python syntax becomes.

At a glance

Python has an extraordinarily simple syntax by design, requiring no class declarations, main methods, or semicolons for basic programs.
Python statements are built from keywords or function names, parentheses, and arguments, organized left-to-right in a readable way.
Indentation is not optional—it defines code blocks and control flow. All lines at the same indentation level belong to the same block.
Colons signal the start of a block; the next line must be indented further to show it belongs inside that block.
Use a text editor or IDE with syntax highlighting and Python support to catch mistakes early and write code more efficiently.

Related concepts

More concepts starting with U