# 🧬 Python pour les biologistes — Fonctions, `map`, `lambda` et `zip`
## 🧪 Exercice 1 — Calculer le contenu GC d’une séquence d’ADN
**Contexte :** Le contenu en bases G et C (contenu GC) est un indicateur important en génomique, car il influence la stabilité de l’ADN et l’expression des gènes.
**Consigne :**
1. Écrivez une fonction `gc_content(seq)` qui prend une séquence d’ADN et renvoie le pourcentage de GC.
Appliquez ensuite cette fonction à une liste de séquences.
2. Utilisez `map` pour calculer le contenu GC de toutes les séquences d’une liste.
```python
# Données d'exemple
sequences = ["ATGCGC", "TTTTAA", "GCGCGC", "ATATAT"]
```
<details>
<summary>đź’ˇ Correction</summary>
```python
# Q1
def gc_content(seq):
seq = seq.upper()
gc_count = seq.count("G") + seq.count("C")
return round(gc_count / len(seq) * 100, 2)
sequences = ["ATGCGC", "TTTTAA", "GCGCGC", "ATATAT"]
for s in sequences:
print(f"{s}: {gc_content(s)}% GC")
```
</details>
<details>
<summary>đź’ˇ Correction</summary>
```python
# Q2
gc_values = list(map(gc_content, sequences))
print(gc_values)
```
</details>
---
## 🌿 Exercice 2 — Normaliser des valeurs d’expression génique
**Contexte :**
En analyse transcriptomique, on compare souvent des niveaux d’expression génique entre gènes ou échantillons.
Pour rendre ces valeurs comparables, il est courant de **normaliser** les données entre 0 et 1.
**Consigne :**
Vous disposez d’une liste de valeurs d’expression d’un échantillon.
Écrivez une fonction `normalize(values)` qui :
1. Calcule le minimum et le maximum des valeurs.
2. Applique une transformation pour que chaque valeur soit comprise entre 0 et 1 :
$$ x_{\text{norm}} = \frac{x - \min(x)}{\max(x) - \min(x)}$$
3. Utilisez `map()` pour appliquer cette normalisation Ă toutes les valeurs.
```python
# Données d'exemple
expression = [10.0, 25.0, 30.0, 15.0, 50.0]
```
<details>
<summary>đź’ˇ Correction</summary>
```python
def normalize(values):
min_v = min(values)
max_v = max(values)
return list(map(lambda x: round((x - min_v) / (max_v - min_v), 2), values))
expression = [10.0, 25.0, 30.0, 15.0, 50.0]
normalized = normalize(expression)
print("Valeurs d'origine :", expression)
print("Valeurs normalisées :", normalized)
```
**Sortie attendue :**
```
Valeurs d'origine : [10.0, 25.0, 30.0, 15.0, 50.0]
Valeurs normalisées : [0.0, 0.38, 0.5, 0.13, 1.0]
```
</details>
---
## 🧫 Exercice 3 — Associer les séquences à leurs identifiants avec `zip`
**Contexte :** En bioinformatique, les séquences sont souvent associées à des identifiants uniques.
**Consigne :**
On dispose de deux listes : une liste d’identifiants et une liste de séquences. Combinez-les en une liste de tuples.
```python
ids = ["seq1", "seq2", "seq3", "seq4"]
sequences = ["ATGCGC", "TTTTAA", "GCGCGC", "ATATAT"]
```
<details>
<summary>đź’ˇ Correction</summary>
```python
paired = list(zip(ids, sequences))
print(paired)
```
</details>
---
## 🧠Exercice 4 — Utiliser `lambda` pour transformer des données
**Contexte :** Un biologiste souhaite convertir des niveaux d’expression génique exprimés en log2 vers une échelle linéaire.
**Consigne :**
```python
log_expr = [1.0, 2.5, -1.0, 0.0]
# convertir chaque valeur : valeur = 2**x
```
<details>
<summary>đź’ˇ Correction</summary>
```python
log_expr = [1.0, 2.5, -1.0, 0.0]
linear_expr = list(map(lambda x: 2 ** x, log_expr))
print(linear_expr)
```
</details>
---
## 🧍‍♀️ Exercice 5 — Combiner `zip`, `map` et `lambda`
**Contexte :** On dispose de deux jeux de données d’expression génique (deux expériences).
On souhaite calculer **l’expression moyenne par gène**.
**Consigne :**
```python
genes = ["geneA", "geneB", "geneC"]
expr1 = [10.0, 5.0, 12.0]
expr2 = [8.0, 7.0, 9.0]
```
<details>
<summary>đź’ˇ Correction</summary>
```python
genes = ["geneA", "geneB", "geneC"]
expr1 = [10.0, 5.0, 12.0]
expr2 = [8.0, 7.0, 9.0]
averages = list(map(lambda x: (x[0] + x[1]) / 2, zip(expr1, expr2)))
for g, avg in zip(genes, averages):
print(f"{g}: {avg}")
```
</details>
---
Sign in with Wallet
Connect another wallet