📋 Antisèches Python

Antisèches Python

Les extraits auxquels vous reviendrez à chaque leçon. Le code s’exécute dans les cellules ci-dessus ; voici les motifs à copier.

Variables
- Affecter et lire
```
x = 5
x = x + 1   # 6
print(x)    # 6
```
  = range une valeur sous un nom. Réaffecter ne fait que pointer le nom vers la nouvelle valeur.
- Règles de nommage
```
score = 10      # snake_case ✅
age_2 = 3       # digits ok after first char
age 2 = 3       # ❌ space & leading digit
Score = 10      # works, but remember: case-sensitive
```
  Les noms sont sensibles à la casse. Utilisez snake_case, des noms descriptifs, et évitez les mots réservés comme print.
- Échange et décomposition
```
a, b = 1, 2
a, b = b, a   # swap in one line
first, *rest = [1, 2, 3]  # first=1, rest=[2, 3]
```
  Python affecte plusieurs noms à la fois — le plus propre des échanges.
Sortie
- print
```
print('Hello, world!')
print(2 + 3)      # 5, values print automatically
```
  La seule fonction que vous utiliserez à chaque leçon.
- Séparateur
```
print('a', 'b', sep='-')   # a-b
```
  sep contrôle le séparateur ; par défaut, c’est une espace.
Entrée
- Lire l’invite
```
name = input('Your name: ')
print('Hi', name)
```
  input() fait une pause et attend ; elle renvoie TOUJOURS une chaîne.
- Convertir
```
age = int(input('Age: '))
price = float(input('Price: '))
```
  Convertissez à la lecture avec int()/float(), sinon chaque étape de calcul échouera ensuite.
Nombres
- Arithmétique de base
```
x = 7
x // 2   # 3  integer division
x % 2    # 1  remainder
x ** 2   # 49 exponent
```
  // et % forment un duo — ils répondent « combien de fois » et « combien reste-t-il ».
- type()
```
type(3)     # <class 'int'>
type(3.0)   # <class 'float'>
type("3")   # <class 'str'>
```
  Vérifiez le type de n’importe quelle valeur quand une erreur évoque un décalage de type.
- Conversion
```
int('42')   # 42
float('4.2')
str(42)     # '42'
```
  input() renvoie toujours une chaîne — convertissez avant de faire des calculs.
Chaînes
- f-strings
```
name = 'PyDA'
print(f'{name} → {len(name)} letters')
```
  Le f avant le guillemet fait insérer les valeurs des {…}. Utilisez ça, pas la concaténation.
- Méthodes
```
'  hi  '.strip()   # 'hi'
'hello'.upper()   # 'HELLO'
'a,b'.split(',')   # ['a', 'b']
```
  Les méthodes renvoient une NOUVELLE chaîne — les chaînes sont immuables.
- Découpage
```
word = 'python'
word[0]    # 'p'
word[-1]   # 'n'
word[1:4]  # 'yth'
```
  Le début est inclus, la fin exclue. Les index négatifs comptent depuis la fin.
- Combiner, répéter, chercher
```
'py' + 'thon'    # 'python'
'ha' * 3        # 'hahaha'
'py' in 'python'  # True
len('abc')        # 3
```
  + colle les chaînes, * les répète, in teste la présence d’une sous-chaîne, len() compte les caractères.
- Échappements antislash
```
print('she\'s fine')   # she's fine
print('line1\nline2')  # two lines
print('tab\there')      # tab       here
```
  \' est un guillemet, \n un saut de ligne, \t une tabulation. Utilisez les chaînes brutes r"…" quand un chemin contient trop d’antislashs.
Listes
- Construire et ajouter
```
nums = [1, 2, 3]
nums.append(4)      # [1, 2, 3, 4]
nums + [5]        # [1, 2, 3, 4, 5]
```
  append modifie la liste sur place ; + en crée une nouvelle.
- Lire
```
nums[0]      # 1
len(nums)    # 4
nums[-1]     # 4
3 in nums    # True
```
  in / not in sont les vérifications d’appartenance.
- Parcourir
```
for n in nums:
    print(n * 2)
```
  La boucle for atteint chaque élément un par un.
- Trier et copier
```
nums.sort()          # in place
sorted(nums)         # NEW sorted list
copy = nums[:]       # real copy, not the same list
```
  sort() modifie la liste et renvoie None ; sorted() renvoie une nouvelle. Utilisez nums[:] pour travailler sur une copie.
- Astuces de découpage
```
nums = [0, 1, 2, 3, 4]
nums[1:]    # [1, 2, 3, 4]  drop the head
nums[:-1]   # [0, 1, 2, 3]  drop the tail
nums[::-1]  # [4, 3, 2, 1, 0]  reversed
```
  La forme [start:end:step] est la chirurgie des listes — supprimer, copier et inverser en une ligne.
