Danfo.js专题 - Series对象

jcLee95 的 CSDN 博客
邮箱 ：291148484@163.com
CSDN 主页：https://blog.csdn.net/qq_28550263?spm=1001.2101.3001.5343
本文地址：https://blog.csdn.net/qq_28550263/article/details/115716277

编辑中【等待添加实战案例】
博文地址：https://blog.csdn.net/qq_28550263/article/details/115716277
提醒博主更新： 291148484@163.com

Series

Series是带有轴标签的一维数组(包括时间序列)。

Series(data, {columns: [ Array ], dtypes: [ Array ], index: [Array]}) [source]

3.1 属性

属性 描述
Series.index Series的索引(轴标签)。
Series.tensor 支持这个数列或索引的Tensorflow tensor 数据。
Series.dtype 返回基础数据的dtype对象。
Series.shape 返回基础数据形状的元组。
Series.ndim 根据定义1的基础数据。
Series.size 返回基础数据中的元素数量。

详解：

Series.index
Series的索引(轴标签)。

const dfd = require("danfojs-node")
​
let data1 = [30.21091, 40.190901, 3.564, 5.0212]
let sf1 = new dfd.Series(data1)
​
console.log(sf1.index)

Output

[ 0, 1, 2, 3 ]

Series.tensor
Series.tensor 支持这个数列或索引的Tensorflow tensor 数据。

const dfd = require("danfojs-node")
​
let data1 = [30.21091, 40.190901, 3.564, 5.0212]
let sf1 = new dfd.Series(data1)
​
console.log(sf1.values)

Output

const dfd = require("danfojs-node")
​
let data1 = [30.21091, 40.190901, 3.564, 5.0212]
let sf1 = new dfd.Series(data1)
​
console.log(sf1.values)

Series.dtype
返回基础数据的dtype对象。

const dfd = require("danfojs-node")let data1 = [30.21091, 40.190901, 3.564, 5.0212]
let sf1 = new dfd.Series(data1)console.log(sf1.values)

Output

[ 30.21091, 40.190901, 3.564, 5.0212 ]

Series.shape
返回基础数据形状的元组。

const dfd = require("danfojs-node")let data1 = [30.21091, 40.190901, 3.564, 5.0212]
let sf1 = new dfd.Series(data1)console.log(sf1.shape)

Output

[ 4, 1 ]

Series.ndim
根据定义1的基础数据。

const dfd = require("danfojs-node")let data1 = [30.21091, 40.190901, 3.564, 5.0212]
let sf1 = new dfd.Series(data1)console.log(sf1.ndim)

Output

1

Series.size
返回基础数据中的元素数量。

const dfd = require("danfojs-node")let data1 = [30.21091, 40.190901, 3.564, 5.0212]
let sf1 = new dfd.Series(data1)console.log(sf1.ndim)

Output

4

3.2 转换

方法 描述
Series.astype 将系列对象转换为指定的数据类型。
Series.copy 复制此对象的索引和数据。

详解：

Series.astype
将系列对象转换为指定的数据类型。

【eg1】将float dtype列转换为int

const dfd = require("danfojs-node")let data = { "A": [-20.1, 30, 47.3, -20] ,"B": [34, -4, 5, 6],"C": [20.1, -20.23, 30.3, 40.11],"D": ["a", "b", "c", "c"] }let df = new dfd.DataFrame(data)
df.print()
df.ctypes.print()let df_new = df.astype({column: "A", dtype: "int32"})
df_new.print()df.ctypes.print()

Output

//before casting
╔═══╤═══════════════════╤═══════════════════╤═══════════════════╤═══════════════════╗
║   │ A                 │ B                 │ C                 │ D                 ║
╟───┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 0 │ -20.1             │ 34                │ 20.1              │ a                 ║
╟───┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 1 │ 30                │ -4                │ -20.23            │ b                 ║
╟───┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 2 │ 47.3              │ 5                 │ 30.3              │ c                 ║
╟───┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 3 │ -20               │ 6                 │ 40.11             │ c                 ║
╚═══╧═══════════════════╧═══════════════════╧═══════════════════╧═══════════════════╝╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ A │ float32              ║
╟───┼──────────────────────╢
║ B │ int32                ║
╟───┼──────────────────────╢
║ C │ float32              ║
╟───┼──────────────────────╢
║ D │ string               ║
╚═══╧══════════════════════╝//after casting╔═══╤═══════════════════╤═══════════════════╤═══════════════════╤═══════════════════╗
║   │ A                 │ B                 │ C                 │ D                 ║
╟───┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 0 │ -20               │ 34                │ 20.1              │ a                 ║
╟───┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 1 │ 30                │ -4                │ -20.23            │ b                 ║
╟───┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 2 │ 47                │ 5                 │ 30.3              │ c                 ║
╟───┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 3 │ -20               │ 6                 │ 40.11             │ c                 ║
╚═══╧═══════════════════╧═══════════════════╧═══════════════════╧═══════════════════╝╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ A │ int32                ║
╟───┼──────────────────────╢
║ B │ int32                ║
╟───┼──────────────────────╢
║ C │ float32              ║
╟───┼──────────────────────╢
║ D │ string               ║
╚═══╧══════════════════════╝

【eg2】将string列转换为int

const dfd = require("danfojs-node")let data = { "A": [-20.1, 30, 47.3, -20] ,"B": [34, -4, 5, 6],"C": [20.1, -20.23, 30.3, 40.11],"D": ["a", "b", "c", "c"] }let df = new dfd.DataFrame(data)
let df_new = df.astype({column: "D", dtype: "int32"})
df_new.print()df.ctypes.print()

Output

╔═══╤═══════════════════╤═══════════════════╤═══════════════════╤═══════════════════╗
║   │ A                 │ B                 │ C                 │ D                 ║
╟───┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 0 │ -20.1             │ 34                │ 20.1              │ 20                ║
╟───┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 1 │ 30                │ -4                │ -20.23            │ 13                ║
╟───┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 2 │ 47.3              │ 5                 │ 30.3              │ 45                ║
╟───┼───────────────────┼───────────────────┼───────────────────┼───────────────────╢
║ 3 │ -20               │ 6                 │ 40.11             │ 90                ║
╚═══╧═══════════════════╧═══════════════════╧═══════════════════╧═══════════════════╝╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ A │ float32              ║
╟───┼──────────────────────╢
║ B │ int32                ║
╟───┼──────────────────────╢
║ C │ float32              ║
╟───┼──────────────────────╢
║ D │ int32                ║
╚═══╧══════════════════════╝

Series.copy
复制此对象的索引和数据。

const dfd = require("danfojs-node")let data1 = [30.21091, 40.190901, 3.564, 5.0212]
let sf1 = new dfd.Series(data1)
let sf2 = sf1.copy()sf2.print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ 30.21091             ║
╟───┼──────────────────────╢
║ 1 │ 40.190901            ║
╟───┼──────────────────────╢
║ 2 │ 3.564                ║
╟───┼──────────────────────╢
║ 3 │ 5.0212               ║
╚═══╧══════════════════════╝

3.3 索引、迭代

方法 描述
Series.loc 通过标签或布尔数组访问一组行和列。
Series.iloc 完全基于整数位置的索引，用于按位置选择。

详解：

Series.loc
通过标签或布尔数组访问一组行和列。

const dfd = require("danfojs-node")
​
let data = { "Name": ["Apples", "Mango", "Banana", "Pear"],"Count": [21, 5, 30, 10],"Price": [200, 300, 40, 250] }
​
let df = new dfd.DataFrame(data, {index: ["a", "b", "c", "d"]})
df.print()
let sub_df = df.loc({rows: ["a", "c"]})
sub_df.print()

Output

​
╔═══╤═══════════════════╤═══════════════════╤═══════════════════╗
║   │ Name              │ Count             │ Price             ║
╟───┼───────────────────┼───────────────────┼───────────────────╢
║ a │ Apples            │ 21                │ 200               ║
╟───┼───────────────────┼───────────────────┼───────────────────╢
║ b │ Mango             │ 5                 │ 300               ║
╟───┼───────────────────┼───────────────────┼───────────────────╢
║ c │ Banana            │ 30                │ 40                ║
╟───┼───────────────────┼───────────────────┼───────────────────╢
║ d │ Pear              │ 10                │ 250               ║
╚═══╧═══════════════════╧═══════════════════╧═══════════════════╝
​
​Shape: (2,3)
​
╔═══╤═══════════════════╤═══════════════════╤═══════════════════╗
║   │ Name              │ Count             │ Price             ║
╟───┼───────────────────┼───────────────────┼───────────────────╢
║ a │ Apples            │ 21                │ 200               ║
╟───┼───────────────────┼───────────────────┼───────────────────╢
║ c │ Banana            │ 30                │ 40                ║
╚═══╧═══════════════════╧═══════════════════╧═══════════════════╝

Series.iloc

  • 完全基于整数位置的索引，用于按位置选择。
const dfd = require("danfojs-node")
​
let data = { "Name": ["Apples", "Mango", "Banana", "Pear"],"Count": [21, 5, 30, 10],"Price": [200, 300, 40, 250] }
​
let df = new dfd.DataFrame(data, {index: ["a", "b", "c", "d"]})
df.print()
let sub_df = df.loc({columns: ["Count", "Price"]})
sub_df.print()

Output

╔═══╤═══════════════════╤═══════════════════╤═══════════════════╗
║   │ Name              │ Count             │ Price             ║
╟───┼───────────────────┼───────────────────┼───────────────────╢
║ a │ Apples            │ 21                │ 200               ║
╟───┼───────────────────┼───────────────────┼───────────────────╢
║ b │ Mango             │ 5                 │ 300               ║
╟───┼───────────────────┼───────────────────┼───────────────────╢
║ c │ Banana            │ 30                │ 40                ║
╟───┼───────────────────┼───────────────────┼───────────────────╢
║ d │ Pear              │ 10                │ 250               ║
╚═══╧═══════════════════╧═══════════════════╧═══════════════════╝
​
​//after slicing
​
╔═══╤═══════════════════╤═══════════════════╗
║   │ Count             │ Price             ║
╟───┼───────────────────┼───────────────────╢
║ a │ 21                │ 200               ║
╟───┼───────────────────┼───────────────────╢
║ b │ 5                 │ 300               ║
╟───┼───────────────────┼───────────────────╢
║ c │ 30                │ 40                ║
╟───┼───────────────────┼───────────────────╢
║ d │ 10                │ 250               ║
╚═══╧═══════════════════╧═══════════════════╝
  • 通过指定的标签索引两个轴
