Detail: Frame: Accessor Transpose

Frame.via_T.via_fill_value(fill_value)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.via_fill_value(fill_value)[source]: Interface for using binary operators and methods with a pre-defined fill value.

>>>

Frame.via_T.__add__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__add__(other)[source]

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0.0
q        -2.0
r        0.5
s        1.0
<<U1>    <float64>
>>> f.via_T + s
<Frame>
<Index> a         b         c         <<U1>
<Index>
p       10.0      8.0       1.0
q       -4.0      -5.0      -2.0
r       0.5       8.5       9.5
s       1.0       1.0       13.0
<<U1>   <float64> <float64> <float64>

Frame.via_T.__sub__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__sub__(other)[source]

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0.0
q        -2.0
r        0.5
s        1.0
<<U1>    <float64>
>>> f.via_T - s
<Frame>
<Index> a         b         c         <<U1>
<Index>
p       10.0      8.0       1.0
q       0.0       -1.0      2.0
r       -0.5      7.5       8.5
s       -1.0      -1.0      11.0
<<U1>   <float64> <float64> <float64>

Frame.via_T.__mul__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__mul__(other)[source]

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0.0
q        -2.0
r        0.5
s        1.0
<<U1>    <float64>
>>> f.via_T * s
<Frame>
<Index> a         b         c         <<U1>
<Index>
p       0.0       0.0       0.0
q       4.0       6.0       -0.0
r       0.0       4.0       4.5
s       0.0       0.0       12.0
<<U1>   <float64> <float64> <float64>

Frame.via_T.__truediv__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__truediv__(other)[source]

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0.0
q        -2.0
r        0.5
s        1.0
<<U1>    <float64>
>>> f.via_T / s
<Frame>
<Index> a         b         c         <<U1>
<Index>
p       inf       inf       inf
q       1.0       1.5       -0.0
r       0.0       16.0      18.0
s       0.0       0.0       12.0
<<U1>   <float64> <float64> <float64>

Frame.via_T.__floordiv__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__floordiv__(other)[source]

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0.0
q        -2.0
r        0.5
s        1.0
<<U1>    <float64>
>>> f.via_T // s
<Frame>
<Index> a         b         c         <<U1>
<Index>
p       inf       inf       inf
q       1.0       1.0       -0.0
r       0.0       16.0      18.0
s       0.0       0.0       12.0
<<U1>   <float64> <float64> <float64>

Frame.via_T.__mod__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__mod__(other)[source]

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0.0
q        -2.0
r        0.5
s        1.0
<<U1>    <float64>
>>> f.via_T % s
<Frame>
<Index> a         b         c         <<U1>
<Index>
p       nan       nan       nan
q       -0.0      -1.0      -0.0
r       0.0       0.0       0.0
s       0.0       0.0       0.0
<<U1>   <float64> <float64> <float64>

Frame.via_T.__pow__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__pow__(other)[source]

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0.0
q        -2.0
r        0.5
s        1.0
<<U1>    <float64>
>>> f.via_T ** s
<Frame>
<Index> a         b                  c         <<U1>
<Index>
p       1.0       1.0                1.0
q       0.25      0.1111111111111111 inf
r       0.0       2.8284271247461903 3.0
s       0.0       0.0                12.0
<<U1>   <float64> <float64>          <float64>

Frame.via_T.__lshift__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__lshift__(other)[source]

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 3, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0
q        -2
r        3
s        1
<<U1>    <int64>
>>> f.via_T << s
<Frame>
<Index> a       b       c       <<U1>
<Index>
p       10      8       1
q       0       0       0
r       0       64      72
s       0       0       24
<<U1>   <int64> <int64> <int64>

Frame.via_T.__rshift__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__rshift__(other)[source]

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 3, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0
q        -2
r        3
s        1
<<U1>    <int64>
>>> f.via_T >> s
<Frame>
<Index> a       b       c       <<U1>
<Index>
p       10      8       1
q       -1      -1      0
r       0       1       1
s       0       0       6
<<U1>   <int64> <int64> <int64>

Frame.via_T.__and__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__and__(other)[source]

>>> f = sf.Frame.from_fields(((False, True, True), (True, True, False)), columns=('a', 'b'), index=('p', 'q', 'r'), name='x')
>>> f
<Frame: x>
<Index>    a      b      <<U1>
<Index>
p          False  True
q          True   True
r          True   False
<<U1>      <bool> <bool>
>>> s = sf.Series((False, True, True), index=('p', 'q', 'r'))
>>> s
<Series>
<Index>
p        False
q        True
r        True
<<U1>    <bool>
>>> f.via_T & s
<Frame>
<Index> a      b      <<U1>
<Index>
p       False  False
q       True   True
r       True   False
<<U1>   <bool> <bool>

Frame.via_T.__xor__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__xor__(other)[source]

>>> f = sf.Frame.from_fields(((False, True, True), (True, True, False)), columns=('a', 'b'), index=('p', 'q', 'r'), name='x')
>>> f
<Frame: x>
<Index>    a      b      <<U1>
<Index>
p          False  True
q          True   True
r          True   False
<<U1>      <bool> <bool>
>>> s = sf.Series((False, True, True), index=('p', 'q', 'r'))
>>> s
<Series>
<Index>
p        False
q        True
r        True
<<U1>    <bool>
>>> f.via_T ^ s
<Frame>
<Index> a      b      <<U1>
<Index>
p       False  True
q       False  False
r       False  True
<<U1>   <bool> <bool>

Frame.via_T.__or__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__or__(other)[source]: Return self|value.

