urllib.parse — Dela upp URL:er i komponenter

Källkod: Lib/urllib/parse.py

---

Denna modul definierar ett standardgränssnitt för att bryta upp URL-strängar (Uniform Resource Locator) i komponenter (adresseringsschema, nätverksplats, sökväg etc.), för att kombinera komponenterna tillbaka till en URL-sträng och för att konvertera en ”relativ URL” till en absolut URL givet en ”bas-URL”

Modulen har utformats så att den överensstämmer med Internet RFC om Relative Uniform Resource Locators. Den stöder följande URL-scheman: file, ftp, gopher, hdl, http, https, imap, itms-services, mailto, mms, news, nntp, prospero, rsync, rtsp, rtsps, rtspu, ftp, shttp,sip, sips, news, svn, svn+ssh, telnet, wais,ws, wsss.

Inkluderingen av URL-schemat itms-services kan förhindra att en app passerar Apples granskningsprocess för App Store för macOS och iOS App Stores. Hantering för itms-services-schema tas alltid bort på iOS; på macOS kan det tas bort om CPython har byggts med --with-app-store-compliance-alternativet.

Modulen urllib.parse definierar funktioner som faller inom två breda kategorier: URL-parsning och URL-citering. Dessa behandlas i detalj i följande avsnitt.

Funktionerna i denna modul använder den föråldrade termen netloc (eller net_loc), som introducerades i RFC 1808. Denna term har dock föråldrats av RFC 3986, som introducerade termen authority som dess ersättare. Användningen av netloc fortsätter för bakåtkompatibilitet.

Parsning av URL

URL-parsingfunktionerna fokuserar på att dela upp en URL-sträng i dess komponenter eller på att kombinera URL-komponenter till en URL-sträng.

urllib.parse.urlparse(urlstring, scheme='', allow_fragments=True)

Analyserar en URL i sex komponenter och returnerar en named tuple med 6 objekt. Detta motsvarar den allmänna strukturen i en URL: scheme://netloc/path;parameters?query#fragment. Varje tuple-element är en sträng, eventuellt tom. Komponenterna är inte uppdelade i mindre delar (t.ex. är nätverksplatsen en enda sträng) och % escapes är inte expanderade. De avgränsningstecken som visas ovan ingår inte i resultatet, med undantag för ett inledande snedstreck i komponenten path, som behålls om det finns. Till exempel

>>> from urllib.parse import urlparse
>>> urlparse("scheme://netloc/path;parameters?query#fragment")
ParseResult(scheme='scheme', netloc='netloc', path='/path;parameters', params='',
            query='query', fragment='fragment')
>>> o = urlparse("http://docs.python.org:80/3/library/urllib.parse.html?"
...              "highlight=params#url-parsing")
>>> o
ParseResult(scheme='http', netloc='docs.python.org:80',
            path='/3/library/urllib.parse.html', params='',
            query='highlight=params', fragment='url-parsing')
>>> o.scheme
'http'
>>> o.netloc
'docs.python.org:80'
>>> o.hostname
'docs.python.org'
>>> o.port
80
>>> o._replace(fragment="").geturl()
'http://docs.python.org:80/3/library/urllib.parse.html?highlight=params'

I enlighet med syntaxspecifikationerna i RFC 1808, känner urlparse igen en netloc endast om den introduceras korrekt av ’//’. Annars antas indata vara en relativ URL och därmed börja med en sökvägskomponent.

>>> from urllib.parse import urlparse
>>> urlparse('//www.cwi.nl:80/%7Eguido/Python.html')
ParseResult(scheme='', netloc='www.cwi.nl:80', path='/%7Eguido/Python.html',
            params='', query='', fragment='')
>>> urlparse('www.cwi.nl/%7Eguido/Python.html')
ParseResult(scheme='', netloc='', path='www.cwi.nl/%7Eguido/Python.html',
            params='', query='', fragment='')
>>> urlparse('help/Python.html')
ParseResult(scheme='', netloc='', path='help/Python.html', params='',
            query='', fragment='')

Argumentet scheme anger standardadresseringsschemat, som endast ska användas om URL:en inte anger något. Det bör vara av samma typ (text eller bytes) som urlstring, förutom att standardvärdet '' alltid tillåts och automatiskt konverteras till b'' om så är lämpligt.

Om argumentet allow_fragments är false identifieras inte fragmentidentifierare. Istället analyseras de som en del av sökvägen, parametrarna eller frågekomponenten, och fragment sätts till den tomma strängen i returvärdet.

Returvärdet är en named tuple, vilket innebär att dess objekt kan nås via index eller som namngivna attribut, vilka är:

Attribut	Index	Värde	Värde om inte närvarande
scheme	0	Specificering av URL-schema	schema parameter
netloc	1	Nätverkslokaliseringsdel	tom sträng
sökväg	2	Hierarkisk väg	tom sträng
params	3	Parametrar för sista banelementet	tom sträng
query	4	Fråga komponent	tom sträng
fragment	5	Identifierare för fragment	tom sträng
användarnamn		Användarnamn	None
lösenord		Lösenord	None
hostname		Värdnamn (gemener)	None
port		Portnummer som heltal, om det finns	None

Att läsa attributet port kommer att ge upphov till ett ValueError om en ogiltig port anges i URL:en. Se avsnitt Resultat av strukturerad parsning för mer information om resultatobjektet.

Omatchade hakparenteser i attributet netloc kommer att ge upphov till ett ValueError.

Tecken i attributet netloc som sönderdelas enligt NFKC-normalisering (som används av IDNA-kodningen) till något av /, ?, #, @ eller : kommer att ge upphov till ett ValueError. Om URL:en bryts ned innan den analyseras kommer inget fel att uppstå.

Precis som för alla namngivna tupler har subklassen några ytterligare metoder och attribut som är särskilt användbara. En sådan metod är _replace(). Metoden _replace() returnerar ett nytt ParseResult-objekt som ersätter angivna fält med nya värden.

>>> from urllib.parse import urlparse
>>> u = urlparse('//www.cwi.nl:80/%7Eguido/Python.html')
>>> u
ParseResult(scheme='', netloc='www.cwi.nl:80', path='/%7Eguido/Python.html',
            params='', query='', fragment='')
>>> u._replace(scheme='http')
ParseResult(scheme='http', netloc='www.cwi.nl:80', path='/%7Eguido/Python.html',
            params='', query='', fragment='')

Varning

urlparse() utför inte validering. Se URL parsing security för mer information.

Ändrad i version 3.2: Funktioner för analys av IPv6-URL:er har lagts till.

Ändrad i version 3.3: Fragmentet analyseras nu för alla URL-scheman (om inte allow_fragments är false), i enlighet med RFC 3986. Tidigare fanns det en lista över scheman som stödde fragment.

Ändrad i version 3.6: Portnummer utanför intervallet ger nu upphov till ValueError, istället för att returnera None.

Ändrad i version 3.8: Tecken som påverkar netloc-parsning under NFKC-normalisering kommer nu att ge upphov till ValueError.

urllib.parse.parse_qs(qs, keep_blank_values=False, strict_parsing=False, encoding='utf-8', errors='replace', max_num_fields=None, separator='&')

Analyserar en frågesträng som anges som ett strängargument (data av typen application/x-www-form-urlencoded). Data returneras som en ordbok. Nycklarna i ordboken är de unika namnen på frågevariablerna och värdena är listor med värden för varje namn.

Det valfria argumentet keep_blank_values är en flagga som anger om tomma värden i procentkodade frågor ska behandlas som tomma strängar. Ett true-värde anger att tomma värden ska behållas som tomma strängar. Standardvärdet false anger att tomma värden ska ignoreras och behandlas som om de inte fanns med.

Det valfria argumentet strict_parsing är en flagga som anger vad som ska göras med parsingfel. Om false (standard) ignoreras felen i tysthet. Om true, ger felen upphov till ett ValueError undantag.

De valfria parametrarna encoding och errors anger hur procentkodade sekvenser ska avkodas till Unicode-tecken, vilket accepteras av metoden bytes.decode().

Det valfria argumentet max_num_fields är det maximala antalet fält som ska läsas. Om det är inställt, kastas ett ValueError om det finns fler än max_num_fields fält lästa.

Det valfria argumentet separator är den symbol som ska användas för att separera frågeargumenten. Standardvärdet är &.

Använd funktionen urllib.parse.urlencode() (med parametern doseq satt till True) för att konvertera sådana ordlistor till frågesträngar.

Ändrad i version 3.2: Lägg till parametrarna encoding och errors.

Ändrad i version 3.8: Lagt till parametern max_num_fields.

