Site pour Cours de python dans l'académie polytechnique de Tanger

i = 0
while i < 10:
    print("{:d} times me".format(i+1))
    i += 1
print("Fin")

for _ in range(0,11,1):
    print("nta/i nadi/a")

for _ in range(1,101,1):
    print(_, end="\t")
    if _ % 10 == 0:
        print()

for _ in range(1,101,2):
    print(_,end="\t")
    if _ % 9 == 0:
        print()

for _ in range(0,101,2):
    print(_,end="\t")
    if _ % 10 == 0:
        print()

n_secret =  10
inp = int(input("entrée un numéro si tu trouve le numéro secret tu gagnes"))
while inp != n_secret:
    print("Le numéro entrée : {:d} n'est pas 10".format(inp))
    inp = int(input("Veuillez entrée un nombre à nouveau :"))
print(" Bravooooo, le numéro entré est bien 10 : {:d}".format(n_secret))

import random as rd
n_secret =  rd.randint(0,10)
inp = int(input("entrée un numéro si tu trouve le numéro secret tu gagnes"))
while inp != n_secret:
    print("Le numéro entrée : {:d} n'est pas le secret".format(inp))
    inp = int(input("Veuillez entrée un nombre à nouveau :"))
print(" Bravooooo, le numéro entré est bien le numéro secret : {:d}".format(n_secret))

while 1:
    # Declaration de variable et input

    var1 = int(input("Entrer la prmière valeur : "))
    var2 = int(input("Entrer la deuxième valeur : "))


    # Logique mathematique
    s = var1 + var2
    m = var1 - var2
    t = var1 * var2 # Multiplication

    # Condionelle

    if var2 != 0:
        d = int(var1 / var2)
        p = var1 ** var2
        mod = var1 % var2
        print("{:d} / {:d} = {:d}".format(var1,var2,d))
        print("{:d} ** {:d} = {:d}".format(var1,var2,p))
        print("{:d} % {:d} = {:d}".format(var1,var2,mod))
    else:
        print(" Error, la division sur 0 est interdite")
        if var1 != 0:
            p = 1
            print("{:d} ** {:d} = {:d}".format(var1,var2,p))
        else:
            print("Error, 0 ** 0 n'est pas autorisée")

    # Affichage des Résultats
    #print(str(var1) + " + " + str(var2) + " = " + str(s))
    print("{:d} + {:d} = {:d}".format(var1,var2,s))
    print("{:d} - {:d} = {:d}".format(var1,var2,m))
    print("{:d} * {:d} = {:d}".format(var1,var2,t))

    print("*"*60)
            

"""Code pour calculer le factoriel de n entrer en input """
n = int(input("Entrez la valeur de \"n\": "))
r = 1 # initialisation de r et pour 0! =1

if n < 0:
    print(" Erreur, le facorielle d'un numbre négative n'existe pas")
else:
    for _ in range(n,0,-1):
        r *= _
    print("{:d}! = {:d}".format(n,r))

# Initialiser une liste de fruits
Fruits = ["Pastèque", "Pomme", "Banane", "Pêche"]

# Définir une fonction pour ajouter deux nouveaux fruits à une liste donnée
def add2(var: list, arg1, arg2):
    # Copier la liste originale pour éviter de la modifier directement
    temp = var.copy()
    # Ajouter le premier nouveau fruit à la liste copiée
    temp.append(arg1)
    # Ajouter le second nouveau fruit à la liste copiée
    temp.append(arg2)
    # Retourner la liste modifiée
    return temp

# Utiliser la fonction add2 pour ajouter 'Fraise' et 'Orange' à la liste
Fruits2 = add2(Fruits, "Fraise", "Orange")
# Afficher la nouvelle liste avec les fruits ajoutés
print(Fruits2)

# Trier la nouvelle liste par ordre alphabétique
Fruits2.sort()
# Afficher la liste triée
print(Fruits2)

# Inverser l'ordre de la liste triée
Fruits2.reverse()
# Afficher la liste inversée
print(Fruits2)

