I en verden oversvømmet av matoppskrifter på internett, der utallige lenker og reklamer kjemper om oppmerksomheten, kan det føles nesten umulig å finne den perfekte oppskriften. Ved å utvikle en egen app for oppskriftssøk, kan du skape en skreddersydd og brukervennlig opplevelse, med et konsistent design. Dette eliminerer irrelevante treff og distraksjoner.
Gjennom utviklingen av denne appen vil du styrke dine ferdigheter i HTTP-forespørsler, håndtering av API-nøkler, bildebehandling, og bygging av grafiske brukergrensesnitt, inkludert dynamisk oppdatering av GUI.
Installer Tkinter, Requests, Pillow og nettlesermodulen
For å lage et program for oppskriftssøk, trenger du Tkinter, Requests, PIL (Pillow) og nettlesermodulen. Tkinter lar deg lage skrivebordsapplikasjoner, med et utvalg av widgets som forenkler utviklingen av GUI-er. For å installere Tkinter, åpne terminalen og kjør:
pip install tkinter
Requests-modulen gjør det enkelt å sende HTTP-forespørsler og returnere et svarobjekt, med data som koding og status. Du kan bruke modulen til å hente informasjon om anrops-ID, lage en kontroll for nettsidestatus, valutakonverter eller en nyhetsapplikasjon. For å installere Requests-modulen, åpne terminalen og kjør:
pip install requests
Pillow-biblioteket, en videreutvikling av Python Imaging Library (PIL), tilbyr funksjoner for bildebehandling, som redigering, opprettelse, konvertering av filformater og lagring av bilder. For å installere Pillow-modulen, åpne terminalen og kjør:
pip install Pillow
Nettlesermodulen gir deg mulighet til å åpne lenker i standardnettleseren. Den er en del av Pythons standardbibliotek, og trenger derfor ikke installeres separat.
Generer Edamam API-nøkkel for oppskriftssøk
For å generere en Edamam Recipe Search API-nøkkel, følg disse trinnene:
- Besøk Edamam og klikk på knappen «Signup API». Fyll ut informasjonen og velg planen «Recipe Search API – Developer».
- Logg inn på kontoen din, klikk på «Accounts»-knappen, og deretter «Go to Dashboard»-knappen.
- Klikk på fanen «Applications» og deretter «View»-knappen ved siden av «Recipe Search API».
- Kopier applikasjons-IDen og applikasjonsnøklene, og lagre dem for bruk i applikasjonen din.
Bygg funksjonaliteten for å få de 5 beste oppskriftene
Du finner all kildekoden for å lage en oppskriftsøk-applikasjon ved hjelp av Python i dette GitHub-depotet.
Importer de nødvendige modulene. Definer en metode `get_top_5_recipes()` som henter de fem beste oppskriftenes titler, bilder og lenker, basert på brukerens søk. Bruk `get()` for å trekke ut navnet på retten brukeren har søkt etter.
Hvis brukeren har skrevet inn et oppskriftsnavn, definer base-URLen for Edamams API-endepunkt for oppskriftssøk. Legg til `app_id` og `app_key` som du kopierte tidligere, for å autentisere og autorisere API-forespørslene.
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 =
Lag en ordbok, `params`, som inneholder de ulike parameterne du må sende med API-forespørselen. Sett nøkkel-verdi-parene for `q`, `app_id` og `app_key` til verdiene du fikk tidligere. Still inn `from` og `to` parametere for å definere antall resultater du vil se.
Send en GET-forespørsel til Edamam API ved å kombinere API-URLen og `params`-ordboken. Lagre svaret og pakk det ut i JSON-format. Kall `clear_recipe_list()` for å fjerne oppskrifter fra tidligere søk.
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()
Sjekk om nøkkelen «hits» er til stede i JSON-dataene, og om det finnes søkeresultater. Hvis det er tilfelle, gå gjennom resultatene og hent ut oppskriftsinformasjon en etter en. Send en GET-forespørsel til bilde-URL-en med parameteren `stream` satt til `True` for å tillate strømming av bildedata.
Bruk Pillow-modulens bildeklasse for å åpne bildet du mottok. Endre størrelsen på bildet til en høyde og bredde på 200 piksler, ved hjelp av Lanczos resampling-metoden for å sikre høy kvalitet. Konverter bildet til et Tkinter-kompatibelt `PhotoImage` for å vise det i det grafiske brukergrensesnittet.
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)
Bygg strukturen til applikasjonen
Definer tre etiketter for å vise oppskriftstittelen, bildet og lenken til oppskriften. Angi det overordnede vinduet du vil plassere det i, teksten som skal vises og skriftstilen den skal ha. For å vise bildet, sett bildeattributtet til `photo_image`. Sett `cursor`-alternativet i lenkeetiketten til `hand2` for å gjøre den klikkbar.
Knytt lenken og hendelsen med venstre museklikk til å kalle `open_link()`-funksjonen. Organiser alle widgets ved hjelp av pakkemetoden, sentrer dem horisontalt og legg til polstring etter behov. Legg til tittel, bilder og lenker i tre separate lister.
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)
Definer en metode, `clear_recipe_list()`, for å fjerne alt innhold som ble generert fra forrige forespørsel. Tøm innholdet i `recipe_list` og gå gjennom hver etikett i `recipe_labels`-listen.
Kall `pack_forget()`-metoden for å fjerne etiketten fra skjermen, men behold widget-objektet intakt. Tøm `recipe_labels`-listen for nye data. Gjenta denne prosessen for bildene og lenkene. Definer en metode, `open_link()`, for å åpne oppskriftslenken i standardnettleseren.
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)
Initialiser Tkinter-rotvinduet. Angi tittel, dimensjoner og bakgrunnsfarge for programmet. Definer en ramme-widget og angi overordnet element samt bakgrunnsfarge. Opprett en etikett, et inntastingsfelt og en søkeknapp. Organiser alle widgets ved hjelp av pakkemetoden, og legg til polstring etter behov.
root = tk.Tk()
root.title("Oppskriftsfinner")
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="Skriv inn oppskriftsnavn:", 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 etter oppskrifter",
font=("Helvetica", 12, "bold"),
command=get_top_5_recipes,
)
search_button.pack(pady=10)
Lag et lerret med hvit bakgrunn for å vise widgets som inneholder oppskriftsinformasjon. Organiser lerretet på venstre side av vinduet, og la det fylle all plass i rammen, og utvide ved endring av størrelse.
Lag et vertikalt rullefelt for lerretet og plasser det på høyre side. Koble `scrollbar.set`-metoden til `canvas.yview`-metoden slik at rulling på rullefeltet ruller innholdet i lerretet.
Lag en ramme inne i lerretet for å fungere som en beholder for oppskriftselementer, forankret øverst til venstre i vinduet. Knytt en `
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"))
)
Definer lister for oppskrifter, etiketter, bilder og lenker. `mainloop()`-funksjonen forteller Python å starte Tkinter-hendelsesløkken og lytte etter hendelser til vinduet lukkes.
recipe_list = [] recipe_labels = [] recipe_images = [] recipe_links = [] root.mainloop()
Sett alt sammen og oppdag nye retter med et klikk på en knapp.
Resultatet av Oppskriftsfinner-applikasjonen
Når du kjører programmet og søker etter for eksempel «kyllingburger», får du de fem beste resultatene. Disse inneholder tittelen, bildet og oppskriftslenken. Når du klikker på lenken, åpner standard nettleser oppskriftslenken. Når du ruller nedover, forblir innholdsstørrelsen den samme, med de ulike resultatene sentrert horisontalt.
Forbedring av Oppskriftsfinner-applikasjonen
For å forbedre appen din for oppskriftssøk, kan du implementere filtrering og sortering i henhold til ulike preferanser. Du kan filtrere etter kostholdshensyn, tilberedningstid og mattype, samt sortere i ønsket rekkefølge.
Lag en funksjon for å bokmerke favorittoppskrifter slik at du kan se dem senere, og et alternativ for å dele dem på sosiale medier. Du kan også opprette en kategori for å finne de mest søkte rettene, de mest bokmerkede, og så videre.
Ved å kombinere dine programmeringskunnskaper og de kraftige funksjonene i API-er, kan du forvandle denne grunnleggende applikasjonen til en fullverdig app.