Python Foundations: Complete Visual Guide

🗺️ Concept Map: Python Foundations Journey

💻 1.1 Google Colab & Python Setup

Getting Started Steps

Essential Keyboard Shortcuts

# Your very first Python code in Colab
print("Hello, World!")  # Output: Hello, World!

# Python is case-sensitive!
Name = "Alice"
name = "Bob"
print(Name)  # Alice
print(name)  # Bob  — these are DIFFERENT variables

# Comments: # for single-line, triple quotes for multi-line
'''
This is a multi-line comment.
It can span several lines.
Useful for documentation.
'''

🔤 1.2 Variables & Data Types

Python Data Types

# Variable assignment — no type declaration needed
age = 25             # int
height = 5.9          # float
name = "Vamshi"       # str
is_student = True     # bool

# Check types
print(type(age))       # <class 'int'>
print(type(height))    # <class 'float'>

# Type conversion
age_str = str(age)     # "25" — now a string
price = float("19.99") # 19.99 — string to float

# Common mistake: concatenating str + int (FAQ #14)
count = 5
# print("I have " + count + " apples")  # TypeError!
print("I have " + str(count) + " apples")  # Fixed!
print(f"I have {count} apples")  # Better: f-string

# Comparison operators (FAQ #4)
print(10 == 10)   # True  (equal to)
print(10 != 5)    # True  (not equal)
print(10 > 5)     # True  (greater than)
print(10 >= 10)   # True  (greater or equal)
print(10 < 20)    # True  (less than)