# Afficher la liste originale pour montrer qu'elle reste inchangée
print(Fruits)

# Modifier le troisième élément (index 2) de la liste en 'Indéfini'
Fruits2[2] = "Indéfini"
# Afficher la liste modifiée
print(Fruits2)

# Initialiser une liste de fruits
Fruits = ["Pastèque", "Pomme", "Banane", "Pêche"]

def ajouter_fruit(var: list, fruit):
    """Ajouter un fruit à la liste s'il n'est pas déjà présent."""
    if fruit in var:
        print(f"{fruit} est déjà dans la liste.")
    else:
        var.append(fruit)

def retirer_fruit(var: list, fruit):
    """Retirer un fruit de la liste s'il existe."""
    if fruit in var:
        var.remove(fruit)
    else:
        print(f"{fruit} n'est pas trouvé dans la liste.")

def afficher_liste(var: list):
    """Afficher la liste des fruits dans un format convivial."""
    print("Liste actuelle des fruits :")
    for fruit in var:
        print(f" - {fruit}")

def compter_fruit(var: list, fruit):
    """Compter et afficher le nombre de fois qu'un fruit apparaît dans la liste."""
    compte = var.count(fruit)
    print(f"{fruit} apparaît {compte} fois dans la liste.")

# Ajouter des fruits en utilisant la nouvelle fonction
ajouter_fruit(Fruits, "Fraise")
ajouter_fruit(Fruits, "Orange")
ajouter_fruit(Fruits, "Pomme")  # Cela devrait afficher un message indiquant qu'il est déjà dans la liste

# Retirer un fruit
retirer_fruit(Fruits, "Banane")

# Afficher la liste
afficher_liste(Fruits)

# Compter les occurrences d'un fruit
compter_fruit(Fruits, "Pomme")

# Le reste de votre code existant peut rester ici pour le tri, l'inversion, etc.

# Créer un tuple avec des types de données mixtes
mixed_tuple = (42, "Bonjour", 3.14, [1, 2, 3], ("a", "b", "c"))

# Afficher le tuple entier
print("Le tuple entier :", mixed_tuple)
# Accéder aux éléments par indice
print("Premier élément (entier) :", mixed_tuple[0])
print("Deuxième élément (chaîne de caractères) :", mixed_tuple[1])
print("Dernier élément (tuple) :", mixed_tuple[-1])
# Extraire les éléments de l'indice 1 à 3
print("Extrait de l'indice 1 à 3 :", mixed_tuple[1:4])

# Accéder à un élément de la liste dans le tuple
print("Deuxième élément de la liste dans le tuple :", mixed_tuple[3][1])

# Accéder à une valeur du dictionnaire dans le tuple
# Note : Il semble y avoir une erreur ici, car le dernier élément du tuple est un autre tuple, pas un dictionnaire.
# Je vais donc corriger cela pour accéder au troisième élément du sous-tuple.
print("Troisième valeur du sous-tuple dans le tuple :", mixed_tuple[4][2])

# Modifier un élément mutable dans le tuple
mixed_tuple[3].append(4)
print("Liste modifiée dans le tuple :", mixed_tuple[3])

# Définition d'une structure de données mixtes contenant des informations personnelles
# Cette structure est un mélange de listes et de tuples
personal_info = (["Hamza", 31, "M"], ("Mohamed", 28, "M"), ["Aissa", 18, "M"], ("Sawssan", 21, "F"), "zineb")

# Afficher la longueur du premier élément (une liste) dans 'personal_info'
print(len(personal_info[0]))

# Afficher le type de la structure de données 'personal_info' (tuple)
print(type(personal_info))
# Afficher le type du premier élément de 'personal_info' (liste)
print(type(personal_info[0]))

# Itération sur chaque caractère du cinquième élément (une chaîne) de 'personal_info'
for character in personal_info[4]:
    print(character)

# Itération sur chaque élément de 'personal_info' et affichage de chaque élément
for info in personal_info:
    print(info)

# Création d'un tuple contenant des nombres de 1 à 100
number_range = tuple(range(1, 101))

