Erweiterung von Python um C oder C ++ (wenn es mehrere Argumente gibt, wenn eine Liste von der Python-Seite übergeben wird)

Ich habe es selbst für eine Weile gemacht, also mach dir eine Notiz

Es wurde verwendet, wenn ein genetischer Algorithmus ausgeführt wurde. Ich fühle mich besser. .. .. Als Bonus habe ich eine einfache Dezimal-Binär-Konvertierung und eine Grau-Code-Konvertierung durchgeführt. Es ist einfach, Bitstring zu verwenden, aber mit der Bedeutung von Übung.

Zunächst C-Code (Teil). Der Einzug ist gebrochen, aber ich habe den gleichen Prozess viele Male geschrieben, aber die Namensregeln sind zufällig, aber als Ausgangspunkt. Es ist ein bisschen lang, aber es ist das gleiche.

Übrigens habe ich die Liste von der Python-Seite übergeben und auf der C-Seite erhalten. Programm ist schwierig ...

Referenz (hauptsächlich API-bezogen) http://stackoverflow.com/questions/5079570/writing-a-python-c-extension-how-to-correctly-load-a-pylistobject

http://rokujyouhitoma.hatenablog.com/entry/20100704/1278216557

http://www.hexacosa.net/documents/python-extending/

Referenz (Bitberechnung usw.) http://saeki-ce.xsrv.jp/index.html

Anderes Wiki etc.

cbinary.c

#include <Python.h>

#define LOWER_BOUND    0
#define UPPER_BOUND    1000
#define MAX_BIT_LENGTH 10

int binaryToValue(int *);

static PyObject *
valueToGray(PyObject *self, PyObject *args)
{
  //return gray code
  int i, n, m, len;
  unsigned int num;
  int b[MAX_BIT_LENGTH];
  PyListObject *binary;
  binary = (PyListObject *) PyList_New(MAX_BIT_LENGTH);

  if (!PyArg_ParseTuple(args, "i", &num)){
    return NULL;
  }
  n = (num >> 1) ^ num; //In grauen Code konvertieren

  //In Binär konvertieren
  for (i=0; n>0; i++){
    m=n%2;   //Geteilt durch 2
    n=n/2;  //Teilen Sie durch 2
    b[i] = m;
  }

  len = i; //Länge bei Konvertierung in eine Binärzahl der Ganzzahl

  //Addiere 0 zum Schwert, so dass es 10 Bit wird
  for (i=len; i<MAX_BIT_LENGTH; i++ ){
    b[i] = 0;
  }
 
  //Kopieren Sie die Bitfolge in umgekehrter Reihenfolge in binärer Reihenfolge
  n = 0;
  for (i=MAX_BIT_LENGTH-1; i>=0; i--){
  //Setzen Sie einen Wert vom Typ int bitweise in grau
    PyList_SET_ITEM(binary, n++, Py_BuildValue("i", b[i]));
  }

  return Py_BuildValue("O", binary);
}


static PyObject *
make_individual(PyObject *self, PyObject *args)
{

  int b[MAX_BIT_LENGTH];
  int m,n,i,len;
  unsigned int min, max;
  unsigned int random_int;
  unsigned int gray_int;

  PyListObject *gray; //Darstellung eines Python-Listenobjekts
  gray = (PyListObject *) PyList_New(MAX_BIT_LENGTH); //Größe ist MAX~Mache eine Liste von

  if (!PyArg_ParseTuple(args, "ii", &min, &max)){ //Wenn es mehrere Argumente gibt, schreiben Sie sie wie ii nebeneinander
    return NULL;
  }

  if (min < LOWER_BOUND){
    exit(0);
  }
  else if (max > UPPER_BOUND){
    exit(0);
  }
  //Generieren Sie zufällig ganze Zahlen
  random_int = min + (int)(rand()*(max-min+1.0)/(1.0+RAND_MAX));
  gray_int = (random_int >> 1) ^ random_int; //In grauen Code konvertieren

  n = gray_int;
  //In Binär konvertieren
  for (i=0; n>0; i++){
    m=n%2;   //Geteilt durch 2
    n=n/2;  //Teilen Sie durch 2
    b[i] = m;
  }

  len = i; //Länge bei Konvertierung in eine Binärzahl der Ganzzahl

  //Addiere 0 zum Schwert, so dass es 10 Bit wird
  for (i=len; i<MAX_BIT_LENGTH; i++ ){
    b[i] = 0;
  }
 
  //Kopieren Sie die Bitfolge in umgekehrter Reihenfolge in binärer Reihenfolge
  n = 0;
  for (i=MAX_BIT_LENGTH-1; i>=0; i--){
  //Setzen Sie einen Wert vom Typ int bitweise in grau
    PyList_SET_ITEM(gray, n++, Py_BuildValue("i", b[i]));
  }

  return Py_BuildValue("O", gray);
}

