python string formatting Columns in line

前端 未结 4 2033
一生所求
一生所求 2020-11-27 20:26

I am trying to format the string so everything lines up between the two.

APPLES                           $.99                           214                          


        
相关标签:
4条回答
  • 2020-11-27 20:47

    I wasn't aware Python has a solution for formatting columns until now - I decided to look into it just in case it did as I already created my own solution for another language which doesn't have a built-in solution ( Lua ) and as Logic is Universal, I ported it to Python in a few key-strokes.

    Knowing Python has its own solution, I'll be looking into integrating it into my current solution.

    However, as I created an alternate solution, I'll go ahead and post my solution here so you can see how user-friendly my solution - one of my complaints with Python is some of the formatting is less than intuitive such as the Ternary Operator of False, True ( Honestly, True, False would be better order along with having the statement first ), and others are just strange...

    The example function shows Truncate in use ( note: some logic costs aren't necessary, still moving things around - for instance the if _truncate ... etc.. ) also showing the format column system...

    It's pretty basic - convert tabs to spaces, count the length of columns, add spaces if there are too many - if there is too much text then chop it ( my other solution has a buffer you can use or border so border chars show up, and to force 1 blank char minimum between columns - I haven't had a chance to add it in the Python variant yet ), etc...

    It is fantastic for debugging, and output..

    There are several main functions... String.FormatColumn( [ _width, _text ], ... ), String.FormatSimpleColumn( _width, [ _text, ... ], and String.FormatColumnEx( _empty_chars, [ _width, _text ], ... )..

    String.FormatSimpleColumn takes width once, and uses that for all columns, repeat text only..

    String.FormatColumn takes width and text for every column...

    String.FormatColumnEx is the same as FormatColumn except it lets you specify the characters to use instead of spaces - I typically use decimals or another char for the index row....

    for my Lua implementation, I also had the option to trim the right spaces but ended up just using a helper function to trim if the spaces aren't wanted... I leave them because if you set up columns, you can simply append something to the string outside of the function call if you wanted to... and trimming is simple.. It also means you can simply chain the function calls for the exact same result instead of chaining arguments... whichever looks best for you..

    ##
    ## 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( '---------------------------------------------' )
    
    0 讨论(0)
  • 2020-11-27 20:50

    I think the better way is auto adjust the column width from its content

    rows = [('apple', '$1.09', '80'), ('truffle', '$58.01', '2')]
    
    lens = []
    for col in zip(*rows):
        lens.append(max([len(v) for v in col]))
    format = "  ".join(["{:<" + str(l) + "}" for l in lens])
    for row in rows:
        print(format.format(*row))
    

    Output:

    apple    $1.09   80
    truffle  $58.01  2 
    

    Demo: https://code.sololearn.com/cttJgVTx55bm/#py

    0 讨论(0)
  • 2020-11-27 20:54

    str.format() is making your fields left aligned within the available space. Use alignment specifiers to change the alignment:

    '<' Forces the field to be left-aligned within the available space (this is the default for most objects).

    '>' Forces the field to be right-aligned within the available space (this is the default for numbers).

    '=' Forces the padding to be placed after the sign (if any) but before the digits. This is used for printing fields in the form ‘+000000120’. This alignment option is only valid for numeric types.

    '^' Forces the field to be centered within the available space.

    Here's an example (with both left and right alignments):

    >>> 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
    
    0 讨论(0)
  • 2020-11-27 20:59

    With python3 f-strings (not your example but mine):

    alist = ["psi", "phi", "omg", "chi1", "chi2", "chi3", "chi4", "chi5", "tau"]
    for ar in alist:
        print(f"{ar: >8}", end=" ")
    print()
    for ar in alist:
        ang = ric.get_angle(ar)
        print(f"{ang:8.4}", end=" ")
    print()
    

    generates

      psi      phi      omg     chi1     chi2     chi3     chi4     chi5      tau 
    4.574   -85.28    178.1   -62.86   -65.01   -177.0    80.83    8.611    115.3 
    
    0 讨论(0)
提交回复
热议问题