Author: Thomas Q.

Projets

NsCinéma – La base de données

Trouver le film idéal à regarder ? C’est ce que vous proposera cette base de donnée de films utilisant tkinter.
Cette collection comportant des films de tout genre regroupe de nombreux films en les notant, très pratique pour dénicher les meilleurs films.

Le thème

Nous avons choisi le cinéma comme thème pour notre base de données car nous avons tous les deux cette passion en commun. En effet, en plus du fait que nous aimons le cinéma, l’idée de choisir des films pour constituer notre base de données semble correspondre aux consignes et nous a assez vite donné des idées de fonctionnalités, notamment avec les filtres de recherche que nous avons mis en place.

Le code

Tout d’abord nous avons importé toutes les bibliothèques nécessaires au bon fonctionnement de la base de donnée.

from tkinter import *
import tkinter as tk
import sqlite3
from tkinter import messagebox

Ici Tkinter va permettre d’avoir un rendu graphique de la base de données, le tutoriel présent sur le site nsi.xyz nous a fortement aidé (tutoriel).

Enfin Sqlite3 permet de nous connecter a la base de donné (DBbrowser)

Page d’accueil

Pour la page d’accueil, nous avons donc décidé de rester simple. En effet, sur cette page, on y trouve le nom de notre projet, « NsCinéma ». Ensuite, il y a deux boutons : tout d’abord, un bouton qui permet de consulter la base de données sans la modifier, avec un système de filtres et de défilement. Ensuite, un deuxième bouton permet de modifier la base de données, ce qui inclut la création d’une table Film, la suppression de la table, l’ajout de films, ainsi que la possibilité de modifier un film en cas d’erreur lors de l’ajout.

Ainsi, afin que les boutons puissent fonctionner correctement avec l’ouverture d’une nouvelle page, il était nécessaire d’implémenter une fonction permettant de créer la page « Modifier la base de donnée »

Fonction create permettant d’acceder a la page modifier la base de donnée :

def create():
    glodef create():
    global nouvelle_fenetre
    nouvelle_fenetre = tk.Toplevel(screen)
    nouvelle_fenetre.geometry("1080x720")
    nouvelle_fenetre.config(bg="#0e101c")
    
    connection = sqlite3.connect('base_films.db')
    curseur = connection.cursor()
    
    def retour():
        nouvelle_fenetre.destroy()

    #titre
    titre = Label(nouvelle_fenetre, text="Mise a jour de la base de donnée", font=("Consolas",40) ,bg="#0e101c", fg="#b3b3b3")
    titre.pack(pady=50)
    
    #creer la table 
    bouton_creer_table = Button(nouvelle_fenetre, text="Créer Table Film", font=("Consolas",13), bg="#1d1e2e", fg="white", command=create_table, width=60, height=3)
    bouton_creer_table.place(x=250, y=300)

    #Bouton supprimer 
    bouton_supprimer_table = Button(nouvelle_fenetre, text="Supprimer Table Film", font=("Consolas",13), bg="#1d1e2e", fg="white", command=supprimer_table, width=60, height=3)
    bouton_supprimer_table.place(x=250, y=400)

    #bouton ajouter
    bouton_ajouter_film = Button(nouvelle_fenetre, text="Ajouter un film", font=("Consolas",13), bg="#1d1e2e", fg="white", command=page_ajouter_film, width=60, height=3)
    bouton_ajouter_film.place(x=250, y=500)
    
    #bouton modifier
    bouton_ajouter_film = Button(nouvelle_fenetre, text="Modifier la table", font=("Consolas",13), bg="#1d1e2e", fg="white", command=update, width=60, height=3)
    bouton_ajouter_film.place(x=250, y=600)
    
    bouton_retour = Button(nouvelle_fenetre, text="Retour", font=("Consolas",13), bg="#1d1e2e", fg="white", command=retour, width=20, height=2)
    bouton_retour.place(x=850, y=650)
    
    
    
    connection.commit()
    curseur.close()
    connection.close()

Dans cette fonction, nous pouvons observer la présence de la fonction ‘retour’ permettant de revenir en arrière en supprimant la page actuelle.

Bouton : 

bouton1 = Button(screen, text="Consulter la base de donnée ", font=("Consolas",13), bg="#272936", fg="white", command= create, width=60, height=3)
bouton1.place(x=250, y=300)

bouton2 = Button(screen, text="Mettre a jour la base de donnée ", font=("Consolas",13), bg="#272936", fg="white", command= create, width=60, height=3)
bouton2.place(x=250, y =400)

Consultation de la base de donnée

Passons maintenons au code permettant de consulter cette base donnée. On créée donc une nouvelle fenêtre constituée de deux parties : une pour appliquer des filtres sur les films et une pour voir les films.

Comme on peut le constater dans le screen ci-dessous.

Vous constatez donc une boîte où l’on peut consulter les films de la base, et au-dessus de celle-ci, un bloc comportant un menu déroulant pour les filtres.

On pourra noter l’utilisation d’un bouton retour pour revenir à la page d’accueil et d’un bouton actualise qui nous servira plus tard pour ajouter/supprimer des films.

Passons plus en détail le code.

nouvelle_fenetre = tk.Tk()
    nouvelle_fenetre.title("NsCinema")
    nouvelle_fenetre.geometry("1080x720")
    nouvelle_fenetre.config(bg="#0e101c")

main_frame = Frame(nouvelle_fenetre, bg="#0e101c")
main_frame.place(x=80, y=300, width=920, height=420)

canvas = Canvas(main_frame, bg="#0e101c")
canvas.pack(side=LEFT, fill=BOTH, expand=YES)

scrollbar = Scrollbar(main_frame, command=canvas.yview)
scrollbar.pack(side=RIGHT, fill=Y)

canvas.configure(yscrollcommand=scrollbar.set)

boitefilm = Frame(canvas, bg="#1d1e2e")
canvas.create_window((0, 0), window=boitefilm, anchor='nw')
    
bouton_retour = Button(nouvelle_fenetre, text="Retour", font=("Consolas",13), bg="#1d1e2e", fg="white", command=retour, width=20, height=2)
bouton_retour.place(x=80, y=120)
    
bouton_actualise = Button(nouvelle_fenetre, text="Actualise", font=("Consolas",13), bg="#1d1e2e", fg="white", command=actualise, width=20, height=2)
bouton_actualise.place(x=800, y=120)

boitefilm correspond à la fenêtre (c’est une frame) où l’on, comme on l’à déjà dit, consulte les films. Elle est dans un canevas (ici canvas) qui lui va regrouper tous les éléments graphiques dont boitefilm et notamment la scrollbar qui va permettre de défiler l’axe des ordonnées de canvas : command=canvas.yview.

def etoile(n):
        c = n
        note = ""
        while c != 0:
            note += "★"
            c -= 1
            
        while (5-n) != 0:
            note += "☆"
            n += 1
        return note

    def titre():
        t_nom = Label(boitefilm, text="Nom", font=("Consolas", 14), bg="#1d1e2e", fg="black")
        t_genre = Label(boitefilm, text="Genre", font=("Consolas", 14), bg="#1d1e2e", fg="black")
        t_realisateur = Label(boitefilm, text="Réalisateur", font=("Consolas", 14), bg="#1d1e2e", fg="black")
        t_annee_pub = Label(boitefilm, text="Année", font=("Consolas", 14), bg="#1d1e2e", fg="black")
        t_note = Label(boitefilm, text="Note", font=("Consolas", 13), bg="#1d1e2e", fg="black")

        t_nom.grid(row=0, column=0, sticky=W, pady=21, padx=20)
        t_genre.grid(row=0, column=1, sticky=W, pady=21, padx=5)
        t_realisateur.grid(row=0, column=2, sticky=W, pady=21, padx=5)
        t_annee_pub.grid(row=0, column=3, sticky=W, pady=21, padx=10)
        t_note.grid(row=0, column=4, sticky=W, pady=21, padx=12)
    
            
    def note(n):
        connection = sqlite3.connect('base_films.db')
        curseur = connection.cursor()

        curseur.execute("SELECT * FROM Film WHERE note=?", (n,))
        films = curseur.fetchall()

        connection.commit()
        curseur.close()
        connection.close()

        return films

