Python do analizy literackiej: Kosmiczne trasy Alisy Selezniowej

Analiza Literacka z Pythonem: Jak wyrażenia regularne pomogły odwzorować kosmiczne podróże Alicji Selezniowej

Zastosowanie metod programistycznych do analizy dzieł literackich otwiera nowe horyzonty w rozumieniu danych tekstowych. Niniejszy materiał przedstawia studium przypadku wykorzystania Pythona i wyrażeń regularnych do pogłębionej analizy korpusu tekstów o przygodach Alicji Selezniowej. Celem badania było nie tylko zidentyfikowanie wszystkich wspomnianych planet, ale także określenie, które z nich główna bohaterka odwiedziła osobiście, wykorzystując metody analizy kontekstowej.

Zbieranie i wstępne przetwarzanie danych tekstowych

Początkowy etap każdej analizy tekstowej to zbieranie i przygotowanie danych. W tym przypadku, rozproszone opowiadania i nowele o przygodach Alicji Selezniowej zostały zagregowane w jeden plik tekstowy w formacie .txt. Biorąc pod uwagę różnorodność źródeł, kluczowym krokiem było automatyczne określenie kodowania pliku, do czego wykorzystano bibliotekę chardet. Pozwoliło to uniknąć problemów z nieprawidłowym wyświetlaniem znaków i zapewnić ujednoliconą obróbkę tekstu.

Do dalszej analizy wykorzystano standardowe biblioteki Pythona:

• re: Wbudowany moduł do pracy z wyrażeniami regularnymi, niezastąpiony do wyszukiwania i ekstrakcji wzorców tekstowych.
• collections: Dostarcza wyspecjalizowane typy kontenerów, takie jak defaultdict, który został użyty do tworzenia słowników z domyślnymi wartościami, oraz Counter do zliczania częstotliwości elementów.

Identyfikacja planet: od prostego wyszukiwania do precyzyjnego wyodrębniania

Zadanie identyfikacji wszystkich wspomnianych w tekście planet okazało się trudniejsze, niż się wydaje na pierwszy rzut oka. Początkowe podejście polegało na wyszukiwaniu słowa „planeta” w różnych przypadkach, a następnie wyodrębnianiu następującego po nim słowa jako nazwy. W tym celu zastosowano wyrażenie regularne, uwzględniające warianty końcówek słowa „planeta” i przechwytujące następujące po nim słowo, zaczynające się od wielkiej litery.

def find_planets_after_word(text):
    if text is None:
        return [], []
    pattern_planet_name = r'''
        (?<![.\!\?\n])          
        (planeta|planety|planecie|planetę|planetą|planeto)   
        \s+                        
        ([A-ZĄĆĘŁŃÓŚŹŻ][a-ząćęłńóśźż]+)           
    '''
    # pattern_sentence_start = r'[.\!\?][\s]+([A-ZĄĆĘŁŃÓŚŹŻ][a-ząćęłńóśźż]+)' # Pierwotnie używany do wykluczania początku zdań
    found_planets = []
    all_matches = []
    for match in re.finditer(pattern_planet_name, text, re.IGNORECASE | re.VERBOSE):
        full_match = match.group(0)
        planet_word = match.group(1)  
        planet_name = match.group(2)
        # Dodatkowa logika do filtrowania i analizy kontekstowej została dodana później

Jednakże, pierwsze zastosowanie takiego wzorca z flagą re.IGNORECASE (wyszukiwanie bez uwzględniania wielkości liter) doprowadziło do licznych fałszywych trafień. Na przykład, po słowie „planeta” mogły następować przymiotniki („inna”, „nowa”) lub inne rzeczowniki, które błędnie interpretowano jako nazwy planet. Ostateczna liczba „planet” przekroczyła 600, co wyraźnie wskazywało na konieczność udoskonalenia algorytmu.

W celu zwiększenia precyzji wprowadzono następujące korekty:

• Rozróżnianie wielkości liter dla nazw: Ograniczenie wyszukiwania do nazw zaczynających się wyłącznie od wielkiej litery. To znacząco zredukowało liczbę fałszywych trafień, wykluczając przymiotniki i inne słowa funkcyjne.
• Lista stop-słów: Stworzenie i zastosowanie listy stop-słów, zawierającej ogólne rzeczowniki (np. „system”, „gwiazda”, „orbita”, „atmosfera”), które mogą następować po słowie „planeta”, ale nie są jej nazwą. Sprawdzenie, czy słowo znajduje się na tej liście, pozwoliło odfiltrować nieistotne dopasowania.
• Minimalna długość słowa: Wprowadzenie ograniczenia minimalnej długości słowa dla nazw planet, aby wykluczyć przyimki i spójniki.
• Wykluczenie początku zdań: Dodatkowe sprawdzenie, czy znalezione słowo jest początkiem zdania (po znaku interpunkcyjnym), aby uniknąć błędnej identyfikacji zwykłych słów, zaczynających się od wielkiej litery, jako nazw planet.

