Python Syntax Rules

Why This Matters

Python's reputation as a "readable" language isn't accidental—it's enforced through strict syntax rules that shape how you write every line of code. Understanding these rules isn't just about avoiding error messages; it's about grasping why Python was designed this way. You're being tested on your ability to write syntactically correct code, debug common mistakes, and explain the reasoning behind Python's design choices.

The syntax rules you'll learn here fall into three categories: structure and whitespace, naming and style conventions, and data representation. Each rule connects to Python's core philosophy of readability and simplicity. Don't just memorize what the rules are—understand what problem each rule solves and how breaking it affects your code's behavior.

---

Structure and Whitespace

Python uses whitespace as syntax, not just formatting. Unlike languages that use braces or keywords to define code blocks, Python makes indentation meaningful—this forces readable code by design.

Indentation Defines Code Blocks

• Four spaces per indentation level—this is the standard convention that most Python code follows
• Mixing tabs and spaces causes errors—Python 3 raises TabError when you inconsistently mix them in the same block
• Indentation determines scope—code at the same indentation level belongs to the same block, making nested logic visually obvious

Colons Introduce New Blocks

• A colon (:) signals "here comes an indented block"—required after if, for, while, def, class, and similar statements
• Forgetting the colon triggers SyntaxError—one of the most common beginner mistakes
• The colon-plus-indent pattern is universal—once you recognize it, you'll read Python control flow instantly

Line Endings Replace Semicolons

• Newlines end statements automatically—no semicolon required, which reduces visual clutter
• Semicolons are legal but discouraged—you can use them to put multiple statements on one line, but this hurts readability
• Long lines can use backslash (\) or parentheses for continuation—keeps code readable when expressions get complex

---

Naming and Style Conventions

Python has strong opinions about how you name things. These aren't just suggestions—following them makes your code recognizable to other Python developers and helps you avoid subtle bugs.

Case Sensitivity Matters

• Variable and variable are completely different identifiers—Python distinguishes uppercase and lowercase letters
• This causes hard-to-find bugs—accidentally capitalizing a variable name creates a new variable instead of referencing the existing one
• Built-in names use specific casing—True, False, and None are capitalized; most functions and methods are lowercase

Snake_case Is Standard

• Use snake_case for variables and functions—lowercase words separated by underscores (e.g., user_name, calculate_total)
• This follows PEP 8, Python's official style guide—consistent naming makes code easier to read and maintain
• Classes use PascalCase instead—capitalizing each word without underscores (e.g., UserAccount) distinguishes classes from functions

Comments Use # and Triple Quotes

• Single-line comments start with #—everything after the hash on that line is ignored by Python
• Triple quotes (''' or """) create multi-line strings—often used as docstrings to document functions and classes
• Comments explain why, not what—good comments clarify intent, not obvious syntax

---

Data Representation

Python is dynamically typed, meaning you don't declare variable types—Python figures them out from the values you assign. Understanding how to represent different data types correctly is essential.

Variables Are Created on Assignment

• No declaration needed—writing x = 5 creates the variable x and assigns it the value 5 in one step
• Dynamic typing means types can change—the same variable can hold an integer, then a string, then a list
• This flexibility requires careful attention—you won't get compiler warnings if you accidentally change a variable's type

Strings Use Matching Quotes

• Single (') or double (") quotes both work—but they must match (start and end with the same type)
• Triple quotes allow multi-line strings—useful for long text or docstrings
• Escape characters handle special cases—use \' or \" when you need quotes inside a string

Data Types Have Distinct Syntax

• Integers are whole numbers without quotes—42, -7, 0 are all integers
• Floats include a decimal point—3.14, 2.0, -0.5 are floats (note: 2.0 is a float, not an integer)
• Booleans are capitalized keywords—True and False (not true or TRUE)

---

Function and Expression Syntax

Parentheses serve multiple purposes in Python. Understanding when they're required versus optional helps you write correct code and read others' code accurately.

Parentheses Are Required for Function Calls

• Every function call needs parentheses—even with no arguments, write print() not print
• Without parentheses, you reference the function object itself—print is the function, print() calls the function
• Arguments go inside the parentheses—separated by commas for multiple arguments

Parentheses Control Order of Operations

• Group expressions to override default precedence—(2 + 3) * 4 gives 20, while 2 + 3 * 4 gives 14
• Standard math precedence applies—multiplication before addition, exponents before multiplication
• When in doubt, use parentheses for clarity—even when not strictly necessary, they make intent obvious

---

Quick Reference Table

---

Self-Check Questions

1. What two syntax elements work together to define a code block in Python, and why does this design enforce readable code?

2. You see TypeError when trying to concatenate a variable. The variable was assigned as count = "5" earlier. What's the likely issue, and how would you fix it?

3. Compare my_list and my_list()—what does each expression do, and when would you use each one?

4. A classmate's code uses both userName and user_name as variables. What two problems might this cause?

5. Why does Python distinguish between 5, 5.0, and "5"? Give an example of an operation that would work with one but fail with another.