# Itération sur chaque nombre dans 'number_range'
# Affichage de chaque nombre, suivi d'une tabulation
# Après chaque dixième nombre, insertion d'un saut de ligne pour une meilleure lisibilité
for number in number_range:
    print(number, end="\t")
    if number % 10 == 0:
        print()

# Initialisation du dictionnaire des notes d'étudiants
notes_etudiants = {
    (12345, 'Automne 2021'): '18',
    (67890, 'Printemps 2021'): '15',
    (13579, 'Automne 2021'): '17'
}
print(notes_etudiants)

# Ajouter une nouvelle note d'étudiant
notes_etudiants[(24680, 'Automne 2021')] = '16'
print(notes_etudiants)

# Mettre à jour une note pour une entrée existante
notes_etudiants[(12345, 'Automne 2021')] = '19'
print(notes_etudiants)

# Supprimer une entrée
del notes_etudiants[(67890, 'Printemps 2021')]

# Rechercher la note d'un étudiant
note = notes_etudiants.get((12345, 'Automne 2021'), 'Non trouvée')
print(note)

# Itérer sur toutes les entrées
for key, value in notes_etudiants.items():
    id_etudiant, semestre = key
    note = value
    print(f'ID Étudiant: {id_etudiant}, Semestre: {semestre}, Note: {note}')

# Vérifier si une note d'étudiant est enregistrée
if (12345, 'Automne 2021') in notes_etudiants:
    print("La note de l'étudiant est enregistrée.")
else:
    print("La note de l'étudiant n'est pas enregistrée.")

# Obtenir toutes les clés ou toutes les valeurs
toutes_les_cles = notes_etudiants.keys()
toutes_les_valeurs = notes_etudiants.values()

print(toutes_les_cles)
print(toutes_les_valeurs)

# Carnet d'adresses initial
carnet_adresses = {
    "Fatima Zahra El Mahdi": "+212 612 345678",
    "Youssef Amrani": "+212 613 876543",
    "Amina Belkadi": "+212 537 123456"
}

# Fonction pour ajouter un nouveau contact au carnet d'adresses
def ajouter_contact(carnet_adresses, nom, numero):
    # Vérification si le numéro commence par +212
    if not numero.startswith("+212"):
        print(f"Numéro de téléphone invalide pour {nom}. Il doit commencer par '+212'.")
        return
    
    # Vérification si le contact existe déjà
    if nom in carnet_adresses:
        print(f"{nom} figure déjà dans le carnet d'adresses avec le numéro {carnet_adresses[nom]}.")
    else:
        carnet_adresses[nom] = numero
        print(f"Contact {nom} ajouté avec le numéro {numero}.")

# Exemple d'utilisation :
ajouter_contact(carnet_adresses, "Mohammed Alami", "+212 614 567890")
ajouter_contact(carnet_adresses, "Fatima Zahra El Mahdi", "+212 615 987654")  # Indique que Fatima Zahra El Mahdi existe déjà

# Affichage du carnet d'adresses mis à jour
print("Carnet d'adresses mis à jour :", carnet_adresses)

Annuaire = [
    ["Nom", "Prénom", "Age", "Sexe", "Notes", "Ville"],
    ["El Aoufi", "Hassan", 19, "M", {"Math": 16, "PC": 15, "SVT": 16, "Ph": 14, "Eng": 15}, "Casablanca"],
    ["Benkirane", "Youssef", 18, "M", {"Math": 14, "PC": 13, "SVT": 15, "Ph": 12, "Eng": 14}, "Marrakech"],
    ["Alami", "Chaima", 20, "F", {"Math": 17, "PC": 18, "SVT": 17, "Ph": 16, "Eng": 17}, "Fes"],
    ["Rahali", "Sara", 21, "F", {"Math": 13, "PC": 14, "SVT": 14, "Ph": 15, "Eng": 16}, "Rabat"],
    ["Moumen", "Khalid", 19, "M", {"Math": 15, "PC": 16, "SVT": 15, "Ph": 14, "Eng": 14}, "Tanger"],
]

