Danfo.js专题 - Series对象

已于 2022-04-08 01:34:49 修改
阅读量847 收藏 3
点赞数
文章标签： Danfo.js danfojs Series Pandas 数据分析
于 2021-04-15 10:30:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28550263/article/details/115716277
版权
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.indexSeries的索引(轴标签)。
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)，仅适用于特定的数据类型。

数据类型访问器
Datetimedt
Stringstr

Datetimelike 属性

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

Datetime 方法

方法描述
Series.dt.yeardatetime中的年份。
Series.dt.month月份，例如 January=1, December=12。
Series.dt.daydatetime中的日。
Series.dt.hourdatetime中的时。
Series.dt.minutedatetime中的分钟。
Series.dt.seconddatetime中的秒
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.splitSplits 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_csvWrite object to a comma-separated values (csv) file.
Series.to_jsonConvert the object to a JSON string.

详解：

js动态添加echarts 中 series
MyLove_Kun的博客
09-17 2160
js动态添加echarts 中series 第一种：数据和x轴说明分开 首先声明一个name var yearList=[2015,2016,2017,2018,2019,2020];//x轴说明文字 var arr_name=["北京","上海","天津","江苏","安徽","江西"]；//每个柱子的说明 对应的数据类似下边（大多数从后端读取/excel中读取) var allList=[ //数据 [100,90,80,70,60,50],//北京 [100,90,80,70,60..
深受 Pandas 启发的 JavaScript 开源库 — Danfo.js
tensorflowforum的博客
07-30 1394
特邀博文 / 独立研究员 Rising Odegua 与来自 Data Science Nigeria 的 Stephen Oni Danfo.js 是个 JavaScript 开源库，提供了高性能、直观易用的数据结构，支持结构化数据的操作和处理。Danfo.js 深受 Python Pandas 库的启发，并提供了类似的接口/API。因此熟悉 Pandas API 且了解 JavaScript 的用户可以轻松上手。 Danfo.js的一大目标是为 JavaScript 开发...
javascript-series-4.27
03-04
La Prairie：JavaScript 欢迎使用JavaScript文件夹。 结构 该文件夹包含73个练习，分为11个系列。 不要害怕数量：这些练习大多数都非常简短，并且专注于特定方面。 练习以逻辑上相对的方式进行，但不要让一个练习阻止您：转到下一个，以后再回来。 :index_pointing_up: 每个练习都必须完成。 :love-you_gesture: 注意：第9系列中的练习稍微复杂一点，值得一试：它们是对取得的进展的良好综合。 ES2015 +？ 您很快就会在研究中看到存在着一个旧的Javascript和一个新的Javascript，称为ES6或ES2015，以及ES2016，ES2017等。 这是什么意思 ？ 因此，在手表中解释这种混乱是一个好主意-眨眼，眨眼-不用太担心：在这种情况下，请保留ES2015是新标准，并继续关注该版本。 本地服务器 一些练习可能需要在本地服务器上运行代码。 这是一个好习惯，应该始终应用。 也许您
探索Danfo.js：一个强大的JavaScript库用于数据处理和可视化
gitblog_00034的博客
04-10 722
探索Danfo.js：一个强大的JavaScript库用于数据处理和可视化 danfojs 项目地址: https://gitcode.com/gh_mirrors/dan/danfojs 项目简介 是一个...
Danfo.js专题 - Danfo.js与Dnotebook简介与入门
jclee95的个人博客
02-02 2550
python数据分析工具的JavaScript替代方案 【前言】：谷歌公司不仅推出了tensorflow的JavaScript版本tensorflow.js，在2020年又相继推出了pandas和jupyter notebook的JavaScript端替代品——Danfo.js和D notebook，它们和python端具有类似的接口，熟悉python中相关工具的开发者可以很快上手对应的工具。本文将追随者最新的相关内容不断更新系列博客。 目录/索引 1.转向JavaScript 2.Dnotebook
danfojs:danfo.js是一个开放源代码JavaScript库，可提供高性能，直观且易于使用的数据结构来处理和处理结构化数据
03-19
Danfojs：功能强大JavaScript数据分析工具包 它是什么？ Danfo.js是一个javascript程序包，提供了快速，灵活和富于表现力的数据结构，旨在使使用“关系”或“标记”数据既简单又直观。它在很大程度上受到库的启发，并提供了类似的API。这意味着熟悉用户可以轻松获取danfo.js。 主要特点 Danfo.js速度很快。它基于Tensorflow.js构建，并开箱即用地支持张量。这意味着您可以为张量。 易于处理浮点数据和非浮点数据中的（表示为NaN ） 大小可变性：可以从DataFrame中列 自动和显式：可以将对象显式对齐到一组标签，或者用户可以简单地忽略标签并让Series ， DataFrame等自动为您对齐数据 功能强大，灵活功能来执行对数据集拆分申请，联合行动，对于聚合和转换数据 轻松将数组，JSON，列表或对象，张量和不同索引的数据结构转换为DataFra
Danfo.js：JavaScript中快速处理结构化数据的利器
danfo.js是一个为JavaScript开发者提供高效、直观且易于操作的数据结构库，主要用于处理和分析结构化数据。该库在设计和功能上受到Python中流行的pandas库的启发，并且其API设计与之类似，使得熟悉pandas的用户可以...
danfo.js教程：JavaScript版Python Pandas库快速入门
资源摘要信息: "danfojs-tutorial" 是一个存储库，它的主要内容是关于一个名为 "danfo.js" 的JavaScript库的使用演示。danfo.js 被设计为一种类似于Python中著名的数据处理库Pandas的JavaScript版本。它旨在为处理和...
forecastico:使用meteor.js和brain.js进行股票预测在线应用
04-30
Forecastico Forecastico是用于股票市场预测的应用... 我还要说已经安装了Node.js和Meteor，然后： git clone https://github.com/cristianexer/forecastico.git cd forecastico meteor 这将是基本的东西。 如有任
js中的new file_深受 Pandas 启发的 JavaScript 开源库 — Danfo.js 现已推出！
weixin_39996035的博客
12-01 356
特邀博文 / 独立研究员 Rising Odegua 与来自 Data Science Nigeria 的 Stephen OniDanfo.js 是个 JavaScript 开源库，提供了高性能、直观易用的数据结构，支持结构化数据的操作和处理。Danfo.js 深受 Python Pandas 库的启发，并提供了类似的接口/API。因此熟悉 Pandas API 且了解 JavaSc...
danfojs-tutorial:这是一个包含danfo.js小型演示的存储库。 danfo.js是一个开放源代码JavaScript库，可提供高性能，直观且易于使用的数据结构来处理和处理结构化数据
04-30
Danfo.js-Python Pandas，例如JavaScript中的Library 观看视频 或点击下面的图片 跟着我
Danfo.js专题 - 附：Dnotebook（Danfo Notebook）单机资源与汉化文档
jclee95的个人博客
02-04 1430
Dnotebook
Danfo.js：强大的JavaScript数据分析工具包
gitblog_00263的博客
10-11 1292
Danfo.js：强大的JavaScript数据分析工具包 danfojs 项目地址: https://gitcode.com/gh_mirrors/dan/danfojs ...
js加载man_深受 Pandas 启发的 JavaScript 开源库 — Danfo.js 现已推出！
weixin_39862716的博客
10-17 222
磐创AI分享来源 |TensorFlow作者 | 独立研究员 Rising Odegua 与来自 Data Science Nigeria 的 Stephen Oni【导读】Danfo.js 是个 JavaScript 开源库，提供了高性能、直观易用的数据结构，支持结构化数据的操作和处理。Danfo.js 深受 Python Pandas 库的启发，并提供了类似的接口/API...
掌握数据处理新利器——Danfo.js
gitblog_00098的博客
05-11 447
掌握数据处理新利器——Danfo.js danfojs Danfo.js is an open source, JavaScript library providing high performance, intuitive, and easy to use data structures for manipulatin...
Danfo.js 使用教程：高性能JavaScript数据处理库
最新发布
gitblog_00291的博客
10-11 664
Danfo.js 使用教程：高性能JavaScript数据处理库 danfojs 项目地址: https://gitcode.com/gh_mirrors/dan/danfojs ...
拆分js文件_JavaScript 版的 Pandas - Danfo.js
weixin_28884811的博客
12-31 518
Danfo.js 是一款开源的 Javascript 库。提供了高性能、直观、易用的数据结构，便于用户维护和处理结构化数据。Danfo.js 深受 Pandas(Python 库)的启发，并提供了相似的 API，因此熟悉 Pandas 的用户可以轻松上手。主要特性Dano.js 很快。它建立在 Tensorflow.js 上，支持现成的张量。您可以方便的将 Danfo.js 数据结构转换为量。很好...
使用 Danfo.js 构建数据驱动应用（六）
龙哥盟
07-31 445
根据Stack Overflow 2020 开发者调查），JavaScript（也称为JS）是世界上最常见的编程语言，大约有 70%的开发人员在某种任务中使用它。这一统计数据并不令人意外，因为在调查进行之前的许多年里，JavaScript 一直是最受欢迎的语言。为什么会这样有很多原因，我们将在这里列出其中一些：它在最常见和最常用的平台上运行——浏览器。许多有用的框架如 Node.js、React 和 Angular 都是围绕它构建的。它是多才多艺的——即它可以用于前端和后端应用。
使用 Danfo.js 构建数据驱动应用（四）
龙哥盟
07-31 337
在本章中，我们看到了如何创建一个无代码环境，您可以在其中上传数据，然后立即开始处理和进行数据分析。我们还看到了如何将 Danfo.js 中的每个DataFrame方法转换为 React 组件。这使得能够将所有 Danfo.js 方法转换为 React 组件，从而为 Danfo.js 创建一个 React 组件库。此外，我们还看到了如何设计应用程序的流程以及如何在 React 中管理状态。即使创建的一些状态是多余的，这也是您贡献和更新应用程序以使其更加健壮的机会。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

jcLee95

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值