{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"![En tête general](img/En_tete_general.png)\n",
"\n",
"*(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/*\n",
"\n",
" Pour exécuter une saisie Python, sélectionner la cellule et valider avec SHIFT+Entrée."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# ADN, ARN et protéines (corrigé)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Le but de cette activité est de simuler la transcription de brins d'ADN en ARN et la traduction de l'ARN en protéines.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1. Génération d'une chaîne d'ADN\n",
"\n",
"![ADN](img/ADN.png)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" 1.1. Compléter la structure suivante, contenant la liste des nucléotides pouvant composer un brin d'ADN. \n",
"\n",
"Attention : Penser ensuite à exécuter la zone ci-dessous (et les suivantes) avec SHIFT+Entrée."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"#Définition de la liste des nucléotides de l'ADN\n",
"#(A COMPLETER)\n",
"Nucleotide_ADN=['A','T','C','G']"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" 1.2. La fonction ADN_Aleatoire ci-dessous permet de générer une chaîne ADN de 3n nucléotides. Effectuer la saisie permettant de créer une chaîne nommée ADN, composée de 30 nucléotides, et afficher cette chaîne. "
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"#import du module random pour la génération aléatoire de l'ADN\n",
"from random import*\n",
"\n",
"def ADN_Aleatoire(n):\n",
" \"Fonction qui crée un brin d'ADN de longueur 3*n\"\n",
" #Création d'une chaîne vide\n",
" ADN='' \n",
" for k in range(3*n):\n",
" #Ajouts successifs de nucléotides choisis au hasard\n",
" ADN += choice(Nucleotide_ADN)\n",
" return ADN"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'GCGAGTTCTCGAGTCATCGGTCTAAGGCGC'"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Effectuer la saisie\n",
"ADN=ADN_Aleatoire(10)\n",
"ADN"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" 1.3. Compléter la structure suivante, qui définit la correspondance des nucléotides entre 2 brins d'ADN correspondants.. "
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"#Définition de la correspondance des nucléotides des brins d'ADN \n",
"#(A COMPLETER)\n",
"Brin_correspondant={ 'A':'T' , 'T':'A' , 'C':'G' , 'G':'C' }"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" 1.4. La fonction Creer_deuxieme_brin ci-dessous permet de générer le brin correspondant d'un brin d'ADN donné. Effectuer la saisie permettant de créer le brin ADN2, correspondant au brin ADN précédemment généré, et afficher le résultat. "
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"def Creer_deuxieme_brin(Brin_ADN):\n",
" \"Fonction qui reçoit un brin d'ADN et renvoie le 2e brin correspondant\"\n",
" Deuxieme_brin=''\n",
" for nucleotide in Brin_ADN:\n",
" Deuxieme_brin += Brin_correspondant[nucleotide]\n",
" return Deuxieme_brin"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'CGCTCAAGAGCTCAGTAGCCAGATTCCGCG'"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Effectuer la saisie\n",
"ADN2=Creer_deuxieme_brin(ADN)\n",
"ADN2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2. Transcription de l'ADN en ARN\n",
"\n",
"![Transcription](img/Transcription.png)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" 2.1. Compléter la structure suivante, qui définit la correspondance des nucléotides de l'ADN et des nucléotides de l'ARN. "
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"#Définition de la correspondance des nucléotides de l'ADN vers ARN\n",
"#(A COMPLETER)\n",
"ARN_correspondant={ 'A':'U' , 'T':'A' , 'C':'G' , 'G':'C' }"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" 2.2. La fonction Transcription ci-dessous permet de transcrire en ARN un brin d'ADN donné. Effectuer la saisie permettant de créer le brin ARN, correspondant au brin ADN précédemment généré, et afficher le résultat. "
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"def Transcription(Brin_ADN):\n",
" \"Fonction qui réalise la transcription d'un brin d'ADN en chaîne ARN\"\n",
" ARN=''\n",
" for nucleotide in Brin_ADN:\n",
" ARN += ARN_correspondant[nucleotide]\n",
" return ARN"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'CGCUCAAGAGCUCAGUAGCCAGAUUCCGCG'"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Effectuer la saisie\n",
"ARN=Transcription(ADN)\n",
"ARN"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3. Traduction de l'ARN\n",
"\n",
"![Naissance_acides_amines](img/Naissance_am.png)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" 3.1. Compléter la structure suivante, qui définit la correspondance des nucléotides de l'ADN et des nucléotides de l'ARN. \n",
"\n",
"On pourra s'aider du schéma ci-dessous et on codera 'STP' pour l'arrêt.. "
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"#Définition de la correspondance des acides aminés et des triplets de nucléotides:\n",
"#(A COMPLETER)\n",
"Acides_amines={ 'His': ['CAU','CAC'] , 'Gln': ['CAA','CAG'] , 'Pro': ['CCU','CCC','CCA','CCG'] , 'Arg': ['CGU','CGC','CGA','CGG','AGA','AGG'] , 'Leu': ['CUU','CUC','CUA','CUG','UUA','UUG'] , 'Asp': ['GAU','GAC'] , 'Glu': ['GAA','GAG'] , 'Ala': ['GCU','GCC','GCA','GCG'] , 'Gly': ['GGU','GGC','GGA','GGG'] , 'Val': ['GUU','GUC','GUA','GUG'] , 'Tyr': ['UAU','UAC'] , 'Ser': ['UCU','UCC','UCA','UCG','AGU','AGC'] , 'Cys': ['UGU','UGC'] , 'Trp': ['UGG'] , 'Phe': ['UUU','UUC'] , 'Asn': ['AAU','AAC'] , 'Lys': ['AAA','AAG'] , 'Thr': ['ACU','ACC','ACA','ACG'] , 'Ile': \n",
"['AUU','AUC','AUA'] , 'Met': ['AUG'] , 'STP': ['UAA','UAG','UGA'] }"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"![Correspondance_acides_amines](img/Correspondance_am.png)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" 3.2. La fonction Acide_amine_correspondant ci-dessous réalise la traduction d'un triplet de nucléotides en acide aminé, et la fonction Traduction réalise la traduction d'une chaîne ARN en protéine.\n",
"\n",
" Effectuer la saisie nécessaire pour créer la protéine, nommée Proteine, obtenue avec le brin ARN précédemment généré."
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"def Acide_amine_correspondant(Triplet):\n",
" \"Fonction qui réalise la traduction d'un triplet de nucléotide en acide aminé\"\n",
" for Ac_am in Acides_amines:\n",
" for Triplet_correspondant in Acides_amines[Ac_am]:\n",
" if Triplet==Triplet_correspondant:\n",
" return Ac_am\n",
" return False\n",
"\n",
"def Traduction(ARN):\n",
" \"Fonction qui réalise la traduction d'une chaîne ARN en Proteine\"\n",
" Proteine=[]\n",
" for k in range(0,len(ARN)-2,3):\n",
" Ac_am=Acide_amine_correspondant(ARN[k:k+3])\n",
" if Ac_am=='STP': break\n",
" else:\n",
" Proteine.append(Ac_am)\n",
" return Proteine"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['Arg', 'Ser', 'Arg', 'Ala', 'Gln']"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Effectuer la saisie\n",
"Proteine=Traduction(ARN)\n",
"Proteine"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" 3.3. Compléter la structure suivante, qui définit la correspondance des acides aminés et de leurs nomenclatures simplifiées.. \n",
"\n",
"Ces nomenclatures sont précisées sur le schéma précédent.. "
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
"Code_Ac_am={ 'His': 'H' , 'Gln': 'Q' , 'Pro': 'P' , 'Arg': 'R' , 'Leu': 'L' , 'Asp': 'D' , 'Glu': 'E' , 'Ala': 'A' , 'Gly': 'G' , 'Val': 'V' , 'Tyr': 'Y' , 'Ser': 'S' , 'Cys': 'C' , 'Trp': 'W' , 'Phe': 'F' , 'Asn': 'N' , 'Lys': 'K' , 'Thr': 'T' , 'Ile': 'I' , 'Met': 'M' , 'STP': '*' }\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" 3.4. La fonction Simplification ci-dessous permet la simplification d'une liste d'acides aminés. Effectuer la saisie nécessaire pour simplifier Proteine précédemment généré. "
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [],
"source": [
"def Simplification(Proteine):\n",
" \"fonction qui renvoie une protéine sous sa forme simplifiée\"\n",
" Proteine_simp=''\n",
" for Ac_am in Proteine:\n",
" Proteine_simp += Code_Ac_am[Ac_am]\n",
" return Proteine_simp\n"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'RSRAQ'"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#Effectuer la saisie\n",
"Prot_simp=Simplification(Proteine)\n",
"Prot_simp"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 4. Annexe : Vérification de cohérence."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Exécuter le programme ci-dessous, pour obtenir une vérification de la cohérence de votre saisie de la correspondance des acides aminés avec les triplets de nucléotides."
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"RECAPITULATIF DES SAISIES:\n",
"His ['CAU', 'CAC']\n",
"Gln ['CAA', 'CAG']\n",
"Pro ['CCU', 'CCC', 'CCA', 'CCG']\n",
"Arg ['CGU', 'CGC', 'CGA', 'CGG', 'AGA', 'AGG']\n",
"Leu ['CUU', 'CUC', 'CUA', 'CUG', 'UUA', 'UUG']\n",
"Asp ['GAU', 'GAC']\n",
"Glu ['GAA', 'GAG']\n",
"Ala ['GCU', 'GCC', 'GCA', 'GCG']\n",
"Gly ['GGU', 'GGC', 'GGA', 'GGG']\n",
"Val ['GUU', 'GUC', 'GUA', 'GUG']\n",
"Tyr ['UAU', 'UAC']\n",
"Ser ['UCU', 'UCC', 'UCA', 'UCG', 'AGU', 'AGC']\n",
"Cys ['UGU', 'UGC']\n",
"Trp ['UGG']\n",
"Phe ['UUU', 'UUC']\n",
"Asn ['AAU', 'AAC']\n",
"Lys ['AAA', 'AAG']\n",
"Thr ['ACU', 'ACC', 'ACA', 'ACG']\n",
"Ile ['AUU', 'AUC', 'AUA']\n",
"Met ['AUG']\n",
"STP ['UAA', 'UAG', 'UGA']\n",
" Nombres d'acides aminés écrits 21\n",
" Nombres de triplets écrits (y compris STP): 64\n",
"\n",
"VERIFICATION DES SAISIES:\n",
"Il y a 0 triplet non attribué \n"
]
}
],
"source": [
"Nucleotide_ARN=[ARN_correspondant[nucleotide] for nucleotide in Nucleotide_ADN]\n",
"\n",
"def Verif_correspondance_acides_amines():\n",
" \"\"\"\n",
" Complément:\n",
" fonction de vérification de la correspondance\n",
" entre Acides aminés et triplets\n",
" \"\"\"\n",
" \n",
" print(\"\\nRECAPITULATIF DES SAISIES:\")\n",
" \n",
" compteur_triplets=0\n",
" for ac_am in Acides_amines:\n",
" print(ac_am, [Triplet for Triplet in Acides_amines[ac_am]])\n",
" compteur_triplets += len(Acides_amines[ac_am])\n",
" print(\" Nombres d'acides aminés écrits\",len(Acides_amines))\n",
" print(\" Nombres de triplets écrits (y compris STP):\",compteur_triplets)\n",
" \n",
" print(\"\\nVERIFICATION DES SAISIES:\")\n",
" \n",
" Liste_oublis=[]\n",
" \n",
" for n1 in Nucleotide_ARN:\n",
" for n2 in Nucleotide_ARN:\n",
" for n3 in Nucleotide_ARN:\n",
" Triplet=n1+n2+n3\n",
" if not Acide_amine_correspondant(Triplet):\n",
" Liste_oublis.append(Triplet)\n",
" \n",
" nbre_oublis=len(Liste_oublis)\n",
" print(\"Il y a\",nbre_oublis,\"triplet\"+(\"s\" if nbre_oublis>1 else \"\"),\"non attribué\"+(\"s\" if nbre_oublis>1 else \"\"),\"\" if nbre_oublis==0 else \"qui est:\" if nbre_oublis==1 else \"qui sont:\")\n",
" for oubli in Liste_oublis: print(oubli)\n",
"\n",
" return None\n",
"\n",
"Verif_correspondance_acides_amines()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/*"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*Remerciements particuliers à Christine DEUTSCHMANN pour son aide précieuse.*"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.6.4"
}
},
"nbformat": 4,
"nbformat_minor": 2
}