# Fonction pour calculer la note générale d'un étudiant
def Note_g(dicts):
    """
    Calcule la moyenne générale d'un étudiant basée sur un dictionnaire de notes.

    Args:
    dicts (dict): Un dictionnaire contenant les notes de l'étudiant dans diverses matières.
    
    Returns:
    float: La moyenne générale de l'étudiant, calculée en pondérant les notes avec des coefficients prédéfinis.
    """
    # Coefficients pour chaque matière
    coefficients = [7, 7, 5, 2, 2]
    Notes = [dicts["Math"], dicts["PC"], dicts["SVT"], dicts["Ph"], dicts["Eng"]]
    S = 0 # somme des notes x coefficients
    S_c = 0 #somme des coefficients

    # Calcul de la somme pondérée des notes
    for i in range(len(Notes)):
        temp = coefficients[i] * Notes[i]
        S = S + temp # S+= temp
        S_c += coefficients[i]
    
    # Calcul de la note finale
    note_f = S / S_c
    return note_f

# Ajout de la note générale à l'annuaire
Annuaire[0].append("Note Générale")
for j in range(1, len(Annuaire)):
    Note_generale = Note_g(Annuaire[j][4])
    Annuaire[j].append(Note_generale)


def afficher_annuaire(annuaire):
    """
    Affiche les informations de chaque étudiant dans l'annuaire d'une manière formatée et lisible.

    Args:
    annuaire (list): Le carnet d'adresses à afficher, où chaque élève est représenté par une liste d'informations.
    """
    # Imprimer l'en-tête
    en_tete = " | ".join([str(item) for item in annuaire[0]])
    print(en_tete)
    print("-" * len(en_tete))

    # Imprimer les informations de chaque élève
    for eleve in annuaire[1:]:
        ligne = " | ".join([str(item) for item in eleve])
        print(ligne)

# Exemple d'utilisation de la fonction pour afficher l'annuaire
afficher_annuaire(Annuaire)

def afficher_annuaire(annuaire):
    """
    Affiche les informations de chaque étudiant dans l'annuaire de manière organisée et formatée.
    La note générale est affichée avec deux décimales.

    Args:
    annuaire (list): Le carnet d'adresses à afficher, où chaque élève est représenté par une liste d'informations.
    """
    # Convertir chaque élément de l'annuaire en chaîne de caractères pour un formatage correct
    annuaire_str = [annuaire[0]]  # Inclure l'en-tête tel quel
    for eleve in annuaire[1:]:
        eleve_str = [str(item) for item in eleve[:-1]]  # Convertir tous sauf la dernière colonne
        # Formater la note générale avec deux décimales
        note_generale = float(eleve[-1])
        eleve_str.append("{:.2f}".format(note_generale))
        annuaire_str.append(eleve_str)

    # Déterminer la largeur de chaque colonne pour un affichage uniforme
    largeurs_colonnes = [max(len(str(annuaire_str[i][j])) for i in range(len(annuaire_str))) for j in range(len(annuaire_str[0]))]

    # Créer une chaîne de formatage en utilisant les largeurs de colonne
    format_ligne = " | ".join(["{:<" + str(largeur) + "}" for largeur in largeurs_colonnes])

    # Imprimer l'en-tête
    print(format_ligne.format(*annuaire_str[0]))
    # Calculer la longueur totale de la ligne de séparation
    longueur_separation = sum(largeurs_colonnes) + (len(largeurs_colonnes) - 1) * 3
    print("-" * longueur_separation)

    # Imprimer les informations de chaque élève
    for eleve in annuaire_str[1:]:
        print(format_ligne.format(*eleve))

# Exemple d'utilisation de la fonction pour afficher l'annuaire
afficher_annuaire(Annuaire)

import random

