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** · 25/05/2019, 00h00

Merci infiniment pour votre réponse !

J'essai maintenant d'adapter le code à mon fichier de base dont voici un extrait (les dernières lignes du fichier):

ZNF727P TRIM28 0 0 0 55 64 900 52 904 ---> EXP
DCHS2 DCHS1 0 0 0 0 81 800 153 830
ADSL MDH2 0 0 0 88 55 800 153 834 ---> EXP
ADSL PAICS 219 0 0 702 519 900 808 997 ---> EXP
ADSL NT5C2 0 0 0 0 220 900 206 932
ADSL ADK 60 0 0 64 412 900 829 989 ---> EXP
ADSL ATIC 219 0 0 757 410 900 862 998 ---> EXP
ADSL MDH1 0 0 0 141 50 800 153 843 ---> EXP
ADSL APRT 156 0 0 485 376 900 868 995 ---> EXP
NXF2 XPO5 0 0 0 82 153 900 203 929 ---> EXP
NXF2 RAE1 0 0 0 62 507 800 627 960 ---> EXP
NXF2 ALYREF 0 0 0 64 268 800 431 911 ---> EXP
NXF2 NUP98 0 0 0 62 261 800 598 936 ---> EXP
NXF2 NXT1 0 0 0 0 719 800 882 992
NXF2 NXT2 0 0 0 0 719 800 958 997
EIF3L RPS8 0 0 0 404 755 900 83 984 ---> EXP
EIF3L RPS27 0 0 0 203 437 900 214 960 ---> EXP
EIF3L RPS10 0 0 0 251 437 900 305 966 ---> EXP
EIF3L EIF4A2 0 0 0 187 79 900 278 938 ---> EXP
EIF3L RPS26 0 0 0 313 731 900 113 981 ---> EXP
EIF3L RPS19 0 0 0 243 731 900 304 983 ---> EXP
EIF3L RPS15 0 0 0 204 731 900 123 978 ---> EXP
EIF3L RPS5 0 0 0 500 755 900 67 987 ---> EXP
EIF3L RPS11 0 0 0 252 731 900 140 980 ---> EXP

voici l'algorithme :

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
with open("resultats_matrice_avec_scores_sans_localisation.txt","r") as f1:
	for ligne in f1:
		lp = ligne.rstrip('\n').split(" ")
		if lp[-1] == "EXP":
			prot1 = lp[0] 
			prot2 = lp[1]
			data=(prot1,prot2)
			print(data)
f1.close()
 
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)

et voici la sortie :

('E', 'I')
('R', 'P')

J'ai l'impression qu'il prends juste les deux premières lettres de la première protéine de la dernière ligne et le deux premières lettres de la seconde protéine de la dernière ligne :/

**Sve@r** · 25/05/2019, 08h00

Envoyé par Amniote

Code python :

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

1
2
3
4
5
6
7
for ligne in f1:
	lp = ligne.rstrip('\n').split(" ")
	if lp[-1] == "EXP":
		prot1 = lp[0] 
		prot2 = lp[1]
		data=(prot1,prot2)
		print(data)

J'ai l'impression qu'il prends juste les deux premières lettres de la première protéine de la dernière ligne et le deux premières lettres de la seconde protéine de la dernière ligne :/

Ben oui. Mon data d'exemple est un tuple de n "tuples". Ou plus simplement un tuple 2D. Ton data à toi se trouve être un bête tuple 1D réécrasé à chaque nouvelle ligne lue et contenant 2 chaines.

Ensuite comme j'utilise la 2D (je boucle dans la boucle) j'obtiens bien mes protéines de façon individuelle (la première boucle récupère un couple de protéines et la seconde récupère les deux protéines du couple). Toi tu boucles dans data donc tu récupères 2 strings et comme les strings sont itérables, la seconde boucle récupère les 2 caractères de chaque string.

