Data Analysispython

Data Analysis: Uncovering Crime Trends in the City of Angels with Python

DataLensBlogger

April 27, 2025

16 Min Read

0 Comments

Los Angeles; often glamorized as the City of Angels; is a sprawling metropolis known for its beaches, entertainment industry, and cultural diversity. But beneath the surface lies a complex web of urban challenges, one of which is crime. In this blog post, we’ll take a data-driven look at crime in Los Angeles using Python, exploring patterns, trends, and insights hidden in publicly available crime data.

Data analysts play a crucial role in the fight against crime; not by chasing criminals, but by uncovering the hidden stories in the data. From identifying crime hotspots to detecting seasonal patterns and informing policy decisions, data analysis empowers law enforcement agencies and city planners to make smarter, more informed decisions.

In this post, we’ll walk through the full data analysis pipeline: loading and cleaning the dataset, conducting exploratory data analysis (EDA), visualizing key findings, and uncovering temporal and geographic crime patterns. Whether you're a data science enthusiast, a Python learner, or just curious about the intersection of analytics and public safety, this real-world case study has something for you.

Let’s dive into the numbers and see how data can shine a light on the dark corners of LA’s streets.

Data Source

For this analysis, we’re using publicly available data from the Los Angeles Open Data Portal, which provides detailed records of crimes reported to the LAPD. The dataset includes information such as:

• Date and time of the incident
• Type of crime (e.g., theft, assault, burglary)
• Location data (area name, coordinates)
• Victim demographics
• Weapon used (if any)
• Crime description

This dataset spans several years, offering a robust foundation for identifying long-term trends and recurring patterns. Since the data is updated regularly and directly sourced from LAPD reports, it provides a reliable and comprehensive view of crime in LA.

Before diving into the analysis, we'll begin by importing the dataset, checking its structure, and performing necessary cleaning to ensure the data is ready for exploration.

Data Acquisition & Initial Exploration

Now that we understand the source and scope of the dataset, it's time to dive into the hands-on part of our analysis. We'll start by importing the necessary Python libraries and loading the dataset into a DataFrame using pandas.

Before jumping into detailed analysis, it's important to take a first look at the data. This involves checking the structure of the dataset, understanding the types of features it includes, identifying missing values, and getting a feel for the data’s overall shape. This step helps us plan the cleaning and transformation process that will follow.

Let’s load the data and start exploring what's under the hood.

import requests
import pandas as pd

link= "https://data.lacity.org/resource/2nrs-mtv8.csv?$limit=1005199"
request= requests.get(link)
request.raise_for_status()
with open("LA_crimes.csv", "wb") as file:
    file.write(request.content)

data= pd.read_csv("LA_crimes.csv")
print(data.shape)
#Output: (1005199, 28)

To begin our analysis, we acquired the crime dataset. Using Python's requests library, we directly fetch the publicly available crime records from the Los Angeles Open Data Portal. The dataset contains over 1 million reported incidents (1,005,199 rows, as confirmed by data.shape), with 28 distinct features including crime type, location, and timestamps. By saving the data as LA_crimes.csv and loading it into a pandas DataFrame, we ensure reproducibility while enabling efficient manipulation for further analysis. This step lays the foundation for uncovering patterns in LA’s crime landscape; ranging from thefts and assaults to more severe offenses.

print(la_crimes.info())

#Output:
# <class 'pandas.core.frame.DataFrame'>
# RangeIndex: 1005199 entries, 0 to 1005198     
# Data columns (total 28 columns):
#  #   Column          Non-Null Count    Dtype  
# ---  ------          --------------    -----  
#  0   DR_NO           1005199 non-null  int64
#  1   Date Rptd       1005199 non-null  object
#  2   DATE OCC        1005199 non-null  object
#  3   TIME OCC        1005199 non-null  int64
#  4   AREA            1005199 non-null  int64
#  5   AREA NAME       1005199 non-null  object
#  6   Rpt Dist No     1005199 non-null  int64
#  7   Part 1-2        1005199 non-null  int64
#  8   Crm Cd          1005199 non-null  int64
#  9   Crm Cd Desc     1005199 non-null  object
#  10  Mocodes         853440 non-null   object
#  11  Vict Age        1005199 non-null  int64
#  12  Vict Sex        860418 non-null   object
#  13  Vict Descent    860406 non-null   object
#  14  Premis Cd       1005183 non-null  float64
#  15  Premis Desc     1004611 non-null  object
#  16  Weapon Used Cd  327282 non-null   float64
#  17  Weapon Desc     327282 non-null   object
#  18  Status          1005198 non-null  object
#  19  Status Desc     1005199 non-null  object
#  20  Crm Cd 1        1005188 non-null  float64
#  21  Crm Cd 2        69159 non-null    float64
#  22  Crm Cd 3        2314 non-null     float64
#  23  Crm Cd 4        64 non-null       float64
#  24  LOCATION        1005199 non-null  object
#  25  Cross Street    154244 non-null   object
#  26  LAT             1005199 non-null  float64
#  27  LON             1005199 non-null  float64
# dtypes: float64(8), int64(7), object(13)

