Python OS.Esempio di camminata

La funzione di camminata in qualsiasi sistema operativo è come il sistema operativo.sentiero. La funzione di camminata genera i nomi dei file in un albero di directory navigando sull'albero in entrambe le direzioni, sia un trasversale dall'alto verso il basso o da un basso verso l'alto. Ogni directory in qualsiasi albero di un sistema ha una directory di base alle sue spalle. E poi funge da sottodirectory. The Walk () genera l'output in tre tuple, il percorso, la directory e i file che sono disponibili in qualsiasi sottodirectory.

• Dirpath: È una stringa che conduce i file o una cartella verso il percorso della directory.
• Dirnames: Tutti i nomi delle sottodirectory che non contengono '.' E '… '.
• Filazioni: Il percorso della directory che contiene file diversi dai file di directory. È un elenco di cartelle o file che possono essere file creati dal sistema o creati dall'utente.

I nomi presenti nell'elenco non contengono alcun componente del percorso. Per prendere il percorso completo che inizia dall'alto in una directory o un file nel percorso della directory, utilizziamo il sistema operativo.camminare.join () che ha argomenti di dirpath e il nome della directory.

Dall'alto verso il basso e dal basso verso l'alto sono i due argomenti opzionali alla volta. Ciò significa che una delle opzioni deve essere utilizzata nella funzione se vogliamo una sequenza di directory. Mentre in alcuni casi, la sequenza top-down viene selezionata per impostazione predefinita se non menzioniamo alcun argomento su questa sequenza. Se l'argomento top-down è vero, la tripla per la directory principale viene prima visualizzata e quindi le sottodirectory in seguito. E se l'alto verso il basso è falso, la tripla per la directory viene visualizzata dopo le sottodirectory. In altre parole, la sequenza è in modo bottom-up.

Quando la situazione top-down è vera, l'utente può aggiornare l'elenco dei nomi della directory, quindi walk () verrà applicato solo sulle sottodirectory. Mentre l'aggiornamento dei nomi delle directory quando l'alto verso il basso è falso è inapplicabile. Questo perché, nella modalità bottom-up, i nomi delle directory nelle directory vengono visualizzati prima del percorso della directory. La funzione ListDir () può eliminare gli errori per impostazione predefinita.

Python OS.Walk () Working

Vediamo come viene attraversato il file system in Python. Funziona come un albero con una sola radice che si divide ulteriormente in rami. E i rami sono ampliati come sotto-rami e così via. Questa funzione di camminata emette i nomi dei file in un albero di directory navigando sull'albero dalla parte superiore o dalla parte inferiore.

Sintassi di OS.camminare()

# OS.walk (top [, topdown = true [onerror = non [followlinks = false]]])

superiore = È la testa o un punto di partenza di qualsiasi traversa della sottodirectory. Produce 3 tuple, come abbiamo descritto all'inizio dell'articolo.

Dall'alto al basso = Nel caso in cui è vero, la scansione delle directory è dall'alto alla fine e viceversa nel caso opposto.

Oneroor = Questa è una funzionalità speciale progettata per monitorare l'errore. Può mostrare un errore da continuare con la passeggiata o aumentare l'eccezione per respingere la passeggiata.

Segui i collegamenti = Porta a ricorsioni inarrestabili; è impostato su vero.

Nota: IL Followlinks L'opzione è impostata come vera; porta a ricorsioni inarrestabili se qualche collegamento indica la directory di base. La funzione Walk () non prende il record delle directory che ha già attraversato.

Esempio 1

Tutti i file nella directory devono essere elencati utilizzando questa funzione. Considera uno snippet di codice. Il primo passo è importare il modulo OS, come altre funzionalità da importare dalla libreria Python.

# Import OS

Dopodiché, definiremo una funzione denominata 'Modulo OS'. All'interno di questa funzione, utilizzare un ciclo per ottenere tutti i file che seguono le directory e la root. La tecnica top-down viene utilizzata qui. E "Followlinks"È mantenuto vero.

Import OS
# Il modulo OS fornisce una funzione che ottiene un elenco di file o cartelle
# in una directory
# '.'Significa la cartella corrente
# walk (...) il metodo genera i nomi dei file in un albero di directory camminando
# albero top-down o bottom-up
def os_module ():
Per root, dir, file in sistema operativo.camminare('.', topdown = false, onerror = nessuno, fowlowlinks = true):
per il nome file nei file:
Stampa (nome file)
def main ():
Stampa ('\ n ... utilizzando il modulo OS per elencare i file ... \ n')
Os_Module ()
Se __Name__ == '__main__':
principale()

Questo modulo stamperà solo i nomi dei file nella directory. IL '.'Full Stop che abbiamo usato qui è specificamente per la cartella corrente. Nel programma principale, chiameremo la funzione dichiarata.

