DEV Community: abiud kipngetich

Mastering Object-Oriented Programming in Python: Classes, Pillars, and Robust Error Handling

abiud kipngetich — Tue, 29 Sep 2026 10:54:52 +0000

1. Introduction

Object-Oriented Programming (OOP) organizes code around objects, which bundle data (attributes) and behavior (methods) together. Python supports OOP natively, and nearly everything in it, including integers, strings, and lists, in an object.

Using libraries and `randint()`

Python's standard library provides ready-made tools through the import statement. The random module is a common example:

import random 

roll = random.randint(1, 6)     # random integer from 1 to 6, inclusive 
print(roll)

Here, random is a module (an object), and randint() is a method of it. You can also import a single function directly:

from random import randint 
print(randint(1, 100))

Attributes are values stored on an object (e.g., car.color).
Methods are functions defined inside a class that act on the object (e.g., car.drive()).

2. Classes and Objects

A class is a blueprint. An object (or instance) is something built from that blueprint.

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

    def bark(self): 
        return f"{self.name} says woof!"  

mutina = Dog("Mutina", 3) 
print(mutina.bark())           # Mutina says woof!

What is __init__? It is the constructor, a special method that runs automatically when an object is created. It sets up the object's initial state.
What is self? It refers to the specific instance being worked on. When you call mutina.bark(), Python passes mutina in as self, so each object keeps its own data.

3. Class Attributes vs. Instance Attributes

class Dog: 
    species = "Canis familiaris"    # class attribute (shared) 

    def __init__(self, name):  
        self.name = name            # instance attribute (unique) 

a = Dog("Rex") 
b = Dog("Bosco") 
print(a.species, b.species)       # shared value 
print(a.name, b.name)             # different values

Class attributes belong to the class and are shared by all instances.
Instance attributes belong to one object and are defined via self (usually in __init__).

4. Methods

Python has three kinds of methods:

class Circle: 
    pi = 3.14159 

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

    def area(self):           # instance method 
        return self.pi * self.radius ** 2 

    @classmethod 
    def unit(cls):            # class method 
        return cls(1) 

    @staticmethod 
    def is_valid(radius):      # static method 
        return radius > 0

Instance methods use self and work with object data.
Class methods use cls and work with the class itself.
Static methods need neither; they are utility functions grouped with the class.

5. Parent and Child Classes

A parent (base) class provides shared features. A child (derived) class inherits them and can add or override behavior.

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

    def speak(self): 
        return "Some sound" 

class Cat(Animal):                # Cat is the child of Animal 
    def __init__(self, name, indoor): 
        super().__init__(name)    # reuse the parent's setup 
        self.indoor = indoor 

    def speak(self):              # overide 
        return f"{self.name} says meow"

super() gives the child access to the parent's methods.

6. The Four Pillars of OOP

Encapsulation bundles data and methods together and restricts direct access to internal state. Python uses naming conventions: _name (protected by convention) and __name (name-mangled, "private").

class BankAccount: 
    def __init__(self, balance): 
        self.__balance = balance 

    def deposit(self, amount): 
        if amount > 0: 
            self.__balance += amount 

    def get_balance(self):                 
        return self.__balance

Inheritance lets a class reuse and extend another class's code, reducing duplication.
Polymorphism means different classes can respond to the same method call in their own way.

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

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

for pet in (Dog(), Cat()): 
    print(pet.speak())       # same call, different behavior

Abstraction hides complexity and exposes only what is neccessary. Python implements it with abstract base classes:

from abc import ABC, abstractmethod 

class Shape(ABC): 
    @abstractmethod 
    def area(self): 
        pass 

class Square(Shape): 
    def __init__(self, side): 
        self.side = side 

    def area(self): 
        return self.side ** 2

Shape cannot be intantiated directly; every child must implement area().

7. Types of Python Errors

Type	When it occurs	Example
Syntax error	Code breaks Python's grammar; the priogram won't start	`print("Hi"`(missing parenthesis)
Runtime error	Code is valid but fails while running	`10 / 0`
Logical error	Code runs without crashing but produces wrong results	Using `+` instead of `*` in a formula

Logical errors are the hardest to find because Python raises no warning. Testing and print() or debugger inspection are the best defenses.

8. Error Handling with `try`/`except`

try: 
    number = int(input("Enter a number: ")) 
    print(10 / number) 
except ValueError: 
    print("That is not a valid number.") 
except ZeroDivisionError: 
    print("Cannot divide by zero.") 
