Voici maintenant les exemples

/*
ctypes_test1.c
L'objectif est d'avoir une soubroutine en C
qui peut être accédé depuis le langage Python.

Pour compiler depuis un Terminal :
gcc -shared -Wl,-soname,ctypes_test1 -o ctypes_test1.so -fPIC ctypes_test1.c
gcc -shared -o ctypes_test1.so -fPIC ctypes_test1.c
Pour les options,
c.f. https://gcc.gnu.org/onlinedocs/gcc/Option-Summary.html

L'option "-Wl,-soname,pyco1" me semble inutile.
********************************************************/

#include <stdio.h>
#include <string.h>
// c.f. https://www.tutorialspoint.com/c_standard_library/string_h.htm

int hellotest() {
//===============
printf("Hello Wolrd\n");  // ne sera écrit nulle part !
return 7;
} // hellotest

long multiplier(long a, long b) {
//===============================
//Attend deux entiers et les multiple
return a * b;
} // multiplier

// Ne fonctionne pas, le type float et le type double ne sont pas
// reconnus.
double multiplierfxf(double a, double b) {
//========================================
//Attend deux nombres à virgule et les multiplie
return a * b;
} // multiplierfxf


char *dit_papa(char *p) {
//=======================
// Retourne le string envoyé en argument, suivit de " papa".
return strcat(p, " papa");
}


char *dit_bonjour(char *p) {
//==========================
// Retourne "Bonjour " suivit du string envoyé en argument
// c.f. https://www.tutorialspoint.com/cprogramming/c_arrays.htm
char temp[100];
strcpy(temp, "Bonjour ");
return strcat(temp, p);
}

# ctypes_test1.py
# L'objectif est d'accéder à des routines écrites en langage C
# depuis un programme Python.

# c.f. https://docs.python.org/3/library/ctypes.html
import ctypes
montest = ctypes.CDLL("/home/bg/Bg2/Python/ctests/testsimple.so")
# Il faut donner le chemin complet du fichier  .so  à inclure.
# Sous Linux, un fichier  .so  correspond à une  .dll  sous Windows.

print(montest.hellotest())

# Par défaut, les type sont int ou long,
# donc, il n'y a pas de conversion à faire.
a = 12
#a = ctypes.c_int(12) # a le même effet que : a = 12
b = 11
c = montest.multiplier(a, b) # Ceci fonctionne bien !
print("a*b=", a, "*", b, "=", c)
print("Le type de  c  est :", type(c))
print()
#================================================

va = 1.1
vb = 1.2
# Converti en type "double" du langage C
cva = ctypes.c_double(va)
cvb = ctypes.c_double(vb)
#print(cva) # pour information
#print(cva.value) # pour information

# Indique que le type de retour de la fonction est "double"
montest.multiplierfxf.restype = ctypes.c_double 

# Appelle de la fonction écrite en langage C
cvres = montest.multiplierfxf(cva, cvb)

print("va*vb =", cva.value, "*", vb, "=", cvres)
print("Le type de cvres est :", type(cvres))
print()
#================================================
mypystring = "le kiwi"
astr = ctypes.c_char_p(mypystring.encode('utf8'))
print(astr.value)

# Indique le type de la variable retournée par la fonction  C
montest.dit_papa.restype = ctypes.c_char_p
cstrrep = montest.dit_papa(astr)
print(cstrrep)
print(astr.value) # L'appelle à la fonction a modifié la valeur de astr.value !
print("Le type de  cstrrep  est :", type(cstrrep))
print()
#================================================

# Indique le type de la variable retournée par la fonction  C
montest.dit_bonjour.restype = ctypes.c_char_p
cret = montest.dit_bonjour(ctypes.c_char_p("Monsieur".encode('utf8')))
print(cret)
print("Le type de  cret  est :", type(cret))

# c.f. # Indique le type de la variable retournée par la fonction  C
# 16.16.1.4 Fundamental data types :
# Ce paragraphe indique les correspondances entre les type en langage C
# et ce qui est utilisable en Python.
# Il faut changer les type des arguments que l'on transmet au C
# Avec  .restype = ...  il faut indiquer le type de la variable retournée.

