Python Fundamentals Explained: Operators, Conditions, Functions, Loops, Sequences, Iteration, Classes & More (2026 Guide)

Python Operators, Conditions, Functions, Sequences, Iteration, Classes & Essential Python Concepts: Complete Guide for Beginners to Advanced Developers

Python is one of the most widely used programming languages in the world because it combines readable syntax, powerful abstractions, a huge ecosystem, and excellent support for fields ranging from web development and automation to data science, artificial intelligence, machine learning, cybersecurity, and scientific computing.

Learning Python is not only about memorizing syntax. A strong Python programmer needs to understand how values move through a program, how decisions are made, how repetition works, how functions organize logic, how sequences store data, and how classes represent objects and behavior.

This guide builds those concepts step by step.

We will explore:

Python variables and data types
Operators
Comparisons
Boolean logic
Conditions
Loops and iteration
break, continue, and pass
Functions
Parameters and arguments
Return values
Scope
Recursion
Sequences
Lists
Tuples
Strings
Ranges
Sets
Dictionaries
Comprehensions
Unpacking
Iterators
Generators
Exceptions
Modules and packages
Classes and objects
Constructors
Instance and class attributes
Methods
Inheritance
Encapsulation
Polymorphism
Special methods
Dataclasses
Lambda expressions
Higher-order functions
Type hints
File handling
Context managers
Useful built-in functions
Mutable vs immutable objects
References and identity
Pythonic programming
Common mistakes
Performance concepts
Advanced concepts
Practical examples
A roadmap for mastering Python

1. What Is Python?

Python is a high-level, general-purpose programming language designed with an emphasis on readability and developer productivity.

A simple Python program can look like this:

name = "Alex"

print("Hello", name)

The important thing about Python is that the syntax is designed to be relatively close to ordinary human-readable logic.

For example:

age = 20

if age >= 18:
    print("Adult")

The program stores 20 in age, checks whether age is at least 18, and executes the indented statement if the condition is true.

Python is dynamically typed, meaning you normally do not need to declare the type of a variable manually.

x = 10
x = "Hello"
x = 3.14

The same variable name can refer to objects of different types during execution.

2. Variables

A variable is a name that refers to a value or object.

x = 10
name = "Python"
price = 12.5

You can think of:

x = 10

as creating a reference named x that points to the integer object 10.

Variables can contain many different types of objects:

number = 100
text = "hello"
active = True
items = [1, 2, 3]

Python does not require:

int number = 100

Instead:

number = 100

is enough.

3. Python Data Types

Some fundamental Python types include:

int
float
complex
bool
str
list
tuple
set
dict
NoneType

Examples:

age = 18
temperature = 36.5
z = 2 + 3j
active = True
name = "Python"
numbers = [1, 2, 3]
coordinates = (10, 20)
unique = {1, 2, 3}
person = {"name": "Alex", "age": 18}
nothing = None

You can inspect a value's type with:

print(type(age))

Output:

<class 'int'>

4. Python Operators

Operators are symbols or keywords that perform operations on values.

Python contains several important categories of operators:

Arithmetic operators
Comparison operators
Assignment operators
Logical operators
Identity operators
Membership operators
Bitwise operators

Understanding operators is essential because almost every program uses them.

5. Arithmetic Operators

Arithmetic operators perform mathematical operations.

Addition

a = 10
b = 5

result = a + b
print(result)

Output:

Subtraction

result = a - b

Result:

Multiplication

result = a * b

Result:

Division

result = a / b

Result:

2.0

Python's / operator normally produces a floating-point result.

Floor Division

result = 10 // 3

Result:

Floor division removes the fractional portion by flooring the result.

Modulo

result = 10 % 3

Result:

The % operator gives the remainder.

This is extremely useful for checking whether a number is divisible by another number.

number = 20

if number % 2 == 0:
    print("Even")

Exponentiation

result = 2 ** 5

Result:

The expression means:

2 × 2 × 2 × 2 × 2

6. Assignment Operators

The basic assignment operator is:

Example:

x = 10

Python also provides compound assignment operators.

x += 5

This is conceptually similar to:

x = x + 5

Other examples:

x -= 5
x *= 5
x /= 5
x //= 5
x %= 5
x **= 2

These operators are particularly useful in loops.

total = 0

for number in range(1, 6):
    total += number

After the loop:

total = 15

7. Comparison Operators

Comparison operators compare values.

Important comparison operators are:

==
!=
>
<
>=
<=

Examples:

x = 10

print(x == 10)
print(x != 5)
print(x > 3)
print(x < 20)
print(x >= 10)
print(x <= 10)

The results are Boolean values:

True
True
True
True
True
True

Comparison operators are fundamental to conditions.

8. Equality vs Identity

One of the most important Python concepts is the difference between:

==

and:

is

== checks whether values are equal.

is checks whether two references point to the same object.

For example:

a = [1, 2, 3]
b = [1, 2, 3]

print(a == b)

This can produce:

True

because the lists contain equal values.

But:

print(a is b)

is normally:

False

because they are separate list objects.

For checking None, use:

if value is None:
    print("No value")

rather than:

if value == None:

9. Logical Operators

Python has three primary logical operators:

and
or
not

`and`

Both conditions need to be true.

age = 20
has_id = True

if age >= 18 and has_id:
    print("Allowed")

`or`

At least one condition must be true.

day = "Saturday"

if day == "Saturday" or day == "Sunday":
    print("Weekend")

`not`

not reverses a Boolean condition.

active = False

if not active:
    print("Inactive")

10. Truthy and Falsy Values

Python allows many objects to be evaluated as Boolean values.

For example:

if []:
    print("True")
else:
    print("False")

The output is:

False

An empty list is considered falsy.

Common falsy values include:

False
None
0
0.0
""
[]
()
{}
set()

Many non-empty objects are truthy.

if [1, 2, 3]:
    print("The list contains data")

This makes Python conditions concise.

11. Membership Operators

Python provides:

in
not in

Example:

numbers = [10, 20, 30]

print(20 in numbers)

Result:

True

You can also use membership with strings:

text = "Python programming"

if "Python" in text:
    print("Found")

For dictionaries, membership normally checks keys:

person = {
    "name": "Alex",
    "age": 20
}

print("name" in person)

Result:

True

12. Bitwise Operators

Python also supports bit-level operations:

&
|
^
~
<<
>>

For example:

a = 6
b = 3