The info() method reveals our dataset’s blueprint: 1,005,199 crime records spanning 28 columns, with a mix of numeric, categorical, and geographic features. While critical fields like crime code (Crm Cd), description (Crm Cd Desc), location (LAT/LON), and timestamps (DATE OCC) are fully populated, others show missing values, notably weapon-related columns (Weapon Used Cd, 67% null). The presence of nested crime codes (Crm Cd 2-4) hints at multi-offense incidents, though these are rare (e.g., only 64 records use Crm Cd 4).

Geographic coordinates being 100% complete will enable spatial analysis, while partial fields like Cross Street (15% populated) may require careful handling. This output guides our data-cleaning strategy, emphasizing which columns are analysis-ready and which need imputation or exclusion.

Cleaning the Data: Handling Missing Values

After inspecting the dataset using df.info(), we noticed that some columns contain missing values. These gaps in the data can introduce bias or errors in our analysis if left unaddressed.

In this section, we'll clean the dataset by removing rows or columns with missing values, depending on their significance and proportion. This step ensures our analysis is based on complete and reliable information, setting the stage for accurate insights.

columns_to_drop = [
    'Crm Cd 4', 'Crm Cd 3', 'Crm Cd 2','Crm Cd 1', 'Weapon Used Cd', 'Weapon Desc',  
    'Cross Street', 'Status', 'Premis Cd', 'Mocodes',  
    'Part 1-2', 'DR_NO', 'Rpt Dist No', 'AREA'  
]  
df= la_crimes.drop(columns=columns_to_drop, axis=1)  

The columns were dropped based on several reasons:

1. High Null Values (Useless for Analysis):
   • Crm Cd 4 (64 non-null) → Extremely sparse
   • Crm Cd 3 (2,314 non-null) → Rarely used
   • Crm Cd 2 (69159 non-null) → Rarely used
   • Weapon Used Cd (327k/1M non-null) & Weapon Desc → Only 33% populated (keep it if analyzing violent crimes)
   • Cross Street (154k/1M non-null) → Mostly empty (use LOCATION or coordinates instead)
2. Redundant/Duplicate Columns:
   • Status (1 null) & Status Desc → Keep only Status Desc (more descriptive)
   • Premis Cd (float) & Premis Desc (object) → Keep only Premis Desc (human-readable)
   • Crm Cd (int) & Crm Cd 1 (int) → Represent the same primary crime code 
   • AREA (int) & AREA NAME (text) → Represent the same geographic division (LAPD patrol areas)
   • Crm Cd (int) & Crm Cd Desc (text) → Keep Crm Cd Desc unless you need codes for mapping
3. Low-Value or Unstructured Data:
   • Mocodes (853k/1M non-null, unstructured modifiers) → Drop unless parsing MO codes is critical
   • Part 1-2 (categorization flag) → Drop unless needed for filtering (Part 1 vs. Part 2 crimes)
4. Identifiers (Context-Dependent):
   • DR_NO (case number) → Drop unless tracking specific incidents
   • Rpt Dist No (report district code) → Redundant with AREA NAME

Handling Datetime Columns

Since df.info() shows that Date Rptd, DATE OCC (date of occurrence) and TIME OCC (time of occurrence) are stored as object (strings) rather than proper datetime types, you should convert them for proper time-based analysis.

# Step 1: Convert TIME OCC to string, pad with leading zeros (e.g., 30 -> '0030')
time_str = df['TIME OCC'].astype(str).str.zfill(4)  