/*
ctypes_test2.c
L'objectif est d'avoir une soubroutine en C
qui peut être accédé depuis le langage Python.
 
gcc -shared -o ctypes_test2.so -fPIC ctypes_test2.c

gcc -I /usr/include/python3.5 -shared -Wl,-soname,pyco2 -o pyc02.so -fPIC pyc02.c
"-I /usr/include/python3.5" indique où trouver la librairie 
 
`gcc -print-prog-name=cc1` -v
Pour afficher la liste des répertoires utilisés par gcc
 
c.f. http://www.network-theory.co.uk/docs/gccintro/gccintro_21.html
-------------------------------------------------------------------
Pour l'emplacement des librairies utilisées par  gcc.

Par défaut, gcc cherche les headers dans :
/usr/local/include/
/usr/include/

Par défaut, gcc cherche les librairies dans :
/usr/local/lib/
/usr/lib/

On peut ajouter des répertoires de  "include" (.h) ainsi :
C_INCLUDE_PATH="/usr/include/python3.5"
export C_INCLUDE_PATH

gcc -shared -o pyc02.so -fPIC pyc02.c
Sera suffisant pour compiler le programme c, qui utilise 
une librairie de Python

Pour du C++, il faut :
CPLUS_INCLUDE_PATH=/opt/gdbm-1.8.3/include
export CPLUS_INCLUDE_PATH

Pour des librairies :
LIBRARY_PATH=/opt/gdbm-1.8.3/lib
export LIBRARY_PATH

This directory will be searched after any directories specified on the command line with the option -L, 
and before the standard default directories (such as ‘/usr/local/lib’ and ‘/usr/lib’).
c.f. : http://www.network-theory.co.uk/docs/gccintro/gccintro_23.html
******************************************************************************/

int fact(int n) {
//===============
// Fonction factorielle récursive en C
if (n < 2) return(1);
return (n)*fact(n-1);
} // fact

int pgcd(int a, int b) {
//======================
// fonction 'pgcd' en C
int r;
while (b!=0) {
  r = a%b;
  a = b;
  b = r;
  }
return a;
} // pgcd

# ctypes_test2.py
# L'objectif est d'accéder à des routines écrites en langage C
# depuis un programme Python.

# c.f. https://docs.python.org/3/library/ctypes.html
import ctypes
montest = ctypes.CDLL("/home/bg/Bg2/Python/ctests/ctypes_test2.so")
# Il faut donner le chemin complet du fichier  .so  à inclure.
# Sous Linux, un fichier  .so  correspond à une  .dll  sous Windows.

print(montest.fact(7))
print(montest.pgcd(5040, 3003))
# Fonctionne très bien.

a=5040
b=3003
c=montest.pgcd(a, b)
print("Le pgcd(", a, ",", b, ") =",c)

n=10
n_fact = montest.fact(n)
print(n, "! =", n_fact)

# Ces tests fonctionnent très bien et sont très simples,
# car on utilise que des nombres entiers !

/*
test0.c
L'objectif est d'avoir une soubroutine en C
qui peut être accédé depuis le langage Python.

Pour compiler depuis un Terminal :
gcc -shared -o test0.so -fPIC test0.c

Depuis Python, si on veut taper dans la console :
import os
os.getcwd() # indique le répertoire par défaut
os.chdir("/home/bg/Bg2/Python/ctests")  # pour changer le répertoire par défaut
import test0
test0.compte("abcdefgh")  # retournera la longueur du string. Ici = 8

Mieux : exécuter le script test0.py qui est donné dans un autre fichier.

Pour les types que Python reconnait et peut convertir en C :
https://www.tutorialspoint.com/python/python_further_extensions.htm

Curiosité :
import sys
sys.getrefcount(test0)
*****************************************************/

#include "Python.h"
#include <string.h>
// c.f. https://www.tutorialspoint.com/c_standard_library/string_h.htm

static PyObject* test0_compte(PyObject *self, PyObject *args) {
//=============================================================
// Définit la fonction en C qui sera appelée depuis Python
const char* command;
int sts;

if (!PyArg_ParseTuple(args, "s", &command)) return NULL;
  // c.f. https://docs.python.org/3.3/c-api/arg.html#PyArg_ParseTuple
sts = strlen(command);  // retourne la longueur de la chaine de caractères
    // Plus exactement, le nombre d'octets qui code cette chaîne de caractères
return PyLong_FromLong(sts);
} // test0_compte

