Python Scripting for ArcGIS Training Course

Participants can write readable Python code using core language constructs required for GIS automation.

• Variables, strings, numbers and Boolean values for GIS parameters
• Lists, tuples, dictionaries and sets for managing datasets
• Conditional logic with if, elif and else statements
• For and while loops controlling repeated processing tasks
• Functions that isolate reusable geoprocessing and validation logic
• Imports, modules and docstrings supporting maintainable script structure

Participants can configure ArcPy environments and run geoprocessing tools with controlled outputs.

• arcpy.env workspace and scratchWorkspace settings for controlled processing
• OverwriteOutput rules and output naming conventions for repeatability
• Extent, mask, cell size and snap raster environments
• Calling ArcPy geoprocessing tools through Python function syntax
• Tool result objects, messages and derived output values
• Path handling with os.path and pathlib methods

Participants can create scripts that accept inputs, define outputs and process user-selected datasets.

• Script parameters defined with arcpy.GetParameterAsText methods
• Typed parameter values retrieved through arcpy.GetParameter functions
• Default values and optional inputs handled by conditional logic
• Output paths assembled from workspaces, names and file extensions
• Feature layers and dataset paths distinguished during parameter handling
• User messages written with AddMessage, AddWarning and AddError

Participants can automate common feature class preparation and management tasks using ArcPy.

• CopyFeatures and FeatureClassToFeatureClass for controlled data extracts
• Select analysis outputs using SQL expressions and selection layers
• Buffer, Clip, Dissolve and Merge workflows scripted in sequence
• Field creation, deletion and calculation through ArcPy tools
• Spatial reference checks before writing projected output datasets
• Schema inspection with Describe objects and ListFields methods

Participants can read, update and create attribute records efficiently with ArcPy cursors.

• SearchCursor patterns for reading selected attribute field values
• UpdateCursor methods for controlled attribute corrections and calculations
• InsertCursor workflows for creating records from external source data
• Cursor field tokens including OID@, SHAPE@ and SHAPE@AREA
• SQL where clauses applied before cursor-based record processing
• Context managers used to close cursors and release locks

Participants can use geometry objects and spatial relationships to build targeted spatial processing logic.

• Point, Polyline, Polygon and Multipoint geometry object properties
• Geometry methods for area, length, centroid and extent
• Spatial relationships tested with contains, intersects and within methods
• Feature geometry accessed through SHAPE@ cursor tokens
• Coordinate transformations specified when creating new geometry outputs
• Multipart features and null geometry records handled safely

Participants can automate raster preparation and analysis using ArcPy and Spatial Analyst tools.

• Raster objects, cell values and metadata accessed through ArcPy
• Raster Calculator expressions built for repeatable suitability analysis
• Reclassify and Con workflows for classified raster outputs
• ExtractByMask processing controlled by analysis environment settings
• Mosaic datasets and image services identified for scripted processing
• NoData values, pixel types and compression checked before export

Participants can structure multi-step spatial analysis scripts with clear inputs, intermediate data and outputs.

• Analysis chains mapped from source data through final outputs
• Intermediate datasets stored in scratch geodatabases and deleted safely
• Near, SpatialJoin and GenerateNearTable methods compared
• Overlay analysis scripted with Intersect, Union and Erase tools
• Suitability criteria translated into transparent geoprocessing decision rules
• Output validation checks applied after each critical processing stage

Participants can diagnose common ArcPy failures and produce useful records of script execution.

• Try, except, else and finally blocks controlling script failures
• arcpy.ExecuteError handling for geoprocessing tool-specific exceptions
• Python traceback messages captured for unexpected coding errors
• Logging module configuration for timestamps, levels and output files
• Input existence checks performed with arcpy.Exists before processing
• Structured error messages identify failed datasets, tools and parameters

Participants can inspect, test and improve ArcPy scripts before operational use.

• Print statements and logging records used for targeted diagnostics
• Breakpoints and variable inspection within supported Python editors
• Assertions used to test expected dataset properties and results
• PEP 8 naming conventions applied to script variables
• Functions refactored to reduce duplicated geoprocessing code blocks
• Code review criteria covering readability, paths, errors and outputs

Participants can modify ArcGIS Pro projects, maps and layers using the arcpy.mp module.

