# Bases de Python - Partie 1

## Qu'est-ce que Python ?

Python est un langage de programmation **interprété** et **multiplateformes** sous **licence libre**. 
- **interprété** : contrairement aux langages compilés comme le C ou le C++, Python analyse le code et le traduit en langage machine à la volée, lors de son exécution, et à chaque fois qu'il est exécuté. Il a donc besoin d'un interpréteur : l'exécutable Python
- **multiplateformes** : Un même programme python est compatible avec plusieurs systèmes d'exploitation : Linux, Windows, MacOS... 
- **Licence libre** : L'ensemble du langage, sa spécification ainsi que CPython, l'interpréteur classique, est libre, c'est à dire qu'elle permet aux utilisateurs de l'utiliser, l'étudier pour le comprendre ou l'adapter, le modifier, et le diffuser à d'autres utilisateurs

## Mode interactif ou script

Il existe deux modes d'utilisation de Python

### Mode interactif

Cela nous permettra de saisir des instructions, que Python va exécuter. On utilise souvent ce mode pour essayer des choses ou comprendre des mécanismes.

Le mode interactif fonctionne de la manière suivante : 
1. Il y a une **invite de commande**, qui est symbolisée par les `>>>`. Comme son nom l'indique, elle est là pour vous inviter à taper une commande.
2. Vous pouvez taper une commande et la valider avec la touche <kbd>Entrée</kbd>
3. Il **évalue l'expression saisie** : il l'analyse et l'exécute
4. Il affiche enfin le résultat.

```admonish tip title="Astuce"
Si vous utilisez les flèches <kbd>&uarr;</kbd> et <kbd>&darr;</kbd> dans l'invite de commande, vous pourrez naviguer dans l'historique des commandes tapées, et réutiliser d'anciennes commandes pour les modifier ou les réexécuter.
```

### Script

On peut aussi utiliser Python avec des fichiers contenant le programme. C'est la manière la plus courante de faire pour avoir un programme qu'on peut réutiliser au cours du temps.
Un fichier contenant du code Python s'appelle un **script**. Les scripts python ont un nom se finissant par l'**extension** `.py`.

Pour cela, il faut éditer un fichier avec un **éditeur de texte**, et l'exécuter avec la commande suivante : `python mon_fichier.py`.

```admonish success title='À retenir'
Un **éditeur de texte** est différent d'un **logiciel de traitement de texte**.
- Un éditeur de texte permet de manipuler du texte brut, sans mise en forme. Il pourra avoir des fonctionnalités de coloration automatique ou de suggestions pour vous aider à écrire dans des langages de programmation. Ex: VSCode, Notepad++, Geany, Gedit, Kate, Sublime Text (non libre)...
- Un logiciel de traitement de texte ne peut pas être utilisé pour écrire du code : il contient de nombreuses informations de mise en forme et travaille généralement avec des fichiers binaires ou un format spécifique très éloigné du texte brut nécessaire à la programmation. Ex: Libre Office Writer, Only Office Document, Microsoft Office Word (non-libre)
```

### Utilisation de Thonny

Pour écrire du code Python, nous allons dans un premier temps utiliser le logiciel Thonny, qui vous donne accès à la fois à l'interpréteur Python et vous permet d'écrire et exécuter des scripts très simplement.

Pour cela, commençons par lancer le logiciel Thonny. Cliquez sur le menu en bas à gauche dans Windows, puis recherchez Thonny.

```admonish tip title="Astuce"
Thonny est un logiciel qui va nous permettre d'utiliser très simplement Python. Il est libre, c'est à dire que vous pouvez l'utiliser librement et gratuitement, y compris chez vous. N'hésitez donc pas à l'installer sur votre propre machine pour vous entraîner à écrire du Python chez vous, ou préparer vos exercices. 

Vous pourrez le trouver sur ce site : https://thonny.org/
```

Vous verrez dans le logiciel plusieurs encadrés :
- Un premier encadré représentant le fichier
- Un second intitulé `Console` dans lequel vous trouverez un interpréteur Python.
- Eventuellement un troisième appelé `Assistant` qui vous aidera à comprendre vos erreurs.

![Thonny init](thonny.png)

## Variables

- Une variable est un espace mémoire dans lequel l'ordinateur stocke une information.

- Cette information peut être un nombre, une chaîne de caractères, ou des données plus complexes.

- Elles sont nommées et on peut les **affecter** en écrivant `ma_variable = <contenu de ma variable>` (attention la variable est toujours à gauche, le contenu toujours à droite). Affecter signifie mettre un contenu dans la variable.

- Les noms des variables en Python :
    - Peuvent comporter des caratères **alphanumériques**, c'est à dire des lettres minuscules ou majuscules et des chiffres
    - Peuvent comporter des `_` (tiret du bas, sur la touche <kbd>8</kbd> de votre clavier)
    - Les noms des variables ne peuvent pas commencer par un chiffre
    - Les noms des variables sont **sensibles à la casse** : c'est à dire qu'une variable écrite avec des majuscules sera différente d'une variable écrite avec des minuscules (par exemple ma variable `age` sera différente de `Age`)
    - Certains mots-clés ne peuvent pas être utilisés comme des noms de variables parce qu'ils sont **réservés**, c'est à dire qu'ils ont une autre signification dans le langage. Vous les verrez plus tard, mais vous pouvez trouver la liste [ici](https://docs.python.org/3/reference/lexical_analysis.html#keywords)