print(a & b)

Bitwise operators are useful in low-level programming, optimization, permissions, binary protocols, and certain algorithms.

You do not need them for every Python program, but understanding them becomes useful as you progress toward systems programming and advanced algorithms.

13. Operator Precedence

When multiple operators appear in an expression, Python follows precedence rules.

For example:

result = 2 + 3 * 4

Multiplication happens before addition.

Therefore:

2 + 12 = 14

You can explicitly control the order using parentheses:

result = (2 + 3) * 4

Now the result is:

A good programming habit is to use parentheses when they make complicated expressions easier to understand.

14. Conditions

Conditions allow a program to make decisions.

The basic structure is:

if condition:
    statement

Example:

age = 20

if age >= 18:
    print("Adult")

The condition:

age >= 18

produces either:

True

or:

False

Python executes the indented block when the condition is true.

15. `if`, `elif`, and `else`

Multiple possible situations can be handled using:

if
elif
else

Example:

score = 75

if score >= 90:
    print("A")
elif score >= 80:
    print("B")
elif score >= 70:
    print("C")
else:
    print("Needs improvement")

Only the first matching branch is executed.

This structure is useful when different inputs require different actions.

16. Nested Conditions

Conditions can exist inside other conditions.

age = 20
student = True

if age >= 18:
    if student:
        print("Adult student")

However, deeply nested conditions can make code difficult to read.

Often, conditions can be combined:

if age >= 18 and student:
    print("Adult student")

Good Python code usually aims for clarity rather than unnecessary nesting.

17. Conditional Expressions

Python supports a compact conditional expression:

result = "adult" if age >= 18 else "minor"

This is useful for simple decisions.

Avoid using complicated nested conditional expressions because they can reduce readability.

18. The `match` Statement

Modern Python also provides structural pattern matching.

Example:

command = "start"

match command:
    case "start":
        print("Starting")
    case "stop":
        print("Stopping")
    case "pause":
        print("Pausing")
    case _:
        print("Unknown command")

The _ pattern acts as a catch-all case.

Pattern matching becomes especially useful when working with structured data and multiple possible forms.

19. Loops and Iteration

Programs often need to repeat operations.

Python provides two primary loop structures:

for
while

A loop allows code to execute repeatedly.

20. The `for` Loop

The for loop iterates over an iterable.

numbers = [1, 2, 3, 4, 5]

for number in numbers:
    print(number)

The loop retrieves each element and assigns it to number.

This is one of Python's most important concepts.

21. The `range()` Function

range() is commonly used when you want a sequence of integers.

for i in range(5):
    print(i)

Output:

The ending value is not included.

You can specify a starting value:

for i in range(2, 6):
    print(i)

Output:

You can also specify a step:

for i in range(0, 10, 2):
    print(i)

Output:

22. The `while` Loop

A while loop continues while its condition is true.

count = 0

while count < 5:
    print(count)
    count += 1

The loop eventually stops because count reaches 5.

Be careful with infinite loops:

while True:
    print("Running")

This loop does not naturally terminate.

23. `break`

break immediately exits a loop.

for number in range(10):
    if number == 5:
        break

    print(number)

The output stops at:

break is useful when the desired result has been found.

24. `continue`

continue skips the current iteration and proceeds to the next one.

for number in range(10):
    if number % 2 == 0:
        continue

    print(number)

This prints odd numbers.

25. `pass`

pass does nothing.

It is useful when Python requires a statement but you have not implemented the logic yet.

def future_function():
    pass

It can also appear inside classes and conditions.

26. Nested Loops

A loop can contain another loop.

for x in range(3):
    for y in range(3):
        print(x, y)

Nested loops are useful for matrices, grids, combinations, and many algorithms.

However, nested loops can increase computational complexity.

A loop inside another loop often has approximately:

O(n²)

time complexity when both loops depend on n.

27. Functions

Functions are reusable blocks of logic.

A basic function:

def greet():
    print("Hello")

Call it:

greet()

Functions help prevent repetition and make programs easier to organize.

28. Function Parameters

Functions can receive values.

def greet(name):
    print("Hello", name)

Call:

greet("Alex")

Here, name is a parameter and "Alex" is an argument.

29. Multiple Parameters

def add(a, b):
    return a + b

Call:

result = add(10, 20)
print(result)

Output:

30. Return Values

return sends a value back to the caller.

def square(number):
    return number * number

Then:

x = square(5)

Now:

x = 25

A function can return almost any Python object.

def get_data():
    return [1, 2, 3]

31. Functions Without `return`

If a function does not explicitly return a value, Python returns:

None

Example:

def hello():
    print("Hello")

result = hello()

print(result)

The output includes:

Hello
None

32. Default Parameters

Parameters can have default values.

def greet(name="Friend"):
    print("Hello", name)

Now:

greet()

produces:

Hello Friend

while:

greet("Alex")

produces:

Hello Alex

33. Keyword Arguments

Arguments can be supplied by parameter name.

def introduce(name, age):
    print(name, age)

introduce(age=20, name="Alex")

This can make function calls clearer.

34. Variable-Length Arguments

Python provides:

*args

and:

**kwargs

Example:

def add_all(*numbers):
    total = 0

    for number in numbers:
        total += number

    return total

Call:

print(add_all(1, 2, 3, 4))

*args collects positional arguments.

**kwargs collects keyword arguments.

def show_info(**data):
    print(data)

show_info(name="Alex", age=20)

The resulting dictionary contains the keyword arguments.

35. Scope

Scope determines where a variable can be accessed.

Consider:

x = 10

def test():
    x = 20
    print(x)

test()
print(x)

The function's local x does not replace the global x.

The outputs are:

20
10

Python commonly discusses scope using the LEGB idea:

Local
Enclosing
Global
Built-in

Understanding scope prevents many confusing bugs.

36. The `global` Keyword

A function can explicitly modify a global variable using global.

count = 0

def increase():
    global count
    count += 1

Although this works, excessive use of global state can make programs harder to understand.

Functions that receive values and return results are often easier to reason about.

37. The `nonlocal` Keyword

nonlocal is used with nested functions to modify variables from an enclosing function scope.

def outer():
    count = 0

    def inner():
        nonlocal count
        count += 1

    inner()

    return count

This becomes useful when learning closures.

38. Recursion

A recursive function calls itself.

Example:

def countdown(n):
    if n <= 0:
        return

    print(n)
    countdown(n - 1)

