spectre/cours
1
0
Fork 0
mirror of https://github.com/Fare-spec/cours.git synced 2025-12-07 10:50:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
Spectre
2024-11-23 13:38:17 +01:00
parent 678203b19f
commit fb915042df
99 changed files with 6624 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
Partie2/Eleve/._livres.sql Normal file
View File

Binary file not shown.

BIN
Partie2/Eleve/._p_app_web_python_sqlite.pdf Normal file
View File

Binary file not shown.

1
Partie2/Eleve/Projet/__init__.py Normal file
View File

@@ -0,0 +1 @@
from .control import app

7
Partie2/Eleve/Projet/control.py Normal file
View File

@@ -0,0 +1,7 @@
from flask import Flask, render_template
app = Flask(__name__)
@app.route('/')
def index():
return render_template('index.html')

13
Partie2/Eleve/Projet/index.html Normal file
View File

@@ -0,0 +1,13 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<link rel="stylesheet" type="text/css" href="{{url_for('static',filename='CSS/style.css')}}">
</head>
<body>
<p>Bonjour</p>
</body>
</html>

13
Partie2/Eleve/Projet/templates/index.html Normal file
View File

@@ -0,0 +1,13 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<link rel="stylesheet" type="text/css" href="{{url_for('static',filename='CSS/style.css')}}">
</head>
<body>
<p>Bonjour</p>
</body>
</html>

BIN
Partie2/Eleve/livres.db Normal file
View File

Binary file not shown.

BIN
Partie2/Eleve/livres.db-journal Normal file
View File

Binary file not shown.

480
Partie2/Eleve/livres.sql Normal file
View File

@@ -0,0 +1,480 @@
BEGIN TRANSACTION;
DROP TABLE IF EXISTS "usagers";
CREATE TABLE IF NOT EXISTS "usagers" (
"nom" VARCHAR(90),
"prenom" VARCHAR(90),
"adresse" VARCHAR(90),
"cp" VARCHAR(90),
"ville" VARCHAR(90),
"email" VARCHAR(90),
"code_barre" CHAR(10),
CONSTRAINT "PK_usagers" PRIMARY KEY("code_barre")
);
DROP TABLE IF EXISTS "livre";
CREATE TABLE IF NOT EXISTS "livre" (
"titre" VARCHAR(300) NOT NULL,
"editeur" VARCHAR(90) NOT NULL,
"annee" INT NOT NULL,
"isbn" CHAR(14),
PRIMARY KEY("isbn")
);
DROP TABLE IF EXISTS "auteur";
CREATE TABLE IF NOT EXISTS "auteur" (
"a_id" INT,
"nom" VARCHAR(90) NOT NULL,
"prenom" VARCHAR(90) NOT NULL,
PRIMARY KEY("a_id")
);
DROP TABLE IF EXISTS "auteur_de";
CREATE TABLE IF NOT EXISTS "auteur_de" (
"a_id" INT,
"isbn" CHAR(14),
FOREIGN KEY("a_id") REFERENCES "Auteur"("a_id"),
FOREIGN KEY("isbn") REFERENCES "livre"("isbn"),
PRIMARY KEY("a_id","isbn")
);
DROP TABLE IF EXISTS "emprunts";
CREATE TABLE IF NOT EXISTS "emprunts" (
"code_barre" CHAR(10),
"isbn" VARCHAR(15),
"date_retour" DATE,
CONSTRAINT "FK_emprunts_usagers" FOREIGN KEY("code_barre") REFERENCES "usagers"("code_barre"),
CONSTRAINT "FK_emprunts_livre" FOREIGN KEY("isbn") REFERENCES "livre"("isbn"),
CONSTRAINT "PK_emprunts" PRIMARY KEY("code_barre","isbn","date_retour")
);
INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('MICHEL','VALÉRIE','104, Rue du Stade','75013','Paris','vmichel5@monmail.com','199614051174633');
INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('DURAND','JULIEN','183, Rue de la Gare','75019','Paris','jdurand9@email.fr','782124241492509');
INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('MOREAU','ALAIN','48, Rue du Château','75005','Paris','amoreau1@abc.de','421921003090881');
INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('DUBOIS','PHILIPPE','35, Rue du Moulin','75014','Paris','pdubois5@chezmoi.net','137332830764072');
INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('ROBERT','PASCAL','95, Rue de la Gare','75005','Paris','probert9@monmail.com','533299198788609');
INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('FOURNIER','DAVID','157, Rue de la Fontaine','75007','Paris','dfournier4@abc.de','612978231522917');
INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('LAURENT','FRANÇOISE','90, Rue Principale','75005','Paris','flaurent3@monmail.com','917547585216771');
INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('SIMON','SANDRINE','45, Rue du Château','75020','Paris','ssimon2@abc.de','654834075188732');
INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('PETIT','SÉBASTIEN','5, Rue du Stade','75012','Paris','spetit4@email.fr','934701281931582');
INSERT INTO "usagers" ("nom","prenom","adresse","cp","ville","email","code_barre") VALUES ('BERNARD','STÉPHANE','131, Place de la Mairie','75015','Paris','sbernard2@chezmoi.net','035184062854281');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Aventures de Huckleberry Finn','Flammarion',2020,'978-2081509511');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Fondation et Empire','Editions Denoël',1999,'978-2207249123');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Akira','Glénat',2000,'978-2723428262');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Robots','Editions Milan',2017,'978-2745989857');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Astérix chez les Pictes','Editions Albert René',2013,'978-2864972662');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Monades urbaines','Robert Laffont',2016,'978-2221197691');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Voyages de Gulliver','Primento',2015,'978-2335008586');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Lolita','Penguin UK',2012,'978-0141391601');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Nuit des temps','Presses de la Cité',2014,'978-2258116429');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Ravage','Editions Gallimard',2014,'978-2072534911');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Lauriers de César','Educa Books',2008,'978-2012101500');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Niourk','French Pulp éditions',2018,'979-1025100639');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Meilleur des mondes','Plon',2013,'978-2259221702');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Berlin Alexanderplatz','Editions Gallimard',1933,'978-2070219292');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Fahrenheit 451','Simon and Schuster',2011,'978-1439142677');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Mort d''Ivan Ilitch','Flammarion',2015,'978-2081364509');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Croisière sans escale','Editions Denoël',1990,'978-2207500293');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Vieil Homme et la Mer','Editions Gallimard',2018,'978-2072762093');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Mrs Dalloway','Flammarion',2015,'978-2081358881');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Idiot','Les Editions de Londres',2019,'978-1911572909');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Carnet d''or','Le Livre de poche',1980,'978-2253025320');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Grandes Espérances','BoD - Books on Demand',2019,'978-2322185801');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Astérix et Cléopâtre','Dargaud',1999,'978-2012100060');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Madame Bovary','UPblisher',2016,'978-2759902293');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Frères Karamazov','Les éditions Pulsio',2016,'978-2371131118');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Moby Dick','Campfire Graphic Novels',2010,'978-8190732673');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Demain les chiens','J''ai Lu',2015,'978-2290112168');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Tour de Gaule d''Astérix','Educa Books',2007,'978-2012101685');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('1984','Houghton Mifflin Harcourt',1983,'978-0547249643');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Don Quichotte','Les éditions Pulsio',2016,'978-2371130418');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Château de Lord Valentin','Robert Laffont',2017,'978-2221216361');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Père Goriot','Primento',2012,'978-2806231697');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Procès','Flammarion',2014,'978-2081351981');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Homme qui rétrécit','Editions Gallimard',2017,'978-2072457340');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Chroniques martiennes','Editions Gallimard',2016,'978-2072455162');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Roi Lear','Éditions Actes Sud',2015,'978-2330052768');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Cadeau de César','Educa Books',2005,'978-2012101531');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Planète des singes','Julliard',2011,'978-2260019183');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Orgueil et Préjugés','Fleurus',2015,'978-2215130475');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Une maison de poupée','Éditions Actes Sud',2016,'978-2330068349');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Vermilion Sands','Carroll & Graf Pub',1988,'978-0881844221');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Grande Traversée','Seuil Jeunesse',2014,'979-1023500448');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Étranger','Editions Gallimard',2012,'978-2072376429');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Île des morts','POL Editeur',2010,'978-2846825573');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Par-delà le mur du sommeil','République des Lettres',2018,'978-2824904269');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Papyrus de César','Editions Albert René',2015,'978-2864972716');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Main de Zeï','Bragelonne Classic',2016,'978-2820511034');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Beloved','Christian Bourgois',2015,'978-2267028133');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Conscience de Zeno','République des Lettres',2015,'978-2824902371');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Delirium Circus','Bragelonne',2013,'978-2820508935');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Médée','Hatier',2013,'978-2218972324');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Nostromo','Oxford University Press',2009,'978-0199555918');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Au carrefour des étoiles','J''ai Lu',1997,'978-2277118473');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Vagabond','BnF collection ebooks',2016,'978-2346014453');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Buddenbrook','LGF/Le Livre de Poche',1993,'978-2253063193');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Métamorphoses','Le Livre de Poche',2011,'978-2253158677');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Jack Barron et l''Éternité','J''ai Lu',2016,'978-2290105504');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Hacker''s Delight','Addison-Wesley Professional',2003,'978-0201914658');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Astérix et les Normands','Dargaud',2005,'978-2012101418');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Temps incertain','Robert Laffont',2011,'978-2221119709');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Astérix en Corse','Dargaud',2005,'978-2012101524');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Fils de la Médina','Arles [France] : Actes sud',2003,'978-2742744824');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Grand secret','Presses de la Cité',2014,'978-2258116405');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Devin','Educa Books',2010,'978-2012101517');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Noir Dessein','Livre de poche',1998,'978-2253062820');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Astérix légionnaire','Educa Books',2011,'978-2012101784');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Romancero gitano','Greenbooks editore',2020,'978-8832957402');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('The Practice of Programming','Addison-Wesley Professional',1999,'978-0201615869');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Crime et Châtiment','Editions Humanis',2012,'979-1021900486');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Promenade au phare','LGF/Le Livre de Poche',1983,'978-2253031536');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Homme sans qualités','Contemporary French Fiction',2011,'978-2757803691');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Bruit et la Fureur','Gallimard Education',1972,'978-2070361625');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Plus qu''humains','adsaa',1999,'000-0000000162');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Main gauche de la nuit','Robert Laffont',2012,'978-2221128121');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Mémoires d''Hadrien','Gallimard Education',1974,'978-2070369218');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Contes de l''absurde','Presses Pocket',1978,'978-2266006095');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Astérix et la Transitalique','Editions Albert René',2017,'978-2864973270');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Odyssée d''Astérix','Educa Books',2008,'978-2864972051');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Singes du temps','Robert Laffont',2011,'978-2221119693');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Contes de Canterbury','Gallimard Education',2000,'978-2070406340');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Sécheresse','La Cheminante',2014,'978-2371270060');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('The Art of Computer Programming','Addison-Wesley Professional',1997,'978-0321635747');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Aveuglement','Contemporary French Fiction',2000,'978-2020403436');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Berceau du chat','Contemporary French Fiction',2010,'978-2757820919');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Anna Karénine','Bibliothèque russe et slave',2018,'978-2371240087');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Montagne magique','Fayard',2016,'978-2213703848');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Domaine des dieux','French & European Publications',1992,'978-0785909903');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Cent ans de solitude','Contemporary French Fiction',1995,'978-2020238113');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Gargantua et Pantagruel','Livre de Poche Jeunesse',2009,'978-2013230827');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Contes','J''ai Lu',2015,'978-2290117965');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Guerre et Paix','Archipoche',2016,'978-2352879183');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Énéide','Belles Lettres',1993,'978-2251013039');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Seconde Fondation','adsaa',1979,'000-0000000097');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Jeux de l''esprit','FeniXX',1971,'978-2402281775');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Middlemarch','Wordsworth Editions',1994,'978-1853262371');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Œdipe roi','J''ai Lu',2013,'978-2290080207');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Amour aux temps du choléra','Grasset',2009,'978-2246819554');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Fictions','Gallimard Education',1974,'978-2070366149');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Astérix chez les Bretons','Dargaud',2002,'978-2012100084');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Château','Points',2011,'978-2757827413');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Voyageur imprudent','Editions Gallimard',2014,'978-2072535031');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Je suis une légende','Editions Gallimard',2013,'978-2072457388');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Maître du Haut Château','J''ai Lu',2017,'978-2290157268');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Âmes mortes','Bibliothèque russe et slave',2018,'978-2371240001');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Tambour','Contemporary French Fiction',1997,'978-2020314305');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Polymath','iMinds Pty Ltd',2014,'978-1921746864');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Seigneur de lumière','Editions Gallimard',2014,'978-2072487958');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Ulysse','Nathan',2012,'978-2092532195');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Pedro Páramo','New York : Grove Press',1959,'000-0000000069');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Ubik','Houghton Mifflin Harcourt',2012,'978-0547728247');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Algorithms','Addison-Wesley Professional',2011,'978-0132762564');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Fifi Brindacier','Hachette Romans',2013,'978-2011179043');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le monde s''effondre','Editions Présence Africaine',1972,'978-2708701915');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Naissance des dieux','Glénat BD',2017,'978-2331035531');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Hamlet','Primento',2012,'978-2806240187');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Enfants de minuit','Gallimard Education',2010,'978-2070402632');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Dune','Penguin',2003,'978-1101658055');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Couleur tombée du ciel','Tiers Livre Éditeur',2014,'978-2814510012');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Éducation sentimentale','FeniXX',1990,'978-2402282697');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Obélix et Compagnie','Educa Books',2008,'978-2012101555');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Journal d''un fou','Bibebook',2013,'978-2824709420');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Les Hauts de Hurlevent','Le Livre de Poche',2012,'978-2253174561');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La Plaie','FeniXX',1967,'978-2402255462');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Astérix chez les Belges','Dargaud',1979,'978-2012101562');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Le Rouge et le Noir','Les Éditions de l''Ebook malin',1971,'978-2367881171');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('À la recherche du temps perdu','Books LLC, Wiki Series',2010,'978-1153611725');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('La storia','Editions Gallimard',2004,'978-2070315017');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('L''Homme total','Presses Universitaires de France - PUF',2011,'978-2130592150');
INSERT INTO "livre" ("titre","editeur","annee","isbn") VALUES ('Mon livre','Buisson',2022,'0-2022');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (0,'Twain','Mark');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (1,'Asimov','Isaac');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (2,'Ōtomo','Katsuhiro');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (3,'Martelle','Myriam');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (4,'Touache','Sébastien');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (5,'Goscinny','René');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (6,'Ferri','Jean-Yves');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (7,'Uderzo','Albert');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (8,'Conrad','Didier');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (9,'SILVERBERG','Robert');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (10,'Swift','Jonathan');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (11,'Ligaran,','');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (12,'Nabokov','Vladimir');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (13,'BARJAVEL','René');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (14,'Barjavel','René');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (15,'Wul','Stefan');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (16,'HUXLEY','Aldous');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (17,'Döblin','Alfred');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (18,'Bradbury','Ray');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (19,'Tolstoï','Léon');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (20,'Aldiss','Brian Wilson');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (21,'Hemingway','Ernest');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (22,'Woolf','Virginia');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (23,'Fiodor','Dostoïevski');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (24,'Lessing','Doris');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (25,'Dickens','Charles');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (26,'Flaubert','Gustave');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (27,'Dostoïevski','Fiodor');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (28,'Melville','Herman');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (29,'Simak','Clifford D.');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (30,'Orwell','George');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (31,'Cervantes','Miguel de');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (32,'Balzac','Honoré de');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (33,'Kafka','Franz');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (34,'Matheson','Richard');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (35,'Py','Olivier');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (36,'Shakespeare','William');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (37,'BOULLE','Pierre');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (38,'Austen','Jane');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (39,'Ibsen','Henrik');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (40,'Ballard','J. G.');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (41,'Demois','Agathe');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (42,'Godeau','Vincent');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (43,'Camus','Albert');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (44,'Frémon','Jean');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (45,'Lovecraft','H. P.');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (46,'Camp','Lyon Sprague de');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (47,'Morrison','Toni');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (48,'Svevo','Italo');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (49,'Pelot','Pierre');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (50,'Corneille','');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (51,'Faerber','Johan');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (52,'Conrad','Joseph');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (53,'Deutsch','Michel');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (54,'Maupassant','Guy de');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (55,'Mann','Thomas');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (56,'Ovide','');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (57,'Spinrad','Norman');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (58,'Warren','Henry S.');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (59,'JEURY','Michel');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (60,'Goscinny','');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (61,'Maḥfūẓ','Naǧīb');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (62,'Farmer','Philip José');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (63,'Lorca','Federico Garcia');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (64,'Kernighan','Brian W.');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (65,'Pike','Rob');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (66,'Dostoïevski','Fédor Mikhaïlovitch');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (67,'Musil','Robert');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (68,'Faulkner','William');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (69,'Fransa','France');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (70,'GUIN','Ursula LE');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (71,'Yourcenar','Marguerite');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (72,'Boulle','Pierre');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (73,'Gascony','Rene');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (74,'Chaucer','Geoffrey');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (75,'Chenet','Gérard');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (76,'Knuth','Donald E.');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (77,'Saramago','José');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (78,'Vonnegut','Kurt');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (79,'Goscinny','Rene');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (80,'Márquez','Gabriel García');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (81,'Rabelais','François');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (82,'Laporte','Michel');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (83,'Nadel','Olivier-Marc');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (84,'Grimm','Jacob');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (85,'Grimm','Wilhelm');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (86,'Vergilius','Publius Maro');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (87,'Virgile','');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (88,'Eliot','George');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (89,'Sophocle','');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (90,'Márquez','Gabriel Garcia');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (91,'Borges','Jorge Luis');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (92,'Dick','Philip K.');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (93,'Gogol','Nikolaï');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (94,'Grass','Günter');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (95,'iMinds','');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (96,'Zelazny','Roger');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (97,'Montardre','Hélène');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (98,'Rulfo','Juan');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (99,'Sedgewick','Robert');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (100,'Wayne','Kevin');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (101,'Lindgren','Astrid');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (102,'Achebe','Chinua');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (103,'Bruneau','Clotilde');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (104,'D.','Dim');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (105,'Santagati','Federico');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (106,'Ferry','Luc');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (107,'Poli','Didier');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (108,'Rushdie','Salman');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (109,'Herbert','Frank');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (110,'Lovecraft','Howard Phillips');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (111,'Rincé','Dominique');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (112,'Gogol','Nikolai');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (113,'Brontë','Emily');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (114,'Fall','Malick');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (115,'Stendhal','');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (116,'Wikipedia','Source');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (117,'Morante','Elsa');
INSERT INTO "auteur" ("a_id","nom","prenom") VALUES (118,'Karsenti','Bruno');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (0,'978-2081509511');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (1,'978-2207249123');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (2,'978-2723428262');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (3,'978-2745989857');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (4,'978-2745989857');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2864972662');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (6,'978-2864972662');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2864972662');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (8,'978-2864972662');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (9,'978-2221197691');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (10,'978-2335008586');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (11,'978-2335008586');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (12,'978-0141391601');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (13,'978-2258116429');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (14,'978-2072534911');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012101500');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012101500');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (15,'979-1025100639');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (16,'978-2259221702');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (17,'978-2070219292');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (18,'978-1439142677');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (19,'978-2081364509');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (20,'978-2207500293');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (21,'978-2072762093');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (22,'978-2081358881');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (23,'978-1911572909');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (24,'978-2253025320');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (25,'978-2322185801');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012100060');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012100060');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (26,'978-2759902293');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (27,'978-2371131118');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (28,'978-8190732673');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (29,'978-2290112168');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012101685');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012101685');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (30,'978-0547249643');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (31,'978-2371130418');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (9,'978-2221216361');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (32,'978-2806231697');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (33,'978-2081351981');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (34,'978-2072457340');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (18,'978-2072455162');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (35,'978-2330052768');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (36,'978-2330052768');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012101531');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012101531');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (37,'978-2260019183');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (38,'978-2215130475');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (39,'978-2330068349');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (40,'978-0881844221');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (41,'979-1023500448');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (42,'979-1023500448');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (43,'978-2072376429');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (44,'978-2846825573');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (45,'978-2824904269');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (6,'978-2864972716');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (46,'978-2820511034');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (47,'978-2267028133');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (48,'978-2824902371');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (49,'978-2820508935');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (50,'978-2218972324');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (51,'978-2218972324');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (52,'978-0199555918');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (29,'978-2277118473');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (53,'978-2277118473');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (54,'978-2346014453');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (55,'978-2253063193');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (56,'978-2253158677');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (57,'978-2290105504');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (58,'978-0201914658');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012101418');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012101418');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (59,'978-2221119709');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (60,'978-2012101524');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012101524');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (61,'978-2742744824');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (13,'978-2258116405');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012101517');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012101517');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (62,'978-2253062820');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012101784');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012101784');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (63,'978-8832957402');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (64,'978-0201615869');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (65,'978-0201615869');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (66,'979-1021900486');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (22,'978-2253031536');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (67,'978-2757803691');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (68,'978-2070361625');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (69,'000-0000000162');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (70,'978-2221128121');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (71,'978-2070369218');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (72,'978-2266006095');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (6,'978-2864973270');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (73,'978-2864972051');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2864972051');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (59,'978-2221119693');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (74,'978-2070406340');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (75,'978-2371270060');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (76,'978-0321635747');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (77,'978-2020403436');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (78,'978-2757820919');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (19,'978-2371240087');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (55,'978-2213703848');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (79,'978-0785909903');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-0785909903');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (80,'978-2020238113');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (81,'978-2013230827');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (82,'978-2013230827');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (83,'978-2013230827');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (84,'978-2290117965');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (85,'978-2290117965');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (19,'978-2352879183');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (86,'978-2251013039');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (87,'978-2251013039');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (1,'000-0000000097');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (72,'978-2402281775');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (88,'978-1853262371');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (89,'978-2290080207');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (90,'978-2246819554');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (91,'978-2070366149');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012100084');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012100084');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (33,'978-2757827413');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (14,'978-2072535031');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (34,'978-2072457388');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (92,'978-2290157268');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (93,'978-2371240001');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (94,'978-2020314305');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (95,'978-1921746864');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (96,'978-2072487958');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (97,'978-2092532195');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (98,'000-0000000069');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (92,'978-0547728247');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (99,'978-0132762564');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (100,'978-0132762564');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (101,'978-2011179043');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (102,'978-2708701915');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (103,'978-2331035531');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (104,'978-2331035531');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (105,'978-2331035531');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (106,'978-2331035531');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (107,'978-2331035531');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (36,'978-2806240187');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (108,'978-2070402632');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (109,'978-1101658055');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (110,'978-2814510012');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (111,'978-2402282697');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012101555');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012101555');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (112,'978-2824709420');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (113,'978-2253174561');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (114,'978-2402255462');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (5,'978-2012101562');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (7,'978-2012101562');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (115,'978-2367881171');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (116,'978-1153611725');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (117,'978-2070315017');
INSERT INTO "auteur_de" ("a_id","isbn") VALUES (118,'978-2130592150');
INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('421921003090881','978-2081358881','2020-04-28');
INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('421921003090881','978-2207249123','2020-04-28');
INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('421921003090881','978-2824709420','2020-04-28');
INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('137332830764072','978-2352879183','2020-02-20');
INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('137332830764072','978-2335008586','2020-02-20');
INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('137332830764072','978-2013230827','2020-02-20');
INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('533299198788609','978-2253174561','2020-02-28');
INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('533299198788609','978-2251013039','2020-02-28');
INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('917547585216771','978-2290105504','2020-04-07');
INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('654834075188732','978-2864973270','2020-02-17');
INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('654834075188732','978-2070406340','2020-02-17');
INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('654834075188732','978-2806231697','2020-02-17');
INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('934701281931582','978-2260019183','2020-01-01');
INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('934701281931582','978-2371240087','2020-01-01');
INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('035184062854281','978-2745989857','2020-02-18');
INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('035184062854281','978-2072762093','2020-02-18');
INSERT INTO "emprunts" ("code_barre","isbn","date_retour") VALUES ('035184062854281','978-2742744824','2020-02-18');
COMMIT;

