Python fnmatch

Quando si lavora con file e file system, è comune cercare molti file per scoprire un determinato file. Trovare i file necessari da molti file prenderà un'eternità se eseguita manualmente. Di conseguenza, i sistemi operativi e i linguaggi di programmazione includono strutture per la localizzazione dinamica dei file necessari. Queste utility di solito prendono di mira i file di file e utilizzo della corrispondenza dei pattern per provare a individuare i file pertinenti.

La libreria FNMatch nel linguaggio di programmazione Python può essere utilizzata per individuare i file in sistemi operativi basati su Unix come MacOS e Linux. Questo articolo utilizza il modulo fnMatch in Python per fare la corrispondenza del pattern.

Cos'è fnmatch?

È un pacchetto Python comune per abbinare caratteri jolly come quelli usati in gusci unix. Se un nome di file singolo corrisponde a uno schema, fnMatch () restituisce vero; Altrimenti, restituisce falso.

Funzioni fornite dal modulo fnMatch

Il modulo fnMatch contiene le funzioni fnmatch (), fnmatchcase (), filtro () e traduzione (). Programmi di esempio che dimostrano ogni funzione in profondità possono essere trovati di seguito.

Esempio 1:

Questo è il primo di diversi esempi nel nostro articolo sul metodo fnMatch (). Se il nome dato del file corrisponde alla stringa di pattern, il metodo FnMatch () eseguito restituisce un valore booleano. Se il sistema operativo è insensibile al caso, il confronto avverrà dopo che entrambi i parametri sono stati normalizzati a tutti i caratteri di tutti i casi.

Ecco un programma; Innanzitutto, abbiamo importato il modulo FNMatch e OS. Dopodiché, cerchiamo tutti i file che iniziano con "fnmatch" e finiamo con ".Py '. Infine, stampa il risultato, come puoi vedere nell'ultima riga di codice.

Importa fnmatch
Import OS
Patrn = 'fnMatch_*.Py '
print ('The Pattern is', Patrn)
stampa()
file_name = os.ListDir ('.')
per il nome in file_name:
print ('Nome del file: %-25s %s' %(nome, fnmatch.fnmatch (nome, Patrn)))

Qui nell'output, puoi vedere che il modello e i file che corrispondono al modello sono elencati.

Esempio 2:

Un altro esempio elabora la funzione fnMatch. Questa funzione richiede il nome del file e un modello di stringa di caratteri. Il nome del file viene confrontato con il modello e il metodo restituisce vero o falso.

Nell'esempio seguente, abbiamo importato i moduli Glob e FnMatch necessari per l'esecuzione di questo programma. Successivamente, abbiamo compilato un elenco di tutti i file presenti nella directory corrente che si adattano al “*.pattern py ".

Importa Glob, fnmatch
per files_names in (glob.glob ('*.*')):
if (fnmatch.fnmatch (files_names, "*.py ")):
Stampa (files_names)

Di seguito puoi scoprire che i file che corrispondono al modello vengono recuperati e elencati correttamente.

Esempio 3:

Ora discuteremo della funzione fnmatchcase () di fnmatch. Se la stringa di nome file corrisponde alla stringa di pattern definita, questa funzione esegue un confronto (sensibile ai casi in questo scenario) e restituisce un valore booleano. Il valore è vero o falso. Indipendentemente dalle impostazioni del filesystem o del sistema operativo, è possibile trovare il codice del programma per un confronto distintivo sui casi di casi nei casi.

Dopo aver importato il modulo FNMatch e OS, abbiamo definito il modello (indicato come Patrn nel codice) su cui si basa la nostra ricerca. Quindi abbiamo elencato tutti i file e i valori booleani se il file corrisponde al modello.

Importa fnmatch
Import OS
Patrn = 'fnMatch_*.Py '
print ('pattern:', Patrn)
stampa()
file_name = os.ListDir ('.')
per il nome in file_name:
(Print ('Nome del file: %-25s %s' %(nome, fnmatch.fnmatchcase (nome, patrn))))

Di seguito puoi trovare l'output e come puoi vedere che tutti i file restituiscono false.

Esempio 4:

In un altro esempio di fnmatchcase di seguito, tutti i file che iniziano con la lettera "H" e l'estensione ".Py 'sono raccolti per la prima volta in un oggetto elenco di file. Il metodo fnmatch () viene utilizzato per emettere solo nomi che iniziano con le lettere H.'

Importa Glob, fnmatch
file = glob.GLOB ("H*.*")
File
['dati.txt ',' demo.txt ',' History.py ',' history_internal.py ',' new_file.txt ',' pdb_history.sqlite ',]
per file nei file:
Se fnmatch.fnmatchcase (file, "h*.*") == vero:
stampa file)

Di seguito, la cronologia dei file.Py e History_internal.Py vengono visualizzati nello screenshot mentre corrispondono al modello definito.

Esempio 5:

Ora parleremo della funzione di filtro del modulo fnMatch. Questo metodo restituisce il sottoinsieme dell'elenco di nomi che corrispondono esattamente al modello fornito dai nomi dati. Qui puoi facilmente filtrare i file non solo per uno ma molte estensioni dei file. Esamina il codice seguente.

Qui abbiamo importato prima i moduli richiesti e definito il modello. Successivamente, elenca tutti i file che corrispondono ai criteri.

Importa fnmatch
Import OS
Patrn = 'fnMatch_*.Py '
print ('pattern is:', Patrn)
file_name = os.ListDir ('.')
Print ('I file sono menzionati qui:', file_name)
stampa ("corrispondenze trovate:", fnmatch.Filtro (file_name, Patrn))

Qui, puoi osservare che il modello viene visualizzato prima, quindi i file vengono recuperati e visualizzati. Infine, le partite vengono visualizzate se trovate. Nel nostro caso, non viene trovata alcuna corrispondenza.

Esempio 6:

Un altro programma elabora la funzione del filtro. Qui solo quei file i cui nomi corrispondono al parametro pattern vengono restituiti da questa funzione. Di tutti i file nella directory corrente, la seguente istruzione fornisce un elenco di file con il '.estensione txt.

Importa fnmatch
Files = ['Data.txt ',' demo.txt ',' History.py ',' history_internal.py ',' new_file.txt ',' pdb_history.sqlite ',]
Stampa (fnmatch.filtro (file "*.TXT"))

Ecco i nomi dei file con il '.estensione txt.

Esempio 7:

In questo esempio è dimostrata la funzione Translate () del modulo fnMatch. Questa funzione converte un modello in stile shell in un'espressione regolare che può essere utilizzata con re.match () (re.match () corrisponde solo all'inizio del testo, non a ciascuna riga). Abbiamo importato i moduli fnmatch e re, come puoi vedere nel codice seguente. Il modello è stato quindi trasformato in un'espressione regolare usando il metodo Translate ().

Importa fnmatch, re
reg_exp = fnmatch.tradurre('*.TXT')
re_obj = re.Compile (reg_exp)
print (reg_exp)
Stampa (re_obj.Match ('Demo.TXT'))

Qui puoi vedere l'output del programma di codice del metodo Translate () sopra eseguito.

Esempio 8:

Ecco un altro esempio della stessa funzione discussa sopra. Dopo aver importato i moduli richiesti, abbiamo eseguito la funzione Translate in cui abbiamo superato il modello che abbiamo definito nella riga di codice sopra. Il valore di ritorno della funzione viene quindi trasformato in un'espressione regolare usando la funzione compile () del modulo RE. Dopodiché, è usato per abbinare il modello dato.

importazione re
Importa fnmatch
Importa Glob
Patrn = "*.TXT"
reg_exp = fnmatch.Translate (Patrn)
reg_exp
'((?S:.*\\.txt) \\ z '
res = re.Compile (reg_exp)
per file_name in glob.glob ("*.*"):
se re.Match (res, file_name):
Stampa (file_name)

Ecco il risultato quando abbiamo eseguito il programma sopra.

Conclusione:

La funzione fnmatch () può corrispondere tra un metodo stringa semplice e un'espressione regolare complessa. Di solito è uno schema ragionevole quando è necessario solo un semplice jolly per elaborare i dati. Abbiamo elaborato diversi esempi per coprire questo argomento in dettaglio.