Ici nous avons trois fonctions qui ont des tâches spécifiques :

  • etoile(n) : c’est une fonction qui va retourner, en fonction du paramètre n, une chaîne de caractère avec n étoiles « ★ » et (5-n) étoiles « ☆ ». Ce qui nous donnes au final un note sur 5 représentée avec des étoiles.
  • titre() : cette fonction va tout simplement permettre l’affichage des titres (avec l’objet Label de tkinter qui permet d’afficher du texte) à la première ligne de la grille avec le paramètre row=0.
  • note() : C’est une fonction qui se connecte à une notre de données contenant les informations sur les films. Elle récupère tous les films ayant une note égale à n et les renvoie. Ici, films = curseur.fetchall() permet de récupérer dans la variable films la requête SQL.

Passons maitenant à la fonction la plus importante de cette partie : ajoute_film()

    
    def ajoute_film(nom, genre, realisateur, annee_pub, note):
        global row_compteur
        connection = sqlite3.connect('base_films.db')
        curseur = connection.cursor()

        truc = (nom, genre, realisateur, annee_pub, note)
        curseur.execute('''CREATE TABLE IF NOT EXISTS Film (
                        id_film INTEGER PRIMARY KEY AUTOINCREMENT,
                        nom TEXT,
                        genre TEXT,
                        realisateur TEXT,
                        annee_pub INTEGER,
                        note REAL
                    )''')
        

        curseur.execute("INSERT INTO Film (nom, genre, realisateur, annee_pub, note) VALUES (?,?,?,?,?)", truc)
        
        

        connection.commit()
        curseur.close()
        connection.close()

        b_nom = Label(boitefilm, text="%s" %(nom), font=("Consolas", 14), bg="#1d1e2e", fg="white")
        b_genre = Label(boitefilm, text="%s" %(genre), font=("Consolas", 14), bg="#1d1e2e", fg="white")
        b_realisateur = Label(boitefilm, text="%s" %(realisateur), font=("Consolas", 14), bg="#1d1e2e", fg="white")
        b_annee_pub = Label(boitefilm, text="%s" %(annee_pub), font=("Consolas", 14), bg="#1d1e2e", fg="white")
        b_note = Label(boitefilm, text="%s" %(etoile(note)), font=("Consolas", 13), bg="#1d1e2e", fg="white")

        b_nom.grid(row=row_compteur, column=0, sticky=W, pady=21, padx=30)
        b_genre.grid(row=row_compteur, column=1, sticky=W, pady=21, padx=15)
        b_realisateur.grid(row=row_compteur, column=2, sticky=W, pady=21, padx=10)
        b_annee_pub.grid(row=row_compteur, column=3, sticky=W, pady=21, padx=10)
        b_note.grid(row=row_compteur, column=4, sticky=W, pady=21, padx=20)
		
        row_compteur += 1


Cette fonction, ajoute_film, ajoute les informations d’un film (nom, genre, réalisateur, année de publication, note) à une base de données SQLite. Elle crée également des objets Label pour afficher ces informations dans une grille, en utilisant la variable row_compteur (c’est une globale) pour déterminer la ligne à laquelle il faut placer ces dernières.

En somme, tel un plat de lasagnes, on ajoute les films ligne après ligne.

Nous utilisons donc cette fonction pour construire notre base de données à l’aide du bout de code suivant et d’une bonne veille boucle for i in range() : 

data = [
        ("American Sniper", "Biopic", "Clint Eastwood", 2015, 4),
        ("The Fabel Man", "Biopic", "Steven Spielberg", 2022, 3),
        ("Truman Show", "Science-Fiction", "Peter Weir", 1998, 4),
        ("Prisoners", "Drame", "Denis Villeneuve", 2013, 4),
        ("Very Bad Trip 1", "Comédie", "Todd Phillips", 2009, 3),
        ("Very Bad Trip 2", "Comédie", "Todd Phillips", 2011, 3),
        ("Very Bad Trip 3", "Comédie", "Todd Phillips", 2013, 2),
        ("Ocean Eleven", "Action", "Steven Soderbergh", 2001, 3),
        ("Ocean Twelve", "Action", "Steven Soderbergh", 2004, 2),
        ("Ocean Thirteen", "Action", "Steven Soderbergh", 2007, 3),
        ("La La Land", "Drame", "Damien Chazelle", 2016, 4),
        ("Fury", "Action", "David Ayer", 2014, 3),
        ("Voyage de Chihiro", "Animation", "Hayao Miyazaki", 2001, 5),
        ("Le Château Ambulant", "Animation", "Hayao Miyazaki", 2004, 4),
        ("Goodfellas", "Drame", "Martin Scorsese", 1990, 3),
        ("A Man Called Otto", "Drame", "Marc Forster", 2022, 3),
        ("Elvis", "Biopic", "John Carpenter", 1979, 3),
        ("127 Hours", "Biopic", "Danny Boyle", 2010, 3),
        ("Ad Astra", "Science-Fiction", "James Gray", 2019, 3),
        ("Life: Origine Inconnue", "Science-Fiction", "Daniel Espinosa", 2017, 3),
        ("The Hobbit 1", "Action", "Peter Jackson", 2012, 4),
        ("The Hobbit 2", "Action", "Peter Jackson", 2013, 4),
        ("The Hobbit 3", "Action", "Peter Jackson", 2014, 4),
        ("The Lord of the Rings 1", "Action", "Peter Jackson", 2001, 4),
        ("The Lord of the Rings 2", "Action", "Peter Jackson", 2002, 4),
        ("The Lord of the Rings 3", "Action", "Peter Jackson", 2003, 5),
        ("The Imitation Game", "Biopic", "Morten Tyldum", 2014, 3),
        ("Seul au monde", "Drame", "Robert Zemeckis", 2000, 4),
        ("Nightcrawler", "Thriller", "Dan Gilroy", 2014, 4),
        ("Marriage Story", "Drame", "Noah Baumbach", 2019, 3),
        ("First Man", "Biopic", "Damien Chazelle", 2018, 3),
        ("L'Intervention", "Action", "Fred Grivois", 2019, 4),
        ("Stand by Me", "Drame", "Rob Reiner", 1986, 4),
        ("Middle Men", "Drame", "George Gallo", 2009, 3),
        ("Happiness Therapy", "Comédie", "David O. Russell", 2012, 4),
        ("The Interview", "Comédie", "Seth Rogen", 2014, 1),
        ("Joy", "Drame", "David O. Russell", 2015, 3),
        ("The Silence of the Lambs", "Thriller", "Jonathan Demme", 1991, 5),
        ("Dune : Partie 2", "Science-Fiction", "Denis Villeneuve", 2024, 4),
        ("Man on Fire", "Action", "Tony Scott", 2004, 3),
        ("Dead Poets Society", "Drame", "Peter Weir", 1989, 5),
        ("Batman & Robin", "Action", "Joel Schumacher", 1997, 2),
        ("Catwoman", "Action", "Pitof", 2004, 1),
        ("Battlefield Earth", "Science-Fiction", "Roger Christian", 2000, 1),
        ("Gigli", "Comédie", "Martin Brest", 2003, 1),
        ("The Love Guru", "Comédie", "Marco Schnabel", 2008, 2),
        ("Movie 43", "Comédie", "Various", 2013, 1),
        ("Birdemic: Shock and Terror", "Thriller", "James Nguyen", 2010, 1),
        ("The Happening", "Thriller", "Night Shyamalan", 2008, 2),
        ("The Room", "Drame", "Tommy Wiseau", 2003, 1),
        ("Troll 2", "Comédie", "Claudio Fragasso", 1990, 2),
        ("Manos: The Hands of Fate", "Thriller", "Harold P. Warren", 1966, 1)]
        
        for m in range(len(data)):
                ajoute_film(data[m][0], data[m][1], data[m][2], data[m][3], data[m][4])

