如何允许 None 或特定类型作为 Python C 扩展函数的参数？

Question

假设我有一个如下所示的人为函数：

静态 int foo(PyObject *self, PyObject *args) {
    字符 *a = "";
    字符 *b = "";
    整数c=0；

    if (!PyArg_ParseTuple(args, "ss|i", &a, &b, &c) {
        返回空值；
    }

    printf("c 是 %i
“， C）;

    //some_function_requiring_int_data_type(c);
}

我希望用户能够提交

int

或

None

作为

c

参数的值，但上面的代码不允许这样做：

>>>from spam import foo
>>>foo('a', 'b')
c is 0
>>>foo('a', 'b', 100)
c is 100
>>>foo('a', 'b', None)
TypeError: an integer is required

---

目前，为了启用此行为，我有一堆丑陋的代码，如下所示：

静态 int foo(PyObject *self, PyObject *args) {
    字符 *a = "";
    字符 *b = "";
    PyObject *c = NULL; // 注意我如何使用 PyObject *
    int c_int = 0; // 注意我如何有一个伴随的 int

    if (!PyArg_ParseTuple(args, "ss|O", &a, &b, &c) {
        返回空值；
    }

    // 丑陋的代码从这里开始
    如果（c）{
        如果（c！= Py_None）{
            如果（！PyInt_Check（c））{
                PyErr_SetString(PyExc_TypeError, "c 必须是 int 或 None");
                返回;
            }
            c_int = PyInt_AsSize_t(c);
        }
    }

    printf("c_int 是 %i
“，c_int);

    //some_function_requiring_int_data_type(c_int);
}

及其用途：

>>>from spam import foo
>>>foo('a', 'b')
c is 0
>>>foo('a', 'b', 100)
c is 100
>>>foo('a', 'b', None)
c is 0

Answer 1

我的第一个建议是仅使用关键字参数。这样做的主要优点是避免必须传递

None

占位符值，因为您永远不必“填写”（例如）未指定的第三个位置参数，以便您可以指定第四个位置参数。它基本上是改变 Python 接口以“符合你的意思”一点。

static PyObject* int_from_kw(PyObject* self, PyObject* args, PyObject* kwargs) {
    char *a, *b;
    Py_ssize_t c = 0; // default value

    char* kwarg_names[] = {"a","b","c",NULL};

    // optional check to ensure c is passed only as a keyword argument - not needed with Python 3
    if (PyTuple_Size(args)>2) {
        PyErr_SetString(PyExc_TypeError,"Only two positional arguments allowed");
        return NULL;
    }

    if (!PyArg_ParseTupleAndKeywords(args,kwargs,"ss|i",kwarg_names,&a,&b,&c)) {
        return NULL;
    }
    printf("c_int is %li\n", c);
    return PyLong_FromSsize_t(c);
}

（在 Python 3 中，您可以删除长度检查并使用

"ss|$i"

指定

$

之后的参数仅是关键字，这样更好一点）。您需要将函数类型指定为

METH_VARARGS|METH_KEYWORDS

。

然后您可以从 Python 中调用它作为

int_from_kw("something","something else") # default c
int_from_kw("something","something else",c=5)
int_from_kw(a="something",b="something else",c=5) # etc

但不是

int_from_kw("something","something else",c="not an int")
int_from_kw("something","something else",5)

缺点是该方法并不总是有效 - 有时您需要该函数符合第三方库强制执行的固定接口。

---

我的第二个建议是使用转换器函数。这并没有消除任何样板，而是将其全部保存在一个封闭且可重复使用的地方。这里的版本适用于 Python 3（因为这就是我安装的！），但我认为主要的 Python 2 更改是将

PyLong

替换为

PyInt

。

int int_or_none(PyObject* o, void* i) {
    Py_ssize_t tmp;
    Py_ssize_t* i2 = i;
    if (o==Py_None) {
        return 1; // happy - leave integer as the default
    }
    if (PyLong_Check(o)) {
        tmp = PyLong_AsSize_t(o);
        if (PyErr_Occurred()) {
           return 0;
        } else {
           *i2 = tmp;
           return 1;
        }
    }
    PyErr_SetString(PyExc_TypeError, "c must be int or None");
    return 0; // conversion failed
}

static PyObject* test_int_none(PyObject* self, PyObject* args) {
    char *a, *b;
    Py_ssize_t c = 0; // default value

    if (!PyArg_ParseTuple(args, "ss|O&", &a, &b, int_or_none, &c)) {
        return NULL;
    }
    printf("c_int is %i\n", c);
    return PyLong_FromSsize_t(c);
}

一些简短的说明（参考您的版本）：

• 我们相信

  o

  永远不会是

  NULL

  ，因为它来自Python，它总是会给你一个对象。
• 如果出现故障或

  None

  ，我们不会更改指针。这允许在调用函数中设置默认值。
• 转换为 C 整数类型后，我们必须检查是否发生错误，因为如果整数太大，可能会出现溢出错误。在这种情况下，正确的异常已经设置，因此我们只需返回 0 来指示失败。 （我认为这对于 Python 2 来说不太重要，因为它使用单独的大整数和小整数类型）

---

这些建议都没有真正回答所提出的问题，但它们确实提供了我认为更干净的替代方案。

Answer 2

使用转换器功能是一种方法。感谢@DavidW 的提示。

我确实有一些问题：

• 如果我不传递正确的数据类型，我现在可能会导致段错误
• 要求在 null 时，int 值只能是一个值（本例中为 0）。它不能被泛化，因此在不同的情况下我会想要默认值（如-1）
• 我必须对异常消息进行硬编码（“c 必须是 int”），所以我不能真正将其重用于不同的变量

如果有人有解决办法，请将其发布为答案。

static int int_or_none(PyObject *python, void *c) {
    int temp = 0;
    if (python) {
        if (python != PyNone) {
            if (!PyInt_Check(python)) {
                PyErr_SetString(PyExc_TypeError, "c must be int");
                return 0;
            }
            
            tmp = PyInt_AsSsize_t(python);
            if (tmp < 0) {
                PyErr_Format(PyExc_ValueError, "Timestamp must be > 0, not %i", tmp);
                return 0;
            }
        }
    }

    *((int *) c) = tmp;

    return 0;
    
}


static int foo(PyObject *self, PyObject *args) {
    char *a = "";
    char *b = "";
    int *c = NULL; // If I accidentally make this a char *c, it may segfault

    if (!PyArg_ParseTuple(args, "ss|O&", &a, &b, &int_or_none, &c) {
        return NULL;
    }

    printf("c_int is %i\n", c_int);

    //some_function_requiring_int_data_type(c_int);
}