else: 
     print("Success!")       # runs only if no exception occurred 
finally: 
    print("Done.")           # always runs

try: code that might fail
except: handles a specific error
else: runs if nothing went wrong
finally: runs no matter what (ideal for cleanup)

You can also raise your own exceptions with raise ValueError("Invalid input").

9. Common Python Exceptions

ZeroDivisionError: dividing by zero.

print(5 / 0)

ValueError: right type, inappropriate value.

int("abc")

TypeError: an operation applied to the wrong type.

"5" + 3

NameError: using a variable that hasn't been defined.

print(undefined_var)

IndexError: accessing a list position that doesn't exist.

items = [1, 2, 3] 
print(items[5])

FileNotFoundError: opening a file that doesn't exist.

open("missing.txt")

Conclusion

Object-oriented programming gives Python developers a clean way to model real-world problems: classes define structure, objects hold state, and the four pillars keep code organized, reusable, and secure. Paired with disciplined error handling, which anticipates syntax, runtime, and logical failures and catches common exceptions gracefully, these skills form the foundation of professional, maintainable Python code.

Understanding SQL: A Practical Guide to Categories, Data Types, Joins, and Core Concepts

abiud kipngetich — Sat, 19 Sep 2026 12:25:58 +0000

SQL (Structured Query Language) is the standard language for interacting with relational databases. Whether you're building an application, generating a report, or maintaining data integrity, a solid grasp of SQL's building blocks is essential. This article walks through the core concepts every developer or analyst should know.

1. SQL Categories

SQL commands are grouped into four main categories based on their function:

DDL (Data Definition Language) - defines and modifies database structure.

CREATE, ALTER, DROP, TRUNCATE

CREATE TABLE employees ( 
id SERIAL PRIMARY KEY,  
name VARCHAR(100) 
);

DML (Data Manipulation Language) - manages the actual data

SELECT, INSERT, UPDATE, DELETE

INSERT INTO employees (name) VALUES ('Alice'); 
UPDATE employees SET name = 'Alicia' WHERE id = 1;

DCL (Data Control Language) - controls access and permissions

GRANT, REVOKE

GRANT SELECT, INSERT ON employees TO analyst_role; 
REVOKE INSERT ON employees FROM analyst_role;

TCL (Transaction Control Language) - manages transactions

COMMIT, ROLLBACK, SAVEPOINT

BEGIN; 
UPDATE employees SET name = 'Bob' WHERE id = 2; 
SAVEPOINT before_delete; 
DELETE FROM employees WHERE id = 3; 
ROLLBACK TO before_delete; 
COMMIT;

2. Data Types

Common data types (illustrated with PostgreSQL-style syntax; other databases use similar variants):

Category------Examples

Numeric------INT, BIGINT, DECIMAL(10,2), FLOAT
Character------CHAR(n), VARCHAR(n), TEXT
Date/Time------DATE, TIME, TIMESTAMP
Boolean------BOOLEAN
Binary------BYTEA, BLOB
JSON------JSON, JSONB

Choosing the right type matters for storage efficiency and query performance, e.g. use VARCHAR(n) over TEXT when a length limit is meaningful, and DECIMAL rather than FLOAT for currency to avoid rounding errors.

3. Constraints and Defaults

Constraints enforce rules on data:

PRIMARY KEY - uniquely identifies each row
FOREIGN KEY - enforces referential integrity between tables
UNIQUE - ensures no duplicate values
NOT NULL - disallows empty values
CHECK - validates a condition
DEFAULT - supplies a fallback value

CREATE TABLE orders ( 
id SERIAL PRIMARY KEY, 
customer_id INT NOT NULL REFERENCES customer(id), 
status VARCHAR(20) DEFAULT 'pending', 
total DECIMAL(10,2) CHECK (total >= 0)

4. Schemas and the `public` Schema

A schema is a namespace that groups related tables, views, and other objects within a database. Schemas help organize large databases and manage access control.
In PostgreSQL, every new database includes a default schema called public. Unless specified otherwise, tables are created there:

CREATE TABLE public.customers (...); 
--equivalent to
 CREATE TABLE customers (...);

Custom schemas are useful for multi-tenant systems or separating concerns (e.g., sales, hr, audit):

CREATE SCHEMA sales; 
CREATE TABLE sales.invoices (...);

5. Common Commands and Examples

  --Retrieve data 
SELECT name, salary FROM employees WHERE salary > 50000; 

  --Sort and limit 
SELECT * FROM employees ORDER BY salary DESC LIMIT 5; 

  --Aggregate 
SELECT department, AVG(salary) FROM employees GROUP BY department; 

  --Filter groups 
SELECT department, COUNT(*) FROM employees 
GROUP BY department HAVING COUNT(*) > 10;

6. The CASE WHEN Statement

CASE WHEN provides conditional logic within a query, similar to if-else in programming languages.

SELECT name,  
    CASE 
        WHEN salary >= 100000 THEN 'Senior' 
        WHEN salary >= 60000 THEN 'Mid-level' 
        ELSE 'Junior' 
    END AS pay_grade 
FROM employees;

This is especially useful for creating derived categories, pivoting data, or cleaning up display values without changing the underlying data.

7. SQL Joins

A join combines rows from two or more tables based on a related column, typically a foreign key relationship.

INNER JOIN - returns only matching rows in both tables.
LEFT JOIN - returns all rows from the left table, with matched rows from the right (or NULL if no match).
RIGHT JOIN - the mirror of LEFT JOIN.
FULL OUTER JOIN - returns all rows from both tables, matched where possible.
CROSS JOIN - returns the Cartesian product of both tables

SELECT o.id, c.name 
FROM orders o 
INNER JOIN customers c ON o.customer_id = c.id; 

SELECT c.name, o.id 
FROM customers c 
LEFT JOIN orders o ON c.id = o.customer_id;

Joins are fundamental because relational databases normalize data across multiple tables to reduce redundancy, joins let you reassemble that data for meaningful queries.

8. CASCADE, DELETE, and Use Cases

ON DELETE CASCADE (and similarly ON UPDATE CASCADE) automatically propagates changes from a parent row to related child rows.

CREATE TABLE orders ( 
    id SERIAL PRIMARY KEY, 
    customer_id INT REFERENCES customers(id) ON DELETE CASCADE 
);

If a customer is deleted, all their orders are automatically deleted too. Other options include:

ON DELETE SET NULL - sets the foreign key to NULL instead of deleting
ON DELETE RESTRICT - blocks deletion if child rows exist
Use cases: CASCADE is appropriate for dependent data with no independent meaning (e.g., order line items belonging to an order). RESTRICT or SET NULL is safer when child records should be preserved or reassigned, such as employee records tied to a department.

9. Keywords, Operators, and Filtering

Filtering conditions commonly use:

Comparison operators: =, !=, <, >, <=, >=
Logical operators: AND, OR, NOT
Range filtering: BETWEEN

SELECT * FROM orders WHERE total BETWEEN 100 AND 500;

Membership filtering: IN, NOT IN

SELECT * FROM employees WHERE department IN ('Sales', 'Marketing');

Pattern matching:LIKE, ILIKE (case-insensitive)

SELECT * FROM customers WHERE name LIKE 'A%';

Null checks: IS NULL, IS NOT NULL

Mastering these filters allows precise, efficient querying without over-fetching data.

Conclusion

SQL's power comes from a relatively small set of consistent concepts, categorized commands, well-defined data types, constraints that protect integrity, and joins that let normalized data come back together meaningfully. A solid foundation in these fundamentals makes it far easier to write efficient, safe, and maintainable database code.

Python Data Structures, Strings, and File Handling

abiud kipngetich — Sat, 12 Sep 2026 10:44:32 +0000

1. Core Data Structures

Lists

Ordered, mutable collections that allow duplicates.
fruits = ["apple", "banana", "cherry"]

Slicing

Extract a sub-sequence using [start:stop:step]. Works on lists, strings, and tuples

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers[2:5])        # [2, 3, 4] 
print(numbers[:3])         # [0, 1, 2] 
print(numbers[7:])         # [7, 8, 9] 
print(numbers[::2])        # [0, 2, 4, 6, 8] 
print(numbers[::-1])       # reversed list

Dictionaries

Unordered collection of key-value pairs. Keys must be unique and immutable.

person = {"name": "Alice", "age": 30} 
print(person["name"])                 # Alice 
print(person.get("email", "N/A"))     # safe lookup with default

Tuples

Ordered, immutable collections. Once created, they can't be changed.

coordinates = (10.0, 20.0) 
x, y = coordinates       # unpacking

Sets

Unordered collections of unique elements. No duplicates, no indexing.

unique_numbers = {1, 2, 2, 3, 3, 3} 
print(unique_numbers)      # {1, 2, 3}

2. List Methods, Adding and Updating Values

