{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Simple Time Series Analysis with Census Data\n", "\n", "This tutorial teaches you how to analyze changes in demographic data over time using the US Census Bureau's datasets. We'll focus on **geographic levels that don't change over time** (like states and counties) to keep things simple and avoid complex boundary adjustments.\n", "\n", "## What You'll Learn\n", "\n", "1. **The Golden Rule**: Only compare like survey types (ACS5↔ACS5, Decennial↔Decennial)\n", "2. **Population trends** using decennial census data (2010 vs 2020)\n", "3. **Income trends** using ACS 5-year data (2012 vs 2020)\n", "4. **Best practices** for temporal analysis\n", "5. **Visualization techniques** for demographic change\n", "\n", "## Why This Matters\n", "\n", "Understanding demographic change over time helps with:\n", "- Urban planning and policy decisions\n", "- Business location and market analysis \n", "- Research on social and economic trends\n", "- Grant writing and community development" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Setup: Import Libraries and API Key\n", "\n", "First, let's import the libraries we need and set up our Census API key." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Libraries imported successfully!\n", "Using pytidycensus version: 1.0.4\n" ] } ], "source": [ "# Import required libraries\n", "import pytidycensus as tc\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", "# Make plots look nicer\n", "plt.style.use('default')\n", "plt.rcParams['figure.figsize'] = (12, 8)\n", "plt.rcParams['font.size'] = 11\n", "\n", "print(\"Libraries imported successfully!\")\n", "print(f\"Using pytidycensus version: {tc.__version__}\")" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Remember to set your Census API key above!\n", " Get one free at: https://api.census.gov/data/key_signup.html\n" ] } ], "source": [ "# Set your Census API key here\n", "# Get a free key at: https://api.census.gov/data/key_signup.html\n", "\n", "# UNCOMMENT and add your key:\n", "# tc.set_census_api_key(\"YOUR_API_KEY_HERE\")\n", "\n", "print(\" Remember to set your Census API key above!\")\n", "print(\" Get one free at: https://api.census.gov/data/key_signup.html\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The Golden Rule of Census Time Series\n", "\n", "**CRITICAL**: Only compare surveys of the same type!\n", "\n", "### ✅ CORRECT Comparisons\n", "- **Decennial 2010 ↔ Decennial 2020**: Complete population counts\n", "- **ACS 5-year 2012 ↔ ACS 5-year 2020**: Same methodology, sample size\n", "- **ACS 1-year 2019 ↔ ACS 1-year 2021**: Recent estimates for large areas\n", "\n", "### ❌ WRONG Comparisons\n", "- **ACS 1-year ↔ ACS 5-year**: Different sample sizes and time periods\n", "- **Decennial ↔ ACS**: Different methodologies (complete count vs. sample)\n", "\n", "### Why This Matters" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SURVEY TYPE COMPARISON:\n", "==================================================\n", "DECENNIAL CENSUS:\n", " • Complete count of all households\n", " • Very low margin of error\n", " • Every 10 years (2010, 2020, 2030...)\n", " • Best for: Long-term trends, small areas\n", "\n", "ACS 5-YEAR:\n", " • Sample survey (~3.5M addresses/year)\n", " • 5 years of data combined for stability\n", " • Available for all geographies\n", " • Best for: Small areas, stable trends\n", "\n", "ACS 1-YEAR:\n", " • Sample survey (~3.5M addresses/year)\n", " • Single year of data\n", " • Only areas with 65,000+ population\n", " • Best for: Large areas, recent trends\n" ] } ], "source": [ "# Let's demonstrate why survey type matters\n", "print(\"SURVEY TYPE COMPARISON:\")\n", "print(\"=\" * 50)\n", "print(\"DECENNIAL CENSUS:\")\n", "print(\" • Complete count of all households\")\n", "print(\" • Very low margin of error\")\n", "print(\" • Every 10 years (2010, 2020, 2030...)\")\n", "print(\" • Best for: Long-term trends, small areas\")\n", "print()\n", "print(\"ACS 5-YEAR:\")\n", "print(\" • Sample survey (~3.5M addresses/year)\")\n", "print(\" • 5 years of data combined for stability\")\n", "print(\" • Available for all geographies\")\n", "print(\" • Best for: Small areas, stable trends\")\n", "print()\n", "print(\"ACS 1-YEAR:\")\n", "print(\" • Sample survey (~3.5M addresses/year)\")\n", "print(\" • Single year of data\")\n", "print(\" • Only areas with 65,000+ population\")\n", "print(\" • Best for: Large areas, recent trends\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Part 1: Population Change Analysis (Decennial Census)\n", "\n", "Let's start by analyzing population changes in the Washington DC metro area between 2010 and 2020 using decennial census data. We'll compare **DC, Maryland, and Virginia** at the state level.\n", "\n", "### Why Use State Level?\n", "- State boundaries don't change over time\n", "- No need for complex boundary adjustments\n", "- Reliable and straightforward comparison" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Fetching 2010 decennial census data...\n", " Variable: P001001 (Total Population)\n", "Getting data from the 2010 decennial Census\n", "Using Census Summary File 1\n", "Retrieved data for 3 states\n", "\n", "2010 Population Data:\n", " NAME total_pop\n", " DC 601723\n", "Maryland 5773552\n", "Virginia 8001024\n" ] } ], "source": [ "# Step 1: Get 2010 population data for DC metro states\n", "print(\" Fetching 2010 decennial census data...\")\n", "print(\" Variable: P001001 (Total Population)\")\n", "\n", "# Define the states we want to analyze\n", "metro_states = [\"DC\", \"MD\", \"VA\"]\n", "\n", "# Get 2010 data\n", "pop_2010 = tc.get_decennial(\n", " geography=\"state\",\n", " variables={\"total_pop\": \"P001001\"}, # P001001 = Total Population in 2010\n", " state=metro_states,\n", " year=2010,\n", " output=\"wide\" # Wide format puts variables as columns\n", ")\n", "\n", "print(f\"Retrieved data for {len(pop_2010)} states\")\n", "print(\"\\n2010 Population Data:\")\n", "print(pop_2010[['NAME', 'total_pop']].to_string(index=False))" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Fetching 2020 decennial census data...\n", " Variable: P1_001N (Total Population)\n", " Note: Variable codes changed between 2010 and 2020!\n", "Getting data from the 2020 decennial Census\n", "Using the PL 94-171 Redistricting Data Summary File\n", "Retrieved data for 3 states\n", "\n", "2020 Population Data:\n", " NAME total_pop\n", " DC 689545\n", "Maryland 6177224\n", "Virginia 8631393\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/home/mmann1123/Documents/github/pytidycensus/pytidycensus/decennial.py:429: UserWarning: Note: 2020 decennial Census data use differential privacy, a technique that introduces errors into data to preserve respondent confidentiality. Small counts should be interpreted with caution. See https://www.census.gov/library/fact-sheets/2021/protecting-the-confidentiality-of-the-2020-census-redistricting-data.html for additional guidance.\n", " warnings.warn(\n" ] } ], "source": [ "# Step 2: Get 2020 population data\n", "print(\" Fetching 2020 decennial census data...\")\n", "print(\" Variable: P1_001N (Total Population)\")\n", "print(\" Note: Variable codes changed between 2010 and 2020!\")\n", "\n", "# Get 2020 data - NOTE: Different variable code!\n", "pop_2020 = tc.get_decennial(\n", " geography=\"state\",\n", " variables={\"total_pop\": \"P1_001N\"}, # P1_001N = Total Population in 2020\n", " state=metro_states,\n", " year=2020,\n", " output=\"wide\"\n", ")\n", "\n", "print(f\"Retrieved data for {len(pop_2020)} states\")\n", "print(\"\\n2020 Population Data:\")\n", "print(pop_2020[['NAME', 'total_pop']].to_string(index=False))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 🔍 Key Learning Point: Variable Codes Change!\n", "\n", "Notice that we used different variable codes:\n", "- **2010**: `P001001` \n", "- **2020**: `P1_001N`\n", "\n", "This is common when comparing across census years. Always check variable definitions!" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Calculating population changes...\n", "Population change analysis complete!\n", "\n", "Population Change Summary (2010-2020):\n", "============================================================\n", "DC:\n", " 2010: 601,723\n", " 2020: 689,545\n", " Change: +87,822 (+14.6%)\n", "\n", "Maryland:\n", " 2010: 5,773,552\n", " 2020: 6,177,224\n", " Change: +403,672 (+7.0%)\n", "\n", "Virginia:\n", " 2010: 8,001,024\n", " 2020: 8,631,393\n", " Change: +630,369 (+7.9%)\n", "\n" ] } ], "source": [ "# Step 3: Merge the data and calculate changes\n", "print(\" Calculating population changes...\")\n", "\n", "# Merge 2010 and 2020 data on state name\n", "pop_change = pd.merge(\n", " pop_2010[['NAME', 'total_pop']].rename(columns={'total_pop': 'pop_2010'}),\n", " pop_2020[['NAME', 'total_pop']].rename(columns={'total_pop': 'pop_2020'}),\n", " on='NAME'\n", ")\n", "\n", "# Calculate absolute and percentage changes\n", "pop_change['change_absolute'] = pop_change['pop_2020'] - pop_change['pop_2010']\n", "pop_change['change_percent'] = (pop_change['change_absolute'] / pop_change['pop_2010']) * 100\n", "\n", "print(\"Population change analysis complete!\")\n", "print(\"\\nPopulation Change Summary (2010-2020):\")\n", "print(\"=\" * 60)\n", "\n", "for _, row in pop_change.iterrows():\n", " print(f\"{row['NAME']}:\")\n", " print(f\" 2010: {row['pop_2010']:,}\")\n", " print(f\" 2020: {row['pop_2020']:,}\")\n", " print(f\" Change: {row['change_absolute']:+,} ({row['change_percent']:+.1f}%)\")\n", " print()" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "DC METRO AREA SUMMARY:\n", " Total 2010 Population: 14,376,299\n", " Total 2020 Population: 15,498,162\n", " Net Change: +1,121,863 (+7.8%)\n" ] } ], "source": [ "# Step 4: Visualize the population changes\n", "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))\n", "\n", "# Chart 1: Absolute change\n", "colors = ['red' if x < 0 else 'steelblue' for x in pop_change['change_absolute']]\n", "bars1 = ax1.bar(pop_change['NAME'], pop_change['change_absolute'], color=colors, alpha=0.7)\n", "ax1.set_title('Population Change 2010-2020\\n(Absolute Numbers)', fontsize=14, fontweight='bold')\n", "ax1.set_ylabel('Population Change')\n", "ax1.axhline(y=0, color='black', linestyle='-', alpha=0.3)\n", "ax1.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'{x/1000:.0f}K'))\n", "\n", "# Add value labels on bars\n", "for bar, value in zip(bars1, pop_change['change_absolute']):\n", " height = bar.get_height()\n", " ax1.text(bar.get_x() + bar.get_width()/2., height + (5000 if height >= 0 else -15000),\n", " f'{value/1000:.0f}K', ha='center', va='bottom' if height >= 0 else 'top', fontweight='bold')\n", "\n", "# Chart 2: Percentage change\n", "colors2 = ['red' if x < 0 else 'darkgreen' for x in pop_change['change_percent']]\n", "bars2 = ax2.bar(pop_change['NAME'], pop_change['change_percent'], color=colors2, alpha=0.7)\n", "ax2.set_title('Population Change 2010-2020\\n(Percentage)', fontsize=14, fontweight='bold')\n", "ax2.set_ylabel('Percent Change (%)')\n", "ax2.axhline(y=0, color='black', linestyle='-', alpha=0.3)\n", "\n", "# Add value labels on bars\n", "for bar, value in zip(bars2, pop_change['change_percent']):\n", " height = bar.get_height()\n", " ax2.text(bar.get_x() + bar.get_width()/2., height + (0.3 if height >= 0 else -0.8),\n", " f'{value:.1f}%', ha='center', va='bottom' if height >= 0 else 'top', fontweight='bold')\n", "\n", "plt.tight_layout()\n", "plt.show()\n", "\n", "# Summary statistics\n", "total_2010 = pop_change['pop_2010'].sum()\n", "total_2020 = pop_change['pop_2020'].sum()\n", "total_change = total_2020 - total_2010\n", "total_pct = (total_change / total_2010) * 100\n", "\n", "print(f\"DC METRO AREA SUMMARY:\")\n", "print(f\" Total 2010 Population: {total_2010:,}\")\n", "print(f\" Total 2020 Population: {total_2020:,}\")\n", "print(f\" Net Change: {total_change:+,} ({total_pct:+.1f}%)\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Part 2: Income Change Analysis (ACS 5-Year Data)\n", "\n", "Now let's analyze how median household income changed in the DC metro area using **ACS 5-year data**. We'll compare 2012 (2008-2012 ACS) with 2020 (2016-2020 ACS).\n", "\n", "### Why These Years?\n", "- **2012 ACS 5-year**: Represents 2008-2012 period (pre-recession recovery)\n", "- **2020 ACS 5-year**: Represents 2016-2020 period (recent data)\n", "- **8-year gap**: Provides meaningful temporal separation\n", "\n", "### County-Level Analysis\n", "We'll look at specific counties in the DC metro area that are economically important." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Target Counties for Income Analysis:\n", " • Washington DC\n", " • Montgomery County, MD\n", " • Arlington County, VA\n", " • Fairfax County, VA\n", "\n", "Variable: B19013_001E (Median Household Income)\n", "Comparing: 2012 ACS 5-year vs 2020 ACS 5-year\n" ] } ], "source": [ "# Define the counties we want to analyze\n", "counties_to_analyze = [\n", " {\"state\": \"DC\", \"county\": None, \"display_name\": \"Washington DC\"},\n", " {\"state\": \"MD\", \"county\": \"Montgomery County\", \"display_name\": \"Montgomery County, MD\"},\n", " {\"state\": \"VA\", \"county\": \"Arlington County\", \"display_name\": \"Arlington County, VA\"},\n", " {\"state\": \"VA\", \"county\": \"Fairfax County\", \"display_name\": \"Fairfax County, VA\"}\n", "]\n", "\n", "print(\"Target Counties for Income Analysis:\")\n", "for county in counties_to_analyze:\n", " print(f\" • {county['display_name']}\")\n", "print()\n", "print(\"Variable: B19013_001E (Median Household Income)\")\n", "print(\"Comparing: 2012 ACS 5-year vs 2020 ACS 5-year\")" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Fetching 2012 ACS 5-year data (2008-2012)...\n", "Getting data from the 2008-2012 5-year ACS\n", " Washington DC: $64,267\n", "Getting data from the 2008-2012 5-year ACS\n", " Montgomery County, MD: $96,985\n", "Getting data from the 2008-2012 5-year ACS\n", " Arlington County, VA: $102,459\n", "Getting data from the 2008-2012 5-year ACS\n", " Fairfax County, VA: $109,383\n", "\n", " Successfully retrieved 2012 data for 4 counties\n" ] } ], "source": [ "# Step 1: Get 2012 ACS income data\n", "print(\"Fetching 2012 ACS 5-year data (2008-2012)...\")\n", "\n", "income_2012_data = []\n", "\n", "for county_info in counties_to_analyze:\n", " try:\n", " income_data = tc.get_acs(\n", " geography=\"county\",\n", " variables={\"median_income\": \"B19013_001E\"},\n", " state=county_info[\"state\"],\n", " county=county_info[\"county\"], # None for DC (state-equivalent)\n", " year=2012,\n", " survey=\"acs5\",\n", " output=\"wide\"\n", " )\n", " \n", " # Add display name for easier tracking\n", " income_data['display_name'] = county_info['display_name']\n", " income_2012_data.append(income_data)\n", " \n", " print(f\" {county_info['display_name']}: ${income_data.iloc[0]['median_income']:,}\")\n", " \n", " except Exception as e:\n", " print(f\" {county_info['display_name']}: Error - {str(e)[:50]}...\")\n", "\n", "# Combine all 2012 data\n", "if income_2012_data:\n", " income_2012_combined = pd.concat(income_2012_data, ignore_index=True)\n", " print(f\"\\n Successfully retrieved 2012 data for {len(income_2012_combined)} counties\")\n", "else:\n", " print(\"\\n No 2012 data retrieved\")" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Fetching 2020 ACS 5-year data (2016-2020)...\n", "Getting data from the 2016-2020 5-year ACS\n", " Washington DC: $90,842\n", "Getting data from the 2016-2020 5-year ACS\n", " Montgomery County, MD: $111,812\n", "Getting data from the 2016-2020 5-year ACS\n", " Arlington County, VA: $122,604\n", "Getting data from the 2016-2020 5-year ACS\n", " Fairfax County, VA: $127,866\n", "\n", " Successfully retrieved 2020 data for 4 counties\n" ] } ], "source": [ "# Step 2: Get 2020 ACS income data\n", "print(\"Fetching 2020 ACS 5-year data (2016-2020)...\")\n", "\n", "income_2020_data = []\n", "\n", "for county_info in counties_to_analyze:\n", " try:\n", " income_data = tc.get_acs(\n", " geography=\"county\",\n", " variables={\"median_income\": \"B19013_001E\"},\n", " state=county_info[\"state\"],\n", " county=county_info[\"county\"],\n", " year=2020,\n", " survey=\"acs5\",\n", " output=\"wide\"\n", " )\n", " \n", " income_data['display_name'] = county_info['display_name']\n", " income_2020_data.append(income_data)\n", " \n", " print(f\" {county_info['display_name']}: ${income_data.iloc[0]['median_income']:,}\")\n", " \n", " except Exception as e:\n", " print(f\" {county_info['display_name']}: Error - {str(e)[:50]}...\")\n", "\n", "# Combine all 2020 data\n", "if income_2020_data:\n", " income_2020_combined = pd.concat(income_2020_data, ignore_index=True)\n", " print(f\"\\n Successfully retrieved 2020 data for {len(income_2020_combined)} counties\")\n", "else:\n", " print(\"\\n No 2020 data retrieved\")" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Calculating income changes...\n", " Income change analysis complete!\n", "\n", "Median Income Change Summary (2012-2020):\n", "======================================================================\n", " Washington DC:\n", " 2012: $64,267\n", " 2020: $90,842\n", " Change: $+26,575 (+41.4%)\n", "\n", " Montgomery County, MD:\n", " 2012: $96,985\n", " 2020: $111,812\n", " Change: $+14,827 (+15.3%)\n", "\n", " Arlington County, VA:\n", " 2012: $102,459\n", " 2020: $122,604\n", " Change: $+20,145 (+19.7%)\n", "\n", " Fairfax County, VA:\n", " 2012: $109,383\n", " 2020: $127,866\n", " Change: $+18,483 (+16.9%)\n", "\n" ] } ], "source": [ "# Step 3: Calculate income changes\n", "if 'income_2012_combined' in locals() and 'income_2020_combined' in locals():\n", " print(\" Calculating income changes...\")\n", " \n", " # Merge data on display name\n", " income_change = pd.merge(\n", " income_2012_combined[['display_name', 'median_income']].rename(columns={'median_income': 'income_2012'}),\n", " income_2020_combined[['display_name', 'median_income']].rename(columns={'median_income': 'income_2020'}),\n", " on='display_name'\n", " )\n", " \n", " # Calculate changes\n", " income_change['change_absolute'] = income_change['income_2020'] - income_change['income_2012']\n", " income_change['change_percent'] = (income_change['change_absolute'] / income_change['income_2012']) * 100\n", " \n", " print(\" Income change analysis complete!\")\n", " print(\"\\nMedian Income Change Summary (2012-2020):\")\n", " print(\"=\" * 70)\n", " \n", " for _, row in income_change.iterrows():\n", " print(f\" {row['display_name']}:\")\n", " print(f\" 2012: ${row['income_2012']:,}\")\n", " print(f\" 2020: ${row['income_2020']:,}\")\n", " print(f\" Change: ${row['change_absolute']:+,} ({row['change_percent']:+.1f}%)\")\n", " print()\n", "else:\n", " print(\"Cannot calculate changes - missing data\")\n", " income_change = pd.DataFrame() # Empty dataframe for later checks" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "INCOME ANALYSIS SUMMARY:\n", " Average income change: 23.3%\n", " Counties with income growth: 4\n", " Counties with income decline: 0\n" ] } ], "source": [ "# Step 4: Visualize income changes\n", "if not income_change.empty:\n", " fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(18, 7))\n", " \n", " # Chart 1: Income levels comparison\n", " x = np.arange(len(income_change))\n", " width = 0.35\n", " \n", " bars1 = ax1.bar(x - width/2, income_change['income_2012'], width, \n", " label='2012 (2008-2012 ACS)', color='lightcoral', alpha=0.8)\n", " bars2 = ax1.bar(x + width/2, income_change['income_2020'], width,\n", " label='2020 (2016-2020 ACS)', color='steelblue', alpha=0.8)\n", " \n", " ax1.set_title('Median Household Income Comparison\\n2012 vs 2020', fontsize=14, fontweight='bold')\n", " ax1.set_ylabel('Median Income ($)')\n", " ax1.set_xticks(x)\n", " ax1.set_xticklabels([name.replace(' County', '').replace(', VA', '').replace(', MD', '') \n", " for name in income_change['display_name']], rotation=45)\n", " ax1.legend()\n", " ax1.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x/1000:.0f}K'))\n", " \n", " # Add value labels\n", " for bar in bars1:\n", " height = bar.get_height()\n", " ax1.text(bar.get_x() + bar.get_width()/2., height + 1000,\n", " f'${height/1000:.0f}K', ha='center', va='bottom', fontsize=9)\n", " \n", " for bar in bars2:\n", " height = bar.get_height()\n", " ax1.text(bar.get_x() + bar.get_width()/2., height + 1000,\n", " f'${height/1000:.0f}K', ha='center', va='bottom', fontsize=9)\n", " \n", " # Chart 2: Percentage change\n", " colors = ['red' if x < 0 else 'darkgreen' for x in income_change['change_percent']]\n", " bars3 = ax2.bar(income_change['display_name'].str.replace(' County', '').str.replace(', VA', '').str.replace(', MD', ''),\n", " income_change['change_percent'], color=colors, alpha=0.7)\n", " \n", " ax2.set_title('Income Change 2012-2020\\n(Percentage)', fontsize=14, fontweight='bold')\n", " ax2.set_ylabel('Percent Change (%)')\n", " ax2.axhline(y=0, color='black', linestyle='-', alpha=0.3)\n", " ax2.tick_params(axis='x', rotation=45)\n", " \n", " # Add value labels\n", " for bar, value in zip(bars3, income_change['change_percent']):\n", " height = bar.get_height()\n", " ax2.text(bar.get_x() + bar.get_width()/2., height + (0.5 if height >= 0 else -1.5),\n", " f'{value:.1f}%', ha='center', va='bottom' if height >= 0 else 'top', fontweight='bold')\n", " \n", " plt.tight_layout()\n", " plt.show()\n", " \n", " # Summary statistics\n", " avg_change = income_change['change_percent'].mean()\n", " print(f\"INCOME ANALYSIS SUMMARY:\")\n", " print(f\" Average income change: {avg_change:.1f}%\")\n", " print(f\" Counties with income growth: {(income_change['change_percent'] > 0).sum()}\")\n", " print(f\" Counties with income decline: {(income_change['change_percent'] < 0).sum()}\")\n", " \n", "else:\n", " print(\" Cannot create visualization - no income data available\")\n", " print(\" This might be due to API key issues or data availability\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Part 3: Understanding Your Results\n", "\n", "### What Do These Numbers Mean?\n", "\n", "**Population Changes (Decennial Census)**\n", "- Shows actual population growth or decline\n", "- DC typically shows high growth due to urban revitalization\n", "- Suburban areas may show different patterns\n", "\n", "**Income Changes (ACS 5-Year)**\n", "- Reflects economic conditions over time\n", "- Adjusted for inflation, this shows real purchasing power changes\n", "- High-income areas often show faster income growth\n", "\n", "### Important Considerations" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " IMPORTANT DATA QUALITY CONSIDERATIONS:\n", "==================================================\n", "\n", " DECENNIAL CENSUS:\n", " Advantages:\n", " • Complete population count (not a sample)\n", " • Very accurate for population totals\n", " • Available for all geographic levels\n", " Limitations:\n", " • Only every 10 years\n", " • Limited variables (basic demographics only)\n", " • 2020 data uses differential privacy (slight noise added)\n", "\n", " ACS 5-YEAR:\n", " Advantages:\n", " • Rich set of variables (income, education, housing, etc.)\n", " • Annual updates\n", " • Available for small geographies\n", " Limitations:\n", " • Sample-based (margins of error)\n", " • 5-year averages may mask recent changes\n", " • Smaller areas have larger margins of error\n", "\n", " BEST PRACTICES:\n", " • Always check margins of error for ACS data\n", " • Consider real vs. nominal changes (adjust for inflation)\n", " • Look for consistent patterns across multiple indicators\n", " • Document your methodology and assumptions\n" ] } ], "source": [ "# Let's discuss data quality and limitations\n", "print(\" IMPORTANT DATA QUALITY CONSIDERATIONS:\")\n", "print(\"=\" * 50)\n", "print()\n", "print(\" DECENNIAL CENSUS:\")\n", "print(\" Advantages:\")\n", "print(\" • Complete population count (not a sample)\")\n", "print(\" • Very accurate for population totals\")\n", "print(\" • Available for all geographic levels\")\n", "print(\" Limitations:\")\n", "print(\" • Only every 10 years\")\n", "print(\" • Limited variables (basic demographics only)\")\n", "print(\" • 2020 data uses differential privacy (slight noise added)\")\n", "print()\n", "print(\" ACS 5-YEAR:\")\n", "print(\" Advantages:\")\n", "print(\" • Rich set of variables (income, education, housing, etc.)\")\n", "print(\" • Annual updates\")\n", "print(\" • Available for small geographies\")\n", "print(\" Limitations:\")\n", "print(\" • Sample-based (margins of error)\")\n", "print(\" • 5-year averages may mask recent changes\")\n", "print(\" • Smaller areas have larger margins of error\")\n", "print()\n", "print(\" BEST PRACTICES:\")\n", "print(\" • Always check margins of error for ACS data\")\n", "print(\" • Consider real vs. nominal changes (adjust for inflation)\")\n", "print(\" • Look for consistent patterns across multiple indicators\")\n", "print(\" • Document your methodology and assumptions\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Part 4: Advanced Topics and Next Steps\n", "\n", "### When Geographic Boundaries Change\n", "\n", "For this tutorial, we used **states and counties** because their boundaries are stable over time. But what if you need to analyze **census tracts** or other small geographies that change?\n", "\n", "**Solution: Area Interpolation**\n", "- Use the `tobler` library's `area_interpolate()` function\n", "- Redistributes data from old boundaries to new boundaries\n", "- Accounts for how areas were split or merged\n", "\n", "See our advanced tutorial: `time_series_analysis.md` for tract-level analysis with boundary changes." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Summary: Key Takeaways\n", "\n", "### What You've Learned\n", "\n", "1. **The Golden Rule**: Only compare like survey types\n", " - Decennial ↔ Decennial for population counts\n", " - ACS 5-year ↔ ACS 5-year for detailed demographics\n", "\n", "2. **Geographic Strategy**: Use stable boundaries when possible\n", " - States and counties don't change over time\n", " - Avoids complex boundary adjustments\n", "\n", "3. **Variable Consistency**: Check codes across years\n", " - 2010: `P001001` vs 2020: `P1_001N` for population\n", " - ACS variables are generally more consistent\n", "\n", "4. **Data Quality**: Understand limitations\n", " - Decennial = complete count, ACS = sample\n", " - Check margins of error for ACS data\n", " - Consider real vs. nominal changes\n", "\n", "### Practical Applications\n", "\n", "- **Urban Planning**: Population growth patterns\n", "- **Economic Development**: Income trend analysis \n", "- **Policy Research**: Demographic change impacts\n", "- **Business Analysis**: Market area dynamics\n", "\n", "### Your Assignment\n", "\n", "Try this analysis with your own area of interest:\n", "1. Pick 3-4 states or counties\n", "2. Run the population change analysis\n", "3. Add income or another ACS variable\n", "4. Create your own visualizations\n", "5. Write a brief interpretation of the results\n", "\n", "**Happy analyzing!**" ] }, { "cell_type": "markdown", "metadata": {}, "source": [] } ], "metadata": { "kernelspec": { "display_name": "census", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.13" } }, "nbformat": 4, "nbformat_minor": 4 }