1 bài viết được gắn thẻ "Phân tích dữ liệu"

# 1. Cấu trúc dữ liệu — dùng mỗi ngày
khach_hang = {"ten": "Minh", "tuoi": 28, "thanh_pho": "Hà Nội"}
danh_sach_don = [120000, 350000, 89000]

# 2. List/dict comprehension — để biến đổi dữ liệu gọn gàng
don_lon = [d for d in danh_sach_don if d > 100000]
tong_theo_thanh_pho = {tp: 0 for tp in {"Hà Nội", "TP.HCM"}}

# 3. Vòng lặp + điều kiện — nhưng HẠN CHẾ dùng, pandas thay thế
for d in danh_sach_don:
    if d > 200000:
        print(f"Đơn lớn: {d:,} đ")

# 4. Hàm — tái sử dụng logic
def phan_loai_khach(so_don: int) -> str:
    if so_don >= 20:
        return "VIP"
    if so_don >= 5:
        return "Thân thiết"
    return "Mới"

# 5. Xử lý file
import json
from pathlib import Path

du_lieu = json.loads(Path("du-lieu.json").read_text(encoding="utf-8"))
Path("ket-qua.json").write_text(
    json.dumps(du_lieu, ensure_ascii=False, indent=2), encoding="utf-8"
)

# 6. Ngoại lệ — dữ liệu thật luôn bẩn
def chuyen_so(gt):
    try:
        return float(str(gt).replace(",", "").replace("đ", "").strip())
    except (ValueError, AttributeError):
        return None

import pandas as pd

# --- Đọc dữ liệu ---
df = pd.read_csv("don-hang.csv", encoding="utf-8", parse_dates=["ngay_dat"])
df_excel = pd.read_excel("bao-cao.xlsx", sheet_name="Sheet1", skiprows=3)
df_sql = pd.read_sql("SELECT * FROM don_hang", conn)

# --- Khám phá ban đầu (LUÔN làm 4 bước này) ---
print(df.shape)              # (số dòng, số cột)
print(df.dtypes)             # kiểu dữ liệu từng cột
print(df.head(10))           # xem 10 dòng đầu
print(df.describe())         # thống kê mô tả
print(df.isna().sum())       # đếm giá trị thiếu mỗi cột
print(df.duplicated().sum()) # đếm dòng trùng

import pandas as pd

df = pd.read_csv("don-hang.csv", parse_dates=["ngay_dat"])

# Làm sạch nhanh
df = df.dropna(subset=["khach_hang_id", "gia"])
df = df[df["gia"] > 0]
df = df.drop_duplicates(subset=["ma_don"])

# Tạo cột thời gian
df["thang"] = df["ngay_dat"].dt.to_period("M").astype(str)

# Báo cáo tổng hợp
bao_cao = (
    df.groupby(["thang", "thanh_pho"])
      .agg(
          so_don=("ma_don", "nunique"),
          doanh_thu=("gia", "sum"),
          gia_tb=("gia", "mean"),
      )
      .reset_index()
)

# Tính tăng trưởng so với tháng trước
bao_cao["tang_truong_pct"] = (
    bao_cao.sort_values("thang")
            .groupby("thanh_pho")["doanh_thu"]
            .pct_change()
            .mul(100)
            .round(2)
)

print(bao_cao.to_string(index=False))

# Xuất kết quả
bao_cao.to_excel("bao-cao-doanh-thu.xlsx", index=False)
bao_cao.to_csv("bao-cao-doanh-thu.csv", index=False, encoding="utf-8-sig")

# ❌ SettingWithCopyWarning — thao tác trên bản sao
df[df.gia > 100]["gia"] = 0

# ✅ Dùng .loc
df.loc[df.gia > 100, "gia"] = 0

# ❌ Vòng lặp qua từng dòng — cực chậm với dữ liệu lớn
for i, row in df.iterrows():
    df.loc[i, "gia_vnd"] = row["gia"] * 25400

# ✅ Vector hoá — nhanh hơn hàng trăm lần
df["gia_vnd"] = df["gia"] * 25400

# ❌ Đọc cả file Excel 500MB vào bộ nhớ
df = pd.read_excel("khong-lo.xlsx")

# ✅ Đọc từng phần
for chunk in pd.read_csv("khong-lo.csv", chunksize=100_000):
    xu_ly(chunk)

import pandas as pd
from sqlalchemy import create_engine, text

engine = create_engine("postgresql+psycopg://user:pass@localhost:5432/analytics")

# Đọc dữ liệu — LUÔN dùng tham số hoá
truy_van = text("""
    SELECT kh.thanh_pho, SUM(dh.tong_tien) AS doanh_thu
    FROM don_hang dh
    JOIN khach_hang kh ON kh.id = dh.khach_hang_id
    WHERE dh.ngay_dat >= :tu_ngay
    GROUP BY kh.thanh_pho
    ORDER BY doanh_thu DESC
""")

df = pd.read_sql(truy_van, engine, params={"tu_ngay": "2026-01-01"})
print(df.head())

import pandas as pd
import numpy as np

df = pd.read_csv("du-lieu-tho.csv")

# --- 1. Kiểm tra tổng quan ---
print(df.info())
print(df.isna().mean().sort_values(ascending=False))   # tỷ lệ thiếu mỗi cột

# --- 2. Chuẩn hoá tên cột ---
df.columns = (
    df.columns.str.strip()
              .str.lower()
              .str.replace(r"[^\w]+", "_", regex=True)
)

# --- 3. Xử lý giá trị thiếu ---
# Cột số: điền median (an toàn hơn mean khi có outlier)
df["gia"] = df["gia"].fillna(df["gia"].median())

# Cột phân loại: điền nhãn rõ ràng, KHÔNG điền mode
df["thanh_pho"] = df["thanh_pho"].fillna("Không xác định")

# Cột quan trọng thiếu nhiều: bỏ luôn
df = df.dropna(subset=["khach_hang_id"])

# --- 4. Xử lý outlier bằng IQR ---
Q1, Q3 = df["gia"].quantile([0.25, 0.75])
IQR = Q3 - Q1
gioi_han_duoi, gioi_han_tren = Q1 - 1.5 * IQR, Q3 + 1.5 * IQR
df["gia"] = df["gia"].clip(gioi_han_duoi, gioi_han_tren)

# --- 5. Chuẩn hoá chuỗi ---
df["email"] = df["email"].str.strip().str.lower()
df["ten"] = df["ten"].str.strip().str.title()

# --- 6. Chuẩn hoá ngày tháng ---
df["ngay_dat"] = pd.to_datetime(df["ngay_dat"], errors="coerce", dayfirst=True)
df = df.dropna(subset=["ngay_dat"])          # bỏ dòng ngày không parse được

# --- 7. Loại trùng ---
df = df.drop_duplicates(subset=["ma_don"], keep="last")

# --- 8. Kiểm tra tính hợp lý ---
assert (df["gia"] >= 0).all(), "Có giá âm!"
assert df["ngay_dat"].max() <= pd.Timestamp.now(), "Có ngày trong tương lai!"

print(f"✅ Sau làm sạch: {df.shape[0]:,} dòng × {df.shape[1]} cột")

import matplotlib.pyplot as plt
import seaborn as sns

plt.rcParams["figure.figsize"] = (12, 6)
plt.rcParams["font.size"] = 11
sns.set_theme(style="whitegrid")

# --- Biểu đồ cột ---
theo_thanh_pho = df.groupby("thanh_pho")["gia"].sum().sort_values()

ax = theo_thanh_pho.plot(kind="barh", color="#2563eb")
ax.set_title("Doanh thu theo thành phố", fontsize=14, fontweight="bold")
ax.set_xlabel("Doanh thu (VNĐ)")
ax.set_ylabel("")
ax.bar_label(ax.containers[0], fmt="%.0f", padding=3)
plt.tight_layout()
plt.savefig("doanh-thu-thanh-pho.png", dpi=150)
plt.show()

import numpy as np
from scipy import stats

# --- 1. Phân biệt mean, median, mode ---
# Lương: 5 người, 1 người lương 500tr → mean bị kéo lệch
luong = [8, 9, 10, 11, 500]
print(f"Mean: {np.mean(luong):.1f} (bị outlier kéo lệch)")
print(f"Median: {np.median(luong):.1f} (đại diện tốt hơn)")

# --- 2. Độ lệch chuẩn — đo mức biến động ---
print(f"Độ lệch chuẩn: {np.std(luong, ddof=1):.2f}")

# --- 3. Kiểm định giả thuyết: hai nhóm có khác nhau thật không? ---
nhom_a = [120, 135, 128, 142, 119, 131]         # thiết kế cũ
nhom_b = [145, 152, 138, 160, 149, 155]         # thiết kế mới

t_stat, p_value = stats.ttest_ind(nhom_a, nhom_b)
print(f"p-value = {p_value:.4f}")
if p_value < 0.05:
    print("✅ Khác biệt có ý nghĩa thống kê")
else:
    print("⚠️ Chưa đủ bằng chứng để kết luận khác biệt")

# --- 4. Tương quan ---
r, p = stats.pearsonr(df["chi_phi_marketing"], df["doanh_thu"])
print(f"Hệ số tương quan r = {r:.3f}, p = {p:.4f}")

"""Báo cáo tuần tự động: lấy dữ liệu → tính toán → xuất file → gửi email."""
import smtplib
from email.mime.application import MIMEApplication
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from pathlib import Path
from datetime import datetime, timedelta

import pandas as pd
from sqlalchemy import create_engine, text


def lay_du_lieu(tu_ngay, den_ngay) -> pd.DataFrame:
    engine = create_engine("postgresql+psycopg://user:pass@localhost/analytics")
    truy_van = text("""
        SELECT dh.ngay_dat, kh.thanh_pho, dh.tong_tien, dh.trang_thai
        FROM don_hang dh
        JOIN khach_hang kh ON kh.id = dh.khach_hang_id
        WHERE dh.ngay_dat BETWEEN :tu AND :den
    """)
    return pd.read_sql(truy_van, engine, params={"tu": tu_ngay, "den": den_ngay})


def tinh_bao_cao(df: pd.DataFrame) -> pd.DataFrame:
    df = df[df["trang_thai"] == "hoan_thanh"].copy()
    df["tuan"] = df["ngay_dat"].dt.to_period("W").astype(str)

    return (
        df.groupby(["tuan", "thanh_pho"])
          .agg(so_don=("tong_tien", "count"),
               doanh_thu=("tong_tien", "sum"),
               don_tb=("tong_tien", "mean"))
          .round(0)
          .reset_index()
    )


def xuat_file(bao_cao: pd.DataFrame, tp: Path) -> Path:
    with pd.ExcelWriter(tp, engine="openpyxl") as writer:
        bao_cao.to_excel(writer, sheet_name="Chi tiết", index=False)

        tong_hop = (bao_cao.groupby("thanh_pho")["doanh_thu"].sum()
                           .sort_values(ascending=False).reset_index())
        tong_hop.to_excel(writer, sheet_name="Tổng hợp", index=False)

        # Tự điều chỉnh độ rộng cột
        for sheet in writer.sheets.values():
            for cot in sheet.columns:
                do_dai = max(len(str(o.value or "")) for o in cot)
                sheet.column_dimensions[cot[0].column_letter].width = min(do_dai + 4, 40)
    return tp


def gui_email(tp: Path, nguoi_nhan: list[str], tom_tat_html: str) -> None:
    msg = MIMEMultipart("mixed")
    msg["Subject"] = f"Báo cáo doanh thu tuần — {datetime.now():%d/%m/%Y}"
    msg["From"] = "bao-cao@congty.com"
    msg["To"] = ", ".join(nguoi_nhan)

    msg.attach(MIMEText(tom_tat_html, "html", "utf-8"))

    with open(tp, "rb") as f:
        dinh_kem = MIMEApplication(f.read(), Name=tp.name)
    dinh_kem["Content-Disposition"] = f'attachment; filename="{tp.name}"'
    msg.attach(dinh_kem)

    with smtplib.SMTP_SSL("smtp.gmail.com", 465) as server:
        server.login("bao-cao@congty.com", "mat-khau-ung-dung")
        server.send_message(msg)


def chay_bao_cao_tuan():
    den_ngay = datetime.now().date()
    tu_ngay = den_ngay - timedelta(days=7)

    df = lay_du_lieu(tu_ngay, den_ngay)
    if df.empty:
        print("⚠️ Không có dữ liệu trong kỳ, bỏ qua.")
        return

    bao_cao = tinh_bao_cao(df)
    tp = xuat_file(bao_cao, Path(f"bao-cao-{den_ngay:%Y-%m-%d}.xlsx"))

    tong = bao_cao["doanh_thu"].sum()
    so_don = bao_cao["so_don"].sum()
    tom_tat = f"""
    <h2>Báo cáo tuần {tu_ngay:%d/%m} – {den_ngay:%d/%m/%Y}</h2>
    <ul>
      <li>Tổng doanh thu: <b>{tong:,.0f} đ</b></li>
      <li>Số đơn hoàn thành: <b>{so_don:,}</b></li>
      <li>Giá trị đơn trung bình: <b>{tong / so_don:,.0f} đ</b></li>
    </ul>
    <p>Chi tiết xem trong file đính kèm.</p>
    """

    gui_email(tp, ["sep@congty.com", "team@congty.com"], tom_tat)
    print(f"✅ Đã gửi báo cáo: {tp.name}")


if __name__ == "__main__":
    chay_bao_cao_tuan()

# streamlit_dashboard.py — dashboard nhanh bằng Python
import streamlit as st
import pandas as pd
import plotly.express as px

st.set_page_config(page_title="Dashboard Bán hàng", layout="wide")
st.title("📊 Dashboard Bán hàng")

@st.cache_data(ttl=600)
def tai_du_lieu():
    return pd.read_csv("du-lieu-da-sach.csv", parse_dates=["ngay_dat"])

df = tai_du_lieu()

with st.sidebar:
    st.header("Bộ lọc")
    thanh_pho = st.multiselect("Thành phố", sorted(df["thanh_pho"].unique()),
                               default=sorted(df["thanh_pho"].unique()))
    khoang = st.date_input("Khoảng thời gian",
                           value=(df["ngay_dat"].min(), df["ngay_dat"].max()))

df_loc = df[df["thanh_pho"].isin(thanh_pho)]
df_loc = df_loc[(df_loc["ngay_dat"] >= pd.Timestamp(khoang[0]))
                & (df_loc["ngay_dat"] <= pd.Timestamp(khoang[1]))]

c1, c2, c3 = st.columns(3)
c1.metric("Doanh thu", f"{df_loc['tong_tien'].sum():,.0f} đ")
c2.metric("Số đơn", f"{len(df_loc):,}")
c3.metric("Đơn trung bình", f"{df_loc['tong_tien'].mean():,.0f} đ")

st.plotly_chart(
    px.line(df_loc.groupby("ngay_dat")["tong_tien"].sum().reset_index(),
            x="ngay_dat", y="tong_tien", title="Doanh thu theo ngày"),
    use_container_width=True,
)

st.plotly_chart(
    px.bar(df_loc.groupby("thanh_pho")["tong_tien"].sum().sort_values().reset_index(),
           x="tong_tien", y="thanh_pho", orientation="h", title="Doanh thu theo thành phố"),
    use_container_width=True,
)

# Đưa việc kiểm tra vào code — chạy được, không phải tự nhớ
from dataclasses import dataclass


@dataclass
class KetQuaKiemTra:
    ten: str
    dat: bool
    chi_tiet: str


def kiem_tra_chat_luong(df, cot_so: list[str], cot_khoa: str) -> list[KetQuaKiemTra]:
    kq = []

    trung = df.duplicated(subset=[cot_khoa]).sum()
    kq.append(KetQuaKiemTra("Không trùng khoá", trung == 0, f"{trung} dòng trùng"))

    thieu = df.isna().mean().max()
    kq.append(KetQuaKiemTra("Tỷ lệ thiếu < 20%", thieu < 0.2, f"cao nhất {thieu:.1%}"))

    am = (df[cot_so] < 0).any().any()
    kq.append(KetQuaKiemTra("Không có giá trị âm bất thường", not am, ""))

    kq.append(KetQuaKiemTra("Có dữ liệu", len(df) > 0, f"{len(df):,} dòng"))

    return kq


for k in kiem_tra_chat_luong(df, ["doanh_thu"], "ma_don"):
    print(f"{'✅' if k.dat else '❌'} {k.ten} — {k.chi_tiet}")