Tuples et Ensembles
- Tuples
```
t = (1, 2, 3)
t[0]        # 1
x, y = t        # unpack
# t[0] = 9      # ❌ tuples can't change
```
  Une liste figée — utilisez-la quand la forme ne doit pas changer : coordonnées, paires de config, données en lecture seule.
- Ensembles
```
s = {1, 2, 2, 3}   # {1, 2, 3} — duplicates dropped
s.add(4)
4 in s        # True
s.remove(4)
```
  Un sac non ordonné d’éléments uniques — idéal pour dédupliquer et pour des tests d’appartenance rapides.
- Opérations d’ensembles
```
a = {1, 2, 3}
b = {3, 4}
a | b       # {1, 2, 3, 4}  union
a & b       # {3}           intersection
a - b       # {1, 2}        difference
a ^ b       # {1, 2, 4}     symmetric
```
  | , & , - , ^ transforment les ensembles en calcul en une ligne — comparez des groupes sans boucles imbriquées.
- Quel conteneur ?
```
list    # ordered, editable, keeps order
tuple   # ordered, read-only
set     # unordered, unique, fast in
dict    # key → value lookup
```
  Choisissez selon ce dont le code a besoin : l’ordre, l’unicité, ou retrouver des choses par leur nom.
Dictionnaires
- Construire et lire
```
ages = {'ada': 36, 'bob': 41}
ages['ada']        # 36
ages.get('zoe')    # None (safe "missing")
ages.get('zoe', 0) # 0 (with default)
```
  Utiliser [key] sur une clé absente lève KeyError — préférez .get() quand vous n’êtes pas sûr.
- Écrire
```
ages['ada'] = 37
ages['zoe'] = 22
del ages['bob']
```
  L’affectation ajoute ou met à jour ; del supprime une clé.
- Itérer
```
for k, v in ages.items():
    print(k, v)
```
  .items() donne des paires (clé, valeur) ; .keys() et .values() n’en donnent qu’un côté.
Conditionnelles
- if / elif / else
```
if score >= 90:
    print("A")
elif score >= 80:
    print("B")
else:
    print("C")
```
  elif s’arrête dès qu’une condition est vraie — l’ordre compte.
- Comparaisons
```
==  !=  <  <=  >  >=
```
  == teste l’égalité ; = affecte. S’en souvenir corrige la plupart des bugs « pourquoi c’est True ».
- Opérateurs booléens
```
a and b    # both truthy
a or b     # at least one
a and not b
```
  and / or / not — les mots simples, pas && ni ! comme dans d’autres langages.
- Véracité
```
if x:             # 'is x non-empty?'
    print(x)
# Falsy: 0, 0.0, '', [], {}, None
# Everything else is truthy
```
  « if x: » est le « est-ce que x est là ? » idiomatique — les conteneurs vides et 0 échouent, tout le reste passe.
- Ternaire en une ligne
```
'pass' if score >= 50 else 'fail'
```
  Un if/else compact qui renvoie une valeur — pratique dans les f-strings et print().
Boucles
- range
```
for i in range(3):   # 0, 1, 2
    print(i)
for i in range(1, 4): # 1, 2, 3
    print(i)
```
  range s’arrête avant le second nombre — même règle d’exclusion de fin que le découpage.
- enumerate / zip
```
for i, item in enumerate(['a','b']):
    print(i, item)
for x, y in zip([1,2],[3,4]):
    print(x, y)
```
  enumerate ajoute un compteur ; zip associe deux séquences élément par élément.
- break / continue
```
for n in range(10):
    if n == 3:
        break      # stop the loop
for n in range(10):
    if n % 2:
        continue   # skip this one
    print(n)
```
  break quitte la boucle entièrement ; continue passe à l’itération suivante.
- while
```
n = 3
while n > 0:
    print(n)
    n -= 1   # don't forget: while needs progress
```
  while répète jusqu’à ce que sa condition devienne fausse — une boucle qui ne met jamais à jour sa condition ne finit jamais.
- else de boucle (optionnel)
```
for n in nums:
    if n == target:
        break
else:
    print("not found")
```
  Le bloc else ne s’exécute que si la boucle s’est terminée sans break — un indicateur intégré « a-t-on trouvé ? ».
Fonctions
- Définir et appeler
```
def double(x):
    return x * 2

y = double(21)   # 42
```
  Le corps de def … doit être indenté. return redonne une valeur ; sans lui vous obtenez None.
