Exercice 1
Ecrire un programme qui demande à l’utilisateur de saisir une séquence d’ADN et renvoi le nombre de
chaque nucléotide.
sequence = input("Entrez une séquence d'ADN : ")
# Initialiser les compteurs
compteur_A = 0
compteur_C = 0
compteur_G = 0
compteur_T = 0
# Parcourir la séquence et compter les nucléotides
for nucleotide in sequence:
if nucleotide == 'A':
compteur_A += 1
elif nucleotide == 'C':
compteur_C += 1
elif nucleotide == 'G':
compteur_G += 1
elif nucleotide == 'T':
compteur_T += 1
# Afficher les résultats
print("Nombre de A :", compteur_A)
print("Nombre de C :", compteur_C)
print("Nombre de G :", compteur_G)
print("Nombre de T :", compteur_T)
Exercice 2 :
Ecrire un programme qui demande à l’utilisateur de saisir une séquence d’ADN et renvoi les positions
de chaque nucléotide.
sequence = input("Entrez une séquence d'ADN : ")
# Initialiser les dictionnaires pour stocker les positions
positions_A = []
positions_C = []
positions_G = []
positions_T = []
# Parcourir la séquence et enregistrer les positions des nucléotides
for i in range(len(sequence)):
nucleotide = sequence[i]
position = i + 1 # Ajouter 1 pour démarrer à la position 1
if nucleotide == 'A':
positions_A.append(position)
elif nucleotide == 'C':
positions_C.append(position)
elif nucleotide == 'G':
positions_G.append(position)
elif nucleotide == 'T':
positions_T.append(position)
# Afficher les résultats
print("Positions de A :", positions_A)
print("Positions de C :", positions_C)
print("Positions de G :", positions_G)
print("Positions de T :", positions_T)
Exercice 3 :
Ecrire un programme qui demande à l’utilisateur de saisir une séquence d’ADN et renvoi les positions
qui contiennent des erreurs de chaque nucléotide.
sequence = input("Entrez une séquence d'ADN : ")
# Initialiser les dictionnaires pour stocker les positions avec erreurs
positions_erreurs_A = []
positions_erreurs_C = []
positions_erreurs_G = []
positions_erreurs_T = []
# Parcourir la séquence et détecter les erreurs de nucléotides
for i in range(len(sequence)):
nucleotide = sequence[i]
position = i + 1 # Ajouter 1 pour démarrer à la position 1
if nucleotide != 'A':
positions_erreurs_A.append(position)
if nucleotide != 'C':
positions_erreurs_C.append(position)
if nucleotide != 'G':
positions_erreurs_G.append(position)
if nucleotide != 'T':
positions_erreurs_T.append(position)
# Afficher les résultats
print("Positions d'erreurs de A :", positions_erreurs_A)
print("Positions d'erreurs de C :", positions_erreurs_C)
print("Positions d'erreurs de G :", positions_erreurs_G)
print("Positions d'erreurs de T :", positions_erreurs_T)
Exercice 4 :
Ecrire un programme qui demande à l’utilisateur de saisir une séquence d’ADN et renvoi la séquence
du 2ème brin.
sequence = input("Entrez une séquence d'ADN : ")
# Convertir la séquence en une liste de nucléotides
nucleotides = list(sequence)
# Initialiser le dictionnaire des paires de nucléotides complémentaires
complements = {'A': 'T', 'T': 'A', 'C': 'G', 'G': 'C'}
# Générer la séquence du deuxième brin en remplaçant chaque nucléotide par son complément
complement_sequence = [complements[nucleotide] for nucleotide in nucleotides]
# Convertir la séquence du deuxième brin en une chaîne de caractères
complement_sequence = ''.join(complement_sequence)
# Afficher la séquence du deuxième brin
print("Séquence du deuxième brin :", complement_sequence)
Exercice 5 :
Ecrire un programme qui demande à l’utilisateur de saisir une séquence d’ARNm et renvoi la
séquence du ARNm.
sequence = input("Entrez une séquence d'ARNm : ")
# Supprimer les espaces éventuels dans la séquence
sequence = sequence.replace(" ", "")
# Afficher la séquence de l'ARNm
print("Séquence de l'ARNm :", sequence)
Exercice 6 :
Ecrire un programme qui demande à l’utilisateur de saisir une séquence d’ADN et renvoi le % de
chaque nucléotide.
sequence = input("Entrez une séquence d'ADN : ")
# Calculer la longueur de la séquence d'ADN
longueur = len(sequence)
# Compter le nombre de chaque nucléotide
compteur_A = sequence.count('A')
compteur_C = sequence.count('C')
compteur_G = sequence.count('G')
compteur_T = sequence.count('T')
# Calculer le pourcentage de chaque nucléotide
pourcentage_A = (compteur_A / longueur) * 100
pourcentage_C = (compteur_C / longueur) * 100
pourcentage_G = (compteur_G / longueur) * 100
pourcentage_T = (compteur_T / longueur) * 100
# Afficher les résultats
print("Pourcentage de A :", pourcentage_A)
print("Pourcentage de C :", pourcentage_C)
print("Pourcentage de G :", pourcentage_G)
print("Pourcentage de T :", pourcentage_T)
Exercice 7 :
Ecrire un programme qui demande à l’utilisateur de saisir deux séquences d’ADN et renvoi les
positions de déférence.
sequence1 = input("Entrez la première séquence d'ADN : ")
sequence2 = input("Entrez la deuxième séquence d'ADN : ")
# Vérifier que les deux séquences ont la même longueur
if len(sequence1) != len(sequence2):
print("Les séquences doivent avoir la même longueur.")
else:
# Trouver les positions où les séquences diffèrent
positions_difference = []
for i in range(len(sequence1)):
if sequence1[i] != sequence2[i]:
positions_difference.append(i + 1) # Ajouter 1 pour démarrer à la position 1
# Afficher les positions de différence
if len(positions_difference) == 0:
print("Les séquences sont identiques.")
else:
print("Positions de différence :", positions_difference)
Exercice 8 :
Ecrire un programme qui demande à l’utilisateur de saisir une séquence d’ADN et cherche si la
séquence ‘ACTG’ existe.
sequence = input("Entrez une séquence d'ADN : ")
# Vérifier si la séquence 'ACTG' existe dans la séquence d'ADN
if 'ACTG' in sequence:
print("La séquence 'ACTG' existe dans la séquence d'ADN.")
else:
print("La séquence 'ACTG' n'existe pas dans la séquence d'ADN.")
Exercice 9 :
Ecrire un programme qui demande à l’utilisateur de saisir une séquence d’ADN et renvoi le nombre de
répétition de la séquence ‘ACTG’.
sequence = input("Entrez une séquence d'ADN : ")
# Compter le nombre de répétitions de la sous-séquence 'ACTG'
count = sequence.count('ACTG')
# Afficher le nombre de répétitions
print("Nombre de répétitions de la séquence 'ACTG' :", count)
Exercice 10 :
Ecrire un programme qui demande à l’utilisateur de saisir une séquence d’ADN et remplace la
séquence ‘ACTG’ par ‘ATGC’.
sequence = input("Entrez une séquence d'ADN : ")
# Remplacer toutes les occurrences de 'ACTG' par 'ATGC'
nouvelle_sequence = sequence.replace('ACTG', 'ATGC')
# Afficher la nouvelle séquence
print("Nouvelle séquence d'ADN :", nouvelle_sequence)
Exercice 11 :
Ecrire un programme qui demande à l’utilisateur de saisir une séquence d’ADN et insère la séquence
‘ACTG’ à partir de la position 23.
sequence = input("Entrez une séquence d'ADN : ")
# Vérifier que la position d'insertion est valide
if len(sequence) >= 23:
nouvelle_sequence = sequence[:22] + 'ACTG' + sequence[22:]
else:
print("La position d'insertion est invalide.")
# Afficher la nouvelle séquence
print("Nouvelle séquence d'ADN :", nouvelle_sequence)
Exercice 12 :
Ecrire un programme qui demande à l’utilisateur de saisir une séquence d’ADN et insère la séquence
‘AAAA’ au début de la séquence.
sequence = input("Entrez une séquence d'ADN : ")
# Insérer la séquence 'AAAA' au début de la séquence
nouvelle_sequence = 'AAAA' + sequence
# Afficher la nouvelle séquence
print("Nouvelle séquence d'ADN :", nouvelle_sequence)
Exercice 13 :
Ecrire un programme qui demande à l’utilisateur de saisir une séquence d’ADN et remplace les
erreurs par la séquence ‘AAAA’.
while True:
sequence = input("Entrez une séquence d'ADN :")
cleaned_sequence = ''
# Remplacer les caractères invalides par 'AAAA'
for base in sequence:
if base in {'A', 'C', 'G', 'T'}:
cleaned_sequence += base
else:
cleaned_sequence += 'AAAA'
if cleaned_sequence != '':
break
else:
print("La séquence ne contient que des caractères invalides. Veuillez réessayer.")
print("Séquence d'ADN nettoyée :", cleaned_sequence)
