Extraire des caractères successif d'une chaine et les ajouter à une autre.

[JakiJake]

Bonjour,

Je donne ici un exemple réduit de ce que je voudrais bien faire en Python:
J'ai une chaine de caractère: dna="AGCATCGATCGTACGTAGCTACTAG CTAG" par exemple.
Par le début de mon programme je réussis à me placer à un endroit précis sur "dna" et extraire cet endroit plus 6 lettres de par et d'autre.
Ce qui fait par exemple que j'obtiens une variable: m="TACGTAGCTACTAG"

Ce que je voudrais maintenant ce que Python ajoute les lettres de "dna" à la suite de "m" selon une condition.
Pour donner un exemple concret:
La condition c'est que le Tm (melting temperature) soit >= 60. Donc python ajouterais successivement les lettres de "dna" à "m" jusqu'à ce que Tm >= 60.
Expl: "G TACGTAGCTACTAG"
Calcul du Tm.
"CG TACGTAGCTACTAG"
Calcul du Tm.
Etc..... jusqu'à ce que Tm >= 60.

Précision: j'ai fais une fonction pour le calcul du Tm.

def tm_get(dna):	
			A_count=dna.count('A')
			T_count=dna.count('T')
			G_count=dna.count('G')
			C_count=dna.count('C')
			if len(dna)>=20:			
				Tm = ((2*(A_count+T_count)) + (4*(G_count+C_count)))*(1+((len(dna)-20)/20))
			else:
				Tm = (2*(A_count+T_count)) + (4*(G_count+C_count))			
			return Tm

Et voilà le brouillon de mon code pour l'instant pour ajouter les lettres successivement:

def primerforward (c) :
			resultat = mutated
			i = mutated[-1]
			Tm=(tm_get(resultat))-(tm_primaire)
			while Tm < 60 :
				resultat = i+resultat
				i=i[-1]
				Tm=(tm_get(resultat))-(tm_primaire)
				if Tm >= 60:
					return resultat
					break
		pf=primerforward(dna)

Ca marche mais le problème c'est qu'il ajoute toujours la lettre en -1, donc ici le G par exemple, mais il ajoute toujours celle-ci et je ne parviens pas à lui dire d'avancer dans "dna" et d'ajouter la lettre -2 après la -1 etc...

Quelqu'un aurait une idée?
-----

[algathor]

Salut, je crois que tu n'as pas bien saisi l’intérêt des boucles dans python (et dans algorithme en général).Voila ton code modifié et fonctionnel:

def primerforward (c) :
			resultat = mutated
			i = mutated[-2]
			Tm=(tm_get(resultat))-(tm_primaire)
			while Tm < 61 :
				resultat = i+resultat
				i=i[-1]
				Tm=(tm_get(resultat))-(tm_primaire)
				if Tm >= 59:
					return resultat
					break
		pf=primerforward(dna)

[JakiJake]

Salut,
Tout d’abords merci de m'avoir répondu. C'est gentil.
Cependant:
- Je sais bien que c'est tentant sous l'anonymat d'internet de critiquer les gens mais là mon gars tu a écris la même boucle que moi..... alors tu peux dire que j'ai rien compris au boucle mais alors toi non plus.
- Deuxièmement ton programme est pas du tout fonctionnel et donne exactement le même résultat que le mien si ce n'est que toi tu a la lettre -2 de "dna" ajouter et moi la lettre -1. Sinon c'est exactement la même chose est bien évidement pas ce pour quoi j'avais demandé de l'aide.

Admettons que dans la fonction "mutated" est un pattern sur "dna" reconnu par la première partie de mon script non affiché ici.
Ce que je veux c'est que depuis "mutated" sur "dna" le programme ajoute les lettre mutated[-1], mutated[-2] etc ..... jusqu’à que Tm >60.

Et pour l'instant ma boucle ne permet que d'ajouter la lettre [-2] toujours jusqu'a ce que Tm >60.

Si quelqu'un à une idée ? merci ! et restez courtoie!!

[fred1599]

Bonjour,

Il manque des informations, comme par exemple la variable mutated, d'où vient-elle ?
tm_primaire, d'où vient cette variable ?

Se sont déjà les deux ingrédients manquants pour comprendre la fonction primerforward.

En attendant une réponse, pour compter le nombre d'occurrences des lettres dans une chaîne, on peut utiliser la classe Counter du module collections.

from collections import Counter