- Valeurs par défaut et mots-clés
```
def greet(name, exclaim=True):
    s = f"Hello {name}"
    return s + ("!" if exclaim else "")

greet("ada")        # Hello ada!
greet("ada", False) # Hello ada
```
  Les paramètres avec = ont des valeurs par défaut ; les appelants peuvent passer par mot-clé.
- Renvoyer plusieurs valeurs
```
def minmax(nums):
    return min(nums), max(nums)

lo, hi = minmax([3, 1, 4])  # lo=1, hi=4
```
  Une fonction peut renvoyer un tuple que les appelants décomposent en plusieurs noms d’un coup.
- Portée et print vs return
```
x = 10            # global

def show(y):
    x = 5         # local — different x!
    print(x, y)   # side effect, returns None

result = show(1)  # result is None
```
  print affiche une valeur dans la console ; return la rend vraiment. Affecter dans une fonction masque la variable globale.
- Lambda (formes courtes)
```
double = lambda x: x * 2
sorted(nums, key=lambda n: -n)
```
  Utilisez les lambdas pour des fonctions jetables d’une ligne passées à sort/max/map.

Compréhensions

Liste

[n * 2 for n in nums]              # [2, 4, 6]
[n for n in nums if n > 1]      # [2, 3]
{n * 2 for n in nums}           # set

Une boucle for entre crochets — la façon idiomatique de transformer une liste.

Dict
```
{n: n ** 2 for n in range(4)}   # {0: 0, 1: 1, 2: 4, 3: 9}
```
Même forme, avec deux-points entre la clé et la valeur.

Fichiers et CSV
- Lire un fichier
```
text = open("file.txt").read()
lines = text.splitlines()
```
  La lecture la plus simple ; utilisez with open(...) as f quand il faut un flux.
- Lignes CSV
```
import csv
with open('data.csv') as f:
    rows = list(csv.reader(f))
```
  rows[0] est l’en-tête ; chaque ligne suivante est une liste de chaînes — convertissez en nombres avant les calculs.
pandas (Analyse de données)
- Charger et survoler
```
import pandas as pd
df = pd.read_csv('data.csv')
df.head()      # first 5 rows
df.describe()  # numeric summary
```
  L’incantation standard — pd.read_csv est la façon dont commence chaque leçon de données.
- Colonnes et lignes
```
df['name']          # one column
df[['a', 'b']]      # several
df.loc[0]           # first row
df[df['age'] > 30]  # filter rows
```
  Des crochets sur un nom de colonne ; des masques booléens pour filtrer.
- Regrouper et agréger
```
df.groupby('city')['sales'].sum()
df.groupby('city').mean()
```
  groupby + une méthode de synthèse est le pivot de la section Analyse de données.
Récupération d’erreurs
- Lire la dernière ligne
```
TypeError: unsupported operand type(s) for +: 'int' and 'str'
```
  La dernière ligne nomme l’erreur et les valeurs fautives — c’est le message qui dit quoi corriger.
- try / except
```
try:
    total = int(user_input) * 2
except ValueError:
    print('That was not a number')
```
  Attrapez uniquement l’erreur précise attendue ; tout attraper masque de vrais bugs.

Antisèches Python

📦 Variables

Affecter et lire

Règles de nommage

Échange et décomposition

🖨️ Sortie

print

Séparateur

⌨️ Entrée

Lire l’invite

Convertir

🔢 Nombres

Arithmétique de base

type()

Conversion

📝 Chaînes

f-strings

Méthodes

Découpage

Combiner, répéter, chercher

Échappements antislash

📚 Listes

Construire et ajouter

Lire

Parcourir

Trier et copier

Astuces de découpage

🏷️ Tuples et Ensembles

Tuples

Ensembles

Opérations d’ensembles

Quel conteneur ?

🗂️ Dictionnaires

Construire et lire

Écrire

Itérer

🔀 Conditionnelles

if / elif / else

Comparaisons

Opérateurs booléens

Véracité

Ternaire en une ligne

🔁 Boucles

range

enumerate / zip

break / continue

while

else de boucle (optionnel)

🛠️ Fonctions

Définir et appeler

Valeurs par défaut et mots-clés

Renvoyer plusieurs valeurs

Portée et print vs return

Lambda (formes courtes)

🧰 Compréhensions

Liste

Dict

🗃️ Fichiers et CSV

Lire un fichier

Lignes CSV

🐼 pandas (Analyse de données)

Charger et survoler

Colonnes et lignes

Regrouper et agréger

🛟 Récupération d’erreurs

Lire la dernière ligne

try / except

Variables

Sortie

Entrée

Nombres

Chaînes

Listes

Tuples et Ensembles

Dictionnaires

Conditionnelles

Boucles

Fonctions

Compréhensions

Fichiers et CSV

pandas (Analyse de données)

Récupération d’erreurs