Every Python program you will ever write — a Django backend, a pandas notebook, a FastAPI microservice, an automation script — is built from the same raw materials: variables that give names to data, data types that decide what that data can do, operators that combine values, and strings that carry text in and out of your program. In Lecture 1 you installed Python and printed your first line. In this lecture you learn how Python actually stores and manipulates data, which is the knowledge that separates someone who copies code from someone who can reason about it.

Why does this matter in real projects? Because most beginner bugs are type bugs. A form field arrives as the string "1,249.50" and you try to add GST to it. A division that used to return an integer in C now returns a float in Python. Two lists look equal but are actually the same object, so changing one silently changes the other. A Windows file path breaks because \n inside it became a newline. Each of these is a direct consequence of how Python treats names, objects and types — and each one is easy to avoid once you understand the model.

This lecture is written for Python 3.10 and newer. At the time of writing, Python 3.14 is the current stable series and 3.13 is still widely installed on servers and laptops; where a feature was introduced in a specific version (for example the = debug specifier in f-strings from Python 3.8, or removeprefix from Python 3.9), it is labelled so you can check compatibility.

By the end you will be able to predict when two variables share an object, use every core type correctly (including the surprising cases such as 0.1 + 0.2 and True + True), convert between types safely, apply arithmetic, comparison and logical operators with the right precedence, choose is versus == deliberately, and slice, search, transform and format strings like a professional. Work through every code snippet in a file or the REPL — reading about Python is not learning Python; typing it is.

In languages like Java or C, a variable is a box with a fixed type: int age = 25; reserves memory that can only ever hold an integer. Python works differently. A variable is a name (a label) that points to an object living somewhere in memory. The object has a type; the name does not. This is what dynamic typing means: the same name can point to a string now and an integer a moment later, and Python determines the type at runtime by looking at the object, not the name.

Three rules follow from this model, and they explain almost every "weird" behaviour you will meet later:

1. Assignment binds a name to an object; it never copies the object. b = a makes b a second label on the same object. For mutable objects like lists this means changing through b is visible through a.
2. Rebinding a name does not touch the object it used to point to. y = y + 1 creates a new integer object and moves the label y to it; x keeps pointing at the old object.
3. Objects are garbage collected when no name refers to them. You never free memory manually.

Python also has rules for valid names: letters, digits and underscores, not starting with a digit, case-sensitive (total and Total are different), and not a reserved keyword (class, def, if, None and about 30 others — see keyword.kwlist). The community style guide, PEP 8, asks for snake_case for variables and functions, UPPER_CASE for constants (Python has no real constants; it is a convention), and CapWords for classes. A leading underscore (_internal) signals "private by convention".

Since Python 3.6 you can write large numbers with underscores (85_000), which makes salaries and populations readable. You can also assign several names at once (price, qty = 499, 3) and swap values without a temporary variable (a, b = b, a) — this is tuple packing and unpacking, which the lecture on collections covers in depth.

Type hints (salary: int = 85_000, Python 3.5+) document the intended type and let tools like mypy, Pyright and your IDE catch mistakes, but the interpreter does not enforce them. Python stays dynamically typed; hints are for humans and tooling.

Python has three built-in numeric types plus two special singletons you will use constantly.

int — whole numbers with arbitrary precision. Unlike Java's 32-bit int or 64-bit long, a Python integer grows as large as memory allows, so 2 ** 100 just works and there is no integer overflow. Literals can be written in decimal, binary (0b1010), octal (0o17) or hexadecimal (0xFF).

float — a 64-bit IEEE 754 double, the same as double in Java/C and number in JavaScript. It has about 15–17 significant decimal digits and cannot represent most decimal fractions exactly, which is why 0.1 + 0.2 prints 0.30000000000000004. This is not a Python bug; it is binary floating point. Never compare floats with == for "closeness" — use math.isclose() (Python 3.5+) — and never store money in floats; use int paise or decimal.Decimal. Floats also support the special values inf, -inf and nan (float("nan") is not equal even to itself).

complex — numbers with a real and imaginary part, written with a j suffix: 3 + 4j. You will rarely use them in web work, but engineers, data scientists and students of signal processing will. abs() returns the magnitude.

