如何找出CPU的使用python的数量如何找出CPU的使用python的数量(How to find

我想知道使用Python在本地计算机上的CPU数量。 结果应该是user/real作为输出通过time(1)当与最佳仅缩放用户空间程序调用。

Answer 1:

如果你有蟒蛇用版本> = 2.6，你可以简单地使用

import multiprocessing

multiprocessing.cpu_count()

http://docs.python.org/library/multiprocessing.html#multiprocessing.cpu_count

Answer 2:

如果你有兴趣到提供给您的当前进程的处理器的数量，你必须检查cpuset第一。 否则（或者如果cpuset未使用）， multiprocessing.cpu_count()是在Python 2.6和更高版本的路要走。 下面的方法回落到一对夫妇在旧版本的Python的替代方法：

import os
import re
import subprocess


def available_cpu_count():
    """ Number of available virtual or physical CPUs on this system, i.e.
    user/real as output by time(1) when called with an optimally scaling
    userspace-only program"""

    # cpuset
    # cpuset may restrict the number of *available* processors
    try:
        m = re.search(r'(?m)^Cpus_allowed:\s*(.*)$',
                      open('/proc/self/status').read())
        if m:
            res = bin(int(m.group(1).replace(',', ''), 16)).count('1')
            if res > 0:
                return res
    except IOError:
        pass

    # Python 2.6+
    try:
        import multiprocessing
        return multiprocessing.cpu_count()
    except (ImportError, NotImplementedError):
        pass

    # https://github.com/giampaolo/psutil
    try:
        import psutil
        return psutil.cpu_count()   # psutil.NUM_CPUS on old versions
    except (ImportError, AttributeError):
        pass

    # POSIX
    try:
        res = int(os.sysconf('SC_NPROCESSORS_ONLN'))

        if res > 0:
            return res
    except (AttributeError, ValueError):
        pass

    # Windows
    try:
        res = int(os.environ['NUMBER_OF_PROCESSORS'])

        if res > 0:
            return res
    except (KeyError, ValueError):
        pass

    # jython
    try:
        from java.lang import Runtime
        runtime = Runtime.getRuntime()
        res = runtime.availableProcessors()
        if res > 0:
            return res
    except ImportError:
        pass

    # BSD
    try:
        sysctl = subprocess.Popen(['sysctl', '-n', 'hw.ncpu'],
                                  stdout=subprocess.PIPE)
        scStdout = sysctl.communicate()[0]
        res = int(scStdout)

        if res > 0:
            return res
    except (OSError, ValueError):
        pass

    # Linux
    try:
        res = open('/proc/cpuinfo').read().count('processor\t:')

        if res > 0:
            return res
    except IOError:
        pass

    # Solaris
    try:
        pseudoDevices = os.listdir('/devices/pseudo/')
        res = 0
        for pd in pseudoDevices:
            if re.match(r'^cpuid@[0-9]+$', pd):
                res += 1

        if res > 0:
            return res
    except OSError:
        pass

    # Other UNIXes (heuristic)
    try:
        try:
            dmesg = open('/var/run/dmesg.boot').read()
        except IOError:
            dmesgProcess = subprocess.Popen(['dmesg'], stdout=subprocess.PIPE)
            dmesg = dmesgProcess.communicate()[0]

        res = 0
        while '\ncpu' + str(res) + ':' in dmesg:
            res += 1

        if res > 0:
            return res
    except OSError:
        pass

    raise Exception('Can not determine number of CPUs on this system')

Answer 3:

另一种选择是使用psutil库，它总是变成有用的这些情况：

>>> import psutil
>>> psutil.cpu_count()
2

这应该支持的任何平台上工作psutil （Unix和Windows）。

请注意，在某些场合multiprocessing.cpu_count可能引发NotImplementedError而psutil就能获得CPU的数量。 这完全是因为psutil首先尝试使用所使用的相同的技术multiprocessing ，如果这些失败，它也采用其他技术。

Answer 4:

在Python 3.4+： os.cpu_count（） 。

multiprocessing.cpu_count()在此功能上实现，但引发NotImplementedError如果os.cpu_count()返回None （“不能确定CPU数”）。

Answer 5:

import os

print(os.cpu_count())

Answer 6:

平台独立：

psutil.cpu_count（逻辑=假）

https://github.com/giampaolo/psutil/blob/master/INSTALL.rst

Answer 7:

multiprocessing.cpu_count()将返回逻辑CPU的数目，因此，如果您有超线程四核CPU，它将返回8 。 如果你想物理CPU的数量，使用Python绑定hwloc：

#!/usr/bin/env python
import hwloc
topology = hwloc.Topology()
topology.load()
print topology.get_nbobjs_by_type(hwloc.OBJ_CORE)

hwloc的设计是跨操作系统和架构便于携带。

Answer 8:

无法弄清楚如何添加到代码或回复邮件，但这里的Jython的支持，你放弃之前，你可以在钉：

# jython
try:
    from java.lang import Runtime
    runtime = Runtime.getRuntime()
    res = runtime.availableProcessors()
    if res > 0:
        return res
except ImportError:
    pass

Answer 9:

您还可以使用“JOBLIB”为了这个目的。

import joblib
print joblib.cpu_count()

这种方法会给你在系统中CPU的数量。 JOBLIB需要被安装，虽然。 在JOBLIB更多信息可以在这里找到https://pythonhosted.org/joblib/parallel.html

或者您可以使用numexpr蟒蛇包。 它有大量的用于获取有关系统的CPU信息有用简单的功能。

import numexpr as ne
print ne.detect_number_of_cores()

Answer 10:

len(os.sched_getaffinity(0))是你平时想什么

https://docs.python.org/3/library/os.html#os.sched_getaffinity

os.sched_getaffinity(0)在Python 3中添加）返回考虑该组可用的CPU sched_setaffinity Linux系统调用 ，这限制了CPU的处理和它的子都可以运行。

0意味着获取当前CPU的值。 该函数返回一个set()允许CPU的，因此需要有len()

multiprocessing.cpu_count()另一方面仅返回物理CPU的总数。

我们可以通过限制与亲和力看出区别taskset效用。

例如，如果我在16核心系统限制Python来仅1核心（核心0）：

taskset -c 0 ./main.py

与测试脚本：

main.py

#!/usr/bin/env python3

import multiprocessing
import os

print(multiprocessing.cpu_count())
print(len(os.sched_getaffinity(0)))

然后输出为：

16
1

这一点尤其重要，因为某些集群管理系统，如平台LSF与限制工作的CPU使用率sched_getaffinity 。

因此，如果你使用multiprocessing.cpu_count()您的脚本可能会尝试使用的方式更多的内核，比它用，这可能会导致个别任务超时。

nproc默认尊重亲和力：

taskset -c 0 nproc

输出：

1

和man nproc使得相当多明确的：

打印的可用的处理单元的数量

nproc有--all为您想获得物理CPU数不常见的情况的标志：

taskset -c 0 nproc --all

经测试在Ubuntu 16.04，Python的3.5.2。

Answer 11:

另一种选择，如果你没有的Python 2.6：

import commands
n = commands.getoutput("grep -c processor /proc/cpuinfo")

Answer 12:

这是由多重功能CPU_COUNT

：}

import os
import sys

def cpu_count():
    '''
    Returns the number of CPUs in the system
    '''
    if sys.platform == 'win32':
        try:
            num = int(os.environ['NUMBER_OF_PROCESSORS'])
        except (ValueError, KeyError):
            num = 0
    elif 'bsd' in sys.platform or sys.platform == 'darwin':
        comm = '/sbin/sysctl -n hw.ncpu'
        if sys.platform == 'darwin':
            comm = '/usr' + comm
        try:
            with os.popen(comm) as p:
                num = int(p.read())
        except ValueError:
            num = 0
    else:
        try:
            num = os.sysconf('SC_NPROCESSORS_ONLN')
        except (ValueError, OSError, AttributeError):
           num = 0

    if num >= 1:
        return num
    else:
        raise NotImplementedError('cannot determine number of cpus')

Answer 13:

因为我不能评论尚未：

这些给你的“物理” CPU计数

1. multiprocessing.cpu_count（）
2. os.cpu_count（）

这些给你的虚拟机CPU计数

1. psutil.cpu_count（）
2. numexpr.detect_number_of_cores（）

只有当你的作品在VM上重要的。

文章来源: How to find out the number of CPUs using python