Another GIS Blog

How to Create a Row with an Empty BLOB in ArcPy

2013-05-09T04:55:00.001-07:00

Insert and Update cursor do now support None type in Blob fields, so what does one do? If you try to set your row object to 'None' you get this error message:

expected contiguous memoryview. type: NoneType

Now let's assume you want to pass None, because for some record you do not have an object that you need to pass for that field. Use the Memoryview object to solve this problem. The documentation on the object can be found here.

The python document describe the object as such:

A memoryview object exposes the new C level buffer interface as a Python object which can then be passed around like any other object.

Now in our context, we must do the following:

row[0] = memoryview('')

That's it. Now we have something similar to 'None' for your blob field.

I also posted a quick tutorial on read/writing blob data using arcpy.da here.

Please support this idea of having GUI designer in python built in with python add-ins.

It can be found here. (direct link: http://ideas.arcgis.com/ideaView?id=087E00000004SmHIAU)

Enjoy

Working with numpy's Structured Array and numpy.dtype

2013-04-26T04:42:00.001-07:00

In my previous post, I showed how to quickly get access data (2007/2010) into a file geodatabase without creating an ODBC connection in ArcCatalog/Map using pyODBC. You might have noticed that I used numpy to create a table pretty easily, but you might be wondering what are the dtypes?

numpy.dtype are data type objects that describe how the bytes in a fixed-size block of memory are seen by the system. So is the data a string, number, etc... It describes the follow aspects of data:

Type of data (integer, float, object, ...)
size of data (number of bytes)
describes an array of data
names of fields in the record
if the data is a sub-array, it's shape

Getting the dtype formats for common python data types if fairly easy in python. The numpy.dtype() will return the proper format for almost any python data type:

>>> print numpy.dtype(str)
|S0

For array protocol type strings, there are various data types supported:

`'b'`	Boolean
`'i'`	(signed) integer
`'u'`	unsigned integer
`'f'`	floating-point
`'c'`	complex-floating point
`'S'`, `'a'`	string
`'U'`	unicode
`'V'`	anything (`void`)

(source: numpy help documents)

This allows you to specify thing like string length.
Example:

>>> dt = numpy.dtype('a25')  # 25-character string

After you know what your data types are, you will want to associate these types with the fields in the records. I prefer to use the optional dictionary method where there are two keys: 'names' and 'formats'. You would then pass this information to create your 'structured array'.

Example:

>>> dt = numpy.dtype({'names': ['r','g','b','a'],

     'formats': [numpy.uint8, numpy.uint8, numpy.uint8, numpy.uint8]})

>>> colors = numpy.zeros(5, dtype = dt)

>>> print colors

[(0, 0, 0, 0) (0, 0, 0, 0) (0, 0, 0, 0) (0, 0, 0, 0) (0, 0, 0, 0)]

There are many ways to declare dtypes for your data, and you can read them all here.
More on structured arrays in numpy can be found here.

Enjoy

Using pyODBC to Connect To Access with ArcPy

2013-04-24T05:00:00.000-07:00

pyODBC allows users to access any data source with the proper ODBC driver installed on the system. This is very convenient, and helpful because at 10.1 using ArcPy only you cannot create ODBC connection.

You can download pyODBC here. Grab the correct python version and install it.

Once installed, let's try to access a 2010-2012 MS Access Database.

I create a dummy database called 'db_text.accdb' and create a table called 'Addresses' with 5 text fields:

name
street
town
country
zipcode

After that I populated two rows with dummy data. Once you have some dummy data, let's move forward.

import pyodbc

import arcpy

import numpy

arcpy.env.overwriteOutput = True

accb = r"C:\temp\db_test.accdb"
access_con_string = r"Driver={Microsoft Access Driver (*.mdb, *.accdb)};Dbq=%s" % accb
cnxn   = pyodbc.connect(access_con_string)
cursor = cnxn.cursor()
cursor.execute("select * from Addresses")
rows = cursor.fetchall()

dts = {'names': ('ID','name','street', 'town', 'country', 'zipcode'),
       'formats':(numpy.uint8, 'S255','S255','S255','S10','S10')}

array = numpy.rec.fromrecords(rows, dtype=dts)

arcpy.da.NumPyArrayToTable(array, r"c:\temp\scratch.gdb\outTable")

Here we connected to the MS Access database using the drivers installed on my local system. Next I performed a simple query to return all records from the table. With the new da.NumPyArrayToTable() at 10.1, I want to convert the pyodbc rows to a table that can be used in ArcMap. I convert the list of tuples (rows object) to a numpy.array object. After the conversion, I fire off the arcpy function and now I have a table on disk.

For a complete listing of 10.1 numpy functions, check out: http://resources.arcgis.com/en/help/main/10.1/index.html#/What_is_the_data_access_module/018w00000008000000/

There you can learn about extending tables, convert feature classes to numpy arrays, and rasters as well.

Enjoy

Dynamic Layers and Workspaces

2013-04-15T05:00:00.000-07:00

An interesting and exciting aspect that I really like at 10.1 is the use of dynamic map services to display data from a work space on disk.

The exciting aspect is this:

Dynamic Rendering
Add 1:n layers to a map service

Where is gets interesting is this, in ArcPy, you cannot update symbology for feature classes. So essentially if you wanted to add a feature class to a map document, you have to accept the default symbology, or apply the symbology from an already existing set of layer files (.lyr). Not real dynamic, and at least I feel, a horrible choice.

Leveraging the web map REST specifications, as a developer you could create a map object (mapping.MapDocument object) and export the display to PNG, PDF, JPG, etc... The downside is that at 10.1, it appears you cannot save the MapDocument object to disk and view the dynamic layer in the TOC. This will throw an error when you open the map document file.

So what is this good for you are probably thinking? It's true you cannot view dynamic layers in 10.1, but the ability to use dynamic layers gives data driven pages the much needed shot in the arm to add layer on the fly from a web application. The new printing services for ArcGIS for Server leverages this concept except the out of box tool only produces one export at a time, where as a data driven page tool would produce multiple exports from a single input.

To get this concept to work, you would have to do the following:

import arcpy

from arcpy import mapping

json = arcpy.GetParameterAsText(0)
results = mapping.ConvertWebMapToMapDocument(json)

mxd = results.mapDocument

mapping.ExportToPDF(mxd, r"c:\temp\export.pdf")

Here we created a new map object from a JSON string input and dumped it out to a PDF. (JSON not included here)

ConvertWebMapToMapDocument() has some other very interesting functions/properties. It can incorporate existing map document templates, and even extract Point, Lines and Polygon graphics to feature classes when passed as JSON to the function.

You can find more about ConvertWebMapToMapDocument here: http://resources.arcgis.com/en/help/main/10.1/index.html#//00s30000006n000000. In addition to the function you can also find examples of web map JSON so you can quickly start playing around with the functions.

Please support this idea of having GUI designer in python built in with python add-ins.

It can be found here. (direct link: http://ideas.arcgis.com/ideaView?id=087E00000004SmHIAU)

Enjoy

Great Learning Python Resource

2013-04-08T05:00:00.000-07:00

Hey Everyone,

The Internet is filled with great resources for learning programming, almost too much, but here is a great resource: http://learnpythonthehardway.org/book/

This site hosts a e-book called 'Learn Python The Hard Way' and I highly recommend if you are starting out programming, or want to just a refresher course on python that you take a look.

There are also courses on C, CLI, SQL, Ruby, and Regex.

You might learn something new, so give it a try.

As always, I encourage my reader to please support my idea on the ArcGIS Ideas Site to allow GUI integration with ArcPy. Please vote it up here: http://ideas.arcgis.com/ideaView?id=087E00000004SmHIAU

Enjoy

Support GUI Design in ArcGIS for Desktop

2013-03-28T06:00:00.000-07:00

Please support this idea of having GUI designer in python built in with python add-ins.

It can be found here: http://ideas.arcgis.com/ideaView?id=087E00000004SmHIAU

Thanks everyone.

Creating Data Frame Extents (ArcPy 10.1)

2013-03-27T05:00:00.000-07:00

I read your comments, and thank you for posting them. I was asked how do you clip all layers in a map document by the current data frame's extent.

In a previous post, I discussed how to create extent polygons for feature classes and individual features. The same method applies for creating an extent polygon using data frames.

The data frame object has a whole host of properties and methods which can be found here. To get the extent of a data frame, just reference the extent property to obtain the data frame's current extent. Create the extent polygon or feature class, and clip by the extent geometry.

# Clip layers by extent of data frame (assuming in arcmap session)
import os
import arcpy
from arcpy import env
from arcpy import mapping
mxd = mapping.MapDocument("CURRENT")
df = mxd.activeDataFrame
extent = df.extent

array = arcpy.Array()
array.add(extent.lowerLeft)
array.add(extent.lowerRight)
array.add(extent.upperRight)
array.add(extent.upperLeft)
array.add(extent.lowerLeft)
polygon = arcpy.Polygon(array, df.spatialReference)
array.removeAll()
del array
for layer in mapping.ListLayers(mxd, data_frame=df):
    clipped_fc = env.scratchGDB + os.sep + layer.datasetName + "_clipped"
    arcpy.Clip_analysis(in_features=layer, 
                        clip_features=polygon,
                        out_feature_class=clipped_fc)
    del layer
del mxd
del df
del extent

This code is just a quick re-hash of old concepts applied to a new method. The extent object creates a polygon, which is used to clip the layers in that data frame.

ArcGIS for Developers

2013-03-22T13:45:00.001-07:00

Today I noticed a new site from Esri, and it's called 'ArcGIS for Developers'. This website consolidates the web, mobile, and introduces some new desktop APIs.

The one that really excites me is the Qt API because I'm a fan of C++. I also introduces the new approach to open for Esri by using GitHub for code sharing. I've only started playing, but I'm excited to see what comes.

Check it out here: http://developers.arcgis.com/en/

Happy coding.

The random Module (python)

2013-03-13T05:00:00.000-07:00

The random module is pseudo-random number generator. This means that's truly not random, but close enough.

You should seed, initialize the generator with either a value, or with the system time (default value).

Example:

>>> import random
>>> random.seed()
>>> print random.random()
0.884447776659
>>> print random.random()
0.379767969805
>>> print random.random()
0.580327390006

Random also has the ability to pick from ranges and collection of elements, like letter:

>>> random.randrange(start=0, stop=101, step=1)
52

>>> random.choice('abcdefghij')
'b'

Happy Randomness.

ArcGIS Server and Spatial Analyst

2013-02-26T03:55:00.003-08:00

In ArcGIS 10.0, you needed to worry about path length for raster operations if the raster path plus file name is over 154 characters. Now at 10.1, the character length has been increased to 254. This means for most raster operations you will not have to alter the TEMP variable for the ArcGIS account.

If you do run into issues where spatial analyst or 3D analyst tools fail on server, but work on desktop in your model, try changing the ArcGIS account's TEMP environmental parameter to a different folder.

A good example would be c:\serverwrksp. You also should make sure that the ArcGIS account has read/write access to that folder.

To shorten or change the path that server uses, you need to modify the ArcGIS account's TEMP variable. Server should then honor the new destination path. You might have to either log in and log off or reboot the box to get the OS to honor the new variable.

Here is how you change the variable in Windows:
To view or change environment variables:

Right-click My Computer, and then click Properties.
Click the Advanced tab.
Click Environment variables.
Click one the following options, for either a user or a system variable:
- Click New to add a new variable name and value.
- Click an existing variable, and then click Edit to change its name or value.
- Click an existing variable, and then click Delete to remove it.

Please support my idea of having a python GUI by voting it up here.

Enjoy

Creating a List with n number of entries (Python)

2013-02-22T04:59:00.000-08:00

Normally when you create a list object in python, you cannot specify the number of items in the object by default unlike say an array object in C# or C++. I recently ran into a situation where I was using the arcpy.da cursor objects for table that could have n number of fields. I wanted the row to be initialized with a default value, so I used the * operator on the list to multiply a single value into a multi-value list.

Example:

# Get a list of fields that are not BLOB, OBJECTID, RASTER, GEOMETRY or GUID
fields = [field.name for field in arcpy.ListFields(service_table) \
                  if not(field.type.upper() in ['BLOB', 'OID', 'RASTER','GEOMETRY','GUID'])
# create a row list with default values
row = [""]* len(fields)

This will create a list object called row, where each value by default is an empty string ("").

Enjoy

Query Feature Service By Object IDs (Python)

2013-02-21T04:30:00.000-08:00

To query a feature service using object ids, you need to perform a POST. For those who don't know the difference between a "GET" and "POST" here is a quick blurb based on the HTML specifications:

"POST" means that former means that form data is to be encoded (by a browser) into a URL while the "GET" means that the form data is to appear within a message body.

Even simpler, "GET" is basically for just getting data where a "POST" may involve anything, like updating data, sending, or creating data.

Using python, you can perform both "GET" and "POST" methods, but since we need a "POST" to query by IDs, here is a simple example. Please note that most feature services limit 1000 features being returned, so if you want to grab all of the features from a feature service, you'll have to perform multiple queries to get all the features back in JSON format.

Example:

import urllib2
import urllib
import urlparse
import httplib

def query_by_objectid(url, objectIDStart=0, objectIDEnd=1001):
    """ performs a POST operation where the query is called using
        the object id method.  If a feature service has more than
        1000 records, use this method to get a range of features
        from the feature service.

        Inputs:
           :url:  - string of feature service URL
           :objectIDStart: - integer of the start whole number
           :objectIDEnd: - end range whole number
        Returns:
           returns string JSON of query
    """
    url = url + '/query'
    start = int(objectIDStart)
    end = int(objectIDEnd)

    objectIDs = ",".join([str(x) for x in range(start, end)])
    headers = {"Content-type": "application/x-www-form-urlencoded",
               "Accept": "text/plain"}
    parameters = {'objectIds' : objectIDs,
                  'f' : 'json'}
    urlparams = urllib.urlencode(parameters)
    parts = urlparse.urlparse(url)
    h = httplib.HTTPConnection(parts.netloc)
    headers = {"Content-type": "application/x-www-form-urlencoded", "Accept": "text/plain"}
    h.request('POST', parts.path, urlparams, headers)
    r = h.getresponse()
    return r.read()

if __name__ == "__main__":
    url = 'http://sampleserver1.arcgisonline.com/ArcGIS/rest/services/TaxParcel/AssessorsLiveLayers/MapServer/1'
    print query_by_objectid(url=url,
                            objectIDStart=0,
                            objectIDEnd=5)

So we have a simple "POST" example. This sample should work with both ArcGIS Server 10.1 and ArcGIS Online feature services.

Please support my idea of having a python GUI by voting it up here.

Enjoy

Creating an Map Document From Python (10.1)

2013-02-14T17:45:00.000-08:00

Previous posts, I have discussed ways to create map service layers from scratch, and now I'm going to show you how to create a blank map document using the 'ConvertWebMapToMapDocument' tool in ArcToolbox. The beauty of this tool is that it doesn't have to be run on server, but can be run from desktop. It uses JSON based on the ExportWebMap specification.

A JSON map consists of the following:

{ 
   "mapOptions": {}, 
   "operationalLayers": [], 
   "baseMap": [], 
   "exportOptions": {}, 
   "layoutOptions": {} 
}

import json
from arcpy import mapping
mapService = {} 
jsonDump = json.dumps(mapService) 
result = mapping.ConvertWebMapToMapDocument(jsonDump)
mxd = result.mapDocument
mxd.saveACopy(r"c:\temp\blank.mxd")

Now you can do whatever you need to do with your map document.

wx GUI Article for ArcGIS

2013-02-13T03:37:00.003-08:00

Here is an interesting article on how to create an interactive GUI for ArcGIS 10.1.

Basically what it does is it creates the form before ArcMap/Catalog finishes loading therefore the core software doesn't prevent the mainloop() to fail. At least that's my take on it.

If you think custom GUIs should be part of the next major release, I suggest you go to the Esri Idea site and vote up this idea. It will need YOUR support to get into the next release.

Happy GUI designing!

Convert Table or Feature class to CSV (10.1)

2013-02-04T04:01:00.000-08:00

Sometimes you need to export data from a feature class or table to a CSV file. CSV stands for comma separated values. Wikipedia defines a CSV file as such:

A comma-separated values (CSV) file stores tabular data (numbers and text) in plain-text form. Plain text means that the file is a sequence of characters, with no data that has to be interpreted instead, as binary numbers. A CSV file consists of any number of records, separated by line breaks of some kind; each record consists of fields, separated by some other character or string, most commonly a literal comma or tab. Usually, all records have an identical sequence of fields.

To create a CSV file at 10.1, you need to strip out certain field types: Geometry, Blob and Raster because the file format only supports plain text. This can be done by doing the following:


 fieldnames = [f.name for f in desc.fields if f.type not in ["Geometry", "Raster", "Blob"]]

Next you need to write the field names and rows to a file. This is extremely easy with the CSV library in python. Documentation about this standard library can be found here.

def get_rows(data_set, fields):
   with da.SearchCursor(data_set, fields) as cursor:
      for row in cursor:
         yield row
if __name__ == "__main__":
   data_set = arcpy.GetParameterAsText(0) # feature class/Table
   output = arcpy.GetParameterAsText(1) # csv file
   desc = arcpy.Describe(data_set)
   fieldnames = [f.name for f in desc.fields if f.type not in ["Geometry", "Raster", "Blob"]]
   rows = get_rows(data_set, fieldnames)
   with open(output,'wb') as out_file:
      out_writer = csv.writer(out_file)
      out_writer.writerow(fieldnames)
      for row in rows:
         out_writer.writerow(row)

Here we have a function called get_rows() which takes two parameters. The first is the data_set, which can be a table or feature class. The next is the fields. At 10.1, you must define your fields unlike the 10.0 cursor objects. The function uses the yield, which is a generator. Basically the code only runs if the function is called in a loop (I know that's not 100% correct), but here is a better explanation. Using the CSV module in python, we can then easily write out each row within the rows generator object.

FYI, this is written so you can put this code into a script and toolbox for ArcGIS 10.1. Just add the imports.

Enjoy

10.1 SP 1 32 bit vs 64 bit

2013-01-18T05:00:00.000-08:00

I ran across an interesting forum posting about the differences of 32 vs 64 bit python.

Check it out here: http://forums.arcgis.com/threads/70241-10.1-sp-1-and-32-64-bit-Python-versions

It's worth a good read to understand if you install the 64-bit background processor provided at SP 1 how it operates and works on your machine.

Remember if you do install the 64-bit version of python, you will have to install the 64-bit of all your extensions as well.

Enjoy

ArcPy 10.1 - Multiple Data Frames and Data Driven Pages

2013-01-03T04:15:00.000-08:00

Data driven pages is a great way to automate map production over a given area, and it works right out of the box with a single data frame. If you have 2 or more data frames though, you will need to control the movement of each data frame object by performing some sort of coding (ArcObjects or ArcPy).

A simple way to move multiple data frames is to:

Get a list of all data frames
Identify the parent data frame
Move the extents of the other data frame

Sounds simple? Well it is.

To get started, get a reference to the map document


mxd = arcpy.mapping.MapDocument("CURRENT")

Change "CURRENT" to a path if not run in ArcMap. Then list all the data frames


dfs = arcpy.mapping.ListDataFrames(mxd)

Now how do you know what data frame is the parent data frame or what data frame is a child data frame? Luckily at 10.1, the data driven page object provides a property called dataFrame, which returns the DataFrame object. At 10.0, you would either use names or indexing values to determine which is the parent or not, but this example is for 10.1.


ddp = mxd.dataDrivePages

parentDF = ddp.dataFrame

Next step is to pan the other data frames to the extent of the parent data frame's extent.


for pageNum in range(1, ddp.pageCount + 1):


   for df in dfs:

ddp.currentPageID = pageNum



      row = ddp.pageRow

      extent = row.Shape.extent

      if (df.name == parentDF.name) and (df.scale == parentDF.scale):

         print 'I found the parent frame'

      else:

         df.panToExtent(extent)

   arcpy.mapping.ExportToPNG(mxd, r"C:\Project\OutPut\ParcelAtlas_" + str(pageNum) + ".png")

Here we have a bunch of code that loops through each data driven page area and then modifies each underlying data frame that isn't the parent. After the data frames are changes, the code then exports the maps to PNG to the '...\output' folder with reference to the page number.

Enjoy

Using env.addOutputsToMap

2012-12-18T04:03:00.000-08:00

The environmental variable addOutputsToMap prevents geoprocessing task results from being displayed in the TOC. This environmental property by default is set to true, so every tool's result will display in the table of contents in ArcMap.

When developing python add-ins, you should utilize this tool to prevent sub-processes results from being added to the map. A good example of this, is if your python add-in creates a table if it doesn't exist for logging purposes. Your end user does not want to see this table, or know it exists, but if addOutputsToMap is set to true, the value will display in the table of contents. Changing it to false would prevent the data from showing.

Example:


from arcpy import env

env.addOutputsToMap = false
#... perform GP task...

env.addOutputsToMap = true

Enjoy

Finding Distance Along A Line

2012-12-17T04:00:00.000-08:00

The arcpy polyline geometry object has a very helpful method called positionAlongLine (value, {use_percentage}). This function finds either a distance (in the feature's coordinate system) or the percentage from the line's starting location. It then returns a PointGeometry object that can be used for further analysis, or that can be saved out as a feature class using the CopyFeatures tool. If you use the optional use_percentages, false means it's a distance, true means it is a percentage with values between 1-100. If a value is great than the length or over 100 % then the last point is used. If values are less than 0 or less than 0% then the first point is used as well.

Assuming you have a line feature class, just create a search cursor and begin accessing your locations.


fc = r"c:\temp\lines.shp"

with da.SearchCursor(fc, ["SHAPE@"] as cursor:
for row in cursor:

       print row[0].positionAlongLine(10, True)

    
       print row[0].positionAlongLine(10, False)

Enjoy

Finding and Changing Max Value in Numpy Array

2012-12-12T04:00:00.000-08:00

Today, I answered a forum question about finding and changing a numpy array. You can use the max() and the where() in the numpy to search for values in your array and change them using loops.

You can download a very simple example here.

Here is the simple code:

import numpy
myarray = numpy.array([[  5.4,   7.5,   2.2,   8.5,   8.6,   7.5],
                       [  7.7,   3.5,   1.4,   9.6,   8.5,   5.5],
                       [  5.2,   6.1,   8.6,   6.7,   4.3 ,  6.8],
                       [  9.6,   4.5,   2.7,   3.6,   6.7,   4.5],
                       [  1.2,   2.3,   7.2,   6.3,   2.2,   2.0 ],
                       [  1.3,   2.0,  -99.0,    9.6,  -99.0,    1.2]
                       ]
                      )
print myarray
maxValue = myarray.max()

itemindex = numpy.where(myarray >= maxValue)

for i in xrange(0, len(itemindex[0])):
    array1 = itemindex[0]
    array2 = itemindex[1]
    myarray[array1[i]][array2[i]] = 0

print myarray

Here we have the numpy array and find the array's maximum value. Then using the where(), the location in the array are given back. From there, the code then changes the values in the 2-D array from the maximum value back to zero.

Enjoy

ArcPy Sample: Zipping a Shapefile

2012-12-06T04:00:00.000-08:00

I've decided to post full code samples on github. Here is my first sample to zip shapefiles.

Enjoy

AGS 10.1 Quirk with Windows Domain Security

2012-12-04T05:11:00.000-08:00

Today I configured a test machine to use windows domain accounts at the GIS tier for security. When I went to connect to the site using catalog, I noticed that if I included the '\' (backslash) in the user name it could not connect. After removing the backslash, the connection worked.

This means that if your user is 'domainname\name' you would use just the 'name' in the AGS connection string.

Truncate Table, A New Way To Erase Rows

2012-12-03T04:00:00.000-08:00

Truncate table is the 10.1 way to erase ALL the rows in a table or feature class. It will ignore any sql query, so use this tool carefully.

Some Notes:

Supported data types are simple, meaning no terrains, topologies, etc..
Data must be unversioned to execute
After rows are removed, the data is unrecoverable, so make sure you know what you are doing before you go and use this.

This is a good tool for workflows where you need to clear out rows on some regular basis.

Usage Example:


import arcpy

from arcpy import env

wrksp = r"c:\temp\data.gdb"

env.workspace = wrksp

fcs = arcpy.ListFeatureClasses()

for fc in fcs:

   arcpy.TruncateTable_management(fc)

del fcs

Enjoy

Walk, new arcpy.da function as 10.1 SP1

2012-11-29T04:00:00.000-08:00

Walk is a useful function that walks directories. Though this is an easy function to create using recursion, it is now including as a core function at 10.1 SP1 for arcpy.

The help describes the function as such:

Generate data names in a catalog tree by walking the tree top-down or bottom-up. Each directory/workspace in the tree yields a tuple of three: dirpath, dirnames, and filenames. Python's os module includes an os.walk function that can be used to walk through a directory tree and find data. os.walk is file based and does not recognize database contents such as geodatabase feature classes, tables, or rasters. arcpy.da.Walk can be used to catalog data.

Example:


import arcpy

import os

workspace = "c:/data"

feature_classes = []

for dirpath, dirnames, filenames in arcpy.da.Walk(workspace,

                                                  datatype="FeatureClass",

                                                  type="Polygon"):

    for filename in filenames:

        feature_classes.append(os.path.join(dirpath, filename))

Enjoy

Shift Those Polygons at 10.1

2012-11-21T04:53:00.000-08:00

The arcpy team at Esri has a great blog post that shows how to shift polygons using the SHAPE@XY tag.
Here is the sample:

with arcpy.da.UpdateCursor(in_features, ['SHAPE@XY']) as cursor:
        for row in cursor:
            cursor.updateRow([[row[0][0] + (x_shift or 0),
                               row[0][1] + (y_shift or 0)]])

Here we have the shape column (column 0) and to access the X and Y property, you just edit the first and second objects in the X,Y pair. The x_shift and y_shift are float values that will move the code in one direction or another.

It's very simple sample, but it shows how you can easily move polygons. In the past you had to adjust each vertex, but now this is done internally thanks to the new arcpy.da module at 10.1.