Programming ArcGIS 10.1 with Python Cookbook

Programming ArcGIS 10.1 with Python Cookbook

By : Donald Eric Pimpler, Eric Pimpler

Buy this Book

Programming ArcGIS 10.1 with Python Cookbook

By: Donald Eric Pimpler, Eric Pimpler

Buy this Book

Overview of this book

ArcGIS is an industry standard geographic information system from ESRI.This book will show you how to use the Python programming language to create geoprocessing scripts, tools, and shortcuts for the ArcGIS Desktop environment.This book will make you a more effective and efficient GIS professional by showing you how to use the Python programming language with ArcGIS Desktop to automate geoprocessing tasks, manage map documents and layers, find and fix broken data links, edit data in feature classes and tables, and much more."Programming ArcGIS 10.1 with Python Cookbook" starts by covering fundamental Python programming concepts in an ArcGIS Desktop context. Using a how-to instruction style you'll then learn how to use Python to automate common important ArcGIS geoprocessing tasks.In this book you will also cover specific ArcGIS scripting topics which will help save you time and effort when working with ArcGIS. Topics include managing map document files, automating map production and printing, finding and fixing broken data sources, creating custom geoprocessing tools, and working with feature classes and tables, among others.In "Python ArcGIS 10.1 Programming Cookbook" you'll learn how to write geoprocessing scripts using a pragmatic approach designed around an approach of accomplishing specific tasks in a Cookbook style format.

Programming ArcGIS 10.1 with Python Cookbook

Credits

About the Author

About the Reviewers

www.PacktPub.com

Preface

Free Chapter

Fundamentals of the Python Language for ArcGIS

Using IDLE for Python script development

Python language fundamentals

Summary

Writing Basic Geoprocessing Scripts with ArcPy

Introduction

Using the ArcGIS Python window

Accessing ArcPy with Python

Executing tools from a script

Using ArcGIS Desktop help

Using variables to store data

Accessing ArcPy modules with Python

Managing Map Documents and Layers

Introduction

Referencing the current map document

Referencing map documents on a disk

Accessing a data frame

Getting a list of layers in a map document

Restricting the list of layers

Changing the map extent

Getting a list of tables

Adding layers to a map document

Inserting layers into a map document

Updating layer symbology

Updating layer properties

Finding and Fixing Broken Data Links

Introduction

Finding broken data sources in your map document and layer files

Fixing broken data sources with MapDocument.findAndReplaceWorkspacePaths()

Fixing broken data sources with MapDocument.replaceWorkspaces()

Fixing individual Layer and Table objects with replaceDataSource()

Finding all broken data sources in all map documents in a folder

Automating Map Production and Printing

Introduction

Creating a list of layout elements

Assigning a unique name to layout elements

Restricting the layout elements returned by ListLayoutElements()

Updating layout element properties

Getting a list of available printers

Printing maps with PrintMap()

Exporting a map to a PDF file

Exporting a map to an image file

Creating a map book with PDFDocumentCreate() and PDFDocumentOpen()

Executing Geoprocessing Tools from Scripts

Introduction

Finding geoprocessing tools

Retrieving a toolbox alias

Executing geoprocessing tools from a script

Using the output of a tool as an input to another tool

Setting environment variables and examining tool messages

Creating Custom Geoprocessing Tools

Introduction

Creating a custom geoprocessing tool

Querying and Selecting Data

Introduction

Constructing proper attribute query syntax

Creating feature layers and table views

Selecting features and rows with the Select Layer by Attribute tool

Selecting features with the Select by Location tool

Combining a spatial and attribute query with the Select by Location tool

Using the ArcPy Data Access Module to Select, Insert, and Update Geographic Data and Tables

Introduction

Retrieving features from a feature class with a SearchCursor

Filtering records with a where clause

Improving cursor performance with geometry tokens

Inserting rows with InsertCursor

Updating rows with an UpdateCursor

Deleting rows with an UpdateCursor

Inserting and updating rows inside an edit session

Reading geometry from a feature class

Listing and Describing GIS Data

Introduction

Getting a list of feature classes in a workspace

Restricting the list of feature classes returned with a wildcard

Restricting the list of feature classes returned with a feature type.