# Listes de prénoms masculins et féminins
male_prenom = [
    "Mohammed", "Ahmed", "Youssef", "Hassan", "Khalid",
    "Abdel", "Rachid", "Jamal", "Karim", "Ali",
    "Omar", "Samir", "Anas", "Ayoub", "Adil"
]
femal_prenom = [
    "Fatima", "Amina", "Khadija", "Nadia", "Hajar",
    "Samira", "Ilham", "Laila", "Sanaa", "Asmaa",
    "Zineb", "Hanan", "Soukaina", "Salma", "Rania"
]

#Liste des nom de famille marocains 

nom_de_famille = [
    "El Aoufi", "Benkirane", "Alami", "Rahali", "Moumen",
    "Berrada", "Khalifi", "Sbai", "Ait Ali", "Ziani",
    "Amrani", "Kabbaj", "Qasmi", "Laaroussi", "El Fassi",
    "El Idrissi", "Benjelloun", "Gharbi", "Fakhouri", "Hassani",
    "Daoudi", "Jabri", "El Khatib", "Boujemaoui", "El Mansouri",
    "Nassiri", "Belhaj", "Chaoui", "El Yazidi", "Benallal",
    "Laalami", "Raji", "El Ghalia", "Benmoussa", "El Kassimi",
    "El Haddad", "Boualam", "Chraibi", "Doukali", "El Ayachi",
    "Guedira", "El Mahi", "Bouchaib", "El Mokhtar", "Bounouar",
    "Cherkaoui", "Tazi", "Alj", "Bouskri", "Mernissi"]


# Fonction pour ajouter une nouvelle personne à l'Annuaire
def ajouter_personne(annuaire, nom, prenom, age, sexe, notes, ville):
    """
    Ajoute une nouvelle personne à l'annuaire.

    Args:
        annuaire (list): Le carnet d'adresses où ajouter la nouvelle personne.
        nom (str): Le nom de famille de la personne.
        prenom (str): Le prénom de la personne.
        age (int): L'âge de la personne.
        sexe (str): Le sexe de la personne (M ou F).
        notes (dict): Un dictionnaire des notes de la personne dans différentes matières.
        ville (str): La ville de résidence de la personne.
    """
    note_generale = Note_g(notes) # Calcul de la note générale (fonction Note_g non fournie)
    annuaire.append([nom, prenom, age, sexe, notes, ville, note_generale]) # Ajout de la personne à l'annuaire

# Fonction pour générer un grand nombre de personnes aléatoires et les ajouter à l'annuaire
def generer_grand_nombre_personnes(annuaire, nombre):
    """
    Génère un grand nombre de personnes aléatoires et les ajoute à l'annuaire.

    Args:
        annuaire (list): Le carnet d'adresses où ajouter les personnes générées.
        nombre (int): Le nombre de personnes à générer.
    """
    
    # Boucle pour générer les personnes
    for _ in range(nombre):
        # Sélection aléatoire d'un nom de famille
        nom = random.choice(nom_de_famille)
        # Sélection aléatoire d'un prénom
        prenom = random.choice(male_prenom + femal_prenom)

        # Détermination du sexe basée sur le prénom
        if prenom in male_prenom:
            sexe = "M"
        elif prenom in femal_prenom:
            sexe = "F"
        else:
            print("Erreur de Sexe")
            continue
        
        # Sélection aléatoire de l'âge
        age = random.randint(17, 21)
        
        # Génération aléatoire des notes dans différentes matières
        notes = {
            "Math": random.randint(1, 20),
            "PC": random.randint(1, 20),
            "SVT": random.randint(1, 20),
            "Ph": random.randint(1, 20),
            "Eng": random.randint(1, 20)
        }

        # Sélection aléatoire d'une ville
        ville = random.choice([
            "Casablanca", "Marrakech", "Fes", "Rabat", "Tanger", "Salé", "Meknes", "Oujda", "Agadir", "Kenitra"
        ])

        # Ajout de la personne générée à l'annuaire
        ajouter_personne(annuaire, nom, prenom, age, sexe, notes, ville)


nombre_de_personnes = 500  
generer_grand_nombre_personnes(Annuaire, nombre_de_personnes)

# Afficher l'annuaire (la fonction afficher_annuaire doit être définie)
afficher_annuaire(Annuaire)