Passons à l’explication du menu déroulant comportant les filtres.

On constate qu’il y a deux filtres : un par genre et un par note.

Cela est possible grâce au bout de code suivant : 

boitefiltre = Frame(nouvelle_fenetre, bg="#1d1e2e")
boitefiltre.place(x=80, y=200, width=920, height=63)

m_genre= Menubutton(boitefiltre, text="Genre", relief="raised", borderwidth=2, width=75)
m_genre.grid(row=1, column=0, sticky="s")

m_note = Menubutton(boitefiltre, text="Note", relief="raised", borderwidth=2, width=75)
m_note.grid(row=1, column=1, sticky="s")

boitefiltre.grid_rowconfigure(0, weight=1)

m_filtre = Label(boitefiltre, text="Appliquer des filtres de recherche", font=("Consolas",20), bg="#1d1e2e", fg="white")
m_filtre.grid(row=0, column=0, sticky="s", columnspan=5)

menuDeroulant1 = Menu(m_genre)
menuDeroulant1.add_command(label='Action', command=lambda: filtrer_par_genre('Action'))
menuDeroulant1.add_command(label="Science-Fiction", command=lambda: filtrer_par_genre('Science fiction'))
menuDeroulant1.add_command(label="Biopic", command=lambda: filtrer_par_genre('Biopic'))
menuDeroulant1.add_command(label="Drame", command=lambda: filtrer_par_genre('Drame'))
menuDeroulant1.add_command(label="Thriller", command=lambda: filtrer_par_genre('Thriller'))
menuDeroulant1.add_command(label="Comédie", command=lambda: filtrer_par_genre('Comédie'))
m_genre.configure(menu=menuDeroulant1)

menuDeroulant2 = Menu(m_note)
menuDeroulant2.add_command(label='★☆☆☆☆', command=lambda: filtrer_par_note(1))
menuDeroulant2.add_command(label="★★☆☆☆", command=lambda: filtrer_par_note(2))
menuDeroulant2.add_command(label="★★★☆☆", command=lambda: filtrer_par_note(3))
menuDeroulant2.add_command(label="★★★★☆", command=lambda: filtrer_par_note(4))
menuDeroulant2.add_command(label="★★★★★", command=lambda: filtrer_par_note(5))

Ce bout de code créée une boîte de filtres comprenant deux menus déroulants (m_genre et m_note). Ces menus permettent de sélectionner des options de filtrage par genre de film et par note. La boîte de filtres contient également un label (m_filtre) indiquant à quoi elle sert, pour faciliter la compréhension de l’utilisateur.

Les menus déroulants sont associés à des commandes qui déclenchent des fonctions (filtrer_par_genre et filtrer_par_note) et en fonction des sélections de l’utilisateur, cela applique les filtres de recherche pour afficher les films voulues.

Modification de la base de donnée

Sur cette page nous pouvons retrouver les 5 boutons principaux :

  • Créer la table film
  • Supprimer la table film
  • Ajouter un film a la table
  • modifier la table film
  • supprimer un film

Fonction Création Table 

def create_table():
    connection = sqlite3.connect('base_films.db')
    curseur = connection.cursor()
    
    curseur.execute('''CREATE TABLE IF NOT EXISTS Film (
                        id_film INTEGER PRIMARY KEY AUTOINCREMENT,
                        nom TEXT,
                        genre TEXT,
                        realisateur TEXT,
                        annee_pub INTEGER,
                        note REAL
                    )''')
     messagebox.showinfo("Creation Table", "La table a été crée.")
    
    connection.commit()
    curseur.close()
    connection.close()

Cette fonction create_table permet de créer une table dans une base de données SQLite nommée 'base_films.db‘. Elle établit une connexion avec la base de donnée 'base_films.db‘ , permettant d’accéder à la base de donnée et d’y effectuer des operations, ajouter, supprimer, mettre à jour… Ainsi la requête SQL permet de creer la table Film avec les attributs suivants : id_film, nom, genre, realisateur, annee_pub, note)

De plus un message est affiché lorsque la table est crée.

Fonction Supprimer Table 

def supprimer_table():
    connection = sqlite3.connect('base_films.db')
    curseur = connection.cursor()
    
    curseur.execute("DROP TABLE IF EXISTS Film")
    messagebox.showinfo("Suppression effectuee", "La table a été supprimée.")
   
    connection.commit()
    curseur.close()
    connection.close()

Cette fonction supprimer_table permet de supprimer la table crée précédemment.

Fonction ajouter un film

Lorsque l’on souhaite ajouter un film, une nouvelle page s’ouvre.

La fonction permettant d’ouvrir cette page : 

def page_ajouter_film():
    global variable, variable1, variable2, variable3, variable4  
    nouvelle_fenetre = tk.Toplevel(screen)
    nouvelle_fenetre.geometry("1080x720")
    nouvelle_fenetre.config(bg="#0e101c")
    def retour():
        nouvelle_fenetre.destroy()

    titre = Label(nouvelle_fenetre, text="Ajouter un film", font=("Consolas",40) ,bg="#0e101c", fg="#b3b3b3")
    titre.pack(pady=50)


    variable = tk.StringVar()
    variable.set("Nom du film")
    entree = Entry(nouvelle_fenetre, textvariable=variable, font=("Helvetica",15), bg="#1d1e2e", fg="#b3b3b3", width=30)
    entree.pack(padx=10, pady=10)


    variable1 = tk.StringVar()
    variable1.set("Genre du Film")
    entree1 = Entry(nouvelle_fenetre, textvariable=variable1, font=("Helvetica",15), bg="#1d1e2e", fg="#b3b3b3", width=30)
    entree1.pack(padx=10, pady=10)

    
    variable2 = tk.StringVar()
    variable2.set("Realisateur")
    entree2 = Entry(nouvelle_fenetre, textvariable=variable2, font=("Helvetica",15), bg="#1d1e2e", fg="#b3b3b3", width=30)
    entree2.pack(padx=10, pady=10)

 
    variable3 = tk.StringVar()
    variable3.set("Annee de publication")
    entree3 = Entry(nouvelle_fenetre, textvariable=variable3, font=("Helvetica",15), bg="#1d1e2e", fg="#b3b3b3", width=30)
    entree3.pack(padx=10, pady=10)

     
    variable4 = tk.StringVar()
    variable4.set("Note")
    entree4 = Entry(nouvelle_fenetre, textvariable=variable4, font=("Helvetica",15), bg="#1d1e2e", fg="#b3b3b3", width=30)
    entree4.pack(padx=10, pady=10)

   
    bouton_ajouter_film = Button(nouvelle_fenetre, text="Ajouter le film", font=("Consolas",13), bg="#1d1e2e", fg="white", command=ajouter_film, width=20, height=2)
    bouton_ajouter_film.pack(pady=20)
    
    bouton_retour = Button(nouvelle_fenetre, text="Retour", font=("Consolas",13), bg="#1d1e2e", fg="white", command=retour, width=20, height=2)
    bouton_retour.place(x=850, y=650)

Ainsi cette fonction permet d’avoir un rendu graphique explicite pour l’utilisateur. En effet cette page est composé de 5 encadrés remplie d’un champ permettant de faire savoir a l’utilisateur ou rentrer le titre du film… Le bouton ajouter film permet d’ajouter le film a la base de donnée

Afin que cette page puisse fonctionner correctement il est imperatif d’avoir une fonction executant le code SQL qui va avec.

Code permettant l’ajout du film : 

def ajouter_film():
    
    global variable, variable1, variable2, variable3, variable4, data  
    nom_film = variable.get()
    genre = variable1.get()
    realisateur = variable2.get()
    annee_pub = variable3.get()
    note = variable4.get()

    connection = sqlite3.connect('base_films.db')
    curseur = connection.cursor()

    curseur.execute('''INSERT INTO Film (nom, genre, realisateur, annee_pub, note)
                        VALUES (?, ?, ?, ?, ?)''', (nom_film, genre, realisateur, annee_pub, note))

    connection.commit()
    curseur.close()
    connection.close() 

    messagebox.showinfo("Film ajoute", "Le film a ete ajoute avec succes.")