Po serii iteracji i udoskonaleń wyrażeń regularnych, lista znalezionych planet skróciła się do 281, co jest bardziej realistycznym wynikiem, odzwierciedlającym różnorodność wspomnianych światów w książkach o Alicji Selezniowej.

Analiza kontekstowa wizyt: określanie tras Alicji

Samo wspomnienie planety w tekście nie oznacza, że główna bohaterka ją odwiedziła. Aby określić faktyczne podróże Alicji, opracowano metodę analizy kontekstowej. Główna hipoteza zakładała, że wizyta na planecie powinna być potwierdzona jednoczesnym wspomnieniem imienia Alicji (w różnych przypadkach) oraz czasowników oznaczających przemieszczanie się lub przebywanie, w bezpośrednim sąsiedztwie nazwy planety.

Do realizacji tego podejścia stworzono:

• Wzorce imienia Alicji: Lista wyrażeń regularnych, obejmujących wszystkie formy przypadków imienia „Alicja” (np. r'\balicja\b', r'\balicji\b', r'\balicję\b'). Użycie \b (granice słowa) zapewniało dokładne dopasowanie.
• Czasowniki podróży: Obszerna lista czasowników wskazujących na przemieszczanie się, przybycie lub przebywanie (np. „przyleciała”, „odwiedziła”, „znalazła się”). Każdy czasownik został również sformułowany jako wyrażenie regularne z granicami słowa w celu zwiększenia precyzji.

Algorytm działał następująco: dla każdej znalezionej nazwy planety określano kontekst – fragment tekstu w promieniu 100 znaków przed i po słowie. W tym kontekście wyszukiwano dopasowania do wzorców imienia Alicji i czasowników podróży. Jeśli oba typy wzorców znajdowały się w danym kontekście, planetę uznawano za odwiedzoną. Takie podejście pozwoliło odróżnić planety, które służyły jedynie jako tło lub były wspomniane mimochodem, od tych, gdzie miały miejsce aktywne wydarzenia z udziałem Alicji.

def find_alisa_visited_planets(text, planets_list):
    if text is None:
        return [], []
    alisa_patterns = [
        r'\balicja\b', r'\balicji\b', r'\balicję\b', 
        r'\balicją\b', r'\balicjo\b' # Dodane polskie przypadki
    ]
    travel_verbs = [
        r'\bprzyleciała\b', r'\bprzylecieli\b', r'\bprzyleciał\b',
        r'\bwylądowała\b', r'\bwylądowali\b',
        r'\bodwiedziła\b', r'\bodwiedzili\b', r'\bodwiedził\b',
        r'\bodleciała\b', r'\bodlecieli\b', r'\bodleciał\b',
        r'\bbyła\b', r'\bbyły\b', r'\bbył\b',
        r'\bgościła\b', r'\bgościli\b',
        r'\bwyruszyła\b', r'\bwyruszyli\b',
        r'\bdotarła\b', r'\bdotarli\b',
        r'\bprzeleciała\b', r'\bprzelecieli\b',
        r'\bprzybyła\b', r'\bprzybyły\b',
        r'\bznajdowała się\b', r'\bznajdowały się\b',
        r'\bpodróżowała\b', r'\bpodróżowali\b',
        r'\bznalazła się\b', r'\bznalazły się\b'
    ]
    visited_planets = []
    all_planet_checks = []
    # Symulacja planet_pattern z poprzedniego etapu
    # Dla demonstracji, zakładamy, że planets_list zawiera już odfiltrowane nazwy planet
    # i dla każdej z nich szukamy kontekstu
    for planet_name_entry in planets_list:
        planet_name = planet_name_entry # Zakładamy, że to po prostu ciąg znaków z nazwą planety
        planet_pattern = r'\b' + re.escape(planet_name) + r'\b'
        planet_visits = []
        for match in re.finditer(planet_pattern, text, re.IGNORECASE):
            position = match.start()
            context_start = max(0, position - 100)
            context_end = min(len(text), position + 100)
            context = text[context_start:context_end].replace('\n', ' ')
            alisa_found = False
            for alisa_pattern in alisa_patterns:
                if re.search(alisa_pattern, context, re.IGNORECASE):
                    alisa_found = True
                    break
            verb_found = False
            matched_verb = None
            for verb_pattern in travel_verbs:
                verb_match = re.search(verb_pattern, context, re.IGNORECASE)
                if verb_match:
                    verb_found = True
                    matched_verb = verb_match.group()
                    break                     
            is_visited = alisa_found and verb_found
            visit_data = {
                'planet': planet_name,
                'position': position,
                'context': context,
                'alisa_found': alisa_found,
                'verb_found': verb_found,
                'matched_verb': matched_verb,
                'is_visited': is_visited
            }
            planet_visits.append(visit_data)
        visited = any(v['is_visited'] for v in planet_visits)
        visit_count = sum(1 for v in planet_visits if v['is_visited'])
        all_planet_checks.append({
            'planet': planet_name,
            'total_mentions': len(planet_visits),
            'visited_mentions': visit_count,
            'is_visited': visited,
            'examples': [v for v in planet_visits if v['is_visited']][:3]
        })
        if visited:
            visited_planets.append({
                'planet': planet_name,
                'total_mentions': len(planet_visits),
                'visited_mentions': visit_count,
                'examples': [v for v in planet_visits if v['is_visited']][:3]
            })
    return visited_planets, all_planet_checks

