Python for Tidyverse Users

library(tidyverse)

# Everything is loaded — dplyr,
# ggplot2, tidyr, readr, etc.

# Interactive: RStudio console
# Scripts: .R files

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Convention: short aliases
# pd, np, plt — you'll see these everywhere

# Interactive: Jupyter notebook
# Scripts: .py files

# Braces define blocks
if (x > 10) {
  print("big")
} else {
  print("small")
}

for (i in 1:5) {
  print(i)
}

# Indentation defines blocks (4 spaces)
if x > 10:
    print("big")
else:
    print("small")

for i in range(1, 6):  # 1 to 5
    print(i)

x <- c(10, 20, 30)
x[1]    # 10  (1-indexed)
x[2:3]  # 20, 30 (inclusive)

x = [10, 20, 30]
x[0]    # 10  (0-indexed!)
x[1:3]  # [20, 30] (end exclusive)

df %>%
  filter(age > 30) %>%
  mutate(decade = age %/% 10) %>%
  group_by(decade) %>%
  summarise(avg_income = mean(income)) %>%
  arrange(desc(avg_income))

(df
  .query("age > 30")
  .assign(decade=lambda x: x["age"] // 10)
  .groupby("decade")
  .agg(avg_income=("income", "mean"))
  .sort_values("avg_income", ascending=False)
)

x <- c(1, 2, 3, 4, 5)
x * 2          # 2, 4, 6, 8, 10 ✓
x[x > 3]      # 4, 5           ✓
mean(x)        # 3              ✓

x = [1, 2, 3, 4, 5]
# x * 2  → [1,2,3,4,5,1,2,3,4,5] 😱

# Use numpy instead:
import numpy as np
x = np.array([1, 2, 3, 4, 5])
x * 2          # array([2,4,6,8,10]) ✓
x[x > 3]      # array([4, 5])       ✓
x.mean()       # 3.0                 ✓

# purrr::map
map_dbl(1:5, ~ .x^2)
# [1]  1  4  9 16 25

# Keep evens
keep(1:10, ~ .x %% 2 == 0)

# List comprehension
[x**2 for x in range(1, 6)]
# [1, 4, 9, 16, 25]

# With condition
[x for x in range(1, 11) if x % 2 == 0]
# [2, 4, 6, 8, 10]

df <- tibble(
  name = c("Alice", "Bob", "Carol"),
  age = c(32, 45, 28),
  score = c(88, 92, 85)
)

glimpse(df)
summary(df)

df = pd.DataFrame({
    "name": ["Alice", "Bob", "Carol"],
    "age": [32, 45, 28],
    "score": [88, 92, 85]
})

df.info()     # like glimpse()
df.describe() # like summary()

# Single column
df %>% select(name)

# Multiple columns
df %>% select(name, age)

# By pattern
df %>% select(starts_with("score"))
df %>% select(where(is.numeric))

# Drop columns
df %>% select(-age)

# Rename
df %>% rename(full_name = name)

# Single column (returns Series)
df["name"]

# Multiple columns (returns DataFrame)
df[["name", "age"]]

# By pattern
df.filter(regex="^score")
df.select_dtypes(include="number")

# Drop columns
df.drop(columns=["age"])

# Rename
df.rename(columns={"name": "full_name"})

# Simple filter
df %>% filter(age > 30)

# Multiple conditions
df %>% filter(age > 30, score > 85)

# OR condition
df %>% filter(age > 30 | score > 90)

# %in% check
df %>% filter(name %in% c("Alice","Bob"))

# Missing values
df %>% filter(!is.na(score))

# Slice
df %>% slice(1:3)
df %>% slice_max(score, n = 2)

# Simple filter
df[df["age"] > 30]            # boolean mask
df.query("age > 30")          # query string

# Multiple conditions
df.query("age > 30 and score > 85")

# OR condition
df.query("age > 30 or score > 90")

# isin check
df[df["name"].isin(["Alice", "Bob"])]

# Missing values
df[df["score"].notna()]        # or .dropna()

# Slice
df.iloc[0:3]                   # by position
df.nlargest(2, "score")        # top N

df %>%
  mutate(
    score_pct = score / 100,
    age_group = case_when(
      age < 30 ~ "Young",
      age < 40 ~ "Mid",
      TRUE     ~ "Senior"
    ),
    rank = row_number()
  )

(df
  .assign(
    score_pct=lambda x: x["score"] / 100,
    age_group=lambda x: np.select(
      [x["age"] < 30, x["age"] < 40],
      ["Young", "Mid"],
      default="Senior"
    ),
    rank=lambda x: range(1, len(x) + 1)
  )
)
# Or directly: df["score_pct"] = df["score"]/100

# case_when
df %>% mutate(
  grade = case_when(
    score >= 90 ~ "A",
    score >= 80 ~ "B",
    score >= 70 ~ "C",
    TRUE        ~ "F"
  )
)

# cut for bins
df %>% mutate(
  age_bin = cut(age, breaks = c(0,30,40,50,Inf))
)

# np.select (order matters!)
conditions = [
    df["score"] >= 90,
    df["score"] >= 80,
    df["score"] >= 70,
]
choices = ["A", "B", "C"]
df["grade"] = np.select(conditions, choices, "F")

# pd.cut for bins
df["age_bin"] = pd.cut(
    df["age"], bins=[0, 30, 40, 50, np.inf]
)

# Ungrouped summary
df %>% summarise(
  avg_score = mean(score),
  n = n()
)

# Grouped summary
df %>%
  group_by(dept) %>%
  summarise(
    avg_score = mean(score),
    max_age = max(age),
    n = n()
  ) %>%
  ungroup()

# Window function in mutate
df %>%
  group_by(dept) %>%
  mutate(
    dept_avg = mean(score),
    rank = rank(-score)
  )

# Ungrouped summary
df.agg(
    avg_score=("score", "mean"),
    n=("score", "size")
)

# Grouped summary
(df
  .groupby("dept")
  .agg(
    avg_score=("score", "mean"),
    max_age=("age", "max"),
    n=("name", "size")
  )
  .reset_index()    # like ungroup()
)

# Window function (transform)
df["dept_avg"] = (
    df.groupby("dept")["score"].transform("mean")
)
df["rank"] = (
    df.groupby("dept")["score"].rank(ascending=False)
)

left_join(df1, df2, by = "id")
inner_join(df1, df2, by = "id")
full_join(df1, df2, by = "id")
anti_join(df1, df2, by = "id")

# Different column names
left_join(df1, df2,
  by = c("emp_id" = "employee_id")
)

df1.merge(df2, on="id", how="left")
df1.merge(df2, on="id", how="inner")
df1.merge(df2, on="id", how="outer")
df1.merge(df2, on="id", how="left",
          indicator=True)  # then filter

# Different column names
df1.merge(df2,
    left_on="emp_id",
    right_on="employee_id"
)

# Long → same as gather
df %>% pivot_longer(
  cols = c(q1, q2, q3),
  names_to = "quarter",
  values_to = "revenue"
)

# Wide → same as spread
df %>% pivot_wider(
  names_from = quarter,
  values_from = revenue
)

# Melt = pivot_longer
df.melt(
    id_vars=["name"],
    value_vars=["q1", "q2", "q3"],
    var_name="quarter",
    value_name="revenue"
)

# Pivot = pivot_wider
df.pivot_table(
    index="name",
    columns="quarter",
    values="revenue"
).reset_index()

str_to_lower(x)
str_to_upper(x)
str_trim(x)
str_detect(x, "pattern")
str_replace(x, "old", "new")
str_sub(x, 1, 3)
str_c("a", "b", sep = "-")
str_extract(x, "\\d+")

df["col"].str.lower()
df["col"].str.upper()
df["col"].str.strip()
df["col"].str.contains("pattern")
df["col"].str.replace("old", "new")
df["col"].str[:3]
"a" + "-" + "b"  # or "-".join(...)
df["col"].str.extract(r"(\d+)")

ymd("2024-03-15")
today()
x <- ymd("2024-03-15")
year(x); month(x); day(x)
x + days(30)
floor_date(x, "month")
interval(start, end) / days(1)

pd.to_datetime("2024-03-15")
pd.Timestamp.today()
x = pd.to_datetime("2024-03-15")
x.year; x.month; x.day
x + pd.Timedelta(days=30)
x.to_period("M").to_timestamp()
(end - start).days

factor(x, levels = c("Low","Med","High"))
fct_relevel(x, "High", "Med", "Low")
fct_reorder(x, value, .fun = median)
fct_lump_n(x, n = 5)

pd.Categorical(x, categories=["Low","Med","High"],
               ordered=True)
df["col"] = df["col"].cat.reorder_categories(
    ["High","Med","Low"])
# Reorder by value — set after sorting
# Lump — use value_counts + threshold

library(tidyverse)
library(fs)

raw <- dir_ls("data/raw", glob = "*.csv") %>%
  map_dfr(read_csv)

clean <- raw %>%
  janitor::clean_names() %>%
  distinct(id, date, .keep_all = TRUE) %>%
  filter(!is.na(id), amount >= 0) %>%
  mutate(
    year = year(date),
    quarter = quarter(date),
    size = cut(amount,
      breaks = c(0, 100, 1000, Inf),
      labels = c("S", "M", "L"))
  )

write_parquet(clean, "data/clean.parquet")

import pandas as pd
from pathlib import Path

files = Path("data/raw").glob("*.csv")
raw = pd.concat(
    [pd.read_csv(f) for f in files],
    ignore_index=True
)

clean = (raw
    .rename(columns=str.lower)
    .drop_duplicates(subset=["id", "date"])
    .dropna(subset=["id"])
    .query("amount >= 0")
    .assign(
        year=lambda x: x["date"].dt.year,
        quarter=lambda x: x["date"].dt.quarter,
        size=lambda x: pd.cut(x["amount"],
            bins=[0,100,1000,np.inf],
            labels=["S","M","L"]),
    )
)

clean.to_parquet("data/clean.parquet")

library(httr)
library(jsonlite)

resp <- GET(
  "https://api.example.com/data",
  add_headers(Authorization = "Bearer xyz"),
  query = list(limit = 100)
)

data <- content(resp, as = "parsed")
df <- as_tibble(data$results)

import requests
import pandas as pd

resp = requests.get(
    "https://api.example.com/data",
    headers={"Authorization": "Bearer xyz"},
    params={"limit": 100}
)

data = resp.json()
df = pd.DataFrame(data["results"])

library(DBI)

con <- dbConnect(
  RPostgres::Postgres(),
  host = "localhost",
  dbname = "mydb",
  user = "user",
  password = "pass"
)

df <- dbGetQuery(con, "
  SELECT dept, AVG(salary)
  FROM employees
  WHERE active = true
  GROUP BY dept
")

dbDisconnect(con)

from sqlalchemy import create_engine
import pandas as pd

engine = create_engine(
    "postgresql://user:pass@localhost/mydb"
)

df = pd.read_sql("""
    SELECT dept, AVG(salary)
    FROM employees
    WHERE active = true
    GROUP BY dept
""", engine)

engine.dispose()

ggplot(df, aes(x = age, y = score,
               colour = dept)) +
  geom_point(alpha = 0.7, size = 3) +
  geom_smooth(method = "lm") +
  labs(
    title = "Score by Age",
    x = "Age", y = "Score"
  ) +
  theme_minimal() +
  scale_colour_brewer(palette = "Set2")

import seaborn as sns
import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(8, 5))
sns.scatterplot(
    data=df, x="age", y="score",
    hue="dept", alpha=0.7, s=60,
    palette="Set2", ax=ax
)
sns.regplot(
    data=df, x="age", y="score",
    scatter=False, ax=ax, color="grey"
)
ax.set(title="Score by Age",
       xlabel="Age", ylabel="Score")
sns.despine()
plt.tight_layout()
plt.savefig("scatter.png", dpi=150)

library(plotly)

plot_ly(df,
  x = ~date, y = ~value,
  color = ~group,
  type = "scatter",
  mode = "lines"
) %>%
  layout(title = "Trend")

import plotly.express as px

fig = px.line(
    df,
    x="date", y="value",
    color="group",
    title="Trend"
)
fig.show()
fig.write_html("trend.html")

# t-test
t.test(score ~ group, data = df)

# Chi-squared
chisq.test(table(df$dept, df$grade))

# Correlation
cor.test(df$age, df$score)

# Shapiro-Wilk normality
shapiro.test(df$score)

# Mann-Whitney U
wilcox.test(score ~ group, data = df)

# Linear regression
model <- lm(score ~ age + dept, data = df)
summary(model)

from scipy import stats

# t-test
stats.ttest_ind(group_a, group_b)

# Chi-squared
ct = pd.crosstab(df["dept"], df["grade"])
stats.chi2_contingency(ct)

# Correlation
stats.pearsonr(df["age"], df["score"])

# Shapiro-Wilk normality
stats.shapiro(df["score"])

# Mann-Whitney U
stats.mannwhitneyu(group_a, group_b)

# Linear regression
import statsmodels.formula.api as smf
model = smf.ols("score ~ age + dept", data=df)
results = model.fit()
print(results.summary())

library(tidymodels)

# Split
split <- initial_split(df, prop = 0.8)
train <- training(split)
test <- testing(split)

# Recipe + model
rec <- recipe(score ~ ., data = train) %>%
  step_dummy(all_nominal()) %>%
  step_normalize(all_numeric_predictors())

model <- linear_reg() %>%
  set_engine("lm") %>%
  fit(score ~ ., data = juice(prep(rec)))

# Predict
preds <- predict(model, bake(prep(rec), test))

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.metrics import r2_score, mean_squared_error

# Split
X = df.drop(columns=["score"])
y = df["score"]
X = pd.get_dummies(X, drop_first=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42)

# Pipeline (recipe + model)
pipe = Pipeline([
    ("scaler", StandardScaler()),
    ("model", LinearRegression())
])
pipe.fit(X_train, y_train)

# Predict
preds = pipe.predict(X_test)
print(f"R² = {r2_score(y_test, preds):.3f}")

clean_names <- function(df,
                        case = "snake") {
  df %>%
    janitor::clean_names(case = case)
}

# Default arguments
calc_rate <- function(n, total,
                      digits = 2) {
  round(n / total * 100, digits)
}

def clean_names(df: pd.DataFrame,
                case: str = "snake") -> pd.DataFrame:
    """Standardise column names."""
    cols = df.columns.str.strip().str.lower()
    cols = cols.str.replace(" ", "_")
    return df.set_axis(cols, axis=1)

# Default arguments + type hints
def calc_rate(n: int, total: int,
              digits: int = 2) -> float:
    return round(n / total * 100, digits)

result <- tryCatch(
  {
    risky_operation()
  },
  error = function(e) {
    message("Error: ", e$message)
    NA
  },
  warning = function(w) {
    message("Warning: ", w$message)
  }
)

try:
    result = risky_operation()
except FileNotFoundError as e:
    print(f"File missing: {e}")
    result = None
except ValueError as e:
    print(f"Bad value: {e}")
    result = None
except Exception as e:
    print(f"Unexpected: {e}")
    raise  # re-raise unexpected errors
finally:
    cleanup()  # always runs

renv::init()        # create lockfile
renv::install("dplyr")
renv::snapshot()    # save state
renv::restore()     # reproduce

python -m venv .venv
source .venv/bin/activate
pip install pandas
pip freeze > requirements.txt  # save
pip install -r requirements.txt # reproduce