Cette fonction ajouter un film dans la base de données SQLite et informe l’utilisateur que le film a été ajouté . En effet la ligne 13 exécute une commande SQL qui insere le film dans la base de données. Les “?” sont des paramètres qui sont remplacés par les valeurs des variables spécifiées.

Fonction modifier la table

Lorsque l’on souhaite modifier la table, une nouvelle page s’ouvre.

Fonction permettant d’ouvrir la page de modification:

def update():
    global variable, variable1, variable2, variable3, variable4 
    nouvelle_fenetre = tk.Toplevel(screen)
    nouvelle_fenetre.geometry("1080x720")
    nouvelle_fenetre.config(bg="#0e101c")
    nouvelle_fenetre.title("Modifier un film")

    def retour():
        nouvelle_fenetre.destroy()

    titre = Label(nouvelle_fenetre, text="Modifier un film", font=("Consolas",40) ,bg="#0e101c", fg="#b3b3b3")
    titre.pack(pady=50)

    variable = tk.StringVar()
    variable.set("Nom du film")
    entree = Entry(nouvelle_fenetre, textvariable=variable, font=("Helvetica",15), bg="#1d1e2e", fg="#b3b3b3", width=30)
    entree.pack(padx=10, pady=10)

    variable1 = tk.StringVar()
    variable1.set("Genre du Film")
    entree1 = Entry(nouvelle_fenetre, textvariable=variable1, font=("Helvetica",15), bg="#1d1e2e", fg="#b3b3b3", width=30)
    entree1.pack(padx=10, pady=10)

    variable2 = tk.StringVar()
    variable2.set("Realisateur")
    entree2 = Entry(nouvelle_fenetre, textvariable=variable2, font=("Helvetica",15), bg="#1d1e2e", fg="#b3b3b3", width=30)
    entree2.pack(padx=10, pady=10)

    variable3 = tk.StringVar()
    variable3.set("Annee de publication")
    entree3 = Entry(nouvelle_fenetre, textvariable=variable3, font=("Helvetica",15), bg="#1d1e2e", fg="#b3b3b3", width=30)
    entree3.pack(padx=10, pady=10)

    variable4 = tk.StringVar()
    variable4.set("Note")
    entree4 = Entry(nouvelle_fenetre, textvariable=variable4, font=("Helvetica",15), bg="#1d1e2e", fg="#b3b3b3", width=30)
    entree4.pack(padx=10, pady=10)

    bouton_update_film = Button(nouvelle_fenetre, text="Mettre a jour le film", font=("Consolas",13), bg="#1d1e2e", fg="white", command=update_film, width=20, height=2)
    bouton_update_film.pack(pady=20)

    bouton_retour = Button(nouvelle_fenetre, text="Retour", font=("Consolas",13), bg="#1d1e2e", fg="white", command=retour, width=20, height=2)
    bouton_retour.place(x=850, y=650)

Ce code est semblable a celui de la creation de la page ajouter_film puisque on y retrouve les champs ou l’on doit inserer les informations necessaire.

Comme la page precedente afin que celle ci puisse fonctionner correctement il est imperatif d’avoir une fonction executant le code SQL qui va avec.

def update_film():
    nom_film = variable.get()
    genre = variable1.get()
    realisateur = variable2.get()
    annee_pub = variable3.get()
    note = variable4.get()

    connection = sqlite3.connect('base_films.db')
    curseur = connection.cursor()

    curseur.execute('''UPDATE Film SET genre=?, realisateur=?, annee_pub=?, note=? WHERE nom=?''', (genre, realisateur, annee_pub, note, nom_film))

    connection.commit()
    curseur.close()
    connection.close()

    messagebox.showinfo("Film modifié", "Le film a été modifié.")

Cette fonction met à jour les informations d’un film spécifique dans une base de données SQLite en utilisant le nom du film comme clé, et informe l’utilisateur que le film a été modifié.

Fonction Supprimer un film

Fonction permettant d’afficher cette page : 

def page_supprimer_film():
    global variable_title
    nouvelle_fenetre = tk.Toplevel(screen)
    nouvelle_fenetre.geometry("1080x720")
    nouvelle_fenetre.config(bg="#0e101c")

    def retour():
        nouvelle_fenetre.destroy()

    titre = Label(nouvelle_fenetre, text="Supprimer un film", font=("Consolas", 40), bg="#0e101c", fg="#b3b3b3")
    titre.pack(pady=50)

    variable_title = tk.StringVar()
    variable_title.set("Titre du film à supprimer")
    entree_title = Entry(nouvelle_fenetre, textvariable=variable_title, font=("Helvetica", 15), bg="#1d1e2e", fg="#b3b3b3", width=30)
    entree_title.pack(padx=10, pady=10)

    bouton_supprimer_film = Button(nouvelle_fenetre, text="Supprimer le film", font=("Consolas", 13), bg="#1d1e2e", fg="white", command=supprimer_titre, width=20, height=2)
    bouton_supprimer_film.pack(pady=20)

    bouton_retour = Button(nouvelle_fenetre, text="Retour", font=("Consolas",13), bg="#1d1e2e", fg="white", command=retour, width=20, height=2)
    bouton_retour.place(x=850, y=650)

Fonction permettant de faire marcher la page : 

def supprimer_titre():
    title = variable_title.get()

    connection = sqlite3.connect('base_films.db')
    cursor = connection.cursor()

    cursor.execute("SELECT id_film FROM Film WHERE nom=?", (title,))
    result = cursor.fetchone()

    if result:
        film_id = result[0]

        cursor.execute("DELETE FROM Film WHERE id_film=?", (film_id,))
        messagebox.showinfo("Film supprimé", "Le film a été supprimé avec succès.")
    else:
        messagebox.showwarning("Film introuvable", "Aucun film trouvé avec ce titre.")

    connection.commit()
    cursor.close()
    connection.close()

Cette fonction supprime un film spécifique de la base de données SQLite en utilisant le titre du film comme clé, et informe l’utilisateur que le film a été supprimé ou qu’aucun film n’a été trouvé avec le titre donné.

Bouton Retour

En effet, a la fin du projet nous avons constater que il manquait un bouton afin de revenir en arrière. Sans bouton l’utilisateur est obligé de fermer la fenêtre par la croix.

Ainsi la fonction suivante permet de fermer la page actuelle afin de revenir sur la page précédente.

def retour():
        nouvelle_fenetre.destroy()

Télécharger le projet

Vous trouverez ici le .zip du projet que vous puissiez le télécharger. PS : si vous relancer le script, il vaut mieux recréer la base de donnée à l’aide de DB Browser.

En espérant que vous trouverez un bon film.

projet-base-filmsTélécharger
Tutoriels

Extensions utiles pour l’utilisation de chrome

  • par

De nombreuses extensions peuvent nous faciliter la vie, mais on ne les connait pas forcément. Ce tutoriel propose donc des extensions qui vous seront utiles dans diverses tâches comme par exemple le travail tout en vous expliquant comment les installer et comment les utiliser à bon escient.

Pourquoi utiliser des extensions ?

Il y a plusieurs raisons d’utiliser des extensions:

  1. Améliorer son écriture: des extensions telles que Grammarly qui améliore la qualité de l’écriture en temps réel, que ce soit dans les e-mails, les messages sur les réseaux sociaux, ou la rédaction en ligne.
  2. Mieux gérer ses onglets : certaines extensions permettent une meilleure organisation des onglets et de même de suspendre automatiquement ceux qui ne sont pas utilisés.
  3. Personnaliser son navigateur: en utilisant des extensions, vous pouvez accéder à de nouvelles fonctionnalités (Exemple : télécharger en un clic une vidéo trouvée sur Twitter).
  4. Optimisation de la Productivité: les extensions offrent des outils dédiés à l’efficacité, comme des gestionnaires de tâches, des rappels, et des fonctionnalités de bloc-notes intégrées, pour maximiser la productivité.

