Warum erhalte ich einen Listenindex außerhalb des Bereichsfehlers?

Question

Ich bin mir nicht sicher, warum ich die folgende Störung erhalte:

builtins.IndexError: list index out of range 

in der folgenden Zeile (Zeile 5):

C[A[key(a)]] == C[A[key(a)]] + 1 

Ein Beispiel für Eingabe für diesen Code A = [2, -2, 1] sein würde und key = lambda x: x**2 und in der Schleife auf Linie 4-5, nimmt es die Taste der Ziffer an A[a] als den gewählten Index für Array C und inkrementiert den Wert an diesem Index von 1. Zum Beispiel: C[A[key(0)]] oder C[4] ist 0, und es wird auf 1 erhöht.

def key_positions(A, key): 
    k = key(max(A, key = key)) 
    C = [0] * (k+1) 
    for a in A: 
     C[A[key(a)]] == C[A[key(a)]] + 1 
    for i in range(0, k): 
     sum = C[i] 
    return C 

Answer 1

Sie versuchen Akey(a) als Index in der Liste zu behandeln. Weder a noch key(a) gilt Indizes im Bereich [0, len(A)].

Wenn Sie Vorkommen von key(a), genau das direkt als Index in C zählen wollte:

def key_positions(A, key): 
    k = key(max(A, key = key)) 
    C = [0] * (k+1) 
    for a in A: 
     C[key(a)] += 1 
    for i in range(0, k): 
     sum = C[i] 
    return C 

I verwendet += Augmented Zuordnung hier statt der ausführlicheren C[key(a)] = C[key(a)] + 1; Dies spart die erneute Ausführung der key() Funktion jedes Mal.

den maximalen k Wertes Berechnung ist auch einfacher mit:

k = max(key(a) for a in A) 

Als nächstes Ihre Schleife mit sum = C[i] ist auch unsinnig; Die Schleife ist redundant, da Sie nie sum verwenden und Sie könnten sum = C[-1] für alle die Schleife verwendet haben.

Answer 2

Der Grund dafür ist, dass Sie die Liste A zugreifen = [2, -2, 1] mit einem Index, der außerhalb der Grenzen der Liste A. ist

Für jede Iteration der ersten Schleife für, Sie berechnet das Quadrat von a (durch deinen key lamba) und dies führt zum Indexfehler.

Sie müssen sicherstellen, dass Sie mit Indexwerten die Liste A greifen nicht, die

Zum Beispiel größer als die Größe der A. Liste sind:

for a in A: 
    # key(a) will be 4, 4, 1 
    # but for key(2) it will be 4 
    # and larger than the list A. 
    C[A[key(a)]] == C[A[key(a)]] + 1