Ändrad i version 3.10: Lagt till parametern separator med standardvärdet &. Python-versioner tidigare än Python 3.10 tillät användning av både ; och & som separator för frågeparametrar. Detta har ändrats så att endast en enda separatornyckel tillåts, med & som standardseparator.

Föråldrad sedan version 3.14: Att acceptera objekt med falska värden (som 0 och []) förutom tomma strängar och byte-liknande objekt och None är nu föråldrat.

urllib.parse.parse_qsl(qs, keep_blank_values=False, strict_parsing=False, encoding='utf-8', errors='replace', max_num_fields=None, separator='&')

Analyserar en frågesträng som anges som ett strängargument (data av typen application/x-www-form-urlencoded). Data returneras som en lista med namn- och värdepar.

Det valfria argumentet keep_blank_values är en flagga som anger om tomma värden i procentkodade frågor ska behandlas som tomma strängar. Ett true-värde anger att tomma värden ska behållas som tomma strängar. Standardvärdet false anger att tomma värden ska ignoreras och behandlas som om de inte fanns med.

Det valfria argumentet strict_parsing är en flagga som anger vad som ska göras med parsingfel. Om false (standard) ignoreras felen i tysthet. Om true, ger felen upphov till ett ValueError undantag.

De valfria parametrarna encoding och errors anger hur procentkodade sekvenser ska avkodas till Unicode-tecken, vilket accepteras av metoden bytes.decode().

Det valfria argumentet max_num_fields är det maximala antalet fält som ska läsas. Om det är inställt, kastas ett ValueError om det finns fler än max_num_fields fält lästa.

Det valfria argumentet separator är den symbol som ska användas för att separera frågeargumenten. Standardvärdet är &.

Använd funktionen urllib.parse.urlencode() för att konvertera sådana listor med par till frågesträngar.

Ändrad i version 3.2: Lägg till parametrarna encoding och errors.

Ändrad i version 3.8: Lagt till parametern max_num_fields.

Ändrad i version 3.10: Lagt till parametern separator med standardvärdet &. Python-versioner tidigare än Python 3.10 tillät användning av både ; och & som separator för frågeparametrar. Detta har ändrats så att endast en enda separatornyckel tillåts, med & som standardseparator.

urllib.parse.urlunparse(parts)

Konstruerar en URL från en tupel som returneras av urlparse(). Argumentet parts kan vara en valfri iterabel med sex punkter. Detta kan resultera i en något annorlunda, men likvärdig URL, om den URL som analyserades ursprungligen hade onödiga avgränsare (till exempel en ? med en tom fråga; RFC anger att dessa är likvärdiga).

urllib.parse.urlsplit(urlstring, scheme='', allow_fragments=True)

Detta liknar urlparse(), men delar inte upp parametrarna från URL:en. Detta bör i allmänhet användas istället för urlparse() om man vill använda den nyare URL-syntaxen som tillåter att parametrar tillämpas på varje segment av sökväg-delen av URL:en (se RFC 2396). En separat funktion behövs för att separera sökvägssegmenten och parametrarna. Denna funktion returnerar en 5-punkts named tuple:

(adresseringsschema, nätverksplats, sökväg, fråga, fragmentidentifierare).

Returvärdet är en named tuple, vars objekt kan nås via index eller som namngivna attribut:

Attribut	Index	Värde	Värde om inte närvarande
scheme	0	Specificering av URL-schema	schema parameter
netloc	1	Nätverkslokaliseringsdel	tom sträng
sökväg	2	Hierarkisk väg	tom sträng
query	3	Fråga komponent	tom sträng
fragment	4	Identifierare för fragment	tom sträng
användarnamn		Användarnamn	None
lösenord		Lösenord	None
hostname		Värdnamn (gemener)	None
port		Portnummer som heltal, om det finns	None

Att läsa attributet port kommer att ge upphov till ett ValueError om en ogiltig port anges i URL:en. Se avsnitt Resultat av strukturerad parsning för mer information om resultatobjektet.

Omatchade hakparenteser i attributet netloc kommer att ge upphov till ett ValueError.

Tecken i attributet netloc som sönderdelas enligt NFKC-normalisering (som används av IDNA-kodningen) till något av /, ?, #, @ eller : kommer att ge upphov till ett ValueError. Om URL:en bryts ned innan den analyseras kommer inget fel att uppstå.

