Alignement, ecriture dans fichier

Bonjour, pour un projet je dois aligner deux séquences entre elles mais il s'agit ici juste d'une facon esthetique de presenter l'alignement, et non pas d'un alignement local, global ou autre.

J'ai écrit ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 def pretty(file,idx,idy,s,x,y): f = open (file,"w") res = "" for x,y in zip (idx,idy): if x == y : res += x "/n" + "|" + "/n" y else: res += x "/n" + "-" + "/n" y f.close() return res
Ma logique étant la suivante :
on parcourt la sequence idx et la sequence idy en meme temps,
si le caractere x de idx == le caractere y de idy alors on ecrit :
x a la ligne, la barre, a la ligne y

si x est different de y on ecrit :
x a la ligne, tiret, y

par exemple :
idx = ATGA
idy = ACGT
pour le premier caractere de idx et idy on a x = A, y = A donc le resultat :
A
|
A
puis on continu et aboutit a :
ATGA
| - |-
ACGT

Mais ca ne fonctionne pas, je ne comprends pas pourquoi. Est ce ma logique qui est fausse ou alors mon code ?

Merci.

Salut,
Le problème vient que tu ajoutes les informations de 3 lignes dans une seule variable res. Il faut stocker le résultat de la comparaison dans une chaine, et une fois le traitement terminé, joindre les 3 chaines. Ce qui donne dans le même style :

Code:

1
2
3
4
5
6
7
8
def match(str1, str2):
    res = list()
    for c1, c2 in zip(str1, str2):
        if c1 == c2:
            res.append("|")
        else:
            res.append("-")
    return "\n".join( [ str1, "".join(res), str2 ] )

Ou avec une liste en intention :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from copy import copy
from random import shuffle
 
def match(str1, str2):
    res = [ "|" if c1 == c2 else "-" for c1, c2 in zip(str1, str2) ]
    return "\n".join( [ str1, "".join(res), str2 ] )
 
def get_one(alpha = "ACGT"):
    ch = list(copy(alpha))
    shuffle(ch)
    return "".join(ch)
 
def main():
    res = [ match(get_one(), get_one()) for _ in range(4) ]
    print( "\n".join(res) )
 
if __name__ == '__main__':
    main()

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> 
AGCT
-||-
TGCA
TAGC
-|-|
GATC
AGCT
----
GTAC
TGAC
---|
ATGC

Salut,

Un oubli peut-être ?
Code:

1 2 f.write(res)
faut pas bosser le week-end, c'est fait pour se reposer.

Citation:

Envoyé par chlowecita

Mais ca ne fonctionne pas, je ne comprends pas pourquoi. Est ce ma logique qui est fausse ou alors mon code ?

C'est quoi ce charabia?

Code:

res += x "/n" + "|" + "/n" y

Vous pourriez tester un peu sous la console "avant":
Code:

1 2 3 4 5 6 >>> res = ''; x = 'A'; y = 'A' >>> res += x "/n" + "|" + "/n" y File "<stdin>", line 1 res += x "/n" + "|" + "/n" y ^ SyntaxError: invalid syntax
Pour faire ce que vous dites:

Citation:

si le caractere x de idx == le caractere y de idy alors on ecrit :
x a la ligne, la barre, a la ligne y

>>> res += x + '\n|\n' + y donne:
Code:

1 2 3 4 5 6 7 >>> res 'A\n|\nA' >>> print (res) A | A >>>
Mais ça ne va pas permettre d’écrire les suivants "a la suite"!
Le plus simple sera de remplir line1, line2, line3 auxquelles on ajoute a chaque itération:
Code:

1 2 3 >>> line1 += x >>> line2 += '|' >>> line3 += y
Et bien, comme l'a fait remarquer VinsS, ne pas oublier de l’écrire dans le fichier "en sortie de boucle".

Mais avant de faire de la chose une fonction qui écrive dans un fichier, vous testez "a la console":
Code:

1 2 3 4 5 6 7 8 9 10 >>> idx = 'ATGA' >>> idy = 'ACGT' >>> line1 = '' >>> line2 = '' >>> line3 = '' >>> for x, y in zip(idx, idy): ... # a vous de jouer ... >>> for e in line1, line2, line3: ... print(e)
La solution de _dardanos_ très bien.
C'est ce que vous serez capable d’écrire lorsque vous aurez acquis des bases.
C'est passer pas mal de temps a faire des essais/erreurs a pianoter a la console pour comprendre et apprendre.

- W

Tout d'abord merci à tous.
En lisant vos commentaire je suis arrivée a ceci (d'abord en test dans ma console avant la version "definitive" avec l'ecriture dans le fichier)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 def pretty(idx,idy,x,y): l1 = [] l2 = [] l3 = [] for x,y in zip (idx,idy): if x == y: l1.append(x) l2.append('|') l3.append(y) else: l1.append(x) l2.append('-') l3.append(y) for e in l1,l2,l3: print "".join(e)
mais quand je veux faire un test, exemple:

Code:

pretty("ATA","AGA",x,y)

ca me renvoie un message d'erreur : x is not defined si c'etait le cas ca devrait aussi me dire ca pour y. Je suis perdue.

Salut,

Avant de voir pour ton erreur, il faudrait que tu clarifies ceci:
Code:

1 2 3 4 def pretty(idx,idy,x,y): ... for x,y in zip (idx,idy):
Pourquoi utilises-tu les même noms x et y si ceux-ci sont déjà les noms de deux arguments.
Quels sont ces arguments ? Ils ont l'air inutile, si c'est le cas, supprime les.

Pour ton erreur, montre nous le traceback complet, je n'ai pas l'impression que cela vient de la portion de code que tu nous montre. Vérifie le numéro de ligne où l'erreur est levée.

Salut,

J'y ai passée une partie de la nuit, car novice, mais j'ai compris d'ou venait mon erreur. J'ai modifié mon code et j'aboutit à :
Code:

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 def pretty(idx,idy,s,x,y): #avec : idx et idy = identifiant des sequences, s : score, x et y les deux sequences l1 = ["> "+ idx + " VS " + idy + ": " + str(s)] l2 = [] l3 = [] l4 = [] i = 0 #j'initialise un compteur car dans un soucis d'esthetique une fois que j'aurai aligne x et y sur un longueur de 80 lettres, il faut sauter une ligne if i <= 80 for a,b in zip (x,y): if a ==b: l2.append(a) l3.append ("|") l4.append(b) else: l2.append(a) l3.append("-") l4.append(b) else: print '/n' for a,b in zip (x,y): if a ==b: l2.append(a) l3.append("|") l4.append(b) else: l2.append(a) l3.append("-") l4.append(b) i += 1 for e in l1,l2,l3,l4: print "".join(e)
Tout d'abord quand je me passe de ce soucis esthetique tout fonctionne très bien. Apres j'ai cru que je ne plaçais pas mon i += 1 au bon endroit, j'ai essaye de le change de place mais ca ne change rien je n'ai toujours pas le resultat escompté.
J'ai essayé avec un while, mais je ne le maitrise pas tres bien et je me retrouvais avec des boucles infinies.
Je suis sure en plus qu'il y a moyen de simplifier le code quand i> 80 pour ne pas avoir a tout reecrire. J'ai essayé d'en faire une fonction récursive mais j'ai de nouveau ma ligne 1 qui s'afficherait et ce n'est pas ce que je veux.
Voila.

Il manque le double-point à la ligne if i <= 80

Le else: de la ligne 19 est incorrectement indenté, est-ce qu'il se rapporte à if i <= 80 auquel cas la ligne i += 1 n'est pas à sa place et si ce else: se rapporte à if a ==b: elle n'est pas indentée correctement.