static PyObject *
grayToBinary(PyObject *self, PyObject *args)
{

  unsigned int num;
  unsigned int mask;
  int m,n,i,len;
  int b[MAX_BIT_LENGTH], inputed_binary[MAX_BIT_LENGTH];
  PyListObject *binary; //Darstellung eines Python-Listenobjekts
  PyObject *get_list;
  binary = (PyListObject *) PyList_New(MAX_BIT_LENGTH); 

  if (!PyArg_ParseTuple(args, "O", &get_list )){
    return NULL;
  }
  if PyList_Check(get_list) {
      for (i=0; i<PyList_Size(get_list); i++){
	//Extrahieren Sie den Inhalt des Listenobjekts, während Sie es konvertieren, damit es in C angezeigt wird?(Kein Selbstbewusstsein)
	inputed_binary[i] = PyInt_AsSsize_t(PyList_GetItem(get_list, (Py_ssize_t)i)); //ok
      }
    }
  
  num = binaryToValue(inputed_binary);
  
  for (mask = num >> 1; mask != 0; mask = mask >> 1){
    //Rückgängig machen vom Gray-Code
    num = num ^ mask;
  }
  
  n = num;
  //In Binär konvertieren
  for (i=0; n>0; i++){
    m=n%2;   //Geteilt durch 2
    n=n/2;  //Teilen Sie durch 2
    b[i] = m;
  }

  len = i; //Länge bei Konvertierung in eine Binärzahl der Ganzzahl

  //Addiere 0 zum Schwert, so dass es 10 Bit wird
  for (i=len; i<MAX_BIT_LENGTH; i++ ){
    b[i] = 0;
  }
  
  //Kopieren Sie die Bitfolge in umgekehrter Reihenfolge in binärer Reihenfolge
  n = 0;
  for (i=MAX_BIT_LENGTH-1; i>=0; i--){
    //Geben Sie bitweise einen Wert vom Typ int binär ein
    PyList_SET_ITEM(binary, n++, Py_BuildValue("i", b[i]));
  }

  return Py_BuildValue("O", binary);
}


int binaryToValue(int *b){
  //Konvertieren Sie Binär in Ganzzahl
  int i,n;
  i=0; n=0;

  while(i < MAX_BIT_LENGTH){
    if (b[i] == 1) n+=1;
    i+=1;
    if (i == MAX_BIT_LENGTH) break;
    n=n*2;
    //printf("%d\n", n);
  }
  return n;
}

static PyObject *
binaryToPtype(PyObject *self, PyObject *args)
{

  int i,n;
  int inputed_binary[MAX_BIT_LENGTH];
  PyListObject *binary; //Darstellung eines Python-Listenobjekts
  PyObject *get_list;

  if (!PyArg_ParseTuple(args, "O", &get_list )){ //Übergeben Sie das Python-Objekt so wie es ist
    return NULL;
  }
  
  if PyList_Check(get_list) {
      for (i=0; i<PyList_Size(get_list); i++){
	inputed_binary[i] = PyInt_AsSsize_t(PyList_GetItem(get_list, (Py_ssize_t)i)); //ok
      }
    }
  
  i=0; n=0;

  while(i < MAX_BIT_LENGTH){
    if (inputed_binary[i] == 1) n+=1;
    i+=1;
    if (i == MAX_BIT_LENGTH) break;
    n=n*2;
    //printf("%d\n", n);
  }
  return Py_BuildValue("i", n);
}


static PyObject *
hello(PyObject *self)
{
    printf("Hello World!!\n");
    Py_RETURN_NONE;
}

static char ext_doc[] = "C extention module example\n";

static PyMethodDef methods[] = {
  {"hello", (PyCFunction)hello, METH_NOARGS, "print hello world.\n"},
  {"value_to_gray", valueToGray, METH_VARARGS, "return gray obj.\n"},
  {"make_individual", make_individual, METH_VARARGS, "return gray code.\n"},
  {"gray_to_binary", grayToBinary, METH_VARARGS, "return binary code.\n"},
  {"binary_to_ptype", binaryToPtype, METH_VARARGS, "return ptype value.\n"},
  {NULL, NULL, 0, NULL}
};

void initcbinarymethods(void)
{
    Py_InitModule3("cbinarymethods", methods, ext_doc);
}

Wie üblich? Schreibe setup.py.

setup.py

from distutils.core import setup, Extension

module1 = Extension('cbinarymethods',
                    sources = ['cbinary.c'])

setup (name = 'cbinarymethods',
       version = '1.0',
       description = 'This is a demo package',
       ext_modules = [module1])

Bauen Sie wie gewohnt auf der Befehlszeile auf.

$ python setup.py build_ext --inplace　#--Fügen Sie es hinzu, um es aktuell zu machen.Es scheint, dass dies getan werden kann

Wenn Sie es erfolgreich erstellen können, haben Sie cbinarymethods.so.

Importieren wir es mit Python und verwenden es

>>> import cbinarymethods as cbm
>>> i = cbm.make_individual(200, 250)
>>> i
[0, 0, 1, 0, 0, 0, 1, 0, 1, 1]
>>> a = cbm.gray_to_binary([0,0,1,0,1,0,0,1,0,1])
>>> a
[0, 0, 1, 1, 0, 0, 0, 1, 1, 0]