Python is a high-level, general-purpose programming language created by Guido van Rossum and first released in 1991. "High-level" means it hides most of the low-level detail — memory management, machine instructions — so you can focus on solving the problem instead of managing the computer.

Its defining trait is readable syntax. Where many languages lean on curly braces and semicolons, Python uses indentation and plain keywords, so code tends to read close to English. That's a big reason it's often recommended as a first language.

The line print("Hello, World!") above calls Python's built-in print() function, which displays whatever is inside the parentheses on the screen. It's traditionally the first program anyone writes in a new language.

Before you can run Python code, you need the Python interpreter installed. Download it from python.org/downloads — pick the latest stable 3.x release for your operating system.

Windows: run the installer, and make sure you tick Add python.exe to PATH on the first screen — this is what lets you type python from any terminal window.

macOS: macOS ships with an old system Python; install a current version from python.org or with Homebrew (brew install python) instead of relying on the built-in one.

Linux: most distributions already include Python 3 — check with the command below before installing anything.

The installer also sets up pip, Python's package manager, which you'll use later to install libraries other people have written.

So far you've typed code straight into the interactive shell, which runs each line immediately but forgets everything once you close it. A real program lives in a .py file — plain text saved with a .py extension — that you can run again any time and share with others.

The file above stores the text "Cynpho" in a variable called name (you'll cover variables properly in lesson 5), then uses two separate print() calls to display messages. Passing print() two things separated by a comma, like line 2 does, prints them on the same line with a space between.

You write .py files in a plain text editor or, better, a code editor with Python support like VS Code, which adds syntax highlighting and a built-in way to run the file.

Python has no curly braces and no semicolons marking the end of a line. Instead, a statement simply ends at the newline, and indentation — not punctuation — is what groups lines into a block. You'll see this properly once if statements and loops arrive, but the rule starts now: stay consistent, and use 4 spaces per indent level (the PEP 8 convention).

A comment is a note left for humans that Python completely ignores when it runs your code. Start one with # — everything after it on that line is skipped. Comments are perfect for explaining why code does something, not restating what it obviously does.

A """triple-quoted string""" that isn't assigned to anything or returned is created and immediately thrown away, which makes it a handy way to write a multi-line comment. Placed as the very first line inside a function or class, that same syntax becomes a docstring — a real piece of documentation tools can read, not just a discarded note.

A variable is a name that refers to a value stored in memory. name = "Maya" creates the variable name and points it at the string "Maya" — the single = is the assignment operator, not a math equals sign.

Python is dynamically typed: you never declare a type up front. A variable's type is simply whatever value it currently holds, and it can hold a different type entirely after a reassignment — age = 25 then later age = "twenty-five" is completely legal.

Naming rules: names can use letters, digits, and underscores, but can't start with a digit and can't be a reserved keyword like class or True. Names are case-sensitive, so age and Age are two different variables. The convention is snake_case for regular variables and UPPER_CASE for values meant to stay constant.

Every value in Python has a data type, whether you state it or not. The four you'll use constantly: str for text, int for whole numbers, float for decimal numbers, and bool for True/False. A fifth, None, is its own type — NoneType — and represents "no value at all," not zero or an empty string.

The built-in type() function tells you exactly what type a value is. It's the fastest way to check your assumptions when a variable isn't behaving the way you expect.

Text always needs quotes: "Jit" is a string, but Jit without quotes would be treated as a variable name instead. A whole number like 17 is an int; the moment a decimal point appears, like 99.99, it becomes a float — even if that decimal is .0.

We define a function named greet() using the def keyword. It takes one parameter name.

Inside the function, f"Hello, {name}!" is an f-string — the f prefix tells Python to embed the variable value directly into the string.

The return statement sends the value back to wherever the function was called.

On line 5 we call the function by writing its name followed by parentheses: greet("Cynpho"). The result is stored in result and printed.

input() lets a running program pause and wait for a person to type something. Whatever you pass in as an argument — like "Enter your name: " — is displayed first as the prompt, then Python waits until the user presses Enter.

Whatever the user typed is returned as a string, always — even if they typed 42, it comes back as the text "42", not the number. If you need a number, you have to convert it explicitly (the next lesson covers exactly that).

Without input(), every run of a program would behave identically — it's the simplest way to make a program interactive.

Type conversion changes a value from one data type into another. Python does some of this automatically (implicit conversion — like 1 + 2.0 becoming a float without you asking), but most of the time you'll do it yourself with explicit conversion: int(), float(), and str().

age = "17" is a string. int(age) reads that string and returns the whole number 17, which gets reassigned back to age. The same pattern works with float() to turn an int like 10 into 10.0.

The single most common reason you'll reach for this: input() always hands back a string, even when the user typed a number — so any calculation needs an explicit conversion first.

Arithmetic operators combine numbers: + - * / // % **. Most are familiar from math class, but two are Python-specific: // is floor division — it divides then drops anything after the decimal point — and % is the modulus, which returns only the remainder of a division.

Comparison operators — == != > < >= <= — compare two values and always produce a bool: True or False. Don't confuse == (compares) with = (assigns) — mixing them up is one of the most common beginner mistakes.

Logical operators — and, or, not — combine or invert boolean values. and needs both sides to be true, or needs at least one side true, and not flips True to False and back.

The if statement lets a program execute a block of code only when a specific condition evaluates to True. If the condition is False, Python simply skips the indented block beneath it.

In the example above, age >= 18 compares two values and produces a boolean result. Since 18 >= 18 is True, Python runs the indented line and prints "Adult".

Indentation — not braces or parentheses — is what defines an if block in Python. Every line that belongs to the block must be indented by the same amount, conventionally four spaces.

if-else provides two possible paths of execution: one branch runs when the condition is True, the other runs when it's False — exactly one of the two always executes.

Here, age >= 18 is False because 15 is less than 18, so Python skips the if block and instead runs the else block, printing "Minor".

Unlike a plain if with no else, this guarantees the program always does something meaningful for both outcomes — the positive case and the negative one.

elif is short for "else if" — it lets a program check several conditions in sequence, one after another, extending if/else to handle more than two possible outcomes.

Python checks each condition top to bottom and stops at the first one that's True — here, 82 >= 90 is False, but 82 >= 80 is True, so "Grade B" prints and every condition below it is skipped.

A final else catches whatever doesn't match any condition above it — order matters: conditions should generally run from most specific to most general.

A nested if is an if statement placed inside another if statement — used when one decision genuinely depends on a previous one having already been satisfied.

Here, the inner if has_id: is only even checked because the outer condition age >= 18 was already True. Both conditions must pass for "Access Granted" to print.

Nesting expresses a genuine dependency between decisions — but keep it shallow. Two levels is usually the practical limit before the logic becomes hard to follow.

A for loop iterates over a sequence of items, running its indented block once for each one — it automates repetition that would otherwise mean writing the same code by hand for every item.

range(1, 6) produces the numbers 1, 2, 3, 4, 5 — the stop value, 6, is never included. Each pass through the loop, i takes the next value in that sequence.

A for loop can iterate over far more than range() — lists, tuples, strings, dictionaries, and sets are all iterable in exactly the same way.

A while loop repeats its block for as long as a given condition remains True, checking that condition before every single pass.

Here, count <= 5 is checked before each iteration; as long as it holds, Python prints count and then increments it with count += 1.

That increment step is essential — without something inside the loop that eventually makes the condition False, a while loop runs forever.

break and continue are loop-control statements that change a loop's normal flow: break exits the loop immediately, continue skips straight to the next iteration without running the rest of the current one.

In the example above, continue skips printing 5 and jumps straight to the next value of i, while break stops the loop completely the moment i reaches 9 — so 9 and 10 never print either.

pass is a third, unrelated keyword that does absolutely nothing — it's a placeholder used where Python's syntax requires a statement but you don't have one yet, like an empty function body or an unfinished branch of an if statement.

A list is an ordered, mutable collection that can store multiple values — including duplicates and mixed types — in a single variable, written with square brackets.

fruits[0] accesses the first item using its index — Python counts from 0, so fruits[0] is "Apple", not "Banana".

fruits.append("Mango") adds a new item to the end of the list in place — unlike strings, lists can be modified freely after they're created.

A tuple is an ordered, immutable collection of values — once created, its contents can never be changed, added to, or removed, and it's written with parentheses instead of square brackets.

colors[1] accesses the item at index 1 — counting from 0, that's "Green", the second item in the tuple.

len(colors) returns 3, the total number of items — the same len() function works on lists, strings, and tuples alike.

A set is an unordered collection of unique values, written with curly braces — Python automatically discards duplicates and gives no guaranteed order.

numbers.add(6) inserts a new value. numbers.add(3) does nothing visible — 3 is already in the set, and a set can never contain the same value twice.

numbers.remove(2) deletes 2 from the set. Because sets are unordered, don't expect print(numbers) to show items in the order you added them.

A dictionary is a collection of key-value pairs — instead of a numeric index, you look up a value using the key it's stored under, inside curly braces with a colon between each key and value.

student["name"] looks up the value stored under the key "name", which is "Jit".

student["age"] = 18 updates the existing "age" key in place — dictionaries are mutable, just like lists.

greeting="Hello" gives that parameter a default value — if the caller doesn't supply one, Python uses "Hello" automatically, which is exactly what happens on line 4.

On line 5, passing a second value — "Welcome" — overrides the default, so greeting becomes "Welcome" for that call only.

A function can also hand back more than one value at once: return a, b actually packages them into a single tuple, which you can unpack directly, e.g. x, y = get_coordinates().

Beyond a fixed default, Python has two special parameter forms for when you don't know in advance how many arguments will arrive: *args and **kwargs — covered in the example below.

def greet(name, age): defines two parameters — named placeholders that only exist inside the function's own definition.

greet("Jit", 17) passes two arguments positionally: "Jit" binds to name and 17 binds to age, purely because of the order they're written in.

A parameter is the name used in the definition; an argument is the actual value supplied at the call site — the two terms describe the same slot at two different moments.

lambda creates a small, anonymous function in a single expression — no def, no name, and no return keyword needed.

square = lambda x: x * x is equivalent to writing def square(x): return x * x — whatever comes after the colon is automatically returned.

map(lambda x: x * x, numbers) applies that lambda to every item in numbers, and list() collects the results back into a list.

A module is simply a .py file containing Python code — functions, variables, classes — that can be reused from other files.

import math_utils loads math_utils.py as a module object; math_utils.add(2, 3) reaches the function through the module's name.

Python runs the imported file once, top to bottom, the first time it's imported — after that, its functions and variables are simply available through the module name.