diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d9fd424d4..b5590d66a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -59,3 +59,20 @@ jobs:
         with:
           name: dist
           path: dist/
+
+  validate-python-examples:
+    name: Validate Python Examples
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install Python dependencies
+        run: pip install pandas numpy
+
+      - name: Validate Python playground examples
+        run: python scripts/validate-python-examples.py playground/
diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.yml
index 6df604a6d..a7ede9cdf 100644
--- a/.github/workflows/pages.yml
+++ b/.github/workflows/pages.yml
@@ -36,6 +36,17 @@ jobs:
       - name: Bundle TypeScript compiler for offline playground
         run: cp node_modules/typescript/lib/typescript.js ./playground/dist/typescript.js
 
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install Python dependencies
+        run: pip install pandas numpy
+
+      - name: Validate Python playground examples
+        run: python scripts/validate-python-examples.py playground/
+
       - name: Setup Pages
         uses: actions/configure-pages@v5
         with:
diff --git a/playground/cat_accessor.html b/playground/cat_accessor.html
index d354c4ae5..51f559f0e 100644
--- a/playground/cat_accessor.html
+++ b/playground/cat_accessor.html
@@ -212,6 +212,22 @@ <h2>1 · Categories and codes</h2>
 
 console.log("nCategories:", size.cat.nCategories);
 console.log("ordered:", size.cat.ordered);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+size = pd.Series(
+    ["M", "S", "L", "S", "M", "XL"],
+    name="size",
+    dtype="category",
+)
+
+# Sorted unique categories
+print("categories:", size.cat.categories.tolist())
+
+# Integer codes (position in categories array; -1 for null)
+print("codes:", size.cat.codes.tolist())
+
+print("nCategories:", len(size.cat.categories))
+print("ordered:", size.cat.ordered)</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -237,6 +253,13 @@ <h2>2 · Nulls are encoded as -1</h2>
 console.log("categories:", [...s.cat.categories.values]);
 console.log("codes:", s.cat.codes.toArray());
 console.log("nCategories:", s.cat.nCategories);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(["a", None, "b", None, "a"], dtype="category")
