print variable Länge in Python3

[Markus W. (dl8mby)]

Hallo Forum,

ich sitze schon eine Weile über dem folgendem Python3 Problem.

Ich habe eine Output den ich lese mit Zeilen unterschiedlicher Länge.

Bei diesen bestimme ich die längste Zeile und möchte
alle weiteren Zeilen mit gleicher maximaler Länge mittels der
print-Anweisung ausgeben.

z.B. print("Ausgabe: |{0}|".format(zeile[i],maxlaenge))

Erhalten möchte ich die folgende Ausgabe:

Ausgabe: |Zeile1                |
Ausgabe: |Z....eile2            |
Ausgabe: |Z.........eile3       |
Ausgabe: |Zeile4 mit max. Laenge|

Bei 'C' würde ich printf("%10sn\",zeile[i]); schreiben,
wobei die '10' statisch ist. Ich brauche es aber dynamisch.

Habe leider trotz Suche auf den Python Seiten und auch bei
stackoverflow nichts passendes gefunden, oder es übersehen.

Habt Ihr was passendes für mich.

Danke schon mal für die Mühe.

Markus

[Helmut H. (helmuth)]

Markus W. schrieb:
> Ich brauche es aber dynamisch.

würde mittels .ljust(ml) den string auf die maximale Länge ml erweitern.
https://www.w3schools.com/python/ref_string_ljust.asp

[Karl (Gast)]

Schau mal nach f-strings.
Es gibt für das Problem was von der Stange.

[MaWin (Gast)]

Markus W. schrieb:
> Ich brauche es aber dynamisch

naja, dann stelle den formatstring doch dynamisch zusammen.

maxlen = 10
fmt = "|%" + str(maxlen) + "s|"
print(fmt % "Zeile")

[Norbert (Gast)]

#!python
output = "FFF"
maxlen = 10
FMTL = f'--{{:<{maxlen}}}--'
FMTR = f'--{{:>{maxlen}}}--'
print(FMTL.format(output))
# --FFF       --
print(FMTR.format(output))
# --       FFF--

[Rolf M. (rmagnus)]

Eine andere Möglichkeit:

print('Ausgabe: |' + zeile[i] + ' ' * (maxlaenge-len(zeile[i]))  + '|')

[Markus W. (dl8mby)]

Hallo Zusammen,

das ging ja schnell - super.

Danke allen Beteiligten für den Input.

Letztendlich habe ich mich für die Variante von MaWin entschieden

ordlenmax=0
for i in range (1, int(lcs)+1):
    if len(p.tables[0][i][1]) > ordlenmax:
        ordlenmax=len(p.tables[0][i][1])

fmt="| %-" + str(ordlenmax) + "s "
for i in range (1, int(lcs)+1):
    print("{0:8}".format(p.tables[0][i][0]),end =" ")
    print(fmt % p.tables[0][i][1],end=" ")
    print("| {0:10}".format(p.tables[0][i][2]),end =" ")
    print("| {0:30}".format(p.tables[0][i][3]),end =" ")
    print("| {0:10}".format(p.tables[0][i][4]),end =" ")
    print("| {0:20}".format(p.tables[0][i][6]),end =" ")
    print()

Output nun wie gewünscht.

Lieben Dank an alle ;-)

PS.: Die Variante von Norbert gefällt mir auch ganz gut!

[Norbert (Gast)]

Falls das nicht nur ein kurzes Python Intermezzo sein soll und falls du 
des Öfteren mit Strings hantieren möchtest, schau dir vielleicht mal PEP 
498 aus dem Jahre 2015 an.

https://peps.python.org/pep-0498/

[Markus W. (dl8mby)]

Danke Norbert für den Hinweis.