The function needs a base case to stop recursion.

Recursion can be elegant for trees, graphs, divide-and-conquer algorithms, and mathematical structures.

However, recursion is not always the best solution in Python because excessive recursion can hit recursion limits and may use more memory than an iterative approach.

39. Sequences

A sequence is an ordered collection of elements.

Important Python sequence types include:

list
tuple
str
range

Sequences support concepts such as:

indexing
slicing
iteration
length
membership
concatenation

40. Lists

Lists are mutable ordered collections.

numbers = [10, 20, 30, 40]

Access an element:

print(numbers[0])

Result:

Python indexes from zero.

Therefore:

numbers[0] -> first
numbers[1] -> second
numbers[2] -> third

41. Negative Indexing

Python supports negative indexes.

numbers = [10, 20, 30, 40]

print(numbers[-1])

Result:

-1 means the last element.

-1 -> last
-2 -> second last
-3 -> third last

42. List Mutation

Lists are mutable.

You can modify an element:

numbers[0] = 100

You can add an item:

numbers.append(50)

Insert:

numbers.insert(1, 15)

Remove:

numbers.remove(30)

Remove by index:

numbers.pop()

Clear the list:

numbers.clear()

43. List Slicing

Slicing extracts part of a sequence.

numbers = [0, 1, 2, 3, 4, 5]

print(numbers[1:4])

Result:

[1, 2, 3]

The ending index is excluded.

You can use:

numbers[:3]

or:

numbers[3:]

You can also specify a step:

numbers[::2]

44. Tuples

Tuples are ordered and immutable.

point = (10, 20)

You cannot normally change an existing tuple element.

Tuples are useful for representing fixed collections of values.

For example:

coordinates = (100, 200)

45. Tuple Unpacking

Python allows unpacking:

point = (10, 20)

x, y = point

Now:

x = 10
y = 20

This is a very useful Python feature.

46. Strings

Strings are sequences of characters.

text = "Python"

You can index strings:

print(text[0])

Result:

You can slice them:

print(text[1:4])

Strings are immutable.

This means:

text[0] = "J"

is not allowed.

Instead, create a new string.

47. Useful String Methods

Python provides many string operations:

text.lower()
text.upper()
text.strip()
text.replace()
text.split()
text.startswith()
text.endswith()

Example:

text = "  Python Programming  "

clean = text.strip().lower()

print(clean)

Output:

python programming

48. Formatted Strings

F-strings are one of the easiest ways to format values.

name = "Alex"
age = 20

message = f"My name is {name} and I am {age}."

F-strings can contain expressions:

a = 10
b = 20

print(f"Total: {a + b}")

49. Sets

A set is an unordered collection of unique elements.

numbers = {1, 2, 3, 3, 3}

print(numbers)

The duplicate values are removed.

Sets are particularly useful for membership testing and mathematical set operations.

a = {1, 2, 3}
b = {3, 4, 5}

Union:

a | b

Intersection:

a & b

Difference:

a - b

50. Dictionaries

Dictionaries store key-value relationships.

person = {
    "name": "Alex",
    "age": 20,
    "language": "Python"
}

Access:

print(person["name"])

Result:

Alex

Add:

person["country"] = "Pakistan"

Update:

person["age"] = 21

Remove:

del person["age"]

51. Dictionary Methods

Useful methods include:

person.keys()
person.values()
person.items()
person.get()
person.update()
person.pop()

For example:

for key, value in person.items():
    print(key, value)

52. Iterables and Iterators

This is one of the most important deeper Python concepts.

An iterable is an object that can provide its elements one at a time.

Examples include:

list
tuple
string
set
dictionary
range

A for loop works with iterables.

for item in [1, 2, 3]:
    print(item)

Behind the scenes, Python obtains an iterator from the iterable.

Conceptually:

iterator = iter([1, 2, 3])

Then values can be retrieved using:

next(iterator)

53. The Iterator Protocol

Python iteration is based around special methods.

An iterator generally provides:

__iter__()
__next__()

When no more values remain, __next__() raises:

StopIteration

This is what allows Python's for loop to know when to stop.

You normally do not need to implement this manually, but understanding it explains how iteration works internally.

54. Generators

Generators provide values lazily.

A generator function uses:

yield

Example:

def numbers():
    yield 1
    yield 2
    yield 3

Calling:

g = numbers()

does not immediately create all values as a normal list.

You can iterate:

for number in g:
    print(number)

Generators are useful when working with large data because values can be produced one at a time.

55. Generator Expressions

A generator expression looks similar to a list comprehension:

numbers = (x * x for x in range(1000000))

Unlike:

numbers = [x * x for x in range(1000000)]

the generator does not need to store all results at once.

This can significantly reduce memory usage.

56. List Comprehensions

List comprehensions provide a compact way to construct lists.

Instead of:

squares = []

for x in range(10):
    squares.append(x * x)

you can write:

squares = [x * x for x in range(10)]

You can also include conditions:

even = [x for x in range(20) if x % 2 == 0]

Comprehensions are powerful, but readability should remain the priority.

57. Dictionary Comprehensions

You can construct dictionaries with comprehensions.

squares = {
    x: x * x
    for x in range(5)
}

The result maps each number to its square.

58. Set Comprehensions

Sets also support comprehensions.

values = {x % 3 for x in range(10)}

The resulting set contains unique remainders.

59. The `enumerate()` Function

Instead of manually maintaining an index:

items = ["a", "b", "c"]

for i in range(len(items)):
    print(i, items[i])

Python provides:

for i, item in enumerate(items):
    print(i, item)

This is cleaner and more Pythonic.

60. The `zip()` Function

zip() combines multiple iterables.

names = ["Alex", "Sam", "John"]
scores = [90, 80, 95]

for name, score in zip(names, scores):
    print(name, score)

This is useful when processing related sequences.

61. `map()`

map() applies a function to elements.

numbers = [1, 2, 3, 4]

result = map(lambda x: x * 2, numbers)

You can convert the result to a list:

result = list(result)

62. `filter()`

filter() selects values according to a condition.

numbers = [1, 2, 3, 4, 5, 6]

result = filter(lambda x: x % 2 == 0, numbers)

Then:

even = list(result)

63. Lambda Functions

A lambda is a small anonymous function.

square = lambda x: x * x

Then:

print(square(5))

Lambda expressions are useful for short operations, particularly with functions such as sorted(), map(), and filter().

