riga 60, in make_tuple return tuple (l) TypeError: iter() ha restituito non iteratore di tipo 'Vector'

Question

Sono nuovo per i vettori e classi di creazione. Sto cercando di costruire la mia classe Vector, ma quando mi passa attraverso il mio codice che è:

posizione + = rubrica * distance_moved

dove la posizione e la direzione sono entrambi i vettori. l'intestazione è normalizzata. il mio obiettivo è ripetere il mio codice fino alla posizione = destinazione. Cosa c'è di sbagliato in questa classe?

import math

class Vector(object): 
    #defaults are set at 0.0 for x and y 
    def __init__(self, x=0.0, y=0.0): 
     self.x = x 
     self.y = y 

    #allows us to return a string for print 
    def __str__(self): 
     return "(%s, %s)"%(self.x, self.y) 

    # from_points generates a vector between 2 pairs of (x,y) coordinates 
    @classmethod 
    def from_points(cls, P1, P2): 
     return cls(P2[0] - P1[0], P2[1] - P1[1]) 

    #calculate magnitude(distance of the line from points a to points b 
    def get_magnitude(self): 
     return math.sqrt(self.x**2+self.y**2) 

    #normalizes the vector (divides it by a magnitude and finds the direction) 
    def normalize(self): 
     magnitude = self.get_magnitude() 
     self.x/= magnitude 
     self.y/= magnitude 

    #adds two vectors and returns the results(a new line from start of line ab to end of line bc) 
    def __add__(self, rhs): 
     return Vector(self.x +rhs.x, self.y+rhs.y) 

    #subtracts two vectors 
    def __sub__(self, rhs): 
     return Vector(self.x - rhs.x, self.y-rhs.y) 

    #negates or returns a vector back in the opposite direction 
    def __neg__(self): 
     return Vector(-self.x, -self.y) 

    #multiply the vector (scales its size) multiplying by negative reverses the direction 
    def __mul__(self, scalar): 
     return Vector(self.x*scalar, self.y*scalar) 

    #divides the vector (scales its size down) 
    def __div__(self, scalar): 
     return Vector(self.x/scalar, self.y/scalar) 

    #iterator 
    def __iter__(self): 
     return self 

    #next 
    def next(self): 
     self.current += 1 
     return self.current - 1 

    #turns a list into a tuple 
    def make_tuple(l): 
     return tuple(l) 

Answer 1

Il primo argomento che viene passato nella make_tuple è l'istanza Vector (è la stessa self argomento che si mette dappertutto).

Devi passare in quello si vuole trasformare in una tupla, che è probabilmente il vostro coordinate x e y:

def make_tuple(self): 
    return (self.x, self.y) 

Answer 2

Credo che si sta utilizzando python 3.x, perché ho ottenuto un errore simile Sono anche nuovo a fare di classe, ma sarebbe bello condividere quello che ho imparato :)

In 3.x, utilizzare __next__() invece di next() nella definizione delle classi. L'errore non si è verificato dopo averlo rinominato nel codice, ma ho avuto un altro problema, "L'oggetto 'Vector' non ha attributo 'corrente'" :)

Penso che potrebbe essere meglio per voi capire gli iteratori (e classe?) di più. Un esempio semplice è:

class Count: 
    def __init__(self, n): 
     self.max = n 

    def __iter__(self): 
     self.count = 0 
     return self 

    def __next__(self): 
     if self.count == self.max: 
      raise StopIteration 
     self.count += 1 
     return self.count - 1 

if __name__ == '__main__': 
    c = Count(4) 
    for i in c: 
     print(i, end = ',') 

e le uscite sono 0,1,2,3 ,.

Con una classe vettoriale, voglio ripetere i componenti del vettore. Quindi:

def __iter__(self): 
    self.count = 0 
    self.list = [self.x, self.y, self.z] # for three dimension 
    return self 

def __next__(self): 
    if self.count == len(self.list): 
     raise StopIteration 
    self.count += 1 
    return self.list[self.count - 1] 

e l'iteratore emette la sequenza x, y, z.

Si noti che la funzione più importante degli iteratori consiste nel dare la sequenza passo dopo passo senza creare l'intero elenco. Quindi non è una buona idea fare self.list se la sequenza sarà molto lunga. Maggiori dettagli qui: python tutorial