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)