Je ne comprend pas cette question de 80 caractères, si je comprend bien ce qui à été dit plus haut, une ligne aura autant de caractères que le nombre d'items de la séquence x (ou y), non ?

le else de la ligne 19 doit se rapporter au if i < 80:

concernant les 80 caractères :
il faut que chaque ligne de l'alignement possède un maximum de 80 colonnes formaté de cette facon :
ATGC
| -*||
AGGC
et une ligne vide doit séparer les lignes a chaque fois qu'on dépasse les 80 caractères.

Je ne sais pas si c'est plus claire de cette facon.

Je n'avais pas regardé en détail, le print "\n" n'a aucun sens à cet endroit là, tu continues à remplir tes listes et puis tu les affiches chacune en une seule ligne.

Plus important encore, pourquoi diable crées-tu trois listes ?

Tu dois pouvoir le faire très simplement avec une seule liste.

En pseudo-code:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 créer la liste: l = [] pour a, b de chaque x, y: ajouter '|' si a == b sinon '-' écrire le résultat: tant que longueur de x > 80: print x[:80] print l[:80] print y[:80] x = x[80:] l = l[80:] y = y[80:] print print x print l print y
Tu peux le faire en moins de vingt lignes de code. Si, si.

Je viens de voir ton post précédent, ça ne change rien, essaye de reproduire mon pseudo-code en vrai code.

je crée trois listes car ca me parait plus simple pour la mise en forme a la fin, comme ca j'ai ma sequence x, le - ou la |, puis ma sequence y

J'essaye de mettre le code en forme et je reviens vers vous.

Merci.

Donc j'ai ceci, mais en testant je n'y arrive toujours pas.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
def pretty(x,y):
   l = []
   for a,b in zip(x,y):
      if a == b:
           l.append("|")
      else:
           l.append("-")
   while len(x) > 80:
       print x[:80]
       print l[:80]
       print x[:80]
       x = x[80:]
       l = l[80:]
       y = y[80:]
   for e in x,l,y:
       print "".join(e)

Qu'est-ce qui foire ?

Si x et y sont des chaînes de caractères, tu ne dois pas les joindre, la liste de symboles doit être stringifiée elle.

Donc ça c'est bon:
Code:

1 2 3 4 5 6 7 8 9 def pretty(x,y): l = [] for a,b in zip(x,y): if a == b: l.append("|") else: l.append("-") while len(x) > 80:
ensuite selon les strings ou les listes tu fais:
Code:

1 2 3 print x[:80] # pour une string print ''.join(l[:80]) # pour une liste
tu ajoutes un print vide pour sauter une ligne et tu termines de la même manière pour finir les restants de listes, donc pas de cette façon qui est inutile:
Code:

1 2 3 for e in x,l,y: print "".join(e)

Citation:

Envoyé par VinsS

Qu'est-ce qui foire ?

ben quand je teste ma fonction avec des sequences de longueur inferieure a 80 j'obtiens :

ATGTATGATC
['|', '|', '|', '-', '-', '-', '-', '-', '-', '|']
ATGGTCATAC

c'est pourquoi j'avais tenté avec le .join, pensant obtenir :

ATGTATGATC
| | |- - - ---|
ATGGTCATAC

correction bug l2 + fonction tant qu'a faire.

Salut,
Maintenant que cette fonction "marche":
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 def pretty(idx,idy): l1 = [] l2 = [] l3 = [] for x,y in zip (idx,idy): if x == y: l1.append(x) l2.append('|') l3.append(y) else: l1.append(x) l2.append('-') l3.append(y) for e in l1,l2,l3: print "".join(e)
Afficher plusieurs lignes lorsque les longueurs d'idx, idy sont >80, c'est expédier a pretty des "tranches" d'idx, idy.
Avant de se lancer la dedans, il faut apprendre a découper en tranches, i.e. jouer avec:
Code:

1 2 3 4 >>> S = '01234567890123456789' >>> size = 2 >>> for x in range(0, len(S), size): .... print (S[x:x+size])
regarder ce qu'il se passe lorsque len(S) n'est pas multiple de size.

Puis appliquer votre fonction "pretty" aux tranches construites avec idx, idy.

Le code de pretty n'est pas beau? Il fonctionne et c'est vous qui l'avez écrit. Apprenez a le réutiliser avant de "modifier", "ameliorer".

La seule amélioration a faire pourrait être d'y supprimer des bavardages et d'en faire une "vrai" fonction, i.e qui retourne le "texte" construit:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 def pretty(idx,idy): # l1 = [] l2 = [] # l3 = [] for x,y in zip (idx,idy): if x == y: # l1.append(x) l2.append('|') # l3.append(y) else: # l1.append(x) l2.append('-') # l3.append(y) # for e in idx,l2,idy: l2 = ''.join(l2) return "\n".join( [ idx,l2,idy ])
note: L1, L2, L3 n’étaient la que pour vous permettre de visualiser le travail a faire sur chacune des 3 lignes. Cela compris, plus besoin de les trimbaler dans le code.
- W

Citation:

Envoyé par chlowecita

c'est pourquoi j'avais tenté avec le .join, pensant obtenir :

ATGTATGATC
| | |- - - ---|
ATGGTCATAC

Oui, mais c'est bon comme tu l'as fait sauf que tu devais supprimer les deux dernières lignes
Code:

1 2 3 for e in x,l,y: print "".join(e)
et les remplacer par
Code:

1 2 3 4 print x print ''.join(l) print y
pour les séquences de moins de 80 caractères.

Citation:
Envoyé par wiztricks
Afficher plusieurs lignes lorsque les longueurs d'idx, idy sont >80, c'est expédier a pretty des "tranches" d'idx, idy.
Avant de se lancer la dedans, il faut apprendre a découper en tranches, i.e. jouer avec:
Code:

1 2 3 4 >>> S = '01234567890123456789' >>> size = 2 >>> for x in range(0, len(S), size): .... print (S[x:x+size])
regarder ce qu'il se passe lorsque len(S) n'est pas multiple de size.

Puis appliquer votre fonction "pretty" aux tranches construites avec idx, idy.
J'ai essayé plusieurs variations. Je suis consciente que c'est pas forcement la plus "belle" et simple facon de faire, mais j'ai décomposé mon code et j'aboutit a :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 def decoupe(S): size = 5 #plus simple a tester au debut for c in range (0,len(S), size): print "".join(S[c: c+ size]) def pretty (x,y) l = [] d = decoupe(x) f = decoupe(y) for a,b in zip (d,f): if a == b : l.append('|') else: l.append('-') for e in d,l,f: print "".join(e)
du coup quand j'ai teste avec

Code:

x = '0123456789' y ='0123456789'

j'obtiens :
Code:

1 2 3 4 5 01234 56789 01234 56789
je pense ne pas être loin mais la solution m'echappe toujours.

Salut,

Je dirais "ouh la la...".

D'abord la fonction découpe que vous montrez ne retourne rien: elle fait "print" et s'en va => Avec d, f a rien, ca n'affichera certainement pas ce que vous dites.

Ensuite, on ne touche pas a "pretty" (sauf remplacer "print" par "return" pour en faire une "vraie" fonction)!

Partons de:
Code:

1 2 >>> X = 'ATGTATGATC' >>> Y = 'ATGGTCATAC'
Le retour de la fonction "decoupe(X)" devrait être une liste de...:
Code:

1 2 >>> print (decoupe(X)) ['ATGTA', 'TGATC']
A partir de la, "on compose" decoupe et pretty en recitant une chanson connue:
Code:

1 2 3 4 5 6 7 8 9 10 11 >>> for a, b in zip(decoupe(X), decoupe(Y)): .... print (pretty (a, b)) .... print () .... ATGTA |||-- ATGGT TGATC ----| CATAC
- W