Introduction
Alex, le cousin de Marie et Pierre Durand, se lance dans l’aventure Python pour contribuer à l’arbre généalogique familial. Suivons ses premiers pas dans le monde fascinant de la programmation Python !
1. Commentaires : Les notes secrètes du généalogiste
Alex apprend à ajouter des explications à son code, comme des notes dans un journal de famille.
Commentaire sur une ligne
Les commentaires sur une ligne sont parfaits pour de petites annotations rapides.
# Ceci est un commentaire sur une ligne. Python l'ignore quand il exécute le code.
# Parfait pour de petites notes ou explications.Commentaire sur plusieurs lignes
Pour des explications plus détaillées, Alex utilise des commentaires sur plusieurs lignes.
"""
Ceci est un commentaire sur plusieurs lignes.
Idéal pour des explications plus détaillées.
Par exemple, ici on pourrait expliquer l'histoire de la famille Durand.
"""2. Variables : Le grand livre de famille
Alex découvre comment stocker différents types d’informations, comme dans un grand livre de famille.
Texte (chaîne de caractères)
Les chaînes de caractères permettent de stocker du texte, comme les noms et les lieux.
nom_famille = "Durand"
prenom = "Alex"
ville_naissance = "Lyon"Nombres
Les nombres peuvent être entiers ou décimaux, parfaits pour les âges et les dates.
age = 25 # Un nombre entier
taille = 1.75 # Un nombre décimal
annee_naissance = 1998Listes (comme une liste de courses, mais pour la famille !)
Les listes permettent de regrouper plusieurs éléments dans un ordre précis.
cousins = ["Marie", "Pierre", "Sophie", "Thomas"]
ages_cousins = [28, 30, 22, 35]Dictionnaires (comme une fiche d’identité)
Les dictionnaires associent des clés à des valeurs, idéal pour des informations détaillées.
info_grand_mere = {
"prenom": "Jeanne",
"nom": "Durand",
"annee_naissance": 1945,
"ville": "Paris",
"enfants": ["Marc", "Lucie", "Paul"]
}3. Opérateurs : La calculatrice du généalogiste
Alex apprend à faire des opérations sur ses données, comme un détective familial !
Arithmétiques
Les opérations arithmétiques permettent de calculer des âges et des statistiques familiales.
annee_actuelle = 2023
age_grand_mere = annee_actuelle - info_grand_mere["annee_naissance"]
nombre_total_cousins = len(cousins) + 1 # N'oublions pas Alex !Logiques
Les opérateurs logiques aident à combiner des conditions.
est_majeur = age >= 18
habite_a_lyon = ville_naissance == "Lyon"
peut_voter_a_lyon = est_majeur and habite_a_lyonComparaison
Les comparaisons permettent de mettre en relation différentes informations.
plus_age_que_marie = age > ages_cousins[0]
meme_age_que_pierre = age == ages_cousins[1]Affectation
L’affectation permet de modifier des variables de manière concise.
nombre_ancetres_connus = 10
nombre_ancetres_connus += 5 # On a découvert 5 nouveaux ancêtres !Type
Vérifier le type d’une variable peut être utile pour éviter des erreurs.
age_est_un_nombre = type(age) is int
prenom_est_une_chaine = type(prenom) is strAppartenance
L’opérateur d’appartenance permet de vérifier si un élément est dans une liste ou un dictionnaire.
sophie_est_cousine = "Sophie" in cousins
pierre_est_enfant_grand_mere = "Pierre" in info_grand_mere["enfants"]4. Fonctions : Les outils du généalogiste
Alex crée des fonctions pour automatiser ses recherches, comme des outils spécialisés.
Les fonctions permettent de regrouper des opérations réutilisables.
def calculer_age(annee_naissance):
return 2023 - annee_naissance
age_grand_mere = calculer_age(info_grand_mere["annee_naissance"])
def presenter_personne(prenom, nom, age):
return f"{prenom} {nom}, âgé(e) de {age} ans, est un membre de la famille Durand."
presentation_alex = presenter_personne(prenom, nom_famille, age)5. Structures conditionnelles : Le tri familial
Alex utilise des conditions pour classer les membres de la famille, comme un archiviste familial.
Les structures conditionnelles permettent de prendre des décisions basées sur des conditions.
def classer_generation(annee_naissance):
age = 2023 - annee_naissance
if age < 20:
return "Nouvelle génération"
elif age < 40:
return "Jeune adulte"
elif age < 60:
return "Génération intermédiaire"
else:
return "Ancienne génération"
generation_alex = classer_generation(annee_naissance)
generation_grand_mere = classer_generation(info_grand_mere["annee_naissance"])
def determiner_lien_parente(nom):
if nom in cousins:
return "Cousin(e)"
elif nom in info_grand_mere["enfants"]:
return "Oncle ou Tante"
elif nom == info_grand_mere["prenom"]:
return "Grand-mère"
else:
return "Lien de parenté inconnu"
lien_sophie = determiner_lien_parente("Sophie")
lien_jeanne = determiner_lien_parente("Jeanne")6. Listes et Dictionnaires : L’album photo et le carnet d’adresses
Alex apprend à manipuler des collections de données, comme s’il organisait un grand album photo familial.
Listes
Les listes sont flexibles et peuvent être modifiées de plusieurs façons.
# Création
ancetres = ["Jean", "Marie", "Pierre", "Louise"]
# Ajout
ancetres.append("Charles")
ancetres.insert(1, "Élise")
# Modification
ancetres[0] = "Jean-Baptiste"
# Suppression
del ancetres[3]
ancetre_retire = ancetres.pop()
# Autres opérations
nombre_ancetres = len(ancetres)
ancetres.sort() # Trie la liste par ordre alphabétiqueDictionnaires
Les dictionnaires permettent d’associer des clés à des valeurs pour une organisation plus structurée.
# Création
info_alex = {
"nom": "Durand",
"prenom": "Alex",
"age": 25,
"ville": "Lyon"
}
# Ajout / Modification
info_alex["profession"] = "Développeur"
info_alex["age"] = 26 # Alex a eu son anniversaire !
# Suppression
del info_alex["ville"]
# Autres opérations
cles = info_alex.keys()
valeurs = info_alex.values()
est_present = "profession" in info_alex7. Boucles : Le parcours de l’arbre généalogique
Alex découvre comment parcourir ses données efficacement, comme s’il explorait chaque branche de l’arbre familial.
Boucle For
La boucle for est idéale pour parcourir des séquences comme des listes ou des dictionnaires.
print("Liste des cousins :")
for cousin in cousins:
print(f"- {cousin} Durand")
total_ages = 0
for age in ages_cousins:
total_ages += age
age_moyen = total_ages / len(ages_cousins)
for cle, valeur in info_grand_mere.items():
print(f"{cle}: {valeur}")Boucle While
La boucle while est utile quand on ne sait pas à l’avance combien d’itérations seront nécessaires.
annee = 2023
generation = 0
while annee > 1900:
print(f"Génération {generation}: née autour de {annee}")
annee -= 25 # On remonte d'environ une génération
generation += 1
# Simulation de recherche d'ancêtres
ancetres_trouves = 0
annee_recherche = 2023
while ancetres_trouves < 10 and annee_recherche > 1800:
if annee_recherche % 50 == 0:
print(f"Ancêtre trouvé en {annee_recherche} !")
ancetres_trouves += 1
annee_recherche -= 1Conclusion
Grâce à ces bases de Python, Alex peut maintenant organiser, analyser et explorer l’histoire de la famille Durand de manière plus efficace. Il peut créer des listes de membres, stocker des informations détaillées dans des dictionnaires, calculer des âges, classer les générations et même simuler des recherches d’ancêtres. Python s’avère être un outil puissant et flexible pour son projet généalogique, ouvrant de nouvelles possibilités pour comprendre et présenter l’histoire de sa famille !
