# Just some code to show the version of Python that I'm ganna be using for the code examples etc.
import sys
print(f"All the code executed in this file is running on Python: \033[36m{sys.version}\033[0m unless explicitly specified.")

All the code executed in this file is running on Python: 3.13.1 (tags/v3.13.1:0671451, Dec  3 2024, 19:06:28) [MSC v.1942 64 bit (AMD64)] unless explicitly specified.

# here is a basic example of the imperative model in play, its just basic code for factorials.
def factorial(n):
    result = 1
    for i in range(1, n + 1):  # Sequential loop, as in sequential execution
        result *= i  # Step-by-step state mutation, as in variables are changing their 'states'
    return result

print(f"\033[31mThe factorial is: {factorial(5)}")

The factorial is: 120

# Here is a simple example of Pure Functions in Python
def add(x, y):
    return x + y
# Always returns the same result for the same inputs.

a = 10
b = 20
result = add(a, b)
print(f"\033[31mThe sum of {a} and {b} is: {result}")

The sum of 10 and 20 is: 30

# Here is an example of Higher Order Functions in Python matee

# this function is ganna accept a function as an argument (a trait of higher order functions)
def apply_to_each(function, data):
    result = [] # this is a list, lists are a simple collection data type in Python, like arrays are in C++. This documentation doesn't cover data structures so I'm not going to go into details
    for item in data:   # oh look, that looks like a foreach loop doesn't it?
        result.append(function(item))  # append is basically adding the element into the list, just like how we insert stuff at the end of a queue
    return result

# Defining the secondary function that we will pass in as the argument
def square(x):
    return x ** 2   ## the ** is for exponentiation, as in power, btw

# Example data
numbers = [1, 2, 3]

# Use the higher-order function
squares = apply_to_each(square, numbers)  # square is passed as an argument, which itself is a function bro
print(f"\033[31mThe list contains the squares of the numbers that we passed(1,2,3), which are: {squares}")  # Output: [1, 4, 9]

The list contains the squares of the numbers that we passed(1,2,3), which are: [1, 4, 9]

# The following is an example of lambda expressions in python; remember, lambda expressions were the ones that didn't have a name and are only a single-line of code

x = 5
double = lambda x: x ** 2        # look, it doesn't have any explicit name, and its in a single-line
print(f"\033[31mSquare of {x} is: {double(x)}")  # Output: 10

Square of 5 is: 25

# We will import in some logical operators like Or and Not 
from sympy import symbols, Or, Not
# But why? Doesn't Python already have the And, Or, Not operators etc? Well, yes it does, here is the issue though:

# Python’s and, or, not:

# Designed for immediate execution.
# Works directly with Boolean values like True or False.
# Cannot handle symbols or expressions.
# The "A AND B" assumes that both A and B are booleans and evaluates that expression immediately
#################################################
# Logical Programming’s And, Or, Not:

# Designed for symbolic computation.
# Works with symbols that don’t have specific values (e.g., A, B).
# Useful for defining rules and constraints in declarative programming.
# The "A AND B" is a logical statement and A and B can be other then 0 and 1. 

# Define some symbols:
Rain = symbols('Rain')
Umbrella = symbols('Umbrella')  # we are ganna try to simulate a simple "if it rains, you need an umbrella"

# Now we define the logical rule.
rule = Or(Not(Rain), Umbrella)  # this just means "[(NOT rain) OR (Umbrella)]" or like "either its not raining or I need an umbrella"

print(f"\033[31m{rule}")

Umbrella | ~Rain

from sympy import symbols, And, Or, Not

# lets run through a simple traffic light example.

# lets define our "what": "Only one light can be ON at one time"
# so we basically need 3 rules/constraints, one where only the Green light is on, one where only the red light is on, and one where only the yellow light is on. We just need to build logical rules where that would become true

# Define symbols like before:
Green = symbols('Green')  # symbol to represent the green light
Yellow = symbols('Yellow')  # the yellow light symbol
Red = symbols('Red')  # The red light symbol

# Logical rules:
rule = Or(And(Not(Yellow), Not(Red), Green),  # It's only green :       [(NOT Yellow) AND (NOT Red) AND (Green)]    so If both yellow and Red are OFF and Green is ON (hence only Green is on)
          And(Not(Green), Not(Red), Yellow),  # Or it's only yellow :   [(NOT green) AND (NOT Red) AND Yellow]      so if both Red and Green are OFF and Yellow is ON (hence only yellow is on)
          And(Not(Yellow), Not(Green), Red))  # or its only red :       [(NOT Yellow) AND (NOT Green) and (Red)]    so if both Green and Yellow are OFF and Red is ON (hence only Red is on)

