DEV Community: Programozás és elemzés Olivérrel

Adattisztítás Python Pandas segítségével

Programozás és elemzés Olivérrel — Thu, 30 Apr 2026 10:57:05 +0000

Ebben a posztban a Pandas alapvető adattisztító és adat előkészítő eszközeit mutatom be. Ha nem vagy járatos a Python programozási nyelvben, ajánlom figyelmedbe ezt a posztomat. Ha a Pandas alapok nem ismerősek számodra, akkor kukkants be ide.

Mik azok a CSV fájlok

A CSV egy betűszó, ami a Comma Separated Values elnevezéshez köthető. A CSV-k olyan egyszerű szöveges állományok (plain text), amelyekben az adatokat soronként tároljuk, és az egyes értékek vesszővel, vagy egyéb elválasztókarakterrel vannak szeparálva. Sok esetben rendelkezik egy fejléc sorral, amely az adatok elnevezéseiről ad információt. Alább látható egy tipikus CSV fájl struktúra. Az első sor a fejléc, a további sorok pedig adatok, vesszővel elválasztva. Fontos, hogy a CSV kiterjesztés nem kötelező, sokszor .txt kiterjesztés látható ezeknél az állományoknál.

CSV fájlok beolvasása

A Pandas lehetőséget nyújt CSV fájlok olvasására és feldolgozására. Gyakorlásnak ilyen állományokat például a kaggle.com oldalról szerezhetsz teljesen ingyenesen. Én ezt a dataset-et használtam a beolvasásnál:
https://www.kaggle.com/datasets/benioktopiansah/global-finance-and-sales-performance

Az első, és legfontosabb dolog mindig az adatstruktúra értelmezése.

Date: az adott értékesítés vagy tranzakció dátuma
Region: a földrajzi régió, ahol az értékesítés történt (például LATAM = Latin-Amerika, APAC = Ázsia és Csendes-óceáni térség)
Product Category: az értékesített termék vagy szolgáltatás kategóriája (például Enterprise Software vagy Consulting)
Sales Channel: az értékesítési csatorna típusa, vagyis hogyan történt az eladás (például Online vagy Direct)
Revenue_USD: a teljes bevétel amerikai dollárban
COGS_USD: az eladott termékek vagy szolgáltatások közvetlen költsége amerikai dollárban (Cost of Goods Sold)
Budget_Target: az előre kitűzött bevételi vagy üzleti cél amerikai dollárban
CSAT: ügyfélelégedettségi mutató (Customer Satisfaction), általában 1–5 közötti érték
Discount_Percent: az alkalmazott kedvezmény százalékos mértéke

Az alábbi kóddal tudunk CSV fájlokat beolvasni Pandas segítségével:

import pandas as pd

df = pd.read_csv("global_finance_sales_dataset_1200_rows.csv")

Alapadatok kinyerése

A következőkben az alapadatok kinyerésével fogunk foglalkozni. Az alábbi kód a sorok és oszlopok számát adja vissza.

#sorok és oszlopok száma
print(df.shape) #(1200, 9)

A következő kódsorok mutatják az adattípusokat:

print(df.dtypes)

Ilyen típusok találhatók a csv fájlban:

str: karakterlánc (string)
int64: egész szám (64 bites integer)
float64: tört szám (64 bites tört)

A következő kódsor automatikusan kiszámolja a legalapvetőbb statisztikai mutatókat.

print(df.describe())

count: hány darab van
mean: átlag
std: szórás
min: minimum
25%: első kvartilis (az adatok 25%-a ennél az értéknél kisebb)
50%: második kvartilis
75%: harmadik kvartilis
max: maximum érték

A Pandas lehetővé teszi az egyes metódusok láncolását (chaining). Ha szimplán csak az isnull metódust hívnánk meg az adatkészletre, az minden egyes sorban és oszlopban (lényegében cellákban) egy True vagy False értéket jelenítene meg attól függően, hogy az adott sor üres-e vagy sem. A sum aggregálja ezeket az eredményeket oszloponként, tehát azt adja meg, hogy az adott oszlopokban hány null érték volt megtalálható. Én magam kézzel kitöröltem bizonyos értékeket, így keletkeztek nálam nullától eltérő értékek. Ezt te magad is megteheted.

print(df.isnull().sum())

A duplikált értékek kiszűrése lényeges lépés. Erre is létezik megoldás a Pandas-ban. Ne feledjük, hogy ez nem jelent megoldást a duplikátumokra, csupán jelzi, hogy léteznek! Én kézzel lemásoltam egy sort, hogy legyen ilyen a datasetben.

print(df.duplicated().sum())

Az adatok tisztítása

Négy alapvető hiba szokott lenni az adatokban, amelyek rossz eredményre vezethetnek.

hiányzó adatok
duplikált/többszörözött sorok
kiugró értékek
dátum oszlopok konvertálása

Hiányzó adatok

Ha hiányzik egy adat, akkor általában véve vagy az átlaggal, vagy a mediánnal töltjük fel az adott cellát, de akár törölhetjük is a teljes sort. Úgy vélem, hogy teljes sort csak akkor érdemes törölni, hogyha kevés adat hiányzik. Ebben az esetben a sor törlése nem okoz komoly problémát. Most kevés adat nincs meg, de ennek ellenére nem fogok törölni, ami mögött pedagógiai szándék rejlik.
Lényeges különbség az átlag és a medián között, hogy az átlag érzékenyebb az eloszlás szimmetriájára, vagy a kiugró értékekre, emiatt a medián általában véve jobban reprezentálja az adatokat.
Itt jönnek képbe az alakmutatók, jelen esetben az alakmutatók. Ezek csúcsosságot és aszimmetriát képesek mérni. Ha egyetlen adat aszimmetriáját szeretném kalkulálni, akkor így járhatok el:

print("aszimmetria\n", df['Revenue_USD'].skew()) #0.042

A Pandas skew metódusa alapértelmezetten a Fisher-Pearson-féle mutatót számolja ki. Negatív értékek esetében bal, pozitív értékeknél jobb oldali aszimmetria van. Tehát, ha jobbra nyúlik az eloszlás szára, akkor pozitív értéket kapunk. A -1 alatti és 1 fölötti értékek jelentős aszimmetriára utalnak. -0.5 és 0.5 között az aszimmetria nem jelentős. A 0.042-es érték meglehetősen alacsony.

Ilyen a jobb oldali aszimmetria (jobbra nyúló szár):

Ilyen a bal oldali aszimmetria (balra nyúló szár):

A csúcsosság mérésére a "kurt" metódus való. Az eloszlás csúcsossága azt írja le, hogy az adatok milyen mértékben koncentrálódnak a középérték körül. Nagy koncentráció csúcsosabb eloszlást eredményez. A Fisher-féle csúcsossági mutató esetében a normál eloszlás értéke nulla. A nullánál kisebb számok laposabb, a nagyobbak csúcsosabb eloszlást feltételeznek.
A -1.07-es érték laposabb eloszlást jelöl. Ezt egyetlen ismérvre így tudod használni:

print("csúcsosság:\n", df[['Revenue_USD']].kurt()) #-1.07

Nade, akkor hogyan is pótoljuk a mediánnal, vagy az átlaggal az adatokat?
A "select_dtypes" metódus képes bizonyos típusú adatokat, pontosabban azok indexeit kiválasztani. Az adattípust az "include" paraméterben lehet kiválasztani. Az alábbi példában a szám (number) típusú adatokat választottuk ki. A print így néz ki:

num_cols = df.select_dtypes(include='number').columns
print(num_cols)
df[num_cols] = df[num_cols].fillna(df[num_cols].median())

Ha kézzel akarnánk megadni több mezőt, akkor ezt kéne tennünk. Itt direkt az átlagot választottam a pótlásra, hogy megmutassam azt is:

df[['Revenue_USD', 'COGS_USD']] = df[['Revenue_USD', 'COGS_USD']].fillna(df[['Revenue_USD', 'COGS_USD']].mean())

A statisztikai mutatók számításakor a Pandas automatikusan figyelmen kívül hagyja a hiányzó értékeket, így a valós eloszlást látjuk. A legtöbb esetben érdemes először megnézni az eloszlást, és utána pótolni az értékeket.

Ha kategorikus oszlopban szeretnénk kitölteni a hiányzó adatokat, akkor azt így tehetjük meg. Ha hiányzik egy régió, akkor azt feltöltjük az 'Unknown' karakterlánccal.

df['Region'] = df['Region'].fillna('Unknown')

Duplikált sorok

A duplikált sorokat a következőképpen eliminálhatjuk:

df = df.drop_duplicates()

Kiugró értékek eltávolítása

A kiugró értékek kezelésére az IQR-módszert (vagy más néven Tukey-féle korlátokat) alkalmaztam. Ez a számítás az interkvartilis tartomány 1.5tel való szorzatát használja fel arra, hogy kijelölje az alsó és felső küszöbértékeket, amelyeken kívül eső adatokat kiugrónak tekintjük.

Q1 = df['Revenue_USD'].quantile(0.25)
Q3 = df['Revenue_USD'].quantile(0.75)
IQR = Q3 - Q1
lower = Q1 - 1.5 * IQR
upper = Q3 + 1.5 * IQR
df = df[(df['Revenue_USD'] >= lower) & (df['Revenue_USD'] <= upper)]

Próbáljuk meg értelmezni a kódot! A quantile(0.25) az alsó kvartilist adja vissza. Ennél az értéknél az adataink negyede kisebb. A felső kvartilis természetesen azt jelenti, hogy az adataink negyede nagyobb annál az értéknél, tehát háromnegyede kisebb. Az utolsó sor az úgynevezett vektoralapú szűrés, vagy más néven maszkolás. Itt annyit állítottunk be, hogy a DataFrame-ben a lower értéknél ne legyen kisebb, és az upper értéknél ne legyen nagyobb. Az & operátor a bitenkénti ÉS, jelen példánál azt jelenti, hogy a bal és jobb oldali kifejezések mindegyikének igaznak kell lennie az adott értékekre vonatkozóan.

Dátumok kezelése

A Pandas a legtöbb esetben automatikus típuskonverziót végez. A dátumoknál viszont ezt a szívességet nem teszi meg magától. Ha dátumműveleteket akarunk elvégezni, ahhoz az szükséges, hogy a string típusból date legyen.
Ezt a feladatot így abszolválhatjuk:

df['Date'] = pd.to_datetime(df['Date'], errors='coerce')

Valójában a dátumokat is be tudja olvasni helyes típusként már a beolvasás pillanatában, ha használod a parse_dates=['Date'] paramétert a read_csv() függvényben.

Az errors paraméter azt határozza meg, hogy mi történjen, amennyibe hibás értéket talál a Pandas. Három lehetőség van:

raise: Megáll a kód, hibát dob, és leáll a kód.
ignore: Megtartja az eredeti értéket.
coerce: Lecseréli az értéket NaT-ra. (Not a Time.)

Ha a típuskonverziót követően megnézzük a DataFrame-ünk oszlopainak típusait, akkor ez a látvány fogad bennünket:

Python Pandas alapok

Programozás és elemzés Olivérrel — Tue, 28 Apr 2026 11:03:41 +0000

Ez a blogbejegyzés a Python egyik adatelemző könyvtáráról, a Pandasról szól. A Pandas lehetővé teszi, hogy feldolgozz, tisztíts és statisztikailag elemezz adatokat. A Pandas elnevezés egyaránt utal a "Python Data Analysis" és a "Panel Data" kifejezésekre.

A Pandas adatszerkezetei

Series

A Pandas "series-ek" olyanok, mint oszlopok egy táblázatban. Tudunk Python listákból, és szótárakból (dictionary) generálni ilyen adatszerkezeteket. Ahhoz, hogy használjuk a Pandas funkcióit, először importálnunk kell a könyvtárat. Az "as pd" kifejezés egy aliast hoz létre, hogy ne "pandas", hanem egy rövidebb "pd" elnevezéssel tudd elérni a Pandas metódusait.

import pandas as pd

my_list = [1,2,3]
my_series = pd.Series(my_list)
print(my_series)

A print-et követően nagyjából az alábbi kép fog minket fogadni. Az első oszlop értékei valójában indexek, amikkel hivatkozni lehet az egyes sorokra. Az indexelés lényegében sorszámozás nullától kezdve. Tehát, a nulladik indexen az egyes szám látható. Ez logikus is a listánk alapján. A dtype: int64 az adattípust jelöli, ami jelen esetben 64 bites egész szám. Itt minket nem a 64 bit, hanem sokkal inkább az egész szám érdekel. A bitek száma a lefedett intervallum nagyságát jelenti. 64 bites egészek esetében például a legmagasabb szám, amit tárolni tudunk ennyi: 9 223 372 036 854 775 807

Ha csak az első (tehát nulladik indexű elemmel akarunk foglalkozni), akkor erre a következőképpen tudunk hivatkozni:

my_list = [1,2,3]
my_series = pd.Series(my_list)
print(my_series[0]) #ez a szám jelenik meg: 1
print(my_series.get(0)) #szintén az egyes jelenik meg
print(my_series.iloc[0]) #újfent az egyes szám jelenik meg

A python szótárak (dictionary) lényegében kulcs-értékpárok. Úgy lehet elképzelni őket, mint listákat, ahol az indexek nem számok, hanem karakterláncok.

student_scores = {
    "Anna": 88,
    "Bob": 92,
    "Adam": 79,
    "Caroline": 95,
    "David": 84
}

#például így tudunk hivatkozni egy kulcsra
print(student_scores["Anna"])

#ez egy másik módszer
print(student_scores.get("Anna"))

Ha ebből létrehozunk egy Series-t, akkor az egész számú indexelés helyett címkézett indexelést kapunk. A címkék felfoghatók egyfajta kulcsokként is.

student_scores = {
    "Anna": 88,
    "Bob": 92,
    "Adam": 79,
    "Caroline": 95,
    "David": 84
}

student_score_series = pd.Series(student_scores)
print(student_score_series)

Az iloc nullától számolt sorszám alapú indexelést használ, és nem az egyes sorok címkéit függetlenül attól, hogy beállítottunk-e címkéket, vagy sem.

student_scores = {
    "Anna": 88,
    "Bob": 92,
    "Adam": 79,
    "Caroline": 95,
    "David": 84
}

student_score_series = pd.Series(student_scores)
print(student_score_series["Anna"])
print(student_score_series.get("Bob"))
print(student_score_series.iloc[0])

Hozzárendelhetünk címkéket is listákhoz az alábbi módon. Ebben az esetben ugyanazt kapjuk eredményül, mint a korábbi szótáras példánál.

student_scores = [88,92,79,95,84]

student_score_series = pd.Series(
    student_scores, 
    index=["Anna", "Bob", "Adam", "Caroline", "David"]
)

DataFrame

A DataFrame-et úgy lehet elképzelni, mint egy táblázatot. Itt az egyes szótár sorok oszlopokká válnak, és az oszlopok fejlécei a "Name", "Age" és "Score" címkék lesznek. Amint látható, az oszlopok értékeit a szótár soraiban lévő listák adják. Így az első sor értékei a következők:
"Anna", 21, 88