static PyMethodDef test0Methods[] = {
//===================================
{"compte",  test0_compte, METH_VARARGS,
 "Compte le nombre de caractères d'une chaîne,\
 les caractères accentués comptent double.\n\
 Il faut donner une chaine de caractères en paramètre."},
 // Est un texte d'aide. Obtenu avec : print(test0.compte.__doc__)
 {NULL, NULL, 0, NULL}  // Sentinel 
};

static struct PyModuleDef test0module = {
//=======================================
// Est une structure nécessaire pour Python ???
  PyModuleDef_HEAD_INIT,
  "test0",   /* name of module */
  NULL,  //test0_doc, /* module documentation, may be NULL */
  -1,       /* size of per-interpreter state of the module,
             or -1 if the module keeps state in global variables. */
  test0Methods
};

PyMODINIT_FUNC PyInit_test0(void) {
//=================================
// Fonction de création du module
return PyModule_Create(&test0module);
} // PyInit_test0

int main(int argc, char *argv[]) {
//================================
// Fonction principale, qui sera exécutée au chargement du module
wchar_t *program = Py_DecodeLocale(argv[0], NULL);
if (program == NULL) {
  fprintf(stderr, "Fatal error: cannot decode argv[0]\n");
  exit(1);
  }

/* Add a built-in module, before Py_Initialize */
PyImport_AppendInittab("test0", PyInit_test0);

/* Pass argv[0] to the Python interpreter */
Py_SetProgramName(program);

/* Initialize the Python interpreter.  Required. */
Py_Initialize();

/* Optionally import the module; alternatively,
   import can be deferred until the embedded script
   imports it. */
PyImport_ImportModule("test0");

PyMem_RawFree(program);
return 0;
} // main

// Il y a beaucoup de points que je ne comprends pas, mais cela fonctionne !

"""
test0.py
Ceci est un exemple d'appel à une routine écrite en langage C.

Test la librairie de démo "test0.c"

"""

import test0

print(test0.compte("abcdefgh")) # affiche 8, qui est le nombre de caractères.
print(test0.compte("abc def")) # affiche 7, qui est le nombre de caractères.
print(test0.compte("aéb")) # affiche 4, car en utf-8, "é" prend 2 octets
str="Ceci est dans une variable"
print(test0.compte(str))
print(test0.compte.__doc__) # pour afficher de l'aide sur la fonction test0.compte

/*
test1.c
L'objectif est d'avoir une soubroutine en C
qui peut être accédé depuis le langage Python.

Pour compiler depuis un Terminal :
gcc -shared -o test1.so -fPIC test1.c

Depuis Python, si on veut taper dans la console :
import os
os.getcwd() # indique le répertoire par défaut
os.chdir("/home/bg/Bg2/Python/ctests")  # pour changer le répertoire par défaut
import test1
test1.mult(11,7)  # retournera le produit 11 * 7
Les arguments doivent être deux nombres entiers.

Mieux : exécuter le script test1.py qui est donné dans un autre fichier.

Pour les types que Python reconnait et peut convertir en C :
https://www.tutorialspoint.com/python/python_further_extensions.htm

Curiosité :
import sys
sys.getrefcount(test1)
***********************************************************/

#include "Python.h"

static PyObject *test1_mult(PyObject *self, PyObject *args) {
//=============================================================
// Définit la fonction en C qui sera appelée depuis Python
const long lNb1;
const long lNb2;
long lRep;

if (!PyArg_ParseTuple(args, "ll", &lNb1, &lNb2)) return NULL;
  // c.f. https://docs.python.org/3.3/c-api/arg.html#PyArg_ParseTuple
lRep = lNb1 * lNb2;  

return PyLong_FromLong(lRep);
// c.f. https://docs.python.org/3.3/c-api/long.html
} // test1_mult

static PyMethodDef test1Methods[] = {
//===================================
{"mult",  test1_mult, METH_VARARGS,
 "mult prend deux nombres entiers en entrée et retourne leur produit."},
 // Est un texte d'aide. Obtenu avec : print(test1.mult.__doc__)
 {NULL, NULL, 0, NULL}  // Sentinel 
};

