Senthil Kumaran | aca8fd7 | 2008-06-23 04:41:59 +0000 | [diff] [blame] | 1 | :mod:`urllib.parse` --- Parse URLs into components |
| 2 | ================================================== |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 3 | |
Senthil Kumaran | aca8fd7 | 2008-06-23 04:41:59 +0000 | [diff] [blame] | 4 | .. module:: urllib.parse |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 5 | :synopsis: Parse URLs into or assemble them from components. |
| 6 | |
| 7 | |
| 8 | .. index:: |
| 9 | single: WWW |
| 10 | single: World Wide Web |
| 11 | single: URL |
| 12 | pair: URL; parsing |
| 13 | pair: relative; URL |
| 14 | |
Éric Araujo | 19f9b71 | 2011-08-19 00:49:18 +0200 | [diff] [blame] | 15 | **Source code:** :source:`Lib/urllib/parse.py` |
| 16 | |
| 17 | -------------- |
| 18 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 19 | This module defines a standard interface to break Uniform Resource Locator (URL) |
| 20 | strings up in components (addressing scheme, network location, path etc.), to |
| 21 | combine the components back into a URL string, and to convert a "relative URL" |
| 22 | to an absolute URL given a "base URL." |
| 23 | |
| 24 | The module has been designed to match the Internet RFC on Relative Uniform |
Senthil Kumaran | 4a27d9f | 2012-06-28 21:07:58 -0700 | [diff] [blame] | 25 | Resource Locators. It supports the following URL schemes: ``file``, ``ftp``, |
| 26 | ``gopher``, ``hdl``, ``http``, ``https``, ``imap``, ``mailto``, ``mms``, |
| 27 | ``news``, ``nntp``, ``prospero``, ``rsync``, ``rtsp``, ``rtspu``, ``sftp``, |
| 28 | ``shttp``, ``sip``, ``sips``, ``snews``, ``svn``, ``svn+ssh``, ``telnet``, |
| 29 | ``wais``. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 30 | |
Nick Coghlan | 9fc443c | 2010-11-30 15:48:08 +0000 | [diff] [blame] | 31 | The :mod:`urllib.parse` module defines functions that fall into two broad |
| 32 | categories: URL parsing and URL quoting. These are covered in detail in |
| 33 | the following sections. |
| 34 | |
| 35 | URL Parsing |
| 36 | ----------- |
| 37 | |
| 38 | The URL parsing functions focus on splitting a URL string into its components, |
| 39 | or on combining URL components into a URL string. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 40 | |
R. David Murray | f5077aa | 2010-05-25 15:36:46 +0000 | [diff] [blame] | 41 | .. function:: urlparse(urlstring, scheme='', allow_fragments=True) |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 42 | |
| 43 | Parse a URL into six components, returning a 6-tuple. This corresponds to the |
| 44 | general structure of a URL: ``scheme://netloc/path;parameters?query#fragment``. |
| 45 | Each tuple item is a string, possibly empty. The components are not broken up in |
| 46 | smaller parts (for example, the network location is a single string), and % |
| 47 | escapes are not expanded. The delimiters as shown above are not part of the |
| 48 | result, except for a leading slash in the *path* component, which is retained if |
Christian Heimes | fe337bf | 2008-03-23 21:54:12 +0000 | [diff] [blame] | 49 | present. For example: |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 50 | |
Senthil Kumaran | aca8fd7 | 2008-06-23 04:41:59 +0000 | [diff] [blame] | 51 | >>> from urllib.parse import urlparse |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 52 | >>> o = urlparse('http://www.cwi.nl:80/%7Eguido/Python.html') |
Christian Heimes | fe337bf | 2008-03-23 21:54:12 +0000 | [diff] [blame] | 53 | >>> o # doctest: +NORMALIZE_WHITESPACE |
| 54 | ParseResult(scheme='http', netloc='www.cwi.nl:80', path='/%7Eguido/Python.html', |
| 55 | params='', query='', fragment='') |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 56 | >>> o.scheme |
| 57 | 'http' |
| 58 | >>> o.port |
| 59 | 80 |
| 60 | >>> o.geturl() |
| 61 | 'http://www.cwi.nl:80/%7Eguido/Python.html' |
| 62 | |
Senthil Kumaran | 7089a4e | 2010-11-07 12:57:04 +0000 | [diff] [blame] | 63 | Following the syntax specifications in :rfc:`1808`, urlparse recognizes |
| 64 | a netloc only if it is properly introduced by '//'. Otherwise the |
| 65 | input is presumed to be a relative URL and thus to start with |
| 66 | a path component. |
Senthil Kumaran | 84c7d9f | 2010-08-04 04:50:44 +0000 | [diff] [blame] | 67 | |
Senthil Kumaran | fe9230a | 2011-06-19 13:52:49 -0700 | [diff] [blame] | 68 | >>> from urllib.parse import urlparse |
Senthil Kumaran | 84c7d9f | 2010-08-04 04:50:44 +0000 | [diff] [blame] | 69 | >>> urlparse('//www.cwi.nl:80/%7Eguido/Python.html') |
| 70 | ParseResult(scheme='', netloc='www.cwi.nl:80', path='/%7Eguido/Python.html', |
| 71 | params='', query='', fragment='') |
Senthil Kumaran | 8fd3669 | 2013-02-26 01:02:58 -0800 | [diff] [blame] | 72 | >>> urlparse('www.cwi.nl/%7Eguido/Python.html') |
Senthil Kumaran | 21b2933 | 2013-09-30 22:12:16 -0700 | [diff] [blame] | 73 | ParseResult(scheme='', netloc='', path='www.cwi.nl/%7Eguido/Python.html', |
Senthil Kumaran | 84c7d9f | 2010-08-04 04:50:44 +0000 | [diff] [blame] | 74 | params='', query='', fragment='') |
| 75 | >>> urlparse('help/Python.html') |
| 76 | ParseResult(scheme='', netloc='', path='help/Python.html', params='', |
| 77 | query='', fragment='') |
| 78 | |
R. David Murray | f5077aa | 2010-05-25 15:36:46 +0000 | [diff] [blame] | 79 | If the *scheme* argument is specified, it gives the default addressing |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 80 | scheme, to be used only if the URL does not specify one. The default value for |
| 81 | this argument is the empty string. |
| 82 | |
| 83 | If the *allow_fragments* argument is false, fragment identifiers are not |
Georg Brandl | a79b8dc | 2012-09-29 08:59:23 +0200 | [diff] [blame] | 84 | allowed. The default value for this argument is :const:`True`. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 85 | |
| 86 | The return value is actually an instance of a subclass of :class:`tuple`. This |
| 87 | class has the following additional read-only convenience attributes: |
| 88 | |
| 89 | +------------------+-------+--------------------------+----------------------+ |
| 90 | | Attribute | Index | Value | Value if not present | |
| 91 | +==================+=======+==========================+======================+ |
| 92 | | :attr:`scheme` | 0 | URL scheme specifier | empty string | |
| 93 | +------------------+-------+--------------------------+----------------------+ |
| 94 | | :attr:`netloc` | 1 | Network location part | empty string | |
| 95 | +------------------+-------+--------------------------+----------------------+ |
| 96 | | :attr:`path` | 2 | Hierarchical path | empty string | |
| 97 | +------------------+-------+--------------------------+----------------------+ |
| 98 | | :attr:`params` | 3 | Parameters for last path | empty string | |
| 99 | | | | element | | |
| 100 | +------------------+-------+--------------------------+----------------------+ |
| 101 | | :attr:`query` | 4 | Query component | empty string | |
| 102 | +------------------+-------+--------------------------+----------------------+ |
| 103 | | :attr:`fragment` | 5 | Fragment identifier | empty string | |
| 104 | +------------------+-------+--------------------------+----------------------+ |
| 105 | | :attr:`username` | | User name | :const:`None` | |
| 106 | +------------------+-------+--------------------------+----------------------+ |
| 107 | | :attr:`password` | | Password | :const:`None` | |
| 108 | +------------------+-------+--------------------------+----------------------+ |
| 109 | | :attr:`hostname` | | Host name (lower case) | :const:`None` | |
| 110 | +------------------+-------+--------------------------+----------------------+ |
| 111 | | :attr:`port` | | Port number as integer, | :const:`None` | |
| 112 | | | | if present | | |
| 113 | +------------------+-------+--------------------------+----------------------+ |
| 114 | |
| 115 | See section :ref:`urlparse-result-object` for more information on the result |
| 116 | object. |
| 117 | |
Senthil Kumaran | 7a1e09f | 2010-04-22 12:19:46 +0000 | [diff] [blame] | 118 | .. versionchanged:: 3.2 |
| 119 | Added IPv6 URL parsing capabilities. |
| 120 | |
Georg Brandl | a79b8dc | 2012-09-29 08:59:23 +0200 | [diff] [blame] | 121 | .. versionchanged:: 3.3 |
| 122 | The fragment is now parsed for all URL schemes (unless *allow_fragment* is |
| 123 | false), in accordance with :rfc:`3986`. Previously, a whitelist of |
| 124 | schemes that support fragments existed. |
| 125 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 126 | |
Victor Stinner | ac71c54 | 2011-01-14 12:52:12 +0000 | [diff] [blame] | 127 | .. function:: parse_qs(qs, keep_blank_values=False, strict_parsing=False, encoding='utf-8', errors='replace') |
Facundo Batista | c469d4c | 2008-09-03 22:49:01 +0000 | [diff] [blame] | 128 | |
| 129 | Parse a query string given as a string argument (data of type |
| 130 | :mimetype:`application/x-www-form-urlencoded`). Data are returned as a |
| 131 | dictionary. The dictionary keys are the unique query variable names and the |
| 132 | values are lists of values for each name. |
| 133 | |
| 134 | The optional argument *keep_blank_values* is a flag indicating whether blank |
Senthil Kumaran | f0769e8 | 2010-08-09 19:53:52 +0000 | [diff] [blame] | 135 | values in percent-encoded queries should be treated as blank strings. A true value |
Facundo Batista | c469d4c | 2008-09-03 22:49:01 +0000 | [diff] [blame] | 136 | indicates that blanks should be retained as blank strings. The default false |
| 137 | value indicates that blank values are to be ignored and treated as if they were |
| 138 | not included. |
| 139 | |
| 140 | The optional argument *strict_parsing* is a flag indicating what to do with |
| 141 | parsing errors. If false (the default), errors are silently ignored. If true, |
| 142 | errors raise a :exc:`ValueError` exception. |
| 143 | |
Victor Stinner | ac71c54 | 2011-01-14 12:52:12 +0000 | [diff] [blame] | 144 | The optional *encoding* and *errors* parameters specify how to decode |
| 145 | percent-encoded sequences into Unicode characters, as accepted by the |
| 146 | :meth:`bytes.decode` method. |
| 147 | |
Michael Foord | 207d229 | 2012-09-28 14:40:44 +0100 | [diff] [blame] | 148 | Use the :func:`urllib.parse.urlencode` function (with the ``doseq`` |
| 149 | parameter set to ``True``) to convert such dictionaries into query |
| 150 | strings. |
Facundo Batista | c469d4c | 2008-09-03 22:49:01 +0000 | [diff] [blame] | 151 | |
Senthil Kumaran | 2933312 | 2011-02-11 11:25:47 +0000 | [diff] [blame] | 152 | |
Victor Stinner | c58be2d | 2011-01-14 13:31:45 +0000 | [diff] [blame] | 153 | .. versionchanged:: 3.2 |
| 154 | Add *encoding* and *errors* parameters. |
| 155 | |
Facundo Batista | c469d4c | 2008-09-03 22:49:01 +0000 | [diff] [blame] | 156 | |
Victor Stinner | ac71c54 | 2011-01-14 12:52:12 +0000 | [diff] [blame] | 157 | .. function:: parse_qsl(qs, keep_blank_values=False, strict_parsing=False, encoding='utf-8', errors='replace') |
Facundo Batista | c469d4c | 2008-09-03 22:49:01 +0000 | [diff] [blame] | 158 | |
| 159 | Parse a query string given as a string argument (data of type |
| 160 | :mimetype:`application/x-www-form-urlencoded`). Data are returned as a list of |
| 161 | name, value pairs. |
| 162 | |
| 163 | The optional argument *keep_blank_values* is a flag indicating whether blank |
Senthil Kumaran | f0769e8 | 2010-08-09 19:53:52 +0000 | [diff] [blame] | 164 | values in percent-encoded queries should be treated as blank strings. A true value |
Facundo Batista | c469d4c | 2008-09-03 22:49:01 +0000 | [diff] [blame] | 165 | indicates that blanks should be retained as blank strings. The default false |
| 166 | value indicates that blank values are to be ignored and treated as if they were |
| 167 | not included. |
| 168 | |
| 169 | The optional argument *strict_parsing* is a flag indicating what to do with |
| 170 | parsing errors. If false (the default), errors are silently ignored. If true, |
| 171 | errors raise a :exc:`ValueError` exception. |
| 172 | |
Victor Stinner | ac71c54 | 2011-01-14 12:52:12 +0000 | [diff] [blame] | 173 | The optional *encoding* and *errors* parameters specify how to decode |
| 174 | percent-encoded sequences into Unicode characters, as accepted by the |
| 175 | :meth:`bytes.decode` method. |
| 176 | |
Facundo Batista | c469d4c | 2008-09-03 22:49:01 +0000 | [diff] [blame] | 177 | Use the :func:`urllib.parse.urlencode` function to convert such lists of pairs into |
| 178 | query strings. |
| 179 | |
Victor Stinner | c58be2d | 2011-01-14 13:31:45 +0000 | [diff] [blame] | 180 | .. versionchanged:: 3.2 |
| 181 | Add *encoding* and *errors* parameters. |
| 182 | |
Facundo Batista | c469d4c | 2008-09-03 22:49:01 +0000 | [diff] [blame] | 183 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 184 | .. function:: urlunparse(parts) |
| 185 | |
Georg Brandl | 0f7ede4 | 2008-06-23 11:23:31 +0000 | [diff] [blame] | 186 | Construct a URL from a tuple as returned by ``urlparse()``. The *parts* |
| 187 | argument can be any six-item iterable. This may result in a slightly |
| 188 | different, but equivalent URL, if the URL that was parsed originally had |
| 189 | unnecessary delimiters (for example, a ``?`` with an empty query; the RFC |
| 190 | states that these are equivalent). |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 191 | |
| 192 | |
R. David Murray | f5077aa | 2010-05-25 15:36:46 +0000 | [diff] [blame] | 193 | .. function:: urlsplit(urlstring, scheme='', allow_fragments=True) |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 194 | |
| 195 | This is similar to :func:`urlparse`, but does not split the params from the URL. |
| 196 | This should generally be used instead of :func:`urlparse` if the more recent URL |
| 197 | syntax allowing parameters to be applied to each segment of the *path* portion |
| 198 | of the URL (see :rfc:`2396`) is wanted. A separate function is needed to |
| 199 | separate the path segments and parameters. This function returns a 5-tuple: |
| 200 | (addressing scheme, network location, path, query, fragment identifier). |
| 201 | |
| 202 | The return value is actually an instance of a subclass of :class:`tuple`. This |
| 203 | class has the following additional read-only convenience attributes: |
| 204 | |
| 205 | +------------------+-------+-------------------------+----------------------+ |
| 206 | | Attribute | Index | Value | Value if not present | |
| 207 | +==================+=======+=========================+======================+ |
| 208 | | :attr:`scheme` | 0 | URL scheme specifier | empty string | |
| 209 | +------------------+-------+-------------------------+----------------------+ |
| 210 | | :attr:`netloc` | 1 | Network location part | empty string | |
| 211 | +------------------+-------+-------------------------+----------------------+ |
| 212 | | :attr:`path` | 2 | Hierarchical path | empty string | |
| 213 | +------------------+-------+-------------------------+----------------------+ |
| 214 | | :attr:`query` | 3 | Query component | empty string | |
| 215 | +------------------+-------+-------------------------+----------------------+ |
| 216 | | :attr:`fragment` | 4 | Fragment identifier | empty string | |
| 217 | +------------------+-------+-------------------------+----------------------+ |
| 218 | | :attr:`username` | | User name | :const:`None` | |
| 219 | +------------------+-------+-------------------------+----------------------+ |
| 220 | | :attr:`password` | | Password | :const:`None` | |
| 221 | +------------------+-------+-------------------------+----------------------+ |
| 222 | | :attr:`hostname` | | Host name (lower case) | :const:`None` | |
| 223 | +------------------+-------+-------------------------+----------------------+ |
| 224 | | :attr:`port` | | Port number as integer, | :const:`None` | |
| 225 | | | | if present | | |
| 226 | +------------------+-------+-------------------------+----------------------+ |
| 227 | |
| 228 | See section :ref:`urlparse-result-object` for more information on the result |
| 229 | object. |
| 230 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 231 | |
| 232 | .. function:: urlunsplit(parts) |
| 233 | |
Georg Brandl | 0f7ede4 | 2008-06-23 11:23:31 +0000 | [diff] [blame] | 234 | Combine the elements of a tuple as returned by :func:`urlsplit` into a |
| 235 | complete URL as a string. The *parts* argument can be any five-item |
| 236 | iterable. This may result in a slightly different, but equivalent URL, if the |
| 237 | URL that was parsed originally had unnecessary delimiters (for example, a ? |
| 238 | with an empty query; the RFC states that these are equivalent). |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 239 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 240 | |
Georg Brandl | 7f01a13 | 2009-09-16 15:58:14 +0000 | [diff] [blame] | 241 | .. function:: urljoin(base, url, allow_fragments=True) |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 242 | |
| 243 | Construct a full ("absolute") URL by combining a "base URL" (*base*) with |
| 244 | another URL (*url*). Informally, this uses components of the base URL, in |
Georg Brandl | 0f7ede4 | 2008-06-23 11:23:31 +0000 | [diff] [blame] | 245 | particular the addressing scheme, the network location and (part of) the |
| 246 | path, to provide missing components in the relative URL. For example: |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 247 | |
Senthil Kumaran | aca8fd7 | 2008-06-23 04:41:59 +0000 | [diff] [blame] | 248 | >>> from urllib.parse import urljoin |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 249 | >>> urljoin('http://www.cwi.nl/%7Eguido/Python.html', 'FAQ.html') |
| 250 | 'http://www.cwi.nl/%7Eguido/FAQ.html' |
| 251 | |
| 252 | The *allow_fragments* argument has the same meaning and default as for |
| 253 | :func:`urlparse`. |
| 254 | |
| 255 | .. note:: |
| 256 | |
| 257 | If *url* is an absolute URL (that is, starting with ``//`` or ``scheme://``), |
| 258 | the *url*'s host name and/or scheme will be present in the result. For example: |
| 259 | |
Christian Heimes | fe337bf | 2008-03-23 21:54:12 +0000 | [diff] [blame] | 260 | .. doctest:: |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 261 | |
| 262 | >>> urljoin('http://www.cwi.nl/%7Eguido/Python.html', |
| 263 | ... '//www.python.org/%7Eguido') |
| 264 | 'http://www.python.org/%7Eguido' |
| 265 | |
| 266 | If you do not want that behavior, preprocess the *url* with :func:`urlsplit` and |
| 267 | :func:`urlunsplit`, removing possible *scheme* and *netloc* parts. |
| 268 | |
| 269 | |
Antoine Pitrou | 55ac5b3 | 2014-08-21 19:16:17 -0400 | [diff] [blame^] | 270 | .. versionchanged:: 3.5 |
| 271 | |
| 272 | Behaviour updated to match the semantics defined in :rfc:`3986`. |
| 273 | |
| 274 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 275 | .. function:: urldefrag(url) |
| 276 | |
Georg Brandl | 0f7ede4 | 2008-06-23 11:23:31 +0000 | [diff] [blame] | 277 | If *url* contains a fragment identifier, return a modified version of *url* |
| 278 | with no fragment identifier, and the fragment identifier as a separate |
| 279 | string. If there is no fragment identifier in *url*, return *url* unmodified |
| 280 | and an empty string. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 281 | |
Nick Coghlan | 9fc443c | 2010-11-30 15:48:08 +0000 | [diff] [blame] | 282 | The return value is actually an instance of a subclass of :class:`tuple`. This |
| 283 | class has the following additional read-only convenience attributes: |
| 284 | |
| 285 | +------------------+-------+-------------------------+----------------------+ |
| 286 | | Attribute | Index | Value | Value if not present | |
| 287 | +==================+=======+=========================+======================+ |
| 288 | | :attr:`url` | 0 | URL with no fragment | empty string | |
| 289 | +------------------+-------+-------------------------+----------------------+ |
| 290 | | :attr:`fragment` | 1 | Fragment identifier | empty string | |
| 291 | +------------------+-------+-------------------------+----------------------+ |
| 292 | |
| 293 | See section :ref:`urlparse-result-object` for more information on the result |
| 294 | object. |
| 295 | |
| 296 | .. versionchanged:: 3.2 |
Raymond Hettinger | 9a236b0 | 2011-01-24 09:01:27 +0000 | [diff] [blame] | 297 | Result is a structured object rather than a simple 2-tuple. |
Nick Coghlan | 9fc443c | 2010-11-30 15:48:08 +0000 | [diff] [blame] | 298 | |
Georg Brandl | 009a6bd | 2011-01-24 19:59:08 +0000 | [diff] [blame] | 299 | .. _parsing-ascii-encoded-bytes: |
Nick Coghlan | 9fc443c | 2010-11-30 15:48:08 +0000 | [diff] [blame] | 300 | |
| 301 | Parsing ASCII Encoded Bytes |
| 302 | --------------------------- |
| 303 | |
| 304 | The URL parsing functions were originally designed to operate on character |
| 305 | strings only. In practice, it is useful to be able to manipulate properly |
| 306 | quoted and encoded URLs as sequences of ASCII bytes. Accordingly, the |
| 307 | URL parsing functions in this module all operate on :class:`bytes` and |
| 308 | :class:`bytearray` objects in addition to :class:`str` objects. |
| 309 | |
| 310 | If :class:`str` data is passed in, the result will also contain only |
| 311 | :class:`str` data. If :class:`bytes` or :class:`bytearray` data is |
| 312 | passed in, the result will contain only :class:`bytes` data. |
| 313 | |
| 314 | Attempting to mix :class:`str` data with :class:`bytes` or |
| 315 | :class:`bytearray` in a single function call will result in a |
Éric Araujo | ff2a4ba | 2010-11-30 17:20:31 +0000 | [diff] [blame] | 316 | :exc:`TypeError` being raised, while attempting to pass in non-ASCII |
Nick Coghlan | 9fc443c | 2010-11-30 15:48:08 +0000 | [diff] [blame] | 317 | byte values will trigger :exc:`UnicodeDecodeError`. |
| 318 | |
| 319 | To support easier conversion of result objects between :class:`str` and |
| 320 | :class:`bytes`, all return values from URL parsing functions provide |
| 321 | either an :meth:`encode` method (when the result contains :class:`str` |
| 322 | data) or a :meth:`decode` method (when the result contains :class:`bytes` |
| 323 | data). The signatures of these methods match those of the corresponding |
| 324 | :class:`str` and :class:`bytes` methods (except that the default encoding |
| 325 | is ``'ascii'`` rather than ``'utf-8'``). Each produces a value of a |
| 326 | corresponding type that contains either :class:`bytes` data (for |
| 327 | :meth:`encode` methods) or :class:`str` data (for |
| 328 | :meth:`decode` methods). |
| 329 | |
| 330 | Applications that need to operate on potentially improperly quoted URLs |
| 331 | that may contain non-ASCII data will need to do their own decoding from |
| 332 | bytes to characters before invoking the URL parsing methods. |
| 333 | |
| 334 | The behaviour described in this section applies only to the URL parsing |
| 335 | functions. The URL quoting functions use their own rules when producing |
| 336 | or consuming byte sequences as detailed in the documentation of the |
| 337 | individual URL quoting functions. |
| 338 | |
| 339 | .. versionchanged:: 3.2 |
| 340 | URL parsing functions now accept ASCII encoded byte sequences |
| 341 | |
| 342 | |
| 343 | .. _urlparse-result-object: |
| 344 | |
| 345 | Structured Parse Results |
| 346 | ------------------------ |
| 347 | |
| 348 | The result objects from the :func:`urlparse`, :func:`urlsplit` and |
Georg Brandl | 4640237 | 2010-12-04 19:06:18 +0000 | [diff] [blame] | 349 | :func:`urldefrag` functions are subclasses of the :class:`tuple` type. |
Nick Coghlan | 9fc443c | 2010-11-30 15:48:08 +0000 | [diff] [blame] | 350 | These subclasses add the attributes listed in the documentation for |
| 351 | those functions, the encoding and decoding support described in the |
| 352 | previous section, as well as an additional method: |
| 353 | |
| 354 | .. method:: urllib.parse.SplitResult.geturl() |
| 355 | |
| 356 | Return the re-combined version of the original URL as a string. This may |
| 357 | differ from the original URL in that the scheme may be normalized to lower |
| 358 | case and empty components may be dropped. Specifically, empty parameters, |
| 359 | queries, and fragment identifiers will be removed. |
| 360 | |
| 361 | For :func:`urldefrag` results, only empty fragment identifiers will be removed. |
| 362 | For :func:`urlsplit` and :func:`urlparse` results, all noted changes will be |
| 363 | made to the URL returned by this method. |
| 364 | |
| 365 | The result of this method remains unchanged if passed back through the original |
| 366 | parsing function: |
| 367 | |
| 368 | >>> from urllib.parse import urlsplit |
| 369 | >>> url = 'HTTP://www.Python.org/doc/#' |
| 370 | >>> r1 = urlsplit(url) |
| 371 | >>> r1.geturl() |
| 372 | 'http://www.Python.org/doc/' |
| 373 | >>> r2 = urlsplit(r1.geturl()) |
| 374 | >>> r2.geturl() |
| 375 | 'http://www.Python.org/doc/' |
| 376 | |
| 377 | |
| 378 | The following classes provide the implementations of the structured parse |
| 379 | results when operating on :class:`str` objects: |
| 380 | |
| 381 | .. class:: DefragResult(url, fragment) |
| 382 | |
| 383 | Concrete class for :func:`urldefrag` results containing :class:`str` |
| 384 | data. The :meth:`encode` method returns a :class:`DefragResultBytes` |
| 385 | instance. |
| 386 | |
| 387 | .. versionadded:: 3.2 |
| 388 | |
| 389 | .. class:: ParseResult(scheme, netloc, path, params, query, fragment) |
| 390 | |
| 391 | Concrete class for :func:`urlparse` results containing :class:`str` |
| 392 | data. The :meth:`encode` method returns a :class:`ParseResultBytes` |
| 393 | instance. |
| 394 | |
| 395 | .. class:: SplitResult(scheme, netloc, path, query, fragment) |
| 396 | |
| 397 | Concrete class for :func:`urlsplit` results containing :class:`str` |
| 398 | data. The :meth:`encode` method returns a :class:`SplitResultBytes` |
| 399 | instance. |
| 400 | |
| 401 | |
| 402 | The following classes provide the implementations of the parse results when |
| 403 | operating on :class:`bytes` or :class:`bytearray` objects: |
| 404 | |
| 405 | .. class:: DefragResultBytes(url, fragment) |
| 406 | |
| 407 | Concrete class for :func:`urldefrag` results containing :class:`bytes` |
| 408 | data. The :meth:`decode` method returns a :class:`DefragResult` |
| 409 | instance. |
| 410 | |
| 411 | .. versionadded:: 3.2 |
| 412 | |
| 413 | .. class:: ParseResultBytes(scheme, netloc, path, params, query, fragment) |
| 414 | |
| 415 | Concrete class for :func:`urlparse` results containing :class:`bytes` |
| 416 | data. The :meth:`decode` method returns a :class:`ParseResult` |
| 417 | instance. |
| 418 | |
| 419 | .. versionadded:: 3.2 |
| 420 | |
| 421 | .. class:: SplitResultBytes(scheme, netloc, path, query, fragment) |
| 422 | |
| 423 | Concrete class for :func:`urlsplit` results containing :class:`bytes` |
| 424 | data. The :meth:`decode` method returns a :class:`SplitResult` |
| 425 | instance. |
| 426 | |
| 427 | .. versionadded:: 3.2 |
| 428 | |
| 429 | |
| 430 | URL Quoting |
| 431 | ----------- |
| 432 | |
| 433 | The URL quoting functions focus on taking program data and making it safe |
| 434 | for use as URL components by quoting special characters and appropriately |
| 435 | encoding non-ASCII text. They also support reversing these operations to |
| 436 | recreate the original data from the contents of a URL component if that |
| 437 | task isn't already covered by the URL parsing functions above. |
Georg Brandl | 7f01a13 | 2009-09-16 15:58:14 +0000 | [diff] [blame] | 438 | |
| 439 | .. function:: quote(string, safe='/', encoding=None, errors=None) |
Senthil Kumaran | aca8fd7 | 2008-06-23 04:41:59 +0000 | [diff] [blame] | 440 | |
| 441 | Replace special characters in *string* using the ``%xx`` escape. Letters, |
Senthil Kumaran | 8aa8bbe | 2009-08-31 16:43:45 +0000 | [diff] [blame] | 442 | digits, and the characters ``'_.-'`` are never quoted. By default, this |
| 443 | function is intended for quoting the path section of URL. The optional *safe* |
Guido van Rossum | 52dbbb9 | 2008-08-18 21:44:30 +0000 | [diff] [blame] | 444 | parameter specifies additional ASCII characters that should not be quoted |
| 445 | --- its default value is ``'/'``. |
Senthil Kumaran | aca8fd7 | 2008-06-23 04:41:59 +0000 | [diff] [blame] | 446 | |
Guido van Rossum | 52dbbb9 | 2008-08-18 21:44:30 +0000 | [diff] [blame] | 447 | *string* may be either a :class:`str` or a :class:`bytes`. |
| 448 | |
| 449 | The optional *encoding* and *errors* parameters specify how to deal with |
| 450 | non-ASCII characters, as accepted by the :meth:`str.encode` method. |
| 451 | *encoding* defaults to ``'utf-8'``. |
| 452 | *errors* defaults to ``'strict'``, meaning unsupported characters raise a |
| 453 | :class:`UnicodeEncodeError`. |
| 454 | *encoding* and *errors* must not be supplied if *string* is a |
| 455 | :class:`bytes`, or a :class:`TypeError` is raised. |
| 456 | |
| 457 | Note that ``quote(string, safe, encoding, errors)`` is equivalent to |
| 458 | ``quote_from_bytes(string.encode(encoding, errors), safe)``. |
| 459 | |
| 460 | Example: ``quote('/El Niño/')`` yields ``'/El%20Ni%C3%B1o/'``. |
Senthil Kumaran | aca8fd7 | 2008-06-23 04:41:59 +0000 | [diff] [blame] | 461 | |
| 462 | |
Georg Brandl | 7f01a13 | 2009-09-16 15:58:14 +0000 | [diff] [blame] | 463 | .. function:: quote_plus(string, safe='', encoding=None, errors=None) |
Senthil Kumaran | aca8fd7 | 2008-06-23 04:41:59 +0000 | [diff] [blame] | 464 | |
Georg Brandl | 0f7ede4 | 2008-06-23 11:23:31 +0000 | [diff] [blame] | 465 | Like :func:`quote`, but also replace spaces by plus signs, as required for |
Georg Brandl | 81c09db | 2009-07-29 07:27:08 +0000 | [diff] [blame] | 466 | quoting HTML form values when building up a query string to go into a URL. |
| 467 | Plus signs in the original string are escaped unless they are included in |
| 468 | *safe*. It also does not have *safe* default to ``'/'``. |
Senthil Kumaran | aca8fd7 | 2008-06-23 04:41:59 +0000 | [diff] [blame] | 469 | |
Guido van Rossum | 52dbbb9 | 2008-08-18 21:44:30 +0000 | [diff] [blame] | 470 | Example: ``quote_plus('/El Niño/')`` yields ``'%2FEl+Ni%C3%B1o%2F'``. |
Senthil Kumaran | aca8fd7 | 2008-06-23 04:41:59 +0000 | [diff] [blame] | 471 | |
Georg Brandl | 7f01a13 | 2009-09-16 15:58:14 +0000 | [diff] [blame] | 472 | |
| 473 | .. function:: quote_from_bytes(bytes, safe='/') |
Guido van Rossum | 52dbbb9 | 2008-08-18 21:44:30 +0000 | [diff] [blame] | 474 | |
| 475 | Like :func:`quote`, but accepts a :class:`bytes` object rather than a |
| 476 | :class:`str`, and does not perform string-to-bytes encoding. |
| 477 | |
| 478 | Example: ``quote_from_bytes(b'a&\xef')`` yields |
| 479 | ``'a%26%EF'``. |
| 480 | |
Georg Brandl | 7f01a13 | 2009-09-16 15:58:14 +0000 | [diff] [blame] | 481 | |
| 482 | .. function:: unquote(string, encoding='utf-8', errors='replace') |
Senthil Kumaran | aca8fd7 | 2008-06-23 04:41:59 +0000 | [diff] [blame] | 483 | |
| 484 | Replace ``%xx`` escapes by their single-character equivalent. |
Guido van Rossum | 52dbbb9 | 2008-08-18 21:44:30 +0000 | [diff] [blame] | 485 | The optional *encoding* and *errors* parameters specify how to decode |
| 486 | percent-encoded sequences into Unicode characters, as accepted by the |
| 487 | :meth:`bytes.decode` method. |
Senthil Kumaran | aca8fd7 | 2008-06-23 04:41:59 +0000 | [diff] [blame] | 488 | |
Guido van Rossum | 52dbbb9 | 2008-08-18 21:44:30 +0000 | [diff] [blame] | 489 | *string* must be a :class:`str`. |
| 490 | |
| 491 | *encoding* defaults to ``'utf-8'``. |
| 492 | *errors* defaults to ``'replace'``, meaning invalid sequences are replaced |
| 493 | by a placeholder character. |
| 494 | |
| 495 | Example: ``unquote('/El%20Ni%C3%B1o/')`` yields ``'/El Niño/'``. |
Senthil Kumaran | aca8fd7 | 2008-06-23 04:41:59 +0000 | [diff] [blame] | 496 | |
| 497 | |
Georg Brandl | 7f01a13 | 2009-09-16 15:58:14 +0000 | [diff] [blame] | 498 | .. function:: unquote_plus(string, encoding='utf-8', errors='replace') |
Senthil Kumaran | aca8fd7 | 2008-06-23 04:41:59 +0000 | [diff] [blame] | 499 | |
Georg Brandl | 0f7ede4 | 2008-06-23 11:23:31 +0000 | [diff] [blame] | 500 | Like :func:`unquote`, but also replace plus signs by spaces, as required for |
Senthil Kumaran | aca8fd7 | 2008-06-23 04:41:59 +0000 | [diff] [blame] | 501 | unquoting HTML form values. |
| 502 | |
Guido van Rossum | 52dbbb9 | 2008-08-18 21:44:30 +0000 | [diff] [blame] | 503 | *string* must be a :class:`str`. |
| 504 | |
| 505 | Example: ``unquote_plus('/El+Ni%C3%B1o/')`` yields ``'/El Niño/'``. |
| 506 | |
Georg Brandl | 7f01a13 | 2009-09-16 15:58:14 +0000 | [diff] [blame] | 507 | |
Guido van Rossum | 52dbbb9 | 2008-08-18 21:44:30 +0000 | [diff] [blame] | 508 | .. function:: unquote_to_bytes(string) |
| 509 | |
| 510 | Replace ``%xx`` escapes by their single-octet equivalent, and return a |
| 511 | :class:`bytes` object. |
| 512 | |
| 513 | *string* may be either a :class:`str` or a :class:`bytes`. |
| 514 | |
| 515 | If it is a :class:`str`, unescaped non-ASCII characters in *string* |
| 516 | are encoded into UTF-8 bytes. |
| 517 | |
Nick Coghlan | 9fc443c | 2010-11-30 15:48:08 +0000 | [diff] [blame] | 518 | Example: ``unquote_to_bytes('a%26%EF')`` yields ``b'a&\xef'``. |
Guido van Rossum | 52dbbb9 | 2008-08-18 21:44:30 +0000 | [diff] [blame] | 519 | |
Senthil Kumaran | aca8fd7 | 2008-06-23 04:41:59 +0000 | [diff] [blame] | 520 | |
Senthil Kumaran | df022da | 2010-07-03 17:48:22 +0000 | [diff] [blame] | 521 | .. function:: urlencode(query, doseq=False, safe='', encoding=None, errors=None) |
Senthil Kumaran | aca8fd7 | 2008-06-23 04:41:59 +0000 | [diff] [blame] | 522 | |
Senthil Kumaran | df022da | 2010-07-03 17:48:22 +0000 | [diff] [blame] | 523 | Convert a mapping object or a sequence of two-element tuples, which may |
Senthil Kumaran | 2933312 | 2011-02-11 11:25:47 +0000 | [diff] [blame] | 524 | either be a :class:`str` or a :class:`bytes`, to a "percent-encoded" |
Senthil Kumaran | 6b3434a | 2012-03-15 18:11:16 -0700 | [diff] [blame] | 525 | string. If the resultant string is to be used as a *data* for POST |
Serhiy Storchaka | 5e1c053 | 2013-10-13 20:06:50 +0300 | [diff] [blame] | 526 | operation with :func:`~urllib.request.urlopen` function, then it should be |
| 527 | properly encoded to bytes, otherwise it would result in a :exc:`TypeError`. |
Senthil Kumaran | 6b3434a | 2012-03-15 18:11:16 -0700 | [diff] [blame] | 528 | |
Senthil Kumaran | df022da | 2010-07-03 17:48:22 +0000 | [diff] [blame] | 529 | The resulting string is a series of ``key=value`` pairs separated by ``'&'`` |
| 530 | characters, where both *key* and *value* are quoted using :func:`quote_plus` |
| 531 | above. When a sequence of two-element tuples is used as the *query* |
| 532 | argument, the first element of each tuple is a key and the second is a |
| 533 | value. The value element in itself can be a sequence and in that case, if |
| 534 | the optional parameter *doseq* is evaluates to *True*, individual |
| 535 | ``key=value`` pairs separated by ``'&'`` are generated for each element of |
| 536 | the value sequence for the key. The order of parameters in the encoded |
Nick Coghlan | 9fc443c | 2010-11-30 15:48:08 +0000 | [diff] [blame] | 537 | string will match the order of parameter tuples in the sequence. |
Senthil Kumaran | df022da | 2010-07-03 17:48:22 +0000 | [diff] [blame] | 538 | |
| 539 | When *query* parameter is a :class:`str`, the *safe*, *encoding* and *error* |
Nick Coghlan | 9fc443c | 2010-11-30 15:48:08 +0000 | [diff] [blame] | 540 | parameters are passed down to :func:`quote_plus` for encoding. |
| 541 | |
| 542 | To reverse this encoding process, :func:`parse_qs` and :func:`parse_qsl` are |
| 543 | provided in this module to parse query strings into Python data structures. |
Senthil Kumaran | df022da | 2010-07-03 17:48:22 +0000 | [diff] [blame] | 544 | |
Senthil Kumaran | 2933312 | 2011-02-11 11:25:47 +0000 | [diff] [blame] | 545 | Refer to :ref:`urllib examples <urllib-examples>` to find out how urlencode |
| 546 | method can be used for generating query string for a URL or data for POST. |
| 547 | |
Senthil Kumaran | df022da | 2010-07-03 17:48:22 +0000 | [diff] [blame] | 548 | .. versionchanged:: 3.2 |
Georg Brandl | 67b21b7 | 2010-08-17 15:07:14 +0000 | [diff] [blame] | 549 | Query parameter supports bytes and string objects. |
Senthil Kumaran | aca8fd7 | 2008-06-23 04:41:59 +0000 | [diff] [blame] | 550 | |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 551 | |
| 552 | .. seealso:: |
| 553 | |
Senthil Kumaran | 6257bdd | 2010-04-22 05:53:18 +0000 | [diff] [blame] | 554 | :rfc:`3986` - Uniform Resource Identifiers |
Senthil Kumaran | fe9230a | 2011-06-19 13:52:49 -0700 | [diff] [blame] | 555 | This is the current standard (STD66). Any changes to urllib.parse module |
Senthil Kumaran | 6257bdd | 2010-04-22 05:53:18 +0000 | [diff] [blame] | 556 | should conform to this. Certain deviations could be observed, which are |
Georg Brandl | 6faee4e | 2010-09-21 14:48:28 +0000 | [diff] [blame] | 557 | mostly for backward compatibility purposes and for certain de-facto |
Senthil Kumaran | 6257bdd | 2010-04-22 05:53:18 +0000 | [diff] [blame] | 558 | parsing requirements as commonly observed in major browsers. |
| 559 | |
| 560 | :rfc:`2732` - Format for Literal IPv6 Addresses in URL's. |
| 561 | This specifies the parsing requirements of IPv6 URLs. |
| 562 | |
| 563 | :rfc:`2396` - Uniform Resource Identifiers (URI): Generic Syntax |
| 564 | Document describing the generic syntactic requirements for both Uniform Resource |
| 565 | Names (URNs) and Uniform Resource Locators (URLs). |
| 566 | |
| 567 | :rfc:`2368` - The mailto URL scheme. |
| 568 | Parsing requirements for mailto url schemes. |
Georg Brandl | 116aa62 | 2007-08-15 14:28:22 +0000 | [diff] [blame] | 569 | |
| 570 | :rfc:`1808` - Relative Uniform Resource Locators |
| 571 | This Request For Comments includes the rules for joining an absolute and a |
| 572 | relative URL, including a fair number of "Abnormal Examples" which govern the |
| 573 | treatment of border cases. |
| 574 | |
Senthil Kumaran | 6257bdd | 2010-04-22 05:53:18 +0000 | [diff] [blame] | 575 | :rfc:`1738` - Uniform Resource Locators (URL) |
| 576 | This specifies the formal syntax and semantics of absolute URLs. |