# Floor division (FAQ #15)
print(9 // 5)     # 1 (not 1.8)
print(9 / 5)      # 1.8 (regular division)
print(9 % 5)      # 4 (modulo — remainder)

📦 1.3 Data Structures: Lists, Tuples, Dictionaries

Comparison: List vs Tuple vs Dictionary (FAQ #5)

# ============ LISTS ============
fruits = ["apple", "banana", "cherry"]
print(fruits[0])      # "apple" — indexing starts at 0
print(fruits[-1])     # "cherry" — negative index = from end

fruits.append("date")   # Add to end: ["apple","banana","cherry","date"]
fruits.remove("banana") # Remove by value
fruits.insert(1, "fig") # Insert at index 1
print(len(fruits))     # 3 — number of items

# Slicing: list[start:stop:step]
nums = [0, 1, 2, 3, 4, 5]
print(nums[1:4])     # [1, 2, 3] — start inclusive, stop exclusive
print(nums[:3])      # [0, 1, 2] — from beginning
print(nums[3:])      # [3, 4, 5] — to end
print(nums[::2])     # [0, 2, 4] — every 2nd element

# ============ TUPLES ============
coords = (10.5, 20.3)
print(coords[0])     # 10.5
# coords[0] = 99      # TypeError! Tuples are immutable

# ============ DICTIONARIES ============
student = {
    "name": "Vamshi",
    "age": 25,
    "courses": ["Python", "ML"]
}
print(student["name"])     # "Vamshi" — access by key (FAQ #7)
student["grade"] = "A"    # Add new key-value pair
print(student.keys())     # dict_keys(['name', 'age', 'courses', 'grade'])
print(student.values())   # dict_values(['Vamshi', 25, ['Python', 'ML'], 'A'])

Common List Methods

🔀 1.4 Control Flow: Conditionals & Loops

# ============ CONDITIONALS ============
score = 85

if score >= 90:
    print("Grade: A")
elif score >= 80:
    print("Grade: B")    # This runs! score=85 >= 80
elif score >= 70:
    print("Grade: C")
else:
    print("Grade: F")

# Logical operators: and, or, not
age = 25
has_license = True
if age >= 18 and has_license:
    print("Can drive")

# ============ FOR LOOP ============
# Iterate over a list
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(f"I like {fruit}")

# Using range(): range(start, stop, step) — FAQ #13
for i in range(0, 10, 2):   # 0, 2, 4, 6, 8
    print(i, end=" ")

# Nested loop with enumerate
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")   # 0: apple, 1: banana, 2: cherry

# ============ WHILE LOOP ============
count = 0
while count < 5:       # FAQ #12: runs while condition is True
    print(count)
    count += 1         # Don't forget this! Otherwise infinite loop

# break and continue
for i in range(10):
    if i == 3: continue   # Skip 3
    if i == 7: break      # Stop at 7
    print(i, end=" ")       # Output: 0 1 2 4 5 6

For Loop vs While Loop

⚙️ 1.5 Functions & List Comprehension

# ============ DEFINING FUNCTIONS ============
def greet(name):
    """Greet a person by name."""
    return f"Hello, {name}!"

print(greet("Vamshi"))   # "Hello, Vamshi!"

# Default parameters
def power(base, exp=2):
    return base ** exp

print(power(3))       # 9 (uses default exp=2)
print(power(3, 3))    # 27 (exp=3)

# Multiple return values
def min_max(numbers):
    return min(numbers), max(numbers)

lo, hi = min_max([4, 2, 9, 1])
print(f"Min: {lo}, Max: {hi}")  # Min: 1, Max: 9

# ============ LAMBDA FUNCTIONS ============
double = lambda x: x * 2
print(double(5))     # 10

# Lambda with sorted
students = [("Alice", 85), ("Bob", 92), ("Charlie", 78)]
by_score = sorted(students, key=lambda s: s[1], reverse=True)
# [('Bob', 92), ('Alice', 85), ('Charlie', 78)]

# ============ LIST COMPREHENSION ============
# Instead of:
squares = []
for x in range(10):
    squares.append(x**2)

# Write this:
squares = [x**2 for x in range(10)]
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# With condition: only even squares
even_sq = [x**2 for x in range(10) if x % 2 == 0]
# [0, 4, 16, 36, 64]

# Nested: flatten 2D list
flat = [n for row in [[1,2],[3,4]] for n in row]  # [1,2,3,4]

🔢 2.1 NumPy: Numerical Computing

NumPy vs Python Lists

import numpy as np

# Creating arrays
arr = np.array([1, 2, 3, 4, 5])
zeros = np.zeros((3, 4))        # 3x4 matrix of zeros
ones = np.ones((2, 3))          # 2x3 matrix of ones
rng = np.arange(0, 10, 2)      # [0, 2, 4, 6, 8]
lin = np.linspace(0, 1, 5)     # [0, 0.25, 0.5, 0.75, 1.0]

# Array properties
print(arr.shape)     # (5,) — dimensions
print(arr.dtype)     # int64 — data type
print(arr.ndim)      # 1 — number of dimensions

# Vectorized operations — no loops needed!
print(arr * 2)       # [2, 4, 6, 8, 10]
print(arr ** 2)      # [1, 4, 9, 16, 25]
print(np.sqrt(arr))  # [1.0, 1.41, 1.73, 2.0, 2.24]

# Statistical functions
print(arr.mean())    # 3.0
print(arr.std())     # 1.414
print(arr.sum())     # 15
print(arr.min())     # 1
print(arr.max())     # 5

# Indexing and slicing (same as lists)
matrix = np.array([[1,2,3], [4,5,6], [7,8,9]])
print(matrix[0, 1])    # 2 (row 0, col 1)
print(matrix[:2, 1:])  # [[2,3],[5,6]] — first 2 rows, cols 1+

# Boolean indexing
print(arr[arr > 3])    # [4, 5] — filter elements

# Reshape
reshaped = np.arange(12).reshape(3, 4)  # 3 rows, 4 cols

🐼 2.2 Pandas: Data Manipulation

import pandas as pd

# Creating a DataFrame from a dictionary
data = {
    "Name": ["Alice", "Bob", "Charlie", "Diana"],
    "Age": [25, 30, 35, 28],
    "Salary": [50000, 60000, 75000, 55000]
}
df = pd.DataFrame(data)

# Reading from a CSV file
df = pd.read_csv("employees.csv")

# First look at data — the essential 5
print(df.head())        # First 5 rows
print(df.tail())        # Last 5 rows
print(df.shape)         # (rows, columns)
print(df.info())        # Column types, non-null counts
print(df.describe())    # Summary statistics

# Selecting columns
print(df["Name"])       # Single column → Series
print(df[["Name", "Age"]])  # Multiple columns → DataFrame

# Selecting rows: loc (label-based) vs iloc (integer-based)
print(df.loc[0])          # First row by label
print(df.iloc[0:3])      # First 3 rows by position

# Boolean indexing — filtering
seniors = df[df["Age"] > 30]
high_earners = df[(df["Salary"] > 55000) & (df["Age"] < 35)]

# Sorting
df_sorted = df.sort_values("Salary", ascending=False)

# Groupby — split-apply-combine
dept_avg = df.groupby("Department")["Salary"].mean()

# Adding new columns
df["Bonus"] = df["Salary"] * 0.1

# Apply custom function
df["Category"] = df["Age"].apply(lambda x: "Senior" if x > 30 else "Junior")

Essential Pandas Methods

🧹 2.3 Data Cleaning & Preparation

import pandas as pd
import numpy as np

# ============ MISSING VALUES ============
# Detect missing values
print(df.isnull().sum())         # Count NaN per column
print(df.isnull().sum() / len(df) * 100)  # Percentage missing

# Strategy 1: Drop rows with any NaN
df_clean = df.dropna()

# Strategy 2: Drop columns with too many NaN
df_clean = df.dropna(axis=1, thresh=len(df)*0.5)  # Keep cols with >50% data

# Strategy 3: Fill missing values
df["Age"].fillna(df["Age"].mean(), inplace=True)   # Fill with mean
df["City"].fillna("Unknown", inplace=True)     # Fill with constant
df["Score"].fillna(df["Score"].median(), inplace=True)  # Median for skewed data

# ============ DUPLICATES ============
print(df.duplicated().sum())     # Count duplicate rows
df_clean = df.drop_duplicates()   # Remove duplicates

# ============ TYPE CONVERSION ============
df["Date"] = pd.to_datetime(df["Date"])
df["Price"] = pd.to_numeric(df["Price"], errors="coerce")

# ============ STRING CLEANING ============
df["Name"] = df["Name"].str.strip()     # Remove whitespace
df["Name"] = df["Name"].str.lower()    # Lowercase
df["Email"] = df["Email"].str.replace("@old.com", "@new.com")

# ============ MERGING DATASETS ============
merged = pd.merge(df1, df2, on="CustomerID", how="left")
stacked = pd.concat([df_2023, df_2024], ignore_index=True)

Missing Value Strategy Decision Guide

📊 3.1 Data Visualization

Chart Selection Guide

import matplotlib.pyplot as plt
import seaborn as sns

# ============ MATPLOTLIB BASICS ============
# Simple line plot
fig, ax = plt.subplots(figsize=(10, 6))
ax.plot([1,2,3,4], [10,20,25,30], marker='o')
ax.set_xlabel("Quarter")
ax.set_ylabel("Revenue ($K)")
ax.set_title("Quarterly Revenue")
plt.show()

# Multiple subplots
fig, axes = plt.subplots(1, 3, figsize=(15, 5))
axes[0].hist(df["Age"], bins=20)
axes[1].scatter(df["Age"], df["Salary"])
axes[2].boxplot(df["Salary"])
plt.tight_layout()
plt.show()

# ============ SEABORN ============
# Distribution plot
sns.histplot(df["Age"], kde=True, bins=20)

# Correlation heatmap
plt.figure(figsize=(10, 8))
sns.heatmap(df.corr(), annot=True, cmap="coolwarm", vmin=-1, vmax=1)

# Box plot for comparing groups
sns.boxplot(x="Department", y="Salary", data=df)

# Pair plot — all relationships at once
sns.pairplot(df, hue="Category")

🔍 3.2 EDA Techniques & Statistics

EDA Checklist

Statistical Measures Quick Reference

# Outlier detection using IQR method
Q1 = df["Salary"].quantile(0.25)
Q3 = df["Salary"].quantile(0.75)
IQR = Q3 - Q1

lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR

# Filter outliers
outliers = df[(df["Salary"] < lower_bound) | (df["Salary"] > upper_bound)]
print(f"Found {len(outliers)} outliers")

# Correlation matrix
corr_matrix = df.corr()
print(corr_matrix)

📝 4.1 Analyzing Text Data

import re

# ============ STRING METHODS ============
text = "  Hello, World! Welcome to Python.  "

print(text.strip())       # Remove leading/trailing whitespace
print(text.lower())       # "  hello, world! welcome to python.  "
print(text.upper())       # "  HELLO, WORLD! WELCOME TO PYTHON.  "
print(text.replace("World", "Data Science"))
print(text.split())        # Split by whitespace → list of words
print(", ".join(["a", "b", "c"]))  # "a, b, c"

# ============ REGULAR EXPRESSIONS ============
text = "Contact us at [email protected] or call 555-123-4567"

# Find all email addresses
emails = re.findall(r'[\w.]+@[\w.]+', text)
print(emails)  # ['[email protected]']

# Find all phone numbers
phones = re.findall(r'\d{3}-\d{3}-\d{4}', text)
print(phones)  # ['555-123-4567']

# Search for a pattern
match = re.search(r'\d+', "Order #12345")
print(match.group())  # "12345"

# ============ WORD FREQUENCY ============
from collections import Counter

text = "the cat sat on the mat the cat likes the mat"
words = text.lower().split()
freq = Counter(words)
print(freq.most_common(3))
# [('the', 4), ('cat', 2), ('mat', 2)]

# Remove stop words
stop_words = {"the", "on", "a", "an", "is", "in"}
filtered = [w for w in words if w not in stop_words]
print(Counter(filtered).most_common(3))
# [('cat', 2), ('mat', 2), ('sat', 1)]

Common Regex Patterns

⚠️ Common Mistakes & Misconceptions

Week 1: Python Basics

Week 2: Data Manipulation

Week 3: EDA & Visualization