student_data = {
    "Name": ["Anna", "Bob", "Caroline", "David", "Emma"],
    "Age": [21, 22, 20, 23, 21],
    "Score": [88, 92, 95, 84, 90]
}

students_age_and_score = pd.DataFrame(student_data)

print(students_age_and_score)

Természetesen a DataFrame-eknek is létrehozhatunk címkéket a sorok számára. Figyeljük meg, hogy a sorokhoz tartozó címkék maguk a nevek lesznek!

student_data = {
    "Age": [21, 22, 20, 23, 21],
    "Score": [88, 92, 95, 84, 90]
}

students_age_and_score = pd.DataFrame(student_data, index=["Anna", "Bob", "Caroline", "David", "Emma"])

print(students_age_and_score)

Ami az egyes adatok címzését jelenti, használhatjuk az oszlopok címkéit az alábbi módokon. Nyilván itt az "Age" oszlopot kapjuk vissza, tehát így címzünk név alapján oszlopot.

print(students_age_and_score["Age"])
print(students_age_and_score.get("Age"))

A loc a location rövdidítése. A loc és az iloc segítségével elsősorban sorokat címezhetünk, de a későbbiekben mutatok példát arra is, hogyan szűkítsünk oszlopokra velük. A loc és az iloc között az a differencia, hogy az iloc úgynevezett integer location, tehát indexeket használ. Példának okáért Bob indexe az egyes.

print(students_age_and_score.loc["Bob"])
print(students_age_and_score.iloc[1])

A következő megoldások az első és a második sort címzik.

print(students_age_and_score.iloc[[0,1]])
print(students_age_and_score.loc[["Anna", "Bob"]])

Az alábbi példában Anna és Bob score-ját kapjuk vissza, tehát a loc első paramétere a sorokat, a második az oszlopokat jelöli. Az iloc-nál a "0:2" szintaxis furcsa lehet számodra. Ez annyit tesz, hogy a nullástól a kettes indexig úgy, hogy a kettes már nem számít bele. Ennyire egyszerű.

print(students_age_and_score.loc[["Anna", "Bob"], ["Score"]])
print(students_age_and_score.iloc[0:2, [1]])

A következő részben szöveges állományokat fogunk beolvasni, és alapvető statisztikai mutatókat kalkulálni, mint a szórás és a korreláció.

Python alapok szoftverhasználóknak I.

Programozás és elemzés Olivérrel — Mon, 27 Apr 2026 07:26:38 +0000

Ez a blogposzt azok számára született, akik eddig szoftvereket (Excel, Power BI, SPSS) használtak adatelemzési célra, de gondolkodnak azon, hogy áttérnek egy programozási nyelvre. A Python remek választás erre a feladatra, hiszen egy széles körben elterjedt, általános célú programozási nyelvről van szó, amelyhez rendkívül sokrétű statisztikai könyvtárakat fejlesztettek. A Python ipari sztenderddé vált, és a munkaerőpiacon nagyon keresett.

Hogyan telepítsd a Python-t

Windows

Mielőtt elkezdenél kódolni, szükséged lesz magára a Python értelmezőre. A telepítés viszonylag egyszerű, látogass el a Python hivatalos weblapjára:
https://www.python.org/
Töltsd le a 3.x-es verziót, és telepítsd az installerrel. Fontos, hogy add hozzá a környezeti változókhoz a Python könyvtárat, hogy bárhol el tudd érni az interpretert! Ezt úgy teheted meg, hogy telepítéskor bepipálod az "add Python to path" opciót. Ha nem pipáltad be, akkor sajna kézzel hozzá kell adnod a környezeti változókhoz a Python könyvtárat. Erről például itt olvashatsz bővebben:
https://realpython.com/add-python-to-path/

Linux

Linuxon nyiss egy terminált, és frissítsd a csomaglistát az alábbi paranccsal:

sudo apt update

Ezt követően telepítsd a Python-t:

sudo apt install python3

Fontos, hogy az eltérő disztribúciókban eltérő parancsok lehetnek érvényben.

Python kód futtatása

Személy szerint én a Visual Studio Code nevű szoftvert használom a legtöbbször, amelyet itt tudsz elérni:
https://code.visualstudio.com/

Változók

Én mindig úgy szoktam magyarázni a változókat, hogy ezek tulajdonképpen nevesített értékek. (Ez nem hivatalos terminológia.) Egy névhez kötünk egy (vagy adott esetben több) értéket. A változók rendelkeznek úgynevezett típusokkal. A típus fogalmát úgy a legegyszerűbb megérteni, hogyha elképzelsz egy űrlapot. Az űrlapon többféle adat található, mint például:

név (karakterlánc)
születési év (egész szám)
testsúly (tört szám)
dohányzik-e (logikai érték tehát igen, vagy nem)
üresen hagyott mező (None)

A karakterláncot hívjuk string-nek, az egész számot int-nek a tört számot float-nak és a logikai változót bool-nak. Létezik a "semmi" típus is, ami a None. A változóknak nevet kell adnunk, amelyek tartalmazhatják az ábécé (már nem csak angol ábécé) kis és nagybetűit, számot és alsóvonást. Habár technikailag helyes az ékezetes változónevek alkalmazása, ugyanakkor szakmai szempontból erősen ellenjavallott! A szám nem lehet elöl. Nem alkalmazhatunk lefoglalt kulcsszavakat változónévként.

name = "Kiss János"
birth_year = 1995
weight = 70.5
smoking = True
nothing = None

Tipikus helytelen változónevek.

2name = "Kiss János"
birth-year = 1995
for = 70.5

Néhány fontos megjegyzés:

A string változók értékeit egyszeres, vagy kétszeres aposztrófba írjuk.
A törteknél tizedespontot, és nem vesszőt alkalmazunk!!!
A bool értéke lehet True és False
Ezeken kívül is léteznek változó típusok, ezek csak a legalapvetőbbek.

Operátorok és műveletek

Nem szeretném definiálni a művelet kifejezést, elég annyi, hogy ez egy meglehetősen sokrétű dolog. Műveletnek minősül például az értékadás egy változónak, vagy két változó értének összeadása. Az operátorok azok a szimbólumok, amelyekkel műveleteket végzünk. Az angol nyelvű szakirodalomban néha másképpen bukkan fel az operátorok kategorizálása, mint a magyar nyelvűben. Ne aggódj, igyekszem mindegyikre mutatni példát, ami nem egyértelmű, de nem feltétlenül sorolom fel az összeset, inkább csak azokat, amelyeket gyakran használjuk.
A kategóriák a következők:

aritmetikai operátorok: +,-,*,/,//,%,**
értékadó operátorok: =, +=, -=, *=, /=, %=
összehasonlító/relációs operátorok: ==, !=, <,<=,>,>=
logikai operátorok: and, or, not
azonossági/identitás operátorok: is, is not
tagsági operátorok: in, not in
bit operátorok: &, |, ^, ~, <<, >>

Az első furcsa operátor a százalékjel (%) lehet számodra. Ez itt nem százalékszámítást, hanem maradékos osztást jelent. A print függvény képes különböző értékeket megjeleníteni a konzolon, akár változók értékeit is.

remainder = 12 % 5
print(remainder) #jelen esetben ez fog megjelenni: 2

Eljött az idő, hogy beszéljünk a kommentelésről. A komment, magyarul megjegyzés olyan külön jelölt rész a kódban, amelyet az interpreter (a program, amely végrehajtja a kódot) nem vesz figyelembe. Kétfajta kommentelés létezik.

"""
Így akár több sorban is tudunk kommentelni.
Bővebb magyarázatokhoz szoktuk használni.
"""
remainder = 12 % 5 #egysoros komment, hogy az eredmény itt 2

