Danfo.js专题 - Series对象
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的索引(轴标签)。
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 支持这个数列或索引的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)
返回基础数据的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 ]
返回基础数据形状的元组。
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 ]
根据定义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
返回基础数据中的元素数量。
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 |
复制此对象的索引和数据。 |
详解：
将系列对象转换为指定的数据类型。
【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 ║ ╚═══╧══════════════════════╝
复制此对象的索引和数据。
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 |
完全基于整数位置的索引，用于按位置选择。 |
详解：
通过标签或布尔数组访问一组行和列。
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 ║ ╚═══╧═══════════════════╧═══════════════════╧═══════════════════╝
- 完全基于整数位置的索引，用于按位置选择。
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的值中减去
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的值中减去
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 ║ ╚═══╧══════════════════════╝
与另一系列值相乘
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的值除
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值的模
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数值的指数幂
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 ║ ╚═══╧══════════════════════╝
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 中的所有值是否都小于一个值
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 中的所有值是否都大于一个值
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中的所有值是否都小于或等于一个值
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中的值进行比较
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 中的所有值与另一个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中的所有值与另一个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 ║ ╚═══╧══════════════════════╝
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. |
详解：
