Beginner

import pandas as pd  # => pandas 3.0.2 — major breaking changes from 2.x
 
# Read CSV with numpy_nullable backend for proper NA handling
# dtype_backend="numpy_nullable" uses pd.NA instead of np.nan for missing values
df = pd.read_csv(
    "sales.csv",              # => path to CSV file
    dtype_backend="numpy_nullable",  # => use nullable dtypes (Int64, Float64, StringDtype)
)
 
# Alternatively, use pyarrow backend for 2-5x memory reduction
# df = pd.read_csv("sales.csv", dtype_backend="pyarrow")
 
print(df.head(3))   # => prints first 3 rows as a formatted table
print(df.shape)     # => (1000, 8) — 1000 rows and 8 columns
print(df.dtypes)    # => shows dtype per column: Int64, Float64, string, etc.

import pandas as pd       # => pandas 3.0.2
 
# Create a sample DataFrame for demonstration
data = {
    "name": ["Alice", "Bob", "Charlie", "Diana", None],  # => one missing name
    "age": [25, 32, None, 41, 28],                        # => one missing age
    "salary": [55000.0, 72000.0, 60000.0, 85000.0, 48000.0],
    "department": ["Engineering", "Marketing", "Engineering", "Finance", "Marketing"],
}
df = pd.DataFrame(data)   # => DataFrame with 5 rows, 4 columns
 
# === Basic shape and column info ===
print(df.shape)       # => (5, 4) — rows, columns as tuple
print(df.columns)     # => Index(['name', 'age', 'salary', 'department'], dtype='object')
print(df.dtypes)      # => name: object, age: float64, salary: float64, department: object
 
# === Summary info: non-null counts + dtypes ===
df.info()
# => <class 'pandas.core.frame.DataFrame'>
# => RangeIndex: 5 entries, 0 to 4
# => Data columns (total 4 columns):
# =>  #   Column      Non-Null Count  Dtype
# => ---  ------      --------------  -----
# =>  0   name        4 non-null      object
# =>  1   age         4 non-null      float64
# =>  2   salary      5 non-null      float64
# =>  3   department  5 non-null      object
 
# === Statistical summary for numeric columns ===
print(df.describe())
# => shows count, mean, std, min, 25%, 50%, 75%, max for age and salary
 
# === First and last rows ===
print(df.head(2))  # => first 2 rows
print(df.tail(2))  # => last 2 rows

import pandas as pd       # => pandas 3.0.2
 
df = pd.DataFrame({
    "name": ["Alice", "Bob", "Charlie"],
    "age": [25, 32, 41],
    "salary": [55000, 72000, 85000],
})
 
# === Single column selection — returns Series ===
ages = df["age"]          # => Series with index [0,1,2], values [25, 32, 41]
print(type(ages))         # => <class 'pandas.core.series.Series'>
 
# === Multiple column selection — returns DataFrame ===
subset = df[["name", "salary"]]   # => DataFrame with 2 columns only
print(subset.shape)               # => (3, 2)
 
# === Label-based row selection with .loc ===
# .loc[row_label, col_label] — inclusive on both ends
row0 = df.loc[0]                  # => Series: name=Alice, age=25, salary=55000
row_range = df.loc[0:1, "name"]   # => Series: ['Alice', 'Bob'] (0 and 1 included)
 
# === Position-based selection with .iloc ===
# .iloc[row_pos, col_pos] — exclusive upper bound (like Python slices)
first_two_rows = df.iloc[0:2]     # => rows 0 and 1 only (row 2 excluded)
cell = df.iloc[1, 2]              # => 72000 — row index 1, col index 2
 
# === Combined: specific rows AND specific columns ===
result = df.loc[0:1, ["name", "age"]]
# => DataFrame: Alice/25, Bob/32 — 2 rows, 2 columns
print(result)

import pandas as pd           # => pandas 3.0.2 — CoW is now enforced
 
df = pd.DataFrame({
    "age": [25, 32, 41, 28],
    "salary": [55000, 72000, 85000, 48000],
    "department": ["Eng", "Mkt", "Eng", "Fin"],
})
 
# === WRONG: ChainedAssignment — raises error in pandas 3.0.2 ===
# df[df["age"] > 30]["salary"] = 99999
# => ChainedAssignmentError: behavior is undefined, CoW means the filtered
# => DataFrame may be a copy, so assignment has no effect on original
 
# === CORRECT: Use df.loc for conditional assignment ===
mask = df["age"] > 30                      # => boolean Series [False, True, True, False]
df.loc[mask, "salary"] = 99999             # => modifies original DataFrame in-place
print(df["salary"].tolist())               # => [55000, 99999, 99999, 48000]
 
# === CORRECT: Assign new column from expression ===
df["salary_k"] = df["salary"] / 1000      # => new column is fine — no chaining
print(df["salary_k"].tolist())            # => [55.0, 99.999, 99.999, 48.0]
 
# === CORRECT: df.assign() for method chaining — returns new DataFrame ===
df2 = df.assign(bonus=df["salary"] * 0.1)  # => new DataFrame, df unchanged
print(df2["bonus"].tolist())               # => [5500.0, 9999.9, 9999.9, 4800.0]

import pandas as pd      # => pandas 3.0.2
 
df = pd.DataFrame({
    "name": ["Alice", "Bob", "Charlie", "Diana", "Eve"],
    "age": [25, 32, 41, 28, 35],
    "salary": [55000, 72000, 85000, 48000, 67000],
    "department": ["Eng", "Mkt", "Eng", "Fin", "Mkt"],
})
 
# === Single condition filter ===
seniors = df[df["age"] > 30]           # => 3 rows: Bob(32), Charlie(41), Eve(35)
print(seniors.shape)                   # => (3, 4)
 
# === Multiple conditions with & (AND) — parentheses required ===
eng_seniors = df[(df["age"] > 30) & (df["department"] == "Eng")]
# => 1 row: Charlie — must be BOTH conditions true
print(eng_seniors["name"].tolist())    # => ['Charlie']
 
# === Multiple conditions with | (OR) ===
high_or_young = df[(df["salary"] > 70000) | (df["age"] < 27)]
# => 3 rows: Alice(age<27), Bob(salary>70k), Charlie(salary>70k)
print(high_or_young.shape)             # => (3, 4)
 
