os.path - Manipolazione Indipendente dalla Piattaforma di Nomi di File

Scopo: Elabora, costruisce, verifica oppure lavora con nomi di file e percorsi.

file_downloadScarica gli esempi

L'utilizzo delle funzioni incluse nel modulo os.path facilita la scrittura di codice per lavorare su file su piattaforme multiple. Anche programmi non concepiti per essere portati su altri sistemi operativi dovrebbero usare questo modulo per una elaborazione affidabile dei nomi di file.

Elaborare Percorsi

Il primo insieme di funzioni in os.path può essere usato per elaborare stringhe che rappresentano nomi di file nelle loro componenti di percorso. E' importante comprendere che queste funzioni non dipendono dai percorsi effettivamente esistenti; esse operano esclusivamente su stringhe.

L'elaborazione di un percorso dipende da alcune variabili definite in os.

  • os.sep - Il separatore tra porzioni di percorso (es. "/" oppure "\").
  • os.extsep - Il separatore tra il nome del file e la sua estensione (es. ".")
  • os.pardir - La componente di percorso che rappresenta la risalita di un livello dell'albero di directory (es. "..").
  • os.curdir - La componente di percorso che rappresenta la directory corrente (es. ".").

La funzione split() divide il percorso in due parti separate e ritorna una tupla con il risultato. Il secondo elemento della tupla è l'ultimo componente del percorso, e il primo è tutto quello che lo precede.

# ospath_split.py

import os.path

PATHS = [
    '/uno/due/tre',
    '/uno/due/tre/',
    '/',
    '.',
    '',
]

for path in PATHS:
    print('{!r:>17} : {}'.format(path, os.path.split(path)))

Quando l'argomento in input termina con os.sep, l'ultimo elemento del percorso è una stringa vuota.

$ python3 ospath_split.py

   '/uno/due/tre' : ('/uno/due', 'tre')
  '/uno/due/tre/' : ('/uno/due/tre', '')
              '/' : ('/', '')
              '.' : ('', '.')
               '' : ('', '')

La funzione basename() ritorna un valore che equivale alla seconda parte del valore di split().

# ospath_basename.py

import os.path

PATHS = [
    '/uno/due/tre',
    '/uno/due/tre/',
    '/',
    '.',
    '',
]

for path in PATHS:
    print('{!r:>17} : {!r}'.format(path, os.path.basename(path)))

Il percorso completo viene ridotto all'ultimo elemento, senza considerare che si tratti di nome di file o di directory. Se il percorso finisce con il separatore di directory (os.sep). la porzione della base del nome viene considerata vuota.

$ python3 ospath_basename.py

   '/uno/due/tre' : 'tre'
  '/uno/due/tre/' : ''
              '/' : ''
              '.' : '.'
               '' : ''

La funzione dirname() ritorna la prima parte del percorso diviso.

# ospath_dirname.py

import os.path

PATHS = [
    '/uno/due/tre',
    '/uno/due/tre/',
    '/',
    '.',
    '',
]

for path in PATHS:
    print('{!r:>17} : {!r}'.format(path, os.path.dirname(path)))

La combinazione dei risultati di dirname() e basename() ricostruisce il percorso completo originale.

$ python3 ospath_dirname.py

   '/uno/due/tre' : '/uno/due'
  '/uno/due/tre/' : '/uno/due/tre'
              '/' : '/'
              '.' : ''
               '' : ''

splitext() agisce come split(), ma divide il percorso in base al separatore di estensione in luogo di quello di directory.

# ospath_splitext.py

import os.path

PATHS = [
    'nomefile.txt',
    'nomefile',
    '/percorso/a/nomefile.txt',
    '/',
    '',
    'mio-filecompresso.tar.gz',
    'no-estensione.',
]

for path in PATHS:
    print('{!r:>21} : {!r}'.format(path, os.path.splitext(path)))

Solo l'ultima occorrenza di os.extsep viene usata quando viene cercata l'estensione, quindi il risultato della separazione di un nome di file con estensioni multiple lascia parte dell'estensione nel prefisso.

$ python3 ospath_splitext.py

       'nomefile.txt' : ('nomefile', '.txt')
           'nomefile' : ('nomefile', '')
'/percorso/a/nomefile.txt' : ('/percorso/a/nomefile', '.txt')
                  '/' : ('/', '')
                   '' : ('', '')
'mio-filecompresso.tar.gz' : ('mio-filecompresso.tar', '.gz')
     'no-estensione.' : ('no-estensione', '.')

commonprefix() riceve un elenco di percorsi come argomento e ritorna una singola stringa che rappresenta un prefisso comune presente in tutti i percorsi. Il valore può rappresentare un percorso che in realtà non esiste, e il separatore di percorso non è incluso nella considerazione, quindi il prefisso potrebbe non fermarsi su di un elemento separatore.

# ospath_commonprefix.py

import os.path

paths = ['/uno/due/tre/quattro',
         '/uno/due/trequalchealtro',
         '/uno/due/tre/'
         ]
for path in paths:
    print('PERCORSO:', path)

print()
print('PREFISSO:', os.path.commonprefix(paths))

In questo esempio, la stringa di prefisso comune è /uno/due/tre, anche se un percorso non comprende una directory che si chiami tre.

$ python3 ospath_commonprefix.py
PERCORSO: /uno/due/tre/quattro
PERCORSO: /uno/due/trequalchealtro
PERCORSO: /uno/due/tre/

PREFISSO: /uno/due/tre

commonpath() tiene conto dei separatori di percorso, e ritorna un prefisso che non include valori di percorso parziali.

# ospath_commonpath.py
import os.path

paths = ['/uno/due/tre/quattro',
         '/uno/due/trequalchealtro',
         '/uno/due/tre/'
         ]
for path in paths:
    print('PERCORSO:', path)

print()
print('PREFISSO:', os.path.commonpath(paths))

Visto che trequalchealtro non ha un separatore di percorso dopo "tre", il prefisso comune è /uno/due.

$ python3 ospath_commonpath.py
PERCORSO: /uno/due/tre/quattro
PERCORSO: /uno/due/trequalchealtro
PERCORSO: /uno/due/tre/

PREFISSO: /uno/due

Costruire Percorsi

Oltre al separare percorsi in parti, è necessario frequentemente costruire percorsi da altre stringhe. Per combinare parecchie componenti di percorso in un unico valore si usi join().

# ospath_join.py

import os.path

PATHS = [
    ('uno', 'due', 'tre'),
    ('/', 'uno', 'due', 'tre'),
    ('/uno', '/due', '/tre'),
]

for parts in PATHS:
    print('{} : {!r}'.format(parts, os.path.join(*parts)))

Un qualsiasi argomento che inizi con os.sep fa sì che tutti i precedenti argomenti siano ignorati e il nuovo diventa l'inizio del valore ritornato.

$ python3 ospath_join.py

('uno', 'due', 'tre') : 'uno/due/tre'
('/', 'uno', 'due', 'tre') : '/uno/due/tre'
('/uno', '/due', '/tre') : '/tre'

E' anche possibile lavorare con percorsi che includono componenti sotto forma di variabile, che possono essere espansi automaticamente. Ad esempio expanduser() converte il carattere tilde (~) nel nome della directory home dell'utente.

# ospath_expanduser.py

import os.path

for user in ['', 'robby', 'nonesistente']:
    lookup = '~' + user
    print('{!r:>15} : {!r}'.format(
        lookup, os.path.expanduser(lookup)))

Se la directory home dell'utente non viene trovata, la stringa viene ritornata immutata, come nell'esempio ~nonesistente.

$ python3 ospath_expanduser.py

            '~' : '/home/robby'
       '~robby' : '/home/robby'
'~nonesistente' : '~nonesistente'

expandvars() è di utilizzo più generale, ed espande qualsiasi variabile di ambiente della shell presente nel percorso.

# ospath_expandvars.py

import os.path
import os

os.environ['MIAVAR'] = 'VALORE'

print(os.path.expandvars('/percorso/a/$MIAVAR'))

Non viene eseguita alcuna validazione per assicurarsi che il valore della variabile risulti in un nome di file che esiste già.

$ python3 ospath_expandvars.py

/percorso/a/VALORE

Normalizzare Percorsi

I percorsi assemblati da stringhe separate usando join() o con variabili incorporate potrebbero far risultare separatori extra o componenti di percorso relativo. Si usi normpath() per sistemarli.

# ospath_normpath.py

import os.path

PATHS = [
    'uno//due//tre',
    'uno/./due/./tre',
    'uno/../alt/due/tre',
]

for path in PATHS:
    print('{!r:>22} : {!r}'.format(path, os.path.normpath(path)))

I segmenti di percorso costituiti da os.curdir ed os.pardir sono esaminati e collassati.

$ python3 ospath_normpath.py
       'uno//due//tre' : 'uno/due/tre'
     'uno/./due/./tre' : 'uno/due/tre'
  'uno/../alt/due/tre' : 'alt/due/tre'

Per convertire un percorso relativo in uno nome di file assoluto si usi abspath().

# ospath_abspath.py

import os
import os.path

os.chdir('/usr')

PATHS = [
    '.',
    '..',
    './uno/due/tre',
    '../uno/due/tre',
]

for path in PATHS:
    print('{!r:>21} : {!r}'.format(path, os.path.abspath(path)))

Il risultato è un percorso completo, che parte al primo livello dell'albero del filesystem.

$ python3 ospath_abspath.py

                  '.' : '/usr'
                 '..' : '/'
      './uno/due/tre' : '/usr/uno/due/tre'
     '../uno/due/tre' : '/uno/due/tre'

Orari dei File

Oltre a lavorare con i percorsi, os.path include funzioni per ottenere proprietà dei file, simili a quelle ritornate da os.stat():

# ospath_properties.py

import os.path
import time

print('File           :', __file__)
print('Ultimo accesso :', time.ctime(os.path.getatime(__file__)))
print('Ultima modifica:', time.ctime(os.path.getmtime(__file__)))
print('Creazione      :', time.ctime(os.path.getctime(__file__)))
print('Dimensione     :', os.path.getsize(__file__))

os.path.getatime() ritorna l'orario di accesso, os.path.getmtime() ritorna l'orario di modifica e os.path.getctime() ritorna l'orario di creazione. os.path.getsize() ritorna il totale di dati in un file, rappresentati in byte.

$ python3 ospath_properties.py

File           : ospath_properties.py
Ultimo accesso : Sat Sep  2 11:59:36 2017
Ultima modifica: Sat Sep  2 11:59:36 2017
Change time    : Sat Sep  2 11:59:36 2017
Dimensione     : 338

Verificare i File

Quando un programma ha a che fare con un nome di percorso, spesso deve conoscere se quel percorso si riferisce a un file, una directory, un collegamento simbolico e se esiste. os.path fornisce funzioni per eseguire una verifica delle condizioni sopra elencate.

# ospath_tests.py
import os.path

FILENAMES = [
    __file__,
    os.path.dirname(__file__),
    '/',
    './collegamento_interrotto',
]

for file in FILENAMES:
    print('File                             : {!r}'.format(file))
    print('Assoluto                         :', os.path.isabs(file))
    print("E' un File?                      :", os.path.isfile(file))
    print("E' una directory                 :", os.path.isdir(file))
    print("E' un collegamento simbolico?    :", os.path.islink(file))
    print('Punto di montaggio?              :', os.path.ismount(file))
    print('Esiste?                          :', os.path.exists(file))
    print('Esiste il collegamento simbolico?:', os.path.lexists(file))
    print()

Tutte le funzioni di verifica ritornano valori booleani.

$ python3 ospath_tests.py
File                             : 'ospath_tests.py'
Assoluto                         : False
E' un File?                      : True
E' una directory                 : False
E' un collegamento simbolico?    : False
Punto di montaggio?              : False
Esiste?                          : True
Esiste il collegamento simbolico?: True

File                             : ''
Assoluto                         : False
E' un File?                      : False
E' una directory                 : False
E' un collegamento simbolico?    : False
Punto di montaggio?              : False
Esiste?                          : False
Esiste il collegamento simbolico?: False

File                             : '/'
Assoluto                         : True
E' un File?                      : False
E' una directory                 : True
E' un collegamento simbolico?    : False
Punto di montaggio?              : True
Esiste?                          : True
Esiste il collegamento simbolico?: True

File                             : './collegamento_interrotto'
Assoluto                         : False
E' un File?                      : False
E' una directory                 : False
E' un collegamento simbolico?    : False
Punto di montaggio?              : False
Esiste?                          : False
Esiste il collegamento simbolico?: False

Vedere anche:

os.path
La documentazione della libreria standard per questo modulo
Note di portabilità per os.path
pathlib
Percorsi come oggetti
os
Dal modulo os discende os.path
time
Il modulo time contiene funzioni per conversioni tra la rappresentazione usata dalle funzioni per la proprietà di orario usate in os.path
Indice articolo: