Skip to content
Learni
View all tutorials
Data Science

How to Master the Basics of Pandas in 2026

12 minBEGINNER
PythonData ScienceAnalyse de donnéesPandas
Lire en français

Introduction

Pandas, the open-source Python library, has revolutionized data analysis since 2008. Inspired by R's structures and NumPy, it excels at handling tabular data—like giant, programmable Excel spreadsheets. In 2026, amid the rise of AI and big data, Pandas remains essential: 80% of data scientists use it daily, per Stack Overflow.

Why learn it? Imagine turning chaotic e-commerce sales CSVs into actionable insights in minutes. This beginner tutorial, 100% conceptual with no code, lays the theoretical groundwork. You'll grasp Series and DataFrames, key operations, and pro practices. Result: go from novice to confident in data manipulation, ready for real projects like cleaning Kaggle datasets or prepping ML models.

Prerequisites

  • Basic Python knowledge (variables, lists, dictionaries).
  • Elementary understanding of tabular data (rows, columns, like a spreadsheet).
  • No prior Pandas experience needed: everything starts from zero.
  • Estimated time: 15-20 minutes of active reading.

Core Structures: Series and DataFrames

Pandas is built on two pillars: Series and DataFrames.

A Series is a one-dimensional, indexed array, like an ordered dictionary. Think: an Excel column with headers. Example: employee salaries {'Alice': 50000, 'Bob': 60000}. The index (names) enables fast access, unlike plain Python lists.

A DataFrame extends this to a 2D table: rows (observations) and columns (variables). Think: a full Excel sheet. Example: employee dataset with 'Name', 'Salary', 'Department' columns. Each column is a Series; rows share an index.

Indexing: unique keys (integers, strings, dates). Key difference: label-based access (df['column']) vs. position-based (df.iloc[0]). This prevents common data analysis errors.

Selection and Filtering Operations

Selection: extracting subsets.

  • Columns: by name (df['salary']) or list (df[['name', 'salary']] → new DataFrame).
  • Rows: by index (df.loc['Alice']) or position (df.iloc[0:3]). Example: top 5 earners.

Filtering (boolean indexing): logical conditions. Like Excel filters. Example: df[df['salary'] > 55000] keeps rows above 55000€. Chainable: df[(df['dept'] == 'IT') & (df['salary'] > 50000)]. Operators: &, |, ~ (AND, OR, NOT).

Query: SQL-like syntax for readability: df.query('salary > 55000 and dept == "IT"'). Perfect for complex datasets like web logs.

Data Manipulation and Transformation

Adding/deleting: dynamic columns. df['bonus'] = df['salary'] * 0.1 (vectorized, blazing fast). Delete: del df['column'] or df.drop().

GroupBy: aggregation by groups, like Excel pivots. Steps: split (by 'department'), apply (mean salary), combine. Example: df.groupby('dept')['salary'].mean() → {'IT': 65000, 'HR': 45000}.

Merge/Join: combining datasets. Types: inner (intersection), left (all from left), etc. Like advanced VLOOKUP. Example: merge employees + departments for enriched data.

Apply/Map: custom functions. map() on Series (element-wise), apply() on axes (rows/columns). Avoid for loops: Pandas vectorization is 100x faster.

Handling Missing Data and Cleaning

Real datasets have 20-30% missing values. Pandas detects NaN/infinites.

Detection: df.isnull().sum() counts per column.
Treatment:

  • Drop: df.dropna() (rows) or subset=['col'].
  • Fill: df.fillna(0) or mean (df['salary'].fillna(df['salary'].mean())). Strategy: forward-fill for time series (e.g., stock prices).

Duplicates: df.duplicated().drop_duplicates().
Types: df.dtypes; convert with astype('int') or pd.to_datetime(). Example: '2026-01-01' strings to dates for time analysis.

Cleaning checklist: 1. Inspect shapes/info. 2. Handle NaN. 3. Fix types. 4. Remove duplicates. Turns chaos into gold.

Essential Best Practices

  • Index smartly: use dates/names as index for fast joins (set_index()). Avoids label/position confusion.
  • Vectorize everything: prefer Pandas ops (df['col'] + 10) over loops. Speed gain: 10-100x on 1M rows.
  • Method chaining: df.query('...').groupby(...).agg(...) for readable pipelines, fewer errors.
  • Copy before modifying: df.copy(deep=True) prevents SettingWithCopyWarning (unexpected mutations).
  • Profile memory: df.info(memory_usage='deep'); astype('category') for factors (e.g., genders) cuts RAM by 90%.

Common Errors to Avoid

  • SettingWithCopyWarning: chains like df[col][row] = val modify views, not copies. Fix: .loc[:] or .copy().
  • Ignoring index: reset_index() after groupby to avoid lost indexes in CSV exports.
  • Memory explosions: load big files without chunksize or early dtypes. Use low_memory=False wisely.
  • Malformed boolean filtering: df[col == val] without parens → errors. Always (cond1) & (cond2).

Next Steps

Mastered Pandas concepts? Time for hands-on:

  • Official docs: pandas.pydata.org.
  • Datasets: Kaggle (Titanic for groupby).
  • Books: "Python for Data Analysis" (Wes McKinney, Pandas creator).
  • Complementary tools: Matplotlib/Seaborn for visualization, Scikit-learn for ML.

Check out our Learni Data Science courses: hands-on Pandas + PyTorch workshops in 2026.