Como acessar linhas adjacentes com o cursor?

Na captura de tela em anexo, os atributos contêm dois campos de interesse "a" e "b". Quero escrever um script para acessar as linhas adjacentes para fazer alguns cálculos. Para acessar uma única linha, eu usaria o seguinte UpdateCursor:

fc = r'C:\path\to\fc'

with arcpy.da.UpdateCursor(fc, ["a", "b"]) as cursor:
     for row in cursor:
          # Do something

Por exemplo, com OBJECTID 4, estou interessado em calcular a soma dos valores da linha no campo "a" adjacente à linha OBJECTID 4 (ou seja, 1 + 3) e adicionar esse valor à linha OBJECTID 4 no campo "b". Como acessar linhas adjacentes com o cursor para fazer esse tipo de cálculo?

Se fosse eu, passaria pela tabela uma vez criando um dicionário em que chave é OBJECTID e item é o valor no campo "a". Depois, percorria a tabela com um cursor de atualização, obtendo o OBJECTID e, a partir disso, conseguia obter os valores adjacentes do dicionário, somar e escrevê-los no campo "b".

Mas, na sua captura de tela, há casos especiais para as linhas 3 e 8, pois eles têm apenas uma linha adjacente. O que você pretenderia para isso?

Ao percorrer as linhas, você precisa acompanhar os valores anteriores. Esta é uma maneira de fazer isso:

 previous_value = None
 cursor = arcpy.UpdateCursor(fc, fields, sort_fields)
 for i, in_row in enumerate(cursor):
      current_value = in_row.getValue("ColName")
      if not previous_value: 
           previous_value = current_value 
           continue
       #
       # here you have access to the current and previous value
       #

       previous_value = current_value

ou, se a tabela não for grande, provavelmente criaria um dicionário, como d = {a: b} e, no cursor de atualização, acesse os dados do dicionário: d.get (a + 1) ou d.get (a -1) para fazer as contas ..

Aceitei a resposta de @Hornbydd por me levar a uma solução de dicionário. O script anexado executa as seguintes ações:

1. Passe por um FC e preencha um dicionário com key = OID e value = "MyField" usando um SearchCursor.
2. Iniciar um UpdateCursor
3. Crie lógica para lidar com a primeira e a última linha (ou seja, onde não há linha anterior ou consecutiva)
4. Vincular linha UpdateCursor ao OID do dicionário e valor do campo
5. Faça o processamento ...

import arcpy, collections

fc = r'C:\path\to\fc'

# Populate a dictionary with key = OID and value = "a"
names = collections.defaultdict(list)

for name1, name2 in arcpy.da.SearchCursor(fc, ("OBJECTID", "a")):
    names[name1].append(name2)

# Use .values() class to access adjacent rows

with arcpy.da.UpdateCursor(fc, ["OBJECTID", "a", "b"]) as cursor:
    for row in cursor:
        # Get first and last rows for special processing
        if row[0] == names.keys()[0] or row[0] == names.keys()[-1]:
            """Note that the first and last row will need special rules because
             they cannot reference either the previous or next row.  In this case
             the features are skipped"""
            pass

        else:
            """This needs to be corrected because OID = (row[0] - 1)"""
            # Now link the dictionary names with row[0] (i.e. OBJECTID)
            x = names.values()[row[0] - 2]  # e.g. OID 2 (pre)
            y = names.values()[row[0] - 1]  # e.g. OID 3 (current row)
            z = names.values()[row[0]]      # e.g. OID 4 (post)

            # Now do the calculation
            row[2] = x + z
            cursor.updateRow(row)

O módulo Data Access é bastante rápido e você pode criar a SearchCursorpara salvar todos os valores de 'a' em uma lista e criar um UpdateCursorpara iterar por cada linha e selecionar na lista para atualizar as linhas 'b' necessárias. Dessa forma, você não precisa se preocupar em salvar dados entre linhas =)

Então, algo como isto:

fc = r'C:\path\to\fc'
fields = ["a","b"]
aList = []
index = 0

with arcpy.da.SearchCursor(fc,fields) as cursor:
     for row in cursor:
         aList.append(row[0])    # This saves each value of 'a'
with arcpy.da.UpdateCursor(fc,fields) as cursor:
     for row in cursor:
         if index-1 > 0 AND index+1 <= len(aList):     # Keeps 'b' null if out of list range 
                                                       # or at end of list
             row[1] = aList[index-1]+aList[index+1]
         index += 1

Essa é uma solução bastante grosseira, mas eu a usei recentemente para solucionar um problema muito semelhante. Se o código não funcionar, espero que ele o coloque no caminho certo!

Editar: Última alteração se instrução de AND para OU Editar2: Alterada novamente. Ahh a pressão do meu primeiro post no StackExchange!

Primeiro você precisa de um cursor de pesquisa; Eu não acho que você pode obter valores com um cursor de atualização. Em cada iteração, use aNext = row.next (). GetValue ('a') para obter o valor da próxima linha.

Para obter o valor da linha anterior, eu configuraria uma variável fora do loop for igual a zero. Isso é atualizado para igualar o valor atual das linhas de 'a'. Você pode acessar essa variável na próxima iteração.

Isso satisfaria sua equação de B = A (rowid-1) + A (rowid + 1)