Enligt en del av WHATWG spec som uppdaterar RFC 3986, tas ledande C0-kontroll- och mellanslagstecken bort från URL:en. tecknen ”n”, ”r” och ”tab” tas bort från URL:en på alla positioner.

Varning

urlsplit() utför inte validering. Se URL parsing security för detaljer.

Ändrad i version 3.6: Portnummer utanför intervallet ger nu upphov till ValueError, istället för att returnera None.

Ändrad i version 3.8: Tecken som påverkar netloc-parsning under NFKC-normalisering kommer nu att ge upphov till ValueError.

Ändrad i version 3.10: ASCII-tecken för nya rader och tabbar tas bort från URL:en.

Ändrad i version 3.12: Ledande WHATWG C0-kontroll- och mellanslagstecken tas bort från URL:en.

urllib.parse.urlunsplit(parts)

Kombinerar elementen i en tupel som returneras av urlsplit() till en komplett URL som en sträng. Argumentet parts kan vara en valfri iterabel med fem element. Detta kan resultera i en något annorlunda, men likvärdig URL, om den URL som analyserades ursprungligen hade onödiga avgränsare (till exempel ett ? med en tom fråga; RFC anger att dessa är likvärdiga).

urllib.parse.urljoin(base, url, allow_fragments=True)

Konstruera en fullständig (”absolut”) URL genom att kombinera en ”bas-URL” (base) med en annan URL (url). Informellt används komponenter i bas-URL:en, i synnerhet adresseringsschemat, nätverksplatsen och (en del av) sökvägen, för att tillhandahålla komponenter som saknas i den relativa URL:en. Till exempel

>>> from urllib.parse import urljoin
>>> urljoin('http://www.cwi.nl/%7Eguido/Python.html', 'FAQ.html')
'http://www.cwi.nl/%7Eguido/FAQ.html'

Argumentet allow_fragments har samma betydelse och standard som för urlparse().

Anteckning

