+1

Author: skirpichev

Doc/c-api/conversion.rst

@@ -88,7 +88,7 @@ The following functions provide locale-independent string to number conversions.
    *format_code*, *precision*, and *flags*.
 
    *format_code* must be one of ``'e'``, ``'E'``, ``'f'``, ``'F'``,
-   ``'g'``, ``'G'`` or ``'r'``.  For ``'r'``, the supplied *precision*
+   ``'g'``, ``'G'``, ``'x'``, ``'X'`` or ``'r'``.  For ``'r'``, the supplied *precision*
    must be 0 and is ignored.  The ``'r'`` format code specifies the
    standard :func:`repr` format.
 
@@ -115,6 +115,9 @@ The following functions provide locale-independent string to number conversions.
 
    .. versionadded:: 3.1
 
+.. versionchanged:: 3.13
+   Support ``'x'`` and ``'X'`` format types for :class:`float`.
+
 
 .. c:function:: int PyOS_stricmp(const char *s1, const char *s2)
 

Doc/library/stdtypes.rst

@@ -2430,9 +2430,9 @@ The conversion types are:
 +------------+-----------------------------------------------------+-------+
 | ``'u'``    | Obsolete type -- it is identical to ``'d'``.        | \(6)  |
 +------------+-----------------------------------------------------+-------+
-| ``'x'``    | Signed hexadecimal (lowercase).                     | \(2)  |
+| ``'x'``    | Signed hexadecimal integer or float (lowercase).    | \(2)  |
 +------------+-----------------------------------------------------+-------+
-| ``'X'``    | Signed hexadecimal (uppercase).                     | \(2)  |
+| ``'X'``    | Signed hexadecimal integer or float (uppercase).    | \(2)  |
 +------------+-----------------------------------------------------+-------+
 | ``'e'``    | Floating point exponential format (lowercase).      | \(3)  |
 +------------+-----------------------------------------------------+-------+
@@ -2473,8 +2473,19 @@ Notes:
    inserted before the first digit.
 
 (2)
-   The alternate form causes a leading ``'0x'`` or ``'0X'`` (depending on whether
-   the ``'x'`` or ``'X'`` format was used) to be inserted before the first digit.
+   The alternate form for an integer causes a leading ``'0x'`` or ``'0X'``
+   (depending on whether the ``'x'`` or ``'X'`` format was used) to be
+   inserted before the first digit.
+
+   For floats, represent the number by a hexadecimal string in the style
+   ``[±]0xh.[hhhp±d``, where there is one hexadecimal digit before the
+   decimal-point character and the number of hexadecimal digits after it is
+   equal to the precision; if the precision is missing, then the precision is
+   sufficient for an exact representation of the value.  If the precision is
+   zero and the alternate form is not specified, no decimal-point character
+   appears.  The exponent ``d`` is written in decimal, it always contains at
+   least one digit, and it gives the power of 2 by which to multiply the
+   coefficient.
 
 (3)
    The alternate form causes the result to always contain a decimal point, even if
@@ -2505,6 +2516,9 @@ that ``'\0'`` is the end of the string.
    ``%f`` conversions for numbers whose absolute value is over 1e50 are no
    longer replaced by ``%g`` conversions.
 
+.. versionchanged:: 3.13
+   Support ``'x'`` and ``'X'`` format types for :class:`float`.
+
 
 .. index::
    single: buffer protocol; binary sequence types

Lib/test/test_format.py

@@ -279,9 +279,7 @@ def test_common_format(self):
         test_exc_common('%d', b'1', TypeError,
                         "%d format: a real number is required, not bytes")
         test_exc_common('%x', '1', TypeError,
-                        "%x format: an integer is required, not str")
-        test_exc_common('%x', 3.14, TypeError,
-                        "%x format: an integer is required, not float")
+                        "%x format: an integer or float is required, not str")
 
     def test_str_format(self):
         testformat("%r", "\u0378", "'\\u0378'")  # non printable

Lib/test/test_peepholer.py

@@ -586,9 +586,7 @@ def test_format_errors(self):
             eval("'%s%z' % (x, 5)", {'x': 1234})
         with self.assertRaisesRegex(TypeError, 'a real number is required, not str'):
             eval("'%d' % (x,)", {'x': '1234'})
-        with self.assertRaisesRegex(TypeError, 'an integer is required, not float'):
-            eval("'%x' % (x,)", {'x': 1234.56})
-        with self.assertRaisesRegex(TypeError, 'an integer is required, not str'):
+        with self.assertRaisesRegex(TypeError, 'an integer or float is required, not str'):
             eval("'%x' % (x,)", {'x': '1234'})
         with self.assertRaisesRegex(TypeError, 'must be real number, not str'):
             eval("'%f' % (x,)", {'x': '1234'})

Lib/test/test_str.py

@@ -1564,12 +1564,10 @@ def __int__(self):
         self.assertEqual('%X' % letter_m, '6D')
         self.assertEqual('%o' % letter_m, '155')
         self.assertEqual('%c' % letter_m, 'm')
