Applying Python Logic To Field Calculations In Arcgis

Performing Field Calculations in Python

Field calculations are essential in ArcGIS to derive new attribute values, update existing columns, or create new fields. While the ArcGIS Field Calculator provides a user interface for basic calculations, Python scripting enables more complex logic and workflow automation. Mastering Python field calculations unlocks the full analytical power of ArcGIS.

The Need for Field Calculations in GIS

GIS analysts frequently need to perform calculations on attribute data to gain insights, automate workflows, and enrich spatial datasets. Common examples include:

Calculating area, length, or perimeter from geometry fields
Combining values from multiple columns like concatenating first and last names
Evaluating conditions to classify or categorize features
Summarizing related data into new informative attributes
Standardizing fields or transforming values into more usable formats

Manually performing field computations for large datasets is impractical. Python scripting provides a flexible programming language to automate calculations across entire attribute tables and multiple map layers. Learning Python opens up many possibilities for sophisticated attribute queries, custom functions, and model-driven analysis.

Table of Contents

Accessing Field Values in Python

The starting point for any field calculation is accessing column values within iterates like SearchCursor and UpdateCursor. For example:


import arcpy

fc = "C:/data/Rivers.shp" 

rows = arcpy.da.SearchCursor(fc, ["LengthKM"])
for row in rows:
    lengthKM = row[0] 
    # Additional logic here

The first argument specifies the feature class or table to query. The second argument lists the fields to return. The cursor returns tuples with an element for each specified field. Values can then be accessed directly by index position or by field name using dictionary syntax. These field variables become inputs for subsequent calculations.

Basic Math Operations

Common field computations involve basic math like adding, subtracting, multiplying or dividing values. Python provides standard math operators for numerical data fields:


areaSQM = row["WidthM"] * row["HeightM"] 

price = row["BasePrice"] * 1.08 # Add 8% sales tax

Watch for potential data type conversion issues. Use the float() or int() functions to explicitly cast values as needed. Always handle potential divide by zero errors through conditional checks.

Conditional Evaluations

Conditional logic allows field values to adapt based on boolean checks. For example:


if row["Score"] > 90:
   letterGrade = "A"
elif row["Score"] > 80: 
   letterGrade = "B" 
elif row["Score"] > 70:
   letterGrade = "C"
else:
   letterGrade = "F"

Any expression that evaluates to True/False can control program flow based on field criteria. Common checks include numeric ranges, string matching, list membership, null checking, and date comparisons.

Working with Date Fields

Dates require specialized handling in Python. Parse string date values into datetime objects to enable calculations:


from datetime import datetime

dateStr = row["ServiceDate"] # String field  
serviceDate = datetime.strptime(dateStr, "%m/%d/%Y") # Convert to datetime
today = datetime.now() 

daysOpen = (today - serviceDate).days

The datetime library handles date formatting, constants like datetime.now for the current date, and arithmetic like subtracting dates to derive durations. Manipulate dates with confidence.

Leveraging the UpdateCursor

An UpdateCursor commits results back to the attribute table. Use it to write calculated values to existing or new columns.


cursor = arcpy.da.UpdateCursor(fc, ["LengthKM", "Miles"]) 
for row in cursor:
   row[1] = row[0] * 0.62 # LengthKM to Miles
   cursor.updateRow(row)

UpdateCursor also enables advanced iteration like skipping records or sampling subsets. Use cursor loops to apply standardized calculations across entire tables.

Example Code for Calculating Area

As a full script example, iterating through geometries with SearchCursor allows area values to be computed and added to a new field:


import arcpy
from math import pi

indata = r"C:\project\sites.shp"
arcpy.AddField_management(indata,"AreaSQM","DOUBLE") 

cursor = arcpy.da.UpdateCursor(indata,["Shape@","AreaSQM"])
for row in cursor:
    feature = row[0] 
    area = feature.getArea("PRESERVE_SHAPE", "SQUARE_METERS")
    row[1] = area
    cursor.updateRow(row)

The Shape@ token gives geometry object access from which Area getters derive values. Calculate geometry properties directly in field calculations.

Creating New Fields

To persist outputs, create new fields with the AddField tool. Specify the field name, type, precision and scale, field length, and other properties based on downstream usage.


arcpy.AddField_management(fc, "FullName", "TEXT", field_length=50)

For temporary analysis, enable the AddField parameter field_is_nullable to skip storage allocation. Add fields strategically within enterprises geodatabases.

Best Practices for Field Calculations

Follow these recommendations for performant, accurate field computations:

Vectorize operations using cursors over row-by-row processes.
Type check inputs and handle null values to avoid exceptions.
Create indexes on frequently filtered fields to speed searches.
Commit results incrementally within update cursors to conserve memory.
Document scripts with module docstrings, inline comments, and descriptive variables.
Build reusable functions for common calculations to codify business logic.

Use Python best practices plus ArcGIS structures to develop field calculations efficiently. Optimize iterative attribute updates for smooth geoprocessing.