BIN
Partie2/Eleve/p_app_web_python_sqlite.pdf Normal file
View File

Binary file not shown.

5
Partie2/Eleve/run.py Normal file
View File

@@ -0,0 +1,5 @@
from Projet import app
if __name__ == "__main__":
app.run()

11
TDliste2liste/exercice1.py Normal file
View File

@@ -0,0 +1,11 @@
def appartient(elt,tableau):
for i in tableau:
if i == elt:
return True
else:
continue
return False
if __name__ == "__main__":
print(appartient(5,[1,2,3,4,5,6,7,8,9,10]))
print(appartient(5,[1,2,3,4,6,7,8,9,10]))

21
TDliste2liste/exercice2.py Normal file
View File

@@ -0,0 +1,21 @@
def max_local(tableau):
maximum = tableau[0]
for i in tableau:
if i > maximum:
maximum = i
else:
continue
return maximum
def indice_max(tableau):
maximum = max_local(tableau)
for i in range(len(tableau)):
if tableau[i] == maximum:
return i
else:
continue
if __name__ == "__main__":
l1 = [0,2,3,4,5,6,7,8,9,90,91,59,1]
print(max_local(l1))
print(indice_max(l1))

8
TDliste2liste/exercice3.py Normal file
View File

@@ -0,0 +1,8 @@
def cree_tableau_n_m(n,m):
return [[0 for _ in range(m)] for _ in range(n)]
def cree_tableau_carre_n(n):
return [[0 for _ in range(n)] for _ in range(n)]
if __name__ == "__main__":
print(cree_tableau_n_m(3,5))
print(cree_tableau_carre_n(5))

12
TDliste2liste/exercice4.py Normal file
View File

@@ -0,0 +1,12 @@
def cree_carre_entier_1_n_carre(n):
carre = []
compteur = 1
for i in range(n):
ligne = []
for j in range(n):
ligne.append(compteur)
compteur += 1
carre.append(ligne)
return carre
print(cree_carre_entier_1_n_carre(8))

9
TDliste2liste/exercice5.py Normal file
View File

@@ -0,0 +1,9 @@
def transpose(carre):
n = len(carre) # Nombre de lignes (ou colonnes, car c'est une matrice carrée)
return [[carre[j][i] for j in range(n)] for i in range(n)]
def transpose_en_place(carre):
n = len(carre) # Nombre de lignes (ou colonnes)
for i in range(n):
for j in range(i + 1, n): # Commencer à j = i + 1 pour éviter de réécrire les éléments déjà transposés
carre[i][j], carre[j][i] = carre[j][i], carre[i][j] # Échange des éléments

9
TDliste2liste/exercice6.py Normal file
View File

@@ -0,0 +1,9 @@
def diag_1(carre):
return [carre[i][i] for i in range(len(carre))]
def diag_2(carre):
n = len(carre)
return [carre[i][n - 1 - i] for i in range(n)]
def colonne(j, carre):
return [carre[i][j] for i in range(len(carre))]

260
TP6/LSC.py Normal file
View File

@@ -0,0 +1,260 @@
"""
Librairie des Listes Simplement Chaînées.
Elle met à distribution cette structure de données et son interface.
@author: L. JOANNIC
"""
# ############################################################################
class Liste_Simplement_Chainee(object):
"""
Classe des Listes Simplement Chainees.
Attributs
- _tete : None si vide, Maillon sinon.
Méthodes
- est_vide
- ajouter_en_tete
- tete
- queue
"""
def __init__(self):
"""
Construire une instance de Liste Simplement Chainee.
Returns
-------
None.
"""
self._tete = None
return None
def est_vide(self):
"""
Tester si l'instance est vide.
Returns
-------
bool
Vrai ssi la liste est vide.
"""
return (self._tete is None)
def ajouter_en_tete(self, element):
"""
Ajouter l'élément en tête de liste.
Parameters
----------
element : type de donnee
Donnnée à ajouter à la liste.
Returns
-------
resultat : Liste_Simplement_Chainee
La liste à abonder.
"""
resultat = Liste_Simplement_Chainee()
resultat._tete = Maillon(element, self)
return resultat
def tete(self):
"""
Renvoyer la donnée stockée en tête de liste.
Returns
-------
type de donnee quelconque
donnee en tete.
"""
assert not(self.est_vide()), "Liste Vide"
return self._tete.donnee
def queue(self):
"""
Renvoyer la sous-liste suivant le maillon de tete.
Returns
-------
Liste_Simplement_Chainee
Queue de la liste.
"""
assert not(self.est_vide()), "Liste Vide"
return self._tete.suite
# ############################################################################
def creer_liste_vide():
"""
Créer une liste simplement chainee vide.
Returns
-------
Liste_Simplement_Chainee
Liste vide.
Effets de bord
--------------
Aucun
"""
return Liste_Simplement_Chainee()
def est_vide(liste):
"""
Tester si la liste simplement chainee est vide.
Parameters
----------
liste : Liste Simplement Chainee
Liste à tester.
Returns
-------
bool
Vrai ssi la liste est vide.
Effets de bord
--------------
Aucun
"""
return liste.est_vide()
def ajouter_en_tete(liste, element):
"""
Inserer un element en tete de liste simplemeent chainee.
Parameters
----------
liste : LSC
Liste à abonder.
element : type de donnee
Donnee à aouter.
Returns
-------
LSC, copie de liste à laquelle element a été ajouté en tete.
Effets de bord
--------------
Aucun
"""
return liste.ajouter_en_tete(element)
def tete(liste):
"""
Consulter la tete de liste.
Parameters
----------
liste : LSC
Liste à consulter.
Returns
-------
type de donnée
valeur de la tete de liste.
Effets de bord
--------------
Aucun
"""
return liste.tete()
def queue(liste):
"""
Renvoyer la liste sans sa tete.
Parameters
----------
liste : LSC
Liste à étêter.
Returns
-------
LSC
Liste sans son maillon de tête.
Effets de bord
--------------
Aucun
"""
return liste.queue()
def afficher_liste(liste, taille=-1):
"""
Afficher la liste en format de présentation.
Parameters
----------
liste : LSC
Liste à énumérer.
Returns
-------
None.
Effets de bord
--------------
Affichage à l'écran.
"""
reste = liste
compteur = 0
print('+-----\n|')
while not(est_vide(reste)) and (taille == -1 or compteur < taille):
print('+- {}\n|'.format(str(tete(reste))))
reste = queue(reste)
compteur += 1
print('+-----')
return None
# ############################################################################
class Maillon(object):
"""
Classe des Maillons d'une Liste Simplement Chainee.
Attributs
- donnee : donnee stockee dans le maillon
- suite : liste simplemement chainee suivant le maillon
"""
def __init__(self, donnee=None, suite=Liste_Simplement_Chainee()):
"""
Construire une instance de la classe des Maillons.
Parameters
----------
donnee : type de donnee, optional
Donnee initiale dans le Maillon. The default is None.
suite : LSC, optional
Sous-liste suivant le Maillon courant.
The default is Liste_Simplement_Chainee().
Returns
-------
None.
"""
self.donnee = donnee
self.suite = suite
return None
# ############################################################################

17
TP6/Pile_LSC.py Normal file
View File

@@ -0,0 +1,17 @@
import LSC as lsc
from typing import Any
def creer_pile_vide() -> lsc.Liste_Simplement_Chainee:
return lsc.creer_liste_vide()
def est_pile_vide(liste: lsc.Liste_Simplement_Chainee) -> bool:
return lsc.est_vide(liste)
def sommet(liste: lsc.Liste_Simplement_Chainee) -> Any:
return lsc.tete(liste)
def empiler(liste: lsc.Liste_Simplement_Chainee, element: Any) -> lsc.Liste_Simplement_Chainee:
return lsc.ajouter_en_tete(liste,element)
def depiler(liste: lsc.Liste_Simplement_Chainee) -> lsc.Liste_Simplement_Chainee:
return lsc.queue(liste)

21
TP6/Pile_List.py Normal file
View File

@@ -0,0 +1,21 @@
from typing import Any
def creer_pile_vide():
return []
def est_pile_vide(pile: list):
return len(pile) == 0
def sommet(pile: list):
return pile[-1]
def empiler(pile: list, element: Any):
return pile + [element]
def depiler(pile: list):
return pile[:-1]

18
TP6/Pile_Tuple.py Normal file
View File

@@ -0,0 +1,18 @@
def creer_pile_vide():
return ()
def est_pile_vide(pile):
return pile == ()
def sommet(pile):
return pile[-1]
def empiler(pile, elt):
return pile + [elt]
def depiler(pile):
return pile[:-1]

BIN
TP6/TP_Piles.pdf Normal file
View File

Binary file not shown.

90
TP6/test.py Normal file
View File

@@ -0,0 +1,90 @@
import Pile_LSC as lifo
import LSC as blsc
from random import shuffle
def afficher(pile):
"""Affiche les éléments d'une pile du sommet à la base."""
print("|----")
while not lifo.est_pile_vide(pile):
print(f"| {lifo.sommet(pile)}")
pile = lifo.depiler(pile)
print("|----\n")
def hauteur_pile(pile):
"""Renvoie la hauteur de la pile sans la modifier."""
copie = pile
n = 0
while not lifo.est_pile_vide(copie):
copie = lifo.depiler(copie)
n += 1
return n
def max_pile(pile: blsc.Liste_Simplement_Chainee, i: int):
"""Trouve le maximum parmi les i premiers éléments de la pile."""
total = hauteur_pile(pile)
#assert i > total (f"Taille insuffisante : attendu au moins {i} éléments")
meilleur = lifo.sommet(pile) # Premier élément comme point de départ
temporaire = pile
for _ in range(i):
courant = lifo.sommet(temporaire)
temporaire = lifo.depiler(temporaire)
if courant > meilleur:
meilleur = courant
return meilleur
def retourner(pile, j):
"""Inverse les j derniers éléments de la pile."""
pile_aux = lifo.creer_pile_vide()
# Depile les éléments dans une pile temporaire:
for _ in range(j):
pile_aux = lifo.empiler(pile_aux, lifo.sommet(pile))
pile = lifo.depiler(pile)
# Remets les éléments inversés dans la pile principale:
while not lifo.est_pile_vide(pile_aux):
pile = lifo.empiler(pile, lifo.sommet(pile_aux))
pile_aux = lifo.depiler(pile_aux)
return pile
def tri_crepes_recursif(pile, n=None):
"""Trie la pile en utilisant le tri des crêpes de manière récursive."""
if n is None:
n = hauteur_pile(pile)
# pas besoin de tri en si len(pile) == 1
if n <= 1:
return pile
pos_max = max_pile(pile, n)
if pos_max != 1:
pile = retourner(pile, pos_max)
pile = retourner(pile, n)
return tri_crepes_recursif(pile, n - 1)
if __name__ == "__main__":
# Initialisation d'une pile avec des valeurs aléatoires
# Tri des crêpes récursif
ma_liste = [_ for _ in range(10)]
shuffle(ma_liste)
print("Liste de départ : ", ma_liste)
ma_pile = lifo.creer_pile_vide()
print("\nEMPILEMENT\n")
for element in ma_liste:
ma_pile = lifo.empiler(ma_pile, element)
afficher(ma_pile)
print("\nDEPILEMENT\n")
while not(lifo.est_pile_vide(ma_pile)):
print(f"Sommet : {lifo.sommet(ma_pile)}")
ma_pile = lifo.depiler(ma_pile)
afficher(ma_pile)
print(max_pile(ma_pile,1))

34
TP6/test.py.patch Normal file
View File

@@ -0,0 +1,34 @@
# Patch generated by Pyment v0.3.3
--- a/test.py
+++ b/test.py
@@ -3,6 +3,14 @@
def afficher(pile):
+ """
+
+ Args:
+ pile:
+
+ Returns:
+
+ """
print("|----\n|")
while not (lifo.est_vide(pile)):
print("| {}\n|".format(lifo.sommet(pile)))
@@ -12,6 +20,14 @@
def hauteur_pile(P):
+ """
+
+ Args:
+ P:
+
+ Returns:
+
+ """
n = 0
while not (lifo.est_vide(P)):
n += 1

7
TP6/test_2.py/Pile_List.rst Normal file
View File

@@ -0,0 +1,7 @@
Pile\_List module
=================
.. automodule:: Pile_List
:members:
:undoc-members:
:show-inheritance:

7
TP6/test_2.py/Pile_Tuple.rst Normal file
View File

@@ -0,0 +1,7 @@
Pile\_Tuple module
==================
.. automodule:: Pile_Tuple
:members:
:undoc-members:
:show-inheritance:

9
TP6/test_2.py/modules.rst Normal file
View File

@@ -0,0 +1,9 @@
TP6
===
.. toctree::
:maxdepth: 4
Pile_List
Pile_Tuple
test

7
TP6/test_2.py/test.rst Normal file
View File

@@ -0,0 +1,7 @@
test module
===========
.. automodule:: test
:members:
:undoc-members:
:show-inheritance:

BIN
elouan_fare.tar.gz Normal file
View File

Binary file not shown.

260
elouan_fare/tp6/LSC.py Normal file
View File

@@ -0,0 +1,260 @@
"""
Librairie des Listes Simplement Chaînées.
Elle met à distribution cette structure de données et son interface.
@author: L. JOANNIC
"""
# ############################################################################
class Liste_Simplement_Chainee(object):
"""
Classe des Listes Simplement Chainees.
Attributs
- _tete : None si vide, Maillon sinon.
Méthodes
- est_vide
- ajouter_en_tete
- tete
- queue
"""
def __init__(self):
"""
Construire une instance de Liste Simplement Chainee.
Returns
-------
None.
"""
self._tete = None
return None
def est_vide(self):
"""
Tester si l'instance est vide.
Returns
-------
bool
Vrai ssi la liste est vide.
"""
return (self._tete is None)
def ajouter_en_tete(self, element):
"""
Ajouter l'élément en tête de liste.
Parameters
----------
element : type de donnee
Donnnée à ajouter à la liste.
Returns
-------
resultat : Liste_Simplement_Chainee
La liste à abonder.
"""
resultat = Liste_Simplement_Chainee()
resultat._tete = Maillon(element, self)
return resultat
def tete(self):
"""
Renvoyer la donnée stockée en tête de liste.
Returns
-------
type de donnee quelconque
donnee en tete.
"""
assert not(self.est_vide()), "Liste Vide"
return self._tete.donnee
def queue(self):
"""
Renvoyer la sous-liste suivant le maillon de tete.
Returns
-------
Liste_Simplement_Chainee
Queue de la liste.
"""
assert not(self.est_vide()), "Liste Vide"
return self._tete.suite
# ############################################################################
def creer_liste_vide():
"""
Créer une liste simplement chainee vide.
Returns
-------
Liste_Simplement_Chainee
Liste vide.
Effets de bord
--------------
Aucun
"""
return Liste_Simplement_Chainee()
def est_vide(liste):
"""
Tester si la liste simplement chainee est vide.
Parameters
----------
liste : Liste Simplement Chainee
Liste à tester.
Returns
-------
bool
Vrai ssi la liste est vide.
Effets de bord
--------------
Aucun
"""
return liste.est_vide()
def ajouter_en_tete(liste, element):
"""
Inserer un element en tete de liste simplemeent chainee.
Parameters
----------
liste : LSC
Liste à abonder.
element : type de donnee
Donnee à aouter.
Returns
-------
LSC, copie de liste à laquelle element a été ajouté en tete.
Effets de bord
--------------
Aucun
"""
return liste.ajouter_en_tete(element)
def tete(liste):
"""
Consulter la tete de liste.
Parameters
----------
liste : LSC
Liste à consulter.
Returns
-------
type de donnée
valeur de la tete de liste.
Effets de bord
--------------
Aucun
"""
return liste.tete()
def queue(liste):
"""
Renvoyer la liste sans sa tete.
Parameters
----------
liste : LSC
Liste à étêter.
Returns
-------
LSC
Liste sans son maillon de tête.
Effets de bord
--------------
Aucun
"""
return liste.queue()
def afficher_liste(liste, taille=-1):
"""
Afficher la liste en format de présentation.
Parameters
----------
liste : LSC
Liste à énumérer.
Returns
-------
None.
Effets de bord
--------------
Affichage à l'écran.
"""
reste = liste
compteur = 0
print('+-----\n|')
while not(est_vide(reste)) and (taille == -1 or compteur < taille):
print('+- {}\n|'.format(str(tete(reste))))
reste = queue(reste)
compteur += 1
print('+-----')
return None
# ############################################################################
class Maillon(object):
"""
Classe des Maillons d'une Liste Simplement Chainee.
Attributs
- donnee : donnee stockee dans le maillon
- suite : liste simplemement chainee suivant le maillon
"""
def __init__(self, donnee=None, suite=Liste_Simplement_Chainee()):
"""
Construire une instance de la classe des Maillons.
Parameters
----------
donnee : type de donnee, optional
Donnee initiale dans le Maillon. The default is None.
suite : LSC, optional
Sous-liste suivant le Maillon courant.
The default is Liste_Simplement_Chainee().
Returns
-------
None.
"""
self.donnee = donnee
self.suite = suite
return None
# ############################################################################

63
elouan_fare/tp6/Pile_LSC.py Normal file
View File

@@ -0,0 +1,63 @@
import LSC as lsc
from typing import Any
def creer_pile_vide() -> lsc.Liste_Simplement_Chainee:
"""Crée une pile vide sous forme de liste simplement chaînée.
Returns:
lsc.Liste_Simplement_Chainee: Une pile vide représentée par une liste simplement chaînée.
"""
return lsc.creer_liste_vide()
def est_pile_vide(pile: lsc.Liste_Simplement_Chainee) -> bool:
"""Vérifie si la pile est vide.
Args:
pile (lsc.Liste_Simplement_Chainee): La pile à vérifier.
Returns:
bool: True si la pile est vide, False sinon.
"""
return lsc.est_vide(pile)
def sommet(pile: lsc.Liste_Simplement_Chainee) -> Any:
"""Renvoie l'élément au sommet de la pile.
Args:
pile (lsc.Liste_Simplement_Chainee): La pile dont on veut connaître le sommet.
Returns:
Any: L'élément au sommet de la pile.
Raises:
AssertionError: Si la pile est vide.
"""
assert not est_pile_vide(pile), "Pile vide."
return lsc.tete(pile)
def empiler(pile: lsc.Liste_Simplement_Chainee, element: Any) -> lsc.Liste_Simplement_Chainee:
"""Ajoute un élément au sommet de la pile.
Args:
pile (lsc.Liste_Simplement_Chainee): La pile actuelle.
element (Any): L'élément à ajouter au sommet de la pile.
Returns:
lsc.Liste_Simplement_Chainee: La nouvelle pile avec l'élément ajouté.
"""
return lsc.ajouter_en_tete(pile, element)
def depiler(pile: lsc.Liste_Simplement_Chainee) -> lsc.Liste_Simplement_Chainee:
"""Retire l'élément au sommet de la pile.
Args:
pile (lsc.Liste_Simplement_Chainee): La pile dont on veut retirer le sommet.
Returns:
lsc.Liste_Simplement_Chainee: La nouvelle pile sans l'élément au sommet.
Raises:
AssertionError: Si la pile est vide.
"""
assert not est_pile_vide(pile), "Pile vide!"
return lsc.queue(pile)