W wyniku tej analizy ustalono, że z 281 wspomnianych planet Alicja Selezniowa odwiedziła 12. Ta liczba pokazuje, jak selektywnie autor wykorzystywał geografię swojego świata, koncentrując się na kluczowych punktach przygód bohaterki, jednocześnie tworząc wrażenie obszernego i szczegółowego uniwersum dzięki licznym, choć nie zawsze odwiedzanym, wzmiankom. Dla 10-letniej dziewczynki 12 odwiedzonych planet to znaczna ilość podróży, biorąc pod uwagę konieczność łączenia ich z nauką.

Wizualizacja danych i wnioski

Końcowym etapem badania była wizualizacja uzyskanych danych. Do stworzenia interaktywnych wykresów i map podróży wykorzystano bibliotekę plotly. Wizualizacja pozwoliła przejrzyście przedstawić:

• Rozkład wszystkich wspomnianych planet.
• Mapę faktycznych podróży Alicji, pokazującą, które planety rzeczywiście odwiedziła.
• Częstotliwość odwiedzin każdej planety, co dało wgląd w najważniejsze lokalizacje w jej przygodach.

Graficzne przedstawienie danych sprawia, że wyniki analizy są bardziej dostępne i intuicyjnie zrozumiałe, pozwalając szybko ocenić skalę kosmicznych wędrówek bohaterki. Na przykład, staje się oczywiste, że niektóre planety były odwiedzane wielokrotnie, stając się kluczowymi miejscami akcji, podczas gdy inne były wspomniane tylko raz, aby stworzyć atmosferę lub rozszerzyć uniwersum.

Uzyskane dane i metody mogą być wykorzystane do dalszej analizy dzieł literackich, w tym do badania stylu autorskiego, rozwoju fabuły, a nawet do tworzenia interaktywnych encyklopedii fikcyjnych światów. Ten przypadek pokazuje potencjał analityki tekstowej w naukach humanistycznych, przekształcając duże ilości niestrukturyzowanego tekstu w cenne, ilościowe spostrzeżenia.

Kluczowe wnioski

• Zastosowanie Pythona i wyrażeń regularnych pozwala na prowadzenie pogłębionej analizy literackiej dużych ilości tekstu, ekstrahując ustrukturyzowane dane.
• Identyfikacja bytów (np. planet) wymaga iteracyjnego udoskonalania wzorców w celu wyeliminowania fałszywych trafień i uwzględnienia kontekstu.
• Analiza kontekstowa jest niezbędna do odróżnienia zwykłego wspomnienia od faktycznego działania lub wydarzenia, co jest kluczowe dla precyzyjnej interpretacji danych.
• Biblioteki re, collections, chardet i plotly są potężnymi narzędziami do analityki tekstowej i wizualizacji wyników.
• Nawet w literaturze pięknej można wydobyć i przeanalizować dane ilościowe, co otwiera nowe perspektywy dla badań w dziedzinie cyfrowych nauk humanistycznych.

— Editorial Team