nums = [1, 2, 3] 
nums.append(4)       # add to end -> [1, 2, 3, 4] 
nums.insert(0, 0)    # insert at index -> [0, 1, 2, 3, 4] 
nums.extend([5, 6])  # add multiple -> [0, 1, 2, 3, 4, 5, 6] 
nums.remove(3)       # remove by value 
popped = nums.pop()  # remove and return last item 
nums.sort()          # sort in place 
nums.reverse()       # reverse in place 

nums[0] = 99         # update by index

Dictionaries update similarly:

person = {"name": "Alice"} 
person["age"] = 30               # add a new key 
person["name"] = "Jack"          # update existing key 
person.update({"city": "Nairobi", "age": 31})    # bulk update 
del person["city"]               # remove a key

Use list for an ordered, changeable collection; a tuple for fixed data that shouldn't change (e.g., coordinates); a dictionary for labeled data accessed by key; a set when you need uniqueness or fast membership testing.

3. List Comprehension

A compact way to build a list from an iterable.

squares = [n ** 2 for n in range(10)] 
evens = [n for n in range(20) if n % 2 == 0] 
upper_names = [name.upper() for name in ["ana", "bo", "cy"]]

Dictionary and set comprehensions work the same way:

square_map = {n: n ** 2 for n in range(5)} 
unique_lengths = {len(word) for word in ["hi", "bye", "ok"]}

4. Set Operations: Intersection, Union, and Unpacking

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

print(a | b)          # union: {1, 2, 3, 4, 5, 6}
print(a.union(b)) 

print(a & b)          # intersection: {3, 4} 
print(a.intersection(b)) 

print(a - b)          # difference: {1, 2} 
print(a ^ b)          # symmetric difference: {1, 2, 5, 6}

Unpacking

Assigning multiple variables at once from an iterable, including with * to capture "the rest."

point = (1, 2, 3) 
x, y, z = point 

first, *middle, last = [1, 2, 3, 4, 5] 
print(first, middle, last)      # 1 [2, 3, 4] 5 

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

values = (1, 2, 3) 
print(add(*values))          # unpack tuple as arguments

5. isnumeric() and Type-Checking Functions

"123".isnumeric()         # True 
"12.5".isnumeric()        # False (decimal point isn't numeric) 
"abc".isnumeric()         # False 

"abc".isalpha()           # True, all are alphabetic characters 
"abc123".isalnum()        # True, letters and/or numbers only 
" ".isspace()             # True, all whitespace 
"Hello World".istitle()   # True, title-cased 
"HELLO".isupper()         # True 
"hello".islower()         # True

These are commonly used to validate user input before conversion, e.g.,if age_str.isnumeric(): age = int(age_str).

6. String Methods, Concatenation, and Repetition

greeting = "Hello" + " " + "Wendy"    # concatenation -> "Hello Wendy" 
laugh = "ha" * 3                  # repetition -> "hahaha" 

text = "Python is Fun" 
print(text.upper())               # PYTHON IS FUN 
print(text.lower())               # python is fun 
print(text.title())               # Python Is Fun

7. Standardizing Text

Before comparing or storing text, it's common to normalize its case and formatting so comparisons are consistent.

user_input = "  Hello WORLD " 
standardized = user_input.strip().lower() 
print(standardized)           # "hello world"

8. Removing Extra Spaces: strip, lstrip, rstrip

text = "  padded text  " 
print(text.strip())         # "padded text" - removes both sides 
print(text.lstrip())        # "padded text "- removes left only 
print(text.rstrip())        # " padded text"- removes right only 

# _can also strip specific characters _
print("---data---".strip("-"))   # "data"

9. Splitting Text Apart

.split() breaks a string into a list based on a separator.
.splitlines() breaks a multi-line string into a list of lines.

sentence = "the quick brown fox" 
words = sentence.split()          # ['the', 'quick', 'brown', 'fox'] 

csv_line = "a,b,c,d 
fields = csv_line.split(",")      # ['a', 'b', 'c', 'd'] 

paragraph = "line one\nline two\nline three" 
lines = paragraph.splitlines()    # ['line one', 'line two', 'line three']

10. Putting Text Back Together: .join()

.join() is the inverse of .split(), it combines a list of strings using a separator string

words = ["the", "quick", "brown", "fox"] 
sentence = " ".join(words)     # "the quick brown fox" 

fields = ["a", "b", "c"] 
csv_line = ",".join(fields)    # "a,b,c" 

lines = ["line one", "line two"]
text_block = "\n".join(lines)

11. Validation Methods: count, replace, and Checking Text Kind