bool — True and False. In Python, bool is a subclass of int: True behaves as 1 and False as 0 in arithmetic, so sum([True, False, True]) is 2. This is handy (count = sum(x > 50 for x in marks)) but also a trap when you check types. Every object has a truth value: 0, 0.0, "", [], {}, None are falsy; everything else, including "0", " " and -1, is truthy. bool(x) tells you which.

None — the single object of type NoneType, meaning "no value". Functions without a return statement return None, and it is the standard default for optional parameters. Always test it with is None, never == None.

Because Python decides types at runtime, you often need to ask what type an object has. There are two tools and they answer slightly different questions.

type(obj) returns the exact class of an object. type(42) is int, type("x") is str, type(None) is NoneType. Comparing with type(x) == int (or type(x) is int) is strict: it is False for a subclass. In particular, type(True) == int is False because the exact class is bool.

isinstance(obj, cls) asks "is obj an instance of cls or any subclass?" This respects inheritance, which is almost always what you want in real code: a function that accepts an int should usually accept a subclass too. isinstance also accepts a tuple of types (isinstance(x, (int, float))) and, since Python 3.10, the union syntax isinstance(x, int | float).

When should you check types at all? Python favours duck typing — "if it quacks like a duck, treat it as a duck" — so you often just call the method and let a TypeError surface. But at the boundaries of your program (parsing user input, reading JSON from an API, validating function arguments in a library) explicit checks give clearer error messages. The example below shows a typical guard: reject anything that is not a number, and explicitly reject bool because isinstance(True, int) is True and you rarely want to format True as ₹1.00.

Two related built-ins you will see: type(x).__name__ gives the type name as a string (useful in error messages), and issubclass(bool, int) checks the class relationship itself.

Data rarely arrives in the type you need. input() always returns a string. Environment variables are strings. JSON numbers may come as floats when you expect integers. Type conversion (also called casting) is how you move between types, and Python makes the explicit kind very visible: you call the target type like a function.

Explicit conversion functions:

• int(x) — from a float it truncates toward zero (int(-12.9) is -12, not -13); from a string it parses an integer and raises ValueError if the text is not a valid integer, so int("12.5") fails even though int(12.5) works. Leading/trailing whitespace and underscores are allowed. A second argument gives the base: int("ff", 16).
• float(x) — parses decimals and scientific notation ("1e3") and the words "inf", "nan".
• str(x) — the human-readable text of any object (what print shows). repr(x) is the developer-oriented form, with quotes around strings.
• bool(x) — the truth value. Watch out: bool("False") is True because the string is non-empty. Parse booleans from text with text.lower() in ("true", "1", "yes").
• round(x, n) — rounds a float to n decimals; with no n it returns an int. Python uses banker's rounding (round half to even), so round(12.5) is 12 and round(13.5) is 14. Combined with binary representation this gives results like round(2.675, 2) == 2.67. For money use decimal.Decimal with ROUND_HALF_UP.
• bin(), hex(), oct() — integer to text in another base; chr() / ord() — between characters and code points.

Implicit conversion happens only inside the numeric family: int + float gives float, int / int gives float, bool + int gives int. Python never silently converts between strings and numbers — "Total: " + 500 raises TypeError. This is deliberate (the Zen of Python says "explicit is better than implicit") and prevents the JavaScript-style "5" + 5 == "55" surprises.

The safe pattern for user input is: convert inside a try block, catch ValueError, and ask again. Lecture 3 covers the control flow; here is the shape.

Python's arithmetic operators look like every other language's, but four of them behave in ways that regularly trip up developers coming from C, Java or JavaScript.

/ true division always returns a float. 6 / 3 is 2.0, not 2. This changed in Python 3 (Python 2 did integer division), and it is why old tutorials sometimes give different output.

// floor division rounds down toward negative infinity, not toward zero. 7 // 2 is 3 as expected, but -7 // 2 is -4 (C and Java give -3). With a float operand it returns a float: 7.0 // 2 is 3.0.