>>> f = sf.Frame.from_fields(((False, True, True), (True, True, False)), columns=('a', 'b'), index=('p', 'q', 'r'), name='x')
>>> f
<Frame: x>
<Index>    a      b      <<U1>
<Index>
p          False  True
q          True   True
r          True   False
<<U1>      <bool> <bool>
>>> s = sf.Series((False, True, True), index=('p', 'q', 'r'))
>>> s
<Series>
<Index>
p        False
q        True
r        True
<<U1>    <bool>
>>> f.via_T | s
<Frame>
<Index> a      b      <<U1>
<Index>
p       False  True
q       True   True
r       True   True
<<U1>   <bool> <bool>

Frame.via_T.__lt__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__lt__(other)[source]: Return self<value.

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0.0
q        -2.0
r        0.5
s        1.0
<<U1>    <float64>
>>> f.via_T < s
<Frame>
<Index> a      b      c      <<U1>
<Index>
p       False  False  False
q       False  True   False
r       True   False  False
s       True   True   False
<<U1>   <bool> <bool> <bool>

Frame.via_T.__le__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__le__(other)[source]: Return self<=value.

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0.0
q        -2.0
r        0.5
s        1.0
<<U1>    <float64>
>>> f.via_T <= s
<Frame>
<Index> a      b      c      <<U1>
<Index>
p       False  False  False
q       True   True   False
r       True   False  False
s       True   True   False
<<U1>   <bool> <bool> <bool>

Frame.via_T.__eq__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__eq__(other)[source]: Return self==value.

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0.0
q        -2.0
r        0.5
s        1.0
<<U1>    <float64>
>>> f.via_T == s
<Frame>
<Index> a      b      c      <<U1>
<Index>
p       False  False  False
q       True   False  False
r       False  False  False
s       False  False  False
<<U1>   <bool> <bool> <bool>

Frame.via_T.__ne__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__ne__(other)[source]: Return self!=value.

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0.0
q        -2.0
r        0.5
s        1.0
<<U1>    <float64>
>>> f.via_T != s
<Frame>
<Index> a      b      c      <<U1>
<Index>
p       True   True   True
q       False  True   True
r       True   True   True
s       True   True   True
<<U1>   <bool> <bool> <bool>

Frame.via_T.__gt__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__gt__(other)[source]: Return self>value.

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0.0
q        -2.0
r        0.5
s        1.0
<<U1>    <float64>
>>> f.via_T > s
<Frame>
<Index> a      b      c      <<U1>
<Index>
p       True   True   True
q       False  False  True
r       False  True   True
s       False  False  True
<<U1>   <bool> <bool> <bool>

Frame.via_T.__ge__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__ge__(other)[source]: Return self>=value.

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0.0
q        -2.0
r        0.5
s        1.0
<<U1>    <float64>
>>> f.via_T >= s
<Frame>
<Index> a      b      c      <<U1>
<Index>
p       True   True   True
q       True   False  True
r       False  True   True
s       False  False  True
<<U1>   <bool> <bool> <bool>

Frame.via_T.__radd__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__radd__(other)[source]

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0.0
q        -2.0
r        0.5
s        1.0
<<U1>    <float64>
>>> f.via_T + s
<Frame>
<Index> a         b         c         <<U1>
<Index>
p       10.0      8.0       1.0
q       -4.0      -5.0      -2.0
r       0.5       8.5       9.5
s       1.0       1.0       13.0
<<U1>   <float64> <float64> <float64>

Frame.via_T.__rsub__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__rsub__(other)[source]

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0.0
q        -2.0
r        0.5
s        1.0
<<U1>    <float64>
>>> f.via_T - s
<Frame>
<Index> a         b         c         <<U1>
<Index>
p       10.0      8.0       1.0
q       0.0       -1.0      2.0
r       -0.5      7.5       8.5
s       -1.0      -1.0      11.0
<<U1>   <float64> <float64> <float64>

Frame.via_T.__rmul__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__rmul__(other)[source]

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0.0
q        -2.0
r        0.5
s        1.0
<<U1>    <float64>
>>> f.via_T * s
<Frame>
<Index> a         b         c         <<U1>
<Index>
p       0.0       0.0       0.0
q       4.0       6.0       -0.0
r       0.0       4.0       4.5
s       0.0       0.0       12.0
<<U1>   <float64> <float64> <float64>

Frame.via_T.__rtruediv__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__rtruediv__(other)[source]

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0.0
q        -2.0
r        0.5
s        1.0
<<U1>    <float64>
>>> f.via_T / s
<Frame>
<Index> a         b         c         <<U1>
<Index>
p       inf       inf       inf
q       1.0       1.5       -0.0
r       0.0       16.0      18.0
s       0.0       0.0       12.0
<<U1>   <float64> <float64> <float64>

Frame.via_T.__rfloordiv__(other)

Frame.via_T: Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceTranspose.__rfloordiv__(other)[source]

>>> f = sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')
>>> f
<Frame: x>
<Index>    a       b       c       <<U1>
<Index>
p          10      8       1
q          -2      -3      0
r          0       8       9
s          0       0       12
<<U1>      <int64> <int64> <int64>
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0.0
q        -2.0
r        0.5
s        1.0
<<U1>    <float64>
>>> f.via_T // s
<Frame>
<Index> a         b         c         <<U1>
<Index>
p       inf       inf       inf
q       1.0       1.0       -0.0
r       0.0       16.0      18.0
s       0.0       0.0       12.0
<<U1>   <float64> <float64> <float64>