Updating X and Y coordinates with UpdateCursor based on another shapefile using ArcPy?

Question

I have two shapefiles: "broken_cities" and "us_cities." "us_cities" contains point data representing cities in the US, and the x and y coordinates are correct. "broken_cities" contains point data representing 10 cities in the US whose X and Y coordinates are incorrect. There is no X and Y coordinate fields in the attribute table of either.

The goal is to update the broken cities X and Y coordinates using the correct coordinates from "us_cities." I know I should use an update cursor, but I don't know how to combine the search cursor and the update cursor. I am aware that my code does not work at all because I'm not sure of the logic of the workflow.

import arcpy

#set workspace
arcpy.env.workspace= r"Y:\Personal\jsmith\EGData.gdb"

fields=["OID@", "SHAPE@X", "SHAPE@Y"] #tokens to access

#create search cursors to look at values
broken_scur=arcpy.da.SearchCursor("cities_broken",fields)
cities_scur=arcpy.da.SearchCursor("us_cities", fields)

#OIDs of the 10 broken cities
broken_city_OIDs=[66, 68, 61, 74, 86, 80, 116, 94, 96, 97]

for row in cities_scur:
    for row1 in broken_scur:
        if row1[0]==broken_city_OIDs:
            row1[1]==row[1]
            row1[2]==row[2]

Answer 1

If you want to search all of values in a layer with SearchCursor and use the result for updatecursor, use dictionaries instead of nested cursors.

OID is not a good reference to compare two layers. I gave an example and compare city names.You maybe want to use another field (better field).

If you want to update some of features you know them, use where_clause(An optional expression that limits the records returned). For more information about building a where clause, see this link.

There is a good tutorial about using where clause in SearchCursors: Retrieving records using an attribute query.

If you want to learn more about python dictionaries, This tutorial is a good source.

import arcpy
sourceFieldsList = ["CITY_NAME", "SHAPE@X", "SHAPE@Y"]
# Use list comprehension to build a dictionary from a da SearchCursor
valueDict = {r[0]: (r[1:]) for r in arcpy.da.SearchCursor("D://test.gdb//cities", sourceFieldsList)}

updateFC = "cities_1"

updateFieldsList = ["CITY_NAME", "SHAPE@X", "SHAPE@Y"]

with arcpy.da.UpdateCursor("D://test.gdb//cities_1", updateFieldsList) as updateRows:
    for updateRow in updateRows:
        # store the Join value of the row being updated in a keyValue variable
        keyValue = updateRow[0]
        print keyValue
        # verify that the keyValue is in the Dictionary
        if keyValue in valueDict:
            # print keyValue
            # transfer the value stored under the keyValue from the dictionary to the updated field.
            updateRow[1] = valueDict[keyValue][0]
            updateRow[2] = valueDict[keyValue][1]
            updateRows.updateRow(updateRow)

Answer 2

I would do it this way:

import arcpy
arcpy.env.workspace= r"Y:\Personal\jsmith\EGData.gdb"

fields=["OID@", "SHAPE@XY"] #tokens to access
D = arcpy.Describe("us_cities") # describe the US Cities to get the OID field name

with arcpy.da.UpdateCursor("cities_broken",fields) as UCur:
    # get ready to update each row
    for URow in UCur:
        # create a definition query
        dQ = "{} = {}".format(D.OIDFieldName,URow[0])
        with arcpy.da.SearchCursor("us_cities",fields,dQ) as SCur:
            # get the matching feature (if any)
            for SRow in SCur:
                # should only do this once or not at all if the OID isn't found
                URow[1] = SRow[1]
                UCur.updateRow(URow) # Important!! or the changes aren't saved

Your first cursor is an update cursor but the 2nd is a search cursor as you're only looking, not changing any values. Use the power of a definition query (where clause) in the docs to limit the matching row.. that is assuming the OID in broken cities matches the OID in US Cities.

I'm using "SHAPE@XY" but you could also just use "SHAPE@" to copy the geometry; SHAPE@XY is a tuple of (X,Y) but SHAPE@ is a geometry object, still copyable but only to a geometry field.

It's also important that you pick up the difference between assignment (=) and conditional (==). When you say X = 1 now the value of X is equal to 1, but if you say X == 1 then X does not change, it will either be True or False depending on the value of X; python will skip right over this without giving an error and you'll end up going nuts trying to find why X is none when you go to use it later.

By popular demand, a dictionary solution

import arcpy
arcpy.env.workspace= r"Y:\Personal\jsmith\EGData.gdb"

fields=["OID@", "SHAPE@XY"] #tokens to access

broken_city_OIDs=[66, 68, 61, 74, 86, 80, 116, 94, 96, 97]

Dict = {} # new empty dictionary
with arcpy.da.SearchCursor("us_cities",fields) as SCur:
    for SRow in SCur:
        if SRow[0] in broken_city_OIDs:
            Dict[SRow[0]] = SRow[1] # put the geometry tuple in the dictionary indexed by the OID

with arcpy.da.UpdateCursor("cities_broken",fields) as UCur:
    # get ready to update each row
    for URow in UCur:
        if URow[0] in broken_city_OIDs:
            # don't just assume that the key is in the dictionary, check!
            if URow[0] in Dict:
                URow[1]=Dict[URow[0]] # copy the dictionary geometry tuple to the updated row
                UCur.updateRow(URow)  # Important!! or the changes aren't saved

This is far more efficient than the nested loop. The process has two iterations

1. Search through the match 'to' data and copy the necessary values into the dictionary.
2. Update the required features with the in memory copy of the values stored in the dictionary.

Dictionaries are a little more advanced, they are like a list but store the values in a Key:Value pair, where a list is addressed from 0 numerically a dictionary can store keys of any type, you can have keys of strings and numbers in the same dictionary.. the only thing to watch for is that you don't inadvertently overwrite an existing value for a given key, a key must be unique.