Introduction aux Primitives
Avant de se plonger dans la programmation avancée, il est essentiel de maîtriser les blocs de construction essentiels offerts par le langage. Voici un survol rapide des différents conteneurs :
- Entiers (int) : Pour les calculs mathématiques.
- Booléens (bool) : Représentés par True ou False pour la logique conditionnelle.
- Chênes (str) : Séquences immuables de caractères.
- Listes (list) : Conteneurs mutables pour stocker plusieurs éléments ordonnés.
- Tuplets (tuple) : Similaires aux listes mais immuables.
- Dictionnaires (dict) : Mappings clés-valeur avec une recherche optimisée.
- Ensembles (set) : Collections non ordonnées d'éléments uniques.
Opérations Numériques et Logiques
Les nombres entiers supportent les opérations arithmétiques stendards ainsi que l'opérateur de division entière (//).
# Opérateurs arithmétiques basiques
print(10 + 5)
print(10 - 5)
print(10 * 5)
print(10 // 3)
print(10 % 3)
Le type booléen est crucial pour évaluer des conditions.
is_active = True
can_continue = False
print(bool(0)) # Affiche False car 0 équivaut à faux
print(bool(-1)) # Affiche True tout nombre non nul est vrai
Gestion Avancée des Chaînes (Str)
Les chaînes sont idéales pour gérer du texte simple ou structuré. Elles supportent l'accès direct via l'indexation et la découpe (slice).
Syntaxe d'Indexation et Découpage
L'index commence à zéro. On peut accéder au dernier élément via -1.
message = "La sagesse commence par la curiosité."
# Premier caractère
char_debut = message[0]
# Découpage [début:fin], la fin n'est pas inclusive
sous_message = message[2:7]
# Utilisation d'un pas négatif pour inverser
inversion = message[::-1]
Méthodes Fréquentes de Manipulation
Pour meettre en forme et analyser le texte, plusieurs méthodes intégrées sont disponibles.
texte = "exemple PYTHON"
# Capitalisation et ajustement de casse
print(texte.capitalize())
print(texte.swapcase())
# Remplacement limité (nombre maximal de substitutions)
texte_moderne = texte.replace("PYTHON", "pyton", 1)
print(texte_moderne)
# Séparation et fusion
mots = "un deux trois".split()
reconstruction = "-".join(mots)
print(reconstruction)
Il est également possible de vérifier les préfixes, suffixes ou de normaliser les entrées utilisateur (supprimer les espaces superflus).
demande = input("Saisir le mot clé : ")
propre_demande = demande.strip()
if propre_demande.startswith("test"):
print("Début confirmé")
# Vérification de contenu (alphanumérique)
val_str = "abc123"
if val_str.isalnum():
pass
Formatage Sortie
Deux approches principales existent pour afficher des résultats dynamiques : le '%' ancien et la méthode .format() moderne.
# Formatage par positionnement (méthode f-string moderne recommandée souvent, mais ici format classique)
infos = "Nom: {} Age: {} Ville: {}".format("Alice", 25, "Paris")
print(infos)
# Formatage nommé
info_detaillee = "{prenom} habite à {ville}".format(prenom="Bob", ville="Lyon")
print(info_detaillee)
Opérateurs Comparatifs et Logiques
La logique booléenne repose sur and, or et not. La valeur retournée dépend des opérandes.
# Comportement de OR : retourne le premier vérité ou le dernier
resultat_or = 0 or 5 # Affiche 5
print(resultat_or)
# Comportement de AND : retourne le premier faussité ou le dernier
resultat_and = 1 and 0 # Affiche 0
print(resultat_and)
Gestion des Listes Mutables
Une liste permet de stocker une collection ordonnée modifiable. Elle accepte divers types d'éléments simultanément.
Création et Modification
items = ["élément_A", "élément_B"]
# Ajout simple en fin
items.append("élément_C")
# Insertion à un index spécifique
items.insert(1, "élément_Midi")
# Extension avec une autre collection
items.extend([5, 6])
Suppression et Nettoyage
On peut retirer des éléments par leur valeur ou leur position. Attention à ne pas modifier la taillle d'une liste pendant sa boucle directe.
cibles = [10, 20, 30, 40]
# Suppression par valeur (lève erreur si inexistant)
if 20 in cibles:
cibles.remove(20)
# Retrait par index (pop renvoie l'élément retiré)
dernier = cibles.pop()
# Suppression totale via del
del cibles[0]
Parcours et Tri
Les listes peuvent être triées directement ou inversées en mémoire.
valeurs = [5, 2, 9, 1]
valeurs.sort(reverse=True) # Tri décroissant
for valeur in valeurs:
print(valeur)
Tuplets et Génération de Séries (Range)
Contrairement aux listes, les tuplets (tuple) sont immuables. Ils offrent une protection contre la modification accidentelle des données.
donnees_fixes = ("alpha", "beta", ["gamma"])
# Note : Un élément contenant une liste reste mutable
donnees_fixes[2].append("delta")
# Fonction Range pour générer des séquences numériques
for i in range(0, 5):
print(i)
Structures Clé-Valeur : Dictionnaires
Le dictionnaire associe des clés uniques à des valeurs. C'est l'équivalent d'une table de hachage.
config = {"mode": "dev", "niveau": 1}
# Mise à jour et ajout
config["mode"] = "prod"
config.setdefault("langue", "fr")
# Lecture sécurisée (.get évite les erreurs KeyError)
valeur_obtenue = config.get("cle_inconnue", "valeur_par_defaut")
# Itération
for cle, valeur in config.items():
print(f"{cle}: {valeur}")
Niveaux de Profondeur et Précautions
Les structures imbriquées (liste dans dictionnaire, dictionnaire dans liste) nécessitent une gestion rigoureuse lors des suppressions.
Récursion Modifiée en Boucle
Modifier la taille d'une collection itérée peut provoquer des bugs. Il est prudent d'itérer sur une copie ou d'inverser l'ordre.
chaine_nombres = [10, 20, 30, 40, 50]
# Méthode sûre pour suppression conditionnelle
# En partant de la fin pour éviter de décaler les indices restants
for i in range(len(chaine_nombres)-1, -1, -1):
if i % 2 == 0:
del chaine_nombres[i]
Attention aux objets mutables comme arguments par défaut
Lors de création de dictionnaires multiples avec des listes initiales communes, une seule référence est partagée si mal utilisée.
# Éviter ceci :
dict_commun = {'a': [], 'b': []}
dict_commun['a'].append(1)
# dict_commun['b'] contiendra aussi 1 si initialisation incorrecte via fromkeys
# Recommandé : Initialiser séparément ou utiliser fromkeys avec immutables
nouveaux_element = dict.fromkeys(['x', 'y'], 0)