Python ArcGIS PowerPoints and Activities

1Lesson 1:Geoprocessing in ArcGIS

Basic Programming in ArcGIS with Python Workshop

RS/GIS Lab, Utah State UniversityWith Material from ESRI

Learning Objectives:

Create a geoprocessing model in ModelBuilder

Export the model as a Python script

Attach a Python script to a tool in ArcToolbox

Become familiar with the PythonWin interface

2Creating a new custom toolbox or adding an existing custom toolbox in Arc Map:

Right-click ArcToolbox

Give the toolbox a name

Toolbox appears in alphabetical order (tip: give a name starting with Z)

Toolbox is a file with extension .tbx that by default is placed:

C:\Documents and Settings\jlowry\Application Data\ESRI\ArcToolbox\My Toolboxes

Lesson 1a: Creating as Simple Model

Creating a new model or adding an existing model to the toolbox:

Models (and scripts) can be organized within Toolsets or placed directly in the toolbox as tools

3Creating a New Model:

Give the model a meaningful name

Use Edit to open the ModelBuilder Window.

Drag and drop geoprocessing tools from ArcToolbox to window:

4Double-click the geoprocessing tool to input the tool parameters:

Colored symbols means process is ready to run. Blue ovals = input, yellow box = tool, green oval = output.

5Element properties: Right-click on output oval example: Open same as double-clickingchange

name or location of output.

Model Parameter Make the output ( or input (blue oval)) a parameter.

Add to Display when the element is created, add to the display.

Intermediateflag as an intermediate dataset, and delete from Model menu.

Create Label Create a text label describing the element.

The Model Menu: Run run selected tool in the model.

Also, Run Entire Model and Validate Entire Model.

Savesave the model (good idea to save often, and make backup copies if its a large model).

Delete Intermediate Datadeletes all data flagged as intermediate.

Export to Python, Jscript, or VBscript.

Importa Arcview 3.3. model.

6Buttons in the ModelBuilder Window:

Model Properties: Right-click on model General: assign model name,

label, description and alias name Parameters: input parameters

for the model, and order of input Environments: environment

settings such as Raster Mask, Raster Cell Size, etc.

Help: Provide a help document to your model

Iteration: Run the model multiple times (batch)

7Environment Settings can be applied for the whole model or single tool in the model:

Right-click model within the Toolbox to get Properties dialog, then choose Environments Tab.

Right-click on the tool to get Properties dialog, then choose Environments Tab.

Setting parameters for certain elements (variables) in your model make the model more flexible:

Right-click on the element and check on Model Parameter.

So when you double-click on the model, or Open the model you will be asked for input parameters.

Right-click on the tool to get Properties dialog, then choose Environments Tab.

8ACTIVITY: Creating a simple Model As a class well create a simple geoprocessing model.

The model will facilitate making a stream burn grid, and will require four geoprocessing tools: Polyline to raster (conversion toolbox) Setnull (spatial analyst toolbox) Thin (spatial analyst toolbox) Con (i.e. conditional statement, from spatial analyst toolbox)

Data inputs will be a vector stream shapefile, and three elevation grids: elev_30m, elev_30m-10, and elev30m-100

Well make and run the model first without parameters, then well make a copy of it and add parameters to the copy.

Finally well run both and see how they differ.

Need to attach the script as a tool in a toolbox.

Need to set the properties of the tool and link to the script.

Advantages: Can be incorporated into a

model Run from command line Assign help documentation User interface with buttons Dialog prevents errors

Data type checking Data existence checking Can use Domains &

Dependencies

Lesson 1b: Running a Python Script from ArcToolbox

9 General: Name: must be unique, no

spaces, used in command line and scripts

Label: need not be unique. Used for tools display name.

Description: appears in the Help Panel.

Stylesheet: controls the dialogs appearance.

Relative Paths: When set all path names within the tool are stored relative to the toolbox containing the tool.

Source: Path to the script file that

will be executed from the tool

Can be Python, VBScript, Jscript, AML, and EXE

Points to the script, so if the script gets updated, the tool gets updated.

10

Parameters: Display Name: label for the

parameter in the dialog Data Type: type of dataset Type: defines whether

parameter is required or optional.

Direction: whether parameter is input or output

Multi-value: Parameter handles multiple values.

Default: default value for the parameter.

Environment: make parameter display current env. setting.

Domain: Limits acceptable values (range & coded)

Dependency: makes one parameter dependent on another parameter

Help: Help documentation that

can be attached to the tool.

11

ACTIVITY: Attaching a script to a tool. As a class well export the 2 models we created in Lesson1a to 2

scripts

Well fill in the properties for the 2 script tools, and run them from ArcToolbox

Well note the difference between having parameters and not having parameters for the script

Well note the difference between using Open and Edit to look at the tools

What is Python? An open-source, object-oriented, scripting language Python files are text files (.py extension) Several Integrated Development Environments (IDE)

available for editing/writing python scripts E.g. PythonWin, Python IDLE, Crimson editors Were using PythonWin 2.4.1

Advantages: Easy to use ESRI primarily supports Python Contemporary equivalent of AML

Lesson 1c: Introduction to PythonWin

12

PythonWinInterface: Menus, toolbars,

and context menus (windows look and feel)

Two windows Script Window:

Write and save code

Interactive Window: Test lines of code, and report (error) messages.

Menus: File: open, new, save,

run Edit: find, replace,

undo, select all, gotoline

View: toolbars> standard & debugging.options>line numbering

Tools, Window and Help

Debugging & Standard Toolbars

Run script dialog-With or w/out Arguments (Parameters)-No debugging or debugging

RUN SCRIPT

SYNTAX CHECKER

INTERACTIVE WINDOW

STEP THROUGH

STEP AROUND

Means script ran successfully

13

Context menu allows commenting/uncommenting regions of code

ACTIVITY: Running a script in PythonWin As a class well:

In PythonWin, well open the two scripts we exported to Python Examine the code to try to understand what it means Run the scripts and edit them as necessary to make them run

properly

Lesson 1: Geoprocessing in ArcGIS Lesson 1a ACTIVITY: Creating a simple Model

1) Open ArcCatalog and navigate to the Lesson1 folder. 2) While in the Contents tab, right-click in the window and choose New, then choose Toolbox. 3) Rename the new toolbox Z_lesson1. 4) Double-click on Lesson1.mxd to open it in ArcMap. 5) In the AcToolbox window, right-click on ArcToolbox and choose Add Toolbox. 6) Right-click on the Z_Lesson1 toolbox and choose New, then choose Model. 7) In the Conversion Tools toolbox, find the To Raster toolset and drag the Polyline to Raster tool to

the ModelBuilder window. 8) Double-click on the Polyline to Raster tool in the ModelBuilder window. 9) For Input Features choose flowline.shp, for Value field leave as FID, for Output Raster put fl_grd

(note the path for the output raster should be to the Lesson1 folder). Change the Cellsize to 30, and leave the other inputs as default. When done, click OK.

10) At the top of the ModelBuilder window, click on the Auto Layout button, then click on the Full Extent button.

11) From the Model menu, click on Save. 12) Close the Conversion Tools toolbox, and open the Spatial Analysts Tools toolbox. 13) From the Conditional toolset, drag and drop the Set Null tool to the window. 14) For the Input conditional raster choose fl_grd, for Input false raster or constant value, put 1.

Name the output raster fl_nodata, and for the Expression put VALUE < 0. When done, click the OK button.

15) To find the Thin took, click on the Search tab within the ArcToolbox window, and type in the work thin, then click the Search button.

16) Drag the Thin tool from the Spatial Analyst Toolbox to the Modelbuilder Window. 17) Double-click on the Thin tool and fill in the input parameters as follows. Use fl_nodata for the

input raster, call the output raster fl_thin, Maximum thickness put 30, and for everything else use the defaults. Click OK.


19) From the Model menu, click on Save. 20) Finally, from the Conditional toolset, drag and drop the Con tool to the window. 21) For the Input conditional raster choose fl_thin, for the Input true raster or constant value choose

elev30m-10, for Input false or constant value put elev30m, name the output raster fl_burn10, for Expression put VALUE=1. Click OK.


23) From the Model menu, click on Save. Then from the Model menu click on Close. Save again, if it asks you to.

24) Right-click on the model and rename it streamburn. 25) Right-click on the streamburn model and choose Properties. Click on the Environments tab and

open General Settings and click on Extent, then click on Values. Then click on General Settings and for the Extent choose the elev30m dataset to specify the extent (otherwise the final output of the model will be the extent of the streams which is smaller than the entire elevation grid). Then click on Current Workspace, click on Values and set the current workspace to the Lesson1 folder.

26) Right-click on the streamburn model and choose Edit, this opens the model again. 27) Right click on all the green ovals and make sure they are checked on for Intermediate and Add to

Display (note you could click Intermediate off for the last output if you wish). 28) From the Model menu choose Run Entire Model. You should see all 4 steps of the model run, and

the intermediate datasets added to ArcMap. Close the model (Model > Close), and examine the new data layers added to the ArcMap.

29) Right-click the streamburn model, and choose Copy. 30) Right-click the Z_Lesson1 Toolbox, and choose Paste.

31) Rename the copied model streamburn_p. 32) Right-click on the streamburn_p model and choose Edit. 33) Right-click on the blue oval for the Con tool that says elev30m-10 (this grid assigns the grid

values where the Thin grid = 1, in other words the elevation minus 10 meters). 34) Check on a Model Parameter for this input. 35) Since the input is now a parameter, we also want to have control over what we name the output, so

right-click the output green oval for the Con took and make it a parameter as well. 36) Save the model, and close. 37) Now double-click (also right-click Open) on the streamburn_p model and you will see that the

default input parameters are there, but you can also change them easily. Instead of elev30m-10, use the elev30m-100 (100 meter burn). And change the output name to fl_burn100. Then click OK to run the model.

38) Zoom in and you should see that the fl_burn100 is quite different from the fl_burn10. You can also test this with the identify button with the Identify from: set to instead of the , which is the default.

39) Finally, double-click on the streamburn model (one with out parameters). What happens? Can you see how setting parameters can be useful?

40) Exit ArcMap, but before you do remove any of the datalayers created in this Activity (e.g. fl_grd, fl_nodata, fl_thin, fl_burn10, etc.), then delete them from the Lesson1 folder using ArcCatalog.

Lesson 1b ACTIVITY: Running a Python Script from ArcToolbox

1) First, export the models we created from Lesson1a to Python scripts. Start the ModelBuilder window for both the streamburn and streamburn_p models by right-clicking on the model and choosing Edit. Under the Model menu, choose Export, and then export the model to a Python script. Create streamburn.py and streamburn_p.py, and make sure theyre both in the Lesson1 folder.

2) Right-click on the Z_Lesson1 toolbox, and choose Add, then choose Script. 3) Right-click on the Script tool and choose Properties. 4) On the General tab, enter streamburn for the Name, Streamburn No Parameters for the Label, and

a short description for the Description. Click on Store relative path names. 5) On the Source tab, link to the tool to the streamburn.py file. 6) Click on the Parameters tab and dont do anything (this file has no parameters), then click OK. 7) Add the streamburn_p.py script in the same way as steps (2-3). 8) Open the Properties and click he General tab. Enter streamburn_p for the Name, Streamburn With

Parameters for the Label, and a short description for the Description. Click on Store relative path names.

9) Click on the Parameters tab and then click on the blank cell just below Display Name. For this parameter enter something like DEM subtracted. To the right of that cell, select Raster Layer from the dropdown list for the Data Type.

10) For the Parameter Properties, leave it as Type=Required, Direction=Input, and MuliValue=No. 11) Click on the blank cell below the Display Name DEM subtracted and enter Streamburn

Output. 12) For the Parameter Properties, change Direction=Output. 13) Click OK. 14) Click on the Streamburn No Parameters script tool ( or alternatively right-click and choose

Open). Click OK. The script should run correctly, but nothing gets added to the ArcMap Display.

15) Click on the Streamburn With Parameters script tool. Choose the elev30m1100 grid as the Alternate DEM and call the output grid fl_burn100. Run the script and see what happens.

16) NOTES: If you wanted to share these script and model tools with someone (or move them to another location) you would give them the Z_Lesson1.tbx file and the .py files. Since the scripts are stored with relative paths, they should work as long as the .py files remain in the same location relative to the .tbx file.

Lesson 1c ACTIVITY: Introduction to PythonWin

1) If a PythonWin icon is not on the desktop, copy and paste the icon there. 2) Start PythonWin by double clicking on the PythonWin icon. 3) Under File choose Open and browse to the Lesson1 folder and open the streamburn.py script. 4) Well talk about the code, though youre not expected to understand what it all means at this time. 5) To run the script click on the Run button, or choose Run under File. And see what happens. 6) The script executes correctly when the message on the bottom bar says returned exit code 0. If it

