Python 7 — Pandas & NumPy cho phân tích dữ liệu

import numpy as np

# Tạo mảng từ list
so_du = np.array([1_200_000, 5_400_000, 800_000, 12_000_000])
print(so_du.dtype)   # int64
print(so_du.shape)   # (4,)  -> mảng 1 chiều, 4 phần tử
print(so_du.ndim)    # 1

# Mảng 2 chiều: 3 khách hàng, 4 tháng số dư
ma_tran = np.array([
    [1.2, 1.5, 1.1, 2.0],
    [0.8, 0.9, 1.0, 1.1],
    [5.0, 4.8, 5.2, 6.0],
])
print(ma_tran.shape)  # (3, 4)

# Các cách khởi tạo nhanh
np.zeros((2, 3))          # ma trận 0
np.ones(5)                # [1. 1. 1. 1. 1.]
np.arange(0, 10, 2)       # [0 2 4 6 8]
np.linspace(0, 1, 5)      # 5 điểm cách đều từ 0 đến 1
np.random.seed(42)
np.random.rand(3)         # 3 số ngẫu nhiên [0,1)

so_du = list(range(1_000_000))
lai = []
for x in so_du:
    lai.append(x * 0.06)

so_du = np.arange(1_000_000)
lai = so_du * 0.06        # một biểu thức, áp dụng cho TẤT CẢ phần tử

import time

n = 5_000_000
a = np.arange(n)

t0 = time.perf_counter()
tong_loop = sum(x * 2 for x in a)        # chậm
t1 = time.perf_counter()
tong_vec = (a * 2).sum()                 # nhanh
t2 = time.perf_counter()

print(f"Vòng lặp: {t1 - t0:.3f}s")       # thường ~0.5-1s
print(f"Vectorized: {t2 - t1:.3f}s")     # thường ~0.01s

# Số dư 3 khách qua 4 tháng (triệu đồng)
sd = np.array([
    [1.2, 1.5, 1.1, 2.0],
    [0.8, 0.9, 1.0, 1.1],
    [5.0, 4.8, 5.2, 6.0],
])

# Cộng phí 0.1 triệu cho MỌI ô (số vô hướng "lan" ra toàn mảng)
print(sd + 0.1)

# Trừ số dư trung bình của từng tháng (mảng 4 phần tử lan theo từng hàng)
tb_thang = sd.mean(axis=0)        # shape (4,)
print(sd - tb_thang)              # (3,4) - (4,) -> hợp lệ, lan theo cột

sd.sum()            # tổng tất cả
sd.sum(axis=0)      # tổng theo cột (gộp các hàng) -> tổng từng tháng
sd.sum(axis=1)      # tổng theo hàng -> tổng cả năm từng khách
sd.mean(), sd.max(), sd.min(), sd.std()
np.where(sd > 2, "cao", "thấp")     # if-else trên cả mảng

import pandas as pd

# Series
so_du = pd.Series([1.2, 0.8, 5.0], index=["KH001", "KH002", "KH003"], name="so_du")
print(so_du["KH002"])     # 0.8

# DataFrame từ dict
df = pd.DataFrame({
    "ma_kh":     ["KH001", "KH002", "KH003", "KH004"],
    "chi_nhanh": ["HN", "HN", "HCM", "HCM"],
    "so_tien":   [1_200_000, 800_000, 5_000_000, 300_000],
    "loai_gd":   ["chuyen", "rut", "chuyen", "nap"],
})
print(df.head())          # 5 dòng đầu
print(df.info())          # kiểu, số dòng, bộ nhớ
print(df.describe())      # thống kê cột số
print(df.shape)           # (4, 4)

# Đọc CSV
df = pd.read_csv(
    "giao_dich_thang_06.csv",
    sep=",",
    parse_dates=["ngay_gd"],          # tự chuyển sang kiểu ngày
    dtype={"ma_kh": "string"},        # ép kiểu cột
    na_values=["", "NULL", "N/A"],    # coi các chuỗi này là thiếu
)

