Hur man bygger en Recept Finder-applikation med Python

Med ett överflöd av recept utspridda över hela internet med hundratals länkar och annonser, kan det vara svårt att hitta det perfekta receptet. Att bygga en receptsökningsapp ger dig en skräddarsydd och användarvänlig upplevelse och konsekvent design, vilket eliminerar alla irrelevanta resultat och distraktioner

.Genom att bygga den här applikationen vässar du dina kunskaper i HTTP-förfrågningar, API-nyckelhantering, bildmanipulation och att bygga grafiska användargränssnitt inklusive dynamisk GUI-uppdatering.

Installera modulen Tkinter, Requests, Pillow och Webbrowser

För att bygga ett receptsökningsprogram behöver du Tkinter, Requests, PIL och webbläsarmodulen. Tkinter låter dig skapa skrivbordsapplikationer. Den erbjuder en mängd olika widgets som gör det lättare att utveckla GUI. För att installera Tkinter, öppna terminalen och kör:

 pip install tkinter 

Modulen Requests gör det enkelt att göra HTTP-förfrågningar och returnera ett svarsobjekt som innehåller data som kodning och status. Du kan använda den för att hämta nummerpresentationsinformation, skapa en webbplatsstatuskontroll, valutaomvandlare eller en nyhetsapplikation. För att installera modulen Requests, öppna terminalen och kör:

 pip install requests 

Pillow-biblioteket – en gaffel från Python Imaging Library (PIL) – tillhandahåller bildbehandlingsfunktioner som hjälper till att redigera, skapa, konvertera filformat och spara bilder. För att installera kuddmodulen, öppna terminalen och kör:

 pip install Pillow 

Webbläsarmodulen hjälper dig att öppna vilken länk som helst i din standardwebbläsare. Det är en del av Python-standardbiblioteket. Därför behöver du inte installera den externt.