doesnt say this we have a problem. 7) Lets change the line that says flowline = flowline, to read flowline = flowline.shp. 8) Then run the script again.and hopefully it works. 9) Now open the streamburn_p.py file. This one as arguments which we find in the code (well learn

more about arguments later). 10) To run this script from PythonWin we provide the arguments in the Run Dialog, separated by a

space. 11) There are two arguments: the Alternative DEM input, and the name for the output streamburn

grid. We must enter the complete paths for these two arguments separated by a space in the Arguments entry box of the Run Dialog.

12) The easiest way to do this is to open ArcCatalog and navigate to the Lesson1 folder, then copy and paste the pathname to the Arguments entry box, adding the two names we wish to use (e.g. elev30m100 for the input and fl_burn100 for the output.

13) We will probably have to edit the line that says flowline = flowline, to read flowline = flowline.shp again.

14) Run the script with the arguments and see what happens. 15) Run the script a second time and see what happens. There should be an error in the Interactive

Windowthe intermediate datasets and the final output datasets already exist. 16) To fix that well add one more line of code. 17) After the gp.workspace = C:\\... assignment, add the following line of code:

gp.Overwriteoutput = 1. Then try running the script again. If everything went okay (and the stars are in the right position), the script executed without a problem.

1Lesson 2:Fundamentals of Python



Learning Objectives: Learn basics of Python syntax

Learn about the importing modules in Python

Learn about the ArcObject concept

Understand the concepts of Properties and Methods

Learn where to find syntax for ArcToolbox tools

Understand why ArcToolbox aliases are important

To be able to edit/write a very simply Python script

2 Comment: non-executable line of code One or two number signs (# or ##)# Set the current workspacegp.workspace = "C:\\john\\Lesson2## Set so output can be overwrittengp.Overwriteoutput = 1

Comment and uncomment blocks of code Right-click the line of code > Source Code >

Comment out region Useful for debugging code

Lesson 2a: The Basics of Python Syntax

Variable: a named entity that holds information Can hold different types of data

Strings, numbers, lists, tuples, dictionaries, files

# Local variables...fg = "C:\\john\\Lesson2\\fl_grd"

No declaration key word or type assignment, Python smart enough to know fg holds a string

Variables are case sensitive (below are two different variables):

Num = 1000num = 2000

3Strings: text or characters Strings surrounded by double () or single () quotes

Pathnames use two back (\\) or one forward (/) slashfg = "C:\\john\\Lesson2\\fl_grd"

Strings can be concatenated (combined together) with + characterfgPath = C:\\john\Lesson2\\fg = fl_grdfullPath = fgPath + \\ + fg

Strings are indexed (you can fetch characters/items)

fl = Flowline.shpfl[0] # fetches the first item (i.e. F)fl[1:3] # fetches from 1 up to, but not including, 3 (i.e. lo)fl[:-4] # fetches from 1 up to, but not including the last

# 4 items ( i.e. Flowline)

Numbers and Lists: Variables can hold numbers and expressionsnum1 = 2.3num2 = 2 + 3

Variables can hold listsnumList = [1, 2, 3, 4, 5]grdList = [elev30m, elev30m10, elev30m100, elev30m250]

Lists are indexed

# create a listgrdList = [elev30m, elev30m10, elev30m100, elev30m250]# fetch the first item (i.e. elev30m)grd1 = grdList[0]# fetch the second item (i.e. elev30m10)grd2 = grdList[1]# fetch from first item up to second itemgrd3 = grdList[0:1]# fetch from 1 up to, but not including the last item grd4 = grdList[0:-1]# fetch third through the endgrd5 = grdList[2:]

4Variable Naming Conventions (ESRI): Use combination of lower and upper case, beginning

with lowercase

Acronym at the beginning, use lowercase, followed by descriptive part with uppercase

fcFlowline = flowline.shpgrdElev = sys.arg[3]

Avoid special characters (e.g. / \ & * !)

Examples of no-so-good variable names

Var1, a, temp-var, b

Line Continuation: Line continuation characters

Backslash \

Parentheses ( ), brackets [ ], and braces { }

Indentation is automatic# Process: Polyline to Raster...gp.PolylineToRaster_conversion(flowline, "FID", fl_grd, \

"MAXIMUM_LENGTH", "NONE", "30")# Create a listfcList = [streams, rivers, ownership, soils,

roads, springs, hazards]

5Built-in Python Functions: len( ) returns the length of a string or a list

fc = flowline.shplen(fc) returns 12grdList = [elev30m, elev30m10, elev30m100]Len(grdList) returns 3

round ( ) returns a rounded numberxCoord = 435690.435676round(xCoord) returns 435690

max ( ) returns the maximum valuexExtent = (435690, 455700)Max(xExtent) returns 455700

Importing Modules for Additional Functions: The math module:

import mathmath.sqrt(49) returns 7math.pow(10,2) returns 100

The string module: import stringstring.split (4 5 9 13) returns [4, 5, 9, 13]string.upper (c:\\john) returns C:\\JOHN

Other Python modules: sys, os, arcgisscripting, gdal

6Python Statements: importimports a module

import mathimport stringimport sys, os, arcgisscripting

printprints to the Interactive Window print buffer done!print dataset does not exist

Other statements:ifelifelsewhileforintryexcept

Decision Making Syntax: Testing conditions

if y == 1:print y is 1

elif y == 2:print y is 2

else:print y is neither 1 nor 2

Notes: Colons used at end of each condition

Indention defines what executes for each condition

Python automatically indents

One equal sign (=) for assignment, two (==) for conditionsy = 48 # assignmentIf y == 48: # testing a condition

7Looping Syntax: While loops:

y = 1while y < 15:

print yy = y + 1

Counted loops:for y in range (1,15):

print y

List loopsnumList = [1, 2, 3, 4, 5]for num in numList:

print num

Notes: Colons at end of each condition (implied do this)

Indentation important for proper execution

ACTIVITY: Learning Python Syntax

As a class well: Experiment with what weve learned about Python syntax.

Well start in the Interactive Window, then move to writing simple scripts in the Script Window

8 ArcGIS is built with hundreds of ArcObjects

Lesson 2b: Accessing Tools and Environment Settings

Feature Class

Application

Map Document

Symbol

RowField

Selection

Table

Layer

Interacting with ArcObjects (Object Oriented Programming)

-Select feature-Clear selection-Add layerMethods-Extent-Map scale-Spatial reference-Name-Layer countProperties

Map Document Each ArcObject has Properties and Methods

Property: Characteristic of an object

Method: Something the object knows how to do (action)

We interact with objects through properties and methods

-Remove feature-Create featureMethods-Extent-Spatial reference-Shape typeProperties

Feature Class

9The Geoprocessor ArcObject:

