+ cleanup and docs

Author: skirpichev

Doc/library/string.rst

@@ -398,9 +398,11 @@ following:
 
 .. index:: single: z; in string formatting
 
-The ``'z'`` option coerces negative zero floating-point values to positive
-zero after rounding to the format precision.  This option is only valid for
-floating-point presentation types.
+For floating-point presentation types the ``'z'`` option coerces negative zero
+floating-point values to positive zero after rounding to the format precision.
+For integer types ``'b'``, ``'o'``, ``'x'`` and ``'X'`` it can be used to
+interpret integer value as two's complement.  This option is invalid for other
+presentation types.
 
 .. versionchanged:: 3.11
    Added the ``'z'`` option (see also :pep:`682`).
@@ -464,10 +466,11 @@ used from the field content.
 
 For integer presentation types (excluding ``'c'``), the precision gives the
 minimal number of digits to appear, expanded with an appropriate number of
-leading zeros.  Note that for non-decimal presentation types --- integer value
-interpreted as ``max(k*precision, number.bit_length())``-bit two's complement,
-where ``k=1,3,4`` for ``'b'``, ``'o'`` and ``'x'``/``'X'`` types, respectively.
-A precision of ``0`` is treated as equivalent to a precision of ``1`` here.
+leading zeros.  If ``'z'`` option specified for non-decimal presentation types
+--- integer value interpreted as ``max(k*precision, number.bit_length())``-bit
+two's complement, where ``k=1,3,4`` for ``'b'``, ``'o'`` and ``'x'``/``'X'``
+types, respectively.  A precision of ``0`` is treated as equivalent to a
+precision of ``1`` here.
 
 .. versionchanged:: next
    Precision specification allowed for integer presentation types.

Lib/test/test_long.py

@@ -745,6 +745,8 @@ def test__format__(self):
         self.assertEqual(format(73, 'z.8b'), '01001001')
         self.assertEqual(format(73, 'z#.8b'), '0b01001001')
         self.assertEqual(format(300, 'z.8b'), '100101100')
+        self.assertEqual(format(200, '.8b'), '11001000')
+        self.assertEqual(format(200, 'z.8b'), '011001000')
         self.assertEqual(format(-200, 'z.8b'), '100111000')
         self.assertEqual(format(128, 'z.8b'), '010000000')
         self.assertEqual(format(-129, 'z.8b'), '101111111')

Python/formatter_unicode.c

@@ -1141,33 +1141,35 @@ format_long_internal(PyObject *value, const InternalFormatSpec *format,
                 goto done;
             }
 
-            /* Prepend enough leading zeros (after the sign) */
+            /* Prepend enough leading zeros (after sign and prefix) */
 
-            int sign = PyUnicode_READ_CHAR(tmp, leading_chars_to_skip) == '-';
+            int sign = PyUnicode_READ_CHAR(tmp, 0) == '-';
             Py_ssize_t tmp2_len = precision + leading_chars_to_skip + sign;
             Py_ssize_t tmp_len = PyUnicode_GET_LENGTH(tmp);
             Py_ssize_t gap = tmp2_len - tmp_len;
 
             if (gap > 0) {
                 PyObject *tmp2 = PyUnicode_New(tmp2_len, 127);
+                Py_ssize_t value_start = leading_chars_to_skip + sign;
 
-                if (PyUnicode_CopyCharacters(tmp2, leading_chars_to_skip + gap + sign,
-                                             tmp, leading_chars_to_skip + sign,
-                                             tmp2_len - leading_chars_to_skip - sign) == -1) {
+                if (PyUnicode_CopyCharacters(tmp2, value_start + gap,
+                                             tmp, value_start,
+                                             precision) == -1) {
                     Py_DECREF(tmp2);
                     goto done;
                 }
-                if (PyUnicode_Fill(tmp2, leading_chars_to_skip + sign, gap, '0') == -1) {
+                if (PyUnicode_Fill(tmp2, value_start, gap, '0') == -1) {
                     Py_DECREF(tmp2);
                     goto done;
                 }
-                if (sign && PyUnicode_WriteChar(tmp2, leading_chars_to_skip, '-') == -1) {
+                if (sign && PyUnicode_WriteChar(tmp2, 0, '-') == -1) {
                     Py_DECREF(tmp2);
                     goto done;
                 }
                 if (leading_chars_to_skip
-                    && PyUnicode_CopyCharacters(tmp2, 0, tmp, 0,
-                                                leading_chars_to_skip) == -1) {
+                    && PyUnicode_CopyCharacters(tmp2, sign, tmp, sign,
+                                                leading_chars_to_skip) == -1)
+                {
                     Py_DECREF(tmp2);
                     goto done;
                 }