Att navigera i det enorma utbudet av recept som finns tillgängliga online, med otaliga länkar och reklam, kan vara en utmaning. Genom att utveckla en egen app för receptsökning får du en anpassad och användarvänlig upplevelse. Med en konsekvent design slipper du irrelevanta resultat och störande element.
Genom att bygga denna applikation förbättrar du dina färdigheter inom HTTP-förfrågningar, hantering av API-nycklar, bildbehandling och utveckling av grafiska användargränssnitt, inklusive dynamisk uppdatering av gränssnittet.
Installation av Tkinter-, Requests-, Pillow- och Webbrowser-modulerna
För att skapa ett program för receptsökning behöver du Tkinter, Requests, PIL (Pillow) och webbläsarmodulen. Tkinter ger dig möjlighet att skapa skrivbordsapplikationer och erbjuder ett brett utbud av widgets som förenklar utvecklingen av GUI. Installera Tkinter genom att öppna terminalen och köra följande kommando:
pip install tkinter
Modulen Requests underlättar HTTP-förfrågningar och returnerar ett svarobjekt med data som kodning och status. Den kan användas för att hämta information, skapa webbplatsstatuskontroller, valutakonverterare eller nyhetsapplikationer. För att installera Requests-modulen, använd terminalen och kör:
pip install requests
Pillow-biblioteket, en vidareutveckling av Python Imaging Library (PIL), erbjuder funktioner för bildbehandling. Det stöder redigering, skapande, konvertering av filformat och sparande av bilder. Installera Pillow-modulen med följande kommando i terminalen:
pip install Pillow
Webbläsarmodulen gör det möjligt att öppna länkar i standardwebbläsaren och ingår i Pythons standardbibliotek, vilket gör att separat installation inte är nödvändig.
Skapa en Edamam API-nyckel för receptsökning
Följ dessa steg för att generera en Edamam Recipe Search API-nyckel:
- Besök Edamam och klicka på ”Signup API”. Fyll i nödvändig information och välj ”Recipe Search API – Developer” som din plan.
- Logga in på ditt konto, klicka på ”Accounts” och därefter ”Go to Dashboard”.
- Klicka sedan på ”Applications” och därefter på ”View” intill ”Recipe Search API”.
- Kopiera ”Application ID” och ”Application keys” och spara dem för användning i din applikation.
Utveckla funktionen för att hämta de 5 bästa recepten
Du hittar den kompletta källkoden för att bygga en receptsökningsapplikation med Python i detta GitHub-förråd.
Importera nödvändiga moduler. Skapa en metod `get_top_5_recipes()` som hämtar de fem bästa receptens namn, bilder och länkar baserat på användarens sökning. Använd `get()` för att extrahera namnet på den rätt som användaren har angett.
Om användaren har angett ett receptnamn, definiera bas-URL:en för Edamams API för receptsökning. Skicka `app_id` och `app_key` som du kopierade tidigare för att autentisera och auktorisera API-anrop.
import tkinter as tk
import requests
from PIL import Image, ImageTk
import webbrowserdef 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 parametrar som krävs för API-anropet. Ställ in nyckel-värdeparen för `q`, `app_id` och `app_key` till de värden du erhållit. Justera parametrarna `from` och `to` för att ange antalet resultat du önskar.
Skicka en GET-förfrågan till Edamams API genom att kombinera API-URL:en och `params`-ordlistan. Spara svaret och extrahera det i JSON-format. Anropa `clear_recipe_list()` för att ta bort tidigare recept från skärmen.
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 ”hits” finns i den extraherade JSON-datan och om den innehåller sökresultat. Om det är fallet, iterera genom resultaten och extrahera receptinformation. Skicka en GET-förfrågan till bildens URL med parametern `stream` inställd på `True` för att möjliggöra streaming av bilddata.
Använd Pillow-modulens `Image` klass för att öppna den nedladdade bilden. Ändra storlek på den till en höjd och bredd på 200 pixlar med Lanczos omsamplingsmetod för högkvalitativ storleksändring. Konvertera detta till ett Tkinter-kompatibelt `PhotoImage` för att visa det i 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)
Skapa applikationens struktur
Definiera tre etiketter för att visa receptets namn, bild och länk. Ange det överordnade fönstret där etiketten ska placeras, texten som ska visas och teckensnittet. För att visa bilden, ange `image`-attributet till `photo_image`. Ställ in `cursor`-alternativet i länketiketten till `hand2` för att göra den klickbar.
Koppla länken och händelsen med vänster musklick för att anropa funktionen `open_link()`. Organisera alla widgets med hjälp av `pack`-metoden, centrera dem horisontellt och lägg till utfyllnad efter behov. Lägg till namn, bilder och länkar till tre separata 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)
Skapa en metod `clear_recipe_list()` för att rensa skärminnehållet som genererats från tidigare förfrågningar. Rensa innehållet i receptlistan och iterera genom varje etikett i listan `recipe_labels`.
Anropa metoden `pack_forget()` för att ta bort etiketten från skärmen, men behåll widgetobjektet intakt.
Rensa listan `recipe_labels` för nya data. Upprepa denna process även för bilderna och länkarna. Skapa en metod `open_link()` för att öppna receptlänken i standardwebbläsaren.
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. Ange programmets titel, dimensioner och bakgrundsfärg. Definiera en ram-widget och ange dess överordnade element tillsammans med dess bakgrundsfärg. Skapa en etikett, ett textinmatningsfält och en sökknapp. Organisera alla widgets med hjälp av `pack`-metoden 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="Ange receptnamn:", 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="Sök recept",
font=("Helvetica", 12, "bold"),
command=get_top_5_recipes,
)
search_button.pack(pady=10)
Skapa en canvas med vit bakgrund för att visa widgets som innehåller receptinformation. Placera den till vänster i fönstret, fyll ramen i båda riktningarna och expandera den vid storleksändring.
Skapa en vertikal scrollbar för canvasen och placera den till höger. Koppla metoden `scrollbar.set` till `canvas.yview` så att rullning med scrollbaren rullar genom canvasinnehållet.
Skapa en ram inuti canvasen som fungerar som en behållare för receptobjekten, förankrad uppe till vänster i fönstret. Koppla `
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 listorna för recept, etiketter, bilder och länkar. Funktionen `mainloop()` talar om för Python att köra Tkinter-händelseloopen och vänta på händelser tills fönstret stängs.
recipe_list = []
recipe_labels = []
recipe_images = []
recipe_links = []root.mainloop()
Sätt samman allt och upptäck mat med ett enkelt knapptryck.
Resultatet av Recept Finder-applikationen
När du startar programmet och söker efter till exempel ”kycklingburgare”, får du de fem bästa resultaten. Dessa inkluderar receptets namn, bild och länk. När du klickar på länken öppnas webbläsaren och visar receptet. När du rullar nedåt behålls storleken på innehållet 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 filter och sortering baserat på olika preferenser. Du kan filtrera efter kost, tillagningstid och kök, och sortera i valfri ordning.
Lägg till en funktion för att bokmärka dina favoritrecept för senare användning och dela dem på sociala medier. Du kan också skapa en kategori för att visa de mest sökta rätterna, de mest bokmärkta och så vidare.
Genom att kombinera dina programmeringsfärdigheter och kraftfulla API-funktioner kan du utveckla denna grundläggande applikation till en fullfjädrad lösning.