```admonish tip title="Convention"
En python, la **convention** veut que l'on écrive les variables sous la forme dite `snake_case` (imaginez un serpent qui rampe au sol) : on va l'écrire avec uniquement des minuscules en remplaçant les espaces par des `_`. Par exemple, une variable représentant la date de naissance pourra s'écrire : `date_de_naissance`

Une autre façon d'écrire serait le `camelCase` (imaginez les bosses du chameau), où chaque mot commence par une majuscule. C'est utilisé aussi en Python mais nous verrons plus tard dans quels cas. Ce n'est pas utilisé pour les variables.
```

```admonish warning title="Important"
Python utilise beaucoup de **conventions** dans son langage. Une convention est une règle qui n'est pas obligatoire mais que tout le monde respecte par habitude, parce que cela permet d'avoir un code qui est facile à lire par tout le monde. 

Même si elles sont parfois arbitraires, elles ont en général été pensées et établies par la communauté suite à des retours d'expérience. Par ailleurs, certaines conventions permettent de donner des informations supplémentaires importantes (nous en verrons régulièrement par la suite). 

Pour la suite de ce TP, mais également dans vos TD, projets ou évaluations, vous devrez respecter les conventions que nous verrons pour prendre les bonnes habitudes, sinon je les considèrerai comme des erreurs.
```

## Types

Les variables peuvent contenir differents **types** de données. Chaque type a son utilité pour représenter une donnée particulière. Il en existe des simples, ci-dessous, ou de plus complexes que nous verrons plus tard.

- Python est capable de trouver le type d'une donnée tout seul, et la variable prend le type souhaité lors de l'affectation. On appelle ça du **typage dynamique**
- Python possède une fonction `type` qui permet d'afficher le type de chaque variable. On l'appelle de la manière suivante : `type(ma_variable)`

Voici un tableau recensant les principaux types de base de Python

| Type | Explication | Exemple |
|------|-------------|---------|
| int  | Nombre entier | `1` |
| float | Nombre décimal (à virgule "flottante") | `1.23` |
| bool | Booléen : une valeur pouvant être soit vraie soit fausse | `True` ou `False` |
| str | Chaîne de caractères : des caractères qui se suivent pour représenter du texte | `'Hello !'` |


```admonish warning title="Attention"
Python utilise la notation anglo-saxonne pour les nombres non entiers (c'est à dire un point au lieu d'une virgule) : on écrira `4.5` et non pas `4,5`.
```

### Conversions

Il est possible, *dans certains cas* de convertir des variables d'un type à un autre. On utilisera pour cela le type dans lequel on veut convertir comme une fonction. Les conversions sont possibles entre la plupart des types courants.

```admonish example title="Exemple"
On récupère le texte `"22"` dans la variable `ma_variable` depuis une saisie utilisateur. Pour traiter ce texte comme un nombre entier, on écrira `int(ma_variable)`.
```

## Afficher et saisir du texte

### Afficher du texte
- La fonction `print` permet d'afficher des chaînes de caractères et/ou des variables.
- Elle peut prendre plusieurs arguments, et affichera les arguments séparés par un espace

```admonish example title="Exemple"
~~~python
>>> print("Je veux afficher ce texte")
Je veux afficher ce texte

>>> print("Je veux afficher ce texte", "Puis celui-ci")
Je veux afficher ce texte Puis celui-ci
~~~
```

### Saisir du texte
- La fonction `input` permet de demander à la personne utilisant votre programme de saisir du texte
- Elle prend en argument optionnel une chaîne de caractère qui s'affichera avant la saisie

```admonish example title="Exemple"
~~~python
input("Veuillez saisir un nombre")
~~~
```

```admonish tip title="Astuces"
- Elle renvoie ce qui a été saisi sous forme d'une chaîne de caractères. Il faut donc penser à convertir si vous avez besoin d'un autre type.
- Le résultat de la fonction peut être immédiatement affecté à une variable.

~~~python
ma_variable = int(input("Veuillez saisir un nombre"))
~~~
```


### Les chaînes de caractères

Les chaînes de caractères sont des suites de caractères représentant du texte.

Les chaînes de caractères peuvent s'écrire avec des guillemets simples `'` (touche <kbd>4</kbd>) (qui est aussi utilisé en apostrophe en français) ou des guillemets doubles `"` (touche <kbd>3</kbd>).

Vous pourrez utiliser des `"` lorsque que votre chaîne contiendra des `'` et inversement. Exemples:
- `"J'aime les spaghettis"`
- `'Elle a dit "Hello"'`

Les chaînes de caractères peuvent être **formatées** : 
- On écrira `f"chaine de caractère {variable}"`, 
- Cela va remplacer les variables entre accolades `{}` par leur valeur dans la chaîne de caractères. 
- Le `f` avant les guillemets est important car il permet de dire à Python que la chaîne est formatée. Si vous l'oubliez, il ne cherchera pas à remplacer les variables par leur valeur.

