urllib.request — Utökat bibliotek för att öppna webbadresser

Källkod: Lib/urllib/request.py


Modulen urllib.request definierar funktioner och klasser som hjälper till att öppna webbadresser (oftast HTTP) i en komplex värld — grundläggande och samlad autentisering, omdirigeringar, cookies och mer.

Se även

Paketet Requests rekommenderas för ett HTTP-klientgränssnitt på högre nivå.

Varning

På macOS är det inte säkert att använda denna modul i program som använder os.fork() eftersom getproxies()-implementeringen för macOS använder ett system-API på högre nivå. Ställ in miljövariabeln no_proxy till * för att undvika detta problem (t.ex. os.environ["no_proxy"] = "*").

Tillgänglighet: not WASI.

Den här modulen fungerar inte eller är inte tillgänglig på WebAssembly. Se WebAssembly-plattformar för mer information.

Modulen urllib.request definierar följande funktioner:

urllib.request.urlopen(url, data=None, [timeout, ]*, context=None)

Öppna url, som kan vara antingen en sträng som innehåller en giltig, korrekt kodad URL eller ett Request-objekt.

data måste vara ett objekt som anger ytterligare data som ska skickas till servern, eller None om inga sådana data behövs. Se Request för detaljer.

urllib.request-modulen använder HTTP/1.1 och inkluderar rubriken Connection:close i sina HTTP-förfrågningar.

Den valfria parametern timeout anger en timeout i sekunder för blockering av åtgärder som anslutningsförsöket (om den inte anges kommer den globala standardinställningen för timeout att användas). Detta fungerar faktiskt bara för HTTP-, HTTPS- och FTP-anslutningar.

Om context anges måste det vara en ssl.SSLContext-instans som beskriver de olika SSL-alternativen. Se HTTPSConnection för mer information.

Denna funktion returnerar alltid ett objekt som kan fungera som en context manager och som har egenskaperna url, headers och status. Se urllib.response.addinfourl för mer information om dessa egenskaper.

För HTTP- och HTTPS-URL:er returnerar denna funktion ett http.client.HTTPResponse-objekt något modifierat. Förutom de tre nya metoderna ovan innehåller msg-attributet samma information som reason-attributet — den reason-fras som returneras av servern — istället för svarshuvudena som det specificeras i dokumentationen för HTTPResponse.

För FTP-, fil- och data-URL:er returnerar denna funktion ett urllib.response.addinfourl-objekt.

Utlöser URLError vid protokollfel.

Observera att None kan returneras om ingen hanterare hanterar begäran (även om den standardinstallerade globala OpenerDirector använder UnknownHandler för att säkerställa att detta aldrig händer).

