Come posso organizzare i file in base alla prima lettera del loro nome file nelle cartelle AZ

Sto cercando un modo (preferibilmente terminale) per organizzare oltre 1000 caratteri con la loro prima lettera.

Fondamentalmente creare directory A-Z, #quindi spostare i file dei caratteri in quelle directory in base al primo carattere del nome file. Caratteri che iniziano con numeri [0-9] o altri caratteri speciali da spostare nella #directory.

Un'opzione di pitone in ritardo:

#!/usr/bin/env python3
import os
import sys
import shutil

def path(dr, f): return os.path.join(dr, f)

dr = sys.argv[1]
for f in os.listdir(dr):
    fsrc = path(dr, f)
    if os.path.isfile(fsrc):
        s = f[0]; target = path(dr, s.upper()) if s.isalpha() else path(dr, "#")
        if not os.path.exists(target):
            os.mkdir(target)
        shutil.move(fsrc, path(target, f))

Come usare

1. Copia lo script in un file vuoto, salvalo come move_files.py

2. Eseguilo con la directory come argomento:

   python3 /path/to/move_files.py /path/to/files
   

Lo script creerà la directory (sub) (-ies) (maiuscola) solo se è effettivamente necessario

Spiegazione

Il copione:

• elenca i file, ottiene il primo carattere (definisce il sourcepath):

  for f in os.listdir(dr):
      s = f[0]; fsrc = path(dr, f)

• controlla se l'articolo è un file:

  if os.path.isfile(fsrc):

• definisce la cartella di destinazione per se il primo carattere è alpha o no:

  target = path(dr, s.upper()) if s.isalpha() else path(dr, "#")

• controlla se la cartella esiste già o no, la crea in caso contrario:

  if not os.path.exists(target):
      os.mkdir(target)

• sposta l'elemento nella cartella corrispondente:

  shutil.move(fsrc, path(target, f))

Code-golfed ma leggibile con solo due comandi e due espressioni regolari:

mkdir -p '#' {a..z}
prename -n 's|^[[:alpha:]]|\l$&/$&|; s|^[0-9]|#/$&|' [[:alnum:]]?*

Se hai una grande quantità di file da spostare, troppi per adattarsi all'elenco degli argomenti del processo (sì, c'è un limite e potrebbe essere solo qualche kilobyte), puoi generare l'elenco dei file con un comando diverso e pipe che prename, per esempio:

find -mindepth 1 -maxdepth 1 -name '[[:alnum:]]?*' -printf '%f\n' |
prename -n 's|^[[:alpha:]]|\l$&/$&|; s|^[0-9]|#/$&|'

Ciò ha l'ulteriore vantaggio di non provare a spostare il nome del file letterale [[:alnum:]]?*se nessun file corrisponde al modello glob. findconsente inoltre molti più criteri di corrispondenza rispetto al gorgogliamento delle coperture. Un'alternativa è impostare l' nullglobopzione shell e chiudere il flusso di input standard di prename. ¹

In entrambi i casi rimuovere l' -ninterruttore per spostare effettivamente i file e non solo mostrare come sarebbero stati spostati.

Addendum: è possibile rimuovere nuovamente le directory vuote con:

rmdir --ignore-fail-on-non-empty '#' {a..z}

¹ shopt -s nullglob; prename ... <&-

Se non ti dispiace zsh, una funzione e un paio di zmvcomandi:

mmv() {echo mkdir -p "${2%/*}/"; echo mv -- "$1" "$2";}
autoload -U zmv
zmv -P mmv '([a-zA-Z])(*.ttf)' '${(UC)1}/$1$2'
zmv -P mmv '([!a-zA-Z])(*.ttf)' '#/$1$2'

La mmvfunzione crea la directory e sposta il file. zmvquindi fornisce la corrispondenza e la sostituzione del modello. Innanzitutto, spostando i nomi dei file che iniziano con un alfabeto, quindi tutto il resto:

$ zmv -P mmv '([a-zA-Z])(*.ttf)' '${(UC)1}/$1$2'
mkdir -p A/
mv -- abcd.ttf A/abcd.ttf
mkdir -p A/
mv -- ABCD.ttf A/ABCD.ttf
$ zmv -P mmv '([!a-zA-Z])(*.ttf)' '#/$1$2'
mkdir -p #/
mv -- 123.ttf #/123.ttf
mkdir -p #/
mv -- 七.ttf #/七.ttf

Eseguire di nuovo senza la echoa mmv's definizione realmente eseguire lo spostamento.

Non ho trovato un modo carino per rendere maiuscoli i nomi delle directory (o spostare i file con lettere maiuscole), anche se in seguito potresti farlo con rename...

mkdir {a..z} \#; for i in {a..z}; do for f in "$i"*; do if [[ -f "$f" ]]; then echo mv -v -- "$f" "$i"; fi; done; done; for g in [![:alpha:]]*; do if [[ -f "$g" ]]; then echo mv -v -- "$g" \#; fi; done

o più facilmente:

mkdir {a..z} \#; 
for i in {a..z}; do 
  for f in "$i"*; do
    if [[ -f "$f" ]]; then 
      echo mv -v -- "$f" "$i"; 
    fi 
  done
done
for g in [![:alpha:]]*; do 
  if [[ -f "$g" ]]; then 
    echo mv -v -- "$g" \#
  fi
done

Rimuovere echodopo il test per spostare effettivamente i file

E poi

rename -n 'y/[a-z]/[A-Z]/' *

rimuovere -nse sembra buono dopo il test ed eseguire di nuovo.

I seguenti comandi all'interno della directory contenente i caratteri dovrebbero funzionare, se si desidera utilizzare al di fuori della directory di archiviazione dei caratteri, passare for f in ./*a for f in /directory/containing/fonts/*. Questo è un metodo molto basato sulla shell, quindi piuttosto lento, ed è anche non ricorsivo. Questo creerà directory solo se ci sono file che iniziano con il carattere corrispondente.

target=/directory/to/store/alphabet/dirs
mkdir "$target"
for f in ./* ; do 
  if [[ -f "$f" ]]; then 
    i=${f##*/}
    i=${i:0:1}
    dir=${i^}
    if [[ $dir != [A-Z] ]]; then 
      mkdir -p "${target}/#" && mv "$f" "${target}/#"
    else
      mkdir -p "${target}/$dir" && mv "$f" "${target}/$dir"
    fi
  fi
done

Come una riga, sempre dalla directory di archiviazione dei caratteri:

target=/directory/to/store/alphabet/dirs; mkdir "$target" && for f in ./* ; do if [[ -f "$f" ]]; then i=${f##*/}; i=${i:0:1} ; dir=${i^} ; if [[ $dir != [A-Z] ]]; then mkdir -p "${target}/#" && mv "$f" "${target}/#"; else mkdir -p "${target}/$dir" && mv "$f" "${target}/$dir" ; fi ; fi ; done

Un metodo che usa find, con una manipolazione di stringhe simile, usa l'espansione dei parametri bash, che sarà ricorsiva e dovrebbe essere un po 'più veloce della versione pura della shell:

find . -type f -exec bash -c 'target=/directory/to/store/alphabet/dirs ; mkdir -p "$target"; f="{}" ; i="${f##*/}"; i="${i:0:1}"; i=${i^}; if [[ $i = [[:alpha:]] ]]; then mkdir -p "${target}/$i" && mv "$f" "${target}/$i"; else mkdir -p "${target}/#" && mv "$f" "${target}/#"; fi' \;

O più facilmente:

find . -type f -exec bash -c 'target=/directory/to/store/alphabet/dirs 
   mkdir -p "$target"
   f="{}"
   i="${f##*/}"
   i="${i:0:1}"
   i=${i^}
   if [[ $i = [[:alpha:]] ]]; then 
      mkdir -p "${target}/$i" && mv "$f" "${target}/$i"
   else
      mkdir -p "${target}/#" && mv "$f" "${target}/#"
   fi' \;

Mappare ciascun nome file su un nome di directory utilizzando tr, quindi mkdire mv:

find /src/dir -type f -print0 |
xargs -0 -I{} bash -c \
  'dir=/dest/$(basename "{}" | cut -c1 | tr -C "a-zA-Z\n" "#" | tr "a-z "A-Z"); mkdir -p $dir; mv "{}" $dir'