Pobieranie kolejnych rzeczy podanych na wejściu i konstruowanie wartości.
*************************************************************************

Te działania są użyteczne przy tworzeniu swoich własnych zadań
rozszerzających i rozszerzających sposobów działania. Dodatkowe
informacje i przykłady dostępne są w Rozszerzony i wbudowany
interpreter Python.

The first three of these functions described, "PyArg_ParseTuple()",
"PyArg_ParseTupleAndKeywords()", and "PyArg_Parse()", all use *format
strings* which are used to tell the function about the expected
arguments.  The format strings use the same syntax for each of these
functions.


Parsowanie argumentów
=====================

napis kształtujący może być pusty lub składać się z "jednostek
kształtujących". Jednostka ukształtowania opisuje jeden pytonowski
przedmiot; jest to zazwyczaj jedna litera, lub kolejką jednostek
ukształtowania w ujętych w nawias. Z kilkoma wyjątkami, jednostka
ukształtowania, która nie jest  kolejką jednostek ujętą w nawias
zwykle odpowiada pojedynczo umiejscowionej rzeczy przekazywanej dla
tych zadań. W poniższych zapisach cytat jest jednostką kształtującą;
polecenie ujęte w nawias okrągły ( ) oznacza typ przedmiotu w języku
pytonowskim, który odpowiada jednostce kształtującej, a zapis ujęty w
nawiasie kwadratowym [ ] określa typ przedmiotu / przedmiotów w języku
C, którego miejsce powinno zostać wskazane i przekazane dla zadania.


Napisy i skrzynki wymiany
-------------------------

These formats allow accessing an object as a contiguous chunk of
memory. You don't have to provide raw storage for the returned unicode
or bytes area.

In general, when a format sets a pointer to a buffer, the buffer is
managed by the corresponding Python object, and the buffer shares the
lifetime of this object.  You won't have to release any memory
yourself. The only exceptions are "es", "es#", "et" and "et#".

However, when a "Py_buffer" structure gets filled, the underlying
buffer is locked so that the caller can subsequently use the buffer
even inside a "Py_BEGIN_ALLOW_THREADS" block without the risk of
mutable data being resized or destroyed.  As a result, **you have to
call** "PyBuffer_Release()" after you have finished processing the
data (or in any early abort case).

Bufory nie są zakończone znakiem NULL, chyba że zaznaczono inaczej.

Some formats require a read-only *bytes-like object*, and set a
pointer instead of a buffer structure.  They work by checking that the
object's "PyBufferProcs.bf_releasebuffer" field is "NULL", which
disallows mutable objects such as "bytearray".

Informacja:

  For all "#" variants of formats ("s#", "y#", etc.), the type of the
  length argument (int or "Py_ssize_t") is controlled by defining the
  macro "PY_SSIZE_T_CLEAN" before including "Python.h".  If the macro
  was defined, length is a "Py_ssize_t" rather than an "int". This
  behavior will change in a future Python version to only support
  "Py_ssize_t" and drop "int" support. It is best to always define
  "PY_SSIZE_T_CLEAN".

"s" ("str") [const char *]
   Convert a Unicode object to a C pointer to a character string. A
   pointer to an existing string is stored in the character pointer
   variable whose address you pass.  The C string is NUL-terminated.
   The Python string must not contain embedded null code points; if it
   does, a "ValueError" exception is raised. Unicode objects are
   converted to C strings using "'utf-8'" encoding. If this conversion
   fails, a "UnicodeError" is raised.

   Informacja:

     This format does not accept *bytes-like objects*.  If you want to
     accept filesystem paths and convert them to C character strings,
     it is preferable to use the "O&" format with
     "PyUnicode_FSConverter()" as *converter*.

   Zmienione w wersji 3.5: Previously, "TypeError" was raised when
   embedded null code points were encountered in the Python string.

"s*" ("str" or *bytes-like object*) [Py_buffer]
   This format accepts Unicode objects as well as bytes-like objects.
   It fills a "Py_buffer" structure provided by the caller. In this
   case the resulting C string may contain embedded NUL bytes. Unicode
   objects are converted to C strings using "'utf-8'" encoding.