För att generera Edamam Recipe Search API-nyckeln, följ följande steg:

  • Besök Edamam och klicka på knappen Signup API. Fyll i detaljerna och välj din plan som Recipe Search API – Developer.
  • Logga in på ditt konto, klicka på knappen Konton och klicka sedan på knappen Gå till instrumentpanelen.
  • Därefter klickar du på fliken Applications och klickar slutligen på knappen Visa bredvid Recept Search API.
  • Kopiera applikations-ID och applikationsnycklar och lagra dem för att använda i din applikation.
  • Bygg funktionaliteten för att få de 5 bästa recepten

    Du kan hitta hela källkoden för att bygga ett receptsökarprogram med Python i detta GitHub-förråd.

    Importera de nödvändiga modulerna. Definiera en metod get_top_5_recipes() som hämtar de fem bästa receptens titlar, bilder och länkar för rätten som användaren söker efter. Använd get() för att extrahera namnet på maträtten som användaren sökte efter.

    Om användaren angav ett receptnamn, definiera bas-URL för Edamam API:s receptsökningsslutpunkt. Skicka app_id och app_key som du kopierade tidigare för att autentisera och auktorisera API-förfrågningar.

     import tkinter as tk
    import requests
    from PIL import Image, ImageTk
    import webbrowser

    def get_top_5_recipes():
        recipe_name = entry_recipe_name.get()
        if recipe_name:
            api_url = "https://api.edamam.com/search"
            app_id =
            app_key =

    Skapa en ordlista, params som innehåller de olika parametrarna du måste skicka som en del av API-begäran. Ställ in nyckel-värdeparen för q, app_id och app_key till de värden du fick tidigare. Ställ in parametrarna från och till för att återspegla antalet resultat du vill se.

    Skicka en GET-förfrågan till Edamam API genom att kombinera API-URL:n och params-ordboken. Lagra svaret och extrahera det i JSON-format. Ring clear_recipe_list() för att rensa bort recepten som finns på skärmen från tidigare förfrågningar.

             params = {
                "q": recipe_name,
                "app_id": app_id,
                "app_key": app_key,
                "from": 0,
                "to": 5,
            }

            response = requests.get(api_url, params=params)
            data = response.json()
            clear_recipe_list()

    Kontrollera om nyckeln, träffar finns i den extraherade JSON-datan och om den innehåller sökresultatet. Om ja, iterera över sökresultaten och extrahera receptinformationen en efter en. Skicka en GET-förfrågan till bildens URL med strömparametern inställd på True för att tillåta streaming av bilddata.

    Använd kuddmodulens bildklass för att öppna bilden du fått. Ändra storlek på den för att få en höjd och bredd på 200 pixlar med Lanczos omsamplingsmetod för högkvalitativ storleksändring. Konvertera detta till Tkinter-kompatibelt PhotoImage för att visa det på det grafiska användargränssnittet.

             if "hits" in data and data["hits"]:
                for i, hit in enumerate(data["hits"]):
                    recipe = hit["recipe"]
                    recipe_list.append(recipe)
                    recipe_name = recipe["label"]
                    recipe_link = recipe["url"]
                    image_url = recipe["image"]

                    image_response = requests.get(image_url, stream=True)
                    image = Image.open(image_response.raw)
                    image = image.resize((200, 200), Image.LANCZOS)
                    photo_image = ImageTk.PhotoImage(image)

    Bygga applikationens struktur

    Definiera tre etiketter för att visa receptets titel, bilden och länken till receptet. Ställ in det överordnade fönstret du vill placera det i, texten du vill visa och typsnittet det ska ha. För att visa bilden, ställ in bildattributet till photo_image. Ställ in marköralternativet i länketiketten till hand2 för att göra det klickbart.

    Bind länken och händelsen med vänster musklick för att anropa funktionen open_link(). Organisera alla widgets med hjälp av packmetoden, centrera dem horisontellt och lägg till stoppningen vid behov. Lägg till titel, bilder och länkar till tre olika listor.

                     recipe_title_label = tk.Label(
                       canvas_frame,
                       text=f"{i+1}. {recipe_name}",
                       font=("Helvetica", 12, "bold"),
                   )
                   recipe_title_label.pack(pady=(5, 0), anchor=tk.CENTER)

                   image_response = requests.get(image_url, stream=True)
                   image = Image.open(image_response.raw)
                   image = image.resize((200, 200), Image.LANCZOS)
                   photo_image = ImageTk.PhotoImage(image)
                   image_label = tk.Label(canvas_frame, image=photo_image)
                   image_label.image = photo_image
                   image_label.pack(pady=(0, 5), anchor=tk.CENTER)

                   link_label = tk.Label(
                       canvas_frame, text=recipe_link, fg="blue", cursor="hand2"
                   )
                   link_label.pack(pady=(0, 10), anchor=tk.CENTER)
                   link_label.bind(
                       "<Button-1>", lambda event, link=recipe_link: open_link(link)
                   )

                   recipe_labels.append(recipe_title_label)
                   recipe_images.append(photo_image)
                   recipe_links.append(link_label)

    Definiera en metod, clear_recipe_list() för att rensa bort hela skärmens innehåll som genererats av föregående begäran. Rensa innehållet i receptlistan och iterera över varje etikett i listan recept_etikett.

    Anropar metoden pack_forget() för att ta bort etiketten från displayen men behålla widgetobjektet intakt.

    Rensa listan recept_etiketter för nya data. Upprepa denna process för bilderna och länkarna också. Definiera en metod, open_link() för att öppna receptlänken i din standardwebbläsare.

     def clear_recipe_list():
        recipe_list.clear()
        for label in recipe_labels:
            label.pack_forget()
        recipe_labels.clear()
        for image_label in recipe_images:
            image_label.pack_forget()
        recipe_images.clear()
        for link_label in recipe_links:
            link_label.pack_forget()
        recipe_links.clear()

    def open_link(link):
        webbrowser.open(link)

    Initiera Tkinter-rotfönstret. Ställ in titel, mått och bakgrundsfärg för programmet. Definiera en ramwidget och ställ in dess överordnade element tillsammans med dess bakgrundsfärg. Skapa en etikett, en post och en sökknapp. Organisera alla widgets med hjälp av packmetoden och lägg till utfyllnad vid behov.

     root = tk.Tk()
    root.title("Recipe Finder")
    root.geometry("600x600")
    root.configure(bg="#F1F1F1")

    frame = tk.Frame(root, bg="#F1F1F1")
    frame.pack(fill=tk.BOTH, expand=tk.YES, padx=20, pady=20)

    label_recipe_name = tk.Label(
       frame, text="Enter Recipe Name:", font=("Helvetica", 14, "bold"), bg="#F1F1F1"
    )
    label_recipe_name.pack()

    entry_recipe_name = tk.Entry(frame, font=("Helvetica", 12))
    entry_recipe_name.pack(pady=5)

    search_button = tk.Button(
       frame,
       text="Search Recipes",
       font=("Helvetica", 12, "bold"),
       command=get_top_5_recipes,
    )
    search_button.pack(pady=10)

    Skapa en duk med vit bakgrund för att visa widgetarna som innehåller receptinformation. Ordna det till vänster i fönstret, ta allt utrymme i ramen åt båda hållen och utöka det när du ändrar storlek.

    Skapa en vertikal rullningslist för duken och placera den på dess högra sida. Länka scrollbar.set-metoden till canvas.yview-metoden så att rullning av rullningslisten rullar genom canvasinnehållet.

    Skapa en ram inuti duken för att fungera som en behållare för receptföremålen, förankrad uppe till vänster i fönstret. Bind -händelsen så att den säkerställer att rutan kan rulla korrekt när dess innehåll ändras eller storleksändras.

     canvas = tk.Canvas(frame, bg="white")
    canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=tk.YES)

    scrollbar = tk.Scrollbar(frame, orient=tk.VERTICAL, command=canvas.yview)
    scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
    canvas.configure(yscrollcommand=scrollbar.set)

    canvas_frame = tk.Frame(canvas, bg="white")
    canvas.create_window((0, 0), window=canvas_frame, anchor=tk.NW)
    canvas_frame.bind(
       "<Configure>", lambda event: canvas.configure(scrollregion=canvas.bbox("all"))
    )

    Definiera listan för recept, etiketter, bilder och länkar. Mainloop()-funktionen säger åt Python att köra Tkinter-händelseloopen och lyssna efter händelser tills du stänger fönstret.

     recipe_list = []
    recipe_labels = []
    recipe_images = []
    recipe_links = []

    root.mainloop()

    Sätt ihop allt och upptäck kök med ett enda knapptryck.

    Resultatet av Recept Finder-applikationen

    När du kör programmet och går in i rätten som kycklingburgare får du de fem bästa resultaten. Den innehåller titeln, bilden och receptlänken för den maträtt du angav. När du klickar på länken öppnar standardwebbläsaren receptlänken. När du rullar nedåt förblir innehållsstorleken densamma och visar de olika resultaten centrerade horisontellt.

    Förbättra Recept Finder-applikationen

    För att förbättra din receptsökningsapplikation kan du implementera filtrering och sortering enligt olika preferenser. Du kan filtrera en maträtt efter kostpreferenser, tillagningstid och kök och sortera dem i valfri ordning.

    Skapa en funktion för att bokmärka dina favoritrecept för att se senare och ett alternativ att dela dem på sociala medier. Du kan skapa en kategori för att upptäcka de mest sökta rätterna, de flesta bokmärkta och så vidare.

    Genom att kombinera dina programmeringskunskaper och de kraftfulla funktionerna i API:er kan du ytterligare konvertera denna grundläggande applikation till en fullfjädrad.