Commit ed475cac authored by GASSIER Ghislain's avatar GASSIER Ghislain
Browse files

Initial commit

parents
Pipeline #58 failed with stages
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"<div class=\"alert alert-block alert-info\">\n",
"<center>\n",
"<font size=\"+5\">Formation<br/> Python<br/> CEREGE</font> \n",
"</center>\n",
"</div>\n",
"<img src = \"./logoCEREGE.png\" title = \"google logo\" alt = \"Google logo\"style=\"float:right;\"height=\"128\" width=\"128\">\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1.1 C'est quoi Python ?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Un peu d'histoire\n",
"Le langage de programmation Python a été créé en 1989 par Guido van Rossum, aux Pays-Bas. Le nom Python vient d'un hommage à la série télévisée Monty Python's Flying Circus dont G. van Rossum est fan. La première version publique de ce langage a été publiée en 1991.\n",
"\n",
"La dernière version de Python est la version 3. Plus précisément, la version 3.7 a été publiée en juin 2018. La version 2 de Python est désormais obsolète et cessera d'être maintenue après le 1er janvier 2020. Dans la mesure du possible évitez de l'utiliser.\n",
"\n",
"La Python Software Foundation est l'association qui organise le développement de Python et anime la communauté de développeurs et d'utilisateurs.\n",
"\n",
"### Pourquoi utilisé python\n",
"Ce langage de programmation présente de nombreuses caractéristiques intéressantes :\n",
"\n",
"- Il est ***multiplateforme***. C'est-à-dire qu'il fonctionne sur de nombreux systèmes d'exploitation : Windows, Mac OS X, Linux, Android, iOS, depuis les mini-ordinateurs Raspberry Pi jusqu'aux supercalculateurs.\n",
"- Il est ***gratuit***. Vous pouvez l'installer sur autant d'ordinateurs que vous voulez (même sur votre téléphone !).\n",
"- C'est un ***langage de haut niveau***. Il demande relativement peu de connaissance sur le fonctionnement d'un ordinateur pour être utilisé.\n",
"- C'est un ***langage interprété***. Un script Python n'a pas besoin d'être compilé pour être exécuté, contrairement à des langages comme le C ou le C++.\n",
"- Il est ***orienté objet***. C'est-à-dire qu'il est possible de concevoir en Python des entités qui miment celles du monde réel (une cellule, une protéine, un atome, etc.) avec un certain nombre de règles de fonctionnement et d'interactions.\n",
"- Il est ***relativement simple*** à prendre en main.\n",
"- Enfin, il est très utilisé en ***analyse de données***.\n",
"Toutes ces caractéristiques font que Python est désormais enseigné dans de nombreuses formations, depuis l'enseignement secondaire jusqu'à l'enseignement supérieur."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1.2 Installer, configurer et configurer Python"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- ***L'interpréteur*** <br/>\n",
"Nous vous conseillons d'installer Miniconda, logiciel gratuit, disponible pour Windows, Mac OS X et Linux,\n",
"et qui installera pour vous Python 3. Avec le gestionnaire de paquets conda, fourni avec Miniconda, vous pourrez installer des modules supplémentaires\n",
"qui sont très utiles en bioinformatique (NumPy, scipy, matplotlib, pandas, Biopython).\n",
"\n",
"- ***Éditeur de texte*** <br/>\n",
"L'utilisation d'un langage informatique comme Python va nécessiter d'écrire des lignes de codes \n",
"à l'aide d'un éditeur de texte notepad++ sous Windows, BBEdit ou CotEditor sous Mac OS X et gedit sous Linux. \n",
"Il existe aussi d'autres éditeurs comme Atom, Visual Studio Code, Sublime Text, emacs, vim, geany... utilisez-les !\n",
"\n",
"À toute fin utile, on rappelle que les logiciels Microsoft Word, WordPad et LibreOffice Writer ne sont pas des éditeurs de texte, ce sont des traitements de texte qui ne peuvent pas et ne doivent pas être utilisés pour écrire du code informatique.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"***\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"***Remarque Python 2 ou Python 3 ?***"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"***Ce cours est basé sur la version 3 de Python***, qui est désormais le standard.\n",
"\n",
"Si, néanmoins, vous deviez un jour travailler sur un ancien programme écrit en Python 2,\n",
"sachez qu'il existe quelques différences importantes entre Python 2 et Python 3.\n",
"Le chapitre 21 Remarques complémentaires vous apportera plus de précisions."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1.4 Python en patique"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La maniére la plus efficasse pour dévellopper du code python et de passer par l'utilisation d'un ***shell ainsi que d'un editeur de texte*** dédié au python (Geany) ou de cce que l'on appelle un IDE : ***un environement de devellopement intégré.***\n",
"\n",
"\n",
"Cependant la 'complexité apparente' des outils, nécaissére à python peuvent s'avérés être un frein et ralentir voir décourager de l'apprentissage de python.\n",
"\n",
"Nous allons donc utilsé un nouveau vecteur de formation qui permet l'utilisation d'un simple navigateur afin d'éxcuter du code python, encapsuler dans du texte permettant d donner des explication as a as.\n",
"Neamoins, cette approche jupytr de python s'avére treés vite limité lorsque l'on souhaite dévellopper des traiement un peu complexe.\n",
"Je vous insite donc dés que vous vous sentirez allaise de passer à des méthodes coventionelle."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<div class=\"alert alert-block alert-info\">\n",
"<center>\n",
"Je vous insite donc dés que vous vous sentirez à l'aise de passer à des méthodes coventionelles.</center>\n",
"</div>"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"ename": "NameError",
"evalue": "name 'alert' is not defined",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-10-0d2ec883e901>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0malert\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Hello wpRock\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mNameError\u001b[0m: name 'alert' is not defined"
]
}
],
"source": [
"alert(\"Hello wpRock\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"<p style=\"text-align: center;\"><span style=\"color: #0000ff;\"><strong>Commandes de bases sur le modelserver</strong></span></p>"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"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.8"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
%% Cell type:markdown id: tags:
<div class="alert alert-block alert-info">
<center>
<font size="+5">Formation<br/> Python<br/> CEREGE</font>
</center>
</div>
<img src = "./logoCEREGE.png" title = "google logo" alt = "Google logo"style="float:right;"height="128" width="128">
%% Cell type:markdown id: tags:
## 1.1 C'est quoi Python ?
%% Cell type:markdown id: tags:
### Un peu d'histoire
Le langage de programmation Python a été créé en 1989 par Guido van Rossum, aux Pays-Bas. Le nom Python vient d'un hommage à la série télévisée Monty Python's Flying Circus dont G. van Rossum est fan. La première version publique de ce langage a été publiée en 1991.
La dernière version de Python est la version 3. Plus précisément, la version 3.7 a été publiée en juin 2018. La version 2 de Python est désormais obsolète et cessera d'être maintenue après le 1er janvier 2020. Dans la mesure du possible évitez de l'utiliser.
La Python Software Foundation est l'association qui organise le développement de Python et anime la communauté de développeurs et d'utilisateurs.
### Pourquoi utilisé python
Ce langage de programmation présente de nombreuses caractéristiques intéressantes :
- Il est ***multiplateforme***. C'est-à-dire qu'il fonctionne sur de nombreux systèmes d'exploitation : Windows, Mac OS X, Linux, Android, iOS, depuis les mini-ordinateurs Raspberry Pi jusqu'aux supercalculateurs.
- Il est ***gratuit***. Vous pouvez l'installer sur autant d'ordinateurs que vous voulez (même sur votre téléphone !).
- C'est un ***langage de haut niveau***. Il demande relativement peu de connaissance sur le fonctionnement d'un ordinateur pour être utilisé.
- C'est un ***langage interprété***. Un script Python n'a pas besoin d'être compilé pour être exécuté, contrairement à des langages comme le C ou le C++.
- Il est ***orienté objet***. C'est-à-dire qu'il est possible de concevoir en Python des entités qui miment celles du monde réel (une cellule, une protéine, un atome, etc.) avec un certain nombre de règles de fonctionnement et d'interactions.
- Il est ***relativement simple*** à prendre en main.
- Enfin, il est très utilisé en ***analyse de données***.
Toutes ces caractéristiques font que Python est désormais enseigné dans de nombreuses formations, depuis l'enseignement secondaire jusqu'à l'enseignement supérieur.
%% Cell type:markdown id: tags:
## 1.2 Installer, configurer et configurer Python
%% Cell type:markdown id: tags:
- ***L'interpréteur*** <br/>
Nous vous conseillons d'installer Miniconda, logiciel gratuit, disponible pour Windows, Mac OS X et Linux,
et qui installera pour vous Python 3. Avec le gestionnaire de paquets conda, fourni avec Miniconda, vous pourrez installer des modules supplémentaires
qui sont très utiles en bioinformatique (NumPy, scipy, matplotlib, pandas, Biopython).
- ***Éditeur de texte*** <br/>
L'utilisation d'un langage informatique comme Python va nécessiter d'écrire des lignes de codes
à l'aide d'un éditeur de texte notepad++ sous Windows, BBEdit ou CotEditor sous Mac OS X et gedit sous Linux.
Il existe aussi d'autres éditeurs comme Atom, Visual Studio Code, Sublime Text, emacs, vim, geany... utilisez-les !
À toute fin utile, on rappelle que les logiciels Microsoft Word, WordPad et LibreOffice Writer ne sont pas des éditeurs de texte, ce sont des traitements de texte qui ne peuvent pas et ne doivent pas être utilisés pour écrire du code informatique.
%% Cell type:markdown id: tags:
***
%% Cell type:markdown id: tags:
***Remarque Python 2 ou Python 3 ?***
%% Cell type:markdown id: tags:
***Ce cours est basé sur la version 3 de Python***, qui est désormais le standard.
Si, néanmoins, vous deviez un jour travailler sur un ancien programme écrit en Python 2,
sachez qu'il existe quelques différences importantes entre Python 2 et Python 3.
Le chapitre 21 Remarques complémentaires vous apportera plus de précisions.
%% Cell type:markdown id: tags:
## 1.4 Python en patique
%% Cell type:markdown id: tags:
La maniére la plus efficasse pour dévellopper du code python et de passer par l'utilisation d'un ***shell ainsi que d'un editeur de texte*** dédié au python (Geany) ou de cce que l'on appelle un IDE : ***un environement de devellopement intégré.***
Cependant la 'complexité apparente' des outils, nécaissére à python peuvent s'avérés être un frein et ralentir voir décourager de l'apprentissage de python.
Nous allons donc utilsé un nouveau vecteur de formation qui permet l'utilisation d'un simple navigateur afin d'éxcuter du code python, encapsuler dans du texte permettant d donner des explication as a as.
Neamoins, cette approche jupytr de python s'avére treés vite limité lorsque l'on souhaite dévellopper des traiement un peu complexe.
Je vous insite donc dés que vous vous sentirez allaise de passer à des méthodes coventionelle.
%% Cell type:markdown id: tags:
<div class="alert alert-block alert-info">
<center>
Je vous insite donc dés que vous vous sentirez à l'aise de passer à des méthodes coventionelles.</center>
</div>
%% Cell type:code id: tags:
``` python
alert("Hello wpRock")
```
%%%% Output: error
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-10-0d2ec883e901> in <module>
----> 1 alert("Hello wpRock")
NameError: name 'alert' is not defined
%% Cell type:markdown id: tags:
<p style="text-align: center;"><span style="color: #0000ff;"><strong>Commandes de bases sur le modelserver</strong></span></p>
%% Cell type:code id: tags:
``` python
```
This diff is collapsed.
This diff is collapsed.
{
"cells": [
{
"cell_type": "raw",
"metadata": {},
"source": [
"fichier = open(\"data.txt\", \"a\")\n",
"fichier.write(\"Bonjour notebook\")\n",
"fichier.close()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"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.8"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
%% Cell type:raw id: tags:
fichier = open("data.txt", "a")
fichier.write("Bonjour notebook")
fichier.close()
%% Cell type:code id: tags:
``` python
```
This diff is collapsed.
This diff is collapsed.
{
"cells": [
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Bonjour monde\n",
"Bonjour monde\n"
]
}
],
"source": [
"fichier = open(\"data.txt\", \"r\")\n",
"print (fichier.read())\n",
"fichier.close()"
]
}
],
"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.8"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
%% Cell type:code id: tags:
``` python
fichier = open("data.txt", "r")
print (fichier.read())
fichier.close()
```
%%%% Output: stream
Bonjour monde
Bonjour monde
{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"13 Dictionnaires et tuples\n",
"13.1 Dictionnaires\n",
"Les dictionnaires se révèlent très pratiques lorsque vous devez manipuler des structures complexes à décrire et que les listes présentent leurs limites. Les dictionnaires sont des collections non ordonnées d'objets, c'est-à-dire qu'il n'y a pas de notion d'ordre (i.e. pas d'indice). On accède aux valeurs d'un dictionnaire par des clés. Ceci semble un peu confus ? Regardez l'exemple suivant :\n",
"\n",
"\n",
">>> ani1 = {}\n",
">>> ani1[\"nom\"] = \"girafe\"\n",
">>> ani1[\"taille\"] = 5.0\n",
">>> ani1[\"poids\"] = 1100\n",
">>> ani1\n",
"{'nom': 'girafe', 'taille': 5.0, 'poids': 1100}\n",
"En premier, on définit un dictionnaire vide avec les accolades {} (tout comme on peut le faire pour les listes avec []). Ensuite, on remplit le dictionnaire avec différentes clés (\"nom\", \"taille\", \"poids\") auxquelles on affecte des valeurs (\"girafe\", 5.0, 1100). Vous pouvez mettre autant de clés que vous voulez dans un dictionnaire (tout comme vous pouvez ajouter autant d'éléments que vous voulez dans une liste).\n",
"\n",
" Remarque\n",
"Un dictionnaire est affiché sans ordre particulier.\n",
"\n",
"On peut aussi initialiser toutes les clés et les valeurs d'un dictionnaire en une seule opération :\n",
"\n",
"\n",
">>> ani2 = {\"nom\":\"singe\", \"poids\":70, \"taille\":1.75}\n",
"Mais rien ne nous empêche d'ajouter une clé et une valeur supplémentaire :\n",
"\n",
"\n",
">>> ani2[\"age\"] = 15\n",
"Pour récupérer la valeur associée à une clé donnée, il suffit d'utiliser la syntaxe suivante dictionnaire[\"cle\"]. Par exemple :\n",
"\n",
"\n",
">>> ani1[\"taille\"]\n",
"5.0\n",
" Remarque\n",
"Toutes les clés de dictionnaire utilisées jusqu'à présent étaient des chaînes de caractères. Rien n'empêche d'utiliser d'autres types d'objets comme des entiers (voire même des tuples, cf. rubrique suivante), cela peut parfois s'avérer très utile.\n",
"\n",
"Néanmoins, nous vous conseillons, autant que possible, d'utiliser systématiquement des chaînes de caractères pour vos clés de dictionnaire.\n",
"\n",
"13.1.1 Itération sur les clés pour obtenir les valeurs\n",
"Il est possible d'obtenir toutes les valeurs d'un dictionnaire à partir de ses clés :\n",
"\n",
"\n",
">>> ani2 = {'nom':'singe', 'poids':70, 'taille':1.75}\n",
">>> for key in ani2:\n",
"... print(key, ani2[key])\n",
"...\n",
"poids 70\n",
"nom singe\n",
"taille 1.75\n",
"13.1.2 Méthodes .keys() et .values()\n",
"Les méthodes .keys() et .values() renvoient, comme vous pouvez vous en doutez, les clés et les valeurs d'un dictionnaire :\n",
"\n",
"\n",
">>> ani2.keys()\n",
"dict_keys(['poids', 'nom', 'taille'])\n",
">>> ani2.values()\n",
"dict_values([70, 'singe', 1.75])\n",
"Les mentions dict_keys et dict_values indiquent que nous avons affaire à des objets un peu particuliers. Si besoin, nous pouvons les transformer en liste avec la fonction list() :\n",
"\n",
"\n",
">>> ani2.values()\n",
"dict_values(['singe', 70, 1.75])\n",
">>> list(ani2.values())\n",
"['singe', 70, 1.75]\n",
"Toutefois, ce sont des objets « itérables », donc utilisables dans une boucle.\n",
"\n",
"13.1.3 Existence d'une clé\n",
"Pour vérifier si une clé existe dans un dictionnaire, on peut utiliser le test d’appartenance avec l'instruction in qui renvoie un booléen :\n",
"\n",
"\n",
">>> if \"poids\" in ani2:\n",
"... print(\"La clé 'poids' existe pour ani2\")\n",
"...\n",
"La clé 'poids' existe pour ani2\n",
">>> if \"age\" in ani2:\n",
"... print(\"La clé 'age' existe pour ani2\")\n",
"...\n",
">>>\n",
"Dans le second test (lignes 5 à 7), le message n'est pas affiché car la clé age n'est pas présente dans le dictionnaire ani2.\n",
"\n",
"13.1.4 Liste de dictionnaires\n",
"En créant une liste de dictionnaires qui possèdent les mêmes clés, on obtient une structure qui ressemble à une base de données :\n",
"\n",
"\n",
">>> animaux = [ani1, ani2]\n",
">>> animaux\n",
"[{'nom': 'girafe', 'poids': 1100, 'taille': 5.0}, {'nom': 'singe',\n",
"'poids': 70, 'taille': 1.75}]\n",
">>>\n",
">>> for ani in animaux:\n",
"... print(ani['nom'])\n",
"...\n",
"girafe\n",
"singe\n",
"Vous constatez ainsi que les dictionnaires permettent de gérer des structures complexes de manière plus explicite que les listes.\n",
"\n",
"13.2 Tuples\n",
"Les tuples (« n-uplets » en français) correspondent aux listes à la différence qu'ils sont non modifiables. On a vu dans le chapitre 11 Plus sur les listes que les listes pouvaient être modifiées par références, notamment lors de la copie de listes. Les tuples s'affranchissent de ce problème puisqu'ils sont non modifiables. Pratiquement, ils utilisent les parenthèses au lieu des crochets :\n",
"\n",
"\n",
">>> x = (1, 2, 3)\n",
">>> x\n",
"(1, 2, 3)\n",
">>> x[2]\n",
"3\n",
">>> x[0:2]\n",
"(1, 2)\n",
">>> x[2] = 15\n",
"Traceback (innermost last):\n",
"File \"<stdin>\", line 1, in ?\n",
"TypeError: object doesn't support item assignment\n",
"L'affectation et l'indiçage fonctionnent comme avec les listes. Mais si on essaie de modifier un des éléments du tuple, Python renvoie un message d'erreur. Si vous voulez ajouter un élément (ou le modifier), vous devez créer un autre tuple :\n",
"\n",
"\n",
">>> x = (1, 2, 3)\n",
">>> x + (2,)\n",
"(1, 2, 3, 2)\n",
" Remarque\n",
"Pour utiliser un tuple d'un seul élément, vous devez utiliser une syntaxe avec une virgule (element,), ceci pour éviter une ambiguïté avec une simple expression.\n",
"\n",
"Autre particularité des tuples, il est possible d'en créer de nouveaux sans les parenthèses, dès lors que ceci ne pose pas d'ambiguïté avec une autre expression :\n",
"\n",
"\n",
">>> x = (1, 2, 3)\n",
">>> x\n",
"(1, 2, 3)\n",
">>> x = 1, 2, 3\n",
">>> x\n",
"(1, 2, 3)\n",
"Toutefois, nous vous conseillons d'utiliser systématiquement les parenthèses afin d'éviter les confusions.\n",
"\n",
"Enfin, on peut utiliser la fonction tuple(sequence) qui fonctionne exactement comme la fonction list(), c'est-à-dire qu'elle prend en argument un objet séquentiel et renvoie le tuple correspondant (opération de casting) :\n",
"\n",
"\n",
">>> tuple([1,2,3])\n",
"(1, 2, 3)\n",
">>> tuple(\"ATGCCGCGAT\")\n",
"('A', 'T', 'G', 'C', 'C', 'G', 'C', 'G', 'A', 'T')\n",
" Remarque\n",
"Les listes, les dictionnaires et les tuples sont des objets qui peuvent contenir des collections d'autres objets. On peut donc construire des listes qui contiennent des dictionnaires, des tuples ou d'autres listes, mais aussi des dictionnaires contenant des tuples, des listes, etc.\n",
"\n",
"Pratiquement, nous avons déjà croisé les tuples avec la fonction enumerate() dans le chapitre 5 Boucles et comparaisons qui renvoie l'indice de l'élément et l'élément d'une liste, ainsi dans le chapitre 9 Fonctions lorsqu'on voulait qu'une fonction renvoie plusieurs valeurs (par exemple dans l'instruction return x,y, le couple x,y est un tuple). Cela revenait à faire une affectation multiple du type x, y = 1, 2.\n",
"\n",
"13.3 Exercices\n",
"Conseil : pour ces exercices, créez des scripts puis exécutez-les dans un shell.\n",
"\n",
"13.3.1 Composition en acides aminés\n",
"En utilisant un dictionnaire, déterminez le nombre d’occurrences de chaque acide aminé dans la séquence AGWPSGGASAGLAILWGASAIMPGALW. Le dictionnaire ne doit contenir que les acides aminés présents dans la séquence.\n",
"\n",
"13.3.2 Mots de 2 et 3 lettres dans une séquence d'ADN\n",
"Créez une fonction compte_mots_2_lettres() qui prend comme argument une séquence sous la forme d'une chaîne de caractères et qui renvoie tous les mots de 2 lettres qui existent dans la séquence sous la forme d'un dictionnaire. Par exemple pour la séquence ACCTAGCCCTA, le dictionnaire renvoyée serait :\n",
"{'AC': 1, 'CC': 3, 'CT': 2, 'TA': 2, 'AG': 1, 'GC': 1}\n",
"\n",
"Créez une nouvelle fonction compte_mots_3_lettres() qui a un comportement similaire à compte_mots_2_lettres() mais avec des mots de 3 lettres.\n",
"\n",
"Utilisez ces fonctions pour affichez les mots de 2 et 3 lettres et leurs occurrences trouvés dans la séquence d'ADN :\n",
"ACCTAGCCATGTAGAATCGCCTAGGCTTTAGCTAGCTCTAGCTAGCTG\n",
"\n",
"Voici un exemple de sortie attendue :\n",
"\n",
"\n",
"Mots de 2 lettres\n",
"AC : 1\n",
"CC : 3\n",
"CT : 8\n",
"[...]\n",
"Mots de 3 lettres\n",
"ACC : 1\n",
"CCT : 2\n",
"CTA : 5\n",
"[...]\n",
"13.3.3 Mots de 2 lettres dans la séquence du chromosome I de Saccharomyces cerevisiae\n",
"Créez une fonction lit_fasta() qui prend comme argument le nom d'un fichier FASTA sous la forme d'une chaîne de caractères, lit la séquence dans le fichier FASTA et la renvoie sous la forme d'une chaîne de caractères. N'hésitez pas à vous inspirer d'un exercice similaire du chapitre 10 Plus sur les chaînes de caractères.\n",
"\n",
"Utilisez cette fonction et la fonction compte_mots_2_lettres() de l'exercice précédent pour extraire les mots de 2 lettres et leurs occurrences dans la séquence du chromosome I de la levure du boulanger Saccharomyces cerevisiae (fichier NC_001133.fna).\n",
"\n",
"Le génome complet est fourni au format FASTA. Vous trouverez des explications sur ce format et des exemples de code dans l'annexe A Quelques formats de données rencontrés en biologie.\n",
"\n",
"13.3.4 Mots de n lettres dans un fichier FASTA\n",
"Créez un script extract-words.py qui prend comme arguments le nom d'un fichier FASTA suivi d'un entier compris entre 1 et 4. Ce script doit extraire du fichier FASTA tous les mots et leurs occurrences en fonction du nombre de lettres passé en option.\n",
"\n",
"Utilisez pour ce script la fonction lit_fasta() de l'exercice précédent. Créez également la fonction compte_mots_n_lettres() qui prend comme argument une séquence sous la forme d'une chaîne de caractères et le nombre de lettres des mots sous la forme d'un entier.\n",
"\n",
"Testez ce script avec :\n",
"\n",
"la séquence du chromosome I de la levure du boulanger Saccharomyces cerevisiae (fichier NC_001133.fna)\n",
"le génome de la bactérie Escherichia coli (fichier NC_000913.fna)\n",
"Les deux fichiers sont au format FASTA.\n",
"\n",
"Cette méthode vous paraît-elle efficace sur un génome assez gros comme celui d'Escherichia coli ?\n",
"\n",
"13.3.5 Atomes carbone alpha d'un fichier PDB\n",
"Téléchargez le fichier 1bta.pdb qui correspond à la structure tridimensionnelle de la protéine barstar sur le site de la Protein Data Bank (PDB).\n",
"\n",
"Créez la fonction trouve_calpha() qui prend en argument le nom d'un fichier PDB (sous la forme d'une chaîne de caractères), qui sélectionne uniquement les lignes contenant des carbones alpha et qui les renvoie sous la forme d'une liste de dictionnaires. Chaque dictionnaire contient quatre clés :\n",
"\n",
"le numéro du résidu (resid) avec une valeur entière,\n",
"la coordonnée atomique x (x) avec une valeur float,\n",
"la coordonnée atomique y (y) avec une valeur float,\n",
"la coordonnée atomique z (z) avec une valeur float.\n",
"Utilisez la fonction trouve_calpha() pour afficher à l'écran le nombre total de carbones alpha de la barstar ainsi que les coordonnées atomiques des carbones alpha des deux premiers résidus (acides aminés).\n",
"\n",
"Conseil : vous trouverez des explications sur le format PDB et des exemples de code pour lire ce type de fichier en Python dans l'annexe A Quelques formats de données rencontrés en biologie.\n",
"\n",
"13.3.6 Barycentre d'une protéine (exercice +++)\n",
"Téléchargez le fichier 1bta.pdb qui correspond à la structure tridimensionnelle de la protéine barstar sur le site de la Protein Data Bank (PDB).\n",
"\n",
"Un carbone alpha est présent dans chaque résidu (acide aminé) d'une protéine. On peut obtenir une bonne approximation du barycentre d'une protéine en calculant le barycentre de ses carbones alpha.\n",
"\n",
"Le barycentre \n",
"G\n",
" de coordonnées (\n",
"G\n",
"x\n",
", \n",
"G\n",
"y\n",
", \n",
"G\n",
"z\n",
") est obtenu à partir des \n",
"n\n",
" carbones alpha (CA) de coordonnées (\n",
"C\n",
"A\n",
"x\n",
", \n",