For complicated logic, a normal def function is usually clearer.

64. Sorting

Python provides:

sorted()

Example:

numbers = [5, 1, 4, 2, 3]

result = sorted(numbers)

The original list remains unchanged.

Lists also provide:

numbers.sort()

which sorts the list in place.

You can sort in reverse:

numbers.sort(reverse=True)

65. Custom Sorting

Suppose you have:

people = [
    {"name": "Alex", "age": 30},
    {"name": "Sam", "age": 20},
    {"name": "John", "age": 25}
]

You can sort by age:

people = sorted(
    people,
    key=lambda person: person["age"]
)

This demonstrates how functions can control other operations.

66. Exception Handling

Programs can encounter errors during execution.

Python provides:

try
except
else
finally

Example:

try:
    number = int(input("Enter number: "))
    print(10 / number)

except ValueError:
    print("Invalid number")

except ZeroDivisionError:
    print("Cannot divide by zero")

Exception handling allows programs to respond gracefully to expected runtime problems.

67. `finally`

The finally block runs whether an exception occurs or not.

try:
    print("Working")
finally:
    print("Finished")

It is useful for cleanup operations.

68. Raising Exceptions

You can intentionally raise an exception.

age = -5

if age < 0:
    raise ValueError("Age cannot be negative")

Custom exceptions are useful for validating program state.

69. Modules

A module is generally a Python file containing reusable code.

For example:

# math_tools.py

def add(a, b):
    return a + b

Another file can import it:

import math_tools

print(math_tools.add(10, 20))

Modules help organize large projects.

70. Importing Specific Items

You can write:

from math_tools import add

Then:

print(add(10, 20))

Python also has a huge standard library.

Examples include modules for:

math
random
datetime
os
pathlib
json
re
statistics
collections
itertools

71. Packages

A package organizes multiple modules into a larger structure.

A project might look like:

project/
    main.py
    utils/
        __init__.py
        math_tools.py
        text_tools.py

Packages are essential for large Python applications.

72. The `name` Pattern

A common Python pattern is:

if __name__ == "__main__":
    main()

This allows a file to behave differently when executed directly versus imported as a module.

Example:

def main():
    print("Program started")

if __name__ == "__main__":
    main()

This pattern is common in Python applications and scripts.

73. Classes and Objects

Classes are one of Python's major abstraction mechanisms.

A class can define:

data
behavior
relationships
validation
reusable structure

Example:

class Person:
    pass

You can create an object:

person = Person()

The object is an instance of the class.

74. The `init()` Method

A class can initialize object data using __init__.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

Create an object:

person = Person("Alex", 20)

Now:

print(person.name)
print(person.age)

75. Understanding `self`

self refers to the current instance.

For example:

class Person:
    def __init__(self, name):
        self.name = name

When:

person = Person("Alex")

the object's name attribute becomes:

Alex

self allows methods to access the specific object's data.

76. Instance Methods

Classes can define functions called methods.

class Person:
    def __init__(self, name):
        self.name = name

    def greet(self):
        print("Hello", self.name)

Then:

person = Person("Alex")
person.greet()

Output:

Hello Alex

77. Instance Attributes

Instance attributes belong to individual objects.

class Person:
    def __init__(self, name):
        self.name = name

Now:

a = Person("Alex")
b = Person("Sam")

The objects contain different values:

a.name -> Alex
b.name -> Sam

78. Class Attributes

A class attribute belongs to the class.

class Person:
    species = "Human"

Instances can access it:

a = Person()
print(a.species)

Class attributes are useful for values shared across instances.

79. Inheritance

Inheritance allows a class to derive behavior from another class.

class Animal:
    def speak(self):
        print("Animal sound")

class Dog(Animal):
    pass

Now:

dog = Dog()
dog.speak()

The Dog class inherits speak() from Animal.

80. Method Overriding

A child class can replace inherited behavior.

class Animal:
    def speak(self):
        print("Animal sound")

class Dog(Animal):
    def speak(self):
        print("Woof")

Now:

dog = Dog()
dog.speak()

Output:

Woof

81. `super()`

super() allows a child class to call parent functionality.

class Animal:
    def __init__(self, name):
        self.name = name

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed

This prevents unnecessary duplication.

82. Polymorphism

Polymorphism means that different objects can provide compatible behavior.

For example:

class Dog:
    def speak(self):
        print("Woof")

class Cat:
    def speak(self):
        print("Meow")

You can write:

animals = [Dog(), Cat()]

for animal in animals:
    animal.speak()

The loop does not need to know the exact class.

It simply expects the object to provide speak().

This idea is extremely important in object-oriented design.

83. Duck Typing

Python often follows the philosophy:

If an object behaves like the required object, use it.

For example:

def make_sound(animal):
    animal.speak()

The function does not necessarily need to check whether animal belongs to a specific class.

If the object provides speak(), the function can use it.

This is called duck typing.

84. Encapsulation

Encapsulation means organizing data and behavior together and controlling how they are accessed.

Python does not enforce private fields in the same strict way as some languages.

A name beginning with _ commonly communicates:

This is intended as an internal implementation detail.

Example:

class Account:
    def __init__(self):
        self._balance = 0

Double underscores trigger name mangling:

self.__balance

But Python's philosophy generally favors conventions over rigid access restrictions.

85. Properties

Properties allow methods to behave like attributes.

class Person:
    def __init__(self, age):
        self._age = age

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, value):
        if value < 0:
            raise ValueError("Invalid age")

        self._age = value

Now:

person = Person(20)

print(person.age)

person.age = 21

This allows validation while maintaining a convenient attribute-like interface.

86. Class Methods

A class method receives the class rather than an instance.

It uses:

@classmethod

Example:

class Person:
    count = 0

    def __init__(self):
        Person.count += 1

    @classmethod
    def total(cls):
        return cls.count

Then:

print(Person.total())

Class methods are also frequently used for alternative constructors.

87. Static Methods

A static method does not automatically receive an instance or class.

class MathTools:

    @staticmethod
    def add(a, b):
        return a + b

Call:

print(MathTools.add(2, 3))

Static methods are useful when a function logically belongs to a class but does not need instance or class state.

88. Dataclasses

Python provides dataclasses for classes primarily used to store data.

from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int

Now:

person = Person("Alex", 20)

Dataclasses can automatically provide useful methods such as initialization and representation.

They are excellent for structured data models.

89. Special Methods

Python classes can implement special methods surrounded by double underscores.

Examples include:

__init__
__str__
__repr__
__len__
__getitem__
__iter__
__next__
__eq__
__lt__

These methods allow objects to integrate naturally with Python syntax.

90. `str()`

You can control how an object is displayed as a string.

class Person:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return self.name

Now:

person = Person("Alex")

print(person)

prints the custom representation.

91. `len()`

A class can support len() by implementing:

__len__

Example:

class Team:
    def __init__(self, members):
        self.members = members

    def __len__(self):
        return len(self.members)

Then:

team = Team(["A", "B", "C"])

print(len(team))

92. Operator Overloading

Python allows classes to define how operators behave.

For example, + can be customized with:

__add__

A vector class might implement:

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector(
            self.x + other.x,
            self.y + other.y
        )

Then:

a = Vector(1, 2)
b = Vector(3, 4)

c = a + b

This allows custom objects to work naturally with Python operators.

93. Mutable vs Immutable Objects

This distinction is extremely important.

Common immutable types include:

int
float
bool
str
tuple
frozenset

Common mutable types include:

list
dict
set

Consider:

numbers = [1, 2, 3]

numbers.append(4)

The same list object is modified.

With strings:

text = "hello"

you cannot modify an individual character.

Instead, a new string must be created.

94. References and Objects

Python variables are references to objects.

Consider:

a = [1, 2, 3]
b = a

Now both names refer to the same list.

Therefore:

b.append(4)

also changes what a sees.

print(a)

produces:

[1, 2, 3, 4]

This is a major concept for understanding Python behavior.

95. Copying Objects

If you want a separate list, you can create a copy:

b = a.copy()

or:

b = list(a)

For nested structures, shallow and deep copying become important.

Python provides:

import copy

with:

copy.copy()
copy.deepcopy()

96. `None`

None represents the absence of a value.

Example:

result = None

It is commonly used when:

a function has no meaningful result
a value is not available
a variable has not been initialized with useful data
an optional value is missing

Check it using:

if result is None:
    print("No result")

97. Boolean Short-Circuiting

Python's and and or operators can stop evaluating early.

Example:

if user is not None and user.is_active:
    ...

If:

user is not None

is false, Python does not need to evaluate the second expression.

This behavior is called short-circuit evaluation.

It can be useful for writing safe conditional expressions.

98. The `all()` Function

all() returns true when all elements are truthy.

values = [True, True, True]

print(all(values))

Result:

True

Example:

numbers = [2, 4, 6, 8]

if all(number % 2 == 0 for number in numbers):
    print("All are even")

99. The `any()` Function

any() returns true when at least one element is truthy.

values = [False, False, True]

print(any(values))

Result:

True

These functions can make collection-based logic concise.

100. `len()`

len() returns the number of elements in supported objects.

numbers = [1, 2, 3, 4]

print(len(numbers))

Result:

It also works with:

len("Python")
len({"a": 1, "b": 2})

Objects can implement __len__() to support this behavior.

101. `min()` and `max()`

Python provides:

min()
max()

Example:

numbers = [10, 5, 30, 15]

print(min(numbers))
print(max(numbers))

Result:

5
30

You can also use a custom key.

102. `sum()`

sum() calculates the total of numeric values.

numbers = [1, 2, 3, 4]

print(sum(numbers))

Result:

It is commonly used in data processing.

103. `abs()`

abs() returns the absolute value.

print(abs(-10))

Result:

This is useful in mathematics, distance calculations, and error measurements.

104. `round()`

Python provides:

round()

Example:

print(round(3.14159, 2))

Result:

3.14

Floating-point arithmetic has its own precision considerations, so exact decimal calculations may require specialized approaches.

105. `isinstance()`

isinstance() checks whether an object is an instance of a class or compatible type.

x = 10

print(isinstance(x, int))

Result:

True

It can also accept multiple types:

isinstance(x, (int, float))

106. Type Hints

Python allows developers to communicate expected types.

def add(a: int, b: int) -> int:
    return a + b

Type hints improve:

editor support
documentation
static analysis
maintainability
readability

Python generally does not enforce these annotations at runtime by itself.

107. Optional Values

Type hints can describe values that may be missing.

Modern Python supports syntax such as:

def find_user(id: int) -> str | None:
    ...

This communicates that the function may return a string or None.

Type hints become increasingly useful as projects grow.

108. File Handling

Python can work with files using open().

file = open("data.txt", "r")

content = file.read()

file.close()

However, the preferred approach is usually a context manager.

with open("data.txt", "r") as file:
    content = file.read()

The file is automatically handled when the with block finishes.

109. Writing Files

with open("data.txt", "w") as file:
    file.write("Hello Python")

The "w" mode writes to the file.

Other common modes include:

r  read
w  write
a  append
b  binary

110. JSON

JSON is frequently used for data exchange.

Python provides the json module.

import json

data = {
    "name": "Alex",
    "age": 20
}

text = json.dumps(data)

To load JSON:

data = json.loads(text)

JSON is especially important in web development and APIs.

111. Context Managers

The with statement is based on the context manager protocol.

Objects can define:

__enter__()
__exit__()

A context manager controls setup and cleanup around a block of code.

Files are a common example.

Context managers are useful for:

files
database connections
locks
transactions
temporary resources

112. Assertions

Python provides:

assert

Example:

age = 20

assert age >= 0

If the condition is false, Python raises an AssertionError.

Assertions are useful for detecting programming assumptions during development.

They should not generally replace proper user-input validation.

113. Virtual Environments

Python projects often use virtual environments to isolate dependencies.

A typical command is:

python -m venv .venv

Then the environment can be activated according to the operating system.

Virtual environments help prevent different projects from interfering with each other's package versions.

114. Package Management

Python's ecosystem contains thousands of third-party packages.

A common package-management tool is pip.

For example:

pip install requests

A project can record dependencies in a file such as:

requirements.txt

Modern Python projects may also use tools and configuration systems such as pyproject.toml.

115. Python and APIs

Python is frequently used to communicate with web APIs.

A typical API workflow looks like:

Python program
      ↓
HTTP request
      ↓
Web server
      ↓
API
      ↓
JSON response
      ↓
Python object

This pattern is central to modern web applications, automation, and AI systems.

116. Python for Data Structures and Algorithms

Python's built-in data structures make algorithm development convenient.