-Select feature-Copy features-Select-Clip-BufferMethods-Cell size-Map extent-Current workspaceProperties

Geoprocessor Most geoprocessing sits on one ArcObject calledthe Geoprocessor Object

The geoprocessor object has many properties and methods

Env.Settings

Tools

Accessing the Geoprocessor with Python:

The gp object can be used in many languages

Perl, VBScript, Jscript, Python, VBA, VB, etc.

Any COM (Component Object Model) compliant language

In Python, objects are accessed through dot notation

# Import the arcgisscripting moduleimport arcgisscripting# Create the Geoprocessor object (assign gp varible name)gp = arcgisscripting.create()

Thereafter all geoprocessing functionality is accessed through the gpobject (or gp variable)

# Check out the spatial analyst extension licensegp.CheckOutExtension("spatial")

10

Syntax for properties and methods:

To assign a value to a property:

Object.Property = Value

gp.Workspace = C:\\john\Lesson2 To get a value of a property:

Object.PropertyPrint The workspace is + gp.Workspace

To use a method: Object.Method(arg, arg, )

All methods require parentheses even if there are no arguments

Arguments are separated by commasgp.Thin_sa(ingrd, thingrd, "ZERO", "NO_FILTER",

"ROUND", "30")

Finding Scripting Syntax for Environment Settings or Tools: ArcGIS Desktop Help:

Contents > Geoprocessing tool reference

Index and Search Tabs

In ArcToolbox (my preferred method):

Right-click tool, then choose Help

Usage in Python (in Interactive Window), type:gp = arcgisscripting.create()gp.Usage("Thin_sa")'Usage: Thin_sa {ZERO | NODATA}

{NO_FILTER | FILTER} {ROUND | SHARP} {maximum_thickness}'

11

Toolbox Aliases:

Many tools in ArcToolbox with the same name

Coverage Tools > Analysis > Clip

Analysis Tools > Extract > Clip

Always suffix the tool with the toolbox alias name

Always assign alias names to custom toolboxes

statsSpatial Statistics

saSpatial Analyst Tools

lrLinear Referencing Tools

geocodingGeocoding Tools

managementData Management Tools

arcCoverage Tools

conversionConversion Tools

cartographyCartography Tools

analysisAnalysis Tools

3d3D Analyst

Alias NameToolbox

Usage: Thin_sa {ZERO | NODATA} {NO_FILTER | FILTER} {ROUND | SHARP} {maximum_thickness}

Example: The Select Tool

Syntax:Select_analysis (in_features, out_feature_class, where_clause)

Example:# gp.select_analysis("nfroads.shp", "paved.shp", '

"ROAD_CLASS" = \'PAVED\' ')

Notes:Fields are double quoted (") and text values are single quoted (')

12

Example: The Polyline to Raster Tool

Syntax:PolylineToRaster_conversion (in_features, value_field, out_raster_dataset,

cell_assignment, priority_field, cellsize)

Example:gp.PolylineToRaster_conversion(InFeatures, "myField", OutRaster,

"MAXIMUM_LENGTH", "","")

Notes:Can use to skip an optional argument

Example: TheThin Tool Syntax:

Thin_sa (in_raster, out_raster, background_value, filter, corners, maximum_thickness)

Example:gp.Thin_sa(inRaster, outRaster, "ZERO", "NO_FILTER", "ROUND",

30") Orgp.Toolbox = sagp.Thin (inRaster, outRaster, "ZERO", "NO_FILTER", "ROUND",

30")

Notes:Can use gp.Toolbox = sa instead of toolbox alias

13

ACTIVITY: Write a Python Script as a Class As a class well:

Write a small geoprocessing script Find the syntax for three geoprocessing tools and include them in the script Run the geoprocessing script from PythonWin

CHALLENGE: Write a Python Script in Teams Use a List Loop with the Slice tool to create 3 elevation zone grids for 5, 10 and

15 zones. Hint 1: Youll need to check out the spatial analysts license to use Slice.

# check out spatial analyst licensegp.CheckoutExtension("spatial")

Hint 2: the items in the list loop will look like this [5,10,15]. However this presents a challenge when you create the output, because each of the output rastersshould have a new name (e.g. slice5, slice10, slice15). The items in the loop are integers and you cant concatenate an integer to a string, so youll have to convert the integers to strings. Youll need to import the string module, then list the functions in the module. From there youll have to find the function that converts an object (e.g. an integer object) to a string object.

Lesson 2: Fundamentals of Python Lesson 2a ACTIVITY: Learning Python Syntax

1) Well begin by entering Python code in the Interactive Window. 2) The >>> is the PythonWin prompt. Do not type >>>. After typing, press Enter and see what is

returned. 3) This is what we did in class (text after the prompt is what we typed, text without a prompt is what

was returned). >>> # Lesson 2a--working with Python syntax in the Interactive Window >>> # John Lowry >>> # Aug. 14, 2007 >>> ################################################################## >>> # Working with variables >>> boy = "Jim" >>> print boy Jim >>> a = 2 + 4 >>> print a 6 >>> boyList = ["Jim", "John", "Andy", "Frank"] >>> print boyList[0] Jim >>> print boyList[2] Andy >>> print boyList[-1] Frank >>> shpName = "Streams.shp" >>> print shpName[:-4] Streams >>> # Working with built-in functions >>> print round(9.2333) 9.0 >>> # Importing a new module >>> import math >>> # Find out what functions come with the math module >>> dir(math) ['__doc__', '__name__', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log', 'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh'] >>> # Look at the documentation for the log function in the math module >>> print math.log.__doc__ log(x[, base]) -> the logarithm of x to the given base. If the base not specified, returns the natural logarithm (base e) of x. >>> # Import the string module >>> import string >>> string.capitalize("HELLO") 'Hello' >>> # Example of Concatenating strings >>> a = "streams" >>> p = ".shp" >>> print a + p streams.shp >>> filename = string.capitalize(a[0])+ a[1:] + p >>> print filename Streams.shp

4) Open a new Script Window. Click on File > New, then choose Python Script, then click OK. 5) Now copy all the text from the Interactive Window and paste it in the Script Window. Highlight

all the text from the Interactive Window and right-click and choose Copy. Put your cursor in the top of the Script Window, then right-click and choose Paste.

6) Click the Edit menu and choose Replace. For Find What put >>> and leave Replace with: blank. Then click the Replace All button. This removes all >>> prompts.

7) The output from what you pasted is flagged with a to the left of it. Delete each of these lines by backspacing. Then take out the blank character between each remaining line. All the code should now be flush with the left margin of the Script Window.