62
elouan_fare/tp6/Pile_List.py Normal file
View File

@@ -0,0 +1,62 @@
from typing import Any
def creer_pile_vide() -> list:
"""Crée une pile vide sous forme de liste.
Returns:
list: Une pile vide représentée par une liste.
"""
return []
def est_pile_vide(pile: list) -> bool:
"""Vérifie si la pile est vide.
Args:
pile (list): La pile à vérifier.
Returns:
bool: True si la pile est vide, False sinon.
"""
return len(pile) == 0
def sommet(pile: list) -> Any:
"""Renvoie l'élément au sommet de la pile.
Args:
pile (list): La pile dont on veut connaître le sommet.
Returns:
Any: L'élément au sommet de la pile.
Raises:
AssertionError: Si la pile est vide.
"""
assert not est_pile_vide(pile), "Pile vide!"
return pile[-1]
def empiler(pile: list, element: Any) -> list:
"""Ajoute un élément au sommet de la pile.
Args:
pile (list): La pile actuelle.
element (Any): L'élément à ajouter au sommet de la pile.
Returns:
list: La nouvelle pile avec l'élément ajouté.
"""
return pile + [element]
def depiler(pile: list) -> list:
"""Retire l'élément au sommet de la pile.
Args:
pile (list): La pile dont on veut retirer le sommet.
Returns:
list: La nouvelle pile sans l'élément au sommet.
Raises:
AssertionError: Si la pile est vide.
"""
assert not est_pile_vide(pile), "Pile vide!"
return pile[:-1]

60
elouan_fare/tp6/Pile_Tuple.py Normal file
View File

@@ -0,0 +1,60 @@
def creer_pile_vide():
"""Crée une pile vide sous forme de tuple.
Returns:
tuple: Une pile vide représentée par un tuple vide.
"""
return ()
def est_pile_vide(pile):
"""Vérifie si la pile est vide.
Args:
pile (tuple): La pile à vérifier.
Returns:
bool: True si la pile est vide, False sinon.
"""
return pile == ()
def sommet(pile):
"""Renvoie l'élément au sommet de la pile.
Args:
pile (tuple): La pile dont on veut connaître le sommet.
Returns:
_type_: L'élément au sommet de la pile.
Raises:
AssertionError: Si la pile est vide.
"""
assert not est_pile_vide(pile), "Pile vide!"
return pile[-1]
def empiler(pile, elt):
"""Ajoute un élément au sommet de la pile.
Args:
pile (tuple): La pile actuelle.
elt (_type_): L'élément à ajouter au sommet de la pile.
Returns:
tuple: La nouvelle pile avec l'élément ajouté.
"""
return pile + (elt,)
def depiler(pile):
"""Retire l'élément au sommet de la pile.
Args:
pile (tuple): La pile dont on veut retirer le sommet.
Returns:
tuple: La nouvelle pile sans l'élément au sommet.
Raises:
AssertionError: Si la pile est vide.
"""
assert not est_pile_vide(pile), "Pile vide!"
return pile[:-1]

69
elouan_fare/tp6/README.md Normal file
View File

