ArcPy GIS Automation Training Course

Participants can write readable Python functions and control structures for GIS automation.

• Variables, strings, numbers and Boolean values used in ArcPy scripts
• Lists and dictionaries for dataset inventories and processing specifications
• Conditional logic for optional inputs, missing data and processing branches
• For loops applied to feature classes, fields and map layers
• Functions that isolate reusable geoprocessing operations and validation rules
• PEP 8 naming, comments and docstrings for maintainable GIS code

Participants can access ArcGIS Pro projects and resolve data paths reliably.

• arcpy.env workspace, scratchWorkspace and overwriteOutput environment settings
• Absolute and relative paths managed with Python pathlib objects
• File geodatabases, enterprise geodatabases and folder workspace distinctions
• ListFeatureClasses and ListDatasets for workspace inventory generation
• Describe objects used to inspect dataset properties before processing
• Data existence checks with arcpy.Exists before tool execution

Participants can create, inspect and modify geodatabase schemas through ArcPy.

• CreateFileGDB and CreateFeatureclass for controlled output data structures
• AddField, AlterField and DeleteField schema maintenance patterns
• Field types, nullability, domains and subtype design considerations
• ListFields inspection for field presence, type and length validation
• CalculateField expressions using Python parser and code blocks
• Feature class naming conventions and collision-safe output generation

Participants can read, update and insert attribute records using ArcPy data access cursors.

• arcpy.da SearchCursor for efficient attribute extraction and inspection
• UpdateCursor rules for standardising values and correcting data defects
• InsertCursor workflows for creating derived records from source datasets
• SQL where clauses for targeted records and query performance
• Field token usage including OID@, SHAPE@ and SHAPE@AREA
• Cursor locking, deletion and context managers for safe editing

Participants can inspect and create geometry objects while controlling coordinate systems.

• Geometry types, multipart features and ArcPy geometry object properties
• SpatialReference objects, factory codes and projected coordinate system checks
• Project management using Project tool and transformation selection
• SHAPE@XY and SHAPE@JSON tokens for geometry exchange workflows
• Extent, centroid and area calculations with coordinate-system awareness
• Geometry methods for distance, intersection and containment tests

Participants can script repeatable vector analysis chains with explicit parameters.

• Buffer parameters including distance units, dissolve options and geodesic method
• Clip and Pairwise Clip for extracting operational study areas
• Intersect, Union and Erase for spatial rule implementation
• Spatial Join match options and field mapping for enrichment
• Dissolve statistics for aggregation of asset and incident records
• Temporary datasets managed through scratch geodatabases and deletion routines

Participants can control feature layers, selections and definition queries in scripts.

• MakeFeatureLayer creates temporary layers with SQL definition queries
• SelectLayerByAttribute methods for new, added and removed selections
• SelectLayerByLocation relationships, search distances and inversion options
• GetCount validation of selected records before downstream processing
• Field delimiters constructed correctly for geodatabase and shapefile sources
• Layer files used to preserve symbology and shared definitions

Participants can automate common raster preparation, classification and suitability procedures.

• Spatial Analyst extension checkout and licence release management
• Raster environments: cell size, extent, mask and snap raster
• Raster Calculator expressions for reproducible map algebra models
• Reclassify remap tables for suitability and risk categorisation
• Zonal Statistics as Table for polygon-based raster summaries
• Mosaic and Clip Raster processing for imagery preparation workflows

Participants can process multiple datasets safely through configurable batch routines.

• Dataset discovery with arcpy.da.Walk across nested workspace structures
• Filename parsing with pathlib for controlled output naming
• Batch loops that isolate failed datasets without stopping processing
• Parameter dictionaries for dataset-specific thresholds and processing options
• Run summaries recording source datasets, outputs and execution status
• Idempotent script design that supports safe reruns after interruption

Participants can diagnose failures and create useful execution records for GIS scripts.