"s#" ("str", read-only *bytes-like object*) [const char *, int or
"Py_ssize_t"]
   Like "s*", except that it doesn't accept mutable objects. The
   result is stored into two C variables, the first one a pointer to a
   C string, the second one its length. The string may contain
   embedded null bytes. Unicode objects are converted to C strings
   using "'utf-8'" encoding.

"z" ("str" or "None") [const char *]
   Like "s", but the Python object may also be "None", in which case
   the C pointer is set to "NULL".

"z*" ("str", *bytes-like object* or "None") [Py_buffer]
   Like "s*", but the Python object may also be "None", in which case
   the "buf" member of the "Py_buffer" structure is set to "NULL".

"z#" ("str", read-only *bytes-like object* or "None") [const char *,
int or "Py_ssize_t"]
   Like "s#", but the Python object may also be "None", in which case
   the C pointer is set to "NULL".

"y" (read-only *bytes-like object*) [const char *]
   This format converts a bytes-like object to a C pointer to a
   character string; it does not accept Unicode objects.  The bytes
   buffer must not contain embedded null bytes; if it does, a
   "ValueError" exception is raised.

   Zmienione w wersji 3.5: Previously, "TypeError" was raised when
   embedded null bytes were encountered in the bytes buffer.

"y*" (*bytes-like object*) [Py_buffer]
   This variant on "s*" doesn't accept Unicode objects, only bytes-
   like objects.  **This is the recommended way to accept binary
   data.**

"y#" (read-only *bytes-like object*) [const char *, int or
"Py_ssize_t"]
   Ten wariant "s#" nie akceptuje obiektów Unicode, a jedynie bajto-
   podobne obiekty.

"S" ("bytes") [PyBytesObject *]
   Requires that the Python object is a "bytes" object, without
   attempting any conversion.  Raises "TypeError" if the object is not
   a bytes object.  The C variable may also be declared as
   "PyObject*".

"Y" ("bytearray") [PyByteArrayObject *]
   Requires that the Python object is a "bytearray" object, without
   attempting any conversion.  Raises "TypeError" if the object is not
   a "bytearray" object. The C variable may also be declared as
   "PyObject*".

"u" ("str") [const Py_UNICODE *]
   Convert a Python Unicode object to a C pointer to a NUL-terminated
   buffer of Unicode characters.  You must pass the address of a
   "Py_UNICODE" pointer variable, which will be filled with the
   pointer to an existing Unicode buffer.  Please note that the width
   of a "Py_UNICODE" character depends on compilation options (it is
   either 16 or 32 bits). The Python string must not contain embedded
   null code points; if it does, a "ValueError" exception is raised.

   Zmienione w wersji 3.5: Previously, "TypeError" was raised when
   embedded null code points were encountered in the Python string.

   Deprecated since version 3.3, will be removed in version 3.12: Part
   of the old-style "Py_UNICODE" API; please migrate to using
   "PyUnicode_AsWideCharString()".

"u#" ("str") [const Py_UNICODE *, int or "Py_ssize_t"]
   This variant on "u" stores into two C variables, the first one a
   pointer to a Unicode data buffer, the second one its length.  This
   variant allows null code points.

   Deprecated since version 3.3, will be removed in version 3.12: Part
   of the old-style "Py_UNICODE" API; please migrate to using
   "PyUnicode_AsWideCharString()".

"Z" ("str" or "None") [const Py_UNICODE *]
   Like "u", but the Python object may also be "None", in which case
   the "Py_UNICODE" pointer is set to "NULL".

   Deprecated since version 3.3, will be removed in version 3.12: Part
   of the old-style "Py_UNICODE" API; please migrate to using
   "PyUnicode_AsWideCharString()".

"Z#" ("str" or "None") [const Py_UNICODE *, int or "Py_ssize_t"]
   Like "u#", but the Python object may also be "None", in which case
   the "Py_UNICODE" pointer is set to "NULL".

   Deprecated since version 3.3, will be removed in version 3.12: Part
   of the old-style "Py_UNICODE" API; please migrate to using
   "PyUnicode_AsWideCharString()".

