DataFrame.query
Query the DataFrame by the result of a logical comparison or boolean mask.
danfo.DataFrame.query(kwargs)
Parameters
Type
Description
Default
kwargs
Object
{
condition: A logical boolean mask,
column : str, name of the column
is: Logical operator, one of ">", "<", ">=", "<=", and. "=="
to: Int, Float, Str. Value to compare against,
inplace: boolean. true
false. Whether to perform operation to the original Object or create a new one.
}

Examples

Query a DataFrame using a boolean mask

Querying by a boolean condition is supported from v0.3.0 and above.
1
const dfd = require("danfojs-node")
2
3
let data = {
4
"A": ["Ng", "Yu", "Mo", "Ng"],
5
"B": [34, 4, 5, 6],
6
"C": [20, 20, 30, 40]
7
}
8
let df = new dfd.DataFrame(data)
9
df.print()
10
let query_df = df.query(df["B"].gt(5))
11
query_df.print() //after query
Copied!
1
╔════════════╤═══════════════════╤═══════════════════╤═══════════════════╗
2
║ │ A │ B │ C ║
3
╟────────────┼───────────────────┼───────────────────┼───────────────────╢
4
║ 0 │ Ng │ 34 │ 20 ║
5
╟────────────┼───────────────────┼───────────────────┼───────────────────╢
6
║ 1 │ Yu │ 4 │ 20 ║
7
╟────────────┼───────────────────┼───────────────────┼───────────────────╢
8
║ 2 │ Mo │ 5 │ 30 ║
9
╟────────────┼───────────────────┼───────────────────┼───────────────────╢
10
║ 3 │ Ng │ 6 │ 40 ║
11
╚════════════╧═══════════════════╧═══════════════════╧═══════════════════╝
12
13
╔════════════╤═══════════════════╤═══════════════════╤═══════════════════╗
14
║ │ A │ B │ C ║
15
╟────────────┼───────────────────┼───────────────────┼───────────────────╢
16
║ 0 │ Ng │ 34 │ 20 ║
17
╟────────────┼───────────────────┼───────────────────┼───────────────────╢
18
║ 3 │ Ng │ 6 │ 40 ║
19
╚════════════╧═══════════════════╧═══════════════════╧═══════════════════╝
Copied!
It also supports condition chaining as long as the final boolean mask is the same length as the DataFrame rows. For example in the following code, we use multiple chaining conditions:
1
const dfd = require("danfojs-node")
2
3
let data = {
4
"A": ["Ng", "Yu", "Mo", "Ng"],
5
"B": [34, 4, 5, 6],
6
"C": [20, 20, 30, 40]
7
}
8
let df = new dfd.DataFrame(data)
9
df.print()
10
11
let query_df = df.query(df["B"].gt(5).and(df["C"].lt(40)))
12
query_df.print() //after query
Copied!
1
// output
2
╔════════════╤═══════════════════╤═══════════════════╤═══════════════════╗
3
║ │ A │ B │ C ║
4
╟────────────┼───────────────────┼───────────────────┼───────────────────╢
5
║ 0 │ Ng │ 34 │ 20 ║
6
╟────────────┼───────────────────┼───────────────────┼───────────────────╢
7
║ 1 │ Yu │ 4 │ 20 ║
8
╟────────────┼───────────────────┼───────────────────┼───────────────────╢
9
║ 2 │ Mo │ 5 │ 30 ║
10
╟────────────┼───────────────────┼───────────────────┼───────────────────╢
11
║ 3 │ Ng │ 6 │ 40 ║
12
╚════════════╧═══════════════════╧═══════════════════╧═══════════════════╝
13
14
╔════════════╤═══════════════════╤═══════════════════╤═══════════════════╗
15
║ │ A │ B │ C ║
16
╟────────────┼───────────────────┼───────────────────┼───────────────────╢
17
║ 0 │ Ng │ 34 │ 20 ║
18
╚════════════╧═══════════════════╧═══════════════════╧═══════════════════╝
Copied!

Query a DataFrame using logical operators

This is only supported in older versions. That is versions lower than v1.0.0
To query a DataFrame, you can specify the column to use, the logical operator (">", "<", ">=", "<=", and. "=="), and the value to compare against.
Node
Browser
1
const dfd = require("danfojs-node")
2
3
let data = {"A": [30, 1, 2, 3],
4
"B": [34, 4, 5, 6],
5
"C": [20, 20, 30, 40]}
6
7
let cols = ["A", "B", "C"]
8
let df = new dfd.DataFrame(data, { columns: cols })
9
df.print() //before query
10
11
let query_df = df.query({ "column": "B", "is": ">", "to": 5 })
12
query_df.print() //after query
Copied!
1
Copied!
Output
1
//before query
2
╔═══╤═══════════════════╤═══════════════════╤═══════════════════╗
3
║ │ A │ B │ C ║
4
╟───┼───────────────────┼───────────────────┼───────────────────╢
5
║ 0 │ 1 │ 2 │ 3 ║
6
╟───┼───────────────────┼───────────────────┼───────────────────╢
7
║ 1 │ 4 │ 5 │ 6 ║
8
╟───┼───────────────────┼───────────────────┼───────────────────╢
9
║ 2 │ 20 │ 30 │ 40 ║
10
╟───┼───────────────────┼───────────────────┼───────────────────╢
11
║ 3 │ 39 │ 89 │ 78 ║
12
╚═══╧═══════════════════╧═══════════════════╧═══════════════════╝
13
14
//after query
15
╔═══╤═══════════════════╤═══════════════════╤═══════════════════╗
16
║ │ A │ B │ C ║
17
╟───┼───────────────────┼───────────────────┼───────────────────╢
18
║ 2 │ 20 │ 30 │ 40 ║
19
╟───┼───────────────────┼───────────────────┼───────────────────╢
20
║ 3 │ 39 │ 89 │ 78 ║
21
╚═══╧═══════════════════╧═══════════════════╧═══════════════════╝
Copied!

Query by a string column in a DataFrame

This is only supported in older versions. That is versions lower than v1.0.0
The query method also works on string columns.
Node
Browser
1
const dfd = require("danfojs-node")
2
let data = {"A": ["Ng", "Yu", "Mo", "Ng"],
3
"B": [34, 4, 5, 6],
4
"C": [20, 20, 30, 40]}
5
6
let df = new dfd.DataFrame(data)
7
8
df.print()
9
10
let query_df = df.query({ column: "A", is: "==", to: "Ng"})
11
query_df.print() //after query
Copied!
1
Copied!
Output
1
╔═══╤═══════════════════╤═══════════════════╤═══════════════════╗
2
║ │ A │ B │ C ║
3
╟───┼───────────────────┼───────────────────┼───────────────────╢
4
║ 0 │ Ng │ 34 │ 20 ║
5
╟───┼───────────────────┼───────────────────┼───────────────────╢
6
║ 1 │ Yu │ 4 │ 20 ║
7
╟───┼───────────────────┼───────────────────┼───────────────────╢
8
║ 2 │ Mo │ 5 │ 30 ║
9
╟───┼───────────────────┼───────────────────┼───────────────────╢
10
║ 3 │ Ng │ 6 │ 40 ║
11
╚═══╧═══════════════════╧═══════════════════╧═══════════════════╝
12
13
//after query
14
15
╔═══╤═══════════════════╤═══════════════════╤═══════════════════╗
16
║ │ A │ B │ C ║
17
╟───┼───────────────────┼───────────────────┼───────────────────╢
18
║ 0 │ Ng │ 34 │ 20 ║
19
╟───┼───────────────────┼───────────────────┼───────────────────╢
20
║ 3 │ Ng │ 6 │ 40 ║
21
╚═══╧═══════════════════╧═══════════════════╧═══════════════════╝
Copied!