# **Obdelovanje besedilnih podatkov: operacije s stringi, regularni izrazi in obdelava besedila** --- ## **Uvod** Besedilni podatki so povsod v analizi podatkov - ne glede na to, ali gre za ocene strank, dnevnike, odzive na ankete ali nestrukturirane zapiske. Za razliko od numeričnih podatkov, besedilo zahteva specializirane tehnike za ekstrakcijo, transformacijo in analizo. Pandas ponuja zmogne orodje za obdelavo besedilnih podatkov preko **operacij s stringi**, **regularnih izrazov (regex)** in **metod obdelave besedila**. V tej lekciji bomo raziskovali: 1. **Osnovne operacije s stringi** (manipulacija s primerom, razdelitev, združitev in odstranjevanje). 2. **Napredne metode s stringi** (iskanje podnizov, zamenjava besedila in ujemanje vzorcev). 3. **Regularni izrazi (regex)** za kompleksno ujemanje vzorcev. 4. **Čiščenje in normalizacija besedila** (odstranjevanje posebnih znakov, standardiziranje formatov). 5. **Praktične aplikacije** (ekstrahiranje informacij, validacija besedila in priprava podatkov za analizo). Do konca te lekcije boste lahko učinkovito manipulirali in analizirali besedilne podatke v Pandas, kar vam bo omogočilo vpogled v nestrukturirane vire. --- ## **Osnovni koncepti** ### **1. Osnovne operacije s stringi v Pandas** Pandas ponuja **vektorizirane operacije s stringi** preko dostopnika `str`, ki vam omogoča uporabo metod za stringe na celotnih serijah ali stolpcih DataFrame brez zank. To je zelo učinkovito in izkorišča optimizirano ogrodje Pandas. #### **Ključne metode za stringe** | Metoda | Opis | Primer | |--------|------------|---------| | `.str.upper()` | Pretvori vse znake v velike črke. | `df['text'].str.upper()` | | `.str.lower()` | Pretvori vse znake v male črke. | `df['text'].str.lower()` | | `.str.capitalize()` | Kapitalizira prvi znak vsakega niza. | `df['text'].str.capitalize()` | | `.str.title()` | Kapitalizira prvo črko vsake besede. | `df['text'].str.title()` | | `.str.strip()` | Odstrani vodilne in zaostale presledke. | `df['text'].str.strip()` | | `.str.lstrip()` | Odstrani vodilne presledke. | `df['text'].str.lstrip()` | | `.str.rstrip()` | Odstrani zaostale presledke. | `df['text'].str.rstrip()` | | `.str.split()` | Razdeli niz na seznam glede na ločilo. | `df['text'].str.split(' ')` | | `.str.join()` | Združi elemente seznama v en niz. | `' '.join(df['text'].str.split(' '))` | | `.str.replace()` | Zamenja podniz z drugim nizom. | `df['text'].str.replace('old', 'new')` | | `.str.contains()` | Preverja, če podniz obstaja v nizu. | `df['text'].str.contains('error')` | | `.str.startswith()` | Preverja, če niz začne z podnizom. | `df['text'].str.startswith('hello')` | | `.str.endswith()` | Preverja, če niz konča s podnizom. | `df['text'].str.endswith('world')` | | `.str.len()` | Vrni dolžino vsakega niza. | `df['text'].str.len()` | | `.str.find()` | Vrni indeks prvega pojava podniza. | `df['text'].str.find('error')` | | `.str.index()` | Podobno kot `.find()`, vendar vrže napako, če ni najdeno. | `df['text'].str.index('error')` | | `.str.count()` | Šteje pojavitve podniza. | `df['text'].str.count('a')` | --- ### **2. Napredne operacije s stringi** Poleg osnovnih metod Pandas podpira **verižene operacije**, **regularne izraze** in **lastne funkcije** za bolj kompleksno obdelavo besedila. #### **Verižanje metod za stringe** Lahko veržete več operacij za učinkovito obdelavo: ```python import pandas as pd # Primer DataFrame data = {'text': [' Hello, World! ', 'python is AWESOME', 'Data Science']} df = pd.DataFrame(data) # Verižanje operacij: odstrani presledke, pretvori v male črke, zamenjaj besedilo df['processed'] = ( df['text'] .str.strip() # Odstrani presledke .str.lower() # Pretvori v male črke .str.replace('awesome', 'great') # Zamenjaj besedilo ) print(df) ``` **Izhod:** ``` text processed 0 ' Hello, World! ' hello, world! 1 'python is AWESOME' python is great 2 'Data Science' data science ``` #### **Uporaba parametra `na` za manjkajoče vrednosti** Metode za stringe v Pandas obravnavajo `NaN` vrednosti gracialno. Lahko nadzorujete vedenje s parametrom `na`: ```python df['text'] = ['valid text', None, 'another text'] df['length'] = df['text'].str.len() # Vrne NaN za None print(df) ``` **Izhod:** ``` text length 0 valid text 10.0 1 NaN NaN 2 another text 12.0 ``` Če želite zamenjati `NaN` z privzeto vrednostjo: ```python df['length'] = df['text'].str.len(na=0) # Zamenjaj NaN z 0 ``` --- ### **3. Regularni izrazi (regex) v Pandas** Regularni izrazi so **zmogljiva orodja za ujemanje vzorcev** za obdelavo besedila. Pandas integriran regex preko dostopnika `str`, kar vam omogoča: - Ekstrahirati specifične vzorce (npr. e-poštne naslove, telefonske številke). - Validirati formate besedila (npr. preverjanje, če je niz veljavna URL). - Zamenjati kompleksne vzorce (npr. odstranjevanje posebnih znakov). #### **Ključne metode regex v Pandas** | Metoda | Opis | Primer | |--------|------------|---------| | `.str.contains()` | Preverja, če niz ujema vzorec regex. | `df['text'].str.contains(r'\d+')` | | `.str.extract()` | Ekstrahira prvi ujemanje vzorca regex. | `df['text'].str.extract(r'(\d+)')` | | `.str.findall()` | Ekstrahira **vse** ujematja vzorca regex. | `df['text'].str.findall(r'(\w+)')` | | `.str.replace()` | Zamenja besedilo, ki ujema vzorec regex. | `df['text'].str.replace(r'\d', '')` | | `.str.match()` | Preverja, če **celoten niz** ujema regex. | `df['text'].str.match(r'^\d+$')` | | `.str.split()` | Razdeli niz z uporabo vzorca regex. | `df['text'].str.split(r'\s+')` | --- #### **Pogosti vzorci regex** | Vzor | Opis | Primer ujemanja | |-------|------------|---------------| | `\d` | Ujema katerikoli cifer (0-9). | `5` v `"abc123"` | | `\D` | Ujema katerikoli ne-cifer. | `a` v `"abc123"` | | `\w` | Ujema katerikoli znak (a-z, A-Z, 0-9, _). | `a` v `"hello_world"` | | `\W` | Ujema katerikoli ne-znak. | `@` v `"user@example.com"` | | `\s` | Ujema katerikoli presledek (presledek, tab, nova vrstica). | ` ` v `"hello world"` | | `\S` | Ujema katerikoli ne-presledek. | `h` v `"hello"` | | `.` | Ujema katerikoli znak (razen nove vrstice). | `l` v `"hello"` | | `^` | Ujema začetek niza. | `H` v `"Hello"` | | `$` | Ujema konec niza. | `o` v `"Hello"` | | `*` | Ujema 0 ali več ponovitev. | `ll` v `"hello"` | | `+` | Ujema 1 ali več ponovitev. | `l+` v `"hello"` | | `?` | Ujema 0 ali 1 ponovitev. | `o?` v `"hello"` (ujema če je `o` neobvezen) | | `{n}` | Ujema točno `n` ponovitev. | `\d{3}` ujema `123` | | `{n,}` | Ujema `n` ali več ponovitev. | `\d{2,}` ujema `12`, `123` | | `[abc]` | Ujema katerikoli od `a`, `b` ali `c`. | `b` v `"abc"` | | `[^abc]` | Ujema katerikoli znak **ne** v `a`, `b` ali `c`. | `d` v `"abc"` | | `()` | Grupira vzorce za ekstrakcijo. | `(\d+)` ekstrahira `123` iz `"abc123"` | | `|` | Deluje kot operator ALTERNATIVE. | `a|b` ujema `a` ali `b` | --- #### **Praktični primeri regex v Pandas` ##### **Primer 1: Ekstrahiranje e-poštnih naslovov** ```python import pandas as pd data = {'text': ['Kontaktiranec support@example.com', 'E-pošta me at user123@gmail.com']} df = pd.DataFrame(data) # Ekstrahira e-poštne naslove z uporabo regex df['email'] = df['text'].str.extract(r'([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})') print(df) ``` **Izhod:** ``` text email 0 Kontaktiranec support@example.com support@example.com 1 E-pošta me at user123@gmail.com user123@gmail.com ``` ##### **Primer 2: Validacija številke telefona** ```python data = { 'phone': ['123-456-7890', '987.654.3210', 'invalid]} df = pd.DataFrame(data) # Preverjanje, če številka telefona ujema veljavni format (XXX-XXX-XXXX ali XXX.XXX.XXXX) df['is_valid'] = df['phone'].str.match(r'^\d{3}[-.]\d{3}[-.]\d{4}$') print(df) ``` **Izhod:** ``` phone is_valid 0 123-456-7890 True 1 987.654.3210 True 2 invalid False ``` ##### **Primer 3: Odstranjevanje posebnih znakov** ```python data = {'text': ['Price: $100', 'Quantity: 5', 'Total: $$200]} df = pd.DataFrame(data) # Odstrani vse ne-znak (razen presledkov) df['cleaned'] = df['text'].str.replace(r'[^\w\s]', '', regex=True) print(df) ``` **Izhod:** ``` text cleaned 0 Price 100 Price 100 1 Quantity 5 Quantity 5 2 Total 200 Total 200` ``` ##### **Primer 4: Ekstrahiranje hashtagov iz Tweetov** ```python data = {'tweet': ['#Python je awesome! #DataScience', 'Love #Pandas and #NumPy']} df = pd.DataFrame(data) # Ekstrahira vse hashtag (besede, ki se začnejo z #) df['hashtags'] = df['tweet'].str.findall(r'#(\w+)') print(df) ``` **Izhod:** ``` tweet hashtags 0 #Python je awesome! #DataScience [Python, DataScience] 1 Love #Pandas and #NumPy [Pandas, NumPy] ``` --- ### **4. Čiščenje in normalizacija besedila** Realni podatki besedila so pogosto **nespodobni** - obsahujejo nekonzistentno vpikovanje, posebnih znakov, posebnih karakterjev in drugih anomalijev. Čiščenje besedila vključuje standardizacijo in pripravo besedila za analizacijo. #### **Pogosti korake za čiščenje besedila |>>> | Korak | Metoda | Primer | |------|--------|---------| | **1. Spremeni v male črke** | `.str.lower()` | `"Hello".lower() → "hello"` | | **2. Odstrani nepotrebni prostorožični prostor** | `.str.strip()` + `.str.replace()` | `" hello ".strip() → "hello"` | | **3. Odstrani posebne znake` | `.str.replace(r'[^\w\s]', '', regex=True)` | `"price: $100" → "price 100"` | | **4. Odstrani številke** | `.str.replace(r'\d', '', regex=True)` | `"error123" → "error"` | | **5. Odstrani stopwords` | Uporabi `nltk.corpus.stopwords` | `"the quick brown fox" → "quick brown fox"` | | **6. Razeni kompres` | `BeautifulSoup` ali regex | `hello df = pd.DataFrame(data) def clean_text(text): if not isinstance(text, str): return "" # Convert to lowercase text = text.lower() # Remove extra whitespace text = re.sub(r'\s+', ' ', text).strip() # Remove special characters (keep letters, numbers, and basic punctuation) text = re.sub(r'[^\w\s] = '', text)text = re.sub(r'[^\w\s]', '', text) # Handle mentions (@user123) =)`text = re.sub(r'@\w+|\#\w+` # Remove emojis (...)` return text df['cleaned'] = df['text'].apply(clean_text) print(df) ```` **Izhod:```` text cleaned 0 Price: $100 (Great Deal! #Shopping price100 1} python is awesome! čist' 2 Data Science is FUN! ``_metka``oven]

Handling Text Data: String Operations, Regular Expressions, and Text Processing