textos - guardar una lista en un archivo python

Encuentra el tamaño y el espacio libre del sistema de archivos que contiene un archivo dado

Question

Estoy usando Python 2.6 en Linux. ¿Cuál es la manera más rápida?

• para determinar qué partición contiene un directorio o archivo determinado?

  Por ejemplo, supongamos que /dev/sda2 está montado en /home , y /dev/mapper/foo está montado en /home/foo . Desde la secuencia "/home/foo/bar/baz" me gustaría recuperar el par ("/dev/mapper/foo", "home/foo") .

• y luego, para obtener estadísticas de uso de la partición dada? Por ejemplo, dado /dev/mapper/foo me gustaría obtener el tamaño de la partición y el espacio libre disponible (en bytes o aproximadamente en megabytes).

Answer 1

A partir de Python 3.3, hay una forma fácil y directa de hacerlo con la biblioteca estándar:

┌─[james@james-desktop] - [~/temp] - [Fri Sep 30, 01:38]
└─[$]> cat free_space.py
#!/usr/bin/env python3
import shutil
total, used, free = shutil.disk_usage(__file__)
print(total, used, free)
┌─[james@james-desktop] - [~/temp] - [Fri Sep 30, 01:38]
└─[$]> ./free_space.py
1007870246912 460794834944 495854989312

Estos números están en bytes. Ver la documentación para más información.

Answer 2

Esto debería hacer todo lo que pidas:

import os
from collections import namedtuple
disk_ntuple = namedtuple(''partition'', ''device mountpoint fstype'')
usage_ntuple = namedtuple(''usage'', ''total used free percent'')
def disk_partitions(all=False):
"""Return all mountd partitions as a nameduple.
If all == False return phyisical partitions only.
"""
phydevs = []
f = open("/proc/filesystems", "r")
for line in f:
if not line.startswith("nodev"):
phydevs.append(line.strip())
retlist = []
f = open(''/etc/mtab'', "r")
for line in f:
if not all and line.startswith(''none''):
continue
fields = line.split()
device = fields[0]
mountpoint = fields[1]
fstype = fields[2]
if not all and fstype not in phydevs:
continue
if device == ''none'':
device = ''''
ntuple = disk_ntuple(device, mountpoint, fstype)
retlist.append(ntuple)
return retlist
def disk_usage(path):
"""Return disk usage associated with path."""
st = os.statvfs(path)
free = (st.f_bavail * st.f_frsize)
total = (st.f_blocks * st.f_frsize)
used = (st.f_blocks - st.f_bfree) * st.f_frsize
try:
percent = ret = (float(used) / total) * 100
except ZeroDivisionError:
percent = 0
# NB: the percentage is -5% than what shown by df due to
# reserved blocks that we are currently not considering:
# http://goo.gl/sWGbH
return usage_ntuple(total, used, free, round(percent, 1))
if __name__ == ''__main__'':
for part in disk_partitions():
print part
print " %s/n" % str(disk_usage(part.mountpoint))

En mi caja, el código de arriba imprime:

giampaolo@ubuntu:~/dev$ python foo.py
partition(device=''/dev/sda3'', mountpoint=''/'', fstype=''ext4'')
usage(total=21378641920, used=4886749184, free=15405903872, percent=22.9)
partition(device=''/dev/sda7'', mountpoint=''/home'', fstype=''ext4'')
usage(total=30227386368, used=12137168896, free=16554737664, percent=40.2)
partition(device=''/dev/sdb1'', mountpoint=''/media/1CA0-065B'', fstype=''vfat'')
usage(total=7952400384, used=32768, free=7952367616, percent=0.0)
partition(device=''/dev/sr0'', mountpoint=''/media/WB2PFRE_IT'', fstype=''iso9660'')
usage(total=695730176, used=695730176, free=0, percent=100.0)
partition(device=''/dev/sda6'', mountpoint=''/media/Dati'', fstype=''fuseblk'')
usage(total=914217758720, used=614345637888, free=299872120832, percent=67.2)

Answer 3

Esto no da el nombre de la partición, pero puede obtener las estadísticas del sistema de archivos directamente usando la statvfs sistema statvfs Unix. Para llamarlo desde Python, use os.statvfs(''/home/foo/bar/baz'') .

Los campos relevantes en el resultado, según POSIX :

unsigned long f_frsize Fundamental file system block size.
fsblkcnt_t f_blocks Total number of blocks on file system in units of f_frsize.
fsblkcnt_t f_bfree Total number of free blocks.
fsblkcnt_t f_bavail Number of free blocks available to
non-privileged process.

Entonces, para darle sentido a los valores, multiplica por f_frsize :

import os
statvfs = os.statvfs(''/home/foo/bar/baz'')
statvfs.f_frsize * statvfs.f_blocks # Size of filesystem in bytes
statvfs.f_frsize * statvfs.f_bfree # Actual number of free bytes
statvfs.f_frsize * statvfs.f_bavail # Number of free bytes that ordinary users
# are allowed to use (excl. reserved space)

Answer 4

La forma más sencilla de descubrirlo.

import os
from collections import namedtuple
DiskUsage = namedtuple(''DiskUsage'', ''total used free'')
def disk_usage(path):
"""Return disk usage statistics about the given path.
Will return the namedtuple with attributes: ''total'', ''used'' and ''free'',
which are the amount of total, used and free space, in bytes.
"""
st = os.statvfs(path)
free = st.f_bavail * st.f_frsize
total = st.f_blocks * st.f_frsize
used = (st.f_blocks - st.f_bfree) * st.f_frsize
return DiskUsage(total, used, free)

Answer 5

Para el primer punto, puede intentar usar os.path.realpath para obtener una ruta canónica, getmntent contra /etc/mtab (en realidad, sugeriría llamar a getmntent , pero no puedo encontrar una forma normal de acceder a ella) para encontrar el partido más largo. (para estar seguro, probablemente debería stat tanto el archivo como el punto de montaje presunto para verificar que están de hecho en el mismo dispositivo)

Para el segundo punto, use os.statvfs para obtener información sobre el tamaño y el uso del bloque.

(Descargo de responsabilidad: no he probado nada de esto, la mayoría de lo que sé proviene de las fuentes de coreutils)

Answer 6

Para la segunda parte de su pregunta, "obtener estadísticas de uso de la partición dada", psutil hace fácil con la función disk_usage(path) . Dada una ruta, disk_usage() devuelve una tupla nombrada que incluye el espacio total, usado y libre expresado en bytes, más el porcentaje de uso.

Ejemplo simple de la documentación:

>>> import psutil
>>> psutil.disk_usage(''/'')
sdiskusage(total=21378641920, used=4809781248, free=15482871808, percent=22.5)

Psutil funciona con versiones de Python de 2.6 a 3.6 y en Linux, Windows y OSX, entre otras plataformas.

Answer 7

Por lo general, el /proc contiene dicha información en Linux, es un sistema de archivos virtual. Por ejemplo, /proc/mounts brinda información sobre los discos montados actualmente; y puedes analizarlo directamente. Las utilidades como top , df hacen uso de /proc .

No lo he usado, pero esto también podría ser útil, si quieres un envoltorio: http://bitbucket.org/chrismiles/psi/wiki/Home

Answer 8

Si solo necesita el espacio libre en un dispositivo, consulte la respuesta usando os.statvfs() continuación.

Si también necesita el nombre del dispositivo y el punto de montaje asociado con el archivo, debe llamar a un programa externo para obtener esta información. df proporcionará toda la información que necesita: cuando se llama como df filename , imprime una línea sobre la partición que contiene el archivo.

Para dar un ejemplo:

import subprocess
df = subprocess.Popen(["df", "filename"], stdout=subprocess.PIPE)
output = df.communicate()[0]
device, size, used, available, percent, mountpoint = /
output.split("/n")[1].split()

Tenga en cuenta que esto es bastante frágil, ya que depende del formato exacto de la salida de df , pero no conozco una solución más sólida. (Hay algunas soluciones basadas en el sistema de archivos /proc continuación que son incluso menos portátiles que esta).

Answer 9

import os
def disk_stat(path):
disk = os.statvfs(path)
percent = (disk.f_blocks - disk.f_bfree) * 100 / (disk.f_blocks -disk.f_bfree + disk.f_bavail) + 1
return percent
print disk_stat(''/'')
print disk_stat(''/data'')

Answer 10

import os
def get_mount_point(pathname):
"Get the mount point of the filesystem containing pathname"
pathname= os.path.normcase(os.path.realpath(pathname))
parent_device= path_device= os.stat(pathname).st_dev
while parent_device == path_device:
mount_point= pathname
pathname= os.path.dirname(pathname)
if pathname == mount_point: break
parent_device= os.stat(pathname).st_dev
return mount_point
def get_mounted_device(pathname):
"Get the device mounted at pathname"
# uses "/proc/mounts"
pathname= os.path.normcase(pathname) # might be unnecessary here
try:
with open("/proc/mounts", "r") as ifp:
for line in ifp:
fields= line.rstrip(''/n'').split()
# note that line above assumes that
# no mount points contain whitespace
if fields[1] == pathname:
return fields[0]
except EnvironmentError:
pass
return None # explicit
def get_fs_freespace(pathname):
"Get the free space of the filesystem containing pathname"
stat= os.statvfs(pathname)
# use f_bfree for superuser, or f_bavail if filesystem
# has reserved space for superuser
return stat.f_bfree*stat.f_bsize

Algunos ejemplos de rutas de acceso en mi computadora:

path ''trash'':
mp /home /dev/sda4
free 6413754368
path ''smov'':
mp /mnt/S /dev/sde
free 86761562112
path ''/usr/local/lib'':
mp / rootfs
free 2184364032
path ''/proc/self/cmdline'':
mp /proc proc
free 0

PD

si en Python ≥3.3, hay shutil.disk_usage(path) que devuelve una tupla con nombre de (total, used, free) expresado en bytes.