Code python :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
def read(fic):
	data=[]
	with open(fic, "r") as fp:
		for ligne in fp:
			lp = ligne.rstrip('\n').split(" ")
			if lp[-1] == "EXP": data.append((lp[0], lp1]))
		# for
	# with (pas besoin de fclose, with le fait automatiquement)
	return data
# read()
 
for c in chaine(read("resultats_matrice_avec_scores_sans_localisation.txt"), 5):
	print(c)

**wiztricks** · 25/05/2019, 12h00

Envoyé par Sve@r

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é.

Se balader dans un arbre de façon récursive dépend de la forme de l'arbre: si on simplifie sa représentation, on simplifie aussi le code à écrire, çà marche ensemble!

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
from collections import defaultdict
 
data = ( "P1,P4\nP1,P5\nP1,P6\nP4,P7\nP4,P9\nP5,P10\n"
         "P5,P11\nP5,P16\nP6,P22\nP6,P26\nP9,P55\nP33,P66\n")
 
dd = defaultdict(set)
for z in data.splitlines():
    a, b = z.split(',')
    dd[a].add(b)
 
 
def chain(nodes, path=None, limit=3):
 
    next_ = nodes.get(path[-1], None)
    if next_ is None or len(path) >= limit:
        yield path
    else:
        for m in next_:
            yield from chain(nodes, path + [m])
 
for k in dd:
    for z in chain(dd, path = [k]):
        print (', '.join(z))

Après, on peut toujours s'amuser à jouer avec çà mais si le PO ne maîtrise pas ces techniques, il ne pourra pas en faire grand chose.

- W

**Sve@r** · 25/05/2019, 12h56

J'aime quand tu nous montres comment faire en 3 lignes ce que j'écris en 45

Malheureusement ta solution ne donne pas le même résultat que la mienne

Voici mes datas que j'ai utilisées: data=("P1,P4\nP1,P5\nP1,P6\nP4,P7\nP4,P9\nP5,P10\nP5,P11\nP5,P16\nP6,P22\nP6,P26\nP9,P33\nP9,P55\nP33,P66\n") (j'ai repris celles de mon code en fait et les ai adaptées quoi)

Et voici ce qu'il sort avec limit=5 (je l'ai trié pour pouvoir mieux le comparer)

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
P1, P4, P7
P1, P4, P9, P33, P66
P1, P4, P9, P55
P1, P5, P10
P1, P5, P11
P1, P5, P16
P1, P6, P22
P1, P6, P26
P33, P66
P4, P7
P4, P9, P33, P66
P4, P9, P55
P5, P10
P5, P11
P5, P16
P6, P22
P6, P26
P9, P33, P66
P9, P55

Voici ce qu'il manque par rapport à mon code

Code :

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

1
2
3
4
5
6
7
8
P1, P4
P1, P4, P9
P1, P4, P9, P33
P1, P5
P1, P6
P4, P9
P4, P9, P33
P9, P33

J'ai l'impression qu'en fait, ton code ne sort pas les chaines intermédiaires...

Envoyé par wiztricks

Après, on peut toujours s'amuser à jouer avec çà mais si le PO ne maîtrise pas ces techniques, il ne pourra pas en faire grand chose.

Entièrement d'accord. J'ai bien conscience que je lui ai donné une solution (à base de yield inclus dans des yield) à 1000 lieues au dessus de ses connaissances (déjà j'en ai chié pour qu'elle fonctionne

). J'espère que cela lui donnera la motivation pour s'y mettre. Sinon ben il aura eu une solution gratos qui lui permettra de manger aujourd'hui mais qui le laissera affamé le reste de sa vie (petite adaptation de la citation de Lao Tseu

)

**wiztricks** · 25/05/2019, 13h50

Envoyé par Sve@r

J'ai l'impression qu'en fait, ton code ne sort pas les chaines intermédiaires...

Tout à fait mais ce n'est pas compliqué à ajouter.

- W

**Amniote** · 26/05/2019, 16h53