# === Negation with ~ ===
not_marketing = df[~(df["department"] == "Mkt")]
# => 3 rows: Alice, Charlie, Diana — excludes Marketing employees
print(not_marketing["department"].tolist())  # => ['Eng', 'Eng', 'Fin']
 
# === Using .isin() for multiple value membership ===
tech_depts = df[df["department"].isin(["Eng", "Fin"])]
# => 3 rows: Alice, Charlie, Diana
print(tech_depts.shape)                # => (3, 4)
 
# === String contains filter ===
# df[df["name"].str.contains("a", case=False)]  => Alice, Charlie, Diana

import pandas as pd    # => pandas 3.0.2
import numpy as np     # => numpy 2.4.4
 
df = pd.DataFrame({
    "name": ["Alice", None, "Charlie", "Diana"],
    "age": [25, 32, np.nan, 41],           # => np.nan for float missing values
    "score": [88.5, 92.0, None, 77.3],
    "grade": ["A", "A", "B", None],
})
 
# === Detect missing values ===
print(df.isnull())      # => boolean DataFrame — True where value is NaN/None/NA
print(df.isna().sum())  # => Series: name=1, age=1, score=1, grade=1 (count per column)
print(df.isnull().sum().sum())  # => 4 — total missing cells in entire DataFrame
 
# === Which rows have any missing value ===
has_null = df[df.isnull().any(axis=1)]   # => all 4 rows (each has one null)
print(has_null.shape)                     # => (4, 4)
 
# === Drop rows with ANY missing value ===
df_clean = df.dropna()               # => 0 rows remain (every row has at least one null)
print(df_clean.shape)                # => (0, 4)
 
# === Drop rows only if specific column is null ===
df_name_ok = df.dropna(subset=["name"])   # => 3 rows: Alice, Charlie, Diana
print(df_name_ok.shape)                    # => (3, 4) — row with None name dropped
 
# === Fill missing values with a constant ===
df_filled = df.fillna({"age": 0, "score": df["score"].mean(), "grade": "Unknown"})
# => age NaN -> 0, score None -> mean(88.5, 92.0, 77.3)=85.93, grade None -> Unknown
print(df_filled["age"].tolist())      # => [25.0, 32.0, 0.0, 41.0]
print(df_filled["grade"].tolist())    # => ['A', 'A', 'B', 'Unknown']
 
# === Forward fill (propagate last valid value forward) ===
df_ffill = df[["score"]].ffill()
# => score column: 88.5, 92.0, 92.0 (filled from 92.0), 77.3
print(df_ffill["score"].tolist())     # => [88.5, 92.0, 92.0, 77.3]

import pandas as pd       # => pandas 3.0.2
 
df = pd.DataFrame({
    "id": ["001", "002", "003", "004"],    # => stored as string/object
    "revenue": ["1200.5", "850.0", "invalid", "2100.0"],  # => mixed — has non-numeric
    "count": [10, 20, 30, 40],             # => int64 by default
    "flag": [1, 0, 1, 0],                  # => int64, but conceptually boolean
})
 
print(df.dtypes)
# => id: object, revenue: object, count: int64, flag: int64
 
# === Convert integer column to boolean ===
df["flag"] = df["flag"].astype(bool)      # => True/False values
print(df["flag"].dtype)                   # => bool
print(df["flag"].tolist())                # => [True, False, True, False]
 
# === Convert string column to float with error handling ===
# astype(float) raises ValueError if non-numeric strings exist
# Use pd.to_numeric with errors="coerce" to replace invalid values with NaN
df["revenue_num"] = pd.to_numeric(df["revenue"], errors="coerce")
# => "1200.5" -> 1200.5, "850.0" -> 850.0, "invalid" -> NaN, "2100.0" -> 2100.0
print(df["revenue_num"].tolist())         # => [1200.5, 850.0, nan, 2100.0]
print(df["revenue_num"].isna().sum())     # => 1 — one coercion failure
 
# === Explicit StringDtype for string columns (pandas 3.0.2) ===
df["id"] = df["id"].astype(pd.StringDtype())
# => id column now uses pd.StringDtype() not object
print(df["id"].dtype)                     # => string[python] or StringDtype()
 
# === Convert int to Int64 (nullable integer) ===
df["count"] = df["count"].astype("Int64")
# => Int64 supports pd.NA for missing values; int64 uses np.nan (forces float)
print(df["count"].dtype)                  # => Int64 (capital I — nullable)

import pandas as pd         # => pandas 3.0.2
 
df = pd.DataFrame({
    "name": ["Charlie", "Alice", "Bob", "Diana", "Eve"],
    "department": ["Eng", "Mkt", "Eng", "Fin", "Eng"],
    "salary": [85000, 55000, 72000, 48000, 72000],
    "years": [8, 3, 5, 2, 5],
})
 
# === Sort by single column, descending ===
by_salary = df.sort_values("salary", ascending=False)
# => Charlie(85k), Bob(72k), Eve(72k), Alice(55k), Diana(48k)
print(by_salary["name"].tolist())    # => ['Charlie', 'Bob', 'Eve', 'Alice', 'Diana']
 
# === Sort by multiple columns — salary desc, then name asc for ties ===
multi_sort = df.sort_values(
    ["salary", "name"],              # => sort by salary first, then name for ties
    ascending=[False, True],         # => salary desc, name asc
)
# => Charlie(85k), Bob(72k) < Eve(72k) by name, Alice(55k), Diana(48k)
print(multi_sort["name"].tolist())   # => ['Charlie', 'Bob', 'Eve', 'Alice', 'Diana']
 
# === Sort and reset index so iloc matches sorted order ===
sorted_df = df.sort_values("salary", ascending=False).reset_index(drop=True)
# => drop=True prevents old index from becoming a column
print(sorted_df.index.tolist())      # => [0, 1, 2, 3, 4] — fresh sequential index
 
# === Sort with NaN handling — na_position controls where NaNs go ===
import numpy as np              # => numpy 2.4.4
df_with_nan = df.copy()
df_with_nan.loc[2, "salary"] = np.nan  # => introduce one missing salary
sorted_nan = df_with_nan.sort_values("salary", na_position="last")
# => NaN rows sorted to end by default (na_position="last")
print(sorted_nan["salary"].tolist())   # => [48000, 55000, 72000, 85000, nan]

import pandas as pd     # => pandas 3.0.2
 
df = pd.DataFrame({
    "name": ["Alice", "Bob", "Charlie"],
    "salary": [55000, 72000, 85000],
    "years": [3, 5, 8],
})
 