static struct PyModuleDef test1module = {
//=======================================
// Est une structure nécessaire pour Python ???
  PyModuleDef_HEAD_INIT,
  "test1",   /* name of module */
  NULL,  //test1_doc, /* module documentation, may be NULL */
  -1,       /* size of per-interpreter state of the module,
             or -1 if the module keeps state in global variables. */
  test1Methods
};

PyMODINIT_FUNC PyInit_test1(void) {
//=================================
// Fonction de création du module
return PyModule_Create(&test1module);
} // PyInit_test1

int main(int argc, char *argv[]) {
//================================
// Fonction principale, qui sera exécutée au chargement du module
wchar_t *program = Py_DecodeLocale(argv[0], NULL);
if (program == NULL) {
  fprintf(stderr, "Fatal error: cannot decode argv[0]\n");
  exit(1);
  }

/* Add a built-in module, before Py_Initialize */
PyImport_AppendInittab("test1", PyInit_test1);

/* Pass argv[0] to the Python interpreter */
Py_SetProgramName(program);

/* Initialize the Python interpreter.  Required. */
Py_Initialize();

/* Optionally import the module; alternatively,
   import can be deferred until the embedded script
   imports it. */
PyImport_ImportModule("test1");

PyMem_RawFree(program);
return 0;
} // main

// Il y a beaucoup de points que je ne comprends pas, mais cela fonctionne !

"""
test1.py
Ceci est un exemple d'appel à une routine écrite en langage C.

Test la librairie de démo "test1.c"

"""

import test1

print(test1.mult(7, 8))
print(test1.mult(123456789, 123))
print(test1.mult(111111111, 111111111))
a=11
b=12
print(test1.mult(a, b))
print(test1.mult.__doc__) # pour afficher de l'aide sur la fonction.

/*
test2.c
L'objectif est d'avoir une soubroutine en C
qui peut être accédé depuis le langage Python.

Pour compiler depuis un Terminal :
gcc -shared -o test2.so -fPIC test2.c

Depuis Python, si on veut taper dans la console :
import os
os.getcwd() # indique le répertoire par défaut
os.chdir("/home/bg/Bg2/Python/ctests")  # pour changer le répertoire par défaut
import test2
test2.mult(3.1415, 7.0)  # retournera le produit 3.1415 * 7
Les arguments doivent être deux nombres à virgule.

Mieux : exécuter le script test2.py qui est donné dans un autre fichier.

Pour les types que Python reconnait et peut convertir en C :
https://www.tutorialspoint.com/python/python_further_extensions.htm

Curiosité :
import sys
sys.getrefcount(test2)
**************************************************************/

#include "Python.h"

static PyObject *test2_mult(PyObject *self, PyObject *args) {
//=============================================================
// Définit la fonction en C qui sera appelée depuis Python
const double vNb1;
const double vNb2;
double vRep;

if (!PyArg_ParseTuple(args, "dd", &vNb1, &vNb2)) return NULL;
vRep = vNb1 * vNb2;  

return PyFloat_FromDouble(vRep);
// https://docs.python.org/3.3/c-api/float.html
} // test2_mult

// Définit l'aide associée à la fonction.
#define AIDE "mult prend deux nombres à virgule en \
entrée et retourne leur produit."

static PyMethodDef test2Methods[] = {
//===================================
{"mult",  test2_mult, METH_VARARGS,
  AIDE}, // Est un texte d'aide. Obtenu avec : print(test2.mult.__doc__)
 {NULL, NULL, 0, NULL}  // Sentinel 
};

static struct PyModuleDef test2module = {
//=======================================
// Est une structure nécessaire pour Python ???
  PyModuleDef_HEAD_INIT,
  "test2",   /* name of module */
  NULL,  //test2_doc, /* module documentation, may be NULL */
  -1,       /* size of per-interpreter state of the module,
             or -1 if the module keeps state in global variables. */
  test2Methods
};

PyMODINIT_FUNC PyInit_test2(void) {
//=================================
// Fonction de création du module
return PyModule_Create(&test2module);
} // PyInit_test2

int main(int argc, char *argv[]) {
//================================
// Fonction principale, qui sera exécutée au chargement du module
wchar_t *program = Py_DecodeLocale(argv[0], NULL);
if (program == NULL) {
  fprintf(stderr, "Fatal error: cannot decode argv[0]\n");
  exit(1);
  }

/* Add a built-in module, before Py_Initialize */
PyImport_AppendInittab("test2", PyInit_test2);

/* Pass argv[0] to the Python interpreter */
Py_SetProgramName(program);

/* Initialize the Python interpreter.  Required. */
Py_Initialize();

/* Optionally import the module; alternatively,
   import can be deferred until the embedded script
   imports it. */
PyImport_ImportModule("test2");

PyMem_RawFree(program);
return 0;
} // main