8) Go to the Interactive Window, right-click and choose Select All. Then press your delete key. The Interactive Window should be blank.

9) Save the script by first making the Script Window active by clicking on it (anywhere). Then go the File menu, and choose Save As. Save the file as lesson2a.py in the Lesson2 folder.

10) Now, run the pythonSyntax.py file by clicking on the Run button, or choosing Run from the File menu.

11) Highlight all the text in the Script Window, righ-click and choose Source Code, then choose Comment out region.

12) Now, type the following code: # working with decision making x = 25 if x < 25: print "the number is less than 25" elif x > 25: print "the number is greater than 25" else: print "the number is 25" 13) Press the Run button. In Interactive Window you should see the number is 25. 14) Things to remember: if, elif and else must be lowercase, colons must be at the end of each

condition, and Python interprets the indentation as the end of the condition, thus executing the line of code.

15) Highlight the decision making code and comment it out as before, and save the file (no need to use Save As this time, just Save).

16) Now, type the following code: # working with loops # while loop example z = 5 while z < 30: print z z = z + 5 17) Press Enter twice to end the construct. Save the script file, then press the Run button. You should

see the following values in the Interactive Window: 5 10 15 20 25 18) Highlight the while loop example code, and comment it out as before, and save the script file. 19) Now, type the following code: # Counted loop example grdList = ["elev30m", "elev30m10", "elev30m100"] for eachGrd in grdList: print eachGrd 20) Press Enter twice to end the construct. Save the script file, then press the Run button. You should

see the following in the Interactive Window: elev30m elev30m10 elev30m100 21) Highlight the count loop example code, and comment it out as before, and save the script file. 22) Now, type the following code: # for loop example for num in range (2,6): print num 23) Press Enter twice to end the construct. Save the script file, then press the Run button. You should

see the following values in the Interactive Window: 2 3 4 5 24) Things to remember: while, for, in, and range have to be lowercase. Colons are required at

the end of each while and for statement. Python recognizes the construct as a loop only when it ends with an indentationcolons and indentations are VERY important in Python!

25) Close the python script File > Close. Lesson 2b ACTIVITY: Writing a Simple Python Script

1) Open the Lesson2b.mxd and look at the flowline layer.

2) In PythonWin open a new script window and save it as lesson2b.py in the Lesson2 folder. 3) Type the following comments to start the script. # Author: John Lowry # Date: August 17, 2007 # Purpose: Lesson 2b example of a simple python script 4) Import the arcgisscripting module and create the gp object. # Import the arcgisscripting module import arcgisscripting # Create the Geoprocessor object gp = arcgisscripting.create() 5) Set the current workspace as the Lesson2 folder (note your path to the Lesson2 folder may be

different than what is typed below). # Set the current workspace gp.workspace = ("C:/john/TeachingGIS/GIS_Programming_with_Python/Lesson2") 6) In ArcToolbox, find the Select tool. If you dont know where it is, use the Search tool. Choose

the Select tool from the Analysis Tools toolbox. Then click on the Locate button. 7) Right-click on the Select tool and choose Help. 8) Scroll down to the Scripting Syntax part, take a look at the table for the parameters and look at the

sample code. Copy and paste the syntax to the Python script window. You may also want to copy the comment in the sample code. Note were copying all of this because were new at this and I recommend that when youre leaning its better to have too much comment than to little. Your code in the script window should look something like this.

# Select Red Butte Creek # Usage: Select_analysis (in_features, out_feature_class, where_clause) # For shapefile expression, fields are double quoted (") and text values are single quoted (') 9) Type in the code for the Select_analysis tool. gp.select_analysis ("flowline.shp", "RBCreek.shp", ' "GNIS_Name" = \'Red Butte Creek \' ') 10) Save the code and run the script. 11) Now, do the same for the Buffer tool from the analysis toolboxfind the tool in ArcToolbox, go

to Help, and scroll down to they scripting syntax, then copy and past the syntax as a comment in the script window. Then write the line of code to execute the tool. Your code should look something like this:

# Buffer the selected creek # Buffer_analysis (in_features, out_feature_class, buffer_distance_or_field, line_side, # line_end_type, dissolve_option, dissolve_field) gp.buffer_analysis ("RBCreek.shp", "RBCreekBuff.shp", "100 feet") 12) When the script is executed, it tells you the RBCreek.shp already exists. Type the following just

below the gp.workspace line. gp.overwriteoutput = 1 13) Do the same for the Polygon to Raster toolfind the tool in ArcToolbox, go to Help, and scroll

down to they scripting syntax, then copy and past the syntax as a comment in the script window. Then write the line of code to execute the tool. Your code should look something like this:

#Convert bufferarea to raster #PolygonToRaster_conversion (in_features, value_field, out_raster_dataset, cell_assignment, priority_field, cellsize) gp.PolygonToRaster_conversion("RBCreekBuff.shp", "FID", "BuffGrd", "CELL_CENTER", "NONE", "30") 14) Now, were going to change the script so that the buffer distance and units can be passed to the

scripts as arguments (i.e. parameters). 15) First, set the arguments just below where you set the workspace and overwrite properties. # Argumentsfor buffer distance and buffer units bufDist = sys.argv[1] distUnit = sys.argv[2] 16) Import the sys module by adding it to the first line of code in the script. # Import the arcgisscripting module import sys, arcgisscripting 17) Comment out the existing buffer_analysis tool, and add the following: gp.buffer_analysis ("RBCreek.shp", "RBCreekBuff.shp", bufDist+" "+distUnit, "", "" , "ALL")

18) To make it so that the final output contains the buffer distance in its name, add the variable to the Polygon to Raster conversion method like this:

gp.PolygonToRaster_conversion("RBCreekBuff.shp", "FID", "BuffGrd"+bufDist, "CELL_CENTER", "NONE", "30") 19) Finally, its good practice to delete the gp object at the end of the script, so at the very end of the

script enter the following code: del gp. 20) Run the code. Remember youll need to pass the arguments in the Run Script dialog. Each

argument is separated by a space, so you enter something like: 500 feet. 21) Your code should look something like this, and you should have a pretty good idea what it

means # Author: John Lowry # Date: August 17, 2007 # Purpose: Lesson 2b example of a simple python sript #############################################################

# Import the arcgisscripting module import sys, arcgisscripting # Create the Geoprocessor object gp = arcgisscripting.create()

# Set the current workspace & set overwrite on gp.workspace = ("C:\\john\TeachingGIS\\GIS_Programming_with_Python\\Lesson2") gp.overwriteoutput = 1