"U" ("str") [PyObject *]
   Requires that the Python object is a Unicode object, without
   attempting any conversion.  Raises "TypeError" if the object is not
   a Unicode object.  The C variable may also be declared as
   "PyObject*".

"w*" (read-write *bytes-like object*) [Py_buffer]
   This format accepts any object which implements the read-write
   buffer interface. It fills a "Py_buffer" structure provided by the
   caller. The buffer may contain embedded null bytes. The caller have
   to call "PyBuffer_Release()" when it is done with the buffer.

"es" ("str") [const char *encoding, char **buffer]
   Ten wariant "s" jest używany do zakodowania Unicode w buforze
   znaków. To działa tylko dla zakodowanych danych bez osadzonych
   znaków NUL.

   This format requires two arguments.  The first is only used as
   input, and must be a "const char*" which points to the name of an
   encoding as a NUL-terminated string, or "NULL", in which case
   "'utf-8'" encoding is used. An exception is raised if the named
   encoding is not known to Python.  The second argument must be a
   "char**"; the value of the pointer it references will be set to a
   buffer with the contents of the argument text. The text will be
   encoded in the encoding specified by the first argument.

   "PyArg_ParseTuple()" will allocate a buffer of the needed size,
   copy the encoded data into this buffer and adjust **buffer* to
   reference the newly allocated storage.  The caller is responsible
   for calling "PyMem_Free()" to free the allocated buffer after use.

"et" ("str", "bytes" or "bytearray") [const char *encoding, char
**buffer]
   Podobnie jak "es" z wyjątkiem tego, że obiekty ciągów znaków są
   przekazywane dalej bez ich zapisywania. Zamiast tego implementacja
   zakłada, że obiekt łańcucha znaków wykorzystuje kodowanie
   przekazane jako parametr.

"es#" ("str") [const char *encoding, char **buffer, int or
"Py_ssize_t" *buffer_length]
   Ten wariant "s#" używany jest do kodowania Unicode w buforze
   znaków. W przeciwieństwie do formatu "es", ten wariant pozwala
   wprowadzać dane zawierające znaki NUL.

   It requires three arguments.  The first is only used as input, and
   must be a "const char*" which points to the name of an encoding as
   a NUL-terminated string, or "NULL", in which case "'utf-8'"
   encoding is used. An exception is raised if the named encoding is
   not known to Python.  The second argument must be a "char**"; the
   value of the pointer it references will be set to a buffer with the
   contents of the argument text. The text will be encoded in the
   encoding specified by the first argument. The third argument must
   be a pointer to an integer; the referenced integer will be set to
   the number of bytes in the output buffer.

   Istnieją dwa tryby pracy:

   If **buffer* points a "NULL" pointer, the function will allocate a
   buffer of the needed size, copy the encoded data into this buffer
   and set **buffer* to reference the newly allocated storage.  The
   caller is responsible for calling "PyMem_Free()" to free the
   allocated buffer after usage.

   If **buffer* points to a non-"NULL" pointer (an already allocated
   buffer), "PyArg_ParseTuple()" will use this location as the buffer
   and interpret the initial value of **buffer_length* as the buffer
   size.  It will then copy the encoded data into the buffer and NUL-
   terminate it.  If the buffer is not large enough, a "ValueError"
   will be set.

   W obu przypadkach, **buffer_length* jest ustawiany na długość
   zakodowanych danych z pominięciem zakańczającego znaku NUL.

"et#" ("str", "bytes" or "bytearray") [const char *encoding, char
**buffer, int or "Py_ssize_t" *buffer_length]
   Tak samo, jak w "es#" oprócz tego, że obiekty ciągu bajtów są
   przekazywane do funkcji bez ich zapisywania. Zamiast tego,
   implementacja zakłada że obiekt ciągu bajtów używa kodowania
   przekazywanego w parametrze.


Liczby
------