-        self.assertRaisesRegex(TypeError, '%x format: an integer is required, not float', operator.mod, '%x', 3.14)
-        self.assertRaisesRegex(TypeError, '%X format: an integer is required, not float', operator.mod, '%X', 2.11)
         self.assertRaisesRegex(TypeError, '%o format: an integer is required, not float', operator.mod, '%o', 1.79)
-        self.assertRaisesRegex(TypeError, '%x format: an integer is required, not PseudoFloat', operator.mod, '%x', pi)
-        self.assertRaisesRegex(TypeError, '%x format: an integer is required, not complex', operator.mod, '%x', 3j)
-        self.assertRaisesRegex(TypeError, '%X format: an integer is required, not complex', operator.mod, '%X', 2j)
+        self.assertRaisesRegex(TypeError, '%x format: an integer or float is required, not PseudoFloat', operator.mod, '%x', pi)
+        self.assertRaisesRegex(TypeError, '%x format: an integer or float is required, not complex', operator.mod, '%x', 3j)
+        self.assertRaisesRegex(TypeError, '%X format: an integer or float is required, not complex', operator.mod, '%X', 2j)
         self.assertRaisesRegex(TypeError, '%o format: an integer is required, not complex', operator.mod, '%o', 1j)
         self.assertRaisesRegex(TypeError, '%u format: a real number is required, not complex', operator.mod, '%u', 3j)
         self.assertRaisesRegex(TypeError, '%i format: a real number is required, not complex', operator.mod, '%i', 2j)

Objects/bytesobject.c

@@ -463,13 +463,36 @@ formatlong(PyObject *v, int flags, int prec, int type)
             Py_DECREF(iobj);
             return result;
         }
-        if (!PyErr_ExceptionMatches(PyExc_TypeError))
+        if (PyErr_ExceptionMatches(PyExc_TypeError)) {
+            if (type == 'x' || type == 'X') {
+                PyErr_Clear();
+
+                PyObject *fobj;
+                if (!PyFloat_Check(v)) {
+                    fobj = PyNumber_Float(v);
+                    if (!fobj) {
+                        goto wrongtype;
+                    }
+                }
+                else {
+                    fobj = Py_NewRef(v);
+                }
+                formatfloat(fobj, flags, prec, type, &result, NULL, NULL);
+                if (!result) {
+                    return NULL;
+                }
+                return PyUnicode_FromEncodedObject(result, NULL, NULL);
+            }
+        }
+        else {
             return NULL;
+        }
     }
+  wrongtype:
     PyErr_Format(PyExc_TypeError,
         "%%%c format: %s is required, not %.200s", type,
-        (type == 'o' || type == 'x' || type == 'X') ? "an integer"
-                                                    : "a real number",
+        (type == 'x' || type == 'X') ?
+        "an integer or float" : type == 'o' ? "an integer": "a real number",
         Py_TYPE(v)->tp_name);
     return NULL;
 }

Objects/floatobject.c

@@ -1225,13 +1225,21 @@ static PyObject *
 float_hex_impl(PyObject *self)
 /*[clinic end generated code: output=0ebc9836e4d302d4 input=bec1271a33d47e67]*/
 {
+    PyObject *result = NULL;
     double x;
 
     CONVERT_TO_DOUBLE(self, x);
 
     char *buf = PyOS_double_to_string(x, 'x', -1, 0, NULL);
+    if (buf) {
+        result = PyUnicode_FromString(buf);
+        PyMem_Free(buf);
+    }
+    else {
+        PyErr_NoMemory();
+    }
 
-    return PyUnicode_FromString(buf);
+    return result;
 }
 
 /* Convert a hexadecimal string to a float. */

Objects/unicodeobject.c

@@ -13902,11 +13902,18 @@ mainformatlong(PyObject *v,
             if (PyErr_ExceptionMatches(PyExc_TypeError)) {
                 if (type == 'x' || type == 'X') {
                     PyErr_Clear();
-                    if (PyFloat_Check(v)) {
-                        if (formatfloat(v, arg, NULL, writer) == -1)
-                            return -1;
-                        return 1;
+
+                    PyObject *fobj;
+                    if (!PyFloat_Check(v)) {
+                        fobj = PyNumber_Float(v);
+                        if (!fobj) {
+                            goto wrongtype;
+                        }
                     }
+                    else {
+                        fobj = Py_NewRef(v);
+                    }
+                    return formatfloat(fobj, arg, p_output, NULL);
                 }
                 goto wrongtype;
             }
@@ -13964,10 +13971,15 @@ mainformatlong(PyObject *v,
     switch(type)
     {
         case 'o':
+            PyErr_Format(PyExc_TypeError,
+                    "%%%c format: an integer is required, "
+                    "not %.200s",
+                    type, Py_TYPE(v)->tp_name);
+            break;
         case 'x':
         case 'X':
             PyErr_Format(PyExc_TypeError,
-                    "%%%c format: an integer is required, "
+                    "%%%c format: an integer or float is required, "
                     "not %.200s",
                     type, Py_TYPE(v)->tp_name);
             break;