0Pricing
Pandas & NumPy Academy · Lekcja

Indeksowanie boolowskie obiektów DataFrame

Filtrować wiersze przez zastosowanie warunku boolowskiego do kolumny i łączyć wiele warunków za pomocą operatorów & i |

Indeksowanie boolowskie obiektów DataFrame to bezpłatna lekcja Pandas & NumPy Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Pandas & NumPy Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Pandas & NumPy Academy zawiera 4 lekcji w sumie.

Czym jest indeksowanie boolowskie?

Indeksowanie boolowskie umożliwia filtrowanie wierszy w obiekcie DataFrame przez zastosowanie warunku, który tworzy serię wartości True i False. Zwracane są tylko wiersze, dla których warunek ma wartość True. Jest to jedna z najczęściej używanych technik wyboru danych w Pandas, ponieważ jest zarówno czytelna, jak i szybka.

Na przykład w przypadku obiektu DataFrame zawierającego dane sprzedażowe można natychmiast pobrać wszystkie wiersze, w których przychód przekroczył 1000, bez pisania pętli.

import pandas as pd

df = pd.DataFrame({
    'product': ['A', 'B', 'C', 'D'],
    'revenue': [500, 1500, 800, 2000]
})

# Boolean condition produces a Series of True/False
mask = df['revenue'] > 1000
print(mask)
# 0    False
# 1     True
# 2    False
# 3     True

Stosowanie maski boolowskiej

Po utworzeniu boolowskiej maski należy przekazać ją w nawiasach kwadratowych obiektu DataFrame, aby wybrać tylko pasujące wiersze. Wynikiem jest nowy obiekt DataFrame — oryginał nigdy nie jest modyfikowany. Indeksy wierszy z oryginalnego obiektu zostają zachowane, dzięki czemu zawsze wiadomo, skąd pochodzi każdy wiersz.

Ten wzorzec — utworzenie maski, a następnie jej zastosowanie — jest standardowym idiomem Pandas do filtrowania wierszy.

import pandas as pd

df = pd.DataFrame({
    'product': ['A', 'B', 'C', 'D'],
    'revenue': [500, 1500, 800, 2000]
})

mask = df['revenue'] > 1000
filtered = df[mask]
print(filtered)
#   product  revenue
# 1       B     1500
# 3       D     2000

Warunki wbudowane bez zmiennej maski

Nie trzeba przypisywać serii boolowskiej do zmiennej. Warunek można zapisać bezpośrednio w nawiasach: df[df['col'] > value]. Ten jednowierszowy styl jest bardzo popularny w notebookach do analizy danych, ponieważ pozwala zachować zwięzłość i czytelność kodu.

Oba podejścia — ze zmienną maski i wbudowane — dają identyczne wyniki. Używaj zmiennej, gdy warunek jest złożony lub będzie używany ponownie, a zapisu wbudowanego w przypadku prostych, jednorazowych filtrów.

import pandas as pd

df = pd.DataFrame({
    'city': ['NYC', 'LA', 'Chicago', 'Houston'],
    'population': [8_336_817, 3_979_576, 2_693_976, 2_320_268]
})

# Inline boolean filter
large_cities = df[df['population'] > 3_000_000]
print(large_cities)
#   city  population
# 0  NYC   8336817
# 1   LA   3979576

Łączenie warunków za pomocą & (AND)

Aby wymagać spełnienia obu warunków, połącz je operatorem & — nie słowem kluczowym Pythona and, które nie działa element po elemencie na tablicach. Każdy warunek musi być ujęty w nawiasy, ponieważ operator & ma wyższy priorytet niż operatory porównania.

Wynik zawiera tylko te wiersze, dla których każdy podwarunek ma wartość True.

import pandas as pd

df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Carol', 'Dave'],
    'age': [25, 35, 28, 45],
    'salary': [50000, 90000, 70000, 120000]
})

# Both conditions must be true
result = df[(df['age'] > 27) & (df['salary'] > 60000)]
print(result)
#     name  age  salary
# 1    Bob   35   90000
# 2  Carol   28   70000

Łączenie warunków za pomocą | (OR)

