J'ai une liste liée, dans laquelle chaque nœud contient les données du cercle (couleur, rayon). J'ai une classe 'forme' qui a
(i) init fort>: pour initialiser la Circle_List. P> (ii) get_circle_list (): qui retourne la Circle_List P > (iii) insertion_circle (new_circle): qui insère le nouveau nœud à la position de la tête de la Circle_List. p> La fonction Par exemple, le nouveau nœud que je veux insérer dans la position de la tête est ("bleu", 6), puis l'insertion_circle (New_circle) l'insère correctement à la position de la tête. Mais lorsque j'essaie d'imprimer une forme.get_circle_list (). Affichage (), la même ancienne old Circle_list est imprimée. P> PS: Ne confondez pas ce code pour une liste liée à la circulaire, que ce n'est pas. Il s'agit d'une liste liée qui comporte des nœuds représentant les fonctionnalités d'un cercle et la liste est désignée avec le nom Circle_List. P> class Node:
def __init__(self,data):
self.__data=data
self.__next=None
def get_data(self):
return self.__data
def set_data(self,data):
self.__data=data
def get_next(self):
return self.__next
def set_next(self,next_node):
self.__next=next_node
class LinkedList:
def __init__(self):
self.__head=None
self.__tail=None
def get_head(self):
return self.__head
def get_tail(self):
return self.__tail
def add(self,data):
new_node=Node(data)
if(self.__head is None):
self.__head=self.__tail=new_node
else:
self.__tail.set_next(new_node)
self.__tail=new_node
def insert(self,data,data_before):
new_node=Node(data)
if(data_before==None):
new_node.set_next(self.__head)
self.__head=new_node
if(new_node.get_next()==None):
self.__tail=new_node
else:
node_before=self.find_node(data_before)
if(node_before is not None):
new_node.set_next(node_before.get_next())
node_before.set_next(new_node)
if(new_node.get_next() is None):
self.__tail=new_node
else:
print(data_before,"is not present in the Linked list")
def display(self):
temp=self.__head
while(temp is not None):
print(temp.get_data())
temp=temp.get_next()
class Circle:
def __init__(self, color,radius):
self.__color=color
self.__radius=radius
def __str__(self):
return (self.__color+" "+str(self.__radius))
def get_color(self):
return self.__color
def get_radius(self):
return self.__radius
class Shape:
def __init__(self,circle_list):
self.__circle_list=circle_list
#Here is where the problem occurs
def get_circle_list(self):
return self.__circle_list
def insert_circle(self,new_circle):
newNode=Node(new_circle)
newNode.set_next(self.__circle_list.get_head())
self.__circle_list.__head=newNode
circle1=Circle("Red",4)
circle2=Circle("Green",5)
circle3=Circle("Purple",3.5)
new_circle=Circle("Blue",6)
circle_list=LinkedList()
circle_list.add(circle1)
circle_list.add(circle2)
circle_list.add(circle3)
shape=Shape(circle_list)
shape.insert_circle(new_circle)
#prints the same old circle_list here
shape.get_circle_list().display()
3 Réponses :
Ceci est dû au fait que vous utilisez des noms d'attribut commençant par deux souligneurs, tels que Utilisez un seul soulignement ou aucun, et vous devriez aller bien. P> __ tête code> et
__ cercle_list code> et Python a des règles spéciales pour ces noms. P >
L'interpréteur Python remplace le nom des membres de la classe commençant par Dans votre cas, l'attribut Lorsque vous appelez la méthode Vous pouvez ajouter un __ code> (double trait de soulignement) à _ClassName__Membername comme moyen de vous assurer que ce nom ne se chevauchra pas avec un nom similaire dans une autre classe.
__ tête code> est interprété comme
_linkedlist__head code>. P>
insertion_circle code> .__ Circle_List .__ Head = Newnode code> Création d'un nouvel attribut code> __ de la tête code> __, pas de réaffectation
_Linkedlist__head code>. p>
set_head Code> Méthode à votre
LinkedList CODE> P>
def insert_circle(self,new_circle):
newNode=Node(new_circle)
newNode.set_next(self.__circle_list.get_head())
self.__circle_list._LinkedList__head=newNode
Utilisez le code ci-dessous pour insérer les données de la position de la tête, pour afficher la liste: p> def get_circle_list(self):
return self.__circle_list