Une extension pour ne plus jamais faire de fautes d’orthographe


L’une des extensions les plus populaires et efficaces pour éviter les fautes d’orthographe est Languagetool.

En bref, c’est un outil qui fonctionne automatiquement en arrière-plan. Il soulignera les erreurs d’ orthographes (en jaune) et grammaticales et vous fournira des suggestions pour les corriger.

Pour cela, il faudra cliquer juste ici.

Une fois l’extension installée, LanguageTool fonctionnera automatiquement en arrière-plan, soulignant les erreurs d’orthographe et de grammaire et fournissant des suggestions de correction.

Et voilà, maintenant votre orthographe est corrigée et vous êtes intelligents ! 😁

À noter : l’efficacité de cette extension peut varier en fonction de la complexité des erreurs grammaticales et de la spécificité linguistique de chaque langue. Il peut être utile d’essayer différentes extensions pour trouver celle qui correspond le mieux à vos besoins et à votre style d’écriture.

Une extension pour mieux gérer ses onglets

La gestion des onglets dans le navigateur peut rapidement devenir chaotique, ce qui peut entrainer une perte de productivité et une expérience de navigation « désorganisée ».

C’est pour cela que je vous présente TabMaster qui résout ce problème en offrant les avantages suivants :

  • Sauvegarde et reprises rapides : Avec la possibilité d’enregistrer des sessions d’onglets, TabMaster permet aux utilisateurs de reprendre rapidement leur travail là où ils l’ont laissé.

Voici ce qu’on obtient, par exemple comme fonctionnalité, en faisant Ctrl + K :

  • Économie de ressources : Cette extension peut vous permettre de fermer automatiquement les onglets inactifs, ainsi TabMaster optimise les performances du navigateur en libérant de la mémoire.

Il y a aussi une liste de commandes utiles pour bien utiliser l’extension :

Vous pouvez donc aller ajouter l’extension ici.

Des extensions pour améliorer votre expérience navigateur

  • Une extension pour disposer toujours du dark mode

Vous en avez marre des sites web qui utilisent des fonds blancs lorsque vous naviguez sur internet la nuit ?

L’extension Dark Reader propose un mode sombre (ou « dark mode ») pour les sites web en inversant les couleurs des sites web, remplaçant les fonds blancs par des fonds noirs ou sombres, et les textes noirs par des textes blancs ou de couleurs sombres.

Voici un avant/après usage de l’extension :

Bien sûr, l’option est activable/désactivable. Et cette extension est aussi intéressante pour d’autres points : vous pouvez gérer la luminosité actuelle, mais aussi le contraste, ce qui peut être utile ! 😁

Comme le montre ici ce screen :

L’extension juste ici. D’autres options non citées ici sont aussi fournies grâce à cette extension.

  • Une extension pour personnaliser son navigateur

Il est intéressant de personnaliser son navigateur à ses gouts, c’est que propose l’extension Stylish.

Stylish est une extension polyvalente qui vous permet de personnaliser l’apparence des sites web que vous visitez. Que vous souhaitiez ajuster les couleurs, les polices de caractères, ou même la disposition d’un site, Stylish offre une grande flexibilité pour créer une expérience de navigation qui vous convient.

Prenons un exemple : vous êtes fan du jeu Hollow Knight et vous voulez personnaliser votre navigateur en fonction de votre jeu favori qu’est Hollow Knight, ainsi Stylish vous permet d’avoir un thème Hollow Knight pour regarder des videos Youtube (comme on le voit sur le screen).

Vous pouvez retrouver l’extension juste ici.

Pour conclure, vous pouvez trouver plus d’extensions quelles qu’elles soient juste ici.

Projets

Jeux de Calcul Mental chronométré en python

Êtes-vous bon en calcul mental ? Ce script en python vous propose de tester vos capacités à travers différents niveaux de difficulté, et tout cela chronométré !

Objectif

L’objectif de ce projet est de tester mes capacités en python et de mobiliser les notions vues en python en spécialité NSI (and, or, not, …etc). De plus, cela à pour but de proposer un outil pour s’entraîner au calcul mental. Je pense aussi l’adapter plus tard pour la calculatrice Numworks, ce qui donnera la possibilité d’y jouer dessus.

Projet

Le choix du langage pour ce projet est assez simple : python. C’est un langage assez simple à maitriser et adapté pour l’idée de mon jeux. Il propose aussi des bibliothèques assez intéressantes pour sa réalisation notamment time et random.

Analyse du code

Analysons le code.

Dans un premier temps on importe différentes bibliothèques qui vont nous être utilise. Nous utilisons la bibliothèque random pour générer des valeurs aléatoires pour diversifier les calculs ainsi que le module time. 

import math
from random import *
from time import time
from art import text2art

operateurs1 = ["+","-"]
operateurs2 = ["+","-","x"]])

Subséquemment, vous pouvez aussi voir une bibliothèque art avec le module text2art qui nous sert à convertir du texte en ascii art et donc à sublimer par exemple le menu.

La première liste sert uniquement au niveau 1 qui est censé être le plus simple, on se limite donc à des additions/soustractions tandis que la deuxième liste est destinée au niveaux 2 et 3.

Passons maintenant au menu.

def menu(): # Interface du début
    titre1 = text2art("NSI : Calcul \t mental") # Titre en ascii art
    print(titre1)
    
    print("Il y a 3 niveaux:") # Présente les différents niveaux 
    print("1-Niveau facile")
    print("2-Niveau intermédiaire") 
    print("3-Niveau difficile")
    
    choix = int(input("\nAlors, qu'allez vous choisir :\n"))
    
    while choix not in [1, 2, 3]:  # Empêche toutes valeurs autre que 1, 2 ou 3
        input("Veuillez choisir un chiffre :\n")
    
    if choix == 1: # Renvoie au niveau choisie
        niveau1()
        
    if choix == 2:
        niveau2()
        
    if choix == 3:
        niveau3()

menu()

On commence par présenter les différents niveaux avec des print() et aussi un titre en ascii art grâce au module text2art(). Vous allez voir que tout au long du code que nous allons utiliser des input() qui permettent à l’utilisateur de rentrer des valeurs ou une chaîne de caractère.

Ici, la boucle à la ligne 12 est nécessaire pour que l’utilisateur entre quelque chose de valable, la logique est simple : tant que qu’il n’a pas rentrer une valeur valable on réitère la question et dès lors qu’il tapera 1,2 ou 3 le script pourra continuer.

Enfin, on ajoute des conditions avec if pour le rediriger le joueur sur le niveau choisi. Passons maintenant à la structure d’un niveau.

def niveau2(): # Deuxième niveau
    score = 0
    compteur =  0
    while compteur < 10:
        indice_aleatoire = randint(0,len(operateurs1)-1)
        generation1 = randint(2,4)
        generation2 = randint(11,42)
        generation3 = randint(300,600)
        generation4 = randint(384,666)  # Plus de génération car on ajoute des multiplications
        
        if indice_aleatoire == 2:
            print("\nPeux tu calculer", str(generation1), operateurs1[indice_aleatoire], str(generation2), "? Tu as 7 secondes.")
        else:
            print("\nPeux tu calculer", str(generation4), operateurs1[indice_aleatoire], str(generation3), "? Tu as 7 secondes.")
        
        depart_temps = time() # Calcule le temps
        rep = int(input("\nMa réponse : "))
        
        fin_temps = time()-depart_temps

Nous allons ici prendre pour exemple le niveau 2 (intermédiaire), mais les autres niveaux ne sont pas si différents que ça. On va diviser le niveau en 3 parties :

  • La génération du calcul et la réponse de l’utilisateur
  • La correction de la réponse
  • Félicite le joueur en fonction de son score

Dans un premier temps, on commence par initialiser le score et le compteur qui correspond au nombre de question, donc ici 12 questions. Le compteur s’incrémente à chaque fin de question d’où l’utilisation de while.

