Linux-nätverk och TCP/IP för utvecklare · Lektion

Introduktion till Socket API

Utforska grundläggande begrepp inom socketprogrammering, inklusive sockettyper, adresser och vanliga API-anrop.

Lektion 1 av 412 steg

Introduktion till Socket API är en gratis lektion i Linux-nätverk och TCP/IP för utvecklare på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Linux-nätverk och TCP/IP för utvecklare, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Linux-nätverk och TCP/IP för utvecklare innehåller totalt 4 lektioner.

Vad är nätverkssocketar?

Välkomna till socketprogrammering! En socket är ett centralt begrepp inom nätverkskommunikation. Tänk på den som en ändpunkt i en tvåvägskommunikationslänk mellan två program som körs i nätverket.

Det fungerar ungefär som ett telefonuttag i en vägg. Ni ansluter en telefon till uttaget för att koppla upp er mot telefonnätet. På samma sätt använder program socketar för att ansluta till och kommunicera över ett datornätverk.

Pythons socket-modul

Python gör socketprogrammering lättillgänglig genom den inbyggda modulen socket. Modulen tillhandahåller alla funktioner och klasser som behövs för att skapa och hantera socketar.

Ni importerar den vanligtvis i början av skriptet. Vi ska se hur ni kommer igång:

import socket

# Now you can use socket functions!

Socketarnas adressfamiljer

Innan ni skapar en socket måste ni ange dess adressfamilj. Den avgör vilken typ av adresser socketen kan använda.

socket.AF_INET: Används för IPv4-adresser (till exempel 192.168.1.1). Detta är den vanligaste.
socket.AF_INET6: Används för IPv6-adresser.
socket.AF_UNIX: Används för kommunikation mellan processer på samma dator.

Vi kommer främst att använda AF_INET för vanlig internetkommunikation.

Sockettyper: ström kontra datagram

Nu väljer vi sockettyp, som definierar kommunikationssättet.

socket.SOCK_STREAM: Den här typen använder TCP (Transmission Control Protocol). Den är tillförlitlig, ordnad och anslutningsorienterad, ungefär som ett telefonsamtal. Data anländer exakt i den ordning den skickades.
socket.SOCK_DGRAM: Den här typen använder UDP (User Datagram Protocol). Den är anslutningslös och mindre tillförlitlig, ungefär som att skicka vykort. Data kan anlända i fel ordning eller inte alls.

De flesta vanliga program, särskilt webbläsare, använder SOCK_STREAM.

Skapa er första socket

Nu sätter vi ihop delarna och skapar ett grundläggande socketobjekt. Vi anger adressfamiljen (IPv4) och sockettypen (TCP-ström).

Den här raden skapar en inaktiv socket som är redo att konfigureras för antingen klient- eller serverrollen.

import socket

# Create a TCP/IP socket
my_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

print(f"Socket created: {my_socket}")
# Don't forget to close sockets when done!
my_socket.close()

Binda en socket (serversidan)

En server behöver en adress att lyssna på. Detta kallas att binda socketen. Ni tilldelar socketen en IP-adress och ett portnummer.

Klienter använder den här adressen och porten för att ansluta till er server. En port är ett nummer som identifierar ett specifikt program eller en specifik tjänst på en värd.

import socket

HOST = '127.0.0.1'  # Localhost
PORT = 65432        # Port to listen on (> 1023 for non-privileged)

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind((HOST, PORT))
    print(f"Socket bound to {HOST}:{PORT}")
    # The socket is now bound, but not yet listening or accepting.

Lyssna efter anslutningar

Efter bindningen måste en serversocket lyssna efter inkommande klientanslutningar. Metoden listen() försätter socketen i serverläge.

Argumentet till listen() är backlog, alltså det maximala antalet anslutningar som ännu inte accepterats som systemet tillåter innan nya anslutningar avvisas.

import socket

HOST = '127.0.0.1'
PORT = 65432

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind((HOST, PORT))
    s.listen(1) # Allow 1 pending connection
    print(f"Server listening on {HOST}:{PORT}")
    # Now the server is ready to accept a connection.

Acceptera en anslutning

När en klient försöker ansluta använder servern metoden accept(). Metoden blockerar (väntar) tills en klient ansluter.

Därefter returnerar den ett nytt socketobjekt (conn) som representerar anslutningen till klienten, samt klientens adress (addr). All kommunikation med klienten sker via den här nya socketen.

import socket

HOST = '127.0.0.1'
PORT = 65432

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind((HOST, PORT))
    s.listen(1)
    print("Waiting for a client connection...")
    # This part would typically be in a loop in a real server
    conn, addr = s.accept()
    with conn:
        print(f"Connected by {addr}")
        # Now 'conn' can be used to send/receive data to/from the client.

Ansluta till en server (klientsidan)

En klientsocket binds inte. I stället använder den metoden connect() för att upprätta en anslutning till en server som lyssnar på en specifik IP-adress och port.

När anslutningen har upprättats kan klienten omedelbart börja skicka och ta emot data. Data utbyts alltid som bytes.

import socket

HOST = '127.0.0.1'
PORT = 65432

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    try:
        s.connect((HOST, PORT))
        print(f"Connected to server at {HOST}:{PORT}")
        s.sendall(b'Hello from client!')
        data = s.recv(1024) # Receive up to 1024 bytes
        print(f"Received: {data.decode()}")
    except ConnectionRefusedError:
        print("Error: Server not running or not listening.")

Skicka och ta emot data

När en anslutning har upprättats kan data utbytas med hjälp av sendall() och recv().

socket.sendall(data): Skickar alla byte-liknande data till den anslutna socketen. Den fortsätter att skicka tills all data har skickats eller ett fel inträffar.
socket.recv(bufsize): Tar emot data från socketen. bufsize är det maximala antalet byte som tas emot åt gången. Metoden returnerar ett tomt bytesobjekt (b'') när anslutningen stängs.

Snabbtest av socket-API:t

Vilket av följande påståenden om Pythons socket-modul och sockettyper är SANT?

Besvara frågan i den interaktiva lektionen

Repetition: Introduktion till socketar

Bra jobbat! I den här lektionen har ni tagit era första steg inom socketprogrammering med Python. Ni har lärt er:

Vad en nätverkssocket är och vilken roll den har i kommunikationen.
Om Pythons socket-modul.
Skillnaden mellan adressfamiljer (AF_INET, AF_INET6) och sockettyper (SOCK_STREAM för TCP, SOCK_DGRAM för UDP).
De grundläggande API-anropen: socket() för att skapa socketar, bind() och listen() för servrar samt connect() för klienter.
Hur accept() hanterar inkommande anslutningar och hur sendall()/recv() fungerar.

Härnäst går vi djupare in på hur man bygger fullständiga TCP-klient-server-program!

Gratis att börja

Lär dig Linux-nätverk och TCP/IP för utvecklare med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Introduktion till Socket API” gratis?

Ja – hela texten till ”Introduktion till Socket API” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Linux-nätverk och TCP/IP för utvecklare, kan Ni uppgradera till CoddyKit PRO. Kursen i Linux-nätverk och TCP/IP för utvecklare innehåller totalt 4 lektioner.

Vad lär jag mig i ”Introduktion till Socket API”?

Utforska grundläggande begrepp inom socketprogrammering, inklusive sockettyper, adresser och vanliga API-anrop. Ni övar på Linux-nätverk och TCP/IP för utvecklare med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Linux-nätverk och TCP/IP för utvecklare?

Du behöver inga förkunskaper. Utbildningen i Linux-nätverk och TCP/IP för utvecklare på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Introduktion till Socket API”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Linux-nätverk och TCP/IP för utvecklare-lektionen?

Ja. Varje Linux-nätverk och TCP/IP för utvecklare-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Linux-nätverk och TCP/IP för utvecklare