# === Add new column by direct assignment ===
df["monthly"] = df["salary"] / 12      # => new column from existing column
# => [4583.33, 6000.0, 7083.33]
print(df["monthly"].round(2).tolist()) # => [4583.33, 6000.0, 7083.33]
 
# === Add column conditionally using numpy where ===
import numpy as np                      # => numpy 2.4.4
df["level"] = np.where(
    df["years"] >= 5,                   # => condition: 5+ years
    "Senior",                           # => value if True
    "Junior",                           # => value if False
)
print(df["level"].tolist())             # => ['Junior', 'Senior', 'Senior']
 
# === df.assign() — immutable chaining, returns new DataFrame ===
df_extended = (
    df.assign(
        annual_bonus=df["salary"] * 0.1,    # => 10% bonus
        total_comp=lambda d: d["salary"] + d["annual_bonus"],  # => uses new column
    )
)
print(df_extended["total_comp"].tolist()) # => [60500.0, 79200.0, 93500.0]
 
# === Remove column with drop() — original unchanged unless inplace=True ===
df_no_monthly = df.drop(columns=["monthly"])      # => new DataFrame without monthly
print(df_no_monthly.columns.tolist())             # => ['name', 'salary', 'years', 'level']
print("monthly" in df.columns)                    # => True — df still has monthly column
 
# === Remove multiple columns at once ===
df_minimal = df.drop(columns=["monthly", "level"])
print(df_minimal.columns.tolist())                # => ['name', 'salary', 'years']

import pandas as pd       # => pandas 3.0.2
# NOTE: pandas uses "groupby" (one word, no space)
# polars uses "group_by" (two words with underscore) — different API!
 
df = pd.DataFrame({
    "department": ["Eng", "Mkt", "Eng", "Fin", "Mkt", "Eng"],
    "name": ["Alice", "Bob", "Charlie", "Diana", "Eve", "Frank"],
    "salary": [55000, 72000, 85000, 48000, 67000, 71000],
    "years": [3, 5, 8, 2, 4, 6],
})
 
# === Single aggregation per group ===
dept_avg = df.groupby("department")["salary"].mean()
# => department
# => Eng    70333.33
# => Fin    48000.00
# => Mkt    69500.00
print(dept_avg)
 
# === Multiple aggregations at once ===
dept_stats = df.groupby("department")["salary"].agg(["mean", "min", "max", "count"])
# => mean, min, max, count columns per department group
print(dept_stats)
 
# === Aggregate different columns with different functions ===
result = df.groupby("department").agg(
    avg_salary=("salary", "mean"),   # => named aggregation syntax (pandas 0.25+)
    max_years=("years", "max"),
    headcount=("name", "count"),
)
# => avg_salary, max_years, headcount columns indexed by department
print(result)
 
# === Group by multiple columns ===
# df.groupby(["department", "level"])["salary"].mean()
 
# === Reset index to get flat DataFrame ===
flat = dept_avg.reset_index()   # => two-column DataFrame: department, salary
print(flat.columns.tolist())    # => ['department', 'salary']

import pandas as pd       # => pandas 3.0.2
 
df = pd.DataFrame({
    "Dept Name": ["Engineering", "Marketing", "Finance"],
    "Avg Salary $": [72000, 65000, 58000],
    "HC": [45, 20, 15],
})
 
# === Rename columns with a dictionary mapping ===
df_renamed = df.rename(columns={
    "Dept Name": "department",     # => spaces replaced, lowercase
    "Avg Salary $": "avg_salary",  # => remove special characters
    "HC": "headcount",             # => expand abbreviation
})
print(df_renamed.columns.tolist())  # => ['department', 'avg_salary', 'headcount']
 
# === Lowercase all column names programmatically ===
df.columns = df.columns.str.lower().str.replace(" ", "_").str.replace("$", "")
# => 'dept_name', 'avg_salary_', 'hc'
print(df.columns.tolist())
 
# === set_index — make a column the row index ===
df2 = pd.DataFrame({
    "id": [101, 102, 103],
    "name": ["Alice", "Bob", "Charlie"],
    "score": [88, 92, 77],
})
df_indexed = df2.set_index("id")    # => id becomes row label
# => df_indexed.loc[101] returns Alice's row
print(df_indexed.loc[101]["name"]) # => 'Alice'
 
# === reset_index — move index back to a column ===
df_flat = df_indexed.reset_index()       # => id returns as regular column
print(df_flat.columns.tolist())          # => ['id', 'name', 'score']
print(df_flat.index.tolist())            # => [0, 1, 2] — default integer index
 
# === Reindex to add/remove rows by label, fills missing with NaN ===
df_reindexed = df2.set_index("id").reindex([101, 102, 103, 104])
# => row 104 added with NaN values since it doesn't exist
print(df_reindexed.loc[104]["name"])     # => NaN

import pandas as pd       # => pandas 3.0.2
 
employees = pd.DataFrame({
    "emp_id": [1, 2, 3, 4],
    "name": ["Alice", "Bob", "Charlie", "Diana"],
    "dept_id": [10, 20, 10, 30],   # => Diana's dept 30 has no match in departments
})
 
departments = pd.DataFrame({
    "dept_id": [10, 20, 40],       # => dept 40 has no employees
    "dept_name": ["Engineering", "Marketing", "Legal"],
})
 
# === inner join — only rows with matching keys in BOTH DataFrames ===
inner = pd.merge(employees, departments, on="dept_id", how="inner")
# => 3 rows: Alice/Eng, Bob/Mkt, Charlie/Eng — Diana(dept 30) dropped
print(inner.shape)                           # => (3, 4)
 
# === left join — ALL left rows + matching right (NaN if no right match) ===
left = pd.merge(employees, departments, on="dept_id", how="left")
# => 4 rows: Alice/Eng, Bob/Mkt, Charlie/Eng, Diana/NaN (dept 30 missing)
print(left.shape)                            # => (4, 4)
print(left["dept_name"].isna().sum())        # => 1 — Diana has NaN dept_name
 
# === outer join — ALL rows from both, NaN where no match ===
outer = pd.merge(employees, departments, on="dept_id", how="outer")
# => 5 rows: 4 employee rows + 1 Legal(dept 40) row with NaN employees
print(outer.shape)                           # => (5, 4)
 
