---
# System prepended metadata

title: 'Cours, pour Coco'

---

# Cours, pour Coco
Voici le petit cours d'informatique pour Coline que j'ai préparé au fur et à mesure des vacances d'Octobre.

# Fondamentaux
## Types de Variables
[...]
### Listes
#### Méthodes
- `list[i]` renvoie le `i`ème élément d'une liste
- `list.append(x)` ajoute l'élément `x` à la fin de la liste.
- `list1.extend(list2)` ajoute `liste2` à la fin de `liste1`

# Control Flow
## Tests
[...]
## Boucles
En python, il y a 2 types de boucles:
- ### Forloops
#### Définition
Une forloop permet d'exécuter un bloc indenté pour chaque valeur d'un itérateur, en la nommant.
#### Syntaxe
```py
for name in iterator:
    run_code()
```
#### Itérateurs Utiles
Quelques itérateurs prédéfinis existent en Python:
- `range(n)` -> `0, 1, ..., n-1`
- `range(a, b)` -> `s, s+1, ..., e-1`
- `range(a, b, c)` -> `a, a+c, ..., b`
- `enumerate(I)` -> `(0, I[0]), (1, I[1]), ..., (n, I[n])`
#### Exemples
```py=
# affiche tous les nombres de 0 à 11
for n in range(12):
    print(n)
    
# affiche tous les nombres pairs de 0 à 143
for n in range(0, 144, 2):
    print(n)
    
# calcule la moyenne d'une liste de donnée
data = read_data_from_somewhere()
sum = 0. # initializes a var to store the sum
for val in data:
    sum += val # adds the value to the sum
mean = sum / len(data)
print(mean)
    
# Donne un bonbon à tout le monde pour Halloween
for person in [Maxime, Coline,]: 
    # ici, les personnes sont des objets définis autre part
    person.bonbons += 1
```
#### Cas Utiles
Les boucles sont utiles pour faire des totaux, ou effectuer un changement sur toute une série de données.
#### Exercices
1. On vous donne le programme suivant:
```python=
my_list = [48, 26, 44, 32, 78, 54, 61]
def one_more(l):
    result = []
    for item in l:
        result.append(item + 1)
    return result
```
Prédire le résultate de `one_more(my_list)`, de `one_more(one_more(my_list))` et de `one_more(3)`.
Écrire un programme qui renvoie une liste constituée du double de chaque élément d'une liste d'entrée.
```python=
def double_elem(input_list):
    ...
    for ... in ...:
        ...
    return ...
```
2. Voici un programme calculant une suite $s$ telle que $s_n = s_{n-1} * 2$ et que $s_0 = 1$, jusqu'à l'élément $x$:
```python=
def suite_double(x):
    suite = [1, ]
    for n in range(x):
        # suite[n] est l'élément généré juste avant
        next = suite[n] * 2
        suite.append(next)
    return suite
suite_double(3) == [1, 2, 4, 8] # True
```
Calculer, de la même façon la suite de Fibonacci telle que $F_n = F_{n-1} + F_{n-2}$, sachant que $F_0 = 0$ et que $F_1 = 1$.
Indice: `suite[n]` et `suite[n-1]` correspondent à $F_{n-1}$ et $F_{n-2}$

#### Approfondissements
[...]
- ### Whileloops
[...]

### Boucles Récursives
Et voici un concept plus difficile...