On génère ensuite un indice aléatoire pour choisir entre tous les opérateurs et des nombres pour les calculs. Si cela tombe sur une multiplication on va multiplier des nombres par des petites valeurs (entre 2 et 4), sinon on fait l’addition ou soustraction de deux nombres entre environ 300 à 600.

Enfin, on lance le chrono avec le module time(), on demande alors la réponse et on arrête le chrono pour savoir le temps passé.

if operateurs2[indice_aleatoire] == "+": # Détermine l'opérateur pour la correction
    resultat = generation4 + generation3
elif operateurs2[indice_aleatoire] == "-":
    resultat = generation4 - generation3
elif operateurs2[indice_aleatoire] == "x":
    resultat = generation1 * generation2
else:
    resultat = None
        
if resultat is not None and resultat == rep and fin_temps <=7: # Correction en fonction du résultat et du temps mis
    print("Bravo, tu as donné la bonne réponse dans le temps imparti. Ton temps:", fin_temps)
    score += 1
elif resultat is not None and resultat == rep and fin_temps > 7:
    print("Tu as donné la bonne réponse mais pas dans le temps imparti. Ton temps:", fin_temps)
            
else:
    print("\nAh...apparemment tu t'es trompé, réessaye !")
    
suite = input("\nPrêt pout ma suite ? o/n\n")  # Demande si l'utilisateur est prêt
if suite.lower() != "o":
    break
compteur += 1

Dans un deuxième temps, on détermine l’opérateur pour effectuer la correction avec la réponse de l’utilisateur. Il y a 3 cas possibles :

  • La réponse est correcte et a été donnée dans le temps imparti (dans ce cas la le score s’incrémente)
  • La réponse est correcte mais n’a pas été donnée dans le temps imparti
  • La réponse est incorrecte et n’a pas été donnée dans le temps imparti

Ensuite, on demande si l’utilisateur est prêt pour passer à la suite. Ici, on utilise la méthode .lower() qui permet d’éviter que le script plante si l’utilisateur a mis un « o » ou un « n » en majuscule.

Puis on incrémente le compteur comme nous l’avons expliqué précédemment.

if score > 4:
    print("\nBravo tu as répondu à tous les calculs et tu a au moins la moyenne, ton  score est de", score) # Donne le score et félicite le joueur
    gg = text2art("gg")
    print(gg)
else:
    print("\nTon score est de", score,", ce n'est pas fameux ! Je te conseille d'acheter ma formation pour seulemment 773€/mois") # Peut être que je vais la prendre cette formation finalement

Dans un troisième temps, à la fin de toutes les questions, on obtient plusieurs grades de félicitation en fonction du score du joueur.

On retrouve aussi l’utilisation tu module text2art() qui permet de dire bien joué.

Conclusion

Le projet était assez plaisant à faire et il a permis de tester mes capacités en python tout en mobilisant des notions vues en spé NSI notamment not, and, or, les boucles, …etc. Ce script peut aussi être adapté sur la numworks dans l’avenir, ce qui peut être sympa.

Télécharger le script

calcul_mentalTélécharger
Tutoriels

Comment Installer Optifine avec des shaders et des textures…

Vous venez de débuter Minecraft et vous commencez à comprendre que creuser sous ses pieds, dans ce jeu, est peut être une mauvaise idée. Nous allons non pas vous présenter un tutoriel sur comment jouer à Minecraft mais bien un tutoriel qui va vous permettre de sublimer et d’améliorer votre expérience de jeux grâce à l’installation d’optifine avec des shaders et des textures packs.

Quel est l’intérêt et qu’est ce que c’est ?

Comme nous l’avons déjà dis, cela va permettre d’améliorer votre expérience de jeu en sublimant les graphismes. Si vous êtes ici c’est que l’univers de Minecraft vous intéresse. En tant que joueur de Minecraft depuis maintenant de nombreuses années, je fais moi même l’usage de packs de textures et de shaders dans mes aventures ou encore même pour combattre contre d’autres joueurs en ligne (appelé « PvP »), c’est pourquoi je vais vous conseiller des packs de textures et des shaders et vous montrer comment se passe l’installation de ces derniers.

Les shaders sont des programmes qui modifient les pixels qui s’affichent, ce qui va donner un meilleur rendu du jeu. Comme moi, l’apparence des textures (blocs, objets, créatures et autres) peut vous lasser, on installe donc un pack de texture qui va venir changer ces apparences.

Aperçu des shaders :

Voici un exemple de ce que donne l’application des quelques étapes qui suivent pour installer des shaders :

Sans shaders VS Avec Shaders

Passons maintenant à l’installation.

Installation Optifine

a) Prérequis

On choisis ici la version 1.8.9 pour le tutoriel, le processus reste le même pour une autre version mais il faudra télécharger les logiciels suivants pour la version souhaitée.

Tout d’abord, pour le bon déroulement de l’installation, il y a certains prérequis :

b) Installation

Vous avez maintenant tous les outils pour installer Optifine. Passons donc à son installation :

Rendez vous sur ce lien pour télécharger Optifine 1.8.9.

Après l’avoir télécharger, vous pouvez le lancer et vous arrivez sur cette fenêtre :

Vous devez tous simplement cliquez sur « Install ».

Shaders

Vous possédez maintenant Optifine qui est enfaite nécéssaire pour l’installation de shaders. Maintenant il va falloir choisir des shaders parmi des centaines qui se trouvent sur le net, c’est pour cela que je vais vous faire 3 suggestions qui sont, à mon sens, des très bons shaders.

a) Suggestions de shaders

  • BSL Shaders : shaders avec de l’eau peu mouvementée accompagnée d’un léger brouillard assez sympathique. Ce pack a aussi une très beau couché de soleil ce qui donne une bonne ambiance.
Sans shaders VS Avec BSL shaders

  • Complementary shaders : shaders lumineux, assez simples mais qui restent néanmoins très beaux. Si vous ne savez pas quoi choisir, ces shaders sont une bonne option ils conviennent généralement à la plupart des gens.
Sans shaders VS Avec complementary shaders

  • Sildur’s Vibrant : d’après moi les plus beaux shaders de Minecraft. C’est une pack qui fait sa force grâce à son couché de soleil compétitif et de très beaux reflets sur l’eau. L’apparence de nuit est aussi très sympathique.
Sans shaders VS Avec BSL shaders

b) Installation des shaders

Vous avez sûrement choisi des shaders parmi les suggestions ci-dessus, passons maintenant à l’installation de ces derniers pour qu’ils soient fonctionnels en jeu. Pour cela on prendra comme exemple les shaders Sildur’s Vibrant.

Tout d’abord, après avoir installé les shaders de votre choix, il va falloir saisir le raccourci Windows+R puis écrire « %appdata% ».

Vous arrivez normalement sur des dossier. Il vous faudra juste cliquer sur le premier dossier nommé « .minecraft » puis le dossier « shaderpacks » : .minecraft > shaderpacks

Vous n’avez plus qu’à glisser le pack dans ce dossier et à lancer Minecraft. 😁

Packs de texures

Concentrons nous maintenant sur les packs de textures. En effet, tout bon joueur minecraft possède des pack de textures que ce soit pour de la survie ou encore pour du PvP (=combat contre d’autres joueurs en ligne).

Si vous êtes arrivé sur ce tutoriel c’est que vous n’avez surement pas de pack de texture et/ou vous cherchez la manière pour les installer. Je vais donc vous proposer quelques packs de textures pour la survie et pour le PvP et par la suite vous montrer le déroulement de l’installation.

a) Suggestions de packs de textures

Voici donc 3 packs de textures que je vous suggère :

  • Faithful : pack très similaire au pack de texture de base de Minecraft mais qui améliore les graphismes. Un très bon choix pour ne pas se retrouver dépayser surtout si vous vous axez sur la survie, je vous le conseille donc fortement.
  • Amaranth : ce pack s’axe principalement sur le PvP. Il offre un style épuré et des graphiques sympathiques. J’utilise personnellement ce pack depuis maintenant quelques temps et il passe très bien.
  • Red Killua x32 Revamp : pack qui s’axe principalement sur le PvP mais peut aussi convenir pour la survie si ce style vous plaît. En revanche, les graphiques sont assez simples, ce qui explique ce côté épuré qu’on peut voir sur les blocs.