const dfd = require("danfojs-node")
​
let data = { "Name": ["Apples", "Mango", "Banana", "Pear"],"Count": [21, 5, 30, 10],"Price": [200, 300, 40, 250] }
​
let df = new dfd.DataFrame(data, { index: ["a", "b", "c", "d"] })
df.print()
let sub_df = df.loc({ rows: ["c","d"], columns: ["Name", "Price"] })
sub_df.print()

Output

​
╔═══╤═══════════════════╤═══════════════════╤═══════════════════╗
║   │ Name              │ Count             │ Price             ║
╟───┼───────────────────┼───────────────────┼───────────────────╢
║ a │ Apples            │ 21                │ 200               ║
╟───┼───────────────────┼───────────────────┼───────────────────╢
║ b │ Mango             │ 5                 │ 300               ║
╟───┼───────────────────┼───────────────────┼───────────────────╢
║ c │ Banana            │ 30                │ 40                ║
╟───┼───────────────────┼───────────────────┼───────────────────╢
║ d │ Pear              │ 10                │ 250               ║
╚═══╧═══════════════════╧═══════════════════╧═══════════════════╝
​
​
//after slicing
​
╔═══╤═══════════════════╤═══════════════════╗
║   │ Name              │ Price             ║
╟───┼───────────────────┼───────────────────╢
║ c │ Banana            │ 40                ║
╟───┼───────────────────┼───────────────────╢
║ d │ Pear              │ 250               ║
╚═══╧═══════════════════╧═══════════════════╝
  • 通过索引对特定行进行索引
const dfd = require("danfojs-node")
// const tf = require("@tensorflow/tfjs-node")let s = new dfd.Series([12, 34, 2.2, 2, 30, 30, 2.1, 7])
s.iloc([0,5]).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ 12                   ║
╟───┼──────────────────────╢
║ 5 │ 30                   ║
╚═══╧══════════════════════╝
  • 按行切片索引
    iloc函数还接受[开始:结束]形式的字符串片段，例如“[1: 4]”。这将返回索引位置1和3之间的所有值。
const dfd = require("danfojs-node")let s = new dfd.Series([12, 34, 2.2, 2, 30, 30, 2.1, 7])
s.iloc(["0:5"]).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ 12                   ║
╟───┼──────────────────────╢
║ 1 │ 34                   ║
╟───┼──────────────────────╢
║ 2 │ 2.2                  ║
╟───┼──────────────────────╢
║ 3 │ 2                    ║
╟───┼──────────────────────╢
║ 4 │ 30                   ║
╚═══╧══════════════════════╝

通过在切片中指定起始索引，将返回该索引之后的所有值。

const dfd = require("danfojs-node")let s = new dfd.Series([12, 34, 2.2, 2, 30, 30, 2.1, 7])
s.iloc(["5:"]).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 5 │ 30                   ║
╟───┼──────────────────────╢
║ 6 │ 2.1                  ║
╟───┼──────────────────────╢
║ 7 │ 7                    ║
╚═══╧══════════════════════╝

3.4 二进制操作函数

方法 描述
Series.add 按元素返回系列和其他的加法(二元运算符加法)。
Series.sub 数列和其他元素的返回减法(二元运算符sub)。
Series.mul 按元素返回系列和其他的乘法(二元运算符mul)。
Series.div 返回数列和其他元素的浮点除法(二元运算符truediv)。
Series.mod 按元素返回系列和其他的模(二进制运算符模)。
Series.pow 返回级数和其他元素指数幂(二元运算符幂)。
Series.round 将数列中的每个值四舍五入到给定的小数位数。
Series.lt 按元素返回小于系列和其他(二元运算符lt)。
Series.gt 按元素返回大于系列和其他(二元运算符gt)。
Series.le 按元素返回小于或等于系列和其他的(二元运算符le)。
Series.ge 按元素返回大于或等于系列和其他的(二元运算符ge)。
Series.ne 返回不等于系列和其他元素(二元运算符ne)。
Series.eq 按元素返回等于系列和其他(二元运算符eq)。
Series.dot 计算数列和其他列之间的点积。

详解：

Series.add
从另一Series的值中减去