Fontos megyjegyezni, hogy amit többsoros kommentnek hívtam, technikailag akként is tud funkcionálni, és a legtöbben így nevezik, de ez valójában egy úgynevezett "docstring", és kiértékeli a Python.

Na, de nézzük tovább a többi operátort! A kettős csillag (**) a hatványozás. A bal oldalon található a hatványalap, a jobb oldalon pedig a kitevő.

result = 2**4 #16

A // operátor az úgynevezett "floor division", tehát az az osztás, amikor csak az egész részt kapjuk vissza akkor is, ha matematikailag törtszám jönne ki.

result = 7 // 2 #3

Nézzük a += operátort! A += lerövidíti azt, amikor a változó önmaga értékét kapja, plusz egy másik értéket. Az alább láthatod a műveletek eredményeit. Az a változón ugyanazt végeztük el, mint a b változón, így pontosan ugyanazt az értéket kaptuk vissza. A /=, *= és a többi is ugyanezzel a logikával működik.

a = 5
a = a + 2 #7
b = 5
b += 2 #b=7

A == operátor nem értékadást jelent, hanem annak az ellenőrzését, hogy az adott érték megegyezik-e egy másikkal. Az eredménye mindig egy bool érték lesz. A != éppen az ellentettjét fogja visszaadni annak, amit a ==.

bo1 = 5 == 5 #True
bo2 = 5 != 5 #False

A többi relációs operátort már feltehetőleg ismered matematikai tanulmányaidból. Fontos, hogy a < és a <= között az a differencia, hogy a <= egyenlőséget is megenged, míg a < nem. A többit szerintem kitalálod. :)

Logikai műveletek

Három alapvető logikai műveletet már kezdő programozóként is ismerned kell, ezek a következők:

negáció (tagadás)
konjunkció (logikai ÉS)
diszjunkció (logikai VAGY)

Ezen műveleteket Pythonban a "not" az "and" és az "or" operátorokkal érheted el. A logikai műveletek végeredménye mindig logikai érték, tehát vagy True, vagy False. A logikai műveletekhez társíthatunk úgynevezett igazságtáblákat, amelyek azt mondják meg, hogy a vizsgált logikai állítások igazságának függvényében milyen eredményt adnak a műveletek. Vegyünk egy példát.

NOT

A NOT (negáció, tagadás) az igazból hamisat, a hamisból pedig igazat hoz létre.

A	NOT A
1	0
0	1

x = True
print(not x) # False

AND

Az AND (konjunkció, ÉS) művelet akkor ad igaz eredményt, ha minden vizsgált feltétel igaz. Ha bármelyik (vagy mindegyik) hamis, az eredmény is hamis lesz. Olyan ez, mint egy belépési feltétel. Csak akkor mehetsz be, ha van jegyed ÉS betöltötted a 18-at.

A	B	A AND B
1	1	1
1	0	0
0	1	0
0	0	0

has_ticket = True
is_adult = False

can_enter = has_ticket and is_adult
print(can_enter) # False

OR

Az OR (diszjunkció, vagy) művelet akkor ad igazat, ha a feltételek közül legalább az egyik igaz. Csak akkor kapunk hamis értéket, ha minden vizsgált állítás hamis. Például akkor kapsz kedvezményt, ha diák vagy VAGY ha elmúltál 65 éves.

A	B	A OR B
1	1	1
1	0	1
0	1	1
0	0	0

is_student = True
is_senior = False

gets_discount = is_student or is_senior
print(gets_discount) # True

A többi operátorról későbbi bejegyzésekben lesz szó, konkrét példákkal bemutatva.

Ami a NumPy-ból hiányzik: Cramer-féle V

Programozás és elemzés Olivérrel — Thu, 23 Apr 2026 15:32:15 +0000

Az előző blogbejegyzésemben A Cramer-féle asszociációs együtthatót mutattam be egy egyszerű példán keresztül. A NumPy alapból nem tartalmazza ezt a számítást, így implementáltam egy megoldást, hogy bemutathassam a NumPy komolyabb szintű használatát is. A NumPy alapokról itt olvashatsz a blogomon.

Cramer-V NumPy implementáció

Az adatszerkezet értelmezése

Ahhoz, hogy értsd az adatszerkezetben lévő adatokat, mindenképpen érdemes nézni a hivatkozott blogbejegyzést, mivel a számokat a blogbejegyzésben lévő példából vettem. Az alap egy 2x4-es mátrix (NumPy array). Fontos, hogy összegezni kellene a sorokat, és az oszlopokat, hogy megkapjuk az úgynevezett kontingenciatáblázatot még, ha részletekben is. (Külön az eredeti, külön az összesített adatok.)

table = np.array([
    [6,4],
    [6,4],
    [7,5],
    [35,32]
])

Sorok és oszlopok összegzése

Az alábbi kódblokkban a táblázat sorainak és oszlopainak összegzése látható. Ehhez a sum metódust alkalmaztam. Az axis nevesített paraméter az összegzés tengelyét jelenti. Az 1-es a sorokat összegzi, míg a 0-ás az oszlopokat.

row_totals = table.sum(axis=1)
col_totals = table.sum(axis=0)
N = table.sum()

Ezek az értékek fognak kijönni:
rows_total = [10, 10, 12, 67]
cols_total = [54, 45]
A végeredmény két vektor lesz a sorok és oszlopok összegzéséről. Kiszámoltam még az értékek összegét is, amelyet az N változó tárol. Erre a későbbiek során szükségünk lesz.

Diadikus szorzat (outer product)

A diadikus szorzat, vagy angolul outer product kiszámítása során az egyik vektort transzponáljuk (elforgatjuk 90 fokkal). Így lehet elképzelni:

\underline{a} \cdot \underline{b}^T

Látszik, hogy az alábbi példában az elso sor elso oszlop eleme 10*54=540 lett. Az első sor második oszlop eleme 10*45=450. Tehát egyszerűen az egyik vektor értékeit minden másik vektorbeli értékkel összeszorozzuk. Az eredmény ebben a konkrét esetben 2x4, azaz 8 elem lesz.

	54	45
10	540	450
10	540	450
12	648	540
67	3618	3015

Független értékek előállítása

Az alábbi kód előállítja azokat az értékeket, amelyek a függetlenséghez szükségesek. Az outer egyszerűen csak a két vektor összes lehetséges szorzatát adja vissza. Ha belegondolsz a műveletek sorrendje mindegy is. Lényegtelen, hogy először szorzunk, aztán osztunk le, vagy fordítva. Az ne tévesszen meg, hogy egy sorban vannak a műveletek! Valójában számonként megy végbe a szorzás és az osztás is, nem aggregálás történik.

expected = np.outer(row_totals, col_totals) / N

Az eredmény valahogyan így fog kinézni:

	54	45
10	540/99 = 5.45	450/99 = 4.55
10	540/99 = 5.45	450/99 = 4.55
12	648/99 = 6.55	540/99 = 5.45
67	3618/99 = 36.55	3015/99 = 30.45

χ² érték kiszámolása

Az alábbi sorral fogjuk kiszámolni χ² értékét. A sum metódussal összegezzük is egyből a kalkulált értékeket. Ha nem emlékeznél a képletre, akkor az így néz ki:

\chi^2 = \Sigma \frac{(f_{ij} - {f^\ast}_{ij})^2}{f^\ast \footnotesize{ij}}

Itt pedig a kód:

chi2 = ((table - expected) ** 2 / expected).sum()

Cramer-féle asszociációs együttható

Most már csak egyetlen lépés van hátra, a Cramer-féle együttható kalkulációja. A table.shape visszaadja a táblázat sorainak és oszlopainak számát.

r, c = table.shape
np.sqrt(chi2 / (N * min(r - 1, c - 1)))