Om proxyinställningar upptäcks (t.ex. när en miljövariabel *_proxy som http_proxy` är inställd) installeras dessutom ProxyHandler som standard och ser till att förfrågningarna hanteras via proxyn.

Den äldre funktionen urllib.urlopen från Python 2.6 och tidigare har utgått; urllib.request.urlopen`() motsvarar den gamla urllib2.urlopen. Proxyhantering, som gjordes genom att skicka en dictionary-parameter till urllib.urlopen, kan erhållas genom att använda ProxyHandler-objekt.

Standardöppnaren genererar en auditing event urllib.Request med argumenten fullurl, data, headers, method hämtade från begäranobjektet.

Ändrad i version 3.2: cafile och capath har lagts till.

Virtuella HTTPS-värdar stöds nu om det är möjligt (dvs. om ssl.HAS_SNI är true).

data kan vara ett itererbart objekt.

Ändrad i version 3.3: cadefault lades till.

Ändrad i version 3.4.3: sammanhang lades till.

Ändrad i version 3.10: HTTPS-anslutning skickar nu ett ALPN-tillägg med protokollindikatorn http/1.1 när ingen kontext anges. Anpassad kontext bör ställa in ALPN-protokoll med set_alpn_protocols().

Ändrad i version 3.13: Ta bort parametrarna cafile, capath och cadefault: använd parametern context i stället.

urllib.request.install_opener(opener)

Installera en instans av OpenerDirector som global standardöppnare. Att installera en öppnare är bara nödvändigt om du vill att urlopen ska använda den öppnaren; annars anropar du helt enkelt OpenerDirector.open() istället för urlopen(). Koden kontrollerar inte om det finns en riktig OpenerDirector, och vilken klass som helst med lämpligt gränssnitt kommer att fungera.

urllib.request.build_opener([handler, ...])

Returnerar en OpenerDirector-instans, som kedjar handlers i den ordning som anges. handlers kan vara antingen instanser av BaseHandler, eller subklasser av BaseHandler (i vilket fall det måste vara möjligt att anropa konstruktören utan några parametrar). Instanser av följande klasser kommer att stå framför handlers, såvida inte handlers innehåller dem, instanser av dem eller subklasser av dem: ProxyHandler (om proxyinställningar upptäcks), UnknownHandler, HTTPHandler, HTTPDefaultErrorHandler, HTTPRedirectHandler, FTPHandler, FileHandler, HTTPErrorProcessor.

Om Python-installationen har SSL-stöd (dvs. om modulen ssl kan importeras) kommer även HTTPSHandler att läggas till.

En BaseHandler subklass kan också ändra sitt handler_order attribut för att ändra sin position i listan över handlers.

urllib.request.pathname2url(path, *, add_scheme=False)

Konverterar den angivna lokala sökvägen till en file: URL. Denna funktion använder quote()-funktionen för att koda sökvägen.

Om add_scheme är false (standard) utelämnas prefixet file: för schemat i returvärdet. Sätt add_scheme till true för att returnera en komplett URL.

Detta exempel visar hur funktionen används i Windows:

>>> from urllib.request import pathname2url
>>> path = 'C:\\Program Files'
>>> pathname2url(path, add_scheme=True)
'file:///C:/Program%20Files'

Ändrad i version 3.14: Windows-enhetsbokstäver konverteras inte längre till versaler, och :-tecken som inte följer efter en enhetsbokstav orsakar inte längre ett OSError-undantag i Windows.

Ändrad i version 3.14: Sökvägar som börjar med ett snedstreck konverteras till webbadresser med auktoritetsavsnitt. Till exempel konverteras sökvägen /etc/hosts till URL:en ///etc/hosts.

Ändrad i version 3.14: Parametern add_scheme har lagts till.

urllib.request.url2pathname(url, *, require_scheme=False, resolve_host=False)

Konverterar den angivna file: URL:en till en lokal sökväg. Denna funktion använder unquote() för att avkoda URL:en.

Om require_scheme är false (standard) ska det angivna värdet utelämna ett prefix för file:-schema. Om require_scheme är satt till true, bör det angivna värdet innehålla prefixet; ett URLError uppstår om det inte gör det.

URL-auktoriteten kasseras om den är tom, localhost eller det lokala värdnamnet. I annat fall, om resolve_host är satt till true, löses auktoriteten upp med socket.gethostbyname() och kasseras om den matchar en lokal IP-adress (enligt RFC 8089 §3). Om behörigheten fortfarande inte kan hanteras returneras en UNC-sökväg på Windows och ett URLError på andra plattformar.

Detta exempel visar hur funktionen används i Windows:

>>> from urllib.request import url2pathname
>>> url = 'file:///C:/Program%20Files'
>>> url2pathname(url, require_scheme=True)
'C:\\Program Files'

Ändrad i version 3.14: Windows-enhetsbokstäver konverteras inte längre till versaler, och :-tecken som inte följer efter en enhetsbokstav orsakar inte längre ett OSError-undantag i Windows.

Ändrad i version 3.14: URL-auktoriteten kasseras om den matchar det lokala värdnamnet. I annat fall, om auktoriteten inte är tom eller localhost, returneras en UNC-sökväg på Windows (som tidigare) och på andra plattformar genereras ett URLError.

Ändrad i version 3.14: URL-frågan och fragmentkomponenterna kasseras om de finns med.

Ändrad i version 3.14: Parametrarna require_scheme och resolve_host har lagts till.

urllib.request.getproxies()

Denna hjälpfunktion returnerar en ordbok med URL-mappningar mellan schema och proxyserver. Den söker i miljön efter variabler med namnet <scheme>_proxy, utan hänsyn till versaler, för alla operativsystem först, och när den inte hittar den söker den efter proxyinformation från System Configuration för macOS och Windows Systems Registry för Windows. Om det finns miljövariabler med både små och stora bokstäver (och de inte är överens) föredras små bokstäver.

Anteckning

Om miljövariabeln REQUEST_METHOD är inställd, vilket vanligtvis indikerar att ditt skript körs i en CGI-miljö, kommer miljövariabeln HTTP_PROXY (versaler _PROXY) att ignoreras. Detta beror på att den variabeln kan injiceras av en klient med hjälp av HTTP-rubriken ”Proxy:”. Om du behöver använda en HTTP-proxy i en CGI-miljö, använd antingen ProxyHandler explicit, eller se till att variabelnamnet är i gemener (eller åtminstone suffixet _proxy).

Följande klasser erbjuds:

class urllib.request.Request(url, data=None, headers={}, origin_req_host=None, unverifiable=False, method=None)

Denna klass är en abstraktion av en URL-begäran.

url ska vara en sträng som innehåller en giltig, korrekt kodad URL.

data måste vara ett objekt som anger ytterligare data som ska skickas till servern, eller None om inga sådana data behövs. För närvarande är HTTP-förfrågningar de enda som använder data. De objekttyper som stöds är bytes, filliknande objekt och iterabler av bytesliknande objekt. Om inget Content-Length eller Transfer-Encoding rubrikfält har tillhandahållits, kommer HTTPHandler` att ställa in dessa rubriker enligt typen av data. Content-Length kommer att användas för att skicka bytesobjekt, medan Transfer-Encoding: chunked enligt specifikationen i RFC 7230, avsnitt 3.3.1 kommer att användas för att skicka filer och andra iterabler.

För en HTTP POST-begäran bör data vara en buffert i standardformatet application/x-www-form-urlencoded. Funktionen urllib.parse.urlencode() tar en mappning eller en sekvens av 2-tupler och returnerar en ASCII-sträng i detta format. Den bör kodas till bytes innan den används som data-parameter.

headers ska vara en ordbok och behandlas som om add_header() hade anropats med varje nyckel och värde som argument. Detta används ofta för att ”förfalska” värdet i User-Agent-rubriken, som används av en webbläsare för att identifiera sig själv – vissa HTTP-servrar tillåter endast förfrågningar från vanliga webbläsare, inte från skript. Till exempel kan Mozilla Firefox identifiera sig som "Mozilla/5.0 (X11; U; Linux i686) Gecko/20071127 Firefox/2.0.0.11", vid urllib:s standardsträng för användaragent är "Python-urllib/2.6" (i Python 2.6). Alla huvudnycklar skickas i kamelstil.

Ett lämpligt Content-Type-huvud bör inkluderas om data-argumentet finns. Om detta huvud inte har angetts och data inte är None, kommer Content-Type: application/x-www-form-urlencoded att läggas till som standard.

De två följande argumenten är endast av intresse för korrekt hantering av HTTP-cookies från tredje part:

origin_req_host bör vara request-host för ursprungstransaktionen, enligt definitionen i RFC 2965. Standardvärdet är http.cookiejar.request_host(self). Detta är värdnamnet eller IP-adressen för den ursprungliga begäran som initierades av användaren. Om begäran t.ex. gäller en bild i ett HTML-dokument bör detta vara request-host för begäran om den sida som innehåller bilden.

unverifiable bör ange om begäran är overifierbar, enligt definitionen i RFC 2965. Standardvärdet är False. En begäran som inte kan verifieras är en begäran vars URL användaren inte hade möjlighet att godkänna. Om begäran t.ex. gäller en bild i ett HTML-dokument och användaren inte hade någon möjlighet att godkänna automatisk hämtning av bilden, bör detta vara sant.

method bör vara en sträng som anger vilken HTTP-förfrågningsmetod som ska användas (t.ex. 'HEAD'). Om den tillhandahålls lagras dess värde i attributet method och används av get_method(). Standardvärdet är 'GET' om data är None eller 'POST' annars. Subklasser kan ange en annan standardmetod genom att ställa in attributet method i själva klassen.

Anteckning

Begäran kommer inte att fungera som förväntat om dataobjektet inte kan leverera sitt innehåll mer än en gång (t.ex. en fil eller en iterabel som bara kan producera innehållet en gång) och begäran omprövas för HTTP-omdirigeringar eller autentisering. Data skickas till HTTP-servern direkt efter rubrikerna. Det finns inget stöd för en 100-continue-förväntan i biblioteket.

Ändrad i version 3.3: Request.method-argumentet läggs till i Request-klassen.

Ändrad i version 3.4: Standard Request.method kan anges på klassnivå.

Ändrad i version 3.6: Ge inte felmeddelanden om Content-Length inte har angetts och data varken är None eller ett bytes-objekt. Fall tillbaka till att använda chunked transfer encoding istället.

class urllib.request.OpenerDirector

Klassen OpenerDirector öppnar URL:er via BaseHandler som kedjats ihop. Den hanterar kedjandet av handlers och återställning efter fel.

class urllib.request.BaseHandler

Detta är basklassen för alla registrerade handläggare — och hanterar endast de enkla mekanikerna för registrering.

class urllib.request.HTTPDefaultErrorHandler

En klass som definierar en standardhanterare för HTTP-felsvar; alla svar förvandlas till HTTPError-undantag.

class urllib.request.HTTPRedirectHandler

En klass för att hantera omdirigeringar.

class urllib.request.HTTPCookieProcessor(cookiejar=None)

En klass för att hantera HTTP-cookies.

class urllib.request.ProxyHandler(proxies=None)

Gör att förfrågningar går via en proxy. Om proxies anges måste det vara en ordbok som mappar protokollnamn till webbadresser för proxyer. Standardinställningen är att läsa listan över proxyer från miljövariablerna <protocol>_proxy. Om inga miljövariabler för proxy anges hämtas proxyinställningar i en Windows-miljö från registrets avsnitt Internetinställningar och i en macOS-miljö hämtas proxyinformation från System Configuration Framework.

För att inaktivera autodetekterad proxy skicka en tom ordbok.

Miljövariabeln no_proxy kan användas för att ange värdar som inte ska nås via proxy; om den är inställd ska den vara en kommaseparerad lista med värdnamnssuffix, eventuellt med :port tillagt, till exempel cern.ch,ncsa.uiuc.edu,some.host:8080.

Anteckning

HTTP_PROXY ignoreras om en variabel REQUEST_METHOD är inställd; se dokumentationen för getproxies().

class urllib.request.HTTPPasswordMgr

Förvara en databas med (realm, uri) -> (user, password) mappningar.

class urllib.request.HTTPPasswordMgrWithDefaultRealm

Förvara en databas med (realm, uri) -> (user, password) mappningar. En sfär med None anses vara en catch-all-sfär, som söks om ingen annan sfär passar.

class urllib.request.HTTPPasswordMgrWithPriorAuth

En variant av HTTPPasswordMgrWithDefaultRealm som också har en databas med uri -> is_authenticated mappningar. Kan användas av en BasicAuth-hanterare för att avgöra när autentiseringsuppgifter ska skickas omedelbart istället för att vänta på ett 401-svar först.

Tillagd i version 3.5.

class urllib.request.AbstractBasicAuthHandler(password_mgr=None)

Detta är en mixin-klass som hjälper till med HTTP-autentisering, både till fjärrvärden och till en proxy. password_mgr, om den ges, bör vara något som är kompatibelt med HTTPPasswordMgr; se avsnitt HTTPPasswordMgr-objekt för information om gränssnittet som måste stödjas. Om passwd_mgr också tillhandahåller metoderna is_authenticated och update_authenticated (se HTTPPasswordMgrWithPriorAuth Objekt), kommer hanteraren att använda resultatet is_authenticated för en given URI för att avgöra om autentiseringsuppgifter ska skickas med begäran eller inte. Om is_authenticated returnerar True för URI:n skickas autentiseringsuppgifter. Om is_authenticated är False skickas inte autentiseringsuppgifterna och om ett 401-svar tas emot skickas begäran på nytt med autentiseringsuppgifterna. Om autentiseringen lyckas anropas update_authenticated för att sätta is_authenticated True för URI:n, så att efterföljande förfrågningar till URI:n eller någon av dess super-URI:er automatiskt kommer att innehålla autentiseringsuppgifterna.

Tillagd i version 3.5: Stöd för is_authenticated har lagts till.

class urllib.request.HTTPBasicAuthHandler(password_mgr=None)

Hantera autentisering med fjärrvärden. password_mgr, om det anges, bör vara något som är kompatibelt med HTTPPasswordMgr; se avsnitt HTTPPasswordMgr-objekt för information om gränssnittet som måste stödjas. HTTPBasicAuthHandler kommer att ge upphov till ett ValueError när den presenteras med ett felaktigt autentiseringsschema.

class urllib.request.ProxyBasicAuthHandler(password_mgr=None)

Hantera autentisering med proxyn. password_mgr, om det anges, bör vara något som är kompatibelt med HTTPPasswordMgr; se avsnitt HTTPPasswordMgr-objekt för information om det gränssnitt som måste stödjas.

class urllib.request.AbstractDigestAuthHandler(password_mgr=None)

Detta är en mixin-klass som hjälper till med HTTP-autentisering, både till fjärrvärden och till en proxy. password_mgr, om den anges, bör vara något som är kompatibelt med HTTPPasswordMgr; se avsnitt HTTPPasswordMgr-objekt för information om det gränssnitt som måste stödjas.

Ändrad i version 3.14: Lagt till stöd för HTTP digest-autentiseringsalgoritmen SHA-256.

class urllib.request.HTTPDigestAuthHandler(password_mgr=None)

Hantera autentisering med fjärrvärden. password_mgr, om det anges, bör vara något som är kompatibelt med HTTPPasswordMgr; se avsnitt HTTPPasswordMgr-objekt för information om det gränssnitt som måste stödjas. När både Digest Authentication Handler och Basic Authentication Handler läggs till, prövas alltid Digest Authentication först. Om Digest Authentication returnerar ett 40x-svar igen skickas det till Basic Authentication Handler för att hanteras. Denna Handler-metod kommer att ge upphov till ett ValueError när den presenteras med ett annat autentiseringsschema än Digest eller Basic.

Ändrad i version 3.3: Utlös ValueError om autentiseringsschema som inte stöds.

class urllib.request.ProxyDigestAuthHandler(password_mgr=None)

Hantera autentisering med proxyn. password_mgr, om det anges, bör vara något som är kompatibelt med HTTPPasswordMgr; se avsnitt HTTPPasswordMgr-objekt för information om det gränssnitt som måste stödjas.

class urllib.request.HTTPHandler

En klass för att hantera öppning av HTTP-URL:er.

class urllib.request.HTTPSHandler(debuglevel=0, context=None, check_hostname=None)

En klass för att hantera öppning av HTTPS-URL:er. context och check_hostname har samma betydelse som i http.client.HTTPSConnection.

Ändrad i version 3.2: context och check_hostname har lagts till.

class urllib.request.FileHandler

Öppna lokala filer.

class urllib.request.DataHandler

URL:er för öppna data.

Tillagd i version 3.4.

class urllib.request.FTPHandler

Öppna FTP-URL:er.

class urllib.request.CacheFTPHandler

Öppna FTP-URL:er och behåll en cache för öppna FTP-anslutningar för att minimera fördröjningar.

class urllib.request.UnknownHandler

En catch-all-klass för att hantera okända webbadresser.

class urllib.request.HTTPErrorProcessor

Behandla HTTP-felsvar.

Begär objekt

Följande metoder beskriver Request publika gränssnitt, och alla kan därför åsidosättas i underklasser. Det definierar också flera publika attribut som kan användas av klienter för att inspektera den analyserade begäran.

Request.full_url

Den ursprungliga URL som skickas till konstruktören.

Ändrad i version 3.4.

Request.full_url är en egenskap med setter, getter och en deleter. Getting full_url returnerar den ursprungliga URL:en för begäran med fragmentet, om det fanns.

Request.type

URI-schema.

Request.host

URI-auktoriteten, vanligtvis en host, men kan också innehålla en port åtskild av ett kolon.

Request.origin_req_host

Den ursprungliga värden för begäran, utan port.

Request.selector

Sökvägen till URI. Om Request använder en proxy, kommer väljaren att vara den fullständiga URL som skickas till proxyn.

Request.data

Entitetskroppen för begäran, eller None om den inte anges.

Ändrad i version 3.4: Ändring av värdet på Request.data raderar nu ”Content-Length”-rubriken om den tidigare var inställd eller beräknad.

Request.unverifiable

boolean, anger om begäran är overifierbar enligt definitionen i RFC 2965.

Request.method

Den HTTP-förfrågningsmetod som ska användas. Som standard är dess värde None, vilket innebär att get_method() kommer att göra sin normala beräkning av den metod som ska användas. Dess värde kan ställas in (och därmed åsidosätta standardberäkningen i get_method()) antingen genom att tillhandahålla ett standardvärde genom att ställa in det på klassnivå i en Request-underklass, eller genom att skicka ett värde till Request-konstruktören via argumentet method.

Tillagd i version 3.3.

Ändrad i version 3.4: Ett standardvärde kan nu anges i underklasser; tidigare kunde det endast anges via konstruktörsargumentet.

Request.get_method()

Returnerar en sträng som anger HTTP-förfrågningsmetoden. Om Request.method inte är None, returneras dess värde, annars returneras 'GET' om Request.data är None, eller 'POST' om den inte är det. Detta är endast meningsfullt för HTTP-förfrågningar.

Ändrad i version 3.3: get_method tittar nu på värdet av Request.method.

Request.add_header(key, val)

Lägg till en ny header till begäran. Headers ignoreras för närvarande av alla hanterare utom HTTP-hanterare, där de läggs till i listan över headers som skickas till servern. Observera att det inte kan finnas mer än en header med samma namn, och att senare anrop kommer att skriva över tidigare anrop om nyckeln kolliderar. För närvarande innebär detta inte någon förlust av HTTP-funktionalitet, eftersom alla headers som har betydelse när de används mer än en gång har ett (header-specifikt) sätt att få samma funktionalitet med endast en header. Observera att headers som läggs till med den här metoden också läggs till i omdirigerade begäranden.

Request.add_unredirected_header(key, header)

Lägg till ett huvud som inte läggs till i en omdirigerad begäran.

Request.has_header(header)

Returnerar om instansen har den angivna rubriken (kontrollerar både vanlig och oomdirigerad).

Request.remove_header(header)

Ta bort namngiven header från request-instansen (både från vanliga och ej omdirigerade headers).

Tillagd i version 3.4.

Request.get_full_url()

Returnerar den URL som anges i konstruktören.

Ändrad i version 3.4.

Returnerar Request.full_url

Request.set_proxy(host, type)

Förbered begäran genom att ansluta till en proxyserver. host och type kommer att ersätta instansens, och instansens väljare kommer att vara den ursprungliga URL som anges i konstruktören.

Request.get_header(header_name, default=None)

Returnerar värdet för den angivna rubriken. Om rubriken inte finns, returneras standardvärdet.

Request.header_items()

Returnerar en lista med tupler (header_name, header_value) av Request-rubrikerna.

Ändrad i version 3.4: Förfrågningsmetoderna add_data, has_data, get_data, get_type, get_host, get_selector, get_origin_req_host och is_unverifiable som inte längre används sedan 3.3 har tagits bort.

OpenerDirector-objekt

OpenerDirector-instanser har följande metoder:

OpenerDirector.add_handler(handler)

handler bör vara en instans av BaseHandler. Följande metoder söks och läggs till i de möjliga kedjorna (observera att HTTP-fel är ett specialfall). Observera att i det följande ska protocol ersättas med det faktiska protokoll som ska hanteras, t.ex. skulle http_response() vara svarshanteraren för HTTP-protokollet. Även type bör ersättas med den faktiska HTTP-koden, t.ex. http_error_404() hanterar HTTP 404-fel.

  • <protocol>_open() — signal att hanteraren vet hur man öppnar protokoll URL:er.

    Se BaseHandler.<protocol>_open() för mer information.

  • http_error_<type>() — signalerar att hanteraren vet hur man hanterar HTTP-fel med HTTP-felkod typ.

    Se BaseHandler.http_error_<nnn>() för mer information.

  • <protocol>_error() — signal att hanteraren vet hur man hanterar fel från (icke http) protokoll.

  • <protocol>_request() — signalera att hanteraren vet hur man förbehandlar protokoll förfrågningar.

    Se BaseHandler.<protocol>_request() för mer information.

  • <protocol>_response() — signalera att hanteraren vet hur man efterbehandlar protokoll svar.

    Se BaseHandler.<protocol>_response() för mer information.

OpenerDirector.open(url, data=None[, timeout])

Öppnar den angivna url (som kan vara ett request-objekt eller en sträng), och skickar eventuellt den angivna data. Argument, returvärden och undantag är desamma som för urlopen() (som helt enkelt anropar metoden open() på den globala OpenerDirector som för närvarande är installerad). Den valfria parametern timeout anger en timeout i sekunder för blockerande operationer som anslutningsförsöket (om den inte anges kommer den globala standardinställningen för timeout att användas). Timeout-funktionen fungerar faktiskt bara för HTTP-, HTTPS- och FTP-anslutningar.

OpenerDirector.error(proto, *args)

Hantera ett fel i det angivna protokollet. Detta kommer att anropa de registrerade felhanterarna för det angivna protokollet med de angivna argumenten (som är protokollspecifika). HTTP-protokollet är ett specialfall som använder HTTP-svarskoden för att bestämma den specifika felhanteraren; se http_error_<type>()-metoderna i hanterarklasserna.

Returvärden och undantag är desamma som för urlopen().

OpenerDirector-objekt öppnar webbadresser i tre steg:

Den ordning i vilken dessa metoder anropas inom varje steg bestäms genom att sortera hanterarinstanserna.

  1. Varje hanterare med en metod som heter <protocol>_request() har den metoden som anropas för att förbehandla begäran.

  2. Hanterare med en metod som heter <protocol>_open() anropas för att hantera begäran. Detta steg avslutas när en hanterare antingen returnerar ett icke-värde None (dvs. ett svar), eller ger upphov till ett undantag (vanligtvis URLError). Undantag tillåts att spridas.

    Faktum är att ovanstående algoritm först prövas för metoder med namnet default_open(). Om alla sådana metoder returnerar None, upprepas algoritmen för metoder med namn som <protocol>_open(). Om alla sådana metoder returnerar None upprepas algoritmen för metoder med namnet unknown_open().

    Observera att implementeringen av dessa metoder kan innebära anrop av den överordnade OpenerDirector-instansens metoder open() och error().

  3. Varje hanterare med en metod som heter som <protocol>_response() har den metoden som anropas för att efterbehandla svaret.

BaseHandler-objekt

BaseHandler-objekt tillhandahåller ett par metoder som är direkt användbara och andra som är avsedda att användas av härledda klasser. Dessa är avsedda för direkt användning:

BaseHandler.add_parent(director)

Lägg till en direktör som förälder.

BaseHandler.close()

Ta bort eventuella föräldrar.

Följande attribut och metoder bör endast användas av klasser som härrör från BaseHandler.

Anteckning

Konventionen har antagits att subklasser som definierar <protocol>_request() eller <protocol>_response() metoder heter *Processor; alla andra heter *Handler.

BaseHandler.parent

En giltig OpenerDirector, som kan användas för att öppna med ett annat protokoll eller hantera fel.

BaseHandler.default_open(req)

Denna metod är inte definierad i BaseHandler, men underklasser bör definiera den om de vill fånga alla URL:er.

Denna metod, om den är implementerad, kommer att anropas av den överordnade OpenerDirector. Den bör returnera ett filliknande objekt som beskrivs i returvärdet för metoden open() i OpenerDirector, eller None. Den bör ge upphov till URLError, såvida inte något verkligt exceptionellt inträffar (till exempel bör MemoryError inte mappas till URLError).

Denna metod kommer att anropas före någon protokollspecifik öppen metod.

BaseHandler.<protocol>_open(req)

Denna metod är inte definierad i BaseHandler, men underklasser bör definiera den om de vill hantera URL:er med det angivna protokollet.

Denna metod, om den är definierad, kommer att anropas av den överordnade OpenerDirector. Returvärdena bör vara desamma som för default_open().

BaseHandler.unknown_open(req)

Denna metod är inte definierad i BaseHandler, men underklasser bör definiera den om de vill fånga upp alla URL:er som inte har någon specifik registrerad hanterare för att öppna den.

Denna metod, om den implementeras, kommer att anropas av parent OpenerDirector. Returvärdena bör vara desamma som för default_open().

BaseHandler.http_error_default(req, fp, code, msg, hdrs)

Denna metod är inte definierad i BaseHandler, men subklasser bör åsidosätta den om de avser att tillhandahålla en catch-all för annars ohanterade HTTP-fel. Den kommer att anropas automatiskt av den OpenerDirector som får felet, och bör normalt inte anropas under andra omständigheter.

OpenerDirector kommer att anropa denna metod med fem positionella argument:

  1. ett Request-objekt,

  2. ett filliknande objekt med HTTP-feltexten,

  3. den tresiffriga koden för felet, som en sträng,

  4. den för användaren synliga förklaringen av koden, som en sträng, och

  5. rubrikerna för felet, som ett mappningsobjekt.

Returvärden och undantag som tas upp bör vara desamma som för urlopen().

BaseHandler.http_error_<nnn>(req, fp, code, msg, hdrs)

nnn bör vara en tresiffrig HTTP-felkod. Denna metod är inte heller definierad i BaseHandler, men kommer att anropas, om den finns, på en instans av en subklass, när ett HTTP-fel med koden nnn inträffar.

Underklasser bör åsidosätta denna metod för att hantera specifika HTTP-fel.

Argument, returvärden och undantag som tas upp bör vara desamma som för http_error_default().

BaseHandler.<protocol>_request(req)

Denna metod är inte definierad i BaseHandler, men underklasser bör definiera den om de vill förbehandla förfrågningar av det angivna protokollet.

Denna metod, om den är definierad, kommer att anropas av den överordnade OpenerDirector. req kommer att vara ett Request-objekt. Returvärdet bör vara ett Request-objekt.

BaseHandler.<protocol>_response(req, response)

Denna metod är inte definierad i BaseHandler, men underklasser bör definiera den om de vill efterbehandla svar från det angivna protokollet.

Denna metod, om den är definierad, kommer att anropas av den överordnade OpenerDirector. req kommer att vara ett Request-objekt. response kommer att vara ett objekt som implementerar samma gränssnitt som returvärdet för urlopen(). Returvärdet bör implementera samma gränssnitt som returvärdet för urlopen().

HTTPRedirectHandler-objekt

Anteckning

Vissa HTTP-omdirigeringar kräver åtgärder från den här modulens klientkod. Om så är fallet kommer HTTPError att uppstå. Se RFC 2616 för detaljer om den exakta betydelsen av de olika omdirigeringskoderna.

Ett HTTPError-undantag som uppstår av säkerhetsskäl om HTTPRedirectHandler presenteras med en omdirigerad URL som inte är en HTTP-, HTTPS- eller FTP-URL.

HTTPRedirectHandler.redirect_request(req, fp, code, msg, hdrs, newurl)

Returnerar en Request eller None som svar på en omdirigering. Detta anropas av standardimplementeringarna av http_error_30*()-metoderna när en omdirigering tas emot från servern. Om en omdirigering ska ske, returnera en ny Request för att tillåta http_error_30*() att utföra omdirigeringen till newurl. I annat fall, skapa HTTPError om ingen annan hanterare bör försöka hantera denna URL, eller returnera None om du inte kan men en annan hanterare kanske kan.

Anteckning

Standardemplementeringen av denna metod följer inte strikt RFC 2616, som säger att 301- och 302-svar på POST-förfrågningar inte får omdirigeras automatiskt utan bekräftelse från användaren. I verkligheten tillåter webbläsare automatisk omdirigering av dessa svar, genom att ändra POST till en GET, och standardimplementeringen reproducerar detta beteende.

HTTPRedirectHandler.http_error_301(req, fp, code, msg, hdrs)

Omdirigera till URL:en Location: eller URI:. Denna metod anropas av den överordnade OpenerDirector när den får ett HTTP-svar ’moved permanently’.

HTTPRedirectHandler.http_error_302(req, fp, code, msg, hdrs)

Samma sak som http_error_301(), men anropas för svaret ”found”.

HTTPRedirectHandler.http_error_303(req, fp, code, msg, hdrs)

Samma sak som http_error_301(), men kallas för svaret ”see other”.

HTTPRedirectHandler.http_error_307(req, fp, code, msg, hdrs)

Samma som http_error_301(), men kallas för svaret ’temporary redirect’. Det tillåter inte att ändra förfrågningsmetoden från POST till GET.

HTTPRedirectHandler.http_error_308(req, fp, code, msg, hdrs)

Samma som http_error_301(), men kallas för svaret ’permanent redirect’. Det tillåter inte att ändra förfrågningsmetoden från POST till GET.

Tillagd i version 3.11.

HTTPCookieProcessor-objekt

HTTPCookieProcessor-instanser har ett attribut:

HTTPCookieProcessor.cookiejar

Den http.cookiejar.CookieJar i vilken cookies lagras.

ProxyHandler-objekt

ProxyHandler.<protocol>_open(request)

ProxyHandler kommer att ha en metod <protocol>_open() för varje protokoll som har en proxy i proxies-ordlistan som ges i konstruktören. Metoden kommer att ändra förfrågningar så att de går genom proxyn, genom att anropa request.set_proxy(), och anropa nästa hanterare i kedjan för att faktiskt exekvera protokollet.

HTTPPasswordMgr-objekt

Dessa metoder är tillgängliga för objekten HTTPPasswordMgr och HTTPPasswordMgrWithDefaultRealm.

HTTPPasswordMgr.add_password(realm, uri, user, passwd)

uri kan vara antingen en enskild URI eller en sekvens av URI:er. realm, user och passwd måste vara strängar. Detta gör att (user, passwd) används som autentiseringstoken när autentisering för realm och en super-URI för någon av de angivna URI:erna anges.

HTTPPasswordMgr.find_user_password(realm, authuri)

Hämta användare/lösenord för given realm och URI, om någon. Denna metod returnerar (None, None) om det inte finns någon matchande användare/lösenord.

För HTTPPasswordMgrWithDefaultRealm-objekt kommer sfären None att sökas om den angivna sfären inte har någon matchande användare/lösenord.

HTTPPasswordMgrWithPriorAuth Objekt

Denna lösenordshanterare utökar HTTPPasswordMgrWithDefaultRealm för att stödja spårning av URI:er för vilka autentiseringsuppgifter alltid ska skickas.

HTTPPasswordMgrWithPriorAuth.add_password(realm, uri, user, passwd, is_authenticated=False)

realm, uri, user, passwd är som för HTTPPasswordMgr.add_password(). is_authenticated anger det initiala värdet för flaggan is_authenticated för den angivna URI:n eller listan med URI:er. Om is_authenticated anges som True ignoreras realm.

HTTPPasswordMgrWithPriorAuth.find_user_password(realm, authuri)

Samma som för HTTPPasswordMgrWithDefaultRealm-objekt

HTTPPasswordMgrWithPriorAuth.update_authenticated(self, uri, is_authenticated=False)

Uppdaterar flaggan is_authenticated för den angivna uri eller listan med URI:er.

HTTPPasswordMgrWithPriorAuth.is_authenticated(self, authuri)

Returnerar det aktuella läget för flaggan is_authenticated för den angivna URI:n.

AbstractBasicAuthHandler-objekt

AbstractBasicAuthHandler.http_error_auth_reqed(authreq, host, req, headers)

Hantera en autentiseringsbegäran genom att hämta ett par av användare/lösenord och försöka igen. authreq ska vara namnet på rubriken där informationen om sfären ingår i begäran, host anger URL och sökväg för autentisering, req ska vara det (misslyckade) Request-objektet och headers ska vara felrubrikerna.

host är antingen en auktoritet (t.ex. "python.org") eller en URL som innehåller en auktoritetskomponent (t.ex. "http://python.org/"). I båda fallen får auktoriteten inte innehålla en userinfo-komponent (så "python.org" och "python.org:80" är bra, "joe:password@python.org" är det inte).

HTTPBasicAuthHandler-objekt

HTTPBasicAuthHandler.http_error_401(req, fp, code, msg, hdrs)

Försök igen med autentiseringsinformation, om sådan finns tillgänglig.

ProxyBasicAuthHandler-objekt

ProxyBasicAuthHandler.http_error_407(req, fp, code, msg, hdrs)

Försök igen med autentiseringsinformation, om sådan finns tillgänglig.

AbstractDigestAuthHandler-objekt

AbstractDigestAuthHandler.http_error_auth_reqed(authreq, host, req, headers)

authreq ska vara namnet på det huvud där informationen om sfären inkluderas i begäran, host ska vara värden att autentisera sig mot, req ska vara det (misslyckade) Request-objektet och headers ska vara felhuvudena.

HTTPDigestAuthHandler-objekt

HTTPDigestAuthHandler.http_error_401(req, fp, code, msg, hdrs)

Försök igen med autentiseringsinformation, om sådan finns tillgänglig.

ProxyDigestAuthHandler-objekt

ProxyDigestAuthHandler.http_error_407(req, fp, code, msg, hdrs)

Försök igen med autentiseringsinformation, om sådan finns tillgänglig.

HTTPHandler-objekt

HTTPHandler.http_open(req)

Skicka en HTTP-begäran, som kan vara antingen GET eller POST, beroende på req.data.

HTTPSHandler-objekt

HTTPSHandler.https_open(req)

Skicka en HTTPS-förfrågan, som kan vara antingen GET eller POST, beroende på req.data.

FileHandler-objekt

FileHandler.file_open(req)

Öppna filen lokalt om det inte finns något värdnamn eller om värdnamnet är 'localhost.

Ändrad i version 3.2: Denna metod är endast tillämplig för lokala värdnamn. När ett fjärrvärddatornamn anges, uppstår ett URLError.

DataHandler-objekt

DataHandler.data_open(req)

Läs en data-URL. Denna typ av URL innehåller innehållet som är kodat i själva URL:en. Syntaxen för data-URL:er anges i RFC 2397. Den här implementationen ignorerar blanksteg i base64-kodade data-URL:er så att URL:en kan förpackas i vilken källfil den än kommer ifrån. Men även om vissa webbläsare inte bryr sig om att det saknas mellanslag i slutet av en base64-kodad data-URL, kommer den här implementationen att ge upphov till ett ValueError i så fall.

FTPHandler-objekt

FTPHandler.ftp_open(req)

Öppna den FTP-fil som anges med req. Inloggningen sker alltid med tomt användarnamn och lösenord.

CacheFTPHandler-objekt

CacheFTPHandler-objekt är FTPHandler-objekt med följande ytterligare metoder:

CacheFTPHandler.setTimeout(t)

Ställ in timeout för anslutningar till t sekunder.

CacheFTPHandler.setMaxConns(m)

Ställ in maximalt antal cachade anslutningar till m.

UnknownHandler-objekt

UnknownHandler.unknown_open()

Utlöser ett URLError undantag.

HTTPErrorProcessor-objekt

HTTPErrorProcessor.http_response(request, response)

Behandla HTTP-felsvar.

För 200-felkoder returneras svarsobjektet omedelbart.

För felkoder som inte är 200 skickas jobbet helt enkelt vidare till hanteringsmetoderna http_error_<type>(), via OpenerDirector.error(). I slutändan kommer HTTPDefaultErrorHandler att skapa en HTTPError om ingen annan hanterare hanterar felet.

HTTPErrorProcessor.https_response(request, response)

Behandla HTTPS-felsvar.

Beteendet är detsamma som http_response().

Exempel

Förutom exemplen nedan finns fler exempel i Så här hämtar du internetresurser med urllib-paketet.

Detta exempel hämtar huvudsidan för python.org och visar de första 300 byte av den:

>>> import urllib.request
>>> with urllib.request.urlopen('http://www.python.org/') as f:
...     print(f.read(300))
...
b'<!doctype html>\n<!--[if lt IE 7]>   <html class="no-js ie6 lt-ie7 lt-ie8 lt-ie9">   <![endif]-->\n<!--[if IE 7]>      <html class="no-js ie7 lt-ie8 lt-ie9">          <![endif]-->\n<!--[if IE 8]>      <html class="no-js ie8 lt-ie9">

Observera att urlopen returnerar ett bytes-objekt. Detta beror på att det inte finns något sätt för urlopen att automatiskt bestämma kodningen av byteströmmen som den tar emot från HTTP-servern. I allmänhet kommer ett program att avkoda det returnerade bytes-objektet till en sträng när det har bestämt eller gissat sig för lämplig kodning.

I följande HTML-specifikationsdokument, https://html.spec.whatwg.org/#charset, listas de olika sätt på vilka ett HTML- eller XML-dokument kan ha specificerat sin kodningsinformation.

För ytterligare information, se W3C-dokumentet: https://www.w3.org/International/questions/qa-html-encoding-declarations.

Eftersom webbplatsen python.org använder utf-8 kodning enligt specifikationen i dess metatagg, kommer vi att använda samma för att avkoda bytesobjektet:

>>> with urllib.request.urlopen('http://www.python.org/') as f:
...     print(f.read(100).decode('utf-8'))
...
<!doctype html>
<!--[if lt IE 7]>   <html class="no-js ie6 lt-ie7 lt-ie8 lt-ie9">   <![endif]-->
<!-

Det är också möjligt att uppnå samma resultat utan att använda context manager:

>>> import urllib.request
>>> f = urllib.request.urlopen('http://www.python.org/')
>>> try:
...     print(f.read(100).decode('utf-8'))
... finally:
...     f.close()
...
<!doctype html>
<!--[if lt IE 7]>   <html class="no-js ie6 lt-ie7 lt-ie8 lt-ie9">   <![endif]-->
<!--

I följande exempel skickar vi en dataström till stdin på en CGI och läser de data som den returnerar till oss. Observera att det här exemplet bara fungerar om Python-installationen stöder SSL.

>>> import urllib.request
>>> req = urllib.request.Request(url='https://localhost/cgi-bin/test.cgi',
...                       data=b'This data is passed to stdin of the CGI')
>>> with urllib.request.urlopen(req) as f:
...     print(f.read().decode('utf-8'))
...
Got Data: "This data is passed to stdin of the CGI"

Koden för den exempel-CGI som används i exemplet ovan är:

#!/usr/bin/env python
import sys
data = sys.stdin.read()
print('Content-type: text/plain\n\nGot Data: "%s"' % data)

Här är ett exempel på hur man gör en PUT förfrågan med Request:

import urllib.request
DATA = b'några data'
req = urllib.request.Request(url='http://localhost:8080', data=DATA, method='PUT')
med urllib.request.urlopen(req) som f:
    pass
print(f.status)
print(f.reason)

Användning av grundläggande HTTP-autentisering:

import urllib.request
# Create an OpenerDirector with support for Basic HTTP Authentication...
auth_handler = urllib.request.HTTPBasicAuthHandler()
auth_handler.add_password(realm='PDQ Application',
                          uri='https://mahler:8092/site-updates.py',
                          user='klem',
                          passwd='kadidd!ehopper')
opener = urllib.request.build_opener(auth_handler)
# ...and install it globally so it can be used with urlopen.
urllib.request.install_opener(opener)
with urllib.request.urlopen('http://www.example.com/login.html') as f:
    print(f.read().decode('utf-8'))

build_opener() tillhandahåller många hanterare som standard, inklusive en ProxyHandler. Som standard använder ProxyHandler miljövariablerna med namnet <scheme>_proxy, där <scheme> är det aktuella URL-schemat. Till exempel läses miljövariabeln http_proxy för att få HTTP-proxyns URL.

Detta exempel ersätter standard ProxyHandler med en som använder programmatiskt angivna proxy-URL:er och lägger till stöd för proxyauktorisering med ProxyBasicAuthHandler.

proxy_handler = urllib.request.ProxyHandler({'http': 'http://www.example.com:3128/'})
proxy_auth_handler = urllib.request.ProxyBasicAuthHandler()
proxy_auth_handler.add_password('realm', 'host', 'username', 'password')

opener = urllib.request.build_opener(proxy_handler, proxy_auth_handler)
# Den här gången använder vi OpenerDirector direkt i stället för att installera den:
med opener.open('http://www.example.com/login.html') som f:
   print(f.read().decode('utf-8'))

Lägga till HTTP-rubriker:

Använd headers-argumentet till Request-konstruktören, eller:

import urllib.request
req = urllib.request.Request('http://www.example.com/')
req.add_header('Referer', 'http://www.python.org/')
# Anpassa standardvärdet för User-Agent-huvudet:
req.add_header('User-Agent', 'urllib-example/0.1 (Kontakt: . . .)')
med urllib.request.urlopen(req) som f:
    print(f.read().decode('utf-8'))

OpenerDirector lägger automatiskt till en User-Agent header till varje Request. För att ändra detta:

import urllib.request
opener = urllib.request.build_opener()
opener.addheaders = [('User-agent', 'Mozilla/5.0')]
med opener.open('http://www.example.com/') som f:
   print(f.read().decode('utf-8'))

Kom också ihåg att några standardrubriker (Content-Length, Content-Type och Host) läggs till när Request skickas till urlopen() (eller OpenerDirector.open()).

Här är ett exempel på en session som använder metoden GET för att hämta en URL som innehåller parametrar:

>>> import urllib.request
>>> import urllib.parse
>>> params = urllib.parse.urlencode({'spam': 1, 'eggs': 2, 'bacon': 0})
>>> url = "http://www.musi-cal.com/cgi-bin/query?%s" % params
>>> with urllib.request.urlopen(url) as f:
...     print(f.read().decode('utf-8'))
...

I följande exempel används istället metoden POST. Notera att params-utdata från urlencode kodas till bytes innan det skickas till urlopen som data:

>>> import urllib.request
>>> import urllib.parse
>>> data = urllib.parse.urlencode({'spam': 1, 'eggs': 2, 'bacon': 0})
>>> data = data.encode('ascii')
>>> with urllib.request.urlopen("http://requestb.in/xrbl82xr", data) as f:
...     print(f.read().decode('utf-8'))
...

I följande exempel används en explicit angiven HTTP-proxy som åsidosätter miljöinställningarna:

>>> import urllib.request
>>> proxies = {'http': 'http://proxy.example.com:8080/'}
>>> opener = urllib.request.build_opener(urllib.request.ProxyHandler(proxies))
>>> with opener.open("http://www.python.org") as f:
...     f.read().decode('utf-8')
...

I följande exempel används inga proxyservrar alls, utan miljöinställningarna åsidosätts:

>>> import urllib.request
>>> opener = urllib.request.build_opener(urllib.request.ProxyHandler({}}))
>>> with opener.open("http://www.python.org/") as f:
...     f.read().decode('utf-8')
...

Äldre gränssnitt

Följande funktioner och klasser är portade från Python 2-modulen urllib (i motsats till urllib2). De kan komma att bli föråldrade någon gång i framtiden.

urllib.request.urlretrieve(url, filename=None, reporthook=None, data=None)

Kopierar ett nätverksobjekt som anges med en URL till en lokal fil. Om URL:en pekar på en lokal fil kommer objektet inte att kopieras om inte filnamnet anges. Returnerar en tupel (filename, headers) där filnamn är det lokala filnamnet under vilket objektet kan hittas, och headers är vad info()-metoden för objektet som returnerades av urlopen() returnerade (för ett fjärrobjekt). Undantag är desamma som för urlopen().

Det andra argumentet, om det finns, anger den filplats som ska kopieras till (om det inte finns någon plats kommer platsen att vara en tempfil med ett genererat namn). Det tredje argumentet, om det finns, är en callable som kommer att anropas en gång när nätverksanslutningen upprättas och en gång efter varje block som läses därefter. Anropet får tre argument: ett antal block som hittills har överförts, blockstorleken i byte och filens totala storlek. Det tredje argumentet kan vara -1 på äldre FTP-servrar som inte returnerar en filstorlek som svar på en hämtningsbegäran.

Följande exempel illustrerar det vanligaste användningsscenariot:

>>> import urllib.request
>>> local_filename, headers = urllib.request.urlretrieve('http://python.org/')
>>> html = open(local_filename)
>>> html.close()

Om url använder schemaidentifieraren http: kan det valfria data-argumentet anges för att specificera en POST-begäran (normalt är begärandetypen GET). Argumentet data måste vara ett bytesobjekt i standardformatet application/x-www-form-urlencoded; se funktionen urllib.parse.urlencode().

urlretrieve() ger upphov till ContentTooShortError när den upptäcker att mängden tillgängliga data var mindre än den förväntade mängden (vilket är den storlek som rapporteras av en Content-Length-header). Detta kan t.ex. inträffa när nedladdningen avbryts.

Content-Length behandlas som en nedre gräns: om det finns mer data att läsa, läser urlretrieve mer data, men om mindre data finns tillgängliga, uppstår ett undantag.

Du kan fortfarande hämta de nedladdade uppgifterna i det här fallet, de lagras i attributet content i undantagsinstansen.

Om ingen Content-Length-header har angetts kan urlretrieve inte kontrollera storleken på de data den har hämtat, utan returnerar dem bara. I det här fallet får man anta att nedladdningen lyckades.

urllib.request.urlcleanup()

Rensar bort temporära filer som kan ha lämnats kvar av tidigare anrop till urlretrieve().

Begränsningar i urllib.request

  • För närvarande stöds endast följande protokoll: HTTP (version 0.9 och 1.0), FTP, lokala filer och data-URL:er.

    Ändrad i version 3.4: Stöd för data-URL:er har lagts till.

  • Cachningsfunktionen i urlretrieve() har inaktiverats tills någon hittar tid att hacka korrekt bearbetning av Expiration time-rubriker.

  • Det bör finnas en funktion för att fråga om en viss URL finns i cacheminnet.

  • Om en URL verkar peka på en lokal fil men filen inte kan öppnas tolkas URL:en på nytt med FTP-protokollet av bakåtkompatibilitetsskäl. Detta kan ibland orsaka förvirrande felmeddelanden.

  • Funktionerna urlopen() och urlretrieve() kan orsaka godtyckligt långa fördröjningar i väntan på att en nätverksanslutning skall upprättas. Detta innebär att det är svårt att bygga en interaktiv webbklient med hjälp av dessa funktioner utan att använda trådar.

  • De data som returneras av urlopen() eller urlretrieve() är de rådata som returneras av servern. Det kan vara binära data (t.ex. en bild), vanlig text eller (t.ex.) HTML. HTTP-protokollet tillhandahåller typinformation i svarshuvudet, som kan inspekteras genom att titta på Content-Type -huvudet. Om de returnerade uppgifterna är HTML kan du använda modulen html.parser för att analysera dem.

  • Koden som hanterar FTP-protokollet kan inte skilja mellan en fil och en katalog. Detta kan leda till oväntat beteende när man försöker läsa en URL som pekar på en fil som inte är tillgänglig. Om URL:en slutar med / antas den hänvisa till en katalog och hanteras därefter. Men om ett försök att läsa en fil leder till ett 550-fel (vilket innebär att URL:en inte kan hittas eller inte är tillgänglig, ofta av behörighetsskäl), behandlas sökvägen som en katalog för att hantera fallet när en katalog anges av en URL men den efterföljande / har utelämnats. Detta kan leda till missvisande resultat när du försöker hämta en fil som inte kan läsas på grund av läsbehörigheter. FTP-koden försöker läsa den, misslyckas med ett 550-fel och utför sedan en kataloglistning för den oläsbara filen. Om du behöver mer detaljerad kontroll bör du överväga att använda modulen ftplib.

urllib.response — Svarsklasser som används av urllib

Modulen urllib.response definierar funktioner och klasser som definierar ett minimalt filliknande gränssnitt, inklusive read() och readline(). Funktioner som definieras av denna modul används internt av modulen urllib.request. Det typiska svarsobjektet är en urllib.response.addinfourl-instans:

class urllib.response.addinfourl
url

URL för den hämtade resursen, används vanligen för att avgöra om en omdirigering följdes.

headers

Returnerar svarets rubriker i form av en EmailMessage-instans.

status

Tillagd i version 3.9.

Statuskod som returneras av servern.

geturl()

Föråldrad sedan version 3.9: Föråldrad till förmån för url.

info()

Föråldrad sedan version 3.9: Föråldrad till förmån för headers.

code

Föråldrad sedan version 3.9: Föråldrad till förmån för status.

getcode()

Föråldrad sedan version 3.9: Föråldrad till förmån för status.