Comment puis-je organiser les fichiers en fonction de leur première lettre de nom de fichier dans des dossiers AZ

Je cherche un moyen (de préférence terminal) d'organiser plus de 1000 polices par leur première lettre.

Fondamentalement, créez des répertoires, A-Z, #puis déplacez les fichiers de police vers ces répertoires en fonction du premier caractère de leur nom de fichier. Polices commençant par des chiffres [0-9] ou d'autres caractères spéciaux à déplacer vers le #répertoire.

Une option de python tardif:

#!/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))

Comment utiliser

1. Copiez le script dans un fichier vide, enregistrez-le sous move_files.py

2. Exécutez-le avec le répertoire comme argument:

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

Le script ne crée le (sous) répertoire (-ies) (majuscule) que s'il est réellement nécessaire

Explication

Le script:

• liste les fichiers, obtient le premier caractère (définit le chemin source):

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

• vérifie si l'élément est un fichier:

  if os.path.isfile(fsrc):

• définit le dossier cible pour si le premier caractère est alpha ou non:

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

• vérifie si le dossier existe déjà ou non, le crée sinon:

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

• déplace l'élément dans son dossier correspondant:

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

Joué au code mais lisible avec seulement deux commandes et deux expressions régulières:

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

Si vous avez une énorme quantité de fichiers à déplacer, trop nombreux pour tenir dans la liste des arguments du processus (oui, il y a une limite et cela peut être seulement quelques kilo-octets), vous pouvez générer la liste des fichiers avec une commande et un canal différents pour prename, par exemple:

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

Cela a l'avantage supplémentaire de ne pas essayer de déplacer le nom de fichier littéral [[:alnum:]]?*si aucun fichier ne correspond au modèle global. findpermet également beaucoup plus de critères de correspondance que la globalisation du shell. Une alternative consiste à définir l' nullgloboption shell et à fermer le flux d'entrée standard de prename. ¹

Dans les deux cas, supprimez le -ncommutateur pour déplacer réellement les fichiers et pas seulement montrer comment ils seraient déplacés.

Addendum: vous pouvez à nouveau supprimer les répertoires vides avec:

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

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

Si cela ne vous dérange pas zsh, une fonction et quelques zmvcommandes:

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 mmvfonction crée le répertoire et déplace le fichier. zmvfournit ensuite le filtrage et la substitution de motifs. Tout d'abord, déplacer les noms de fichiers commençant par un alphabet, puis tout le reste:

$ 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

Exécutez à nouveau sans echodans mmvla définition de » pour réaliser effectivement le mouvement.

Je n'ai pas trouvé une bonne façon de mettre les noms de répertoires en majuscules (ou de déplacer les fichiers avec des lettres majuscules), bien que vous puissiez le faire ensuite avec 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

ou plus lisible:

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

Supprimer echoaprès les tests pour déplacer réellement les fichiers

Puis

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

supprimer -nsi cela semble bon après le test et réexécuter.

Les commandes suivantes dans le répertoire contenant les polices devraient fonctionner, si vous souhaitez utiliser à l'extérieur du répertoire de stockage des polices, passez for f in ./*à for f in /directory/containing/fonts/*. Il s'agit d'une méthode très basée sur le shell, donc assez lente et non récurrente. Cela ne créera des répertoires que s'il existe des fichiers commençant par le caractère correspondant.

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

Comme une ligne, à nouveau à partir du répertoire de stockage des polices:

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

Une méthode utilisant find, avec une manipulation de chaîne similaire, utilisant l'expansion des paramètres bash, qui sera récursive, et devrait être un peu plus rapide que la version pure 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' \;

Ou plus lisible:

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' \;

Mappez chaque nom de fichier à un nom de répertoire en utilisant tr, puis mkdiret 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'