+
+print("categories:", s.cat.categories.tolist())
+print("codes:", s.cat.codes.tolist())
+print("nCategories:", len(s.cat.categories))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -267,6 +290,18 @@ <h2>3 · Add and remove categories</h2>
 const s3 = s.cat.removeCategories(["red"]);
 console.log("after remove values:", s3.toArray());
 console.log("after remove cats:", [...s3.cat.categories.values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(["red", "blue", "red"], dtype="category")
+
+# Add a new category (not yet in data)
+s2 = s.cat.add_categories(["green"])
+print("after add:", s2.cat.categories.tolist())
+
+# Remove a category — matching values become null
+s3 = s.cat.remove_categories(["red"])
+print("after remove values:", s3.tolist())
+print("after remove cats:", s3.cat.categories.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -294,6 +329,16 @@ <h2>4 · Remove unused categories</h2>
 const s3 = s2.cat.removeUnusedCategories();
 console.log("after:", s3.cat.nCategories);
 console.log("cats:", [...s3.cat.categories.values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(["a", "b"], dtype="category")
+# Manually add extra categories
+s2 = s.cat.add_categories(["c", "d", "e"])
+print("before:", len(s2.cat.categories))
+
+s3 = s2.cat.remove_unused_categories()
+print("after:", len(s3.cat.categories))
+print("cats:", s3.cat.categories.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -323,6 +368,18 @@ <h2>5 · Rename categories</h2>
 // Array replacement (same order as categories)
 const s3 = s.cat.renameCategories(["H", "L", "M"]);
 console.log("array rename:", s3.toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(["low", "mid", "high", "mid"], dtype="category")
+
+# Object mapping
+s2 = s.cat.rename_categories({"low": "L", "mid": "M", "high": "H"})
+print("renamed values:", s2.tolist())
+print("renamed cats:", s2.cat.categories.tolist())
+
+# Array replacement (same order as categories)
+s3 = s.cat.rename_categories(["H", "L", "M"])
+print("array rename:", s3.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -354,6 +411,18 @@ <h2>6 · Set and reorder categories</h2>
 const s3 = s.cat.reorderCategories(["XS", "S", "M", "L", "XL"], true);
 console.log("ordered:", s3.cat.ordered);
 console.log("custom order:", [...s3.cat.categories.values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(["XS", "S", "M", "L", "XL"], dtype="category")
+
+# set_categories: restrict to a subset
+s2 = s.cat.set_categories(["S", "M", "L"])
+print("set cats:", s2.tolist())
+
+# reorder_categories: custom ordering (e.g., by size not alphabetically)
+s3 = s.cat.reorder_categories(["XS", "S", "M", "L", "XL"], ordered=True)
+print("ordered:", s3.cat.ordered)
+print("custom order:", s3.cat.categories.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -380,6 +449,14 @@ <h2>7 · Value counts per category</h2>
 const counts = gradesFull.cat.valueCounts();
 console.log("categories:", [...gradesFull.cat.categories.values]);
 console.log("counts:", counts.toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+grades = pd.Series(["A", "B", "A", "C", "B", "A"], dtype="category")
+grades_full = grades.cat.add_categories(["D", "F"])
+
+counts = grades_full.value_counts()
+print("categories:", grades_full.cat.categories.tolist())
+print("counts:", counts.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -411,6 +488,20 @@ <h2>8 · Ordered categories</h2>
 
 // bad=0, good=1, excellent=2
 console.log("codes:", ordered.cat.codes.toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+rating = pd.Series(["good", "bad", "excellent", "good"], dtype="category")
+
+# Establish a meaningful order
+ordered = rating.cat.reorder_categories(
+    ["bad", "good", "excellent"], ordered=True
+)
+
+print("ordered:", ordered.cat.ordered)
+print("categories:", ordered.cat.categories.tolist())
+
+# bad=0, good=1, excellent=2
+print("codes:", ordered.cat.codes.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/concat.html b/playground/concat.html
index fd19e7739..52f09e027 100644
--- a/playground/concat.html
+++ b/playground/concat.html
@@ -217,6 +217,13 @@ <h2>1 · Stack Series vertically (axis=0)</h2>
 
 const result = concat([s1, s2]);
 console.log(result.toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s1 = pd.Series([10, 20], index=["a", "b"])
+s2 = pd.Series([30, 40], index=["c", "d"])
+
+result = pd.concat([s1, s2])
+print(result.to_string())</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -242,6 +249,14 @@ <h2>2 · Stack DataFrames vertically (axis=0)</h2>
 // join="outer" by default — fills missing columns with null
 const result = concat([df1, df2]);
 console.log(result.toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df1 = pd.DataFrame({"a": [1, 2], "b": [3, 4]})
+df2 = pd.DataFrame({"b": [5], "c": [6]})
+
+# join="outer" by default — fills missing columns with NaN
+result = pd.concat([df1, df2])
+print(result.to_string())</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -276,6 +291,21 @@ <h2>3 · Column-wise concat (axis=1)</h2>
 
 console.log("\n=== DataFrame axis=1 ===");
 console.log(concat([left, right], { axis: 1 }).toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+# Series → DataFrame (each Series becomes a column)
+age = pd.Series([25, 30, 35], name="age")
+score = pd.Series([88, 92, 79], name="score")
+
+print("=== Series axis=1 ===")
+print(pd.concat([age, score], axis=1).to_string())
+
+# DataFrame side-by-side
+left = pd.DataFrame({"a": [1, 2], "b": [3, 4]})
+right = pd.DataFrame({"c": [5, 6], "d": [7, 8]})
+
+print("\n=== DataFrame axis=1 ===")
+print(pd.concat([left, right], axis=1).to_string())</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -317,6 +347,27 @@ <h2>4 · Join modes — outer vs inner</h2>
 
 console.log("\n=== axis=1, join='inner' (only shared row 'b') ===");
 console.log(concat([s1, s2], { axis: 1, join: "inner" }).toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+# axis=0: outer vs inner columns
+df1 = pd.DataFrame({"a": [1, 2], "b": [3, 4]})
+df2 = pd.DataFrame({"b": [5], "c": [6]})
+
+print("=== axis=0, join='outer' (default) ===")
+print(pd.concat([df1, df2]).to_string())
+
+print("\n=== axis=0, join='inner' (only shared col 'b') ===")
+print(pd.concat([df1, df2], join="inner").to_string())
+
+# axis=1: outer vs inner row indexes
+s1 = pd.Series([1, 2], index=["a", "b"], name="s1")
+s2 = pd.Series([3, 4], index=["b", "c"], name="s2")
+
+print("\n=== axis=1, join='outer' (union of row indexes) ===")
+print(pd.concat([s1, s2], axis=1).to_string())
+
+print("\n=== axis=1, join='inner' (only shared row 'b') ===")
+print(pd.concat([s1, s2], axis=1, join="inner").to_string())</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -349,6 +400,21 @@ <h2>5 · ignoreIndex — reset to RangeIndex</h2>
 
 console.log("\n=== DataFrame ignoreIndex ===");
 console.log(concat([df1, df2], { ignoreIndex: true }).toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+# Series with string indexes → reset to 0, 1, 2
+a = pd.Series([1, 2], index=["x", "y"])
+b = pd.Series([3], index=["z"])
+
+print("=== Series ignore_index ===")
+print(pd.concat([a, b], ignore_index=True).to_string())
+
+# DataFrame ignore_index
+df1 = pd.DataFrame({"v": [10, 20]})
+df2 = pd.DataFrame({"v": [30, 40]})
+
+print("\n=== DataFrame ignore_index ===")
+print(pd.concat([df1, df2], ignore_index=True).to_string())</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -390,6 +456,29 @@ <h2>🧪 Scratch Pad</h2>
 
 console.log("\n=== Side-by-side columns ===");
 console.log(concat([names, q1rev, q2rev], { axis: 1 }).toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+# Try it! Combine DataFrames in creative ways.
+q1 = pd.DataFrame({
+    "product": ["Widget", "Gadget"],
+    "revenue": [1000, 1500],
+})
+
+q2 = pd.DataFrame({
+    "product": ["Widget", "Gadget"],
+    "revenue": [1200, 1800],
+})
+
+print("=== Q1 + Q2 stacked ===")
+print(pd.concat([q1, q2], ignore_index=True).to_string())
+
+# Side-by-side with axis=1
+names = pd.Series(["Widget", "Gadget"], name="product")
+q1_rev = pd.Series([1000, 1500], name="q1_rev")
+q2_rev = pd.Series([1200, 1800], name="q2_rev")
+
+print("\n=== Side-by-side columns ===")
+print(pd.concat([names, q1_rev, q2_rev], axis=1).to_string())</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
diff --git a/playground/corr.html b/playground/corr.html
index e5c918cf9..13fe13133 100644
--- a/playground/corr.html
+++ b/playground/corr.html
@@ -236,6 +236,25 @@ <h2>1 · Series pearsonCorr</h2>
 
 // Require at least 5 valid pairs — returns NaN when fewer exist
 console.log("r (minPeriods=5):", pearsonCorr(c, d, { minPeriods: 5 }));</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+temperature = pd.Series([22, 24, 28, 31, 35], name="temp_C")
+ice_cream = pd.Series([120, 145, 190, 230, 285], name="sales")
+
+r = temperature.corr(ice_cream)
+print(f"Pearson r: {r:.4f}")   # strong positive correlation
+
+# Negative correlation
+warm_clothes = pd.Series([310, 280, 210, 150, 90], name="jackets")
+print(f"r (temp vs jackets): {temperature.corr(warm_clothes):.4f}")
+
+# Missing values are dropped per-pair
+c = pd.Series([1, None, 3, 4])
+d = pd.Series([2, 4, 6, 8])
+print(f"r (nulls dropped): {c.corr(d):.4f}")
+
+# Require at least 5 valid pairs — returns NaN when fewer exist
+print(f"r (minPeriods=5): {c.corr(d, min_periods=5)}")</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -277,6 +296,25 @@ <h2>2 · DataFrame corr matrix (dataFrameCorr)</h2>
 console.log("height–weight r:", rHW.toFixed(4));
 console.log("height–age r:   ", rHA.toFixed(4));
 console.log("diagonal:", [r.col("height").iat(0), r.col("weight").iat(1), r.col("age").iat(2)]);</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "height": [160, 172, 185, 155, 168],
+    "weight": [55, 72, 90, 48, 65],
+    "age": [22, 35, 28, 19, 31],
+    "city": ["A", "B", "C", "A", "B"],  # non-numeric — skipped
+})
+
+r = df.corr(numeric_only=True)
+print("columns:", list(r.columns))
+print("shape:", r.shape)
+
+# Read off-diagonal entries via iloc (positional access)
+r_hw = r["weight"].iloc[0]  # corr(height, weight)
+r_ha = r["age"].iloc[0]     # corr(height, age)
+print(f"height–weight r: {r_hw:.4f}")
+print(f"height–age r:    {r_ha:.4f}")
+print("diagonal:", [r["height"].iloc[0], r["weight"].iloc[1], r["age"].iloc[2]])</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -318,6 +356,25 @@ <h2>3 · DataFrame cov matrix (dataFrameCov)</h2>
 const varPop    = dataFrameCov(returns, { ddof: 0 }).col("AAPL").iat(0);
 console.log("\nAAPL sample variance:", varSample.toFixed(6));
 console.log("AAPL population variance:", varPop.toFixed(6));</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+returns = pd.DataFrame({
+    "AAPL": [0.02, 0.01, -0.03, 0.04, 0.01],
+    "GOOG": [0.01, 0.02, -0.02, 0.03, 0.02],
+    "TSLA": [-0.05, 0.08, -0.10, 0.12, -0.03],
+})
+
+cov = returns.cov()
+print("Covariance matrix:")
+for col in cov.columns:
+    vals = [f"{v:.6f}" for v in cov[col]]
+    print(f"{col}: {'  '.join(vals)}")
+
+# Compare sample (ddof=1) vs population (ddof=0) variance
+var_sample = returns.cov(ddof=1)["AAPL"].iloc[0]
+var_pop = returns.cov(ddof=0)["AAPL"].iloc[0]
+print(f"\nAAPL sample variance: {var_sample:.6f}")
+print(f"AAPL population variance: {var_pop:.6f}")</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -362,6 +419,31 @@ <h2>🧪 Scratch Pad</h2>
   const vals = [...dataFrameCov(df).col(col).values].map(v => (v).toFixed(2));
   console.log(col + ":", vals.join("  "));
 }</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+# Try it! Explore correlation and covariance.
+a = pd.Series([1, 2, 3, 4, 5])
+b = pd.Series([2, 4, 6, 8, 10])
+
+print("Perfect positive r:", a.corr(b))
+
+df = pd.DataFrame({
+    "x": [1, 2, 3, 4, 5],
+    "y": [5, 4, 3, 2, 1],
+    "z": [2, 4, 6, 8, 10],
+})
+
+print("\nCorrelation matrix:")
+corr = df.corr()
+for col in corr.columns:
+    vals = [f"{v:.2f}" for v in corr[col]]
+    print(f"{col}: {'  '.join(vals)}")
+
+print("\nCovariance matrix:")
+cov = df.cov()
+for col in cov.columns:
+    vals = [f"{v:.2f}" for v in cov[col]]
+    print(f"{col}: {'  '.join(vals)}")</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
diff --git a/playground/csv.html b/playground/csv.html
index e25df347c..898ae9cbd 100644
--- a/playground/csv.html
+++ b/playground/csv.html
@@ -215,6 +215,22 @@ <h2>1 · Parse a CSV string</h2>
 console.log("score dtype:", df.col("score").dtype.name);
 console.log("names:", [...df.col("name").values]);
 console.log("ages :", [...df.col("age").values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import io
+
+csv = """name,age,score
+alice,30,88.5
+bob,25,92.0
+carol,35,75.3"""
+
+df = pd.read_csv(io.StringIO(csv))
+print("shape:", df.shape)
+print("columns:", list(df.columns))
+print("name dtype :", df["name"].dtype)
+print("age dtype  :", df["age"].dtype)
+print("score dtype:", df["score"].dtype)
+print("names:", list(df["name"]))
+print("ages :", list(df["age"]))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -246,6 +262,19 @@ <h2>2 · Missing values (NA)</h2>
 const df = readCsv(csv, { naValues: ["?"] });
 console.log("x:", [...df.col("x").values]);
 console.log("y:", [...df.col("y").values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import io
+
+csv = """x,y
+1,
+2,NA
+3,?
+4,5"""
+
+# "?" added as an extra NA value
+df = pd.read_csv(io.StringIO(csv), na_values=["?"])
+print("x:", list(df["x"]))
+print("y:", list(df["y"]))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -275,6 +304,18 @@ <h2>3 · Quoted fields &amp; custom separator</h2>
 console.log("name[0]:", df.col("name").values[0]);
 console.log("note[1]:", df.col("note").values[1]);
 console.log("name[2]:", df.col("name").values[2]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import io
+
+csv = """name;note
+"Smith, Jr.";Senior developer
+"O'Brien";"Joined ""the team"" in 2020"
+Jones;Junior"""
+
+df = pd.read_csv(io.StringIO(csv), sep=";")
+print("name[0]:", df["name"].iloc[0])
+print("note[1]:", df["note"].iloc[1])
+print("name[2]:", df["name"].iloc[2])</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -304,6 +345,18 @@ <h2>4 · Index column</h2>
 console.log("index:", [...df.index.values]);
 console.log("columns:", [...df.columns.values]);
 console.log("city at A:", df.col("city").at("A"));</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import io
+
+csv = """id,city,pop
+A,London,9000000
+B,Paris,2200000
+C,Berlin,3700000"""
+
+df = pd.read_csv(io.StringIO(csv), index_col="id")
+print("index:", list(df.index))
+print("columns:", list(df.columns))
+print("city at A:", df.loc["A", "city"])</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -336,6 +389,21 @@ <h2>5 · Limiting rows</h2>
 
 const skip2 = readCsv(csv, { skipRows: 2 });
 console.log("skipRows=2:", [...skip2.col("val").values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import io
+
+csv = """val
+10
+20
+30
+40
+50"""
+
+first3 = pd.read_csv(io.StringIO(csv), nrows=3)
+print("nrows=3:", list(first3["val"]))
+
+skip2 = pd.read_csv(io.StringIO(csv), skiprows=range(1, 3))
+print("skiprows=2:", list(skip2["val"]))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -373,6 +441,25 @@ <h2>6 · Serialize with toCsv</h2>
 const df2 = DataFrame.fromColumns({ x: [1, null, 3] });
 console.log("--- semicolons + NA rep ---");
 console.log(toCsv(df2, { sep: ";", index: false, naRep: "MISSING" }));</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "name": ["alice", "bob", "carol"],
+    "score": [88, 92, 75],
+})
+
+# Default: includes index and header
+print("--- with index ---")
+print(df.to_csv())
+
+# Without index
+print("--- no index ---")
+print(df.to_csv(index=False))
+
+# Semicolon separator, custom NA rep
+df2 = pd.DataFrame({"x": [1, None, 3]})
+print("--- semicolons + NA rep ---")
+print(df2.to_csv(sep=";", index=False, na_rep="MISSING"))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -407,6 +494,23 @@ <h2>7 · Round-trip</h2>
 console.log("restored y:", [...restored.col("y").values]);
 console.log("restored label:", [...restored.col("label").values]);
 console.log("shapes match:", JSON.stringify(original.shape) === JSON.stringify(restored.shape));</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import io
+
+original = pd.DataFrame({
+    "x": [1, 2, 3, 4, 5],
+    "y": [10.1, 20.2, 30.3, 40.4, 50.5],
+    "label": ["a", "b", "c", "d", "e"],
+})
+
+csv = original.to_csv(index=False)
+print("CSV:\n" + csv)
+
+restored = pd.read_csv(io.StringIO(csv))
+print("restored x:", list(restored["x"]))
+print("restored y:", list(restored["y"]))
+print("restored label:", list(restored["label"]))
+print("shapes match:", original.shape == restored.shape)</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/cum_ops.html b/playground/cum_ops.html
index b9f5e7c59..1390c9320 100644
--- a/playground/cum_ops.html
+++ b/playground/cum_ops.html
@@ -204,6 +204,11 @@ <h2>1 · cumsum: running total</h2>
 const s = new Series({ data: [1, 2, 3, 4, 5] });
 const cs = cumsum(s);
 console.log("cumsum:", [...cs.values]); // [1, 3, 6, 10, 15]</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([1, 2, 3, 4, 5])
+cs = s.cumsum()
+print("cumsum:", cs.tolist())  # [1, 3, 6, 10, 15]</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -228,6 +233,11 @@ <h2>2 · cumprod: running product</h2>
 const s = new Series({ data: [1, 2, 3, 4, 5] });
 const cp = cumprod(s);
 console.log("cumprod:", [...cp.values]); // [1, 2, 6, 24, 120]</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([1, 2, 3, 4, 5])
+cp = s.cumprod()
+print("cumprod:", cp.tolist())  # [1, 2, 6, 24, 120]</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -252,6 +262,11 @@ <h2>3 · cummax and cummin</h2>
 const s = new Series({ data: [3, 1, 4, 1, 5, 9, 2, 6] });
 console.log("cummax:", [...cummax(s).values]); // [3, 3, 4, 4, 5, 9, 9, 9]
 console.log("cummin:", [...cummin(s).values]); // [3, 1, 1, 1, 1, 1, 1, 1]</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([3, 1, 4, 1, 5, 9, 2, 6])
+print("cummax:", s.cummax().tolist())  # [3, 3, 4, 4, 5, 9, 9, 9]
+print("cummin:", s.cummin().tolist())  # [3, 1, 1, 1, 1, 1, 1, 1]</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -283,6 +298,18 @@ <h2>4 · Handling missing values (skipna)</h2>
 // skipna: false — NaN at position 1 poisons everything after
 const skipFalse = cumsum(s, { skipna: false });
 console.log("skipna=false:", [...skipFalse.values]); // [1, NaN, NaN, NaN]</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import numpy as np
+
+s = pd.Series([1, None, 3, 4])
+
+# skipna: True (default) — NaN at position 1, accumulator continues
+skip_true = s.cumsum()
+print("skipna=true: ", skip_true.tolist())  # [1, NaN, 4, 8]
+
+# skipna: False — NaN at position 1 poisons everything after
+skip_false = s.cumsum(skipna=False)
+print("skipna=false:", skip_false.tolist())  # [1, NaN, NaN, NaN]</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -314,6 +341,19 @@ <h2>5 · DataFrame: axis=0 (column-wise)</h2>
 
 const cmDf = dataFrameCummax(df);
 console.log("cummax revenue:", [...cmDf.col("revenue").values]); // [100, 150, 200, 200]</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "revenue": [100, 150, 200, 120],
+    "cost":    [60,  80,  110, 70],
+})
+
+cs_df = df.cumsum()
+print("cumsum revenue:", cs_df["revenue"].tolist())  # [100, 250, 450, 570]
+print("cumsum cost:   ", cs_df["cost"].tolist())      # [60, 140, 250, 320]
+
+cm_df = df.cummax()
+print("cummax revenue:", cm_df["revenue"].tolist())  # [100, 150, 200, 200]</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -346,6 +386,19 @@ <h2>6 · DataFrame: axis=1 (row-wise)</h2>
 console.log("q1 (unchanged):", [...ytd.col("q1").values]); // [10, 20, 30]
 console.log("q2 (q1+q2):   ", [...ytd.col("q2").values]); // [25, 45, 65]
 console.log("q3 (q1+q2+q3):", [...ytd.col("q3").values]); // [37, 67, 97]</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "q1": [10, 20, 30],
+    "q2": [15, 25, 35],
+    "q3": [12, 22, 32],
+})
+
+# axis=1: running total across quarters for each year-row
+ytd = df.cumsum(axis=1)
+print("q1 (unchanged):", ytd["q1"].tolist())  # [10, 20, 30]
+print("q2 (q1+q2):   ", ytd["q2"].tolist())   # [25, 45, 65]
+print("q3 (q1+q2+q3):", ytd["q3"].tolist())   # [37, 67, 97]</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -383,6 +436,20 @@ <h2>7 · Real-world example: portfolio tracking</h2>
 console.log("Equity curve: ", [...equity.values]);
 console.log("All-time high:", [...peak.values]);
 console.log("Drawdown:     ", [...drawdown.values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+# Daily P&L in dollars
+pnl = pd.Series([200, -50, 300, -150, 400, -80, 600])
+
+equity = pnl.cumsum()
+peak   = equity.cummax()
+
+# Drawdown: how far below the all-time high we currently are
+drawdown = equity - peak
+
+print("Equity curve: ", equity.tolist())
+print("All-time high:", peak.tolist())
+print("Drawdown:     ", drawdown.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -408,6 +475,13 @@ <h2>8 · String series: lexicographic cummax / cummin</h2>
 // ["banana", "banana", "cherry", "cherry", "cherry"]
 console.log("cummin:", [...cummin(words).values]);
 // ["banana", "apple",  "apple",  "apple",  "apple"]</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+words = pd.Series(["banana", "apple", "cherry", "apricot", "date"])
+print("cummax:", words.cummax().tolist())
+# ["banana", "banana", "cherry", "cherry", "cherry"]
+print("cummin:", words.cummin().tolist())
+# ["banana", "apple",  "apple",  "apple",  "apple"]</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/dataframe.html b/playground/dataframe.html
index e0b506976..5a7b5bdd1 100644
--- a/playground/dataframe.html
+++ b/playground/dataframe.html
@@ -238,6 +238,28 @@ <h2>Construction</h2>
   ["a", "b"],
 );
 console.log("\nfrom2D col 'a' values:", df3.col("a").values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+# Dict of columns — most common
+df1 = pd.DataFrame({
+    "name":  ["Alice", "Bob", "Carol"],
+    "age":   [30, 25, 35],
+    "score": [90, 80, 95],
+})
+print("DataFrame from dict:")
+print(df1.to_string())
+
+# from_records — list of dicts
+df2 = pd.DataFrame.from_records([
+    {"city": "London", "pop": 9_000_000},
+    {"city": "Tokyo",  "pop": 14_000_000},
+    {"city": "NYC",    "pop": 8_300_000},
+])
+print("\nfrom_records shape:", df2.shape)
+
+# From 2D array with column names
+df3 = pd.DataFrame([[1, 4], [2, 5], [3, 6]], columns=["a", "b"])
+print("\nfrom 2D col 'a' values:", df3["a"].values)</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -269,6 +291,20 @@ <h2>Properties</h2>
 console.log("empty:", df.empty);     // false
 console.log("index:", df.index.toString());
 console.log("columns:", df.columns.toString());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "name":  ["Alice", "Bob", "Carol"],
+    "age":   [30, 25, 35],
+    "score": [90, 80, 95],
+})
+
+print("shape:", df.shape)      # (rows, cols)
+print("ndim:", df.ndim)        # always 2
+print("size:", df.size)        # rows × cols
+print("empty:", df.empty)      # False
+print("index:", df.index.tolist())
+print("columns:", df.columns.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -308,6 +344,27 @@ <h2>Column Access</h2>
 
 // Chain into Series methods
 console.log("mean age:", df.col("age").mean());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "name":  ["Alice", "Bob", "Carol"],
+    "age":   [30, 25, 35],
+    "score": [90, 80, 95],
+})
+
+# df["col"] returns a Series — raises KeyError if missing
+print("df['age']:", df["age"].to_string())
+
+# .get("col") returns Series or default
+print("get('score'):", df.get("score").values)
+print("get('nope'):", df.get("nope"))
+
+# Check existence
+print("'name' in columns:", "name" in df.columns)
+print("'xyz' in columns:", "xyz" in df.columns)
+
+# Chain into Series methods
+print("mean age:", df["age"].mean())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -349,6 +406,29 @@ <h2>Slicing</h2>
 );
 console.log("\nloc(['a', 'c']):");
 console.log(labeled.loc(["a", "c"]).toString());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "name":  ["Alice", "Bob", "Carol", "Dave", "Eve"],
+    "score": [90, 80, 95, 70, 85],
+})
+
+print("head(2):")
+print(df.head(2).to_string())
+
+print("\ntail(2):")
+print(df.tail(2).to_string())
+
+print("\niloc[[0, 2, 4]]:")
+print(df.iloc[[0, 2, 4]].to_string())
+
+# loc uses index labels
+labeled = pd.DataFrame(
+    {"val": [10, 20, 30]},
+    index=["a", "b", "c"],
+)
+print("\nloc[['a', 'c']]:")
+print(labeled.loc[["a", "c"]].to_string())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -395,6 +475,33 @@ <h2>Column Mutations</h2>
 const renamed = df.rename({ age: "years" });
 console.log("\nrename({ age: 'years' }):");
 console.log(renamed.columns.values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "name":  ["Alice", "Bob", "Carol"],
+    "age":   [30, 25, 35],
+    "score": [90, 80, 95],
+})
+
+# assign — add or replace columns
+with_bonus = df.assign(bonus=[5, 10, 15])
+print("assign:")
+print(with_bonus.to_string())
+
+# drop — remove columns
+dropped = df.drop(columns=["score"])
+print("\ndrop(['score']):")
+print(dropped.to_string())
+
+# select — reorder / subset columns
+selected = df[["score", "name"]]
+print("\nselect(['score', 'name']):")
+print(selected.to_string())
+
+# rename — rename columns
+renamed = df.rename(columns={"age": "years"})
+print("\nrename({'age': 'years'}):")
+print(renamed.columns.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -432,6 +539,26 @@ <h2>Missing Values</h2>
 // fillna — replace nulls with a value
 console.log("\nfillna(0):");
 console.log(df.fillna(0).toString());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "a": [1, None, 3],
+    "b": [4, 5, None],
+})
+
+print("isna():")
+print(df.isna().to_string())
+
+print("\nnotna():")
+print(df.notna().to_string())
+
+# dropna — keep only rows with no nulls
+print("\ndropna() shape:", df.dropna().shape)
+print(df.dropna().to_string())
+
+# fillna — replace nulls with a value
+print("\nfillna(0):")
+print(df.fillna(0).to_string())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -466,6 +593,21 @@ <h2>Aggregations</h2>
 
 console.log("\ndescribe():");
 console.log(df.describe().toString());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "a": [10, 20, 30],
+    "b": [1, 2, 3],
+})
+
+print("sum:  ", df.sum().to_string())
+print("mean: ", df.mean().to_string())
+print("min:  ", df.min().to_string())
+print("max:  ", df.max().to_string())
+print("count:", df.count().to_string())
+
+print("\ndescribe():")
+print(df.describe().to_string())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -506,6 +648,28 @@ <h2>Sorting</h2>
 );
 console.log("\nsortIndex():");
 console.log(labeled.sortIndex().toString());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "name":  ["Alice", "Bob", "Carol"],
+    "score": [90, 80, 95],
+})
+
+# Sort ascending by score
+print("sort_values('score'):")
+print(df.sort_values("score").to_string())
+
+# Sort descending
+print("\nsort_values('score', ascending=False):")
+print(df.sort_values("score", ascending=False).to_string())
+
+# Sort by index
+labeled = pd.DataFrame(
+    {"val": [30, 10, 20]},
+    index=["c", "a", "b"],
+)
+print("\nsort_index():")
+print(labeled.sort_index().to_string())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -548,6 +712,28 @@ <h2>Apply &amp; Iteration</h2>
 for (const [label, row] of df.iterrows()) {
   console.log(`  row ${label}:`, row.values);
 }</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "a": [1, 2, 3],
+    "b": [4, 5, 6],
+})
+
+# apply axis=0 — aggregate each column
+print("apply(sum, axis=0):", df.apply(sum, axis=0).to_string())
+
+# apply axis=1 — aggregate each row
+print("apply(sum, axis=1):", df.apply(sum, axis=1).to_string())
+
+# items() — iterate over (col_name, Series) pairs
+print("\nitems():")
+for name, col in df.items():
+    print(f"  {name}: sum = {col.sum()}")
+
+# iterrows() — iterate over (label, row_series) pairs
+print("\niterrows():")
+for label, row in df.iterrows():
+    print(f"  row {label}:", row.values)</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -590,6 +776,29 @@ <h2>Conversion</h2>
 console.log("\nresetIndex():");
 console.log(reset.toString());
 console.log("columns:", reset.columns.values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "name":  ["Alice", "Bob"],
+    "score": [90, 80],
+})
+
+print("to_dict('records'):", df.to_dict("records"))
+print("to_dict('list'):", df.to_dict("list"))
+print("values:", df.values.tolist())
+
+# set_index — promote a column to the row index
+indexed = df.set_index("name")
+print("\nset_index('name'):")
+print(indexed.to_string())
+print("index values:", indexed.index.tolist())
+print("columns:", indexed.columns.tolist())
+
+# reset_index — restore a numeric index
+reset = indexed.reset_index()
+print("\nreset_index():")
+print(reset.to_string())
+print("columns:", reset.columns.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -622,6 +831,20 @@ <h2>🧪 Try It Yourself</h2>
 console.log("Avg price:", sales.col("price").mean());
 console.log("\nSorted by price (desc):");
 console.log(sales.sortValues("price", false).toString());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+# Build a DataFrame, explore, and transform!
+sales = pd.DataFrame([
+    {"product": "Widget", "qty": 100, "price": 9.99},
+    {"product": "Gadget", "qty": 50,  "price": 24.99},
+    {"product": "Doohickey", "qty": 200, "price": 4.99},
+])
+
+print(sales.to_string())
+print("\nTotal qty:", sales["qty"].sum())
+print("Avg price:", sales["price"].mean())
+print("\nSorted by price (desc):")
+print(sales.sort_values("price", ascending=False).to_string())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/datetime_accessor.html b/playground/datetime_accessor.html
index 110997cac..83aaaa4fd 100644
--- a/playground/datetime_accessor.html
+++ b/playground/datetime_accessor.html
@@ -215,6 +215,20 @@ <h2>1 · Calendar Components</h2>
 console.log("hour  :", dates.dt.hour().toArray());
 console.log("minute:", dates.dt.minute().toArray());
 console.log("second:", dates.dt.second().toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+dates = pd.Series([
+    pd.Timestamp("2024-01-15T09:30:00"),
+    pd.Timestamp("2024-07-04T18:00:00"),
+    pd.Timestamp("2024-12-31T23:59:59"),
+], name="events")
+
+print("year  :", dates.dt.year.tolist())
+print("month :", dates.dt.month.tolist())
+print("day   :", dates.dt.day.tolist())
+print("hour  :", dates.dt.hour.tolist())
+print("minute:", dates.dt.minute.tolist())
+print("second:", dates.dt.second.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -247,6 +261,18 @@ <h2>2 · Day of Week &amp; Quarter</h2>
 console.log("dayofweek:", dates.dt.dayofweek().toArray());
 console.log("quarter  :", dates.dt.quarter().toArray());
 console.log("dayofyear:", dates.dt.dayofyear().toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+dates = pd.Series([
+    pd.Timestamp("2024-07-15"),  # Monday
+    pd.Timestamp("2024-07-14"),  # Sunday
+    pd.Timestamp("2024-04-01"),  # Q2 start
+    pd.Timestamp("2024-10-15"),  # Q4
+])
+
+print("dayofweek:", dates.dt.dayofweek.tolist())
+print("quarter  :", dates.dt.quarter.tolist())
+print("dayofyear:", dates.dt.dayofyear.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -282,6 +308,22 @@ <h2>3 · Boolean Properties</h2>
 console.log("is_year_end   :", dates.dt.is_year_end().toArray());
 console.log("is_leap_year  :", dates.dt.is_leap_year().toArray());
 console.log("days_in_month :", dates.dt.days_in_month().toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+dates = pd.Series([
+    pd.Timestamp("2024-01-01"),  # year start
+    pd.Timestamp("2024-03-31"),  # Q1 end, month end
+    pd.Timestamp("2024-02-29"),  # month end (leap year)
+    pd.Timestamp("2024-12-31"),  # year end
+    pd.Timestamp("2024-07-15"),  # ordinary day
+])
+
+print("is_year_start :", dates.dt.is_year_start.tolist())
+print("is_quarter_end:", dates.dt.is_quarter_end.tolist())
+print("is_month_end  :", dates.dt.is_month_end.tolist())
+print("is_year_end   :", dates.dt.is_year_end.tolist())
+print("is_leap_year  :", dates.dt.is_leap_year.tolist())
+print("days_in_month :", dates.dt.days_in_month.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -313,6 +355,18 @@ <h2>4 · strftime Formatting</h2>
 console.log("Datetime   :", dates.dt.strftime("%Y-%m-%d %H:%M:%S").toArray());
 console.log("Friendly   :", dates.dt.strftime("%A, %B %d %Y").toArray());
 console.log("Short month:", dates.dt.strftime("%b %d, %Y").toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+dates = pd.Series([
+    pd.Timestamp("2024-03-15T09:05:03"),
+    pd.Timestamp("2024-12-31T23:59:59"),
+])
+
+print("ISO date   :", dates.dt.strftime("%Y-%m-%d").tolist())
+print("US date    :", dates.dt.strftime("%m/%d/%Y").tolist())
+print("Datetime   :", dates.dt.strftime("%Y-%m-%d %H:%M:%S").tolist())
+print("Friendly   :", dates.dt.strftime("%A, %B %d %Y").tolist())
+print("Short month:", dates.dt.strftime("%b %d, %Y").tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -347,6 +401,15 @@ <h2>5 · Normalization &amp; Rounding</h2>
 console.log("floor(H) :", ts.dt.floor("H").toArray().map(fmt));
 console.log("ceil(H)  :", ts.dt.ceil("H").toArray().map(fmt));
 console.log("round(T) :", ts.dt.round("T").toArray().map(fmt));</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+ts = pd.Series([pd.Timestamp("2024-03-15T14:37:28.750")])
+
+print("original :", ts.dt.strftime("%H:%M:%S").tolist())
+print("normalize:", ts.dt.normalize().tolist())
+print("floor(H) :", ts.dt.floor("h").tolist())
+print("ceil(H)  :", ts.dt.ceil("h").tolist())
+print("round(T) :", ts.dt.round("min").tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -373,6 +436,17 @@ <h2>6 · Null Propagation</h2>
 console.log("year  :", mixed.dt.year().toArray());
 console.log("month :", mixed.dt.month().toArray());
 console.log("fmt   :", mixed.dt.strftime("%Y-%m-%d").toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+mixed = pd.Series([
+    pd.Timestamp("2024-01-15"),
+    None,
+    pd.Timestamp("2024-07-04"),
+])
+
+print("year  :", mixed.dt.year.tolist())
+print("month :", mixed.dt.month.tolist())
+print("fmt   :", mixed.dt.strftime("%Y-%m-%d").tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -399,6 +473,13 @@ <h2>7 · total_seconds &amp; date()</h2>
 
 console.log("total_seconds:", dates.dt.total_seconds().toArray());
 console.log("date         :", dates.dt.date().toArray().map(d => d.toISOString()));</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+dates = pd.Series([pd.Timestamp("2024-01-01T12:30:00", tz="UTC")])
+
+epoch = pd.Timestamp("1970-01-01", tz="UTC")
+print("total_seconds:", (dates - epoch).dt.total_seconds().tolist())
+print("date         :", dates.dt.date.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -441,6 +522,29 @@ <h2>8 · Combining dt with Other Operations</h2>
 // Month names via strftime
 const monthNames = dates.dt.strftime("%B");
 console.log("Month names    :", monthNames.toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+dates = pd.Series([
+    pd.Timestamp("2024-01-15"),
+    pd.Timestamp("2024-06-20"),
+    pd.Timestamp("2024-11-07"),
+])
+
+# Format as ISO strings
+formatted = dates.dt.strftime("%Y-%m-%d")
+print("Formatted dates:", formatted.tolist())
+
+# Group by quarter
+quarters = dates.dt.quarter
+print("Quarters       :", quarters.tolist())
+
+# Day of week (Mon=0 … Sun=6)
+dow = dates.dt.dayofweek
+print("Day of week    :", dow.tolist())
+
+# Month names via strftime
+month_names = dates.dt.strftime("%B")
+print("Month names    :", month_names.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/describe.html b/playground/describe.html
index 30b4d1a9b..617ef8e44 100644
--- a/playground/describe.html
+++ b/playground/describe.html
@@ -215,6 +215,19 @@ <h2>1 · Describe a numeric Series</h2>
 console.log("50%   :", stats.at("50%"));
 console.log("75%   :", stats.at("75%"));
 console.log("max   :", stats.at("max"));</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([4, 7, 13, 16, 21, 3, 9, 12], name="scores")
+
+stats = s.describe()
+print("count :", stats["count"])
+print("mean  :", f"{stats['mean']:.2f}")
+print("std   :", f"{stats['std']:.2f}")
+print("min   :", stats["min"])
+print("25%   :", stats["25%"])
+print("50%   :", stats["50%"])
+print("75%   :", stats["75%"])
+print("max   :", stats["max"])</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -248,6 +261,20 @@ <h2>2 · Custom percentiles</h2>
 for (const label of stats.index.values) {
   console.log(`${label.toString().padEnd(5)}: ${Number(stats.at(label)).toFixed(2)}`);
 }</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+prices = pd.Series(
+    [100, 200, 150, 300, 250, 180, 90, 400, 210, 175],
+    name="price",
+)
+
+# Get deciles: 10th through 90th percentile
+stats = prices.describe(
+    percentiles=[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9],
+)
+print(stats.index.tolist())
+for label in stats.index:
+    print(f"{str(label).ljust(5)}: {stats[label]:.2f}")</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -279,6 +306,18 @@ <h2>3 · Describe a categorical Series</h2>
 console.log("unique:", stats.at("unique"));
 console.log("top   :", stats.at("top"));
 console.log("freq  :", stats.at("freq"));</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+dept = pd.Series(
+    ["Engineering", "Marketing", "Engineering", "HR", "Engineering", None, "Marketing"],
+    name="department",
+)
+
+stats = dept.describe()
+print("count :", stats["count"])
+print("unique:", stats["unique"])
+print("top   :", stats["top"])
+print("freq  :", stats["freq"])</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -315,6 +354,22 @@ <h2>4 · Describe a DataFrame</h2>
     .join("   ");
   console.log(`${String(label).padEnd(8)} ${row}`);
 }</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "age":    [25, 30, 35, 28, 45, 22, 31, 40],
+    "salary": [50000, 70000, 90000, 62000, 110000, 45000, 75000, 95000],
+    "score":  [82, 90, 88, 76, 95, 70, 85, 92],
+})
+
+summary = df.describe()
+
+# Print row by row
+for label in summary.index:
+    row = "   ".join(
+        f"{col}: {summary[col][label]:.1f}" for col in summary.columns
+    )
+    print(f"{str(label).ljust(8)} {row}")</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -358,6 +413,30 @@ <h2>5 · include="all" for mixed DataFrames</h2>
   const v = summary.col("score").at(lbl);
   if (v !== null) console.log(`${String(lbl).padEnd(8)}: ${Number(v).toFixed(2)}`);
 }</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "name":  ["Alice", "Bob", "Alice", "Carol", "Bob"],
+    "score": [88, 92, 75, 95, 83],
+})
+
+summary = df.describe(include="all")
+print("rows :", summary.index.tolist())
+print("cols :", summary.columns.tolist())
+
+# Show the name (categorical) stats
+print("\n--- name column ---")
+for lbl in summary.index:
+    v = summary["name"][lbl]
+    if pd.notna(v):
+        print(f"{str(lbl).ljust(8)}: {v}")
+
+# Show the score (numeric) stats
+print("\n--- score column ---")
+for lbl in summary.index:
+    v = summary["score"][lbl]
+    if pd.notna(v):
+        print(f"{str(lbl).ljust(8)}: {float(v):.2f}")</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -391,6 +470,20 @@ <h2>6 · Series.quantile()</h2>
 console.log("\nmedian()     :", s.median());
 console.log("quantile(0.5):", s.quantile(0.5));
 console.log("Equal?       :", s.quantile(0.5) === s.median());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([3, 7, 1, 9, 5, 11, 2, 8, 4, 6])
+
+print("Q0   (min)   :", s.quantile(0))
+print("Q0.25 (Q1)   :", s.quantile(0.25))
+print("Q0.5  (med)  :", s.quantile(0.5))
+print("Q0.75 (Q3)   :", s.quantile(0.75))
+print("Q1   (max)   :", s.quantile(1))
+
+# Compare with median()
+print("\nmedian()     :", s.median())
+print("quantile(0.5):", s.quantile(0.5))
+print("Equal?       :", s.quantile(0.5) == s.median())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -433,6 +526,30 @@ <h2>7 · Standalone quantile() utility</h2>
   if (v < lower || v > upper) console.log(`  OUTLIER: ${v}`);
 }
 console.log("No outliers found in this dataset.");</textarea>
+      <textarea class="playground-python" style="display:none">import numpy as np
+
+# Pre-sorted exam scores
+sorted_scores = [42, 55, 61, 67, 72, 78, 81, 85, 90, 95]
+
+# IQR = Q3 - Q1
+q1 = np.quantile(sorted_scores, 0.25)
+q3 = np.quantile(sorted_scores, 0.75)
+iqr = q3 - q1
+
+print("Q1  :", q1)
+print("Q3  :", q3)
+print("IQR :", iqr)
+
+# Detect outliers: values outside [Q1 - 1.5·IQR, Q3 + 1.5·IQR]
+lower = q1 - 1.5 * iqr
+upper = q3 + 1.5 * iqr
+print(f"Fence: [{lower:.1f}, {upper:.1f}]")
+
+# Check each value
+for v in sorted_scores:
+    if v < lower or v > upper:
+        print(f"  OUTLIER: {v}")
+print("No outliers found in this dataset.")</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/dtype.html b/playground/dtype.html
index 5381c603e..566212571 100644
--- a/playground/dtype.html
+++ b/playground/dtype.html
@@ -231,6 +231,27 @@ <h2>Creating Dtypes</h2>
 ];
 console.log("All dtypes:", all.map(d => d.name).join(", "));
 console.log("Total count:", all.length);</textarea>
+      <textarea class="playground-python" style="display:none">import numpy as np
+
+# Factory method — returns dtype object
+dt = np.dtype("int64")
+print("dtype('int64'):", dt)
+
+# Dtype comparison — same object identity
+print("np.dtype('int64') == dtype('int64'):", np.dtype("int64") == dt)
+
+# Common NumPy/pandas dtypes
+all_dtypes = [
+    np.dtype("int8"), np.dtype("int16"), np.dtype("int32"), np.dtype("int64"),
+    np.dtype("uint8"), np.dtype("uint16"), np.dtype("uint32"), np.dtype("uint64"),
+    np.dtype("float32"), np.dtype("float64"),
+    np.dtype("bool"), np.dtype("U"),    # string
+    np.dtype("O"),                       # object
+    np.dtype("datetime64[ns]"), np.dtype("timedelta64[ns]"),
+    # category is pd.CategoricalDtype(), not a numpy dtype
+]
+print("All dtypes:", ", ".join(d.name for d in all_dtypes))
+print("Total count:", len(all_dtypes))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -264,6 +285,28 @@ <h2>Kind Classification</h2>
 for (const d of checks) {
   console.log(`${d.name}: isBool=${d.isBool}, isString=${d.isString}, isDatetime=${d.isDatetime}, isTimedelta=${d.isTimedelta}, isCategory=${d.isCategory}, isObject=${d.isObject}`);
 }</textarea>
+      <textarea class="playground-python" style="display:none">import numpy as np
+
+dt = np.dtype("int32")
+print("dtype:", dt.name, "  kind:", dt.kind)
+print("isNumeric:", np.issubdtype(dt, np.number))
+print("isInteger:", np.issubdtype(dt, np.integer))
+print("isSignedInteger:", np.issubdtype(dt, np.signedinteger))
+print("isUnsignedInteger:", np.issubdtype(dt, np.unsignedinteger))
+print("isFloat:", np.issubdtype(dt, np.floating))
+
+print("\n--- Non-numeric types ---")
+checks = {
+    "bool": np.dtype("bool"),
+    "string": np.dtype("U"),
+    "datetime64[ns]": np.dtype("datetime64[ns]"),
+    "timedelta64[ns]": np.dtype("timedelta64[ns]"),
+    "object": np.dtype("O"),
+}
+for name, d in checks.items():
+    print(f"{name}: is_bool={d.kind == 'b'}, is_string={d.kind == 'U'}, "
+          f"is_datetime={d.kind == 'M'}, is_timedelta={d.kind == 'm'}, "
+          f"is_object={d.kind == 'O'}")</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -298,6 +341,20 @@ <h2>Item Sizes</h2>
   const pad = d.name.padEnd(13);
   console.log(`${pad}${d.itemsize}`);
 }</textarea>
+      <textarea class="playground-python" style="display:none">import numpy as np
+
+dtypes = [
+    np.dtype("int8"), np.dtype("int16"), np.dtype("int32"), np.dtype("int64"),
+    np.dtype("uint8"), np.dtype("uint16"), np.dtype("uint32"), np.dtype("uint64"),
+    np.dtype("float32"), np.dtype("float64"),
+    np.dtype("bool"), np.dtype("U1"), np.dtype("O"),
+    np.dtype("datetime64[ns]"), np.dtype("timedelta64[ns]"),
+]
+
+print("Dtype        Itemsize (bytes)")
+print("─────────────────────────────")
+for d in dtypes:
+    print(f"{d.name:<13}{d.itemsize}")</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -337,6 +394,29 @@ <h2>Type Casting</h2>
 
 // Cross-family: int → float
 console.log("int32 → float64:", Dtype.int32.canCastTo(Dtype.float64));</textarea>
+      <textarea class="playground-python" style="display:none">import numpy as np
+
+# numpy.can_cast checks safe type promotion
+
+# Widening: smaller int → larger int is safe
+print("int8 → int32:", np.can_cast("int8", "int32"))
+print("int32 → int64:", np.can_cast("int32", "int64"))
+
+# Narrowing: larger → smaller is NOT safe
+print("int64 → int8:", np.can_cast("int64", "int8"))
+
+# Unsigned → signed needs extra headroom
+print("uint8 → int16:", np.can_cast("uint8", "int16"))
+print("uint8 → int8:", np.can_cast("uint8", "int8"))
+
+# Bool → numeric is safe
+print("bool → float64:", np.can_cast("bool", "float64"))
+
+# String → object
+print("string → object:", np.can_cast("U10", "O"))
+
+# Cross-family: int → float
+print("int32 → float64:", np.can_cast("int32", "float64"))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -374,6 +454,26 @@ <h2>Common Type Resolution</h2>
 // Incompatible → object
 console.log("string + int32:", Dtype.commonType(Dtype.string, Dtype.int32).name);
 console.log("datetime + float64:", Dtype.commonType(Dtype.datetime, Dtype.float64).name);</textarea>
+      <textarea class="playground-python" style="display:none">import numpy as np
+
+# np.result_type finds the common type for two dtypes
+
+# Same type → same type
+print("int32 + int32:", np.result_type("int32", "int32"))
+
+# Promotion within family
+print("int8 + int64:", np.result_type("int8", "int64"))
+print("float32 + float64:", np.result_type("float32", "float64"))
+
+# Mixed int + float → float64
+print("int32 + float32:", np.result_type("int32", "float32"))
+
+# Bool + numeric → numeric
+print("bool + int64:", np.result_type("bool", "int64"))
+
+# Incompatible → object (pandas falls back to object)
+print("string + int32: object  # pandas falls back to object")
+print("datetime + float64: object  # pandas falls back to object")</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -418,6 +518,36 @@ <h2>Type Inference</h2>
 
 // Nulls are ignored during inference
 console.log("with nulls:", Dtype.inferFrom([null, 42, null]).name);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+from pandas.api.types import infer_dtype
+from datetime import datetime
+
+# pandas infer_dtype detects the type from values
+
+# All booleans → boolean
+print("booleans:", infer_dtype([True, False, True], skipna=True))
+
+# All integers → integer
+print("integers:", infer_dtype([1, 2, 3, 100], skipna=True))
+
+# Floats or NaN → floating
+print("floats:", infer_dtype([1.5, 2.7, 3.14], skipna=True))
+print("with NaN:", infer_dtype([1, float("nan"), 3], skipna=True))
+
+# Dates → datetime
+print("dates:", infer_dtype([datetime.now(), datetime(2024, 1, 1)], skipna=True))
+
+# Strings → string
+print("strings:", infer_dtype(["hello", "world"], skipna=True))
+
+# Mixed types → mixed
+print("mixed:", infer_dtype([1, "hello", True], skipna=True))
+
+# Empty → empty
+print("empty:", infer_dtype([], skipna=True))
+
+# Nulls are ignored during inference
+print("with nulls:", infer_dtype([None, 42, None], skipna=True))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -452,6 +582,24 @@ <h2>🧪 Try It Yourself</h2>
   const row = numericTypes.map(to => (from.canCastTo(to) ? "✓" : "✗").padEnd(8)).join("");
   console.log(`${from.name.padEnd(10)}${row}`);
 }</textarea>
+      <textarea class="playground-python" style="display:none">import numpy as np
+
+# Explore dtype relationships
+numeric_types = [
+    np.dtype("int8"), np.dtype("int16"), np.dtype("int32"),
+    np.dtype("int64"), np.dtype("float32"), np.dtype("float64"),
+]
+
+# Build a casting compatibility matrix
+print("Casting matrix (row → col):")
+header = "          " + "".join(d.name.ljust(8) for d in numeric_types)
+print(header)
+for src in numeric_types:
+    row = "".join(
+        ("✓" if np.can_cast(src, dst) else "✗").ljust(8)
+        for dst in numeric_types
+    )
+    print(f"{src.name:<10}{row}")</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/elem_ops.html b/playground/elem_ops.html
index 1ff9d3f80..2c1aedaae 100644
--- a/playground/elem_ops.html
+++ b/playground/elem_ops.html
@@ -209,6 +209,15 @@ <h2>1 · clip: bound values to a range</h2>
 // One-sided: only lower bound
 const pos = clip(s, { lower: 0 });
 console.log("lower only:", [...pos.values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([-3, 0, 1, 5, 10])
+clipped = s.clip(lower=0, upper=6)
+print("clipped:", clipped.tolist())
+
+# One-sided: only lower bound
+pos = s.clip(lower=0)
+print("lower only:", pos.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -236,6 +245,15 @@ <h2>2 · clip on a DataFrame</h2>
 const safe = dataFrameClip(df, { lower: 0, upper: 100 });
 console.log("temperature:", [...safe.col("temperature").values]);
 console.log("humidity:", [...safe.col("humidity").values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "temperature": [-10, 5, 20, 45],
+    "humidity": [0, 30, 80, 110],
+})
+safe = df.clip(lower=0, upper=100)
+print("temperature:", safe["temperature"].tolist())
+print("humidity:", safe["humidity"].tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -260,6 +278,11 @@ <h2>3 · seriesAbs: absolute value</h2>
 const returns = new Series({ data: [-0.05, 0.12, -0.08, 0.03] });
 const magnitude = seriesAbs(returns);
 console.log("magnitude:", [...magnitude.values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+returns = pd.Series([-0.05, 0.12, -0.08, 0.03])
+magnitude = returns.abs()
+print("magnitude:", magnitude.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -287,6 +310,15 @@ <h2>4 · dataFrameAbs: absolute values for all columns</h2>
 const result = dataFrameAbs(df);
 console.log("x:", [...result.col("x").values]);
 console.log("y:", [...result.col("y").values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "x": [-1, 2, -3],
+    "y": [4, -5, 6],
+})
+result = df.abs()
+print("x:", result["x"].tolist())
+print("y:", result["y"].tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -316,6 +348,15 @@ <h2>5 · seriesRound: round to N decimal places</h2>
 // Round to nearest 10
 const big = new Series({ data: [14, 25, 36] });
 console.log("nearest 10:", [...seriesRound(big, { decimals: -1 }).values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+prices = pd.Series([1.2349, 9.9999, 3.14159])
+r2 = prices.round(decimals=2)
+print("rounded to 2:", r2.tolist())
+
+# Round to nearest 10
+big = pd.Series([14, 25, 36])
+print("nearest 10:", big.round(decimals=-1).tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -343,6 +384,15 @@ <h2>6 · dataFrameRound: round all columns</h2>
 const r2 = dataFrameRound(df, { decimals: 2 });
 console.log("lat:", [...r2.col("lat").values]);
 console.log("lon:", [...r2.col("lon").values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "lat": [51.5074, 48.8566, 40.7128],
+    "lon": [-0.1278, 2.3522, -74.006],
+})
+r2 = df.round(decimals=2)
+print("lat:", r2["lat"].tolist())
+print("lon:", r2["lon"].tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -368,6 +418,14 @@ <h2>7 · Missing values pass through</h2>
 console.log("clip:", [...clip(s, { lower: 0, upper: 5 }).values]);
 console.log("abs:", [...seriesAbs(s).values]);
 console.log("round:", [...seriesRound(s, { decimals: 0 }).values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import numpy as np
+
+s = pd.Series([None, -5, np.nan, 7])
+
+print("clip:", s.clip(lower=0, upper=5).tolist())
+print("abs:", s.abs().tolist())
+print("round:", s.round(decimals=0).tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/ewm.html b/playground/ewm.html
index 8e2c5d98a..a8a2a7d92 100644
--- a/playground/ewm.html
+++ b/playground/ewm.html
@@ -231,6 +231,20 @@ <h2>1 · Decay Parameters</h2>
 console.log("com=1:     ", b.values);
 console.log("halflife=1:", c.values);
 console.log("alpha=0.5: ", d.values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([1, 2, 3, 4, 5])
+
+# All four are equivalent (alpha ≈ 0.5):
+a = s.ewm(span=3).mean()        # alpha = 2/(3+1) = 0.5
+b = s.ewm(com=1).mean()         # alpha = 1/(1+1) = 0.5
+c = s.ewm(halflife=1).mean()    # alpha = 1 − 2^(−1/1) = 0.5
+d = s.ewm(alpha=0.5).mean()     # alpha = 0.5 directly
+
+print("span=3:    ", list(a))
+print("com=1:     ", list(b))
+print("halflife=1:", list(c))
+print("alpha=0.5: ", list(d))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -262,6 +276,13 @@ <h2>2 · EWM Mean</h2>
 // EWM mean with span=3 (alpha=0.5)
 const ewmMean = s.ewm({ span: 3 }).mean();
 console.log("ewm mean:", ewmMean.values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([10, 20, 15, 30, 25])
+
+# EWM mean with span=3 (alpha=0.5)
+ewm_mean = s.ewm(span=3).mean()
+print("ewm mean:", list(ewm_mean))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -288,6 +309,13 @@ <h2>3 · adjust=false: Simple IIR Filter</h2>
 // Simple exponential smoothing (alpha=0.3)
 const smooth = s.ewm({ alpha: 0.3, adjust: false }).mean();
 console.log("smoothed:", smooth.values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([1, 2, 3, 4, 5])
+
+# Simple exponential smoothing (alpha=0.3)
+smooth = s.ewm(alpha=0.3, adjust=False).mean()
+print("smoothed:", list(smooth))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -317,6 +345,17 @@ <h2>4 · EWM Variance and Standard Deviation</h2>
 // Biased (population) variance
 const ewmVarBiased = prices.ewm({ span: 5 }).var(true);
 console.log("var (biased):", ewmVarBiased.values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+prices = pd.Series([100, 102, 98, 105, 103, 99])
+
+# EWM standard deviation (span=5)
+ewm_std = prices.ewm(span=5).std()
+print("std:", list(ewm_std))
+
+# Biased (population) variance
+ewm_var_biased = prices.ewm(span=5).var(bias=True)
+print("var (biased):", list(ewm_var_biased))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -343,6 +382,14 @@ <h2>5 · EWM Covariance</h2>
 // x goes up, y goes down → negative covariance
 const ewmCov = x.ewm({ alpha: 0.4 }).cov(y);
 console.log("cov(x, y):", ewmCov.values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+x = pd.Series([1, 2, 3, 4, 5])
+y = pd.Series([5, 4, 3, 2, 1])
+
+# x goes up, y goes down → negative covariance
+ewm_cov = x.ewm(alpha=0.4).cov(y)
+print("cov(x, y):", list(ewm_cov))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -368,6 +415,13 @@ <h2>6 · EWM Correlation</h2>
 
 const ewmCorr = s1.ewm({ span: 3 }).corr(s2);
 console.log("corr(s1, s2):", ewmCorr.values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s1 = pd.Series([1, 2, 3, 4, 5])
+s2 = pd.Series([2, 4, 6, 8, 10])  # perfect linear
+
+ewm_corr = s1.ewm(span=3).corr(s2)
+print("corr(s1, s2):", list(ewm_corr))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -399,6 +453,18 @@ <h2>7 · Missing Values (ignoreNa)</h2>
 // ignoreNa=true: missing values completely skipped
 const r2 = s.ewm({ alpha: 0.5, ignoreNa: true }).mean();
 console.log("ignoreNa=true: ", r2.values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import numpy as np
+
+s = pd.Series([1, None, 3, None, 5])
+
+# ignore_na=False (default): null positions advance time (extra decay)
+r1 = s.ewm(alpha=0.5, ignore_na=False).mean()
+print("ignore_na=False:", list(r1))
+
+# ignore_na=True: missing values completely skipped
+r2 = s.ewm(alpha=0.5, ignore_na=True).mean()
+print("ignore_na=True: ", list(r2))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -432,6 +498,22 @@ <h2>8 · DataFrame EWM</h2>
 const dfStd = df.ewm({ span: 3 }).std();
 console.log("\nEWM std:");
 dfStd.print();</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "open": [10, 11, 10.5, 12, 11.8],
+    "close": [11, 10.5, 12, 11.8, 13],
+})
+
+# EWM mean for each column independently
+df_mean = df.ewm(span=3).mean()
+print("EWM mean:")
+print(df_mean.to_string())
+
+# EWM std for each column
+df_std = df.ewm(span=3).std()
+print("\nEWM std:")
+print(df_std.to_string())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -459,6 +541,14 @@ <h2>9 · Custom apply</h2>
   vals.reduce((acc, v, i) => acc + v * weights[i], 0)
 );
 console.log("weighted sum:", ewmWeightedSum.values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([1, 2, 3, 4, 5])
+
+# EWM weighted sum (equivalent to unadjusted numerator)
+# Note: pandas 3.0 removed ewm().apply(); use ewm().sum() instead
+ewm_weighted_sum = s.ewm(alpha=0.5).sum()
+print("weighted sum:", list(ewm_weighted_sum))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/groupby.html b/playground/groupby.html
index 4a8b5e80d..017e97e16 100644
--- a/playground/groupby.html
+++ b/playground/groupby.html
@@ -221,6 +221,16 @@ <h2>1 · Basic groupby + sum()</h2>
 
 const result = df.groupby("dept").sum();
 console.log(result.toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "dept":  ["A", "A", "B", "B", "C"],
+    "sales": [10, 20, 30, 40, 50],
+    "bonus": [1,  2,  3,  4,  5],
+})
+
+result = df.groupby("dept").sum()
+print(result)</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -254,6 +264,22 @@ <h2>2 · mean(), min(), max()</h2>
 
 console.log("\n=== max() ===");
 console.log(df.groupby("team").max().toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "team":   ["X", "X", "Y", "Y", "Z"],
+    "points": [10, 20, 30, 40, 50],
+    "fouls":  [2,  4,  1,  3,  5],
+})
+
+print("=== mean() ===")
+print(df.groupby("team").mean())
+
+print("\n=== min() ===")
+print(df.groupby("team").min())
+
+print("\n=== max() ===")
+print(df.groupby("team").max())</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -281,6 +307,16 @@ <h2>3 · count()</h2>
 
 const counts = df.groupby("dept").count();
 console.log(counts.toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "dept":   ["A", "A", "B", "B", "B"],
+    "score":  [90,  None, 80, 70, None],
+    "rating": [5,   4,    None, 3, 2],
+})
+
+counts = df.groupby("dept").count()
+print(counts)</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -308,6 +344,16 @@ <h2>4 · std()</h2>
 const result = df.groupby("group").std();
 console.log(result.toString());
 // Group C has only 1 row → std is NaN</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "group":  ["A", "A", "A", "B", "B", "C"],
+    "value":  [10, 20, 30, 100, 200, 42],
+})
+
+result = df.groupby("group").std()
+print(result)
+# Group C has only 1 row → std is NaN</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -338,6 +384,20 @@ <h2>5 · first() / last()</h2>
 
 console.log("\n=== last() ===");
 console.log(df.groupby("dept").last().toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import numpy as np
+
+df = pd.DataFrame({
+    "dept":  ["A", "A", "A", "B", "B"],
+    "sales": [None, 20, 30, 40, 50],
+    "bonus": [1,  2,  3,  4,  None],
+})
+
+print("=== first() ===")
+print(df.groupby("dept").first())
+
+print("\n=== last() ===")
+print(df.groupby("dept").last())</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -369,6 +429,20 @@ <h2>6 · size(), ngroups, groupKeys</h2>
 
 console.log("\nsize():");
 console.log(gb.size().toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "dept":  ["A", "A", "B", "B", "C"],
+    "sales": [10, 20, 30, 40, 50],
+})
+
+gb = df.groupby("dept")
+
+print("ngroups:", gb.ngroups)
+print("group_keys:", list(gb.groups.keys()))
+
+print("\nsize():")
+print(gb.size())</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -410,6 +484,28 @@ <h2>7 · agg() with named specs</h2>
   return Math.max(...nums) - Math.min(...nums);
 });
 console.log(range.toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "dept":  ["A", "A", "B", "B", "C"],
+    "sales": [10, 20, 30, 40, 50],
+    "bonus": [1,  2,  3,  4,  5],
+})
+
+# Per-column named specs
+print("=== per-column specs ===")
+result = df.groupby("dept").agg({
+    "sales": "sum",
+    "bonus": "mean",
+})
+print(result)
+
+# Custom function: range = max - min
+print("\n=== custom agg (range) ===")
+range_result = df.groupby("dept")[["sales", "bonus"]].agg(
+    lambda x: x.max() - x.min()
+)
+print(range_result)</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -446,6 +542,20 @@ <h2>8 · transform()</h2>
   return vals.map((v) => (typeof v === "number" ? v - mean : v));
 });
 console.log(demeaned.toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "dept":  ["A", "A", "B", "B", "C"],
+    "sales": [10, 20, 30, 40, 50],
+    "bonus": [1,  2,  3,  4,  5],
+})
+
+# Subtract group mean (demeaning)
+demeaned = df.copy()
+demeaned[["sales", "bonus"]] = df.groupby("dept")[["sales", "bonus"]].transform(
+    lambda x: x - x.mean()
+)
+print(demeaned)</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -476,6 +586,19 @@ <h2>9 · apply()</h2>
   sub.sortValues("sales", false).head(1),
 );
 console.log(topRows.toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "dept":  ["A", "A", "B", "B", "C"],
+    "sales": [10, 20, 30, 40, 50],
+    "bonus": [1,  2,  3,  4,  5],
+})
+
+# Keep only the top-sales row from each dept
+top_rows = df.groupby("dept").apply(
+    lambda sub: sub.sort_values("sales", ascending=False).head(1)
+)
+print(top_rows)</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -505,6 +628,18 @@ <h2>10 · filter()</h2>
 const big = df.groupby("dept").filter((sub) => sub.shape[0] > 1);
 console.log("Groups with > 1 row (C dropped):");
 console.log(big.toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "dept":  ["A", "A", "B", "B", "C"],
+    "sales": [10, 20, 30, 40, 50],
+    "bonus": [1,  2,  3,  4,  5],
+})
+
+# Keep only groups with more than 1 row
+big = df.groupby("dept").filter(lambda sub: len(sub) > 1)
+print("Groups with > 1 row (C dropped):")
+print(big)</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -540,6 +675,23 @@ <h2>🧪 Scratch Pad</h2>
 
 console.log("\nGroup sizes:");
 console.log(sales.groupby("region").size().toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+# Try it! Build a DataFrame and explore the GroupBy API.
+sales = pd.DataFrame({
+    "region":  ["East", "East", "West", "West", "East"],
+    "quarter": [1, 2, 1, 2, 1],
+    "revenue": [100, 150, 200, 250, 120],
+})
+
+print("Revenue by region:")
+print(sales.groupby("region").sum())
+
+print("\nAverage revenue by region:")
+print(sales.groupby("region").mean())
+
+print("\nGroup sizes:")
+print(sales.groupby("region").size())</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
diff --git a/playground/index-playground.html b/playground/index-playground.html
index 308e694b7..9f773b421 100644
--- a/playground/index-playground.html
+++ b/playground/index-playground.html
@@ -228,6 +228,23 @@ <h2>Creating an Index</h2>
 const stepped = new RangeIndex(0, 10, 2);
 console.log(stepped.toString());
 console.log("Values:", stepped.toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+# String labels
+labels = pd.Index(["a", "b", "c", "d"], name="letters")
+print(labels.to_list())
+
+# Numeric labels
+nums = pd.Index([10, 20, 30])
+print(nums.to_list())
+
+# RangeIndex — memory-efficient integer range
+range_idx = pd.RangeIndex(5)
+print(range_idx.to_list())
+
+stepped = pd.RangeIndex(0, 10, 2)
+print(stepped.to_list())
+print("Values:", stepped.to_list())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -257,6 +274,18 @@ <h2>Properties</h2>
 console.log("isUnique:", idx.isUnique);
 console.log("hasDuplicates:", idx.hasDuplicates);
 console.log("isMonotonicIncreasing:", idx.isMonotonicIncreasing);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+idx = pd.Index(["x", "y", "z"], name="axis")
+
+print("size:", idx.size)
+print("shape:", idx.shape)
+print("ndim:", idx.ndim)
+print("empty:", idx.empty)
+print("name:", idx.name)
+print("is_unique:", idx.is_unique)
+print("has_duplicates:", idx.has_duplicates)
+print("is_monotonic_increasing:", idx.is_monotonic_increasing)</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -282,6 +311,14 @@ <h2>Label Look-up</h2>
 console.log("getLoc('a'):", idx.getLoc("a"));     // duplicated → array
 console.log("contains('c'):", idx.contains("c"));
 console.log("isin(['a', 'c']):", idx.isin(["a", "c"]));</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+idx = pd.Index(["a", "b", "c", "a"])
+
+print("get_loc('b'):", idx.get_loc("b"))     # unique → single int
+print("get_loc('a'):", idx.get_loc("a"))     # duplicated → boolean mask
+print("contains 'c':", "c" in idx)
+print("isin(['a', 'c']):", idx.isin(["a", "c"]).tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -308,6 +345,15 @@ <h2>Set Operations</h2>
 console.log("intersection:", a.intersection(b).toString());
 console.log("difference:  ", a.difference(b).toString());
 console.log("symm. diff.: ", a.symmetricDifference(b).toString());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+a = pd.Index([1, 2, 3])
+b = pd.Index([2, 3, 4])
+
+print("union:       ", a.union(b).to_list())
+print("intersection:", a.intersection(b).to_list())
+print("difference:  ", a.difference(b).to_list())
+print("symm. diff.: ", a.symmetric_difference(b).to_list())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -335,6 +381,16 @@ <h2>Sorting &amp; Aggregation</h2>
 console.log("max:", idx.max());
 console.log("argmin:", idx.argmin());
 console.log("argmax:", idx.argmax());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+idx = pd.Index([30, 10, 20])
+
+print("sort_values:", idx.sort_values().to_list())
+print("argsort:   ", idx.argsort().tolist())
+print("min:", idx.min())
+print("max:", idx.max())
+print("argmin:", idx.argmin())
+print("argmax:", idx.argmax())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -361,6 +417,15 @@ <h2>Manipulation (immutable — always returns new Index)</h2>
 console.log("delete: ", idx.delete(0).toString());
 console.log("drop:   ", idx.drop(["b"]).toString());
 console.log("rename: ", idx.rename("new_name").toString());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+idx = pd.Index(["a", "b", "c"])
+
+print("append: ", idx.append(pd.Index(["d", "e"])).to_list())
+print("insert: ", idx.insert(1, "x").to_list())
+print("delete: ", idx.delete(0).to_list())
+print("drop:   ", idx.drop(["b"]).to_list())
+print("rename: ", idx.rename("new_name"))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -386,6 +451,15 @@ <h2>Missing Values</h2>
 console.log("notna:", idx.notna());
 console.log("dropna:", idx.dropna().toString());
 console.log("fillna(0):", idx.fillna(0).toString());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import numpy as np
+
+idx = pd.Index([1, None, 3])
+
+print("isna: ", idx.isna().tolist())
+print("notna:", idx.notna().tolist())
+print("dropna:", idx.dropna().to_list())
+print("fillna(0):", idx.fillna(0).to_list())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -417,6 +491,20 @@ <h2>RangeIndex — Memory Efficient</h2>
 // Slicing preserves RangeIndex type
 const sliced = r.slice(10, 20);
 console.log("sliced:", sliced.toString());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+# Only stores start/stop/step — values computed on the fly
+r = pd.RangeIndex(0, 1_000_000)
+print("size:", r.size)
+print("at(500):", r[500])
+
+# Negative step
+desc = pd.RangeIndex(10, 0, -2)
+print("desc values:", desc.to_list())
+
+# Slicing preserves RangeIndex type
+sliced = r[10:20]
+print("sliced:", sliced.to_list())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -448,6 +536,19 @@ <h2>🧪 Try It Yourself</h2>
 console.log("\nMean:", temps.mean());
 console.log("Max:", temps.max());
 console.log("Min:", temps.min());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+# Create a Series with a custom index
+temps = pd.Series(
+    data=[72, 68, 75, 80, 77],
+    index=["Mon", "Tue", "Wed", "Thu", "Fri"],
+    name="temperature",
+)
+
+print(temps)
+print("\nMean:", temps.mean())
+print("Max:", temps.max())
+print("Min:", temps.min())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/json.html b/playground/json.html
index ee6ab1276..61139bf8a 100644
--- a/playground/json.html
+++ b/playground/json.html
@@ -215,6 +215,16 @@ <h2>1 · Parse records JSON (default)</h2>
 console.log("columns:", [...df.columns.values]);
 console.log("names:", [...df.col("name").values]);
 console.log("ages:", [...df.col("age").values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import io
+
+json_text = '[{"name": "alice", "age": 30, "score": 88.5}, {"name": "bob", "age": 25, "score": 92.0}, {"name": "carol", "age": 35, "score": 75.3}]'
+
+df = pd.read_json(io.StringIO(json_text))
+print("shape:", df.shape)
+print("columns:", list(df.columns))
+print("names:", list(df["name"]))
+print("ages:", list(df["age"]))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -248,6 +258,22 @@ <h2>2 · Split orient</h2>
 console.log("index:", [...df.index.values]);
 console.log("x:", [...df.col("x").values]);
 console.log("y:", [...df.col("y").values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import json
+import io
+
+data = json.dumps({
+    "columns": ["x", "y"],
+    "index": [10, 20, 30],
+    "data": [[1, 4], [2, 5], [3, 6]],
+})
+
+df = pd.read_json(io.StringIO(data), orient="split")
+print("orient auto-detected: split")
+print("shape:", df.shape)
+print("index:", list(df.index))
+print("x:", list(df["x"]))
+print("y:", list(df["y"]))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -279,6 +305,21 @@ <h2>3 · Index orient</h2>
 console.log("index:", [...df.index.values]);
 console.log("a:", [...df.col("a").values]);
 console.log("b:", [...df.col("b").values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import json
+import io
+
+data = json.dumps({
+    "r0": {"a": 1, "b": "foo"},
+    "r1": {"a": 2, "b": "bar"},
+    "r2": {"a": 3, "b": "baz"},
+})
+
+df = pd.read_json(io.StringIO(data), orient="index")
+print("shape:", df.shape)
+print("index:", list(df.index))
+print("a:", list(df["a"]))
+print("b:", list(df["b"]))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -310,6 +351,20 @@ <h2>4 · Columns orient</h2>
 console.log("index:", [...df.index.values]);
 console.log("x:", [...df.col("x").values]);
 console.log("y:", [...df.col("y").values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import json
+import io
+
+data = json.dumps({
+    "x": {"0": 10, "1": 20, "2": 30},
+    "y": {"0": 1.1, "1": 2.2, "2": 3.3},
+})
+
+df = pd.read_json(io.StringIO(data), orient="columns")
+print("shape:", df.shape)
+print("index:", list(df.index))
+print("x:", list(df["x"]))
+print("y:", list(df["y"]))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -337,6 +392,15 @@ <h2>5 · Values orient</h2>
 console.log("shape:", df.shape);
 console.log("columns:", [...df.columns.values]);
 console.log("col 0:", [...df.col("0").values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import io
+
+json_text = "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
+
+df = pd.read_json(io.StringIO(json_text), orient="values")
+print("shape:", df.shape)
+print("columns:", list(df.columns))
+print("col 0:", list(df[0]))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -369,6 +433,19 @@ <h2>6 · Serialize with toJson()</h2>
 
 console.log("--- split (indented) ---");
 console.log(toJson(df, { orient: "split", indent: 2 }));</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "city": ["New York", "London", "Tokyo"],
+    "pop": [8_336_817, 8_982_000, 13_960_000],
+    "gdp": [1.6, 0.6, 1.0],
+})
+
+print("--- records (compact) ---")
+print(df.to_json(orient="records"))
+
+print("--- split (indented) ---")
+print(df.to_json(orient="split", indent=2))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -401,6 +478,21 @@ <h2>7 · Round-trip</h2>
 console.log("x restored:", [...restored.col("x").values]);
 console.log("label restored:", [...restored.col("label").values]);
 console.log("shapes match:", JSON.stringify(original.shape) === JSON.stringify(restored.shape));</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import io
+
+original = pd.DataFrame({
+    "x": [1, 2, 3, 4, 5],
+    "label": ["a", "b", "c", "d", "e"],
+})
+
+json_text = original.to_json(orient="split")
+restored = pd.read_json(io.StringIO(json_text), orient="split")
+
+print("JSON:", json_text)
+print("x restored:", list(restored["x"]))
+print("label restored:", list(restored["label"]))
+print("shapes match:", original.shape == restored.shape)</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/melt.html b/playground/melt.html
index 64f6a3991..6ecd76dae 100644
--- a/playground/melt.html
+++ b/playground/melt.html
@@ -207,6 +207,16 @@ <h2>1 · Basic melt</h2>
 
 const long = melt(df);
 console.log(long.toRecords());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "A": [1, 2, 3],
+    "B": [4, 5, 6],
+    "C": [7, 8, 9],
+})
+
+long = pd.melt(df)
+print(long.to_dict("records"))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -240,6 +250,21 @@ <h2>2 · Preserve identifier columns</h2>
   value_name: "sales",
 });
 console.log(long.toRecords());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "id": ["alice", "bob", "carol"],
+    "jan": [100, 200, 150],
+    "feb": [110, 190, 160],
+    "mar": [120, 210, 140],
+})
+
+long = pd.melt(df,
+    id_vars="id",
+    var_name="month",
+    value_name="sales",
+)
+print(long.to_dict("records"))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -273,6 +298,22 @@ <h2>3 · Selective value columns</h2>
   value_name: "score",
 });
 console.log(long.toRecords());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "name": ["Alice", "Bob"],
+    "score1": [85, 90],
+    "score2": [78, 92],
+    "grade": ["B", "A"],
+})
+
+long = pd.melt(df,
+    id_vars="name",
+    value_vars=["score1", "score2"],
+    var_name="test",
+    value_name="score",
+)
+print(long.to_dict("records"))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -305,6 +346,21 @@ <h2>4 · Multiple id columns</h2>
   value_name: "revenue",
 });
 console.log(long.toRecords());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "year": [2022, 2023],
+    "city": ["NYC", "LA"],
+    "q1": [100, 200],
+    "q2": [110, 210],
+})
+
+long = pd.melt(df,
+    id_vars=["year", "city"],
+    var_name="quarter",
+    value_name="revenue",
+)
+print(long.to_dict("records"))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/merge.html b/playground/merge.html
index f99707a31..99f75ec82 100644
--- a/playground/merge.html
+++ b/playground/merge.html
@@ -226,6 +226,21 @@ <h2>1 · Basic inner merge</h2>
 // Default how="inner" — customers 30 and 40 have no match → excluded
 const result = merge(orders, customers, { on: "customerId" });
 console.log(result.toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+orders = pd.DataFrame({
+    "orderId": [1, 2, 3, 4],
+    "customerId": [10, 20, 10, 30],
+    "amount": [100, 200, 150, 80],
+})
+customers = pd.DataFrame({
+    "customerId": [10, 20, 40],
+    "name": ["Alice", "Bob", "Dave"],
+})
+
+# Default how="inner" — customers 30 and 40 have no match → excluded
+result = pd.merge(orders, customers, on="customerId")
+print(result.to_string())</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -260,6 +275,19 @@ <h2>2 · Left, Right, and Outer joins</h2>
 
 console.log("\n=== OUTER JOIN ===");
 console.log(merge(left, right, { on: "k", how: "outer" }).toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+left = pd.DataFrame({"k": [1, 2], "v": [10, 20]})
+right = pd.DataFrame({"k": [2, 3], "w": [200, 300]})
+
+print("=== LEFT JOIN ===")
+print(pd.merge(left, right, on="k", how="left").to_string())
+
+print("\n=== RIGHT JOIN ===")
+print(pd.merge(left, right, on="k", how="right").to_string())
+
+print("\n=== OUTER JOIN ===")
+print(pd.merge(left, right, on="k", how="outer").to_string())</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -298,6 +326,23 @@ <h2>3 · Merge on different column names</h2>
   right_on: "id",
 });
 console.log(result.toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+employees = pd.DataFrame({
+    "empId": [1, 2, 3],
+    "salary": [50000, 60000, 70000],
+})
+departments = pd.DataFrame({
+    "id": [2, 3, 4],
+    "dept": ["Eng", "HR", "Fin"],
+})
+
+# empId in left matches id in right
+result = pd.merge(employees, departments,
+    left_on="empId",
+    right_on="id",
+)
+print(result.to_string())</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -334,6 +379,21 @@ <h2>4 · Custom suffixes for overlapping columns</h2>
   on:       "id",
   suffixes: ["_pre", "_post"],
 }).toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+left = pd.DataFrame({"id": [1, 2], "score": [80, 90]})
+right = pd.DataFrame({"id": [1, 2], "score": [75, 95]})
+
+# Default suffixes: _x and _y
+print("=== Default suffixes ===")
+print(pd.merge(left, right, on="id").to_string())
+
+# Custom suffixes
+print("\n=== Custom suffixes (_pre, _post) ===")
+print(pd.merge(left, right,
+    on="id",
+    suffixes=("_pre", "_post"),
+).to_string())</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
@@ -375,6 +435,29 @@ <h2>🧪 Scratch Pad</h2>
   on: "productId",
   how: "left",
 }).toString());</pre>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+# Try it! Build two DataFrames and explore the merge API.
+products = pd.DataFrame({
+    "productId": [1, 2, 3],
+    "name": ["Widget", "Gadget", "Gizmo"],
+    "price": [9.99, 24.99, 14.99],
+})
+
+sales = pd.DataFrame({
+    "productId": [1, 1, 2, 3, 3],
+    "qty": [10, 5, 8, 3, 7],
+    "region": ["East", "West", "East", "East", "West"],
+})
+
+print("Products joined with sales (inner):")
+print(pd.merge(products, sales, on="productId").to_string())
+
+print("\nAll products, even with no sales (left join):")
+print(pd.merge(products, sales,
+    on="productId",
+    how="left",
+).to_string())</textarea>
       <pre class="playground-output">Click ▶ Run to execute</pre>
       <div class="playground-hint">Ctrl+Enter to run</div>
     </div>
diff --git a/playground/multi_index.html b/playground/multi_index.html
index 861bb3262..6e8a939f8 100644
--- a/playground/multi_index.html
+++ b/playground/multi_index.html
@@ -211,6 +211,20 @@ <h2>1 · Create from tuples</h2>
 console.log("names:", mi.names);
 console.log("at(0):", mi.at(0));
 console.log("at(-1):", mi.at(-1));</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+mi = pd.MultiIndex.from_tuples([
+    ("bar", "one"),
+    ("bar", "two"),
+    ("baz", "one"),
+    ("baz", "two"),
+], names=["first", "second"])
+
+print("nlevels:", mi.nlevels)
+print("size:", mi.size)
+print("names:", list(mi.names))
+print("at(0):", mi[0])
+print("at(-1):", mi[-1])</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -240,6 +254,17 @@ <h2>2 · Create from arrays</h2>
 );
 
 console.log("toArray:", mi.toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+mi = pd.MultiIndex.from_arrays(
+    [
+        ["a", "a", "b", "b"],
+        [1, 2, 1, 2],
+    ],
+    names=["letter", "number"],
+)
+
+print("tolist:", mi.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -269,6 +294,16 @@ <h2>3 · Create from Cartesian product</h2>
 for (const t of mi) {
   console.log(t.join(" / "));
 }</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+mi = pd.MultiIndex.from_product(
+    [["control", "treatment"], ["pre", "post"]],
+    names=["group", "period"],
+)
+
+print("size:", mi.size)
+for t in mi:
+    print(" / ".join(str(x) for x in t))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -299,6 +334,18 @@ <h2>4 · Look-up by label</h2>
 // Duplicate tuples return an array of positions
 const dup = MultiIndex.fromTuples([["a", 1], ["b", 2], ["a", 1]]);
 console.log("dup getLoc(['a', 1]):", dup.getLoc(["a", 1]));</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+mi = pd.MultiIndex.from_tuples([
+    ("a", 1), ("a", 2), ("b", 1), ("b", 2),
+])
+
+print("get_loc(('a', 2)):", mi.get_loc(("a", 2)))
+print("contains (('b', 3) in mi):", ("b", 3) in mi)
+
+# Duplicate tuples return a slice or array of positions
+dup = pd.MultiIndex.from_tuples([("a", 1), ("b", 2), ("a", 1)])
+print("dup get_loc(('a', 1)):", dup.get_loc(("a", 1)))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -335,6 +382,25 @@ <h2>5 · Level operations: droplevel &amp; swaplevel</h2>
 // Drop to a single level → plain Index
 const idx = mi.droplevel([0, 1]);
 console.log("droplevel([0,1]) type:", idx.constructor.name);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+mi = pd.MultiIndex.from_tuples([
+    ("a", 1, "x"),
+    ("b", 2, "y"),
+], names=["letter", "num", "code"])
+
+# Drop the first level — returns a 2-level MultiIndex
+two = mi.droplevel(0)
+print("after droplevel(0) nlevels:", two.nlevels)
+print("after droplevel(0) at(0):", two[0])
+
+# Swap levels 0 and 1
+swapped = mi.swaplevel(0, 1)
+print("after swaplevel(0,1) at(0):", swapped[0])
+
+# Drop to a single level — plain Index
+idx = mi.droplevel([0, 1])
+print("droplevel([0,1]) type:", type(idx).__name__)</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -361,6 +427,14 @@ <h2>6 · Set operations</h2>
 console.log("union:", mi1.union(mi2).toArray());
 console.log("intersection:", mi1.intersection(mi2).toArray());
 console.log("difference:", mi1.difference(mi2).toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+mi1 = pd.MultiIndex.from_tuples([("a", 1), ("b", 2), ("c", 3)])
+mi2 = pd.MultiIndex.from_tuples([("b", 2), ("d", 4)])
+
+print("union:", mi1.union(mi2).tolist())
+print("intersection:", mi1.intersection(mi2).tolist())
+print("difference:", mi1.difference(mi2).tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -387,6 +461,15 @@ <h2>7 · Sorting and deduplication</h2>
 console.log("sortValues:", mi.sortValues().toArray());
 console.log("dropDuplicates:", mi.dropDuplicates().toArray());
 console.log("duplicated('first'):", mi.duplicated("first"));</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+mi = pd.MultiIndex.from_tuples([
+    ("b", 2), ("a", 1), ("b", 1), ("a", 2), ("a", 1),
+])
+
+print("sort_values:", mi.sort_values().tolist())
+print("drop_duplicates:", mi.drop_duplicates().tolist())
+print("duplicated('first'):", mi.duplicated(keep="first").tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -418,6 +501,20 @@ <h2>8 · Missing values</h2>
 const clean = mi.dropna();
 console.log("after dropna size:", clean.size);
 console.log("after dropna toArray:", clean.toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import numpy as np
+
+mi = pd.MultiIndex.from_tuples([
+    (None, 1),
+    ("a",  2),
+    ("b",  None),
+    ("c",  3),
+])
+
+print("isna:", [any(x is None for x in t) for t in mi])
+clean = mi.dropna()
+print("after dropna size:", clean.size)
+print("after dropna tolist:", clean.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/nlargest.html b/playground/nlargest.html
index ee3638926..ed7b25d9a 100644
--- a/playground/nlargest.html
+++ b/playground/nlargest.html
@@ -206,6 +206,14 @@ <h2>1 · Series.nlargest basics</h2>
 const top3 = nlargestSeries(s, 3);
 console.log("values:", [...top3.values]);
 console.log("indices:", [...top3.index.values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([3, 1, 4, 1, 5, 9, 2, 6])
+
+# 3 largest values, sorted descending
+top3 = s.nlargest(3)
+print("values:", top3.tolist())
+print("indices:", top3.index.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -231,6 +239,13 @@ <h2>2 · Series.nsmallest basics</h2>
 const bottom3 = nsmallestSeries(s, 3);
 console.log("values:", [...bottom3.values]);
 console.log("indices:", [...bottom3.index.values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([3, 1, 4, 1, 5, 9, 2, 6])
+
+bottom3 = s.nsmallest(3)
+print("values:", bottom3.tolist())
+print("indices:", bottom3.index.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -272,6 +287,27 @@ <h2>3 · The <code>keep</code> parameter</h2>
 const all = nlargestSeries(s, 2, { keep: "all" });
 console.log("all values:", [...all.values]);
 console.log("all index:", [...all.index.values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(
+    [1, 3, 3, 5],
+    index=["a", "b", "c", "d"],
+)
+
+# keep="first" — keeps "b" (first 3)
+first = s.nlargest(2, keep="first")
+print("first values:", first.tolist())
+print("first index:", first.index.tolist())
+
+# keep="last" — keeps "c" (last 3)
+last = s.nlargest(2, keep="last")
+print("last values:", last.tolist())
+print("last index:", last.index.tolist())
+
+# keep="all" — includes both 3s even though n=2
+all_ = s.nlargest(2, keep="all")
+print("all values:", all_.tolist())
+print("all index:", all_.index.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -303,6 +339,20 @@ <h2>4 · Labeled index preservation</h2>
 const cheapest = nsmallestSeries(prices, 2);
 console.log("cheapest values:", [...cheapest.values]);
 console.log("cheapest labels:", [...cheapest.index.values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+prices = pd.Series(
+    [42.5, 18.0, 93.1, 67.8, 55.4],
+    index=["AAPL", "META", "NVDA", "MSFT", "AMZN"],
+)
+
+top_stocks = prices.nlargest(3)
+print("top values:", top_stocks.tolist())
+print("top labels:", top_stocks.index.tolist())
+
+cheapest = prices.nsmallest(2)
+print("cheapest values:", cheapest.tolist())
+print("cheapest labels:", cheapest.index.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -327,6 +377,14 @@ <h2>5 · NaN / null handling</h2>
 
 console.log("values:", [...top3.values]);
 console.log("size:", top3.size);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import numpy as np
+
+s = pd.Series([3, np.nan, 9, None, 1, np.nan, 5])
+top3 = s.nlargest(3)
+
+print("values:", top3.tolist())
+print("size:", len(top3))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -362,6 +420,22 @@ <h2>6 · DataFrame.nlargest</h2>
 // Break ties on "score" using "age" (secondary sort descending)
 const top2ByAge = nlargestDataFrame(df, 2, { columns: ["score", "age"] });
 console.log("tie-break names:", [...top2ByAge.col("name").values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "name":  ["Alice", "Bob", "Carol", "Dave", "Eve"],
+    "score": [88, 95, 72, 95, 80],
+    "age":   [30, 25, 35, 28, 22],
+})
+
+# Top 3 scorers
+top3 = df.nlargest(3, "score")
+print("names:", top3["name"].tolist())
+print("scores:", top3["score"].tolist())
+
+# Break ties on "score" using "age" (secondary sort descending)
+top2_by_age = df.nlargest(2, ["score", "age"])
+print("tie-break names:", top2_by_age["name"].tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -392,6 +466,18 @@ <h2>7 · DataFrame.nsmallest</h2>
 const cheapest2 = nsmallestDataFrame(df, 2, { columns: "price" });
 console.log("products:", [...cheapest2.col("product").values]);
 console.log("prices:", [...cheapest2.col("price").values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "product": ["A", "B", "C", "D", "E"],
+    "price":   [12.5, 9.9, 12.5, 7.0, 20.0],
+    "rating":  [4.2, 3.8, 4.5, 4.1, 3.2],
+})
+
+# 2 cheapest products
+cheapest2 = df.nsmallest(2, "price")
+print("products:", cheapest2["product"].tolist())
+print("prices:", cheapest2["price"].tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -428,6 +514,25 @@ <h2>8 · Edge cases</h2>
 const words = new Series({ data: ["banana", "apple", "cherry"] });
 console.log("largest strings:", [...nlargestSeries(words, 2).values]);
 console.log("smallest strings:", [...nsmallestSeries(words, 2).values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import numpy as np
+
+# n > series length → return all (sorted)
+s = pd.Series([2, 1, 3])
+print("nlargest(100):", s.nlargest(100).tolist())
+print("nsmallest(100):", s.nsmallest(100).tolist())
+
+# n = 0 → empty
+print("nlargest(0) size:", len(s.nlargest(0)))
+
+# all-NaN → empty
+all_nan = pd.Series([np.nan, np.nan])
+print("all-NaN size:", len(all_nan.nlargest(2)))
+
+# string values — lexicographic order
+words = pd.Series(["banana", "apple", "cherry"])
+print("largest strings:", words.sort_values(ascending=False).head(2).tolist())
+print("smallest strings:", words.sort_values().head(2).tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/pivot.html b/playground/pivot.html
index 1fc7e3343..bd07df288 100644
--- a/playground/pivot.html
+++ b/playground/pivot.html
@@ -208,6 +208,17 @@ <h2>1 · pivot: basic reshape</h2>
 const wide = pivot(df, { index: "date", columns: "city", values: "temp" });
 console.log("records:", wide.toRecords());
 console.log("index:", [...wide.index.values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "date": ["2020-01", "2020-01", "2020-02", "2020-02"],
+    "city": ["NYC", "LA", "NYC", "LA"],
+    "temp": [50, 60, 55, 65],
+})
+
+wide = df.pivot(index="date", columns="city", values="temp")
+print("records:", wide.reset_index().to_dict("records"))
+print("index:", list(wide.index))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -238,6 +249,18 @@ <h2>2 · pivot: multiple value columns</h2>
 const wide = pivot(df, { index: "row", columns: "col" });
 console.log("columns:", wide.columns.values);
 console.log("records:", wide.toRecords());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "row": ["A", "A", "B", "B"],
+    "col": ["x", "y", "x", "y"],
+    "val1": [1, 2, 3, 4],
+    "val2": [10, 20, 30, 40],
+})
+
+wide = df.pivot(index="row", columns="col")
+print("columns:", list(wide.columns))
+print("records:", wide.reset_index().to_dict("records"))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -271,6 +294,21 @@ <h2>3 · pivotTable: mean aggregation</h2>
   aggfunc: "mean",
 });
 console.log("records:", table.toRecords());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "region": ["East", "East", "East", "West", "West", "West"],
+    "product": ["A", "A", "B", "A", "B", "B"],
+    "sales": [100, 120, 80, 150, 90, 110],
+})
+
+table = pd.pivot_table(df,
+    index="region",
+    columns="product",
+    values="sales",
+    aggfunc="mean",
+)
+print("records:", table.reset_index().to_dict("records"))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -305,6 +343,22 @@ <h2>4 · pivotTable: sum with fill_value</h2>
   fill_value: 0,
 });
 console.log("records:", table.toRecords());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "dept": ["eng", "eng", "mktg", "mktg"],
+    "quarter": ["Q1", "Q2", "Q1", "Q2"],
+    "budget": [500, 600, 300, 350],
+})
+
+table = pd.pivot_table(df,
+    index="dept",
+    columns="quarter",
+    values="budget",
+    aggfunc="sum",
+    fill_value=0,
+)
+print("records:", table.reset_index().to_dict("records"))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -337,6 +391,21 @@ <h2>5 · pivotTable: count</h2>
   aggfunc: "count",
 });
 console.log("records:", counts.toRecords());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "gender": ["M", "F", "M", "F", "M", "F"],
+    "category": ["A", "A", "B", "B", "A", "B"],
+    "value": [1, 2, 3, 4, 5, 6],
+})
+
+counts = pd.pivot_table(df,
+    index="gender",
+    columns="category",
+    values="value",
+    aggfunc="count",
+)
+print("records:", counts.reset_index().to_dict("records"))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/playground-runtime.js b/playground/playground-runtime.js
index 6cba3e499..8a6afbd50 100644
--- a/playground/playground-runtime.js
+++ b/playground/playground-runtime.js
@@ -8,10 +8,43 @@
  *   2. Loads the TypeScript compiler (local bundle first, CDN fallback)
  *   3. Converts playground blocks into editable editors with Run/Reset buttons
  *   4. Transforms imports, transpiles TS → JS, and executes with output capture
+ *   5. Shows equivalent Python/pandas code in a switchable tab (read-only)
+ *   6. Reports execution timing for each code run
  *
  * No WASM needed — the TypeScript compiler runs natively in JavaScript.
  */
 
+// ── Inject tab-related CSS ─────────────────────────────────────────
+
+(function injectTabStyles() {
+  var style = document.createElement("style");
+  style.textContent = [
+    ".playground-tabs { display: flex; gap: 0; margin-bottom: -1px; position: relative; z-index: 1; }",
+    ".playground-tab {",
+    "  padding: 0.35rem 0.9rem; font-size: 0.8rem; font-weight: 500;",
+    "  border: 1px solid #30363d; border-bottom: none;",
+    "  border-radius: 0.4rem 0.4rem 0 0; cursor: pointer;",
+    "  background: #0d1117; color: #8b949e; transition: background 0.15s, color 0.15s;",
+    "}",
+    ".playground-tab:hover { background: #161b22; color: #e6edf3; }",
+    ".playground-tab.active { background: #1c2128; color: #58a6ff; border-bottom-color: #1c2128; }",
+    ".playground-tab-python.active { color: #3572A5; }",
+    ".playground-python-view {",
+    "  display: none; width: 100%; background: #0d1117; color: #e6edf3;",
+    "  border: 1px solid #30363d; border-top: none; border-bottom: none;",
+    "  padding: 1rem; font-family: 'Cascadia Code', 'Fira Code', 'JetBrains Mono', monospace;",
+    "  font-size: 0.875rem; line-height: 1.55; white-space: pre; overflow-x: auto;",
+    "  tab-size: 4;",
+    "}",
+    ".playground-python-view.active { display: block; }",
+    ".playground-timing {",
+    "  font-size: 0.75rem; color: #8b949e; margin-left: auto; font-family: system-ui, sans-serif;",
+    "}",
+    ".playground-timing .timing-value { color: #3fb950; font-weight: 600; }",
+  ].join("\n");
+  document.head.appendChild(style);
+})();
+
 // ── Load TypeScript compiler (local bundle → CDN fallback) ─────────
 
 function loadScriptWithTimeout(src, timeoutMs) {
@@ -176,11 +209,68 @@ function setupBlock(block, ts) {
   var runBtn = block.querySelector(".playground-run");
   var resetBtn = block.querySelector(".playground-reset");
   var output = block.querySelector(".playground-output");
+  var pythonSource = block.querySelector(".playground-python");
   if (!editor || !runBtn || !output) return;
 
   var originalCode = getEditorCode(editor);
 
-  // Auto-resize textarea to fit content
+  // ── Python tab setup ───────────────────────────────
+  if (pythonSource) {
+    var pythonCode = getEditorCode(pythonSource);
+    pythonSource.style.display = "none"; // hide the source textarea
+
+    // Create tab bar
+    var header = block.querySelector(".playground-header");
+    var tabBar = document.createElement("div");
+    tabBar.className = "playground-tabs";
+
+    var tsTab = document.createElement("div");
+    tsTab.className = "playground-tab playground-tab-ts active";
+    tsTab.textContent = "TypeScript";
+
+    var pyTab = document.createElement("div");
+    pyTab.className = "playground-tab playground-tab-python";
+    pyTab.textContent = "Python";
+
+    tabBar.appendChild(tsTab);
+    tabBar.appendChild(pyTab);
+
+    // Insert tab bar before the header
+    block.insertBefore(tabBar, header);
+
+    // Hide the label in the header since tabs show the language
+    var label = header.querySelector(".playground-label");
+    if (label) label.style.display = "none";
+
+    // Create Python read-only view
+    var pythonView = document.createElement("pre");
+    pythonView.className = "playground-python-view";
+    pythonView.textContent = pythonCode;
+
+    // Insert Python view after editor
+    editor.parentNode.insertBefore(pythonView, editor.nextSibling);
+
+    // Tab switching
+    tsTab.addEventListener("click", function () {
+      tsTab.classList.add("active");
+      pyTab.classList.remove("active");
+      editor.style.display = "";
+      pythonView.classList.remove("active");
+      runBtn.style.display = "";
+      if (resetBtn) resetBtn.style.display = "";
+    });
+
+    pyTab.addEventListener("click", function () {
+      pyTab.classList.add("active");
+      tsTab.classList.remove("active");
+      editor.style.display = "none";
+      pythonView.classList.add("active");
+      runBtn.style.display = "none";
+      if (resetBtn) resetBtn.style.display = "none";
+    });
+  }
+
+  // ── Auto-resize textarea to fit content ────────────
   function autoResize() {
     if (!isTextarea(editor)) return;
     editor.style.height = "auto";
@@ -212,16 +302,31 @@ function setupBlock(block, ts) {
     }
   });
 
-  // Run button handler
+  // Create timing display element
+  var timingEl = document.createElement("span");
+  timingEl.className = "playground-timing";
+  var actionsEl = block.querySelector(".playground-actions");
+  if (actionsEl) {
+    actionsEl.parentNode.insertBefore(timingEl, actionsEl);
+  }
+
+  // Run button handler (with timing)
   runBtn.addEventListener("click", function () {
     output.classList.remove("error");
     output.classList.add("active");
+    timingEl.innerHTML = "";
     try {
       var code = getEditorCode(editor);
+      var startTime = performance.now();
       var js = transformCode(code, ts);
       var result = executeCode(js);
+      var elapsed = performance.now() - startTime;
       output.textContent =
         result || "(no output \u2014 add console.log() to see results)";
+      timingEl.innerHTML =
+        "\u23f1 <span class=\"timing-value\">" +
+        elapsed.toFixed(1) +
+        "ms</span>";
     } catch (err) {
       output.textContent = "\u274c " + err.message;
       output.classList.add("error");
@@ -234,6 +339,7 @@ function setupBlock(block, ts) {
       setEditorCode(editor, originalCode);
       output.textContent = "";
       output.classList.remove("error", "active");
+      timingEl.innerHTML = "";
       autoResize();
     });
   }
diff --git a/playground/rank.html b/playground/rank.html
index 9ac4f5d92..14c2943f6 100644
--- a/playground/rank.html
+++ b/playground/rank.html
@@ -205,6 +205,12 @@ <h2>1 · Basic ranking</h2>
 const r = rankSeries(s);
 console.log("ranks:", [...r.values]);
 // 1 appears twice → average rank (1+2)/2 = 1.5</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([3, 1, 4, 1, 5])
+r = s.rank()
+print("ranks:", r.tolist())
+# 1 appears twice → average rank (1+2)/2 = 1.5</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -233,6 +239,15 @@ <h2>2 · Tie-breaking methods</h2>
 console.log("max:    ", [...rankSeries(s, { method: "max"     }).values]);
 console.log("first:  ", [...rankSeries(s, { method: "first"   }).values]);
 console.log("dense:  ", [...rankSeries(s, { method: "dense"   }).values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([3, 1, 4, 1, 5])
+
+print("average:", s.rank(method="average").tolist())
+print("min:    ", s.rank(method="min").tolist())
+print("max:    ", s.rank(method="max").tolist())
+print("first:  ", s.rank(method="first").tolist())
+print("dense:  ", s.rank(method="dense").tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -259,6 +274,15 @@ <h2>3 · Descending rank</h2>
 const rank = rankSeries(scores, { ascending: false });
 console.log("ranks:", [...rank.values]);
 // Dana (95) → rank 1, Bob (92) → rank 2, etc.</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+scores = pd.Series(
+    [85, 92, 78, 95, 88],
+    index=["Alice", "Bob", "Charlie", "Dana", "Eve"],
+)
+rank = scores.rank(ascending=False)
+print("ranks:", rank.tolist())
+# Dana (95) → rank 1, Bob (92) → rank 2, etc.</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -290,6 +314,18 @@ <h2>4 · Handling NaN/null values</h2>
 console.log("keep:  ", [...keep.values]);
 console.log("top:   ", [...top.values]);
 console.log("bottom:", [...bottom.values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import numpy as np
+
+s = pd.Series([3, None, 1, None, 2])
+
+keep   = s.rank(na_option="keep")
+top    = s.rank(na_option="top")
+bottom = s.rank(na_option="bottom")
+
+print("keep:  ", keep.tolist())
+print("top:   ", top.tolist())
+print("bottom:", bottom.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -312,6 +348,11 @@ <h2>5 · Percentage rank (pct)</h2>
 const s = new Series({ data: [10, 20, 30, 40, 50] });
 const pct = rankSeries(s, { pct: true });
 console.log("pct ranks:", [...pct.values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([10, 20, 30, 40, 50])
+pct = s.rank(pct=True)
+print("pct ranks:", pct.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -339,6 +380,16 @@ <h2>6 · DataFrame rank by column (axis=0)</h2>
 const ranked = rankDataFrame(df);
 console.log("score ranks:", [...ranked.col("score").values]);
 console.log("time ranks: ", [...ranked.col("time").values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "score": [85, 92, 78],
+    "time":  [12, 8,  15],
+}, index=["Alice", "Bob", "Charlie"])
+
+ranked = df.rank()
+print("score ranks:", ranked["score"].tolist())
+print("time ranks: ", ranked["time"].tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -369,6 +420,19 @@ <h2>7 · DataFrame rank by row (axis=1)</h2>
 console.log("math ranks:   ", [...ranked.col("math").values]);
 console.log("english ranks:", [...ranked.col("english").values]);
 console.log("science ranks:", [...ranked.col("science").values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "math":    [90, 70, 85],
+    "english": [80, 95, 75],
+    "science": [85, 80, 90],
+})
+
+# For each student, rank their three subject scores
+ranked = df.rank(axis=1)
+print("math ranks:   ", ranked["math"].tolist())
+print("english ranks:", ranked["english"].tolist())
+print("science ranks:", ranked["science"].tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -397,6 +461,16 @@ <h2>8 · Dense rank for competition rankings</h2>
 const denseRank = rankSeries(points, { method: "dense", ascending: false });
 console.log("dense ranks:", [...denseRank.values]);
 // Tied players share the same position; no position is skipped</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+points = pd.Series(
+    [100, 85, 85, 72, 72, 60],
+    index=["A", "B", "C", "D", "E", "F"],
+)
+
+dense_rank = points.rank(method="dense", ascending=False)
+print("dense ranks:", dense_rank.tolist())
+# Tied players share the same position; no position is skipped</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/rolling.html b/playground/rolling.html
index 24a8bb367..3cd41875b 100644
--- a/playground/rolling.html
+++ b/playground/rolling.html
@@ -208,6 +208,13 @@ <h2>1 · Basic rolling mean</h2>
 // 3-day rolling mean — first two positions are null (not enough data)
 const ma3 = prices.rolling(3).mean();
 console.log(ma3.toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+prices = pd.Series([100, 102, 98, 105, 110, 108, 112], name="price")
+
+# 3-day rolling mean — first two positions are NaN (not enough data)
+ma3 = prices.rolling(3).mean()
+print(ma3.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -233,6 +240,13 @@ <h2>2 · minPeriods — allow partial windows</h2>
 // window=3 but minPeriods=1 → start computing from index 0
 const result = s.rolling(3, { minPeriods: 1 }).mean();
 console.log(result.toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([10, 20, 30, 40, 50])
+
+# window=3 but min_periods=1 → start computing from index 0
+result = s.rolling(3, min_periods=1).mean()
+print(result.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -260,6 +274,15 @@ <h2>3 · Rolling sum, std, min, max</h2>
   v === null ? null : Number(v.toFixed(4))));
 console.log("min :", w.min().toArray());
 console.log("max :", w.max().toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([2, 4, 4, 4, 5, 5, 7, 9])
+w = s.rolling(3)
+
+print("sum :", w.sum().tolist())
+print("std :", [round(v, 4) if pd.notna(v) else None for v in w.std()])
+print("min :", w.min().tolist())
+print("max :", w.max().tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -288,6 +311,17 @@ <h2>4 · Rolling count (handles nulls)</h2>
 
 // mean() with minPeriods=1 skips null-only windows
 console.log(s.rolling(2, { minPeriods: 1 }).mean().toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import numpy as np
+
+s = pd.Series([1, None, 3, None, 5])
+
+# count valid observations per window
+print(s.rolling(2).count().tolist())
+print(s.rolling(3).count().tolist())
+
+# mean() with min_periods=1 skips null-only windows
+print(s.rolling(2, min_periods=1).mean().tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -314,6 +348,15 @@ <h2>5 · Rolling median</h2>
 
 console.log("mean  :", meanW.map(v => v === null ? null : +v.toFixed(2)));
 console.log("median:", medW);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([1, 3, 5, 1, 100, 2, 4])
+
+mean_w = s.rolling(3, min_periods=1).mean().tolist()
+med_w = s.rolling(3, min_periods=1).median().tolist()
+
+print("mean  :", [round(v, 2) if v is not None else None for v in mean_w])
+print("median:", med_w)</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -345,6 +388,17 @@ <h2>6 · Custom aggregation with apply()</h2>
 // Rolling product
 const prod = s.rolling(2).apply(vals => vals.reduce((a, b) => a * b, 1));
 console.log("prod :", prod.toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([1, 2, 3, 4, 5])
+
+# Rolling range (max - min)
+range_s = s.rolling(3).apply(lambda vals: vals.max() - vals.min())
+print("range:", range_s.tolist())
+
+# Rolling product
+prod = s.rolling(2).apply(lambda vals: vals.prod())
+print("prod :", prod.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -374,6 +428,17 @@ <h2>7 · Centered window</h2>
 
 console.log("trailing:", trailing);
 console.log("centered:", centered);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([1, 2, 3, 4, 5])
+
+# trailing (default)
+trailing = s.rolling(3).mean().tolist()
+# centered
+centered = s.rolling(3, center=True, min_periods=1).mean().tolist()
+
+print("trailing:", trailing)
+print("centered:", centered)</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -402,6 +467,16 @@ <h2>8 · DataFrame.rolling()</h2>
 const rolled = df.rolling(3).mean();
 console.log(rolled.col("open").toArray());
 console.log(rolled.col("close").toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame({
+    "open": [100, 101, 103, 102, 105],
+    "close": [101, 103, 102, 105, 107],
+})
+
+rolled = df.rolling(3).mean()
+print(rolled["open"].tolist())
+print(rolled["close"].tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/series.html b/playground/series.html
index 0bce6feed..55bab4319 100644
--- a/playground/series.html
+++ b/playground/series.html
@@ -228,6 +228,19 @@ <h2>Creating a Series</h2>
 // From an object (keys become index labels)
 const s3 = Series.fromObject({ x: 1, y: 2, z: 3 });
 console.log(s3.toString());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+# From data array with default integer index
+s1 = pd.Series([10, 20, 30])
+print(s1.to_string())
+
+# With custom index and name
+s2 = pd.Series([100, 200, 300], index=["a", "b", "c"], name="revenue")
+print(s2.to_string())
+
+# From a dict (keys become index labels)
+s3 = pd.Series({"x": 1, "y": 2, "z": 3})
+print(s3.to_string())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -261,6 +274,18 @@ <h2>Properties</h2>
 console.log("values:", s.values);
 console.log("dtype: ", s.dtype.toString());
 console.log("name:  ", s.name);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([10, 20, 30, 40], index=["a", "b", "c", "d"], name="scores")
+
+print("size:  ", s.size)
+print("length:", len(s))
+print("shape: ", s.shape)
+print("ndim:  ", s.ndim)
+print("empty: ", s.empty)
+print("values:", s.values)
+print("dtype: ", s.dtype)
+print("name:  ", s.name)</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -300,6 +325,24 @@ <h2>Element Access</h2>
 // Multiple positions → sub-Series
 console.log("\niloc([1, 3]):");
 console.log(s.iloc([1, 3]).toString());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([10, 20, 30, 40, 50], index=["a", "b", "c", "d", "e"], name="vals")
+
+# Single element by label
+print("at('c'):", s.at["c"])
+
+# Single element by position
+print("iat(0): ", s.iat[0])
+print("iat(-1):", s.iat[-1])
+
+# Multiple labels → sub-Series
+print("\nloc(['a', 'c', 'e']):")
+print(s.loc[["a", "c", "e"]].to_string())
+
+# Multiple positions → sub-Series
+print("\niloc([1, 3]):")
+print(s.iloc[[1, 3]].to_string())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -328,6 +371,17 @@ <h2>Arithmetic</h2>
 console.log("div(b):", a.div(b).values);
 console.log("mod(7):", a.mod(7).values);
 console.log("pow(2):", a.pow(2).values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+a = pd.Series([10, 20, 30], index=["x", "y", "z"])
+b = pd.Series([1, 2, 3], index=["x", "y", "z"])
+
+print("add(5):", a.add(5).values)
+print("sub(b):", a.sub(b).values)
+print("mul(2):", a.mul(2).values)
+print("div(b):", a.div(b).values)
+print("mod(7):", a.mod(7).values)
+print("pow(2):", a.pow(2).values)</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -355,6 +409,16 @@ <h2>Comparison</h2>
 console.log("le(3):", s.le(3).values);
 console.log("gt(3):", s.gt(3).values);
 console.log("ge(3):", s.ge(3).values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([1, 2, 3, 4, 5])
+
+print("eq(3):", s.eq(3).values)
+print("ne(3):", s.ne(3).values)
+print("lt(3):", s.lt(3).values)
+print("le(3):", s.le(3).values)
+print("gt(3):", s.gt(3).values)
+print("ge(3):", s.ge(3).values)</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -388,6 +452,18 @@ <h2>Filtering &amp; Boolean Masking</h2>
 // Filter with a comparison result (boolean Series)
 console.log("\nValues > 12:");
 console.log(s.filter(s.gt(12)).toString());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([10, 25, 5, 40, 15], index=["a", "b", "c", "d", "e"], name="prices")
+
+# Filter with a boolean array
+mask = [True, False, True, False, True]
+print("Boolean array filter:")
+print(s[mask].to_string())
+
+# Filter with a comparison result (boolean Series)
+print("\nValues > 12:")
+print(s[s.gt(12)].to_string())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -417,6 +493,19 @@ <h2>Missing Values</h2>
 
 console.log("\nfillna(0):");
 console.log(s.fillna(0).toString());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import numpy as np
+
+s = pd.Series([1, np.nan, 3, np.nan, 5], name="sparse")
+
+print("isna: ", s.isna().values)
+print("notna:", s.notna().values)
+
+print("\ndropna():")
+print(s.dropna().to_string())
+
+print("\nfillna(0):")
+print(s.fillna(0).to_string())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -451,6 +540,23 @@ <h2>Statistics</h2>
 
 console.log("\nvalueCounts():");
 console.log(s.valueCounts().toString());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series([4, 1, 7, 4, 2, 7, 4])
+
+print("sum:    ", s.sum())
+print("mean:   ", s.mean())
+print("min:    ", s.min())
+print("max:    ", s.max())
+print("std:    ", s.std())
+print("var:    ", s.var())
+print("median: ", s.median())
+print("count:  ", s.count())
+print("nunique:", s.nunique())
+print("unique: ", s.unique())
+
+print("\nvalueCounts():")
+print(s.value_counts().to_string())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -483,6 +589,19 @@ <h2>Sorting</h2>
 
 console.log("\nsortIndex:");
 console.log(s.sortIndex().toString());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import numpy as np
+
+s = pd.Series([30, 10, np.nan, 20], index=["c", "a", "d", "b"])
+
+print("sortValues (ascending):")
+print(s.sort_values().to_string())
+
+print("\nsortValues (descending, na first):")
+print(s.sort_values(ascending=False, na_position="first").to_string())
+
+print("\nsortIndex:")
+print(s.sort_index().to_string())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -514,6 +633,19 @@ <h2>🧪 Try It Yourself</h2>
 console.log("\nMean:", temps.mean());
 console.log("Hot days (>= 75):");
 console.log(temps.filter(temps.ge(75)).toString());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+# Try it! Build a Series and explore the API.
+temps = pd.Series(
+    [72, 68, 75, 80, 77],
+    index=["Mon", "Tue", "Wed", "Thu", "Fri"],
+    name="temperature",
+)
+
+print(temps.to_string())
+print("\nMean:", temps.mean())
+print("Hot days (>= 75):")
+print(temps[temps.ge(75)].to_string())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/stack_unstack.html b/playground/stack_unstack.html
index affbeaf1c..7f9cdf2ec 100644
--- a/playground/stack_unstack.html
+++ b/playground/stack_unstack.html
@@ -208,6 +208,16 @@ <h2>1 · Basic stack</h2>
 const s = stack(df, { dropna: false });
 console.log("index:", [...s.index.values]);
 console.log("values:", [...s.values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame(
+    {"A": [1, 2, 3], "B": [4, 5, 6]},
+    index=["x", "y", "z"],
+)
+
+s = df.stack()
+print("index:", list(s.index))
+print("values:", list(s.values))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -243,6 +253,23 @@ <h2>2 · stack drops null by default</h2>
 const sFull = stack(df, { dropna: false });
 console.log("dropna=false index:", [...sFull.index.values]);
 console.log("dropna=false values:", [...sFull.values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import numpy as np
+
+df = pd.DataFrame(
+    {"score": [10, None, 30], "bonus": [None, 2, 3]},
+    index=["a", "b", "c"],
+)
+
+# default: stack preserves NaN, chain dropna() to remove
+s = df.stack().dropna()
+print("dropna=True  index:", list(s.index))
+print("dropna=True  values:", list(s.values))
+
+# keep nulls (default in pandas 3.0)
+s_full = df.stack()
+print("dropna=False index:", list(s_full.index))
+print("dropna=False values:", list(s_full.values))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -274,6 +301,19 @@ <h2>3 · unstack: recover the original DataFrame</h2>
 console.log("index:", [...recovered.index.values]);
 console.log("columns:", [...recovered.columns.values]);
 console.log("records:", recovered.toRecords());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame(
+    {"A": [1, 2], "B": [3, 4]},
+    index=["x", "y"],
+)
+
+s = df.stack()
+recovered = s.unstack()
+
+print("index:", list(recovered.index))
+print("columns:", list(recovered.columns))
+print("records:", recovered.reset_index().to_dict("records"))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -307,6 +347,20 @@ <h2>4 · unstack fills missing cells</h2>
 // unstack with fill_value=0
 const recovered = unstack(s, { fill_value: 0 });
 console.log("records:", recovered.toRecords());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import numpy as np
+
+df = pd.DataFrame(
+    {"revenue": [100, None, 300], "cost": [None, 50, 60]},
+    index=["jan", "feb", "mar"],
+)
+
+# stack then drop nulls
+s = df.stack().dropna()
+
+# unstack with fill_value=0
+recovered = s.unstack(fill_value=0)
+print("records:", recovered.reset_index().to_dict("records"))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -338,6 +392,20 @@ <h2>5 · Custom separator</h2>
 const recovered = unstack(s, { sep: "::" });
 console.log("index:", [...recovered.index.values]);
 console.log("columns:", [...recovered.columns.values]);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame(
+    {"col-A": [10, 20], "col-B": [30, 40]},
+    index=["row-1", "row-2"],
+)
+
+# pandas uses MultiIndex natively, no separator needed
+s = df.stack()
+print("stacked index:", list(s.index))
+
+recovered = s.unstack()
+print("index:", list(recovered.index))
+print("columns:", list(recovered.columns))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -374,6 +442,26 @@ <h2>6 · Reshape workflow: stack → filter → unstack</h2>
 
 console.log("index:", [...result.index.values]);
 console.log("records:", result.toRecords());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+import numpy as np
+
+# Quarterly sales by product
+df = pd.DataFrame(
+    {
+        "widgets": [120, 80, 150, 200],
+        "gadgets": [60, None, 90, 110],
+        "gizmos": [30, 45, None, 70],
+    },
+    index=["Q1", "Q2", "Q3", "Q4"],
+)
+
+# Stack then drop nulls, filter to values > 80, then unstack
+s = df.stack().dropna()
+filtered = s[s > 80]
+result = filtered.unstack(fill_value=0)
+
+print("index:", list(result.index))
+print("records:", result.reset_index().to_dict("records"))</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/string_accessor.html b/playground/string_accessor.html
index 0fc19aae4..c65928008 100644
--- a/playground/string_accessor.html
+++ b/playground/string_accessor.html
@@ -144,6 +144,15 @@ <h2>Case Operations</h2>
 console.log("title :", s.str.title().toArray());
 console.log("capitalize:", s.str.capitalize().toArray());
 console.log("swapcase  :", s.str.swapcase().toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(["hello", "WORLD", "foo BAR", None])
+
+print("lower :", s.str.lower().tolist())
+print("upper :", s.str.upper().tolist())
+print("title :", s.str.title().tolist())
+print("capitalize:", s.str.capitalize().tolist())
+print("swapcase  :", s.str.swapcase().tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -169,6 +178,15 @@ <h2>Length &amp; Slicing</h2>
 console.log("get(0)     :", s.str.get(0).toArray());
 console.log("get(-1)    :", s.str.get(-1).toArray());
 console.log("slice step :", s.str.slice(0, undefined, 2).toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(["hello", "world", "pandas"])
+
+print("len        :", s.str.len().tolist())
+print("slice(1,4) :", s.str.slice(1, 4).tolist())
+print("get(0)     :", s.str.get(0).tolist())
+print("get(-1)    :", s.str.get(-1).tolist())
+print("slice step :", s.str.slice(0, None, 2).tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -196,6 +214,17 @@ <h2>Strip &amp; Pad</h2>
 console.log("center(10) :", s.str.center(10).toArray());
 console.log("zfill(5)   :",
   new Series({ data: ["42", "-7", "3"] }).str.zfill(5).toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(["  hello  ", "***world***", "42"])
+
+print("strip()    :", s.str.strip().tolist())
+print("strip('*') :", s.str.strip("*").tolist())
+print("ljust(10)  :", s.str.ljust(10).tolist())
+print("rjust(10)  :", s.str.rjust(10).tolist())
+print("center(10) :", s.str.center(10).tolist())
+print("zfill(5)   :",
+  pd.Series(["42", "-7", "3"]).str.zfill(5).tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -222,6 +251,16 @@ <h2>Search &amp; Match</h2>
 console.log("endswith('3')     :", s.str.endswith("3").toArray());
 console.log("match('\\d+')      :", s.str.match("\\d+").toArray());
 console.log("fullmatch('\\w+')  :", s.str.fullmatch("\\w+").toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(["foo123", "bar456", "foo_bar", None])
+
+print("contains('foo')   :", s.str.contains("foo").tolist())
+print("contains (literal):", s.str.contains("foo", regex=False).tolist())
+print("startswith('foo') :", s.str.startswith("foo").tolist())
+print("endswith('3')     :", s.str.endswith("3").tolist())
+print("match('\\d+')      :", s.str.match("\\d+").tolist())
+print("fullmatch('\\w+')  :", s.str.fullmatch("\\w+").tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -247,6 +286,15 @@ <h2>Count, Find &amp; Replace</h2>
 console.log("rfind('a')      :", s.str.rfind("a").toArray());
 console.log("replace('a','X'):", s.str.replace("a", "X").toArray());
 console.log("replace n=1     :", s.str.replace("a", "X", 1).toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(["banana", "apple", "abracadabra"])
+
+print("count('a')      :", s.str.count("a").tolist())
+print("find('a')       :", s.str.find("a").tolist())
+print("rfind('a')      :", s.str.rfind("a").tolist())
+print("replace('a','X'):", s.str.replace("a", "X").tolist())
+print("replace n=1     :", s.str.replace("a", "X", n=1).tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -269,6 +317,12 @@ <h2>Extract</h2>
 
 const prices = s.str.extract(":\\s*([\\d.]+)");
 console.log("extracted:", prices.toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(["price: 42", "cost: 99.5", "free"])
+
+prices = s.str.extract(r":\s*([\d.]+)")
+print("extracted:", prices[0].tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -298,6 +352,19 @@ <h2>Split &amp; Join</h2>
 const a = new Series({ data: ["foo", "bar"] });
 const b = new Series({ data: ["1", "2"] });
 console.log("cat      :", a.str.cat([b.toArray()], "-").toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(["a,b,c", "x,y,z"])
+
+print("split n=0:", s.str.split(",", n=0).tolist())
+print("split n=1:", s.str.split(",", n=1).tolist())
+
+joined = s.str.split(",").str.join(" | ")
+print("rejoin   :", joined.tolist())
+
+a = pd.Series(["foo", "bar"])
+b = pd.Series(["1", "2"])
+print("cat      :", a.str.cat([b], sep="-").tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -324,6 +391,16 @@ <h2>Predicates</h2>
 console.log("isupper :", s.str.isupper().toArray());
 console.log("istitle :", s.str.istitle().toArray());
 console.log("isspace :", s.str.isspace().toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(["abc", "123", "abc123", "ABC", "Hello World", "   "])
+
+print("isalpha :", s.str.isalpha().tolist())
+print("isdigit :", s.str.isdigit().tolist())
+print("isalnum :", s.str.isalnum().tolist())
+print("isupper :", s.str.isupper().tolist())
+print("istitle :", s.str.istitle().tolist())
+print("isspace :", s.str.isspace().tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -347,6 +424,13 @@ <h2>Null Propagation</h2>
 console.log("upper:", s.str.upper().toArray());
 console.log("len  :", s.str.len().toArray());
 console.log("contains:", s.str.contains("o").toArray());</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(["hello", None, "world"])
+
+print("upper:", s.str.upper().tolist())
+print("len  :", s.str.len().tolist())
+print("contains:", s.str.contains("o").tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/playground/value_counts.html b/playground/value_counts.html
index 2f9e5a7bd..887a1c5a7 100644
--- a/playground/value_counts.html
+++ b/playground/value_counts.html
@@ -206,6 +206,13 @@ <h2>1 · Basic usage (Series)</h2>
 
 console.log("index:", vc.index.values);
 console.log("values:", vc.values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(["apple", "banana", "apple", "cherry", "banana", "apple"])
+vc = s.value_counts()
+
+print("index:", vc.index.tolist())
+print("values:", vc.values.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -231,6 +238,13 @@ <h2>2 · Normalize — return proportions</h2>
 
 console.log("index:", pct.index.values);
 console.log("proportions:", pct.values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(["apple", "banana", "apple", "cherry", "banana", "apple"])
+pct = s.value_counts(normalize=True)
+
+print("index:", pct.index.tolist())
+print("proportions:", pct.values.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -262,6 +276,19 @@ <h2>3 · Sort order</h2>
 const ins = valueCounts(s, { sort: false });
 console.log("unsorted index:", ins.index.values);
 console.log("unsorted values:", ins.values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(["apple", "banana", "apple", "cherry", "banana", "apple"])
+
+# Ascending order (least frequent first)
+asc = s.value_counts(ascending=True)
+print("ascending index:", asc.index.tolist())
+print("ascending values:", asc.values.tolist())
+
+# Preserve insertion order (no sort)
+ins = s.value_counts(sort=False)
+print("unsorted index:", ins.index.tolist())
+print("unsorted values:", ins.values.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -293,6 +320,19 @@ <h2>4 · Missing-value handling</h2>
 const keepNull = valueCounts(s, { dropna: false });
 console.log("dropna=false index:", keepNull.index.values);
 console.log("dropna=false values:", keepNull.values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+s = pd.Series(["a", None, "b", None, "a"])
+
+# dropna=True (default) — exclude nulls
+drop_null = s.value_counts()
+print("dropna=True  index:", drop_null.index.tolist())
+print("dropna=True  values:", drop_null.values.tolist())
+
+# dropna=False — include nulls
+keep_null = s.value_counts(dropna=False)
+print("dropna=False index:", keep_null.index.tolist())
+print("dropna=False values:", keep_null.values.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -323,6 +363,18 @@ <h2>5 · DataFrame value_counts</h2>
 const vc = dataFrameValueCounts(df);
 console.log("index:", vc.index.values);
 console.log("counts:", vc.values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame([
+    {"city": "NYC", "temp": "hot"},
+    {"city": "NYC", "temp": "cold"},
+    {"city": "LA",  "temp": "hot"},
+    {"city": "NYC", "temp": "hot"},
+])
+
+vc = df.value_counts()
+print("index:", vc.index.tolist())
+print("counts:", vc.values.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
@@ -352,6 +404,18 @@ <h2>6 · DataFrame subset</h2>
 const vc = dataFrameValueCounts(df, { subset: ["city"] });
 console.log("index:", vc.index.values);
 console.log("counts:", vc.values);</textarea>
+      <textarea class="playground-python" style="display:none">import pandas as pd
+
+df = pd.DataFrame([
+    {"city": "NYC", "temp": "hot"},
+    {"city": "NYC", "temp": "cold"},
+    {"city": "LA",  "temp": "hot"},
+    {"city": "NYC", "temp": "hot"},
+])
+
+vc = df.value_counts(subset=["city"])
+print("index:", vc.index.tolist())
+print("counts:", vc.values.tolist())</textarea>
       <div class="playground-output">Click ▶ Run to execute</div>
       <div class="playground-hint">Ctrl+Enter to run · Tab to indent</div>
     </div>
diff --git a/scripts/validate-python-examples.py b/scripts/validate-python-examples.py
new file mode 100644
index 000000000..39da0b4e7
--- /dev/null
+++ b/scripts/validate-python-examples.py
@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""
+Validate Python/pandas examples from playground HTML pages.
+
+Extracts all <textarea class="playground-python"> blocks from playground HTML
+files, runs each one with Python/pandas, and reports any failures.
+
+Usage:
+    python scripts/validate-python-examples.py [playground_dir]
+
+Exit code 0 if all examples pass, 1 if any fail.
+"""
+
+import html
+import os
+import re
+import subprocess
+import sys
+import tempfile
+import time
+
+
+def extract_python_blocks(html_file: str) -> list[tuple[str, str]]:
+    """Extract Python code blocks from a playground HTML file.
+
+    Returns a list of (section_label, code) tuples.
+    """
+    with open(html_file, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    blocks: list[tuple[str, str]] = []
+
+    # Find all playground-python textareas
+    pattern = re.compile(
+        r'<textarea\s+class="playground-python"[^>]*>(.*?)</textarea>',
+        re.DOTALL,
+    )
+
+    # Also find section headings to label blocks
+    section_pattern = re.compile(r"<h2>(.*?)</h2>", re.DOTALL)
+    sections = section_pattern.findall(content)
+
+    for i, match in enumerate(pattern.finditer(content)):
+        code = html.unescape(match.group(1))
+        # Try to find the closest preceding section heading
+        label = sections[i] if i < len(sections) else f"block_{i}"
+        # Strip HTML tags from label
+        label = re.sub(r"<[^>]+>", "", label).strip()
+        blocks.append((label, code))
+
+    return blocks
+
+
+def run_python_block(code: str, label: str, html_file: str) -> tuple[bool, str, float]:
+    """Run a Python code block and return (success, output, elapsed_ms)."""
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".py", delete=False, encoding="utf-8"
+    ) as f:
+        f.write(code)
+        tmp_path = f.name
+
+    try:
+        start = time.perf_counter()
+        result = subprocess.run(
+            [sys.executable, tmp_path],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        elapsed_ms = (time.perf_counter() - start) * 1000
+
+        if result.returncode != 0:
+            return (
+                False,
+                f"STDERR:\n{result.stderr}\nSTDOUT:\n{result.stdout}",
+                elapsed_ms,
+            )
+        return True, result.stdout, elapsed_ms
+    except subprocess.TimeoutExpired:
+        return False, "TIMEOUT (30s)", 0.0
+    finally:
+        os.unlink(tmp_path)
+
+
+def main() -> int:
+    playground_dir = sys.argv[1] if len(sys.argv) > 1 else "playground"
+
+    if not os.path.isdir(playground_dir):
+        print(f"Error: directory '{playground_dir}' not found", file=sys.stderr)
+        return 1
+
+    html_files = sorted(
+        f
+        for f in os.listdir(playground_dir)
+        if f.endswith(".html") and f != "index.html"
+    )
+
+    total = 0
+    passed = 0
+    failed = 0
+    failures: list[str] = []
+
+    for html_file in html_files:
+        filepath = os.path.join(playground_dir, html_file)
+        blocks = extract_python_blocks(filepath)
+
+        if not blocks:
+            continue
+
+        print(f"\n{'='*60}")
+        print(f"  {html_file} ({len(blocks)} Python blocks)")
+        print(f"{'='*60}")
+
+        for i, (label, code) in enumerate(blocks):
+            total += 1
+            success, output, elapsed_ms = run_python_block(
+                code, label, html_file
+            )
+
+            if success:
+                passed += 1
+                print(f"  ✅ [{i+1}] {label} ({elapsed_ms:.1f}ms)")
+            else:
+                failed += 1
+                fail_msg = f"  ❌ [{i+1}] {label} in {html_file}"
+                print(fail_msg)
+                print(f"     {output[:200]}")
+                failures.append(f"{html_file} [{i+1}] {label}")
+
+    print(f"\n{'='*60}")
+    print(f"  Results: {passed}/{total} passed, {failed} failed")
+    print(f"{'='*60}")
+
+    if failures:
+        print("\nFailed examples:")
+        for f in failures:
+            print(f"  - {f}")
+        return 1
+
+    print("\n✅ All Python examples validated successfully!")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())