diff -r c450b69c355f Doc/library/urllib.parse.rst
--- a/Doc/library/urllib.parse.rst	Tue Apr 14 12:46:49 2015 -0400
+++ b/Doc/library/urllib.parse.rst	Tue Apr 14 14:51:32 2015 -0400
@@ -519,7 +519,7 @@
    Example: ``unquote_to_bytes('a%26%EF')`` yields ``b'a&\xef'``.


-.. function:: urlencode(query, doseq=False, safe='', encoding=None, errors=None)
+.. function:: urlencode(query, doseq=False, safe='', encoding=None, errors=None, quote_via=quote_plus)

    Convert a mapping object or a sequence of two-element tuples, which may
    contain :class:`str` or :class:`bytes` objects, to a "percent-encoded"
@@ -528,8 +528,11 @@
    properly encoded to bytes, otherwise it would result in a :exc:`TypeError`.

    The resulting string is a series of ``key=value`` pairs separated by ``'&'``
-   characters, where both *key* and *value* are quoted using :func:`quote_plus`
-   above. When a sequence of two-element tuples is used as the *query*
+   characters, where both *key* and *value* are quoted using the `quote_via`
+   function. By default, `quote_plus` is used to quote the values, which means
+   spaces are quoted as a '+' character. In order to quote spaces as '%20',
+   pass `quote_via=quote`.
+   When a sequence of two-element tuples is used as the *query*
    argument, the first element of each tuple is a key and the second is a
    value. The value element in itself can be a sequence and in that case, if
    the optional parameter *doseq* is evaluates to *True*, individual
diff -r c450b69c355f Lib/test/test_urlparse.py
--- a/Lib/test/test_urlparse.py	Tue Apr 14 12:46:49 2015 -0400
+++ b/Lib/test/test_urlparse.py	Tue Apr 14 14:51:32 2015 -0400
@@ -782,6 +782,12 @@
         result = urllib.parse.urlencode({'a': Trivial()}, True)
         self.assertEqual(result, 'a=trivial')

+    def test_urlencode_quote_via(self):
+        result = urllib.parse.urlencode({'a': 'some value'})
+        assert result == "a=some+value"
+        result = urllib.parse.urlencode({'a': 'some value'}, quote_via=urllib.parse.quote)
+        assert result == "a=some%20value"
+
     def test_quote_from_bytes(self):
         self.assertRaises(TypeError, urllib.parse.quote_from_bytes, 'foo')
         result = urllib.parse.quote_from_bytes(b'archaeological arcana')
diff -r c450b69c355f Lib/urllib/parse.py
--- a/Lib/urllib/parse.py	Tue Apr 14 12:46:49 2015 -0400
+++ b/Lib/urllib/parse.py	Tue Apr 14 14:51:32 2015 -0400
@@ -751,7 +751,7 @@
         _safe_quoters[safe] = quoter = Quoter(safe).__getitem__
     return ''.join([quoter(char) for char in bs])

-def urlencode(query, doseq=False, safe='', encoding=None, errors=None):
+def urlencode(query, doseq=False, safe='', encoding=None, errors=None, quote_via=quote_plus):
     """Encode a dict or sequence of two-element tuples into a URL query string.

     If any values in the query arg are sequences and doseq is true, each
@@ -763,8 +763,8 @@

     The components of a query arg may each be either a string or a bytes type.

-    The safe, encoding, and errors parameters are passed down to quote_plus()
-    (encoding and errors only if a component is a str).
+    The safe, encoding, and errors parameters are passed down to the function
+    specified by quote_via (encoding and errors only if a component is a str).
     """

     if hasattr(query, "items"):
@@ -790,27 +790,27 @@
     if not doseq:
         for k, v in query:
             if isinstance(k, bytes):
-                k = quote_plus(k, safe)
+                k = quote_via(k, safe)
             else:
-                k = quote_plus(str(k), safe, encoding, errors)
+                k = quote_via(str(k), safe, encoding, errors)

             if isinstance(v, bytes):
-                v = quote_plus(v, safe)
+                v = quote_via(v, safe)
             else:
-                v = quote_plus(str(v), safe, encoding, errors)
+                v = quote_via(str(v), safe, encoding, errors)
             l.append(k + '=' + v)
     else:
         for k, v in query:
             if isinstance(k, bytes):
-                k = quote_plus(k, safe)
+                k = quote_via(k, safe)
             else:
-                k = quote_plus(str(k), safe, encoding, errors)
+                k = quote_via(str(k), safe, encoding, errors)

             if isinstance(v, bytes):
-                v = quote_plus(v, safe)
+                v = quote_via(v, safe)
                 l.append(k + '=' + v)
             elif isinstance(v, str):
-                v = quote_plus(v, safe, encoding, errors)
+                v = quote_via(v, safe, encoding, errors)
                 l.append(k + '=' + v)
             else:
                 try:
@@ -818,15 +818,15 @@
                     x = len(v)
                 except TypeError:
                     # not a sequence
-                    v = quote_plus(str(v), safe, encoding, errors)
+                    v = quote_via(str(v), safe, encoding, errors)
                     l.append(k + '=' + v)
                 else:
                     # loop over the sequence
                     for elt in v:
                         if isinstance(elt, bytes):
-                            elt = quote_plus(elt, safe)
+                            elt = quote_via(elt, safe)
                         else:
-                            elt = quote_plus(str(elt), safe, encoding, errors)
+                            elt = quote_via(str(elt), safe, encoding, errors)
                         l.append(k + '=' + elt)
     return '&'.join(l)