# === Merge on different column names in each DataFrame ===
# pd.merge(left, right, left_on="emp_dept", right_on="dept_id")
 
# === Merge on index ===
# pd.merge(left, right, left_index=True, right_index=True)

import pandas as pd       # => pandas 3.0.2
 
# === Vertical concatenation (stacking rows) ===
q1 = pd.DataFrame({
    "month": ["Jan", "Feb", "Mar"],
    "revenue": [12000, 15000, 11000],
})
q2 = pd.DataFrame({
    "month": ["Apr", "May", "Jun"],
    "revenue": [16000, 18000, 14000],
})
 
# Concatenate vertically — adds rows from q2 below q1
combined = pd.concat([q1, q2], ignore_index=True)
# => ignore_index=True resets index to 0,1,2,3,4,5 — prevents duplicate indices
print(combined.shape)                  # => (6, 2)
print(combined.index.tolist())         # => [0, 1, 2, 3, 4, 5]
 
# === WITHOUT ignore_index — index from each DataFrame preserved ===
combined_raw = pd.concat([q1, q2])
print(combined_raw.index.tolist())     # => [0, 1, 2, 0, 1, 2] — duplicate indices!
 
# === Add a source label to track origin ===
combined_labeled = pd.concat(
    [q1, q2],
    keys=["Q1", "Q2"],                 # => creates MultiIndex (Q1/Q2, 0/1/2)
    ignore_index=False,
)
print(combined_labeled.index)         # => MultiIndex: Q1-0, Q1-1, Q1-2, Q2-0, Q2-1, Q2-2
 
# === Horizontal concatenation (adding columns) ===
ids = pd.DataFrame({"id": [101, 102, 103]})
names = pd.DataFrame({"name": ["Alice", "Bob", "Charlie"]})
horiz = pd.concat([ids, names], axis=1)  # => axis=1 means columns direction
# => DataFrame with id and name columns
print(horiz.columns.tolist())             # => ['id', 'name']
 
# === Handling mismatched columns — fills with NaN ===
df_a = pd.DataFrame({"x": [1, 2], "y": [3, 4]})
df_b = pd.DataFrame({"x": [5, 6], "z": [7, 8]})  # => no 'y' column
combined_mismatch = pd.concat([df_a, df_b], ignore_index=True)
# => y column has NaN for df_b rows; z column has NaN for df_a rows
print(combined_mismatch)

import pandas as pd      # => pandas 3.0.2
 
df = pd.DataFrame({
    "email": ["ALICE@example.com", "  bob@DOMAIN.ORG  ", "charlie@test.net", "invalid-email"],
    "description": ["Product A - red", "Product B - blue", "Product C - red", "Product D - green"],
    "code": ["SKU-001", "SKU-002", "SKU-003", "SKU-004"],
})
 
# === Case normalization ===
df["email_clean"] = df["email"].str.lower().str.strip()
# => 'alice@example.com', 'bob@domain.org', 'charlie@test.net', 'invalid-email'
print(df["email_clean"].tolist())
 
# === Check if string contains a pattern ===
is_red = df["description"].str.contains("red", case=False, na=False)
# => True where description has "red" (case-insensitive)
print(is_red.tolist())   # => [True, False, True, False]
 
# === Extract substring — get domain from email ===
df["domain"] = df["email_clean"].str.split("@").str[-1]
# => 'example.com', 'domain.org', 'test.net', 'invalid-email' (no @ so last part is full string)
print(df["domain"].tolist())
 
# === Replace pattern ===
df["code_num"] = df["code"].str.replace("SKU-", "", regex=False)
# => '001', '002', '003', '004'
print(df["code_num"].tolist())
 
# === Pad strings to fixed width ===
df["code_padded"] = df["code_num"].str.zfill(5)
# => '00001', '00002', '00003', '00004'
print(df["code_padded"].tolist())
 
# === String length ===
df["email_len"] = df["email_clean"].str.len()
# => 17, 14, 16, 13 (characters in cleaned email)
print(df["email_len"].tolist())
 
# === startswith / endswith ===
is_com = df["email_clean"].str.endswith(".com")
# => True, False, False, False
print(is_com.tolist())

import pandas as pd       # => pandas 3.0.2
 
df = pd.DataFrame({
    "date_str": ["2025-01-15", "2025-03-22", "2025-07-04", "2026-01-01"],
    "sales": [1200, 1800, 2100, 950],
})
 
# === Parse string column to datetime ===
df["date"] = pd.to_datetime(df["date_str"])
# => dtype becomes datetime64[ns]
print(df["date"].dtype)              # => datetime64[ns]
 
# === Extract datetime components using .dt accessor ===
df["year"] = df["date"].dt.year      # => [2025, 2025, 2025, 2026]
df["month"] = df["date"].dt.month    # => [1, 3, 7, 1]
df["quarter"] = df["date"].dt.quarter  # => [1, 1, 3, 1]
df["day_name"] = df["date"].dt.day_name()  # => ['Wednesday', 'Saturday', 'Friday', 'Thursday']
df["week"] = df["date"].dt.isocalendar().week   # => ISO week number
 
print(df[["date", "year", "month", "quarter"]].to_string())
 
# === Date arithmetic ===
df["days_from_start"] = (df["date"] - df["date"].min()).dt.days
# => [0, 66, 169, 351] — days elapsed from earliest date
print(df["days_from_start"].tolist())
 
# === Create a date range for time series ===
# CRITICAL: pandas 3.0.2 uses "ME" for month-end, NOT deprecated "M"
monthly_dates = pd.date_range("2025-01-01", periods=6, freq="ME")
# => DatetimeIndex: 2025-01-31, 2025-02-28, 2025-03-31, ..., 2025-06-30
print(monthly_dates)
 
# === Other new aliases (pandas 3.0.2) ===
# "YE" for year-end (was "Y" in 2.x — deprecated)
# "QE" for quarter-end (was "Q" in 2.x — deprecated)
# "MS" for month-start (unchanged)
# "YS" for year-start (unchanged)
annual_dates = pd.date_range("2020-01-01", periods=5, freq="YE")
# => DatetimeIndex: 2020-12-31, 2021-12-31, ..., 2024-12-31
print(annual_dates)

import numpy as np       # => numpy 2.4.4 — major type alias changes from 1.x
 