Użyj operatora |, aby zachować wiersze, w których prawdziwy jest co najmniej jeden warunek. Podobnie jak w przypadku &, każdy podwarunek musi być ujęty w nawiasy. Operator | wykonuje elementowe logiczne LUB na tablicach boolowskich.

Łączenie operatorów & i | jest całkowicie poprawne — należy tylko uważać na nawiasy, aby wymusić prawidłową kolejność obliczeń i uniknąć trudnych do wykrycia błędów logicznych.

import pandas as pd

df = pd.DataFrame({
    'product': ['Laptop', 'Mouse', 'Monitor', 'Keyboard'],
    'price': [1200, 25, 300, 80],
    'category': ['Electronics', 'Accessories', 'Electronics', 'Accessories']
})

# Rows where price > 200 OR category is Accessories
result = df[(df['price'] > 200) | (df['category'] == 'Accessories')]
print(result)
#     product  price     category
# 0    Laptop   1200  Electronics
# 1     Mouse     25  Accessories
# 2   Monitor    300  Electronics
# 3  Keyboard     80  Accessories

Negowanie warunku za pomocą ~

Operator tyldy ~ odwraca serię boolowską — zamienia True na False i odwrotnie. Użyj ~, aby wyrazić logikę „NIE” i zachować wiersze, które nie pasują do warunku. Jest to czytelniejsze niż ręczne konstruowanie warunku przeciwnego.

Na przykład df[~df['status'].isin(['cancelled', 'refunded'])] zachowuje wszystkie wiersze z wyjątkiem tych o dwóch podanych statusach.

import pandas as pd

df = pd.DataFrame({
    'order_id': [1, 2, 3, 4],
    'status': ['shipped', 'cancelled', 'delivered', 'refunded']
})

# Keep only rows that are NOT cancelled
active = df[~(df['status'] == 'cancelled')]
print(active)
#    order_id     status
# 0         1    shipped
# 2         3  delivered
# 3         4   refunded

Filtrowanie wartości tekstowych

Indeksowanie boolowskie równie dobrze działa na kolumnach tekstowych. Można filtrować według dokładnego dopasowania za pomocą == albo używać metod .str, takich jak .str.startswith(), .str.contains() lub .str.upper(), wewnątrz warunku, aby elastycznie filtrować tekst.

Porównywanie ciągów znaków w Pandas domyślnie uwzględnia wielkość liter, więc 'NYC' i 'nyc' są traktowane jako różne wartości. W razie potrzeby najpierw ujednolić wielkość liter.

import pandas as pd

df = pd.DataFrame({
    'country': ['USA', 'Germany', 'UK', 'USA', 'France'],
    'sales': [400, 200, 150, 600, 300]
})

# Filter rows where country equals USA
us_sales = df[df['country'] == 'USA']
print(us_sales)
#   country  sales
# 0     USA    400
# 3     USA    600

# Filter rows where country starts with 'G'
g_countries = df[df['country'].str.startswith('G')]
print(g_countries)
#    country  sales
# 1  Germany    200

Filtrowanie według wielu kolumn

Złożone analizy często wymagają warunków dotyczących wielu kolumn, połączonych za pomocą & i |. Bardzo długie warunki warto rozbić na nazwane serie boolowskie, aby zwiększyć czytelność — każda z nich pełni rolę nazwanego podfiltra, które na końcu łączysz.

Takie podejście jasno pokazuje zamiar: każda linia przypomina zdanie opisujące jedną część logiki filtrowania.

import pandas as pd

df = pd.DataFrame({
    'region': ['North', 'South', 'North', 'East'],
    'year': [2022, 2023, 2023, 2022],
    'profit': [5000, -200, 8000, 3000]
})

is_north = df['region'] == 'North'
is_2023 = df['year'] == 2023
is_profitable = df['profit'] > 0

result = df[is_north & is_2023 & is_profitable]
print(result)
#   region  year  profit
# 2  North  2023    8000

Używanie np.where do tworzenia kolumn warunkowych