b) Installation des packs de textures

Contrairement au shaders, vous n’avez pas besoin d’Optifine pour avoir des pack de textures, ce qui vous laisse plus de liberté pour essayer les packs proposés !

Passons maintenant à l’installation :

Après avoir téléchargé l’un des packs, il faut saisir le même raccourci que pour les shaders : Windows+R et écrire « %appdata ». Aller dans .minecraft > ressourcepacks et glisser votre pack dans ce dossier.

Mise en place en jeu

Vous possédez maintenant tous les packs de textures et shaders installés, peut-être avez vous envie de les essayer, lancez donc votre jeu !

Je vais vous montrer comment les avoir en jeu directement, c’est enfaite assez simple :

Commençons par les packs de textures.

Etape 1 : accéder aux options comme l’affiche le screen ci-dessous.

Etape 2 : aller dans les packs de ressources.

Etape 3 : transférer le pack souhaité dans la colonne « Packs de ressources sélectionnés ».

La colonne a gauche « Packs de ressources disponibles » correspond enfaite au dossier « ressourcepacks », même si ils sont là, pour en utiliser un il faut simplement cliquer sur la flèche comme on le voit dans le screen ci-dessous.

Pour les shaders, rendez-vous dans encore une fois dans les options puis dans la section « Options graphiques ».

Etape 1 :

Etape 2 : aller dans la section « Shader… »

Etape 3 : vous pouvez enfin voir les packs que vous avez téléchargés. Pour appliquer un des shaders, vous avez tout simplement à cliquer dessus, il se chargera (ce qui peut bugger parfois) et vous en avez terminé.

Conclusion

Voila, maintenant vous savez comment installer des shaders et des packs de texures. N’hésitez pas à en tester pleins pour trouver le style qui vous convient dans l’optique d’améliorer votre expérience de jeu !

Art

Perspective : un paysage Synthwave

Dans le cadre de la 5ème édition du dispositif “Regards de Géomètre”, nous avons décidé dans le thème « Perspective » de produire un paysage synthwave.

Origines de la Synthwave

Avant tout la synthwave est un genre musical électronique ayant émergé dans les années 2000/2010 qui s’inspire d’éléments des années 80. Et c’est justement dans les clips de ces musiques que l’on va retrouver ce type d’image.

Pour en savoir plus nous vous conseillons cette vidéo qui explique brièvement les origines.

Le Projet

Revenons donc au projet. Pour ce projet nous avons donc décidé de produire une image d’un paysage synthwave. Pour cela nous utilisons le module turtle ainsi que le module random, le module turtle est utilisé pour produire l’image est le module random est utilisé pour les étoiles de l’image où la taille et leur position est générée aléatoirement nous avons également utilisé le script permettant d’exporter une image générée par turtle en .png que vous pouvez retrouver ici.

Structure du script

Pour la structure du script nous avons décidé de découper chaque partie de l’image (pavage, fond, étoiles, soleil, ville et montagnes) afin de créer des fonctions et à la fin nous les avons toutes appelées dans un ordre précis pour que les différentes parties de l’image soit dans leur plan respectif.

Analyse du script

Nous allons donc analyser le script.

Commençons par l’appel des modules et la mise en place de turtle.

from turtle import *
from random import randint
# vérification des modules importés
try:
    from PIL import Image
    pillow_installed = True
except:
    print("Oops! - ModuleNotFoundError: No module named 'PIL' - RTFM :")
    print("https://nsi.xyz/py2png")
    pillow_installed = False
titre = "Perspective - Un paysage Synthwave"
title(titre+" | Au lycée, la meilleure spécialité, c'est la spé NSI")
setup(1280, 720) # définit la taille de la fenêtre
colormode(255) # permet l'utilisation de couleurs rgb
speed(0) #Remplaçable par tracer(2) (10x plus rapide) mais si il est utilisé des lignes du pavage peuvent manquer
hideturtle() #dissimule la tortue

On appelle les fonctions turtle, random avec pour random uniquement randint et on utilise une partie du script « exporter une image générée par turtle » pour vérifier que l’utilisateur a bien installé le module PIL et dans le cas contraire un message d’erreur s’affichera et lui donnera un lien pour installer le module et tout ça sans que le script ne s’arrête. Après la vérification on met en place le titre de la fenêtre qui va affiché le rendu ainsi que sa taille. Enfin on définit le type de couleurs utilisées (R,G,B), la vitesse de la tortue, et on dissimule la tortue (c’est plus joli).

Commençons par la première fonction : le fond

def fond():
    penup()
    rciel = 0
    gciel = 0 
    bciel = 0
    hauteur = -360
    goto(-642,-358)
    pendown()
    while hauteur != 360:
        pencolor(round(239 + rciel), round(41 + gciel), round(209 + bciel))
        forward(1280)
        hauteur += 1
        goto(-640, hauteur)
        rciel += (-29/180)
        gciel += (2/45)
        bciel += (7/720)

Pour le fond on aurait pu utiliser une fonction qui crée un rectangle et qui le remplit avec fill_rect, cependant la couleur dans ce cas est uni ce qui ne nous intéresse pas. Nous avons donc produit un script qui fait un fond dégradé qui fait avancer la tortue sur une ligne d’un pixel de large et à la fin de cette ligne la tortue est envoyé grâce à un goto à la ligne d’après et qui ajoute la différence de chaque couleur (rouge,vert et bleu) entre la couleur de début du dégradé et la couleur de fin. Tout ceci est arrondi car turtle n’est pas compatible avec des arguments à virgule (pour la fonction pencolor en tout cas).

Par la suite la fonction qui produit les étoiles a été codée :

def etoile():
    for i in range(90):
        penup()
        goto(randint(-720,720), randint(0,360))
        pendown()
        pencolor(255, 255, 255)
        lcercle = randint(1,3)
        fillcolor('white')
        begin_fill()
        circle(lcercle)
        end_fill()

Pour les étoiles on définit aléatoirement leur position sur la moitié haute de l’image, on les met en blanc, on définit aussi aléatoirement la taille de l’étoile et on créer l’étoile avec sa position, et sa taille en aléatoire puis on refait ce processus 90 fois pour avoir 90 étoiles.

Ensuite nous avons le soleil (Le script affiché n’est qu’une petite partie du script total du soleil car il est très long et qu’il se répète, il est donc inutile de commenter la suite) :

def soleil():
    penup()
    liste1 = [10,7,5,4,3,3,3,3,2,2,2,2,2,2,2,1,2,1,2,1,1,2,1,1,1,1,2,1,1,1]
    liste2 = [1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0]
    pliste1 = 0
    pliste2 = 0
    rsoleil = 0
    gsoleil = 0
    bsoleil = 0
    lsoleil = 8
    hauteur = 30
    goto(0,30)
    pendown()
    for i in range(15):
        pencolor(round(255 + rsoleil), round(23 + gsoleil), round(226 + bsoleil))
        forward(lsoleil)
        backward(2*lsoleil)
        hauteur += 1
        lsoleil += liste1[pliste1]
        pliste1 += 1
        goto(0, hauteur)
        rsoleil += (0)
        gsoleil += (114/101)
        bsoleil += (-203/202)
    forward(lsoleil)
    backward(2*lsoleil)
    penup()

Pour le soleil nous réutilisons le script du dégradé, cependant nous l’avons modifier pour que le point d’origine de la tortue soit au centre du rectangle et que la longueur de chaque ligne soit défini par une liste (ce qui permet de faire un cercle en prenant les longueur d’un cercle utilisable en pixel art). Pour ce qui est des endroits ou le soleil est coupé la tortue fait le tracé mais on a utilisé la fonction penup() qui fait que la tortue ne dessine plus.

