FIX, ENH: #395 got float formatting working

Author: adamklein

RELEASE.rst

@@ -104,6 +104,7 @@ pandas 0.7.0
   - Some performance enhancements in constructing a Panel from a dict of
     DataFrame objects
   - Made ``Index._get_duplicates`` a public method by removing the underscore
+  - Prettier printing of floats, and column spacing fix (GH #395, GH #571)
 
 **Bug fixes**
 

pandas/__init__.py

@@ -23,7 +23,7 @@
 from pandas.sparse.api import *
 from pandas.stats.api import *
 
-from pandas.core.common import set_printoptions
+from pandas.core.common import set_printoptions, reset_printoptions
 from pandas.core.common import set_eng_float_format
 from pandas.io.parsers import read_csv, read_table, read_clipboard, ExcelFile
 from pandas.io.pytables import HDFStore

pandas/core/common.py

@@ -380,17 +380,22 @@ def set_printoptions(precision=None, column_space=None, max_rows=None,
         out how big the terminal is and will not display more rows or/and
         columns that can fit on it.
     """
-    global _float_format, _column_space, _max_rows, _max_columns
+    global _float_format, _column_space, _max_rows, _max_columns, _precision
     if precision is not None:
-        float_format = '% .' + '%d' % precision + 'g'
-        _float_format = lambda x: float_format % x
+        _precision = precision
     if column_space is not None:
         _column_space = column_space
     if max_rows is not None:
         _max_rows = max_rows
     if max_columns is not None:
         _max_columns = max_columns
 
+def reset_printoptions():
+    global _float_format, _column_space, _precision
+    _float_format = None
+    _column_space = 12
+    _precision = 4
+
 class EngFormatter(object):
     """
     Formats float values according to engineering format.
@@ -494,8 +499,9 @@ def set_eng_float_format(precision=3, use_eng_prefix=False):
     _float_format = EngFormatter(precision, use_eng_prefix)
     _column_space = max(12, precision + 9)
 
-_float_format = lambda x: '% .4g' % x
+_float_format = None
 _column_space = 12
+_precision = 4
 _max_rows = 500
 _max_columns = 0
 
@@ -506,6 +512,59 @@ def _stringify(col):
     else:
         return '%s' % col
 
+def _float_format_default(v, width = None):
+    """
+    Take a float and its formatted representation and if it needs extra space
+    to fit the width, reformat it to that width.
+    """
+
+    fmt_str   = '%% .%dg' % _precision
+    formatted = fmt_str % v
+
+    if width is None:
+        return formatted
+
+    extra_spc = width - len(formatted)
+
+    if extra_spc <= 0:
+        return formatted
+
+    if 'e' in formatted:
+        # we have something like 1e13 or 1.23e13
+        base, exp = formatted.split('e')
+
+        if '.' in base:
+            # expand fraction by extra space
+            whole, frac = base.split('.')
+            fmt_str = '%%.%df' % (len(frac) + extra_spc)
+            frac = fmt_str % float("0.%s" % frac)
+            base = whole + frac[1:]
+        else:
+            if extra_spc > 1:
+                # enough room for fraction
+                fmt_str = '%% .%df' % (extra_spc - 1)
+                base = fmt_str % float(base)
+            else:
+                # enough room for decimal point only
+                base += '.'
+
+        return base + 'e' + exp
+    else:
+        # we have something like 123 or 123.456
+        if '.' in formatted:
+            # expand fraction by extra space
+            wholel, fracl = map(len, formatted.split("."))
+            fmt_str = '%% .%df' % (fracl + extra_spc)
+        else:
+            if extra_spc > 1:
+                # enough room for fraction
+                fmt_str = '%% .%df' % (extra_spc - 1)
+            else:
+                # enough room for decimal point only
+                fmt_str = '% d.'
+
+        return fmt_str % v
+
 def _format(s, space=None, na_rep=None, float_format=None, col_width=None):
     def _just_help(x):
         if space is None:
@@ -520,18 +579,10 @@ def _just_help(x):
 
         if float_format:
             formatted = float_format(s)
-        else:
+        elif _float_format:
             formatted = _float_format(s)
-
-        # TODO: fix this float behavior!
-        # if we pass col_width, pad-zero the floats so all are same in column
-        #if col_width is not None and '.' in formatted:
-        #    padzeros = col_width - len(formatted)
-        #    if padzeros > 0 and 'e' in formatted:
-        #        num, exp = formatted.split('e')
-        #        formatted = "%s%se%s" % (num, ('0' * padzeros), exp)
-        #    elif padzeros > 0:
-        #        formatted = formatted + ('0' * padzeros)
+        else:
+            formatted = _float_format_default(s, col_width)
 
         return _just_help(formatted)
     elif isinstance(s, int):

pandas/core/format.py

@@ -68,7 +68,6 @@ def to_string(self):
         Render a DataFrame to a console-friendly tabular output.
         """
         frame = self.frame
-        format_col = self._get_column_formatter()
 
         to_write = []
 
@@ -83,11 +82,10 @@ def to_string(self):
             str_columns = self._get_formatted_column_labels()
 
             if self.header:
-                stringified = [str_columns[i] + format_col(c)
+                stringified = [str_columns[i] + self._format_col(c)
                                for i, c in enumerate(self.columns)]
             else:
-                stringified = [format_col(c) for c in self.columns]
-
+                stringified = [self._format_col(c) for c in self.columns]
 
             if self.index:
                 to_write.append(adjoin(1, str_index, *stringified))
@@ -101,6 +99,34 @@ def to_string(self):
 
         self.buf.writelines(to_write)
 
+    def _default_col_formatter(self, v, col_width=None):
+        from pandas.core.common import _format
+
+        return _format(v, space=self.col_space, na_rep=self.na_rep,
+                       float_format=self.float_format, col_width=col_width)
+
+    def _format_col(self, col, i=None):
+        if self.formatters is None:
+            self.formatters = {}
+
+        if col in self.formatters:
+            formatter = self.formatters[col]
+
+            if i is None:
+                return [formatter(x) for x in self.frame[col]]
+            else:
+                return formatter(self.frame[col][i])
+        else:
+            formatter = self._default_col_formatter
+
+            if i is not None:
+                return formatter(self.frame[col][i])
+            else:
+                formatted = [formatter(x) for x in self.frame[col]]
+                max_len = max(map(len, formatted))
+                return [formatter(x, col_width=max_len)
+                        for x in self.frame[col]]
+
     def to_html(self):
         """
         Render a DataFrame to a html table.
@@ -130,7 +156,6 @@ def write_tr(buf, l, indent=0, indent_delta=4, header=False):
         indent_delta = 2
         frame = self.frame
         buf = self.buf
-        format_col = self._get_column_formatter()
 
         write(buf, '<table border="1">', indent)
 
@@ -181,44 +206,14 @@ def _column_header():
                 else:
                     row.append(frame.index[i])
                 for column in frame.columns:
-                    row.append(format_col(column, i))
+                    row.append(self._format_col(column, i))
                 write_tr(buf, row, indent, indent_delta)
             indent -= indent_delta
             write(buf, '</tbody>', indent)
             indent -= indent_delta
 
         write(buf, '</table>', indent)
 
-    def _get_column_formatter(self):
-        from pandas.core.common import _format
-
-        col_space = self.col_space
-
-        def _myformat(col):
-            formatter = lambda v: _format(v, space=col_space,
-                                          na_rep=self.na_rep,
-                                          float_format=self.float_format)
-            # one pass through when float to stringify column, to pad with
-            # zeros
-            if issubclass(col.dtype.type, np.floating):
-                col_width = max(map(len, map(formatter, col)))
-                formatter = lambda v: _format(v, space=col_space,
-                                              na_rep=self.na_rep,
-                                              float_format=self.float_format,
-                                              col_width=col_width)
-            return formatter
-
-        formatters = {} if self.formatters is None else self.formatters
-
-        def _format_col(col, i=None):
-            formatter = formatters.get(col, _myformat(self.frame[col]))
-            if i == None:
-                return [formatter(x) for x in self.frame[col]]
-            else:
-                return formatter(self.frame[col][i])
-
-        return _format_col
-
     def _get_formatted_column_labels(self):
         from pandas.core.index import _sparsify
 

pandas/core/series.py

@@ -512,7 +512,7 @@ def _get_repr(self, name=False, print_header=False, length=True,
         padSpace = min(maxlen, 60)
 
         if float_format is None:
-            float_format = com._float_format
+            float_format = com._float_format_default
 
         def _format(k, v):
             # GH #490

pandas/tests/test_frame.py

@@ -1738,6 +1738,34 @@ def test_to_string_no_index(self):
 
         assert(df_s == expected)
 
+    def test_to_string_float_formatting(self):
+        com.reset_printoptions()
+        com.set_printoptions(precision=6, column_space=12)
+
+        df = DataFrame({'x' : [0, 0.25, 3456.000, 12e+45, 1.64e+6,
+                               1.7e+8, 1.253456, np.pi, -1e6]})
+
+        df_s = df.to_string()
+
+        expected = '   x       \n0  0.000000\n1  0.250000\n' \
+                   '2  3456.000\n3  1.20e+46\n4  1.64e+06\n' \
+                   '5  1.70e+08\n6  1.253456\n7  3.141593\n' \
+                   '8 -1.00e+06'
+        assert(df_s == expected)
+
+        df = DataFrame({'x' : [3234, 0.253]})
+        df_s = df.to_string()
+
+        expected = '   x    \n0  3234.\n1  0.253'
+        assert(df_s == expected)
+
+        com.reset_printoptions()
+
+        df = DataFrame({'x': [1e9, 0.2512]})
+        df_s = df.to_string()
+        expected = '   x     \n0  1.e+09\n1  0.2512'
+        assert(df_s == expected)
+
     def test_to_html(self):
         # big mixed
         biggie = DataFrame({'A' : randn(1000),