const dfd = require("danfojs-node")let data1 = [30, 40, 3, 5]
let data2 = [1, 2, 3, 4]
let sf1 = new dfd.Series(data1)
let sf2 = new dfd.Series(data2)
sf1.add(sf2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ 31                   ║
╟───┼──────────────────────╢
║ 1 │ 42                   ║
╟───┼──────────────────────╢
║ 2 │ 6                    ║
╟───┼──────────────────────╢
║ 3 │ 9                    ║
╚═══╧══════════════════════╝

从数值中减去

const dfd = require("danfojs-node")let data1 = [1, 2, 3, 4, 5]
let sf1 = new dfd.Series(data1)sf1.add(2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ 3                    ║
╟───┼──────────────────────╢
║ 1 │ 4                    ║
╟───┼──────────────────────╢
║ 2 │ 5                    ║
╟───┼──────────────────────╢
║ 3 │ 6                    ║
╟───┼──────────────────────╢
║ 4 │ 7                    ║
╚═══╧══════════════════════╝

Series.sub
从另一series的值中减去

const dfd = require("danfojs-node")let data1 = [30, 40, 3, 5]
let data2 = [1, 2, 3, 4]
let sf1 = new dfd.Series(data1)
let sf2 = new dfd.Series(data2)
sf1.sub(sf2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ 29                   ║
╟───┼──────────────────────╢
║ 1 │ 38                   ║
╟───┼──────────────────────╢
║ 2 │ 0                    ║
╟───┼──────────────────────╢
║ 3 │ 1                    ║
╚═══╧══════════════════════╝

从数值中减去

const dfd = require("danfojs-node")let data1 = [1, 2, 3, 4, 5]
let sf1 = new dfd.Series(data1)sf1.sub(2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ -1                   ║
╟───┼──────────────────────╢
║ 1 │ 0                    ║
╟───┼──────────────────────╢
║ 2 │ 1                    ║
╟───┼──────────────────────╢
║ 3 │ 2                    ║
╟───┼──────────────────────╢
║ 4 │ 3                    ║
╚═══╧══════════════════════╝

Series.mul
与另一系列值相乘

const dfd = require("danfojs-node")let data1 = [30, 40, 3, 5]
let data2 = [1, 2, 3, 4]
let sf1 = new dfd.Series(data1)
let sf2 = new dfd.Series(data2)
sf1.mul(sf2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ 30                   ║
╟───┼──────────────────────╢
║ 1 │ 80                   ║
╟───┼──────────────────────╢
║ 2 │ 9                    ║
╟───┼──────────────────────╢
║ 3 │ 20                   ║
╚═══╧══════════════════════╝

与一个值相乘

const dfd = require("danfojs-node")let data1 = [1, 2, 3, 4, 5]
let sf1 = new dfd.Series(data1)sf1.mul(2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ 2                    ║
╟───┼──────────────────────╢
║ 1 │ 4                    ║
╟───┼──────────────────────╢
║ 2 │ 6                    ║
╟───┼──────────────────────╢
║ 3 │ 8                    ║
╟───┼──────────────────────╢
║ 4 │ 10                   ║
╚═══╧══════════════════════╝

Series.div
用另一series的值除

const dfd = require("danfojs-node")let data1 = [30, 40, 3, 5]
let data2 = [1, 2, 3, 4]
let sf1 = new dfd.Series(data1)
let sf2 = new dfd.Series(data2)
sf1.div(sf2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ 30                   ║
╟───┼──────────────────────╢
║ 1 │ 20                   ║
╟───┼──────────────────────╢
║ 2 │ 1                    ║
╟───┼──────────────────────╢
║ 3 │ 1.25                 ║
╚═══╧══════════════════════╝

用一个值除

const dfd = require("danfojs-node")let data1 = [1, 2, 3, 4, 5]
let sf1 = new dfd.Series(data1)sf1.div(2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ 0.5                  ║
╟───┼──────────────────────╢
║ 1 │ 1                    ║
╟───┼──────────────────────╢
║ 2 │ 1.5                  ║
╟───┼──────────────────────╢
║ 3 │ 2                    ║
╟───┼──────────────────────╢
║ 4 │ 2.5                  ║
╚═══╧══════════════════════╝

Series.mod
另一series值的模

const dfd = require("danfojs-node")let data1 = [2, 30, 4, 5]
let data2 = [1.1, 2.2, 3.3, 2.4]
let sf1 = new dfd.Series(data1)
let sf2 = new dfd.Series(data2)
sf1.mod(sf2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ 0.8999999761581421   ║
╟───┼──────────────────────╢
║ 1 │ 1.3999993801116943   ║
╟───┼──────────────────────╢
║ 2 │ 0.7000000476837158   ║
╟───┼──────────────────────╢
║ 3 │ 0.19999980926513672  ║
╚═══╧══════════════════════╝

以值为模

const dfd = require("danfojs-node")let data1 = [1, 2, 3, 4, 5]
let sf1 = new dfd.Series(data1)sf1.mod(2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ 1                    ║
╟───┼──────────────────────╢
║ 1 │ 0                    ║
╟───┼──────────────────────╢
║ 2 │ 1                    ║
╟───┼──────────────────────╢
║ 3 │ 0                    ║
╟───┼──────────────────────╢
║ 4 │ 1                    ║
╚═══╧══════════════════════╝

Series.pow
另一series数值的指数幂

const dfd = require("danfojs-node")let data1 = [2, 3, 4, 5]
let data2 = [1, 2, 3, 0]
let sf1 = new dfd.Series(data1)
let sf2 = new dfd.Series(data2)
sf1.pow(sf2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ 2                    ║
╟───┼──────────────────────╢
║ 1 │ 9                    ║
╟───┼──────────────────────╢
║ 2 │ 64                   ║
╟───┼──────────────────────╢
║ 3 │ 1                    ║
╚═══╧══════════════════════╝

有值的指数值

const dfd = require("danfojs-node")let data1 = [1, 2, 3, 4, 5]
let sf1 = new dfd.Series(data1)sf1.pow(2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ 1                    ║
╟───┼──────────────────────╢
║ 1 │ 4                    ║
╟───┼──────────────────────╢
║ 2 │ 9                    ║
╟───┼──────────────────────╢
║ 3 │ 16                   ║
╟───┼──────────────────────╢
║ 4 │ 25                   ║
╚═══╧══════════════════════╝

Series.round

const dfd = require("danfojs-node")let data1 = [30.21091, 40.190901, 3.564, 5.0212]
let sf1 = new dfd.Series(data1)sf1.round(2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ 30.21                ║
╟───┼──────────────────────╢
║ 1 │ 40.19                ║
╟───┼──────────────────────╢
║ 2 │ 3.56                 ║
╟───┼──────────────────────╢
║ 3 │ 5.02                 ║
╚═══╧══════════════════════╝

Series.lt
检查series 中的所有值是否都小于一个值

const dfd = require("danfojs-node")let data1 = [10, 45, 56, 25, 23, 20, 10]
let sf1 = new dfd.Series(data1)sf1.lt(20).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ false                ║
╟───┼──────────────────────╢
║ 1 │ true                 ║
╟───┼──────────────────────╢
║ 2 │ true                 ║
╟───┼──────────────────────╢
║ 3 │ true                 ║
╟───┼──────────────────────╢
║ 4 │ true                 ║
╟───┼──────────────────────╢
║ 5 │ false                ║
╟───┼──────────────────────╢
║ 6 │ false                ║
╚═══╧══════════════════════╝

const dfd = require("danfojs-node")let data1 = [10, 45, 56, 25, 23, 20, 10]
let data2 = [10, 450, 56, 5, 25, 2, 0]
let sf1 = new dfd.Series(data1)
let sf2 = new dfd.Series(data2)sf1.lt(sf2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ false                ║
╟───┼──────────────────────╢
║ 1 │ true                 ║
╟───┼──────────────────────╢
║ 2 │ false                ║
╟───┼──────────────────────╢
║ 3 │ false                ║
╟───┼──────────────────────╢
║ 4 │ true                 ║
╟───┼──────────────────────╢
║ 5 │ false                ║
╟───┼──────────────────────╢
║ 6 │ false                ║
╚═══╧══════════════════════╝

检查一个series中的所有值是否小于另一个series中的值。

const dfd = require("danfojs-node")let data1 = [10, 45, 56, 25, 23, 20, 10]
let data2 = [10, 450, 56, 5, 25, 2, 0]
let sf1 = new dfd.Series(data1)
let sf2 = new dfd.Series(data2)sf1.lt(sf2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ false                ║
╟───┼──────────────────────╢
║ 1 │ true                 ║
╟───┼──────────────────────╢
║ 2 │ false                ║
╟───┼──────────────────────╢
║ 3 │ false                ║
╟───┼──────────────────────╢
║ 4 │ true                 ║
╟───┼──────────────────────╢
║ 5 │ false                ║
╟───┼──────────────────────╢
║ 6 │ false                ║
╚═══╧══════════════════════╝

Series.gt
检查series 中的所有值是否都大于一个值

const dfd = require("danfojs-node")let data1 = [10, 45, 56, 25, 23, 20, 10]
let sf1 = new dfd.Series(data1)sf1.gt(20).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ false                ║
╟───┼──────────────────────╢
║ 1 │ true                 ║
╟───┼──────────────────────╢
║ 2 │ true                 ║
╟───┼──────────────────────╢
║ 3 │ true                 ║
╟───┼──────────────────────╢
║ 4 │ true                 ║
╟───┼──────────────────────╢
║ 5 │ false                ║
╟───┼──────────────────────╢
║ 6 │ false                ║
╚═══╧══════════════════════╝

检查一个series 中的所有值是否大于另一个series 中的值。

const dfd = require("danfojs-node")let data1 = [10, 45, 56, 25, 23, 20, 10]
let data2 = [10, 450, 56, 5, 25, 2, 0]
let sf1 = new dfd.Series(data1)
let sf2 = new dfd.Series(data2)sf1.gt(sf2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ false                ║
╟───┼──────────────────────╢
║ 1 │ false                ║
╟───┼──────────────────────╢
║ 2 │ false                ║
╟───┼──────────────────────╢
║ 3 │ true                 ║
╟───┼──────────────────────╢
║ 4 │ false                ║
╟───┼──────────────────────╢
║ 5 │ true                 ║
╟───┼──────────────────────╢
║ 6 │ true                 ║
╚═══╧══════════════════════╝

Series.le
检查series中的所有值是否都小于或等于一个值

const dfd = require("danfojs-node")
​
let data1 = [10, 45, 56, 25, 23, 20, 10]
let sf1 = new dfd.Series(data1)
​
sf1.le(20).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ true                 ║
╟───┼──────────────────────╢
║ 1 │ false                ║
╟───┼──────────────────────╢
║ 2 │ false                ║
╟───┼──────────────────────╢
║ 3 │ false                ║
╟───┼──────────────────────╢
║ 4 │ false                ║
╟───┼──────────────────────╢
║ 5 │ true                 ║
╟───┼──────────────────────╢
║ 6 │ true                 ║
╚═══╧══════════════════════╝

检查一个series中的所有值是否小于或等于另一个series中的值。

const dfd = require("danfojs-node")
​
let data1 = [10, 45, 56, 25, 23, 20, 10]
let data2 = [10, 450, 56, 5, 25, 2, 0]
let sf1 = new dfd.Series(data1)
let sf2 = new dfd.Series(data2)
​
sf1.le(sf2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ true                 ║
╟───┼──────────────────────╢
║ 1 │ true                 ║
╟───┼──────────────────────╢
║ 2 │ true                 ║
╟───┼──────────────────────╢
║ 3 │ false                ║
╟───┼──────────────────────╢
║ 4 │ true                 ║
╟───┼──────────────────────╢
║ 5 │ false                ║
╟───┼──────────────────────╢
║ 6 │ false                ║
╚═══╧══════════════════════╝

Series.ge
将一个序列中的所有值与另一个series中的值进行比较

const dfd = require("danfojs-node")let data1 = [10, 45, 56, 25, 23, 20, 10]
let data2 = [10, 450, 56, 5, 25, 2, 0]
let sf1 = new dfd.Series(data1)
let sf2 = new dfd.Series(data2)sf1.ge(sf2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ true                 ║
╟───┼──────────────────────╢
║ 1 │ false                ║
╟───┼──────────────────────╢
║ 2 │ true                 ║
╟───┼──────────────────────╢
║ 3 │ true                 ║
╟───┼──────────────────────╢
║ 4 │ false                ║
╟───┼──────────────────────╢
║ 5 │ true                 ║
╟───┼──────────────────────╢
║ 6 │ true                 ║
╚═══╧══════════════════════╝

检查Series 中的所有值是否都大于或等于一个值。

const dfd = require("danfojs-node")let data1 = [10, 45, 56, 25, 23, 20, 10]
let sf1 = new dfd.Series(data1)sf1.ge(20).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ false                ║
╟───┼──────────────────────╢
║ 1 │ true                 ║
╟───┼──────────────────────╢
║ 2 │ true                 ║
╟───┼──────────────────────╢
║ 3 │ true                 ║
╟───┼──────────────────────╢
║ 4 │ true                 ║
╟───┼──────────────────────╢
║ 5 │ true                 ║
╟───┼──────────────────────╢
║ 6 │ false                ║
╚═══╧══════════════════════╝

Series.ne
将一个series 中的所有值与另一个series 中的值进行比较

const dfd = require("danfojs-node")
​
let data1 = [10, 45, 56, 25, 23, 20, 10]
let data2 = [10, 450, 56, 5, 25, 2, 0]
let sf1 = new dfd.Series(data1)
let sf2 = new dfd.Series(data2)
​
sf1.ne(sf2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ false                ║
╟───┼──────────────────────╢
║ 1 │ true                 ║
╟───┼──────────────────────╢
║ 2 │ false                ║
╟───┼──────────────────────╢
║ 3 │ true                 ║
╟───┼──────────────────────╢
║ 4 │ true                 ║
╟───┼──────────────────────╢
║ 5 │ true                 ║
╟───┼──────────────────────╢
║ 6 │ true                 ║
╚═══╧══════════════════════╝

将Series 中的所有值与一个值进行比较。

const dfd = require("danfojs-node")
​
let data1 = [10, 45, 56, 25, 23, 20, 10]
let sf1 = new dfd.Series(data1)
​
sf1.ne(10).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ false                ║
╟───┼──────────────────────╢
║ 1 │ true                 ║
╟───┼──────────────────────╢
║ 2 │ true                 ║
╟───┼──────────────────────╢
║ 3 │ true                 ║
╟───┼──────────────────────╢
║ 4 │ true                 ║
╟───┼──────────────────────╢
║ 5 │ true                 ║
╟───┼──────────────────────╢
║ 6 │ false                ║
╚═══╧══════════════════════╝

Series.eq
将一个series中的所有值与另一个series进行比较

const dfd = require("danfojs-node")let data1 = [10, 45, 56, 25, 23, 20, 10]
let data2 = [10, 450, 56, 5, 25, 2, 0]
let sf1 = new dfd.Series(data1)
let sf2 = new dfd.Series(data2)sf1.eq(sf2).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ true                 ║
╟───┼──────────────────────╢
║ 1 │ false                ║
╟───┼──────────────────────╢
║ 2 │ true                 ║
╟───┼──────────────────────╢
║ 3 │ false                ║
╟───┼──────────────────────╢
║ 4 │ false                ║
╟───┼──────────────────────╢
║ 5 │ false                ║
╟───┼──────────────────────╢
║ 6 │ false                ║
╚═══╧══════════════════════╝

检查所有值是否等于一个值

const dfd = require("danfojs-node")let data1 = [10, 45, 56, 25, 23, 20, 10]
let sf1 = new dfd.Series(data1)sf1.eq(10).print()

Output

╔═══╤══════════════════════╗
║   │ 0                    ║
╟───┼──────────────────────╢
║ 0 │ true                 ║
╟───┼──────────────────────╢
║ 1 │ false                ║
╟───┼──────────────────────╢
║ 2 │ false                ║
╟───┼──────────────────────╢
║ 3 │ false                ║
╟───┼──────────────────────╢
║ 4 │ false                ║
╟───┼──────────────────────╢
║ 5 │ false                ║
╟───┼──────────────────────╢
║ 6 │ true                 ║
╚═══╧══════════════════════╝

Series.dot

Output

Output

3.5 Function application & GroupBy

方法 描述
Series.apply 对数列的值调用函数。
Series.map 根据输入的对应关系映射系列的值。

详解：

3.6 Computations / descriptive stats

方法 描述
Series.abs 返回包含每个元素的绝对数值的Series 。
Series.corr 计算与其他Series的相关性，不包括缺失值。
Series.count 返回系列中非NaN观测值的数目。
Series.cummax 返回DataFrame或Series轴上的累积最大值。
Series.cummin 返回DataFrame或Series轴上的累积最小值。
Series.cumprod 返回DataFrame或Series轴上的累计乘积。
Series.cumsum 返回DataFrame或Series轴上的累计总和。
Series.describe 生成描述性统计数据。
Series.max 返回所请求轴的最大值。
Series.mean 返回所请求轴的平均值。
Series.median 返回所请求轴的值的中间值。
Series.min 返回所请求轴的最小值。
Series.mode 返回数据集的模式。
Series.std 返回要求轴上的样本标准偏差。
Series.sum 返回所请求轴的值的总和。
Series.var 返回指定轴上的无偏方差。
Series.unique 返回Series对象中的唯一值.
Series.nunique 返回对象中唯一元素的数量。
Series.value_counts 返回包含唯一值计数的序列。

详解：

3.7 重新索引（Reindexing） / 选择/ 标签操作

方法 描述
Series.drop_duplicates 移除重复值后返回序列。
Series.head 返回前n行。
Series.reset_index 在重置索引的情况下生成新的DataFrame或Series。
Series.sample 从对象的轴返回项目的随机样本。
Series.tail 返回最后n行。

3.8 数据缺失处理

方法 描述
Series.dropna 返回一个新系列，并删除缺失的值。
Series.fillna 使用指定的方法填充 NaN 值。
Series.isna 检测缺失值。
Series.replace 用值替换to_replace中给出的值。

详解：

3.9 再成形（reshape）, 排序

方法 描述
Series.argsort 返回将对序列值进行排序的整数索引。
Series.argmin 返回序列中最小值的整数位置。
Series.argmax 返回序列中最大值的整数位置。
Series.sort_values 按值排序。

详解：

3.10 访问器

Danfo在各种访问器下提供特定于数据类型的方法。这些是Series内单独的命名空间(https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.html#pandas.Series)，仅适用于特定的数据类型。

数据类型 访问器
Datetime dt
String str

Datetimelike 属性

Series.dt 可用于以datetime形式访问系列的值，并返回几个属性。这些可以通过以下方式访问如 Series.dt.<property>.

Datetime 方法

方法 描述
Series.dt.year datetime中的年份。
Series.dt.month 月份，例如 January=1, December=12。
Series.dt.day datetime中的日。
Series.dt.hour datetime中的时。
Series.dt.minute datetime中的分钟。
Series.dt.second datetime中的秒
Series.dt.weekdays 一周中的某天，使用 （周一）Monday=0, （周日）Sunday=6.
Series.dt.month_name 返回指定区域设置的日期时间索引的月份名称

详解：

字符串处理

Series.str 可用于以字符串形式访问系列的值，并对其应用几种方法。这些可以像 Series.str.<function/property>一样访问。

方法 描述
Series.str.capitalize 将每个字符串的第一个字符大写
Series.str.toUpperCase 将所有字符转换为大写
Series.str.toLowerCase 将所有字符转换为小写
Series.str.charAt 返回指定索引(位置)处的字符。
Series.str.concat 连接两个或多个字符串/数组。
Series.str.startsWith 检查字符串是否以指定的字符开头。
Series.str.endsWith 检查字符串是否以指定的字符结尾
Series.str.includes 检查字符串是否包含指定的字符串/字符。
Series.str.indexOf 返回字符串中第一个找到的指定值的位置。
Series.str.lastIndexOf 返回字符串中指定值最后一次出现的位置。
Series.str.repeat 返回一个新字符串，其中包含现有字符串的指定数量的副本。
Series.str.search 在字符串中搜索指定的值或正则表达式，并返回匹配的位置。
Series.str.slice 提取字符串的一部分并返回一个新字符串。
Series.str.split Splits a string into an array of substrings.
Series.str.substr 从字符串中提取字符，从指定的开始位置开始，通过指定的字符数。
Series.str.substring 从两个指定索引之间的字符串中提取字符。
Series.str.len 计算每个字符串中的字符数。
Series.str.trim 删除字符串两端的空白。
Series.str.join 将字符串连接到指定值。
Series.str.replace 替换序列/索引中模式/正则表达式的每次出现。

详解：

3.11 绘图

Series.plot 是一个可调用的方法，也是一个命名空间属性，用于Series.plot.<kind>形式的特定绘图方法。

方法 描述
Series.plot.bar 竖线图
Series.plot.box 制作DataFrame一列的方框图
Series.plot.violin 制作DataFrame一列的小提琴图
Series.plot.hist 为DataFrame的一列炯之一个矩形图
Series.plot.scatter 使用高斯核生成核密度估计图
Series.plot.line 使用Series或DataFrame绘制线图
Series.plot.pie 生成一个饼图
Timeseries Plots 时间序列图
Table 在Div中将Series 显示为交互式表格

详解：

3.12 序列化/ IO / 转换

方法 描述
Series.to_csv Write object to a comma-separated values (csv) file.
Series.to_json Convert the object to a JSON string.

详解：

Danfo.js专题 - Series对象相关推荐

  1. Danfo.js专题 - Danfo.js与Dnotebook简介与入门

    Danfo.js与Dnotebook -- pandas.jupyter的JavaScript版本 [前言]:谷歌公司不仅推出了tensorflow的JavaScript版本tensorflow.js ...

  2. Danfo.js专题 - 附：Dnotebook（Danfo Notebook）单机资源与汉化文档

    本文是汉化版的Danfo notebook对应修改的demo,与原版demo内容相比,请求csv的路径发生了变化,且部分文字汉化了.该汉化版本在博主发布的资源中可以找到. 由于G内网无法访问该文档,故 ...

  3. js中的new file_深受 Pandas 启发的 JavaScript 开源库 — Danfo.js 现已推出！

    特邀博文 / 独立研究员 Rising Odegua 与来自 Data Science Nigeria 的 Stephen Oni Danfo.js 是个 JavaScript 开源库,提供了高性能. ...

  4. excel html modify,在Excel 2010中修改Series对象上的Z-index(Modify Z-index on Series object in Excel 2010)...

    在Excel 2010中修改Series对象上的Z-index(Modify Z-index on Series object in Excel 2010) 我正在使用excel 2010. 我有一个 ...

  5. pandas使用argmax函数返回给定series对象中最大值（max、maximum）的行索引实战

    pandas使用argmax函数返回给定series对象中最大值(max.maximum)的行索引实战 目录 pandas使用argmax函数返回给定series对象中最大值的行索引实战

  6. JS获取当前对象大小以及屏幕分辨率等...

    <!DOCTYPE html> <html> <head><meta charset="utf-8"/><meta name= ...

  7. JS的事件对象和事件冒泡

    2019独角兽企业重金招聘Python工程师标准>>> 1.事件对象 js的事件对象中保存了当前被触发事件的一些相关的属性信息,如事件源.事件发生时的鼠标位置.事件按键等. 事件对象 ...

  8. JS中集合对象(Array、Map、Set)及类数组对象的使用与对比

    JS中集合对象(Array.Map.Set)及类数组对象的使用与对比 在使用js编程的时候,常常会用到集合对象,集合对象其实是一种泛型,在js中没有明确的规定其内元素的类型,但在强类型语言譬如Java ...

  9. Pandas中兼并数组和字典功能的Series 2013-03-24 11:24:00 分类： Python/Ruby In [2]: # 这段代码用于并排显示多个Series对象 from it

    Pandas中兼并数组和字典功能的Series 2013-03-24 11:24:00 分类: Python/Ruby In [2]: # 这段代码用于并排显示多个Series对象 from iter ...

最新文章

  1. knn的python代码_Python代码实现KNN算法
  2. 商业周刊评出08年增长最快的美国科技公司
  3. Qt的简单介绍和安装
  4. Python的正则表达式笔记
  5. 黑马商城项目级联选择占满全屏解决方案
  6. Python 利用pymupdf将pdf转换为图片并拆分，后通过PIL合并生成一张图片
  7. 华为鸿蒙商标被驳回复审：易造成混淆
  8. 引用和指针自增的不同
  9. UVALive 6909 Kevin's Problem 数学排列组合
  10. 试述计算机控制系统的大致组成,试述工业计算机控制系统的组成及应用
  11. 东北育才10天大总结
  12. 图解Python机器学习pdf 中日双语 第1页
  13. 《穿越计算机的迷雾》读书笔记六
  14. Abaqus中多层介质设置初始应力场（补充介绍）
  15. 关于微信卡券网页跳转链接能力的下线
  16. 圣诞老人python代码_用Python画圣诞老人的N种方法
  17. cognex扫码枪识别内容直接_康耐视cognex DataMan8600系列-手持终端-条码扫描枪-PDA-扫描模块-条码打印机-苏州奥维尔...
  18. JAVA 中的修饰符的适用范围
  19. Debezium系列之：永久保存history topic中的数据
  20. Steam自建游戏服务器配置

热门文章

  1. 程序员面试金典——5.1二进制插入
  2. 剑指offer——面试题39：二叉树的深度
  3. Caffe中merge卷积和bn层的原理
  4. 部署和操作 Enterprise Library 加密应用程序块
  5. linux执行jmeter脚本解决响应数据为空
  6. LR11中web_save_timestamp_param
  7. 二叉树的遍历 《算法导论》10.4-1~10.4-3 10.4-5
  8. JDK 和 tomcat 安装 配置
  9. 产品原型设计5：移动App原型设计神器 - POP（Prototyping on Paper）
  10. Google 加入反 IE6 联盟：IE6 真的能被消灭吗？