Comparer un dictionnaire à deux dimensions à un dictionnaire simple

**Amniote** · 23/05/2019, 16h51

Bonjour à tous

Voici un extrait de mon fichier sur lequel je travaille:

HS3ST1 GPC5 0 0 0 0 96 900 387 939
HS3ST1 GPC1 0 0 0 61 96 900 470 948 ---> EXP
HS3ST1 GPC4 0 0 0 0 96 900 462 947
SEMA3F PLXNA4 0 0 0 0 188 600 433 799
SEMA3F PLXNA3 0 0 0 62 188 600 900 965 ---> EXP
SEMA3F PLXNA1 0 0 0 111 188 600 904 968 ---> EXP
SEMA3F NRP1 0 0 0 0 478 800 839 981
SEMA3F PLXNA2 0 0 0 88 188 600 431 809 ---> EXP
CFTR PSMC2 0 0 0 62 59 900 50 905 ---> EXP
CFTR PSMD11 0 0 0 62 103 900 41 908 ---> EXP
CFTR DVL2 0 0 0 62 52 900 514 951 ---> EXP
CFTR CBL 0 0 0 0 379 900 207 946
CFTR PSMD4 0 0 0 0 51 900 87 905
CFTR EGFR 0 0 0 0 51 900 383 936

Voici mon script:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
from collections import defaultdict
Dprot1 = defaultdict(set)
Dprot2 = defaultdict(set)
Dinter = defaultdict(dict)
couple = []
with open("C:/Users/lveillat/Desktop/Données stage/Données/resultats_matrice_avec_scores_sans_localisation.txt","r") as f1:
	for ligne in f1:
		lp = ligne.rstrip('\n').split(" ") 
		if lp[-1] == "EXP": #Si il y a présence d'une coexpression
			prot1 = lp[0] #prot1=la première proteine
			prot2 = lp[1] #prot2=la seconde proteine
			if prot1 not in Dprot1: #Si la prot n'est pas dans mon dico on la rajout (pas de doublons comme ça)
				Dprot1[prot1].add(prot1) 
			if prot2 not in Dprot2: #Idem pour prot 2
				Dprot2[prot2].add(prot2)
			Dinter[prot1][prot2]=1 #Si interaction entre 2 prot on marque 1
	#print (Dinter)
f1.close()
 
for i in Dprot1: #On parcours tout les elements de Dprot2
	for j in Dprot2: #On parcours tout les elements de Dprot2
		if Dinter[i][j]: #Si i=prot1 et j=prot2
			print ("1")
		else:
			print("0")

Prot1 = différents noms de protéines, par exemple:
KDGHZ
DFGF
SDFET
SDGFT
SDDZ
BJJU
DAA
INS
ect ...

Prot2 = identique
KQV
SHYZ
CKZ
YSC5E
2FQT
SGY2
ect…

Dinter [prot1] [prot2] = 1 : A comme première clé une protéine en seconde clé toutes les protéines avec lesquelles elle interagit et en valeur 1. Extrait:

F5': {'SPTBN2': 1, 'ARFGAP1': 1, 'ANK2': 1, 'COPZ2': 1, 'KIF15': 1, 'KIF2B': 1, 'KIF25': 1, 'KDELR2': 1, 'RAB1B': 1, 'TMED10': 1, 'KIF3B': 1, 'GBF1': 1, 'CAPZB': 1, 'KIF3C': 1, 'COPA': 1, 'YKT6': 1, 'COPB1': 1, 'KIF20A': 1, 'RAB1A': 1, 'ACTR1A': 1, 'CAPZA2': 1, 'CAPZA1': 1, 'SPTBN5': 1, 'USO1': 1, 'CENPE': 1, 'KIFC1': 1, 'KIF9': 1, 'ARF1': 1, 'KIF6': 1, 'KIF18B': 1, 'KIF26A': 1, 'KIF5A': 1, 'KIF20B': 1, 'ANK1': 1, 'KIF18A': 1, 'KIF19': 1, 'KIF23': 1, 'BET1': 1, 'KDELR1': 1, 'ANK3': 1, 'SPTBN1': 1, 'KIF5B': 1, 'COPB2': 1, 'KIF11': 1, 'KIF2C': 1, 'ARCN1': 1, 'DYNLL2': 1, 'COPG2': 1, 'KIFC2': 1, 'COPG1': 1, 'KIF26B': 1, 'DYNLL1': 1, 'ARFGAP2': 1, 'KIF2A': 1, 'KIF22': 1, 'KIF12': 1, 'SEC22B': 1, 'ARFGAP3': 1, 'KDELR3': 1, 'KIF3A': 1, 'COPZ1': 1, 'COPE': 1, 'DCTN1': 1}, 'FKBP4': {'HSF1': 1, 'PPP5C': 1, 'ACTR1A': 1, 'HSPA1A': 1, 'PPID': 1, 'HSPA2': 1, 'PTGES3': 1, 'HSP90AA1': 1, 'HSP90AB1': 1, 'STIP1': 1, 'HSPA8': 1, 'EP300': 1, 'FOXA1': 1, 'HSPA1L': 1, 'ESR2': 1, 'MAPK3': 1, 'HSPA1B': 1, 'DCTN1': 1}

Je suis coincé à la fin de mon script (a partir de "for i in Dprot1") , il faudrait que mon algorithme teste toutes les paires de protéines possibles dans mon fichier et qu'il me printe 1 s'il y a une interaction entre les deux protéines ou 0 s'il n'y en a pas.

Pour ce faire, dans les dernières lignes de mon algorithme, je dois comparer la paire i et j, correspondant à toutes les paires de protéines possibles (une paire n'est pas forcément une interaction) à mon dictionnaire Dinter qui contient toutes les interactions possibles. Ainsi si la paire i,j correspond a une paire de protéine dans mon dictionnaire alors il me printe 1 si non, 0.

Malheureusement cela ne fonctionne pas avec mon algorithme, pouvez-vous m'aider?

Je vous remercie

**wiztricks** · 23/05/2019, 17h53

Salut,

Envoyé par Amniote

Malheureusement cela ne fonctionne pas avec mon algorithme, pouvez-vous m'aider?

"ca ne fonctionne" pas mérite d'être précisé par: "çà plante avec le message d'erreur ..." ou "j'obtiens ce résultat alors que j'attendais ceci".

De plus vous ne décrivez pas votre algorithme mais vous montrez juste des lignes de code plutôt bizarre car, à défaut, on ne comprends pas pourquoi elles sont là (et on peut se demander pourquoi est-ce aussi compliqué/codé comme çà).

- W

**Amniote** · 23/05/2019, 18h13

Merci pour votre réponse

je vais essayer d'être plus précis,

Le but de mon algorithme est de créer toutes les chaines d'interactions protéiques possibles à partir de mon fichier d'origine qui indique toutes les interactions entre 2 protéines.

La grande majorité de mes lignes de codes sont commentées pour expliquer ce que je fais.

ensuite voici ce que le print de mon programme génère :

1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
Traceback (most recent call last):
File "C:\Users\Loïs\Desktop\chainesmatrice.py", line 22, in <module>
if Dinter[i][j]: #Si i=prot1 et j=prot2
KeyError: 'HSF1'

J'ai l'impression que mon programme prends en compte que la première protéine, lorsque Prot1 change il y a une erreur.

Au final j'attends dans un premier comme résultat la totalité des paires de protéines possibles avec un 1 à coté de la paire pour indiquer qu'il y a interaction entre ces deux protéines et un 0 pour indiquer qu'il n'y a pas d'interaction entre ces deux protéines.
exemple:

DTDE LGOSJ 1
SDSF GLY 0
DFSDG LDF 0
ZEFIH FJUFG 1
FSDF LJKG 1
ect...

Merci de votre aide

**wiztricks** · 23/05/2019, 18h34

Salut,

Relisez votre code!
Les clefs des dictionnaires Dprot1 et Dprot2 contiennent des noms de protéines.
Avec un x pris dans Dprot1, il y aura toujours un dictionnaire Dinter[x].
Mais tous les y de Dprot2 n'auront pas une clef.
Et si Dinter[x][y] n'existe pas, la punition est "KeyError".

Voilà le côté Python... pour le reste, si vous ne prenez pas le temps d'expliquer ce que vous cherchez à faire et pourquoi vous avez essayé de coder cela comme çà: votre code, c'est juste du charabia que vous seul (peut être) arrivez à comprendre.

- W

**Sve@r** · 23/05/2019, 20h18

Bonjour

Envoyé par Amniote

Comparer un dictionnaire à deux dimensions à un dictionnaire simple

As-tu en tête les manipulations qui permettront (permettraient) de comparer un trucA[x][y] avec un trucB[z] ???

Si encore c'étaient des indices numériques continus ce serait envisageable mais quand "x", "y" et "z" sont des clefs pouvant valoir à peu près n'importe quoi...

**Amniote** · 23/05/2019, 20h21

Bonjour,

malheureusement non, ça fait deux jours que je suis bloqué sur ce script, je ne vois absolument pas comment faire...

**wiztricks** · 23/05/2019, 20h43

Envoyé par Amniote

malheureusement non, ça fait deux jours que je suis bloqué sur ce script, je ne vois absolument pas comment faire...

Parce que vous n'avez pas pris le temps de prendre un papier et un crayon pour définir ce que vous vouliez faire ni commencé à décrire un algorithme (ou les différentes étapes) qui permettrait d'y arriver.
Sinon vous auriez commencer par l'exposer et expliquer comment vous avez essayé de le traduire en Python.
A défaut, vous essayez des trucs qui marchent ou pas sans trop savoir où çà vous mène... Et comme quand on relit votre code, on ne comprend pas trop ce que vous cherchez à faire, c'est difficile de vous aider.

Relisez votre code, au début, il y a Dprot1 = defaultdict(set).
On pourrait imaginez que vous allez construire un dictionnaire où les clefs seraient les 1ères protéines et les valeurs, l'ensemble des protéines associées.
Cela reflèterait les informations tirées du fichiers.
Mais ce n'est pas ce que vous en faites (et on ne peut pas comprendre à quoi servent Dprot2 et Dinter dans ce cas).

- W

**Amniote** · 23/05/2019, 21h17

Je vais essayer alors de bien expliquer l'objectif :

Le fichier de départ (voire extrait dans mon premier message) représente l'intégralité des interactions protèine-proteine chez l'humain. Je dois, avec un script, générer toutes les possibilités de chaînes d'interactions de protéines d'une longueur de 10 protéines (donc une chaine=10 protéines soit 9 interactions).

Par exemple, si P1 interagit avec P4, P5, P6 alors ça nous fait déjà 3 chaînes initiées :
P1 P4
P1 P5
P1 P6

On regarde ensuite avec qui interagit P4 ( supposons P7 et P9), P5 (supposons P10 P11 et P16) et P6 ( supposons P22 et P26)
On obtient donc les chaînes suivantes:

P1 P4 P7
P1 P4 P9
P1 P5 P10
P1 P5 P11
P1 P5 P16
P1 P6 P22
P1 P6 P26

Et ainsi de suite jusqu'à ce la chaîne initiée fasse 10 protéines de long et il faut donc que mon programme me trouves toutes les possibilités de chaînes de 10 protéines.

Je crois que je ne pourrai pas être plus précis ...

A votre avis ma méthode expliquée plus haut (dans mes messages précédents) vous semble elle bonne ?
Voyez vous des méthodes plus simples ou plus rapides peut être ?

Merci

**wiztricks** · 23/05/2019, 22h27

Salut,

Envoyé par Amniote

A votre avis ma méthode expliquée plus haut (dans mes messages précédents) vous semble elle bonne ?

Une méthode (et je vous ai déjà posté çà dans une discussion précédente), c'est décrire la suite d'opération qui va produire un résultat. Et çà commence par une description en français qui raconte:
étape 0: qu'est ce qu'on a, qu'est ce qu'on regarde, qu'est ce qu'on change,...
étape 1: comment se répète l'opération...
...
étape 10: si on y arrive, on a un résultat.
Et en essayant de construire cela, vous allez définir vos structures de données, voir comment elles répondent à vos attentes et surtout les problèmes cachés dans la description du problème qui vont demander des informations complémentaires et des règles d'arbitrage.

Pour l'instant, quand je vois:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
P1 P4 P7
P1 P4 P9
P1 P5 P10
P1 P5 P11
P1 P5 P16
P1 P6 P22
P1 P6 P26

je pense (à priori) "arbre" et "parcours récursif"... Et si on pense "arbre", il faut voir quelle est sa nature avant de se plonger à coder. Mais, si vous ignorez ces techniques, je comprends que çà n'aide pas...

- W

**Sve@r** · 24/05/2019, 19h08

Envoyé par Amniote

Je vais essayer alors de bien expliquer l'objectif :

On demandait plutôt comment vous aviez pensé l'algorithme permettant d'atteindre l'objectif en question. Donc si je comprends bien, on va devoir trouver l'algorithme...

Envoyé par Amniote

Par exemple, si P1 interagit avec P4, P5, P6 alors ça nous fait déjà 3 chaînes initiées :
P1 P4
P1 P5
P1 P6

On regarde ensuite avec qui interagit P4 ( supposons P7 et P9), P5 (supposons P10 P11 et P16) et P6 ( supposons P22 et P26)
On obtient donc les chaînes suivantes:

P1 P4 P7
P1 P4 P9
P1 P5 P10
P1 P5 P11
P1 P5 P16
P1 P6 P22
P1 P6 P26

Et ainsi de suite jusqu'à ce la chaîne initiée fasse 10 protéines de long et il faut donc que mon programme me trouves toutes les possibilités de chaînes de 10 protéines.

wiztricks pense à juste titre arbre. Ok il a à la base tout à fait raison (un arbre permet en effet de tout stocker puis tout restituer à la demande).

Toutefois s'il s'agit juste d'afficher les chaines en one shot, alors on peut s'en passer et simplement utiliser la récursivité.

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#!/usr/bin/env python3
# coding: utf-8
 
data=(
	("P1", "P4"),
	("P1", "P5"),
	("P1", "P6"),
	("P4", "P7"),
	("P4", "P9"),
	("P5", "P10"),
	("P5", "P11"),
	("P5", "P16"),
	("P6", "P22"),
	("P6", "P26"),
	("P9", "P33"),
	("P9", "P55"),
	("P33", "P66"),
)
 
def chaine(data, limit=0):
	def find(d, data, suite, limit):
		suite+=(d,)
		if limit == 0 or len(suite) < limit:
			for d in data:
				if d[0] != suite[-1]: continue
				for f in find(d[1], data, suite, limit): yield f
			# for
		# if
		yield suite
	# find()
	for d in data:
		for f in find(d[1], data, (d[0],), limit): yield f
# chaine()
 
for c in chaine(data, 5):
	print(c)

Pour l'exemple j'affiche des chaines de longueur jusqu'à 5 protéines max. Et si je ne veux que les chaines de longueur 5, me suffit de filtrer en final sur len(c) == 5...

**Amniote** · 13/06/2019, 09h30

Bonjour à tous,

Je suis en train de créer un algorithme qui me permettrai de me trouver toutes les chaines d'interactions de taille 4 dans cet arbre en prenant en compte le fait que nous pouvons remonter dans l'arbre (les interactions sont à double sens) (et on ne peut pas retrouver deux fois le même chiffre dans une chaîne).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
                                 1
                                -  -
                               -     -
                             6       4
                              -        -
                                 -      -
                                     -   9
                                        -   -
                                       -     -
                                     33       66

J'ai réussi a générer les chaines de tailles 4 (voici ce que me trouve actuellement mon algorithme)

1 6 9 66
1 6 9 4
1 6 9 33
1 4 9 6
1 4 9 66
1 4 9 33
4 1 6 9
4 9 6 1
6 1 4 9
6 9 4 1
9 6 1 4
9 4 1 6
33 9 6 1
33 9 4 1
66 9 6 1
66 9 4 1

Cependant il me faudrait aussi les "chaines intermédiaires", c'est a dire les chaines qui sont "bloquées" avant d'atteindre la taille de 4, par exemple :

4-9-33
6-9-33
9-33
9-66
66-9-33
33-9-66
6-9-66
ect...

ça ne doit pas être grand chose à modifier/rajouter, j'ai fait des recherches sur de potentielles fonctions (intertools notamment) permettant cela mais je ne trouve rien qui résolve mon problème...

Voici le fichier sur lequel je travaille:

1 4
1 6
4 9
6 9
9 33
9 66
4 1
6 1
9 4
9 6
33 9
66 9

Voici mon algorithme actuel (je travaille sur des protéines, représentées ici par les chiffres):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
import sys
sys.setrecursionlimit(1000000)
from collections import defaultdict
dd = defaultdict(set)
 
with open ("C:/Users/lveillat/Desktop/Données stage/Fichiers tests/testchaines3.txt","r") as f1:
	for ligne in f1:
		lp = ligne.rstrip('\n').split(" ")
		prot1 = lp[0] #je sélectionne la première protéine de chaques interactions
		prot2 = lp[1] #je sélectionne la seconde protéine de chaques interactions
		dd[prot1].add(prot2) #Je crée mon dictionnaire avec en clé la première prot de l'interaction et en valeurs l'ensembles des prots avec qui elle peut interagir
	print(dd)
 
def chain(maillon, pathway, limite=4): #Je définis une fonction chain(maillon, chaine d'interaction, limite de taille de la chaine)
	next_ = maillon.get(pathway[-1], None) #next_ = On rajoute un maillon à la chaine existante en fonction de la dernière protéine du pathway
 
	if next_ is None or len(pathway) >= limite : #Si il n'y a pas de protéine trouvée interagissant avec la dernière protéine du pathway, ou si la taille dépasse la limite alors on passe a la chaine suivante
		yield pathway #yield est pratique quand on sait que la fonction va retourner de nombreuses valeurs qu?on ne souhaite lire qu?une seule fois (c'est notre cas ici), permet d'économiser de la mémoire.
 
	else: #Si on trouve encore des protéines interagissant  avec la dernière protéine du pathway et si la taille limite n'est pas atteinte,
		for m in next_: # pour une interaction dans l'ensemble des interactions possibles de pathway[-1]
			if m not in pathway:
				yield from chain(maillon, pathway + [m]) #On rajoute une autre prot à la chaine uniquement si la protéine que l'on rajoute n'est pas déjà apparue dans la chaine
 
for k in dd: # Pour chaques prot du dico
	for z in chain(dd, pathway = [k]): #Pour chaques chaines
		print (' '.join(z))

et voici ma sortie actuelle :

defaultdict(<class 'set'>, {'1': {'6', '4'}, '4': {'1', '9'}, '6': {'1', '9'}, '9': {'6', '66', '4', '33'}, '33': {'9'}, '66': {'9'}})
1 6 9 66
1 6 9 4
1 6 9 33
1 4 9 6
1 4 9 66
1 4 9 33
4 1 6 9
4 9 6 1
6 1 4 9
6 9 4 1
9 6 1 4
9 4 1 6
33 9 6 1
33 9 4 1
66 9 6 1
66 9 4 1

Merci de votre aide

**wiztricks** · 13/06/2019, 10h02

Salut,

Envoyé par Amniote

Cependant il me faudrait aussi les "chaines intermédiaires", c'est a dire les chaines qui sont "bloquées" avant d'atteindre la taille de 4, par exemple :

4-9-33
6-9-33
9-33
9-66
66-9-33
33-9-66
6-9-66
ect...

Ces chaînes là ne sont pas bloquées, elles commencent par... et ont une longueur inférieure aux conditions que vous avez fixé: il suffit de changer ces conditions.
Ce que vous avez déjà dans les versions d'algo. qui vous ont déjà été proposées au début de cette longue discussion notamment par VinsS.

- W

**Amniote** · 13/06/2019, 15h41

Envoyé par wiztricks

Salut,

Ces chaînes là ne sont pas bloquées, elles commencent par... et ont une longueur inférieure aux conditions que vous avez fixé: il suffit de changer ces conditions.
Ce que vous avez déjà dans les versions d'algo. qui vous ont déjà été proposées au début de cette longue discussion notamment par VinsS.

- W

Etes vous sur qu'elles ne sont pas bloquées ? Si je prends 4-9-33 et que je ne l'autorise pas à reprendre un chiffre déjà utilisé, alors elle doit bien s'arréter là non ?

Je cherche depuis hier une solution et je ne trouve toujours pas

Je suis sur cette idée actuellement (ligne 21 à 26) mais je ne sais pas du tout si je vais dans la bonne direction...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
import sys
sys.setrecursionlimit(1000000)
from collections import defaultdict
dd = defaultdict(set)
 
with open ("C:/Users/lveillat/Desktop/Données stage/Fichiers tests/testchaines3.txt","r") as f1:
	for ligne in f1:
		lp = ligne.rstrip('\n').split(" ")
		prot1 = lp[0] #je sélectionne la première protéine de chaques interactions
		prot2 = lp[1] #je sélectionne la seconde protéine de chaques interactions
		dd[prot1].add(prot2) #Je crée mon dictionnaire avec en clé la première prot de l'interaction et en valeurs l'ensembles des prots avec qui elle peut interagir
	print(dd)
 
def chain(maillon, pathway, limite=4): #Je définis une fonction chain(maillon, chaine d'interaction, limite de taille de la chaine)
	next_ = maillon.get(pathway[-1], None) #next_ = On rajoute un maillon à la chaine existante en fonction de la dernière protéine du pathway
 
	if next_ is None or len(pathway) >= limite : #Si il n'y a pas de protéine trouvée interagissant avec la dernière protéine du pathway, ou si la taille dépasse la limite alors on passe a la chaine suivante
		yield pathway #yield est pratique quand on sait que la fonction va retourner de nombreuses valeurs qu?on ne souhaite lire qu?une seule fois (c'est notre cas ici), permet d'économiser de la mémoire.
 
	if len(pathway) < limite  : #Si on trouve encore des protéines interagissant  avec la dernière protéine du pathway et si la taille limite n'est pas atteinte,
		for m in next_: # pour une interaction dans l'ensemble des interactions possibles de pathway[-1]
			if m not in pathway:
				yield from chain(maillon, pathway + [m]) #On rajoute une autre prot à la chaine uniquement si la protéine que l'on rajoute n'est pas déjà apparue dans la chaine
			Si m apparait déja dans le pathway[-1] et que les autres 'm' ont déjà été utilisés alors: 
				yield pathway
 
for k in dd: # Pour chaques prot du dico
	for z in chain(dd, pathway = [k]): #Pour chaques chaines
		print (' '.join(z))

**wiztricks** · 13/06/2019, 18h35

Envoyé par Amniote

Etes vous sur qu'elles ne sont pas bloquées ? Si je prends 4-9-33 et que je ne l'autorise pas à reprendre un chiffre déjà utilisé, alors elle doit bien s'arréter là non ?

Ça n'en fait rien car 33 est connecté à 9.
Donc ligne 18, next_ n'est pas vide et la longueur de 4-9-33 est inférieure à 4...
Et donc on continue pour arriver ligne 23 où 9 étant déjà dans le chemin...

Si tout cela n'est pas logique pour vous, çà se comprends très bien: c'est de la programmation difficile et pas très intuitive: soit vous prenez le temps d'apprendre, soit vous continuez à patauger et avoir mal au crane.

- W

**Amniote** · 08/07/2019, 10h27

Bonjour à tous,

J'avais réussi à terminer ce fameux code, il faut maintenant que j'y apporte quelques modifications:

je dois maintenant demander deux protéines (chiffres) à l'utilisateur. Le premier chiffre rentré sera la protéine qui initiera la chaîne, le second chiffre sera la protéine qui terminera la chaîne. Ensuite l'algorithme doit me trouver tout les chemins possibles reliant ces deux protéines.

Pour l'instant je pense ne pas m'en sortir trop mal

voici le fichier test que j'utilise:

1 4
4 1
1 6
6 1
1 66
66 1
4 9
9 4
6 9
6 66
66 6
9 6
9 33
33 9
9 66
66 9

et le code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
import sys
sys.setrecursionlimit(1000)
from collections import defaultdict
dd = defaultdict(set)
 
with open("testchaines3.txt","r") as f1:
	for lignes in f1:
		lignes=lignes.rstrip('\n').split(" ")
		prot1=lignes[0]
		prot2=lignes[1]
		dd[prot1].add(prot2)
	#print(dd)
 
proteine1 = (input("Enter the first protein in the chain : "))
proteine2 = (input("Enter the last protein in the chain : "))
 
def chain(proteine1, proteine2, maillon, pathway, limite=10): 
	next_= maillon.get(pathway[-1], None) 
	if len(pathway)<limite:
		for m in next_:
			if m not in pathway:
				if m==proteine2 and pathway[0]==proteine1:
					pathway.append(m)
					yield pathway
				if m != proteine2:
					yield from chain(proteine1, proteine2, maillon, pathway + [m])
					pass
 
for k in dd: 
	for z in chain(proteine1,proteine2, dd, pathway = [k]):
		print (' '.join(z))

Cependant j'ai un petit soucis, lorsque je print le résultat, je ne vais jamais avoir les combinaisons qui apparaissent, soit je les ais toutes, soit il m'en manque une partie!

par exemple pour protéine1 = 1 et protéine2 = 6 :

Un coup je vais avoir cela :

Enter the first protein in the chain : 1
Enter the last protein in the chain : 6
1 66 9 6
1 66 6
1 6

un autre coup cela :

Enter the first protein in the chain : 1
Enter the last protein in the chain : 6
1 6

ou encore cela (qui est la réponse attendue):

Enter the first protein in the chain : 1
Enter the last protein in the chain : 6
1 66 9 6
1 66 6
1 4 9 66 6
1 4 9 6
1 6

je ne comprends pas d'où viens ce problème...

Merci de votre aide