df['TIME OCC']= pd.to_datetime(time_str.str[:2]+':'+time_str.str[2:], format='%H:%M')
df['Date Rptd']= pd.to_datetime(df['Date Rptd'], format='mixed')
df['DATE OCC']= pd.to_datetime(df['DATE OCC'].astype(str)+" "+df['TIME OCC'].dt.time.astype(str), format='mixed')

print(df[['Date Rptd', 'DATE OCC', 'TIME OCC']].info())

#Output:

# <class 'pandas.core.frame.DataFrame'>    
# RangeIndex: 1005199 entries, 0 to 1005198
# Data columns (total 3 columns):
#  #   Column     Non-Null Count    Dtype
# ---  ------     --------------    -----
#  0   Date Rptd  1005199 non-null  datetime64[ns]
#  1   DATE OCC   1005199 non-null  datetime64[ns]
#  2   TIME OCC   1005199 non-null  datetime64[ns]
# dtypes: datetime64[ns](3)

Digging Into the Digits: Exploring Numeric Columns

To get a quick overview of the numeric features in our dataset, we use df.describe(). This provides basic statistical summaries such as mean, standard deviation, minimum, maximum, and quartiles for all numerical columns.

This step helps us understand the distribution, scale, and potential outliers in the data, which is essential for guiding future analysis and visualizations.

One of the most important numerical features in our dataset is victim_age. Understanding the age distribution of crime victims can reveal which age groups are most affected by crime in Los Angeles, making it a key variable for demographic and policy-related insights.

#describe data
print(df.describe(include=['int64', 'float64']))

#Output:
# Vict Age           
# count  1.005199e+06  
# mean   2.891254e+01  
# std    2.199378e+01  
# min   -4.000000e+00  
# 25%    0.000000e+00  
# 50%    3.000000e+01 
# 75%    4.400000e+01 
# max    1.200000e+02

Decoding the Victim Age Distribution

The numbers reveal some fascinating and concerning patterns about crime victims in Los Angeles:

1. The Typical Victim
   • Average age: 29 years (mean = 28.9)
   • Most common age: 30 years (median = 30)
   • Middle 50% range: Infants to 44 years old (25th-75th percentile)
2. Shocking Extremes
   • Negative ages: -4.0 (clear data errors needing cleanup)
   • Maximum age: 120 (likely data entry issues for centenarians)
   • Minimum valid age: 0 (newborn victims present)
3. Concerning Youth Exposure
   • 25% of victims are children under 18 (since 25th percentile = 0)
   • Standard deviation of 22 years shows wide variability in victim ages

Data Quality Flags

• Negative values must be removed or corrected
• Ages > 110 need verification (supercentenarians are exceptionally rare)
• Zero values may represent:
  • Actual infant victims
  • Missing data placeholder
  • Reporting errors

#Handle Vict Age negative values
df_age= df[df['Vict Age']>=1]
print(df_age['Vict Age'].min())
#Output:
2.0

Victim Age Distribution

Before diving into how age varies across different crime types, it's helpful to understand the overall age distribution of crime victims in Los Angeles. This gives us a sense of which age groups are most commonly affected and helps identify any unusual patterns such as spikes in certain age ranges or the presence of outliers.

We’ll use visualizations like histograms to explore the distribution and get a clearer picture of the demographic impact of crime.

import matplotlib.pyplot as plt

plt.figure(figsize=(10, 6))
df_age['Vict Age'].plot(kind='hist', edgecolor='black')
plt.xlabel('Victme Age')
plt.title('Victim Age Distribution')
plt.show()

Interpretation of Victim Age Distribution

The histogram illustrates how crime victim ages are distributed across the dataset. Here's what stands out:

• Peak Age Range: The most common victim age group is between 25 and 35 years old, with this bin having the highest frequency around 240,000 incidents.
• Young Victims (Under 20): There's a noticeable number of victims in their teens, with a steep rise starting from age 15, suggesting a vulnerable younger population.
• Middle-Aged Groups (35–55): There's a gradual decline in frequency after age 35, though this group still makes up a significant portion of victims.
• Older Victims (60+): The frequency continues to decline but remains non-negligible, showing that elderly individuals are also affected by crime, albeit less frequently.
• Outliers: There are a few entries beyond age 100, which may be data entry errors or rare cases—these should be reviewed during data cleaning.