# === Creating arrays from Python lists ===
arr = np.array([1, 2, 3, 4, 5])   # => 1D array, dtype inferred as int64
print(arr)                          # => [1 2 3 4 5]
print(arr.dtype)                    # => int64
print(arr.shape)                    # => (5,) — 1D array with 5 elements
print(arr.ndim)                     # => 1 — one dimension
 
# === Creating 2D arrays ===
matrix = np.array([[1, 2, 3], [4, 5, 6]])   # => 2 rows, 3 columns
print(matrix.shape)                           # => (2, 3)
print(matrix.ndim)                            # => 2
print(matrix[0, 2])                           # => 3 — row 0, col 2
 
# === Utility creation functions ===
zeros = np.zeros((3, 4))           # => 3x4 array of 0.0 floats
ones = np.ones((2, 3), dtype=np.float64)  # => float64, NOT np.float_ (removed in 2.x)
identity = np.eye(3)               # => 3x3 identity matrix
range_arr = np.arange(0, 10, 2)   # => [0, 2, 4, 6, 8] — like Python range()
linspace = np.linspace(0, 1, 5)   # => [0.0, 0.25, 0.5, 0.75, 1.0] — 5 evenly spaced
 
print(zeros.shape)    # => (3, 4)
print(range_arr)      # => [0 2 4 6 8]
print(linspace)       # => [0.   0.25 0.5  0.75 1.  ]
 
# === Reshaping arrays ===
flat = np.arange(12)               # => [0, 1, 2, ..., 11] — 12 elements
reshaped = flat.reshape(3, 4)      # => 3 rows, 4 columns
print(reshaped.shape)              # => (3, 4)
print(reshaped[1, 2])              # => 6 — row 1, col 2 of reshaped array
 
# === Array metadata ===
print(reshaped.size)               # => 12 — total number of elements
print(reshaped.nbytes)             # => 96 — bytes used (12 elements * 8 bytes each for int64)

import numpy as np     # => numpy 2.4.4
 
a = np.array([1, 2, 3, 4, 5])     # => 1D array
b = np.array([10, 20, 30, 40, 50]) # => same shape as a
 
# === Element-wise arithmetic ===
print(a + b)   # => [11, 22, 33, 44, 55] — adds corresponding elements
print(a * b)   # => [10, 40, 90, 160, 250]
print(b / a)   # => [10.0, 10.0, 10.0, 10.0, 10.0]
print(a ** 2)  # => [1, 4, 9, 16, 25] — squares each element
 
# === Scalar broadcasting — scalar applied to every element ===
print(a + 100)   # => [101, 102, 103, 104, 105]
print(a * 2.5)   # => [2.5, 5.0, 7.5, 10.0, 12.5]
 
# === 2D broadcasting — row vector added to each row of a matrix ===
matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])       # => shape (3, 3)
row_bias = np.array([10, 20, 30])    # => shape (3,) — 1D row vector
 
result = matrix + row_bias   # => row_bias broadcast to each row
# => [[11, 22, 33],
# =>  [14, 25, 36],
# =>  [17, 28, 39]]
print(result)
 
# === Column broadcasting — column vector added to each column ===
col_bias = np.array([[100], [200], [300]])  # => shape (3, 1) — column vector
result_col = matrix + col_bias
# => [[101, 102, 103],   (row 0 + 100)
# =>  [204, 205, 206],   (row 1 + 200)
# =>  [307, 308, 309]]   (row 2 + 300)
print(result_col)
 
# === Aggregate functions ===
print(matrix.sum())          # => 45 — sum all elements
print(matrix.sum(axis=0))    # => [12, 15, 18] — sum each column
print(matrix.sum(axis=1))    # => [6, 15, 24] — sum each row
print(matrix.mean())         # => 5.0 — mean of all elements
print(matrix.std())          # => ~2.58 — standard deviation

import numpy as np       # => numpy 2.4.4
 
# === NEW API: default_rng (RECOMMENDED in numpy 2.x) ===
rng = np.random.default_rng(seed=42)  # => creates Generator object with reproducible seed
# => rng is a numpy.random.Generator instance
 
# Continuous distributions
normal_samples = rng.normal(loc=0.0, scale=1.0, size=5)
# => loc=mean, scale=std_dev, size=number of samples
# => e.g., [ 0.304, -1.035, 0.750, 0.940, -0.151] (exact values depend on seed)
print(normal_samples.round(3))
 
uniform_samples = rng.uniform(low=0.0, high=100.0, size=5)
# => 5 uniform samples between 0 and 100
print(uniform_samples.round(1))   # => e.g., [77.4, 43.2, 0.3, 63.8, 53.6]
 
# Discrete distributions
int_samples = rng.integers(low=1, high=7, size=10)
# => 10 integers from 1 to 6 (high is exclusive, like Python range)
print(int_samples)                # => e.g., [1, 5, 2, 3, 6, 4, 1, 5, 3, 2]
 
# Shuffle and choice
arr = np.arange(10)               # => [0, 1, 2, ..., 9]
rng.shuffle(arr)                  # => shuffles in-place
print(arr)                        # => e.g., [7, 4, 2, 0, 9, 6, 1, 8, 5, 3]
 
choices = rng.choice(["A", "B", "C"], size=5, replace=True)
# => 5 random choices from the list, with replacement
print(choices)                    # => e.g., ['B', 'A', 'C', 'A', 'B']
 
# === DEPRECATED API (still works but discouraged) ===
# np.random.seed(42)             # => module-level seed, not thread-safe
# np.random.normal(0, 1, 5)      # => uses global state, not recommended
# np.random.RandomState(42)      # => legacy class, use default_rng instead

import numpy as np     # => numpy 2.4.4 — type alias breaking changes
 
# === CORRECT type names in numpy 2.4.4 ===
x_float = np.float64(3.14)     # => np.float64 — 64-bit IEEE float
x_int = np.intp(42)            # => np.intp — platform-native integer (64-bit on 64-bit systems)
x_complex = np.complex128(1+2j) # => np.complex128 — 128-bit complex (64+64)
x_bool = np.bool_(True)         # => np.bool_ — numpy boolean
missing = np.nan                 # => lowercase np.nan — Python float('nan')
 
print(type(x_float))    # => <class 'numpy.float64'>
print(type(missing))    # => <class 'float'> — np.nan is Python's float nan
 