# Đọc theo từng khối (chunk) khi file quá lớn để vừa RAM
tong = 0
for chunk in pd.read_csv("giao_dich_lon.csv", chunksize=100_000):
    tong += chunk["so_tien"].sum()

from sqlalchemy import create_engine

engine = create_engine("postgresql://user:pass@host:5432/corebank")

df = pd.read_sql(
    """
    SELECT ma_kh, chi_nhanh, so_tien, loai_gd, ngay_gd
    FROM giao_dich
    WHERE ngay_gd >= '2026-06-01'
    """,
    con=engine,
    parse_dates=["ngay_gd"],
)

# 1. Chọn cột
df["so_tien"]                 # một cột -> Series
df[["ma_kh", "so_tien"]]      # nhiều cột -> DataFrame

# 2. .loc — chọn theo NHÃN (tên cột, giá trị index)
df.loc[0, "so_tien"]                       # ô tại index 0, cột so_tien
df.loc[0:2, ["ma_kh", "chi_nhanh"]]        # dải index 0..2 (BAO GỒM 2)

# 3. .iloc — chọn theo VỊ TRÍ số (như mảng)
df.iloc[0, 2]                 # hàng 0, cột thứ 3
df.iloc[0:2, :]               # 2 hàng đầu (KHÔNG bao gồm 2)

# 4. Boolean indexing — lọc theo điều kiện (rất quan trọng)
df[df["so_tien"] > 1_000_000]                       # giao dịch lớn
df[(df["chi_nhanh"] == "HN") & (df["so_tien"] > 500_000)]   # AND dùng &
df[df["loai_gd"].isin(["chuyen", "rut"])]            # thuộc danh sách
df[df["so_tien"].between(100_000, 1_000_000)]        # trong khoảng

# Phát hiện giao dịch đáng ngờ
nghi_van = df[df["so_tien"] >= 500_000_000]

df.isna().sum()               # đếm số ô thiếu của từng cột
df["chi_nhanh"].isna().any()  # có thiếu không?

# Xóa dòng/cột thiếu
df.dropna()                          # bỏ dòng có BẤT KỲ ô nào thiếu
df.dropna(subset=["so_tien"])        # chỉ bỏ khi thiếu so_tien
df.dropna(axis=1)                    # bỏ cột có thiếu

# Điền giá trị thiếu
df["chi_nhanh"] = df["chi_nhanh"].fillna("KHONG_RO")
df["so_tien"] = df["so_tien"].fillna(df["so_tien"].median())   # điền trung vị
df["so_du"] = df["so_du"].fillna(method="ffill")               # lấy giá trị trước

# Tổng số tiền theo chi nhánh
df.groupby("chi_nhanh")["so_tien"].sum()

# Nhiều thống kê cùng lúc
df.groupby("chi_nhanh")["so_tien"].agg(["sum", "mean", "count", "max"])

# Gộp theo nhiều cột
df.groupby(["chi_nhanh", "loai_gd"])["so_tien"].sum()

# Tên cột kết quả tùy chỉnh (named aggregation)
bao_cao = df.groupby("chi_nhanh").agg(
    tong_tien=("so_tien", "sum"),
    so_giao_dich=("so_tien", "count"),
    tien_lon_nhat=("so_tien", "max"),
).reset_index()
print(bao_cao)

khach_hang = pd.DataFrame({
    "ma_kh":  ["KH001", "KH002", "KH003"],
    "ten":    ["An", "Bình", "Cường"],
    "hang":   ["Vàng", "Bạc", "Kim cương"],
})

# inner: chỉ giữ ma_kh có ở CẢ hai bảng
kq = df.merge(khach_hang, on="ma_kh", how="inner")

# left: giữ TẤT CẢ giao dịch, thêm thông tin khách nếu có
kq = df.merge(khach_hang, on="ma_kh", how="left")