Es wird sicherlich ein längeres Intermezzo aber dafür muss
ich mich erst fit machen, wie man sieht.
Bis dato habe ich meine Skripting Intermezzi in Perl praktiziert.
Nun ändert sich das bei uns in der Arbeit und Python gewinnt bei
mir immer mehr an Bedeutung, auch bedingt durch die ganzen Cloud
Deploment Tools wie z.B. bei ansible.

Danke nochmals.

Markus

[Yalu X. (yalu) (Moderator)]

Etwas unschön ist, dass du hier alte (mit %) und neue Formatierung
(mit {} und format()) mischst:

Markus W. schrieb:
> fmt="| %-" + str(ordlenmax) + "s "
> for i in range (1, int(lcs)+1):
>     print("{0:8}".format(p.tables[0][i][0]),end =" ")

Alles mit neuer Formatierung und etwas pythonischer:

#!/usr/bin/python3
table = p.tables[0][1:]
maxlen = max(len(line[1]) for line in table)
for line in table:
  print('{0:8} | {1:{w}}  | {2:10} | {3:30} | {4:10} | {6:20}'.format(*line, w=maxlen))

Ich bin dabei davon ausgegangen, dass lcs die Anzahl der Zeilen der
Tabelle ohne die Kopfzeile ist. Sollte dies nicht der Fall sein, müsste
der Code noch leicht angepasst werden.

[Markus W. (dl8mby)]

@Yalu X.

danke für Deine Mühe und Berichtigung.
Wie schon erwähnt ist bei mir Python noch nicht sehr gefestigt.
Habe zwar schon einige Kurse besucht, muss aber noch an den Details
arbeiten. Der Wandel zwischen Py2 und Py3 macht die Sache auch
nicht unbedingt leichter, aber ich hoffe dass es mit der Zeit
reift und von mir verinnerlicht wird.
Je mehr man damit macht, desto mehr bleibt hoffentlich hängen.
Die C-ähnlichen Formatierungen sind am Anfang halt vertrauter.
Und über das Mischen der Formate habe ich auch noch nicht so richtig
nachgedacht. Danke, dass Du mich darauf aufmerksam gemacht hast.

LG
Markus

[Yalu X. (yalu) (Moderator)]

Markus W. schrieb:
> Die C-ähnlichen Formatierungen sind am Anfang halt vertrauter.

Ja, das geht mir ganz ähnlich. Die C-Formatsyntax kenne ich auswendig,
bei der {}-Syntax in Python muss ich die etwas seltener genutzten
Features öfter mal nachschlagen.

Man kann übrigens in C im Formatstring eine variable Feldbreite mit '*'
angeben und den Zahlenwert als Argument übergeben:

char text[] = "abc";
int width = 5;
printf("|%-*s|\n", width, text);

Das geht ganz ähnlich auch in Python:

#!/usr/bin/python
text = 'abc'
width = 5
print('|%-*s|' % (width, text))

Ausgabe in beiden Fällen:

|abc  |

[Markus W. (dl8mby)]

@Yalu X.
and the others,

ich habe mir mal alle Varianten in meine
Python3-Knowled-Base-Doku archiviert, um
wieder bei Bedarf darauf zugreifen zu können.

Leider ist der Output zu lang um ihn in den code Tag einzubetten.
Also habe ich ihn als Anhang dran gehängt. (DOS und UNIX Variante)
Oder wisst Ihr eine bessere Methode - z.B. Fenster mit horiz. Scroll-Balken

Markus

[Markus W. (dl8mby)]

Noch zum Abschluß

Mein Testskript habe ich auch mal angehängt.
Es liest eine html GUI Seite ein und stellt sie
textlich dar.

Mit Eurem Input konnte ich die Länge und die
Formatierungs Blöcke deutlich verkürzen und
die Ausgabe ansehnlicher machen.

Jetzt will ich noch einige Bereiche zu Unterfunktionen
zusammenfassen und das Ganze in einem main-Block
kapseln mit

if _name_ == '__main__':

und Co.

Danke nochmals für Eure Assistenz|Hilfe :-)

Markus