# === REMOVED in numpy 2.x (will raise AttributeError) ===
# np.float_    => AttributeError: module 'numpy' has no attribute 'float_'
# np.int_      => removed (was alias for intp but confusingly named like int)
# np.complex_  => removed (use np.complex128)
# np.NaN       => removed (use np.nan lowercase)
# np.bool      => removed in 1.20, still gone (use np.bool_ or Python bool)
# np.string_   => removed (use np.bytes_)
 
# === How to safely check for NaN in numpy 2.4.4 ===
arr = np.array([1.0, np.nan, 3.0, np.nan, 5.0])
nan_mask = np.isnan(arr)              # => [False, True, False, True, False]
print(nan_mask)
 
valid = arr[~nan_mask]               # => [1.0, 3.0, 5.0] — filter out NaN
print(valid)
 
# === Dtype specification with correct names ===
arr_f64 = np.zeros(5, dtype=np.float64)    # => correct
arr_i64 = np.zeros(5, dtype=np.int64)      # => correct
arr_bool = np.zeros(5, dtype=bool)          # => Python bool works
print(arr_f64.dtype)                        # => float64
print(arr_i64.dtype)                        # => int64

import matplotlib.pyplot as plt   # => matplotlib 3.10.x
import numpy as np                # => numpy 2.4.4
 
# === Generate sample data ===
rng = np.random.default_rng(seed=42)         # => reproducible random data
x = np.linspace(0, 10, 100)                  # => 100 points from 0 to 10
y_signal = np.sin(x)                          # => sine wave
y_noisy = y_signal + rng.normal(0, 0.2, 100) # => sine + Gaussian noise
 
# === Create figure and axes with OO API ===
fig, ax = plt.subplots(figsize=(10, 4))
# => fig is the Figure container, ax is the Axes (the plot area)
# => figsize=(width_inches, height_inches)
 
# === Plot data ===
ax.plot(x, y_signal, color="#0173B2", linewidth=2, label="Clean signal")
# => solid blue line for the true signal
ax.plot(x, y_noisy, color="#DE8F05", alpha=0.5, linewidth=1, label="Noisy signal")
# => orange line with 50% transparency for noisy observations
 
# === Annotations and labels ===
ax.set_xlabel("Time (seconds)", fontsize=12)  # => x-axis label
ax.set_ylabel("Amplitude", fontsize=12)        # => y-axis label
ax.set_title("Sine Wave with Gaussian Noise", fontsize=14, fontweight="bold")
ax.legend(loc="upper right")                   # => show legend with labels
ax.grid(True, alpha=0.3)                        # => faint grid for readability
 
# === Save to file ===
# plt.savefig("sine_wave.png", dpi=150, bbox_inches="tight")
# => dpi=150 for reasonable print quality; bbox_inches="tight" removes extra whitespace
 
plt.tight_layout()   # => adjusts subplot parameters to fit labels
plt.show()           # => display in notebook/interactive session

import pandas as pd             # => pandas 3.0.2
import matplotlib.pyplot as plt # => matplotlib 3.10.x
import numpy as np              # => numpy 2.4.4
 
# === Generate correlated data ===
rng = np.random.default_rng(seed=42)          # => reproducible generator
n = 100
experience = rng.integers(1, 15, size=n)       # => years 1-14
base_salary = experience * 5000               # => salary increases with experience
noise = rng.normal(0, 8000, size=n)            # => random variation
salary = base_salary + 40000 + noise           # => total salary with noise
 
df = pd.DataFrame({
    "experience_years": experience,
    "salary": salary.astype(int),
    "department": rng.choice(["Eng", "Mkt", "Fin"], size=n),
})
 
# === Method 1: pandas .plot.scatter() convenience method ===
ax = df.plot.scatter(
    x="experience_years",     # => x-axis column
    y="salary",               # => y-axis column
    alpha=0.6,                # => transparency to see overlapping points
    color="#0173B2",          # => blue — accessible color
    figsize=(8, 5),
)
ax.set_title("Salary vs Experience")
ax.set_xlabel("Years of Experience")
ax.set_ylabel("Annual Salary ($)")
plt.tight_layout()
 
# === Method 2: matplotlib directly — more control ===
fig, ax = plt.subplots(figsize=(8, 5))
 
# Color-code by department using a color map
dept_colors = {"Eng": "#0173B2", "Mkt": "#DE8F05", "Fin": "#029E73"}
for dept, color in dept_colors.items():
    mask = df["department"] == dept              # => filter to this department
    ax.scatter(
        df.loc[mask, "experience_years"],
        df.loc[mask, "salary"],
        c=color, alpha=0.7, label=dept, s=40,   # => s=marker size in points^2
    )
 
ax.set_xlabel("Years of Experience")
ax.set_ylabel("Annual Salary ($)")
ax.set_title("Salary vs Experience by Department")
ax.legend()
plt.tight_layout()
plt.show()

import pandas as pd              # => pandas 3.0.2
import matplotlib.pyplot as plt  # => matplotlib 3.10.x
 
sales_data = pd.DataFrame({
    "region": ["North", "South", "East", "West", "North", "South", "East", "West"],
    "product": ["A", "A", "A", "A", "B", "B", "B", "B"],
    "revenue": [120000, 95000, 140000, 88000, 75000, 110000, 65000, 130000],
})
 
# === Grouped bar chart ===
pivot = sales_data.pivot(index="region", columns="product", values="revenue")
# => creates a 4x2 DataFrame: regions as rows, products as columns
print(pivot)
# =>         A        B
# => East   140000   65000
# => North  120000   75000
# => South   95000  110000
# => West    88000  130000
 
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
# => 1 row, 2 columns of subplots — axes is array [ax1, ax2]
 
# Grouped bar chart (side-by-side bars per region)
pivot.plot.bar(
    ax=axes[0],          # => plot on first subplot
    color=["#0173B2", "#DE8F05"],  # => blue for A, orange for B
    rot=0,               # => don't rotate x-axis labels
    width=0.7,           # => bar width (0 to 1)
)
axes[0].set_title("Grouped: Revenue by Region and Product")
axes[0].set_xlabel("Region")
axes[0].set_ylabel("Revenue ($)")
axes[0].legend(title="Product")
 
# Stacked bar chart
pivot.plot.bar(
    ax=axes[1],
    stacked=True,        # => bars stacked vertically
    color=["#0173B2", "#DE8F05"],
    rot=0,
)
axes[1].set_title("Stacked: Revenue by Region and Product")
axes[1].set_xlabel("Region")
axes[1].set_ylabel("Total Revenue ($)")
 