A teljes számítás függvény alakban

A függvény kialakítása során hibakezelést is végeztem. Ahhoz, hogy egy táblázat kontingenciatáblázat legyen, és több ismérv szerint tudjunk kapcsolatot számolni, nyilván szükséges, hogy mind a sorok, mind az oszlopok száma legalább kettő legyen.

if r < 2 or c < 2:
        raise ValueError("Cramer's V requires at least a 2x2 contingency table.")

Ha bármelyik érték negatív a táblázatban, akkor teljesen értelmetlenek az adatok, hiszen itt gyakoriságokról van szó.

if np.any(table < 0):
        raise ValueError("Contingency table cannot contain negative values.")

Az alábbi kódblokkban azt ellenőrzöm, hogy az értékek összege kisebb-e, vagy egyenlő, mint nulla. Nulla csak akkor lehet, hogyha minden érték nulla, a negatív számokat pedig alapból kiszűrtük, tehát negatív érték itt elő sem fordulhatna. Elméletben elég lenne annyit ellenőrizni hogy N értéke egyenlő-e nullával. Ettől függetlenül szerintem maradhat a megoldás. Neked mi a véleményed erről a kérdésről?

if N <= 0:
        raise ValueError("Total count must be greater than zero.")

Az utolsó ellenőrzés azt hivatott kiszűrni, hogy a számolt várható értékek (függetlenséghez szükséges értékek) között ne legyen nulla. Ez akkor következhet be, hogyha egy-egy sorban, vagy oszlopban csak nullás értékek találhatók az eredeti táblázatban. Mivel ilyenkor nullosztó hibát kapnánk, ezért dobunk kivételt.

if np.any(expected == 0):
        raise ValueError("Expected frequencies contain zeros. Cannot compute chi-square.")

A teljes kód pedig itt olvasható:

import numpy as np

def cramers_v(table):
    r, c = table.shape

    if r < 2 or c < 2:
        raise ValueError("Cramer's V requires at least a 2x2 contingency table.")

    if np.any(table < 0):
        raise ValueError("Contingency table cannot contain negative values.")

    row_totals = table.sum(axis=1)
    col_totals = table.sum(axis=0)
    N = table.sum()

    if N <= 0:
        raise ValueError("Total count must be greater than zero.")

    expected = np.outer(row_totals, col_totals) / N

    if np.any(expected == 0):
        raise ValueError("Expected frequencies contain zeros. Cannot compute chi-square.")

    chi2 = ((table - expected) ** 2 / expected).sum()

    return np.sqrt(chi2 / (N * min(r - 1, c - 1)))

Amikor nem működik a korreláció I.

Programozás és elemzés Olivérrel — Wed, 22 Apr 2026 15:22:39 +0000

Vannak esetek, amikor két ismérv között nem számolhatunk Pearson-féle lineáris korrelációt. A kapcsolat szorossága kiszámításának módját az határozza meg, hogy az ismérveink minőségi, vagy mennyiségi ismérvek. Ha az ismérveink kvalitatívak, akkor asszociációs kapcsolatról beszélünk, és Cramer-féle asszociációs együtthatót számolunk. (Tehát, ha két minőségi ismérv szerinti kapcsolat szorosságát mérnénk.) De előtte nézzünk meg egy alapvető statisztikai fogalmat, a mérési skálát!

Mérési skála

Nominális skála: Az sokaság elemei között nincs sorrendiség, az adatok csak kategóriákat jelölnek (pl. hajszín, nem, postai irányítószám).
Ordinális skála: A sokaság elemei csoportokba vannak sorolva, és a csoportok között létezik sorrendiség, de a különbségek nem számszerűsíthetőek (pl. hotelek csillagjai, iskolai végzettség).
Intervallum skála: Az elemek valamilyen mérés szerint sorba rendezettek, és választ tud adni a "mennyivel több" kérdésre, de a "hányszor annyira" nem. Ennek oka, hogy nincs abszolút nulla pontja, a nulla csak egy kijelölt pont és nem a tulajdonság hiányát jelenti (pl. Celsius-fok, naptári év). Ha nulla pénzem van, akkor nincs pénzem. Ha nulla Celsius fok van, attól még a hőmérséklet létező dolog.
Arány skála: Rendelkezik az intervallum skála tulajdonságaival, de van egy természetes nulla pontja, így a "hányszor több" kérdésre is választ ad (pl. magasság, súly, jövedelem).

A nominális és ordinális skálák minőségi, az intervallum és arány skálák mennyiségi ismérveket feltételeznek.

Cramer-féle asszociációs együttható

Példánkban azt fogjuk elemezni, hogy mennyire erős a kapcsolat szorossága a nem és betöltött munkakör között. A számítás maga nagyon egyszerű és intuitív. A könnyebb érthetőség kedvéért nem feltétlenül fogom minden esetben követni a tankönyvi terminológiát.
A Pearson-féle korrelációhoz először is átlagot kellene kalkulálnunk. Amint ránézünk a táblára láthatjuk is, hogy miért nem lehet egyik ismérv szerint sem például átlagot számolni. Mit mondana el például az oszlopok átlaga? Olyan értékekből logikus átlagot számítani, amelyeknél van értelme az értékek különbségének, például árak, eladási mennyiségek vagy magasságok. A "HR specialist" nem kevesebb, vagy több, mint a "Sales manager".

Foglalkozás	Férfiak	Nők	Összesen
HR Specialist	6	4	10
Product Manager	6	4	10
Sales Manager	7	5	12
Software Engineer	35	32	67
Összesen	54	45	99

Számoljunk!
Az alábbi táblázatban most még számodra értelmezhetetlen számok találhatók. Ne aggódj, ez nem marad sokáig is! Nézzük meg, hogy jött ki a férfiak független oszlop, első sorának értéke! 54 férfi van összesen, az ő arányuk a teljes populációban:
54/99 ≈ 0.545
Ha ezt megszorozzuk a HR specialisták számával (10), egy olyan értéket kapunk, ahol a férfiak teljes populáción belüli arányához igazodik a férfi HR specialisták száma. Így jön ki az 5.45-ös érték. (Ez a függetlenséghez szükséges várható érték.) A következő sor értéke ugyanez lesz, hiszen a product manager-ek száma is 10. Az azt követő szám így jön ki:
54/99 * 12 ≈ 6.55
Pontosan ugyanezzel a logikával számoljuk ki a nők független oszlop számait is.

Foglalkozás	Férfiak független	Nők független	Férfiak eltérés	Nők eltérés
HR Specialist	5.45	4.55	0.06	0.07
Product Manager	5.45	4.55	0.06	0.07
Sales Manager	6.55	5.45	0.03	0.04
Software Engineer	36.55	30.45	0.07	0.08
Összesen			0.22	0.26

A nők eltérés és férfiak eltérés oszlopokban a valós érték (első táblázat) és az "független" érték közötti differenciák négyzetét osztottam le az "független" értékkel.

\frac{(tényleges - független)^2}{független}

Példa:

\frac{(6 - 5.45)^2}{5.45} \approx 0.06

Az így keletkezett oszlopok értékeit mind a férfiaknál (férfiak eltérés), mind a nőknél (nők eltérés) összesítettem. Ha valakit érdekel a képlet, akkor az így néz ki:

\chi^2 = \Sigma \frac{(f_{ij} - {f^\ast}_{ij})^2}{f^\ast \footnotesize{ij}}

ahol:

i=sor
j=oszlop
fij=tényleges érték
f*ij="független érték"

Cramer-féle asszociációs együttható

A Cramer-féle képlet a következő:

\sqrt{\frac{\chi^2}{N \cdot \min(r-1, c-1)}}

ahol:
N=elemek száma
r=sorok száma (rows)
c=oszlopok száma (cols)
min=legkisebb érték

Tehát a χ² értékét osztjuk le az elemszám, és a sorok száma -1, valamint az oszlopok száma -1 közül a kisebbel, és az egészből négyzetgyököt vonunk.
Az eredmény a következő:

\sqrt{\frac{0.48}{99 \cdot 1}} \approx 0.069

Az eredmény értelmezése

A Cramer-féle együttható értéke nulla és egy között alakulhat, tehát ez egy standardizált mutató. Az "1" jelenti a függvényszerű kapcsolatot, a "0" a függetlenséget tehát, hogy nincs összefüggés az ismérvek között. A 0.069 rendkívül gyenge, elhanyagolható érték, amely azt sugallja, hogy nincs érdemi kapcsolat a nem és a munkakör között.

Python NumPy alapok

Programozás és elemzés Olivérrel — Tue, 21 Apr 2026 07:43:25 +0000

A Numpy rendkívül fontos eszköz mind az adatelemzésben, mind pedig az AI világában. Rengeteg alapvető statisztikai eszközt tartalmaz, amiért érdemes használni és, mivel egy programozási nyelven belül alkalmazzuk, ezért tetszőleges algoritmusokat írhatunk segítségével. A következő statisztikai mutatókat és megoldásokat fogjuk megnézni ebben a cikkben:

minimum és maximum érték
átlag
módusz
medián
kvartilisek
interkvartilis terjedelem
szórás
relatív szórás
outlierek kiszűrése
korreláció
kovariancia

Ha nem vagy tisztában ezekkel a fogalmakkal, akkor az alábbi két blogbejegyzést érdemes elolvasnod, amelyek több információt tartalmaznak, mint amire a címekből lehet következtetni.

A könyvtárak telepítése

Blogbejegyzésemben feltételezem, hogy fel van már nálad telepítve a Python megfelelő verziója és ismered a Python alapokat. Ha nem, akkor millió kiváló forrás létezik a Python programozási nyelv alapjainak elsajátítására. A könyvtár telepítéséhez Windowson nyisd meg a CMD-t, Linuxon pedig a terminált. (Ha Linuxon esetleg nem működne, a terminál hibaüzenetére rákeresve biztosan találsz megoldást, ez disztribúciónként eltérhet.)

pip install numpy

Amire még szükségünk lesz, az a scipy könyvtár. Telepítése ugyancsak nem túl bonyolult.

pip install scipy

A legalapvetőbb mutatók

import numpy as np
from scipy import stats


#numpy array létrehozása
x = np.array([1, 2, 3, 4, 7, 7, 7, 9, 13, 15])

#minimum és maximum (gondolom ezt kitaláltad)
minimum = np.min(x)
maximum = np.max(x)

#módusz és medián és átlag
mode = stats.mode(x).mode
median = np.median(x)
mean = np.mean(x)

#kvartilisek (alsó és felső)
"""
    Itt az első paraméter nyilván a tömb, míg a másodiknál a 25-ös érték
    az adatok 25%-ra utal. Vigyázz, nem 0.25!!!
"""
q1 = np.percentile(x, 25)
q3 = np.percentile(x, 75)
"""
    Az interkvartilis terjedelem a harmadik és az első kvartilis különbsége.
    Igen, ennyire egyszerű.
"""
iqr = q3 - q1

#populációs szórás
std = np.std(x)

#szórás minta alapján
std2 = np.std(x, ddof=1)

#ha nem tudnád a relatív szórás a szórás osztva az átlaggal
rstd = std/mean

Az outlierek (kiugró értékek) szűrése

A statisztikában a kiugró értékek torzíthatják a mutatókat, hiszen egy-egy rendkívül kicsi, vagy rendkívül nagy érték még nem feltétlenül szignifikáns, sokkal inkább csak egy kis valószínűségű esemény bekövetkezte. Szűrésük viszont szerencsére nem bonyolult. Kiszámoljuk az alsó és felső kvartilist, az interkvartilis terjedelmet, és a többi már gyerekjáték.
q1=alsó kvartilis
q3=felső kvartilis
iqr=q3-q1
alsó küszöb = q1 - 1,5*iqr
felső küszöb = q3 + 1,5*iqr
Nézzük ezt meg kód szinten!

import numpy as np
x = np.array([1, 60, 65, 70, 75, 80, 85, 400])

q1 = np.percentile(x, 25)
q3 = np.percentile(x, 75)
iqr = q3 - q1

Most jön a lényeg! Semmiféle if-re, vagy ciklusra nincs szükséged. A szűrést megoldhatod a következőképpen:

lower = q1 - 1.5 * iqr
upper = q3 + 1.5 * iqr

no_outliers = x[(x > lower) & (x < upper)]

Semmi más nem történik pusztán annyi, hogy az x változóban csak azok az értékek maradhatnak bent, amelyek nagyobbak, mint az alsó határ (lower) és kisebbek, mint a felső határ (upper). Ez a Numpy egyik leghatékonyabb funkciója, az úgynevezett vektoralapú szűrés vagy maszkolás.

Kovariancia és korreláció

Mint ismeretes, mind a korreláció, mind pedig a kovariancia két változó együttmozgására ad mérőszámot. A különbség a kettő között, hogy a korreláció standardizált, tehát egy és mínusz egy között lehet az eredmény. Így több korrelációs együtthatót viszonyítani egymáshoz pontosabb, mint több kovariancia értéket.
A skálázhatóság kedvéért amit visszakapunk, nem pusztán a két változó közötti kovariancia és korreláció, hanem kovariancia és korrelációs mátrixok. Ez azért logikus így, mert a statisztikában gyakran fordul elő, hogy nem kettő, hanem akár sok száz paraméter között húzódó kapcsolatot szeretnénk feltárni. Ami létrejön, az a következő:

Kovariancia mátrix

	x	y
x	cov(x, x)	cov(x, y)
y	cov(y, x)	cov(y, y)

Korrelációs mátrix

	x	y
x	corr(x, x)	corr(x, y)
y	corr(y, x)	corr(y, y)

Ami itt fura, hogy így megjelenik x vagy y önmagával vett kovarianciája és korrelációja is. Egy változó önmagával vett kovarianciája nem más, mint a variancia (szórásnégyzet).

import numpy as np

x = np.array([10, 12, 13, 14, 15, 16, 18])
y = np.array([20, 24, 27, 30, 32, 35, 40])

# Kovariancia mátrix
cov_matrix = np.cov(x, y)

# Ha csak a két változó közötti kovariancia kell:
covariance = cov_matrix[0, 1]

print(f"Kovariancia mátrix:\n{cov_matrix}")
print(f"Kovariancia: {covariance}")

# Korrelációs mátrix
corr_matrix = np.corrcoef(x, y)

# Ha csak a korrelációs együttható kell:
correlation = corr_matrix[0, 1]

print(f"Korrelációs mátrix:\n{corr_matrix}")
print(f"Korrelációs együttható: {correlation}")

Amit még érdemes lenne tisztáznom, az az alábbi sor. Mivel egy mátrixot kapunk vissza ezért, ha csak az adott két változó közötti kapcsolat erőssége szükséges, akkor elég a nulladik sor első oszlopa. Ne feledd, nullától indexelünk, tehát ez az első sor második oszlopnak felel meg matematikai szempontból! Ezt adja vissza az alábbi sor:

covariance = cov_matrix[0, 1]

Módusz és medián gyakorisági soroknál

Programozás és elemzés Olivérrel — Mon, 20 Apr 2026 13:21:32 +0000

Gyakorisági sorok esetében a módusz, valamint a medián számolása kissé trükkös, de meg lehet érteni a képlet mögötti logikát. Ha esetleg nem lennél tisztában a két fogalommal, a módusz a leggyakoribb (legtöbbször előforduló) érték, a medián pedig a helyzeti középérték. Nézzünk egy adatsort:
1,2,2,3,4,7,10,12
A módusz itt a kettő, hiszen az fordul elő a legtöbbször. A medián a középső érték lenne, tehát az, amelyik fizikailag középen van, viszont az elemszámunk páros, tehát két középső is létezik. Ezek a három és a négy.
Ha átlagoljuk őket, akkor megkapjuk a mediánt, ami jelen esetben 3,5.
Létezik erre két képlet is, az egyik a páros, a másik a páratlan elemszám esetében használható. A képlettel az elem/elemek sorszáma adható meg!

Páratlan elemszámnál:

\frac{n+1}{2}

Páros elemszámnál:

i_1 = \frac{n}{2} \newline i_2 = \frac{n}{2} + 1

Páratlan számoknál egyszerűen csak kiválasztjuk a megfelelő i. sorszámú elemet. Páros elemszám esetében két sorszámot kapunk, ezt a két elemet átlagoljuk.
Ha Python-ban számolod ki ezen értékeket, akkor eltérő végeredményre jutsz. Ennek az oka az, hogy sok statisztikai könyvtár interpolációs megoldást alkalmaz, de erről majd egy másik bejegyzésben fogok értekezni. Most jöjjenek a számok!

A gyakorisági sor

Érték	Gyakoriság	Kumulált gyakoriság
10 - 19	3	3
20 - 29	5	8
30 - 39	8	16
40 - 49	4	20
50 - 59	2	22

Módusz

\frac{k_1}{k_1 + k_2} \cdot h_{mo}

mo = a módusz osztályközének alsó határa
k1 = módusz osztályköz gyakorisága - módusz előtti osztályköz gyakorisága
k2 = módusz osztályköz gyakorisága - módusz utáni osztályköz gyakorisága
hmo = módusz osztályköz hossza

Semmi más nem történik a képletben csak egy arányt számolunk, amivel megszorozzuk az osztályköz hosszát. Jelen esetben k1 és k2 aránya számít. Ahogy növekszik k1, tehát a tört számlálója, úgy nő a módusz osztályköz és az előtte lévő osztályköz gyakorisága közötti differencia. Logikus, hogy ilyenkor pont a másik irányba, tehát a következő osztályköz felé tolódik az érték. Ilyenkor a szorzó nagyobb lesz. Ha k2 értékét növeljük, akkor egyre kisebb és kisebb lesz a szorzó. (Ne zavarjon meg, hogy k1 a számlálóban és a nevezőben is megtalálható, mivel a számláló nagyobb arányban fog növekedni, mint a nevező.)
A gyakoriság a harmadik osztályközben a legnagyobb, egészen pontosan nyolc. Ilyenkor a következőképpen alakul a számítás:

{k_1} = 8 - 5 = 3 \newline {k_2} = 8 - 4 = 4 \newline Mo = 30 + \frac{3}{3+ 4} \cdot 10 \approx 34,286

Medián

A medián, mint már említettem a helyzeti középérték. Itt is hasonló logikával arányt számolunk, viszont itt nem a gyakoriságból, hanem a kumulált gyakoriságból indulunk ki. A kumulált gyakoriság annyit tesz, hogy a gyakoriság értékeit az adott sorig összeadogatjuk. Az első marad az, mint a gyakoriság, a második már két sor összege, a harmadik három sor összege, stb... A medián képlete a következő:

