One place for hosting & domains

      archivos

      Cómo usar Find y Locate para buscar archivos en Linux


      Introducción

      Un problema al que los usuarios se enfrentan cuando utilizan por primera vez una máquina Linux es cómo encontrar los archivos que buscan.

      En esta guía, se explicará cómo utilizar el comando llamado find de manera adecuada. Eso lo ayudará a buscar archivos en su VPS utilizando diversos filtros y parámetros. También abordaremos brevemente el comando locate, que se puede utilizar para buscar archivos de distinta manera.

      Cómo buscar por nombre

      La forma más evidente de buscar archivos es por nombre.

      Para encontrar un archivo por nombre, escriba lo siguiente:

      Distingue entre mayúsculas y minúsculas, lo que significa que una búsqueda de file será diferente a File.

      Para encontrar un archivo por nombre, pero ignorar mayúsculas o minúsculas en la consulta, escriba lo siguiente:

      Si desea encontrar todos los archivos que no se ajustan a un patrón específico, puede invertir la búsqueda con -not o !. Si utiliza !, debe quitar el carácter de forma que bash no intente interpretarlo antes que find pueda actuar:

      • find -not -name "query_to_avoid"

      o

      • find ! -name "query_to_avoid"

      Cómo buscar por tipo

      Puede especificar el tipo de archivos que desea encontrar con el parámetro -type. Funciona de la siguiente manera:

      • find -type type_descriptor query

      A continuación, encontrará algunos de los descriptores más frecuentes que puede utilizar para especificar el tipo de archivo:

      Por ejemplo, si quisiéramos encontrar todos los dispositivos de caracteres en nuestro sistema, podríamos ejecutar el siguiente comando:

      Output

      /dev/parport0 /dev/snd/seq /dev/snd/timer /dev/autofs /dev/cpu/microcode /dev/vcsa7 /dev/vcs7 /dev/vcsa6 /dev/vcs6 /dev/vcsa5 /dev/vcs5 /dev/vcsa4 . . .

      Podemos buscar todos los archivos que terminan en .conf como se muestra a continuación:

      • find / -type f -name "*.conf"

      Output

      /var/lib/ucf/cache/:etc:rsyslog.d:50-default.conf /usr/share/base-files/nsswitch.conf /usr/share/initramfs-tools/event-driven/upstart-jobs/mountall.conf /usr/share/rsyslog/50-default.conf /usr/share/adduser/adduser.conf /usr/share/davfs2/davfs2.conf /usr/share/debconf/debconf.conf /usr/share/doc/apt-utils/examples/apt-ftparchive.conf . . .

      Cómo filtrar por fecha y tamaño

      Find le proporciona diversas maneras de filtrar resultados por tamaño y fecha.

      Tamaño

      Puede filtrar por tamaño utilizando el parámetro -size.

      Añadimos un sufijo al final de nuestro valor con el que se especifica cómo se cuenta. Estas son algunas opciones populares:

      • c: bytes

      • k: kilobytes

      • M: megabytes

      • G: gigabytes

      • b: bloques de 512 bytes

      Para encontrar todos los archivos que son exactamente de 50 bytes, escriba lo siguiente:

      Para encontrar todos los archivos de menos de 50 bytes, podemos utilizar la siguiente forma:

      Para encontrar todos los archivos de más de 700 megabytes, podemos utilizar el siguiente comando:

      Fecha

      Linux almacena datos de fecha de las fechas de acceso, fechas de modificación y fechas de cambio.

      • Fechas de acceso: La última vez que se leyó o se escribió un archivo.

      • Fecha de modificación: La última vez que el contenido del archivo se modificó.

      • Fecha de cambio: La última vez que se modificaron los metadatos inode del archivo.

      Podemos utilizarlos con los parámetros -atime, -mtime y -ctime. Con estos, se pueden usar los signos de más y menos para especificar mayor o menor que, como hicimos con el tamaño.

      Con el valor de este parámetro, se especifica cuántos días atrás le gustaría buscar.

      Para encontrar archivos que tengan una fecha de modificación de un día atrás, escriba lo siguiente:

      Si queremos archivos a los que se haya accedido hace menos de un día, podemos escribir lo siguiente:

      Para obtener archivos cuya metainformación se haya modificado hace más de 3 días, escriba lo siguiente:

      También existen algunos parámetros complementarios que podemos usar para especificar minutos en vez de días:

      Con esto, se mostrarán los archivos que se modificaron en el último minuto en el sistema.

      Find también puede hacer comparaciones con un archivo de referencia y mostrar los que son más recientes:

      Cómo buscar por propietario y permisos

      También puede buscar archivos por su propietario o propietario del grupo.

      Para hacerlo, utilice los parámetros -user y -group respectivamente. Busque un archivo que sea propiedad del usuario “syslog” ingresando lo siguiente:

      De igual manera, podemos especificar archivos que son propiedad del grupo “shadow” escribiendo lo siguiente:

      También podemos buscar archivos con permisos específicos.

      Si queremos que coincida un conjunto exacto de permisos, utilizamos esta forma:

      Eso relacionará los archivos con los permisos especificados.

      Si queremos especificar algún elemento con al menos esos permisos, puede utilizar esta forma:

      Eso relacionará cualquier archivo que tenga permisos adicionales. En este caso, se relacionaría un archivo con permisos de “744”.

      Cómo filtrar por profundidad

      Para esta sección, crearemos una estructura de directorio en un directorio temporal. Contendrá tres niveles de directorios, con diez directorios en el primer nivel. Cada directorio (incluido el directorio temporal) contendrá diez archivos y diez subdirectorios.

      Cree esta estructura ejecutando los siguientes comandos:

      • cd
      • mkdir -p ~/test/level1dir{1..10}/level2dir{1..10}/level3dir{1..10}
      • touch ~/test/{file{1..10},level1dir{1..10}/{file{1..10},level2dir{1..10}/{file{1..10},level3dir{1..10}/file{1..10}}}}
      • cd ~/test

      No dude en consultar las estructuras de directorios con ls y cd para entender cómo se organizan los elementos. Cuando termine, regrese al directorio de prueba:

      Trabajaremos en cómo obtener archivos específicos con esta estructura. Para comparar, primero probaremos un ejemplo con una búsqueda de nombre normal:

      Output

      ./level1dir7/level2dir8/level3dir9/file1 ./level1dir7/level2dir8/level3dir3/file1 ./level1dir7/level2dir8/level3dir4/file1 ./level1dir7/level2dir8/level3dir1/file1 ./level1dir7/level2dir8/level3dir8/file1 ./level1dir7/level2dir8/level3dir7/file1 ./level1dir7/level2dir8/level3dir2/file1 ./level1dir7/level2dir8/level3dir6/file1 ./level1dir7/level2dir8/level3dir5/file1 ./level1dir7/level2dir8/file1 . . .

      Aparecen muchos resultados. Si canalizamos el resultado en un contador, observamos que hay 1111 resultados en total:

      Output

      1111

      Probablemente, sean demasiados resultados para que le resulte útil en la mayoría de los casos. Intentemos reducirlo.

      Puede especificar la profundidad máxima de la búsqueda en el directorio de búsqueda de nivel superior:

      • find -maxdepth num -name query

      Para encontrar “file1” solo en los directorios de “level1” y superiores, puede especificar una profundidad máxima de 2 (1 para el directorio de nivel superior y 1 para los directorios de level1):

      • find -maxdepth 2 -name file1

      Output

      ./level1dir7/file1 ./level1dir1/file1 ./level1dir3/file1 ./level1dir8/file1 ./level1dir6/file1 ./file1 ./level1dir2/file1 ./level1dir9/file1 ./level1dir4/file1 ./level1dir5/file1 ./level1dir10/file1

      Esa lista es mucho más manejable.

      También se puede especificar un directorio mínimo si sabe que todos los archivos existen a partir de cierto punto en el directorio actual:

      • find -mindepth num -name query

      Podemos utilizarlo para encontrar solo los archivos al final de las ramas de los directorios:

      • find -mindepth 4 -name file

      Output

      ./level1dir7/level2dir8/level3dir9/file1 ./level1dir7/level2dir8/level3dir3/file1 ./level1dir7/level2dir8/level3dir4/file1 ./level1dir7/level2dir8/level3dir1/file1 ./level1dir7/level2dir8/level3dir8/file1 ./level1dir7/level2dir8/level3dir7/file1 ./level1dir7/level2dir8/level3dir2/file1 . . .

      Una vez más, debido a nuestra estructura de directorio con ramificaciones, obtendremos un gran número de resultados (1000).

      Puede combinar los parámetros de profundidad min y max para centrarse en un rango más pequeño:

      • find -mindepth 2 -maxdepth 3 -name file

      Output

      ./level1dir7/level2dir8/file1 ./level1dir7/level2dir5/file1 ./level1dir7/level2dir7/file1 ./level1dir7/level2dir2/file1 ./level1dir7/level2dir10/file1 ./level1dir7/level2dir6/file1 ./level1dir7/level2dir3/file1 ./level1dir7/level2dir4/file1 ./level1dir7/file1 . . .

      Cómo ejecutar y combinar comandos find

      Puede ejecutar un comando auxiliar arbitrario en todo lo que se encuentre con find mediante el uso del parámetro -exec. Eso se invoca de la siguiente manera:

      • find find_parameters -exec command_and_params {} ;

      El {} se utiliza como un marcador de posición para los archivos que se encuentren con find. El ; se utiliza para que find sepa dónde termina el comando.

      Por ejemplo, podríamos encontrar los archivos en la sección anterior que tenían 644 permisos y modificarlos para que tengan 664 permisos:

      • cd ~/test
      • find . -type f -perm 644 -exec chmod 664 {} ;

      Luego, podríamos cambiar los permisos del directorio de esta manera:

      • find . -type d -perm 755 -exec chmod 700 {} ;

      Si desea encadenar diferentes resultados, puede usar los comandos -and o -or. Si se omite, se asume el comando -and.

      • find . -name file1 -or -name file9

      Cómo encontrar archivos utilizando Locate

      Una alternativa a utilizar find es el comando locate. A menudo, este comando es más rápido y puede realizar una búsqueda en todo el sistema de archivos con facilidad.

      Puede instalar el comando en Debian o Ubuntu con apt:

      En CentOS, utilice dnf en su lugar:

      La razón por la que locate es más rápido que find es porque utiliza una base de datos de los archivos en el sistema de archivos.

      Normalmente, la base de datos se actualiza una vez al día con una secuencia de comandos de Cron, pero puede actualizarla de forma manual escribiendo lo siguiente:

      Ejecute ese comando ahora. Recuerde que la base de datos siempre debe estar actualizada si desea encontrar archivos recientemente adquiridos o creados.

      Para encontrar archivos con locate, simplemente utilice la siguiente sintaxis:

      Puede filtrar el resultado de alguna manera.

      Por ejemplo, para solo obtener archivos que contengan la consulta en sí, en vez de obtener cada archivo que contenga la consulta en los directorios en que se encuentre, puede utilizar el -b solamente para buscar el “nombre de base”:

      Para que con locate solo se obtengan resultados que todavía existen en el sistema de archivos (que no se eliminaron entre la última invocación de updatedb y la invocación actual de locate), utilice el indicador -e:

      Para ver estadísticas sobre la información que se catalogó con locate, utilice la opción -S:

      Output

      Database /var/lib/mlocate/mlocate.db: 3,315 directories 37,228 files 1,504,439 bytes in file names 594,851 bytes used to store database

      Conclusión

      Find y locate son buenas maneras de encontrar archivos en su sistema. Le corresponde decidir cuál de estas herramientas es la adecuada para cada situación.

      Find y locate son comandos potentes que se pueden reforzar combinándolos con otras utilidades mediante canalizaciones. Experimente con filtros utilizando comandos como wc, sort y grep.



      Source link

      Cómo usar SFTP para transferir archivos con un servidor remoto de manera segura


      Introducción

      FTP, o “File Transfer Protocol” (Protocolo de transferencia de archivos), era un método popular sin cifrar para transferir archivos entre dos sistemas remotos.

      SFTP, que significa Protocolo de transferencia de archivos SSH o Protocolo de transferencia segura de archivos, es un protocolo independiente empaquetado con SSH que funciona de forma similar pero a través de una conexión segura. La ventaja es la capacidad de aprovechar una conexión segura para transferir archivos y recorrer el sistema de archivos en los sistemas local y remoto.

      En casi todos los casos, es preferible usar SFTP, en vez de FTP, debido a sus características de seguridad subyacentes y a su capacidad para aprovechar una conexión SSH. FTP es un protocolo no seguro que solo debería utilizarse en casos limitados o en redes de confianza.

      Aunque SFTP está integrado en muchas herramientas gráficas, esta guía mostrará cómo utilizarlo en su interfaz de línea de comandos interactiva.

      Cómo conectarse con SFTP

      De forma predeterminada, SFTP utiliza el protocolo SSH para autenticarse y establecer una conexión segura. Por eso, están disponibles los mismos métodos de autenticación que en SSH.

      Aunque las contraseñas son fáciles de usar y se configuran de forma predeterminada, le recomendamos crear claves SSH y transferir su clave pública a cualquier sistema al que necesite acceder. Eso es mucho más seguro y puede ahorrarle tiempo a largo plazo.

      Consulte esta guía para configurar claves SSH para acceder a su servidor si aún no lo hizo.

      Si puede conectarse al equipo usando SSH, habrá completado todos los requisitos necesarios para usar SFTP para administrar archivos. Pruebe el acceso SSH con el siguiente comando:

      • ssh sammy@your_server_ip_or_remote_hostname

      Si esto funciona, salga de nuevo escribiendo:

      Ahora, podemos establecer una sesión SFTP ejecutando el siguiente comando:

      • sftp sammy@your_server_ip_or_remote_hostname

      Conectará el sistema remoto, y la entrada de su línea de comandos cambiará a una instrucción SFTP.

      Si está trabajando en un puerto SSH personalizado (no el puerto 22 predeterminado), puede iniciar una sesión SFTP de la siguiente manera:

      • sftp -oPort=custom_port sammy@your_server_ip_or_remote_hostname

      Eso lo conectará al sistema remoto mediante el puerto especificado.

      Cómo obtener ayuda en SFTP

      El comando más útil que debe conocer primero es el comando help. Este comando le da acceso a un resumen de la ayuda en SFTP. Puede invocarlo escribiendo cualquiera de estos en la instrucción:

      o

      Eso mostrará una lista de los comandos disponibles:

      Output

      Available commands: bye Quit sftp cd path Change remote directory to 'path' chgrp grp path Change group of file 'path' to 'grp' chmod mode path Change permissions of file 'path' to 'mode' chown own path Change owner of file 'path' to 'own' df [-hi] [path] Display statistics for current directory or filesystem containing 'path' exit Quit sftp get [-Ppr] remote [local] Download file help Display this help text lcd path Change local directory to 'path' . . .

      En las siguientes secciones, exploraremos algunos de los comandos que verá.

      Cómo navegar con SFTP

      Podemos navegar a través de la jerarquía de archivos del sistema remoto usando varios comandos que funcionan de forma similar a sus contrapartes de shell.

      Primero, orientémonos averiguando en qué directorio estamos actualmente en el sistema remoto. Al igual que en una sesión típica de shell, podemos escribir lo siguiente para obtener el directorio actual:

      Output

      Remote working directory: /home/demouser

      Podemos ver el contenido del directorio actual del sistema remoto con otro comando familiar:

      Output

      Summary.txt info.html temp.txt testDirectory

      Tenga en cuenta que los comandos en la interfaz SFTP no son los comandos de shell normales y no cuentan con la misma cantidad de funciones, pero implementan algunos de los indicadores opcionales más importantes:

      Output

      drwxr-xr-x 5 demouser demouser 4096 Aug 13 15:11 . drwxr-xr-x 3 root root 4096 Aug 13 15:02 .. -rw------- 1 demouser demouser 5 Aug 13 15:04 .bash_history -rw-r--r-- 1 demouser demouser 220 Aug 13 15:02 .bash_logout -rw-r--r-- 1 demouser demouser 3486 Aug 13 15:02 .bashrc drwx------ 2 demouser demouser 4096 Aug 13 15:04 .cache -rw-r--r-- 1 demouser demouser 675 Aug 13 15:02 .profile . . .

      Para llegar a otro directorio, podemos ejecutar este comando:

      Ahora, podemos recorrer el sistema de archivos remotos, pero ¿qué pasa si necesitamos acceder a nuestro sistema de archivos local? Podemos dirigir los comandos al sistema de archivos locales precediéndolos con una l que hace referencia a “local”.

      Todos los comandos examinados hasta ahora tienen equivalentes locales. Podemos imprimir el directorio local de trabajo:

      Output

      Local working directory: /Users/demouser

      Podemos enumerar el contenido del directorio actual en el equipo local:

      Output

      Desktop local.txt test.html Documents analysis.rtf zebra.html

      También podemos cambiar el directorio con el que deseamos interactuar en el sistema local:

      Cómo transferir archivos con SFTP

      Navegar por los sistemas de archivos locales y remotos es muy poco útil si no se puede transferir archivos entre ambos.

      Transferencia de archivos remotos al sistema local

      Si queremos descargar archivos de nuestro host remoto, podemos hacerlo ejecutando el siguiente comando:

      Output

      Fetching /home/demouser/remoteFile to remoteFile /home/demouser/remoteFile 100% 37KB 36.8KB/s 00:01

      Como puede ver, de forma predeterminada, el comando get descarga un archivo remoto a un archivo con el mismo nombre en el sistema de archivos locales.

      Podemos copiar el archivo remoto a un nombre diferente especificando el nombre después:

      El comando get también toma algunos indicadores de opción. Por ejemplo, podemos copiar un directorio y todo su contenido especificando la opción recursiva:

      Podemos indicarle a SFTP que mantenga los permisos y los tiempos de acceso adecuados utilizando el indicador -P o -p:

      Transferencia de archivos locales al sistema remoto

      Transferir archivos al sistema remoto es tan fácil como utilizar el comando correctamente llamado “put”:

      Output

      Uploading localFile to /home/demouser/localFile localFile 100% 7607 7.4KB/s 00:00

      Los mismos indicadores que funcionan con get se aplican a put. Para copiar un directorio local completo, puede ejecutar:

      Nota: Actualmente, hay un error en las versiones de OpenSSH incluidas en las versiones actuales de Ubuntu (al menos de la versión 14.04 a la 15.10) que impide que el comando anterior funcione correctamente. Cuando se ejecuta el comando anterior para transferir contenido a un servidor utilizando la versión con errores de OpenSSH, se producirá el siguiente error: Couldn't canonicalise: No such file or directory (No se pudo canonizar: no existe tal archivo o directorio).

      Para resolver este problema, primero cree el directorio de destino en el extremo remoto escribiendo mkdir localDirectory. Luego, el comando anterior debería completarse sin errores.

      Una herramienta familiar que es útil para descargar y cargar archivos es el comando df, que funciona de forma similar a la versión de la línea de comandos. Al utilizarla, puede verificar que tiene suficiente espacio para completar las transferencias que le interesan:

      Output

      Size Used Avail (root) %Capacity 19.9GB 1016MB 17.9GB 18.9GB 4%

      Tenga en cuenta que no hay ninguna variación local de este comando, pero podemos solucionarlo ejecutando ! como comando.

      El comando ! nos lleva a un shell local, donde podemos ejecutar cualquier comando disponible en nuestro sistema local. Podemos verificar el uso del disco escribiendo lo siguiente:

      y luego

      Output

      Filesystem Size Used Avail Capacity Mounted on /dev/disk0s2 595Gi 52Gi 544Gi 9% / devfs 181Ki 181Ki 0Bi 100% /dev map -hosts 0Bi 0Bi 0Bi 100% /net map auto_home 0Bi 0Bi 0Bi 100% /home

      Cualquier otro comando local funcionará de la manera esperada. Para volver a su sesión SFTP, escriba lo siguiente:

      Ahora, debería ver el retorno de la instrucción de SFTP.

      Manipulaciones de archivos simples con SFTP

      SFTP le permite realizar el tipo de mantenimiento básico de archivos que es útil cuando se trabaja con jerarquías de archivos.

      Por ejemplo, puede cambiar el propietario de un archivo en el sistema remoto con:

      Observe cómo, a diferencia del comando chmod del sistema, el comando SFTP no acepta nombres de usuario, sino que utiliza UID. Lamentablemente, no hay una manera sencilla de saber el UID adecuado desde la interfaz SFTP.

      Se puede realizar una solución alternativa más compleja con:

      • get /etc/passwd
      • !less passwd

      Output

      root:x:0:0:root:/root:/bin/bash daemon:x:1:1:daemon:/usr/sbin:/bin/sh bin:x:2:2:bin:/bin:/bin/sh sys:x:3:3:sys:/dev:/bin/sh sync:x:4:65534:sync:/bin:/bin/sync games:x:5:60:games:/usr/games:/bin/sh man:x:6:12:man:/var/cache/man:/bin/sh . . .

      Observe cómo en vez de utilizar el comando ! en sí, lo utilizamos como prefijo para un comando de shell local. Eso funciona para ejecutar cualquier comando disponible en nuestro equipo local y podría haberse utilizado anteriormente con el comando local df.

      El UID se encuentra en la tercera columna del archivo, delimitado por caracteres de dos puntos.

      De manera similar, podemos cambiar el propietario del grupo de un archivo con:

      De nuevo, no existe una forma sencilla de obtener una lista de los grupos del sistema remoto. Podemos solucionarlo con el siguiente comando:

      • get /etc/group
      • !less group

      Output

      root:x:0: daemon:x:1: bin:x:2: sys:x:3: adm:x:4: tty:x:5: disk:x:6: lp:x:7: . . .

      La tercera columna contiene el ID del grupo asociado con el nombre en la primera columna. Eso es lo que buscamos.

      Por suerte, el comando chmod funciona correctamente en el sistema de archivos remotos:

      Output

      Changing mode on /home/demouser/publicFile

      No existe ningún comando para manipular permisos de archivo locales, pero puede quitar la máscara local para que todos los archivos que se copien al sistema local tengan los permisos adecuados.

      Eso se puede lograr con el comando lumask:

      Output

      Local umask: 022

      Ahora, todos los archivos regulares descargados (siempre que no se utilice el indicador -p) tendrán 644 permisos.

      SFTP permite crear directorios en sistemas locales y en sistemas remotos con lmkdir y mkdir, respectivamente. Estos funcionan de la manera prevista.

      El resto de los comandos del archivo solo apuntan al sistema de archivos remotos:

      Estos comandos replican el comportamiento básico de las versiones del shell. Si necesita realizar estas acciones en el sistema de archivos local, recuerde que puede ingresar a un shell ejecutando este comando:

      O ejecutar un comando único en el sistema local anteponiendo ! al comando de esta manera:

      Cuando termine con la sesión SFTP, utilice exit o bye para cerrar la conexión.

      Conclusión

      Aunque SFTP es una herramienta simple, es muy útil para administrar servidores y transferir archivos entre ellos.

      Por ejemplo, puede usar SFTP para permitir que determinados usuarios transfieran archivos sin acceso SSH. Para obtener más información sobre este proceso, consulte nuestro tutorial Cómo habilitar SFTP sin acceso de shell.

      Si está acostumbrado a utilizar FTP o SCP para realizar sus transferencias, SFTP es una buena forma de aprovechar las ventajas de ambos. Si bien no es adecuado para todas las situaciones, es útil tenerlo en su repertorio por ser una herramienta flexible.



      Source link

      Cómo usar el módulo pathlib para manipular las rutas de sistemas de archivos en Python 3


      El autor seleccionó el COVID-19 Relief Fund para que reciba una donación como parte del programa Write for DOnations.

      Introducción

      Python 3 incluye el módulo pathlib para manipular rutas de sistemas de archivos de forma agnóstica en cualquier sistema operativo. El módulo pathlib es similar al os.path, pero pathlib ofrece una interfaz de nivel más alto, y, a menudo, más conveniente, que os.path.

      Podemos identificar archivos en una computadora con rutas jerárquicas. Por ejemplo, podemos identificar el archivo wave.txt en una computadora con esta ruta: /Users/sammy/ocean/wave.txt. Cada sistema operativo tiene una manera ligeramente distinta de representar rutas. Windows puede representar la ruta al archivo wave.txt de la siguiente manera: C:Userssammyoceanwave.txt.

      El módulo pathlib le puede resultar útil si desea a crear o mover archivos en el sistema de archivos de su programa de Python, enumerar los archivos del sistema de archivos que coincidan con una extensión o un patrón determinado o crear rutas de archivos apropiadas para el sistema operativo basadas en colecciones de cadenas sin procesar. Si bien es posible usar otras herramientas (como el módulo os.path) para realizar muchas de estas tareas, el módulo pathlib le permite realizar estas operaciones con un alto grado de legibilidad y una cantidad de código mínima.

      En este tutorial, revisaremos algunas de las maneras de usar el módulo pathlib para representar y manipular las rutas de los sistemas de archivos.

      Requisitos previos

      Para sacar el máximo provecho de este tutorial, se recomienda tener cierta familiaridad con la programación en Python 3. Puede consultar estos tutoriales para obtener la información de fondo necesaria:

      Cómo crear instancias Path

      El módulo pathlib proporciona varias clases, pero una de las más importantes es la clase Path. Las instancias de la clase Path representan una ruta a un archivo o un directorio en el sistema de archivos de nuestra computadora.

      Por ejemplo, el siguiente código inicia una instancia Path que representa una parte de la ruta a un archivo wave.txt:

      from pathlib import Path
      
      wave = Path("ocean", "wave.txt")
      print(wave)
      

      Si ejecutamos este código, obtendremos un resultado como el siguiente:

      Output

      ocean/wave.txt

      from pathlib import Path permite que la clase Path esté disponible en nuestro programa. Luego, Path("ocean", "wave.txt") crea una instancia de Path nueva. El resultado muestra que Python ha añadido el separador / adecuado del sistema operativo entre los dos componentes de la ruta que le proporcionamos: "ocean" y "wave.txt".

      Nota: Sus resultados pueden diferir ligeramente de los que se muestran como ejemplo en este tutorial en función del sistema operativo que utilice. Si utiliza Windows, por ejemplo, su resultado para este primer ejemplo puede tener este aspecto: oceanwave.txt.

      Actualmente, el objeto Path asignado a la variable wave contiene una ruta relativa. En otras palabras, ocean/wave.txt puede existir en varias ubicaciones de nuestro sistema de archivos. Por ejemplo, puede estar presente en /Users/user_1/ocean/wave.txt o /Users/user_2/research/ocean/wave.txt, pero no especificamos exactamente a cuál nos estamos refiriendo. Por el contrario, una ruta absoluta se refiere inequívocamente a una ubicación en el sistema de archivos.

      Puede usar Path.home() para obtener la ruta absoluta al directorio principal del usuario actual:

      home = Path.home()
      wave_absolute = Path(home, "ocean", "wave.txt")
      print(home)
      print(wave_absolute)
      

      Si ejecutamos este código, obtendremos un resultado similar al siguiente:

      Output

      /Users/sammy /Users/sammy/ocean/wave.txt

      Nota: Como se mencionó anteriormente, su resultado variará dependiendo de su sistema operativo. Por supuesto, su directorio principal también será distinto de /Users/sammy.

      Path.home() devuelve una instancia Path con una ruta absoluta al directorio principal del usuario actual. Luego, pasamos esta instancia de Path y las cadenas "ocean" y "wave.txt" a otro constructor de Path para crear una ruta absoluta al archivo wave.txt. El resultado indica que la primera línea es el directorio principal y la segunda, el directorio principal más ocean/wave.txt.

      Este ejemplo también ilustra una característica importante de la clase Path: el constructor Path acepta tanto cadenas como objetos preexistentes de Path.

      Analicemos con mayor detalle cómo es que el constructor Path admite tanto cadenas como de objetos de Path:

      shark = Path(Path.home(), "ocean", "animals", Path("fish", "shark.txt"))
      print(shark)
      

      Si ejecutamos este código de Python, obtendremos un resultado similar al siguiente:

      Output

      /Users/sammy/ocean/animals/fish/shark.txt

      shark es un Path a un archivo que construimos usando tanto objetos Path (Path.home() y Path("fish", "shark.txt")) como cadenas ("ocean" y "animals"). El constructor Path gestiona de forma inteligente ambos tipos de objetos y los une de forma correcta usando el separador correspondiente del sistema operativo, en este caso: /.

      Acceder a los atributos de los archivos

      Ahora que hemos aprendido a crear instancias de Path, vamos a repasar cómo puede usar esas instancias para acceder a información sobre un archivo.

      Podemos usar los atributos name y suffix para acceder a los nombres y los sufijos de archivos:

      wave = Path("ocean", "wave.txt")
      print(wave)
      print(wave.name)
      print(wave.suffix)
      

      Al ejecutar este código, obtendremos un resultado similar al siguiente:

      Output

      /Users/sammy/ocean/wave.txt wave.txt .txt

      Este resultado indica que el nombre del archivo al final de nuestra ruta es wave.txt y el sufijo de ese archivo es .txt.

      Las instancias de Path también ofrecen la función with_name, que le permite crear de forma sencilla un objeto Path nuevo con un nombre distinto:

      wave = Path("ocean", "wave.txt")
      tides = wave.with_name("tides.txt")
      print(wave)
      print(tides)
      

      Si ejecutamos este código, obtendremos un resultado similar al siguiente:

      ocean/wave.txt
      ocean/tides.txt
      

      El código, primero, construye una instancia Path que apunta a un archivo llamado wave.txt. Luego, invoca el método with_name en wave para devolver una segunda instancia Path que apunta a un archivo nuevo denominado tides.txt. La parte del directorio ocean/ de la ruta permanece intacta, por lo tanto, la ruta final queda establecida como ocean/tides.txt

      Acceder a antecesores

      A veces, resulta útil acceder a directorios que contienen una ruta determinada. Consideremos un ejemplo:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      print(shark)
      print(shark.parent)
      

      Si ejecutamos este código, obtendremos un resultado similar al siguiente:

      Output

      ocean/animals/fish/shark.txt ocean/animals/fish

      El atributo parent en una instancia de Path devuelve el antecesor más inmediato de una ruta de archivos determinada. En este caso, devuelve el directorio que contiene el archivo shark.txt: ocean/animals/fish.

      Podemos acceder al atributo parent varias veces seguidas para recorrer el árbol de ancestros de un archivo determinado:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      print(shark)
      print(shark.parent.parent)
      

      Si ejecutamos este código, obtendremos el siguiente resultado:

      Output

      ocean/animals/fish/shark.txt ocean/animals

      El resultado es similar al anterior, pero, ahora, hemos llegado a un nivel más alto al acceder a .parent por segunda vez. El directorio ocean/animals se encuentra dos directorios por encima de shark.txt.

      Usar Glob para enumerar archivos

      También es posible usar la clase Path para enumerar archivos usando el método glob.

      Imaginemos que tenemos una estructura de directorios similar a la siguiente:

      └── ocean
          ├── animals
          │   └── fish
          │       └── shark.txt
          ├── tides.txt
          └── wave.txt
      

      Un directorio ocean que contiene los archivos tides.txt y wave.txt. Tenemos un archivo denominado shark.txt anidado en el directorio ocean, un directorio animals y otro fish: ocean/animals/fish.

      Para enumerar todos los archivos .txt del directorio ocean, podríamos escribir lo siguiente:

      for txt_path in Path("ocean").glob("*.txt"):
          print(txt_path)
      

      Este código tendría un resultado similar al siguiente:

      Output

      ocean/wave.txt ocean/tides.txt

      El patrón glob __"*.txt" busca todos los archivos que terminan en .txt. Como el código del ejemplo ejecuta ese glob en el directorio ocean, devuelve los dos archivos .txt del directorio ocean: wave.txt y tides.txt.

      Nota: Para duplicar los resultados que se muestran en este ejemplo, copie la estructura de directorios que se ilustra aquí en su computadora.

      También podemos usar el método glob de manera recursiva. Para enumerar todos los archivos .txt del directorio ocean y todos sus subdirectorios, podemos escribir lo siguiente:

      for txt_path in Path("ocean").glob("**/*.txt"):
          print(txt_path)
      

      Al ejecutar este código, obtendríamos un resultado similar al siguiente:

      Output

      ocean/wave.txt ocean/tides.txt ocean/animals/fish/shark.txt

      La sección ** del patrón glob coincidirá con este directorio y todos sus subdirectorios de manera recursiva. Por tanto, no solo tenemos los archivos wave.txt y tides.txt en el resultado, sino que también recibimos el archivo shark.txt que estaba anidado en ocean/animals/fish.

      Calcular rutas relativas

      Podemos usar el método Path.relative_to para calcular rutas relacionadas entre sí. El método relative_to es útil cuando, por ejemplo, se desea recuperar una porción de una ruta de archivos larga.

      Analice el siguiente código:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      below_ocean = shark.relative_to(Path("ocean"))
      below_animals = shark.relative_to(Path("ocean", "animals"))
      print(shark)
      print(below_ocean)
      print(below_animals)
      

      Si ejecutamos este código, obtendremos un resultado similar al siguiente:

      Output

      ocean/animals/fish/shark.txt animals/fish/shark.txt fish/shark.txt

      El método relative_to devuelve un nuevo objeto Path relacionado con el argumento determinado. En nuestro ejemplo, calculamos el Path a shark.txt en relación con el directorio ocean y, luego, en relación con los directorios ocean y animals.

      Si relative_to no puede calcular una respuesta porque le indicamos una ruta no relacionada, presenta un ValueError:

      shark = Path("ocean", "animals", "fish", "shark.txt")
      shark.relative_to(Path("unrelated", "path"))
      

      Obtendremos una excepción ValueError generada a partir de este código que será similar a la siguiente:

      Output

      Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/usr/local/lib/Python3.8/pathlib.py", line 899, in relative_to raise ValueError("{!r} does not start with {!r}" ValueError: 'ocean/animals/fish/shark.txt' does not start with 'unrelated/path'

      unrelated/path no forma parte de ocean/animals/fish/shark.txt, por lo tanto, Python no puede calcular una ruta relativa.

      Conclusión

      El módulo pathlib es un componente importante de la biblioteca estándar de Python que nos permite manipular rutas de sistemas de archivos de forma rápida en cualquier sistema operativo. En este tutorial, ha aprendido a usar algunas de las herramientas clave de pathlib para acceder a los atributos de archivos, enumerar archivos con patrones glob y desplazarse por archivos y directorios principales.

      El módulo pathlib expone clases y utilidades adicionales que no abarcamos en este tutorial. Ahora que tiene una referencia, puede usar la documentación del módulo pathlib para obtener más información sobre otras clases y utilidades disponibles.

      Si está interesado en utilizar otras bibliotecas de Python, consulte los siguientes tutoriales:



      Source link