plt.tight_layout()
plt.show()

import pandas as pd              # => pandas 3.0.2
import matplotlib.pyplot as plt  # => matplotlib 3.10.x
import numpy as np               # => numpy 2.4.4
 
rng = np.random.default_rng(seed=42)      # => reproducible generator
 
# Create a bimodal distribution (two salary groups)
junior_salaries = rng.normal(45000, 8000, 300)   # => junior cluster ~45k
senior_salaries = rng.normal(90000, 12000, 200)  # => senior cluster ~90k
all_salaries = np.concatenate([junior_salaries, senior_salaries])
 
df = pd.DataFrame({"salary": all_salaries})
 
fig, axes = plt.subplots(1, 3, figsize=(15, 4))
 
# === Histogram with auto bins ===
axes[0].hist(df["salary"], bins="auto", color="#0173B2", edgecolor="#000", alpha=0.8)
# => bins="auto" uses Sturges formula to choose bin count
axes[0].set_title("Auto Bins")
axes[0].set_xlabel("Salary ($)")
axes[0].set_ylabel("Frequency")
 
# === Histogram with specific bin count ===
axes[1].hist(df["salary"], bins=30, color="#029E73", edgecolor="#000", alpha=0.8)
# => bins=30 divides salary range into 30 equal-width buckets
axes[1].set_title("30 Bins")
axes[1].set_xlabel("Salary ($)")
 
# === pandas convenience histogram ===
df["salary"].hist(
    ax=axes[2],
    bins=25,
    color="#CC78BC",         # => purple — accessible color
    edgecolor="black",
    grid=False,
)
# => adds mean and median reference lines
mean_val = df["salary"].mean()
median_val = df["salary"].median()
axes[2].axvline(mean_val, color="#DE8F05", linewidth=2, label=f"Mean: {mean_val:,.0f}")
axes[2].axvline(median_val, color="#CA9161", linewidth=2, linestyle="--", label=f"Median: {median_val:,.0f}")
axes[2].legend()
axes[2].set_title("With Mean/Median Lines")
axes[2].set_xlabel("Salary ($)")
 
plt.tight_layout()
plt.show()
 
# Bimodality visible in all three histograms — two humps around 45k and 90k
print(f"Mean: {mean_val:,.0f}, Median: {median_val:,.0f}")
# => Mean: 64399, Median: 58102 (mean pulled right by senior group)

import seaborn as sns             # => seaborn 0.13.2
import matplotlib.pyplot as plt   # => matplotlib 3.10.x
import pandas as pd               # => pandas 3.0.2
import numpy as np                # => numpy 2.4.4
 
rng = np.random.default_rng(seed=42)
n = 150
df = pd.DataFrame({
    "experience": rng.integers(1, 15, n),
    "salary": rng.integers(40000, 130000, n),
    "department": rng.choice(["Eng", "Mkt", "Fin"], n),
    "score": rng.normal(75, 15, n).clip(0, 100),
})
 
fig, axes = plt.subplots(1, 3, figsize=(16, 5))
 
# === scatterplot with hue (color by category) ===
palette = {"Eng": "#0173B2", "Mkt": "#DE8F05", "Fin": "#029E73"}
sns.scatterplot(
    data=df,
    x="experience",    # => x-axis column name
    y="salary",        # => y-axis column name
    hue="department",  # => color-codes dots by department
    palette=palette,   # => explicit accessible colors
    alpha=0.7,
    ax=axes[0],
)
axes[0].set_title("Salary vs Experience by Department")
 
# === lineplot with confidence interval ===
# seaborn auto-aggregates y values for each unique x and shows CI
sns.lineplot(
    data=df,
    x="experience",
    y="salary",
    hue="department",
    palette=palette,
    ax=axes[1],
    errorbar="ci",     # => 95% confidence interval shading
)
axes[1].set_title("Mean Salary Trend with 95% CI")
 
# === histplot with KDE overlay ===
sns.histplot(
    data=df,
    x="score",
    hue="department",
    palette=palette,
    kde=True,           # => overlay kernel density estimate curve
    alpha=0.5,
    ax=axes[2],
)
axes[2].set_title("Score Distribution by Department")
 
plt.tight_layout()
plt.show()

import pandas as pd              # => pandas 3.0.2
import seaborn as sns            # => seaborn 0.13.2
import matplotlib.pyplot as plt  # => matplotlib 3.10.x
import numpy as np               # => numpy 2.4.4
 
rng = np.random.default_rng(seed=42)
n = 200
 
df = pd.DataFrame({
    "age": rng.integers(22, 65, n),
    "experience": rng.integers(0, 40, n),
    "salary": rng.integers(35000, 150000, n),
    "performance": rng.normal(75, 12, n).clip(0, 100),
    "satisfaction": rng.normal(68, 15, n).clip(0, 100),
})
 
# Make salary correlate with experience for realism
df["salary"] = df["salary"] + df["experience"] * 2000
 
# === Compute Pearson correlation matrix ===
corr_matrix = df.corr(method="pearson")
# => corr() returns a square DataFrame where each cell is correlation coefficient
# => values range from -1 (perfect negative) to +1 (perfect positive)
print(corr_matrix.round(2))
 
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
 
# === Full correlation heatmap ===
sns.heatmap(
    corr_matrix,
    annot=True,          # => show numeric values in each cell
    fmt=".2f",           # => format as 2 decimal places
    cmap="Blues",        # => blue sequential colormap (lighter = closer to 0)
    vmin=-1, vmax=1,     # => fix color scale from -1 to 1
    center=0,            # => white at 0
    square=True,         # => equal aspect ratio cells
    ax=axes[0],
)
axes[0].set_title("Pearson Correlation Matrix")
 
# === Upper triangle only (remove redundant lower half) ===
mask = np.triu(np.ones_like(corr_matrix, dtype=bool))
# => mask is True in upper triangle including diagonal
sns.heatmap(
    corr_matrix,
    mask=mask,           # => hide upper triangle cells
    annot=True,
    fmt=".2f",
    cmap="Blues",
    vmin=-1, vmax=1,
    center=0,
    square=True,
    ax=axes[1],
)
axes[1].set_title("Lower Triangle Only")
 
plt.tight_layout()
plt.show()

import matplotlib.pyplot as plt   # => matplotlib 3.10.x
import numpy as np                # => numpy 2.4.4
 
