Concaténation de listes en python

Bonjour,

Je ne vois pas bien ce que tu cherches dans le fond. "je ne trouve pas ça très satisfaisant." ???

a = ['chat']
b = ['chien']
b += a
a = b
b.append('poisson')

print(a)

On peut utiliser une particularité des listes quand on fait a = b,  a et b en fait ne forment plus qu'une seule liste (elles pointent en mémoire au même endroit). Modifier l'une ou l'autre c'est pareil.

C'est pourquoi quand on veut 2 listes indépendantes, on utilise la méthode copy()

a = b.copy()

Il est vrai que dans ma question j'ai mal exprimé mon problème, je suis désolé.

Dans mon exercice, un groupe d'amis veut aller au cinéma. Mais ce jour-là, à cause d'une grève, tout les cinémas sont fermés. De plus, chaque cinéma a une affiche indiquant l'emplacement d'un autre cinéma où le groupe d'amis peut se rendre.

Le programme est censé recevoir une liste de taille n où l'emplacement d'un cinéma est son index dans la liste et le cinéma vers le quel il redirige est donné par sa valeur. Par exemple, avec la liste [2, 3, 1] :

• le premier cinéma redirige vers le deuxième,
• le deuxième redirige vers le troisième,
• et le troisième redirige vers le premier.

Le programme est censé renvoyer pour chaque cinéma tout les cinémas qui ont été visités avant de retourner sur un cinéma qui a déjà été visité.

Avec un programme avec deux boucles emboitées, ce serait simple mais trop complexe algorithmiquement.

Pour que la liste ne soit parcourue qu'une seule fois, j'ai donc créé un dictionnaire.

Admettons que l'on commence avec le premier cinéma  : 

dico = {}
redirection = [# redirection des cinéma ici]
s = 1 #le premier cinéma
dico[s] = [s]
dico[redirection(s)] = [redirection(s)]
dico[s] += dico[redirection(s)]

dico[redirection(redirection(s))] = [redirection(redirection(s))]
dico[redirection(s)] += dico[redirection(redirection(s))]

... # jusqu'à que l'on arrive sur un cinéma où l'on est déjà passé


# de cette façon j'aimerais que dico[s] renvoie tout les cinémas qui ont été parcouru.

"tout les cinémas sont fermés," donc l'exercice est résolu, je reste chez moi devant la TV ;-)

tu devrais reposer une nouvelle question avec le bon sujet dès le départ, et terminer celle ci. La question d'origine est trompeuse. D'ailleurs, liste et dictionnaire fonctionnent différemment.

En fait, pourquoi ne trouves pas cela satisfaisant d'utiliser a += [b] ?

Bonjour,

Dans ta question initiale #0, il y a une confusion entre référence et copie d'objet en mémoire. En écrivant a += b, tu recopies le contenue de b dans a, et donc les modifications futures de b n'ont pas d'impact sur le contenu de a. À moins d'avoir une structure qui maintient un ensemble de listes et qui itère sur chacune d'elle (e.g. avec itertools.chain) tu ne peux pas y faire grand chose.

Dans ton exercice complètement formulé #2, on voit de toute façon que ça n'est pas vraiment la bonne approche. Dans ton exercice, tu peux voir chaque cinéma comme le sommet d'un graphe orienté et chaque redirection comme un arc qui connecte le sommet vers le cinéma de secours. Par exemple, ton exemple #2 le graphe serait constitué de trois sommets (1, 2 et 3) formant un cycle orienté 1 -> 2 -> 3 -> 1. Les algorithme de traversée dans un graphe orienté sont prévus pour fonctionner pour n'importe quelle structure de graphe.

Dès que le graphe peut comporter des boucles ou des cycles (ce qui est ton cas), il faut mémoriser au cours du parcours les sommets déjà traversés et ne pas les réexplorer, sans quoi le programme peut boucler indéfiniment.

Les algorithmes usuels, tels que le BFS ou le DFS, associent pour cela en général à chaque sommet une couleur qui indique son statut (blanc - pas exploré ; gris - en cours d'exploration ; noir complètement exploré). Le vecteur de couleur permet d'une part les boucles infinies au cours de la traversée de graphe, mais également de voir les sommets atteints lors du parcours. En terme de complexité, pour un graphe G(V, E), un tel algorithme s'exécute en O(|V|+|E|) (on visite au plus une fois chaque sommet et chaque arc) et a une empreinte mémoire en O(|V|) (à cause du vecteur de couleur).

Dans ton cas, on peut simplifier l'algorithme car on sait que la liste est finie, supposée valide (tout identifiant inclus dedans correspond à un cinéma) et donc forme nécessairement un cycle quelque soit le cinéma de départ. De plus, au lieu d'utiliser une vecteur de couleur, on peut directement mémoriser l'ensemble des sommets visités et interrompre l'exploration dès que l'on revisite un sommet déjà découvert.

Programme :

def list_visited(redirections, current) -> set:
    visited = set()
    while current not in visited:
        visited.add(current)
        current = redirections[current]
    return visited

n = 6
redirections = [1, 2, 0, 3, 5, 4]
assert set(redirections) == {i for i in range(n)}
for start in range(n):
    visited = list_visited(redirections, start)
    print(f"start = {start} visited = {visited}")

Résultat :

start = 0 visited = {0, 1, 2}
start = 1 visited = {0, 1, 2}
start = 2 visited = {0, 1, 2}
start = 3 visited = {3}
start = 4 visited = {4, 5}
start = 5 visited = {4, 5}

Bonne chance