socket — Low-Level Networking

import socket

HOST = "127.0.0.1"      # localhost — only this machine can connect
PORT = 65432            # a port above 1024

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server:
    # Allow reusing the address immediately after the program restarts
    server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

    server.bind((HOST, PORT))    # claim the address and port
    server.listen()              # start listening for connections
    print(f"Listening on {HOST}:{PORT}")

    while True:
        # accept() blocks until a client connects, returning a NEW
        # socket for that specific client plus their address
        conn, addr = server.accept()
        with conn:
            print(f"Connected by {addr}")
            while True:
                data = conn.recv(1024)
                if not data:
                    break             # client disconnected
                # Echo the data back, uppercased
                conn.sendall(data.upper())

import socket

# UDP — connectionless. No connect/accept; you send to an address directly.
# UDP server
server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server.bind(("127.0.0.1", 9999))
data, addr = server.recvfrom(1024)   # returns (data, sender_address)
server.sendto(b"reply", addr)        # send back to that address

# UDP client
client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
client.sendto(b"hello", ("127.0.0.1", 9999))   # no connection needed
reply, _ = client.recvfrom(1024)

# Timeouts prevent a socket from blocking forever
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(5.0)                    # raise socket.timeout after 5 seconds
try:
    s.connect(("example.com", 80))
except socket.timeout:
    print("Connection timed out")
except socket.gaierror:
    print("Could not resolve the hostname (DNS failure)")
finally:
    s.close()

# TCP guarantees order and delivery; UDP is faster but does neither.
# Use TCP for web, email, files. Use UDP for video, games, DNS.

import socket, selectors

# A selector lets ONE thread watch many sockets, reacting only to
# those that are ready — the foundation of high-concurrency servers.
sel = selectors.DefaultSelector()

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("127.0.0.1", 65432))
server.listen()
server.setblocking(False)            # non-blocking mode
sel.register(server, selectors.EVENT_READ, data=None)

def event_loop():
    while True:
        events = sel.select(timeout=None)   # wait for ANY socket to be ready
        for key, mask in events:
            if key.data is None:
                # The listening socket is ready -> accept a new client
                conn, addr = key.fileobj.accept()
                conn.setblocking(False)
                sel.register(conn, selectors.EVENT_READ, data=addr)
            else:
                # A client socket is ready -> read without blocking
                data = key.fileobj.recv(1024)
                if data:
                    key.fileobj.sendall(data.upper())
                else:
                    sel.unregister(key.fileobj)
                    key.fileobj.close()

# socketserver — the stdlib's higher-level server framework
import socketserver
class EchoHandler(socketserver.BaseRequestHandler):
    def handle(self):
        data = self.request.recv(1024)
        self.request.sendall(data.upper())
# with socketserver.ThreadingTCPServer(("127.0.0.1", 0), EchoHandler) as srv:
#     srv.serve_forever()   # threaded server, one thread per client

# socket.create_connection — convenience for TCP clients (handles DNS,
# IPv4/IPv6 fallback, and timeout in one call)
with socket.create_connection(("example.com", 80), timeout=5) as s:
    s.sendall(b"GET / HTTP/1.0\r\n\r\n")