Nell'output, è possibile vedere i nomi dei file nella cartella corrente.

Esempio 2

Questa funzione restituirà il valore scansionando tutte le directory e le sottodirectory nel percorso corrente della directory dalla direzione inferiore alla direzione superiore, come in alto = false qui.

Sistema operativo.camminare(".", Topdown = false) #!/usr/bin/python
Import OS
Per root, dir, file in sistema operativo.camminare(".", topdown = false):
per il nome nei file:
Stampa (sistema operativo.sentiero.join (root, name))
Per il nome in Dir:
Stampa (sistema operativo.sentiero.join (root, name))

A per loop viene utilizzato per stampare i file e le directory separatamente. IL "sistema operativo.sentiero.giuntura"Porta il nome e la directory principale dal percorso.

Una piccola parte dell'uscita è mostrata sopra. Se uno vuole ottenere l'output nella parte superiore per ridurre l'ordine, allora il modulo di top-down dovrebbe essere mantenuto come vero.

# OS.camminare(".", Topdown = true)

Esempio 3

Questo esempio differisce da quelli precedenti nel tipo di parametri utilizzati. Qui la funzione prende solo il "percorso". A per loop viene utilizzato per visualizzare i valori dei file, le directory del percorso. Se la dichiarazione viene utilizzata per limitare il valore risultante in ogni riga alla volta. Qui abbiamo usato 4. Dopo ogni 4 parole, il valore verrà spostato verso la riga successiva. Il valore iniziale della variabile "i" è preso come zero.

Import OS
Path = "C: \\ utenti"
i = 0
per (percorso, dir, file) nel sistema operativo.Walk (Path):
Stampa (percorso)
Stampa (Dirs)
Stampa (file)
stampa("----")
i += 1
Se i> = 4:
rottura

Il rispettivo output è mostrato di seguito. Il percorso, le directory e i file vengono visualizzati come output.

Esempio 4

Come il metodo Walk () nel sistema operativo, possiamo anche usare il "sistema operativo.listDir ()"Alternativa al percorso, che visualizzerà tutti i valori del valore particolare. io.e., Qui, abbiamo usato i file da stampare. Il percorso viene preso come argomento per la funzione. Il valore risultante verrà archiviato nella variabile dei file. Per loop visualizzerà tutti i file nella rispettiva directory.

# Files = OS.ListDir (Path) Import OS
path = '/utenti/utente/.spyder-py3 '
Files = OS.ListDir (Path)
Per F nei file:
stampa (f)

L'elenco viene visualizzato qui che contiene tutti i file nella rispettiva directory.

Esempio 5

Hai visto gli esempi in cui vengono visualizzate tutte le cartelle o i percorsi, anche quelli che vogliamo nascondere; Sono anche esposti. Ma “OS.Walk () ”utilizza alcune funzionalità che consentono di escludere le directory nascoste.

Dopo aver importato il modulo OS, abbiamo introdotto il percorso che useremo nell'esempio.

# Dirs.[:] = [d per d in dirs. Se non d.inizia con('.')] Import OS
path = 'c:/utenti/utente/.spyder-py3 '
Per root, dir, file in sistema operativo.Walk (Path):
stampa (root)
Dirs [:] = [d per d in dir se non d.inizia con('-')]
Per Dir in Dirs:
Stampa (sistema operativo.sentiero.join (root, dir))
per file nei file:
Stampa (sistema operativo.sentiero.join (root, file))

Questa funzione è in grado di nascondere le directory, ora con questo elenco, le directory nascoste non sono incluse nell'output.

Esempio 6

Supponiamo di avere un elenco di nomi della directory che si desidera trascurare durante la funzione Walk (). Un modo è usare il metodo come descritto sopra. Il secondo modo verrà spiegato qui. Questo darà lo stesso risultato.

# Dirs.[:] = [] Import OS
path = 'c:/utenti/utente/.spyder-py3 '
Per root, dir, file in sistema operativo.Walk (Path):
Se root in ignore_list:
Dirs [:] = []
File [:] = []
Stampa (Dirs [:])

Esempio 7

Se si desidera prendere la stampa dei valori assoluti, i nomi delle sottodirectory e le directory ma non l'intero percorso, in questo caso, viene utilizzata la funzione Python Walk.

Import OS
x = r'c:/utenti/utente/.spyder-py3 '
per r, d, f nel sistema operativo.Walk (x):
stampa (d)

Dall'output, puoi vedere che i valori risultanti sono diventati limitati.

Conclusione

La funzione "Python Os Walk" viene utilizzata per attraversare tutti i percorsi in una directory, dall'alto verso il basso o dal basso verso la parte superiore. Abbiamo anche visto come nascondere i dati indesiderati da visualizzare in anteprima. Sicuramente questo articolo sarà un vantaggio per l'implementazione della funzione di camminata del modulo OS in Python.