Après nous avons la fonctions des montagnes (Encore une fois le script n’est pas complet car il se répète encore 3 fois après.) :

def montagne():
    #montagne derrière la première
    penup()
    goto(-480,0)
    fillcolor(110, 27, 188)
    begin_fill()
    for i in range(3):
        forward(250)
        left(120)
    end_fill()
    
    goto(-480,0)
    pencolor(51, 210, 246)
    ymontagne = 10
    for i in range(11):
        pendown()
        goto(-355,ymontagne)
        goto(-230,0)
        penup()
        goto(-480,0)
        ymontagne += 20

Pour le script des montagnes nous avons utilisé le script pour faire des triangles équilatéraux retrouvable ici. Et ensuite nous avons utilisé un ‘for i in range’ pour faire des goto enchaîné pour faire les lignes des montagnes.

Ensuite nous avons les fonctions de la ville. Pourquoi les fonctions car il y a une fonction pour chaque bâtiment différent ainsi qu’une fonction finale qui définit l’ordre des bâtiments.

def bat1():
    penup()
    rbat = 0
    gbat = 0 
    bbat = 0
    hauteur = 0
    pendown()
    xturtle, yturtle = pos()
    while hauteur != 72:
        pencolor(round(125 + rbat), round(35 + gbat), round(216 + bbat))
        forward(42)
        hauteur += 1
        goto(xturtle, hauteur)
        rbat += (-5/3)
        gbat += (-7/15)
        bbat += (-72/25)
    forward(42)
    penup()
    right(90)
    forward(72)
    left(90)

Pour le bâtiment 1 il y a un dégradé (toujours le même script) puis on fait que la tortue finisse le bâtiment en bas à droite de ce dernier pour pouvoir enchainer les bâtiments.

fun fact : Au début nous n’avions pas prévu les quelques lignes à la fin pour que la tortue puisse enchaîner les bâtiments sans que les fonctions des bâtiments aient besoin d’être modifiés ce qui nous a amené à avoir tous les bâtiments qui se chevauchaient.

def ville():
    penup()
    goto(-320,0)
    bat3(), bat2(), bat1(), bat4() ,bat3(), bat4(), bat3(), bat2(), bat1(), bat2(), bat1(), bat3(), bat1(), bat4(), bat2(), bat1(), bat3(), bat1(), bat4(), bat3()

Et à la fin on a fait la fonction ville qui appelle dans l’ordre choisi les bâtiments. Le goto permet de définir où commence le premier bâtiment, les autres se mettent juste après le premier sans se chevaucher ni laisser un espace.

Par la suite nous avons le pavage (très long aussi, il sera donc coupé) :

def pavage():
    colormode(255)
    pensize(5)
    speed(0)
    rciel = 0
    gciel = 0 
    bciel = 0
    hauteur = -360
    penup()
    goto(-640,-360)
    pendown()
    while hauteur != 0:
        pencolor(round(15 + rciel), round(4 + gciel), round(76 + bciel))
        forward(1280)
        hauteur += 1
        goto(-640, hauteur)
        rciel += (91/180)
        gciel += (1/36)
        bciel += (7/18)

Pour le début du pavage on retrouve encore le script du dégradé mais avec les couleurs modifiées.

pencolor(229, 123, 240)
    #Lignes au dessus du pavage
    pensize(4),penup(),goto(-640,0),pendown(),goto(640,0),pensize(2),penup(),goto(-640, 0),pendown()
    #lignes gauche
    penup(),goto(-20.00,0),pendown(),goto(-60.00,-360.00),penup(),goto(-60.00,0),pendown(),goto(-180.00,-360.00),penup(),goto(-100.00,0),pendown(),goto(-300.00,-360.00),penup(),goto(-140.00,0),pendown(),goto(-420.00,-360.00),penup(),goto(-180.00,0),pendown(),goto(-540.00,-360.00),penup(),goto(-220.00,0),pendown(),goto(-660.00,-360.00),penup(),goto(-260.00,0),pendown(),goto(-780.00,-360.00),penup(),goto(-300.00,0),pendown(),goto(-900.00,-360.00),penup(),goto(-340.00,0),pendown(),goto(-1020.00,-360.00),penup(),goto(-380.00,0),pendown(),goto(-1140.00,-360.00),penup(),goto(-420.00,0),pendown(),goto(-1260.00,-360.00),penup(),goto(-460.00,0),pendown(),goto(-1380.00,-360.00),penup(),goto(-500.00,0),pendown(),goto(-1500.00,-360.00),penup(),goto(-540.00,0),pendown(),goto(-1620.00,-360.00),penup(),goto(-580.00,0),pendown(),goto(-1740.00,-360.00),penup(),goto(-620.00,0),pendown(),goto(-1760.00,-360.00)
    #lignes droites
    penup(),goto(20,0),pendown(),goto(60.00,-360.00),penup(),goto(60.00,0),pendown(),goto(180.00,-360.00),penup(),goto(100.00,0),pendown(),goto(300.00,-360.00),penup(),goto(140.00,0),pendown(),goto(420.00,-360.00),penup(),goto(180.00,0),pendown(),goto(540.00,-360.00),penup(),goto(220.00,0),pendown(),goto(660.00,-360.00),penup(),goto(260.00,0),pendown(),goto(780.00,-360.00),penup(),goto(300.00,0),pendown(),goto(900.00,-360.00),penup(),goto(340.00,0),pendown(),goto(1020.00,-360.00),penup(),goto(380.00,0),pendown(),goto(1140.00,-360.00),penup(),goto(420.00,0),pendown(),goto(1260.00,-360.00),penup(),goto(460.00,0),pendown(),goto(1380.00,-360.00),penup(),goto(500.00,0),pendown(),goto(1500.00,-360.00),penup(),goto(540.00,0),pendown(),goto(1620.00,-360.00),penup(),goto(580.00,0),pendown(),goto(1740.00,-360.00),penup(),goto(620.00,0),pendown(),goto(1760.00,-360.00)
    #Lignes horizontales
    penup(),goto(-640, -300),pendown(),goto(640, -300),penup(),goto(-640, -240),pendown(),goto(640, -240),penup(),goto(-640, -190),pendown(),goto(640, -190),penup(),goto(-640, -140),pendown(),goto(640, -140),penup(),goto(-640, -100),pendown(),goto(640, -100),penup(),goto(-640, -70),pendown(),goto(640, -70),penup(),goto(-640, -40),pendown(),goto(640, -40),penup(),goto(-640, -15),pendown(),goto(640, -15),

On a par la suite énormément de goto afin de faire le quadrillage du pavage.

Pour produire l’image finale nous avons les appels des différents fonctions à la fin :

#appel de toutes les fonctions
fond(), etoile(), soleil(), montagne(), ville(), pavage()

Et pour exporter l’image finale en .png il y a la suite du script pour exporter une image générée par turtle en .png utilisé au début du script.

#enregistrement de l'image finale avec vérification des modules importés
image = getcanvas()
nom_du_fichier_sans_extension=titre+"_"+hex(randint(2**30+2**25,2**30+2**25+2**24-1))[2:]
image.postscript(file=nom_du_fichier_sans_extension+".ps", colormode='color')
try:
    psimage = Image.open(nom_du_fichier_sans_extension+".ps")
    psimage.load(scale=2)
    psimage_resized = psimage.resize((1280, 720))
    psimage.save(nom_du_fichier_sans_extension+".png")
    print(nom_du_fichier_sans_extension+".png", psimage.size, "sauvegardé dans le dossier")    
except:
    if not pillow_installed:
        print("Oops! - ModuleNotFoundError: No module named 'PIL' - RTFM :")
        print("https://nsi.xyz/py2png")
    else:
        print("Oops! - 'ghostscript' not installed- RTFM :")
        print("https://nsi.xyz/py2png")
exitonclick()

Le script va donc générer une image en .ps et la convertir en .png avec un nom généré aléatoirement pour éviter que à chaque fois que vous générez une image l’image soit écrasée

Télécharger le .py

Télécharger

L’image finale