For example, a dictionary can provide fast average-case key lookup:

users = {
    "alex": 100,
    "sam": 200
}

A set can efficiently test membership:

blocked = {"a", "b", "c"}

if "b" in blocked:
    print("Blocked")

A list provides ordered storage and efficient indexing.

Choosing the correct data structure can dramatically affect performance.

117. Algorithmic Thinking

When writing Python, do not only ask:

How can I write this code?

Also ask:

What algorithm am I implementing?

For example, searching a list:

for item in items:
    if item == target:
        ...

may require checking many elements.

A set:

if target in item_set:
    ...

may provide much faster average-case membership testing.

Understanding data structures and complexity is therefore more important than memorizing syntax.

118. Time Complexity

Big-O notation describes how an algorithm scales.

Common complexities include:

O(1)
O(log n)
O(n)
O(n log n)
O(n²)
O(2ⁿ)

Example:

for x in numbers:
    print(x)

is generally:

O(n)

A nested loop:

for x in numbers:
    for y in numbers:
        print(x, y)

is generally:

O(n²)

This becomes important when processing large datasets.

119. Memory Complexity

Algorithms also consume memory.

A generator:

(x * x for x in range(1000000))

can avoid storing all generated values simultaneously.

A list:

[x * x for x in range(1000000)]

stores the generated elements.

Understanding memory behavior is particularly important for large datasets, AI workloads, and data processing.

120. Pythonic Programming

"Pythonic" generally means writing code in a way that fits Python's design philosophy.

For example, instead of:

for i in range(len(items)):
    print(items[i])

prefer:

for item in items:
    print(item)

Instead of manually building a list:

result = []

for x in numbers:
    result.append(x * 2)

a comprehension may be appropriate:

result = [x * 2 for x in numbers]

Pythonic code is generally readable, expressive, and avoids unnecessary complexity.

121. Readability Matters

Python's popularity is strongly connected to readability.

Compare:

if x > 10 and x < 20:
    print(x)

with extremely compressed code that attempts to do everything on one line.

Shorter code is not automatically better code.

The goal is:

clear
correct
maintainable
efficient when necessary

122. Common Python Mistake: `=` vs `==`

This is a common beginner mistake.

Assignment:

x = 10

Comparison:

x == 10

Inside a condition, you normally want:

if x == 10:
    ...

not assignment.

123. Common Mistake: Mutable Default Arguments

Avoid patterns such as:

def add_item(item, items=[]):
    items.append(item)
    return items

The default list is created once and reused.

A safer pattern is:

def add_item(item, items=None):
    if items is None:
        items = []

    items.append(item)
    return items

This is an important Python-specific behavior to understand.

124. Common Mistake: Modifying a Collection During Iteration

Code such as:

for item in items:
    if condition(item):
        items.remove(item)

can produce unexpected behavior.

Often, create a new collection instead:

items = [
    item
    for item in items
    if not condition(item)
]

Or use an appropriate algorithm.

125. Common Mistake: Catching Every Exception

This:

try:
    ...
except:
    pass

can hide real bugs.

It is generally better to catch specific exceptions:

try:
    ...
except ValueError:
    ...

Good exception handling should make failures understandable rather than invisible.

126. Common Mistake: Excessive Global Variables

Global variables can make programs difficult to reason about.

Instead of:

total = 0

def calculate():
    global total
    ...

prefer passing values and returning results when practical:

def calculate(total):
    ...
    return total

This makes dependencies explicit.

127. Functions as First-Class Objects

In Python, functions are objects.

You can assign a function to a variable:

def greet():
    print("Hello")

f = greet
f()

You can pass functions to other functions:

def execute(function):
    function()

execute(greet)

This is the foundation of higher-order programming.

128. Higher-Order Functions

A higher-order function either receives functions or returns functions.

Example:

def multiplier(n):
    def multiply(x):
        return x * n

    return multiply

Then:

double = multiplier(2)

print(double(5))

Result:

This demonstrates a closure.

129. Closures

A closure occurs when an inner function remembers values from its enclosing scope.

def create_counter():
    count = 0

    def counter():
        nonlocal count
        count += 1
        return count

    return counter

Then:

counter = create_counter()

print(counter())
print(counter())
print(counter())

The inner function remembers count.

Closures are powerful for encapsulation, callbacks, decorators, and functional programming patterns.

130. Decorators

Decorators modify or extend function behavior.

A basic decorator:

def log_call(function):

    def wrapper():
        print("Calling function")
        return function()

    return wrapper

Use:

@log_call
def hello():
    print("Hello")

Calling:

hello()

executes the wrapper behavior around the original function.

Decorators are widely used in Python frameworks.

131. The `functools` Module

Python's standard library includes tools for functional programming.

For example:

from functools import wraps

wraps helps decorators preserve metadata from the original function.

Other useful utilities include:

partial
reduce
cache
lru_cache

132. Caching

Some computations repeatedly produce the same result.

Caching can avoid recalculating them.

Python provides:

from functools import lru_cache

For example:

@lru_cache
def expensive_function(x):
    ...

Caching can dramatically improve performance when the same inputs occur repeatedly.

133. Regular Expressions

Python provides the re module for pattern matching.

Example:

import re

text = "Python 123"

result = re.search(r"\d+", text)

if result:
    print(result.group())

Regular expressions are useful for structured text processing, validation, extraction, and searching.

134. The `pathlib` Module

Instead of manipulating file paths purely as strings, Python provides:

from pathlib import Path

Example:

path = Path("data") / "file.txt"

print(path)

This provides a cleaner object-oriented interface for filesystem paths.

135. The `datetime` Module

Python can represent dates and times.

from datetime import datetime

now = datetime.now()

print(now)

Dates and times are important in:

logging
databases
scheduling
analytics
APIs
financial systems

Time zones require additional care in real applications.

136. The `collections` Module

Python provides specialized containers.

Important examples include:

Counter
defaultdict
deque

A Counter counts elements:

from collections import Counter

letters = Counter("banana")

print(letters)

A deque provides efficient operations from both ends.

137. The `itertools` Module

itertools provides efficient iterator-building tools.

Examples include:

count
cycle
repeat
chain
product
permutations
combinations

These tools become particularly useful for algorithmic programming and large-scale iteration.

138. Python's Object Model

One of Python's deepest concepts is that almost everything is an object.

Numbers are objects.

Strings are objects.

Lists are objects.

Functions are objects.