# Arguments for buffer distance and buffer units bufDist = sys.argv[1] distUnit = sys.argv[2]

# Select Red Butte Creek # Select_analysis (in_features, out_feature_class, where_clause) # For shapefile expression, fields are double quoted (") and text values are single quoted (') gp.select_analysis ("flowline.shp", "RBCreek.shp", ' "GNIS_Name" = \'Red Butte Creek \' ')

# Buffer the selected creek # Buffer_analysis (in_features, out_feature_class, buffer_distance_or_field, line_side, # line_end_type, dissolve_option, dissolve_field) # gp.buffer_analysis ("RBCreek.shp", "RBCreekBuff.shp", "100 feet") gp.buffer_analysis ("RBCreek.shp", "RBCreekBuff.shp", bufDist+" "+distUnit, "", "", "ALL")

#Convert bufferarea to raster #PolygonToRaster_conversion (in_features, value_field, out_raster_dataset, cell_assignment, priority_field, cellsize) gp.PolygonToRaster_conversion("RBCreekBuff.shp", "FID", "BuffGrd"+bufDist, "CELL_CENTER", "NONE", "30")

del gp Lesson 2b CHALLANGE: Write a Python Script that does the following:

a. Use a List Loop with the Slice tool to create 3 elevation zone grids for 5, 10 and 15 zones.

b. Hint 1: Youll need to check out the spatial analysts license c. Hint 2: the items in the list loop will look like this [5,10,15]. However this presents a

challenge when you create the output, because each of the output rasters should have a new name (e.g. slice5, slice10, slice15). The items in the loop are integers and you cant concatenate an integer to a string, so youll have to convert the integers to strings. Youll need to import the string module, then list the functions in the module. From there youll have to find the function that converts an object (e.g. an integer object) to a string object.

import string dir(string) print string.digits.__doc__

Your script should look something like this: # Author: John Lowry # Date: August 17, 2007 # Purpose: Lesson 2b example of a simple python sript # Challenge: convert integer variable to string and use list loop #############################################################

# Import the arcgisscripting module import sys, arcgisscripting # Create the Geoprocessor object gp = arcgisscripting.create()

# check out spatial analyst license gp.CheckoutExtension("spatial")

# Set the current workspace & set overwrite on gp.workspace = ("C:\\john\TeachingGIS\\GIS_Programming_with_Python\\Lesson2") gp.overwriteoutput = 1

# set up list loop for Slice tool # Slice_sa (in_raster, out_raster, number_zones, slice_type, base_output_zone) zoneList = [5,10,15] for zone in zoneList: zonestr = str(zone) gp.slice_sa("elev30m", "slice"+zonestr, zone) print "creating sliced grid for zone "+zonestr+" zones"

del gp

1Lesson 3: Geoprocessing Programming Model



Learning Objectives: Understand the role of the Geoprocessor (gp) Object

Learn about Properties and Methods of the gp

To be able to interpret the Geoprocessing Programming Model Diagram

Learn that Properties and Methods return objects and standard data

Understand why you would want to use a Describe object

To be able to write a simple script using a Describe object

2 The Geoprocessor is an object (special variable) that has properties and methods All tools are methods All environmental settings are properties

We access the methods and properties through the gpobject

Lesson 3a: The Geoprocessor (gp) Object

Env. Setting

Env. Setting

Tool

Tool

Propertygp.workspace

Propertygp.extent

Methodgp.Buffer_analylsis

Methodgp.Thin_sa

The Geoprocessor has properties and methods that are NOT environmental settings or toolsgp.Toolboxgp.Usagegp.Exists

There are other scripting objects besides the gp Describe objects Enumeration objects Cursor objects Other objects

3 The GeoprocessorProgramming Model

Diagram shows all objects, properties, methods

Descriptions and Usage found in Desktop Help

Each box represents and object Objects grouped by functionality (colors) All objects sit on the geoprocessing object

Property Read onlyPrint gp.MessageCount Read/WritePrint gp.Toolbox

Methods Gp.AddError(Error)

4 All tools and environment setting not listed in the diagram

All can be called from the Geoprocessor Tools and env. settings depend on whats

available (e.g. what toolbox has been added)

System toolboxes available by defaultGp.buffer_analysis()

If you call a tool from custom toolbox you must add it.

Gp.Addtoolbox(C:/john/Z_lesson.tbx)

Addtoolbox method does not add toolbox from ArcToolbox, just makes tools available for the script

5 Example of a Method: Check if data exists with the Exists method

If gp.Exists(flowline.shp):Print The flowline feature class exists

If not gp.Exists(flowline.shp)Print The flowline feature class does not exist

Example of a Property: Overwriteoutput property overwrites existing data

# will overwrite RBCreek.shp if it existsgp.overwriteoutput = 1gp.select_analysis ("flowline.shp", "RBCreek.shp", ' "GNIS_Name" = \'Red Butte Creek \' ')

Lesson 3a ACTIVITY: Write a script using the Exists method and the Overwriteoutput property

In teams, write a short script that does the following: Checks the current workspace (Lesson3) for a dataset called

landcover. If the dataset exists then use the Copy Raster tool (Data

Management) to make a backup copy called landcover_bak

6 Properties and methods return either standard data or objects

Most return standard data (a string or number (sometimes a boolean))

Exists(InputValue): Boolean, returns 1 or 0 and can be used in an If statement:

If gp.Exists(C:/john/flowline.shp):print The feature class exists

Some return an object

Describe(IntputValue): Object, returns an new object

dscDS = gp.Describe (C:/john/flowline.shp)print dscDS.Extent

Lesson 3b: Using Describe Objects

In the model diagram: Type of data returned by property or method on right of colon If not indicated, a string or numeric data is returned.

7 The Describe method on the geoprocessor object returns an object (a describe object)

The type of describe object returned, depends on the type datadescribed (feature class, table, raster dataset, etc.)

All describe objects provide descriptive information about the data being described Extent Spatial reference Coverage tolerances Cell size Band count Etc.

dscDS = gp.describeprint dscDS.Extent

dscRB = gp.describeprint dscRB.Height

Help for the Describe Method from ArcGIS Desktop Help Contents Tab > Geoprocessing > Automating your work with

scripts > Scripting object: Properties and Methods> Describe method

8Lesson 3b ACTIVITY: Create Describe objects using the Describe method

As a class, use the model diagram to answer the following questions: After the Describe method, what method would be

used to find out the Type of dataset were looking at? What about the Spatial Reference name? How could we determine the cell size of a raster

dataset? As a class well write a script that does this.

Lesson 3: The Geoprocessing Model Lesson 3a ACTIVITY: Write a script using the Exists method and the Overwriteoutput property. # Author: John Lowry # Date: August 17, 2007 # Purpose: Lesson 3a: Describing datasets with the Exists Method #############################################################

# Import the arcgisscripting module import arcgisscripting

# Create the Geoprocessor object gp = arcgisscripting.create()

# Set the current workspace & set overwrite on gp.workspace = ("C:/john/TeachingGIS/ArcGIS_Python/Lesson3_results") gp.overwriteoutput = 1

# check the current workspace for a dataset called "landcover" # make a backup copy if it exists if gp.Exists("landcover"): gp.CopyRaster_management("landcover", "landcover_bak") else: print "dataset doesn't exist"

del gp Lesson 3b ACTIVITY: Writing a script that creates Describe objects using the Describe method. # Author: John Lowry # Date: August 17, 2007 # Purpose: Lesson 3b: Describing datasets with the Describe Method #############################################################

# Import the arcgisscripting module import arcgisscripting


# Set the current workspace & set overwrite on gp.workspace = ("C:/john/TeachingGIS/ArcGIS_Python/Lesson3_results")

# describing a dataset dsc = gp.Describe("landcover") print "The data type is: " + dsc.DataType #print dsc.SpatialReference print "The spatial reference is:" + dsc.SpatialReference.Name

# doing something based on a decision if dsc.DataType == "RasterDataset": print "The cell size is: " + str(dsc.MeanCellHeight) else: print "not a raster dataset"

del gp del dsc

1Lesson 4:Enumeration & Cursor Objects

(with some coding tips)



Learning Objectives: To understand uses of enumeration objects

To be able to write a simple script using enumeration

To understand uses of cursor objets

To be able to write a simple script using cursors

To nderstand some basic debugging and coding guidelines

To review how scripts are added to ArcToolbox

2 Enumeration methods: Sit on the geoprocessor

object Each returns an object Each object holds a list of

data Object returned depends

on the method called

Lesson 4a: Enumeration Methods & Objects

Enumeration objects: A list of data (any type) without a known count ListFields returns a Fields object ListIndex returns a Indexes object All other Enumeration methods return an Enumeration object

3 The Enumeration object: Has two methods: Next and Reset

Next returns the name of an item in the enumeration object (list) Reset returns to the item as the start of the list

# workspace must be set!!gp.workspace = (C:/john/Lesson4)# get a list of grids beginning with elevrasList = gp.ListRasters(elev*, GRID)# loop through list and print items in listras = rasList.next()while ras:

print rasras = rasList.next

# reset ras to top of listras = rasList.reset()

An Enumeration object example: ListRasters(wildcard, rasterType)

4fldList = gp.ListFields(flowline, *, String)fld = fldList.Next()While fld None:

Print fld.Namefld = fldList.Next()

The ListFields (InputValue, wildCard, fieldtype) example: ListFields returns the Fields object Next returns the Field object The Field object returns the Name

Lesson 4a ACTIVITY: Complete the Code

As a class, using Desktop Help and the model diagram write the code:

List all the .dbf files in a workspace that begin with 199090dbfList = gp.ListTables(1990*, dBASE)

List all the CAD files in a workspace that begin with rdcmpCADList = gp.ListDatasets(rd*, CAD)

List all the tools from the conversion toolboxconToolList = gp.ListTools(*_conversion)

5 Cursor methods access attributes/values in table cells: Sit on the geoprocessor object Each returns an object (an enumeration/list of row objects) Cursors work with rows in a table or feature class

Add and delete rows Read values in rows Modify values in rows

Lesson 4b: Cursor Methods & Objects

InsertCursor returns the InsertCursor object Used to insert new rows

SearchCursor returns the SearchCursor object Used to read values in a row

UpdateCursor returns the UpdateCursor object Used to make changes to values in rows, and delete rows

Cursor Methods return Cursor Objects:

6 Next returns an individual row object To find out the value of a field for individual row (row), use:

Fieldname (a property)Print row.GNIS_NameOr- GetValue (fieldName) (a method)Print row.GetValue(GNIS_Name)

Reset takes you back to the start of the cursor

SearchCursor object:

gp.workspace = (C:/john/Lesson4)cur = gp.SearchCursor (nests1990)row = cur.Next()while row None:

print row.nestsiteidprint row.conditionrow = cur.Next()

del cur

SearchCursor example:

Notes:- Because row is not a string, but an object, we use None for the conditional- We could also have use the GetValue method

print row.GetValue(netsiteid)print row.GetValue(condition)

- We delete the cursor object at end of the while construct

7 Next returns an individual row object To find out the value of a field for individual row (row), use:

Fieldname Reads/writes a value from/to a field- GetValue (fieldName) Reads a value from a field- SetValue (fieldName, Value) Writes a value to a field

UpdateRow passes modified row into the table/feature class DeleteRow deletes a row

UpdateCursor object:

gp.workspace = (C:/john/Lesson4)cur = gp.UpdateCursor (nests1990, nestsiteid > 5)row = cur.Next()while row:

row.condition = string.replace(row.condition, poor, good)cur.UpdateRow(row)row = cur.Next()

del cur

UpdateCursor example:

Notes:- This code: Begins with the first row that has a

nestsiteid > 5, replaces condition that is poorwith good for each row, finally updates the row change.

- The string.replace method requires the string module be imported (not shown in code).

- We delete the cursor object at end of the while construct (to free the variable & memory).

8 NewRow creates a new row object Fieldname Reads/writes a value from/to a field- GetValue (fieldName) Reads a value from a field- SetValue (fieldName, Value) Writes a value to a field

InsertRow inserts the row into the table or feature class Automatically fills the OID field

InsertCursor object:

gp.workspace = (C:/john/Lesson4)cur = gp.InsertCursor (nestdata1990.dbf)row = cur.NewRow()row.nestsiteid = 11row.height =90row.count = 3 cur.InsertRow(row)

InsertCursor example:

Notes:- This code: Inserts a new row to the table

nestdata1990.dbf and fills the nestsiteid, height and count fields.

- Once all the the values are populated, the row is inserted into the table.

- If this were a feature class, the shape field would have to be added as well.

9gp.workspace = (C:/john/Lesson4)cur = gp.SearchCursor (flowline)row = cur.Next()while row:

geom = row.Shapeprint geom.Lengthrow = cur.Next()

del cur

Geometry Object and example:

Lesson 4b ACTIVITY: Write a script using cursor methods and objects.

The objective of the script is to create a viewshed for each nest site. We will use a cursor object to loop through all of the nest sites in