% modulo takes the sign of the divisor. -7 % 3 is 2 in Python but -1 in C/Java/JavaScript. The guarantee Python keeps is a == (a // b) * b + a % b. This makes % ideal for wrap-around arithmetic (clock hours, circular buffers, day-of-week), because the result is always in 0 .. b-1 for positive b. divmod(a, b) returns both results in one call.

** exponentiation is right-associative and binds tighter than unary minus. 2 ** 3 ** 2 is 2 ** 9 == 512, and -2 ** 2 is -(2 ** 2) == -4. Write (-2) ** 2 when you mean the square of -2. Negative and fractional exponents work: 2 ** -1 is 0.5, 9 ** 0.5 is 3.0. The three-argument pow(base, exp, mod) does fast modular exponentiation, the core of RSA and many interview problems.

Precedence from highest to lowest: parentheses, **, unary + -, * / // %, binary + -, comparisons, not, and, or. When in doubt, add parentheses — readability beats cleverness.

Augmented assignment (+=, -=, *=, /=, //=, %=, **=) rebinds the name to the result. Note that balance *= 1.05 turns an int balance into a float.

Dividing by zero raises ZeroDivisionError for both ints and floats (Python does not return inf like JavaScript). For more maths, the math module provides sqrt, floor, ceil, pi, log and friends.

Comparison operators — ==, !=, <, <=, >, >= — always return a bool. A few rules matter:

• Numbers compare by value across types: 1 == 1.0 and 1 == True are True. But a number never equals a string: 25 == "25" is False.
• Ordering between unrelated types raises TypeError (5 < "10"). Python 2 allowed this; Python 3 refuses because it was a silent source of bugs.
• Strings compare lexicographically by Unicode code point, so all uppercase letters sort before lowercase: "Zebra" < "apple" is True. For human-friendly sorting, compare s.casefold() or use sorted(words, key=str.lower).
• Chained comparisons read like mathematics: 60 <= marks < 75 means 60 <= marks and marks < 75, and marks is evaluated only once.

Logical operators — and, or, not — are words, not symbols (&&, || do not exist; & and | are bitwise). Two behaviours make them more powerful than they look:

1. Short-circuit evaluation. and stops at the first falsy operand; or stops at the first truthy one. The right side is not evaluated at all, which is why user is not None and user.upper() is safe.
2. They return an operand, not necessarily True/False. 0 or "default" returns "default"; 3 and 7 returns 7. This gives the idiom name = user_input or "guest". Only not always returns a bool.

Precedence is not > and > or, so True or False and False is True. Parenthesise anything non-trivial.

Finally, the walrus operator := (Python 3.8+) assigns a value inside an expression. It shines in while loops and conditions where you would otherwise compute the same thing twice.

This is one of the most common Python interview questions and one of the most common beginner bugs, so it gets its own section.

== tests equality: do two objects have the same value? It calls the object's __eq__ method, so a class can define what "equal" means. Two separate lists [1, 2, 3] and [1, 2, 3] are equal.

is tests identity: are the two names pointing to the same object in memory? It compares id(a) == id(b) and cannot be overridden. The two separate lists above are not identical.

When is is correct? Only for singletons — objects of which exactly one exists: None, True, False, NotImplemented, Ellipsis, and sentinel objects you create yourself. PEP 8 explicitly says: compare with None using is / is not, never ==. The reason is both correctness (__eq__ could be overridden to return True for anything) and speed.

The trap: is sometimes appears to work for numbers and strings. CPython caches small integers from -5 to 256 and interns many short strings, so x = 100; y = 100; x is y is True. Even 257 is 257 can be True when both literals are compiled in the same unit. But this is an implementation detail — it varies between versions, between the REPL and script files, and between CPython and PyPy. Code that relies on it will break unpredictably. Since Python 3.8 the compiler emits a SyntaxWarning when you write x is 5 or s is "abc".

Rule of thumb: use == for values, is for None and other singletons, and if you are not sure, you want ==.

A string (str) is an immutable sequence of Unicode characters. "Unicode" means Python 3 strings handle Hindi, Tamil, emoji and the rupee sign as naturally as ASCII — len("नमस्ते") counts code points, not bytes. You create strings with single quotes, double quotes (identical in meaning — pick one and be consistent; double quotes are the black formatter default) or triple quotes for multi-line text. Adjacent string literals are joined at compile time, which is a clean way to split a long string across lines inside parentheses.

Indexing uses square brackets and starts at 0. Negative indexes count from the end: s[-1] is the last character. Indexing outside the range raises IndexError.

Slicing s[start:stop:step] returns a new string. start is inclusive, stop is exclusive, and all three parts are optional (defaults: 0, len(s), 1). This design means s[:k] + s[k:] == s and len(s[a:b]) == b - a. A negative step walks backwards; s[::-1] is the idiomatic reverse. Unlike indexing, slices never raise IndexError — out-of-range bounds are clipped, and an empty range gives "". These rules apply identically to lists and tuples, so learn them well once.

Useful operators: + concatenates, * repeats, in tests substring membership, len() gives the length, and ord() / chr() convert between a character and its Unicode code point.

Immutability is the key property. Once created, a string's characters cannot change: s[0] = "H" raises TypeError. Every "modifying" method — upper(), replace(), strip() — returns a new string and leaves the original untouched. Forgetting to capture the return value (name.strip() on its own line) is a classic bug. Immutability is what makes strings safe as dictionary keys, safe to share between threads, and cheap to hash. The cost is that building a large string with repeated += in a loop creates many intermediate objects; for that use "".join(parts) or io.StringIO.

Strings come with more than 40 methods. You do not need to memorise all of them — dir(str) and help(str.split) are always available — but the ones below cover 95% of real work. Remember: every method returns a new string (or a list/bool) and never modifies the original.

Cleaning and case

• strip(), lstrip(), rstrip() — remove whitespace (or the characters you pass) from the ends. Essential for user input.
• lower(), upper(), title(), capitalize(), swapcase() — case changes. Use casefold() for case-insensitive comparison; it handles special cases like German "ß" that lower() misses.

Searching

• find(sub) returns the first index or -1; index(sub) does the same but raises ValueError when not found. rfind / rindex search from the right.
• count(sub), startswith(prefix), endswith(suffix) — the last two accept a tuple of alternatives.
• The in operator is the most readable way to ask "does it contain?".

Splitting and joining

• split(sep) returns a list; with no argument it splits on any whitespace run and drops empties. rsplit, splitlines() and partition(sep) (returns a 3-tuple: before, separator, after) are variants.
• sep.join(iterable) is the inverse. Note the slightly odd syntax: the separator comes first. All items must be strings.

Transforming

• replace(old, new, count=-1), removeprefix(p) and removesuffix(s) (Python 3.9+; unlike strip, they remove a whole substring, not a set of characters).
• zfill(width), center, ljust, rjust — padding (f-strings usually do this better).

Validating

• isdigit(), isalpha(), isalnum(), isspace(), isupper(), islower() — note "4.2".isdigit() and "-5".isdigit() are False; for real number validation, try float() in a try block.

Encoding

• encode("utf-8") turns a str into bytes for files, sockets and HTTP; bytes.decode() goes back. The file-handling lecture returns to this.

f-strings (formatted string literals, Python 3.6+) are the modern way to build strings from values. Prefix the literal with f and put any expression inside {}. They are faster than str.format() and the % operator, easier to read, and evaluated at runtime, so they can contain method calls, arithmetic and even function calls.

The real power is the format specifier after a colon: {value:spec}. The spec follows the pattern [fill][align][sign][#][0][width][,|_][.precision][type]. The pieces you will actually use:

• Precision and type: .2f fixed-point with 2 decimals; e scientific; % multiplies by 100 and adds a percent sign; d integer; b, o, x, X binary/octal/hex; # adds the 0b/0x prefix.
• Grouping: , inserts thousands separators (125,000.50), _ uses underscores. Python's , uses Western grouping, not the Indian lakh/crore system (1,25,000); for that use the locale module with en_IN or write a small helper.
• Width and alignment: < left, > right, ^ centre, optionally preceded by a fill character ({name:*^20}). 0 before the width zero-pads numbers. Width and precision can themselves be nested fields ({value:>{width}.{prec}f}), set at runtime.
• Sign: + always shows the sign, a space reserves room for it.
• Conversion flags: !r uses repr() (shows quotes around strings), !s uses str(), !a ASCII-escapes.
• Debug form {expr=} (Python 3.8+) prints expr=value — perfect for quick debugging and far better than print("x", x).
• Dates: any object with a __format__ method accepts its own spec, so {today:%d-%m-%Y} formats a date directly with strftime codes.

Python 3.12 (PEP 701) removed the old limits: you can now reuse the same quote type inside an f-string, write backslashes inside the expression, and nest f-strings arbitrarily.

You will still meet "{} {}".format(a, b) and "%s %d" % (a, b) in older codebases and in the logging module (which uses %-style lazily for performance). Read them, but write f-strings.

Inside a normal string literal the backslash is an escape character: it gives the next character a special meaning. The escape sequences you will use most:

• \n newline, \t tab, \r carriage return.
• \\ a single literal backslash.
• \' and \" quotes inside a string delimited by the same quote (or just switch the outer quote type — it is cleaner).
• \uXXXX and \UXXXXXXXX Unicode code points, \N{NAME} a character by its Unicode name (\N{RUPEE SIGN}), \xHH a byte-sized hex value.
• A backslash at the very end of a line continues the string on the next line without inserting a newline.

An unknown escape such as \d or \p is left as-is with a SyntaxWarning (Python 3.12+; a DeprecationWarning before that), and it may become an error in a future version — so never rely on it.

Raw strings (r"...") switch escaping off: every backslash is kept literally. They exist for two jobs:

1. Regular expressions, which use backslashes heavily. r"\d{3}-\d{4}" is a 3-digit, dash, 4-digit pattern; without r you would need "\\d{3}-\\d{4}".
2. Windows paths like C:\Users\ravi\new_folder. In a normal string, \n in \new_folder becomes a newline and \U in \Users is an invalid Unicode escape that raises SyntaxError. With a raw string both are fine.

One limitation: a raw string cannot end with an odd number of backslashes, because the backslash would escape the closing quote. r"C:\path\" is a SyntaxError; write r"C:\path" + "\\" or, better, stop building paths by hand. The modern approach is pathlib.Path, which joins segments with / and works on Windows, Linux and macOS without any backslashes at all.

Combining prefixes is allowed: rf"..." (or fr"...") gives a raw f-string, useful for regex patterns that include a variable. Also note that print() interprets escapes when it outputs the string, while repr() (and the REPL's echo) shows them escaped — "a\nb" is 3 characters, not 4.

Everything in this lecture shows up daily in production Python. Here is where you will meet it.

Configuration and environment variables. Every setting from the environment is a string. A web service reads PORT, DEBUG and DATABASE_URL with os.environ, then converts: int() for ports, a lowercase membership test for booleans, and or for defaults. Libraries like Pydantic Settings automate this, but under the hood it is the same type conversion.

Validating and normalising user input. Signup forms send " Priya.Nair@Gmail.COM ". Before storing it you strip(), lower(), check "@" in email and split on @ to validate the domain. Phone numbers get replace()d to digits and checked with isdigit() and len(). Doing this consistently at the boundary avoids duplicate accounts and broken SMS sends.

Money and billing. GST calculation, invoice totals and payment splits must not drift by a paisa. Teams either store amounts as integer paise (int) and use divmod to display rupees and paise, or use Decimal with explicit rounding. float is for analytics, not for ledgers.

Reports, logs and CLI output. Operations teams read aligned tables from cron jobs. f-string width and alignment specifiers ({name:<20}{amount:>12,.2f}) produce those tables without any third-party library. The {x=} debug form speeds up troubleshooting in a live shell.

Regular expressions and file paths. Log parsers, scrapers and ETL jobs use raw strings for patterns and pathlib for paths, so the same script runs on a developer's Windows laptop and a Linux server.

Identity checks in frameworks. Django and FastAPI code is full of if value is None and sentinel objects (_MISSING = object()) to distinguish "argument not provided" from "argument provided as None". Understanding is vs == is what lets you read and write that code correctly.

The snippet shows a realistic startup config block that uses conversion, defaults, string methods and f-strings together.

1. Comparing floats with ==. 0.1 + 0.2 == 0.3 is False. Fix: math.isclose(a, b), or round both to a fixed number of decimals, or use Decimal / integer paise for money.

2. Using is for value comparison. if count is 0: or if name is "admin": works by accident on small ints and interned strings and then fails mysteriously. Fix: == for values; is only for None, True, False and sentinels.

3. Forgetting that string methods return new strings. name.strip() on its own line does nothing visible. Fix: name = name.strip().

4. Concatenating a string and a number. "Age: " + 25 raises TypeError. Fix: f"Age: {25}" or str(25).

5. Assuming b = a copies a list. Mutating b changes a. Fix: b = a.copy() (or list(a), a[:]); for nested structures copy.deepcopy(a). Strings and numbers are immutable, so this problem never arises with them.

6. Expecting C-style integer division and modulo. 7 / 2 is 3.5; -7 // 2 is -4; -7 % 3 is 2. Fix: use // when you want an integer; use int(a / b) or math.trunc if you specifically need truncation toward zero.

7. -2 ** 2 giving -4. Exponentiation binds tighter than unary minus. Fix: (-2) ** 2.

8. bool("False") being True. Any non-empty string is truthy. Fix: value.lower() in ("true", "1", "yes").

9. isinstance(x, int) accepting True. Because bool subclasses int. Fix: add and not isinstance(x, bool) when booleans must be rejected.

10. Backslashes in Windows paths. "C:\new\\test" contains a newline and a tab. Fix: raw strings r"C:\new\test", forward slashes (Windows accepts them), or pathlib.Path.

11. Building large strings with += in a loop. Each iteration copies the whole string. Fix: collect parts in a list and "".join() them once.

12. round() surprises. round(2.5) is 2 (half-to-even) and round(2.675, 2) is 2.67 (binary float). Fix: Decimal with ROUND_HALF_UP for financial rounding.

What is dynamic typing in Python?

Dynamic typing means the type belongs to the object, not to the variable name, and is checked at runtime. The same name can refer to a string now and an integer later. Python is also strongly typed: it never silently converts a string to a number, so "5" + 5 is an error rather than "55". Type hints such as def total(items: list[int]) -> int: are optional annotations for tools like mypy and your IDE; the interpreter ignores them.

What is the difference between is and == in Python?

== compares values (it calls __eq__), while is compares identity (whether both names point to the same object). Use == for values and is only for singletons like None. x is 5 may appear to work because CPython caches small integers, but it is not guaranteed and Python 3.8+ warns about it.

Why does 0.1 + 0.2 not equal 0.3 in Python?

Floats are binary fractions, and 0.1 and 0.2 cannot be represented exactly in base 2, so tiny rounding errors accumulate and the sum is 0.30000000000000004. Every language using IEEE 754 doubles has the same behaviour. Compare with math.isclose or use Decimal for exact decimal arithmetic.

Are strings mutable or immutable in Python?

Strings are immutable: you cannot change a character in place, and every method like upper() or replace() returns a new string. This makes strings hashable (usable as dict keys and set members) and safe to share. To "modify" a string, build a new one and rebind the name.

What is the difference between / and // in Python?

/ is true division and always returns a float (7 / 2 == 3.5). // is floor division: it rounds the result down toward negative infinity and returns an int when both operands are ints (7 // 2 == 3, -7 // 2 == -4).

What are f-strings in Python and why should I use them?

f-strings (Python 3.6+) are string literals prefixed with f in which {expression} is evaluated and inserted at runtime, with an optional format spec like {amount:,.2f}. They are more readable and faster than str.format() and % formatting, support the {x=} debug form (3.8+), and since Python 3.12 can reuse quotes and nest freely.

What is a raw string in Python and when should I use it?

A raw string r"..." keeps backslashes literally instead of treating them as escapes. Use raw strings for regular expressions and for Windows paths. The one restriction is that a raw string cannot end with an odd number of backslashes; for paths, prefer pathlib.Path anyway.

Q1. Explain how variable assignment works in Python. Is a variable a container?

No. A Python variable is a name bound to an object. Assignment creates or moves a label; it does not copy data. This is why b = a for a list makes both names refer to one list, while for immutable objects such as ints and strings aliasing is harmless because the object can never change.

Q2. Is bool a subclass of int? What are the consequences?

Yes. True == 1, False == 0, True + True == 2 and isinstance(True, int) is True. Consequences: you can sum() a list of booleans to count matches, but type checks that mean "integer only" must explicitly exclude bool, and {1: "a", True: "b"} has a single key because 1 and True are equal and hash the same.

Q3. What is the output of print(-7 // 2, -7 % 2) and why?

-4 1. Floor division rounds toward negative infinity, and modulo takes the sign of the divisor so that a == (a // b) * b + a % b always holds: (-4) * 2 + 1 == -7.

Q4. Why is x is 257 unreliable, and why does None use is?

CPython preallocates ints from -5 to 256 and may deduplicate other constants within one compilation unit, so identity comparisons on numbers depend on implementation details. None is a true singleton — there is exactly one None object in the process — so is None is both correct and faster than == None, which would invoke __eq__.

Q5. What is the difference between type() and isinstance()?

type(x) returns the exact class; comparing it is strict and ignores inheritance. isinstance(x, C) returns True for C and all its subclasses, accepts a tuple or (3.10+) a union of classes, and is the idiomatic choice.

Q6. How does string slicing work, and what does s[::-1] do?

s[start:stop:step] returns a new string from start (inclusive) to stop (exclusive) every step characters. Omitted values default to the beginning, the end and 1. A negative step walks backwards, so s[::-1] returns the reversed string. Slices clip out-of-range bounds instead of raising.

Q7. Why is "".join(list) preferred over += in a loop?

Because strings are immutable, each += allocates a new string and copies the old content, giving O(n²) behaviour for n pieces. join() computes the total size once and copies each piece once, which is O(n).

Q8. What does f"{value:>10,.2f}" produce?

A right-aligned field 10 characters wide, with thousands separators and two decimal places — for value = 1234.5 it gives " 1,234.50". The order inside the spec is fill, align, sign, width, grouping, precision, type.

Time to put every concept from this lecture into one small, realistic program. A payment gateway hands you raw, messy fields — exactly as they would arrive from an HTML form or a webhook: a name with stray spaces and wrong capitalisation, a UPI ID in mixed case, a phone number with +91 and dashes, an amount with a thousands separator, and a blank tip field. Your program must:

1. Clean and convert every field using string methods and explicit type conversion (strip, title, lower, replace, float, int, the or default idiom).
2. Calculate GST and the total with arithmetic operators, then split the total into rupees and paise with divmod on an integer so no paisa is lost to float drift.
3. Validate the UPI ID and phone number with comparison, membership and logical operators, and set a status.
4. Print a receipt using f-string alignment, width, grouping and precision specifiers, plus the {x=} debug form.

Save the file as upi_receipt.py and run python upi_receipt.py. Read the expected output in the comments and compare.

Extend it yourself (recommended):

• Replace the hard-coded raw values with input() calls and keep the program working when the user types 1249.5, 1,249.50 or 1249 .
• Add an inr() helper (from Section 11) so the amount prints as 1,249.50 in Indian grouping for large values such as 12,50,000.00.
• Reject a phone number that does not start with 6, 7, 8 or 9 (Indian mobile numbers) using startswith with a tuple.
• Mask the UPI ID as pr***@okaxis using slicing and partition.
• Store the amount in integer paise from the start and format rupees with divmod only at print time.

• A Python variable is a name bound to an object; the object carries the type. Python is dynamically typed (types checked at runtime) and strongly typed (no silent string-to-number conversion). Assignment never copies — b = a aliases mutable objects.
• Core types: int (arbitrary precision), float (IEEE 754 double — never compare with ==, never use for money), complex, bool (a subclass of int) and the singleton None. Falsy values: 0, 0.0, "", [], {}, None.
• type() gives the exact class; isinstance() respects inheritance and accepts tuples or int | float unions (3.10+).
• Explicit conversion with int(), float(), str(), bool(), round(); invalid text raises ValueError; input() and environment variables are always strings. Implicit conversion happens only between numeric types.
• / always returns a float; // floors toward negative infinity; % takes the sign of the divisor; ** is right-associative and binds tighter than unary minus. Precedence: **, unary, * / // %, + -, comparisons, not, and, or.
• Comparisons chain (60 <= m < 75); and/or short-circuit and return an operand; x := expr assigns inside expressions (3.8+).
• == compares values, is compares identity. Use is only for None and other singletons.
• Strings are immutable Unicode sequences: 0-based indexing, negative indexes, s[start:stop:step] slicing with exclusive stop, s[::-1] to reverse, "".join() to build.
• Key methods: strip, lower/casefold, split/join/partition, find/index, replace, startswith/endswith, removeprefix/removesuffix (3.9+), isdigit, encode/decode.
• f-strings (3.6+) with specifiers {v:,.2f}, {v:>10}, {v:08.3f}, {v:.1%}, {v!r}, {v=} (3.8+), {d:%d-%m-%Y}; same-quote reuse from 3.12.
• Escape sequences (\n, \t, \\, \u20b9) versus raw strings r"..." for regex and Windows paths; prefer pathlib.Path for paths.

Next lecture: Control Flow — Conditionals, match, Loops & Comprehensions