Key Insight:

The distribution is right-skewed, with most victims being young to middle-aged adults, particularly in their 20s and 30s. This suggests that crime in Los Angeles disproportionately affects individuals in their most active working and social years.

Crime Trends Over Time

Understanding how crime rates change over time is essential for spotting long-term trends, identifying seasonal patterns, and evaluating the impact of public policies or events. By analyzing the number of reported crimes per year, month, or even day, we can gain insights into the rhythm of crime in Los Angeles.

In this section, we’ll group crimes by time intervals (such as year and month) and visualize how crime levels have evolved across the dataset’s timeline.

#Analyse Crime Trend Over Time
df_years= df[df['DATE OCC'].dt.year != 2025]#Since 2025 year has only 3 moths recorded
df_years['year_occured']= df_years['DATE OCC'].dt.year

df['month_occured']= df['DATE OCC'].dt.month
df['year_occured']= df['DATE OCC'].dt.year

plt.style.use('seaborn-v0_8-darkgrid')

plt.figure(figsize=(10, 6))
plt.subplot(1,2, 1)
plt.title("Crime Trend Over Years")
df_years['year_occured'].value_counts().sort_index().plot(kind='bar', color='blue', edgecolor='black')
plt.xlabel("Years")
plt.ylabel("Crime Count")

plt.subplot(1,2, 2)
plt.title("Crime Trend Over Years and Months")
df.groupby(['year_occured', 'month_occured']).size().sort_index().plot(color='brown')
plt.xlabel("Year-Month")
plt.ylabel("Crime Count")
plt.show()

#Crime Count per Hour
crime_count_per_hour= df['DATE OCC'].dt.hour.value_counts()\
                                    .reset_index(name="crime_count").sort_index()
plt.figure(figsize=(10, 6))
plt.title("Crime Count per Hour")
plt.bar(crime_count_per_hour['DATE OCC'], crime_count_per_hour['crime_count'], edgecolor='black', color='orange')
plt.xlabel("Hour of the Day")
plt.ylabel("Crime Count")
plt.show()

To understand how crime evolved in Los Angeles over recent years, we first exclude the year 2025, which has only a few months of data recorded. Then, we analyze both yearly and monthly crime trends.

1. Crime Trend Over Years (Left Plot):

• The bar chart shows a steady increase in crime from 2020 through 2023.
• Crimes peaked in 2022 and 2023, with both years showing the highest number of incidents.
• There’s a noticeable drop in 2024, but this could be because the data for 2024 might be incomplete.
• This upward trend followed by a drop could suggest real changes in crime patterns or simply gaps in data collection.

2. Crime Trend Over Years and Months (Right Plot):

• The line plot gives a finer monthly view.
• From 2020 to late 2023, the monthly crime rate remained relatively stable, fluctuating between 16,000 to 20,000 crimes per month.
• However, starting in early 2024, there's a sharp and sudden decline in reported crimes.
• By 2025, crime counts drop close to zero, confirming that the 2025 data is incomplete and should not be considered for trend analysis.

3. Crime Trend by hour of the day (Bottom Plot):

• Most crimes happen around midday (12:00 PM), there's a huge spike.
• Crime activity is also high during the afternoon and evening (from 12 PM to 8 PM).
• There is much less crime between 3 AM and 6 AM, when people are usually asleep.
• Noticeable peak around midnight (hour = 0), but then it drops sharply overnight.

Time to Report a Crime

By calculating the difference between the crime occurrence date and the reporting date, we can gain insights into how quickly crimes are typically reported in Los Angeles.

Analyzing these delays can reveal cases of underreporting, hesitation, or systemic delays in certain types of crimes.

#Longuest Time to report a crime
df['Time_To_Report'] = (df['Date Rptd'] - df['DATE OCC']).dt.days
longuest_time_to_report= df.groupby(['Crm Cd Desc'])['Time_To_Report'].mean()\
                  .reset_index(name='Avg_Time_To_Report').sort_values(by='Avg_Time_To_Report', ascending=False).head(10)