@@ -0,0 +1,69 @@
# Devoir Maison : Gestion de Piles et Notation Polonaise Inverse
Ce devoir présente des fonctions pour manipuler des piles et évaluer des expressions en notation polonaise inverse (NPI).
## Prérequis
Pour exécuter ce devoir, vous aurez besoin de :
- [Python 3.x](https://www.python.org/downloads/) installé sur votre machine.
### Installation de Python
1. **Téléchargez Python** : Allez sur le [site officiel de Python](https://www.python.org/downloads/) et téléchargez la dernière version stable pour votre système d'exploitation.
2. **Installez Python** : Suivez les instructions d'installation. Assurez-vous de cocher l'option "Add Python to PATH" lors de l'installation sur Windows.
3. **Vérifiez l'installation** : Ouvrez votre terminal ou votre invite de commande et exécutez la commande suivante :
```bash
python --version
```
Cela devrait afficher la version de Python installée.
## Utilisation des Modules
### Modules Fournis
Le devoir contient les modules suivants :
- `LSC` : Implémentation d'une liste simplement chaînée.
- `Pile_LSC` : Implémentation d'une pile utilisant une liste simplement chaînée.
- `Tuple` : Implémentation d'une pile utilisant un tuple.
- `Liste` : Implémentation d'une pile utilisant une liste.
#### Primitives du Module `LSC`
- `creer_liste_vide()`: Crée une liste vide.
- `est_vide(liste)`: Vérifie si la liste est vide.
- `ajouter_en_tete(liste, element)`: Ajoute un élément au début de la liste.
- `queue(liste)`: Retire le premier élément de la liste.
- `tete(liste)`: Renvoie le premier élément de la liste.
#### Primitives du Module `Pile_LSC`
- `creer_pile_vide()`: Crée une pile vide sous forme de liste simplement chaînée.
- `est_pile_vide(pile)`: Vérifie si la pile est vide.
- `sommet(pile)`: Renvoie l'élément au sommet de la pile.
- `empiler(pile, element)`: Ajoute un élément au sommet de la pile.
- `depiler(pile)`: Retire l'élément au sommet de la pile.
## Fichier `test.py`
Le fichier `test.py` contient des exemples d'utilisation des fonctionnalités de gestion de piles et d'évaluation en notation polonaise inverse.
### Fonctions dans `test.py`
- **Afficher une pile** : Affiche les éléments d'une pile du sommet à la base.
- **Copier une pile** : Crée une copie d'une pile donnée.
- **Hauteur de la pile** : Renvoie la hauteur de la pile.
- **Inverser des éléments** : Inverse les `j` derniers éléments de la pile.
- **Trouver le maximum** : Renvoie la position du maximum parmi les `i` derniers éléments de la pile.
- **Tri des crêpes** : Trie les éléments de la pile en utilisant la méthode des crêpes.
- **Évaluation NPI** : Évalue une expression arithmétique en notation polonaise inverse.
### Exécution de `test.py`
Pour exécuter le script, ouvrez votre terminal, naviguez vers le dossier contenant le fichier `test.py`, puis exécutez la commande suivante :
```bash
python test.py

BIN
elouan_fare/tp6/TP_Piles.pdf Normal file
View File

Binary file not shown.

46
elouan_fare/tp6/npi.py Normal file
View File

@@ -0,0 +1,46 @@
def evaluer_npi(expression):
"""fais la notation polonaise inversée (NPI) d'une expression arithmétique
Args:
expression (_type_): String contenant l'expression arithmétique
Returns:
_type_: Integer contenant le resultat.
"""
pile = []
elements = expression.split()
for element in elements:
if element.isdigit():
pile.append(int(element))
else:
droite = pile.pop()
gauche = pile.pop()
if element == '+':
resultat = gauche + droite
elif element == '-':
resultat = gauche - droite
elif element == '*':
resultat = gauche * droite
elif element == '/':
resultat = gauche / droite
else:
raise ValueError(f"Opérateur inconnu: {element}")
pile.append(resultat)
if len(pile) != 1:
raise ValueError("L'expression est mal formée.")
return pile.pop()
expression = "100 60 / 60 + 90 *"
resultat = evaluer_npi(expression)
print(f"Le résultat de l'expression '{expression}' est: {resultat}")

125
elouan_fare/tp6/test.py Normal file
View File

@@ -0,0 +1,125 @@
import Pile_LSC as lifo
from random import shuffle
def afficher(pile):
"""Affiche les éléments d'une pile du sommet à la base."""
print("|----")
temp = pile
while not lifo.est_pile_vide(temp):
print(f"| {lifo.sommet(temp)}")
temp = lifo.depiler(temp)
print("|----\n")
def copier_pile(pile):
"""Copie une pile représentée par une liste simplement chaînée."""
copie = lifo.creer_pile_vide()
pile_temp = lifo.creer_pile_vide()
while not lifo.est_pile_vide(pile):
sommet = lifo.sommet(pile)
pile_temp = lifo.empiler(pile_temp, sommet)
pile = lifo.depiler(pile)
while not lifo.est_pile_vide(pile_temp):
sommet = lifo.sommet(pile_temp)
pile = lifo.empiler(pile, sommet)
copie = lifo.empiler(copie, sommet)
pile_temp = lifo.depiler(pile_temp)
return copie
def hauteur_pile(pile):
"""
Renvoie hauteur de la pile.
PARAMETRES : pile - pile à analyser.
RETURN : hauteur.
EFFET DE BORD : Aucune.
"""
n = 0
while not lifo.est_pile_vide(pile):
n += 1
pile = lifo.depiler(pile)
return n
def retourner(pile, j):
"""
Inverse j derniers éléments de la pile.
PARAMETRES : pile - pile à modifier, j - nombre d'éléments à inverser.
RETURN : Aucune.
EFFET DE BORD : Modifie la pile.
"""
pile_aux = lifo.creer_pile_vide()
for _ in range(j):
if lifo.est_pile_vide(pile):
break
pile_aux = lifo.empiler(pile_aux, lifo.sommet(pile))
pile = lifo.depiler(pile)
while not lifo.est_pile_vide(pile_aux):
pile = lifo.empiler(pile, lifo.sommet(pile_aux))
pile_aux = lifo.depiler(pile_aux)
def max_pile(pile, i):
"""
Renvoie position du maximum parmi i derniers éléments.
PARAMETRES : pile - pile à analyser, i - nombre d'éléments.
RETURN : position du maximum.
EFFET DE BORD : Aucune.
"""
copy = copier_pile(pile)
max_value = lifo.sommet(copy)
ind = 1
ind_n = 1
for _ in range(i):
if lifo.est_pile_vide(copy):
break
current = lifo.sommet(copy)
if current > max_value:
max_value = current
ind = ind_n
copy = lifo.depiler(copy)
ind_n += 1
return ind
def tri_crepes_iteratif(pile): #ne fonctionne pas
"""
Tri des crêpes en cours.
PARAMETRES : pile - pile à trier.
RETURN : pile triée.
EFFET DE BORD : Modifie la pile.
"""
n = hauteur_pile(pile)
for i in range(n):
max_position = max_pile(pile, n - i)
if max_position!= n - i:
retourner(pile, n - max_position)
retourner(pile, i + 1)
return pile
if __name__ == "__main__":
from random import shuffle
ma_liste = [i for i in range(10)]
shuffle(ma_liste)
print("Liste de départ :", ma_liste)
ma_pile = lifo.creer_pile_vide()
for element in ma_liste:
ma_pile = lifo.empiler(ma_pile, element)
print("\nPile initiale :")
afficher(ma_pile)
print(max_pile(ma_pile,10))
print("Tri des crêpes en cours...")
ma_pile = tri_crepes_iteratif(ma_pile)
print("Pile après tri :")
afficher(ma_pile)

BIN
elouan_fare_v1.1.tar.gz Normal file
View File

Binary file not shown.

BIN
elouan_fare_v1.1.tart.gz Normal file
View File

Binary file not shown.

BIN
elouan_fare_v2.tar.gz Normal file
View File

Binary file not shown.

260
elouan_fare_v2/tp6_self/LSC.py Normal file
View File

@@ -0,0 +1,260 @@
"""
Librairie des Listes Simplement Chaînées.
Elle met à distribution cette structure de données et son interface.
@author: L. JOANNIC
"""
# ############################################################################
class Liste_Simplement_Chainee(object):
"""
Classe des Listes Simplement Chainees.
Attributs
- _tete : None si vide, Maillon sinon.
Méthodes
- est_vide
- ajouter_en_tete
- tete
- queue
"""
def __init__(self):
"""
Construire une instance de Liste Simplement Chainee.
Returns
-------
None.
"""
self._tete = None
return None
def est_vide(self):
"""
Tester si l'instance est vide.
Returns
-------
bool
Vrai ssi la liste est vide.
"""
return (self._tete is None)
def ajouter_en_tete(self, element):
"""
Ajouter l'élément en tête de liste.
Parameters
----------
element : type de donnee
Donnnée à ajouter à la liste.
Returns
-------
resultat : Liste_Simplement_Chainee
La liste à abonder.
"""
resultat = Liste_Simplement_Chainee()
resultat._tete = Maillon(element, self)
return resultat
def tete(self):
"""
Renvoyer la donnée stockée en tête de liste.
Returns
-------
type de donnee quelconque
donnee en tete.
"""
assert not(self.est_vide()), "Liste Vide"
return self._tete.donnee
def queue(self):
"""
Renvoyer la sous-liste suivant le maillon de tete.
Returns
-------
Liste_Simplement_Chainee
Queue de la liste.
"""
assert not(self.est_vide()), "Liste Vide"
return self._tete.suite
# ############################################################################
def creer_liste_vide():
"""
Créer une liste simplement chainee vide.
Returns
-------
Liste_Simplement_Chainee
Liste vide.
Effets de bord
--------------
Aucun
"""
return Liste_Simplement_Chainee()
def est_vide(liste):
"""
Tester si la liste simplement chainee est vide.
Parameters
----------
liste : Liste Simplement Chainee
Liste à tester.
Returns
-------
bool
Vrai ssi la liste est vide.
Effets de bord
--------------
Aucun
"""
return liste.est_vide()
def ajouter_en_tete(liste, element):
"""
Inserer un element en tete de liste simplemeent chainee.
Parameters
----------
liste : LSC
Liste à abonder.
element : type de donnee
Donnee à aouter.
Returns
-------
LSC, copie de liste à laquelle element a été ajouté en tete.
Effets de bord
--------------
Aucun
"""
return liste.ajouter_en_tete(element)
def tete(liste):
"""
Consulter la tete de liste.
Parameters
----------
liste : LSC
Liste à consulter.
Returns
-------
type de donnée
valeur de la tete de liste.
Effets de bord
--------------
Aucun
"""
return liste.tete()
def queue(liste):
"""
Renvoyer la liste sans sa tete.
Parameters
----------
liste : LSC
Liste à étêter.
Returns
-------
LSC
Liste sans son maillon de tête.
Effets de bord
--------------
Aucun
"""
return liste.queue()
def afficher_liste(liste, taille=-1):
"""
Afficher la liste en format de présentation.
Parameters
----------
liste : LSC
Liste à énumérer.
Returns
-------
None.
Effets de bord
--------------
Affichage à l'écran.
"""
reste = liste
compteur = 0
print('+-----\n|')
while not(est_vide(reste)) and (taille == -1 or compteur < taille):
print('+- {}\n|'.format(str(tete(reste))))
reste = queue(reste)
compteur += 1
print('+-----')
return None
# ############################################################################
class Maillon(object):
"""
Classe des Maillons d'une Liste Simplement Chainee.
Attributs
- donnee : donnee stockee dans le maillon
- suite : liste simplemement chainee suivant le maillon
"""
def __init__(self, donnee=None, suite=Liste_Simplement_Chainee()):
"""
Construire une instance de la classe des Maillons.
Parameters
----------
donnee : type de donnee, optional
Donnee initiale dans le Maillon. The default is None.
suite : LSC, optional
Sous-liste suivant le Maillon courant.
The default is Liste_Simplement_Chainee().
Returns
-------
None.
"""
self.donnee = donnee
self.suite = suite
return None
# ############################################################################

55
elouan_fare_v2/tp6_self/Pile_LSC.py Normal file
View File

@@ -0,0 +1,55 @@
import LSC as lsc
# Chacune des fonctions renvoie et n'ont pas d'effet de bord
def creer_pile_vide():
"""Creer une pile vide.
Returns:
lsc.Liste_Simplement_Chainee: La liste vide
"""
return lsc.creer_liste_vide()
def est_pile_vide(pile: lsc.Liste_Simplement_Chainee):
"""Retourne True si la pile est vide, False sinon.
Args:
pile (lsc.Liste_Simplement_Chainee): La pile à tester
Returns:
bool: True si la pile est vide
"""
return lsc.est_vide(pile)
def sommet(pile: lsc.Liste_Simplement_Chainee):
"""Retourne le sommet de la pile.
Args:
pile (lsc.Liste_Simplement_Chainee): La pile avec le sommet
Returns:
any: Le sommet de la pile
"""
assert not est_pile_vide(pile), "La pile est vide"
return lsc.tete(pile)
def empiler(pile: lsc.Liste_Simplement_Chainee,elt: any):
"""Ajoute un element en tete de la pile
Args:
pile lsc.Liste_Simplement_Chainee: La pile à modifier
elt any: l'element a ajouter
Returns:
lsc.Liste_Simplement_Chainee : La pile avec l'element ajouté
"""
return lsc.ajouter_en_tete(pile, elt)
def depiler(pile: lsc.Liste_Simplement_Chainee):
"""Retire le sommet de la pile
Args:
pile (lsc.Liste_Simplement_Chainee): La pile avec le sommet
Returns:
lsc.Liste_Simplement_Chainee: La pile avec le sommet retiré
"""
assert not est_pile_vide(pile), "La pile est vide"
return lsc.queue(pile)

54
elouan_fare_v2/tp6_self/Pile_List.py Normal file
View File

@@ -0,0 +1,54 @@
# Chacune des fonctions renvoie et n'ont pas d'effet de bord
def creer_pile_vide()->list:
"""Créer une pile vide.
Returns:
list: La pile vide
"""
return []
def est_pile_vide(pile: list) -> bool:
"""Retourne True si la pile est vide, False sinon.
Args:
pile (list): La pile à tester
Returns:
bool: True si la pile est vide
"""
return len(pile) == 0
def sommet(pile: list)->int:
"""Retourne le sommet de la pile.
Args:
pile (list): La pile avec le sommet
Returns:
any: le sommet de la pile
"""
assert not est_pile_vide(pile), "La pile est vide"
return pile[-1]
def empiler(pile: list, elt: any)-> list:
"""rajoute elt au sommet de la pile
Args:
pile (list): La pile à modifier
elt (any): l'élement à ajouter
Returns:
list: la pile modifiée
"""
return pile + [elt]
def depiler(pile: list)-> any:
"""retourne la pile sans le sommet
Args:
pile (list): la pile avec le sommet
Returns:
any: la pile sans le sommet
"""
assert not est_pile_vide(pile), "La pile est vide"
return pile[:-1]

54
elouan_fare_v2/tp6_self/Pile_Tuple.py Normal file
View File

@@ -0,0 +1,54 @@
# Chacune des fonctions renvoie et n'ont pas d'effet de bord
def creer_pile_vide() -> tuple:
"""Créer une pile vide.
Returns:
Tuple: La pile vide
"""
return ()
def est_pile_vide(pile: tuple) -> bool:
"""Retourne True si la pile est vide, False sinon.
Args:
pile (tuple): La pile à tester
Returns:
bool: True si la pile est vide
"""
return len(pile) == 0
def sommet(pile: tuple) -> any:
"""Renvoie le sommet de la pile.
Args:
pile (tuple): La pile contenant le sommet
Returns:
any: Le sommet de la pile
"""
return pile[-1]
def empiler(pile: tuple, elt: any)-> tuple:
"""ajoute elt au sommet de la pile
Args:
pile (tuple): la pile a modifier
elt (any): l'élement à ajouter
Returns:
tuple: la pile avec l'élement ajouté
"""
return pile + (elt,)
def depiler(pile: tuple) -> tuple:
"""Retire le sommet de la pile
Args:
pile (tuple): La pile avec le sommet
Returns:
tuple: La pile avec le sommet retiré
"""
assert not est_pile_vide(pile), "La pile est vide"
return pile[:-1]

133
elouan_fare_v2/tp6_self/README.md Normal file
View File

@@ -0,0 +1,133 @@
# **README - DM Piles et NPI**
## **Comment exécuter le programme :**
1. Verfier que tous les fichiers sont dans le même répertoire :
- `test.py`
- `Pile_Tuple.py`
- `Pile_LSC.py`
- `Pile_Liste.py`
- `npi.py`
2. Ouvrez un terminal dans ce répertoire.
3. Exécutez le programme avec la commande suivante :
```bash
python3 test.py
```
ou executer pour la notation polonaise inverse:
```bash
python3 npi.py
```
---
## **Fonctions disponibles et leur utilisation :**
### 1. **`creer_pile_vide()`**
- **Description** : Crée et renvoie une pile vide.
- **Utilisation** :
```python
pile = creer_pile_vide()
```
---
### 2. **`est_pile_vide(pile)`**
- **Description** : Vérifie si une pile est vide.
- **Paramètre** :
- `pile` : La pile à vérifier.
- **Retour** : Renvoie `True` si la pile est vide, sinon `False`.
- **Utilisation** :
```python
if est_pile_vide(pile):
print("La pile est vide.")
```
---
### 3. **`sommet(pile)`**
- **Description** : Retourne l’élément au sommet de la pile sans le retirer.
- **Paramètre** :
- `pile` : La pile à consulter.
- **Retour** : L’élément au sommet de la pile.
- **Utilisation** :
```python
print(sommet(pile))
```
---
### 4. **`empiler(pile, elt)`**
- **Description** : Ajoute un élément au sommet de la pile.
- **Paramètres** :
- `pile` : La pile à modifier.
- `elt` : L’élément à empiler.
- **Retour** : La nouvelle pile avec l’élément ajouté.
- **Utilisation** :
```python
pile = empiler(pile, 5)
```
---
### 5. **`depiler(pile)`**
- **Description** : Retire l’élément au sommet de la pile.
- **Paramètre** :
- `pile` : La pile à modifier.
- **Retour** : La pile sans l’élément au sommet.
- **Utilisation** :
```python
pile = depiler(pile)
```
---
### 6. **`hauteur_pile(pile)`**
- **Description** : Renvoie le nombre d'éléments présents dans la pile sans la modifier.
- **Paramètre** :
- `pile` : La pile à analyser.
- **Retour** : La hauteur de la pile (nombre d'éléments).
- **Utilisation** :
```python
print(hauteur_pile(pile))
```
---
### 7. **`max_pile(pile, i)`**
- **Description** : Trouve le maximum parmi les `i` premiers éléments de la pile.
- **Paramètres** :
- `pile` : La pile à analyser.
- `i` : Le nombre d'éléments à prendre en compte depuis le sommet.
- **Retour** : Le maximum trouvé parmi les `i` éléments.
- **Utilisation** :
```python
print(max_pile(pile, 3))
```
---
### 8. **`retourner(pile, j)`**
- **Description** : Inverse l’ordre des `j` premiers éléments de la pile.
- **Paramètres** :
- `pile` : La pile à modifier.
- `j` : Le nombre d'éléments à inverser.
- **Retour** : La pile modifiée.
- **Utilisation** :
```python
pile = retourner(pile, 2)
```
---
### 9. **`tri_crepes_recursif(pile)`**
- **Description** : Trie une pile en suivant le tri des crêpes.
- **Paramètre** :
- `pile` : La pile à trier.
- **Retour** : La pile triée.
- **Utilisation** :
```python
pile = tri_crepes_recursif(pile)
```
<hr>
Cela conclut la documentation des fonctions. Pour toute question, consultez le fichier **test.py** pour des exemples plus détaillés.
pour toutes questions: elouan.fare@protonmail.ch

44
elouan_fare_v2/tp6_self/npi.py Normal file
View File

@@ -0,0 +1,44 @@
def npi(exp: str) -> float:
"""Calcule une expression arithmétique en NPI (notation polonaise inverse).
Args:
exp (str): L'expression arithmétique à calculer.
Returns:
float: Le résultat de l'expression.
"""
assert exp, "L'expression est vide."
pile = []
for token in exp.split():
if token in "+-*/":
if len(pile) < 2:
print("Erreure : Pas assez d'opérandes.")
return None
b, a = pile.pop(), pile.pop()
match token:
case '+': pile.append(a + b)
case '-': pile.append(a - b)
case '*': pile.append(a * b)
case '/':
if b == 0:
print("Erreur : Division par zéro.")
return None
pile.append(a / b)
elif token.replace('.', '', 1).isdigit(): # isdigit verifie si 'token' est un nombre ou un chiffre
pile.append(float(token))
else:
print(f"erreur : '{token}' n'est pas un opérande valide.")
return None
if len(pile) != 1:
print("erreur : Expression mal formée.")
return None
return pile[0] # On aurait pu mettre pile[-1]
if __name__ == "__main__":
# Test
exp = "3 4 + 5 * 2 /" # correspond a (3+4)(5/2) soit 7 * 2.5 = 17.5
print(npi(exp))

160
elouan_fare_v2/tp6_self/test.py Normal file
View File

@@ -0,0 +1,160 @@
#!/usr/bin/python3
import LSC as lsc
import Pile_List as lifo
from random import shuffle
from typing import List, Tuple, Union, TypeVar, Any
T = TypeVar('T')
PileType = Union[List[T], Tuple[T,...], lsc.Liste_Simplement_Chainee]
#----------------------------------------------------------------
# Aucun effet de bord sur les fonctions ajoutés car je n'y suis pas arrivé
#----------------------------------------------------------------
def afficher(pile):
print("|----\n|")
while not(lifo.est_pile_vide(pile)):
print(f"| {lifo.sommet(pile)}\n|")
pile = lifo.depiler(pile)
print("|----")
return None
def hauteur_pile(pile: PileType) -> int:
"""Retourne la taille/ hauteur de la pile
Args:
pile (list/tuple/lsc.Liste_Simplement_Chainee): la pile a mesurer
Returns:
int: la taille de la pile
"""
n = 0
while not(lifo.est_pile_vide(pile)):
n += 1
pile = lifo.depiler(pile)
return n
def copie(pile: PileType) -> PileType:
"""creer une copie de la pile
Args:
pile (PileType): pile a copier
Returns:
PileType: une copie de la pile
"""
pile_copie = lifo.creer_pile_vide()
while not(lifo.est_pile_vide(pile)):
pile_copie = lifo.empiler(pile_copie, lifo.sommet(pile))
pile = lifo.depiler(pile)
return pile_copie
def max_pile(pile: PileType,start: int)-> int:
"""Retourne l'element le plus grand de la pile
Args:
start: int: la position de départ de la recherche
pile: PileType: la pile a analyser
Returns:
int: l'indice de l'element le plus grand de la pile
"""
assert start >=0, "Position de départ invalide"
assert hauteur_pile(pile) >= start, "Position de départ dépasse la taille de la pile"
assert not(lifo.est_pile_vide(pile)), "La pile est vide"
pile2 = copie(copie(pile)) # <--- pas très propre c'est pour renverser la copie qui a été renversé
# J'itère jusqu' a start:
max_n = lifo.sommet(pile)
for _ in range(start):
sommet = lifo.sommet(pile2)
pile2 = lifo.depiler(pile2)
if sommet > max_n:
max_n = sommet
pile2 = copie(copie(pile))
# je cherche l'index du max dans pile2
for i in range(start):
i+=1
if lifo.sommet(pile2) == max_n:
return i
else:
pile2 = lifo.depiler(pile2)
def retourner(pile: PileType, j: int) -> PileType:
"""retourne la pile avec les j premiers éléments renversés.
Args:
pile (PileType): la pile
j (int): l'index a renverser
Returns:
PileType: la pile renversée
"""
pile1 = copie(copie(pile))
pile2 = lifo.creer_pile_vide()
# je déplace les j premiers éléments de pile1 dans pile2
for _ in range(j):
sommet = lifo.sommet(pile1)
pile1 = lifo.depiler(pile1)
pile2 = lifo.empiler(pile2, sommet)
# renverse Pile 2
pile2 = copie(pile2)
#ajoute pile2 a pile1
while not(lifo.est_pile_vide(pile2)):
sommet = lifo.sommet(pile2)
pile1 = lifo.empiler(pile1,sommet)
pile2 = lifo.depiler(pile2)
pile = lifo.creer_pile_vide()
# remplace Pile par Pile1
while not(lifo.est_pile_vide(pile1)):
sommet = lifo.sommet(pile1)
pile = lifo.empiler(pile, sommet)
pile1 = lifo.depiler(pile1)
return copie(pile)
def tri_crepes(pile: PileType) -> PileType:
"""tri la pile en utilisant 'pancakes sort'
Args:
pile (PileType): la pile a trier
Returns:
PileType: la pile triée
"""
n = hauteur_pile(pile)
while n > 1:
index_max = max_pile(pile, n)
pile = retourner(pile,index_max)
pile = retourner(pile,n)
n-=1
return (pile)
if __name__ == "__main__":
ma_liste = [_ for _ in range(10)]
shuffle(ma_liste)
print("Liste de départ : ", ma_liste)
ma_pile = lifo.creer_pile_vide()
print("\nEMPILEMENT\n")
for element in ma_liste:
ma_pile = lifo.empiler(ma_pile, element)
j = 4
print("\nTaille de la pile : ", hauteur_pile(ma_pile))
print(f"Element le plus grand de la pile à partir de l'index {j}: {max_pile(ma_pile,4)}")
pile = retourner(ma_pile, j)
hauteur_pile(ma_pile)
afficher(pile)
print("\nDEPILEMENT\n")
pile_triee = tri_crepes(ma_pile)
afficher(pile_triee)
while not(lifo.est_pile_vide(ma_pile)):
print(f"Sommet : {lifo.sommet(ma_pile)}")
ma_pile = lifo.depiler(ma_pile)
afficher(ma_pile)

185
ensembles_dynamiques/TP/_collection.py Normal file
View File

@@ -0,0 +1,185 @@
#!/usr/bin/python3
# -*- coding: utf8 -*-
#################################
#
# _COLLECTION.PY
# --------------
#
# Module du type ensemble
#
#################################
# Un ensemble est une collection d'éléments, d'occurence unique.
# Les fonctions sont implémentées dans le paradigme fonctionnel.
def initialiser_ensemble():
"""
Construit un ensemble vide.
Paramètre :
- aucun
Résultat :
- ENSEMBLE vide
Pré-condition :
- aucune
Effet de bord
- aucune
"""
return set()
def est_ensemble_vide(ensemble):
"""
Teste si l'ensemble est vide.
Paramètre :
- ensemble : ENSEMBLE, l'ensemble à tester
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
return len(ensemble) == 0
def copier_ensemble(ensemble):
"""
Construit la copie d'un ensemble.
Paramètre :
- ensemble : ENSEMBLE, la source
Résultat :
- ENSEMBLE : une copie de la source
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
resultat = initialiser_ensemble()
for _ in ensemble:
resultat.add(_)
return resultat
def ajouter(ensemble, element):
"""
Ajoute un element à la copie d'un ensemble
Paramètres :
- ensemble : ENSEMBLE, l'ensemble à abonder
- element : ANY, l'élément à ajouter
Résultat :
- ENSEMBLE, l'ensemble abondé
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
resultat = copier_ensemble(ensemble)
resultat.add(element)
return resultat
def supprimer(ensemble, element):
"""
Construire une copie de l'ensemble privé d'un élément.
Si l'élément à supprimer n'est pas dans l'ensemble initial,
alors une copie intégrale est renvoyée.
Paramètres :
- ensemble ; ENSEMBLE, la collection à amender
- element : ANY, l'élément à supprimer
Résultat :
- ENSEMBLE, la copie amendée de l'ensemble
"""
resultat = initialiser_ensemble()
for _ in ensemble:
if not(_ == element):
resultat = ajouter(resultat, _)
return resultat
def rechercher(ensemble, cle, critere = lambda x, y: x==y):
"""
Construit la sous-collection constituée des éléments d'un ensemble
dont la clé satisfait un critère donné.
Paramètres :
- ensemble : ENSEMBLE, la collection à explorer
- cle : ANY, la clé à rechercher
- critere : FUNCTION ou LAMBDA, test utilisé pour la recherche
Résultat :
- ENSEMBLE, la collection extraite des éléments satisfaisant le test
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
resultat = initialiser_ensemble()
for _ in ensemble:
if critere(_, cle):
resultat = ajouter(resultat, _)
return resultat
def supprimer_critere(ensemble, cle, critere):
"""
Construit la collection des éléments d'un ensemble,
dont la clé satisfait le critère donné.
Paramètres :
- ensemble : ENSEMBLE, la collection source
- cle : ANY, la clé à employer pour la suppression
- critere : FUNCTION ou LAMBDA, critère de sélection
Résultat :
- ENSEMBLE : la copie de l'ensemble amendée
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
resultat = copier_ensemble(ensemble)
elements = rechercher(ensemble, cle, critere)
for _ in elements:
resultat = supprimer(resultat, _)
return resultat
def lister(ensemble, affichage=print):
"""
Afficher le contenu d'un ensemble,
en formattant chaque élément selon la fonction d'affichage fournie.
Paramètres :
- ensemble : ENSEMBLE, la collection à énumérer
- affichage : FUNCTION, la fonction à appliquer à chaque élément.
Résultat :
- None : NONETYPE
Pré-condition :
- aucune
Effet de bord :
- Affichage sur la sortie standard
"""
for element in ensemble:
affichage(element)
return None
if __name__ == "__main__":
pass

167
ensembles_dynamiques/TP/_collection_list.py Normal file
View File

@@ -0,0 +1,167 @@
#!/usr/bin/python3
# -*- coding: utf8 -*-
#################################
#
# _COLLECTION_LIST.PY
# -------------------
#
# Module du type ensemble
# implémenté sur les listes
#################################
# Un ensemble est une collection d'éléments, d'occurence unique.
# Les fonctions sont implémentées dans le paradigme fonctionnel.
def initialiser_ensemble():
"""
Construit un ensemble vide.
Paramètre :
- aucun
Résultat :
- ENSEMBLE vide
Pré-condition :
- aucune
Effet de bord :
- aucune
"""
return list()
def est_ensemble_vide(ensemble):
"""
Teste si l'ensemble est vide.
Paramètre :
- ensemble : LIST, l'ensemble à tester
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
return len(ensemble) == 0
def copier_ensemble(ensemble):
"""
Construit la copie d'un ensemble.
Paramètre :
- ensemble : LIST, la source
Résultat :
- LIST : une copie de la source
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
return ensemble[:]
def ajouter(ensemble, element):
"""
Ajoute un element à la copie d'un ensemble
Paramètres :
- ensemble : LIST, l'ensemble à abonder
- element : ANY, l'élément à ajouter
Résultat :
- LIST, l'ensemble abondé
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
copie = ensemble.copy()
copie.append(element)
return copie
def supprimer(ensemble, element):
"""
Construire une copie de l'ensemble privé d'un élément.
Si l'élément à supprimer n'est pas dans l'ensemble initial,
alors une copie intégrale est renvoyée.
Paramètres :
- ensemble ; LIST, la collection à amender
- element : ANY, l'élément à supprimer
Résultat :
- LIST, la copie amendée de l'ensemble
"""
resultat = ensemble[:]
return resultat.remove(element)
def rechercher(ensemble, cle, critere = lambda x, y: x==y):
"""
Construit la sous-collection constituée des éléments d'un ensemble
dont la clé satisfait un critère donné.
Paramètres :
- ensemble : LIST, la collection à explorer
- cle : ANY, la clé à rechercher
- critere : FUNCTION ou LAMBDA, test utilisé pour la recherche
Résultat :
- LIST, la collection extraite des éléments satisfaisant le test
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
return [element for element in ensemble if critere(element, cle)]
def supprimer_critere(ensemble, cle, critere):
"""
Construit la collection des éléments d'un ensemble,
dont la clé satisfait le critère donné.
Paramètres :
- ensemble : LIST, la collection source
- cle : ANY, la clé à employer pour la suppression
- critere : FUNCTION ou LAMBDA, critère de sélection
Résultat :
- LIST : la copie de l'ensemble amendée
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
return [element for element in ensemble if not critere(element,cle)]
def lister(ensemble, affichage=print):
"""
Afficher le contenu d'un ensemble,
en formattant chaque élément selon la fonction d'affichage fournie.
Paramètres :
- ensemble : LIST, la collection à énumérer
- affichage : FUNCTION, la fonction à appliquer à chaque élément.
Résultat :
- None : NONETYPE
Pré-condition :
- aucune
Effet de bord :
- Affichage sur la sortie standard
"""
for item in ensemble:
affichage(item)
if __name__ == "__main__":
pass

175
ensembles_dynamiques/TP/_sommets.py Normal file
View File

@@ -0,0 +1,175 @@
#!/usr/bin/python3
# -*- coding: utf8 -*-
###################################
#
# _SOMMETS.PY
# -----------
#
# Module de traitement des Sommets
#
###################################
# Un sommet est un tuple (nom, altitude, massif)
# - nom : STR
# - altitude : INT, altitude en m
# - massif : STR
def creer_sommet(nom, altitude, massif):
"""
Construit le tuple sommet.
Paramètres :
- nom : STR, le nom du sommet
- altitude : INT, l'altitude en m
- massif : STR, le massif contenant le sommet
Résultat :
- TUPLE, le sommet
Pré-condition :
- aucune (programmation défensive à envisager)
Effet de bord :
- aucun
"""
return (nom, altitude, massif)
def altitude_en_m(altitude):
"""
Conversion de l'altitude en entier ("2 062 m" -> 2062)
Paramètre :
- altitude : STR, chaîne du type "2 062 m", avec espaces et 'm'
Résultat :
- INT, l'altitude en m
Pré-condition :
- aucune (prog def à envisager)
Effet de bord :
- aucun
"""
tmp = ''
for symbole in altitude:
if not(symbole in ' m'):
tmp += symbole
return int(tmp)
def creer_sommet_csv(ligne, massif):
"""
Construit un sommet à partir d'une ligne du fichier csv.
Paramètres :
- ligne : STR, ligne du fichier csv
- massif : STR, basename du fichier contenant la ligne
Résultat :
- TUPLE, le sommet correspondant
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
nom, alt = ligne.rstrip().split(',')
return creer_sommet(nom, altitude_en_m(alt), massif)
def afficher(sommet):
"""
Affichage formatté du sommet.
Paramètres :
- sommet : TUPLE, le sommet à afficher
Résultat :
- NONETYPE, None
Pré-condition :
- aucune
Effet de bord :
- Affichage sur la sortie standard
"""
nom, altitude, massif = sommet
print(f'{nom:35s}\t[{massif}]\n\taltitude : {altitude} m')
return None
def nom(sommet):
"""
Consulte le nom d'un sommet
Paramètre :
- sommet : TUPLE
Résultat :
- STR, le nom du sommet
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
return sommet[0]
def altitude(sommet):
"""
Consulte l'altitude d'un sommet
Paramètre :
- sommet : TUPLE
Résultat :
- INT : l'altitude du sommet
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
return sommet[1]
def massif(sommet):
"""
Consulte le massif d'un sommet
Paramètre :
- sommet : TUPLE
Résultat :
- STR, le massif du sommet
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
return sommet[2]
def coincide_nom(sommet, motif):
"""
Compare le nom du sommet au motif
Paramètres :
- sommet : TUPLE, le sommet à tester
- motif : STR, le motif à identifier
Résultat :
- BOOL : Vrai ssi le nom du sommet correspond au motif
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
nom_sommet = nom(sommet)
return (len(motif) <= len(nom_sommet)) and (nom_sommet[:len(motif)] == motif)
if __name__ == '__main__':
pass

180
ensembles_dynamiques/TP/_sommets_dict.py Normal file
View File

@@ -0,0 +1,180 @@
#!/usr/bin/python3
# -*- coding: utf8 -*-
############################
#
# _SOMMETS_DICT.PY
# ----------------
#
# Module des sommets
# implémentés par des dict
############################
# Un sommet est un dictionnaire
# dont les clés sont 'nom', 'altitude' et 'massif'
# - nom : STR
# - altitude : INT, altitude en m
# - massif : STR
def creer_sommet(nom, altitude, massif):
"""
Construit le dico sommet.
Paramètres :
- nom : STR, le nom du sommet
- altitude : INT, l'altitude en m
- massif : STR, le massif contenant le sommet
Résultat :
- DICT, le sommet
Pré-condition :
- aucune (programmation défensive à envisager)
Effet de bord :
- aucun
"""
sommet = {
"Nom": nom,
"Altitude": altitude,
"Massif": massif
}
return sommet
def altitude_en_m(altitude):
"""
Conversion de l'altitude en entier ("2 062 m" -> 2062)
Paramètre :
- altitude : STR, chaîne du type "2 062 m", avec espaces et 'm'
Résultat :
- INT, l'altitude en m
Pré-condition :
- aucune (prog def à envisager)
Effet de bord :
- aucun
"""
tmp = ''
for symbole in altitude:
if not(symbole in ' m'):
tmp += symbole
return int(tmp)
def creer_sommet_csv(ligne, massif):
"""
Construit un sommet à partir d'une ligne du fichier csv.
Paramètres :
- ligne : STR, ligne du fichier csv
- massif : STR, basename du fichier contenant la ligne
Résultat :
- DICT, le sommet correspondant
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
nom, alt = ligne.rstrip().split(',')
return creer_sommet(nom, altitude_en_m(alt), massif)
def afficher(sommet):
"""
Affichage formatté du sommet.
Paramètres :
- sommet : TUPLE, le sommet à afficher
Résultat :
- NONETYPE, None
Pré-condition :
- aucune
Effet de bord :
- Affichage sur la sortie standard
"""
print(f"{sommet['Nom']:35s}\t[{sommet['Massif']}]\n\taltitude : {sommet['Altitude']} m")
def nom(sommet):
"""
Consulte le nom d'un sommet
Paramètre :
- sommet : DICT
Résultat :
- STR, le nom du sommet
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
return sommet["Nom"]
def altitude(sommet):
"""
Consulte l'altitude d'un sommet
Paramètre :
- sommet : DICT
Résultat :
- INT : l'altitude du sommet
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
return sommet['Altitude']
def massif(sommet):
"""
Consulte le massif d'un sommet
Paramètre :
- sommet : DICT
Résultat :
- STR, le massif du sommet
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
return sommet["Massif"]
def coincide_nom(sommet, motif):
"""
Compare le nom du sommet au motif
Paramètres :
- sommet : TUPLE, le sommet à tester
- motif : STR, le motif à identifier
Résultat :
- BOOL : Vrai ssi le nom du sommet correspond au motif
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
nom_sommet = nom(sommet)
return (len(motif) <= len(nom_sommet)) and (nom_sommet[:len(motif)] == motif)
if __name__ == '__main__':
pass

29
ensembles_dynamiques/TP/data/Chartreuse.csv Normal file
View File

@@ -0,0 +1,29 @@
Grande Sure (La), 1 920 m
Rocher de Lorzier (Le), 1 838 m
Rochers de Chalves (Les), 1 845 m
Rocher de l'Église (Le), 1 300 m
Pointe de la Gorgeat (La), 1 486 m
Mont Joigny (Le), 1 556 m
Mont Outheran (Le), 1 673 m
Cochette (La), 1 618 m
Roc de Gleisin (Le), 1 434 m
Roche Veyrand (La), 1 429 m
Dent de l'Ours (La), 1 820 m
Petit Som (Le), 1 772 m
Grand Som (Le), 2 026 m
Charmant Som (Le), 1 867 m
Pinéa (La), 1 771 m
Néron (Le), 1 299 m
Mont Granier (Le), 1 933 m
Sommet du Pinet (Le) ou le Truc, 1 867 m
Grand Manti (Le), 1 818 m
Scia (La), 1 791 m
Lances de Malissard (Les), 2 045 m
Dôme de Bellefont (Le), 1 975 m
Dent de Crolles (La), 2 062 m
Piton de Bellefont (Le), 1 958 m
Chamechaude, 2 082 m
Grands Crêts (Les), 1 489 m
Mont Saint-Eynard (Le), 1 379 m
Écoutoux (L'), 1 406 m
Rachais (Le), 1 050 m
1 Grande Sure (La) 1 920 m
2 Rocher de Lorzier (Le) 1 838 m
3 Rochers de Chalves (Les) 1 845 m
4 Rocher de l'Église (Le) 1 300 m
5 Pointe de la Gorgeat (La) 1 486 m
6 Mont Joigny (Le) 1 556 m
7 Mont Outheran (Le) 1 673 m
8 Cochette (La) 1 618 m
9 Roc de Gleisin (Le) 1 434 m
10 Roche Veyrand (La) 1 429 m
11 Dent de l'Ours (La) 1 820 m
12 Petit Som (Le) 1 772 m
13 Grand Som (Le) 2 026 m
14 Charmant Som (Le) 1 867 m
15 Pinéa (La) 1 771 m
16 Néron (Le) 1 299 m
17 Mont Granier (Le) 1 933 m
18 Sommet du Pinet (Le) ou le Truc 1 867 m
19 Grand Manti (Le) 1 818 m
20 Scia (La) 1 791 m
21 Lances de Malissard (Les) 2 045 m
22 Dôme de Bellefont (Le) 1 975 m
23 Dent de Crolles (La) 2 062 m
24 Piton de Bellefont (Le) 1 958 m
25 Chamechaude 2 082 m
26 Grands Crêts (Les) 1 489 m
27 Mont Saint-Eynard (Le) 1 379 m
28 Écoutoux (L') 1 406 m
29 Rachais (Le) 1 050 m

67
ensembles_dynamiques/TP/main.py Normal file
View File

@@ -0,0 +1,67 @@
#!/usr/bin/python3
# -*- coding: utf8 -*-
#######################################
#
# MAIN.PY
# -------
#
# Interface principale
#
#######################################
import _collection_list as col
import _sommets as som
# Le module _collection définit nos ENSEMBLES
# Le module _sommets définit nos SOMMETS
def file_2_set(fichier='./data/Chartreuse.csv'):
"""
Lecture du fichier csv contenant les caractéristiques des sommets.
Paramètres :
- fichier : STR, le nom complet du fichier csv à parcourir
Résultat :
- resultat : ENSEMBLE, la collection des sommets
Pré-conditions :
- aucune
Effets de bord :
- aucun
"""
massif = fichier[7:-4]
resultat = col.initialiser_ensemble()
with open(fichier) as src:
ligne = src.readline()
while ligne:
resultat = col.ajouter(resultat, som.creer_sommet_csv(ligne, massif))
ligne = src.readline()
return resultat
def rechercher(ensemble, motif):
"""
Recherche les sommets de la collection dont le nom
correspond à un motif donné.
Paramètres :
- ensemble : ENSEMBLE, la collection des somets
- motif : STR, la chaîne de caractères à identifier
Résultat :
- ENSEMBLE, la sous-collection des sommets satisfaisant au critère
Pré-condition :
- aucune
Effet de bord :
- aucun
"""
return col.rechercher(ensemble, motif, som.coincide_nom)
if __name__ == '__main__':
col.lister(col.supprimer_critere(file_2_set(), 'Grand', som.coincide_nom), \
som.afficher)

260
file/LSC.py Normal file
View File

@@ -0,0 +1,260 @@
"""
Librairie des Listes Simplement Chaînées.
Elle met à distribution cette structure de données et son interface.
@author: L. JOANNIC
"""
# ############################################################################
class Liste_Simplement_Chainee(object):
"""
Classe des Listes Simplement Chainees.
Attributs
- _tete : None si vide, Maillon sinon.
Méthodes
- est_vide
- ajouter_en_tete
- tete
- queue
"""
def __init__(self):
"""
Construire une instance de Liste Simplement Chainee.
Returns
-------
None.
"""
self._tete = None
return None
def est_vide(self):
"""
Tester si l'instance est vide.
Returns
-------
bool
Vrai ssi la liste est vide.
"""
return (self._tete is None)
def ajouter_en_tete(self, element):
"""
Ajouter l'élément en tête de liste.
Parameters
----------
element : type de donnee
Donnnée à ajouter à la liste.
Returns
-------
resultat : Liste_Simplement_Chainee
La liste à abonder.
"""
resultat = Liste_Simplement_Chainee()
resultat._tete = Maillon(element, self)
return resultat
def tete(self):
"""
Renvoyer la donnée stockée en tête de liste.
Returns
-------
type de donnee quelconque
donnee en tete.
"""
assert not(self.est_vide()), "Liste Vide"
return self._tete.donnee
def queue(self):
"""
Renvoyer la sous-liste suivant le maillon de tete.
Returns
-------
Liste_Simplement_Chainee
Queue de la liste.
"""
assert not(self.est_vide()), "Liste Vide"
return self._tete.suite
# ############################################################################
def creer_liste_vide():
"""
Créer une liste simplement chainee vide.
Returns
-------
Liste_Simplement_Chainee
Liste vide.
Effets de bord
--------------
Aucun
"""
return Liste_Simplement_Chainee()
def est_vide(liste):
"""
Tester si la liste simplement chainee est vide.
Parameters
----------
liste : Liste Simplement Chainee
Liste à tester.
Returns
-------
bool
Vrai ssi la liste est vide.
Effets de bord
--------------
Aucun
"""
return liste.est_vide()
def ajouter_en_tete(liste, element):
"""
Inserer un element en tete de liste simplemeent chainee.
Parameters
----------
liste : LSC
Liste à abonder.
element : type de donnee
Donnee à aouter.
Returns
-------
LSC, copie de liste à laquelle element a été ajouté en tete.
Effets de bord
--------------
Aucun
"""
return liste.ajouter_en_tete(element)
def tete(liste):
"""
Consulter la tete de liste.
Parameters
----------
liste : LSC
Liste à consulter.
Returns
-------
type de donnée
valeur de la tete de liste.
Effets de bord
--------------
Aucun
"""
return liste.tete()
def queue(liste):
"""
Renvoyer la liste sans sa tete.
Parameters
----------
liste : LSC
Liste à étêter.
Returns
-------
LSC
Liste sans son maillon de tête.
Effets de bord
--------------
Aucun
"""
return liste.queue()
def afficher_liste(liste, taille=-1):
"""
Afficher la liste en format de présentation.
Parameters
----------
liste : LSC
Liste à énumérer.
Returns
-------
None.
Effets de bord
--------------
Affichage à l'écran.
"""
reste = liste
compteur = 0
print('+-----\n|')
while not(est_vide(reste)) and (taille == -1 or compteur < taille):
print('+- {}\n|'.format(str(tete(reste))))
reste = queue(reste)
compteur += 1
print('+-----')
return None
# ############################################################################
class Maillon(object):
"""
Classe des Maillons d'une Liste Simplement Chainee.
Attributs
- donnee : donnee stockee dans le maillon
- suite : liste simplemement chainee suivant le maillon
"""
def __init__(self, donnee=None, suite=Liste_Simplement_Chainee()):
"""
Construire une instance de la classe des Maillons.
Parameters
----------
donnee : type de donnee, optional
Donnee initiale dans le Maillon. The default is None.
suite : LSC, optional
Sous-liste suivant le Maillon courant.
The default is Liste_Simplement_Chainee().
Returns
-------
None.
"""
self.donnee = donnee
self.suite = suite
return None
# ############################################################################

58
file/file.py Normal file
View File

@@ -0,0 +1,58 @@
def creer_file_vide():
"""
Crée une nouvelle file vide.
Returns:
list: Une liste vide représentant la file.
"""
return []
def est_vide(file):
"""
Vérifie si une file est vide.
Args:
file (list): La file à vérifier.
Returns:
bool: `True` si la file est vide, `False` sinon.
"""
return len(file) == 0
def enfiler(file, elt):
"""
Ajoute un élément à la fin de la file.
Args:
file (list): La file à laquelle ajouter l'élément.
elt: L'élément à ajouter.
Returns:
None
"""
return file.append(elt)
def defiler(file: list):
"""
Retire et renvoie le premier élément de la file.
Args:
file (list): La file dont l'élément de tête doit être retiré.
Returns:
list: La file sans le premier élément.
"""
return file[1:]
def peak(file: list):
"""
Renvoie l'élément en tête de la file sans le retirer.
Args:
file (list): La file dont on veut consulter le premier élément.
Returns:
L'élément en tête de la file.
"""
return file[0]

4
file/file_LSC.py Normal file
View File

@@ -0,0 +1,4 @@
import LSC as lifo
def creer_liste_vide():
return lifo.cr

23
file/file_tuple.py Normal file
View File

@@ -0,0 +1,23 @@
def creer_file_vide():
return ()
def est_vide(file: tuple)-> bool:
return () == file
def tete(file: tuple):
assert not(est_vide(file)), "file vide"
element, reste = file
return element
def queue(file):
element,reste = liste
return reste
def inserer_tete(file,elt):
return (elt,file)
def inserer_queue(file,elt):
if est_vide(file):
return inserer_tete(file,elt)
return inserer_tete(inserer_queu(queue(file),elt)tete(file))

11
magic_square/TDliste2liste/exercice1.py Normal file
View File

@@ -0,0 +1,11 @@
def appartient(elt,tableau):
for i in tableau:
if i == elt:
return True
else:
continue
return False
if __name__ == "__main__":
print(appartient(5,[1,2,3,4,5,6,7,8,9,10]))
print(appartient(5,[1,2,3,4,6,7,8,9,10]))

21
magic_square/TDliste2liste/exercice2.py Normal file
View File

@@ -0,0 +1,21 @@
def max_local(tableau):
maximum = tableau[0]
for i in tableau:
if i > maximum:
maximum = i
else:
continue
return maximum
def indice_max(tableau):
maximum = max_local(tableau)
for i in range(len(tableau)):
if tableau[i] == maximum:
return i
else:
continue
if __name__ == "__main__":
l1 = [0,2,3,4,5,6,7,8,9,90,91,59,1]
print(max_local(l1))
print(indice_max(l1))

8
magic_square/TDliste2liste/exercice3.py Normal file
View File

@@ -0,0 +1,8 @@
def cree_tableau_n_m(n,m):
return [[0 for _ in range(m)] for _ in range(n)]
def cree_tableau_carre_n(n):
return [[0 for _ in range(n)] for _ in range(n)]
if __name__ == "__main__":
print(cree_tableau_n_m(3,5))
print(cree_tableau_carre_n(5))

12
magic_square/TDliste2liste/exercice4.py Normal file
View File

@@ -0,0 +1,12 @@
def cree_carre_entier_1_n_carre(n):
carre = []
compteur = 1
for i in range(n):
ligne = []
for j in range(n):
ligne.append(compteur)
compteur += 1
carre.append(ligne)
return carre
print(cree_carre_entier_1_n_carre(8))

9
magic_square/TDliste2liste/exercice5.py Normal file
View File

@@ -0,0 +1,9 @@
def transpose(carre):
n = len(carre) # Nombre de lignes (ou colonnes, car c'est une matrice carrée)
return [[carre[j][i] for j in range(n)] for i in range(n)]
def transpose_en_place(carre):
n = len(carre) # Nombre de lignes (ou colonnes)
for i in range(n):
for j in range(i + 1, n): # Commencer à j = i + 1 pour éviter de réécrire les éléments déjà transposés
carre[i][j], carre[j][i] = carre[j][i], carre[i][j] # Échange des éléments

9
magic_square/TDliste2liste/exercice6.py Normal file
View File

@@ -0,0 +1,9 @@
def diag_1(carre):
return [carre[i][i] for i in range(len(carre))]
def diag_2(carre):
n = len(carre)
return [carre[i][n - 1 - i] for i in range(n)]
def colonne(j, carre):
return [carre[i][j] for i in range(len(carre))]

48
magic_square/magic_square.py Normal file
View File

@@ -0,0 +1,48 @@
from TDliste2liste.exercice6 import diag_1, diag_2, colonne
def check_diagonale(liste):
return diag1(liste), diag2(liste)
def check_colonne(liste):
somme = []
for i in range(len(liste)):
somme.append(colonne(i,liste))
return somme
def check_line(liste):
somme = []
for i in range(len(liste)):
somme.append(sum(liste[i]))
return somme
def check_all(carre):
diag1_values, diag2_values = check_diagonale(carre)
colonne_values = check_colonne(carre)
line_values = check_line(carre)
# On récupère la première valeur de diag1 pour la comparaison
reference_value = diag1_values[0] if diag1_values else None
# Vérification si toutes les valeurs sont les mêmes
all_same = True
# Vérification des diagonales
if not all(value == reference_value for value in diag1_values):
all_same = False
if not all(value == reference_value for value in diag2_values):
all_same = False
# Vérification des colonnes
for col in colonne_values:
if not all(value == reference_value for value in col):
all_same = False
# Vérification des lignes
for line in line_values:
if line != reference_value:
all_same = False
return all_same
carre1=[[4, 9, 2],\
[3, 5, 7],\
[8, 1, 6]]
print(check_all(carre1))

27
magic_square/td_carre_magique.py Normal file
View File

@@ -0,0 +1,27 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
if __name__ == '__main__':
carre1=[[4, 9, 2],\
[3, 5, 7],\
[8, 1, 6]]
carre2=[[16, 9, 14],\
[11, 13, 15],\
[12, 17, 10]]
carre3=[[1, 2, 3],\
[4, 5, 6],\
[7, 8, 9]]
carre4=[[16, 3, 2, 13],\
[5, 10, 11, 8],\
[9, 6, 7, 12],\
[4, 15, 14, 1]]
carre5=[[1, 14, 14, 4],\
[11, 7, 6, 9],\
[8, 10, 10, 5],\
[13, 2, 3, 15]]

72
oracle/finder.py Normal file
View File

@@ -0,0 +1,72 @@
from tri import triii
def dichotomie_maximum(arr: list):
"""cherche le maximum d'une liste triée de façon dichotomique
Args:
arr (list): la liste contenant le maximum
Returns:
int: le maximum
"""
arr = triii(arr)
if not arr:
return None
left, right = 0, len(arr) - 1
while left < right:
mid = (left + right) // 2
if arr[mid] > arr[mid + 1]:
right = mid
else:
left = mid + 1
return arr[left]
def dichotomie_minimum(arr: list)->int:
"""cherche le minimum d'une liste de façon dichotometrique trier !
Args:
arr (list): la liste
Returns:
int: le minimum
"""
arr = triii(arr)
if not arr:
return None
left, right = 0, len(arr) - 1
while left < right:
mid = (left + right) // 2
if arr[mid] < arr[mid + 1]:
right = mid
else:
left = mid + 1
return arr[left]
def trouver_indice_dichotomie(arr, x):
"""cherche l'élement x dans une liste arr
Args:
arr (list): la liste
x (int): l'élement
Returns:
int: l'indice de l'element dans la liste ou -1 s'il est absent
"""
arr = sorted(arr)
left, right = 0, len(arr) - 1
while left <= right:
mid = (left + right) // 2
if arr[mid] == x:
return mid
elif arr[mid] < x:
left = mid + 1
else:
right = mid - 1
return None
liste = [i for i in range(20000)]
print(trouver_indice_dichotomie(liste,5624))

52
oracle/oracle.py Normal file
View File

@@ -0,0 +1,52 @@
from tri import triage, triii
total_tests = 0
successes = 0
failures = 0
def run_test(func, input_data, expected_output, test_name):
global total_tests, successes, failures
total_tests += 1
try:
result = func(input_data)
if result == expected_output:
print(f"[SUCCÈS] {test_name}")
successes += 1
else:
print(f"[ÉCHEC] {test_name}: attendu {expected_output}, mais obtenu {result}")
failures += 1
except Exception as e:
print(f"[ERREUR] {test_name}: exception {e}")
failures += 1
def test_triage():
run_test(triage, [], [], "triage avec liste vide")
run_test(triage, [5], [5], "triage avec un seul élément")
run_test(triage, [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], "triage avec liste déjà triée")
run_test(triage, [3, 1, 4, 2, 5], [1, 2, 3, 4, 5], "triage avec liste non triée")
run_test(triage, [9, 3, 7, 1, 5], [1, 3, 5, 7, 9], "triage avec liste non triée aléatoire")
def test_triii():
run_test(triii, [], [], "triii avec liste vide")
run_test(triii, [7], [7], "triii avec un seul élément")
run_test(triii, [1, 2, 3], [1, 2, 3], "triii avec liste déjà triée")
run_test(triii, [3, 2, 1, 4], [1, 2, 3, 4], "triii avec liste non triée")
run_test(triii, [6, 3, 9, 1, 2], [1, 2, 3, 6, 9], "triii avec liste non triée aléatoire")
if __name__ == '__main__':
print("Tests pour la fonction triage:")
test_triage()
print("\nTests pour la fonction triii:")
test_triii()
print("\n--- Résumé des tests ---")
print(f"Total de tests exécutés : {total_tests}")
print(f"Tests réussis : {successes}")
print(f"Tests échoués : {failures}")
if failures == 0:
print("Tous les tests ont réussi !")
else:
print(f"{failures} tests ont échoué.")

18
oracle/tri.py Normal file
View File

@@ -0,0 +1,18 @@
def triage(liste:list) -> list:
if len(liste) < 2:
return list
for i in range(len(liste)-1):
if liste[i] > liste[i+1]:
liste[i], liste[i+1] = liste[i+1], liste[i]
return triage(liste)
return liste
def triii(liste: list) -> list:
if liste == [] :
return []
mini = 0
for i in range(1, len(liste)):
if liste[i] < liste[mini]:
mini = i
liste[0], liste[mini] = liste[mini], liste[0]
return [liste[0]] + triii(liste[1:])

45
partition_fusion/code.py Normal file
View File

@@ -0,0 +1,45 @@
def partition(tab, debut, fin):
pivot = tab[fin]
i = debut - 1
for j in range(debut, fin):
if tab[j] <= pivot:
i += 1
tab[i], tab[j] = tab[j], tab[i]
tab[i + 1], tab[fin] = tab[fin], tab[i + 1]
return i + 1
def fusion(tab, debut, milieu, fin):
gauche = tab[debut:milieu + 1]
droite = tab[milieu + 1:fin + 1]
i, j, k = 0, 0, debut
while i < len(gauche) and j < len(droite):
if gauche[i] <= droite[j]:
tab[k] = gauche[i]
i += 1
else:
tab[k] = droite[j]
j += 1
k += 1
while i < len(gauche):
tab[k] = gauche[i]
i += 1
k += 1
while j < len(droite):
tab[k] = droite[j]
j += 1
k += 1
def tri_fusion_partition(tab, debut, fin):
if debut < fin:
pivot_index = partition(tab, debut, fin)
tri_fusion_partition(tab, debut, pivot_index - 1)
tri_fusion_partition(tab, pivot_index + 1, fin)
fusion(tab, debut, pivot_index, fin)
tableau = [34, 7, 23, 32, 5, 62, 32, 8, 9]
tri_fusion_partition(tableau, 0, len(tableau) - 1)
print("Tableau trié :", tableau)

28
recurivite/TD1.py Normal file
View File

@@ -0,0 +1,28 @@
def factorielle(number: int):
if number == 0:
return 1
else:
return number * factorielle(number-1)
def modulo(a, b):
if b-a < 0:
return b
elif b == 0:
return b
else:
return modulo(a,b-a)
def somme(n):
if n == 0:
return n
else:
return(n+somme(n-1))
def init_quotient(a,b):
i = 0
return (quotient(a,b,i))
def quotient(a,b,i):
if b == 0 or b-a < 0:
return i
else:
return(quotient(a,b-a,i+1))
print(init_quotient(6,18))

12
recurivite/exercice_MJoannic/palindrom.py Normal file
View File

@@ -0,0 +1,12 @@
def is_palindrom(word)->bool:
word = list(word)
if len(word) < 2:
return True
if word[0] == word[-1]:
word.pop(0)
word.pop(-1)
return is_palindrom(word)
else:
return False
print(is_palindrom("do geese see god".replace(' ', '')))

13
referencement/search.py Normal file
View File

@@ -0,0 +1,13 @@
import requests
from bs4 import BeautifulSoup
def search(url):
r = requests.get(url)
return r.text
def search_urls_in_text(content):
soup = BeautifulSoup(content, 'html5lib')
hrefs = [a['href'] for a in soup.find_all('a', href=True)]
return hrefs
print(search_urls_in_text(search("https://google.com")))

BIN
sqlite/test Normal file
View File

Binary file not shown.

BIN
sqlite/test-journal Normal file
View File

Binary file not shown.

260
tp6/LSC.py Normal file
View File

@@ -0,0 +1,260 @@
"""
Librairie des Listes Simplement Chaînées.
Elle met à distribution cette structure de données et son interface.
@author: L. JOANNIC
"""
# ############################################################################
class Liste_Simplement_Chainee(object):
"""
Classe des Listes Simplement Chainees.
Attributs
- _tete : None si vide, Maillon sinon.
Méthodes
- est_vide
- ajouter_en_tete
- tete
- queue
"""
def __init__(self):
"""
Construire une instance de Liste Simplement Chainee.
Returns
-------
None.
"""
self._tete = None
return None
def est_vide(self):
"""
Tester si l'instance est vide.
Returns
-------
bool
Vrai ssi la liste est vide.
"""
return (self._tete is None)
def ajouter_en_tete(self, element):
"""
Ajouter l'élément en tête de liste.
Parameters
----------
element : type de donnee
Donnnée à ajouter à la liste.
Returns
-------
resultat : Liste_Simplement_Chainee
La liste à abonder.
"""
resultat = Liste_Simplement_Chainee()
resultat._tete = Maillon(element, self)
return resultat
def tete(self):
"""
Renvoyer la donnée stockée en tête de liste.
Returns
-------
type de donnee quelconque
donnee en tete.
"""
assert not(self.est_vide()), "Liste Vide"
return self._tete.donnee
def queue(self):
"""
Renvoyer la sous-liste suivant le maillon de tete.
Returns
-------
Liste_Simplement_Chainee
Queue de la liste.
"""
assert not(self.est_vide()), "Liste Vide"
return self._tete.suite
# ############################################################################
def creer_liste_vide():
"""
Créer une liste simplement chainee vide.
Returns
-------
Liste_Simplement_Chainee
Liste vide.
Effets de bord
--------------
Aucun
"""
return Liste_Simplement_Chainee()
def est_vide(liste):
"""
Tester si la liste simplement chainee est vide.
Parameters
----------
liste : Liste Simplement Chainee
Liste à tester.
Returns
-------
bool
Vrai ssi la liste est vide.
Effets de bord
--------------
Aucun
"""
return liste.est_vide()
def ajouter_en_tete(liste, element):
"""
Inserer un element en tete de liste simplemeent chainee.
Parameters
----------
liste : LSC
Liste à abonder.
element : type de donnee
Donnee à aouter.
Returns
-------
LSC, copie de liste à laquelle element a été ajouté en tete.
Effets de bord
--------------
Aucun
"""
return liste.ajouter_en_tete(element)
def tete(liste):
"""
Consulter la tete de liste.
Parameters
----------
liste : LSC
Liste à consulter.
Returns
-------
type de donnée
valeur de la tete de liste.
Effets de bord
--------------
Aucun
"""
return liste.tete()
def queue(liste):
"""
Renvoyer la liste sans sa tete.
Parameters
----------
liste : LSC
Liste à étêter.
Returns
-------
LSC
Liste sans son maillon de tête.
Effets de bord
--------------
Aucun
"""
return liste.queue()
def afficher_liste(liste, taille=-1):
"""
Afficher la liste en format de présentation.
Parameters
----------
liste : LSC
Liste à énumérer.
Returns
-------
None.
Effets de bord
--------------
Affichage à l'écran.
"""
reste = liste
compteur = 0
print('+-----\n|')
while not(est_vide(reste)) and (taille == -1 or compteur < taille):
print('+- {}\n|'.format(str(tete(reste))))
reste = queue(reste)
compteur += 1
print('+-----')
return None
# ############################################################################
class Maillon(object):
"""
Classe des Maillons d'une Liste Simplement Chainee.
Attributs
- donnee : donnee stockee dans le maillon
- suite : liste simplemement chainee suivant le maillon
"""
def __init__(self, donnee=None, suite=Liste_Simplement_Chainee()):
"""
Construire une instance de la classe des Maillons.
Parameters
----------
donnee : type de donnee, optional
Donnee initiale dans le Maillon. The default is None.
suite : LSC, optional
Sous-liste suivant le Maillon courant.
The default is Liste_Simplement_Chainee().
Returns
-------
None.
"""
self.donnee = donnee
self.suite = suite
return None
# ############################################################################

63
tp6/Pile_LSC.py Normal file
View File

@@ -0,0 +1,63 @@
import LSC as lsc
from typing import Any
def creer_pile_vide() -> lsc.Liste_Simplement_Chainee:
"""Crée une pile vide sous forme de liste simplement chaînée.
Returns:
lsc.Liste_Simplement_Chainee: Une pile vide représentée par une liste simplement chaînée.
"""
return lsc.creer_liste_vide()
def est_pile_vide(pile: lsc.Liste_Simplement_Chainee) -> bool:
"""Vérifie si la pile est vide.
Args:
pile (lsc.Liste_Simplement_Chainee): La pile à vérifier.
Returns:
bool: True si la pile est vide, False sinon.
"""
return lsc.est_vide(pile)
def sommet(pile: lsc.Liste_Simplement_Chainee) -> Any:
"""Renvoie l'élément au sommet de la pile.
Args:
pile (lsc.Liste_Simplement_Chainee): La pile dont on veut connaître le sommet.
Returns:
Any: L'élément au sommet de la pile.
Raises:
AssertionError: Si la pile est vide.
"""
assert not est_pile_vide(pile), "Pile vide."
return lsc.tete(pile)
def empiler(pile: lsc.Liste_Simplement_Chainee, element: Any) -> lsc.Liste_Simplement_Chainee:
"""Ajoute un élément au sommet de la pile.
Args:
pile (lsc.Liste_Simplement_Chainee): La pile actuelle.
element (Any): L'élément à ajouter au sommet de la pile.
Returns:
lsc.Liste_Simplement_Chainee: La nouvelle pile avec l'élément ajouté.
"""
return lsc.ajouter_en_tete(pile, element)
def depiler(pile: lsc.Liste_Simplement_Chainee) -> lsc.Liste_Simplement_Chainee:
"""Retire l'élément au sommet de la pile.
Args:
pile (lsc.Liste_Simplement_Chainee): La pile dont on veut retirer le sommet.
Returns:
lsc.Liste_Simplement_Chainee: La nouvelle pile sans l'élément au sommet.
Raises:
AssertionError: Si la pile est vide.
"""
assert not est_pile_vide(pile), "Pile vide!"
return lsc.queue(pile)

62
tp6/Pile_List.py Normal file
View File

@@ -0,0 +1,62 @@
from typing import Any
def creer_pile_vide() -> list:
"""Crée une pile vide sous forme de liste.
Returns:
list: Une pile vide représentée par une liste.
"""
return []
def est_pile_vide(pile: list) -> bool:
"""Vérifie si la pile est vide.
Args:
pile (list): La pile à vérifier.
Returns:
bool: True si la pile est vide, False sinon.
"""
return len(pile) == 0
def sommet(pile: list) -> Any:
"""Renvoie l'élément au sommet de la pile.
Args:
pile (list): La pile dont on veut connaître le sommet.
Returns:
Any: L'élément au sommet de la pile.
Raises:
AssertionError: Si la pile est vide.
"""
assert not est_pile_vide(pile), "Pile vide!"
return pile[-1]
def empiler(pile: list, element: Any) -> list:
"""Ajoute un élément au sommet de la pile.
Args:
pile (list): La pile actuelle.
element (Any): L'élément à ajouter au sommet de la pile.
Returns:
list: La nouvelle pile avec l'élément ajouté.
"""
return pile + [element]
def depiler(pile: list) -> list:
"""Retire l'élément au sommet de la pile.
Args:
pile (list): La pile dont on veut retirer le sommet.
Returns:
list: La nouvelle pile sans l'élément au sommet.
Raises:
AssertionError: Si la pile est vide.
"""
assert not est_pile_vide(pile), "Pile vide!"
return pile[:-1]

60
tp6/Pile_Tuple.py Normal file
View File

@@ -0,0 +1,60 @@
def creer_pile_vide():
"""Crée une pile vide sous forme de tuple.
Returns:
tuple: Une pile vide représentée par un tuple vide.
"""
return ()
def est_pile_vide(pile):
"""Vérifie si la pile est vide.
Args:
pile (tuple): La pile à vérifier.
Returns:
bool: True si la pile est vide, False sinon.
"""
return pile == ()
def sommet(pile):
"""Renvoie l'élément au sommet de la pile.
Args:
pile (tuple): La pile dont on veut connaître le sommet.
Returns:
_type_: L'élément au sommet de la pile.
Raises:
AssertionError: Si la pile est vide.
"""
assert not est_pile_vide(pile), "Pile vide!"
return pile[-1]
def empiler(pile, elt):
"""Ajoute un élément au sommet de la pile.
Args:
pile (tuple): La pile actuelle.
elt (_type_): L'élément à ajouter au sommet de la pile.
Returns:
tuple: La nouvelle pile avec l'élément ajouté.
"""
return pile + (elt,)
def depiler(pile):
"""Retire l'élément au sommet de la pile.
Args:
pile (tuple): La pile dont on veut retirer le sommet.
Returns:
tuple: La nouvelle pile sans l'élément au sommet.
Raises:
AssertionError: Si la pile est vide.
"""
assert not est_pile_vide(pile), "Pile vide!"
return pile[:-1]

69
tp6/README.md Normal file
View File

@@ -0,0 +1,69 @@
# Devoir Maison : Gestion de Piles et Notation Polonaise Inverse
Ce devoir présente des fonctions pour manipuler des piles et évaluer des expressions en notation polonaise inverse (NPI).
## Prérequis
Pour exécuter ce devoir, vous aurez besoin de :
- [Python 3.x](https://www.python.org/downloads/) installé sur votre machine.
### Installation de Python
1. **Téléchargez Python** : Allez sur le [site officiel de Python](https://www.python.org/downloads/) et téléchargez la dernière version stable pour votre système d'exploitation.
2. **Installez Python** : Suivez les instructions d'installation. Assurez-vous de cocher l'option "Add Python to PATH" lors de l'installation sur Windows.
3. **Vérifiez l'installation** : Ouvrez votre terminal ou votre invite de commande et exécutez la commande suivante :
```bash
python --version
```
Cela devrait afficher la version de Python installée.
## Utilisation des Modules
### Modules Fournis
Le devoir contient les modules suivants :
- `LSC` : Implémentation d'une liste simplement chaînée.
- `Pile_LSC` : Implémentation d'une pile utilisant une liste simplement chaînée.
- `Tuple` : Implémentation d'une pile utilisant un tuple.
- `Liste` : Implémentation d'une pile utilisant une liste.
#### Primitives du Module `LSC`
- `creer_liste_vide()`: Crée une liste vide.
- `est_vide(liste)`: Vérifie si la liste est vide.
- `ajouter_en_tete(liste, element)`: Ajoute un élément au début de la liste.
- `queue(liste)`: Retire le premier élément de la liste.
- `tete(liste)`: Renvoie le premier élément de la liste.
#### Primitives du Module `Pile_LSC`
- `creer_pile_vide()`: Crée une pile vide sous forme de liste simplement chaînée.
- `est_pile_vide(pile)`: Vérifie si la pile est vide.
- `sommet(pile)`: Renvoie l'élément au sommet de la pile.
- `empiler(pile, element)`: Ajoute un élément au sommet de la pile.
- `depiler(pile)`: Retire l'élément au sommet de la pile.
## Fichier `test.py`
Le fichier `test.py` contient des exemples d'utilisation des fonctionnalités de gestion de piles et d'évaluation en notation polonaise inverse.
### Fonctions dans `test.py`
- **Afficher une pile** : Affiche les éléments d'une pile du sommet à la base.
- **Copier une pile** : Crée une copie d'une pile donnée.
- **Hauteur de la pile** : Renvoie la hauteur de la pile.
- **Inverser des éléments** : Inverse les `j` derniers éléments de la pile.
- **Trouver le maximum** : Renvoie la position du maximum parmi les `i` derniers éléments de la pile.
- **Tri des crêpes** : Trie les éléments de la pile en utilisant la méthode des crêpes.
- **Évaluation NPI** : Évalue une expression arithmétique en notation polonaise inverse.
### Exécution de `test.py`
Pour exécuter le script, ouvrez votre terminal, naviguez vers le dossier contenant le fichier `test.py`, puis exécutez la commande suivante :
```bash
python test.py

BIN
tp6/TP_Piles.pdf Normal file
View File

Binary file not shown.

46
tp6/npi.py Normal file
View File

@@ -0,0 +1,46 @@
def evaluer_npi(expression):
"""fais la notation polonaise inversée (NPI) d'une expression arithmétique
Args:
expression (_type_): String contenant l'expression arithmétique
Returns:
_type_: Integer contenant le resultat.
"""
pile = []
elements = expression.split()
for element in elements:
if element.isdigit():
pile.append(int(element))
else:
droite = pile.pop()
gauche = pile.pop()
if element == '+':
resultat = gauche + droite
elif element == '-':
resultat = gauche - droite
elif element == '*':
resultat = gauche * droite
elif element == '/':
resultat = gauche / droite
else:
raise ValueError(f"Opérateur inconnu: {element}")
pile.append(resultat)
if len(pile) != 1:
raise ValueError("L'expression est mal formée.")
return pile.pop()
expression = "100 60 / 60 + 90 *"
resultat = evaluer_npi(expression)
print(f"Le résultat de l'expression '{expression}' est: {resultat}")

125
tp6/test.py Normal file
View File

@@ -0,0 +1,125 @@
import Pile_LSC as lifo
from random import shuffle
def afficher(pile):
"""Affiche les éléments d'une pile du sommet à la base."""
print("|----")
temp = pile
while not lifo.est_pile_vide(temp):
print(f"| {lifo.sommet(temp)}")
temp = lifo.depiler(temp)
print("|----\n")
def copier_pile(pile):
"""Copie une pile représentée par une liste simplement chaînée."""
copie = lifo.creer_pile_vide()
pile_temp = lifo.creer_pile_vide()
while not lifo.est_pile_vide(pile):
sommet = lifo.sommet(pile)
pile_temp = lifo.empiler(pile_temp, sommet)
pile = lifo.depiler(pile)
while not lifo.est_pile_vide(pile_temp):
sommet = lifo.sommet(pile_temp)
pile = lifo.empiler(pile, sommet)
copie = lifo.empiler(copie, sommet)
pile_temp = lifo.depiler(pile_temp)
return copie
def hauteur_pile(pile):
"""
Renvoie hauteur de la pile.
PARAMETRES : pile - pile à analyser.
RETURN : hauteur.
EFFET DE BORD : Aucune.
"""
n = 0
while not lifo.est_pile_vide(pile):
n += 1
pile = lifo.depiler(pile)
return n
def retourner(pile, j):
"""
Inverse j derniers éléments de la pile.
PARAMETRES : pile - pile à modifier, j - nombre d'éléments à inverser.
RETURN : Aucune.
EFFET DE BORD : Modifie la pile.
"""
pile_aux = lifo.creer_pile_vide()
for _ in range(j):
if lifo.est_pile_vide(pile):
break
pile_aux = lifo.empiler(pile_aux, lifo.sommet(pile))
pile = lifo.depiler(pile)
while not lifo.est_pile_vide(pile_aux):
pile = lifo.empiler(pile, lifo.sommet(pile_aux))
pile_aux = lifo.depiler(pile_aux)
def max_pile(pile, i):
"""
Renvoie position du maximum parmi i derniers éléments.
PARAMETRES : pile - pile à analyser, i - nombre d'éléments.
RETURN : position du maximum.
EFFET DE BORD : Aucune.
"""
copy = copier_pile(pile)
max_value = lifo.sommet(copy)
ind = 1
ind_n = 1
for _ in range(i):
if lifo.est_pile_vide(copy):
break
current = lifo.sommet(copy)
if current > max_value:
max_value = current
ind = ind_n
copy = lifo.depiler(copy)
ind_n += 1
return ind
def tri_crepes_iteratif(pile): #ne fonctionne pas
"""
Tri des crêpes en cours.
PARAMETRES : pile - pile à trier.
RETURN : pile triée.
EFFET DE BORD : Modifie la pile.
"""
n = hauteur_pile(pile)
for i in range(n):
max_position = max_pile(pile, n - i)
if max_position!= n - i:
retourner(pile, n - max_position)
retourner(pile, i + 1)
return pile
if __name__ == "__main__":
from random import shuffle
ma_liste = [i for i in range(10)]
shuffle(ma_liste)
print("Liste de départ :", ma_liste)
ma_pile = lifo.creer_pile_vide()
for element in ma_liste:
ma_pile = lifo.empiler(ma_pile, element)
print("\nPile initiale :")
afficher(ma_pile)
print(max_pile(ma_pile,10))
print("Tri des crêpes en cours...")
ma_pile = tri_crepes_iteratif(ma_pile)
print("Pile après tri :")
afficher(ma_pile)

260
tp6_self/LSC.py Normal file
View File

@@ -0,0 +1,260 @@
"""
Librairie des Listes Simplement Chaînées.
Elle met à distribution cette structure de données et son interface.
@author: L. JOANNIC
"""
# ############################################################################
class Liste_Simplement_Chainee(object):
"""
Classe des Listes Simplement Chainees.
Attributs
- _tete : None si vide, Maillon sinon.
Méthodes
- est_vide
- ajouter_en_tete
- tete
- queue
"""
def __init__(self):
"""
Construire une instance de Liste Simplement Chainee.
Returns
-------
None.
"""
self._tete = None
return None
def est_vide(self):
"""
Tester si l'instance est vide.
Returns
-------
bool
Vrai ssi la liste est vide.
"""
return (self._tete is None)
def ajouter_en_tete(self, element):
"""
Ajouter l'élément en tête de liste.
Parameters
----------
element : type de donnee
Donnnée à ajouter à la liste.
Returns
-------
resultat : Liste_Simplement_Chainee
La liste à abonder.
"""
resultat = Liste_Simplement_Chainee()
resultat._tete = Maillon(element, self)
return resultat
def tete(self):
"""
Renvoyer la donnée stockée en tête de liste.
Returns
-------
type de donnee quelconque
donnee en tete.
"""
assert not(self.est_vide()), "Liste Vide"
return self._tete.donnee
def queue(self):
"""
Renvoyer la sous-liste suivant le maillon de tete.
Returns
-------
Liste_Simplement_Chainee
Queue de la liste.
"""
assert not(self.est_vide()), "Liste Vide"
return self._tete.suite
# ############################################################################
def creer_liste_vide():
"""
Créer une liste simplement chainee vide.
Returns
-------
Liste_Simplement_Chainee
Liste vide.
Effets de bord
--------------
Aucun
"""
return Liste_Simplement_Chainee()
def est_vide(liste):
"""
Tester si la liste simplement chainee est vide.
Parameters
----------
liste : Liste Simplement Chainee
Liste à tester.
Returns
-------
bool
Vrai ssi la liste est vide.
Effets de bord
--------------
Aucun
"""
return liste.est_vide()
def ajouter_en_tete(liste, element):
"""
Inserer un element en tete de liste simplemeent chainee.
Parameters
----------
liste : LSC
Liste à abonder.
element : type de donnee
Donnee à aouter.
Returns
-------
LSC, copie de liste à laquelle element a été ajouté en tete.
Effets de bord
--------------
Aucun
"""
return liste.ajouter_en_tete(element)
def tete(liste):
"""
Consulter la tete de liste.
Parameters
----------
liste : LSC
Liste à consulter.
Returns
-------
type de donnée
valeur de la tete de liste.
Effets de bord
--------------
Aucun
"""
return liste.tete()
def queue(liste):
"""
Renvoyer la liste sans sa tete.
Parameters
----------
liste : LSC
Liste à étêter.
Returns
-------
LSC
Liste sans son maillon de tête.
Effets de bord
--------------
Aucun
"""
return liste.queue()
def afficher_liste(liste, taille=-1):
"""
Afficher la liste en format de présentation.
Parameters
----------
liste : LSC
Liste à énumérer.
Returns
-------
None.
Effets de bord
--------------
Affichage à l'écran.
"""
reste = liste
compteur = 0
print('+-----\n|')
while not(est_vide(reste)) and (taille == -1 or compteur < taille):
print('+- {}\n|'.format(str(tete(reste))))
reste = queue(reste)
compteur += 1
print('+-----')
return None
# ############################################################################
class Maillon(object):
"""
Classe des Maillons d'une Liste Simplement Chainee.
Attributs
- donnee : donnee stockee dans le maillon
- suite : liste simplemement chainee suivant le maillon
"""
def __init__(self, donnee=None, suite=Liste_Simplement_Chainee()):
"""
Construire une instance de la classe des Maillons.
Parameters
----------
donnee : type de donnee, optional
Donnee initiale dans le Maillon. The default is None.
suite : LSC, optional
Sous-liste suivant le Maillon courant.
The default is Liste_Simplement_Chainee().
Returns
-------
None.
"""
self.donnee = donnee
self.suite = suite
return None
# ############################################################################

55
tp6_self/Pile_LSC.py Normal file
View File

@@ -0,0 +1,55 @@
import LSC as lsc
# Chacune des fonctions renvoie et n'ont pas d'effet de bord
def creer_pile_vide():
"""Creer une pile vide.
Returns:
lsc.Liste_Simplement_Chainee: La liste vide
"""
return lsc.creer_liste_vide()
def est_pile_vide(pile: lsc.Liste_Simplement_Chainee):
"""Retourne True si la pile est vide, False sinon.
Args:
pile (lsc.Liste_Simplement_Chainee): La pile à tester
Returns:
bool: True si la pile est vide
"""
return lsc.est_vide(pile)
def sommet(pile: lsc.Liste_Simplement_Chainee):
"""Retourne le sommet de la pile.
Args:
pile (lsc.Liste_Simplement_Chainee): La pile avec le sommet
Returns:
any: Le sommet de la pile
"""
assert not est_pile_vide(pile), "La pile est vide"
return lsc.tete(pile)
def empiler(pile: lsc.Liste_Simplement_Chainee,elt: any):
"""Ajoute un element en tete de la pile
Args:
pile lsc.Liste_Simplement_Chainee: La pile à modifier
elt any: l'element a ajouter
Returns:
lsc.Liste_Simplement_Chainee : La pile avec l'element ajouté
"""
return lsc.ajouter_en_tete(pile, elt)
def depiler(pile: lsc.Liste_Simplement_Chainee):
"""Retire le sommet de la pile
Args:
pile (lsc.Liste_Simplement_Chainee): La pile avec le sommet
Returns:
lsc.Liste_Simplement_Chainee: La pile avec le sommet retiré
"""
assert not est_pile_vide(pile), "La pile est vide"
return lsc.queue(pile)

54
tp6_self/Pile_List.py Normal file
View File

@@ -0,0 +1,54 @@
# Chacune des fonctions renvoie et n'ont pas d'effet de bord
def creer_pile_vide()->list:
"""Créer une pile vide.
Returns:
list: La pile vide
"""
return []
def est_pile_vide(pile: list) -> bool:
"""Retourne True si la pile est vide, False sinon.
Args:
pile (list): La pile à tester
Returns:
bool: True si la pile est vide
"""
return len(pile) == 0
def sommet(pile: list)->int:
"""Retourne le sommet de la pile.
Args:
pile (list): La pile avec le sommet
Returns:
any: le sommet de la pile
"""
assert not est_pile_vide(pile), "La pile est vide"
return pile[-1]
def empiler(pile: list, elt: any)-> list:
"""rajoute elt au sommet de la pile
Args:
pile (list): La pile à modifier
elt (any): l'élement à ajouter
Returns:
list: la pile modifiée
"""
return pile + [elt]
def depiler(pile: list)-> any:
"""retourne la pile sans le sommet
Args:
pile (list): la pile avec le sommet
Returns:
any: la pile sans le sommet
"""
assert not est_pile_vide(pile), "La pile est vide"
return pile[:-1]

54
tp6_self/Pile_Tuple.py Normal file
View File

@@ -0,0 +1,54 @@
# Chacune des fonctions renvoie et n'ont pas d'effet de bord
def creer_pile_vide() -> tuple:
"""Créer une pile vide.
Returns:
Tuple: La pile vide
"""
return ()
def est_pile_vide(pile: tuple) -> bool:
"""Retourne True si la pile est vide, False sinon.
Args:
pile (tuple): La pile à tester
Returns:
bool: True si la pile est vide
"""
return len(pile) == 0
def sommet(pile: tuple) -> any:
"""Renvoie le sommet de la pile.
Args:
pile (tuple): La pile contenant le sommet
Returns:
any: Le sommet de la pile
"""
return pile[-1]
def empiler(pile: tuple, elt: any)-> tuple:
"""ajoute elt au sommet de la pile
Args:
pile (tuple): la pile a modifier
elt (any): l'élement à ajouter
Returns:
tuple: la pile avec l'élement ajouté
"""
return pile + (elt,)
def depiler(pile: tuple) -> tuple:
"""Retire le sommet de la pile
Args:
pile (tuple): La pile avec le sommet
Returns:
tuple: La pile avec le sommet retiré
"""
assert not est_pile_vide(pile), "La pile est vide"
return pile[:-1]

133
tp6_self/README.md Normal file
View File

@@ -0,0 +1,133 @@
# **README - DM Piles et NPI**
## **Comment exécuter le programme :**
1. Verfier que tous les fichiers sont dans le même répertoire :
- `test.py`
- `Pile_Tuple.py`
- `Pile_LSC.py`
- `Pile_Liste.py`
- `npi.py`
2. Ouvrez un terminal dans ce répertoire.
3. Exécutez le programme avec la commande suivante :
```bash
python3 test.py
```
ou executer pour la notation polonaise inverse:
```bash
python3 npi.py
```
---
## **Fonctions disponibles et leur utilisation :**
### 1. **`creer_pile_vide()`**
- **Description** : Crée et renvoie une pile vide.
- **Utilisation** :
```python
pile = creer_pile_vide()
```
---
### 2. **`est_pile_vide(pile)`**
- **Description** : Vérifie si une pile est vide.
- **Paramètre** :
- `pile` : La pile à vérifier.
- **Retour** : Renvoie `True` si la pile est vide, sinon `False`.
- **Utilisation** :
```python
if est_pile_vide(pile):
print("La pile est vide.")
```
---
### 3. **`sommet(pile)`**
- **Description** : Retourne l’élément au sommet de la pile sans le retirer.
- **Paramètre** :
- `pile` : La pile à consulter.
- **Retour** : L’élément au sommet de la pile.
- **Utilisation** :
```python
print(sommet(pile))
```
---
### 4. **`empiler(pile, elt)`**
- **Description** : Ajoute un élément au sommet de la pile.
- **Paramètres** :
- `pile` : La pile à modifier.
- `elt` : L’élément à empiler.
- **Retour** : La nouvelle pile avec l’élément ajouté.
- **Utilisation** :
```python
pile = empiler(pile, 5)
```
---
### 5. **`depiler(pile)`**
- **Description** : Retire l’élément au sommet de la pile.
- **Paramètre** :
- `pile` : La pile à modifier.
- **Retour** : La pile sans l’élément au sommet.
- **Utilisation** :
```python
pile = depiler(pile)
```
---
### 6. **`hauteur_pile(pile)`**
- **Description** : Renvoie le nombre d'éléments présents dans la pile sans la modifier.
- **Paramètre** :
- `pile` : La pile à analyser.
- **Retour** : La hauteur de la pile (nombre d'éléments).
- **Utilisation** :
```python
print(hauteur_pile(pile))
```
---
### 7. **`max_pile(pile, i)`**
- **Description** : Trouve le maximum parmi les `i` premiers éléments de la pile.
- **Paramètres** :
- `pile` : La pile à analyser.
- `i` : Le nombre d'éléments à prendre en compte depuis le sommet.
- **Retour** : Le maximum trouvé parmi les `i` éléments.
- **Utilisation** :
```python
print(max_pile(pile, 3))
```
---
### 8. **`retourner(pile, j)`**
- **Description** : Inverse l’ordre des `j` premiers éléments de la pile.
- **Paramètres** :
- `pile` : La pile à modifier.
- `j` : Le nombre d'éléments à inverser.
- **Retour** : La pile modifiée.
- **Utilisation** :
```python
pile = retourner(pile, 2)
```
---
### 9. **`tri_crepes_recursif(pile)`**
- **Description** : Trie une pile en suivant le tri des crêpes.
- **Paramètre** :
- `pile` : La pile à trier.
- **Retour** : La pile triée.
- **Utilisation** :
```python
pile = tri_crepes_recursif(pile)
```
<hr>
Cela conclut la documentation des fonctions. Pour toute question, consultez le fichier **test.py** pour des exemples plus détaillés.
pour toutes questions: elouan.fare@protonmail.ch

44
tp6_self/npi.py Normal file
View File

@@ -0,0 +1,44 @@
def npi(exp: str) -> float:
"""Calcule une expression arithmétique en NPI (notation polonaise inverse).
Args:
exp (str): L'expression arithmétique à calculer.
Returns:
float: Le résultat de l'expression.
"""
assert exp, "L'expression est vide."
pile = []
for token in exp.split():
if token in "+-*/":
if len(pile) < 2:
print("Erreure : Pas assez d'opérandes.")
return None
b, a = pile.pop(), pile.pop()
match token:
case '+': pile.append(a + b)
case '-': pile.append(a - b)
case '*': pile.append(a * b)
case '/':
if b == 0:
print("Erreur : Division par zéro.")
return None
pile.append(a / b)
elif token.replace('.', '', 1).isdigit(): # isdigit verifie si 'token' est un nombre ou un chiffre
pile.append(float(token))
else:
print(f"erreur : '{token}' n'est pas un opérande valide.")
return None
if len(pile) != 1:
print("erreur : Expression mal formée.")
return None
return pile[0] # On aurait pu mettre pile[-1]
if __name__ == "__main__":
# Test
exp = "3 4 + 5 * 2 /" # correspond a (3+4)(5/2) soit 7 * 2.5 = 17.5
print(npi(exp))

160
tp6_self/test.py Normal file
View File

@@ -0,0 +1,160 @@
#!/usr/bin/python3
import LSC as lsc
import Pile_List as lifo
from random import shuffle
from typing import List, Tuple, Union, TypeVar, Any
T = TypeVar('T')
PileType = Union[List[T], Tuple[T,...], lsc.Liste_Simplement_Chainee]
#----------------------------------------------------------------
# Aucun effet de bord sur les fonctions ajoutés car je n'y suis pas arrivé
#----------------------------------------------------------------
def afficher(pile):
print("|----\n|")
while not(lifo.est_pile_vide(pile)):
print(f"| {lifo.sommet(pile)}\n|")
pile = lifo.depiler(pile)
print("|----")
return None
def hauteur_pile(pile: PileType) -> int:
"""Retourne la taille/ hauteur de la pile
Args:
pile (list/tuple/lsc.Liste_Simplement_Chainee): la pile a mesurer
Returns:
int: la taille de la pile
"""
n = 0
while not(lifo.est_pile_vide(pile)):
n += 1
pile = lifo.depiler(pile)
return n
def copie(pile: PileType) -> PileType:
"""creer une copie de la pile
Args:
pile (PileType): pile a copier
Returns:
PileType: une copie de la pile
"""
pile_copie = lifo.creer_pile_vide()
while not(lifo.est_pile_vide(pile)):
pile_copie = lifo.empiler(pile_copie, lifo.sommet(pile))
pile = lifo.depiler(pile)
return pile_copie
def max_pile(pile: PileType,start: int)-> int:
"""Retourne l'element le plus grand de la pile
Args:
start: int: la position de départ de la recherche
pile: PileType: la pile a analyser
Returns:
int: l'indice de l'element le plus grand de la pile
"""
assert start >=0, "Position de départ invalide"
assert hauteur_pile(pile) >= start, "Position de départ dépasse la taille de la pile"
assert not(lifo.est_pile_vide(pile)), "La pile est vide"
pile2 = copie(copie(pile)) # <--- pas très propre c'est pour renverser la copie qui a été renversé
# J'itère jusqu' a start:
max_n = lifo.sommet(pile)
for _ in range(start):
sommet = lifo.sommet(pile2)
pile2 = lifo.depiler(pile2)
if sommet > max_n:
max_n = sommet
pile2 = copie(copie(pile))
# je cherche l'index du max dans pile2
for i in range(start):
i+=1
if lifo.sommet(pile2) == max_n:
return i
else:
pile2 = lifo.depiler(pile2)
def retourner(pile: PileType, j: int) -> PileType:
"""retourne la pile avec les j premiers éléments renversés.
Args:
pile (PileType): la pile
j (int): l'index a renverser
Returns:
PileType: la pile renversée
"""
pile1 = copie(copie(pile))
pile2 = lifo.creer_pile_vide()
# je déplace les j premiers éléments de pile1 dans pile2
for _ in range(j):
sommet = lifo.sommet(pile1)
pile1 = lifo.depiler(pile1)
pile2 = lifo.empiler(pile2, sommet)
# renverse Pile 2
pile2 = copie(pile2)
#ajoute pile2 a pile1
while not(lifo.est_pile_vide(pile2)):
sommet = lifo.sommet(pile2)
pile1 = lifo.empiler(pile1,sommet)
pile2 = lifo.depiler(pile2)
pile = lifo.creer_pile_vide()
# remplace Pile par Pile1
while not(lifo.est_pile_vide(pile1)):
sommet = lifo.sommet(pile1)
pile = lifo.empiler(pile, sommet)
pile1 = lifo.depiler(pile1)
return copie(pile)
def tri_crepes(pile: PileType) -> PileType:
"""tri la pile en utilisant 'pancakes sort'
Args:
pile (PileType): la pile a trier
Returns:
PileType: la pile triée
"""
n = hauteur_pile(pile)
while n > 1:
index_max = max_pile(pile, n)
pile = retourner(pile,index_max)
pile = retourner(pile,n)
n-=1
return (pile)
if __name__ == "__main__":
ma_liste = [_ for _ in range(10)]
shuffle(ma_liste)
print("Liste de départ : ", ma_liste)
ma_pile = lifo.creer_pile_vide()
print("\nEMPILEMENT\n")
for element in ma_liste:
ma_pile = lifo.empiler(ma_pile, element)
j = 4
print("\nTaille de la pile : ", hauteur_pile(ma_pile))
print(f"Element le plus grand de la pile à partir de l'index {j}: {max_pile(ma_pile,4)}")
pile = retourner(ma_pile, j)
hauteur_pile(ma_pile)
afficher(pile)
print("\nDEPILEMENT\n")
pile_triee = tri_crepes(ma_pile)
afficher(pile_triee)
while not(lifo.est_pile_vide(ma_pile)):
print(f"Sommet : {lifo.sommet(ma_pile)}")
ma_pile = lifo.depiler(ma_pile)
afficher(ma_pile)

BIN
tp_listes_chaines/TP 5 Listes Chaînées-20240925.zip Normal file
View File

Binary file not shown.

BIN
tp_listes_chaines/TP5_Listes_Chainees.pdf Normal file
View File

Binary file not shown.

278
tp_listes_chaines/execute.py Executable file
View File

@@ -0,0 +1,278 @@
# Création du fichier complet TP5_1.py avec toutes les fonctions demandées
contenu_tp5 = """
import re
from Sommets import Sommet
from LSC import creer_liste_vide, ajouter_en_tete, afficher_liste, est_vide, tete, queue
# 1. Fonction extraire_altitude
def extraire_altitude(chaine):
\"\"\"
Extrait la partie numérique de l'altitude depuis une chaîne du type '1 029 m'.
Paramètres :
chaine (str) : La chaîne contenant l'altitude et l'unité.
Retourne :
int : La valeur numérique de l'altitude.
\"\"\"
return int(re.sub(r'\\D', '', chaine))
# 2. Fonction csv2liste
def csv2liste(fichier_csv):
\"\"\"
Lit un fichier CSV et retourne une liste simplement chaînée des sommets.
Paramètres :
fichier_csv (str) : Le chemin vers le fichier CSV à lire.
Retourne :
Une liste simplement chaînée contenant les sommets.
\"\"\"
liste_sommets = creer_liste_vide()
with open(fichier_csv, 'r') as fichier:
for ligne in fichier:
nom, altitude = ligne.strip().split(',')
altitude = extraire_altitude(altitude) # Extraction de la valeur numérique
sommet = Sommet(nom, altitude, 'Chartreuse') # Le massif est 'Chartreuse'
liste_sommets = ajouter_en_tete(liste_sommets, sommet)
return liste_sommets
# 3. Fonction copier_liste
def copier_liste(liste):
\"\"\"
Copie une liste simplement chaînée.
Paramètres :
liste : Une liste simplement chaînée.
Retourne :
Une copie de la liste.
\"\"\"
if est_vide(liste):
return creer_liste_vide()
else:
return ajouter_en_tete(copier_liste(queue(liste)), tete(liste))
# 4. Fonction rechercher
def rechercher(liste, nom):
\"\"\"
Recherche un sommet dans la liste par son nom.
Paramètres :
liste : Une liste simplement chaînée.
nom (str) : Le nom du sommet à rechercher.
Retourne :
bool : True si le sommet est trouvé, False sinon.
\"\"\"
reste = liste
while not est_vide(reste):
sommet = tete(reste)
if sommet.nom == nom:
return True
reste = queue(reste)
return False
# 5. Fonction modifier_altitude
def modifier_altitude(liste, nom, nouvelle_altitude):
\"\"\"
Modifie l'altitude d'un sommet dans la liste.
Paramètres :
liste : Une liste simplement chaînée.
nom (str) : Le nom du sommet à modifier.
nouvelle_altitude (int) : La nouvelle altitude du sommet.
\"\"\"
reste = liste
while not est_vide(reste):
sommet = tete(reste)
if sommet.nom == nom:
sommet.altitude = nouvelle_altitude
break
reste = queue(reste)
# 6. Fonction supprimer_sommet
def supprimer_sommet(liste, nom):
\"\"\"
Supprime la première occurrence du sommet de nom donné dans la liste.
Paramètres :
liste : Une liste simplement chaînée.
nom (str) : Le nom du sommet à supprimer.
Retourne :
Une liste simplement chaînée avec la première occurrence du sommet supprimée.
\"\"\"
if est_vide(liste):
return liste
elif tete(liste).nom == nom:
return queue(liste)
else:
return ajouter_en_tete(supprimer_sommet(queue(liste), nom), tete(liste))
# 7. Fonction supprimer_sommets
def supprimer_sommets(liste, nom):
\"\"\"
Supprime toutes les occurrences du sommet de nom donné dans la liste.
Paramètres :
liste : Une liste simplement chaînée.
nom (str) : Le nom du sommet à supprimer.
Retourne :
Une liste simplement chaînée avec toutes les occurrences du sommet supprimées.
\"\"\"
if est_vide(liste):
return liste
elif tete(liste).nom == nom:
return supprimer_sommets(queue(liste), nom)
else:
return ajouter_en_tete(supprimer_sommets(queue(liste), nom), tete(liste))
# 8. Fonction longueur
def longueur(liste):
\"\"\"
Renvoie le nombre d'éléments de la liste simplement chaînée.
Paramètres :
liste : Une liste simplement chaînée.
Retourne :
int : Le nombre d'éléments dans la liste.
\"\"\"
if est_vide(liste):
return 0
else:
return 1 + longueur(queue(liste))
# 9. Fonction inserer
def inserer(liste, element, rang):
\"\"\"
Insère un élément à un rang donné dans la liste.
Paramètres :
liste : Une liste simplement chaînée.
element : L'élément à insérer.
rang (int) : Le rang auquel insérer l'élément.
Retourne :
Une liste simplement chaînée avec l'élément inséré.
\"\"\"
if rang == 0:
return ajouter_en_tete(liste, element)
else:
return ajouter_en_tete(inserer(queue(liste), element, rang - 1), tete(liste))
# 10. Fonction supprimer
def supprimer(liste, rang):
\"\"\"
Supprime un élément à un rang donné dans la liste.
Paramètres :
liste : Une liste simplement chaînée.
rang (int) : Le rang de l'élément à supprimer.
Retourne :
Une liste simplement chaînée avec l'élément supprimé.
\"\"\"
if rang == 0:
return queue(liste)
else:
return ajouter_en_tete(supprimer(queue(liste), rang - 1), tete(liste))
# 11. Fonction modifier
def modifier(liste, rang, element):
\"\"\"
Modifie un élément à un rang donné dans la liste.
Paramètres :
liste : Une liste simplement chaînée.
rang (int) : Le rang de l'élément à modifier.
element : Le nouvel élément à insérer à ce rang.
Retourne :
Une liste simplement chaînée avec l'élément modifié.
\"\"\"
if rang == 0:
return ajouter_en_tete(queue(liste), element)
else:
return ajouter_en_tete(modifier(queue(liste), rang - 1, element), tete(liste))
# 12. Fonction rechercher_par_rang
def rechercher_par_rang(liste, element):
\"\"\"
Recherche l'élément dans la liste et retourne son rang.
Paramètres :
liste : Une liste simplement chaînée.
element : L'élément à rechercher.
Retourne :
int : Le rang de l'élément ou -1 s'il n'est pas trouvé.
\"\"\"
reste = liste
rang = 0
while not est_vide(reste):
if tete(reste) == element:
return rang
reste = queue(reste)
rang += 1
return -1
# 13. Fonction lire
def lire(liste, rang):
\"\"\"
Renvoie l'élément à un rang donné dans la liste.
Paramètres :
liste : Une liste simplement chaînée.
rang (int) : Le rang de l'élément à lire.
Retourne :
L'élément à ce rang.
\"\"\"
if rang == 0:
return tete(liste)
else:
return lire(queue(liste), rang - 1)
# 14. Fonction trier
def trier(liste, ordre=lambda x, y: x < y):
\"\"\"
Trie la liste dans un ordre donné.
Paramètres :
liste : Une liste simplement chaînée.
ordre : Une fonction de comparaison, par défaut x < y.
Retourne :
Une liste simplement chaînée triée.
\"\"\"
if est_vide(liste):
return liste
else:
pivot = tete(liste)
sous_liste = queue(liste)
# Séparer en deux listes
inferieurs = creer_liste_vide()
superieurs = creer_liste_vide()
while not est_vide(sous_liste):
elt = tete(sous_liste)
if ordre(elt, pivot):
inferieurs = ajouter_en_tete(inferieurs, elt)
else:
superieurs = ajouter_en_tete(superieurs, elt)
sous_liste = queue(sous_liste)
# Trier les sous-listes
inferieurs = trier(inferieurs, ordre)
superieurs = trier(superieurs, ordre)
# Ajouter le pivot au résultat
return ajouter_en_tete(superieurs, pivot)
"""
# Sauvegarder le fichier
path = "/home/spectre/Python/tp_listes_chaines/TP5.py"

29
tp_listes_chaines/fichiers/Chartreuse.csv Normal file
View File

@@ -0,0 +1,29 @@
Grande Sure (La), 1 920 m
Rocher de Lorzier (Le), 1 838 m
Rochers de Chalves (Les), 1 845 m
Rocher de l'Église (Le), 1 300 m
Pointe de la Gorgeat (La), 1 486 m
Mont Joigny (Le), 1 556 m
Mont Outheran (Le), 1 673 m
Cochette (La), 1 618 m
Roc de Gleisin (Le), 1 434 m
Roche Veyrand (La), 1 429 m
Dent de l'Ours (La), 1 820 m
Petit Som (Le), 1 772 m
Grand Som (Le), 2 026 m
Charmant Som (Le), 1 867 m
Pinéa (La), 1 771 m
Néron (Le), 1 299 m
Mont Granier (Le), 1 933 m
Sommet du Pinet (Le) ou le Truc, 1 867 m
Grand Manti (Le), 1 818 m
Scia (La), 1 791 m
Lances de Malissard (Les), 2 045 m
Dôme de Bellefont (Le), 1 975 m
Dent de Crolles (La), 2 062 m
Piton de Bellefont (Le), 1 958 m
Chamechaude, 2 082 m
Grands Crêts (Les), 1 489 m
Mont Saint-Eynard (Le), 1 379 m
Écoutoux (L'), 1 406 m
Rachais (Le), 1 050 m
1 Grande Sure (La) 1 920 m
2 Rocher de Lorzier (Le) 1 838 m
3 Rochers de Chalves (Les) 1 845 m
4 Rocher de l'Église (Le) 1 300 m
5 Pointe de la Gorgeat (La) 1 486 m
6 Mont Joigny (Le) 1 556 m
7 Mont Outheran (Le) 1 673 m
8 Cochette (La) 1 618 m
9 Roc de Gleisin (Le) 1 434 m
10 Roche Veyrand (La) 1 429 m
11 Dent de l'Ours (La) 1 820 m
12 Petit Som (Le) 1 772 m
13 Grand Som (Le) 2 026 m
14 Charmant Som (Le) 1 867 m
15 Pinéa (La) 1 771 m
16 Néron (Le) 1 299 m
17 Mont Granier (Le) 1 933 m
18 Sommet du Pinet (Le) ou le Truc 1 867 m
19 Grand Manti (Le) 1 818 m
20 Scia (La) 1 791 m
21 Lances de Malissard (Les) 2 045 m
22 Dôme de Bellefont (Le) 1 975 m
23 Dent de Crolles (La) 2 062 m
24 Piton de Bellefont (Le) 1 958 m
25 Chamechaude 2 082 m
26 Grands Crêts (Les) 1 489 m
27 Mont Saint-Eynard (Le) 1 379 m
28 Écoutoux (L') 1 406 m
29 Rachais (Le) 1 050 m

260
tp_listes_chaines/fichiers/LSC.py Normal file
View File

@@ -0,0 +1,260 @@
"""
Librairie des Listes Simplement Chaînées.
Elle met à distribution cette structure de données et son interface.
@author: L. JOANNIC
"""
# ############################################################################
class Liste_Simplement_Chainee(object):
"""
Classe des Listes Simplement Chainees.
Attributs
- _tete : None si vide, Maillon sinon.
Méthodes
- est_vide
- ajouter_en_tete
- tete
- queue
"""
def __init__(self):
"""
Construire une instance de Liste Simplement Chainee.
Returns
-------
None.
"""
self._tete = None
return None
def est_vide(self):
"""
Tester si l'instance est vide.
Returns
-------
bool
Vrai ssi la liste est vide.
"""
return (self._tete is None)
def ajouter_en_tete(self, element):
"""
Ajouter l'élément en tête de liste.
Parameters
----------
element : type de donnee
Donnnée à ajouter à la liste.
Returns
-------
resultat : Liste_Simplement_Chainee
La liste à abonder.
"""
resultat = Liste_Simplement_Chainee()
resultat._tete = Maillon(element, self)
return resultat
def tete(self):
"""
Renvoyer la donnée stockée en tête de liste.
Returns
-------
type de donnee quelconque
donnee en tete.
"""
assert not(self.est_vide()), "Liste Vide"
return self._tete.donnee
def queue(self):
"""
Renvoyer la sous-liste suivant le maillon de tete.
Returns
-------
Liste_Simplement_Chainee
Queue de la liste.
"""
assert not(self.est_vide()), "Liste Vide"
return self._tete.suite
# ############################################################################
def creer_liste_vide():
"""
Créer une liste simplement chainee vide.
Returns
-------
Liste_Simplement_Chainee
Liste vide.
Effets de bord
--------------
Aucun
"""
return Liste_Simplement_Chainee()
def est_vide(liste):
"""
Tester si la liste simplement chainee est vide.
Parameters
----------
liste : Liste Simplement Chainee
Liste à tester.
Returns
-------
bool
Vrai ssi la liste est vide.
Effets de bord
--------------
Aucun
"""
return liste.est_vide()
def ajouter_en_tete(liste, element):
"""
Inserer un element en tete de liste simplemeent chainee.
Parameters
----------
liste : LSC
Liste à abonder.
element : type de donnee
Donnee à aouter.
Returns
-------
LSC, copie de liste à laquelle element a été ajouté en tete.
Effets de bord
--------------
Aucun
"""
return liste.ajouter_en_tete(element)
def tete(liste):
"""
Consulter la tete de liste.
Parameters
----------
liste : LSC
Liste à consulter.
Returns
-------
type de donnée
valeur de la tete de liste.
Effets de bord
--------------
Aucun
"""
return liste.tete()
def queue(liste):
"""
Renvoyer la liste sans sa tete.
Parameters
----------
liste : LSC
Liste à étêter.
Returns
-------
LSC
Liste sans son maillon de tête.
Effets de bord
--------------
Aucun
"""
return liste.queue()
def afficher_liste(liste, taille=-1):
"""
Afficher la liste en format de présentation.
Parameters
----------
liste : LSC
Liste à énumérer.
Returns
-------
None.
Effets de bord
--------------
Affichage à l'écran.
"""
reste = liste
compteur = 0
print('+-----\n|')
while not(est_vide(reste)) and (taille == -1 or compteur < taille):
print('+- {}\n|'.format(str(tete(reste))))
reste = queue(reste)
compteur += 1
print('+-----')
return None
# ############################################################################
class Maillon(object):
"""
Classe des Maillons d'une Liste Simplement Chainee.
Attributs
- donnee : donnee stockee dans le maillon
- suite : liste simplemement chainee suivant le maillon
"""
def __init__(self, donnee=None, suite=Liste_Simplement_Chainee()):
"""
Construire une instance de la classe des Maillons.
Parameters
----------
donnee : type de donnee, optional
Donnee initiale dans le Maillon. The default is None.
suite : LSC, optional
Sous-liste suivant le Maillon courant.
The default is Liste_Simplement_Chainee().
Returns
-------
None.
"""
self.donnee = donnee
self.suite = suite
return None
# ############################################################################

191
tp_listes_chaines/fichiers/Sommets.py Normal file
View File

@@ -0,0 +1,191 @@
#! /usr/bin/python3
# coding=utf-8
"""
Ce fichier contient la définition des objets Sommets.
Un sommet dispose
- des attributs
+ nom
+ altitude
+ massif
- des méthodes
+ __lt__ : inférieur
+ __le__ : inférieur ou égal
+ __eq__ : égal
+ __ge__ : supérieur ou égal
+ __gt__ : supérieur
+ __repr__ : représentation (affichage)
"""
# ############################################################################
class Sommet(object):
"""
Classe des Sommets montagneux.
Attributs
- nom : STR, nom du sommet
- altitude : INT, altitude en mètres
- massif : STR, nom du massif d'appartenance
Méthodes
- comparaison
- représentation
"""
def __init__(self, nom, altitude, massif):
"""
Construire une instance de la classe Sommet.
Parameters
----------
nom : str
nom du sommet.
altitude : int
altitude en m.
massif : str
massif d'appartenance.
Returns
-------
None.
"""
self.nom = nom
self.altitude = altitude
self.massif = massif
return None
def __repr__(self):
"""
Construire l'affichage d'une instance de Sommet.
Returns
-------
str
chaine formattée d'affichage.
"""
if self.altitude < 1000:
altitude = str(self.altitude)
else:
altitude = str(self.altitude)
altitude = altitude[:-3]+' '+altitude[-3:]
return "{:<35s} [ {:^10s} ] :\t{:>10s} m".format(self.nom, self.massif, altitude)
def __str__(self):
"""
Construire la chaîne de caractères résumant
une instance de Sommet.
Returns
-------
str
chaine formattée d'affichage.
"""
if self.altitude < 1000:
altitude = str(self.altitude)
else:
altitude = str(self.altitude)
altitude = altitude[:-3]+' '+altitude[-3:]
return "{:<35s} [ {:^10s} ] :\t{:>10s} m".format(self.nom, self.massif, altitude)
def __gt__(self, other):
"""
Strictement plus grand.
Parameters
----------
other : Sommet
Sommet à comparer.
Returns
-------
boolean
Resultat du test.
"""
return (self.altitude > other.altitude)\
or ((self.altitude == other.altitude) and (self.nom > other.nom))
def __lt__(self, other):
"""
Strictement plus petit.
Parameters
----------
other : Sommet
Sommet à comparer.
Returns
-------
boolean
Resultat du test.
"""
return (self.altitude < other.altitude)\
or ((self.altitude == other.altitude) and (self.nom < other.nom))
def __eq__(self, other):
"""
Est égal à.
Parameters
----------
other : Sommet
Sommet à comparer.
Returns
-------
boolean
Resultat du test.
"""
return (self.altitude == other.altitude)
def __ge__(self, other):
"""
Plus grand ou égal.
Parameters
----------
other : Sommet
Sommet à comparer.
Returns
-------
boolean
Resultat du test.
"""
return (self > other) or (self == other)
def __le__(self, other):
"""
Plus petit ou égal.
Parameters
----------
other : Sommet
Sommet à comparer.
Returns
-------
boolean
Resultat du test.
"""
return (self < other) or (self == other)
# ############################################################################
if __name__ == '__main__':
s = Sommet('Chamechaude', 2062, 'Chartreuse')
print(s)

276
tp_listes_chaines/fichiers/TP5.py Normal file
View File

@@ -0,0 +1,276 @@
import re
from Sommets import Sommet
from LSC import creer_liste_vide, ajouter_en_tete, afficher_liste, est_vide, tete, queue
# 1. Fonction extraire_altitude (inchangée, non récursive)
def extraire_altitude(chaine):
"""
Extrait la partie numérique de l'altitude depuis une chaîne du type '1 029 m'.
Paramètres :
chaine (str) : La chaîne contenant l'altitude et l'unité.
Retourne :
int : La valeur numérique de l'altitude.
"""
return int(re.sub(r'\D', '', chaine))
# 2. Fonction csv2liste (récursive)
def csv2liste(fichier_csv):
"""
Lit un fichier CSV et retourne une liste simplement chaînée des sommets.
Paramètres :
fichier_csv (str) : Le chemin vers le fichier CSV à lire.
Retourne :
Une liste simplement chaînée contenant les sommets.
"""
with open(fichier_csv, 'r') as fichier:
lignes = fichier.readlines()
# Fonction récursive interne pour construire la liste
def construire_liste(lignes):
if not lignes:
return creer_liste_vide()
else:
nom, altitude = lignes[0].strip().split(',')
altitude = extraire_altitude(altitude)
sommet = Sommet(nom, altitude, 'Chartreuse')
return ajouter_en_tete(construire_liste(lignes[1:]), sommet)
return construire_liste(lignes)
# 3. Fonction copier_liste (récursive)
def copier_liste(liste):
"""
Copie une liste simplement chaînée.
Paramètres :
liste : Une liste simplement chaînée.
Retourne :
Une copie de la liste.
"""
if est_vide(liste):
return creer_liste_vide()
else:
return ajouter_en_tete(copier_liste(queue(liste)), tete(liste))
# 4. Fonction rechercher (récursive)
def rechercher(liste, nom):
"""
Recherche un sommet dans la liste par son nom.
Paramètres :
liste : Une liste simplement chaînée.
nom (str) : Le nom du sommet à rechercher.
Retourne :
bool : True si le sommet est trouvé, False sinon.
"""
if est_vide(liste):
return False
elif tete(liste).nom == nom:
return True
else:
return rechercher(queue(liste), nom)
# 5. Fonction modifier_altitude (récursive)
def modifier_altitude(liste, nom, nouvelle_altitude):
"""
Modifie l'altitude d'un sommet dans la liste.
Paramètres :
liste : Une liste simplement chaînée.
nom (str) : Le nom du sommet à modifier.
nouvelle_altitude (int) : La nouvelle altitude du sommet.
"""
if not est_vide(liste):
sommet = tete(liste)
if sommet.nom == nom:
sommet.altitude = nouvelle_altitude
modifier_altitude(queue(liste), nom, nouvelle_altitude)
# 6. Fonction supprimer_sommet (récursive)
def supprimer_sommet(liste, nom):
"""
Supprime la première occurrence du sommet de nom donné dans la liste.
Paramètres :
liste : Une liste simplement chaînée.
nom (str) : Le nom du sommet à supprimer.
Retourne :
Une liste simplement chaînée avec la première occurrence du sommet supprimée.
"""
if est_vide(liste):
return liste
elif tete(liste).nom == nom:
return queue(liste)
else:
return ajouter_en_tete(supprimer_sommet(queue(liste), nom), tete(liste))
# 7. Fonction supprimer_sommets (récursive)
def supprimer_sommets(liste, nom):
"""
Supprime toutes les occurrences du sommet de nom donné dans la liste.
Paramètres :
liste : Une liste simplement chaînée.
nom (str) : Le nom du sommet à supprimer.
Retourne :
Une liste simplement chaînée avec toutes les occurrences du sommet supprimées.
"""
if est_vide(liste):
return liste
elif tete(liste).nom == nom:
return supprimer_sommets(queue(liste), nom)
else:
return ajouter_en_tete(supprimer_sommets(queue(liste), nom), tete(liste))
# 8. Fonction longueur (récursive)
def longueur(liste):
"""
Renvoie le nombre d'éléments de la liste simplement chaînée.
Paramètres :
liste : Une liste simplement chaînée.
Retourne :
int : Le nombre d'éléments dans la liste.
"""
if est_vide(liste):
return 0
else:
return 1 + longueur(queue(liste))
# 9. Fonction inserer (récursive)
def inserer(liste, element, rang):
"""
Insère un élément à un rang donné dans la liste.
Paramètres :
liste : Une liste simplement chaînée.
element : L'élément à insérer.
rang (int) : Le rang auquel insérer l'élément.
Retourne :
Une liste simplement chaînée avec l'élément inséré.
"""
if rang == 0:
return ajouter_en_tete(liste, element)
else:
return ajouter_en_tete(inserer(queue(liste), element, rang - 1), tete(liste))
# 10. Fonction supprimer (récursive)
def supprimer(liste, rang):
"""
Supprime un élément à un rang donné dans la liste.
Paramètres :
liste : Une liste simplement chaînée.
rang (int) : Le rang de l'élément à supprimer.
Retourne :
Une liste simplement chaînée avec l'élément supprimé.
"""
if rang == 0:
return queue(liste)
else:
return ajouter_en_tete(supprimer(queue(liste), rang - 1), tete(liste))
# 11. Fonction modifier (récursive)
def modifier(liste, rang, element):
"""
Modifie un élément à un rang donné dans la liste.
Paramètres :
liste : Une liste simplement chaînée.
rang (int) : Le rang de l'élément à modifier.
element : Le nouvel élément à insérer à ce rang.
Retourne :
Une liste simplement chaînée avec l'élément modifié.
"""
if rang == 0:
return ajouter_en_tete(queue(liste), element)
else:
return ajouter_en_tete(modifier(queue(liste), rang - 1, element), tete(liste))
# 12. Fonction rechercher_par_rang (récursive)
def rechercher_par_rang(liste, element):
"""
Recherche l'élément dans la liste et retourne son rang.
Paramètres :
liste : Une liste simplement chaînée.
element : L'élément à rechercher.
Retourne :
int : Le rang de l'élément ou -1 s'il n'est pas trouvé.
"""
def rechercher_recursif(liste, element, rang):
if est_vide(liste):
return -1
elif tete(liste) == element:
return rang
else:
return rechercher_recursif(queue(liste), element, rang + 1)
return rechercher_recursif(liste, element, 0)
# 13. Fonction lire (récursive)
def lire(liste, rang):
"""
Renvoie l'élément à un rang donné dans la liste.
Paramètres :
liste : Une liste simplement chaînée.
rang (int) : Le rang de l'élément à lire.
Retourne :
L'élément à ce rang.
"""
if rang == 0:
return tete(liste)
else:
return lire(queue(liste), rang - 1)
# 14. Fonction trier (récursive)
def trier(liste, ordre=lambda x, y: x < y):
"""
Trie la liste dans un ordre donné.
Paramètres :
liste : Une liste simplement chaînée.
ordre : Une fonction de comparaison, par défaut x < y.
Retourne :
Une liste simplement chaînée triée.
"""
if est_vide(liste):
return liste
else:
pivot = tete(liste)
sous_liste = queue(liste)
# Séparer en deux listes
inferieurs = creer_liste_vide()
superieurs = creer_liste_vide()
while not est_vide(sous_liste):
elt = tete(sous_liste)
if ordre(elt, pivot):
inferieurs = ajouter_en_tete(inferieurs, elt)
else:
superieurs = ajouter_en_tete(superieurs, elt)
sous_liste = queue(sous_liste)
# Trier les sous-listes
inferieurs = trier(inferieurs, ordre)
superieurs = trier(superieurs, ordre)
# Ajouter le pivot au résultat
return ajouter_en_tete(superieurs, pivot)

86
tp_listes_chaines/fichiers/TP5_1.py Normal file
View File

@@ -0,0 +1,86 @@
from Sommets import Sommet
from LSC import creer_liste_vide, ajouter_en_tete, afficher_liste
def csv2liste(fichier_csv):
"""
Lit un fichier CSV et retourne une liste simplement chaînée des sommets.
Paramètres :
fichier_csv (str) : Le chemin vers le fichier CSV à lire.
Retourne :
Une liste simplement chaînée contenant les sommets.
"""
liste_sommets = creer_liste_vide()
with open(fichier_csv, 'r') as fichier:
for ligne in fichier:
nom, altitude = ligne.strip().split(',')
sommet = Sommet(nom, int(altitude), 'Chartreuse') # Modifier selon le massif si nécessaire
liste_sommets = ajouter_en_tete(liste_sommets, sommet)
return liste_sommets
# Test
liste_sommets = csv2liste('Chartreuse.csv')
afficher_liste(liste_sommets)
from LSC import est_vide, tete, queue, ajouter_en_tete
def copier_liste(liste):
"""
Copie une liste simplement chaînée.
Paramètres :
liste : Une liste simplement chaînée.
Retourne :
Une copie de la liste.
"""
if est_vide(liste):
return creer_liste_vide()
else:
return ajouter_en_tete(copier_liste(queue(liste)), tete(liste))
# Test
copie = copier_liste(liste_sommets)
afficher_liste(copie)
def rechercher(liste, nom):
"""
Recherche un sommet dans la liste par son nom.
Paramètres :
liste : Une liste simplement chaînée.
nom (str) : Le nom du sommet à rechercher.
Retourne :
bool : True si le sommet est trouvé, False sinon.
"""
reste = liste
while not est_vide(reste):
sommet = tete(reste)
if sommet.nom == nom:
return True
reste = queue(reste)
return False
# Test
print(rechercher(liste_sommets, "Chamechaude"))
def modifier_altitude(liste, nom, nouvelle_altitude):
"""
Modifie l'altitude d'un sommet dans la liste.
Paramètres :
liste : Une liste simplement chaînée.
nom (str) : Le nom du sommet à modifier.
nouvelle_altitude (int) : La nouvelle altitude du sommet.
"""
reste = liste
while not est_vide(reste):
sommet = tete(reste)
if sommet.nom == nom:
sommet.altitude = nouvelle_altitude
break
reste = queue(reste)
# Test
modifier_altitude(liste_sommets, "Chamechaude", 2082)
afficher_liste(liste_sommets)

0
tp_listes_chaines/fichiers/factorial.py Normal file
View File

22
tp_listes_chaines/fichiers/test.py Normal file
View File

@@ -0,0 +1,22 @@
import LSC as lc
import csv
import Sommets as sm
liste = lc.creer_liste_vide()
with open("Chartreuse.csv", mode="r",encoding='utf-8') as f:
lecteur_csv = csv.reader(f)
for ligne in lecteur_csv:
nom = ligne[0].strip()
altitude_str = ligne[1].strip()
altitude = int(altitude_str.replace('m', '').replace(' ', ''))
sommet = sm.Sommet(nom, altitude, "Chartreuse")
liste = lc.ajouter_en_tete(liste, sommet)
lecteur_csv = csv.reader(f)
for ligne in lecteur_csv:
nom = ligne[0].strip()
altitude_str = ligne[1].strip()
altitude = int(altitude_str.replace('m', '').replace(' ', ''))
sommet = sm.Sommet(nom, altitude, "Chartreuse")
liste = lc.ajouter_en_tete(liste, sommet)
lc.afficher_liste(liste.queue())
liste1 = liste.tete()
print(liste1[0])