0Pricing
Pandas & NumPy Academy · Lesson

Chi-Squared Test for Independence

Test whether two categorical variables are independent using chi2_contingency on a crosstab frequency table.

Chi-Squared Test for Independence is a free Pandas & NumPy Academy lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Pandas & NumPy Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Testing Categorical Relationships

The chi-squared test for independence tests whether two categorical variables are statistically independent or whether there is an association between them. For example: 'Is customer churn independent of subscription tier?' or 'Is product preference independent of age group?' Unlike t-tests that compare numeric means, chi-squared tests compare observed frequencies in a contingency table to the frequencies we would expect if the variables were independent.

Building a Contingency Table with Pandas

A contingency table (also called a cross-tabulation) shows the count of observations for each combination of two categorical variables. pd.crosstab(df['var1'], df['var2']) builds this table directly from a DataFrame. Each cell contains the count of observations where row category and column category co-occur. This is the input to scipy.stats.chi2_contingency().

import pandas as pd
import numpy as np

np.random.seed(0)
df = pd.DataFrame({
    'subscription': np.random.choice(['free', 'basic', 'pro'], 300),
    'churned': np.random.choice(['yes', 'no'], 300, p=[0.3, 0.7])
})

# Build contingency table
ct = pd.crosstab(df['subscription'], df['churned'])
print(ct)
print()
print('Row totals:', ct.sum(axis=1).to_dict())

Running chi2_contingency()

scipy.stats.chi2_contingency(observed) takes the observed contingency table (as a NumPy array or Pandas DataFrame) and returns four values: the chi-squared statistic, the p-value, the degrees of freedom, and the expected frequency table. The null hypothesis is H₀: the two variables are independent. If p ≤ 0.05, we reject independence and conclude there is a statistically significant association.

import pandas as pd
import numpy as np
from scipy import stats

np.random.seed(0)
df = pd.DataFrame({
    'tier': np.random.choice(['free', 'basic', 'pro'], 300),
    'churned': np.random.choice(['yes', 'no'], 300, p=[0.3, 0.7])
})

ct = pd.crosstab(df['tier'], df['churned'])
chi2, p, dof, expected = stats.chi2_contingency(ct)

print(f'Chi-squared: {chi2:.3f}')
print(f'p-value: {p:.4f}')
print(f'Degrees of freedom: {dof}')
print('Association significant?', 'Yes' if p < 0.05 else 'No')

Understanding Expected Frequencies

The expected frequencies represent what the cell counts would look like if the two variables were perfectly independent. For each cell, expected = (row_total × column_total) / grand_total. The chi-squared statistic measures the sum of squared differences between observed and expected counts, normalised by the expected counts. Large chi-squared means observed counts deviate strongly from independence; small chi-squared means the data is consistent with independence.

import pandas as pd
import numpy as np
from scipy import stats

observed = pd.DataFrame({
    'converted': [50, 30],
    'not_converted': [150, 170]
}, index=['variant', 'control'])

chi2, p, dof, expected = stats.chi2_contingency(observed)
print('Observed:')
print(observed)
print()
print('Expected (under independence):')
print(pd.DataFrame(expected,
                   index=observed.index,
                   columns=observed.columns).round(1))

Degrees of Freedom in Chi-Squared

For a contingency table with r rows and c columns, the degrees of freedom is df = (r-1) × (c-1). A 2×2 table has df=1; a 3×4 table has df=6. The critical value of chi-squared increases with degrees of freedom: for df=1 at α=0.05, critical value ≈ 3.84; for df=6 at α=0.05, critical value ≈ 12.6. The chi2_contingency function handles this automatically, but knowing the formula helps you understand why chi-squared from larger tables requires bigger statistics to be significant.

from scipy import stats

# Critical values of chi-squared for alpha=0.05
for df in [1, 2, 3, 4, 6, 9]:
    critical = stats.chi2.ppf(0.95, df=df)
    print(f'df={df}: critical value = {critical:.3f}')

The Assumption of Minimum Expected Frequency

The chi-squared test is only reliable when all expected frequencies are at least 5 (some sources say at least 1 with no more than 20% below 5). Small expected counts make the chi-squared approximation inaccurate. When this assumption is violated, use Fisher's exact test (scipy.stats.fisher_exact()) for 2×2 tables, or collapse rare categories to increase expected counts. Always inspect the expected frequency matrix returned by chi2_contingency.

import numpy as np
from scipy import stats

# Table with small expected counts
observed = np.array([[2, 3], [100, 95]])
chi2, p, dof, expected = stats.chi2_contingency(observed)

print('Expected frequencies:')
print(expected)
print('Min expected:', expected.min())

if expected.min() < 5:
    print('Warning: Expected frequency < 5. Use Fisher\'s exact test.')
    odds_ratio, p_fisher = stats.fisher_exact(observed)
    print(f'Fisher\'s exact p: {p_fisher:.4f}')

Fisher's Exact Test for Small Samples

scipy.stats.fisher_exact(table) computes the exact probability of observing the given 2×2 table (or one more extreme) under the null hypothesis of independence, without any approximation. It is always valid regardless of sample size or cell counts — the p-value is exact, not approximate. The cost is computational: it enumerates all possible tables, making it slow for large totals. For 2×2 tables with any cell count below 5, always prefer Fisher's exact test over chi-squared.

import numpy as np
from scipy import stats

# Small clinical trial: treatment vs. outcome
observed = np.array([
    [3, 12],   # treated: 3 improved, 12 did not
    [1, 18]    # control: 1 improved, 18 did not
])