rng = np.random.default_rng(seed=42)     # => reproducible data
x = np.linspace(0, 2 * np.pi, 200)      # => 200 points for smooth sine curve
y = np.sin(x) * np.exp(-x / 5)          # => damped sine wave
 
fig, ax = plt.subplots(figsize=(8, 4))   # => 8 inches wide, 4 inches tall
 
ax.plot(x, y, color="#0173B2", linewidth=2, label="Damped sine")
ax.fill_between(x, y, 0, alpha=0.2, color="#0173B2")  # => shaded area under curve
ax.axhline(0, color="black", linewidth=0.5)             # => horizontal reference line
ax.set_xlabel("Time (radians)", fontsize=12)
ax.set_ylabel("Amplitude", fontsize=12)
ax.set_title("Damped Sine Wave", fontsize=14)
ax.legend()
ax.grid(True, alpha=0.3)
 
# === Save as PNG (raster format) ===
plt.savefig(
    "damped_sine.png",       # => filename with extension
    dpi=150,                 # => dots per inch — 72=screen, 150=good quality, 300=print
    bbox_inches="tight",     # => crop extra whitespace around figure
    facecolor="white",       # => explicit white background (avoids transparent PNG issue)
)
# => file saved to current working directory
 
# === Save as SVG (vector format — scalable for presentations) ===
plt.savefig("damped_sine.svg", bbox_inches="tight")
# => SVG is lossless and infinitely scalable — best for slides and web
 
# === Save as PDF (vector format for LaTeX/academic papers) ===
plt.savefig("damped_sine.pdf", bbox_inches="tight", dpi=300)
# => PDF embeds fonts properly for academic submissions
 
# === Save with transparent background ===
plt.savefig("damped_sine_transparent.png", transparent=True, bbox_inches="tight")
# => PNG with alpha channel — useful for overlaying on colored slide backgrounds
 
plt.close(fig)     # => release memory — important in scripts that create many figures
# => plt.show() not called when saving to file in scripts
print("Plots saved successfully")

# === Cell 1: Setup magic commands ===
# Run this in the FIRST cell of any analytics notebook
 
# Inline matplotlib — renders plots in the notebook output cell
# %matplotlib inline      # => renders static PNG inline
# %matplotlib widget      # => renders interactive pan/zoom widget (requires ipympl)
 
# Auto-reload modules without restarting kernel
# %load_ext autoreload
# %autoreload 2           # => reloads imported modules on every cell execution
 
# Display all outputs from a cell (not just the last expression)
# from IPython.core.interactiveshell import InteractiveShell
# InteractiveShell.ast_node_interactivity = "all"
 
# === Cell 2: Standard imports block ===
import pandas as pd       # => pandas 3.0.2
import numpy as np        # => numpy 2.4.4
import matplotlib.pyplot as plt   # => matplotlib 3.10.x
import seaborn as sns     # => seaborn 0.13.2
 
# Configure display options
pd.set_option("display.max_columns", 20)   # => show up to 20 columns in cell output
pd.set_option("display.max_rows", 100)     # => show up to 100 rows
pd.set_option("display.float_format", "{:.2f}".format)  # => 2 decimal places
 
sns.set_theme(style="whitegrid")  # => seaborn white background with gridlines for all plots
 
# === Cell 3: Rich DataFrame display ===
df = pd.DataFrame({
    "name": ["Alice", "Bob", "Charlie"],
    "salary": [55000, 72000, 85000],
    "dept": ["Eng", "Mkt", "Fin"],
})
 
# Jupyter renders DataFrame as HTML table automatically
# Just type the variable name on the last line of a cell:
df  # => displays styled HTML table in Jupyter output (not in .py scripts)
 
# === Styled display for reports ===
styled = (
    df.style
    .format({"salary": "${:,.0f}"})      # => format salary as currency
    .highlight_max(subset=["salary"])     # => highlight highest salary cell
)
styled   # => renders with formatting in Jupyter output

import pandas as pd       # => pandas 3.0.2
import numpy as np        # => numpy 2.4.4
 
# Simulate a realistic dataset with quality issues
rng = np.random.default_rng(seed=42)
n = 500
df = pd.DataFrame({
    "customer_id": range(1001, 1001 + n),
    "age": np.where(rng.random(n) < 0.05, np.nan, rng.integers(18, 75, n)),
    "income": rng.lognormal(10.8, 0.6, n),  # => right-skewed income distribution
    "region": rng.choice(["North", "South", "East", "West", None], n, p=[0.3, 0.3, 0.2, 0.15, 0.05]),
    "product_tier": rng.choice(["Basic", "Standard", "Premium"], n, p=[0.5, 0.3, 0.2]),
    "churn": rng.choice([0, 1], n, p=[0.75, 0.25]),
})
 
print("=" * 60)
print("DATA QUALITY REPORT")
print("=" * 60)
 
# === 1. Basic shape and schema ===
print(f"\nRows: {df.shape[0]:,}")        # => 500 rows
print(f"Columns: {df.shape[1]}")         # => 6 columns
print(f"\nDtypes:\n{df.dtypes}")
 
# === 2. Missing values analysis ===
missing = df.isnull().sum()              # => count per column
missing_pct = (missing / len(df) * 100).round(1)  # => percentage
missing_report = pd.DataFrame({"count": missing, "pct": missing_pct})
missing_report = missing_report[missing_report["count"] > 0]  # => only columns with nulls
print(f"\nMissing Values:\n{missing_report}")
# => age: ~25 (5%), region: ~25 (5%)
 
# === 3. Numeric column statistics ===
print(f"\nNumeric Summary:\n{df.describe().round(2)}")
# => count, mean, std, min, 25%, 50%, 75%, max for age, income, churn
 
# === 4. Categorical column distribution ===
for col in df.select_dtypes(include=["object"]).columns:
    print(f"\n{col} distribution:")
    print(df[col].value_counts(dropna=False))  # => dropna=False shows NaN count too
    # => region: North 150, South 150, East 100, West 75, NaN 25
    # => product_tier: Basic 250, Standard 150, Premium 100
 
# === 5. Target variable distribution ===
print(f"\nTarget (churn) balance:")
print(df["churn"].value_counts(normalize=True).round(3))
# => 0 (retained): ~0.750
# => 1 (churned):  ~0.250 — 3:1 class imbalance, relevant for modeling
 
print("\nReport complete.")