text = "banana" 
print(text.count("a"))                # 3 

text2 = "I like dogs" 
print(text2.replace("dogs", "cats"))   # "I like cats" 

# checking kind of text (combines with isnumeric/isalpha etc.) 
def validate_username(name):
    if not name.isalnum(): 
        return "Username must be letters/numbers only" 
    return "Valid"

12. Prefixes, Suffixes, and Professional Formatting

filename = "report_final.pdf 
print(filename.startswith("report"))   # True 
print(filename.endswith(".pdf"))       # True

plaintext

professional formatting example

name = "john thuto" 
formatted = name.title()             # "John Thuto" 

price = 1234.5 
print(f"ksh {price:,.2f})            # "Ksh 1,234.50"

plaintext

13. File Handling

Opening and closing a file

file = open("data.txt", "r")    # modes: 'r' read, 'w' write, 'a' append, 'x' create 
content = file.read() 
file.close()       # must manually close to free the resource

plaintext
Forgetting to close a file can leak resources or leave writes unflushed, this is why the with statement is preferred.

The with statement

with automatically closes the file when the block ends, even if an error occurs.

with open("data.text", "r") as file: 
     content = file.read() 
# file is automatically closed here

plaintext

Reading from a file

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

with open("data.txt", "r") as file: 
    for line in file:                # iterate line by line 
        print(line.strip()) 

with open("data.txt", "r") as file: 
    lines = file.readlines()         # list of lines, icluding \n

plaintext

Writing to a file

with open("output.txt"z, "w") as file: 
    file.write("Hello, World!\n") 

with open("output.txt", "a") as file:    # append mode adds without erasing 
    file.write("Another line.\n")

Python Fundamentals: Variables, Control Flow, and Functions

abiud kipngetich — Fri, 11 Sep 2026 10:46:06 +0000

1. Variables and Naming Conventions

A variable is a name bound to a value in memory. Python is dynamically typed, so you don't declare a type, the type is inferred from the value assigned .
age = 25 price = 19

Snake_case

Python's official style guide (PEP 8) recommends snake_case for variable and functions names: lowercase words separated by underscores.
first_name = "Jonah" total_price = 50
Constants are typically written in ALL_CAPS:
PI = 3.14159

2. input() and f-strings

input() pauses execution and reads a line of text from the user as a string
name = input("What is your name? ") age = int(input("what is your age? "))# convert to int explicitly
f-strings(formatted string literals) let you embed expressions directly inside a string using {}

name = "Bud" 
age = 30 
print(f"{name} is {age} years old."

3. Operators and Conditionals

Operator-Meaning

== equal to
!= not equal to
>,< greater/less than
>=,<= greater/less than or equal

if, elif, else

score = 82 
if score >= 90: 
    grade = "A" 
elif score >= 80: 
    grade = "B" 
elif score >= 70: 
    grade = "C" 
else:
    grade = "F" 
print(grade)    #  B

Logical operators

and, or, not combine or invert boolean conditions.

temperature = 55 
is_sunny = True 
if temperature > 50 and is_sunny: 
    print("Great beach day") 
if temperature < 30 or temperature > 70: 
    print("Extreme weather") 
if not is_sunny: 
    print("Bring an umbrella")

4. Loops

for loop

Iterates over a sequence (list, string, range, etc.)

fruits = ["apple", "banana", "cherry"] 
for fruit in fruits: 
    print(fruit)

range()

Generates a sequence of numbers, commonly used with for.

for i in range(5):     # 0, 1, 2, 3, 4
    print(i) 
for i in range(2,10,2):     # _start, stop, step -> 2,4,6,8_
    print(i)

while loop

Repeats as long as a condition is true.

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

while True

An infinite loop that must be broken out of explicitly, useful for menus or input validation.

while True: 
    answer = input("Type 'quit' to exit: " 
    if answer == "quit": 
        break

Accumulators

A pattern where a variable collects a running total or result across loop iterations.

total = 0 
for number in [10, 20, 30]: 
    total += number 
print(total)    # 60 

# Accumulating into a list 
squares = [] 
for n in range(5): 
    squares.append(n ** 2) 
print(squares)    # [0, 1, 4, 9, 16]

5. break and continue

break exits the loop immediately.
continue skips to the next iteration.

for n in range(10): 
    if n == 5: 
        break     # stop entirely once n hits 5 
    print(n) 
for n in range (10): 
    if n % 2 == 0: 
        continue      # skip even numbers 
    print(n)

6. enumerate()

Gives you both the index and the value while looping, cleaner than manually tracking a counter.

colors = ["red", "green", "blue"] 
for index, color in enumerate(colors): 
    print(index, color) 
# 0 red 
# 1 green 
# 2 blue 

for index, color in enumerate(colors, start=1): 
    print(f"{index}. {color}")

7. Functions and return

Functions bundle reusable logic under a name.
return sends a value back to the caller and ends the function.

def square(x): 
    return x ** 2 
result = square(4)v 
print(result)           # 16 

def greet(name): 
    return f"Hello, {name}!" 

def add_and_multiply(a,b, factor): 
    total = (a + b) * factor 
    return total

Afunction without an explicit return returns None

8. Parameters, Arguments, and Scope

Parameters are the names listed in a function's definition. Arguments are the actual values passed in when calling it.

def introduce(name, age):     # name, age are parameters 
    print(f"{name} is {age}") 

introduce("Sam", 22)          # "Sam", 22 are arguments

Functions can have default parameter values and keyword arguments:

def power(base, exponent=2): 
    return base ** exponent 

print(power(5))        # 25 (uses default exponent)
print(power(5, 3))     # 125 
print(power(base=2, exponent=10))     # 1024

Local vs global variables

A local variable is defined inside a function and only exists there. A global variable is defined at the top level of a script and accessible everywhere (read access by default).

counter = 0    # global variable 
def increment(): 
    local_value = 1      # local variable, disappears after the function runs
    print(local_value) 

increment() 
# print(local_value)   # Error: local_value doesn't exist here 

def modify_global() 
    global counter     # explicitly declare intent to modify the global 

modify_global() 
print(counter)     # 1

Without the global keyword, assigning to a variable inside a function creates a new local variable instead of modifying the outer one.

Power BI Dashboard on Sales & Performance Logistics

abiud kipngetich — Wed, 08 Jul 2026 16:38:45 +0000

I recently built a Power BI dashboard analyzing sales and delivery performance for a car logistics company as part of a class project. It covers revenue by branch, sales rep performance, payment methods, and delivery status tracking: Check it out here

DEV Community: abiud kipngetich

Mastering Object-Oriented Programming in Python: Classes, Pillars, and Robust Error Handling

1. Introduction

Using libraries and randint()

2. Classes and Objects

3. Class Attributes vs. Instance Attributes

4. Methods

5. Parent and Child Classes

6. The Four Pillars of OOP

7. Types of Python Errors

8. Error Handling with try/except

9. Common Python Exceptions

Conclusion

Understanding SQL: A Practical Guide to Categories, Data Types, Joins, and Core Concepts

1. SQL Categories

DDL (Data Definition Language) - defines and modifies database structure.

DML (Data Manipulation Language) - manages the actual data

DCL (Data Control Language) - controls access and permissions

TCL (Transaction Control Language) - manages transactions

2. Data Types

Category------Examples

3. Constraints and Defaults

4. Schemas and the public Schema

5. Common Commands and Examples

6. The CASE WHEN Statement

7. SQL Joins

8. CASCADE, DELETE, and Use Cases

9. Keywords, Operators, and Filtering

Conclusion

Python Data Structures, Strings, and File Handling

1. Core Data Structures

Lists

Slicing

Dictionaries

Tuples

Sets

2. List Methods, Adding and Updating Values

3. List Comprehension

4. Set Operations: Intersection, Union, and Unpacking

Unpacking

5. isnumeric() and Type-Checking Functions

6. String Methods, Concatenation, and Repetition

7. Standardizing Text

8. Removing Extra Spaces: strip, lstrip, rstrip

9. Splitting Text Apart

10. Putting Text Back Together: .join()

11. Validation Methods: count, replace, and Checking Text Kind

12. Prefixes, Suffixes, and Professional Formatting

professional formatting example

13. File Handling

Opening and closing a file

The with statement

Reading from a file

Writing to a file

Python Fundamentals: Variables, Control Flow, and Functions

1. Variables and Naming Conventions

Snake_case

2. input() and f-strings

3. Operators and Conditionals

Operator-Meaning

if, elif, else

Logical operators

4. Loops

for loop

range()

while loop

while True

Accumulators

5. break and continue

6. enumerate()

7. Functions and return

8. Parameters, Arguments, and Scope

Local vs global variables

Power BI Dashboard on Sales & Performance Logistics

Using libraries and `randint()`

8. Error Handling with `try`/`except`

4. Schemas and the `public` Schema