odds_ratio, p = stats.fisher_exact(observed, alternative='two-sided')
print(f'Odds ratio: {odds_ratio:.3f}')
print(f'p-value: {p:.4f}')
print('Association significant?', 'Yes' if p < 0.05 else 'No')

Measuring Association Strength: Cramér's V

Like Cohen's d for t-tests, the chi-squared statistic alone does not measure the strength of association — it is inflated by sample size. Cramér's V normalises chi-squared to a 0–1 scale: 0 means no association, 1 means perfect association. V = sqrt(chi2 / (n × min(r-1, c-1))). Guidelines: < 0.1 is weak, 0.1–0.3 is moderate, > 0.3 is strong. Always report Cramér's V alongside the p-value for a complete picture.

import pandas as pd
import numpy as np
from scipy import stats

np.random.seed(0)
df = pd.DataFrame({
    'tier': np.random.choice(['free', 'basic', 'pro'], 500),
    'churn': np.random.choice(['yes', 'no'], 500, p=[0.3, 0.7])
})
ct = pd.crosstab(df['tier'], df['churn'])

chi2, p, dof, _ = stats.chi2_contingency(ct)
n = ct.sum().sum()
min_dim = min(ct.shape[0]-1, ct.shape[1]-1)
cramers_v = np.sqrt(chi2 / (n * min_dim))

print(f'chi2={chi2:.3f}, p={p:.4f}')
print(f'Cramer\'s V: {cramers_v:.4f}')
print('Association strength:', 'strong' if cramers_v > 0.3 else 'moderate' if cramers_v > 0.1 else 'weak')

Chi-Squared Goodness of Fit

A different application of chi-squared is the goodness-of-fit test: it tests whether observed frequencies match a hypothesised distribution. For example, 'Are die rolls uniformly distributed?' or 'Does our website traffic follow the expected day-of-week pattern?' Use scipy.stats.chisquare(f_obs, f_exp) where f_exp is the expected frequencies. The null hypothesis is that the data follows the specified distribution.

import numpy as np
from scipy import stats

# Observed: counts for each weekday over 70 weeks
observed = np.array([980, 1050, 1020, 1080, 1120, 850, 900])
# Expected: uniform distribution
expected = np.full(7, observed.sum() / 7)

chi2, p = stats.chisquare(f_obs=observed, f_exp=expected)
print('Observed:', observed)
print('Expected (uniform):', expected.round(0))
print(f'chi2={chi2:.3f}, p={p:.4f}')
print('Uniform?', 'Yes' if p > 0.05 else 'No - some days significantly busier')

Using pd.crosstab with normalise

When reporting chi-squared results, it helps to show proportions rather than raw counts so readers can see the relative association. pd.crosstab(var1, var2, normalize='index') shows the row proportion (what fraction of each row category falls in each column). normalize='columns' shows column proportions. Comparing these proportions visually before running the test helps you anticipate the direction of the association and interpret the result in context.

import pandas as pd
import numpy as np

np.random.seed(0)
df = pd.DataFrame({
    'tier': np.random.choice(['free', 'basic', 'pro'], 300),
    'churned': np.random.choice(['yes', 'no'], 300, p=[0.3, 0.7])
})

# Row-proportions: churn rate within each tier
prop_table = pd.crosstab(df['tier'], df['churned'], normalize='index')
print('Churn rate by tier:')
print((prop_table * 100).round(1))

Chi-Squared Test in A/B Testing

The chi-squared test is the standard test for A/B testing conversion rates. Create a 2×2 contingency table with rows = (control, variant) and columns = (converted, not converted). The chi-squared test tells you whether the conversion rate differs significantly between groups. This is equivalent to a two-proportion z-test for large samples. For small samples (any expected count < 5), use Fisher's exact test instead.

import numpy as np
from scipy import stats

# A/B test: control vs. variant, conversions vs. non-conversions
control_conv = 45
control_total = 500
variant_conv = 63
variant_total = 500

contingency = np.array([
    [control_conv, control_total - control_conv],
    [variant_conv, variant_total - variant_conv]
])

chi2, p, dof, expected = stats.chi2_contingency(contingency)
print(f'Control rate: {control_conv/control_total:.1%}')
print(f'Variant rate: {variant_conv/variant_total:.1%}')
print(f'p-value: {p:.4f}')
print('Variant significantly better?', 'Yes' if p < 0.05 else 'No')

Quick Check

Test your understanding of Data Analysis concepts from this lesson.

Lesson Recap

In this lesson you learned: pd.crosstab() + chi2_contingency() test whether two categorical variables are independent based on observed vs. expected frequencies, Fisher's exact test is the safe alternative when expected counts are below 5, and Cramér's V measures association strength independently of sample size. Next up we compare means across three or more groups with ANOVA and post-hoc tests.

Frequently asked questions

Is the “Chi-Squared Test for Independence” lesson free?

Yes — the full text of “Chi-Squared Test for Independence” is free to read here on the web, and the Pandas & NumPy Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Pandas & NumPy Academy course, upgrade to CoddyKit PRO.

What will I learn in “Chi-Squared Test for Independence”?

Test whether two categorical variables are independent using chi2_contingency on a crosstab frequency table. You practise Pandas & NumPy Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Pandas & NumPy Academy?

No prior experience is required. Pandas & NumPy Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Chi-Squared Test for Independence” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Pandas & NumPy Academy lesson?

Yes. Every Pandas & NumPy Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Descriptive Stats and Normality Testing
  2. T-Tests for Comparing Means
  3. Chi-Squared Test for Independence
  4. ANOVA and Post-Hoc Tests
← Back to Pandas & NumPy Academy