In [5]: def to_int(value):
...:     """Convert binary sysctl value to integer."""
...:     return int.from_bytes(value, byteorder='little')
...:

In [6]: def memory():
...:     """
...:     Report on the RAM usage on FreeBSD.
...:
...:     Returns: a formatted string to display.
...:     """
...:     suffixes = ('page_count', 'free_count', 'inactive_count', 'cache_count')
...:     stats = {
...:         suffix: sysctlbyname(f'vm.stats.vm.v_{suffix}', convert=to_int)
...:         for suffix in suffixes
...:     }
...:     memmax = stats['page_count']
...:     mem = (memmax - stats['free_count'] - stats['inactive_count'] - stats['cache_count'])
...:     free = int(100 * mem / memmax)
...:     return f'RAM: {free}%'
...:

In [7]: memory()
Out[7]: 'RAM: 18%'

In [8]: %timeit memory()
90.8 µs ± 182 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [21]: sysctlbyname('net.link.generic.system.ifcount', convert=to_int)
Out[21]: 3

> ifconfig -l
age0 rl0 lo0

def sysctl(name, buflen=4, convert=None):
    """
    Python wrapper for sysctl(3) on FreeBSD.

    Arguments:
        name: list or tuple of integers.
        buflen (int): Length of the data buffer to use.
        convert: Optional function to convert the data.

    Returns:
        The requested binary data, converted if desired.
    """
    cnt = len(name)
    mib = ctypes.c_int * cnt
    name_in = mib(*name)
    oldlen = ctypes.c_size_t(buflen)
    oldlenp = ctypes.byref(oldlen)
    oldp = ctypes.create_string_buffer(buflen)
    rv = libc.sysctl(
        ctypes.byref(name_in), ctypes.c_uint(cnt), oldp, oldlenp, None, ctypes.c_size_t(0)
    )
    if rv != 0:
        errno = ctypes.get_errno()
        raise ValueError(f'sysctl error: {errno}')
    if convert:
        return convert(oldp.raw[:buflen])
    return oldp.raw[:buflen]

struct ifmibdata {
        char    ifmd_name[IFNAMSIZ]; /* name of interface */
        int     ifmd_pcount;    /* number of promiscuous listeners */
        int     ifmd_flags;     /* interface flags */
        int     ifmd_snd_len;   /* instantaneous length of send queue */
        int     ifmd_snd_maxlen; /* maximum length of send queue */
        int     ifmd_snd_drops; /* number of drops in send queue */
        int     ifmd_filler[4]; /* for future expansion */
        struct  if_data ifmd_data; /* generic information and statistics */
};

struct if_data {
        /* generic interface information */
        uint8_t ifi_type;               /* ethernet, tokenring, etc */
        uint8_t ifi_physical;           /* e.g., AUI, Thinnet, 10base-T, etc */
        uint8_t ifi_addrlen;            /* media address length */
        uint8_t ifi_hdrlen;             /* media header length */
        uint8_t ifi_link_state;         /* current link state */
        uint8_t ifi_vhid;               /* carp vhid */
        uint16_t        ifi_datalen;    /* length of this data struct */
        uint32_t        ifi_mtu;        /* maximum transmission unit */
        uint32_t        ifi_metric;     /* routing metric (external only) */
        uint64_t        ifi_baudrate;   /* linespeed */
        /* volatile statistics */
        uint64_t        ifi_ipackets;   /* packets received on interface */
        uint64_t        ifi_ierrors;    /* input errors on interface */
        uint64_t        ifi_opackets;   /* packets sent on interface */
        uint64_t        ifi_oerrors;    /* output errors on interface */
        uint64_t        ifi_collisions; /* collisions on csma interfaces */
        uint64_t        ifi_ibytes;     /* total number of octets received */
        uint64_t        ifi_obytes;     /* total number of octets sent */
        uint64_t        ifi_imcasts;    /* packets received via multicast */
        uint64_t        ifi_omcasts;    /* packets sent via multicast */
        uint64_t        ifi_iqdrops;    /* dropped on input */
        uint64_t        ifi_oqdrops;    /* dropped on output */
        uint64_t        ifi_noproto;    /* destined for unsupported protocol */
        uint64_t        ifi_hwassist;   /* HW offload capabilities, see IFCAP */

