Writing

Polars filter·sort 사용법: 데이터 필터링과 정렬 #3

지난 글에서 불러온 데이터를 바탕으로 필터링과 정렬을 다룹니다. 조건을 조합해 행을 선택하고, 여러 열을 기준으로 정렬하는 방법을 살펴봅니다.

예제는 원문 작성 당시 Polars 1.5를 기준으로 작성했습니다. 다른 버전에서의 동작은 별도로 검증하지 않았습니다.

먼저 필요한 라이브러리를 임포트하고 예제 데이터를 불러와 보겠습니다. (아직 설치를 안 하신 분들이 있다면 지난 글을 참고해서 먼저 설치해 주세요 🛠️)

예제 데이터는 아래 파일을 다운받아주세요.

Pokemon.csv 다운로드

0. polars 임포트 및 데이터 불러오기

import polars as pl

# 데이터 불러오기
df = pl.read_csv("Pokemon.csv")

1. 기본 필터링 🎯

Polars에서 데이터 필터링은 filter 메서드를 사용합니다. 필터링 조건은 pl.col()을 사용하여 표현하며, 다양한 비교 연산자를 활용할 수 있습니다.

단일 조건 필터링

# HP가 100 이상인 포켓몬 찾기
high_hp = df.filter(pl.col("HP") >= 100)

print("HP가 100 이상인 포켓몬:")
print(high_hp.select(["Name", "HP", "Type 1"]).head())

실행 결과

HP가 100 이상인 포켓몬:
shape: (5, 3)
┌────────────┬─────┬────────┐
│ Name       ┆ HP  ┆ Type 1 │
│ ---        ┆ --- ┆ ---    │
│ str        ┆ i64 ┆ str    │
╞════════════╪═════╪════════╡
│ Jigglypuff ┆ 115 ┆ Normal │
│ Wigglytuff ┆ 140 ┆ Normal │
│ Muk        ┆ 105 ┆ Poison │
│ Rhydon     ┆ 105 ┆ Ground │
│ Chansey    ┆ 250 ┆ Normal │
└────────────┴─────┴────────┘

다중 조건 필터링

여러 조건을 조합할 때는 &(and), |(or), ~(not) 연산자를 사용합니다:

# 불꽃 타입이면서 공격력이 100 이상인 포켓몬
strong_fire = df.filter(
    (pl.col("Type 1") == "Fire") & (pl.col("Attack") >= 100)
)
print("\n불꽃 타입 & 공격력 100 이상:")
print(strong_fire.select(["Name", "Type 1", "Attack"]).head())

실행 결과

불꽃 타입 & 공격력 100 이상:
shape: (5, 3)
┌───────────────────────────┬────────┬────────┐
│ Name                      ┆ Type 1 ┆ Attack │
│ ---                       ┆ ---    ┆ ---    │
│ str                       ┆ str    ┆ i64    │
╞═══════════════════════════╪════════╪════════╡
│ CharizardMega Charizard X ┆ Fire   ┆ 130    │
│ CharizardMega Charizard Y ┆ Fire   ┆ 104    │
│ Arcanine                  ┆ Fire   ┆ 110    │
│ Rapidash                  ┆ Fire   ┆ 100    │
│ Flareon                   ┆ Fire   ┆ 130    │
└───────────────────────────┴────────┴────────┘
# 전설의 포켓몬이거나 HP가 150 이상인 포켓몬
special = df.filter(
    pl.col("Legendary") | (pl.col("HP") >= 150)
)

print("\n전설의 포켓몬 or HP 150 이상:")
print(special.select(["Name", "HP", "Legendary"]).head())

실행 결과