"b" ("int") [unsigned char]
   Convert a nonnegative Python integer to an unsigned tiny int,
   stored in a C "unsigned char".

"B" ("int") [unsigned char]
   Convert a Python integer to a tiny int without overflow checking,
   stored in a C "unsigned char".

"h" ("int") [short int]
   Convert a Python integer to a C "short int".

"H" ("int") [unsigned short int]
   Convert a Python integer to a C "unsigned short int", without
   overflow checking.

"i" ("int") [int]
   Convert a Python integer to a plain C "int".

"I" ("int") [unsigned int]
   Convert a Python integer to a C "unsigned int", without overflow
   checking.

"l" ("int") [long int]
   Convert a Python integer to a C "long int".

"k" ("int") [unsigned long]
   Convert a Python integer to a C "unsigned long" without overflow
   checking.

"L" ("int") [long long]
   Convert a Python integer to a C "long long".

"K" ("int") [unsigned long long]
   Convert a Python integer to a C "unsigned long long" without
   overflow checking.

"n" ("int") ["Py_ssize_t"]
   Convert a Python integer to a C "Py_ssize_t".

"c" ("bytes" or "bytearray" of length 1) [char]
   Convert a Python byte, represented as a "bytes" or "bytearray"
   object of length 1, to a C "char".

   Zmienione w wersji 3.3: Allow "bytearray" objects.

"C" ("str" of length 1) [int]
   Convert a Python character, represented as a "str" object of length
   1, to a C "int".

"f" ("float") [float]
   Convert a Python floating point number to a C "float".

"d" ("float") [double]
   Convert a Python floating point number to a C "double".

"D" ("complex") [Py_complex]
   Convert a Python complex number to a C "Py_complex" structure.


Inne obiekty
------------

"O" (object) [PyObject *]
   Store a Python object (without any conversion) in a C object
   pointer.  The C program thus receives the actual object that was
   passed.  The object's reference count is not increased.  The
   pointer stored is not "NULL".

"O!" (object) [*typeobject*, PyObject *]
   Store a Python object in a C object pointer.  This is similar to
   "O", but takes two C arguments: the first is the address of a
   Python type object, the second is the address of the C variable (of
   type "PyObject*") into which the object pointer is stored.  If the
   Python object does not have the required type, "TypeError" is
   raised.

"O&" (object) [*converter*, *anything*]
   Convert a Python object to a C variable through a *converter*
   function.  This takes two arguments: the first is a function, the
   second is the address of a C variable (of arbitrary type),
   converted to "void *".  The *converter* function in turn is called
   as follows:

      status = converter(object, address);

   where *object* is the Python object to be converted and *address*
   is the "void*" argument that was passed to the "PyArg_Parse*()"
   function. The returned *status* should be "1" for a successful
   conversion and "0" if the conversion has failed.  When the
   conversion fails, the *converter* function should raise an
   exception and leave the content of *address* unmodified.

   If the *converter* returns "Py_CLEANUP_SUPPORTED", it may get
   called a second time if the argument parsing eventually fails,
   giving the converter a chance to release any memory that it had
   already allocated. In this second call, the *object* parameter will
   be "NULL"; *address* will have the same value as in the original
   call.

   Zmienione w wersji 3.1: "Py_CLEANUP_SUPPORTED" was added.

"p" ("bool") [int]
   Tests the value passed in for truth (a boolean **p**redicate) and
   converts the result to its equivalent C true/false integer value.
   Sets the int to "1" if the expression was true and "0" if it was
   false. This accepts any valid Python value.  See Truth Value
   Testing for more information about how Python tests values for
   truth.

   Nowe w wersji 3.3.

"(items)" ("tuple") [*matching-items*]
   Obiekt musi być sekwencją języka Python, której długość jest liczbą
   elementów formatu mierzoną w *elementach*. Argumenty języka C muszą
   odpowiadać poszczególnym jednostkom formatu w *elementach*.
   Jednostki formatu dla sekwencji mogą być zagnieżdżane.

