python string-Formatierung Spalten in der Zeile

Ich versuche, das format der Zeichenfolge, so dass alles Linien, die sich zwischen die beiden.

APPLES                           $.99                           214                       
kiwi                             $1.09                           755

Ich versuche dies durch:

fmt = ('{0:30}{1:30}{2:30}'.format(Fruit,price,qty))

Wie kann ich eine Spalte oder Zeile? Ich lese die docs, aber ich bin verwirrt. Ich dachte, dass die {1:30} würde es 30 Räume, dann wäre das drucken der nächste Punkt, aber es scheint, dass es 30 Räume, von wo das Vorherige Element beendet.

Dank

InformationsquelleAutor Trying_hard | 2013-09-30

python

35

str.format() macht Ihre Felder Linksbündig innerhalb der zur Verfügung stehenden Raum. Verwenden Ausrichtung Planern zum ändern der Ausrichtung:

'<' Kräfte das Feld, Linksbündig innerhalb der zur Verfügung stehenden Raum (dies ist die Standardeinstellung für die meisten Objekte).

'>' Kräfte das Feld, Rechtsbündig innerhalb der
verfügbaren Raum (dies ist die Standardeinstellung für zahlen).

'=' Kräfte die Polsterung gelegt werden, nachdem der
sign (wenn überhaupt), aber vor den Ziffern. Dieser wird verwendet für den Druck von Feldern
in der form '+000000120'. Diese Ausrichtung option ist nur gültig für
numerische Typen.

'^' Kräfte das Feld zentriert werden, innerhalb der
verfügbaren Speicherplatz.

Hier ein Beispiel (mit Links und rechts Ausrichtungen):
```
>>> for args in (('apple', '$1.09', '80'), ('truffle', '$58.01', '2')):
...     print '{0:<10} {1:>8} {2:>8}'.format(*args)
...
apple         $1.09       80
truffle      $58.01        2
```
Was ist, wenn, zum Beispiel, 1.09 ist ein Wert, der berechnet wurde, von irgendwo, aber es ist im format 1.0934433432 (e.g high precision) - Und ich will nur Runde es bis zu 2 Dezimalstellen (d.h. =1.09) Was soll ich tun ?
Sie können die precision. Weitere Informationen finden Sie unter Antwort, Wie formatiere ich einen dezimal-zu-zeigen immer 2 Nachkommastellen?.

InformationsquelleAutor Steven Rumbalski

Ich war mir nicht bewusst, dass Python eine Lösung hat, die für die Formatierung der Spalten, bis jetzt - habe ich beschlossen, diese zu prüfen, nur für den Fall es kam, als ich schon meine eigene Lösung für eine andere Sprache, die nicht über eine integrierte Lösung, die ( Lua ) und als Logik ist Universell, ich portiert, um Python in ein paar Tastenanschläge.

Wissen Python hat seine eigene Lösung, ich werde auf der Suche in die Integration in meine aktuelle Lösung.

Jedoch, wie erstellte ich eine Alternative Lösung, ich werde gehen Sie vor und poste meine Lösung hier, damit Sie sehen können, wie Benutzer-freundlich meine Lösung - einer meiner Beschwerden mit Python ist, dass ein Teil der Formatierung ist weniger als intuitiv wie der Ternäre Operator False, True ( Ehrlich, True, False wäre besser, um zusammen mit der Aussage der ersten ), und andere sind einfach nur seltsam...

Beispiel-Funktion veranschaulicht, Truncate ( Hinweis: einige Logik-Kosten, die nicht nötig sind, noch das, was sich bewegt um, zum Beispiel, wenn _truncate ... etc.. ) zeigt auch die Spalte " format system...

