Detail: FrameGO: Accessor Transpose

Overview: FrameGO: Accessor Transpose

FrameGO.via_T.via_fill_value(fill_value)
FrameGO.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.

>>> 
FrameGO.via_T.__add__(other)
FrameGO.via_T

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

InterfaceTranspose.__add__(other)[source]
>>> f = sf.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__sub__(other)
FrameGO.via_T

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

InterfaceTranspose.__sub__(other)[source]
>>> f = sf.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__mul__(other)
FrameGO.via_T

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

InterfaceTranspose.__mul__(other)[source]
>>> f = sf.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__truediv__(other)
FrameGO.via_T

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

InterfaceTranspose.__truediv__(other)[source]
>>> f = sf.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__floordiv__(other)
FrameGO.via_T

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

InterfaceTranspose.__floordiv__(other)[source]
>>> f = sf.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__mod__(other)
FrameGO.via_T

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

InterfaceTranspose.__mod__(other)[source]
>>> f = sf.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__pow__(other)
FrameGO.via_T

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

InterfaceTranspose.__pow__(other)[source]
>>> f = sf.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__lshift__(other)
FrameGO.via_T

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

InterfaceTranspose.__lshift__(other)[source]
>>> f = sf.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__rshift__(other)
FrameGO.via_T

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

InterfaceTranspose.__rshift__(other)[source]
>>> f = sf.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__and__(other)
FrameGO.via_T

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

InterfaceTranspose.__and__(other)[source]
>>> f = sf.FrameGO.from_fields(((False, True, True), (True, True, False)), columns=('a', 'b'), index=('p', 'q', 'r'), name='x')
>>> f
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> a      b      <<U1>
<Index>
p         False  False
q         True   True
r         True   False
<<U1>     <bool> <bool>
FrameGO.via_T.__xor__(other)
FrameGO.via_T

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

InterfaceTranspose.__xor__(other)[source]
>>> f = sf.FrameGO.from_fields(((False, True, True), (True, True, False)), columns=('a', 'b'), index=('p', 'q', 'r'), name='x')
>>> f
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> a      b      <<U1>
<Index>
p         False  True
q         False  False
r         False  True
<<U1>     <bool> <bool>
FrameGO.via_T.__or__(other)
FrameGO.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.FrameGO.from_fields(((False, True, True), (True, True, False)), columns=('a', 'b'), index=('p', 'q', 'r'), name='x')
>>> f
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> a      b      <<U1>
<Index>
p         False  True
q         True   True
r         True   True
<<U1>     <bool> <bool>
FrameGO.via_T.__lt__(other)
FrameGO.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.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__le__(other)
FrameGO.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.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__eq__(other)
FrameGO.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.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__ne__(other)
FrameGO.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.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__gt__(other)
FrameGO.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.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__ge__(other)
FrameGO.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.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__radd__(other)
FrameGO.via_T

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

InterfaceTranspose.__radd__(other)[source]
>>> f = sf.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__rsub__(other)
FrameGO.via_T

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

InterfaceTranspose.__rsub__(other)[source]
>>> f = sf.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__rmul__(other)
FrameGO.via_T

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

InterfaceTranspose.__rmul__(other)[source]
>>> f = sf.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__rtruediv__(other)
FrameGO.via_T

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

InterfaceTranspose.__rtruediv__(other)[source]
>>> f = sf.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>
FrameGO.via_T.__rfloordiv__(other)
FrameGO.via_T

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

InterfaceTranspose.__rfloordiv__(other)[source]
>>> f = sf.FrameGO.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
<FrameGO: x>
<IndexGO>    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
<FrameGO>
<IndexGO> 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>

FrameGO: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Assignment | Selector | Iterator | Operator Binary | Operator Unary | Accessor Values | Accessor Datetime | Accessor String | Accessor Transpose | Accessor Fill Value | Accessor Regular Expression | Accessor Hashlib | Accessor Type Clinic