Możliwe jest przekazywanie liczb całkowitych "długich" (liczb
całkowitych, których wartość przekracza wartość stałej "LONG_MAX"
określoną dla danej architektury) chociaż żadne właściwe sprawdzenie
zakresu nie jest wykonywane - najbardziej znaczące cyfry dwójkowe są w
milczeniu obcinane, gdy docelowy obszar pamięci jest zbyt mały, aby
przyjąć wartość (w rzeczywistości składnia jest odziedziczona po
rzutowaniu z języka C --- twoje doświadczenia mogą się różnić).

Kilka innych znaków ma jeszcze znaczenie w ciągu formatu. Nie mogą one
wystąpić wewnątrz zagnieżdżonych nawiasach okrągłych. Są to:

"|"
   Indicates that the remaining arguments in the Python argument list
   are optional. The C variables corresponding to optional arguments
   should be initialized to their default value --- when an optional
   argument is not specified, "PyArg_ParseTuple()" does not touch the
   contents of the corresponding C variable(s).

"$"
   "PyArg_ParseTupleAndKeywords()" only: Indicates that the remaining
   arguments in the Python argument list are keyword-only.  Currently,
   all keyword-only arguments must also be optional arguments, so "|"
   must always be specified before "$" in the format string.

   Nowe w wersji 3.3.

":"
   The list of format units ends here; the string after the colon is
   used as the function name in error messages (the "associated value"
   of the exception that "PyArg_ParseTuple()" raises).

";"
   Na tym kończy się lista jednostek formatu; ciąg po średniku jest
   traktowany jako informacja o błędzie do użycia *zamiast*
   automatycznej wiadomości o błędzie. Znaki dwukropka ":" i średnika
   ";" wzajemnie się wykluczają.

Zwróć uwagę, że każde odniesienie do obiektu Pythona które jest
dostarczone do wywołującego funkcję jest odniesieniem *pożyczonym*;
nie zmniejsza ich liczby odniesień!

Dodatkowe parametry przekazywane do tych funkcji muszą być adresami
zmiennych których typ jest określany przez ciąg formatu; są one
używane do przechowywania wartości z krotki wejściowej. Jest parę
przypadków, jak opisuje to lista jednostek formatu powyżej, gdzie te
parametry są używane jako wprowadzane wartości; w takich przypadku
powinny one odpowiadać temu, co jest określone we właściwych im
jednostach formatu.

For the conversion to succeed, the *arg* object must match the format
and the format must be exhausted.  On success, the "PyArg_Parse*()"
functions return true, otherwise they return false and raise an
appropriate exception. When the "PyArg_Parse*()" functions fail due to
conversion failure in one of the format units, the variables at the
addresses corresponding to that and the following format units are
left untouched.


Funkcje interfejsu programowania aplikacji
------------------------------------------

int PyArg_ParseTuple(PyObject *args, const char *format, ...)

   Parse the parameters of a function that takes only positional
   parameters into local variables.  Returns true on success; on
   failure, it returns false and raises the appropriate exception.

int PyArg_VaParse(PyObject *args, const char *format, va_list vargs)

   Identical to "PyArg_ParseTuple()", except that it accepts a va_list
   rather than a variable number of arguments.

int PyArg_ParseTupleAndKeywords(PyObject *args, PyObject *kw, const char *format, char *keywords[], ...)

   Parse the parameters of a function that takes both positional and
   keyword parameters into local variables.  The *keywords* argument
   is a "NULL"-terminated array of keyword parameter names.  Empty
   names denote positional-only parameters. Returns true on success;
   on failure, it returns false and raises the appropriate exception.

   Zmienione w wersji 3.6: Added support for positional-only
   parameters.

int PyArg_VaParseTupleAndKeywords(PyObject *args, PyObject *kw, const char *format, char *keywords[], va_list vargs)

   Identical to "PyArg_ParseTupleAndKeywords()", except that it
   accepts a va_list rather than a variable number of arguments.

int PyArg_ValidateKeywordArguments(PyObject *)

   Ensure that the keys in the keywords argument dictionary are
   strings.  This is only needed if "PyArg_ParseTupleAndKeywords()" is
   not used, since the latter already does this check.

   Nowe w wersji 3.2.

int PyArg_Parse(PyObject *args, const char *format, ...)

   Function used to deconstruct the argument lists of "old-style"
   functions --- these are functions which use the "METH_OLDARGS"
   parameter parsing method, which has been removed in Python 3.  This
   is not recommended for use in parameter parsing in new code, and
   most code in the standard interpreter has been modified to no
   longer use this for that purpose.  It does remain a convenient way
   to decompose other tuples, however, and may continue to be used for
   that purpose.

int PyArg_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, ...)

   A simpler form of parameter retrieval which does not use a format
   string to specify the types of the arguments.  Functions which use
   this method to retrieve their parameters should be declared as
   "METH_VARARGS" in function or method tables.  The tuple containing
   the actual parameters should be passed as *args*; it must actually
   be a tuple.  The length of the tuple must be at least *min* and no
   more than *max*; *min* and *max* may be equal.  Additional
   arguments must be passed to the function, each of which should be a
   pointer to a "PyObject*" variable; these will be filled in with the
   values from *args*; they will contain borrowed references.  The
   variables which correspond to optional parameters not given by
   *args* will not be filled in; these should be initialized by the
   caller. This function returns true on success and false if *args*
   is not a tuple or contains the wrong number of elements; an
   exception will be set if there was a failure.

   This is an example of the use of this function, taken from the
   sources for the "_weakref" helper module for weak references:

      static PyObject *
      weakref_ref(PyObject *self, PyObject *args)
      {
          PyObject *object;
          PyObject *callback = NULL;
          PyObject *result = NULL;

          if (PyArg_UnpackTuple(args, "ref", 1, 2, &object, &callback)) {
              result = PyWeakref_NewRef(object, callback);
          }
          return result;
      }

   The call to "PyArg_UnpackTuple()" in this example is entirely
   equivalent to this call to "PyArg_ParseTuple()":

      PyArg_ParseTuple(args, "O|O:ref", &object, &callback)


Budowanie wartości
==================