Classes are objects.

Modules are objects.

This explains why Python supports:

object.method()

and why functions can be passed around like data.

139. Attributes

Objects can have attributes.

person.name

Methods are also attributes that happen to be callable.

You can inspect objects using:

dir(object)

For deeper inspection:

type(object)

and:

help(object)

can be useful.

140. `dict`

Many Python objects expose instance attributes through:

object.__dict__

For example:

class Person:
    def __init__(self):
        self.name = "Alex"
        self.age = 20

The object's dictionary may contain the stored attributes.

Understanding this helps explain how many Python objects store state.

141. Garbage Collection

Python manages memory automatically.

When objects are no longer reachable, Python can eventually reclaim their memory.

Python primarily uses reference counting in its standard implementation, along with a cyclic garbage collector for reference cycles.

As a Python developer, you normally do not manually free objects.

However, understanding object references is still important for memory optimization.

142. Concurrency Concepts

Python programs can perform multiple activities using different concurrency approaches.

Important concepts include:

threading
multiprocessing
asyncio

Threads can be useful for I/O-bound work.

Processes can be useful for CPU-bound workloads.

Asynchronous programming is especially useful for handling many waiting operations efficiently.

143. Asynchronous Functions

Python supports asynchronous programming with:

async
await

Example:

async def fetch_data():
    result = await some_operation()
    return result

Async programming is common in:

network applications
web servers
APIs
database clients
real-time systems

144. Python for Artificial Intelligence

Python is particularly important in AI because its ecosystem includes libraries for:

numerical computing
machine learning
deep learning
natural language processing
computer vision
data analysis

AI programming frequently combines Python with mathematical concepts such as:

vectors
matrices
probability
statistics
optimization
linear algebra
calculus

For example, a vector can be represented as:

vector = [0.2, 0.5, 0.8]

More advanced numerical libraries provide optimized array structures.

145. Python and Machine Learning

A machine-learning workflow might look like:

Data
 ↓
Cleaning
 ↓
Feature preparation
 ↓
Training
 ↓
Validation
 ↓
Prediction
 ↓
Evaluation

Python can coordinate each stage.

The language itself is not the machine-learning algorithm. Instead, Python provides the programming environment and ecosystem used to implement and connect those algorithms.

146. Python and Neural Networks

A neural network can be understood mathematically as transformations involving vectors, matrices, parameters, and nonlinear functions.

A simplified transformation is:

y = f(Wx + b)

where:

x = input
W = weights
b = bias
f = activation function
y = output

Python is frequently used to express these mathematical operations using specialized numerical and deep-learning libraries.

147. Learning Python in the Correct Order

A strong learning sequence is:

Variables
↓
Data Types
↓
Operators
↓
Conditions
↓
Loops
↓
Functions
↓
Sequences
↓
Dictionaries/Sets
↓
Exceptions
↓
Modules
↓
Classes
↓
Iterators
↓
Generators
↓
Decorators
↓
Type Hints
↓
Async Programming
↓
Algorithms
↓
Libraries
↓
Real Projects

Do not rush directly into advanced frameworks without understanding the fundamentals.

148. Practice Project: Number Analyzer

A beginner project can combine operators, conditions, loops, and functions.

def analyze(numbers):

    total = sum(numbers)
    maximum = max(numbers)
    minimum = min(numbers)

    even = []
    odd = []

    for number in numbers:

        if number % 2 == 0:
            even.append(number)
        else:
            odd.append(number)

    return {
        "total": total,
        "maximum": maximum,
        "minimum": minimum,
        "even": even,
        "odd": odd
    }

This small program uses:

functions
lists
loops
conditions
modulo
dictionaries
built-in functions
return values

149. Practice Project: Student System

Classes can represent real-world concepts.

class Student:

    def __init__(self, name):
        self.name = name
        self.scores = []

    def add_score(self, score):
        self.scores.append(score)

    def average(self):

        if not self.scores:
            return 0

        return sum(self.scores) / len(self.scores)

Use:

student = Student("Alex")

student.add_score(80)
student.add_score(90)
student.add_score(70)

print(student.average())

This demonstrates object-oriented design.

150. Practice Project: Simple Search

def search(items, target):

    for item in items:

        if item == target:
            return True

    return False

This simple algorithm demonstrates:

iteration
comparison
conditions
early return
functions

As you progress, you can compare this linear search with more advanced search algorithms.

151. Practice Project: Word Counter

def count_words(text):

    words = text.lower().split()

    counts = {}

    for word in words:

        if word in counts:
            counts[word] += 1
        else:
            counts[word] = 1

    return counts

This demonstrates how dictionaries can model relationships between keys and values.

152. Python's Most Important Mental Model

Instead of thinking:

Python variables contain values.

It is often more accurate to think:

Python names refer to objects.

For example:

a = [1, 2]
b = a

Both names refer to the same list object.

Then:

b.append(3)

changes the object.

Therefore:

print(a)

produces:

[1, 2, 3]

Understanding references explains many Python behaviors that otherwise appear mysterious.

153. Another Important Mental Model: Iteration

When you write:

for item in data:
    ...

you should understand that Python is conceptually asking the object for an iterator and repeatedly requesting the next item until iteration finishes.

This model connects many apparently different Python objects.

Lists, tuples, strings, dictionaries, sets, ranges, files, and generators can all participate in iteration.

154. Another Important Mental Model: Functions

A function is more than a block of code.

It can be:

stored
passed
returned
decorated
called
assigned
used as an object

This is why Python can support functional programming techniques alongside object-oriented programming.

155. Another Important Mental Model: Classes

A class is not merely a template for storing variables.

A class can define:

state
behavior
relationships
construction
validation
operator behavior
iteration behavior
representation

This makes classes powerful abstractions for larger software systems.

156. How Python Concepts Connect

The concepts in this guide are not isolated.

They form a system:

Variables
   ↓
Objects
   ↓
Operators
   ↓
Conditions
   ↓
Loops
   ↓
Functions
   ↓
Collections
   ↓
Iterators
   ↓
Classes
   ↓
Modules
   ↓
Applications

For example, a real application might:

Read data from a file.
Store it in dictionaries.
Iterate through records.
Use conditions to validate them.
Call functions to process them.
Create class objects.
Save results.
Return data through an API.

That is how the fundamental concepts combine into real software.

157. What Beginners Should Memorize

Do not try to memorize every Python feature.