longuest_time_to_report.sort_values(by='Avg_Time_To_Report', ascending=True, inplace=True)
plt.style.use('seaborn-v0_8-darkgrid')
plt.figure(figsize=(10, 6))
plt.title('Longuest Time to Report a Crime')
plt.barh(longuest_time_to_report['Crm Cd Desc'], longuest_time_to_report['Avg_Time_To_Report'], color='red')
plt.xlabel("Avg Time To Report (Days)")
plt.ylabel("Crime Description")
plt.tight_layout()
plt.show()

After creating and formatting the date columns, we calculated the number of days between the crime occurrence (DATE OCC) and the crime report (Date Rptd) for each record.

We then grouped the data by crime description to find which types of crimes, on average, take the longest time to be reported.

Key Findings:

• Crimes against children (such as “Crimes Against Child (13 or Under)”) show the longest average reporting delay — around 156 days.
• Sex-related crimes (like “Sex Offender Registrant Out of Compliance”, “Unlawful Sex Acts”, “Lewd Acts with Child”, “Oral Copulation”, and “Sexual Penetration with Foreign Object”) dominate the list, often taking over 100 days to report.
• Crimes like Bigamy and Identity Theft also exhibit significant reporting delays.

This pattern suggests that crimes involving personal trauma, fear of stigma, complicated legal procedures, or lack of immediate discovery (such as identity theft) often take much longer to come to light.

Exploring Categorical Columns: Crime Descriptions and Area Names

In this section, we dive into the key categorical variables of the dataset, focusing on the types of crimes reported and the areas where they occurred. By analyzing the frequency and distribution of crime descriptions and area names, we can uncover important patterns about the nature of criminal activity and how it varies across different neighborhoods. This exploration helps provide a clearer picture of the context and concentration of crimes within the city.

crime_count_per_area= df.groupby(['AREA NAME'])['Crm Cd Desc'].count()\
                        .reset_index(name='crime_count').sort_values(by='crime_count', ascending=False).head(10)

crime_count_per_area.sort_values(by='crime_count', ascending=True, inplace=True)

plt.figure(figsize=(10, 6))
plt.title("Crime Count per Area ")
plt.barh(crime_count_per_area['AREA NAME'], crime_count_per_area['crime_count'], edgecolor='black', color='orange')
plt.xlabel("Crime Count")
plt.ylabel("Area Name")
plt.show()

The horizontal bar chart shows the top ten LAPD areas by total reported crimes (across the entire dataset period). Here’s what the output tells us:

• Central tops the list with roughly 70,000 incidents, making it the single highest-crime area in Los Angeles. This district includes downtown neighborhoods and is known for high foot traffic and dense population, which likely contributes to its elevated crime count.
• 77th Street (around 62,000 crimes) and Pacific (about 59,000) follow, indicating that South and West LA also experience substantial criminal activity.
• Southwest and Hollywood report around 56,000 and 53,000 incidents respectively again reflecting both residential and entertainment hubs where opportunities for crime may be greater.
• North Hollywood, Olympic, Southeast, Newton, and Wilshire round out the top ten, each with between 48,000 and 52,000 crimes. Though lower than Central, these numbers are still significant, highlighting that crime is not confined to just a couple of neighborhoods.
• The spread between the highest (Central ~70k) and the tenth (Wilshire ~49k) is about 21,000 crimes, showing a clear concentration in a handful of districts but also a long tail of other areas with substantial incident counts.

Overall, this chart underscores how crime in Los Angeles is geographically clustered, with certain precincts especially Central and parts of South LA bearing a disproportionate share of incidents. These insights can help target community policing efforts and resource allocation more effectively.

Crime Patterns During Nighttime Hours

After exploring overall crime distribution across different areas, it is equally important to understand how crime patterns change based on the time of day. Nighttime, in particular, often sees different trends compared to daytime. In this section, we focus on analyzing which areas report the highest number of crimes during nighttime hours, offering deeper insights into how crime dynamics shift after dark.

crime_during_night= df[(df['DATE OCC'].dt.hour >= 20) | (df['DATE OCC'].dt.hour <= 5)]
area_crime_by_night= crime_during_night.groupby(['AREA NAME'])['Crm Cd Desc'].count()\
                    .reset_index(name='crime_count').sort_values(by='crime_count', ascending=False).head(10)

area_crime_by_night.sort_values(by='crime_count', ascending=True, inplace=True)