// Il y a beaucoup de points que je ne comprends pas, mais cela fonctionne !

"""
test2.py
Ceci est un exemple d'appel à une routine écrite en langage C.

Test la librairie de démo "test2.c"
"""

import test2

print(test2.mult(3.1415, 7.0))
print(test2.mult(3.141593, 113.0)) 
print(test2.mult(1.111e8, 1.111e9))
a = 9.999
b = 1.111
print(test2.mult(a, b))
print(test2.mult.__doc__) # pour afficher de l'aide sur la fonction.

/*
test3.c
L'objectif est d'avoir une soubroutine en C
qui peut être accédé depuis le langage Python.

Pour compiler depuis un Terminal :
gcc -shared -o test3.so -fPIC test3.c

Depuis Python, si on veut taper dans la console :
import os
os.getcwd() # indique le répertoire par défaut
os.chdir("/home/bg/Bg2/Python/ctests")  # pour changer le répertoire par défaut
import test3
test3.sommeInv(700)  # retournera la somme des inverses des entiers de 1 à 700
L'argument doit être un nombre entier.
Retourne un nombre à virgule

Mieux : exécuter le script test3.py qui est donné dans un autre fichier.

Pour les types que Python reconnait et peut convertir en C :
https://www.tutorialspoint.com/python/python_further_extensions.htm
***********************************************************************/

#include "Python.h"

static PyObject *test3_sommeInv(PyObject *self, PyObject *args) {
//===============================================================
// Définit la fonction en C qui sera appelée depuis Python
// PyObject *x_obj;  // autre possibilité.
// Somme des inverses des nombres entiers de lNbMin à lNbMax-1
// lNbMin et lNbMax sont les deux arguments.
long lNbMax;
long lNbMin;
long lNbr;
double vRep;

if (!PyArg_ParseTuple(args, "ll", &lNbMin, &lNbMax)) return NULL; 
   // c.f. https://docs.python.org/3.3/c-api/arg.html#PyArg_ParseTuple
//if (!PyArg_ParseTuple(args, "O", &x_obj)) return NULL;
//lNbMax = PyLong_AsLong(x_obj); // c.f. https://docs.python.org/3.3/c-api/long.html

vRep = 0.0;
for (lNbr=lNbMax-1; lNbr>=lNbMin; lNbr--) vRep = vRep + 1.0 / lNbr;

return PyFloat_FromDouble(vRep);
// https://docs.python.org/3.3/c-api/float.html
} // test3_sommeInv

// Définit l'aide associée à la fonction.
#define AIDE "sommeInv prend deux nombres entiers Nmin et Nmax en entrée\n\
et retourne la somme des inverses des entiers de 1/Nmin à 1/(Nmax-1)."

static PyMethodDef test3Methods[] = {
//===================================
{"sommeInv",  test3_sommeInv, METH_VARARGS,
  AIDE}, // Est un texte d'aide. Obtenu avec : print(test3.sommeInv.__doc__)
 {NULL, NULL, 0, NULL}  // Sentinel 
};

static struct PyModuleDef test3module = {
//=======================================
// Est une structure nécessaire pour Python ???
  PyModuleDef_HEAD_INIT,
  "test3",   /* name of module */
  NULL,  //test3_doc, /* module documentation, may be NULL */
  -1,       /* size of per-interpreter state of the module,
             or -1 if the module keeps state in global variables. */
  test3Methods
};

PyMODINIT_FUNC PyInit_test3(void) {
//=================================
// Fonction de création du module
return PyModule_Create(&test3module);
} // PyInit_test3

