=== Tömb létrehozása ===

  * Python listából / tuple-ből NumPy tömböt hoz létre: **np.array(iterable)**
  * Tartomány generálása (mint range, de array): **np.arange(start, stop, step)**
  * Egyenletesen elosztott num darab érték adott intervallumban: **np.linspace(start, stop, num)**
  * Nullákkal feltöltött tömb: **np.zeros(shape)**
  * 1-esekkel feltöltött tömb: **np.ones(shape)**
  * Inicializálatlan tömb (gyors, de szemétértékkel): **np.empty(shape)**
  * Adott értékkel feltöltött tömb: **np.full(shape, value)**
  * Egységmátrix: **np.eye(n)**
  * 0–1 közötti egyenletes eloszlás: **np.random.rand(...)**
  * Normál eloszlás: **np.random.randn(...)**
  * Véletlen egész számok: **np.random.randint(low, high, size)**

=== Tömb tulajdonságok ===

  * Dimenziók mérete: **arr.shape**
  * Dimenziók száma: **arr.ndim**
  * Elemek száma: **arr.size**
  * Adattípus: **arr.dtype**
  * Típuskonverzió: **arr.astype(type)**

=== Matematikai alapműveletek (vektorizált) ===

  * Elemankénti műveletek.:
     * **np.add(a, b)**
     * **np.subtract(a, b)**
     * **np.multiply(a, b)**
     * **np.divide(a, b)**
  * Hatványozás: **np.power(a, b)**
  * Négyzetgyök: **np.sqrt(a)**
  * Abszolútérték: **np.abs(a)**
  * e^x: **np.exp(a)**
  * Természetes logaritmus: **np.log(a)**

=== Aggregáló (redukciós) függvények ===

  * Összegzés: **np.sum(a, axis=None)**
  * Átlag: **np.mean(a, axis=None)**
  * Medián: **np.median(a)**
  * Szórás: **np.std(a)**
  * Variancia: **np.var(a)**
  * Minimum: **np.min(a)**
  * Maximum: **np.max(a)**
  * Minimum indexe: **np.argmin(a)**
  * Maximum indexe: **np.argmax(a)**
  * Szorzat: **np.prod(a)**

=== Mátrix- és lineáris algebra ===

  * Skalárszorzat / mátrixszorzás (régebbi forma): **np.dot(a, b)**
  * Modern mátrixszorzás operátor: **a @ b**
  * Mátrixszorzás: **np.matmul(a, b)**
  * Transzponálás: **np.transpose(a) / a.T**
  * Inverz mátrix: **np.linalg.inv(a)**
  * Determináns: **np.linalg.det(a)**
  * Sajátértékek, sajátvektorok: **np.linalg.eig(a)**
  * Lineáris egyenletrendszer megoldása: **np.linalg.solve(A, b)**

=== Indexelés és szűrés ===

  * Boolean indexelés, feltételes szűrés: **a[a > 5]**
  * Feltétel indexei: **np.where(condition)**
  * Nem nulla elemek indexei: **np.nonzero(a)**
  * Értékek levágása intervallumra: **np.clip(a, min, max)**

=== Tömb átalakítás ===

  * Átalakítás: **np.reshape(a, shape)**
  * 1D-re lapítás (másolat): **a.flatten()**
  * 1D-re lapítás (nézet, ha lehet): **a.ravel()**
  * Összefűzés: **np.concatenate([a, b], axis=0)**
  * Függőleges összefűzés: **np.vstack([...])**
  * Vízszintes összefűzés: **np.hstack([...])**
  * Felosztás: **np.split(a, indices)**

=== Rendezés és keresés ===

  * Rendezett másolat: **np.sort(a)**
  * Helyben rendez: **a.sort()**
  * Rendezési indexek: **np.argsort(a)**
  * Egyedi elemek: **np.unique(a)**

=== Statisztikai / speciális ===

  * Percentilis: **np.percentile(a, q)**
  * Kumulatív összeg: **np.cumsum(a)**
  * Kumulatív szorzat: **np.cumprod(a)**
  * Korreláció: **np.corrcoef(a, b)**
  * Konvolúció (pl. mozgóátlag): **np.convolve(a, kernel, mode)**

=== Broadcasting (nem függvény, hanem mechanizmus) ===

  * Automatikus méretillesztés műveleteknél:
  * <code>
a + 5
a + np.array([1,2,3])
</code>

=== Fontos logikai függvények ===

  * Minden elem igaz? **np.all(condition)**
  * Van legalább egy igaz? **np.any(condition)**
  * És: **np.logical_and(a, b)**
  * Vagy: **np.logical_or(a, b)**

=== Fájlkezelés NumPy-val ===

  * Szövegfájl betöltése: **np.loadtxt("file.txt")**
  * Mentés szövegfájlba: **np.savetxt("file.txt", array)**
  * Bináris mentés: **np.save("file.npy", array)**
  * Bináris betöltés: **np.load("file.npy")**


=== A legfontosabb 20, amit tudni kell ===

<code>
array, arange, linspace
zeros, ones, full
shape, reshape
sum, mean, std, min, max
argmax, argmin
dot / @
where
sort, argsort
concatenate
unique
loadtxt, savetxt
</code>


----
==== Gyakorló feladatok ====

**I. Tömb létrehozás: Alap generálás**

  - Hozz létre egy 0–99 közötti egész számokat tartalmazó tömböt np.arange() segítségével.
  - Hozz létre 50 darab egyenletesen elosztott számot 0 és 1 között np.linspace()-szel.
  - Készíts egy 4x4-es nullmátrixot.
  - Készíts egy 3x5-ös, 7-esekkel feltöltött mátrixot.

<sxh python>
import numpy as np

# 1
a = np.arange(100)
# 2
b = np.linspace(0, 1, 50)
# 3
c = np.zeros((4, 4))
# 4
d = np.full((3, 5), 7)
print(a, b, c, d)
</sxh>

**II. Tömb tulajdonságok és átalakítás: Shape és reshape**

  - Generálj egy 1D tömböt 0–23-ig.
  - Alakítsd át 4x6-os mátrixszá.
  - Transzponáld.
  - Lapítsd vissza 1D-be flatten() és ravel() segítségével.
  - Ellenőrizd shape, ndim, size, dtype.

<sxh python>
arr = np.arange(24)

matrix = arr.reshape(4, 6)
transposed = matrix.T

flat1 = matrix.flatten()
flat2 = matrix.ravel()

print(matrix.shape)
print(matrix.ndim)
print(matrix.size)
print(matrix.dtype)
</sxh>

**III. Vektorizált matematikai műveletek: Elemankénti műveletek**

Hozz létre két 10 elemű tömböt.
  - Számold ki:
     - összegüket
     - különbségüket
     - szorzatukat
     - hányadosukat
  - Emeld az egyik tömb elemeit négyzetre.
  - Számold ki a négyzetgyöküket.
  - Alkalmazz logaritmust és exponenciális függvényt.

<sxh python>
a = np.arange(1, 11)
b = np.arange(11, 21)

osszeg = a + b
kulonbseg = a - b
szorzat = a * b
hanyados = a / b

negyzet = a ** 2
gyok = np.sqrt(a)

log = np.log(a)
exp = np.exp(a)

print(osszeg, kulonbseg, szorzat, hanyados)
</sxh>

**IV. Aggregáló függvények: Statisztikai elemzés**

  - Generálj 1000 normál eloszlású számot.
  - Számold ki:
     - átlag
     - medián
     - szórás
     - variancia
     - minimum
     - maximum
  - Add meg a legnagyobb elem indexét.
  - Számold ki az első 100 elem összegét.

<sxh python>
data = np.random.randn(1000)

print("Átlag:", np.mean(data))
print("Medián:", np.median(data))
print("Szórás:", np.std(data))
print("Variancia:", np.var(data))
print("Min:", np.min(data))
print("Max:", np.max(data))

print("Max index:", np.argmax(data))
print("Első 100 elem összege:", np.sum(data[:100]))
</sxh>

**V. Mátrixműveletek: Lineáris algebra**

  - Generálj két 3x3-as mátrixot.
  - Szorozd össze őket:
     - np.dot()
     - @ operátorral
  - Számold ki az egyik determinánsát.
  - Számold ki az inverzét.
  - Oldj meg egy Ax = b lineáris egyenletrendszert.

<sxh python>
A = np.random.randint(1, 10, (3, 3))
B = np.random.randint(1, 10, (3, 3))

dot1 = np.dot(A, B)
dot2 = A @ B

det = np.linalg.det(A)

# Inverz csak ha invertálható
if det != 0:
    inv = np.linalg.inv(A)

b = np.array([1, 2, 3])
if det != 0:
    x = np.linalg.solve(A, b)

print(dot1, det)
</sxh>

**VI. Boolean indexelés és szűrés: Feltételes műveletek**

  - Generálj 100 elemből álló véletlen tömböt.
  - Szűrd ki az 50-nél nagyobb elemeket.
  - Cseréld az 50 alatti elemeket nullára np.where() segítségével.
  - Számold meg, hány elem nagyobb 75-nél.
  - Használd np.clip()-et az értékek 10–90 közé szorítására.

<sxh python>
arr = np.random.randint(0, 100, 100)
nagyobb_50 = arr[arr > 50]
uj = np.where(arr < 50, 0, arr)
db_75 = np.sum(arr > 75)
clipped = np.clip(arr, 10, 90)
print(nagyobb_50, db_75)
</sxh>

**VII. Összefűzés és darabolás: Tömbmanipuláció**

  - Hozz létre két 2x3-as mátrixot.
  - Fűzd össze:
     - függőlegesen (vstack)
     - vízszintesen (hstack)
     - Használd concatenate()-et.
  - Oszd fel a mátrixot 3 részre split() segítségével.

<sxh python>
A = np.random.randint(1, 10, (2, 3))
B = np.random.randint(1, 10, (2, 3))

v = np.vstack((A, B))
h = np.hstack((A, B))

c = np.concatenate((A, B), axis=0)
split = np.split(v, 2)
print(v, h)
</sxh>

**VIII. Rendezés és keresés: Rendezési feladatok**

  - Generálj 20 véletlen számot.
  - Rendezd növekvő sorrendbe.
  - Add meg a rendezési indexeket (argsort).
  - Találd meg az egyedi elemeket (unique).
  - Számold ki a 90. percentilist.

<sxh python>
arr = np.random.randint(0, 50, 20)

sorted_arr = np.sort(arr)
indices = np.argsort(arr)
unique_vals = np.unique(arr)

p90 = np.percentile(arr, 90)

print(sorted_arr, indices, unique_vals, p90)
</sxh>

**IX. Haladó – Idősor feldolgozás:mMozgóátlag és kumuláció**

  - Generálj 365 napi adatot.
  - Számold ki:
     - kumulatív összeget (cumsum)
     - kumulatív szorzatot (cumprod)
  - Számolj 7 napos mozgóátlagot np.convolve() segítségével.
  - Határozd meg azokat a napokat, ahol az érték nagyobb az éves átlagnál.

<sxh python>
data = np.random.randn(365)

cumsum = np.cumsum(data)
cumprod = np.cumprod(data)

kernel = np.ones(7) / 7
moving_avg = np.convolve(data, kernel, mode="valid")

atlag = np.mean(data)
nagyobb = data[data > atlag]

print(cumsum[:5], moving_avg[:5])
</sxh>

**X. NumPy fájlkezelés: Fájlműveletek**

  - Ments el egy tömböt .txt formátumban (savetxt).
  - Olvasd vissza (loadtxt).
  - Mentsd el .npy formátumban.
  - Töltsd vissza.
  - Ellenőrizd, hogy a két tömb megegyezik-e (np.array_equal).

<sxh python>
arr = np.random.randint(1, 100, (5, 5))

np.savetxt("adat.txt", arr)
loaded_txt = np.loadtxt("adat.txt")

np.save("adat.npy", arr)
loaded_npy = np.load("adat.npy")

print(np.array_equal(arr, loaded_txt))
print(np.array_equal(arr, loaded_npy))
</sxh>

**XI. Broadcasting gyakorlás: Méretillesztés**

  - Adj hozzá egy 1D tömböt egy 2D mátrix minden sorához.
  - Normalizálj soronként.
  - Vond ki minden oszlopból az oszlopátlagot.
  - Szorozd meg az egész mátrixot egy skalárral.
  - Ellenőrizd np.all() és np.any() használatával bizonyos feltételeket.

<sxh python>
matrix = np.random.randint(1, 10, (4, 3))
vector = np.array([1, 2, 3])

# Soronkénti hozzáadás
result = matrix + vector

# Soronkénti normalizálás
row_mean = np.mean(matrix, axis=1, keepdims=True)
norm = matrix - row_mean

# Oszlopátlag kivonása
col_mean = np.mean(matrix, axis=0)
centered = matrix - col_mean

# Skalárszorzás
scaled = matrix * 10

print(np.all(matrix > 0))
print(np.any(matrix > 8))
</sxh>