Skip to content
Snippets Groups Projects
Commit d6f35c05 authored by Koffi Gantchou's avatar Koffi Gantchou
Browse files

depot

parent a131833c
No related branches found
No related tags found
No related merge requests found
...@@ -41,6 +41,16 @@ def indice_seq(elem: C, liste: list[C], comp: Callable[[C, C], int]) \ ...@@ -41,6 +41,16 @@ def indice_seq(elem: C, liste: list[C], comp: Callable[[C, C], int]) \
$$$ indice_seq(42, [], compare) $$$ indice_seq(42, [], compare)
(False, 0) (False, 0)
""" """
trouve = False
i = 0
while i<len(liste) and trouve == False:
res = comp(elem, liste[i])
if res == 0:
trouve = True
i+=1
if trouve :
return ((trouve, i-1))
return ((trouve,i))
def indice_dicho(elem: C, liste: list[C], comp: Callable[[C, C], int]) \ def indice_dicho(elem: C, liste: list[C], comp: Callable[[C, C], int]) \
...@@ -70,25 +80,20 @@ def indice_dicho(elem: C, liste: list[C], comp: Callable[[C, C], int]) \ ...@@ -70,25 +80,20 @@ def indice_dicho(elem: C, liste: list[C], comp: Callable[[C, C], int]) \
$$$ indice_dicho(42, [], compare) $$$ indice_dicho(42, [], compare)
(False, 0) (False, 0)
""" """
if len(liste) == 0:
return (False, 0)
trouve = False trouve = False
i = 0 i = 0
res = len(liste)-1 sup = False
while i < len(liste) and not trouve: while i<len(liste) and trouve == False and sup == False:
cmp = comp(elem , liste[i]) res = comp(elem, liste[i])
if cmp == 0: if res == 0:
trouve = True trouve = True
res = i if res == -1:
elif cmp==-1: sup = True
trouve = False
res = elem
else:
trouve = False
res = len(liste)
i+=1 i+=1
if trouve or sup:
return (trouve,res) return ((trouve, i-1))
else:
return ((trouve,i))
def inserer(indice: int, elem: C, liste: list[C]) -> NoneType: def inserer(indice: int, elem: C, liste: list[C]) -> NoneType:
...@@ -111,12 +116,14 @@ def inserer(indice: int, elem: C, liste: list[C]) -> NoneType: ...@@ -111,12 +116,14 @@ def inserer(indice: int, elem: C, liste: list[C]) -> NoneType:
$$$ vide $$$ vide
[42] [42]
""" """
licopier = liste.copy() if indice == 0:
for i in range(len(licopier)): liste[:] = [elem]+liste
licopier[indice] = elem elif indice == len(liste):
licopier[i] = licopier[i+1] liste.append(elem)
licopier.append(liste[-1]) else:
return licopier l = liste[:indice]
l.append(elem)
liste[:] = l+liste[indice:]
if __name__ == '__main__': if __name__ == '__main__':
import apl1test import apl1test
......
#!/usr/bin/python3
# -*- coding: utf-8 -*-
"""
:mod:`date` module : a module for date
:author: `FIL - Faculté des Sciences et Technologies -
Univ. Lille <http://portail.fil.univ-lille1.fr>`_
:date: 2024, january. Last revision: 2024, january
Date are objects
"""
NOM_MOIS = ['janvier', 'février', 'mars', 'avril', 'mai', 'juin', 'juillet',
'août', 'septembre', 'octobre', 'novembre', 'décembre']
DUREE_MOIS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
def est_bissextile(annee: int) -> bool:
"""
Renvoie True si et seulement si annee est bissextile.
précondition: annee >= 1582.
$$$ est_bissextile(2024)
True
$$$ est_bissextile(2000)
True
$$$ est_bissextile(2100)
False
"""
return annee % 4 == 0 and (annee % 100 != 0 or annee % 400 == 0)
def nombre_de_jour_dans_mois(mois: int, annee: int) -> int:
"""
Renvoie le nombre de jour dans le mois `mois` de l'année `année`.
précondition : 0 <= mois < 12 et annee >= 1582.
"""
duree_mois = DUREE_MOIS[mois - 1]
if est_bissextile(annee) and mois == 2:
return duree_mois + 1
return duree_mois
def nom_mois(mois) -> str:
"""Renvoie le nom du mois en français."""
return NOM_MOIS[mois - 1]
class Date:
"""
une classe permettant de représenter des dates
"""
def __init__(self, jour: int, mois: int, annee: int):
"""
initialise une nouvelle date
précondition : jour/mois/annee est une date valide
exemples :
$$$ adate = Date(4, 6, 2024)
$$$ type(adate) == Date
True
"""
self.jour = jour
self.mois = mois
self.annee = annee
def __str__(self) -> str:
"""
Renvoie une châine représentant la date.
$$$ adate = Date(23, 1, 2024)
$$$ str(adate)
'23 janvier 2024'
"""
return f"{self.jour} {nom_mois(self.mois)} {self.annee}"
def __repr__(self) -> str:
"""
Une représentation textuelle d'une date;
"""
return f"Date({self.jour}, {self.mois}, {self.annee})"
def __eq__(self, other: 'Date') -> bool:
"""
Renvoie True si, et seulement si, deux dates sont égales.
exemples :
$$$ adate1 = Date(23, 1, 2024)
$$$ adate2 = Date(23, 1, 2024)
$$$ id(adate1) == id(adate2)
False
$$$ adate1 == adate2
True
"""
return self.jour == other.jour and \
self.mois == other.mois and \
self.annee == other.annee
def __lt__(self, other: 'Date') -> bool:
"""
Renvoie True si, et seulement si, la date représentée par
self est avant celle représentée par other.
exemples :
$$$ adate1 = Date(23, 1, 2024)
$$$ adate2 = Date(25, 1, 2024)
$$$ adate1 < adate2
True
$$$ adate2 < adate1
False
$$$ adate1 < Date(23, 1, 2024)
False
"""
if self.annee == other.annee:
if self.mois == other.mois:
res = self.jour < other.jour
else:
res = self.mois < other.mois
else:
res = self.annee < other.annee
return res
def __le__(self, other: 'Date') -> bool:
"""
Renvoie True si, et seulement si, la date représentée par
self est avant ou egale à celle représentée par other.
exemples :
$$$ adate1 = Date(23, 1, 2024)
$$$ adate2 = Date(25, 1, 2024)
$$$ adate1 <= adate2
True
$$$ adate2 <= adate1
False
$$$ adate1 <= Date(23, 1, 2024)
True
"""
return self < other or self == other
def tomorrow(self) -> 'Date':
"""
renvoie la date du lendemain.
$$$ Date(31, 12, 2023).tomorrow() == Date(1, 1, 2024)
True
$$$ Date(31, 1, 2024).tomorrow() == Date(1, 2, 2024)
True
$$$ Date(24, 1, 2024).tomorrow() == Date(25, 1, 2024)
True
"""
annee = self.annee
mois = self.mois
jour = self.jour
if jour == nombre_de_jour_dans_mois(mois, annee):
jour = 1
if mois == 12:
annee = annee + 1
mois = 1
else:
mois = mois + 1
else:
jour = jour + 1
return Date(jour, mois, annee)
def __add__(self, njour: int) -> 'Date':
"""
ajoute un nombre de jour à une date.
$$$ Date(31, 1, 24) + 7
Date(7, 2, 24)
"""
res = self
for _ in range(njour):
res = res.tomorrow()
return res
def __sub__(self, other: 'Date') -> int:
"""
Renvoie le nombre de jour entre deux dates.
$$$ Date(7, 2, 24) - Date(31, 1, 24)
7
"""
if self <= other:
start, ending = self, other
else:
start, ending = other, self
res = 0
while start != ending:
start = start.tomorrow()
res = res + 1
return res
def __gt__(self, other: 'Date') -> bool:
""" à_remplacer_par_ce_que_fait_la_fonction
Précondition :
Exemple(s) :
$$$
"""
if self.annee == other.annee:
if self.mois == other.mois:
res = self.jour > other.jour
else:
res = self.mois > other.mois
else:
res = self.annee > other.annee
return res
if (__name__ == '__main__'):
import apl1test
apl1test.testmod('date.py')
#!/usr/bin/python3
# -*- coding: utf-8 -*-
"""
:author: FIL - FST - Univ. Lille.fr <http://portail.fil.univ-lille.fr>_
:date: janvier 2019
:last revised:
:Fournit :
"""
from date import Date
class Etudiant:
"""
une classe représentant des étudiants.
$$$ etu = Etudiant(314159, 'Oléon', 'Tim', Date(7, 11, 2004), 'MI', '15')
$$$ str(etu)
'Tim Oléon'
$$$ repr(etu)
"Etudiant(314159, 'Oléon', 'Tim', Date(7, 11, 2004), 'MI', '15')"
$$$ etu.prenom
'Tim'
$$$ etu.nip
314159
$$$ etu.nom
'Oléon'
$$$ etu.formation
'MI'
$$$ etu.groupe
'15'
$$$ etu2 = Etudiant(314159, 'Oléon', 'Tim', Date(7, 11, 2004), 'MI', '15')
$$$ etu == etu2
True
$$$ etu3 = Etudiant(141442, 'Oléon', 'Tim', Date(7, 11, 2004), 'MI', '15')
$$$ etu == etu3
False
$$$ etu4 = Etudiant(141442, 'Calbuth', 'Raymond', Date(2, 1, 2005), 'MI', '11')
$$$ etu < etu4
True
$$$ isinstance(etu.naissance, Date)
True
"""
from date import Date
def __init__(self, nip: int, nom, prenom,
naissance: Date, formation: str, groupe: str):
"""
initialise un nouvel étudiant à partir de son nip, son nom, son
prénom, sa formation et son groupe.
précondition : le nip, le nom et le prénom ne peuvent être nuls ou vides.
"""
self.nip = nip
self.nom = nom
self.prenom = prenom
self.naissance = naissance
self.formation = formation
self.groupe = groupe
def __eq__(self, etudiant) -> bool:
"""
Renvoie True ssi other est un étudiant ayant :
- même nip,
- même nom et
- même prénom que `self`,
et False sinon.
"""
if isinstance(etudiant,Etudiant):
return etudiant.nom == self.nom and self.prenom==etudiant.prenom and self.nip == etudiant.nip
def __lt__(self, other) -> bool:
"""
Renvoie True si self est né avant other
"""
if not (self.prenom < other.prenom and self.nom < other.nom and (self.Date < other.Date) and (self.naissance < other.naissance) and (self.nip < other.nip) and (self.formation < other.formation)):
return True
return False
def __str__(self) -> str:
"""
Renvoie une représentation textuelle de self pour impression.
"""
return f"{self.prenom} {self.nom}"
def __repr__(self) -> str:
"""
Renvoie une représentation textuelle interne de self pour le shell.
"""
return f"Etudiant({self.nip}, '{self.nom}', '{self.prenom}', {repr(self.naissance)}, '{self.formation}', '{self.groupe}')"
if (__name__ == "__main__"):
import apl1test
apl1test.testmod('etudiant.py')
This diff is collapsed.
def pour_tous(seq_bool:list[bool])->bool:
""" à_remplacer_par_ce_que_fait_la_fonction
Précondition :
Exemple(s) :
$$$ pour_tous([])
True
$$$ pour_tous([True, True, True])
True
$$$ pour_tous([True, True, False])
False
"""
if False in seq_bool:
return False
return True
def il_existe(seq_bool:list[bool])->bool:
""" à_remplacer_par_ce_que_fait_la_fonction
Précondition :
Exemple(s) :
$$$ il_existe([])
False
$$$ il_existe([False, True, False])
True
$$$ il_existe([False, False])
False
"""
if True in seq_bool:
return True
return False
from date import Date
from etudiant import Etudiant
def charge_fichier_etudiants(fname: str) -> list[Etudiant]:
"""
Renvoie la liste des étudiants présents dans le fichier dont
le nom est donné en paramètre.
précondition: le fichier est du bon format.
"""
res = []
with open(fname, 'r') as fin:
fin.readline()
ligne = fin.readline()
while ligne != '':
nip, nom, prenom, naissance, formation, groupe = ligne.strip().split(';')
y, m, d = naissance.split('-')
date_naiss = Date(int(d.lstrip('0')), int(m.lstrip('0')), int(y))
res.append(Etudiant(int(nip), nom, prenom, date_naiss, formation, groupe))
ligne = fin.readline()
return res
L_ETUDIANTS = charge_fichier_etudiants('etudiants.csv')
COURTE_LISTE = L_ETUDIANTS[0:11]
def est_liste_d_etudiants(x) -> bool:
"""
Renvoie True si ``x`` est une liste de d'étudiant, False dans le cas contraire.
Précondition: aucune
Exemples:
$$$ est_liste_d_etudiants(COURTE_LISTE)
True
$$$ est_liste_d_etudiants("Timoleon")
False
$$$ est_liste_d_etudiants([('12345678', 'Calbuth', 'Raymond', 'Danse', '12') ])
False
"""
for elt in x:
if not(isinstance(elt, Etudiant)):
return False
return True
#c'est Etudiant(49801751, 'Bertin', 'Étienne', Date(9, 12, 2005), 'MI', '22')
def ensemble_des_formations(liste: list[Etudiant]) -> set[str]:
"""
Renvoie un ensemble de chaînes de caractères donnant les formations
présentes dans les fiches d'étudiants
Précondition: liste ne contient que des fiches d'étudiants
Exemples:
$$$ ensemble_des_formations(COURTE_LISTE)
{'MI', 'PEIP', 'MIASHS', 'LICAM'}
$$$ ensemble_des_formations(COURTE_LISTE[0:2])
{'MI', 'MIASHS'}
"""
ens = set()
for etudiant in liste:
ens.add(etudiant.formation)
return ens
def nom_pas_judicieux(liste):
""" renvoie le nombre de fois qu'un nom se repetent
Précondition :
Exemple(s) :
$$$
"""
res = {}
for etud in liste:
prenom = etud.prenom
if prenom in res:
res[prenom] = res[prenom] + 1
else:
res[prenom] = 1
return res
# 1)
res = nom_pas_judicieux(L_ETUDIANTS)
res['Alexandre']
# il y'a un Alexandre
# il y'a pas de Camille
# cette fonction necessite 603 parcours
# il y'a 201 prenom differents parmis tous les etudiants
# ces prenoms sont Cécile , Benoît
def frequent(dico):
""" à_remplacer_par_ce_que_fait_la_fonction
Précondition :
Exemple(s) :
$$$
"""
nb_max = 0
liste = []
for nom, val in dico.items():
if val > nb_max:
nb_max = val
liste = [nom]
elif val == nb_max:
liste.append(nom)
return liste
print(frequent(res))
def occurrences_nip(etudiants:list)->bool:
""" à_remplacer_par_ce_que_fait_la_fonction
Précondition :
Exemple(s) :
$$$
"""
nips = []
for etudiant in etudiants:
if etudiant.nip in nips:
return False
nips.append(etudiant.nip)
return True
def etu_formation(liste:list[Etudiant])->dict:
""" à_remplacer_par_ce_que_fait_la_fonction
Précondition :
Exemple(s) :
$$$
"""
dico={}
for etudiant in liste:
if etudiant.formation in liste:
dico[etudiant.formation]+=1
else:
dico[etudiant.formation] = 1
return dico
print(etu_formation(L_ETUDIANTS))
def liste_formation(liste: list[Etudiant], form: str) -> list[Etudiant]:
"""
Renvoie la liste des étudiants de la formation ``form``
Précondition: liste ne contient que des fiches d'étudiants
Exemples:
$$$ l_MI = liste_formation(COURTE_LISTE, 'MI')
$$$ len(l_MI)
7
$$$ type(l_MI[1]) == Etudiant
True
$$$ len(liste_formation(L_ETUDIANTS, 'INFO'))
0
"""
res = []
for etudiant in liste:
if etudiant.formation == form:
if not(etudiant in res):
res.append(etudiant)
return res
if __name__ == '__main__':
# éxécuté qd ce module n'est pas initialisé par un import.
L_ETUDIANTS = charge_fichier_etudiants('etudiants.csv')
COURTE_LISTE = L_ETUDIANTS[0:10]
NBRE_ETUDIANTS = len(L_ETUDIANTS)
# il y'a 603 etudiants dans L_ETUDIANTS
NIP = 42425158
\ No newline at end of file
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment