Python: la sortie au Format chaîne de caractères, alignement à droite

Je suis le traitement d'un fichier texte contenant les coordonnées x, y, z

     1      128  1298039
123388        0        2
....

chaque ligne est séparée en 3 éléments à l'aide de

words = line.split()

Après le traitement de données dont j'ai besoin pour écrire les coordonnées de retour dans un autre fichier txt, de sorte que les éléments de chaque colonne sont alignés à droite (ainsi que le fichier d'entrée). Chaque ligne est composée des coordonnées

line_new = words[0]  + '  ' + words[1]  + '  ' words[2].

Est-il un manipulateur comme std::setw() etc. en C++ permettant de définir la largeur et l'alignement?

Quelle est la relation entre les variables words et word?
Marque: Faute de frappe, a été fixé...

InformationsquelleAutor justik | 2011-11-22

190

Essayer cette approche à l'aide de la plus récente str.format syntaxe:
```
line_new = '{:>12}  {:>12}  {:>12}'.format(word[0], word[1], word[2])
```
Et voici comment le faire en utilisant l'ancienne % syntaxe (utile pour les anciennes versions de Python qui ne supportent pas str.format):
```
line_new = '%12s  %12s  %12s' % (word[0], word[1], word[2])
```
- Notez comment les "vieux" syntaxe est plus propre, plus facile à lire, et de plus courte durée.
- Je pensais ajouter un lien plus direct que celui fourni: docs.python.org/2/library/...
- Plus courte pour sûr, je ne sais pas ce nettoyant signifie vraiment, mais "facile à lire" est juste parce que c'est familier, je pense. Si vous n'êtes pas déjà familier avec l'un d'eux, le nouveau format semble plus facile à lire. ".format" pour la mise en forme de chaîne semble bien plus intuitive que pourcentage/modulo. Flèche vers la droite pour un alignement à droite semble assez intuitif trop.
- Si vous utilisez python 2 et alligning lignes avec des caractères non-latin utiliser l'unicode! (u'...'.format)
- Comment puis-je combiner les deux > < en python 2 avec la même chaîne à l'aide de %
- Une façon à l'ancienne est plus propre, c'est qu'il utilise moins de caractères. Oui, avec la familiarité d'une nouvelle manière devient intuitif, mais il n'est pas plus propre et plus simple. L'ancienne méthode est plus intuitive pour ceux qui sont habitués à la syntaxe qui nous vient à travers le vénérable langage C, un langage de l'exemplaire de la concision et de la précision. Ce précédent est-il une nouvelle façon?
- Donc, vous dites qu'il y a une façon que nous pourrions le faire en Python tout aussi lisible que du C? Que doit être une cause populaire en effet.
- Ha! Bon point. M'a donné un éclat de rire. Mais si je peux me greffer sur votre point sur la connaissance, l'expérimenté programmeurs C trouver C plus facile à lire que, disons, Perl au premier coup d'œil, donc... Après que, bien que je préfère l'ancienne façon, même quand je peux lire d'une nouvelle manière. Je trouve la nouvelle manière cryptique et verbeux, préférez le nouveau format de la fonction.
InformationsquelleAutor Mark Byers
45

Vous pouvez l'aligner comme ça:
```
print('{:>8} {:>8} {:>8}'.format(*words))
```
où > signifie "aligner à droite" et 8 est le largeur de valeur spécifique.

Et en voici la preuve:
```
>>> for line in [[1, 128, 1298039], [123388, 0, 2]]:
    print('{:>8} {:>8} {:>8}'.format(*line))


       1      128  1298039
  123388        0        2
```
Ps. *line signifie la line liste sera déballé, donc .format(*line) fonctionne de façon similaire à .format(line[0], line[1], line[2]) (en supposant que line une liste avec seulement trois éléments).

InformationsquelleAutor Tadeck
43

Elle peut être obtenue en utilisant rjust:
```
line_new = word[0].rjust(10) + word[1].rjust(10) + word[2].rjust(10)
```
- Je me demande juste pourquoi cette réponse a si peu de upvotes. C'est le seul qui ne dispose pas d'une telle laideur de la syntaxe.
InformationsquelleAutor clwen
13

J'ai vraiment profiter d'une nouvelle chaîne littérale de l'interpolation en Python 3.6+:
```
line_new = f'{word[0]:>12}  {word[1]:>12}  {word[2]:>12}'
```
Référence: PEP 498 -- Chaîne Littérale de l'Interpolation

InformationsquelleAutor dmitry_romanov

Simple totalisation de la sortie:

a = 0.3333333
b = 200/3
print("variable a    variable b")
print("%10.2f    %10.2f" % (a, b))

de sortie:

variable a    variable b
      0.33         66.67

%10.2 f: 10 est la longueur minimale et 2 est le nombre de décimales.

InformationsquelleAutor Thoran

Voici une autre façon de comment vous pouvez mettre en forme à l'aide de " f-chaîne de format:

print(
    f"{'Trades:':<15}{cnt:>10}",
    f"\n{'Wins:':<15}{wins:>10}",
    f"\n{'Losses:':<15}{losses:>10}",
    f"\n{'Breakeven:':<15}{evens:>10}",
    f"\n{'Win/Loss Ratio:':<15}{win_r:>10}",
    f"\n{'Mean Win:':<15}{mean_w:>10}",
    f"\n{'Mean Loss:':<15}{mean_l:>10}",
    f"\n{'Mean:':<15}{mean_trd:>10}",
    f"\n{'Std Dev:':<15}{sd:>10}",
    f"\n{'Max Loss:':<15}{max_l:>10}",
    f"\n{'Max Win:':<15}{max_w:>10}",
    f"\n{'Sharpe Ratio:':<15}{sharpe_r:>10}",
)

Cela donnera le résultat suivant:

Trades:              2304
Wins:                1232
Losses:              1035
Breakeven:             37
Win/Loss Ratio:      1.19
Mean Win:           0.381
Mean Loss:         -0.395
Mean:               0.026
Std Dev:             0.56
Max Loss:          -3.406
Max Win:             4.09
Sharpe Ratio:      0.7395

Ce que vous faites ici, c'est vous dire que la première colonne est de 15 caractères et c'est justifié à gauche et de la deuxième colonne (valeurs) est de 10 caractères de long et il est justifié à droite.

InformationsquelleAutor Vlad Bezden

Vous devez vous connecter pour publier un commentaire.