PyObject* Py_BuildValue(const char *format, ...)
    *Return value: New reference.*

   Create a new value based on a format string similar to those
   accepted by the "PyArg_Parse*()" family of functions and a sequence
   of values.  Returns the value or "NULL" in the case of an error; an
   exception will be raised if "NULL" is returned.

   "Py_BuildValue()" does not always build a tuple.  It builds a tuple
   only if its format string contains two or more format units.  If
   the format string is empty, it returns "None"; if it contains
   exactly one format unit, it returns whatever object is described by
   that format unit.  To force it to return a tuple of size 0 or one,
   parenthesize the format string.

   When memory buffers are passed as parameters to supply data to
   build objects, as for the "s" and "s#" formats, the required data
   is copied.  Buffers provided by the caller are never referenced by
   the objects created by "Py_BuildValue()".  In other words, if your
   code invokes "malloc()" and passes the allocated memory to
   "Py_BuildValue()", your code is responsible for calling "free()"
   for that memory once "Py_BuildValue()" returns.

   In the following description, the quoted form is the format unit;
   the entry in (round) parentheses is the Python object type that the
   format unit will return; and the entry in [square] brackets is the
   type of the C value(s) to be passed.

   The characters space, tab, colon and comma are ignored in format
   strings (but not within format units such as "s#").  This can be
   used to make long format strings a tad more readable.

   "s" ("str" or "None") [const char *]
      Convert a null-terminated C string to a Python "str" object
      using "'utf-8'" encoding. If the C string pointer is "NULL",
      "None" is used.

   "s#" ("str" or "None") [const char *, int or "Py_ssize_t"]
      Convert a C string and its length to a Python "str" object using
      "'utf-8'" encoding. If the C string pointer is "NULL", the
      length is ignored and "None" is returned.

   "y" ("bytes") [const char *]
      This converts a C string to a Python "bytes" object.  If the C
      string pointer is "NULL", "None" is returned.

   "y#" ("bytes") [const char *, int or "Py_ssize_t"]
      This converts a C string and its lengths to a Python object.  If
      the C string pointer is "NULL", "None" is returned.

   "z" ("str" or "None") [const char *]
      Same as "s".

   "z#" ("str" or "None") [const char *, int or "Py_ssize_t"]
      Same as "s#".

   "u" ("str") [const wchar_t *]
      Convert a null-terminated "wchar_t" buffer of Unicode (UTF-16 or
      UCS-4) data to a Python Unicode object.  If the Unicode buffer
      pointer is "NULL", "None" is returned.

   "u#" ("str") [const wchar_t *, int or "Py_ssize_t"]
      Convert a Unicode (UTF-16 or UCS-4) data buffer and its length
      to a Python Unicode object.   If the Unicode buffer pointer is
      "NULL", the length is ignored and "None" is returned.

   "U" ("str" or "None") [const char *]
      Same as "s".

   "U#" ("str" or "None") [const char *, int or "Py_ssize_t"]
      Same as "s#".

   "i" ("int") [int]
      Convert a plain C "int" to a Python integer object.

   "b" ("int") [char]
      Convert a plain C "char" to a Python integer object.

   "h" ("int") [short int]
      Convert a plain C "short int" to a Python integer object.

   "l" ("int") [long int]
      Convert a C "long int" to a Python integer object.

   "B" ("int") [unsigned char]
      Convert a C "unsigned char" to a Python integer object.

   "H" ("int") [unsigned short int]
      Convert a C "unsigned short int" to a Python integer object.

   "I" ("int") [unsigned int]
      Convert a C "unsigned int" to a Python integer object.

   "k" ("int") [unsigned long]
      Convert a C "unsigned long" to a Python integer object.

   "L" ("int") [long long]
      Convert a C "long long" to a Python integer object.

   "K" ("int") [unsigned long long]
      Convert a C "unsigned long long" to a Python integer object.

   "n" ("int") ["Py_ssize_t"]
      Convert a C "Py_ssize_t" to a Python integer.

   "c" ("bytes" of length 1) [char]
      Convert a C "int" representing a byte to a Python "bytes" object
      of length 1.

   "C" ("str" of length 1) [int]
      Convert a C "int" representing a character to Python "str"
      object of length 1.

   "d" ("float") [double]
      Convert a C "double" to a Python floating point number.

   "f" ("float") [float]
      Convert a C "float" to a Python floating point number.

   "D" ("complex") [Py_complex *]
      Convert a C "Py_complex" structure to a Python complex number.

   "O" (object) [PyObject *]
      Pass a Python object untouched (except for its reference count,
      which is incremented by one).  If the object passed in is a
      "NULL" pointer, it is assumed that this was caused because the
      call producing the argument found an error and set an exception.
      Therefore, "Py_BuildValue()" will return "NULL" but won't raise
      an exception.  If no exception has been raised yet,
      "SystemError" is set.

   "S" (object) [PyObject *]
      Same as "O".

   "N" (object) [PyObject *]
      Same as "O", except it doesn't increment the reference count on
      the object. Useful when the object is created by a call to an
      object constructor in the argument list.

   "O&" (object) [*converter*, *anything*]
      Convert *anything* to a Python object through a *converter*
      function.  The function is called with *anything* (which should
      be compatible with "void*") as its argument and should return a
      "new" Python object, or "NULL" if an error occurred.

   "(items)" ("tuple") [*matching-items*]
      Convert a sequence of C values to a Python tuple with the same
      number of items.

   "[items]" ("list") [*matching-items*]
      Convert a sequence of C values to a Python list with the same
      number of items.

   "{items}" ("dict") [*matching-items*]
      Convert a sequence of C values to a Python dictionary.  Each
      pair of consecutive C values adds one item to the dictionary,
      serving as key and value, respectively.

   If there is an error in the format string, the "SystemError"
   exception is set and "NULL" returned.

PyObject* Py_VaBuildValue(const char *format, va_list vargs)
    *Return value: New reference.*

   Identical to "Py_BuildValue()", except that it accepts a va_list
   rather than a variable number of arguments.