plt.figure(figsize=(10, 6))
plt.title("Crime Count per Area By Night", fontsize=18)
plt.barh(area_crime_by_night['AREA NAME'], area_crime_by_night['crime_count'], edgecolor='black', color='red')
plt.xlabel("Crime Count")
plt.ylabel("Area Name")
plt.show()

The bar chart above highlights the areas with the highest number of crimes reported during nighttime hours (between 8 PM and 5 AM). Central again leads by a significant margin, followed closely by 77th Street and Pacific. Other areas like Hollywood, Southwest, and Southeast also show elevated crime counts during the night. This trend suggests that major, densely populated zones continue to experience a high volume of criminal activity even after dark, which could reflect nightlife activity, lower visibility, or reduced law enforcement presence during late hours. The pattern largely mirrors the overall area crime distribution but puts stronger emphasis on urban centers and busy districts at night.

Geospatial Analysis: Mapping Crime Distribution Across LA

Mapping crime data geographically provides powerful insights that traditional charts and tables cannot easily reveal. By visualizing the locations of reported incidents, we can better understand the spatial patterns of crime, identify high-risk areas, and uncover potential hotspots that might require more focused public safety efforts. This geospatial analysis helps translate raw numbers into a clearer, more intuitive picture of how crime is distributed across Los Angeles.

import geopandas as gpd
import folium
crime_count_per_area= df.groupby(['area_name']).agg({'crm_cd_desc':'count', 'lat':'median', 
                                  'lon':'median'}).reset_index().sort_values(by='crm_cd_desc', ascending=False)

gdf=gpd.GeoDataFrame(crime_count_per_area,geometry=gpd.points_from_xy(crime_count_per_area['lon'],crime_count_per_area['lat']))          

# Create a geometry list from the GeoDataFrame
geo_df_list = [[point.xy[1][0], point.xy[0][0]] for point in gdf.geometry]

# OpenStreetMap
map = folium.Map(location=[34.0608, -118.3004], tiles="OpenStreetMap", zoom_start=12)

# Iterate through list and add a marker for each volcano, color-coded by its type.
i = 0
for coordinates in geo_df_list:
    # Place the markers with the popup labels and data
    map.add_child(
        folium.Marker(
            location=coordinates,
            popup= folium.Popup("Area Name: "
            + str(gdf.area_name[i])
            + "<br>"
            + "Crime Count: "
            + str(gdf.crm_cd_desc[i]), max_width=150),
            icon=folium.Icon(color="blue" ),
        )
    )
    i = i + 1

map       

The interactive map above displays crime counts across different areas in Los Angeles, using geographic coordinates. Each marker represents the median location of reported crimes within a specific area. By clicking on a marker, you can view the area name along with the corresponding total number of crimes. This map offers a more intuitive way to explore crime distribution, making it easy to identify neighborhoods with higher crime volumes at a glance. Areas with higher crime counts are visually distinguishable by the clustering and density of markers, helping reveal important spatial patterns that are not immediately obvious in traditional charts or tables.

Conclusion

Through this analysis of the Los Angeles crime dataset, we uncovered important patterns about when, where, and how crimes occur across the city. We observed that crime trends are not uniform in certain areas like Central, 77th Street, and Pacific experience consistently higher crime rates, both overall and during nighttime hours. Victim demographics, particularly age, revealed important insights, while the time trend analysis showed that criminal activity fluctuates both across years and months. Additionally, mapping the crimes geospatially helped to visualize hotspots and better understand the spatial concentration of incidents.

This kind of data-driven exploration is crucial for city planning, law enforcement resource allocation, and community awareness. Although this analysis provides valuable insights, it is important to acknowledge limitations, such as the reliance on reported crimes and potential delays between crime occurrence and reporting. Future work could expand into predicting crime risk based on environmental or socio-economic factors, or studying the evolution of crime patterns over longer periods.

By leveraging data analysis, we can move closer to making our cities safer, smarter, and more resilient.

This next section may contain affiliate links. If you click one of these links and make a purchase, I may earn a small commission at no extra cost to you. Thank you for supporting the blog!

References

Python for Data Analysis: Data Wrangling with pandas, NumPy, and IPython

Introduction to Machine Learning with Python: A Guide for Data Scientists

Murach's Python for Data Analysis (Training & Reference)

Python Machine Learning By Example: Unlock machine learning best practices with real-world use cases

Python Data Analytics: With Pandas, NumPy, and Matplotlib

FAQs