the point feature dataset: As we loop through we will select out each point (Select tool), run the Viewshed tool for that point, and then do the same for the next point.

Finally, we want to give the script two arguments: a workspace argument, so the script can be run in any user defined workspace, and second, a dataset argument, so the script can be run on any user defined nest site dataset.

10

Debugging and Coding Tips Test code in PythonWin, not ArcToolbox

Check Python syntax in PythonWin with Check button

Dont forget arguments (if you have them)

Check error message in Interactive Window

Try to understand the code

Narrow errors to a block or line of code (using commenting)

Coding Guidelines- Use consistent variable naming conventions (e.g. myIntegerVar = 1)

- Script names should follow similar naming conventions (e.g. mySript.py)

- Use indentation to show structure (Python enforces this).

- Use arguments in a script

- If a script has arguments, you should have code that checks the inputs have been given by the user (when attaching script in ArcToolbox we can provide a default input).

- Use comments (over commenting your own scripts, esp. when youre beginning is not a bad idea).

- Include a header to each script telling the scripts name, a little about how it works, its requirements, who wrote it and when it was written.

- Other guidelines?

Lesson 4: Enumerations and Cursors Lesson 4a ACTIVITY: Complete the code. List all the .dbf files in a workspace that begin with 1990 90dbfList = gp.ListTables(1990*, dBASE) List all the CAD files in a workspace that begin with rd cmpCADList = gp.ListDatasets(rd*, CAD) List all the tools from the conversion toolbox conToolList = gp.ListTools(*_conversion) Lesson 4b ACTIVITY: Write a script using cursor methods and objects.

The objective of the script is to create a viewshed for each nest site. We will use a cursor object to loop through all of the nest sites in the point

feature dataset: As we loop through we will select out each point (Select tool), run the Viewshed tool for that point, and then do the same for the next point.

Finally, we want to give the script two arguments: a workspace argument, so the script can be run in any user defined workspace, and second, a dataset argument, so the script can be run on any user defined nest site dataset.

Below are 4 progressively flushed-out iterations of a script written to meet the objectives of this activity. Note, I first start out simply trying to get the Cursor loop to work (script 1), when I get the cursor loop to work, I add the first geoprocessing step to the loop (script 2), when thats working I add another geoprocessing step to the loop (script 3). Finally, I add my arguments so I can run the tool in ArcToolbox with parameters, and I add messages the script user will see.

# Author: John Lowry # Date: August 17, 2007 # Purpose: Lesson 4b1: Using cursors script # FIRST SET UP THE BASICS AND GET THE CURSOR LOOP WORKING #############################################################

# Import the arcgisscripting module import sys, arcgisscripting


# Set the workspace gp.workspace = ("C:\john\TeachingGIS\ArcGIS_Python\Lesson4_results")

##if gp.Exists("nests1990.shp"): ## print "the shapefile exists"

# Set up cursor object cur = gp.SearchCursor("nests1990.shp") row = cur.Next() while row None: print row.nestsiteid row = cur.Next() del cur del gp

# Author: John Lowry # Date: August 17, 2007 # Purpose: Lesson 4b2: Using cursors script # NEXT, GET THE SELECT TOOL TO WORK IN THE CURSOR LOOP #############################################################


# Create the Geoprocessor object gp = arcgisscripting.create() gp.overwriteoutput = 1 # ADDED THIS TO HELP IN THE DEBUGGING

# check out spatial anlayst extension gp.checkoutextension("spatial")


# Set up cursor cur = gp.SearchCursor("nests1990.shp") row = cur.Next() while row None: i = str(row.nestsiteid) # NEED TO MAKE THIS A STRING print i #Select_analysis {where_clause} #note line conintuation \ character gp.Select_analysis("nests1990.shp", "tmp"+i+".shp", \

"\"nestsiteid\" = "+i+"") row = cur.Next() del cur del gp

# Author: John Lowry # Date: August 17, 2007 # Purpose: Lesson 4b3: Using cursors script # NEXT, ADD MORE GEOPROCESSING STEPS (E.G. VIEWSHED) TO THE LOOP #############################################################


# Create the Geoprocessor object gp = arcgisscripting.create() gp.overwriteoutput = 1



# Set up cursor cur = gp.SearchCursor("nests1990.shp") row = cur.Next() while row None: i = str(row.nestsiteid) print i #Select_analysis {where_clause} #note line continuation \ character gp.Select_analysis("nests1990.shp", "tmp"+i+".shp", \

"\"nestsiteid\" = "+i+"") # Viewshed_sa (in_raster, in_observer_features, out_raster, # z_factor, curvature_correction, refractivity_coefficient) gp.ViewShed_sa ("elev30m", "tmp"+i+".shp", "tmpras"+i,"" ,"" ,"" ) row = cur.Next() del cur del gp

# Author: John Lowry # Date: August 17, 2007 # Purpose: Lesson 4b3: Using cursors script # FINALLY, ADD ARGUMENTS FOR WORKSPACE AND DATASET, ADD ERROR # CHECKING AND MESSAGES #############################################################

# Import the arcgisscripting module import sys, arcgisscripting #ADD SYS MODULE FOR ARGUMENTS

# Create the Geoprocessor object gp = arcgisscripting.create() gp.overwriteoutput = 1


wks = sys.argv[1] data = sys.argv[2]

# Set the workspace gp.workspace = wks # REPLACED WITH WORKSPACE VARIABLE

# Set up cursor cur = gp.SearchCursor(data) #REPLACED WITH DATA VARAIBALE row = cur.Next() while row None: try: i = str(row.nestsiteid) print "Processing site: " +i #ADD SOME MESSAGES #Select_analysis

#{where_clause} gp.Select_analysis(data, "tmp"+i+".shp", \ "\"nestsiteid\" = "+i+"") # REPLACED WITH DATA VARIABLE # Viewshed_sa (in_raster, in_observer_features, out_raster,

#z_factor, curvature_correction, refractivity_coefficient) gp.ViewShed_sa ("elev30m", "tmp"+i+".shp", \ "tmpras"+i,"" ,"" ,"" ) row = cur.Next() except: print gp.GetMessage() del cur print "Done!" del gp

# note the line continuation \ character is used in the above code.

Python_ArcGIS_Lesson1.pdfLesson1_Activities.docPython_ArcGIS_Lesson2.pdfLesson2_Activities.docPython_ArcGIS_Lesson3.pdfLesson3_Activities.docPython_ArcGIS_Lesson4.pdfLesson4_Activities.doc

Python ArcGIS PowerPoints and Activities

Documents

Transcript of Python ArcGIS PowerPoints and Activities