전설의 포켓몬 또는 HP 150 이상:
shape: (5, 3)
┌──────────┬─────┬───────────┐
│ Name     ┆ HP  ┆ Legendary │
│ ---      ┆ --- ┆ ---       │
│ str      ┆ i64 ┆ bool      │
╞══════════╪═════╪═══════════╡
│ Chansey  ┆ 250 ┆ false     │
│ Snorlax  ┆ 160 ┆ false     │
│ Articuno ┆ 90  ┆ true      │
│ Zapdos   ┆ 90  ┆ true      │
│ Moltres  ┆ 90  ┆ true      │
└──────────┴─────┴───────────┘
# 불꽃 타입이 아니면서 물 타입도 아닌 포켓몬
not_fire_water = df.filter(
    ~(pl.col("Type 1").is_in(["Fire", "Water"]))
)


print("\n불꽃 타입이 아니면서 물 타입도 아닌 포켓몬:")
print(not_fire_water.select(["Name", "Type 1"]).head())

실행 결과

불꽃/물 타입이 아닌 포켓몬:
shape: (5, 2)
┌───────────────────────┬────────┐
│ Name                  ┆ Type 1 │
│ ---                   ┆ ---    │
│ str                   ┆ str    │
╞═══════════════════════╪════════╡
│ Bulbasaur             ┆ Grass  │
│ Ivysaur               ┆ Grass  │
│ Venusaur              ┆ Grass  │
│ VenusaurMega Venusaur ┆ Grass  │
│ Caterpie              ┆ Bug    │
└───────────────────────┴────────┘

Null 값 필터링

Polars에서는 is_null()과 is_not_null() 메서드를 사용하여 null 값을 처리할 수 있습니다:

# Type 2가 없는 (단일 타입) 포켓몬
single_type = df.filter(pl.col("Type 2").is_null())

print("\n단일 타입 포켓몬:")
print(single_type.select(["Name", "Type 1", "Type 2"]).head())

실행 결과

단일 타입 포켓몬:
shape: (5, 3)
┌────────────┬────────┬────────┐
│ Name       ┆ Type 1 ┆ Type 2 │
│ ---        ┆ ---    ┆ ---    │
│ str        ┆ str    ┆ str    │
╞════════════╪════════╪════════╡
│ Charmander ┆ Fire   ┆ null   │
│ Charmeleon ┆ Fire   ┆ null   │
│ Squirtle   ┆ Water  ┆ null   │
│ Wartortle  ┆ Water  ┆ null   │
│ Blastoise  ┆ Water  ┆ null   │
└────────────┴────────┴────────┘
# Type 2가 있는 (이중 타입) 포켓몬
dual_type = df.filter(pl.col("Type 2").is_not_null())

print("\n이중 타입 포켓몬:")
print(dual_type.select(["Name", "Type 1", "Type 2"]).head())

실행 결과

이중 타입 포켓몬:
shape: (5, 3)
┌───────────────────────┬────────┬────────┐
│ Name                  ┆ Type 1 ┆ Type 2 │
│ ---                   ┆ ---    ┆ ---    │
│ str                   ┆ str    ┆ str    │
╞═══════════════════════╪════════╪════════╡
│ Bulbasaur             ┆ Grass  ┆ Poison │
│ Ivysaur               ┆ Grass  ┆ Poison │
│ Venusaur              ┆ Grass  ┆ Poison │
│ VenusaurMega Venusaur ┆ Grass  ┆ Poison │
│ Charizard             ┆ Fire   ┆ Flying │
└───────────────────────┴────────┴────────┘

2. 다양한 필터링 기법 더 알아보기 🚀

is_in을 활용한 필터링

특정 값들의 목록에 포함되는지 확인할 때는 is_in() 메서드를 사용합니다:

# 스타팅 포켓몬들 찾기
starters = ["Bulbasaur", "Charmander", "Squirtle", "Chikorita", "Cyndaquil", "Totodile"]
starter_pokemon = df.filter(pl.col("Name").is_in(starters))

print("스타팅 포켓몬:")
print(starter_pokemon.select(["Name", "Type 1", "Generation"]))

실행 결과

