Pimpler - Programming ArcGIS Pro with Python (2nd Edition)

About the Author

Eric Pimpler is the founder and owner of Geospatial Training Services (geospatialtraining.com) and have over 25 years of experience implementing and teaching GIS solutions using Esri software. Currently he focuses on ArcGIS Pro and Desktop scripting with Python and the development of custom ArcGIS Enterprise (Server) and ArcGIS Online web and mobile applications with JavaScript.

Eric is the also the author of several other books including Programming ArcGIS with Python Cookbook (https://www.packtpub.com/application-development/programming-arcgis-python-cookbook-second-edition), Spatial Analytics with ArcGIS (https://www.packtpub.com/application-development/spatial-analytics-arcgis ), Building Web and Mobile ArcGIS Server Applications with JavaScript (https://www.packtpub.com/application-development/building-web-and-mobile-arcgis-server-applications-javascript ), and ArcGIS Blueprints (https://www.packtpub.com/application-development/arcgis-blueprints ).

If you need consulting assistance with your ArcGIS Pro project please contact Eric at provides contract application development and programming expertise for ArcGIS Pro, ArcGIS Desktop, ArcGIS Enterprise (Server), and ArcGIS Online using Python, .NET/ArcObjects, and JavaScript.

Downloading and
Installing Exercise Data for this Book

Before beginning any of the exercises in this book you will want to download and install the exercise data. Please follow these instructions to download and install the exercise data.

Table of Contents

Chapter 1:

Chapter 2:

Chapter 3:

Chapter 4:

Chapter 5:

Chapter 6:

Chapter 7:

Chapter 8:

Chapter 9:

Chapter 10:

Fundamentals of
the Python Language

Python supports many of the programming constructs found in other languages. In this chapter, well cover many of the basic language features found in Python. Initially, well delve into language features, such as adding comments to your code, importing modules, creating and assigning data to variables, and using the built-in primitive data types such as strings and numbers.

Next, well look at the more complex data types that Python offers, such as lists, tuples, and dictionaries. Classes and objects are a fundamental concept in object-oriented programming and in the Python language. Well introduce you to these complex data structures, which youll use extensively when you write geoprocessing scripts with ArcGIS Pro.

In addition to this, well cover statements, including decision support and looping structures to make decisions in your code, and/or looping through a code block multiple times along with the with statement.

You have many choices for the environment that will be used to write, test, and debug your Python code. In this book well use several environments so that you can become familiar with various options. In this chapter youll be introduced to ArcGIS Pro Notebooks, first released with ArcGIS Pro 2.5, which provides a Jupyter Notebook implementation for writing and executing Python code directly in ArcGIS Pro. Future chapters will use PyCharm, and the ArcGIS Pro Python Window.

In this chapter we will cover the following:

Python Language Fundamentals

To effectively write geoprocessing scripts for ArcGIS Pro, you are going to need to understand at least the basic features of the Python language. Python is easier to learn than most other programming languages, but it does take some time to learn and effectively use. This section will teach you how to create variables, assign various data types to variables, understand the different types of data that can be assigned to variables, use different types of statements, work with objects, read and write files, and import Python modules.

Commenting code

Python scripts should follow a common structure. It is a commonly accepted practice that the beginning of each script should serve as documentation, detailing the script name, author, and a general description of the processing provided by the script. This introductory documentation will help you and other programmers in the future to quickly scan the details and purpose of a script. This documentation is accomplished in Python through the use of comments. Comments are lines of code that you add to your script that serve as documentation of what functionality the script provides. These lines of code begin with a single pound sign ( # ) or a double pound sign ( ## ), and are followed by whatever text you need to document the code. The Python interpreter does not execute these lines of code. They are simply used to document your code. You should also strive to include comments throughout your script to describe important sections of your script. This will be useful to you (or another programmer) when the time comes to update your scripts. In the code example below, the commented lines of code are displayed with a single pound sign that prefixes the line of code.

# This script programmatically adds layers to an ArcGIS Project

# Author: Eric Pimpler

# Last Editied: 10/01/2017

import arcpy.mp as map

try:

aprx = map.ArcGISProject(CURRENT)

for m in aprx.listMaps(Map):

for lyr in m.listLayers():

if lyr.name == Zoning:

m.removeLayer(lyr)

#lyr = map.LayerFile(rC:\Student\Zoning.lyrx)

#m.addLayer(lyr)

#m.addBasemap(Imagery)

#m.addDataFromPath(rC:\Student\

Trippville_GIS.gdb\Floodplains)

except Exception as e:

print(Error: + e.args[0])

Importing modules

Although Python includes many built-in functions, you will frequently need to access specific bundles of functionality, which are stored in external modules. For instance, the Math module stores specific functions related to processing numeric values and the os module provides functionality for working with files and folders at the operating system level. Modules are imported through the use of an import statement. When writing geoprocessing scripts with ArcGIS, you will always need to import the arcpy module, which is the Python package that is used to access GIS tools and functions provided by ArcGIS. The import statements will be the first lines of code (not including comments) in your scripts. The following lines of code import the arcpy and os modules. The Python os module provides a way of interfacing with the underlying operating system: