Warning
This documentation refers to new 2.X version of psutil. Instructions on how to port existing 1.2.1 code are here. Old 1.2.1 documentation is still available here.
psutil documentation¶
Quick links¶
About¶
From project’s home page:
psutil (python system and process utilities) is a cross-platform library for retrieving information on running processes and system utilization (CPU, memory, disks, network) in Python. It is useful mainly for system monitoring, profiling and limiting process resources and management of running processes. It implements many functionalities offered by command line tools such as: ps, top, lsof, netstat, ifconfig, who, df, kill, free, nice, ionice, iostat, iotop, uptime, pidof, tty, taskset, pmap. It currently supports Linux, Windows, OSX, FreeBSD and Sun Solaris, both 32-bit and 64-bit architectures, with Python versions from 2.6 to 3.4 (users of Python 2.4 and 2.5 may use 2.1.3 version). PyPy is also known to work.
The psutil documentation you’re reading is distributed as a single HTML page.
Processes¶
Functions¶
-
psutil.
pids
()¶ Return a list of current running PIDs. To iterate over all processes
process_iter()
should be preferred.
-
psutil.
pid_exists
(pid)¶ Check whether the given PID exists in the current process list. This is faster than doing
"pid in psutil.pids()"
and should be preferred.
-
psutil.
process_iter
()¶ Return an iterator yielding a
Process
class instance for all running processes on the local machine. Every instance is only created once and then cached into an internal table which is updated every time an element is yielded. CachedProcess
instances are checked for identity so that you’re safe in case a PID has been reused by another process, in which case the cached instance is updated. This is should be preferred overpsutil.pids()
for iterating over processes. Sorting order in which processes are returned is based on their PID. Example usage:import psutil for proc in psutil.process_iter(): try: pinfo = proc.as_dict(attrs=['pid', 'name']) except psutil.NoSuchProcess: pass else: print(pinfo)
-
psutil.
wait_procs
(procs, timeout=None, callback=None)¶ Convenience function which waits for a list of
Process
instances to terminate. Return a(gone, alive)
tuple indicating which processes are gone and which ones are still alive. The gone ones will have a new returncode attribute indicating process exit status (it may beNone
).callback
is a function which gets called every time a process terminates (aProcess
instance is passed as callback argument). Function will return as soon as all processes terminate or when timeout occurs. Tipical use case is:- send SIGTERM to a list of processes
- give them some time to terminate
- send SIGKILL to those ones which are still alive
Example:
import psutil def on_terminate(proc): print("process {} terminated with exit code {}".format(proc, proc.returncode)) procs = [...] # a list of Process instances for p in procs: p.terminate() gone, alive = wait_procs(procs, timeout=3, callback=on_terminate) for p in alive: p.kill()
Exceptions¶
-
class
psutil.
Error
¶ Base exception class. All other exceptions inherit from this one.
-
class
psutil.
NoSuchProcess
(pid, name=None, msg=None)¶ Raised by
Process
class methods when no process with the given pid is found in the current process list or when a process no longer exists. “name” is the name the process had before disappearing and gets set only ifProcess.name()
was previosly called.
-
class
psutil.
ZombieProcess
(pid, name=None, ppid=None, msg=None)¶ This may be raised by
Process
class methods when querying a zombie process on UNIX (Windows doesn’t have zombie processes). Depending on the method called the OS may be able to succeed in retrieving the process information or not. Note: this is a subclass ofNoSuchProcess
so if you’re not interested in retrieving zombies (e.g. when usingprocess_iter()
) you can ignore this exception and just catchNoSuchProcess
.New in 3.0.0
-
class
psutil.
AccessDenied
(pid=None, name=None, msg=None)¶ Raised by
Process
class methods when permission to perform an action is denied. “name” is the name of the process (may beNone
).
-
class
psutil.
TimeoutExpired
(seconds, pid=None, name=None, msg=None)¶ Raised by
Process.wait()
if timeout expires and process is still alive.
Process class¶
-
class
psutil.
Process
(pid=None)¶ Represents an OS process with the given pid. If pid is omitted current process pid (os.getpid()) is used. Raise
NoSuchProcess
if pid does not exist. When accessing methods of this class always be prepared to catchNoSuchProcess
andAccessDenied
exceptions. hash() builtin can be used against instances of this class in order to identify a process univocally over time (the hash is determined by mixing process PID and creation time). As such it can also be used with set()s.Warning
the way this class is bound to a process is uniquely via its PID. That means that if the
Process
instance is old enough and the PID has been reused by another process in the meantime you might end up interacting with another process. The only exceptions for which process identity is pre-emptively checked (via PID + creation time) and guaranteed are fornice()
(set),ionice()
(set),cpu_affinity()
(set),rlimit()
(set),children()
,parent()
,suspend()
resume()
,send_signal()
,terminate()
, andkill()
methods. To prevent this problem for all other methods you can useis_running()
before querying the process or useprocess_iter()
in case you’re iterating over all processes.-
pid
¶ The process PID.
-
ppid
()¶ The process parent pid. On Windows the return value is cached after first call.
-
name
()¶ The process name. The return value is cached after first call.
-
exe
()¶ The process executable as an absolute path. On some systems this may also be an empty string. The return value is cached after first call.
-
cmdline
()¶ The command line this process has been called with.
-
create_time
()¶ The process creation time as a floating point number expressed in seconds since the epoch, in UTC. The return value is cached after first call.
>>> import psutil, datetime >>> p = psutil.Process() >>> p.create_time() 1307289803.47 >>> datetime.datetime.fromtimestamp(p.create_time()).strftime("%Y-%m-%d %H:%M:%S") '2011-03-05 18:03:52'
-
as_dict
(attrs=None, ad_value=None)¶ Utility method returning process information as a hashable dictionary. If attrs is specified it must be a list of strings reflecting available
Process
class’s attribute names (e.g.['cpu_times', 'name']
) else all public (read only) attributes are assumed. ad_value is the value which gets assigned to a dict key in caseAccessDenied
orZombieProcess
exception is raised when retrieving that particular process information.>>> import psutil >>> p = psutil.Process() >>> p.as_dict(attrs=['pid', 'name', 'username']) {'username': 'giampaolo', 'pid': 12366, 'name': 'python'}
Changed in version 3.0.0: ad_value is used also when incurring into
ZombieProcess
exception, not onlyAccessDenied
-
parent
()¶ Utility method which returns the parent process as a
Process
object pre-emptively checking whether PID has been reused. If no parent PID is known returnNone
.
-
status
()¶ The current process status as a string. The returned string is one of the
psutil.STATUS_*
constants.
-
cwd
()¶ The process current working directory as an absolute path.
-
username
()¶ The name of the user that owns the process. On UNIX this is calculated by using real process uid.
-
uids
()¶ The real, effective and saved user ids of this process as a namedtuple. This is the same as os.getresuid() but can be used for every process PID.
Availability: UNIX
-
gids
()¶ The real, effective and saved group ids of this process as a namedtuple. This is the same as os.getresgid() but can be used for every process PID.
Availability: UNIX
-
terminal
()¶ The terminal associated with this process, if any, else
None
. This is similar to “tty” command but can be used for every process PID.Availability: UNIX
-
nice
(value=None)¶ Get or set process niceness (priority). On UNIX this is a number which usually goes from
-20
to20
. The higher the nice value, the lower the priority of the process.>>> import psutil >>> p = psutil.Process() >>> p.nice(10) # set >>> p.nice() # get 10 >>>
Starting from Python 3.3 this functionality is also available as os.getpriority() and os.setpriority() (UNIX only).
On Windows this is available as well by using GetPriorityClass and SetPriorityClass and value is one of the
psutil.*_PRIORITY_CLASS
constants. Example which increases process priority on Windows:>>> p.nice(psutil.HIGH_PRIORITY_CLASS)
-
ionice
(ioclass=None, value=None)¶ Get or set process I/O niceness (priority). On Linux ioclass is one of the
psutil.IOPRIO_CLASS_*
constants. value is a number which goes from0
to7
. The higher the value, the lower the I/O priority of the process. On Windows only ioclass is used and it can be set to2
(normal),1
(low) or0
(very low). The example below sets IDLE priority class for the current process, meaning it will only get I/O time when no other process needs the disk:>>> import psutil >>> p = psutil.Process() >>> p.ionice(psutil.IOPRIO_CLASS_IDLE) # set >>> p.ionice() # get pionice(ioclass=<IOPriority.IOPRIO_CLASS_IDLE: 3>, value=0) >>>
On Windows only ioclass is used and it can be set to
2
(normal),1
(low) or0
(very low).Availability: Linux and Windows > Vista
Changed in version 3.0.0: on >= Python 3.4 the returned
ioclass
constant is an enum instead of a plain integer.
-
rlimit
(resource, limits=None)¶ Get or set process resource limits (see man prlimit). resource is one of the
psutil.RLIMIT_*
constants. limits is a(soft, hard)
tuple. This is the same as resource.getrlimit() and resource.setrlimit() but can be used for every process PID and only on Linux. Example:>>> import psutil >>> p = psutil.Process() >>> # process may open no more than 128 file descriptors >>> p.rlimit(psutil.RLIMIT_NOFILE, (128, 128)) >>> # process may create files no bigger than 1024 bytes >>> p.rlimit(psutil.RLIMIT_FSIZE, (1024, 1024)) >>> # get >>> p.rlimit(psutil.RLIMIT_FSIZE) (1024, 1024) >>>
Availability: Linux
-
io_counters
()¶ Return process I/O statistics as a namedtuple including the number of read and write operations performed by the process and the amount of bytes read and written. For Linux refer to /proc filesysem documentation. On BSD there’s apparently no way to retrieve bytes counters, hence
-1
is returned for read_bytes and write_bytes fields. OSX is not supported.>>> import psutil >>> p = psutil.Process() >>> p.io_counters() pio(read_count=454556, write_count=3456, read_bytes=110592, write_bytes=0)
Availability: all platforms except OSX and Solaris
-
num_ctx_switches
()¶ The number voluntary and involuntary context switches performed by this process.
-
num_fds
()¶ The number of file descriptors used by this process.
Availability: UNIX
-
num_handles
()¶ The number of handles used by this process.
Availability: Windows
-
num_threads
()¶ The number of threads currently used by this process.
-
threads
()¶ Return threads opened by process as a list of namedtuples including thread id and thread CPU times (user/system).
-
cpu_times
()¶ Return a tuple whose values are process CPU user and system times which means the amount of time expressed in seconds that a process has spent in user / system mode. This is similar to os.times() but can be used for every process PID.
-
cpu_percent
(interval=None)¶ Return a float representing the process CPU utilization as a percentage. When interval is >
0.0
compares process times to system CPU times elapsed before and after the interval (blocking). When interval is0.0
orNone
compares process times to system CPU times elapsed since last call, returning immediately. That means the first time this is called it will return a meaningless0.0
value which you are supposed to ignore. In this case is recommended for accuracy that this function be called a second time with at least0.1
seconds between calls. Example:>>> import psutil >>> p = psutil.Process() >>> >>> # blocking >>> p.cpu_percent(interval=1) 2.0 >>> # non-blocking (percentage since last call) >>> p.cpu_percent(interval=None) 2.9 >>>
Note
a percentage > 100 is legitimate as it can result from a process with multiple threads running on different CPU cores.
Warning
the first time this method is called with interval =
0.0
orNone
it will return a meaningless0.0
value which you are supposed to ignore.
-
cpu_affinity
(cpus=None)¶ Get or set process current CPU affinity. CPU affinity consists in telling the OS to run a certain process on a limited set of CPUs only. The number of eligible CPUs can be obtained with
list(range(psutil.cpu_count()))
. On set raisesValueError
in case an invalid CPU number is specified.>>> import psutil >>> psutil.cpu_count() 4 >>> p = psutil.Process() >>> p.cpu_affinity() # get [0, 1, 2, 3] >>> p.cpu_affinity([0]) # set; from now on, process will run on CPU #0 only >>> p.cpu_affinity() [0] >>> >>> # reset affinity against all CPUs >>> all_cpus = list(range(psutil.cpu_count())) >>> p.cpu_affinity(all_cpus) >>>
Availability: Linux, Windows, BSD
Changed in version 2.2.0: added support for FreeBSD
-
memory_info
()¶ Return a tuple representing RSS (Resident Set Size) and VMS (Virtual Memory Size) in bytes. On UNIX rss and vms are the same values shown by ps. On Windows rss and vms refer to “Mem Usage” and “VM Size” columns of taskmgr.exe. For more detailed memory stats use
memory_info_ex()
.
-
memory_info_ex
()¶ Return a namedtuple with variable fields depending on the platform representing extended memory information about the process. All numbers are expressed in bytes.
Linux OSX BSD SunOS Windows rss rss rss rss num_page_faults vms vms vms vms peak_wset shared pfaults text wset text pageins data peak_paged_pool lib stack paged_pool data peak_nonpaged_pool dirty nonpaged_pool pagefile peak_pagefile private Windows metrics are extracted from PROCESS_MEMORY_COUNTERS_EX structure. Example on Linux:
>>> import psutil >>> p = psutil.Process() >>> p.memory_info_ex() pextmem(rss=15491072, vms=84025344, shared=5206016, text=2555904, lib=0, data=9891840, dirty=0)
-
memory_percent
()¶ Compare physical system memory to process resident memory (RSS) and calculate process memory utilization as a percentage.
-
memory_maps
(grouped=True)¶ Return process’s mapped memory regions as a list of namedtuples whose fields are variable depending on the platform. As such, portable applications should rely on namedtuple’s path and rss fields only. This method is useful to obtain a detailed representation of process memory usage as explained here. If grouped is
True
the mapped regions with the same path are grouped together and the different memory fields are summed. If grouped isFalse
every mapped region is shown as a single entity and the namedtuple will also include the mapped region’s address space (addr) and permission set (perms). See examples/pmap.py for an example application.>>> import psutil >>> p = psutil.Process() >>> p.memory_maps() [pmmap_grouped(path='/lib/x8664-linux-gnu/libutil-2.15.so', rss=16384, anonymous=8192, swap=0), pmmap_grouped(path='/lib/x8664-linux-gnu/libc-2.15.so', rss=6384, anonymous=15, swap=0), pmmap_grouped(path='/lib/x8664-linux-gnu/libcrypto.so.0.1', rss=34124, anonymous=1245, swap=0), pmmap_grouped(path='[heap]', rss=54653, anonymous=8192, swap=0), pmmap_grouped(path='[stack]', rss=1542, anonymous=166, swap=0), ...] >>>
-
children
(recursive=False)¶ Return the children of this process as a list of
Process
objects, pre-emptively checking whether PID has been reused. If recursive is True return all the parent descendants. Example assuming A == this process:A ─┐ │ ├─ B (child) ─┐ │ └─ X (grandchild) ─┐ │ └─ Y (great grandchild) ├─ C (child) └─ D (child) >>> p.children() B, C, D >>> p.children(recursive=True) B, X, Y, C, D
Note that in the example above if process X disappears process Y won’t be returned either as the reference to process A is lost.
-
open_files
()¶ Return regular files opened by process as a list of namedtuples including the absolute file name and the file descriptor number (on Windows this is always
-1
). Example:>>> import psutil >>> f = open('file.ext', 'w') >>> p = psutil.Process() >>> p.open_files() [popenfile(path='/home/giampaolo/svn/psutil/file.ext', fd=3)]
Warning
on Windows this is not fully reliable as due to some limitations of the Windows API the underlying implementation may hang when retrieving certain file handles. In order to work around that psutil on Windows Vista (and higher) spawns a thread and kills it if it’s not responding after 100ms. That implies that on Windows this method is not guaranteed to enumerate all regular file handles (see full discusion here).
Warning
on FreeBSD this method can return files with a ‘null’ path (see issue 595).
Changed in version 3.1.0: no longer hangs on Windows.
-
connections
(kind="inet")¶ Return socket connections opened by process as a list of namedtuples. To get system-wide connections use
psutil.net_connections()
. Every namedtuple provides 6 attributes:- fd: the socket file descriptor. This can be passed to
socket.fromfd()
to obtain a usable socket object.
This is only available on UNIX; on Windows
-1
is always returned. - family: the address family, either AF_INET, AF_INET6 or AF_UNIX.
- type: the address type, either SOCK_STREAM or SOCK_DGRAM.
- laddr: the local address as a
(ip, port)
tuple or apath
in case of AF_UNIX sockets. - raddr: the remote address as a
(ip, port)
tuple or an absolutepath
in case of UNIX sockets. When the remote endpoint is not connected you’ll get an empty tuple (AF_INET) orNone
(AF_UNIX). On Linux AF_UNIX sockets will always have this set toNone
. - status: represents the status of a TCP connection. The return value
is one of the
psutil.CONN_*
constants. For UDP and UNIX sockets this is always going to bepsutil.CONN_NONE
.
The kind parameter is a string which filters for connections that fit the following criteria:
Kind value Connections using “inet” IPv4 and IPv6 “inet4” IPv4 “inet6” IPv6 “tcp” TCP “tcp4” TCP over IPv4 “tcp6” TCP over IPv6 “udp” UDP “udp4” UDP over IPv4 “udp6” UDP over IPv6 “unix” UNIX socket (both UDP and TCP protocols) “all” the sum of all the possible families and protocols Example:
>>> import psutil >>> p = psutil.Process(1694) >>> p.name() 'firefox' >>> p.connections() [pconn(fd=115, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 48776), raddr=('93.186.135.91', 80), status='ESTABLISHED'), pconn(fd=117, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 43761), raddr=('72.14.234.100', 80), status='CLOSING'), pconn(fd=119, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 60759), raddr=('72.14.234.104', 80), status='ESTABLISHED'), pconn(fd=123, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 51314), raddr=('72.14.234.83', 443), status='SYN_SENT')]
- fd: the socket file descriptor. This can be passed to
socket.fromfd()
to obtain a usable socket object.
This is only available on UNIX; on Windows
-
is_running
()¶ Return whether the current process is running in the current process list. This is reliable also in case the process is gone and its PID reused by another process, therefore it must be preferred over doing
psutil.pid_exists(p.pid)
.Note
this will return
True
also if the process is a zombie (p.status() == psutil.STATUS_ZOMBIE
).
-
send_signal
(signal)¶ Send a signal to process (see signal module constants) pre-emptively checking whether PID has been reused. On UNIX this is the same as
os.kill(pid, sig)
. On Windows only SIGTERM, CTRL_C_EVENT and CTRL_BREAK_EVENT signals are supported and SIGTERM is treated as an alias forkill()
.Changed in 3.2.0: support for CTRL_C_EVENT and CTRL_BREAK_EVENT signals was added.
-
suspend
()¶ Suspend process execution with SIGSTOP signal pre-emptively checking whether PID has been reused. On UNIX this is the same as
os.kill(pid, signal.SIGSTOP)
. On Windows this is done by suspending all process threads execution.
-
resume
()¶ Resume process execution with SIGCONT signal pre-emptively checking whether PID has been reused. On UNIX this is the same as
os.kill(pid, signal.SIGCONT)
. On Windows this is done by resuming all process threads execution.
-
terminate
()¶ Terminate the process with SIGTERM signal pre-emptively checking whether PID has been reused. On UNIX this is the same as
os.kill(pid, signal.SIGTERM)
. On Windows this is an alias forkill()
.
-
kill
()¶ Kill the current process by using SIGKILL signal pre-emptively checking whether PID has been reused. On UNIX this is the same as
os.kill(pid, signal.SIGKILL)
. On Windows this is done by using TerminateProcess.
-
wait
(timeout=None)¶ Wait for process termination and if the process is a children of the current one also return the exit code, else
None
. On Windows there’s no such limitation (exit code is always returned). If the process is already terminated immediately returnNone
instead of raisingNoSuchProcess
. If timeout is specified and process is still alive raiseTimeoutExpired
exception. It can also be used in a non-blocking fashion by specifyingtimeout=0
in which case it will either return immediately or raiseTimeoutExpired
. To wait for multiple processes usepsutil.wait_procs()
.
-
Popen class¶
-
class
psutil.
Popen
(*args, **kwargs)¶ A more convenient interface to stdlib subprocess.Popen. It starts a sub process and deals with it exactly as when using subprocess.Popen but in addition it also provides all the methods of
psutil.Process
class in a single interface. For method names common to both classes such assend_signal()
,terminate()
andkill()
psutil.Process
implementation takes precedence. For a complete documentation refer to subprocess module documentation.Note
Unlike subprocess.Popen this class pre-emptively checks wheter PID has been reused on
send_signal()
,terminate()
andkill()
so that you can’t accidentally terminate another process, fixing http://bugs.python.org/issue6973.>>> import psutil >>> from subprocess import PIPE >>> >>> p = psutil.Popen(["/usr/bin/python", "-c", "print('hello')"], stdout=PIPE) >>> p.name() 'python' >>> p.username() 'giampaolo' >>> p.communicate() ('hello\n', None) >>> p.wait(timeout=2) 0 >>>
Constants¶
-
psutil.
STATUS_RUNNING
¶ -
psutil.
STATUS_SLEEPING
¶ -
psutil.
STATUS_DISK_SLEEP
¶ -
psutil.
STATUS_STOPPED
¶ -
psutil.
STATUS_TRACING_STOP
¶ -
psutil.
STATUS_ZOMBIE
¶ -
psutil.
STATUS_DEAD
¶ -
psutil.
STATUS_WAKE_KILL
¶ -
psutil.
STATUS_WAKING
¶ -
psutil.
STATUS_IDLE
¶ -
psutil.
STATUS_LOCKED
¶ -
psutil.
STATUS_WAITING
¶ A set of strings representing the status of a process. Returned by
psutil.Process.status()
.
-
psutil.
CONN_ESTABLISHED
¶ -
psutil.
CONN_SYN_SENT
¶ -
psutil.
CONN_SYN_RECV
¶ -
psutil.
CONN_FIN_WAIT1
¶ -
psutil.
CONN_FIN_WAIT2
¶ -
psutil.
CONN_TIME_WAIT
¶ -
psutil.
CONN_CLOSE
¶ -
psutil.
CONN_CLOSE_WAIT
¶ -
psutil.
CONN_LAST_ACK
¶ -
psutil.
CONN_LISTEN
¶ -
psutil.
CONN_CLOSING
¶ -
psutil.
CONN_NONE
¶ -
psutil.
CONN_DELETE_TCB
(Windows)¶ -
psutil.
CONN_IDLE
(Solaris)¶ -
psutil.
CONN_BOUND
(Solaris)¶ A set of strings representing the status of a TCP connection. Returned by
psutil.Process.connections()
(status field).
-
psutil.
ABOVE_NORMAL_PRIORITY_CLASS
¶ -
psutil.
BELOW_NORMAL_PRIORITY_CLASS
¶ -
psutil.
HIGH_PRIORITY_CLASS
¶ -
psutil.
IDLE_PRIORITY_CLASS
¶ -
psutil.
NORMAL_PRIORITY_CLASS
¶ -
psutil.
REALTIME_PRIORITY_CLASS
¶ A set of integers representing the priority of a process on Windows (see MSDN documentation). They can be used in conjunction with
psutil.Process.nice()
to get or set process priority.Availability: Windows
Changed in version 3.0.0: on Python >= 3.4 these constants are enums instead of a plain integer.
-
psutil.
IOPRIO_CLASS_NONE
¶ -
psutil.
IOPRIO_CLASS_RT
¶ -
psutil.
IOPRIO_CLASS_BE
¶ -
psutil.
IOPRIO_CLASS_IDLE
¶ A set of integers representing the I/O priority of a process on Linux. They can be used in conjunction with
psutil.Process.ionice()
to get or set process I/O priority. IOPRIO_CLASS_NONE and IOPRIO_CLASS_BE (best effort) is the default for any process that hasn’t set a specific I/O priority. IOPRIO_CLASS_RT (real time) means the process is given first access to the disk, regardless of what else is going on in the system. IOPRIO_CLASS_IDLE means the process will get I/O time when no-one else needs the disk. For further information refer to manuals of ionice command line utility or ioprio_get system call.Availability: Linux
Changed in version 3.0.0: on Python >= 3.4 thse constants are enums instead of a plain integer.
-
psutil.
RLIMIT_INFINITY
¶ -
psutil.
RLIMIT_AS
¶ -
psutil.
RLIMIT_CORE
¶ -
psutil.
RLIMIT_CPU
¶ -
psutil.
RLIMIT_DATA
¶ -
psutil.
RLIMIT_FSIZE
¶ -
psutil.
RLIMIT_LOCKS
¶ -
psutil.
RLIMIT_MEMLOCK
¶ -
psutil.
RLIMIT_MSGQUEUE
¶ -
psutil.
RLIMIT_NICE
¶ -
psutil.
RLIMIT_NOFILE
¶ -
psutil.
RLIMIT_NPROC
¶ -
psutil.
RLIMIT_RSS
¶ -
psutil.
RLIMIT_RTPRIO
¶ -
psutil.
RLIMIT_RTTIME
¶ -
psutil.
RLIMIT_RTPRIO
-
psutil.
RLIMIT_SIGPENDING
¶ -
psutil.
RLIMIT_STACK
¶ Constants used for getting and setting process resource limits to be used in conjunction with
psutil.Process.rlimit()
. See man prlimit for futher information.Availability: Linux
-
psutil.
AF_LINK
¶ Constant which identifies a MAC address associated with a network interface. To be used in conjunction with
psutil.net_if_addrs()
.New in 3.0.0
-
psutil.
NIC_DUPLEX_FULL
¶ -
psutil.
NIC_DUPLEX_HALF
¶ -
psutil.
NIC_DUPLEX_UNKNOWN
¶ Constants which identifies whether a NIC (network interface card) has full or half mode speed. NIC_DUPLEX_FULL means the NIC is able to send and receive data (files) simultaneously, NIC_DUPLEX_FULL means the NIC can either send or receive data at a time. To be used in conjunction with
psutil.net_if_stats()
.New in 3.0.0
Development guide¶
If you plan on hacking on psutil (e.g. want to add a new feature or fix a bug) take a look at the development guide.