# Detail: Series: Operator Binary

Overview: Series: Operator Binary

```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> s + 8
<Series>
<Index>
a        18
b        10
c        16
<<U1>    <int64>
>>> s + s.reindex(('c', 'b'))
<Series>
<Index>
a        nan
b        4.0
c        16.0
<<U1>    <float64>
```
Series.__and__(other)
```>>> s = sf.Series((False, False, True), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        False
b        False
c        True
<<U1>    <bool>
>>> s & True
<Series>
<Index>
a        False
b        False
c        True
<<U1>    <bool>
>>> s & (True, False, True)
<Series>
<Index>
a        False
b        False
c        True
<<U1>    <bool>
```
Series.__eq__(other)

Return self==value.

```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> s == 8
<Series>
<Index>
a        False
b        False
c        True
<<U1>    <bool>
>>> s == s.reindex(('c', 'b'))
<Series>
<Index>
a        False
b        True
c        True
<<U1>    <bool>
```
Series.__floordiv__(other)
```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> s // 8
<Series>
<Index>
a        1
b        0
c        1
<<U1>    <int64>
>>> s // s.reindex(('c', 'b'))
<Series>
<Index>
a        nan
b        1.0
c        1.0
<<U1>    <float64>
```
Series.__ge__(other)

Return self>=value.

```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> s >= 8
<Series>
<Index>
a        True
b        False
c        True
<<U1>    <bool>
>>> s >= s.reindex(('c', 'b'))
<Series>
<Index>
a        False
b        True
c        True
<<U1>    <bool>
```
Series.__gt__(other)

Return self>value.

```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> s > 8
<Series>
<Index>
a        True
b        False
c        False
<<U1>    <bool>
>>> s > s.reindex(('c', 'b'))
<Series>
<Index>
a        False
b        False
c        False
<<U1>    <bool>
```
Series.__le__(other)

Return self<=value.

```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> s <= 8
<Series>
<Index>
a        False
b        True
c        True
<<U1>    <bool>
>>> s <= s.reindex(('c', 'b'))
<Series>
<Index>
a        False
b        True
c        True
<<U1>    <bool>
```
Series.__lt__(other)

Return self<value.

```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> s < 8
<Series>
<Index>
a        False
b        True
c        False
<<U1>    <bool>
>>> s < s.reindex(('c', 'b'))
<Series>
<Index>
a        False
b        False
c        False
<<U1>    <bool>
```
Series.__matmul__(other)
```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> s @ (3, 0, 4)
62
```
Series.__mod__(other)
```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> s % 8
<Series>
<Index>
a        2
b        2
c        0
<<U1>    <int64>
>>> s % s.reindex(('c', 'b'))
<Series>
<Index>
a        nan
b        0.0
c        0.0
<<U1>    <float64>
```
Series.__mul__(other)
```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> s * 8
<Series>
<Index>
a        80
b        16
c        64
<<U1>    <int64>
>>> s * s.reindex(('c', 'b'))
<Series>
<Index>
a        nan
b        4.0
c        64.0
<<U1>    <float64>
```
Series.__ne__(other)

Return self!=value.

```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> s != 8
<Series>
<Index>
a        True
b        True
c        False
<<U1>    <bool>
>>> s != s.reindex(('c', 'b'))
<Series>
<Index>
a        True
b        False
c        False
<<U1>    <bool>
```
Series.__or__(other)

Return self|value.

```>>> s = sf.Series((False, False, True), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        False
b        False
c        True
<<U1>    <bool>
>>> s | True
<Series>
<Index>
a        True
b        True
c        True
<<U1>    <bool>
>>> s | (True, False, True)
<Series>
<Index>
a        True
b        False
c        True
<<U1>    <bool>
```
Series.__pow__(other)
```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> s ** 8
<Series>
<Index>
a        100000000
b        256
c        16777216
<<U1>    <int64>
>>> s ** s.reindex(('c', 'b'))
<Series>
<Index>
a        nan
b        4.0
c        16777216.0
<<U1>    <float64>
```
```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> 8 + s
<Series>
<Index>
a        18
b        10
c        16
<<U1>    <int64>
```
Series.__rfloordiv__(other)
```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> 8 // s
<Series>
<Index>
a        0
b        4
c        1
<<U1>    <int64>
```
Series.__rmatmul__(other)
```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> s @ (3, 0, 4)
62
```
Series.__rmul__(other)
```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> 8 * s
<Series>
<Index>
a        80
b        16
c        64
<<U1>    <int64>
```
Series.__rshift__(other)
```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> s >> 1
<Series>
<Index>
a        5
b        1
c        4
<<U1>    <int64>
```
Series.__rsub__(other)
```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> 8 - s
<Series>
<Index>
a        -2
b        6
c        0
<<U1>    <int64>
```
Series.__rtruediv__(other)
```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> 8 / s
<Series>
<Index>
a        0.8
b        4.0
c        1.0
<<U1>    <float64>
```
Series.__sub__(other)
```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> s - 8
<Series>
<Index>
a        2
b        -6
c        0
<<U1>    <int64>
>>> s - s.reindex(('c', 'b'))
<Series>
<Index>
a        nan
b        0.0
c        0.0
<<U1>    <float64>
```
Series.__truediv__(other)
```>>> s = sf.Series((10, 2, 8), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        10
b        2
c        8
<<U1>    <int64>
>>> s / 8
<Series>
<Index>
a        1.25
b        0.25
c        1.0
<<U1>    <float64>
>>> s / s.reindex(('c', 'b'))
<Series>
<Index>
a        nan
b        1.0
c        1.0
<<U1>    <float64>
```
Series.__xor__(other)
```>>> s = sf.Series((False, False, True), index=('a', 'b', 'c'))
>>> s
<Series>
<Index>
a        False
b        False
c        True
<<U1>    <bool>
>>> s ^ True
<Series>
<Index>
a        True
b        True
c        False
<<U1>    <bool>
>>> s ^ (True, False, True)
<Series>
<Index>
a        True
b        False
c        False
<<U1>    <bool>
```