Es ist ziemlich basic - konvertiert tabs in Leerzeichen um, zählen die Länge der Spalten, Leerzeichen einfügen, wenn es zu viele - wenn es zu viel text dann hacken Sie ( meine andere Lösung ist ein Puffer, die Sie verwenden können, oder an der Grenze, also der Grenze chars auftauchen, und Sie zu zwingen 1 leer, char minimum zwischen den Spalten - ich haven ' T hatte eine chance, fügen Sie es in die Python-Variante noch nicht ), etc...

Es ist fantastisch für das Debuggen und output..

Gibt es mehrere wichtige Funktionen... String.FormatColumn( [ _width _text ], ... ), String.FormatSimpleColumn( _width, [ _text, ... ] und "String".FormatColumnEx( _empty_chars, [ _width _text ], ... )..

String.FormatSimpleColumn nimmt die Breite mal, und verwendet, dass für alle Spalten, wiederholen Sie nur text..

String.FormatColumn nimmt Breite und text für jede Spalte...

String.FormatColumnEx ist das gleiche wie FormatColumn außer es können Sie die Zeichen festlegen, die zu verwenden statt Leerzeichen - ich in der Regel verwenden Sie Dezimalzahlen oder anderen char für die index-Zeile....

für meine Lua-Implementierung, hatte ich auch die option zum zuschneiden der richtigen Räume, sondern endete nur mit einem Helfer-Funktion zu trimmen, wenn die Räume nicht wollte... ich lasse Sie da, wenn Sie Spalten, Sie können einfach Anhängen etwas an den string außerhalb der Funktion aufrufen, wenn Sie wollte... und trimmen ist einfach.. Es bedeutet auch, können Sie einfach die Kette der Funktionsaufrufe für genau das gleiche Ergebnis anstelle der Verkettung Argumente... je nachdem, was am besten aussieht für Sie..

##
## Sandbox - All Works, if public, are released under the ACL or Acecool Company License - Josh 'Acecool' Moser
##


##
## Declarations for Globals, CONSTants, ENUMeration, etc..
##

## Define the tab width in terms of how many space-chars are used per tab character - Pi uses 8, Windows uses 4, some use 2, etc..
CONST_TAB_WIDTH                             = 4


##
## String Library - This library only includes Format Column debugging output format system..
##
class String:


    ##
    ##
    ##
    def FormatColumnStripR( _width = 25, _text ='', *_varargs ):
        return String.FormatColumn( _width, _text, *_varargs ).rstrip( )


    ##
    ##
    ##
    def FormatSimpleColumnStripR( _width = 25, *_varargs ):
        return String.FormatSimpleColumn( _width, *_varargs ).rstrip( )


    ##
    ## Helper function which lets you define width for each text, and it repeats it for you so you can repeat text and all columns will be the same width
    ##
    ## Purpose:
    ##          The purpose of the Format Column Helpers is to improve data output, primarily for debugging so output is easier to follow..
    ## Usage:
    ##      String.FormatColumn( 25, 'Text /Key', 15, 'Some Value', 15, 'Another Key', 50, 'Another Value' )
    ##      String.FormatColumn( 25, 'Text /Key', 15, 'Some Value', 15, 'Another Key', 50, 'Another Value' )
    ##      String.FormatColumn( 25, 'Key', 15, 'Some', 15, 'Another', 50, 'Value' )
    ##
    ## Output:
    ##      Text /Key               Some Value     Another Key    Another Value                                     <LINE END>
    ##      Text /Key               Some Value     Another Key    Another Value                                     <LINE END>
    ##      Key                      Some           Another        Value                                             <LINE END>
    ##
    def FormatColumn( _width = 25, _text = '', *_varargs ):
        return String.FormatColumnEx( ' ', _width, _text, *_varargs )


    ##
    ## Helper function which lets you define width for each text, and it repeats it for you so you can repeat text and all columns will be the same width
    ##
    ## Purpose:
    ##          The purpose of the Format Column Helpers is to improve data output, primarily for debugging so output is easier to follow..
    ## Usage:
    ##      String.FormatColumnEx( '.', 25, 'Text /Key', 15, 'Some Value', 15, 'Another Key', 50, 'Another Value' )
    ##      String.FormatColumnEx( ' ', 25, 'Text /Key', 15, 'Some Value', 15, 'Another Key', 50, 'Another Value' )
    ##      String.FormatColumnEx( ' ', 25, 'Key', 15, 'Some', 15, 'Another', 50, 'Value' )
    ##
    ## Output:
    ##      Text /Key...............Some Value.....Another Key....Another Value.....................................<LINE END>
    ##      Text /Key               Some Value     Another Key    Another Value                                     <LINE END>
    ##      Key                      Some           Another        Value                                             <LINE END>
    ##
    def FormatColumnEx( _empty_char = ' ', _width = 25, _text = '', *_varargs ):
        ## Make sure our text is a string
        _text = str( _text )

        ## For each tab used, calculate how many spaces should be used with minimum of 1 and maximum of 4 being the range depending which snap-point is used.. Then strip that tab and add spaces in its place..
        _text = _text.expandtabs( CONST_TAB_WIDTH )

        ## Count how many additional arguments we have
        _count = len( _varargs )

        ## Since our Ex function, this, must use a paired-system, we make sure the rounded division is > 0
        _more = ( round( _count / 2, 0 ) > 0 )

        ## How many repeating chars do we need to create?
        _reps = ( _width - len( _text ) )

        ## Build a string to fill the empty column space with spaces so everything lines up - as long as the right font is used ( where all chars are the same size )
        _empty = _empty_char * _reps

        ## Now we ensure our text is limited to the _width size - data going over is truncated...TernaryFunc( _reps > 0, _empty, _empty )
        ## _data = String.SubStr( _text + ( _empty ), 0, _width )
        ## _data = ( _text + ( _empty ) )[  : _width ]
        _data = String.Truncate( _text + ( _empty ), _width )

        ## If we have more cars
        if ( _more ):
            ## Recursive call by shifting our VarArgs left so they populate _width and _text - then add the result to the data var... This only stops when no more paired options are left...
            _data = _data + String.FormatColumnEx( _empty_char, *_varargs )

        ## Return the data..
        return _data


    ##
    ## Helper function which lets you define width once, and it repeats it for you so you can repeat text and all columns will be the same width
    ##
    ## Purpose:
    ##          The purpose of the Format Column Helpers is to improve data output, primarily for debugging so output is easier to follow..
    ## Usage:
    ##      String.FormatSimpleColumn( 15, 'Text /Key', 'Some Value', 'Another Key', 'Another Value' )
    ##      String.FormatSimpleColumn( 15, 'Key', 'Some', 'Another', 'Value' )
    ##
    ## Output:
    ##      Text /Key     Some Value     Another Key    Another Value  <LINE END>
    ##      Key            Some           Another        Value          <LINE END>
    ##
    def FormatSimpleColumn( _width = 25, *_varargs ):
        ## Count how many text elements we have...
        _count = len( _varargs )

        ## Set up our return var
        _data = ''

        ## If we have at least 1 text element to set-up into a column
        if ( _count > 0 ):
            ## Then we loop through each vararg
            for _text in _varargs:
                ## If width is negative, use the length of the string plus the absolute value of width as a buffer...
                if ( _width < 0 ):
                    _data = _data + String.FormatColumn( len( str( _text ) ) + abs( _width ), str( _text ) )
                else:
                    ## And we use a pseudo recursive call on the FormatColumnEx function - extra args...
                    _data = _data + String.FormatColumn( _width, str( _text ) )

        ## Return the data..
        return _data


    ##
    ## SubString replacement
    ##
    ## Usage:
    ##      _data = String.SubStr( _text, 0, 10 )
    ##
    def SubStr( _text, _start, _end ):
        return _text[ _start : _end ]


    ##
    ## Truncate characters of a string after _len'nth char, if necessary... If _len is less than 0, don't truncate anything... Note: If you attach a suffix, and you enable absolute max length then the suffix length is subtracted from max length... Note: If the suffix length is longer than the output then no suffix is used...
    ##
    ## Usage: Where _text = 'Testing', _width = 4
    ##      _data = String.Truncate( _text, _width )                        == Test
    ##      _data = String.Truncate( _text, _width, '..', True )            == Te..
    ##
    ## Equivalent Alternates: Where _text = 'Testing', _width = 4
    ##      _data = String.SubStr( _text, 0, _width )                       == Test
    ##      _data = _text[  : _width ]                                      == Test
    ##      _data = ( _text )[  : _width ]                                  == Test
    ##
    def Truncate( _text, _max_len = -1, _suffix = False, _absolute_max_len = True ):
        ## Length of the string we are considering for truncation
        _len            = len( _text )

        ## Whether or not we have to truncate
        _truncate       = ( False, True )[ _len > _max_len ]

        ## Note: If we don't need to truncate, there's no point in proceeding...
        if ( not _truncate ):
            return _text

        ## The suffix in string form
        _suffix_str     = ( '',  str( _suffix ) )[ _truncate and _suffix != False ]

        ## The suffix length
        _len_suffix     = len( _suffix_str )

        ## Whether or not we add the suffix
        _add_suffix     = ( False, True )[ _truncate and _suffix != False and _max_len > _len_suffix ]

        ## Suffix Offset
        _suffix_offset = _max_len - _len_suffix
        _suffix_offset  = ( _max_len, _suffix_offset )[ _add_suffix and _absolute_max_len != False and _suffix_offset > 0 ]

        ## The truncate point.... If not necessary, then length of string.. If necessary then the max length with or without subtracting the suffix length... Note: It may be easier ( less logic cost ) to simply add the suffix to the calculated point, then truncate - if point is negative then the suffix will be destroyed anyway.
        ## If we don't need to truncate, then the length is the length of the string.. If we do need to truncate, then the length depends on whether we add the suffix and offset the length of the suffix or not...
        _len_truncate   = ( _len, _max_len )[ _truncate ]
        _len_truncate   = ( _len_truncate, _max_len )[ _len_truncate <= _max_len ]

        ## If we add the suffix, add it... Suffix won't be added if the suffix is the same length as the text being output...
        if ( _add_suffix ):
            _text = _text[ 0 : _suffix_offset ] + _suffix_str + _text[ _suffix_offset: ]

        ## Return the text after truncating...
        return _text[ : _len_truncate ]


    ##
    ##
    ##
    def __example__( self ):
        ##
        ## Truncate Example...
        ##
        _col_key    = 20
        _col_eq     = 10
        _col_res    = 15
        _row_eq     = '=='
        _text       = 'Testing'
        print( '--------------------------------------------- 8' )
        _width = 8
        print( String.FormatColumn( _col_key, 'Testing',        _col_eq, _row_eq,           _col_res, String.Truncate( _text, _width ) ) )
        print( String.FormatColumn( _col_key, 'Testing',        _col_eq, _row_eq,           _col_res, String.Truncate( _text, _width, '..', True ) ) )
        print( '--------------------------------------------- 7' )
        _width = 7
        print( String.FormatColumn( _col_key, 'Testing',        _col_eq, _row_eq,           _col_res, String.Truncate( _text, _width ) ) )
        print( String.FormatColumn( _col_key, 'Testing',        _col_eq, _row_eq,           _col_res, String.Truncate( _text, _width, '..', True ) ) )
        print( '--------------------------------------------- 6' )
        _width = 6
        print( String.FormatColumn( _col_key, 'Testin',         _col_eq, _row_eq,           _col_res, String.Truncate( _text, _width ) ) )
        print( String.FormatColumn( _col_key, 'Test..',         _col_eq, _row_eq,           _col_res, String.Truncate( _text, _width, '..', True ) ) )
        print( '--------------------------------------------- 5' )
        _width = 5
        print( String.FormatColumn( _col_key, 'Testi',          _col_eq, _row_eq,           _col_res, String.Truncate( _text, _width ) ) )
        print( String.FormatColumn( _col_key, 'Tes..',          _col_eq, _row_eq,           _col_res, String.Truncate( _text, _width, '..', True ) ) )
        print( '--------------------------------------------- 4' )
        _width = 4
        print( String.FormatColumn( _col_key, 'Test',           _col_eq, _row_eq,           _col_res, String.Truncate( _text, _width ) ) )
        print( String.FormatColumn( _col_key, 'Te..',           _col_eq, _row_eq,           _col_res, String.Truncate( _text, _width, '..', True ) ) )
        print( '--------------------------------------------- 3' )
        _width = 3
        print( String.FormatColumn( _col_key, 'Tes',            _col_eq, _row_eq,           _col_res, String.Truncate( _text, _width ) ) )
        print( String.FormatColumn( _col_key, 'T..',            _col_eq, _row_eq,           _col_res, String.Truncate( _text, _width, '..', True ) ) )
        print( '--------------------------------------------- 2' )
        _width = 2
        print( String.FormatColumn( _col_key, 'Te',             _col_eq, _row_eq,           _col_res, String.Truncate( _text, _width ) ) )
        print( String.FormatColumn( _col_key, '..',             _col_eq, _row_eq,           _col_res, String.Truncate( _text, _width, '..', True ) ) )
        print( '--------------------------------------------- 1' )
        _width = 1
        print( String.FormatColumn( _col_key, 'T',              _col_eq, _row_eq,           _col_res, String.Truncate( _text, _width ) ) )
        print( String.FormatColumn( _col_key, '.',              _col_eq, _row_eq,           _col_res, String.Truncate( _text, _width, '..', True ) ) )
        print( '--------------------------------------------- 0' )
        _width = 0
        print( String.FormatColumn( _col_key, '',               _col_eq, _row_eq,           _col_res, String.Truncate( _text, _width ) ) )
        print( String.FormatColumn( _col_key, '',               _col_eq, _row_eq,           _col_res, String.Truncate( _text, _width, '..', True ) ) )
        print( '---------------------------------------------' )

Interessant, aber nicht relevant für die Antwort

InformationsquelleAutor Acecool

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.