• try, except, else and finally blocks for controlled failure handling
• arcpy.ExecuteError handling and retrieval of geoprocessing tool messages
• Python logging levels for diagnostic, warning and error records
• Timestamped log files linked to script runs and output folders
• Custom validation messages that identify invalid parameters and datasets
• Failure recovery choices: retry, skip, rollback and controlled termination

Participants can build validation checks that prevent invalid spatial processing outputs.

• Required field checks before joins, calculations and analysis steps
• Geometry validation using Check Geometry and Repair Geometry tools
• Coordinate-system checks before overlay, distance and area calculations
• Null-value, duplicate identifier and domain compliance tests
• Output acceptance criteria for counts, extents and expected attributes
• Quality-control reports comparing source, intermediate and final datasets

Participants can update ArcGIS Pro maps and export standard cartographic products.

• arcpy.mp ArcGISProject access to maps, layouts and map frames
• Layer visibility, definition queries and symbology update approaches
• Map extent control through camera properties and selected features
• Dynamic text updates for dates, titles and report identifiers
• Layout export to PDF, PNG and SVG output formats
• Map series export for district, asset-zone and parcel reporting

Participants can create structured tabular outputs and exchange GIS data reliably.

• TableToTable exports with field mappings and controlled output schemas
• ExportTable operations for CSV reporting and downstream analysis
• JoinField and AddJoin selection for permanent versus temporary joins
• Pandas DataFrames for tabular inspection outside ArcGIS geoprocessing
• JSON and CSV configuration files for repeatable processing settings
• Metadata fields recording processing date, source and script version

Participants can package ArcPy scripts as usable tools with validated parameters.

• Script tool parameters: data types, directions, filters and defaults
• GetParameterAsText and SetParameterAsText for toolbox script interfaces
• Parameter dependencies that constrain valid user input combinations
• Tool validation methods: initializeParameters, updateParameters and updateMessages
• Python toolbox structure with Tool and Toolbox classes
• Help text, tool labels and usage guidance for GIS colleagues

Participants can identify and reduce common ArcPy performance bottlenecks.

• Pairwise overlay tools selected for scalable vector processing
• Attribute indexes added to support frequent query and join fields
• SearchCursor field minimisation to reduce unnecessary data transfer
• In-memory workspace use, limitations and cleanup requirements
• Spatial indexes and grid considerations for feature class operations
• Timing functions used to profile scripts and locate bottlenecks

Participants can design scripts that operate safely with enterprise geodatabase data.

• Database connection files and authenticated enterprise geodatabase access
• Versioned data concepts and edit-session implications for automation
• Read-only versus update operations in shared production datasets
• Schema locks, data locks and scheduling considerations for team scripts
• Query layers and database views for controlled source access
• Staging geodatabases used before publishing approved production outputs

Participants can prepare ArcPy automation for review, maintenance and controlled release.

• Unit test cases for helper functions and validation logic
• Test datasets representing normal, boundary and invalid input conditions
• Expected-output checks for counts, fields, values and spatial extent
• README structure covering installation, inputs, outputs and known limitations
• Git repositories for script history, branches and peer review
• Semantic versioning applied to scripts, toolboxes and configuration files

Participants can specify a maintainable ArcPy solution for a business GIS process.

• Process mapping identifies manual steps, decisions, controls and handoffs
• Input-output specification defines datasets, formats, ownership and refresh frequency
• Parameter catalogue separates fixed business rules from user-entered values
• Exception register records foreseeable failures, responses and escalation owners
• Runbook content defines setup, execution, verification and recovery procedures
• Deployment options compare analyst desktop, scheduled task and toolbox delivery

Participants can build, review and present a complete ArcPy automation package for a defined GIS workflow.

• Select a realistic workflow involving spatial data transformation and reporting
• Define requirements, inputs, outputs, acceptance criteria and processing constraints
• Build parameterised ArcPy functions with validated geoprocessing tool settings
• Implement logging, error handling and quality-control checks for key outputs
• Package the solution as a script tool or Python toolbox
• Conduct peer code review against maintainability, safety and documentation criteria
• Present processing results, limitations, implementation plan and operational runbook