Om url är en absolut URL (dvs. den börjar med // eller scheme://) kommer url:s värdnamn och/eller schema att finnas med i resultatet. Till exempel

>>> urljoin('http://www.cwi.nl/%7Eguido/Python.html',
...         '//www.python.org/%7Eguido')
'http://www.python.org/%7Eguido'

Om du inte vill ha det beteendet, förbehandla url med urlsplit() och urlunsplit(), och ta bort eventuella scheme- och netloc-delar.

Varning

Eftersom en absolut URL kan skickas som url-parameter är det i allmänhet inte säkert att använda urljoin med en angriparstyrd url. Till exempel i urljoin("https://website.com/users/", användarnamn), om användarnamn kan innehålla en absolut URL, kommer resultatet av urljoin att vara den absoluta URL:en.

Ändrad i version 3.5: Beteendet uppdaterat för att matcha semantiken som definieras i RFC 3986.

urllib.parse.urldefrag(url)

Om url innehåller en fragmentidentifierare, returneras en modifierad version av url utan fragmentidentifierare, och fragmentidentifieraren som en separat sträng. Om det inte finns någon fragmentidentifierare i url, returneras url omodifierad och en tom sträng.

Returvärdet är en named tuple, vars objekt kan nås via index eller som namngivna attribut:

Attribut	Index	Värde	Värde om inte närvarande
url	0	URL utan fragment	tom sträng
fragment	1	Identifierare för fragment	tom sträng

Se avsnitt Resultat av strukturerad parsning för mer information om resultatobjektet.

Ändrad i version 3.2: Resultatet är ett strukturerat objekt snarare än en enkel 2-tupel.

urllib.parse.unwrap(url)

Extrahera webbadressen från en omsluten URL (dvs. en sträng formaterad som <URL:scheme://host/path>, <scheme://host/path>, URL:scheme://host/path eller scheme://host/path). Om url inte är en omsluten URL returneras den utan ändringar.

Säkerhet för URL-parsning

API:erna urlsplit() och urlparse() utför inte validering av indata. De kanske inte ger upphov till fel på indata som andra program anser vara ogiltiga. De kan också lyckas med vissa inmatningar som kanske inte betraktas som URL:er någon annanstans. Deras syfte är praktisk funktionalitet snarare än renhet.

Istället för att skapa ett undantag vid ovanlig inmatning kan de istället returnera vissa komponentdelar som tomma strängar. Eller så kan komponenterna innehålla mer än de kanske borde.

Vi rekommenderar att användare av dessa API:er där värdena kan användas var som helst med säkerhetsimplikationer kodar defensivt. Gör lite verifiering i din kod innan du litar på en returnerad komponentdel. Är det där schemat vettigt? Är det en vettig väg? Är det något konstigt med det där hostname? etc.

Vad som utgör en URL är inte universellt väldefinierat. Olika applikationer har olika behov och önskade begränsningar. Exempelvis beskriver den levande WHATWG spec vad webbklienter som vänder sig till användare, t.ex. en webbläsare, kräver. Medan RFC 3986 är mer allmän. Dessa funktioner innehåller vissa aspekter av båda, men kan inte påstås överensstämma med någon av dem. API:erna och den befintliga användarkoden med förväntningar på specifika beteenden är äldre än båda standarderna, vilket gör att vi måste vara mycket försiktiga med att ändra API-beteenden.

Parsning av ASCII-kodade byte

URL-parsingfunktionerna var ursprungligen utformade för att endast fungera på teckensträngar. I praktiken är det användbart att kunna manipulera korrekt citerade och kodade webbadresser som sekvenser av ASCII-bytes. Därför använder alla URL-parsingfunktioner i den här modulen bytes och bytearray-objekt utöver str-objekt.

Om str-data skickas in kommer resultatet också att innehålla endast str-data. Om bytes eller bytearray data skickas in, kommer resultatet endast att innehålla bytes data.

Försök att blanda str-data med bytes eller bytearray i ett enda funktionsanrop kommer att resultera i att TypeError tas upp, medan försök att skicka in icke-ASCII-bytevärden kommer att utlösa UnicodeDecodeError.

För att underlätta konvertering av resultatobjekt mellan str och bytes innehåller alla returvärden från URL-parsingfunktioner antingen en encode()-metod (när resultatet innehåller str-data) eller en decode()-metod (när resultatet innehåller bytes-data). Dessa metoder har samma signaturer som motsvarande metoder str och bytes (förutom att standardkodningen är 'ascii' i stället för 'utf-8'). Var och en producerar ett värde av motsvarande typ som innehåller antingen bytes-data (för encode()-metoder) eller str-data (för decode()-metoder).

Program som behöver arbeta med URL-adresser som kan vara felaktigt citerade och som kan innehålla icke-ASCII-data måste göra sin egen avkodning från bytes till tecken innan URL-parsningsmetoderna anropas.

Det beteende som beskrivs i detta avsnitt gäller endast för URL-parsing-funktionerna. URL-citeringsfunktionerna använder sina egna regler när de producerar eller konsumerar byte-sekvenser, vilket beskrivs i dokumentationen för de enskilda URL-citeringsfunktionerna.

Ändrad i version 3.2: URL-parsingfunktioner accepterar nu ASCII-kodade byte-sekvenser

Resultat av strukturerad parsning

Resultatobjekten från funktionerna urlparse(), urlsplit() och urldefrag() är subklasser av typen tuple. Dessa subklasser lägger till de attribut som anges i dokumentationen för dessa funktioner, det stöd för kodning och avkodning som beskrivs i föregående avsnitt, samt ytterligare en metod:

urllib.parse.SplitResult.geturl()

Returnerar den omkombinerade versionen av den ursprungliga URL:en som en sträng. Denna kan skilja sig från den ursprungliga URL:en genom att schemat kan normaliseras till gemener och tomma komponenter kan tas bort. Specifikt kommer tomma parametrar, frågor och fragmentidentifierare att tas bort.

För urldefrag()-resultat kommer endast tomma fragmentidentifierare att tas bort. För urlsplit() och urlparse() resultat, kommer alla noterade ändringar att göras i URL:en som returneras av denna metod.

Resultatet av denna metod förblir oförändrat om det skickas tillbaka genom den ursprungliga parsingfunktionen:

>>> from urllib.parse import urlsplit
>>> url = 'HTTP://www.Python.org/doc/#'
>>> r1 = urlsplit(url)
>>> r1.geturl()
'http://www.Python.org/doc/'
>>> r2 = urlsplit(r1.geturl())
>>> r2.geturl()
'http://www.Python.org/doc/'

Följande klasser innehåller implementeringar av strukturerade parseresultat när de används på str-objekt:

class urllib.parse.DefragResult(url, fragment)

Konkret klass för urldefrag()-resultat som innehåller str-data. Metoden encode() returnerar en instans av DefragResultBytes.

Tillagd i version 3.2.

class urllib.parse.ParseResult(scheme, netloc, path, params, query, fragment)

Konkret klass för urlparse()-resultat som innehåller str-data. Metoden encode() returnerar en instans av ParseResultBytes.

class urllib.parse.SplitResult(scheme, netloc, path, query, fragment)

Konkret klass för urlsplit()-resultat som innehåller str-data. Metoden encode() returnerar en instans av SplitResultBytes.

Följande klasser innehåller implementeringar av analysresultaten när de används på objekt av typen bytes eller bytearray:

class urllib.parse.DefragResultBytes(url, fragment)

Konkret klass för urldefrag()-resultat som innehåller bytes-data. Metoden decode() returnerar en instans av DefragResult.

Tillagd i version 3.2.

class urllib.parse.ParseResultBytes(scheme, netloc, path, params, query, fragment)

Konkret klass för urlparse()-resultat som innehåller bytes-data. Metoden decode() returnerar en instans av ParseResult.

Tillagd i version 3.2.

class urllib.parse.SplitResultBytes(scheme, netloc, path, query, fragment)

Konkret klass för urlsplit()-resultat som innehåller bytes-data. Metoden decode() returnerar en instans av SplitResult.

Tillagd i version 3.2.

URL-citering

URL-citeringsfunktionerna fokuserar på att ta programdata och göra dem säkra för användning som URL-komponenter genom att citera specialtecken och på lämpligt sätt koda icke-ASCII-text. De stöder också reversering av dessa operationer för att återskapa originaldata från innehållet i en URL-komponent om den uppgiften inte redan täcks av URL-parsingfunktionerna ovan.

urllib.parse.quote(string, safe='/', encoding=None, errors=None)

Ersätt specialtecken i string med hjälp av %xx escape. Bokstäver, siffror och tecknen '_.-~' citeras aldrig. Som standard är den här funktionen avsedd för att citera sökvägsavsnittet i en URL. Den valfria parametern safe anger ytterligare ASCII-tecken som inte ska citeras — dess standardvärde är '/'.

string kan vara antingen ett str- eller ett bytes-objekt.

Ändrad i version 3.7: Flyttad från RFC 2396 till RFC 3986 för citering av URL-strängar. ”~” ingår nu i uppsättningen av oreserverade tecken.

De valfria parametrarna encoding och errors anger hur icke-ASCII-tecken ska hanteras, vilket accepteras av metoden str.encode(). encoding är som standard 'utf-8'. errors är som standard 'strict', vilket innebär att tecken som inte stöds ger upphov till ett UnicodeEncodeError. encoding och errors får inte anges om string är en bytes, eller om ett TypeError uppstår.

Observera att quote(string, safe, encoding, errors) är likvärdigt med quote_from_bytes(string.encode(encoding, errors), safe).

Exempel: quote('/El Niño/') ger '/El%20Ni%C3%B1o/'.

urllib.parse.quote_plus(string, safe='', encoding=None, errors=None)

Som quote(), men ersätter även mellanslag med plustecken, vilket krävs för att citera HTML-formulärvärden när man bygger upp en frågesträng som ska ingå i en URL. Plustecken i den ursprungliga strängen escapas om de inte ingår i safe. Det har inte heller safe som standard till '/'.

Exempel: quote_plus('/El Niño/') ger '%2FEl+Ni%C3%B1o%2F'.

urllib.parse.quote_from_bytes(bytes, safe='/')

Som quote(), men accepterar ett bytes-objekt i stället för ett str, och utför inte kodning av sträng till byte.

Exempel: quote_from_bytes(b'a&\xef') ger 'a%26%EF'.

urllib.parse.unquote(string, encoding='utf-8', errors='replace')

Ersätt %xx escapes med deras motsvarighet i form av enstaka tecken. De valfria parametrarna encoding och errors anger hur procentkodade sekvenser ska avkodas till Unicode-tecken, vilket accepteras av metoden bytes.decode().

string kan vara antingen ett str- eller ett bytes-objekt.

encoding standardvärdet är 'utf-8'. errors har 'replace' som standard, vilket innebär att ogiltiga sekvenser ersätts med ett platshållartecken.

Exempel: unquote('/El%20Ni%C3%B1o/') ger '/El Niño/'.

Ändrad i version 3.9: string-parametern stöder bytes- och str-objekt (tidigare endast str).

urllib.parse.unquote_plus(string, encoding='utf-8', errors='replace')

Som unquote(), men ersätter även plustecken med mellanslag, vilket krävs för att avcitera HTML-formulärvärden.

string måste vara en str.

Exempel: unquote_plus('/El+Ni%C3%B1o/') ger '/El Niño/'.

urllib.parse.unquote_to_bytes(string)

Ersätt %xx escapes med deras motsvarighet i en oktett, och returnera ett bytes-objekt.

string kan vara antingen ett str- eller ett bytes-objekt.

Om det är en str kodas oavkortade icke-ASCII-tecken i string till UTF-8-byte.

Exempel: unquote_to_bytes('a%26%EF') ger b'a&\xef'.

urllib.parse.urlencode(query, doseq=False, safe='', encoding=None, errors=None, quote_via=quote_plus)

Konverterar ett mappningsobjekt eller en sekvens av tuples med två element, som kan innehålla str- eller bytes-objekt, till en procentkodad ASCII-textsträng. Om den resulterande strängen ska användas som data för POST-operation med funktionen urlopen(), bör den kodas till bytes, annars resulterar det i ett TypeError.

Den resulterande strängen är en serie par av nyckel=värde åtskilda av '&'-tecken, där både nyckel och värde citeras med hjälp av funktionen quote_via. Som standard används quote_plus() för att citera värdena, vilket innebär att mellanslag citeras som ett '+'-tecken och att ’/’-tecken kodas som %2F, vilket följer standarden för GET-begäranden (application/x-www-form-urlencoded). En alternativ funktion som kan skickas som quote_via är quote(), som kodar mellanslag som %20 och inte kodar ’/’-tecken. För maximal kontroll över vad som citeras, använd quote och ange ett värde för safe.

När en sekvens av tupler med två element används som query-argument är det första elementet i varje tupel en nyckel och det andra ett värde. Värdeelementet i sig kan vara en sekvens och i så fall, om den valfria parametern doseq utvärderas till True, genereras individuella key=value-par åtskilda av '&' för varje element i värdesekvensen för nyckeln. Ordningen på parametrarna i den kodade strängen kommer att överensstämma med ordningen på parametertuplarna i sekvensen.

Parametrarna safe, encoding och errors skickas vidare till quote_via (parametrarna encoding och errors skickas bara vidare när ett frågeelement är en str).

För att vända denna kodningsprocess tillhandahålls parse_qs() och parse_qsl() i denna modul för att analysera frågesträngar till Python-datastrukturer.

Se urllib examples för att ta reda på hur metoden urllib.parse.urlencode() kan användas för att generera frågesträngen för en URL eller data för en POST-begäran.

Ändrad i version 3.2: query stöder bytes och strängobjekt.

Ändrad i version 3.5: Lagt till parametern quote_via.

Föråldrad sedan version 3.14: Att acceptera objekt med falska värden (som 0 och []) förutom tomma strängar och byte-liknande objekt och None är nu föråldrat.

Se även

WHATWG - URL Levnadsstandard

Arbetsgrupp för URL-standarden som definierar URL:er, domäner, IP-adresser, det applikation/x-www-form-urlencoded-formatet och deras API.

RFC 3986 - Enhetliga resursidentifierare

Detta är den nuvarande standarden (STD66). Alla ändringar av urllib.parse-modulen bör överensstämma med denna. Vissa avvikelser kan observeras, som mestadels är för bakåtkompatibilitet och för vissa de facto parsing-krav som vanligtvis observeras i större webbläsare.

RFC 2732 - Format för bokstavliga IPv6-adresser i URL:er.

Här anges kraven på analys av IPv6-URL:er.

RFC 2396 - Enhetliga resursidentifierare (URI): Generisk syntax

Dokument som beskriver de generiska syntaktiska kraven för både Uniform Resource Names (URN) och Uniform Resource Locators (URL).

RFC 2368 - URL-schema för mailto.

Parsing-krav för mailto URL-system.

RFC 1808 - Relativa sökvägar för enhetliga resurser

Denna begäran om kommentarer innehåller reglerna för hur man sammanfogar en absolut och en relativ URL, inklusive ett stort antal ”onormala exempel” som styr behandlingen av gränsfall.

RFC 1738 - Uniform Resource Locators (URL)

Här anges den formella syntaxen och semantiken för absoluta URL:er.