스타팅 포켓몬:
shape: (3, 4)
┌────────────┬────────┬─────┬────────┐
│ Name       ┆ Type 1 ┆ HP  ┆ Attack │
│ ---        ┆ ---    ┆ --- ┆ ---    │
│ str        ┆ str    ┆ i64 ┆ i64    │
╞════════════╪════════╪═════╪════════╡
│ Bulbasaur  ┆ Grass  ┆ 45  ┆ 49     │
│ Charmander ┆ Fire   ┆ 39  ┆ 52     │
│ Squirtle   ┆ Water  ┆ 44  ┆ 48     │
└────────────┴────────┴─────┴────────┘

문자열 패턴 매칭

문자열 패턴을 이용한 필터링은 str 네임스페이스의 메서드들을 활용합니다:

# 이름에 'Mega'가 포함된 포켓몬
mega_pokemon = df.filter(pl.col("Name").str.contains("Mega"))

print("\n메가 진화 포켓몬:")
print(mega_pokemon.select(["Name", "Type 1"]).head())

실행 결과

메가진화 포켓몬:
shape: (5, 2)
┌───────────────────────────┬────────┐
│ Name                      ┆ Type 1 │
│ ---                       ┆ ---    │
│ str                       ┆ str    │
╞═══════════════════════════╪════════╡
│ VenusaurMega Venusaur     ┆ Grass  │
│ CharizardMega Charizard X ┆ Fire   │
│ CharizardMega Charizard Y ┆ Fire   │
│ BlastoiseMega Blastoise   ┆ Water  │
│ BeedrillMega Beedrill     ┆ Bug    │
└───────────────────────────┴────────┘
# 이름이 'D'로 시작하는 포켓몬
d_pokemon = df.filter(pl.col("Name").str.starts_with("D"))

print("\nD로 시작하는 포켓몬:")
print(d_pokemon.select(["Name"]).head())

실행 결과

'D'로 시작하는 포켓몬:
shape: (5, 2)
┌─────────┬────────┐
│ Name    ┆ Type 1 │
│ ---     ┆ ---    │
│ str     ┆ str    │
╞═════════╪════════╡
│ Diglett ┆ Ground │
│ Dugtrio ┆ Ground │
│ Doduo   ┆ Normal │
│ Dodrio  ┆ Normal │
│ Dewgong ┆ Water  │
└─────────┴────────┘

정규표현식 활용

더 복잡한 패턴 매칭이 필요할 때는 정규표현식을 사용할 수 있습니다:

# 이름에 숫자가 포함된 포켓몬
numbered = df.filter(pl.col("Name").str.contains(r"\d"))

print("\n이름에 숫자가 있는 포켓몬:")
print(numbered.select(["Name"]).head())
이름에 숫자가 포함된 포켓몬:
shape: (2, 2)
┌──────────────────┬────────┐
│ Name             ┆ Type 1 │
│ ---              ┆ ---    │
│ str              ┆ str    │
╞══════════════════╪════════╡
│ Porygon2         ┆ Normal │
│ Zygarde50% Forme ┆ Dragon │
└──────────────────┴────────┘
# 'mega'로 시작하거나, 'X' 또는 'Y'로 끝나는 포켓몬
complex_pattern = df.filter(pl.col("Name").str.contains(r"(^[Mm]ega|[XY]$)"))

print("\n'mega'로 시작하거나, 'X' 또는 'Y'로 끝나는 포켓몬:")
print(complex_pattern.select(["Name"]).head())
복잡한 패턴 매칭 포켓몬:
shape: (5, 2)
┌───────────────────────────┬────────┐
│ Name                      ┆ Type 1 │
│ ---                       ┆ ---    │
│ str                       ┆ str    │
╞═══════════════════════════╪════════╡
│ CharizardMega Charizard X ┆ Fire   │
│ CharizardMega Charizard Y ┆ Fire   │
│ Pidgey                    ┆ Normal │
│ Clefairy                  ┆ Fairy  │
│ Vulpix                    ┆ Fire   │
└───────────────────────────┴────────┘