bang_cheo = df.pivot_table(
    index="chi_nhanh",       # hàng
    columns="loai_gd",       # cột
    values="so_tien",        # giá trị tổng hợp
    aggfunc="sum",           # cách gộp
    fill_value=0,            # ô trống -> 0
    margins=True,            # thêm dòng/cột "All" (tổng)
)
print(bang_cheo)

# map trên Series: ánh xạ giá trị
muc_phi = {"chuyen": 0.0003, "rut": 0.0, "nap": 0.0}
df["phi"] = df["loai_gd"].map(muc_phi) * df["so_tien"]

# apply trên Series
df["so_tien_trieu"] = df["so_tien"].apply(lambda x: round(x / 1_000_000, 2))

# apply trên DataFrame theo từng dòng (axis=1)
def phan_loai(row):
    if row["so_tien"] >= 500_000_000:
        return "Báo cáo NHNN"
    elif row["so_tien"] >= 100_000_000:
        return "Theo dõi"
    return "Bình thường"

df["canh_bao"] = df.apply(phan_loai, axis=1)

# Phiên bản vector hóa nhanh của phan_loai
dieu_kien = [df["so_tien"] >= 500_000_000, df["so_tien"] >= 100_000_000]
nhan = ["Báo cáo NHNN", "Theo dõi"]
df["canh_bao"] = np.select(dieu_kien, nhan, default="Bình thường")

df.sort_values("so_tien", ascending=False)
df.sort_values(["chi_nhanh", "so_tien"], ascending=[True, False])

# Tạo cột mới
df["sau_phi"] = df["so_tien"] - df["phi"]

# Xử lý cột ngày
df["thang"] = df["ngay_gd"].dt.month
df["ngay_trong_tuan"] = df["ngay_gd"].dt.day_name()

bao_cao.to_csv("bao_cao_chi_nhanh.csv", index=False, encoding="utf-8-sig")
bao_cao.to_excel("bao_cao.xlsx", sheet_name="ChiNhanh", index=False)
bao_cao.to_sql("bao_cao_thang", con=engine, if_exists="replace", index=False)
bao_cao.to_parquet("bao_cao.parquet")   # nén tốt, đọc nhanh, giữ kiểu

import pandas as pd
import numpy as np

# 1. Đọc
gd = pd.read_csv("giao_dich.csv", parse_dates=["ngay_gd"],
                 na_values=["", "NULL"])

# 2. Làm sạch
gd = gd.dropna(subset=["so_tien", "ma_kh"])
gd["chi_nhanh"] = gd["chi_nhanh"].fillna("KHONG_RO")
gd["so_tien"] = gd["so_tien"].astype("float64")

# 3. Lọc giao dịch hợp lệ trong tháng
gd = gd[(gd["so_tien"] > 0) & (gd["ngay_gd"].dt.month == 6)]

# 4. Cột cảnh báo (vector hóa)
gd["canh_bao"] = np.select(
    [gd["so_tien"] >= 500_000_000, gd["so_tien"] >= 100_000_000],
    ["Báo cáo NHNN", "Theo dõi"],
    default="Bình thường",
)

# 5. Tổng hợp theo chi nhánh
bao_cao = gd.groupby("chi_nhanh").agg(
    tong_tien=("so_tien", "sum"),
    so_gd=("so_tien", "count"),
    gd_lon=("canh_bao", lambda s: (s == "Báo cáo NHNN").sum()),
).reset_index()

# 6. Nối hạng khách của giao dịch lớn nhất mỗi chi nhánh (ví dụ merge)
kh = pd.read_csv("khach_hang.csv")
chi_tiet = gd.merge(kh[["ma_kh", "hang"]], on="ma_kh", how="left")

# 7. Xuất
bao_cao.to_csv("bao_cao_thang_06.csv", index=False, encoding="utf-8-sig")
print(bao_cao)