并行循环的完全CPU使用率可以通过使用多线程或多进程来实现。这样可以同时运行多个循环，以充分利用CPU资源。

以下是一个使用多线程来实现并行循环的代码示例：

import threading

def parallel_loop(start, end, func):
    # 计算每个线程需要处理的迭代范围
    num_threads = threading.cpu_count()
    chunk_size = (end - start + 1) // num_threads

    # 创建并启动多个线程
    threads = []
    for i in range(num_threads):
        thread_start = start + i * chunk_size
        thread_end = thread_start + chunk_size - 1

        t = threading.Thread(target=func, args=(thread_start, thread_end))
        t.start()
        threads.append(t)

    # 等待所有线程完成
    for t in threads:
        t.join()

# 待处理的任务
def process_data(start, end):
    for i in range(start, end + 1):
        # 在这里执行需要并行处理的操作
        print(i)

# 示例调用
parallel_loop(1, 10, process_data)

该示例代码将一个任务分为多个线程处理，每个线程处理一部分循环迭代。使用threading.cpu_count()函数获取CPU核心数，以确定需要创建多少个线程。然后根据迭代范围和线程数量，计算每个线程需要处理的迭代范围。最后，创建并启动多个线程，并通过join()方法等待所有线程完成。

类似的，你也可以使用多进程来实现并行循环。下面是一个使用multiprocessing模块的示例代码：

import multiprocessing

def parallel_loop(start, end, func):
    # 获取CPU核心数
    num_processes = multiprocessing.cpu_count()

    # 创建进程池
    pool = multiprocessing.Pool(processes=num_processes)

    # 将任务分割为多个子任务，分配给进程池中的进程处理
    chunk_size = (end - start + 1) // num_processes
    results = []
    for i in range(num_processes):
        process_start = start + i * chunk_size
        process_end = process_start + chunk_size - 1

        result = pool.apply_async(func, (process_start, process_end))
        results.append(result)

    # 等待所有子任务完成，并获取结果
    for result in results:
        result.get()

    # 关闭进程池
    pool.close()
    pool.join()

# 待处理的任务
def process_data(start, end):
    for i in range(start, end + 1):
        # 在这里执行需要并行处理的操作
        print(i)

# 示例调用
parallel_loop(1, 10, process_data)

该示例代码使用multiprocessing.Pool创建一个进程池，然后将任务分割为多个子任务，分配给进程池中的进程处理。使用apply_async方法提交任务，并使用get方法等待所有子任务完成并获取结果。最后，通过close和join方法关闭进程池。

无论是使用多线程还是多进程，这些示例代码都可以帮助你实现并行循环，并充分利用CPU资源。根据具体的需求和环境，选择合适的方法即可。