int main(int argc, char *argv[]) {
//================================
// Fonction principale, qui sera exécutée au chargement du module
wchar_t *program = Py_DecodeLocale(argv[0], NULL);
if (program == NULL) {
  fprintf(stderr, "Fatal error: cannot decode argv[0]\n");
  exit(1);
  }

/* Add a built-in module, before Py_Initialize */
PyImport_AppendInittab("test3", PyInit_test3);

/* Pass argv[0] to the Python interpreter */
Py_SetProgramName(program);

/* Initialize the Python interpreter.  Required. */
Py_Initialize();

/* Optionally import the module; alternatively,
   import can be deferred until the embedded script
   imports it. */
PyImport_ImportModule("test3");

PyMem_RawFree(program);
return 0;
} // main

"""
test3.py
Ceci est un exemple d'appel à une routine écrite en langage C.

Test la librairie de démo "test3.c"

"""

import test3
print(test3.sommeInv.__doc__) # pour afficher de l'aide sur la fonction.
print()

print(test3.sommeInv(10, 100)) # 1/10 + 1/11 + 1/12 + 1/13 + 1/14 + ... + 1/(N-1)
print(test3.sommeInv(100, 1000)) # 1/100 + 1/101 + 1/102 + 1/103 + ... + 1/(N-1)
print(test3.sommeInv(1000, 10000)) # 1/1000 + 1/1001 + 1/1002 + ... + 1/(N-1)
print(test3.sommeInv(10000, 100000)) # 1/10000 + 1/10001 + 1/10002 + ... + 1/(N-1)
print()

nn=10
while (nn < 100000000):
    print(test3.sommeInv(nn, 10*nn))
    nn=10*nn

# On remarque que ces sommes donnent presque le même résultat.
# Ceci suggère très fortement que la série harmonique diverge
# et montre également qu'elle diverge comme Ln(N).
# La constante d'Euler-Mascheroni est définie par
# gamme = lim(N -> infini) (somme 1/k - Ln(N)) = 0,577 215 664 901 532 860 6…
# c.f. https://fr.wikipedia.org/wiki/Constante_d%27Euler-Mascheroni

print()
import math
nn=100000000
print("gama = ", test3.sommeInv(1, nn) - math.log(nn))

/*
test4.c
L'objectif est d'avoir une soubroutine en C
qui peut être accédé depuis le langage Python.

Pour compiler depuis un Terminal :
gcc -shared -o test4.so -fPIC test4.c

Depuis Python, exécuter le script test4.py qui est donné dans un autre fichier.

Pour les types que Python reconnait et peut convertir en C :
https://www.tutorialspoint.com/python/python_further_extensions.htm
***********************************************************************/

#include "Python.h"

static PyObject *test4_sommeInv9(PyObject *self, PyObject *args) {
//===============================================================
// Définit la fonction en C qui sera appelée depuis Python
// PyObject *x_obj;  // autre possibilité.
// Somme des inverses des nombres entiers de lNbMin à lNbMax-1
// lNbMin et lNbMax sont les deux arguments.
// test4_sommeInv9(1,10) = 2.8178571428571426;  // La somme de 1 à 8
// test4_sommeInv9(10,100) = 2.063991622224917;  // La somme de 10 à 88
// test4_sommeInv9(100,1000) = 1.818871425200977;  // La somme de 1 à 8888
// test4_sommeInv9(1000,10000) = 1.633464212583175;  // La somme de 1 à 88888
long lNbMax;
long lNbMin;
long lNbr;
long lDixPow;
double vRep;

if (!PyArg_ParseTuple(args, "ll", &lNbMin, &lNbMax)) return NULL; 
//if (!PyArg_ParseTuple(args, "O", &x_obj)) return NULL;
//lNbMax = PyLong_AsLong(x_obj); // c.f. https://docs.python.org/3.3/c-api/long.html

vRep = 0.0;
lNbr=lNbMin;
while (lNbr<lNbMax) {
  if (lNbr % 10 == 9) { lNbr ++;
    if (lNbr/10 % 10 == 9) { lNbr += 10;
      if (lNbr/100 % 10 == 9) { lNbr += 100;
        // J'ai laissé quelques "if" pour comprendre la structures des tests.
        lDixPow = 1000;
        while (lNbr/lDixPow % 10 == 9) {
          lNbr += lDixPow;
          lDixPow *=10;
          }
        }      
      }
    }
  vRep = vRep + 1.0 / lNbr;
  lNbr++;
  } // while

return PyFloat_FromDouble(vRep);
// https://docs.python.org/3.3/c-api/float.html
} // test4_sommeInv9

// Définit l'aide associée à la fonction.
#define AIDE "sommeInv9 prend deux nombres entiers Nmin et Nmax en entrée\n\
et retourne la somme des inverses des entiers de 1/Nmin à 1/(Nmax-1)\n\
dans laquelle tous les nombres contenant le chiffre 9\n\
ont été éliminés. Voici des nombres éliminés :\n\
9 ; 19 ; 29 ; 9xxx ; 19xxx ; 29xxx ; 999999.\n\
Nmin ne doit pas contenir de chiffre 9."

static PyMethodDef test4Methods[] = {
//===================================
{"sommeInv9",  test4_sommeInv9, METH_VARARGS,
  AIDE}, // Est un texte d'aide. Obtenu avec : print(test4.sommeInv9.__doc__)
 {NULL, NULL, 0, NULL}  // Sentinel 
};

static struct PyModuleDef test4module = {
//=======================================
// Est une structure nécessaire pour Python ???
  PyModuleDef_HEAD_INIT,
  "test4",   /* name of module */
  NULL,  //test4_doc, /* module documentation, may be NULL */
  -1,       /* size of per-interpreter state of the module,
             or -1 if the module keeps state in global variables. */
  test4Methods
};

PyMODINIT_FUNC PyInit_test4(void) {
//=================================
// Fonction de création du module
return PyModule_Create(&test4module);
} // PyInit_test4

int main(int argc, char *argv[]) {
//================================
// Fonction principale, qui sera exécutée au chargement du module
wchar_t *program = Py_DecodeLocale(argv[0], NULL);
if (program == NULL) {
  fprintf(stderr, "Fatal error: cannot decode argv[0]\n");
  exit(1);
  }

/* Add a built-in module, before Py_Initialize */
PyImport_AppendInittab("test4", PyInit_test4);

/* Pass argv[0] to the Python interpreter */
Py_SetProgramName(program);

/* Initialize the Python interpreter.  Required. */
Py_Initialize();

/* Optionally import the module; alternatively,
   import can be deferred until the embedded script
   imports it. */
PyImport_ImportModule("test4");

PyMem_RawFree(program);
return 0;
} // main

"""
test4.py
Ceci est un exemple d'appel à une routine écrite en langage C.

Test la librairie de démo "test4.c"

"""

import test4
print(test4.sommeInv9.__doc__) # pour afficher de l'aide sur la fonction.
print()

print(test4.sommeInv9(1, 10)) # 1/1 + 1/2 + 1/3 + 1/4 + ... + 1/8 (1/9 est éliminé)
print(test4.sommeInv9(10, 100)) # 1/10 + 1/11 + 1/12 + 1/13 + 1/14 + ... + 1/88
   # Eliminé : 1/19, 1/29, ..., 1/79, 1/89 à 1/99
print(test4.sommeInv9(100, 1000)) # 1/100 + 1/101 + 1/102 + 1/103 + ... + 1/888
print(test4.sommeInv9(1000, 10000)) # 1/1000 + 1/1001 + 1/1002 + ... + 1/8888
print(test4.sommeInv9(10000, 100000)) # 1/10000 + 1/10001 + 1/10002 + ... + 1/88888
print()

nn=10
s2 = test4.sommeInv9(nn, 10*nn)
while (nn < 100000000):
    s1 = s2
    nn=10*nn
    s2 = test4.sommeInv9(nn, 10*nn)
    print("Rapport =", s2/s1)

# On remarque que le rapport de ces sommes tend vers 0,9
# Ceci suggère très fortement que cette série converge
# comme 0.9^Log10(N)
# Donc la convergence est très lente.

nn = 10000000
s1 = test4.sommeInv9(1, nn)
s2 = test4.sommeInv9(nn, 10*nn)
# La valeur limite est environ :
# s1 + s2*(1 + 0.9 + 0.9^2 + 0.9^3 + 0.9^4 + ...) = s1 + 10*s2
print("Valeur limite =", s1 + 10*s2)
# On montre par d'autres méthodes que la valeur limite vaut bien :
# 22,92067 66192 64150 34816 ...

Plan du Site : Home     Python     python_code_c.html ( = http://www.juggling.ch/gisin/python/python_code_c.html )

Page mise à jour le 15 mars 2018 par Bernard Gisin     ( Envoyer un e-mail )
Hébergement par : www.infomaniak.ch