import psutil

# 1. CPU 时间统计（user=用户态耗时、system=系统态耗时、idle=空闲耗时等）
print("CPU 时间统计：", psutil.cpu_times())

# 2. 核心数查询
print("逻辑核心数：", psutil.cpu_count())       # 含超线程的逻辑核心
print("物理核心数：", psutil.cpu_count(logical=False))  # 实际物理核心

# 3. 使用率查询（interval=1 表示采样1秒后返回结果，避免瞬时值）
print("CPU 总使用率（1秒采样）：", psutil.cpu_percent(interval=1))
print("各逻辑核心使用率（1秒采样）：", psutil.cpu_percent(interval=1, percpu=True))

import psutil

def bytes_to_human(n: int, unit_base: int = 1024) -> str:
    """字节单位转换为人类可读格式（如 B→KB→MB→GB）"""
    if n < 0:
        return "0.00 B"
    units = ["B", "KB", "MB", "GB", "TB"]
    index = 0
    while n >= unit_base and index < len(units) - 1:
        n /= unit_base
        index += 1
    return f"{n:.2f} {units[index]}"

# ---------------------- 物理内存信息 ----------------------
print("=== 物理内存（virtual_memory）===")
virtual_mem = psutil.virtual_memory()
virtual_mem_human = {
    "总量": bytes_to_human(virtual_mem.total),
    "可用": bytes_to_human(virtual_mem.available),
    "已用": bytes_to_human(virtual_mem.used),
    "空闲": bytes_to_human(virtual_mem.free),
    "使用率": f"{virtual_mem.percent}%",
}
for key, value in virtual_mem_human.items():
    print(f"{key:8s}: {value}")

# ---------------------- 交换内存信息 ----------------------
print("\n=== 交换内存（swap_memory）===")
swap_mem = psutil.swap_memory()
swap_mem_human = {
    "总量": bytes_to_human(swap_mem.total),
    "已用": bytes_to_human(swap_mem.used),
    "空闲": bytes_to_human(swap_mem.free),
    "使用率": f"{swap_mem.percent}%",
    "从磁盘交换入内存": bytes_to_human(swap_mem.sin),
    "从内存交换到磁盘": bytes_to_human(swap_mem.sout)
}
for key, value in swap_mem_human.items():
    print(f"{key:12s}: {value}")

import psutil
import platform

# 复用之前定义的字节转换工具函数
def bytes_to_human(n: int, unit_base: int = 1024) -> str:
    if n < 0:
        return "0.00 B"
    units = ["B", "KB", "MB", "GB", "TB"]
    index = 0
    while n >= unit_base and index < len(units) - 1:
        n /= unit_base
        index += 1
    return f"{n:.2f} {units[index]}"

def windows_time_convert(n: int) -> str:
    """Windows 磁盘时间单位转换（100纳秒 → 毫秒）"""
    if platform.system() == "Windows":
        ms = n * 0.0001
        return f"{ms:.2f} 毫秒"
    else:
        return f"{n:.2f} 毫秒"

# ---------------------- 1. 磁盘分区信息 ----------------------
print("=== 1. 磁盘分区信息 ===")
partitions = psutil.disk_partitions(all=False)  # all=False：仅显示物理分区
for idx, part in enumerate(partitions, 1):
    print(f"\n分区 {idx}：")
    print(f"  设备路径：{part.device}")
    print(f"  挂载点：{part.mountpoint}")
    print(f"  文件系统：{part.fstype}")
    print(f"  挂载选项：{part.opts}")

# ---------------------- 2. 磁盘使用率 ----------------------
print("\n\n=== 2. 磁盘使用率（按挂载点）===")
# 跨平台适配：Windows 默认查询 C 盘，Linux/macOS 默认查询根目录
target_path = "C:" if platform.system() == "Windows" else "/"
disk_usage = psutil.disk_usage(target_path)
disk_usage_human = {
    "挂载点": target_path,
    "总容量": bytes_to_human(disk_usage.total),
    "已用容量": bytes_to_human(disk_usage.used),
    "空闲容量": bytes_to_human(disk_usage.free),
    "使用率": f"{disk_usage.percent:.2f}%"
}
for key, value in disk_usage_human.items():
    print(f"  {key:8s}: {value}")

# ---------------------- 3. 磁盘 IO 统计（全局） ----------------------
print("\n\n=== 3. 磁盘 IO 统计（全局汇总）===")
disk_io = psutil.disk_io_counters(perdisk=False)
disk_io_human = {
    "读取次数": disk_io.read_count,
    "写入次数": disk_io.write_count,
    "读取总字节": bytes_to_human(disk_io.read_bytes),
    "写入总字节": bytes_to_human(disk_io.write_bytes),
    "读取总时间": windows_time_convert(disk_io.read_time),
    "写入总时间": windows_time_convert(disk_io.write_time),
    "合并读取次数": disk_io.read_merged_count,
    "合并写入次数": disk_io.write_merged_count
}
# 仅 Linux 显示忙碌时间
if hasattr(disk_io, "busy_time") and disk_io.busy_time > 0:
    disk_io_human["磁盘忙碌时间"] = f"{disk_io.busy_time:.2f} 毫秒"

