Découvrez Python avec l’arbre généalogique des Durand Part 3.1 – Résumé

Apprendre le python
Apprendre le python

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 = 1998

Listes (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_lyon

Comparaison

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 str

Appartenance

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étique

Dictionnaires

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_alex

7. 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.

Apprendre le python

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 -= 1

Conclusion

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 !

Comments

No comments yet. Why don’t you start the discussion?

    Laisser un commentaire

    Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *