Hur fungerar typ-hinting i Python och varför är det viktigt?

I den motsatta änden av spektrumet finns de så kallade statiskt typade språken: C, C++, Java, Rust, Go och så vidare. I dessa språk är variabelns typ känd vid kompileringstid och kan inte ändras över tid. Typkontrollen utförs under kompileringen (före körning), vilket innebär att fel fångas upp innan programmet körs, då kompilatorn hindrar programmet från att bli kompilerat.

Python är ett dynamiskt typat språk, vilket innebär att typer inte är kända förrän körningstiden. Eftersom variabelns typ är inbäddad i själva värdet av variabeln, kan utvecklaren inte veta vilken typ av en variabel som hen möter i en kodbas bara genom att titta på den eller inspektera den i en IDE. Men Python introducerade en mycket efterfrågad funktion med version 3.5—typ-annotationer (https://peps.python.org/pep-0484/). Typ-annotationer eller "hints" i Python är en extra syntax som informerar utvecklaren om den förväntade typen av en variabel. Dessa används inte av Python vid körning och påverkar inte på något sätt programmets beteende.

Men vad är då användningen av dessa hints, om Python-tolken ändå inte ser dem? Det visar sig att det finns flera viktiga fördelar som gör nästan varje kodbas mer robust, underhållbar och framtidssäker:

Snabbare kodutveckling: När du läser någon annans kod kommer du direkt att veta vilken typ varje variabel förväntas ha—om det är ett heltal eller ett flyttal, en lista eller ett set. Detta gör utvecklingen snabbare.

Kunskap om metoder och egenskaper: Du kommer att veta exakt vilka metoder eller egenskaper som finns för varje variabel. Om du oavsiktligt ändrar en variabels typ i en större kodbas kommer detta att märkas omedelbart.

Förenklad kodutveckling: Kodredigerare och IDE:er (som Visual Studio Code) ger utmärkt stöd och automatisk komplettering (IntelliSense), vilket gör utvecklingen enklare och minskar den kognitiva belastningen på utvecklaren.

Automatisk kodgenerering: FastAPI erbjuder automatisk och interaktiv dokumentation, helt baserat på Python-typ-hints.

Typkontroller: Detta är den viktigaste fördelen. Typkontroll är program som körs i bakgrunden och utför statisk analys av din kod, vilket gör att potentiella problem upptäcks och rapporteras direkt.

Lättare att läsa och mindre kognitiv belastning: Annoterad kod är mycket lättare att läsa och orsakar mindre kognitiv belastning när du som utvecklare behöver arbeta med en kod och försöker förstå vad den gör.

Starkt typat och flexibelt: Det bevarar språkets starka typning samtidigt som det tillåter den flexibilitet som dynamisk typning ger, och samtidigt inför nödvändiga säkerhetskrav och restriktioner.

Även om typ-hinting rekommenderas för större kodbaser, är det ingripet i FastAPI och Pydantic, så även de minsta projekten kommer att kräva att du åtminstone vet hur du hanterar typer och arbetar med dem. Typ-hinting är grundläggande för FastAPI. Tillsammans med MongoDB:s flexibla dokumentstruktur utgör det ryggraden i utvecklingen av FARM-stack (FastAPI, React, MongoDB, Pydantic). Typ-hinting säkerställer att dataflödet i din applikation bibehåller rätt datatyper vid varje ögonblick när data går in och ut ur systemet.

Vid enklare endpoints, som när kvantiteter bör vara heltal och namn strängar, kan detta verka trivialt. Men när din datastruktur blir mer komplex kan felsökning av typfel bli väldigt mödosamt. Typ-hints kan också ses som en formalisering—ett formellt sätt att statiskt (före körning) indikera typen av ett värde för en typkontroller (t.ex. Mypy), vilket säkerställer att när Python-runtime kör ditt program kommer typerna inte att skapa problem.

Typ-hinting i Python använder en enkel syntax för att ange datatyper, och för att implementera det behöver du skapa funktioner och variabler med specificerade typer. För att visa hur det fungerar kan vi börja med ett enkelt exempel.

Anta att vi skapar en funktion som skriver ut ett namn ett antal gånger. Den här funktionen accepterar två parametrar: name, som är en sträng, och times, som är ett heltal. Den returnerar ingenting (None). Om du nu använder en IDE som Visual Studio Code, kommer den omedelbart att föreslå en sträng som det första argumentet och ett heltal som det andra. Om du försöker använda felaktiga typer, som att skriva in ett heltal först och en sträng därefter, kommer Mypy att ge dig ett felmeddelande om att typerna är inkompatibla.

Ett exempel på typ-hinting-syntax kan vara att skapa en enkel variabel:

python
Copy code
text: str = "John"

Här specificeras typen för variabeln text som en sträng. När du annoterar returvärdet från en funktion använder du en "pil" (->), som så här:

python
Copy code
def count_users(users: list[str]) -> int:
    return len(users)

Du har nu sett enkla annotationer som begränsar en variabel till vissa grundläggande Python-typer, som heltal och strängar. Men typ-hinting kan vara mer flexibel; du kan till exempel vilja att en variabel ska kunna acceptera flera typer, som både heltal och strängar.

Hur man bygger en grundläggande FastAPI-applikation

FastAPI är ett modernt och snabbt ramverk för att bygga API:er med Python. Dess förmåga att kombinera enkelhet och kraft gör det till ett populärt val för utvecklare som arbetar med REST API:er. FastAPI bygger på standarder som HTTP, REST och OpenAPI och erbjuder ett sätt att bygga robusta applikationer snabbt. I denna kapitel ska vi gå igenom grunderna i FastAPI, hur du bygger en enkel REST API och förstår de viktigaste delarna som gör ramverket så användbart.

FastAPI ger ett effektivt sätt att hantera HTTP-förfrågningar och svar genom sin användning av Python-hints, asynkrona funktioner och modern syntax som async/await. Genom att använda FastAPI kan du snabbt skapa funktionella endpoints och hantera alla de vanliga uppgifterna som krävs för att bygga ett API, såsom hantering av parametrar, formulärdata och cookies. Ramverket gör det också möjligt att enkelt hantera headers och andra viktiga webbrelaterade funktioner.

För att komma igång med FastAPI behöver du först och främst se till att din Python-installation är uppdaterad. Du ska använda Python 3.11.7 eller senare versioner för att säkerställa kompatibilitet med de funktioner som används i denna bok. Python versioner från 3.6 och framåt hanterar typ-hinting på ett modernt sätt, vilket är en grundläggande funktion för FastAPI.

Det är också viktigt att arbeta med virtuella miljöer i Python. Detta gör att du kan skapa en isolerad utvecklingsmiljö för varje projekt och undvika konflikter mellan olika paket och deras versioner. Genom att använda verktyg som virtualenv kan du skapa en virtuell miljö där alla nödvändiga paket för ditt FastAPI-projekt är installerade utan att påverka andra projekt eller systemet. Det är en rekommenderad bästa praxis att alltid ha en separat virtuell miljö för varje projekt.

Ett grundläggande FastAPI-projekt består av några viktiga komponenter: routing, datavalidering och hantering av HTTP-förfrågningar. FastAPI använder Pydantic för att säkerställa datavaliditet, vilket gör att du kan definiera och validera data på ett enkelt sätt med hjälp av Python-typer. När du skapar en endpoint i FastAPI kan du definiera de typer av data som förväntas tas emot, och FastAPI kommer att validera dessa data automatiskt.

För att skapa en enkel REST API med FastAPI börjar du med att definiera en rutt. En rutt är en funktion som körs när en viss URL begärs. Du kan också ange vilken HTTP-metod (GET, POST, PUT, DELETE) som ska användas. En rutt kan returnera olika typer av data, till exempel JSON-objekt, eller även svar som innehåller cookies eller headers.

En typisk FastAPI-applikation kan se ut så här:

python
Copy code
from fastapi import FastAPI

app = FastAPI()
@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

I exemplet ovan definieras en rutt med HTTP-metoden GET som accepterar en parameter item_id i URL:en och en valfri query-parameter q. FastAPI hanterar automatiskt alla förfrågningar och validerar att item_id är ett heltal och att q är en sträng.

En annan viktig aspekt av FastAPI är hantering av formulärdata. Formulärdata är vanligt i webben och kan skickas via POST-förfrågningar. FastAPI gör det enkelt att ta emot och bearbeta formulärdata genom att använda Pydantic-modeller för att validera inkommande data.

För att sammanfatta: FastAPI gör det möjligt att skapa REST API:er på ett snabbt och effektivt sätt. Genom att använda de grundläggande funktionerna som routing, datavalidering och hantering av HTTP-förfrågningar kan du bygga pålitliga och skalbara applikationer. När du arbetar med FastAPI bör du alltid komma ihåg vikten av att använda en virtuell miljö för att hantera beroenden och paketversioner, och att ha en uppdaterad Python-installation.

Vidare är det också viktigt att förstå hur FastAPI använder asynkrona funktioner för att hantera förfrågningar. Detta gör det möjligt för FastAPI att hantera tusentals samtidiga förfrågningar utan att blockera servern, vilket ger bättre prestanda och skalbarhet för din applikation. Dessutom ger asynkron programmering flexibilitet när du arbetar med externa tjänster som databaser eller API:er, eftersom det tillåter andra förfrågningar att bearbetas medan en långsam förfrågan väntar på att slutföras.

Hur man kommunicerar med externa API:er i React genom att använda useEffect

I en typisk React-applikation handlar mycket av arbetet om att hantera och synkronisera användargränssnittet med applikationens tillstånd. När det gäller att hämta data från externa källor, såsom API:er, behövs särskilda metoder för att undvika problem som kan uppstå vid asynkrona processer. En sådan metod är användningen av React Hooks, och i synnerhet useEffect, för att hantera externa dataflöden.

En vanligt förekommande uppgift i utveckling av web-applikationer är att lista objekt eller resurser från en extern källa. Tänk på en applikation där användaren ska kunna filtrera bilar baserat på en budget. För att lösa denna uppgift behöver man inte bara definiera bilens data utan också ge användaren möjlighet att interagera med applikationen genom att filtrera objekten. Genom att använda JavaScript kan du enkelt implementera denna funktionalitet med hjälp av ett filter som selekterar objekt baserat på ett angivet pris.

För att hantera dynamiska uppdateringar i komponenter är React ett utmärkt val. React tillhandahåller useState för att definiera och hantera tillstånd i en komponent. Detta gör det möjligt för applikationen att reagera på användarens interaktioner och uppdatera gränssnittet i enlighet med detta. För exempelvis en bilsökfunktion, där användaren vill filtrera bilar inom en viss budget, kan koden se ut på följande sätt:

javascript
Copy code
{data.filter((el) => el.price <= budget).map((el) => {

    return (
        <div>{el.name}</div>
    )
})}

Men vad händer när vi behöver hämta data från en extern källa, till exempel ett API? I så fall kommer den vanliga useState inte att räcka till för att hantera den asynkrona dataladdningen. Här kommer useEffect in i bilden. Med hjälp av useEffect kan vi utföra operationer som inte är direkt kopplade till komponentens återgivning, till exempel API-anrop. Denna Hook gör det möjligt att hantera de "side effects" som uppstår när applikationen interagerar med externa källor, som en server.

När vi arbetar med externa API:er i React, till exempel när vi ska hämta användardata från en server, är det avgörande att förstå de potentiella problem som kan uppstå med att kontinuerligt uppdatera komponentens tillstånd efter varje render. Om du inte vidtar försiktighetsåtgärder kan du hamna i en oändlig loop där varje förändring i tillståndet leder till ett nytt API-anrop. För att förhindra detta använder vi useEffect, som bara aktiveras vid specifika händelser.

Nedan är ett exempel på hur du kan hämta och visa användardata från ett externt API med hjälp av useEffect och fetch:

javascript
Copy code
import { useState, useEffect } from "react";

export default function App() {

    const [users, setUsers] = useState([]);
    useEffect(() => {
        fetchUsers();
    }, []);  // Tom array gör att effekten körs bara en gång
    const fetchUsers = () => {
        fetch("https://jsonplaceholder.typicode.com/users")
            .then((res) => res.json())
            .then((data) => setUsers(data));
    };
    return (
        <div>
            <h2>List of users</h2>
            {users.map((user) => (
                <div key={user.id}>{user.name}</div>
            ))}
        </div>
    );
}

I detta exempel används useEffect för att utföra ett API-anrop en gång, direkt efter att komponenten har renderats. Den tomma beroendearrayen ([]) säkerställer att API-anropet bara görs en gång, vilket förhindrar onödiga upprepningar.

Det är viktigt att förstå hur Reacts återgivningscykel och tillståndshantering fungerar för att effektivt använda useEffect. Eftersom useEffect är designad för att hantera asynkrona operationer och externa effekter, bör utvecklare vara medvetna om när och hur effekterna körs. Genom att ange beroenden i den andra parametern av useEffect kan vi kontrollera när effekten ska aktiveras. Om vi till exempel skulle vilja hämta nya användardata baserat på en URL-ändring, kan vi lägga till URL:en som ett beroende.

När du hanterar API-anrop och externa effekter är det också viktigt att tänka på att rensa upp eventuella långvariga effekter, som eventlyssnare eller öppna anslutningar. useEffect ger möjlighet att tillhandahålla en rensningsfunktion för att ta bort sådana effekter när komponenten tas bort eller uppdateras.

För att summera, useEffect och andra Hooks som useState, useReducer och useContext ger utvecklare kraftfulla verktyg för att bygga interaktiva och dynamiska applikationer. Att förstå hur man hanterar externa dataflöden och effekter är en av de viktigaste aspekterna av att utveckla med React, vilket gör det möjligt att skapa responsiva och skalbara applikationer.

Hur MongoDB Struktur och Datatyper Påverkar Ditt Applikationsdesign

En grundläggande egenskap för dokument i MongoDB är att varje nyckel (eller fält) ska vara en sträng, även om det finns vissa undantag som beskrivs i dokumentationen. Det är också viktigt att förstå att MongoDB är känslig för stora och små bokstäver, vilket kan påverka hur nycklar definieras och hämtas.

När vi pratar om strukturen för en MongoDB-databas, är den nära besläktad med datatyperna som används i många programmeringsspråk. Till exempel kan en MongoDB-dokumentstruktur jämföras med ett Python-dictionary, vilket gör det möjligt för utvecklare att enkelt överföra data mellan en applikation och databasen. På samma sätt som Python-dictionaries, ger MongoDB:s dokumentstruktur en lättläst och anpassningsbar metod för att hantera information i en applikation, vare sig den är för webben eller skrivbordet.

När man designar databaser i MongoDB, är det viktigt att vara medveten om möjligheten att skapa djupt inbäddade dokument. MongoDB tillåter att dokument kan innehålla andra dokument, vilket gör det möjligt att skapa komplexa, hierarkiska datastrukturer. Detta öppnar upp för användning av 100 nivåer av inbäddning, vilket är en flexibilitet som sällan behövs i praktiska tillämpningar men som ger möjligheten att skapa mycket detaljerade och sammanlänkade datarepresentationer.

Ett exempel på en vanlig användning av MongoDB:s flexibla datamodell är filminformation. En dokumentbeskrivning av en film kan innehålla en mängd olika fält, som titel, beskrivning, genre, regissör, språk, årtal, och betyg från olika källor som IMDb eller Rotten Tomatoes. Eftersom MongoDB tillåter olika fält att ha olika typer av data, kan varje filmbeskrivning vara unikt anpassad för att återspegla den information som är relevant för just den filmen, utan att behöva följa en strikt, fördefinierad struktur.

En annan viktig aspekt av MongoDB är att varje dokument har ett unikt "_id"-fält som fungerar som en primärnyckel. Detta fält genereras automatiskt om det inte anges vid dokumentets skapande och gör det möjligt att snabbt identifiera och referera till dokument i samlingarna. Denna funktion är mycket användbar för applikationer som kräver hög tillgänglighet och prestanda.

MongoDB:s användning av BSON (Binary JSON) gör att den stöder ett bredare spektrum av datatyper än traditionella JSON-strukturer. BSON:s binära format ger snabbare lagring och hämtning av data, samtidigt som det möjliggör lagring av icke-UTF-8-strängar, bilder och andra filer i databasen. BSON:s struktur stödjer till och med lagring av funktioner och skript som kan exekveras direkt från databasen, vilket gör det till ett kraftfullt verktyg för utvecklare.

En annan viktig aspekt är MongoDB:s stöd för samlingar och databaser. Samlingar är grupper av dokument, och de fungerar på samma sätt som tabeller i en relationsdatabas. MongoDB tillåter lagring av data i flera samlingar och databaser, vilket gör det möjligt att organisera och optimera prestanda för specifika datatyper. Det är också möjligt att indexera specifika samlingar för att ytterligare förbättra sök- och hämtningseffektivitet. Att separera data i olika samlingar kan hjälpa till att optimera prestanda och säkerställa att relevanta uppgifter hämtas effektivt utan att behöva gå igenom hela databasen.

Att använda flera samlingar och databaser har flera fördelar, bland annat genom att förbättra både prestanda och hanterbarhet. Genom att hålla data åtskilda efter typ eller användning kan man enklare hålla reda på och säkerställa att sökfrågor och operationer är optimerade för de specifika datamängderna. Detta hjälper också till att minimera risken för att databasen växer ohanterligt eller blir långsam vid stora datamängder.

Slutligen är det också viktigt att tänka på datalokalitet och hur MongoDB hanterar indexering. Eftersom samlingar i MongoDB är grupper av dokument av samma typ, kan frågorna effektivt riktas mot specifika samlingar, vilket gör att hämtningstider minskar och systemets svarstider blir kortare. Databaser kan dessutom innehålla flera samlingar utan att behöva oroa sig för att korsa datagränser mellan dem, vilket ytterligare förbättrar både flexibiliteten och prestandan.