💡 Polars 데이터 필터링 팁

  • 복잡한 필터링 조건을 작성할 때는 가독성을 위해 조건을 변수로 분리해 보세요. 재사용성도 높아지고 디버깅도 쉬워집니다.
condition1 = pl.col("col1") > 0
condition2 = pl.col("col2").is_not_null()
df.filter(condition1 & condition2)
  • 필터링 결과가 예상과 다르다면 describe()나 glimpse()를 활용하여 데이터를 먼저 살펴보세요. 특히 대소문자나 공백 차이로 인한 문제가 자주 발생합니다.
  • 필터링 조건이 복잡할 때는 select()와 with_columns()로 임시 컬럼을 만들어 활용해보세요. 조건식이 단순해지고 로직을 이해하기 쉬워집니다.
  • 문자열 필터링에서 contains()나 starts_with() 등은 대소문자를 구분합니다. 대소문자를 무시하려면 str.to_lowercase()를 먼저 적용하세요.

3. 데이터 정렬하기 📊

Polars는 sort 메서드를 통해 단순한 정렬부터 복잡한 정렬까지 다양한 정렬 기능을 제공합니다.

단일 컬럼 기준 정렬

sort 메서드를 사용하여 특정 컬럼을 기준으로 정렬할 수 있습니다:

# HP 기준 내림차순 정렬
hp_sorted = df.sort("HP", descending=True)

print("HP 기준 상위 5마리:")
print(hp_sorted.select(["Name", "HP"]).head())

실행 결과

HP 기준 내림차순 정렬:
shape: (5, 2)
┌───────────┬─────┐
│ Name      ┆ HP  │
│ ---       ┆ --- │
│ str       ┆ i64 │
╞═══════════╪═════╡
│ Blissey   ┆ 255 │
│ Chansey   ┆ 250 │
│ Wobbuffet ┆ 190 │
│ Wailord   ┆ 170 │
│ Alomomola ┆ 165 │
└───────────┴─────┘
# 공격력 기준 오름차순 정렬
attack_sorted = df.sort("Attack")

print("\n공격력 기준 하위 5마리:")
print(attack_sorted.select(["Name", "Attack"]).head())

실행 결과

공격력 기준 오름차순 정렬:
shape: (5, 2)
┌──────────┬────────┐
│ Name     ┆ Attack │
│ ---      ┆ ---    │
│ str      ┆ i64    │
╞══════════╪════════╡
│ Chansey  ┆ 5      │
│ Happiny  ┆ 5      │
│ Magikarp ┆ 10     │
│ Shuckle  ┆ 10     │
│ Blissey  ┆ 10     │
└──────────┴────────┘

다중 컬럼 기준 정렬

여러 컬럼을 기준으로 정렬할 때는 sort 메서드에 리스트를 전달합니다:

# Type 1으로 먼저 정렬하고, 같은 타입 내에서는 Attack으로 정렬
type_attack_sorted = df.sort(["Type 1", "Attack"], descending=[False, True])

print("\n타입별 공격력 상위 포켓몬:")
print(type_attack_sorted.select(["Name", "Type 1", "Attack"]).head(10))

실행 결과

다중 컬럼 정렬 (Type 1 오름차순, Attack 내림차순):
shape: (5, 3)
┌─────────────────────────┬────────┬────────┐
│ Name                    ┆ Type 1 ┆ Attack │
│ ---                     ┆ ---    ┆ ---    │
│ str                     ┆ str    ┆ i64    │
╞═════════════════════════╪════════╪════════╡
│ HeracrossMega Heracross ┆ Bug    ┆ 185    │
│ PinsirMega Pinsir       ┆ Bug    ┆ 155    │
│ BeedrillMega Beedrill   ┆ Bug    ┆ 150    │
│ ScizorMega Scizor       ┆ Bug    ┆ 150    │
│ Escavalier              ┆ Bug    ┆ 135    │
└─────────────────────────┴────────┴────────┘