        /* Unions are here to make sizes MI. */
        union {                         /* uptime at attach or stat reset */
                time_t          tt;
                uint64_t        ph;
        } __ifi_epoch;
#define ifi_epoch       __ifi_epoch.tt
        union {                         /* time of last administrative change */
                struct timeval  tv;
                struct {
                        uint64_t ph1;
                        uint64_t ph2;
                } ph;
        } __ifi_lastchange;
#define ifi_lastchange  __ifi_lastchange.tv
};

In [11]: def network(previous):
...:     """
...:     Report on bytes in/out for the network interfaces.
...:
...:     Arguments:
...:         previous: A dict of {interface: (inbytes, outbytes, time)} or None.
...:
...:     Returns:
...:         A new dict of {interface: (inbytes, outbytes, time)}, and a formatted
...:         string to display.
...:     """
...:     cnt = sysctlbyname('net.link.generic.system.ifcount', convert=to_int)
...:     newdata = {}
...:     items = []
...:     for n in range(1, cnt):
...:         tm = time.time()
...:         data = sysctl([4, 18, 0, 2, n, 1], buflen=208)
...:         name = data[:16].strip(b'\x00').decode('ascii')
...:         ibytes = to_int(data[120:128])
...:         obytes = to_int(data[128:136])
...:         if previous:
...:             dt = tm - previous[name][2]
...:             d_in = int((ibytes - previous[name][0])/dt)
...:             d_out = int((obytes - previous[name][1])/dt)
...:             items.append(f'{name}: {d_in}B/{d_out}B')
...:         else:
...:             items.append(f'{name}: 0B/0B')
...:         newdata[name] = (ibytes, obytes, tm)
...:     return newdata, '  '.join(items)
...:

In [12]: p, _ = network(None)

In [13]: %timeit network(p)
86.6 µs ± 202 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [14]: import statistics as stat

In [15]: import struct

In [16]: def to_degC(value):
    ...:     """Convert binary sysctl value to degree Centigrade."""
    ...:     return round(int.from_bytes(value, byteorder='little')/10 - 273.15, 1)
    ...:

In [17]: def cpu(previous):
    ...:     """
    ...:     Report the CPU usage and temperature.
    ...:
    ...:     Argument:
    ...:         previous: A 2-tuple (used, total) from the previous run.
    ...:
    ...:     Returns:
    ...:         A 2-tuple (used, total) and a string to display.
    ...:     """
    ...:     temps = [
    ...:         sysctlbyname(f'dev.cpu.{n}.temperature', convert=to_degC)
    ...:         for n in range(4)
    ...:     ]
    ...:     T = round(stat.mean(temps))
    ...:     resbuf = sysctlbyname('kern.cp_time', buflen=40)
    ...:     states = struct.unpack('5L', resbuf)
    ...:     # According to /usr/include/sys/resource.h, these are:
    ...:     # USER, NICE, SYS, INT, IDLE
    ...:     total = sum(states)
    ...:     used = total - states[-1]
    ...:     if previous:
    ...:         prevused, prevtotal = previous
    ...:         frac = int((used - prevused) / (total - prevtotal) * 100)
    ...:     else:
    ...:         frac = 0
    ...:     return (used, total), f'CPU: {frac}%, {T}°C'
    ...:

In [18]: p, _ = cpu(None)

In [19]: p, cpustr = cpu(p)

In [20]: p
Out[20]: (5810156, 193222344)

In [21]: cpustr
Out[21]: 'CPU: 0%, 53°C'

In [22]: %timeit cpu(p)
248 µs ± 658 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)