Cheatsheet Python¶
Aide-memoire des bases de Python pour les TD.
Variables et types¶
# Entiers et flottants
age = 21
pi = 3.14
# Chaines de caracteres
nom = "Alice"
message = 'Hello World'
# Booleens
actif = True
vide = False
# Verifier le type
type(age) # <class 'int'>
type(nom) # <class 'str'>
Chaines de caracteres¶
texte = "Hello World"
len(texte) # 11 — longueur
texte.upper() # "HELLO WORLD"
texte.lower() # "hello world"
texte[0] # "H" — premier caractere
texte[-1] # "d" — dernier caractere
texte[0:5] # "Hello" — slice
# Verifications
"H".isalpha() # True — est une lettre ?
"H".isupper() # True — est majuscule ?
"3".isdigit() # True — est un chiffre ?
# f-strings (formatage)
cle = 7
print(f"La cle est {cle}") # La cle est 7
print(f"Resultat : {2 + 3}") # Resultat : 5
print(f"Cle {cle:2d}: {texte}") # Cle 7: Hello World
ord() et chr() — indispensables pour Cesar¶
ord('A') # 65 — caractere → code ASCII
ord('a') # 97
ord('Z') # 90
chr(65) # 'A' — code ASCII → caractere
chr(97) # 'a'
# Decalage d'une lettre
lettre = 'D'
base = ord('A')
decalage = 3
nouvelle = chr((ord(lettre) - base + decalage) % 26 + base)
# nouvelle = 'G'
Listes et dictionnaires¶
Listes¶
nombres = [1, 2, 3, 4, 5]
vide = []
nombres[0] # 1 — premier element
nombres[-1] # 5 — dernier element
nombres.append(6) # [1, 2, 3, 4, 5, 6]
len(nombres) # 6
# List comprehension
carres = [x**2 for x in range(5)] # [0, 1, 4, 9, 16]
Tuples¶
# Comme une liste, mais immuable (non modifiable)
point = (3, 7)
cle, texte = (7, "Hello") # deballage
Dictionnaires¶
freq = {'a': 0.08, 'b': 0.01, 'c': 0.03}
freq['a'] # 0.08 — acces par cle
freq['d'] = 0.04 # ajout
freq.get('z', 0.0) # 0.0 — valeur par defaut si absent
freq.keys() # dict_keys(['a', 'b', 'c', 'd'])
freq.values() # dict_values([0.08, 0.01, 0.03, 0.04])
freq.items() # dict_items([('a', 0.08), ...])
# Trouver la cle avec la valeur max
max(freq, key=freq.get) # 'a'
Boucles¶
for¶
# Sur une chaine
for c in "Hello":
print(c) # H, e, l, l, o
# Sur une range
for i in range(5): # 0, 1, 2, 3, 4
print(i)
for i in range(2, 8): # 2, 3, 4, 5, 6, 7
print(i)
# Sur une liste
for nom in ["Alice", "Bob", "Eve"]:
print(nom)
# Sur un dictionnaire
for lettre, frequence in freq.items():
print(f"{lettre}: {frequence}")
# Avec index
for i, valeur in enumerate(["a", "b", "c"]):
print(f"{i}: {valeur}") # 0: a, 1: b, 2: c
while¶
Fonctions¶
def saluer(nom: str) -> str:
"""Retourne un message de salutation."""
return f"Bonjour {nom}"
resultat = saluer("Alice") # "Bonjour Alice"
# Parametres par defaut
def chiffrer(texte: str, cle: int = 3) -> str:
# ...
pass
chiffrer("Hello") # cle = 3 par defaut
chiffrer("Hello", 7) # cle = 7
Conditions¶
x = 10
if x > 0:
print("positif")
elif x == 0:
print("zero")
else:
print("negatif")
# Operateurs de comparaison
# == != < > <= >=
# Operateurs logiques
if x > 0 and x < 100:
print("entre 1 et 99")
if x == 0 or x == 1:
print("zero ou un")
Operateur XOR ^¶
Le XOR (ou exclusif) est l'operation fondamentale en cryptographie symetrique (AES, CBC...).
# XOR entre deux entiers
5 ^ 3 # 6
# En binaire : 101 ^ 011 = 110
0xFF ^ 0xFF # 0 — XOR avec soi-meme = 0
0xFF ^ 0x00 # 255 — XOR avec 0 = inchange
Proprietes du XOR¶
a = 42
cle = 7
# Chiffrement
chiffre = a ^ cle # 45
# Dechiffrement — meme operation !
dechiffre = chiffre ^ cle # 42
assert dechiffre == a # XOR est son propre inverse
XOR sur des bytes (octets)¶
# XOR octet par octet entre deux bytes de meme longueur
def xor_bytes(a: bytes, b: bytes) -> bytes:
return bytes(x ^ y for x, y in zip(a, b))
message = b"Hello"
cle = b"CCCCC"
chiffre = xor_bytes(message, cle)
clair = xor_bytes(chiffre, cle)
assert clair == message
XOR et AES-CBC¶
# En CBC, chaque bloc est XORe avec le bloc chiffre precedent
# Bloc 1 : XOR avec l'IV, puis AES
# Bloc 2 : XOR avec le bloc chiffre 1, puis AES
bloc_clair = b"AAAAAAAAAAAAAAAA" # 16 bytes
iv = os.urandom(16)
# XOR avant chiffrement
bloc_xore = xor_bytes(bloc_clair, iv)
# Puis on chiffre bloc_xore avec AES...
Operateur modulo %¶
# Reste de la division entiere — tres utile en crypto
10 % 3 # 1
26 % 26 # 0
27 % 26 # 1
-1 % 26 # 25 — Python gere bien le modulo negatif
# Application : boucler dans l'alphabet
for decalage in range(30):
position = decalage % 26 # reste toujours entre 0 et 25
Fichiers¶
# Lire un fichier
with open("messages/message_fr.txt") as f:
contenu = f.read()
# Lire ligne par ligne
with open("messages/message_fr.txt") as f:
for ligne in f:
print(ligne.strip())
# Ecrire dans un fichier
with open("resultat.txt", "w") as f:
f.write("Cle trouvee : 7\n")
# Lire/ecrire des octets (pour les images BMP)
with open("tux.bmp", "rb") as f:
data = f.read()
with open("tux_ecb.bmp", "wb") as f:
f.write(data)
Matplotlib — graphiques¶
import matplotlib.pyplot as plt
import numpy as np
# Graphique a barres simple
lettres = ['a', 'b', 'c', 'd', 'e']
valeurs = [0.08, 0.01, 0.03, 0.04, 0.13]
plt.bar(lettres, valeurs)
plt.xlabel("Lettres")
plt.ylabel("Frequence")
plt.title("Frequences des lettres")
plt.show()
# Deux series cote a cote
x = np.arange(5)
largeur = 0.35
plt.bar(x - largeur/2, valeurs_1, largeur, label="Texte", color="steelblue")
plt.bar(x + largeur/2, valeurs_2, largeur, label="Reference", color="indianred")
plt.xticks(x, lettres)
plt.legend()
plt.tight_layout()
plt.show()
Modules utiles pour les TD¶
import os
import hashlib
# Octets aleatoires (TD2 — cles AES)
cle = os.urandom(32) # 32 bytes = 256 bits
iv = os.urandom(16) # 16 bytes = 128 bits
# Hexadecimal
cle.hex() # "a1b2c3..." — bytes → hex string
bytes.fromhex("a1b2c3") # hex string → bytes
# Hash SHA-256 (TD3)
h = hashlib.sha256(b"Hello").hexdigest()
# "185f8db32271fe25f561a6fc938b2e264306ec304eda518007d1764826381969"