Getting a list of fields in a feature class or table

Using the Describe() function to return descriptive information about a feature class

Using the Describe() function to return descriptive information about an image

Returning workspace information with the Describe() function

Customizing the ArcGIS Interface with Add-Ins

Introduction

Downloading and installing the Python Add-In wizard

Creating a button add-in

Installing and testing an add-in

Creating a tool add-in

Error Handling and Troubleshooting

Introduction

Exploring the default Python error message

Adding Python exception handling structures (try/except/finally)

Retrieving tool messages with GetMessages()

Filtering tool messages by severity level

Testing for and responding to specific error messages

Returning individual messages with GetMessage()

Automating Python Scripts

Introduction

Running Python scripts from the command line

Using sys.argv[ ] to capture command-line input

Adding Python scripts to batch files

Scheduling batch files to run at prescribed times

Five Things Every GIS Programmer Should Know How to Do with Python

Introduction

Reading data from a delimited text file

Sending e-mails

Retrieving files from an FTP server

Creating ZIP files

Reading XML files

Index

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Using sys.argv[ ] to capture command-line input

Instead of hardcoding your scripts with paths to specific datasets, you can make your scripts more flexible by allowing them to accept input in the form of parameters from the command prompt. These input parameters can be captured using Python's sys.argv[] object.

Getting ready

Python's sys.argv[] object allows you to capture input parameters from the command line when a script is executed. An example is useful for illustrating how this works. Take a look at the following screenshot:

Each word must be separated by a space. These words are stored in a zero-based list object called sys.argv[]. With sys.argv[], the first item in the list, referenced by index 0, stores the name of the script. In this case, it would be ListFields.py. Each successive word is referenced by the next integer. Therefore, the first parameter (c:\ArcpyBook\data) will be stored in sys.argv[1], and the second parameter (Burglaries.shp) will be stored in sys.argv[2]. Each of the arguments in the sys.argv[] object can be accessed and used inside your geoprocessing script. In this recipe, you're going to update the ListFields.py script to accept input parameters from the command line.

How to do it...

Follow these steps to create a Python script that can accept input parameters from the command prompt using sys.argv[]:

Open C:\ArcpyBook\Appendix1\ListFields.py in IDLE.
Import the sys module:
```
import arcpy, sys
```
Create a variable to hold the workspace that will be passed into the script:
```
wkspace = sys.argv[1]
```
Create a variable to hold the feature class that will be passed into the script:
```
fc = sys.argv[2]
```

Update the lines of code that set the workspace and call the ListFields() function:

arcpy.env.workspace = wkspace
fields = arcpy.ListFields(fc)

Your completed script should appear as follows:

import arcpy, sys
wkspace = sys.argv[1]
fc = sys.argv[2]
try:
  arcpy.env.workspace = wkspace
  fields = arcpy.ListFields(fc)
  for fld in fields:
    print fld.name
except:
  print arcpy.GetMessages()

Save the script.
If necessary, open the command prompt and navigate to c:\ArcpyBook\Appendix1.
On the command line, type the following and press on the Enter key:
```
python ListFields.py c:\ArcpyBook\data Burglaries_2009.shp
```
Once again you should see the output detailing the attribute fields for the Burglaries_2009.shp file. The difference is that your script no longer has a hardcoded workspace and feature class name. You now have a more flexible script capable of listing the attribute fields for any feature class.

How it works...

The sys module contains a list of objects called argv[], which is used to store the input parameters for the command-line execution of a Python script. The first item stored in the list is always the name of the script. So, in this case, sys.argv[0] contains the word ListFields.py. Two parameters are passed into the script, including the workspace and a feature class. These are stored in sys.argv[1] and sys.argv[2] respectively. These values are then assigned to variables and used in the script. 

Programming ArcGIS 10.1 with Python Cookbook

By : Donald Eric Pimpler, Eric Pimpler

Programming ArcGIS 10.1 with Python Cookbook

By: Donald Eric Pimpler, Eric Pimpler

Overview of this book

Related Content you might be interested in

Current Title:

Programming ArcGIS 10.1 with Python Cookbook

Using sys.argv[ ] to capture command-line input

Getting ready

How to do it...

How it works...