print(f"\033[31m{rule}")
# Output: (Green & ~Yellow & ~Red) | (Yellow & ~Green & ~Red)

(Green & ~Red & ~Yellow) | (Red & ~Green & ~Yellow) | (Yellow & ~Green & ~Red)

class BankAccount:
    def __init__(self, balance=0):     # constructors normally have the same name as the class name, but not in Python. in Python, all constructors use a keyword __init__
        self.__balance = balance  # Private attribute (it will take forever if I start explaining the code line by line so yeah, just ganna provide some resources for you guys later on, this is taking too long)

# methods being defined
    def deposit(self, amount):  
        self.__balance += amount

    def withdraw(self, amount):
        if amount <= self.__balance:
            self.__balance -= amount
        else:
            print("Insufficient funds!")

    def get_balance(self):
        return self.__balance

# Using the class
account = BankAccount() # object created
account.deposit(1000)   # method called
account.withdraw(500)   # another method called
print(f"\033[31m{account.get_balance()}")

500

class Vehicle:
    def __init__(self, brand, wheels):
        self.brand = brand
        self.wheels = wheels

    def display_info(self):
        print(f"\033[31mBrand: {self.brand}, Wheels: {self.wheels}")

class Car(Vehicle):  # Inheriting from Vehicle
    def __init__(self, brand, wheels, fuel_type):
        super().__init__(brand, wheels)  # Calling the parent constructor
        self.fuel_type = fuel_type

    def display_info(self):  # Method overriding
        super().display_info()
        print(f"Fuel Type: {self.fuel_type}")

# Using the classes
my_car = Car("Toyota", 4, "Petrol")
my_car.display_info()

Brand: Toyota, Wheels: 4
Fuel Type: Petrol

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow Meow!"

animals = [Dog(), Cat()]
for animal in animals:
    print(f"\033[31m{animal.speak()}")

Woof Woof!
Meow Meow!

from abc import ABC, abstractmethod

class Shape(ABC):  # Abstract Base Class
    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass

class Rectangle(Shape):
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

    def perimeter(self):
        return 2 * (self.length + self.width)

# Using the classes
rect = Rectangle(5, 3)
print("\033[31mArea:", rect.area())
print("\033[31mPerimeter:", rect.perimeter())

Area: 15
Perimeter: 16

import random as rd     # this is how we import libraries in Python (10 and 2✅)
# you can see we don't need to use semi-colon or anything as a statement terminator

class Player:           # this is a class in Python, and you can also see indentation in play here, the block of code is represented using indentation instead of braces (like in c++) (12 and 4✅)
    """This is a class that is going to represent the players in our RPG game.
    Oh, and this is a multi-line comment btw, you just enclose multiple lines into 6 quotation marks, this multi-line comment is usually called a docstring"""     # (3✅)
    def __init__(self, name):       # this is a constructor, which is a method in a class, which has identical syntax to functions for the most part (9 and 4✅)
        self.name = name
        self.health = 120
        self.inventory = {"Sword": 1, "Battle Axe": 1, "Potion": 2} # default inventory
    def drink_potion(self):
        if (self.health < 200) and (self.inventory.get("Potion", 0) > 0):
            self.health += 20
            self.inventory["Potion"] -= 1
            if self.health > 200:
                self.health = 200
            print(f"The mighty {self.name} just used a potion, their health has been increased to: {self.health}")
        else:
            print(f"My apologies Dear Knight, it seems as if you have ran out of potions.")
    def show_inventory(self):
        print("\nThis is your inventory good sir:")
        for item, count in self.inventory.items():      # A for loop applied on the inventory dictionary (data structures are not in the scope of the documentation so not going to cover dictionaries)
            print(f"{item}: {count}")           # (8✅)

class Enemy:
        def __init__(self, name, health, attack):
            self.name = name
            self.health = health
            self.attack = attack

