Book Image

Programming ArcGIS 10.1 with Python Cookbook

By : Donald Eric Pimpler, Eric Pimpler
Book Image

Programming ArcGIS 10.1 with Python Cookbook

By: Donald Eric Pimpler, Eric Pimpler

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.

Related Content you might be interested in

Current Title:

Small book image
Programming ArcGIS 10.1 with Python Cookbook
Donald Eric Pimpler | Eric Pimpler
Feb, 2013 | 304 pages
No titles found
Table of Contents (21 chapters)
Programming ArcGIS 10.1 with Python Cookbook
Programming ArcGIS 10.1 with Python Cookbook
Credits
Credits
About the Author
About the Author
About the Reviewers
About the Reviewers
www.PacktPub.com
www.PacktPub.com
Preface
Preface
Free Chapter
1
Fundamentals of the Python Language for ArcGIS
Fundamentals of the Python Language for ArcGIS
Using IDLE for Python script development
Python language fundamentals
Summary
2
Writing Basic Geoprocessing Scripts with ArcPy
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
3
Managing Map Documents and Layers
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
4
Finding and Fixing Broken Data Links
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
5
Automating Map Production and Printing
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()
6
Executing Geoprocessing Tools from Scripts
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
7
Creating Custom Geoprocessing Tools
Creating Custom Geoprocessing Tools
Introduction
Creating a custom geoprocessing tool
8
Querying and Selecting Data
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
9
Using the ArcPy Data Access Module to Select, Insert, and Update Geographic Data and Tables
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
10
Listing and Describing GIS Data
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
11
Customizing the ArcGIS Interface with Add-Ins
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
12
Error Handling and Troubleshooting
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
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
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
Index

Creating ZIP files

GIS often requires the use of large files that will be compressed into a .zip format for ease of sharing. Python includes a module that you can use to decompress and compress files in this format.

Getting ready

Zip is a common compression and archive format and is implemented in Python through the zipfile module. The ZipFile class can be used to create, read, and write .zip files. To create a new .zip file, simply provide the filename along with a mode such as w, which indicates that you want to write data to the file. In the following code example, we are creating a .zip file called datafile.zip. The second parameter, w, indicates that a new file will be created. A new file will be created or an existing file with the same name will be truncated in the write mode. An optional compression parameter can also be used when creating the file. This value can be set to either ZIP_STORED or ZIP_DEFLATED: 

zipfile.ZipFile('dataFile.zip', 'w',zipfile.ZIP_STORED)

In this exercise, you will use Python to create file, add files, and apply compression to a .zip. You'll be archiving all the shapefiles located in the c:\ArcpyBook\data directory.

How to do it…

Follow these steps to learn how to create a script that build a .zip file:

  1. Open IDLE and create a script called c:\ArcpyBook\Appendix2\CreateZipfile.py.

  2. Import the zipfile and os modules:

    import os
import zipfile

  3. Create a new .zip file called shapefiles.zip in write mode and add a compression parameter:

    zfile = zipfile.ZipFile("shapefiles.zip", "w", zipfile.ZIP_STORED)

  4. Next, we'll use the os.listdir() function to create a list of files in the data directory:

    files = os.listdir("c:/ArcpyBook/data")

  5. Loop through a list of all the files and write to the .zip file, if the file ends with shp, dbf, or shx:

    for f in files:
  if f.endswith("shp") or f.endswith("dbf") or f.endswith("shx"):
    zfile.write("C:/ArcpyBook/data/" + f)

  6. Print out a list of all the files that were added to the zip archive. You can use the ZipFile.namelist() function to create a list of files in the archive:

    for f in zfile.namelist():
    print "Added %s" % f

  7. Close the .zip archive:

    zfile.close()

  8. The entire script should appear as follows:

    import os
import zipfile

#create the zip file
zfile = zipfile.ZipFile("shapefiles.zip", "w", zipfile.ZIP_STORED)
files = os.listdir("c:/ArcpyBook/data")

for f in files:
  if f.endswith("shp") or f.endswith("dbf") or f.endswith("shx"):
    zfile.write("C:/ArcpyBook/data/" + f)

#list files in the archive
for f in zfile.namelist():
    print "Added %s" % f

zfile.close()

  9. Save and run the script. You should see the following output:

    Added ArcpyBook/data/Burglaries_2009.dbf
Added ArcpyBook/data/Burglaries_2009.shp
Added ArcpyBook/data/Burglaries_2009.shx
Added ArcpyBook/data/Streams.dbf
Added ArcpyBook/data/Streams.shp
Added ArcpyBook/data/Streams.shx

  10. In Windows Explorer, you should be able to see the output .zip file as shown in the following screenshot. Note the size of the archive. This file was created without compression:

  11. Now, we're going to create a compressed version of the .zip file to see the difference. Make the following changes to the line of code that creates the .zip file:

    zfile = zipfile.ZipFile("shapefiles2.zip", "w", zipfile.ZIP_DEFLATED)

  12. Save and re-run the script.

  13. Take a look at the size of the new shapefiles2.zip file that you just created. Note the decreased size of the file due to compression:

How it works…

In this recipe, you created a new .zip file called shapefiles.zip in write mode. In the first iteration of this script, you didn't compress the contents of the file. However, in the second iteration, you did by using the DEFLATED parameter passed into the constructor for the ZipFile object. The script then obtained a list of files in the data directory and looped through each of the files. Each file that has an extension of .shp, .dbf, or .shx is then written to the archive file using the write() function. Finally, the names of each of the files written to the archive is printed to the screen.

There's more…

The contents of an existing file stored in a ZIP archive can be read using the read() method. The file should first be opened in a read mode, and then you can call the read() method passing in a parameter that represents the filename that should be read. The contents of the file can then be printed to the screen, written to another file, or stored as a list or dictionary variable.

Previous Section
End of Section
Next Section