Merci encore pour les précisions, j'ai (normalement) un dernier petit soucis avec l'algorithme :

J'ai le fichier test suivant qui représente des interactions entre deux chiffres (1 interagit avec 2, 2 avec 3, 6 avec 7...) :

1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9

J'ai le fichier test suivant qui représente des interactions entre deux chiffres (1 interagit avec 2, 2 avec 3, 6 avec 7...) :

et l'algorithme :

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
 
data=[]
with open ("test.txt","r") as f1:
    for ligne in f1:
        lp = ligne.rstrip('\n').split(" ")
        prot1 = lp[0] #J'isole les premières protéines
        prot2 = lp[1] #J'isole les secondes protéines
        couple=(prot1,prot2) #Couple = chaques couples d'interactions
        data.append(couple) #Je créé une liste contentant toutes les interactions de mon fichier
    #print(data)
f1.close()
 
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
                yield suite
        for d in data:
                for f in find(d[1], data, (d[0],), limit):
                        yield f
for c in chaine(data, 5):
        print(c)

Voici la sortie de l'algorithme:

('1', '2', '3', '4', '5')
('1', '2', '3', '4')
('1', '2', '3')
('1', '2')
('2', '3', '4', '5', '6')
('2', '3', '4', '5')
('2', '3', '4')
('2', '3')
('3', '4', '5', '6', '7')
('3', '4', '5', '6')
('3', '4', '5')
('3', '4')
('4', '5', '6', '7', '8')
('4', '5', '6', '7')
('4', '5', '6')
('4', '5')
('5', '6', '7', '8', '9')
('5', '6', '7', '8')
('5', '6', '7')
('5', '6')
('6', '7', '8', '9')
('6', '7', '8')
('6', '7')
('7', '8', '9')
('7', '8')
('8', '9')

L'algorithme fonctionne donc bien, mais cependant il y a des chaines d'interactions en trop ici, voici la sortie que j'attends :

('1', '2', '3', '4', '5')

('2', '3', '4', '5', '6')

('3', '4', '5', '6', '7')

('4', '5', '6', '7', '8')

('5', '6', '7', '8', '9')

('6', '7', '8', '9')

('7', '8', '9')

('8','9')

Ici, les trois dernières chaines d'interactions sont bien prises en compte car elles ne peuvent pas aller plus loin (contrairement aux autres chaines telles que ('6', '7') par exemple qui peut enchainer jusqu'à ('6', '7', '8', '9'.

Pour simplifier j'aimerai que l'algorithme ne prenne pas en compte les chaines qui peuvent continuer jusqu’à une longueur de 5 (qui ne sont donc pas bloquées par l'absence d'interactions possible au maillon suivant).

Comment puis-je modifier mon algorithme pour arriver à ce type de résultat ?

Merci encore...

**wiztricks** · 26/05/2019, 17h49

Envoyé par Amniote

Comment puis-je modifier mon algorithme pour arriver à ce type de résultat ?

C'est ce que fait mon code.

- W

**Amniote** · 26/05/2019, 18h53

Envoyé par wiztricks

C'est ce que fait mon code.

- W

En effet, merci !

J'ai testé votre code sur mes données complète et il fonctionne très bien à un détail près...

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
 
from collections import defaultdict
dd = defaultdict(set)
 
with open ("resultats_matrice_avec_scores_sans_localisation.txt","r") as f1:
	for ligne in f1:
		lp = ligne.rstrip('\n').split(" ")
		prot1 = lp[0]
		prot2 = lp[1]
		dd[prot1].add(prot2)
 
def chain(nodes, path=None, limit=100):
 
    next_ = nodes.get(path[-1], None)
    if next_ is None or len(path) >= limit:
        yield path
    else:
        for m in next_:
            yield from chain(nodes, path + [m])
 
for k in dd:
    for z in chain(dd, path = [k]):
        print (' '.join(z),'\n')

Je me suis rendu compte lorsque j'ai testé l'algorithme sur des chaînes de protéines très longues (ici des chaînes de 100 interactions) l'algorithme réutilisait des interactions entre deux protéines qui étaient déjà utilisées, un exemple avec cette chaîne de 100 interactions :

ARF5 COPE ARFGAP1 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR10 TXNDC5 ACTR2 RAC1 GDI2

Comme on peut le voir, nous avons une succession d'interaction entre les protéines ACTR10 et TXNDC5...ce qui fait que je me retrouve face à des chaînes d'interaction qui tournent en rond, à l'infini... Il faudrait que lorsque une interaction a été utilisée une fois, elle ne le soit plus pour le restant de la chaîne en cours. Une fois que la chaîne en cours est terminée, les interactions sont "réinitialisées" pour pouvoir servir à la nouvelle chaine en construction.

Merci encore de votre aide

**Sve@r** · 26/05/2019, 19h07

Envoyé par Amniote

Envoyé par Sve@r

J'ai l'impression qu'en fait, ton code ne sort pas les chaines intermédiaires...

Pour simplifier j'aimerai que l'algorithme ne prenne pas en compte les chaines qui peuvent continuer jusqu’à une longueur de 5 (qui ne sont donc pas bloquées par l'absence d'interactions possible au maillon suivant).
Comment puis-je modifier mon algorithme pour arriver à ce type de résultat ?

Ouais super, le type il ne lit même pas les posts quoi !!!

Envoyé par Amniote

L'algorithme fonctionne donc bien, mais cependant il y a des chaines d'interactions en trop ici, voici la sortie que j'attends :
('1', '2', '3', '4', '5')
('2', '3', '4', '5', '6')
('3', '4', '5', '6', '7')
('4', '5', '6', '7', '8')
('5', '6', '7', '8', '9')
('6', '7', '8', '9')
('7', '8', '9')
('8','9')

Au début tu ne voulais que les chaines d'une certaine longueur bien définie (10 dans ton énoncé). Maintenant tu veux toutes les chaines finies mêmes celles qui ne font pas 10 (ou 5 dans ce dernier exemple). Si tu changes d'avis à chaque post...

Envoyé par Amniote

Comme on peut le voir, nous avons une succession d'interaction entre les protéines ACTR10 et TXNDC5...ce qui fait que je me retrouve face à des chaînes d'interaction qui tournent en rond, à l'infini... Il faudrait que lorsque une interaction a été utilisée une fois, elle ne le soit plus pour le restant de la chaîne en cours. Une fois que la chaîne en cours est terminée, les interactions sont "réinitialisées" pour pouvoir servir à la nouvelle chaine en construction.

"Il faudrait il faudrait". Tu nous prends pour tes secréataires ?
On t'a donné des idées, montré comment les exploiter. Tu ne veux pas qu'une protéine qui se retrouve plusieurs fois soit réutilisée => tu utilises une liste que tu remplis avec les protéines déjà traitées (et j'ai dit "liste" par habitude mais tu auras très bien compris que comme ladite liste ne contiendra que des chaines distinctes, alors un ensemble est bien plus approprié).

**wiztricks** · 26/05/2019, 23h31

Salut,

Envoyé par Amniote

Comme on peut le voir, nous avons une succession d'interaction entre les protéines ACTR10 et TXNDC5...ce qui fait que je me retrouve face à des chaînes d'interaction qui tournent en rond, à l'infini... Il faudrait que lorsque une interaction a été utilisée une fois, elle ne le soit plus pour le restant de la chaîne en cours. Une fois que la chaîne en cours est terminée, les interactions sont "réinitialisées" pour pouvoir servir à la nouvelle chaine en construction.

Supprimer l'interaction qu'on va utiliser et la rajouter ensuite ne pose pas de problème particulier... Si?

- W

Comparer un dictionnaire à deux dimensions à un dictionnaire simple

Python

Discussions similaires

Partager

Partager