def tm_get(dna):    
    c = Counter(dna)
    if len(dna)>=20:            
        Tm = ((2*(c['A'] + c['T']) + (4*(c['G'] + c['C']))) * (1 + ((len(dna)-20)/20)))
    else:
        Tm = (2*(c['A'] + c['T'])) + (4*(c['G'] + c['C']))        
    return Tm
    
dna = "AGCATCGATCGTACGTAGCTACTAG CTAG"

print(tm_get(dna))

[A voir en vidéo sur Futura]

[JakiJake]

Salut,
Merci pour ta réponse. La classe counter est intéressante à connaître.
Enfaite "mutated" = "m" dans la première description du problème que j'ai écrite. Et Tm_primaire et le Tm de "m" que j'enlève au calcul finale du Tm qui doit être >= à 60.
Mais je vais reexpliquer ici mieux avec un exemple simple utilisant l'alphabet:
Par exemple j'ai:
dna="ABCDEFGHIJKLMNOPQRSTUVWXY Z"
"mutated" sera un pattern sur "dna", soit: mutated="IJKLMNOP" par exemple.

Et là je voudrais faire une fonction ou une loupe ou n'importe quoi qui pourrait ajouter à "mutated" les lettre de "dna" afin que le Tm de ça moins Tm_primaire (Tm de mutated) soit >= à 60.
Soit par exemple:
new_dna="DEFGHIJKLMNOP" avec Tm de "DEFGH" >= 60.

Voilà c'est ça que je veux faire. Et j'y arrive sauf que le programme ajoute la lettre en -1 de mutated, donc ici "H" par exemple et l'ajoute toujours celle ci jusqu'a que Tm >= 60, alors que je voudrais que après -1 (H) il ajoute -2 (G) puis -3(F) etc.... Mais je ne parviens pas à le faire incrémenter dans la variable "dna".

Merci de votre aide!

[fred1599]

C'est toujours pas clair dans ma tête, mais bon j'ai déjà modifié ta fonction selon ce que je pense être logique à mon goût. Peut-être que cela t'aideras à voir ton erreur...

def primerforward (c) :
    resultat = mutated
    n = -1
    i = mutated[n]
    Tm = tm_get(resultat) - (tm_primaire)
    while Tm < 60 :
        resultat += i
        n -= 1
        i = mutated[n]
        Tm = tm_get(resultat) - (tm_primaire)
    return resultat

[JakiJake]

Salut,
merci pour ta réponse.
Ca marche mais le problème c'est que c'est toujours le même problème , ca rajoute toujours la lettre en mutated[-1] et toujours celle là alors que je voudrais qu'il prenne la [-2] etc...

Alors je vais tenter de reexpliquer correctement:

J'ai une variable dna:"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
Sur ce "dna" mon programme (non affiché ici) repère une zone précise, par exemple: "IJKLM". Nous la nommerons "mutated". Donc mutated="IJKLM"

Ce que je veux faire c'est écrire un programme qui:
- A partir de la zone détecter (mutated), le programme lirait les lettres de "dna" en amont de "mutated" et afficherait une chaine qui regroupe "mutated" + les lettres de "dna" situées avant "mutated" selon une condition (calcule du Tm ici).

Soit par exemple le résultat du programme ici serait:
resultat="EFGHIJKLM" avec selon la condition Tm de EFGH >= 60.

En gros mon problème c'est que je sais pas comment dire à Python: "Lit la chaine dna à partir de mutated et affiche mutated plus les lettres avant successivement jusqu'a que la condition Tm soit remplie."

Merci de votre aide.

[fred1599]

Bon j'ai tenté un truc, car ça me semble plus clair, dis moi si c'est le résultat attendu, j'ai choisi des valeurs arbitraires.

from collections import Counter, deque

tm_primaire = 12.0

def tm_get(dna):    
    c = Counter(dna)
    if len(dna)>=20:            
        Tm = ((2*(c['A'] + c['T']) + (4*(c['G'] + c['C']))) * (1 + ((len(dna)-20)/20)))
    else:
        Tm = (2*(c['A'] + c['T'])) + (4*(c['G'] + c['C']))        
    return Tm

def primeforward(dna, mutated):
    ind = dna.find(mutated)
    result = deque(mutated)
    Tm = tm_get(''.join(result)) - (tm_primaire)
    while Tm < 60 and ind > 0:
        result.appendleft(dna[ind-1])
        ind -= 1
        Tm = tm_get(''.join(result)) - (tm_primaire)
    return ''.join(result)
    

dna = "AGCATCGATCGTACGTAGCTACTAGCTAG"
mutated = "TACGTAGCTACTAG"

res = primeforward(dna, mutated)
print(res)