```python
mon_age = 22
print(f"J'ai {mon_age} ans")

# Résultat affiché :
# J'ai 22 ans
```

Les chaînes formatées sont très utilisées en python. Elles servent à afficher des informations dynamiques en fonction de variables, mais vous aideront aussi à comprendre ce que font vos programmes et vous aider à les corriger.

## Opérateurs
Les opérateurs sont des symboles permettant d'effectuer des calculs. Il en existe de nombreux en python.

### Opérateurs de calcul

Voici les principaux opérateurs mathématiques :

|Opérateur|Explication|
|-|-|
|`+`|Addition|
|`-`|Soustraction|
|`*`|Multiplication|
|`/`|Division|
|`//`|Division entière (renvoie un quotient entier)|
|`%`|Modulo (renvoie le reste de la division euclidienne)|
|`**`|Puissance|

```admonish example title="Exemples"
~~~python
>>> 3+4
7
>>> 3-1
2
>>> 2*2
4
>>> 5/3
1.6666666666666667
>>> 5//3
1
>>> 5%3
2
>>> 10**3
1000
~~~
```

### Opérateurs de comparaison

|Opérateur|Description|
|---------|-----------|
|`==`| Égal à|
|`!=`| Différent de|
|`<`| Strictement inférieur à|
|`>`| Strictement supérieur à|
|`<=`| Inférieur ou égal à|
|`>=`| Supérieur ou égal à|

```admonish warning title="Attention"
Attention, l'opérateur d'égalité est bien `==`, et non pas `=`. Utiliser l'opérateur d'affectation `=` pourra produire un code qui s'exécute, mais n'aura pas le résultat que vous attendez.
```

```admonish example title="Exemples"
~~~python
>>> 2 == 4
False
>>> 3 != '3'
True
>>> 3 < 4
True
>>> 3 <= 3
True
~~~
```

### Opérateurs booléens

Les **opérateurs booléens** servent à faire des opérations avec des types `bool` ou pour créer des conditions plus complexes.

|Opérateur| Description|
|---------|------------|
|`and`| Si les deux conditions sont vraies, retourne `True`, sinon `False`|
|`or` | Si **au moins** l'une des deux conditions est vraie, retourne `True`, sinon `False`|
|`not`| Inverse le résultat de la condition|

Les opérateurs booléens peuvent être chainés et combinés pour faire des conditions plus complexes.

Les nombres (et plein d'autres types) peuvent être considérés comme `True` ou `False` dans une condition (ou convertis avec la fonction `bool`).
- Un entier non nul sera considéré comme `True`, un `0` sera considéré comme `False`
- Une chaîne de caractères sera considérée comme `True`, sauf si elle est vide. 

```admonish tip title="Astuce"
Les opérateurs `>`, `<`, `>=`, `<=` peuvent être chaînés pour faire des comparaisons d'intervalles. Par exemple, pour vérifier que la variable a est comprise entre 0 et 100, vous pouvez écrire '0 < a < 100'
```

```admonish example title="Exemples"
~~~python
>>> True and True
True
>>> 3 < 4 or 6 == 4
True
>>> not 0 != 0
True
~~~
```

### Opérateurs bit à bit

Les **opérateurs bit à bit** servent à appliquer des opérations logiques bit à bit entre deux nombres. Ils sont différents des opérateurs booléens qui eux s'appliquent entre deux booléens. Dit autrement les opérateurs booléens vont faire une opération logique entre des valeurs True ou False, alors que les opérateurs bit à bit travaillent avec la représentation binaire du nombre et vont effectuer des opérations logiques entre tous les bits de même rang.

|Opérateur|Description|
|-|-|
|`&`|Applique l'opération ET logique bit à bit entre les deux éléments|
|`|`|Applique l'opération OU logique bit à bit entre les deux éléments|
|`^`|Applique l'opération XOR (ou exclusif) logique bit à bit entre les deux éléments|
|`~`|Applique l'opération NOT (inversion) logique bit à bit entre les deux éléments|

```admonish example title="Exemples"
Dans l'exemple ci dessous, la fonction `bin` permet d'afficher le résultat sous forme binaire, pour vous aider à comprendre ce que font les opérateurs
~~~python
>>> bin(0b1111 & 0b0101)
'0b101'
>>> bin(0b1111 | 0b0101)
'0b1111'
>>> bin(0b1111 ^ 0b0101)
'0b1010'
>>> bin(~0b1111)
'-0b10000'
~~~
```

### Autres usages des opérateurs en Python

Certains opérateurs peuvent être utilisés avec des types spécifiques et avoir une signification différente avec ce type précis. Nous en verrons en temps et en heure.

Par exemple, l'opérateur `+` entre deux chaînes de caractères vient les concaténer (c'est à dire les coller bout à bout). En effet, l'addition (au sens mathématique) de chaînes de caractères n'a aucun sens, mais la concaténation de chaînes de caractères est un besoin courant.