Indeksowanie boolowskie filtruje wiersze, ale czasami zamiast usuwać wiersze chcesz dodać nową kolumnę na podstawie warunku. np.where(condition, value_if_true, value_if_false) jest zwektoryzowanym odpowiednikiem konstrukcji if/else stosowanej element po elemencie w całej kolumnie i działa znacznie szybciej niż użycie apply z lambdą.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'score': [45, 72, 88, 61, 95]
})

# Create a new column based on a condition
df['grade'] = np.where(df['score'] >= 70, 'Pass', 'Fail')
print(df)
#    score grade
# 0     45  Fail
# 1     72  Pass
# 2     88  Pass
# 3     61  Fail
# 4     95  Pass

Przypisywanie wartości do przefiltrowanego podzbioru

Można aktualizować wartości w miejscu dla przefiltrowanych wierszy za pomocą .loc[mask, column]. Jest to bezpieczny sposób ustawiania wartości w podzbiorze — użycie indeksowania łańcuchowego, takiego jak df[mask]['col'] = value, może wywołać ostrzeżenie SettingWithCopyWarning, ponieważ działa na kopii.

Gdy chcesz zmodyfikować oryginalny obiekt DataFrame w miejscu, zawsze wybieraj df.loc[mask, 'col'] = value.

import pandas as pd

df = pd.DataFrame({
    'item': ['A', 'B', 'C', 'D'],
    'stock': [0, 5, 0, 12]
})

# Mark out-of-stock items
df.loc[df['stock'] == 0, 'status'] = 'Out of Stock'
df.loc[df['stock'] > 0, 'status'] = 'Available'
print(df)
#   item  stock        status
# 0    A      0  Out of Stock
# 1    B      5     Available
# 2    C      0  Out of Stock
# 3    D     12     Available

Zliczanie i sumowanie maski

Ponieważ wartości boolowskie są wewnętrznie reprezentowane jako 1 (True) i 0 (False), można wywołać .sum() na masce, aby zliczyć pasujące wiersze, lub .mean(), aby uzyskać ułamek pasujących wierszy. Te szybkie obliczenia pomagają zweryfikować logikę filtrowania przed zastosowaniem jej do wyboru wierszy.

import pandas as pd

df = pd.DataFrame({'value': [10, 55, 30, 80, 20, 70]})

mask = df['value'] > 40
print('Count of rows > 40:', mask.sum())      # 3
print('Fraction > 40:', mask.mean().round(2)) # 0.5

# Now apply
print(df[mask])
#    value
# 1     55
# 3     80
# 5     70

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat indeksowania boolowskiego obiektów DataFrame.

Podsumowanie rozdziału

W tym rozdziale nauczyłeś się, że maski boolowskie filtrują wiersze przez zastosowanie warunku do kolumny, operatory & i | łączą wiele warunków (w przeciwieństwie do pythonowych and/or), a ~ odwraca maskę boolowską, umożliwiając zastosowanie logiki NIE. Używaj df.loc[mask, col] = value, aby bezpiecznie przypisywać wartości do przefiltrowanych wierszy. W następnej części omówimy metodę query(), która pozwala zapisywać filtry w postaci czytelnych ciągów znaków.

Często zadawane pytania

Czy lekcja „Indeksowanie boolowskie obiektów DataFrame” jest bezpłatna?

Tak — pełny tekst „Indeksowanie boolowskie obiektów DataFrame” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Pandas & NumPy Academy, przejdź na CoddyKit PRO. Kurs Pandas & NumPy Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Indeksowanie boolowskie obiektów DataFrame”?

Filtrować wiersze przez zastosowanie warunku boolowskiego do kolumny i łączyć wiele warunków za pomocą operatorów & i | Ćwiczysz Pandas & NumPy Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Pandas & NumPy Academy?

Nie wymagamy żadnego doświadczenia. Pandas & NumPy Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Indeksowanie boolowskie obiektów DataFrame”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Pandas & NumPy Academy?

Tak. Każda lekcja Pandas & NumPy Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Indeksowanie boolowskie obiektów DataFrame
  2. Metoda query()
  3. Filtry isin() i between()
  4. Wybieranie kolumn według wzorca
← Powrót do Pandas & NumPy Academy