• ArcGISProject objects opened and saved through arcpy.mp
• Map objects listed by name and updated programmatically
• Layers added, removed and grouped within project maps
• Definition queries applied to layers through Python properties
• Symbology sources copied between compatible feature layers
• Connection properties updated when data locations change

Participants can automate standard map layouts, exports and map-series production from ArcGIS Pro.

• Layout elements identified through listElements and element type filters
• Text elements updated with dates, titles and processing metadata
• Map frames assigned extent and scale from feature geometry
• PDF, PNG and SVG exports configured for publication requirements
• Map series pages exported using index layers and page queries
• Output folders organised by project, date and map product

Participants can package scripts as ArcGIS Pro tools with clear parameters and validation.

• Script tool properties configured within an ArcGIS Pro toolbox
• Parameter data types, directions and filters chosen appropriately
• ToolValidator classes used for dynamic parameter validation
• Dependencies between input parameters controlled through updateParameters methods
• Derived outputs declared for ModelBuilder and workflow compatibility
• Tool help text documents purpose, inputs, outputs and limitations

Participants can process collections of datasets efficiently and maintain predictable output structures.

• arcpy.da.Walk searches geodatabases for target dataset types
• Python glob patterns identify files within folder-based data stores
• Batch loops process feature classes using consistent naming rules
• File geodatabase creation and deletion managed through ArcPy tools
• Temporary files removed after successful completion of processing steps
• Run summaries record processed datasets, timings and failed items

Participants can build scripted extract, transform and load processes with measurable data quality controls.

• ETL workflows separate source extraction, transformation and destination loading
• Required field checks identify incomplete records before loading
• Domain values and coded attributes validated against approved lists
• Duplicate features detected through keys, geometry and spatial joins
• Coordinate systems standardised before combining incoming spatial datasets
• Quality-control reports summarise exceptions for data owner review

Participants can apply ArcPy safely to enterprise geodatabase datasets and controlled editing workflows.

• Database connection files referenced without exposing authentication details
• Versioned datasets identified before automated editing and reconciliation
• Edit sessions managed with arcpy.da.Editor transaction methods
• Schema locks diagnosed before field, index and dataset changes
• Indexes created to improve repeated attribute query performance
• Enterprise outputs separated from temporary processing workspaces

Participants can automate selected ArcGIS Online and portal content management tasks using Python.

• ArcGIS API for Python objects authenticate to portal content
• Content searches locate items through type, tags and owners
• Feature layers queried and updated through hosted service methods
• Item metadata updated with descriptions, tags and credits
• Web map layers inspected before operational content updates
• Sharing settings checked for groups, organisations and public access

Participants can improve script efficiency and avoid common memory, lock and processing bottlenecks.

• Processing times measured with perf_counter and structured log entries
• In-memory workspaces evaluated for suitable intermediate processing tasks
• Field lists restricted to reduce cursor processing overhead
• Selections and queries applied before expensive spatial operations
• Dataset locks released through object deletion and context managers
• Chunking strategies used for large tables and feature collections

Participants can prepare scripts for team maintenance through documented configuration and source control practices.

• Configuration files store paths, thresholds and user-adjustable settings
• JSON and CSV files read for repeatable external configuration
• README files document installation, inputs, outputs and operating steps
• Git repositories track script changes, branches and release versions
• Sensitive credentials excluded through environment variables and ignore files
• Naming conventions link scripts, toolboxes, logs and output datasets

Participants can specify an ArcGIS automation workflow that is suitable for operational ownership and review.

• Process maps distinguish manual decisions from automatable processing steps
• Input-output specifications define datasets, formats, owners and refresh cycles
• Acceptance criteria state spatial accuracy, completeness and delivery requirements
• Risk registers identify destructive operations, permissions and dependency failures
• Release checklists confirm paths, parameters, logs and rollback arrangements
• Support handover documents assign script ownership and maintenance responsibilities

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

• Business requirement translated into a defined ArcGIS automation scope
• Parameterised ArcPy script processes source data through validated outputs
• Script tool interface exposes inputs, options and derived deliverables
• Logging and exception handling provide traceable processing evidence
• Quality checks confirm spatial, attribute and output file requirements
• Peer review assesses code structure, usability and documentation quality