def fight(player, enemy):       # (9✅)
    print(f"A frightening {enemy.name} has appeared out of the blue")
    while player.health > 0 and enemy.health > 0:           # while loop in action
        print(f"\033[32m{player.name}'s health is {player.health}.")
        print(f"\033[31m{enemy.name} has a health of {enemy.health}.")
        
        action = input("Choose an action {player.name} (attack, heal, run)").strip().lower()    # taking input from user, strip takes away the blank spaces and lower makes the entire input string lower case
        if action == "attack":  # (7✅)
            damage = rd.randint(10, 30)  # Dynamic typing
            enemy.health -= damage
            print(f"\033[32m{player.name} attacked {enemy.name} for {damage} damage!!!")
        elif action == "heal":
            player.drink_potion()
        elif action == "run":
            print(f"\033[35m{player.name} fled the battle! What a fricking coward am I right?")
            return
        else:
            print("Invalid action. Try again.")
            continue
        
        # Enemy's turn
        if enemy.health > 0:
            damage = rd.randint(5, 45)
            player.health -= damage
            print(f"\033[31m{enemy.name} attacked {player.name} for {damage} damage!")

    if player.health <= 0:
        print(f"\n\033[31m{player.name} has been defeated by {enemy.name}...")
    elif enemy.health <= 0:
        print(f"\n\033[32m{enemy.name} has been defeated! Victoryyyy!")


def main():
    print("\033[34mWelcome to the Fantasy RPG!\033[0m")
    
    # Multiple assignment and also dynamic typing (5 and 6✅)
    player_name, enemy_name = "Galileo", "Friedrich Nietzsche"  
    player = Player(player_name)
    enemy = Enemy(enemy_name, health=100, attack=10)

    # Swapping inventory items as an example (6✅)
    player.inventory["Bow"], player.inventory["Sword"] = 1, player.inventory.pop("Sword")
    
    # Show initial inventory
    player.show_inventory()

    # Start battle
    fight(player, enemy)

# Run the program
if __name__ == "__main__":
    main()

Welcome to the Fantasy RPG!

This is your inventory good sir:
Battle Axe: 1
Potion: 2
Bow: 1
Sword: 1
A frightening Friedrich Nietzsche has appeared out of the blue
Galileo's health is 120.
Friedrich Nietzsche has a health of 100.
Galileo attacked Friedrich Nietzsche for 30 damage!!!
Friedrich Nietzsche attacked Galileo for 41 damage!
Galileo's health is 79.
Friedrich Nietzsche has a health of 70.
Galileo attacked Friedrich Nietzsche for 19 damage!!!
Friedrich Nietzsche attacked Galileo for 9 damage!
Galileo's health is 70.
Friedrich Nietzsche has a health of 51.
Galileo fled the battle! What a fricking coward am I right?

