Hogyan működnek az SQL lekérdezések és műveletek?

Az SQL lekérdezések kulcsfontosságúak az adatok manipulálásában és lekérdezésében, különösen összetett adatbázisokban. A megfelelő SQL műveletek alkalmazása lehetővé teszi a pontos és hatékony adatkinyerést, ami elengedhetetlen az adatbázisok kezelésében. Az alábbiakban bemutatjuk azokat az alapvető SQL műveleteket, amelyek segítenek a lekérdezések finomításában, és lehetővé teszik a pontosabb és hasznosabb eredmények elérését.

A lekérdezés példája, amely egy adott évben kiadott filmeket és azok kölcsönzési számát adja vissza:

sql
Copy code
WHERE f.release_year = 2006 GROUP BY f.title HAVING COUNT(r.rental_id) > 10 ORDER BY rental_count DESC LIMIT 3;

Ez a lekérdezés az alábbi eredményeket adja:

• A 2006-ban kiadott filmeket (WHERE f.release_year = 2006).

• Azokat a filmeket, amelyeket több mint 10 alkalommal kölcsönöztek (HAVING COUNT(r.rental_id) > 10).

• A filmeket a kölcsönzési szám alapján csökkenő sorrendbe rendezve (ORDER BY rental_count DESC).

• Csak a legjobb három eredményt (LIMIT 3).

A lekérdezésben alkalmazott klauzulák együtt használva biztosítják a pontos és hatékony adatkinyerést, lehetővé téve összetett lekérdezések végrehajtását, amelyek értékes betekintést nyújtanak az adatbázisban tárolt információkba.

SQL operátorok

Az SQL operátorok alapvető eszközei az SQL lekérdezéseknek, amelyek lehetővé teszik a felhasználók számára, hogy összehasonlításokat végezzenek, matematikai műveleteket hajtsanak végre és logikai értékeléseket végezzenek a lekérdezésekben. Az operátorok finomítják a lekérdezéseket, meghatározzák a WHERE klauzulákban szereplő feltételeket, manipulálják az adatokat a SELECT utasításokban és számításokat végeznek az UPDATE vagy INSERT utasításokban.

Aritmetikai operátorok

Az aritmetikai operátorok matematikai műveleteket végeznek a numerikus adatokon az SQL lekérdezésekben. Ezek az operátorok gyakran szerepelnek a SELECT utasításokban, számításokban és adatátalakításokban. Néhány példa:

• + Összeadás: SELECT rental_rate + 2 FROM film;

• - Kivonás: SELECT rental_rate - 1 FROM film;

• * Szorzás: SELECT rental_rate * 2 FROM film;

• / Osztás: SELECT rental_rate / 2 FROM film;

• % Maradék: SELECT rental_duration % 3 FROM film;

Például egy 10%-os kedvezmény alkalmazásához a következő lekérdezés használható:

sql
Copy code
SELECT title, rental_rate, rental_rate * 0.90 AS discounted_price FROM film;

Ez a lekérdezés a rental_rate értékére 10%-os csökkentést alkalmaz, és visszaadja az új árat.

Összehasonlító operátorok

Az összehasonlító operátorok lehetővé teszik a felhasználók számára, hogy szűrjék és összehasonlítsák az értékeket az SQL lekérdezésekben, elsősorban a WHERE klauzulákban. A leggyakrabban használt operátorok:

• = Egyenlő: SELECT * FROM film WHERE release_year = 2006;

• != vagy <> Nem egyenlő: SELECT * FROM customer WHERE first_name != 'John';

• > Nagyobb mint: SELECT * FROM payment WHERE amount > 5.00;

• < Kisebb mint: SELECT * FROM payment WHERE amount < 10.00;

• >= Nagyobb vagy egyenlő: SELECT * FROM payment WHERE amount >= 5.00;

• <= Kisebb vagy egyenlő: SELECT * FROM payment WHERE amount <= 10.00;

Például az alábbi lekérdezés visszaadja az összes filmet, amelyet 2005 után adtak ki:

sql
Copy code
SELECT title, release_year FROM film WHERE release_year > 2005;

Logikai operátorok

A logikai operátorok lehetővé teszik több feltétel összekapcsolását az SQL lekérdezésekben, segítve a lekérdezés eredményeinek finomítását. A leggyakrabban használt logikai operátorok:

• AND Mindkét feltételnak igaznak kell lennie: SELECT * FROM film WHERE rental_rate > 2 AND release_year > 2005;

• OR Legalább az egyik feltétel igaz: SELECT * FROM customer WHERE first_name = 'John' OR first_name = 'Jane';

• NOT Tagadja a feltételt: SELECT * FROM rental WHERE NOT return_date IS NULL;

Például egy olyan lekérdezés, amely visszaadja az összes 2005 után kiadott filmet, amelyek bérleti díja meghaladja a 3 dollárt:

sql
Copy code
SELECT title, rental_rate, release_year FROM film WHERE release_year > 2005 AND rental_rate > 3;

Speciális operátorok

Az SQL különböző speciális operátorokat is biztosít, amelyek lehetővé teszik a minták keresését, a halmaztagság ellenőrzését és az intervallum keresést:

• IN operátor: Egy érték meglétét vizsgálja egy előre meghatározott listában. Példa:

sql
Copy code
SELECT * FROM customer WHERE first_name IN ('John', 'Jane', 'Alice');

Ez a lekérdezés visszaadja az összes olyan vásárlót, akiknek a keresztneve John, Jane vagy Alice.

• BETWEEN operátor: Az értékek közötti intervallumban szűri az eredményeket. Példa:

sql
Copy code
SELECT title, rental_rate FROM film WHERE rental_rate BETWEEN 2 AND 5;

Ez a lekérdezés azokat a filmeket választja ki, amelyek bérleti díja 2 és 5 dollár között van.

• LIKE operátor: Minták keresésére használható. A % bármely karakterláncot, az _ pedig egyetlen karaktert jelöl. Példa:

sql
Copy code
SELECT title FROM film WHERE title LIKE 'A%';

Ez a lekérdezés az összes olyan filmet visszaadja, amelyek címe A betűvel kezdődik.

• IS NULL operátor: Ellenőrzi, hogy egy érték NULL-e. Példa:

sql
Copy code
SELECT * FROM rental WHERE return_date IS NULL;

Ez a lekérdezés visszaadja azokat a kölcsönzéseket, ahol a filmek még nem kerültek visszaadásra.

SQL JOIN műveletek

A SQL JOIN műveletek lehetővé teszik, hogy adatokat nyerjünk ki és kombináljunk több táblából egy relációs adatbázison belül. Mivel az adatokat több táblában tárolják egy relációs adatbázisban, a JOIN-ok elengedhetetlenek az összefüggő információk hatékony lekérdezéséhez.

A JOIN-ok két vagy több tábla sorait kombinálják egy kapcsolódó feltétel alapján, mint például egy elsődleges kulcs egy táblában és egy idegen kulcs egy másik táblában.

A leggyakoribb JOIN típusok a következők:

• INNER JOIN: Csak azok a sorok jelennek meg, amelyek mindkét táblában egyeznek. Ha nincs egyezés, a sor nem szerepel az eredményben.

• LEFT JOIN: Az összes rekordot visszaadja a bal oldali táblából, és illeszkedő rekordokat keres a jobb oldali táblában. Ha nincs illeszkedés, a jobb oldali tábla oszlopai NULL értékeket tartalmaznak.

• RIGHT JOIN: A jobb oldali táblából minden rekordot visszaad, és illeszkedő rekordokat keres a bal oldali táblában. Ha nincs illeszkedés, a bal oldali tábla oszlopai NULL értékeket tartalmaznak.

• FULL JOIN: Az összes rekord

Hogyan végezzünk összetett SQL lekérdezéseket a SET operátorokkal?

A SQL nyelv egyik erőteljes eszköze a különböző adatkészletek kombinálására a UNION, INTERSECT és EXCEPT operátorok, amelyek lehetővé teszik az adatok szűrését és a redundanciák eltávolítását. Ezen operátorok alkalmazásakor különösen fontos a megfelelő sorrend és precedencia figyelembevételével dolgozni, hogy a lekérdezések eredményei megfeleljenek a kívánt céloknak. Ezen operátorok sorrendje, illetve a zárójelek használata alapvetően befolyásolja, hogyan kombinálódnak és szűrődnek az adatok, így elengedhetetlen a helyes alkalmazásuk megértése.

A UNION operátor egyesíti a különböző táblák adatait, eltávolítva a duplikált rekordokat, így egyedi értékeket ad vissza. Az INTERSECT operátor azokat az értékeket adja vissza, amelyek mindkét táblában megtalálhatók, míg az EXCEPT operátor kizárja azokat a rekordokat, amelyek egy másik táblában szerepelnek. Az operátorok alkalmazásának megértése kulcsfontosságú a pontos, szűrt eredmények eléréséhez.

A következő SQL lekérdezés például egyesíti az aktív színészeket és a személyzetet, de kizárja azokat, akik már inaktívak:

sql
Copy code
SELECT first_name, last_name FROM film_actor

EXCEPT
SELECT first_name, last_name FROM inactive_staff;

Ez a lekérdezés az alábbi műveleteket hajtja végre: először a UNION operátor összekapcsolja a színészeket és a személyzetet, eltávolítva a duplikált rekordokat, így biztosítva az egyedi egyéneket. Ezután az INTERSECT operátor kiszűri a közös rekordokat a két táblából, azaz azok közül, akik a filmekben szerepeltek. Végül az EXCEPT operátor eltávolítja azokat, akik az inaktív személyzet táblájában szerepelnek, biztosítva, hogy csak az aktív színészek és személyzet tagjai maradjanak, akik részt vettek a filmekben.

A zárójelek alkalmazása

A bonyolultabb lekérdezésekben, amikor több SET operátort használunk, fontos az operátorok sorrendjét megfelelően kezelni. Az SQL alapértelmezés szerint az INTERSECT operátort végzi el elsőként, majd a UNION és az EXCEPT operátorokat. A kívánt eredmény eléréséhez, különösen bonyolultabb lekérdezéseknél, célszerű zárójeleket használni a műveletek körül, hogy pontosan meghatározhassuk, mely műveletek hajtódjanak végre először.

Egy példában, ahol szeretnénk megtalálni az aktív színészeket, akik filmekben dolgoztak, és ezen kívül az aktív személyzetet is figyelembe venni:

sql
Copy code
(SELECT first_name, last_name FROM actor EXCEPT SELECT first_name, last_name FROM inactive_actors)
UNION

SELECT first_name, last_name FROM staff WHERE active = 'Y';

Ebben a lekérdezésben az EXCEPT operátor a zárójelek között elsőként fut le, és visszaadja az aktív színészeket, kizárva azokat, akik az inactive_actors táblában szerepelnek. Az eredmény ezután összevonódik az aktív személyzet tagjaival, akik a staff táblában szerepelnek, az UNION operátor alkalmazásával.

Precedencia és sorrend

Például a következő lekérdezésben először az INTERSECT operátor végzi el az összehasonlítást, majd az eredményeket összevonja a UNION operátorral:

sql
Copy code
SELECT first_name, last_name FROM actor
UNION
SELECT first_name, last_name FROM film_directors
INTERSECT
SELECT first_name, last_name FROM active_cast;

Ebben a példában először az INTERSECT operátor végzi el a közös elemek keresését a film_directors és az active_cast táblák között. Ezt követően az UNION operátor egyesíti az eredményt a színészek adataival. Ha a célunk az lett volna, hogy először a színészeket és a rendezőket egyesítsük, és csak utána szűrjük le az aktív személyeket, akkor zárójeleket kellett volna használnunk, hogy meghatározzuk a megfelelő műveleti sorrendet:

sql
Copy code
(SELECT first_name, last_name FROM actor

UNION
SELECT first_name, last_name FROM film_directors)
INTERSECT
SELECT first_name, last_name FROM active_cast;

Ez a lekérdezés először egyesíti a színészeket és a rendezőket, majd szűri az aktív szereplők adatait, figyelembe véve az aktív személyeket is.

Gyakorlati alkalmazások

A SET operátorok alkalmazása különösen hasznos lehet összetett jelentések és adatfeldolgozási feladatok során. Például, ha szeretnénk azonosítani azokat az aktív személyeket, akik egy filmprojekten dolgoznak, és egyúttal a vezetői csapat tagjai, de kizárnánk azokat, akik szabadságon vannak, használhatjuk az alábbi lekérdezést:

sql
Copy code
(SELECT first_name || ' ' || last_name AS name FROM staff_projects

INTERSECT
SELECT first_name || ' ' || last_name AS name FROM management_team)
EXCEPT

SELECT first_name || ' ' || last_name AS name FROM leave_list;

Ebben a lekérdezésben először az INTERSECT operátor segítségével kiszűrjük azokat, akik mind a staff_projects táblában, mind a management_team táblában szerepelnek. Ezt követően az EXCEPT operátor eltávolítja azokat, akik a leave_list táblában találhatók, így biztosítva, hogy csak azok maradjanak, akik aktívan dolgoznak.

Rendelkezésre álló adatok rendezése

Ha a SET operátorokkal kombinálva szeretnénk adatokat rendezni, fontos megjegyezni, hogy az ORDER BY utasítást csak az eredményhalmaz végső szintjén lehet alkalmazni, miután az összes művelet (például UNION, INTERSECT, EXCEPT) végbement. Ha az egyes lekérdezésekben külön-külön szeretnénk rendezi a rekordokat, használhatunk közös táblákat (CTE-ket) vagy ideiglenes táblákat. A következő példa mutatja, hogyan lehet ezt megvalósítani:

sql
Copy code
WITH actor_list AS (

    SELECT first_name, last_name
    FROM actor
),
staff_list AS (
    SELECT first_name, last_name
    FROM staff
)
SELECT * FROM actor_list
UNION
SELECT * FROM staff_list
ORDER BY last_name;

Ebben a lekérdezésben először definiálunk két CTE-t (actor_list és staff_list), majd az UNION operátorral egyesítjük őket, és végül az ORDER BY utasítást alkalmazzuk az összesített eredmény rendezésére.

A megfelelő alkalmazásuk elengedhetetlen a pontos adatfeldolgozáshoz és a komplexebb jelentések elkészítéséhez.

Hogyan válasszunk megfelelő adatbázist és biztosítsuk a biztonságos kapcsolódást?

Az adatbázis kiválasztása és a kapcsolódás megértése alapvető fontosságú lépések a fejlesztési környezetekben, amelyek hatással vannak a teljes alkalmazás működésére és skálázhatóságára. Az adatbázisok nemcsak az aktuális igények kiszolgálására, hanem a jövőbeli bővítésekre és változásokra is felkészítenek minket. A megfelelő adatbázis kiválasztása, figyelembe véve a jövőbeli szükségleteket és a kapcsolódás biztonságát, lehetőséget ad arra, hogy alkalmazásunk hosszú távon is megbízhatóan működjön. Az alábbiakban bemutatjuk, hogyan válasszuk ki a legmegfelelőbb adatbázist és miként végezzünk biztonságos kapcsolódásokat SQL-alapú adatbázisokhoz.

A SQL adatbázisokhoz való kapcsolódás a fejlesztési környezetekben kulcsfontosságú. A kapcsolat lehetővé teszi számunkra, hogy lekérdezéseket futtassunk, adatokat kérjünk le és interakcióba lépjünk az adatbázissal. A kapcsolódás megvalósítása különböző programozási nyelvek, keretrendszerek és eszközök segítségével történhet, mindegyik más alkalmazási környezetekhez igazodva. E folyamat elsajátítása biztosítja a biztonságos és hatékony kommunikációt az alkalmazás és az adatbázis között.

A kapcsolódás alapvető fogalmainak megértése szükséges, hogy biztosak legyünk a megfelelő konfigurációban. Az SQL adatbázisokhoz való kapcsolódáshoz alapvetően az alábbi információk szükségesek:

1. Hostnév: Az adatbázis kiszolgáló címe, amely lehet helyi gép vagy távoli IP cím vagy domain név.

2. Port: Az adatbázis szolgáltatás kommunikációs portja. A leggyakoribb alapértelmezett portok a MySQL esetében a 3306, a PostgreSQL-nél a 5432, míg a Microsoft SQL Server 1433-at használ.

3. Adatbázis név: Az a konkrét adatbázis, amelyhez kapcsolódni szeretnénk.

4. Felhasználónév és jelszó: Az autentikációs adatok szükségesek az adatbázis eléréséhez.

5. Driver vagy könyvtár: Olyan szoftver, amely lehetővé teszi az alkalmazás számára az adatbázissal való kommunikációt, mint például a Pythonban a psycopg2 könyvtár a PostgreSQL-hez vagy a JDBC driver Java alkalmazásokhoz.

Az alábbiakban bemutatunk néhány példát, hogyan történhet az adatbázishoz való kapcsolódás különböző programozási nyelveken és eszközökkel.

A MySQL adatbázishoz való kapcsolódás a Python mysql-connector könyvtárával történhet, mint az alábbi példában:

python
Copy code
import mysql.connector
connection = mysql.connector.connect(
    host="localhost",
    user="root",
    password="password",
    database="sakila"
)
cursor = connection.cursor()
cursor.execute("SELECT * FROM film LIMIT 10")
for row in cursor.fetchall():
    print(row)
connection.close()

Ez a kód a Sakila mintaadatbázis csatlakozását mutatja be, majd lekérdezi az első tíz sort a film táblából.

A PostgreSQL adatbázis esetében a psycopg2 könyvtár segítségével történhet a kapcsolat létrehozása:

python
Copy code
import psycopg2

connection = psycopg2.connect(
    host="localhost",
    user="postgres",
    password="password",
    database="sakila"
)
cursor = connection.cursor()
cursor.execute("SELECT * FROM film LIMIT 10")
for row in cursor.fetchall():
    print(row)
connection.close()

A PostgreSQL előnye, hogy támogatja a csatlakozási poolingot is, például a pgbouncer használatával, amely javítja a rendszer erőforrásainak hatékony kihasználását.

A Microsoft SQL Server adatbázishoz való kapcsolódás az ADO.NET keretrendszeren keresztül, C# nyelvben történhet, mint az alábbi példában:

csharp
Copy code
using System;
using System.Data.SqlClient;
class Program
{
    static void Main()
    {
        string connectionString = "Server=localhost;Database=sakila;User Id=sa;Password=your_password;";
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();
            SqlCommand command = new SqlCommand("SELECT TOP 10 * FROM film", connection);
            SqlDataReader reader = command.ExecuteReader();
            while (reader.Read())
            {
                Console.WriteLine(reader["title"]);
            }
        }
    }
}

A fentiek mindegyike szemlélteti, hogy a különböző adatbázisokhoz való kapcsolódás más-más programozási környezetekhez és nyelvekhez igazodhat, de mindegyik biztosítja a szükséges rugalmasságot az alkalmazás és az adatbázis közötti hatékony kommunikációhoz.

A biztonságos kapcsolódás létrehozása érdekében kiemelten fontos a következő gyakorlatok alkalmazása:

• Környezeti változók használata: A felhasználónevek és jelszavak helyett jobb környezeti változókban tárolni ezeket az információkat, elkerülve ezzel azok közvetlen tárolását a kódban.

• Titkosítás engedélyezése: A Secure Sockets Layer/Transport Layer Security (SSL/TLS) titkosítást alkalmazva biztosíthatjuk az alkalmazás és az adatbázis közötti kommunikáció védelmét.

• IP-címek korlátozása: Az adatbázis elérését érdemes csak megbízható IP-címek számára engedélyezni, illetve VPN-t használni a biztonságos kapcsolódás érdekében.

• Kapcsolódási pooling alkalmazása: A kapcsolódás pooling segít hatékonyan kezelni az adatbázis kapcsolatokat, csökkentve az új kapcsolatok létrehozásával járó terhelést.

• Rendszeres frissítések: A megfelelő driverek és könyvtárak folyamatos frissítése biztosítja a legújabb biztonsági javításokat és a legújabb adatbázis-funkciók támogatását.

Hogyan készíthetünk adatvizualizációkat Python, SQLite és Matplotlib segítségével?

A Python és a SQLite együttes használata adatbázisok kezelésére és az adatvizualizációk előállítására egy rendkívül erőteljes eszközkombináció. A folyamat lépései, kezdve az adatbázis létrehozásától a grafikonok generálásáig, lehetőséget adnak arra, hogy a felhasználók valós idejű adatokat jelenítsenek meg és elemezzenek különböző módszerekkel. Az alábbiakban részletesen bemutatjuk, hogyan hozhatunk létre egy adatvizualizációs projektet Python, SQLite és Matplotlib segítségével, melyet egy egyszerű példán keresztül illusztrálunk.

Először is, szükséges telepíteni a szükséges eszközöket:

bash
Copy code
pip install matplotlib==3.10.0
pip install pandas==2.2.3

Ezután létre kell hozni egy új SQLite adatbázist, amely tartalmazza a vizualizálandó adatokat. Az adatbázist az alábbi parancsokkal hozhatjuk létre:

bash
Copy code
sqlite3 visualization_project.db

A következő lépés a sémák megtervezése, azaz az adatbázis struktúrájának definiálása. Mivel a célunk az eladási adatok tárolása, egy egyszerű sales (eladások) táblát hozunk létre, amely tartalmazza az eladásokat leíró alapvető információkat:

sql
Copy code
CREATE TABLE sales (
    sale_id INTEGER PRIMARY KEY AUTOINCREMENT,
    region TEXT NOT NULL,
    product TEXT NOT NULL,
    quantity INTEGER NOT NULL,
    price REAL NOT NULL,
    sale_date DATETIME NOT NULL
);

A tábla a következő adatokat tartalmazza: eladások egyedi azonosítója, régió, termék neve, eladott mennyiség, termék ára és a tranzakció dátuma.

Ezután mintákat kell hozzáadnunk a sales táblához, hogy szimuláljuk a valódi tranzakciókat. Az alábbi SQL lekérdezéssel több rekordot adhatunk hozzá:

sql
Copy code
INSERT INTO sales (region, product, quantity, price, sale_date) 

VALUES 
('North', 'Laptop', 10, 1200.00, '2024-01-10'),

('South', 'Tablet', 15, 500.00, '2024-01-11'),

('East', 'Smartphone', 20, 800.00, '2024-01-12'),

('West', 'Headphones', 25, 150.00, '2024-01-13'),

('North', 'Tablet', 12, 300.00, '2024-02-14'),

('South', 'Laptop', 8, 2000.00, '2024-02-15'),

('North', 'Laptop', 10, 1500.00, '2024-02-10'),

('South', 'Tablet', 15, 400.00, '2024-03-11'),

('East', 'Smartphone', 20, 1300.00, '2024-03-12'),

('West', 'Headphones', 25, 750.00, '2024-03-13');

Miután az adatokat feltöltöttük, készen állunk arra, hogy lekérdezzük az adatokat a vizualizációhoz. Ehhez SQL lekérdezéseket alkalmazunk. Az első példa egy egyszerű lekérdezés, amely kiszámolja az összesített bevételt régiók szerint:

sql
Copy code
SELECT region, SUM(quantity * price) AS total_revenue
FROM sales
GROUP BY region;

Egy másik hasznos lekérdezés lehet az eladott termékek összesített száma:

sql
Copy code
SELECT product, SUM(quantity) AS total_sales

FROM sales
GROUP BY product;

A harmadik lekérdezés pedig havi bevételt aggregál:

sql
Copy code
SELECT strftime('%Y-%m', sale_date) AS month, SUM(quantity * price) AS monthly_revenue
FROM sales
GROUP BY month
ORDER BY month;

A lekérdezések után fontos lépés a kinyert adatok exportálása. Ehhez SQLite shell parancsokat használunk CSV formátumba, amely könnyen importálható Pythonban vagy bármely más elemző eszközbe:

sql
Copy code
.headers on

.mode csv
.output regional_revenue.csv
SELECT region, SUM(quantity * price) AS total_revenue FROM sales GROUP BY region;
.output

Ezeket az adatokat aztán felhasználhatjuk a vizualizációs lépéshez. A következő lépés Python és Matplotlib használatával történik, ahol a CSV fájlokat betöltjük és grafikonokat készítünk belőlük. A következő kóddal készíthetünk egy oszlopdiagramot, amely megjeleníti a régiók szerinti bevételt:

python
Copy code
import pandas as pd

import matplotlib.pyplot as plt
# Adatok betöltése
regional_revenue = pd.read_csv('regional_revenue.csv')
# Grafikon készítése
plt.bar(regional_revenue['region'], regional_revenue['total_revenue'], color='blue')
plt.title('Összes bevétel régiónként')
plt.xlabel('Régió')
plt.ylabel('Bevétel')
plt.show()

Ugyanígy létrehozhatunk egy vonaldiagramot is a havi bevételi trendek megjelenítésére:

python
Copy code
monthly_revenue = pd.read_csv('monthly_revenue.csv')
plt.plot(monthly_revenue['month'], monthly_revenue['monthly_revenue'], marker='o')
plt.title('Havi bevételi trendek')
plt.xlabel('Hónap')
plt.ylabel('Bevétel')
plt.xticks(rotation=45)
plt.show()

Miután a szükséges adatokat lekérdeztük és vizualizáltuk, további finomításokat végezhetünk, ha szükséges. Például érdemes a grafikonokat különböző szempontok szerint testre szabni, például színek, címkék vagy tengelyek módosításával, hogy a vizualizáció minél érthetőbb és hasznosabb legyen.

Az adatok vizualizálása segít a döntéshozatalban, mivel az üzleti trendeket és a teljesítmény különböző aspektusait egyértelműen és könnyen értelmezhető módon mutatja be. Továbbá a Python és Matplotlib alkalmazása automatizálható és testre szabható, így alkalmas különböző típusú riportok generálására és elosztására is. Az adatok ilyen módon történő feldolgozása és elemzése hatékony módja annak, hogy jobban megértsük az üzleti teljesítményt és pontosabb döntéseket hozzunk.