표현식을 활용한 정렬

sort 메서드에 표현식을 전달하여 복잡한 정렬 조건을 적용할 수 있습니다:

# 공격력과 방어력의 합계를 기준으로 정렬
total_power_expr = (pl.col("Attack") + pl.col("Defense")).alias("Total Power")

power_sorted = (
    df
    .sort(total_power_expr, descending=True)
    .select([
        "Name",
        "Attack",
        "Defense",
        total_power_expr
    ])
)

print("\n공격+방어력 기준 상위 5마리:")
print(power_sorted.head())

실행 결과

공격력 + 방어력 합계 기준 정렬:
shape: (5, 3)
┌─────────────────────────┬────────┬─────────┐
│ Name                    ┆ Attack ┆ Defense │
│ ---                     ┆ ---    ┆ ---     │
│ str                     ┆ i64    ┆ i64     │
╞═════════════════════════╪════════╪═════════╡
│ AggronMega Aggron       ┆ 140    ┆ 230     │
│ SteelixMega Steelix     ┆ 125    ┆ 230     │
│ GroudonPrimal Groudon   ┆ 180    ┆ 160     │
│ TyranitarMega Tyranitar ┆ 164    ┆ 150     │
│ Avalugg                 ┆ 117    ┆ 184     │
└─────────────────────────┴────────┴─────────┘

🎯 실전 예제: 최강의 포켓몬 찾기

필터링과 정렬 기능을 활용해서 조건에 맞는 "최강의 포켓몬"을 찾아보겠습니다:

strongest = (
    df
    # 전설의 포켓몬 제외
    .filter(~pl.col("Legendary"))
    # 총 스탯 계산
    .with_columns(
        (
            pl.col("HP")
            + pl.col("Attack")
            + pl.col("Defense")
            + pl.col("Sp. Atk")
            + pl.col("Sp. Def")
            + pl.col("Speed")
        ).alias("Total Stats")
    )
    # 총 스탯 기준 정렬
    .sort("Total Stats", descending=True)
    # 필요한 컬럼만 선택
    .select(["Name", "Type 1", "Type 2", "Total Stats"])
)

print("일반 포켓몬 중 최강자들:")
print(strongest.head())

실행 결과

1세대 비전설 최강 포켓몬:
shape: (5, 6)
┌───────────────────────────┬────────┬───────┬─────┬────────┬─────────┐
│ Name                      ┆ Type 1 ┆ Total ┆ HP  ┆ Attack ┆ Defense │
│ ---                       ┆ ---    ┆ ---   ┆ --- ┆ ---    ┆ ---     │
│ str                       ┆ str    ┆ i64   ┆ i64 ┆ i64    ┆ i64     │
╞═══════════════════════════╪════════╪═══════╪═════╪════════╪═════════╡
│ GyaradosMega Gyarados     ┆ Water  ┆ 640   ┆ 95  ┆ 155    ┆ 109     │
│ CharizardMega Charizard X ┆ Fire   ┆ 634   ┆ 78  ┆ 130    ┆ 111     │
│ CharizardMega Charizard Y ┆ Fire   ┆ 634   ┆ 78  ┆ 104    ┆ 78      │
│ BlastoiseMega Blastoise   ┆ Water  ┆ 630   ┆ 79  ┆ 103    ┆ 120     │
│ VenusaurMega Venusaur     ┆ Grass  ┆ 625   ┆ 80  ┆ 100    ┆ 123     │
└───────────────────────────┴────────┴───────┴─────┴────────┴─────────┘

이번 글에서는 Polars의 필터링과 정렬 기능에 대해 자세히 알아보았습니다. 여러분도 다양한 방식으로 응용해서 여러분들의 문제를 해결해 보시기를 바랍니다! 🚀

다음 글에서는 데이터 그룹화와 집계 함수 사용법을 살펴봅니다. 긴 글 읽어주셔서 감사합니다! 😊

📚 참고자료