Prawidłowe analizowanie dat
Konwertuj tekstowe daty na datetime64 za pomocą pd.to_datetime, obsługuj wiele formatów i ustaw DatetimeIndex.
Prawidłowe analizowanie dat to bezpłatna lekcja Pandas & NumPy Academy na CoddyKit. To lekcja 4 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.
Dlaczego analizowanie dat ma znaczenie
Dane dotyczące dat i czasu występują niemal wszędzie w rzeczywistych zbiorach danych — są to znaczniki czasu transakcji, daty urodzenia, dzienniki zdarzeń i okresy finansowe. Gdy daty są przechowywane jako ciągi znaków (typ object), nie można obliczać przedziałów czasu, wykonywać ponownego próbkowania według miesięcy ani sortować chronologicznie. Konwersja ciągów do typu datetime64 biblioteki Pandas udostępnia pełne API szeregów czasowych i umożliwia analizę danych w czasie.
import pandas as pd
df = pd.DataFrame({'date': ['2024-01-15', '2024-03-20', '2024-07-04']})
print(df['date'].dtype) # object
# You cannot do arithmetic on string dates
# df['date'] + pd.Timedelta('1 day') # TypeError!
# After parsing:
df['date'] = pd.to_datetime(df['date'])
print(df['date'].dtype) # datetime64[ns]
print(df['date'] + pd.Timedelta('1 day'))Podstawy pd.to_datetime()
pd.to_datetime(series) to podstawowa funkcja służąca do konwertowania kolumn zawierających ciągi znaków na typ datetime64. Potrafi automatycznie rozpoznawać większość popularnych formatów dat (ISO 8601, format amerykański i europejski) bez konieczności podawania ciągu formatu. Wynikiem jest obiekt Series typu datetime64[ns] — z precyzją nanosekundową, umożliwiający przechowywanie znaczników czasu od roku 1677 do 2262.
import pandas as pd
dates = pd.Series([
'2024-01-15',
'15/01/2024',
'January 15, 2024',
'2024-01-15 08:30:00'
])
parsed = pd.to_datetime(dates)
print(parsed)
# 0 2024-01-15 00:00:00
# 1 2024-01-15 00:00:00
# 2 2024-01-15 00:00:00
# 3 2024-01-15 08:30:00
print(parsed.dtype) # datetime64[ns]Określanie argumentu format=
Gdy automatyczne rozpoznawanie jest zbyt wolne lub niejednoznaczne (np. '01-02-03' może oznaczać 2 stycznia 2003 roku, 1 lutego 2003 roku albo 3 lutego 2001 roku), należy podać dokładny ciąg formatu za pomocą kodów strftime języka Python. Jest to również znacznie szybsze — w przypadku dużych zbiorów danych jawne analizowanie formatu może być 10 razy szybsze niż automatyczne rozpoznawanie, ponieważ Pandas nie musi sprawdzać wielu wzorców.
import pandas as pd
dates = pd.Series(['15/01/2024', '20/03/2024', '04/07/2024'])
# Explicit format: day/month/year
parsed = pd.to_datetime(dates, format='%d/%m/%Y')
print(parsed)
# 0 2024-01-15
# 1 2024-03-20
# 2 2024-07-04
# Common format codes:
# %Y = 4-digit year, %y = 2-digit year
# %m = month (01-12), %d = day (01-31)
# %H = hour (0-23), %M = minute, %S = seconderrors='coerce' dla niepoprawnych dat
Rzeczywiste zbiory danych często zawierają literówki albo ciągi zastępcze, takie jak 'TBD', 'N/A' lub '99/99/9999', w kolumnach z datami. Przekazanie errors='coerce' powoduje, że pd.to_datetime() konwertuje wartości, których nie można przeanalizować, na NaT (Not a Time — odpowiednik NaN dla daty i czasu), zamiast zgłaszać wyjątek. Umożliwia to osobne zidentyfikowanie i obsłużenie niepoprawnych dat.
import pandas as pd
dates = pd.Series(['2024-01-15', 'TBD', '2024-07-04', 'N/A'])
parsed = pd.to_datetime(dates, errors='coerce')
print(parsed)
# 0 2024-01-15
# 1 NaT
# 2 2024-07-04
# 3 NaT
# Detect bad dates
print('Bad date rows:', parsed.isna().sum()) # 2parse_dates w read_csv()
Najwydajniej jest analizować daty już podczas wczytywania danych, używając parametru parse_dates funkcji pd.read_csv(). Należy przekazać listę nazw kolumn (albo ich indeksów), które powinny zostać zinterpretowane jako daty. Pozwala to uniknąć osobnego etapu przetwarzania i często jest szybsze, ponieważ Pandas wykonuje tę operację podczas analizowania pliku CSV na poziomie C.
import pandas as pd
import io
csv_data = '''order_id,order_date,ship_date
1,2024-01-15,2024-01-18
2,2024-02-20,2024-02-22
'''
df = pd.read_csv(
io.StringIO(csv_data),
parse_dates=['order_date', 'ship_date']
)
print(df.dtypes)
# order_id int64
# order_date datetime64[ns]
# ship_date datetime64[ns]Akcesor .dt do elementów daty
Po nadaniu kolumnie typu datetime64 akcesor .dt udostępnia dziesiątki właściwości i metod. Można wyodrębnić .dt.year, .dt.month, .dt.day, .dt.hour, .dt.dayofweek (0 = poniedziałek) oraz .dt.is_month_end. Są one używane do tworzenia cech w prognozowaniu szeregów czasowych oraz do grupowania danych według okresów.
import pandas as pd
df = pd.DataFrame({
'event_time': pd.to_datetime([
'2024-03-15 08:30:00',
'2024-07-04 14:00:00',
'2024-12-25 09:00:00'
])
})
df['year'] = df['event_time'].dt.year
df['month'] = df['event_time'].dt.month
df['day_of_week'] = df['event_time'].dt.day_name()
df['hour'] = df['event_time'].dt.hour
print(df[['year', 'month', 'day_of_week', 'hour']])Ustawianie DatetimeIndex
W analizie szeregów czasowych standardowo ustawia się kolumnę zawierającą daty i czas jako indeks obiektu DataFrame. DatetimeIndex umożliwia używanie wycinania na podstawie czasu (df['2024'], df['2024-01':'2024-06']), zmianę częstotliwości próbkowania na dowolną oraz korzystanie z pełnego API szeregów czasowych biblioteki Pandas. Należy użyć set_index() albo przekazać parametr index_col do read_csv.
import pandas as pd
df = pd.DataFrame({
'date': pd.to_datetime(['2024-01-01', '2024-01-02', '2024-01-03']),
'temp': [22.5, 23.0, 21.8]
})
df = df.set_index('date')
print(df)
# temp
# date
# 2024-01-01 22.5
# 2024-01-02 23.0
# 2024-01-03 21.8
# Time-based slicing
print(df['2024-01-02':'2024-01-03'])Obsługa wielu formatów dat
Jeśli kolumna z datami zawiera mieszankę formatów (np. niektóre wiersze zawierają daty w formacie ISO, a inne w formacie amerykańskim), nie można określić jednego ciągu formatu. Należy przekazać format='mixed' (Pandas 2.0+), aby włączyć rozpoznawanie formatu dla każdego wiersza, albo wstępnie oczyścić kolumnę za pomocą wyrażeń regularnych, normalizując wszystkie daty do jednego formatu przed wywołaniem pd.to_datetime().
import pandas as pd
mixed_dates = pd.Series([
'2024-01-15',
'03/20/2024',
'2024-07-04T10:30:00'
])
# format='mixed' handles different formats row-by-row (Pandas >= 2.0)
parsed = pd.to_datetime(mixed_dates, format='mixed')
print(parsed)
# 0 2024-01-15 00:00:00
# 1 2024-03-20 00:00:00
# 2 2024-07-04 10:30:00Daty i czas ze strefą czasową
Rzeczywiste znaczniki czasu często zawierają informacje o strefie czasowej. pd.to_datetime() potrafi analizować ciągi z przesunięciem względem UTC (np. '2024-01-15 08:30:00+05:30') i przechowywać je jako datetime64 ze strefą czasową. Użyj .dt.tz_convert('UTC'), aby ujednolicić wszystkie znaczniki czasu do wspólnej strefy czasowej i umożliwić ich poprawne porównywanie oraz wykonywanie działań arytmetycznych.
import pandas as pd
dates = pd.to_datetime(['2024-01-15 08:30:00+05:30', '2024-01-15 10:00:00-08:00'])
print(dates)
# DatetimeIndex(['2024-01-15 08:30:00+05:30', '2024-01-15 10:00:00-08:00'])
# Convert both to UTC for fair comparison
utc_dates = dates.tz_convert('UTC')
print(utc_dates)
# DatetimeIndex(['2024-01-15 03:00:00+00:00', '2024-01-15 18:00:00+00:00'])Obliczanie różnic między datami
Działanie arytmetyczne na dwóch kolumnach datetime64 tworzy obiekt Series typu Timedelta. Z obiektu Timedelta można wyodrębnić liczbę dni, godzin lub sekund za pomocą właściwości .dt.days, .dt.seconds i .dt.total_seconds(). Jest to standardowy sposób obliczania wieku, czasu trwania lub cech określających liczbę dni od ostatniego zdarzenia.
import pandas as pd
df = pd.DataFrame({
'start': pd.to_datetime(['2024-01-01', '2024-03-10', '2024-06-15']),
'end': pd.to_datetime(['2024-01-20', '2024-04-05', '2024-06-30'])
})
df['duration_days'] = (df['end'] - df['start']).dt.days
print(df[['start', 'end', 'duration_days']])
# start end duration_days
# 0 2024-01-01 2024-01-20 19
# 1 2024-03-10 2024-04-05 26
# 2 2024-06-15 2024-06-30 15pd.date_range() do generowania dat
pd.date_range(start, end, freq=) generuje ciąg równomiernie rozmieszczonych dat jako obiekt DatetimeIndex. Jest to przydatne do utworzenia kompletnej osi czasu, względem której można ponownie indeksować dane — dzięki temu w wyniku pojawia się każdy okres kalendarzowy, nawet jeśli danego dnia nie wystąpiły żadne zdarzenia. Typowe wartości freq to: 'D' (dziennie), 'ME' (koniec miesiąca), 'h' (co godzinę).
import pandas as pd
# Weekly dates for the first quarter of 2024
weekly = pd.date_range(start='2024-01-01', end='2024-03-31', freq='W')
print(weekly[:5])
# DatetimeIndex(['2024-01-07', '2024-01-14', '2024-01-21', '2024-01-28', '2024-02-04'])
# Monthly date spine
monthly = pd.date_range(start='2024-01', periods=12, freq='ME')
print(len(monthly), monthly[0], monthly[-1])
# 12 2024-01-31 2024-12-31Szybkie sprawdzenie
Sprawdź swoje rozumienie poprawnego analizowania dat w Pandas.
Podsumowanie lekcji
W tej lekcji poznali Państwo: pd.to_datetime() konwertuje kolumny zawierające ciągi znaków na datetime64, format= określa dokładny wzorzec, zapewniając szybkość i poprawność, a errors='coerce' zamienia niepoprawne daty na NaT zamiast przerywać działanie programu. Akcesor .dt wyodrębnia rok, miesiąc, dzień i inne elementy, a ustawienie DatetimeIndex umożliwia wycinanie na podstawie czasu. W następnej części poznają Państwo akcesor .str do wykonywania zwektoryzowanych operacji na ciągach znaków.
Ucz się Python dzięki korepetycjom AI — za darmo
Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.
- Kursy
- 30
- Lekcje
- 120
Często zadawane pytania
Czy lekcja „Prawidłowe analizowanie dat” jest bezpłatna?
Tak — pełny tekst „Prawidłowe analizowanie dat” 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 „Prawidłowe analizowanie dat”?
Konwertuj tekstowe daty na datetime64 za pomocą pd.to_datetime, obsługuj wiele formatów i ustaw DatetimeIndex. Ć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 4 z 4.
Ile czasu zajmuje lekcja „Prawidłowe analizowanie dat”?
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
- Sprawdzanie typów danych kolumn
- Rzutowanie za pomocą astype()
- Kategoryczny typ danych
- Prawidłowe analizowanie dat