### Operators in Python (13✅)
# Arithmetic Operators
x = 10
y = 3
print("\033[34mArithmetic Operators\033[0m")
print("\033[31mAddition:", x + y)       # 13
print("Subtraction:", x - y)            # 7
print("Multiplication:", x * y)         # 30
print("Division:", x / y)               # 3.3333
print("Floor Division:", x // y)        # 3
print("Modulus:", x % y)                # 1
print("Exponentiation:", x ** y)        # 1000
print("\033[32m=================================================================================")
# Comparison Operators
print("\033[34mComparison Operators\033[0m")
print("\033[31mEqual:", x == y)             # False
print("Not Equal:", x != y)                 # True
print("Greater than:", x > y)               # True
print("Less than:", x < y)                  # False
print("Greater or Equal:", x >= y)          # True
print("Less or Equal:", x <= y)             # False
print("\033[32m=================================================================================")

# Logical Operators
print("\033[34mLogical Operators\033[0m")
a = True
b = False
print("\033[31mAND:", a and b)          # False
print("OR:", a or b)                    # True
print("NOT:", not a)                    # False
print("\033[32m=================================================================================")

# Assignment Operators
print("\033[34mAssignment Operators\033[0m")
z = 5
z += 2                                  # z = z + 2
print("\033[31mz after +=:", z)         # 7
z *= 3                                  # z = z * 3
print("z after *=:", z)                 # 21
print("\033[32m=================================================================================")

# Membership Operators
print("\033[34mMembership Operators\033[0m")
my_list = [1, 2, 3, 4]
print("\033[31m2 in list:", 2 in my_list)   # True
print("5 not in list:", 5 not in my_list)   # True
print("\033[32m=================================================================================")

# Identity Operators
print("\033[34mIdentity Operators\033[0m")
a = [1, 2, 3]
b = a
c = [1, 2, 3]
print("\033[31ma is b:", a is b)          # True
print("a is c:", a is c)          # False
print("a == c:", a == c)          # True
print("\033[32m=================================================================================")

### Operator Precedence (14✅)
print("\033[34mOperator Precedence\033[0m")
# Example of precedence
result = 2 + 3 * 5 ** 2 - 4 / 2
# Exponentiation first, then multiplication, division, addition, subtraction
print("\033[31mPrecedence result:", result) # 75.0
print("\033[32m=================================================================================")

### Associativity (15✅)
print("\033[34mAssociativity\033[0m")

# Left-to-right example
print("\033[31mLeft-to-right:", 5 - 3 - 1)  # 1
# Right-to-left example (exponentiation)
print("Right-to-left:", 2 ** 3 ** 2) # 512
print("\033[32m=================================================================================")

### Implicit and Explicit Type Casting (16✅)
# Implicit Type Casting
print("\033[34mType Casting\033[0m")

x = 5  # Integer
y = 2.5  # Float
z = x + y  # Python converts x to float implicitly
print("\033[31mImplicit Casting:", z, type(z))  # 7.5, float

# Explicit Type Casting
x = 10.7
y = "42"
z = int(x) + int(y)  # Explicit conversion to int
print("\033[31mExplicit Casting:", z)  # 52
print("\033[32m=================================================================================")

### String Manipulation (11✅)
print("\033[34mBasic String Manipulation\033[0m")
# Basic Operations
my_str = "This is taking foreverrrr!"
print("\033[31mUppercase:", my_str.upper())  
print("Lowercase:", my_str.lower())  
print("Replace:", my_str.replace("foreverrrr", "MOST CERTAINLY TAKING FOREVERRRRRRRRRRRRR"))  # "Hello, World!"
print("Slice:", my_str[7:13])

# F-Strings
name = "David Corenswet"
age = 31
print(f"Superman's new name is {name} and he is {age} years old.")

# String Concatenation
first = "Good Morning!"
second = "How are you doing today Lois?"
print("Concatenation:", first + " " + second)

Arithmetic Operators
Addition: 13
Subtraction: 7
Multiplication: 30
Division: 3.3333333333333335
Floor Division: 3
Modulus: 1
Exponentiation: 1000
=================================================================================
Comparison Operators
Equal: False
Not Equal: True
Greater than: True
Less than: False
Greater or Equal: True
Less or Equal: False
=================================================================================
Logical Operators
AND: False
OR: True
NOT: False
=================================================================================
Assignment Operators
z after +=: 7
z after *=: 21
=================================================================================
Membership Operators
2 in list: True
5 not in list: True
=================================================================================
Identity Operators
a is b: True
a is c: False
a == c: True
=================================================================================
Operator Precedence
Precedence result: 75.0
=================================================================================
Associativity
Left-to-right: 1
Right-to-left: 512
=================================================================================
Type Casting
Implicit Casting: 7.5 <class 'float'>
Explicit Casting: 52
=================================================================================
Basic String Manipulation
Uppercase: THIS IS TAKING FOREVERRRR!
Lowercase: this is taking foreverrrr!
Replace: This is taking MOST CERTAINLY TAKING FOREVERRRRRRRRRRRRR!
Slice:  takin
Superman's new name is David Corenswet and he is 31 years old.
Concatenation: Good Morning! How are you doing today Lois?

x = 5
y = 3
z = x + y  # Addition as defined mathematically
print(z)  # Output: 8

x = 10
y = 20
z = x + y
print(z)

# No need to try to understand the code, its GPT generated, just to show you an example of an AST, move to the output and the explanation
import ast
from anytree import Node, RenderTree

# Python source code
code = """
x = 10
y = 20
z = x + y
print(z)
"""

# Parse the code into an AST
parsed_ast = ast.parse(code)

# Function to recursively build the tree
def build_tree(node, parent=None):
    node_name = type(node).__name__
    tree_node = Node(node_name, parent=parent)
    for child in ast.iter_child_nodes(node):
        build_tree(child, tree_node)
    return tree_node

# Build the AST tree
root = build_tree(parsed_ast)

# Print the tree
for pre, fill, node in RenderTree(root):
    print(f"{pre}{node.name}")

Module
├── Assign
│   ├── Name
│   │   └── Store
│   └── Constant
├── Assign
│   ├── Name
│   │   └── Store
│   └── Constant
├── Assign
│   ├── Name
│   │   └── Store
│   └── BinOp
│       ├── Name
│       │   └── Load
│       ├── Add
│       └── Name
│           └── Load
└── Expr
    └── Call
        ├── Name
        │   └── Load
        └── Name
            └── Load

import dis

def example():
    x = 10
    y = 20
    z = x + y
    print(z)

dis.dis(example)

  3           RESUME                   0

  4           LOAD_CONST               1 (10)
              STORE_FAST               0 (x)

  5           LOAD_CONST               2 (20)
              STORE_FAST               1 (y)

  6           LOAD_FAST_LOAD_FAST      1 (x, y)
              BINARY_OP                0 (+)
              STORE_FAST               2 (z)

  7           LOAD_GLOBAL              1 (print + NULL)
              LOAD_FAST                2 (z)
              CALL                     1
              POP_TOP
              RETURN_CONST             0 (None)

# Importing The Zen of Python
import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

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

print(add(5, 3))

import numpy as np
import time

# Using NumPy
start = time.time()

# Create matrices a and b
a = np.arange(1000)[:, None] * np.arange(1000) 
b = np.arange(1000)[:, None] * np.arange(1000).T 

# Perform matrix multiplication
result = np.dot(a, b)

end = time.time()
print(f"NumPy Execution Time: {end - start:.4f} seconds")

numpy_time = end - start
print(f"NumPy took {numpy_time} seconds to run this code")

NumPy Execution Time: 2.1261 seconds
NumPy took 2.126063585281372 seconds to run this code

import numpy as np
import time

# Using NumPy
start = time.time()

# Create matrices a and b
a = np.arange(1000)[:, None] * np.arange(1000) 
b = np.arange(1000)[:, None] * np.arange(1000).T 

# Perform matrix multiplication
result = np.dot(a, b)

end = time.time()
print(f"NumPy Execution Time: {end - start:.4f} seconds")

numpy_time = end - start
print(f"NumPy took {numpy_time} seconds to run this code")

NumPy Execution Time: 2.1261 seconds
NumPy took 2.126063585281372 seconds to run this code

import sys
import numpy as np

# Python list
python_list = [i for i in range(10000)]
print(f"Memory used by Python list: {sys.getsizeof(python_list)} bytes")

# NumPy array
numpy_array = np.arange(10000)
print(f"Memory used by NumPy array: {numpy_array.nbytes} bytes")

Memory used by Python list: 85176 bytes
Memory used by NumPy array: 40000 bytes

Precedence
** Exponentiation
Unary Plus, Minus	Multiplication, Division, Floor Division, Modulus	Addition, Subtraction
Comparison (==, !=, >, >=, <=)	Identity (is, is not)	Membership (in, not in)
Logical AND	Logical OR	Assignment Operators (=, +=, -=, *=, /=, //=, %=, &=, ^=, \|=, <<=, >>=)

Data Type	Python (Bytes)	Java (Bytes)	C++ (Bytes)
Integer	~28 (varies by size)	4 (primitive `int`)	4 (primitive `int`)
Float	~24	4 (primitive `float`)	4 (primitive `float`)
String (1 char)	~50	~40	1 (character literal)
List (Empty)	~64	N/A (ArrayList is dynamic)	Varies by implementation
Dictionary	~240 (Empty)	N/A	N/A

Topics¶

Origins and Motivations¶

Major Milestones in Python's Evolution¶

Current Day Status of Python¶

Imperative Computational Model¶

Functional Computational Model¶

Logical Computational Model¶

Object Oriented Computational Model¶

The Dominant Model of Python¶

Why is Object Oriented Model the dominant model in Python?¶

Encapsulation¶

Inheritance¶

Polymorphism¶

Abstraction¶

Advanced OOP Concepts¶

Lets quickly cover the few points that the above example didn't cover now¶

Algebraic Semantics¶

Axiomatic Semantics¶

Denotational Semantics¶

Operational Semantics¶

Summary of Semantics¶

Step-by-Step Compilation Process¶

Points of Confusion¶

Step-by-Step Example¶

The Zen of Python¶

Readability¶

Dynamic Typing¶

Interoperability¶

Modularity¶

Dedicated Interactive Environment¶

Major Fields Where Python Excels¶

1. Data Science and Artificial Intelligence (AI)¶

2. Web Development¶

3. Automation and Scripting¶

4. Cybersecurity and Ethical Hacking¶

5. Scientific Computing and Research¶

Python's Impact in the Real-World¶

Syntax¶

Performance¶

Potential Performance Improvements¶

Memory Consumption¶

Potential Ways to Reduce Memory Consumption¶

Type System¶

Ways to Potentially mitigate runtime errors due to Dynamic Typing¶

Compilation/Execution¶

Concurrency¶

Parallelism¶

Ways to bypass the GIL and enable Parallelism in Python¶

Platform Independence¶

Error Handling¶

Use Cases¶

Python VS R¶