Focus first on understanding:

=
==
!=
>
<
>=
<=

and
or
not

if
elif
else

for
while
break
continue

def
return

list
tuple
set
dict
str

try
except
finally

class
self
__init__

import
from

After that, learn the deeper concepts.

158. What You Should Understand Rather Than Memorize

Some concepts should be understood conceptually:

references
mutability
iteration
iterators
generators
scope
closures
decorators
object-oriented programming
inheritance
polymorphism
complexity
memory behavior

If you understand these ideas, you can learn new Python syntax much faster.

159. A Practical Python Learning Strategy

A good learning process is:

Step 1: Write tiny programs

Do not begin with a massive application.

Write:

print("Hello")

Then:

x = 10
y = 20

print(x + y)

Then conditions.

Then loops.

Then functions.

Step 2: Change the code

Do not only copy examples.

Change:

to:

Change the conditions.

Change the data structures.

Observe the result.

Step 3: Break programs deliberately

Make mistakes and understand the errors.

Step 4: Build projects

Projects turn syntax into actual programming ability.

160. Final Python Cheat Sheet

Variables

x = 10
name = "Python"

Arithmetic

+
-
*
/
//
%
**

Comparison

==
!=
>
<
>=
<=

Logic

and
or
not

Membership

in
not in

Identity

is
is not

Conditions

if condition:
    ...
elif condition:
    ...
else:
    ...

Loops

for item in items:
    ...

while condition:
    ...

Functions

def function(value):
    return value

Lists

items = []
items.append(value)

Dictionaries

data = {
    "key": "value"
}

Sets

items = {1, 2, 3}

Tuples

point = (10, 20)

Exceptions

try:
    ...
except ValueError:
    ...
finally:
    ...

Classes

class Person:

    def __init__(self, name):
        self.name = name

Iteration

for item in iterable:
    ...

Generator

def generate():
    yield value

Comprehension

values = [x * 2 for x in numbers]

Type hints

def add(a: int, b: int) -> int:
    return a + b

To fully understand this topic, we recommend reading the previous lesson first. It explains the core concepts that this article builds upon.

Read the previous article here:
https://khayyamshah2007.blogspot.com/2026/08/python-variables-and-data-types_01102212708.html

Conclusion

Learning Python is not simply learning a list of commands. The real goal is to understand how Python represents information and how those pieces combine to create programs.

Operators allow you to calculate and compare values.

Conditions allow programs to make decisions.

Loops and iteration allow programs to process many values.

Functions allow logic to be organized and reused.

Sequences provide ordered collections of data.

Lists, tuples, sets, and dictionaries give you different ways to model information.

Iterators and generators explain how Python processes data lazily and efficiently.

Exceptions allow programs to handle unexpected situations.

Modules and packages allow applications to grow beyond a single file.

Classes and objects provide powerful ways to model complex systems.

Decorators, closures, context managers, comprehensions, and special methods reveal some of Python's deeper capabilities.

And concepts such as references, mutability, scope, iteration, and algorithmic complexity are what transform basic Python knowledge into serious programming ability.

If you are learning Python for AI, machine learning, data science, automation, backend development, or software engineering, these fundamentals form the foundation for everything that comes later.

Once these concepts become natural, frameworks and libraries become much easier to understand because you are no longer simply copying Python syntax—you understand the programming model underneath it.

The best way to master Python is therefore simple:

Learn a concept → write code → change the code → make mistakes → understand the errors → build a project → repeat.

Python becomes powerful when its individual features stop feeling like separate commands and start working together as one system.

AI Insights Hub | Generative AI, ChatGPT, LLMs, AI Agents & Future Technology

Python Fundamentals Explained: Operators, Conditions, Functions, Loops, Sequences, Iteration, Classes & More (2026 Guide)

Python Operators, Conditions, Functions, Sequences, Iteration, Classes & Essential Python Concepts: Complete Guide for Beginners to Advanced Developers

1. What Is Python?

2. Variables

3. Python Data Types

4. Python Operators

5. Arithmetic Operators

Addition

Subtraction

Multiplication

Division

Floor Division

Modulo

Exponentiation

6. Assignment Operators

7. Comparison Operators

8. Equality vs Identity

9. Logical Operators

and

or

not

10. Truthy and Falsy Values

11. Membership Operators

12. Bitwise Operators

13. Operator Precedence

14. Conditions

15. if, elif, and else

16. Nested Conditions

17. Conditional Expressions

18. The match Statement

19. Loops and Iteration

20. The for Loop

21. The range() Function

22. The while Loop

23. break

24. continue

25. pass

26. Nested Loops

27. Functions

28. Function Parameters

29. Multiple Parameters

30. Return Values

31. Functions Without return

32. Default Parameters

33. Keyword Arguments

34. Variable-Length Arguments

35. Scope

36. The global Keyword

37. The nonlocal Keyword

38. Recursion

39. Sequences

40. Lists

41. Negative Indexing

42. List Mutation

43. List Slicing

44. Tuples

45. Tuple Unpacking

46. Strings

47. Useful String Methods

48. Formatted Strings

49. Sets

50. Dictionaries

51. Dictionary Methods

52. Iterables and Iterators

53. The Iterator Protocol

54. Generators

55. Generator Expressions

56. List Comprehensions

57. Dictionary Comprehensions

58. Set Comprehensions

59. The enumerate() Function

60. The zip() Function

61. map()

62. filter()

63. Lambda Functions

64. Sorting

65. Custom Sorting

66. Exception Handling

67. finally

`and`

`or`

`not`

15. `if`, `elif`, and `else`

18. The `match` Statement

20. The `for` Loop

21. The `range()` Function

22. The `while` Loop

23. `break`

24. `continue`

25. `pass`

31. Functions Without `return`

36. The `global` Keyword

37. The `nonlocal` Keyword

59. The `enumerate()` Function

60. The `zip()` Function

61. `map()`

62. `filter()`

67. `finally`

72. The `name` Pattern

74. The `init()` Method

75. Understanding `self`

81. `super()`

90. `str()`

91. `len()`

96. `None`

98. The `all()` Function

99. The `any()` Function

100. `len()`

101. `min()` and `max()`

102. `sum()`

103. `abs()`

104. `round()`

105. `isinstance()`

122. Common Python Mistake: `=` vs `==`

131. The `functools` Module

134. The `pathlib` Module

135. The `datetime` Module

136. The `collections` Module