데이터프레임
지금까지 보았듯이 누셸은 데이터 작업을 최우선으로 합니다. 목록과 테이블은 여러 작업을 수행하거나 데이터를 쉽게 찾기 위해 값을 순환하는 데 도움이 됩니다. 그러나 행 기반 데이터 레이아웃이 데이터를 처리하는 가장 효율적인 방법이 아닌 특정 작업이 있으며, 특히 매우 큰 파일로 작업할 때 그렇습니다. 큰 데이터 세트를 사용하는 group-by 또는 join과 같은 작업은 메모리 측면에서 비용이 많이 들 수 있으며 적절한 데이터 형식을 사용하지 않으면 계산 시간이 길어질 수 있습니다.
이러한 이유로 DataFrame 구조가 누셸에 도입되었습니다. DataFrame은 Apache Arrow 사양을 기반으로 데이터를 열 형식으로 저장하고 Polars를 모터로 사용하여 매우 빠른 열 작업을 수행합니다.
이 콤보가 얼마나 빠를 수 있는지, 그리고 데이터 작업을 더 쉽고 안정적으로 만들 수 있는지 궁금할 것입니다. 이러한 이유로 이 장에서는 데이터 처리 시 수행되는 일반적인 작업에 대한 벤치마크를 제시하는 것으로 시작하겠습니다.
벤치마크 비교
이 작은 벤치마크 연습에서는 네이티브 누셸 명령, 데이터프레임 누셸 명령 및 Python Pandas 명령을 비교합니다. 당분간 Dataframe 명령에 너무 많은 주의를 기울이지 마십시오. 이 페이지의 뒷부분에서 설명합니다.
시스템 세부 정보
이 섹션에 제시된 벤치마크는 M1 pro 프로세서와 32GB RAM이 장착된 Macbook을 사용하여 실행되었습니다. 모든 예제는 nu_plugin_polars 0.97을 사용하여 누셸 버전 0.97에서 실행되었습니다.
파일 정보
벤치마크에 사용할 파일은 뉴질랜드 비즈니스 인구 통계 데이터 세트입니다. 이 테스트를 따라하고 싶다면 자유롭게 다운로드하십시오.
데이터 세트에는 5개의 열과 5,429,252개의 행이 있습니다. polars store-ls 명령을 사용하여 확인할 수 있습니다.
let df_0 = polars open --eager Data7602DescendingYearOrder.csv
polars store-ls | select key type columns rows estimated_size
# => ╭──────────────────────────────────────┬───────────┬─────────┬─────────┬────────────────╮
# => │ key │ type │ columns │ rows │ estimated_size │
# => ├──────────────────────────────────────┼───────────┼─────────┼─────────┼────────────────┤
# => │ b2519dac-3b64-4e5d-a0d7-24bde9052dc7 │ DataFrame │ 5 │ 5429252 │ 184.5 MB │
# => ╰──────────────────────────────────────┴───────────┴─────────┴─────────┴────────────────╯팁
누셸 0.97부터 polars open은 열성 데이터프레임 대신 지연 데이터프레임으로 열립니다. 열성 데이터프레임으로 열려면 --eager 플래그를 사용하십시오.
first를 사용하여 파일의 첫 번째 줄을 볼 수 있습니다.
$df_0 | polars first
# => ╭───┬──────────┬─────────┬──────┬───────────┬──────────╮
# => │ # │ anzsic06 │ Area │ year │ geo_count │ ec_count │
# => ├───┼──────────┼─────────┼──────┼───────────┼──────────┤
# => │ 0 │ A │ A100100 │ 2000 │ 96 │ 130 │
# => ╰───┴──────────┴─────────┴──────┴───────────┴──────────╯...그리고 마지막으로 추론된 데이터 형식을 알 수 있습니다.
$df_0 | polars schema
# => ╭───────────┬─────╮
# => │ anzsic06 │ str │
# => │ Area │ str │
# => │ year │ i64 │
# => │ geo_count │ i64 │
# => │ ec_count │ i64 │
# => ╰───────────┴─────╯Group-by 비교
더 통계적으로 정확한 타이밍을 출력하려면 std bench 명령을 로드하고 사용하겠습니다.
use std/bench데이터를 연도별로 그룹화하고 geo_count 열을 합산할 것입니다.
먼저 네이티브 누셸 명령 파이프라인의 성능을 측정해 보겠습니다.
bench -n 10 --pretty {
open 'Data7602DescendingYearOrder.csv'
| group-by year --to-table
| update items {|i|
$i.items.geo_count
| math sum
}
}
# => 3sec 268ms +/- 50ms따라서 이 집계를 수행하는 데 3.3초가 걸립니다.
pandas에서 동일한 작업을 시도해 보겠습니다.
('import pandas as pd
df = pd.read_csv("Data7602DescendingYearOrder.csv")
res = df.groupby("year")["geo_count"].sum()
print(res)'
| save load.py -f)그리고 벤치마크 결과는 다음과 같습니다.
bench -n 10 --pretty {
python load.py | complete | null
}
# => 1sec 322ms +/- 6ms나쁘지 않습니다. Pandas는 누셸보다 2.6배 빠르게 처리했습니다. 그리고 더 큰 파일의 경우 Pandas의 우위가 여기서 증가해야 합니다.
비교를 마치기 위해 누셸 데이터프레임을 시도해 보겠습니다. 올바른 비교를 하고 있는지 확인하기 위해 모든 작업을 하나의 nu 파일에 넣을 것입니다.
( 'polars open Data7602DescendingYearOrder.csv
| polars group-by year
| polars agg (polars col geo_count | polars sum)
| polars collect'
| save load.nu -f )그리고 데이터프레임과의 벤치마크(정직한 비교를 위해 각 테스트에 대해 새로운 누셸 및 polars 인스턴스를 로드하는 것과 함께)는 다음과 같습니다.
bench -n 10 --pretty {
nu load.nu | complete | null
}
# => 135ms +/- 4mspolars 데이터프레임 플러그인은 python을 사용하는 pandas보다 10배 빠르게 작업을 완료했습니다. 대단하지 않습니까?
보시다시피 누셸의 polars 플러그인은 polars 자체처럼 성능이 뛰어납니다. 누셸 명령 및 파이프라인과 결합하면 터미널을 떠나지 않고도 정교한 분석을 수행할 수 있습니다.
벤치마킹 중에 사용한 데이터프레임에서 캐시를 정리하겠습니다. 이를 위해 polars를 중지하겠습니다. 다음 명령을 실행하면 플러그인의 새 인스턴스를 시작합니다.
plugin stop polars데이터프레임 작업
Dataframe 명령으로 할 수 있는 일을 살짝 본 후 이제 테스트를 시작할 시간입니다. 시작하려면 예제와 함께 사용할 샘플 데이터프레임이 될 샘플 CSV 파일을 만들어 보겠습니다. 좋아하는 파일 편집기에서 다음 줄을 붙여넣어 샘플 CSV 파일을 만듭니다.
("int_1,int_2,float_1,float_2,first,second,third,word
1,11,0.1,1.0,a,b,c,first
2,12,0.2,1.0,a,b,c,second
3,13,0.3,2.0,a,b,c,third
4,14,0.4,3.0,b,a,c,second
0,15,0.5,4.0,b,a,a,third
6,16,0.6,5.0,b,a,a,second
7,17,0.7,6.0,b,c,a,third
8,18,0.8,7.0,c,c,b,eight
9,19,0.9,8.0,c,c,b,ninth
0,10,0.0,9.0,c,c,b,ninth"
| save --raw --force test_small.csv)파일을 저장하고 원하는 대로 이름을 지정하십시오. 이 예제에서는 파일을 test_small.csv라고 합니다.
이제 해당 파일을 데이터프레임으로 읽으려면 다음과 같이 polars open 명령을 사용하십시오.
let df_1 = polars open --eager test_small.csv이렇게 하면 방금 만든 데이터를 보유하는 $df_1 값이 메모리에 생성됩니다.
팁
polars open 명령은 csv, tsv, parquet, json(l), arrow 및 avro 형식의 파일을 읽을 수 있습니다.
메모리에 저장된 모든 데이터프레임을 보려면 다음을 사용할 수 있습니다.
polars store-ls | select key type columns rows estimated_size
# => ╭──────────────────────────────────────┬───────────┬─────────┬──────┬────────────────╮
# => │ key │ type │ columns │ rows │ estimated_size │
# => ├──────────────────────────────────────┼───────────┼─────────┼──────┼────────────────┤
# => │ e780af47-c106-49eb-b38d-d42d3946d66e │ DataFrame │ 8 │ 10 │ 403 B │
# => ╰──────────────────────────────────────┴───────────┴─────────┴──────┴────────────────╯보시다시피 명령은 생성된 데이터프레임과 함께 기본 정보를 보여줍니다.
그리고 로드된 데이터프레임의 미리보기를 보려면 데이터프레임 변수를 스트림으로 보낼 수 있습니다.
$df_1
# => ╭───┬───────┬───────┬─────────┬─────────┬───────┬────────┬───────┬────────╮
# => │ # │ int_1 │ int_2 │ float_1 │ float_2 │ first │ second │ third │ word │
# => ├───┼───────┼───────┼─────────┼─────────┼───────┼────────┼───────┼────────┤
# => │ 0 │ 1 │ 11 │ 0.10 │ 1.00 │ a │ b │ c │ first │
# => │ 1 │ 2 │ 12 │ 0.20 │ 1.00 │ a │ b │ c │ second │
# => │ 2 │ 3 │ 13 │ 0.30 │ 2.00 │ a │ b │ c │ third │
# => │ 3 │ 4 │ 14 │ 0.40 │ 3.00 │ b │ a │ c │ second │
# => │ 4 │ 0 │ 15 │ 0.50 │ 4.00 │ b │ a │ a │ third │
# => │ 5 │ 6 │ 16 │ 0.60 │ 5.00 │ b │ a │ a │ second │
# => │ 6 │ 7 │ 17 │ 0.70 │ 6.00 │ b │ c │ a │ third │
# => │ 7 │ 8 │ 18 │ 0.80 │ 7.00 │ c │ c │ b │ eight │
# => │ 8 │ 9 │ 19 │ 0.90 │ 8.00 │ c │ c │ b │ ninth │
# => │ 9 │ 0 │ 10 │ 0.00 │ 9.00 │ c │ c │ b │ ninth │
# => ╰───┴───────┴───────┴─────────┴─────────┴───────┴────────┴───────┴────────╯메모리에 데이터프레임이 있으면 DataFrame으로 열 작업을 시작할 수 있습니다.
팁
사용 가능한 모든 데이터프레임 명령을 보려면 scope commands | where category =~ dataframe을 사용할 수 있습니다.
기본 집계
데이터프레임에 대한 기본 집계부터 시작하겠습니다. aggregate 명령을 사용하여 df에 있는 모든 열을 합산해 보겠습니다.
$df_1 | polars sum | polars collect
# => ╭───┬───────┬───────┬─────────┬─────────┬───────┬────────┬───────┬──────╮
# => │ # │ int_1 │ int_2 │ float_1 │ float_2 │ first │ second │ third │ word │
# => ├───┼───────┼───────┼─────────┼─────────┼───────┼────────┼───────┼──────┤
# => │ 0 │ 40 │ 145 │ 4.50 │ 46.00 │ │ │ │ │
# => ╰───┴───────┴───────┴─────────┴─────────┴───────┴────────┴───────┴──────╯보시다시피 집계 함수는 합계가 의미 있는 열에 대해 합계를 계산합니다. 텍스트 열을 필터링하려면 polars select 명령을 사용하여 원하는 열을 선택할 수 있습니다.
$df_1 | polars sum | polars select int_1 int_2 float_1 float_2 | polars collect
# => ╭───┬───────┬───────┬─────────┬─────────╮
# => │ # │ int_1 │ int_2 │ float_1 │ float_2 │
# => ├───┼───────┼───────┼─────────┼─────────┤
# => │ 0 │ 40 │ 145 │ 4.50 │ 46.00 │
# => ╰───┴───────┴───────┴─────────┴─────────╯다른 누셸 변수를 저장하는 것처럼 이 집계 결과를 저장할 수도 있습니다.
let res = $df_1 | polars sum | polars select int_1 int_2 float_1 float_2팁
let res = !!를 입력하고 Enter 키를 누릅니다. 그러면 이전에 실행한 명령이 자동 완성됩니다. =와 !! 사이의 공백에 유의하십시오.
이제 메모리에 두 개의 데이터프레임이 저장되었습니다.
polars store-ls | select key type columns rows estimated_size
╭──────────────────────────────────────┬───────────┬─────────┬──────┬────────────────╮
│ key │ type │ columns │ rows │ estimated_size │
├──────────────────────────────────────┼───────────┼─────────┼──────┼────────────────┤
│ e780af47-c106-49eb-b38d-d42d3946d66e │ DataFrame │ 8 │ 10 │ 403 B │
│ 3146f4c1-f2a0-475b-a623-7375c1fdb4a7 │ DataFrame │ 4 │ 1 │ 32 B │
╰──────────────────────────────────────┴───────────┴─────────┴──────┴────────────────╯정말 멋지지 않습니까?
데이터프레임에 대한 여러 집계를 수행하여 데이터프레임에서 기본 정보를 추출하고 새로운 데이터프레임에 대한 기본 데이터 분석을 수행할 수 있습니다.
데이터프레임 조인
열을 참조로 사용하여 두 데이터프레임을 조인할 수도 있습니다. 미니 데이터프레임을 다른 미니 데이터프레임과 조인할 것입니다. 이 줄을 다른 파일에 복사하고 해당 데이터프레임을 만듭니다(이 예제에서는 test_small_a.csv라고 함).
"int_1,int_2,float_1,float_2,first
9,14,0.4,3.0,a
8,13,0.3,2.0,a
7,12,0.2,1.0,a
6,11,0.1,0.0,b"
| save --raw --force test_small_a.csvpolars open 명령을 사용하여 새 변수를 만듭니다.
let df_2 = polars open --eager test_small_a.csv이제 두 번째 데이터프레임이 메모리에 로드되었으므로 왼쪽 데이터프레임의 int_1 열과 오른쪽 데이터프레임의 int_1 열을 사용하여 조인할 수 있습니다.
$df_1 | polars join $df_2 int_1 int_1
# => ╭───┬───────┬───────┬─────────┬─────────┬───────┬────────┬───────┬────────┬─────────┬───────────┬───────────┬─────────╮
# => │ # │ int_1 │ int_2 │ float_1 │ float_2 │ first │ second │ third │ word │ int_2_x │ float_1_x │ float_2_x │ first_x │
# => ├───┼───────┼───────┼─────────┼─────────┼───────┼────────┼───────┼────────┼─────────┼───────────┼───────────┼─────────┤
# => │ 0 │ 6 │ 16 │ 0.60 │ 5.00 │ b │ a │ a │ second │ 11 │ 0.10 │ 0.00 │ b │
# => │ 1 │ 7 │ 17 │ 0.70 │ 6.00 │ b │ c │ a │ third │ 12 │ 0.20 │ 1.00 │ a │
# => │ 2 │ 8 │ 18 │ 0.80 │ 7.00 │ c │ c │ b │ eight │ 13 │ 0.30 │ 2.00 │ a │
# => │ 3 │ 9 │ 19 │ 0.90 │ 8.00 │ c │ c │ b │ ninth │ 14 │ 0.40 │ 3.00 │ a │
# => ╰───┴───────┴───────┴─────────┴─────────┴───────┴────────┴───────┴────────┴─────────┴───────────┴───────────┴─────────╯팁
Nu에서 명령에 여러 값을 기대하는 여러 인수가 있는 경우 대괄호 []를 사용하여 해당 값을 묶습니다. polars join의 경우 동일한 유형을 가진 한 여러 열에서 조인할 수 있습니다.
예시:
$df_1 | polars join $df_2 [int_1 first] [int_1 first]
# => ╭───┬───────┬───────┬─────────┬─────────┬───────┬────────┬───────┬────────┬─────────┬───────────┬───────────╮
# => │ # │ int_1 │ int_2 │ float_1 │ float_2 │ first │ second │ third │ word │ int_2_x │ float_1_x │ float_2_x │
# => ├───┼───────┼───────┼─────────┼─────────┼───────┼────────┼───────┼────────┼─────────┼───────────┼───────────┤
# => │ 0 │ 6 │ 16 │ 0.60 │ 5.00 │ b │ a │ a │ second │ 11 │ 0.10 │ 0.00 │
# => ╰───┴───────┴───────┴─────────┴─────────┴───────┴────────┴───────┴────────┴─────────┴───────────┴───────────╯기본적으로 join 명령은 내부 조인을 수행하므로 두 데이터프레임이 동일한 값을 공유하는 행을 유지합니다. 왼쪽 조인을 선택하여 왼쪽 데이터프레임의 누락된 행을 유지할 수 있습니다. 추가 작업을 위해 이 결과를 저장할 수도 있습니다.
데이터프레임 그룹별
데이터프레임으로 수행할 수 있는 가장 강력한 작업 중 하나는 polars group-by입니다. 이 명령을 사용하면 그룹화 기준에 따라 집계 작업을 수행할 수 있습니다. 누셸에서 GroupBy는 여러 집계를 위해 저장하고 재사용할 수 있는 개체 유형입니다. 그룹화 쌍을 만드는 것이 그룹별 작업을 수행하는 동안 가장 비용이 많이 드는 작업이고 동일한 그룹 조건으로 여러 작업을 계획하는 경우 반복할 필요가 없으므로 매우 편리합니다.
GroupBy 개체를 만들려면 polars_group-by 명령을 사용하기만 하면 됩니다.
let group = $df_1 | polars group-by first
$group
# => ╭─────────────┬──────────────────────────────────────────────╮
# => │ LazyGroupBy │ apply aggregation to complete execution plan │
# => ╰─────────────┴──────────────────────────────────────────────╯GroupBy 개체를 인쇄할 때 집계를 추가하여 완료되기를 기다리는 백그라운드에서 지연 작업임을 알 수 있습니다. GroupBy를 사용하여 열에 대한 집계를 만들 수 있습니다.
$group | polars agg (polars col int_1 | polars sum)
# => ╭────────────────┬───────────────────────────────────────────────────────────────────────────────────────╮
# => │ plan │ AGGREGATE │
# => │ │ [col("int_1").sum()] BY [col("first")] FROM │
# => │ │ DF ["int_1", "int_2", "float_1", "float_2"]; PROJECT */8 COLUMNS; SELECTION: "None" │
# => │ optimized_plan │ AGGREGATE │
# => │ │ [col("int_1").sum()] BY [col("first")] FROM │
# => │ │ DF ["int_1", "int_2", "float_1", "float_2"]; PROJECT 2/8 COLUMNS; SELECTION: "None" │
# => ╰────────────────┴───────────────────────────────────────────────────────────────────────────────────────╯또는 동일하거나 다른 열에 대해 여러 집계를 정의할 수 있습니다.
$group
| polars agg [
(polars col int_1 | polars n-unique)
(polars col int_2 | polars min)
(polars col float_1 | polars sum)
(polars col float_2 | polars count)
] | polars sort-by first
# => ╭────────────────┬─────────────────────────────────────────────────────────────────────────────────────────────────────╮
# => │ plan │ SORT BY [col("first")] │
# => │ │ AGGREGATE │
# => │ │ [col("int_1").n_unique(), col("int_2").min(), col("float_1") │
# => │ │ .sum(), col("float_2").count()] BY [col("first")] FROM │
# => │ │ DF ["int_1", "int_2", "float_1", "float_2 │
# => │ │ "]; PROJECT */8 COLUMNS; SELECTION: "None" │
# => │ optimized_plan │ SORT BY [col("first")] │
# => │ │ AGGREGATE │
# => │ │ [col("int_1").n_unique(), col("int_2").min(), col("float_1") │
# => │ │ .sum(), col("float_2").count()] BY [col("first")] FROM │
# => │ │ DF ["int_1", "int_2", "float_1", "float_2 │
# => │ │ "]; PROJECT 5/8 COLUMNS; SELECTION: "None" │
# => ╰────────────────┴─────────────────────────────────────────────────────────────────────────────────────────────────────╯보시다시피 GroupBy 개체는 매우 강력한 변수이며 데이터 세트를 탐색하는 동안 메모리에 보관할 가치가 있습니다.
데이터프레임 만들기
정수, 십진수 또는 문자열과 같은 기본 누셸 기본형에서 데이터프레임을 구성할 수도 있습니다. polars into-df 명령을 사용하여 작은 데이터프레임을 만들어 보겠습니다.
let df_3 = [[a b]; [1 2] [3 4] [5 6]] | polars into-df
$df_3
# => ╭───┬───┬───╮
# => │ # │ a │ b │
# => ├───┼───┼───┤
# => │ 0 │ 1 │ 2 │
# => │ 1 │ 3 │ 4 │
# => │ 2 │ 5 │ 6 │
# => ╰───┴───┴───╯팁
현재 모든 누셸 기본형을 데이터프레임으로 변환할 수는 없습니다. 데이터프레임 기능이 성숙해짐에 따라 이는 앞으로 변경될 것입니다.
새 변수를 만들기 위해 데이터프레임에 열을 추가할 수 있습니다. 예로서 미니 데이터프레임 $df_3에 두 개의 열을 추가해 보겠습니다.
let df_4 = $df_3 | polars with-column $df_3.a --name a2 | polars with-column $df_3.a --name a3
$df_4
# => ╭───┬───┬───┬────┬────╮
# => │ # │ a │ b │ a2 │ a3 │
# => ├───┼───┼───┼────┼────┤
# => │ 0 │ 1 │ 2 │ 1 │ 1 │
# => │ 1 │ 3 │ 4 │ 3 │ 3 │
# => │ 2 │ 5 │ 6 │ 5 │ 5 │
# => ╰───┴───┴───┴────┴────╯누셸의 강력한 파이핑 구문을 사용하면 다른 데이터프레임에서 데이터를 가져와 추가하여 새 데이터프레임을 만들 수 있습니다. 이제 데이터프레임을 나열하면 총 5개의 데이터프레임이 표시됩니다.
polars store-ls | select key type columns rows estimated_size
# => ╭──────────────────────────────────────┬─────────────┬─────────┬──────┬────────────────╮
# => │ key │ type │ columns │ rows │ estimated_size │
# => ├──────────────────────────────────────┼─────────────┼─────────┼──────┼────────────────┤
# => │ e780af47-c106-49eb-b38d-d42d3946d66e │ DataFrame │ 8 │ 10 │ 403 B │
# => │ 3146f4c1-f2a0-475b-a623-7375c1fdb4a7 │ DataFrame │ 4 │ 1 │ 32 B │
# => │ 455a1483-e328-43e2-a354-35afa32803b9 │ DataFrame │ 5 │ 4 │ 132 B │
# => │ 0d8532a5-083b-4f78-8f66-b5e6b59dc449 │ LazyGroupBy │ │ │ │
# => │ 9504dfaf-4782-42d4-9110-9dae7c8fb95b │ DataFrame │ 2 │ 3 │ 48 B │
# => │ 37ab1bdc-e1fb-426d-8006-c3f974764a3d │ DataFrame │ 4 │ 3 │ 96 B │
# => ╰──────────────────────────────────────┴─────────────┴─────────┴──────┴────────────────╯데이터프레임으로 작업하는 동안 메모리가 어떻게 최적화되는지 언급하는 것이 중요하며, 이는 Apache Arrow와 Polars 덕분입니다. 매우 간단한 표현으로, 데이터프레임의 각 열은 Arrow Array이며, 데이터를 가능한 한 압축된 상태로 유지하기 위해 여러 메모리 사양을 사용합니다(Arrow 열 형식 확인). 다른 최적화 트릭은 가능한 경우 데이터프레임의 열이 데이터프레임 간에 공유되어 동일한 데이터에 대한 메모리 중복을 피한다는 사실입니다. 즉, 데이터프레임 $df_3과 $df_4는 polars into-df 명령을 사용하여 만든 동일한 두 열을 공유합니다. 이러한 이유로 데이터프레임의 열 값을 변경할 수 없습니다. 그러나 다른 열이나 데이터프레임의 데이터를 기반으로 새 열을 만들 수 있습니다.
시리즈 작업
시리즈는 데이터프레임의 구성 요소입니다. 각 시리즈는 동일한 데이터 유형을 가진 열을 나타내며, float, int 또는 string과 같은 다양한 유형의 여러 시리즈를 만들 수 있습니다.
polars into-df 명령을 사용하여 시리즈를 만드는 것으로 시리즈 탐색을 시작하겠습니다.
let df_5 = [9 8 4] | polars into-df
$df_5
# => ╭───┬───╮
# => │ # │ 0 │
# => ├───┼───┤
# => │ 0 │ 9 │
# => │ 1 │ 8 │
# => │ 2 │ 4 │
# => ╰───┴───╯정수 목록에서 새 시리즈를 만들었습니다(float 또는 string을 사용하여 동일한 작업을 수행할 수 있음).
시리즈에는 자체 기본 작업이 정의되어 있으며 다른 시리즈를 만드는 데 사용할 수 있습니다. 이전에 만든 열에 대한 일부 산술을 수행하여 새 시리즈를 만들어 보겠습니다.
let df_6 = $df_5 * 3 + 10
$df_6
# => ╭───┬────╮
# => │ # │ 0 │
# => ├───┼────┤
# => │ 0 │ 37 │
# => │ 1 │ 34 │
# => │ 2 │ 22 │
# => ╰───┴────╯이제 이전 변수에 대한 기본 작업을 수행하여 구성된 새 시리즈가 있습니다.
팁
메모리에 저장된 변수 수를 보려면 scope variables를 사용할 수 있습니다.
이전 시리즈의 이름을 기억하기 쉬운 이름으로 변경해 보겠습니다.
let df_7 = $df_6 | polars rename "0" memorable
$df_7
# => ╭───┬───────────╮
# => │ # │ memorable │
# => ├───┼───────────┤
# => │ 0 │ 37 │
# => │ 1 │ 34 │
# => │ 2 │ 22 │
# => ╰───┴───────────╯동일한 데이터 유형을 가진 한 두 시리즈로 기본 작업을 수행할 수도 있습니다.
$df_5 - $df_7
# => ╭───┬─────────────────╮
# => │ # │ sub_0_memorable │
# => ├───┼─────────────────┤
# => │ 0 │ -28 │
# => │ 1 │ -26 │
# => │ 2 │ -18 │
# => ╰───┴─────────────────╯그리고 이전에 정의된 데이터프레임에 추가할 수 있습니다.
let df_8 = $df_3 | polars with-column $df_5 --name new_col
$df_8
# => ╭───┬───┬───┬─────────╮
# => │ # │ a │ b │ new_col │
# => ├───┼───┼───┼─────────┤
# => │ 0 │ 1 │ 2 │ 9 │
# => │ 1 │ 3 │ 4 │ 8 │
# => │ 2 │ 5 │ 6 │ 4 │
# => ╰───┴───┴───┴─────────╯데이터프레임에 저장된 시리즈도 직접 사용할 수 있습니다. 예를 들어 a 및 b 열을 곱하여 새 시리즈를 만들 수 있습니다.
$df_8.a * $df_8.b
# => ╭───┬─────────╮
# => │ # │ mul_a_b │
# => ├───┼─────────┤
# => │ 0 │ 2 │
# => │ 1 │ 12 │
# => │ 2 │ 30 │
# => ╰───┴─────────╯그리고 새 열과 데이터프레임을 만들기 위해 파이핑을 시작할 수 있습니다.
let df_9 = $df_8 | polars with-column ($df_8.a * $df_8.b / $df_8.new_col) --name my_sum
$df_9
# => ╭───┬───┬───┬─────────┬────────╮
# => │ # │ a │ b │ new_col │ my_sum │
# => ├───┼───┼───┼─────────┼────────┤
# => │ 0 │ 1 │ 2 │ 9 │ 0 │
# => │ 1 │ 3 │ 4 │ 8 │ 1 │
# => │ 2 │ 5 │ 6 │ 4 │ 7 │
# => ╰───┴───┴───┴─────────┴────────╯누셸의 파이핑 시스템은 매우 흥미로운 워크플로를 만드는 데 도움이 될 수 있습니다.
시리즈 및 마스크
시리즈는 데이터프레임으로 작업할 때 또 다른 핵심 용도를 가지고 있으며, 부울 마스크를 만들 수 있다는 사실입니다. 등호 연산자를 사용하여 간단한 마스크를 만드는 것으로 시작하겠습니다.
let mask_0 = $df_5 == 8
$mask_0
# => ╭───┬───────╮
# => │ # │ 0 │
# => ├───┼───────┤
# => │ 0 │ false │
# => │ 1 │ true │
# => │ 2 │ false │
# => ╰───┴───────╯그리고 이 마스크를 사용하여 다음과 같이 데이터프레임을 필터링할 수 있습니다.
$df_9 | polars filter-with $mask_0
# => ╭───┬───┬───┬─────────┬────────╮
# => │ # │ a │ b │ new_col │ my_sum │
# => ├───┼───┼───┼─────────┼────────┤
# => │ 0 │ 3 │ 4 │ 8 │ 1 │
# => ╰───┴───┴───┴─────────┴────────╯이제 마스크가 true인 값만 있는 새 데이터프레임이 있습니다.
마스크는 누셸 목록에서도 만들 수 있습니다. 예를 들어:
let mask_1 = [true true false] | polars into-df
$df_9 | polars filter-with $mask_1
# => ╭───┬───┬───┬─────────┬────────╮
# => │ # │ a │ b │ new_col │ my_sum │
# => ├───┼───┼───┼─────────┼────────┤
# => │ 0 │ 1 │ 2 │ 9 │ 0 │
# => │ 1 │ 3 │ 4 │ 8 │ 1 │
# => ╰───┴───┴───┴─────────┴────────╯복잡한 마스크를 만들려면 AND가 있습니다.
$mask_0 and $mask_1
# => ╭───┬─────────╮
# => │ # │ and_0_0 │
# => ├───┼─────────┤
# => │ 0 │ false │
# => │ 1 │ true │
# => │ 2 │ false │
# => ╰───┴─────────╯그리고 OR 연산
$mask_0 or $mask_1
# => ╭───┬────────╮
# => │ # │ or_0_0 │
# => ├───┼────────┤
# => │ 0 │ true │
# => │ 1 │ true │
# => │ 2 │ false │
# => ╰───┴────────╯다른 시리즈에 일부 값이 있는지 확인하여 마스크를 만들 수도 있습니다. 만든 첫 번째 데이터프레임을 사용하여 다음과 같은 작업을 수행할 수 있습니다.
let mask_2 = $df_1 | polars col first | polars is-in [b c]
$mask_2
# => ╭──────────┬─────────────────────────╮
# => │ input │ [table 2 rows] │
# => │ function │ Boolean(IsIn) │
# => │ options │ FunctionOptions { ... } │
# => ╰──────────┴─────────────────────────╯그리고 이 새 마스크를 사용하여 데이터프레임을 필터링할 수 있습니다.
$df_1 | polars filter-with $mask_2
# => ╭───┬───────┬───────┬─────────┬─────────┬───────┬────────┬───────┬────────╮
# => │ # │ int_1 │ int_2 │ float_1 │ float_2 │ first │ second │ third │ word │
# => ├───┼───────┼───────┼─────────┼─────────┼───────┼────────┼───────┼────────┤
# => │ 0 │ 4 │ 14 │ 0.40 │ 3.00 │ b │ a │ c │ second │
# => │ 1 │ 0 │ 15 │ 0.50 │ 4.00 │ b │ a │ a │ third │
# => │ 2 │ 6 │ 16 │ 0.60 │ 5.00 │ b │ a │ a │ second │
# => │ 3 │ 7 │ 17 │ 0.70 │ 6.00 │ b │ c │ a │ third │
# => │ 4 │ 8 │ 18 │ 0.80 │ 7.00 │ c │ c │ b │ eight │
# => │ 5 │ 9 │ 19 │ 0.90 │ 8.00 │ c │ c │ b │ ninth │
# => │ 6 │ 0 │ 10 │ 0.00 │ 9.00 │ c │ c │ b │ ninth │
# => ╰───┴───────┴───────┴─────────┴─────────┴───────┴────────┴───────┴────────╯마스크로 수행할 수 있는 또 다른 작업은 시리즈에서 값을 설정하거나 바꾸는 것입니다. 예를 들어, first 열에서 값이 a와 같은 값을 변경할 수 있습니다.
$df_1 | polars get first | polars set new --mask ($df_1.first =~ a)
# => ╭───┬────────╮
# => │ # │ string │
# => ├───┼────────┤
# => │ 0 │ new │
# => │ 1 │ new │
# => │ 2 │ new │
# => │ 3 │ b │
# => │ 4 │ b │
# => │ 5 │ b │
# => │ 6 │ b │
# => │ 7 │ c │
# => │ 8 │ c │
# => │ 9 │ c │
# => ╰───┴────────╯인덱스로서의 시리즈
시리즈는 인덱스 목록으로 사용하여 데이터프레임을 필터링하는 방법으로도 사용할 수 있습니다. 예를 들어, 원래 데이터프레임에서 1, 4, 6행을 가져오고 싶다고 가정해 보겠습니다. 이를 염두에 두고 다음 명령을 사용하여 해당 정보를 추출할 수 있습니다.
let indices_0 = [1 4 6] | polars into-df
$df_1 | polars take $indices_0
# => ╭───┬───────┬───────┬─────────┬─────────┬───────┬────────┬───────┬────────╮
# => │ # │ int_1 │ int_2 │ float_1 │ float_2 │ first │ second │ third │ word │
# => ├───┼───────┼───────┼─────────┼─────────┼───────┼────────┼───────┼────────┤
# => │ 0 │ 2 │ 12 │ 0.20 │ 1.00 │ a │ b │ c │ second │
# => │ 1 │ 0 │ 15 │ 0.50 │ 4.00 │ b │ a │ a │ third │
# => │ 2 │ 7 │ 17 │ 0.70 │ 6.00 │ b │ c │ a │ third │
# => ╰───┴───────┴───────┴─────────┴─────────┴───────┴────────┴───────┴────────╯polars take 명령은 특히 다른 명령과 혼합할 때 매우 편리합니다. first 열에 대한 첫 번째 중복 요소의 모든 행을 추출하고 싶다고 가정해 보겠습니다. 이를 위해 다음 예제와 같이 polars arg-unique 명령을 사용할 수 있습니다.
let indices_1 = $df_1 | polars get first | polars arg-unique
$df_1 | polars take $indices_1
# => ╭───┬───────┬───────┬─────────┬─────────┬───────┬────────┬───────┬────────╮
# => │ # │ int_1 │ int_2 │ float_1 │ float_2 │ first │ second │ third │ word │
# => ├───┼───────┼───────┼─────────┼─────────┼───────┼────────┼───────┼────────┤
# => │ 0 │ 1 │ 11 │ 0.10 │ 1.00 │ a │ b │ c │ first │
# => │ 1 │ 4 │ 14 │ 0.40 │ 3.00 │ b │ a │ c │ second │
# => │ 2 │ 8 │ 18 │ 0.80 │ 7.00 │ c │ c │ b │ eight │
# => ╰───┴───────┴───────┴─────────┴─────────┴───────┴────────┴───────┴────────╯또는 특정 열을 사용하여 새 정렬된 데이터프레임을 만들려면 어떻게 해야 할까요? arg-sort를 사용하여 이를 달성할 수 있습니다. 다음 예제에서는 word 열별로 데이터프레임을 정렬할 수 있습니다.
팁
sort 명령을 사용하여 동일한 결과를 얻을 수 있습니다.
let indices_2 = $df_1 | polars get word | polars arg-sort
$df_1 | polars take $indices_2
# => ╭───┬───────┬───────┬─────────┬─────────┬───────┬────────┬───────┬────────╮
# => │ # │ int_1 │ int_2 │ float_1 │ float_2 │ first │ second │ third │ word │
# => ├───┼───────┼───────┼─────────┼─────────┼───────┼────────┼───────┼────────┤
# => │ 0 │ 8 │ 18 │ 0.80 │ 7.00 │ c │ c │ b │ eight │
# => │ 1 │ 1 │ 11 │ 0.10 │ 1.00 │ a │ b │ c │ first │
# => │ 2 │ 9 │ 19 │ 0.90 │ 8.00 │ c │ c │ b │ ninth │
# => │ 3 │ 0 │ 10 │ 0.00 │ 9.00 │ c │ c │ b │ ninth │
# => │ 4 │ 2 │ 12 │ 0.20 │ 1.00 │ a │ b │ c │ second │
# => │ 5 │ 4 │ 14 │ 0.40 │ 3.00 │ b │ a │ c │ second │
# => │ 6 │ 6 │ 16 │ 0.60 │ 5.00 │ b │ a │ a │ second │
# => │ 7 │ 3 │ 13 │ 0.30 │ 2.00 │ a │ b │ c │ third │
# => │ 8 │ 0 │ 15 │ 0.50 │ 4.00 │ b │ a │ a │ third │
# => │ 9 │ 7 │ 17 │ 0.70 │ 6.00 │ b │ c │ a │ third │
# => ╰───┴───────┴───────┴─────────┴─────────┴───────┴────────┴───────┴────────╯그리고 마지막으로 표시된 인덱스에 새 값을 설정하여 새 시리즈를 만들 수 있습니다. 다음 명령을 살펴보십시오.
let indices_3 = [0 2] | polars into-df
$df_1 | polars get int_1 | polars set-with-idx 123 --indices $indices_3
# => ╭───┬───────╮
# => │ # │ int_1 │
# => ├───┼───────┤
# => │ 0 │ 123 │
# => │ 1 │ 2 │
# => │ 2 │ 123 │
# => │ 3 │ 4 │
# => │ 4 │ 0 │
# => │ 5 │ 6 │
# => │ 6 │ 7 │
# => │ 7 │ 8 │
# => │ 8 │ 9 │
# => │ 9 │ 0 │
# => ╰───┴───────╯고유 값
시리즈로 수행할 수 있는 또 다른 작업은 목록이나 열에서 고유 값을 검색하는 것입니다. 이러한 작업을 테스트하기 위해 만든 첫 번째 데이터프레임을 다시 사용해 보겠습니다.
우리가 가진 첫 번째이자 가장 일반적인 작업은 value_counts입니다. 이 명령은 시리즈에 있는 고유 값의 개수를 계산합니다. 예를 들어 first 열에 있는 발생 횟수를 계산하는 데 사용할 수 있습니다.
$df_1 | polars get first | polars value-counts
# => ╭───┬───────┬───────╮
# => │ # │ first │ count │
# => ├───┼───────┼───────┤
# => │ 0 │ a │ 3 │
# => │ 1 │ b │ 4 │
# => │ 2 │ c │ 3 │
# => ╰───┴───────┴───────╯예상대로 이 명령은 더 많은 쿼리를 수행하는 데 사용할 수 있는 새 데이터프레임을 반환합니다.
시리즈 탐색을 계속하면서 다음으로 할 수 있는 일은 시리즈에서 고유한 값을 가져오는 것입니다.
$df_1 | polars get first | polars unique
# => ╭───┬───────╮
# => │ # │ first │
# => ├───┼───────┤
# => │ 0 │ a │
# => │ 1 │ b │
# => │ 2 │ c │
# => ╰───┴───────╯또는 데이터가 고유하거나 중복된 행을 필터링하는 데 사용할 수 있는 마스크를 얻을 수 있습니다. 예를 들어 word 열의 고유 값에 대한 행을 선택할 수 있습니다.
$df_1 | polars filter-with ($in.word | polars is-unique)
# => ╭───┬───────┬───────┬─────────┬─────────┬───────┬────────┬───────┬───────╮
# => │ # │ int_1 │ int_2 │ float_1 │ float_2 │ first │ second │ third │ word │
# => ├───┼───────┼───────┼─────────┼─────────┼───────┼────────┼───────┼───────┤
# => │ 0 │ 1 │ 11 │ 0.10 │ 1.00 │ a │ b │ c │ first │
# => │ 1 │ 8 │ 18 │ 0.80 │ 7.00 │ c │ c │ b │ eight │
# => ╰───┴───────┴───────┴─────────┴─────────┴───────┴────────┴───────┴───────╯또는 모든 중복된 것들
$df_1 | polars filter-with ($in.word | polars is-duplicated)
# => ╭───┬───────┬───────┬─────────┬─────────┬───────┬────────┬───────┬────────╮
# => │ # │ int_1 │ int_2 │ float_1 │ float_2 │ first │ second │ third │ word │
# => ├───┼───────┼───────┼─────────┼─────────┼───────┼────────┼───────┼────────┤
# => │ 0 │ 2 │ 12 │ 0.20 │ 1.00 │ a │ b │ c │ second │
# => │ 1 │ 3 │ 13 │ 0.30 │ 2.00 │ a │ b │ c │ third │
# => │ 2 │ 4 │ 14 │ 0.40 │ 3.00 │ b │ a │ c │ second │
# => │ 3 │ 0 │ 15 │ 0.50 │ 4.00 │ b │ a │ a │ third │
# => │ 4 │ 6 │ 16 │ 0.60 │ 5.00 │ b │ a │ a │ second │
# => │ 5 │ 7 │ 17 │ 0.70 │ 6.00 │ b │ c │ a │ third │
# => │ 6 │ 9 │ 19 │ 0.90 │ 8.00 │ c │ c │ b │ ninth │
# => │ 7 │ 0 │ 10 │ 0.00 │ 9.00 │ c │ c │ b │ ninth │
# => ╰───┴───────┴───────┴─────────┴─────────┴───────┴────────┴───────┴────────╯지연 데이터프레임
지연 데이터프레임은 논리적 계획을 만들어 데이터를 쿼리하는 방법입니다. 이 방법의 장점은 데이터를 추출할 때까지 계획이 평가되지 않는다는 것입니다. 이렇게 하면 집계, 조인 및 선택을 함께 연결하고 선택한 작업에 만족하면 데이터를 수집할 수 있습니다.
지연 데이터프레임의 작은 예제를 만들어 보겠습니다.
let lf_0 = [[a b]; [1 a] [2 b] [3 c] [4 d]] | polars into-lazy
$lf_0
# => ╭────────────────┬───────────────────────────────────────────────────────╮
# => │ plan │ DF ["a", "b"]; PROJECT */2 COLUMNS; SELECTION: "None" │
# => │ optimized_plan │ DF ["a", "b"]; PROJECT */2 COLUMNS; SELECTION: "None" │
# => ╰────────────────┴───────────────────────────────────────────────────────╯보시다시피 결과 데이터프레임은 아직 평가되지 않았으며 데이터에 대해 수행할 수 있는 명령어 집합으로 남아 있습니다. 해당 데이터프레임을 수집하면 다음 결과를 얻을 수 있습니다.
$lf_0 | polars collect
# => ╭───┬───┬───╮
# => │ # │ a │ b │
# => ├───┼───┼───┤
# => │ 0 │ 1 │ a │
# => │ 1 │ 2 │ b │
# => │ 2 │ 3 │ c │
# => │ 3 │ 4 │ d │
# => ╰───┴───┴───╯보시다시피 collect 명령은 계획을 실행하고 누셸 테이블을 만듭니다.
모든 데이터프레임 작업은 열성 또는 지연 데이터프레임과 함께 작동해야 합니다. 호환성을 위해 백그라운드에서 변환됩니다. 그러나 지연 작업의 이점을 활용하려면 지연 데이터프레임과 함께 지연 작업만 사용하는 것이 좋습니다.
모든 지연 데이터프레임 작업을 찾으려면 다음을 사용할 수 있습니다.
scope commands | where category =~ lazyframe | select name category usage지연 프레임이 정의되면 작업을 연결하기 시작할 수 있습니다. 예를 들어 다음과 같습니다.
$lf_0
| polars reverse
| polars with-column [
((polars col a) * 2 | polars as double_a)
((polars col a) / 2 | polars as half_a)
]
| polars collect
# => ╭───┬───┬───┬──────────┬────────╮
# => │ # │ a │ b │ double_a │ half_a │
# => ├───┼───┼───┼──────────┼────────┤
# => │ 0 │ 4 │ d │ 8 │ 2 │
# => │ 1 │ 3 │ c │ 6 │ 1 │
# => │ 2 │ 2 │ b │ 4 │ 1 │
# => │ 3 │ 1 │ a │ 2 │ 0 │
# => ╰───┴───┴───┴──────────┴────────╯팁
줄 버퍼 편집기(ctr + o)를 사용하여 쿼리를 쉽게 서식 지정할 수 있습니다.
이 쿼리는 지연 역순 명령을 사용하여 데이터프레임을 반전하고 polars with-column 명령을 사용하여 표현식을 사용하여 새 두 열을 만듭니다. 표현식은 지연 프레임에서 실행되는 작업을 정의하는 데 사용됩니다. 함께 사용하면 지연 명령이 데이터를 쿼리하는 데 사용하는 전체 명령어 집합을 만듭니다. 표현식을 생성하는 모든 명령을 나열하려면 다음을 사용할 수 있습니다.
scope commands | where category =~ expression | select name category usage이전 예제에서는 polars col 명령을 사용하여 a 열이 2로 곱해진 다음 double_a라는 이름으로 별칭이 지정됨을 나타냅니다. 경우에 따라 polars col 명령의 사용을 유추할 수 있습니다. 예를 들어 polars select 명령을 사용하면 문자열만 사용할 수 있습니다.
$lf_0 | polars select a | polars collect
# => ╭───┬───╮
# => │ # │ a │
# => ├───┼───┤
# => │ 0 │ 1 │
# => │ 1 │ 2 │
# => │ 2 │ 3 │
# => │ 3 │ 4 │
# => ╰───┴───╯또는 polars col 명령
$lf_0 | polars select (polars col a) | polars collect
# => ╭───┬───╮
# => │ # │ a │
# => ├───┼───┤
# => │ 0 │ 1 │
# => │ 1 │ 2 │
# => │ 2 │ 3 │
# => │ 3 │ 4 │
# => ╰───┴───╯더 복잡한 것을 시도하고 지연 데이터프레임에서 집계를 만들어 보겠습니다.
let lf_1 = [[name value]; [one 1] [two 2] [one 1] [two 3]] | polars into-lazy
$lf_1
| polars group-by name
| polars agg [
(polars col value | polars sum | polars as sum)
(polars col value | polars mean | polars as mean)
]
| polars collect
# => ╭───┬──────┬─────┬──────╮
# => │ # │ name │ sum │ mean │
# => ├───┼──────┼─────┼──────┤
# => │ 0 │ two │ 5 │ 2.50 │
# => │ 1 │ one │ 2 │ 1.00 │
# => ╰───┴──────┴─────┴──────╯그리고 수집되지 않은 지연 데이터프레임에서 조인할 수 있습니다. 결과 그룹을 원래 지연 프레임에 조인해 보겠습니다.
let lf_2 = [[name value]; [one 1] [two 2] [one 1] [two 3]] | polars into-lazy
let group = $lf_2
| polars group-by name
| polars agg [
(polars col value | polars sum | polars as sum)
(polars col value | polars mean | polars as mean)
]
$lf_2 | polars join $group name name | polars collect
# => ╭───┬──────┬───────┬─────┬──────╮
# => │ # │ name │ value │ sum │ mean │
# => ├───┼──────┼───────┼─────┼──────┤
# => │ 0 │ one │ 1 │ 2 │ 1.00 │
# => │ 1 │ two │ 2 │ 5 │ 2.50 │
# => │ 2 │ one │ 1 │ 2 │ 1.00 │
# => │ 3 │ two │ 3 │ 5 │ 2.50 │
# => ╰───┴──────┴───────┴─────┴──────╯보시다시피 지연 프레임은 유연한 구문을 사용하여 데이터를 쿼리할 수 있는 강력한 구성 요소이며, 매우 빠른 결과를 제공합니다.
데이터프레임 명령
지금까지 DataFrame 명령을 사용하여 수행할 수 있는 몇 가지 작업을 보았습니다. 그러나 지금까지 사용한 명령은 데이터 작업에 사용할 수 있는 모든 명령이 아니며 기능이 안정화됨에 따라 더 많은 명령이 추가될 것입니다.
다음 목록은 설명과 함께 사용 가능한 데이터프레임 명령을 보여주며, 가능한 경우 해당 누셸 명령도 보여줍니다.
경고
이 목록은 오래되었을 수 있습니다. 최신 명령 목록을 보려면 데이터프레임, 지연 프레임, 데이터프레임 또는 지연 프레임, 표현식 명령 범주를 참조하십시오.
| 명령 이름 | 적용 대상 | 설명 | 누셸 등가물 |
|---|---|---|---|
| polars agg | 데이터프레임 | 그룹별로 일련의 집계를 수행합니다. | math |
| polars agg-groups | 표현식 | agg_groups 표현식을 만듭니다. | |
| polars all-false | 데이터프레임 | 모든 값이 false이면 true를 반환합니다. | |
| polars all-true | 데이터프레임 | 모든 값이 true이면 true를 반환합니다. | all |
| polars append | 데이터프레임 | 새 데이터프레임을 추가합니다. | |
| polars arg-max | 데이터프레임 | 시리즈의 최대값에 대한 인덱스를 반환합니다. | |
| polars arg-min | 데이터프레임 | 시리즈의 최소값에 대한 인덱스를 반환합니다. | |
| polars arg-sort | 데이터프레임 | 정렬된 시리즈에 대한 인덱스를 반환합니다. | |
| polars arg-true | 데이터프레임 | 값이 true인 인덱스를 반환합니다. | |
| polars arg-unique | 데이터프레임 | 고유 값에 대한 인덱스를 반환합니다. | |
| polars arg-where | any | 표현식이 true인 인수를 반환하는 표현식을 만듭니다. | |
| polars as | 표현식 | 별칭 표현식을 만듭니다. | |
| polars as-date | 데이터프레임 | 문자열을 날짜로 변환합니다. | |
| polars as-datetime | 데이터프레임 | 문자열을 날짜/시간으로 변환합니다. | |
| polars cache | 데이터프레임 | 새 LazyFrame에 작업을 캐시합니다. | |
| polars cast | 표현식, 데이터프레임 | 열을 다른 dtype으로 캐스트합니다. | |
| polars col | any | 명명된 열 표현식을 만듭니다. | |
| polars collect | 데이터프레임 | 지연 데이터프레임을 열성 데이터프레임으로 수집합니다. | |
| polars columns | 데이터프레임 | 데이터프레임 열을 표시합니다. | |
| polars concat-str | any | 연결 문자열 표현식을 만듭니다. | |
| polars concatenate | 데이터프레임 | 다른 배열과 문자열을 연결합니다. | |
| polars contains | 데이터프레임 | 문자열에 패턴이 포함되어 있는지 확인합니다. | |
| polars count | 표현식 | 개수 표현식을 만듭니다. | |
| polars count-null | 데이터프레임 | null 값을 계산합니다. | |
| polars cumulative | 데이터프레임 | 시리즈에 대한 누적 계산입니다. | |
| polars datepart | 표현식 | 열에서 지정된 날짜 부분을 캡처하는 표현식을 만듭니다. | |
| polars drop | 데이터프레임 | 선택한 열을 삭제하여 새 데이터프레임을 만듭니다. | drop |
| polars drop-duplicates | 데이터프레임 | 데이터프레임에서 중복 값을 삭제합니다. | |
| polars drop-nulls | 데이터프레임 | 데이터프레임에서 null 값을 삭제합니다. | |
| polars dummies | 데이터프레임 | 더미 변수가 있는 새 데이터프레임을 만듭니다. | |
| polars explode | 표현식, 데이터프레임 | 데이터프레임을 분해하거나 분해 표현식을 만듭니다. | |
| polars expr-not | 표현식 | not 표현식을 만듭니다. | |
| polars fetch | 데이터프레임 | 선택한 행으로 지연 프레임을 수집합니다. | |
| polars fill-nan | 데이터프레임 | NaN 값을 지정된 표현식으로 바꿉니다. | |
| polars fill-null | 데이터프레임 | NULL 값을 지정된 표현식으로 바꿉니다. | |
| polars filter | 데이터프레임 | 표현식을 기반으로 데이터프레임을 필터링합니다. | |
| polars filter-with | 데이터프레임 | 마스크 또는 표현식을 참조로 사용하여 데이터프레임을 필터링합니다. | |
| polars first | 표현식, 데이터프레임 | 처음 몇 개의 행만 표시하거나 첫 번째 표현식을 만듭니다. | first |
| polars flatten | 표현식, 데이터프레임 | polars explode의 별칭입니다. | |
| polars get | 데이터프레임 | 선택한 열이 있는 데이터프레임을 만듭니다. | get |
| polars get-day | 데이터프레임 | 날짜에서 일을 가져옵니다. | |
| polars get-hour | 데이터프레임 | 날짜에서 시간을 가져옵니다. | |
| polars get-minute | 데이터프레임 | 날짜에서 분을 가져옵니다. | |
| polars get-month | 데이터프레임 | 날짜에서 월을 가져옵니다. | |
| polars get-nanosecond | 데이터프레임 | 날짜에서 나노초를 가져옵니다. | |
| polars get-ordinal | 데이터프레임 | 날짜에서 서수를 가져옵니다. | |
| polars get-second | 데이터프레임 | 날짜에서 초를 가져옵니다. | |
| polars get-week | 데이터프레임 | 날짜에서 주를 가져옵니다. | |
| polars get-weekday | 데이터프레임 | 날짜에서 요일을 가져옵니다. | |
| polars get-year | 데이터프레임 | 날짜에서 연도를 가져옵니다. | |
| polars group-by | 데이터프레임 | 다른 집계에 사용할 수 있는 그룹별 개체를 만듭니다. | group-by |
| polars implode | 표현식 | 그룹을 시리즈로 집계합니다. | |
| polars into-df | any | 목록, 테이블 또는 레코드를 데이터프레임으로 변환합니다. | |
| polars into-lazy | any | 데이터프레임을 지연 데이터프레임으로 변환합니다. | |
| polars into-nu | 표현식, 데이터프레임 | 데이터프레임 또는 표현식을 액세스 및 탐색을 위해 누셸 값으로 변환합니다. | |
| polars is-duplicated | 데이터프레임 | 중복된 값을 나타내는 마스크를 만듭니다. | |
| polars is-in | 표현식, 데이터프레임 | is-in 표현식을 만들거나 요소가 오른쪽 시리즈에 포함되어 있는지 확인합니다. | in |
| polars is-not-null | 표현식, 데이터프레임 | 값이 null이 아닌 마스크를 만듭니다. | |
| polars is-null | 표현식, 데이터프레임 | 값이 null인 마스크를 만듭니다. | <column_name> == null |
| polars is-unique | 데이터프레임 | 고유 값을 나타내는 마스크를 만듭니다. | |
| polars join | 데이터프레임 | 지연 프레임을 다른 지연 프레임과 조인합니다. | |
| polars last | 표현식, 데이터프레임 | 꼬리 행이 있는 새 데이터프레임을 만들거나 마지막 표현식을 만듭니다. | last |
| polars lit | any | 리터럴 표현식을 만듭니다. | |
| polars lowercase | 데이터프레임 | 열의 문자열을 소문자로 변환합니다. | |
| polars max | 표현식, 데이터프레임 | 최대 표현식을 만들거나 열을 최대값으로 집계합니다. | |
| polars mean | 표현식, 데이터프레임 | 집계에 대한 평균 표현식을 만들거나 열을 평균값으로 집계합니다. | |
| polars median | 표현식, 데이터프레임 | 데이터프레임의 열에서 중앙값을 구하거나 집계에 대한 표현식을 만듭니다. | |
| polars melt | 데이터프레임 | 데이터프레임을 넓은 형식에서 긴 형식으로 피벗 해제합니다. | |
| polars min | 표현식, 데이터프레임 | 최소 표현식을 만들거나 열을 최소값으로 집계합니다. | |
| polars n-unique | 표현식, 데이터프레임 | 고유 값을 계산합니다. | |
| polars not | 데이터프레임 | 부울 마스크를 반전합니다. | |
| polars open | any | CSV, JSON, JSON lines, arrow, avro 또는 parquet 파일을 열어 데이터프레임을 만듭니다. | open |
| polars otherwise | any | when 표현식을 완료합니다. | |
| polars quantile | 표현식, 데이터프레임 | 열을 선택한 분위수로 집계합니다. | |
| polars query | 데이터프레임 | SQL을 사용하여 데이터프레임을 쿼리합니다. 참고: 데이터프레임은 항상 쿼리의 from 절에서 'df'로 명명됩니다. | |
| polars rename | 데이터프레임 | 데이터프레임 열의 이름을 바꿉니다. | rename |
| polars replace | 데이터프레임 | 가장 왼쪽 (하위)문자열을 정규식 패턴으로 바꿉니다. | |
| polars replace-all | 데이터프레임 | 모든 (하위)문자열을 정규식 패턴으로 바꿉니다. | |
| polars reverse | 데이터프레임 | LazyFrame을 반전합니다. | |
| polars rolling | 데이터프레임 | 시리즈에 대한 롤링 계산입니다. | |
| polars sample | 데이터프레임 | 샘플 데이터프레임을 만듭니다. | |
| polars save | 데이터프레임 | 데이터프레임을 디스크에 저장합니다. 지연 데이터프레임의 경우 파일 형식이 지원하는 경우(parquet, ipc/arrow, csv 및 ndjson) 싱크 작업이 사용됩니다. | |
| polars schema | 데이터프레임 | 데이터프레임의 스키마를 표시합니다. | |
| polars select | 데이터프레임 | 지연 프레임에서 열을 선택합니다. | select |
| polars set | 데이터프레임 | 지정된 마스크가 true인 값을 설정합니다. | |
| polars set-with-idx | 데이터프레임 | 지정된 인덱스에 값을 설정합니다. | |
| polars shape | 데이터프레임 | 데이터프레임의 열 및 행 크기를 표시합니다. | |
| polars shift | 데이터프레임 | 지정된 기간만큼 값을 이동합니다. | |
| polars slice | 데이터프레임 | 행의 슬라이스에서 새 데이터프레임을 만듭니다. | |
| polars sort-by | 데이터프레임 | 표현식을 기반으로 지연 데이터프레임을 정렬합니다. | sort |
| polars std | 표현식, 데이터프레임 | 데이터프레임의 열에서 표준편차의 집계에 대한 표준편차 표현식을 만듭니다. | |
| polars store-get | any, any | 플러그인 캐시에서 데이터프레임 또는 기타 개체를 가져옵니다. | |
| polars store-ls | 저장된 데이터프레임을 나열합니다. | ||
| polars store-rm | any | 플러그인 캐시에서 저장된 데이터프레임 또는 기타 개체를 제거합니다. | |
| polars str-lengths | 데이터프레임 | 모든 문자열의 길이를 가져옵니다. | |
| polars str-slice | 데이터프레임 | 시작 위치에서 선택한 길이까지 문자열을 슬라이스합니다. | |
| polars strftime | 데이터프레임 | 문자열 규칙에 따라 날짜를 서식 지정합니다. | |
| polars sum | 표현식, 데이터프레임 | 집계에 대한 합계 표현식을 만들거나 열을 합계 값으로 집계합니다. | |
| polars summary | 데이터프레임 | 데이터프레임의 경우 숫자 열에 대한 설명 통계(요약 통계)를 생성합니다. | |
| polars take | 데이터프레임 | 지정된 인덱스를 사용하여 새 데이터프레임을 만듭니다. | |
| polars unique | 데이터프레임 | 데이터프레임에서 고유 값을 반환합니다. | uniq |
| polars uppercase | 데이터프레임 | 열의 문자열을 대문자로 변환합니다. | |
| polars value-counts | 데이터프레임 | 시리즈의 고유 값에 대한 개수가 있는 데이터프레임을 반환합니다. | |
| polars var | 표현식, 데이터프레임 | 집계에 대한 분산 표현식을 만듭니다. | |
| polars when | 표현식 | when 표현식을 만들고 수정합니다. | |
| polars with-column | 데이터프레임 | 데이터프레임에 시리즈를 추가합니다. | insert <column_name> <value> | upsert <column_name> { <new_value> } |
데이터프레임의 미래
이 페이지가 끝날 무렵에는 데이터프레임 명령을 사용하는 방법에 대해 확실히 이해하셨기를 바랍니다. 보시다시피 데이터를 더 빠르고 기본적으로 처리하는 데 도움이 되는 강력한 작업을 제공합니다.
그러나 이러한 데이터프레임의 미래는 아직 매우 실험적입니다. 이러한 명령을 활용하는 새로운 명령과 도구는 성숙해짐에 따라 추가될 것입니다.
새로운 데이터프레임 기능과 데이터를 더 빠르고 효율적으로 처리하는 데 도움이 되는 방법에 대해 알아보려면 이 장과 블로그를 정기적으로 확인하십시오.