for key, value in disk_io_human.items():
    print(f"  {key:12s}: {value}")

# ---------------------- 4. 单个磁盘 IO 统计（可选） ----------------------
print("\n\n=== 4. 单个磁盘 IO 统计 ===")
disk_io_per_disk = psutil.disk_io_counters(perdisk=True)
for disk_name, io_data in disk_io_per_disk.items():
    print(f"\n  磁盘 {disk_name}：")
    print(f"    读取字节：{bytes_to_human(io_data.read_bytes)}")
    print(f"    写入字节：{bytes_to_human(io_data.write_bytes)}")
    print(f"    读取次数：{io_data.read_count}")
    print(f"    写入次数：{io_data.write_count}")

import psutil
import socket
import platform

# 复用字节转换工具函数
def bytes_to_human(n: int, unit_base: int = 1024) -> str:
    if n < 0:
        return "0.00 B"
    units = ["B", "KB", "MB", "GB", "TB"]
    index = 0
    while n >= unit_base and index < len(units) - 1:
        n /= unit_base
        index += 1
    return f"{n:.2f} {units[index]}"

def family_to_name(family: int) -> str:
    """地址族枚举值转中文（AF_INET→IPv4、AF_INET6→IPv6、AF_LINK→MAC）"""
    family_map = {
        socket.AF_INET: "IPv4",
        socket.AF_INET6: "IPv6",
        psutil.AF_LINK: "MAC"
    }
    return family_map.get(family, f"未知({family})")

def duplex_to_name(duplex: int) -> str:
    """双工模式转中文（0→未知、1→半双工、2→全双工）"""
    duplex_map = {0: "未知", 1: "半双工", 2: "全双工"}
    return duplex_map.get(duplex, "未知")

# ---------------------- 1. 全局网络 IO 统计 ----------------------
print("=== 1. 全局网络 IO 统计 ===")
net_io_global = psutil.net_io_counters()
net_io_global_human = {
    "接收总字节": bytes_to_human(net_io_global.bytes_recv),
    "发送总字节": bytes_to_human(net_io_global.bytes_sent),
    "接收数据包数": net_io_global.packets_recv,
    "发送数据包数": net_io_global.packets_sent,
    "接收错误包数": net_io_global.errin,
    "发送错误包数": net_io_global.errout,
    "接收丢弃包数": net_io_global.dropin,
    "发送丢弃包数": net_io_global.dropout
}
for key, value in net_io_global_human.items():
    print(f"  {key:12s}: {value}")

# ---------------------- 2. 网卡地址信息 ----------------------
print("\n\n=== 2. 网络接口地址信息 ===")
net_if_addrs = psutil.net_if_addrs()
for nic_name, addr_list in net_if_addrs.items():
    # 过滤回环网卡和虚拟网卡，仅显示物理网卡
    if "loopback" in nic_name.lower() or "虚拟" in nic_name:
        continue
    print(f"\n  网卡：{nic_name}")
    ipv4_info = []
    ipv6_info = []
    mac_info = []
    for addr in addr_list:
        family_name = family_to_name(addr.family)
        if family_name == "IPv4":
            ipv4_info.append({
                "IP地址": addr.address,
                "子网掩码": addr.netmask or "无",
                "广播地址": addr.broadcast or "无"
            })
        elif family_name == "IPv6":
            ipv6_info.append({
                "IP地址": addr.address,
                "子网掩码": addr.netmask or "无"
            })
        elif family_name == "MAC":
            mac_info.append(addr.address)
    
    if ipv4_info:
        print("    IPv4 地址：")
        for info in ipv4_info:
            print(f"      - IP：{info['IP地址']} | 子网掩码：{info['子网掩码']} | 广播：{info['广播地址']}")
    if ipv6_info:
        print("    IPv6 地址：")
        for info in ipv6_info:
            print(f"      - IP：{info['IP地址']} | 子网掩码：{info['子网掩码']}")
    if mac_info:
        print(f"    MAC 地址：{mac_info[0]}")

# ---------------------- 3. 网卡状态信息 ----------------------
print("\n\n=== 3. 网络接口状态信息 ===")
net_if_stats = psutil.net_if_stats()
for nic_name, stats_data in net_if_stats.items():
    if "loopback" in nic_name.lower() or "虚拟" in nic_name:
        continue
    print(f"\n  网卡：{nic_name}")
    print(f"    连接状态：{'已启用' if stats_data.isup else '已禁用'}")
    print(f"    双工模式：{duplex_to_name(stats_data.duplex)}")
    print(f"    网卡速率：{stats_data.speed} Mbps" if stats_data.speed > 0 else "    网卡速率：未知")
    print(f"    最大传输单元（MTU）：{stats_data.mtu} 字节")

import psutil
from datetime import datetime

# 获取启动时间戳（秒级）
boot_ts = psutil.boot_time()
# 格式化为人类可读时间
boot_time = datetime.fromtimestamp(boot_ts).strftime("%Y-%m-%d %H:%M:%S")
print("系统启动时间：", boot_time)