\frac{\frac{N}{2}-f' \tiny \text{me-1}}{f_{me}} \cdot h_{me}\newline

N = elemszám
me = medián osztályköz alsó határa
f'me-1 = medián előtti osztályköz kumulált gyakorisága
fme = medián osztályköz gyakorisága

Az első kérdés az, hogy honnan tudjuk meg, melyik a medián osztályköz. Itt az elemszám 22, annak a fele 11, tehát azt az osztályközt keressük, amelyikben a 11. elem található. Ez a középső osztályköz. (Arról az osztályközről van szó, amelyik kumulált gyakoriságba beleesik a 11-es érték.)

Próbáljuk megfejteni ezt a képletet! Az N/2 nyilván az adatok számának fele, ez a medián esetében egyértelmű, hogy miért így alakul. A kumulált gyakoriság az előző osztályközig (f'me-1) azért fontos, mert szükségünk van arra, hogy mennyi a különbsége az adatok tényleges felének, és az előző osztályközig felhalmozódott értéknek. Ezt a különbséget osztjuk le a medián osztályköz gyakoriságával. Úgy lehet ezt elképzelni, mint egy csúszkát, amely azt mutatja meg a fent megadott arányosság alapján, hogy a medián osztályköz alsó és felső határa között pontosan hol legyen a medián.
A képletbe behelyettesítve a következő értéket kapjuk:

\frac{\frac{22}{2}-8}{8} \cdot 10 = 33,75

Tetszőleges kvantilisek (egy kis extra)

Ez a rész rendkívül hasonlít a mediánra, gyakorlatilag ugyanazt a logikát követjük. A különbség annyi, hogy míg a mediánnál a felezőpontot kerestük, itt azt határozzuk meg, hogy az adatsor hányad részénél lévő értéket szeretnénk megkapni.

A képletben a következő jelöléseket használjuk:

k: megadja, hogy hanyadik egységet keressük (pl. a 3. decilist).
m: megadja, hogy hány részre osztjuk az adatsort (kvartilisnél 4, kvintilisnél 5, decilisnél 10, percentilisnél 100).
N: továbbra is az összes elem száma.

A módosított képlet pedig így néz ki:

Q_{k/m} = m_q + \frac{\frac{k \cdot N}{m}-f'\tiny \footnotesize{m_q-} \tiny{1}}{f_{m_q}} \cdot h_{m_q}

A logika itt is a "csúszka" elv. A k/m arány megmutatja, mekkora részt kell "kihasítanunk" az adatokból, mi pedig megkeressük, hogy ez a pont az adott osztályköz alsó és felső határa között pontosan hol helyezkedik el.

Osztályközök képzése SQL-ben (GROUP BY trükk)

Programozás és elemzés Olivérrel — Sun, 19 Apr 2026 12:00:58 +0000

Ebben a rendkívül rövid blogbejegyzésben arról fogok értekezni, hogyan lehet osztályközös lekérdezést létrehozni SQL nyelven. A példához MSSQL-t használok majd, de mivel az SQL szintaxisok nagyon hasonlóak, így ezt bármelyik SQL dialektusban meg lehet oldani.
Itt is van a mérhetetlenül egyszerű lekérdezés:

SELECT
    amount / 200000 * 200000 AS BinStart,
    amount / 200000 * 200000 + 199999 AS BinEnd,
    COUNT(*) AS Count
FROM Salaries
WHERE end_date IS NULL
GROUP BY
    amount / 200000;

A tábla maga így néz ki:

CREATE TABLE Salaries (
  salary_id int PRIMARY KEY IDENTITY(1, 1),
  employee_id int,
  amount int,
  start_date date,
  end_date date,
  registered datetime DEFAULT (GETDATE())
)

Hogyan működik a lekérdezés?

Az alábbi sor alakítja ki az osztályközöket úgy, hogy az "amount" oszlop értékét osztja, majd megszorozza az osztályköz hosszával:
amount / 200000 * 200000 AS BinStart
Ha belegondolunk, itt nyilván egy egész számot fogunk kapni, ami megmondja, hogy hány egészszer van meg a fizetésben az osztályköz hosszával egyenlő szám. Azért nem szükséges a FLOOR alkalmazása, mert az MSSQL erősen típusos, és integert osztunk integerrel. Ez viszont nem azt jelenti, hogy más adatbázisrendszernél ez így működik. MySQL-ben például szükséges lenne a FLOOR alkalmazása.
Ha az eredményt beszorozzuk az osztályköz hosszával, akkor nyilván n-szer kapjuk meg az annak nagyságát. Az osztályköz felső határát az összeadás biztosítja. A "GROUP BY" művelet segítségével csoportosítunk aszerint, hogy hányszor egészszer van meg a fizetésben az osztályköz hossza.
A "WHERE end_date IS NULL" azért került oda, mert a táblában az aktuális fizetésnél az "end_date" mező értéke null.

Miért működik a korreláció?

Programozás és elemzés Olivérrel — Thu, 16 Apr 2026 15:22:29 +0000

Ebben a rövid cikkben egy egyszerűnek tűnő, ámbár a színfalak mögött mélyebb gondolkodást igénylő fogalomról fogok beszélni, ami rendkívül alapvető a statisztikában, az adatelemzésben, de akár a programozás világában is. Ez a fogalom nem más, mint a korreláció.

A korreláció egy standardizált statisztikai mutató, amely megadja két úgynevezett mennyiségi ismérv közötti kapcsolat szorosságot. Mindjárt egy példával is rávilágítanék a problémára. Van két adatsorunk, a termékek ára, és az eladási számok. Szeretnénk tudni, hogy termékek ára befolyásolja-e az eladási volument. Ebben a kontextusban a termékek ára a független, az eladási volumen pedig a függő változó. Az elnevezések logikusak, hiszen a független változó értékétől függ a függő változó értéke.

Három mutatót kell először kiszámolnunk ahhoz, hogy megkapjuk a korrelációt:

a függő változó szórását
a független változó szórását
és a kovarianciát a két változó között

Ha esetleg nem ismernéd a szórás fogalmát, a szórás megmondja, hogy az egyes értékek átlagosan mennyire térnek el a sokasági átlagtól. (Egészen pontosan az átlagtól való eltérések négyzetes átlaga.) A kovariancia a változók együttmozgását méri tehát azt, hogy a két adatsor értékei mennyire változnak együtt.

A két adatsor legyen a következő:

Termék ára (független változó) (Ft): 1, 2, 3, 4, 5

Eladási volumen (függő változó) (db): 2, 4, 6, 8, 10

Átlagár: 3 Ft

Átlag eladási volumen: 6 db

A szórás képlete a következő:

\sigma = \sqrt{\frac{\sum\limits_{i=1}^{n} (x_i - \bar{x})^2}{n}}

A kovariancia pedig:

\text{cov}(x,y) = \frac{\sum\limits_{i=1}^{n} (x_i - \bar{x})(y_i - \bar{y})}{n}

Szórások kiszámítása

Termék árának szórása

\sigma = \sqrt{\frac{(1-3)^2 + (2-3)^2 + (3-3)^2 + (4-3)^2 + (5-3)^2}{5}} \approx 1.414

Termék eladási volumenének szórása

\sigma = \sqrt{\frac{(2-6)^2 + (4-6)^2 + (6-6)^2 + (8-6)^2 + (10-6)^2}{5}} \approx 2.828

Kovariancia kiszámítása

\frac{(1-3)(2-6) + (2-3)(4-6) + (3-3)(6-6) + (4-3)(8-6) + (5-3)(10-6)}{5}

\frac{(-2)(-4) + (-1)(-2) + (0)(0) + (1)(2) + (2)(4)}{5} = 4

Intuitív megfigyelés

Az adatok nyilván ebben a speciális esetben függvényszerűen követik egymást. Az látható, hogy a kovariancia kiszámításánál lényegében keresztbe szorozzuk az átlagtól való eltéréseket. Mivel az értékek számszorosai egymásnak, ezért a mondhatjuk, hogy az átlagtól való eltérést, és az átlagtól való eltérés számszorosát szorozzuk össze. Így tehát a variancia számszorosát fogjuk megkapni.

Ha a függő és független változók értékei számszorosai egymásnak, akkor ugyanez lesz igaz szórásokra is. Az alább képletekkel is levezettem ezt az összefüggést. Így tehát, ha függvényszerű a kapcsolat a független és függő változó között, akkor a korrelációnak mindenképpen egynek, vagy mínusz egynek kell lennie, hiszen az a kovariancia és a szórások szorzatának hányadosa. (Azt ne felejtsük el, hogy a szóban forgó Peason-féle korrelációs együttható alapvetően lineáris kapcsolatot mér. Nem lineáris kapcsolat esetében másképpen szükséges számolni.)

\sum\frac{(x-\bar{x})(y-\bar{y})}{n} = \sum\frac{(x-\bar{x}) \cdot k \cdot (x-\bar{x})}{n} = \newline \newline k \cdot \sum\frac{(x-\bar{x})(x-\bar{x})}{n} = k \cdot \sum\frac{(x-\bar{x})^2}{n} = k \cdot \sigma^2

\sigma_x \cdot \sigma_y = \sigma_x \cdot (k \cdot \sigma_x) = k \cdot \sigma_x^2

A korrelációs együttható kiszámítása

A korrelációs együttható képlete a következő:

\frac{\text{cov}(x,y)}{\sigma_x \cdot \sigma_y}

Amint látod, egyszerűen csak le kell osztani a kovarianciát, a szórások szorzatával. Az így kalkulált érték egy és mínusz egy között alakulhat.

Végkövetkeztetés

Kimondhatjuk, hogyha függő változó értékei függvényszerű kapcsolatban állnak a független változó értékeivel, akkor a korreláció csak egy és mínusz egy lehet. Minden más esetben a kettő érték közötti számot fogunk kapni. Ezért működik jól ez az egyszerűnek tűnő, ámbár rendkívül hatékony mutató.

DEV Community: Programozás és elemzés Olivérrel

Adattisztítás Python Pandas segítségével

Mik azok a CSV fájlok

CSV fájlok beolvasása

Alapadatok kinyerése

Az adatok tisztítása

Hiányzó adatok

Duplikált sorok

Kiugró értékek eltávolítása

Dátumok kezelése

Python Pandas alapok

A Pandas adatszerkezetei

Series

DataFrame

Python alapok szoftverhasználóknak I.

Hogyan telepítsd a Python-t

Windows

Linux

Python kód futtatása

Változók

Operátorok és műveletek

Logikai műveletek

NOT

AND

OR

Ami a NumPy-ból hiányzik: Cramer-féle V

Cramer-V NumPy implementáció

Az adatszerkezet értelmezése

Sorok és oszlopok összegzése

Diadikus szorzat (outer product)

Független értékek előállítása

χ2 érték kiszámolása

Cramer-féle asszociációs együttható

A teljes számítás függvény alakban

Amikor nem működik a korreláció I.

Mérési skála

Cramer-féle asszociációs együttható

Cramer-féle asszociációs együttható

Az eredmény értelmezése

Python NumPy alapok

A könyvtárak telepítése

A legalapvetőbb mutatók

Az outlierek (kiugró értékek) szűrése

Kovariancia és korreláció

Kovariancia mátrix

Korrelációs mátrix

Módusz és medián gyakorisági soroknál

A gyakorisági sor

Módusz

Medián

Tetszőleges kvantilisek (egy kis extra)

Osztályközök képzése SQL-ben (GROUP BY trükk)

Hogyan működik a lekérdezés?

Miért működik a korreláció?

Szórások kiszámítása

Termék árának szórása

Termék eladási volumenének szórása

Kovariancia kiszámítása

Intuitív megfigyelés

A korrelációs együttható kiszámítása

Végkövetkeztetés

χ² érték kiszámolása