Bonjour,

Le problème que je rencontre peut paraitre simple mais me pose quelques problèmes.

J'ai un ensemble de variable de type float stocker dans des listes que je souhaiterais écrire dans un fichier (jusque la tout va bien, mon code fonctionne).

Ce fichier doit obligatoirement contenir par ligne 6 variables de 12 caractères maximum chacun de type float : soit 6*12 caractères par ligne.

Ce fichier est par la suite lu par un code fortran et doit strictement respecter les conditions cité au dessus sinon le programme fortran ne fonctionne pas. Celui-ci ne peux être modifié.

Par exemple, la ligne a écrire contenu dans une liste est la suivante :

liste = [0.000000001 , 0.000001, 0.0001, 0.0 , 120000.0 , 125.53]

Pour cela mon code utilisé est le suivant :

for element in liste :
fichier = fichier.writeline('%12f' %element)

Le résultat est le suivant :
0.000000 0.000001 0.000100 0.000000120000.000000 125.530000
Le premier élément n'est pas complet, et le 5ème est de 13 caractères.

Si à la place, on écrit : fichier = fichier.writeline('%12.9f' %element)on obtient :
0.000000001 0.000001000 0.000100000 0.000000000120000.000000000125.530000000
Les 4 premiers éléments sont correcte, et le 5ème est de 16 caractères au lieu des 12 forcés

Pour éviter ce problème, j'ai utilisé le type %g : fichier = fichier.writeline('%12g' %element) on obtient :
1e-09 1e-06 0.0001 0 120000 125.53
Avec cette méthode, les éléments 1,2,4 et 5 ne sont pas de type float et le code fortran ne les prend pas en compte. Les exponentielles peuvent être pris en compte si un float est devant l'exponentielle (cad 1.0e-9)


Si quelqu'un trouve une solution pour que l'élément soit écrit sur 12 caractères maximum, je suis preneur. Ce qui m'étonne lorsque l'on écrit %12f, est que celui-ci ne soit pas forcé à écrire sur 12 caractères mais que les 6 chiffres après la virgule du type float soit prépondérant.

Merci pour les réponses.
Cordialement,
REQVIEM

C'est un peu normal, tu as un entier dont il ne connait pas la longueur et un décimal dont il ne connait pas la longueur.

Je te propose quelquechose qui n'est pas forcément optimisé, car j'ai pas eu le temps, mais ça à l'air de fonctionner.

def result(nombre):
    n = 12-(len(str(nombre))-1)
    if isinstance(nombre, float):
        entier, decimal = str(nombre).split(".")
        if n < 0 :
            return entier + "." + decimal[:(12-len(entier))]
        else :
            return entier + "." + decimal + n*"0"
    elif isinstance(nombre, int):
        return str(nombre) + "." + (12-len(str(nombre)))*"0"
    else:
        return "\"%s\" n'est pas un nombre" %(nombre)

print result(15.5789)
print result(5.3)
print result(189.15699877121313)
print result("a")
print result(15)

Résultat

15.5789000000
5.30000000000
189.156998771
"a" n'est pas un nombre
15.0000000000

Edit : Par contre pour des nombres < à <math>\(10 ^-^4\)</math>, ça ne fonctionne pas, pour tester, il suffit de faire

str(0.00001) # là ça merderait...

Il me semblait que python était capable de gérer ce style de problème !

Et bien, merci pour la solution que tu m'apporte. Ton code fonctionne correctement excepté pour les cas inférieur à 0.0001 ou le float le converti en exponentiel. Mais en codant de la même manière en ajoutant une exception pour le cas exponentiel j'aurais la bonne solution. Merci encore.

Ok alors c'est résolu

Pour info, si cela intéresse quelqu'un autre voici avec la modification comprenant les exponentiels

def result(nombre):
    n = 12-(len(str(nombre)))
    
    print n," :",nombre
    
    if isinstance(nombre, float):
        
        try : 
            entier, decimal = str(nombre).split(".")
            if n < 0  : 
                return entier + "." + decimal[:(12-len(entier))]
            else :
                return entier + "." + decimal + n*"0"
            
        except :
            entier,exponentiel = str(nombre).split("e")
            if n < 0  : 
                return entier + "E" + decimal[:(12-len(entier))]
            else :
                return entier + ".0E" + exponentiel
        
    elif isinstance(nombre, int):
        return str(nombre) + "." + (12-len(str(nombre)))*"0"
    else:
        return "\"%s\" n'est pas un nombre" %(nombre)

def result(nombre):
    n = 12-(len(str(nombre)))
    if isinstance(nombre, float):
        
        try : 
            entier, decimal = str(nombre).split(".")
            if n < 0  : 
                return entier + "." + decimal[:(12-len(entier))]
            else :
                return entier + "." + decimal + n*"0"   
        except :
            exponentiel = str(nombre).split("e")[1][2:]
            return "0." + (int(exponentiel)-1)*"0" + "1" + (12-(int(exponentiel)+1))*"0"
        
    elif isinstance(nombre, int):
        return str(nombre) + "." + (12-len(str(nombre)))*"0"
    else:
        return "\"%s\" n'est pas un nombre" %(nombre)

print result(0.00000001)
print result(15)

Resultat

0.00000001000
15.0000000000