Terminal (1/3): navegação, arquivos e comandos

12 de setembro de 2021

Aviso: Este post foi traduzido para o português usando um modelo de tradução automática. Por favor, me avise se encontrar algum erro.

📚 **Esta entrada faz parte da série _Introdução ao terminal_**, dividida em três capítulos que se leem em ordem:

> * 👉 **Parte 1: Navegação, arquivos e comandos**

* Parte 2: Rede, compressão e processos

* Parte 3: Administração do sistema

Formato do post

Para não ter que ficar colocando imagens do console em cada ação que eu fizer, criei a seguinte função que recebe o comando do terminal que queremos executar e devolve a saída que o terminal nos daria.

Algumas vezes vou usar essa função, e outras vou usar ! antes de cada comando, que em notebooks quer dizer que você vai executar um comando do terminal.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		import subprocess
import os
 
last_directory = ''
 
def terminal(command, max_lines_output=None):
    global last_directory
    debug = False
    str = command.split()
 
    # Check if there are " or ' characters
    for i in range(len(str)):
        if debug: print(f"i = {i}, str[i] = {str[i]}")
        if len(str[i]) &gt; 0:
            if str[i][0] == '"' or str[i][0] == "'":
                for j in range(i+1,len(str)):
                    if debug: print(f"	 j = {j}, str[j] = {str[j]}")
                    if str[j][-1] == '"' or str[j][-1] == "'":
                        for k in range(i+1,j+1):
                            if debug: print(f"		 k = {k}, str[i] = {str[i]}, str[k] = {str[k]}")
                            str[i] = str[i] + " " + str[k]
                            if debug: print(f"		 k = {k}, str[i] = {str[i]}, str[k] = {str[k]}")
                        str[j:] = [""]
                        str[i] = str[i].replace('"','')
    
    # Remove empty strings
    str = [x for x in str if x != ""]
    if debug:
        print(str)
        return
    if str[0] == "cd":
        last_dir = os.getcwd()
        if len(str) == 1:
            os.chdir('/home/wallabot')
        else:
            if str[1] == "-":
                os.chdir(last_directory)
            else:
                os.chdir(str[1])
        last_directory = last_dir
    else:
        result = subprocess.run(str, stdout=subprocess.PIPE).stdout.decode('utf-8')
        if max_lines_output is not None:
            result_split = result.split('
')
            print('
'.join(result_split[:max_lines_output]))
            print("	 ...")
            print('
'.join(result_split[-5:]))
        else:
            print(result)
	
	Copied

Primeiros comandos para se mover pelo terminal

`ls` (listar diretório)

O primeiro comando que vamos a ver é ls (list directory), que serve para listar todos os arquivos da pasta em que estivermos.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("ls")
	
	Copied

>_ Output

			
				2021-02-11-Introduccion-a-Python.ipynb
2021-04-23-Calculo-matricial-con-Numpy.ipynb
2021-06-15-Manejo-de-datos-con-Pandas.ipynb
2022-09-12 Introduccion a la terminal.ipynb
2022-09-12 Introduccion a la terminal.txt
command-line-cheat-sheet.pdf
CSS.ipynb
Docker.html
Docker.ipynb
Expresiones regulares.html
Expresiones regulares.ipynb
html_files
html.ipynb
introduccion_python
movies.csv
movies.dat
notebooks_translated
__pycache__
ssh.ipynb
test.html
test.ipynb

Os comandos normalmente podem receber opções (flags), que são introduzidas com o carácter -, por exemplo, vejamos ls -l, que nos devolve a lista de ficheiros do diretório em que estamos, mas com mais informação

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('ls -l')
	
	Copied

>_ Output

			
				total 4512
-rw-rw-r-- 1 wallabot wallabot 285898 nov 12 02:07 2021-02-11-Introduccion-a-Python.ipynb
-rw-rw-r-- 1 wallabot wallabot  78450 nov 13 00:10 2021-04-23-Calculo-matricial-con-Numpy.ipynb
-rw-rw-r-- 1 wallabot wallabot 484213 nov 13 00:44 2021-06-15-Manejo-de-datos-con-Pandas.ipynb
-rw-rw-r-- 1 wallabot wallabot 320810 dic  6 00:11 2022-09-12 Introduccion a la terminal.ipynb
-rw-rw-r-- 1 wallabot wallabot 320594 dic  6 00:04 2022-09-12 Introduccion a la terminal.txt
-rw-rw-r-- 1 wallabot wallabot 119471 oct  3 16:13 command-line-cheat-sheet.pdf
-rw-rw-r-- 1 wallabot wallabot   2660 sep 18 03:32 CSS.ipynb
-rw-rw-r-- 1 wallabot wallabot 699225 nov 27 04:16 Docker.html
-rw-rw-r-- 1 wallabot wallabot 509125 sep 22 16:48 Docker.ipynb
-rw-rw-r-- 1 wallabot wallabot 156193 nov 27 04:21 Expresiones regulares.html
-rw-rw-r-- 1 wallabot wallabot  53094 oct  2 04:57 Expresiones regulares.ipynb
drwxrwxr-x 2 wallabot wallabot   4096 nov 28 14:39 html_files
-rw-rw-r-- 1 wallabot wallabot  14775 sep 18 03:29 html.ipynb
drwxrwxr-x 3 wallabot wallabot   4096 nov 12 01:51 introduccion_python
-rw-rw-r-- 1 wallabot wallabot 446172 oct  2 04:39 movies.csv
-rw-rw-r-- 1 wallabot wallabot 522197 oct  2 04:33 movies.dat
drwxrwxr-x 2 wallabot wallabot   4096 nov 28 14:39 notebooks_translated
drwxrwxr-x 2 wallabot wallabot   4096 ago 27 03:25 __pycache__
-rw-rw-r-- 1 wallabot wallabot    586 dic  4 02:31 ssh.ipynb
-rw-rw-r-- 1 wallabot wallabot 292936 nov  9 01:46 test.html
-rw-rw-r-- 1 wallabot wallabot 260227 nov  9 01:13 test.ipynb

Como vemos, temos quantos bytes ocupa cada arquivo, mas quando temos arquivos que ocupam muito, isso não é muito fácil de ler, então podemos adicionar a opção h (human) que nos dá informação mais fácil de ler

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('ls -lh')
	
	Copied

>_ Output

			
				total 4,5M
-rw-rw-r-- 1 wallabot wallabot 280K nov 12 02:07 2021-02-11-Introduccion-a-Python.ipynb
-rw-rw-r-- 1 wallabot wallabot  77K nov 13 00:10 2021-04-23-Calculo-matricial-con-Numpy.ipynb
-rw-rw-r-- 1 wallabot wallabot 473K nov 13 00:44 2021-06-15-Manejo-de-datos-con-Pandas.ipynb
-rw-rw-r-- 1 wallabot wallabot 314K dic  6 00:11 2022-09-12 Introduccion a la terminal.ipynb
-rw-rw-r-- 1 wallabot wallabot 314K dic  6 00:04 2022-09-12 Introduccion a la terminal.txt
-rw-rw-r-- 1 wallabot wallabot 117K oct  3 16:13 command-line-cheat-sheet.pdf
-rw-rw-r-- 1 wallabot wallabot 2,6K sep 18 03:32 CSS.ipynb
-rw-rw-r-- 1 wallabot wallabot 683K nov 27 04:16 Docker.html
-rw-rw-r-- 1 wallabot wallabot 498K sep 22 16:48 Docker.ipynb
-rw-rw-r-- 1 wallabot wallabot 153K nov 27 04:21 Expresiones regulares.html
-rw-rw-r-- 1 wallabot wallabot  52K oct  2 04:57 Expresiones regulares.ipynb
drwxrwxr-x 2 wallabot wallabot 4,0K nov 28 14:39 html_files
-rw-rw-r-- 1 wallabot wallabot  15K sep 18 03:29 html.ipynb
drwxrwxr-x 3 wallabot wallabot 4,0K nov 12 01:51 introduccion_python
-rw-rw-r-- 1 wallabot wallabot 436K oct  2 04:39 movies.csv
-rw-rw-r-- 1 wallabot wallabot 510K oct  2 04:33 movies.dat
drwxrwxr-x 2 wallabot wallabot 4,0K nov 28 14:39 notebooks_translated
drwxrwxr-x 2 wallabot wallabot 4,0K ago 27 03:25 __pycache__
-rw-rw-r-- 1 wallabot wallabot  586 dic  4 02:31 ssh.ipynb
-rw-rw-r-- 1 wallabot wallabot 287K nov  9 01:46 test.html
-rw-rw-r-- 1 wallabot wallabot 255K nov  9 01:13 test.ipynb

Se quisermos ver os arquivos ocultos, podemos usar a opção a, que nos mostrará todos os arquivos de um diretório.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('ls -lha')
	
	Copied

>_ Output

			
				total 4,5M
drwxrwxr-x 6 wallabot wallabot 4,0K dic  6 00:04 .
drwxrwxr-x 5 wallabot wallabot 4,0K oct  2 03:10 ..
-rw-rw-r-- 1 wallabot wallabot 280K nov 12 02:07 2021-02-11-Introduccion-a-Python.ipynb
-rw-rw-r-- 1 wallabot wallabot  77K nov 13 00:10 2021-04-23-Calculo-matricial-con-Numpy.ipynb
-rw-rw-r-- 1 wallabot wallabot 473K nov 13 00:44 2021-06-15-Manejo-de-datos-con-Pandas.ipynb
-rw-rw-r-- 1 wallabot wallabot 314K dic  6 00:11 2022-09-12 Introduccion a la terminal.ipynb
-rw-rw-r-- 1 wallabot wallabot 314K dic  6 00:04 2022-09-12 Introduccion a la terminal.txt
-rw-rw-r-- 1 wallabot wallabot 117K oct  3 16:13 command-line-cheat-sheet.pdf
-rw-rw-r-- 1 wallabot wallabot 2,6K sep 18 03:32 CSS.ipynb
-rw-rw-r-- 1 wallabot wallabot 683K nov 27 04:16 Docker.html
-rw-rw-r-- 1 wallabot wallabot 498K sep 22 16:48 Docker.ipynb
-rw-rw-r-- 1 wallabot wallabot 153K nov 27 04:21 Expresiones regulares.html
-rw-rw-r-- 1 wallabot wallabot  52K oct  2 04:57 Expresiones regulares.ipynb
drwxrwxr-x 2 wallabot wallabot 4,0K nov 28 14:39 html_files
-rw-rw-r-- 1 wallabot wallabot  15K sep 18 03:29 html.ipynb
drwxrwxr-x 3 wallabot wallabot 4,0K nov 12 01:51 introduccion_python
-rw-rw-r-- 1 wallabot wallabot 436K oct  2 04:39 movies.csv
-rw-rw-r-- 1 wallabot wallabot 510K oct  2 04:33 movies.dat
drwxrwxr-x 2 wallabot wallabot 4,0K nov 28 14:39 notebooks_translated
drwxrwxr-x 2 wallabot wallabot 4,0K ago 27 03:25 __pycache__
-rw-rw-r-- 1 wallabot wallabot  586 dic  4 02:31 ssh.ipynb
-rw-rw-r-- 1 wallabot wallabot 287K nov  9 01:46 test.html
-rw-rw-r-- 1 wallabot wallabot 255K nov  9 01:13 test.ipynb

Se o que queremos é que ele os ordene por tamanho, podemos usar a opção S

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('ls -lhS')
	
	Copied

>_ Output

			
				total 4,5M
-rw-rw-r-- 1 wallabot wallabot 683K nov 27 04:16 Docker.html
-rw-rw-r-- 1 wallabot wallabot 510K oct  2 04:33 movies.dat
-rw-rw-r-- 1 wallabot wallabot 498K sep 22 16:48 Docker.ipynb
-rw-rw-r-- 1 wallabot wallabot 473K nov 13 00:44 2021-06-15-Manejo-de-datos-con-Pandas.ipynb
-rw-rw-r-- 1 wallabot wallabot 436K oct  2 04:39 movies.csv
-rw-rw-r-- 1 wallabot wallabot 314K dic  6 00:11 2022-09-12 Introduccion a la terminal.ipynb
-rw-rw-r-- 1 wallabot wallabot 314K dic  6 00:04 2022-09-12 Introduccion a la terminal.txt
-rw-rw-r-- 1 wallabot wallabot 287K nov  9 01:46 test.html
-rw-rw-r-- 1 wallabot wallabot 280K nov 12 02:07 2021-02-11-Introduccion-a-Python.ipynb
-rw-rw-r-- 1 wallabot wallabot 255K nov  9 01:13 test.ipynb
-rw-rw-r-- 1 wallabot wallabot 153K nov 27 04:21 Expresiones regulares.html
-rw-rw-r-- 1 wallabot wallabot 117K oct  3 16:13 command-line-cheat-sheet.pdf
-rw-rw-r-- 1 wallabot wallabot  77K nov 13 00:10 2021-04-23-Calculo-matricial-con-Numpy.ipynb
-rw-rw-r-- 1 wallabot wallabot  52K oct  2 04:57 Expresiones regulares.ipynb
-rw-rw-r-- 1 wallabot wallabot  15K sep 18 03:29 html.ipynb
drwxrwxr-x 2 wallabot wallabot 4,0K nov 28 14:39 html_files
drwxrwxr-x 3 wallabot wallabot 4,0K nov 12 01:51 introduccion_python
drwxrwxr-x 2 wallabot wallabot 4,0K nov 28 14:39 notebooks_translated
drwxrwxr-x 2 wallabot wallabot 4,0K ago 27 03:25 __pycache__
-rw-rw-r-- 1 wallabot wallabot 2,6K sep 18 03:32 CSS.ipynb
-rw-rw-r-- 1 wallabot wallabot  586 dic  4 02:31 ssh.ipynb

Se quisermos que ele nos mostre os arquivos ordenados alfabeticamente, mas ao contrário, devemos usar a opção -r

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('ls -lhr')
	
	Copied

>_ Output

			
				total 4,5M
-rw-rw-r-- 1 wallabot wallabot 255K nov  9 01:13 test.ipynb
-rw-rw-r-- 1 wallabot wallabot 287K nov  9 01:46 test.html
-rw-rw-r-- 1 wallabot wallabot  586 dic  4 02:31 ssh.ipynb
drwxrwxr-x 2 wallabot wallabot 4,0K ago 27 03:25 __pycache__
drwxrwxr-x 2 wallabot wallabot 4,0K nov 28 14:39 notebooks_translated
-rw-rw-r-- 1 wallabot wallabot 510K oct  2 04:33 movies.dat
-rw-rw-r-- 1 wallabot wallabot 436K oct  2 04:39 movies.csv
drwxrwxr-x 3 wallabot wallabot 4,0K nov 12 01:51 introduccion_python
-rw-rw-r-- 1 wallabot wallabot  15K sep 18 03:29 html.ipynb
drwxrwxr-x 2 wallabot wallabot 4,0K nov 28 14:39 html_files
-rw-rw-r-- 1 wallabot wallabot  52K oct  2 04:57 Expresiones regulares.ipynb
-rw-rw-r-- 1 wallabot wallabot 153K nov 27 04:21 Expresiones regulares.html
-rw-rw-r-- 1 wallabot wallabot 498K sep 22 16:48 Docker.ipynb
-rw-rw-r-- 1 wallabot wallabot 683K nov 27 04:16 Docker.html
-rw-rw-r-- 1 wallabot wallabot 2,6K sep 18 03:32 CSS.ipynb
-rw-rw-r-- 1 wallabot wallabot 117K oct  3 16:13 command-line-cheat-sheet.pdf
-rw-rw-r-- 1 wallabot wallabot 314K dic  6 00:04 2022-09-12 Introduccion a la terminal.txt
-rw-rw-r-- 1 wallabot wallabot 314K dic  6 00:11 2022-09-12 Introduccion a la terminal.ipynb
-rw-rw-r-- 1 wallabot wallabot 473K nov 13 00:44 2021-06-15-Manejo-de-datos-con-Pandas.ipynb
-rw-rw-r-- 1 wallabot wallabot  77K nov 13 00:10 2021-04-23-Calculo-matricial-con-Numpy.ipynb
-rw-rw-r-- 1 wallabot wallabot 280K nov 12 02:07 2021-02-11-Introduccion-a-Python.ipynb

`cd` (mudar de diretório)

O segundo comando será cd (change directory), que nos permite mudar de diretório

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('cd /home/wallabot/Documentos/')
	
	Copied

Se agora voltarmos a usar ls para ver os arquivos que temos, vemos que mudam

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('ls')
	
	Copied

>_ Output

			
				aprendiendo-git.pdf
balena-etcher-electron-1.7.9-linux-x64
camerasIP
Documentacion
gstreamer
gstreamer_old
jetsonNano
kaggle
Libros
nerf
prueba.txt
pytorch
wallabot
web

Se a cd, em vez de lhe darmos o diretório para o qual queremos nos mover, lhe damos o caractere -, ele voltará ao diretório anterior onde estava

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('cd -')
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('ls')
	
	Copied

>_ Output

			
				2021-02-11-Introduccion-a-Python.ipynb
2021-04-23-Calculo-matricial-con-Numpy.ipynb
2021-06-15-Manejo-de-datos-con-Pandas.ipynb
2022-09-12 Introduccion a la terminal.ipynb
2022-09-12 Introduccion a la terminal.txt
command-line-cheat-sheet.pdf
CSS.ipynb
Docker.html
Docker.ipynb
Expresiones regulares.html
Expresiones regulares.ipynb
html_files
html.ipynb
introduccion_python
movies.csv
movies.dat
notebooks_translated
__pycache__
ssh.ipynb
test.html
test.ipynb

Se quisermos ir para a home introduzindo apenas cd no terminal, ele nos levará.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('cd')
	
	Copied

`pwd` (imprimir diretório de trabalho)

Para obter o diretório em que estamos, podemos usar pwd (print working directory)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('pwd')
	
	Copied

>_ Output

			
				/home/wallabot

Podemos nos mover usando o comando cd por meio de caminhos relativos e por meio de caminhos absolutos. Por exemplo, vamos nos mover para um diretório por meio de um caminho absoluto.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('cd /home/wallabot/Documentos/')
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('pwd')
	
	Copied

>_ Output

			
				/home/wallabot/Documentos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('ls')
	
	Copied

>_ Output

			
				aprendiendo-git.pdf
balena-etcher-electron-1.7.9-linux-x64
camerasIP
Documentacion
gstreamer
gstreamer_old
jetsonNano
kaggle
Libros
nerf
prueba.txt
pytorch
wallabot
web

Podemos nos mover usando rotas relativas se apenas colocarmos a direção a partir do ponto em que nos encontramos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('cd web')
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('pwd')
	
	Copied

>_ Output

			
				/home/wallabot/Documentos/web

Também, por meio de rotas relativas, podemos subir um diretório usando ..

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('cd ..')
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('pwd')
	
	Copied

>_ Output

			
				/home/wallabot/Documentos

Se em vez de .. colocarmos ., estamos nos referindo ao diretório em que nos encontramos agora mesmo, ou seja, se colocarmos cd . não nos moveremos, já que estamos dizendo ao terminal para ir ao diretório em que estamos.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('cd .')
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('pwd')
	
	Copied

>_ Output

			
				/home/wallabot/Documentos

Vamos nos mover para um caminho em que tenhamos arquivos para mostrar o seguinte comando

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('cd web/portafolio/posts/')
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('ls')
	
	Copied

>_ Output

			
				2021-02-11-Introduccion-a-Python.ipynb
2021-04-23-Calculo-matricial-con-Numpy.ipynb
2021-06-15-Manejo-de-datos-con-Pandas.ipynb
2022-09-12 Introduccion a la terminal.ipynb
2022-09-12 Introduccion a la terminal.txt
command-line-cheat-sheet.pdf
CSS.ipynb
Docker.html
Docker.ipynb
Expresiones regulares.html
Expresiones regulares.ipynb
html_files
html.ipynb
introduccion_python
movies.csv
movies.dat
notebooks_translated
__pycache__
ssh.ipynb
test.html
test.ipynb

Informações de arquivos com `file`

Se eu não souber que tipo de arquivo é um em particular, por meio do comando file posso obter uma descrição

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('file 2021-02-11-Introduccion-a-Python.ipynb')
	
	Copied

>_ Output

			
				2021-02-11-Introduccion-a-Python.ipynb: UTF-8 Unicode text, with very long lines

Manipulando arquivos e diretórios

Vamos primeiro para a página inicial.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('cd /home/wallabot/Documentos/')
	
	Copied

Árvore de diretórios com `tree`

Podemos ver toda a estrutura da pasta em que estamos por meio do comando tree

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('tree', max_lines_output=20)
	
	Copied

>_ Output

			
				.
├── aprendiendo-git.pdf
├── balena-etcher-electron-1.7.9-linux-x64
│   └── balenaEtcher-1.7.9-x64.AppImage
├── camerasIP
│   ├── camerasIP.py
│   ├── camerasIP.sh
│   ├── config.py
│   ├── __pycache__
│   │   ├── config.cpython-38.pyc
│   │   └── config.cpython-39.pyc
│   └── README.md
├── Documentacion
│   ├── Curriculum Vitae (5).pdf
│   ├── Firma Pris.PNG
│   └── Firma.png
├── gstreamer
│   ├── basic_tutorial_c
│   │   ├── basic_tutorial_1_hello_world
│   │   │   ├── basic-tutorial-1
...
        ├── upload_page.py
        └── utils.py
873 directories, 119679 files

Mas na saída temos linhas demais, e isso porque tree é um comando que mostra todos os arquivos a partir do caminho em que estamos, então é um pouco difícil de ler. No entanto, com a opção L podemos indicar em quantos níveis queremos que ele aprofunde

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('tree -L 2')
	
	Copied

>_ Output

			
				.
├── aprendiendo-git.pdf
├── balena-etcher-electron-1.7.9-linux-x64
│   └── balenaEtcher-1.7.9-x64.AppImage
├── camerasIP
│   ├── camerasIP.py
│   ├── camerasIP.sh
│   ├── config.py
│   ├── __pycache__
│   └── README.md
├── Documentacion
│   ├── Curriculum Vitae (5).pdf
│   ├── Firma Pris.PNG
│   └── Firma.png
├── gstreamer
│   ├── basic_tutorial_c
│   └── README.md
├── gstreamer_old
│   ├── basic_tutorial_c
│   └── basic_tutorial_python
...
├── wallabot
│   ├── Microfono - Blue Yeti X
│   ├── placa base - Asus prime x570-p
│   └── Silla - Corsair T3 Rush
└── web
    ├── jupyter-to-html
    ├── jupyter-translator
    ├── portafolio
    └── wordpress_api_rest
30 directories, 12 files

Podemos ver que mostra que há 30 diretórios e 12 arquivos, enquanto antes indicava 873 diretórios e 119679 arquivos

Criar pastas com `mkdir` (make directory)

Se quisermos criar um novo diretório, podemos usar o comando mkdir (make directory) e um nome

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cd /home/wallabot/Documentos/web/portafolio/posts/")
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('mkdir prueba')
	
	Copied

>_ Output

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('ls')
	
	Copied

>_ Output

			
				2021-02-11-Introduccion-a-Python.ipynb
2021-04-23-Calculo-matricial-con-Numpy.ipynb
2021-06-15-Manejo-de-datos-con-Pandas.ipynb
2022-09-12 Introduccion a la terminal.ipynb
2022-09-12 Introduccion a la terminal.txt
command-line-cheat-sheet.pdf
CSS.ipynb
Docker.html
Docker.ipynb
Expresiones regulares.html
Expresiones regulares.ipynb
html_files
html.ipynb
introduccion_python
movies.csv
movies.dat
notebooks_translated
prueba
__pycache__
ssh.ipynb
test.html
test.ipynb

Se o que queremos é criar um diretório com espaços no nome, temos que colocar o nome entre aspas.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('mkdir "directorio prueba"')
	
	Copied

>_ Output

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('ls')
	
	Copied

>_ Output

			
				2021-02-11-Introduccion-a-Python.ipynb
2021-04-23-Calculo-matricial-con-Numpy.ipynb
2021-06-15-Manejo-de-datos-con-Pandas.ipynb
2022-09-12 Introduccion a la terminal.ipynb
2022-09-12 Introduccion a la terminal.txt
command-line-cheat-sheet.pdf
CSS.ipynb
directorio prueba
Docker.html
Docker.ipynb
Expresiones regulares.html
Expresiones regulares.ipynb
html_files
html.ipynb
introduccion_python
movies.csv
movies.dat
notebooks_translated
prueba
__pycache__
ssh.ipynb
test.html
test.ipynb

Vamos a entrar na pasta prueba que criámos, para continuar a ver ali o terminal

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cd prueba")
	
	Copied

Criar arquivos com `touch`

No caso de querermos criar um arquivo, o comando que temos que usar é touch

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("touch prueba.txt")
	
	Copied

>_ Output

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("ls")
	
	Copied

>_ Output

			
				prueba.txt

Copiar arquivos com `cp` (copy)

Se quisermos copiar um arquivo, fazemos isso por meio do comando cp (copy)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cp prueba.txt prueba_copy.txt")
	
	Copied

>_ Output

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("ls")
	
	Copied

>_ Output

			
				prueba_copy.txt
prueba.txt

Mover arquivos com `mv` (move)

Se o que queremos é movê-lo, o que usamos é o comando mv (move)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("mv prueba.txt ../prueba.txt")
	
	Copied

>_ Output

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("ls")
	
	Copied

>_ Output

			
				prueba_copy.txt

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("ls ../")
	
	Copied

>_ Output

			
				2021-02-11-Introduccion-a-Python.ipynb
2021-04-23-Calculo-matricial-con-Numpy.ipynb
2021-06-15-Manejo-de-datos-con-Pandas.ipynb
2022-09-12 Introduccion a la terminal.ipynb
2022-09-12 Introduccion a la terminal.txt
command-line-cheat-sheet.pdf
CSS.ipynb
directorio prueba
Docker.html
Docker.ipynb
Expresiones regulares.html
Expresiones regulares.ipynb
html_files
html.ipynb
introduccion_python
movies.csv
movies.dat
notebooks_translated
prueba
prueba.txt
__pycache__
ssh.ipynb
test.html
test.ipynb

Renomear arquivos com `mv` (move)

O comando mv também nos serve para renomear arquivos, já que, se o que fazemos é movê-lo no mesmo diretório, mas dando a ele outro nome, no final isso é renomear o arquivo.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("mv prueba_copy.txt prueba_move.txt")
	
	Copied

>_ Output

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("ls")
	
	Copied

>_ Output

			
				prueba_move.txt

Excluir arquivos com `rm` (remove)

Para apagar arquivos ou diretórios, usamos o comando rm (remove)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("rm prueba_move.txt")
	
	Copied

>_ Output

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("ls")
	
	Copied

>_ Output

Eliminar diretórios com `rm -r` (remove recursive)

Se o que queremos é eliminar um diretório com arquivos dentro, devemos usar a flag -r.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cd ..")
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal('rm -r "directorio prueba"')
	
	Copied

>_ Output

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("ls")
	
	Copied

>_ Output

			
				2021-02-11-Introduccion-a-Python.ipynb
2021-04-23-Calculo-matricial-con-Numpy.ipynb
2021-06-15-Manejo-de-datos-con-Pandas.ipynb
2022-09-12 Introduccion a la terminal.ipynb
2022-09-12 Introduccion a la terminal.txt
command-line-cheat-sheet.pdf
CSS.ipynb
Docker.html
Docker.ipynb
Expresiones regulares.html
Expresiones regulares.ipynb
html_files
html.ipynb
introduccion_python
movies.csv
movies.dat
notebooks_translated
prueba
prueba.txt
__pycache__
ssh.ipynb
test.html
test.ipynb

Como você pode ver, ele nunca pergunta se estamos seguros; para que pergunte, é preciso adicionar a flag -i (interactive)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("rm -i prueba.txt")
	
	Copied

>_ Output

			
				rm: ¿borrar el fichero regular vacío 'prueba.txt'? (s/n) s

Sincronizar arquivos mediante `rsync`

Até agora vimos como copiar, mover e eliminar arquivos, mas suponhamos que temos uma pasta e copiamos esses arquivos para outra. Agora suponhamos que modificamos um arquivo da primeira pasta e queremos que a segunda tenha as alterações. Temos duas opções: copiar todos os arquivos novamente ou fazer uma sincronização usando rsync

Primeiro vamos criar uma nova pasta na qual criamos vários arquivos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!mkdir sourcefolder
!touch sourcefolder/file1 sourcefolder/file2 sourcefolder/file3
	
	Copied

Agora criamos uma segunda pasta, que é a que vamos sincronizar com a primeira

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!mkdir syncfolder
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!echo "ls sourcefolder:" && ls sourcefolder && echo "ls syncfolder:" && ls syncfolder
	
	Copied

>_ Output

			
				ls sourcefolder:
file1  file2  file3
ls syncfolder:

Sincronizamos as duas pastas com rsync, na primeira vez ele apenas copiará os arquivos da primeira pasta para a segunda. Para fazer isso, além disso devemos adicionar a flag -r (recursive)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!rsync -r sourcefolder/ syncfolder/
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!echo "ls sourcefolder:" && ls sourcefolder && echo "ls syncfolder:" && ls syncfolder
	
	Copied

>_ Output

			
				ls sourcefolder:
file1  file2  file3
ls syncfolder:
file1  file2  file3

Se agora eu crio um novo arquivo em sourcefolder e sincronizo novamente, apenas esse arquivo é copiado para syncfolder. Para ver que apenas um arquivo é copiado, podemos usar a flag -v (verbose)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!touch sourcefolder/file4
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!rsync -r -v sourcefolder/ syncfolder/
	
	Copied

>_ Output

			
				sending incremental file list
file1
file2
file3
file4
sent 269 bytes  received 92 bytes  722.00 bytes/sec
total size is 0  speedup is 0.00

Mas parece que ele copiou todos os arquivos, então para que isso não aconteça e copie apenas os que foram modificados, é preciso usar a flag -u

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!touch sourcefolder/file5
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!rsync -r -v -u sourcefolder/ syncfolder/
	
	Copied

>_ Output

			
				sending incremental file list
file5
sent 165 bytes  received 35 bytes  400.00 bytes/sec
total size is 0  speedup is 0.00

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!echo "ls sourcefolder:" && ls sourcefolder && echo "ls syncfolder:" && ls syncfolder
	
	Copied

>_ Output

			
				ls sourcefolder:
file1  file2  file3  file4  file5
ls syncfolder:
file1  file2  file3  file4  file5

E o que acontece se eu criar um novo arquivo em syncfolder?

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!touch syncfolder/file6
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!rsync -r -v -u sourcefolder/ syncfolder/
	
	Copied

>_ Output

			
				sending incremental file list
sent 122 bytes  received 12 bytes  268.00 bytes/sec
total size is 0  speedup is 0.00

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!echo "ls sourcefolder:" && ls sourcefolder && echo "ls syncfolder:" && ls syncfolder
	
	Copied

>_ Output

			
				ls sourcefolder:
file1  file2  file3  file4  file5
ls syncfolder:
file1  file2  file3  file4  file5  file6

Não sincroniza, então é importante ter isso em conta

Algumas flags importantes que devem ser levadas em conta são:

-a: Este flag é um atalho para várias opções, incluindo -r (recursivo), -l (copiar links simbólicos), -p (manter permissões), -t (manter a hora de modificação) e -g (manter grupo). Esta opção é útil para fazer uma cópia exata de um diretório, incluindo todas as suas subpastas e arquivos.
-v: Este sinal ativa a saída detalhada, que mostra os arquivos que estão sendo copiados e o progresso da operação.
-r: Este flag é utilizado para copiar de forma recursiva, o que significa que copia todas as subpastas e arquivos dentro de um diretório.
-u: Este flag é utilizado para copiar apenas os arquivos novos ou modificados. Se um arquivo já existe no destino e é mais recente que o arquivo de origem, ele não é copiado.* -n: Este sinal é usado para fazer um teste de cópia, o que significa que nenhuma alteração é feita no destino.
--exclude: Este flag é utilizado para excluir arquivos ou pastas específicos da operação de cópia. Você pode especificar vários arquivos ou pastas para excluir usando esta opção várias vezes.
-z: Este flag é usado para comprimir os dados durante a transferência, o que reduz a largura de banda utilizada e acelera a velocidade de transferência.
-h: este sinalizador é usado para mostrar a informação em um formato mais legível, especialmente ao trabalhar com grandes quantidades de dados ou tamanhos de arquivos grandes.

Apagamos as duas pastas criadas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!rm -r sourcefolder syncfolder
	
	Copied

Explorando o conteúdo dos arquivos

Para não ter que abrir um arquivo a partir de uma interface gráfica, temos várias formas. Vou copiar um arquivo de texto para esta pasta primeiro.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cd prueba")
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cp ../2021-02-11-Introduccion-a-Python.ipynb .")
	
	Copied

>_ Output

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("ls")
	
	Copied

>_ Output

			
				2021-02-11-Introduccion-a-Python.ipynb

Cabeçalho de arquivos com `head`

O primeiro comando para poder ver dentro de um arquivo de texto é head, que nos permite ver as primeiras 10 linhas de um arquivo, mas se for adicionado o flag -n você pode indicar o número de linhas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("head 2021-02-11-Introduccion-a-Python.ipynb")
	
	Copied

>_ Output

			
				{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dsaKCKL0IxZl"
      },
      "source": [
        "# Introducción a Python"
      ]

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("head -n 5 2021-02-11-Introduccion-a-Python.ipynb")
	
	Copied

>_ Output

			
				{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {

Calda de um arquivo com `tail`

No caso de querer ver as últimas linhas, usamos tail

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("tail 2021-02-11-Introduccion-a-Python.ipynb")
	
	Copied

>_ Output

			
				    },
    "vscode": {
      "interpreter": {
        "hash": "d5745ab6aba164e1152437c779991855725055592b9f2bdb41a4825db7168d26"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("tail -n 5 2021-02-11-Introduccion-a-Python.ipynb")
	
	Copied

>_ Output

			
				    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}

Se queremos ver continuamente as últimas linhas de um arquivo, por exemplo, queremos estar monitorizando continuamente um arquivo de LOG para ver eventos, adicionamos a flag -f, isso fará com que o terminal fique continuamente verificando o arquivo, e cada vez que aparecer uma nova linha nele a mostrará

Por exemplo, se eu monitoro o log de início de sessão na minha máquina

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!tail -f /var/log/auth.log
	
	Copied

>_ Output

			
				Dec  1 16:27:22 wallabot gcr-prompter[1457]: Gcr: calling the PromptDone method on /org/gnome/keyring/Prompt/p2@:1.26, and ignoring reply
Dec  1 16:27:22 wallabot gnome-keyring-daemon[1178]: asked to register item /org/freedesktop/secrets/collection/login/10, but it's already registered
Dec  1 16:27:26 wallabot systemd-logind[835]: Watching system buttons on /dev/input/event28 (Logitech Wireless Mouse MX Master 3)
Dec  1 16:27:33 wallabot gcr-prompter[1457]: Gcr: 10 second inactivity timeout, quitting
Dec  1 16:27:33 wallabot gcr-prompter[1457]: Gcr: unregistering prompter
Dec  1 16:27:33 wallabot gcr-prompter[1457]: Gcr: disposing prompter
Dec  1 16:27:33 wallabot gcr-prompter[1457]: Gcr: finalizing prompter
Dec  1 16:27:34 wallabot polkitd(authority=local): Operator of unix-session:1 successfully authenticated as unix-user:wallabot to gain TEMPORARY authorization for action org.debian.apt.install-or-remove-packages for system-bus-name::1.96 [/usr/bin/python3 /usr/bin/update-manager --no-update --no-focus-on-map] (owned by unix-user:wallabot)
Dec  1 16:27:42 wallabot systemd-logind[835]: Watching system buttons on /dev/input/event30 (T9-R (AVRCP))
Dec  1 16:27:49 wallabot gnome-keyring-daemon[1178]: asked to register item /org/freedesktop/secrets/collection/login/2, but it's already registered

Vemos nas duas últimas linhas o meu início de sessão quando liguei o meu computador hoje.

Agora me conecto por SSH à minha própria máquina

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ssh localhost
	
	Copied

>_ Output

			
				wallabot@localhost's password:
Welcome to Ubuntu 20.04.5 LTS (GNU/Linux 5.15.0-53-generic x86_64)
* Documentation:  https://help.ubuntu.com
* Management:     https://landscape.canonical.com
* Support:        https://ubuntu.com/advantage
1 device has a firmware upgrade available.
Run `fwupdmgr get-upgrades` for more information.
Se pueden aplicar 0 actualizaciones de forma inmediata.
Your Hardware Enablement Stack (HWE) is supported until April 2025.
*** System restart required ***
Last login: Sun May  8 02:18:09 2022 from 192.168.1.147

No console onde eu estava monitorando o início de sessão, apareceram duas novas linhas

>_ Output

			
				Dec  1 16:32:23 wallabot sshd[25647]: Accepted password for wallabot from 127.0.0.1 port 54668 ssh2
Dec  1 16:32:23 wallabot sshd[25647]: pam_unix(sshd:session): session opened for user wallabot by (uid=0)
Dec  1 16:32:23 wallabot systemd-logind[835]: New session 4 of user wallabot.

E quando fecho a sessão SSH, aparecem mais duas novas linhas

>_ Output

			
				Dec  1 16:33:52 wallabot sshd[25647]: pam_unix(sshd:session): session closed for user wallabot
Dec  1 16:33:52 wallabot systemd-logind[835]: Session 4 logged out. Waiting for processes to exit.
Dec  1 16:33:52 wallabot systemd-logind[835]: Removed session 4.

O visualizador de arquivos mais poderoso: `less`

Um dos comandos mais poderosos para ver o conteúdo dos arquivos é less

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("less 2021-02-11-Introduccion-a-Python.ipynb", max_lines_output=20)
	
	Copied

>_ Output

			
				{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dsaKCKL0IxZl"
      },
      "source": [
        "# Introducción a Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ho_8zgIiI0We"
      },
      "source": [
        "## 1. Resumen"
      ]
    },
...
  },
  "nbformat": 4,
  "nbformat_minor": 0
}

Ao estar dentro de um caderno não se pode ver o que realmente acontece ao usar less, mas quando o usamos entramos no documento, podemos mover-nos através dele por meio das teclas ou com o rato

Se quisermos procurar algo dentro do documento, escrevemos o caractere / e o que quisermos procurar. Para alternar entre as diferentes instâncias que encontrou, pressionamos a tecla n, e se quisermos voltar nas pesquisas, pressionamos shift+n

Para sair, basta pressionar q

O visualizador `cat`

Não permite navegar pelo arquivo nem fazer buscas.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cat 2021-02-11-Introduccion-a-Python.ipynb", max_lines_output=20)
	
	Copied

>_ Output

			
				{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dsaKCKL0IxZl"
      },
      "source": [
        "# Introducción a Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ho_8zgIiI0We"
      },
      "source": [
        "## 1. Resumen"
      ]
    },
...
  },
  "nbformat": 4,
  "nbformat_minor": 0
}

Editor padrão do sistema `xdg-open`

Se quisermos abri-lo com o editor padrão do arquivo, temos que usar xdg-open

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("xdg-open 2021-02-11-Introducción-a-Python.ipynb")
	
	Copied

>_ Output

Navegador de arquivos `nautilus`

Se o que queremos é abrir a pasta em que estamos, usamos nautilus

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("nautilus")
	
	Copied

>_ Output

E se o que queremos é que ele se abra em uma rota específica, inclui-se a rota

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("nautilus ~/")
	
	Copied

>_ Output

Contador de palavras de um arquivo com `wc` (word count)

Por fim, um comando muito útil é wc (word count), que te mostra quantas linhas, palavras e bytes tem um arquivo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("wc 2021-02-11-Introduccion-a-Python.ipynb")
	
	Copied

>_ Output

			
				11678  25703 285898 2021-02-11-Introduccion-a-Python.ipynb

Como vemos, o arquivo tem 11678 linhas, 25703 palavras e ocupa 285898 bytes

O que é um comando?

Um comando pode ser quatro coisas

Um programa executável, estes normalmente são guardados no caminho /usr/bin
Um comando de shell * Uma função de shell
Um alias

Para ver a que classe pertence um comando usamos type

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!type cd
	
	Copied

>_ Output

			
				cd is a shell builtin

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!type mkdir
	
	Copied

>_ Output

			
				mkdir is /usr/bin/mkdir

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!type ls
	
	Copied

>_ Output

			
				ls is /usr/bin/ls

O que é um alias?

Um alias é um comando que definimos nós mesmos; ele é definido por meio do comando alias. Por exemplo, vamos criar o alias l, que fará ls -h

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!alias l='ls -l'
	
	Copied

Quando executamos l, ele nos mostra o resultado de ls -h

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!l
	
	Copied

>_ Output

			
				2021-02-11-Introducción-a-Python.ipynb

Mas isso tem o problema de que, quando fecharmos o terminal, o alias desaparece. Mais adiante aprenderemos a criar alias permanentes

Ajuda dos comandos

Ajuda com `help`

Com muitos comandos da shell, podemos obter sua ajuda por meio do comando help

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!help cd
	
	Copied

>_ Output

			
				cd: cd [-L|[-P [-e]]] [dir]
    Modifica el directorio de trabajo del shell.
    
    Modifica el directorio actual a DIR.  DIR por defecto es el valor de la
    variable de shell HOME.
    
    La variable CDPATH define la ruta de búsqueda para el directorio que
    contiene DIR.  Los nombres alternativos de directorio en CDPATH se
    separan con dos puntos (:).  Un nombre de directorio nulo es igual que
    el directorio actual.  Si DIR comienza con una barra inclinada (/),
    entonces no se usa CDPATH.
    
    Si no se encuentra el directorio, y la opción del shell "cdable_vars"
    está activa, entonces se trata la palabra como un nombre de variable.
    Si esa variable tiene un valor, se utiliza su valor para DIR.
    
    Opciones:
      -L	fuerza a seguir los enlaces simbólicos: resuelve los enlaces
    		simbólicos en DIR después de procesar las instancias de ".."
      -P	usa la estructura física de directorios sin seguir los enlaces
    		simbólicos: resuelve los enlaces simbólicos en DIR antes de procesar
    		las instancias de ".."
      -e	si se da la opción -P y el directorio actual de trabajo no se
    		puede determinar con éxito, termina con un estado diferente de cero.
    
    La acción por defecto es seguir los enlaces simbólicos, como si se
    especificara "-L".
    ".." se procesa quitando la componente del nombre de la ruta inmediatamente
    anterior hasta una barra inclinada o el comienzo de DIR.
    
    Estado de Salida:
    Devuelve 0 si se cambia el directorio, y si $PWD está definido como
    correcto cuando se emplee -P; de otra forma es diferente a cero.

Manual com `man`

Outro comando é man, que faz referência ao manual do usuário.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("man ls", max_lines_output=20)
	
	Copied

>_ Output

			
				LS(1)                            User Commands                           LS(1)
NAME
       ls - list directory contents
SYNOPSIS
       ls [OPTION]... [FILE]...
DESCRIPTION
       List  information  about  the FILEs (the current directory by default).
       Sort entries alphabetically if none of -cftuvSUX nor --sort  is  speci‐
       fied.
       Mandatory  arguments  to  long  options are mandatory for short options
       too.
       -a, --all
              do not ignore entries starting with .
       -A, --almost-all
...
       Full documentation at: &lt;https://www.gnu.org/software/coreutils/ls&gt;
       or available locally via: info '(coreutils) ls invocation'
GNU coreutils 8.30              September 2019                           LS(1)

Para sair, pressione q, já que man utiliza less como visualizador do manual

Informação com `info`

Outro comando é info

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("info ls", max_lines_output=20)
	
	Copied

>_ Output

			
				File: coreutils.info,  Node: ls invocation,  Next: dir invocation,  Up: Directory listing
10.1 ‘ls’: List directory contents
==================================
The ‘ls’ program lists information about files (of any type, including
directories).  Options and file arguments can be intermixed arbitrarily,
as usual.
   For non-option command-line arguments that are directories, by
default ‘ls’ lists the contents of directories, not recursively, and
omitting files with names beginning with ‘.’.  For other non-option
arguments, by default ‘ls’ lists just the file name.  If no non-option
argument is specified, ‘ls’ operates on the current directory, acting as
if it had been invoked with a single argument of ‘.’.
   By default, the output is sorted alphabetically, according to the
locale settings in effect.(1)  If standard output is a terminal, the
output is in columns (sorted vertically) and control characters are
output as question marks; otherwise, the output is listed one per line
...
‘--show-control-chars’
     Print nongraphic characters as-is in file names.  This is the
     default unless the output is a terminal and the program is ‘ls’.

Para sair, pressione q, pois info utiliza less como visualizador das informações

Informação de um comando com `whatis`

Outro comando é whatis

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("whatis ls")
	
	Copied

>_ Output

			
				ls (1)               - list directory contents

Wildcards

As wildcards são caracteres especiais que nos servem para realizar buscas especiais. Por exemplo, se quiser buscar todos os arquivos que terminem em .txt. Vamos criar alguns arquivos para vê-las.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("touch file.txt dot.txt dot2.txt index.html datos1 datos123 Abc")
	
	Copied

>_ Output

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("ls")
	
	Copied

>_ Output

			
				2021-02-11-Introduccion-a-Python.ipynb
Abc
datos1
datos123
dot2.txt
dot.txt
file.txt
index.html

Todos os caracteres `*`

Vamos procurar agora todos os arquivos .txt

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls *.txt
	
	Copied

>_ Output

			
				dot2.txt  dot.txt  file.txt

Vamos agora procurar todos os que comecem pela palavra datos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls datos*
	
	Copied

>_ Output

			
				datos1	datos123

Números `?`

Mas o que acontece se, na verdade, o que queremos é que nos mostre todos os arquivos que comecem pela palavra datos, mas seguidos apenas de um número, temos que colocar um sinal de interrogação ?

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls datos?
	
	Copied

>_ Output

			
				datos1

Se o que queremos é que tenha três números, então temos que colocar três sinais de interrogação ???

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls datos???
	
	Copied

>_ Output

			
				datos123

Maiúsculas `[[:upper:]]`

Se queremos que ele procure os arquivos que comecem por maiúsculas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls [[:upper:]]*
	
	Copied

>_ Output

Abc

Minúsculas `[[:lower:]]`

Para os arquivos que começam com minúsculas.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls [[:lower:]]*
	
	Copied

>_ Output

			
				datos1  datos123  dot2.txt  dot.txt  file.txt  index.html

Classes

Por meio do uso de colchetes podemos criar classes, assim, se quisermos procurar os arquivos que comecem pelas letras d ou f seguidas de qualquer caractere

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls [df]*
	
	Copied

>_ Output

			
				datos1  datos123  dot2.txt  dot.txt  file.txt

Redirecionamentos: como funciona o shell

Um comando funciona da seguinte maneira

Tem um standard input, que por padrão é o texto que introduzimos pelo teclado, um standard output, que por padrão é o texto que sai pela consola e um standard error que também é, por padrão, um texto que sai pela consola, mas que tem outro formato

Redirecionamento da `standard output`

Mas com o caractere > podemos modificar o standard output de um comando. Por exemplo, se quisermos listar com ls os arquivos da pasta em que estamos, mas não queremos que o resultado seja impresso na tela, e sim salvo em um arquivo, faríamos o seguinte ls > lista.txt, isso escreve a lista em lista.txt. Além disso, se lista.txt não existir, ele o cria

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls &gt; lista.txt
	
	Copied

Vemos que criou o arquivo e vemos o que há dentro

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("ls")
	
	Copied

>_ Output

			
				2021-02-11-Introduccion-a-Python.ipynb
Abc
datos1
datos123
dot2.txt
dot.txt
file.txt
index.html
lista.txt

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cat lista.txt")
	
	Copied

>_ Output

			
				2021-02-11-Introduccion-a-Python.ipynb
Abc
datos1
datos123
dot2.txt
dot.txt
file.txt
index.html
lista.txt

Vemos que dentro de lista.txt aparece lista.txt, isso acontece porque primeiro cria o arquivo e depois executa o comando

Fazemos o mesmo, mas com a pasta pai

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls ../ &gt; lista.txt
	
	Copied

Se olharmos novamente dentro de lista.txt

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cat lista.txt")
	
	Copied

>_ Output

			
				2021-02-11-Introduccion-a-Python.ipynb
2021-04-23-Calculo-matricial-con-Numpy.ipynb
2021-06-15-Manejo-de-datos-con-Pandas.ipynb
2022-09-12 Introduccion a la terminal.ipynb
2022-09-12 Introduccion a la terminal.txt
command-line-cheat-sheet.pdf
CSS.ipynb
Docker.html
Docker.ipynb
Expresiones regulares.html
Expresiones regulares.ipynb
html_files
html.ipynb
introduccion_python
movies.csv
movies.dat
notebooks_translated
prueba
__pycache__
ssh.ipynb
test.html
test.ipynb

Vemos que o conteúdo é sobrescrito

Se o que queremos é que o conteúdo seja concatenado, devemos usar >>

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls &gt; lista.txt
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls ../ &gt;&gt; lista.txt
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cat lista.txt")
	
	Copied

>_ Output

			
				2021-02-11-Introduccion-a-Python.ipynb
Abc
datos1
datos123
dot2.txt
dot.txt
file.txt
index.html
lista.txt
2021-02-11-Introduccion-a-Python.ipynb
2021-04-23-Calculo-matricial-con-Numpy.ipynb
2021-06-15-Manejo-de-datos-con-Pandas.ipynb
2022-09-12 Introduccion a la terminal.ipynb
2022-09-12 Introduccion a la terminal.txt
command-line-cheat-sheet.pdf
CSS.ipynb
Docker.html
Docker.ipynb
Expresiones regulares.html
Expresiones regulares.ipynb
html_files
html.ipynb
introduccion_python
movies.csv
movies.dat
notebooks_translated
prueba
__pycache__
ssh.ipynb
test.html
test.ipynb

Agora sim, a informação foi concatenada

Isto é muito útil para criar arquivos de logs

Redirecionamento do `standard error`

Se realizarmos uma operação incorreta, obtemos um erro; vejamos o que acontece ao redirecionar um comando que gera um erro

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls fjhdsalkfs &gt; lista.txt
	
	Copied

>_ Output

			
				ls: no se puede acceder a 'fjhdsalkfs': No existe el archivo o el directorio

Como vemos, deu um erro, mas se agora olharmos dentro de lista.txt

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cat lista.txt")
	
	Copied

>_ Output

Vemos que o arquivo está vazio, isso é porque não redirecionamos o standard error para lista.txt, mas sim o standard output. Como vimos na imagem, há dois padrões de saída em um comando, o primeiro é o standard output e o segundo o standard error, portanto, para redirecionar o standard error é necessário indicá-lo por meio de 2>. Vamos agora assim

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls kjhsfskjd 2&gt; lista.txt
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cat lista.txt")
	
	Copied

>_ Output

			
				ls: no se puede acceder a 'kjhsfskjd': No existe el archivo o el directorio

Como vemos, agora sim foi redirecionado

Redirecionamento de `standard output` e de `standard error`

Se quisermos redirecioná-los ambos, usamos o seguinte

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls kjhsfskjd &gt; lista.txt 2&gt;&amp;1
	
	Copied

Vamos ver dentro de lista.txt

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cat lista.txt")
	
	Copied

>_ Output

			
				ls: no se puede acceder a 'kjhsfskjd': No existe el archivo o el directorio

Se agora executarmos um comando sem erros

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls . &gt;&gt; lista.txt 2&gt;&amp;1
	
	Copied

Vamos ver dentro de lista.txt (**atenção**, agora concatenamos)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cat lista.txt")
	
	Copied

>_ Output

			
				ls: no se puede acceder a 'kjhsfskjd': No existe el archivo o el directorio
2021-02-11-Introduccion-a-Python.ipynb
Abc
datos1
datos123
dot2.txt
dot.txt
file.txt
index.html
lista.txt

Como se pode ver, foram redirecionados, tanto o standard error quanto o standard output para o mesmo arquivo

Pipelines

Podemos criar pipelines fazendo com que o standard output de um comando se converta no standard input de outro. Por exemplo, vamos fazer com que a saída de ls -lha seja a entrada de grep, que veremos mais adiante, mas é um comando para buscar.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls -lha | grep -i "txt"
	
	Copied

>_ Output

			
				-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 dot2.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 dot.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 file.txt
-rw-rw-r-- 1 wallabot wallabot  182 dic  6 01:06 lista.txt

Como podemos ver, o que fizemos foi levar a saída de ls para grep com o qual procuramos algum arquivo com txt no nome

Operadores de controle - encadear comandos

Comandos de maneira sequencial

Uma forma de encadear comandos de forma sequencial é separá-los por ;. Isso cria diferentes threads para cada tarefa

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls; echo 'Hola'; cal
	
	Copied

>_ Output

			
				2021-02-11-Introduccion-a-Python.ipynb	datos123  file.txt
Abc					dot2.txt  index.html
datos1					dot.txt   lista.txt
Hola
   Diciembre 2022
do lu ma mi ju vi sá
             1  2  3
4  5  6  7  8  9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31

Como podemos ver, primeiro foi executado o comando ls, depois foi impresso Olá graças ao comando echo "Hola" e, por último, foi impresso um calendário graças ao comando cal

Vamos agora fazer outro exemplo para ver que são executados de maneira sequencial.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!echo "Before touch;"; ls -lha; touch secuential.txt; echo "After touch:"; ls -lha
	
	Copied

>_ Output

			
				Before touch;
total 292K
drwxrwxr-x 2 wallabot wallabot 4,0K dic  6 01:04 .
drwxrwxr-x 7 wallabot wallabot 4,0K dic  6 00:24 ..
-rw-rw-r-- 1 wallabot wallabot 280K dic  6 00:28 2021-02-11-Introduccion-a-Python.ipynb
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 Abc
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 datos1
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 datos123
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 dot2.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 dot.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 file.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 index.html
-rw-rw-r-- 1 wallabot wallabot  182 dic  6 01:06 lista.txt
After touch:
total 292K
drwxrwxr-x 2 wallabot wallabot 4,0K dic  6 01:07 .
drwxrwxr-x 7 wallabot wallabot 4,0K dic  6 00:24 ..
-rw-rw-r-- 1 wallabot wallabot 280K dic  6 00:28 2021-02-11-Introduccion-a-Python.ipynb
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 Abc
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 datos1
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 datos123
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 dot2.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 dot.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 file.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 index.html
-rw-rw-r-- 1 wallabot wallabot  182 dic  6 01:06 lista.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 01:07 secuential.txt

Como se pode ver, no primeiro ls não aparece sequential.txt, enquanto no segundo sim. Isso quer dizer que os comandos foram executados em ordem, um atrás do outro

Comandos de maneira paralela

Se o que queremos é que os comandos sejam executados de maneira paralela, é preciso usar o operador &. Isso fará com que seja criado um novo processo para cada comando.

Vamos ver o exemplo de antes

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!rm secuential.txt
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!echo "Before touch;" &amp; ls -lha &amp; touch secuential.txt &amp; echo "After touch:" &amp; ls -lha
	
	Copied

>_ Output

			
				Before touch;
After touch:
total 292K
drwxrwxr-x 2 wallabot wallabot 4,0K dic  6 01:08 .
drwxrwxr-x 7 wallabot wallabot 4,0K dic  6 00:24 ..
-rw-rw-r-- 1 wallabot wallabot 280K dic  6 00:28 2021-02-11-Introduccion-a-Python.ipynb
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 Abc
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 datos1
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 datos123
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 dot2.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 dot.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 file.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 index.html
-rw-rw-r-- 1 wallabot wallabot  182 dic  6 01:06 lista.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 01:08 secuential.txt

Agora é possível ver que não foram executados sequencialmente, já que primeiro foram executados os echos, que serão os que menos demoram, e depois o resto

Comandos de maneira condicional

E

Usando o operador &&, um comando será executado quando o anterior tiver sido executado com sucesso

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!rm secuential.txt
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!echo "Before touch;" && ls -lha && touch secuential.txt && echo "After touch:" && ls -lha
	
	Copied

>_ Output

			
				Before touch;
total 292K
drwxrwxr-x 2 wallabot wallabot 4,0K dic  6 01:08 .
drwxrwxr-x 7 wallabot wallabot 4,0K dic  6 00:24 ..
-rw-rw-r-- 1 wallabot wallabot 280K dic  6 00:28 2021-02-11-Introduccion-a-Python.ipynb
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 Abc
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 datos1
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 datos123
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 dot2.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 dot.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 file.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 index.html
-rw-rw-r-- 1 wallabot wallabot  182 dic  6 01:06 lista.txt
After touch:
total 292K
drwxrwxr-x 2 wallabot wallabot 4,0K dic  6 01:08 .
drwxrwxr-x 7 wallabot wallabot 4,0K dic  6 00:24 ..
-rw-rw-r-- 1 wallabot wallabot 280K dic  6 00:28 2021-02-11-Introduccion-a-Python.ipynb
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 Abc
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 datos1
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 datos123
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 dot2.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 dot.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 file.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 index.html
-rw-rw-r-- 1 wallabot wallabot  182 dic  6 01:06 lista.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 01:08 secuential.txt

Aqui podemos ver como se ha executado um atrás do outro, isto é, um comando não começa até que o anterior termine

Mas então, qual é a diferença entre ; e &&?

No primeiro, o sequencial ;, primeiro executa-se um comando e depois outro, mas para que um comando seja executado, tanto faz se o anterior foi executado com sucesso ou não.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!rm prueba ; ls -lha
	
	Copied

>_ Output

			
				rm: no se puede borrar 'prueba': No existe el archivo o el directorio
total 292K
drwxrwxr-x 2 wallabot wallabot 4,0K dic  6 01:08 .
drwxrwxr-x 7 wallabot wallabot 4,0K dic  6 00:24 ..
-rw-rw-r-- 1 wallabot wallabot 280K dic  6 00:28 2021-02-11-Introduccion-a-Python.ipynb
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 Abc
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 datos1
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 datos123
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 dot2.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 dot.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 file.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 index.html
-rw-rw-r-- 1 wallabot wallabot  182 dic  6 01:06 lista.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 01:08 secuential.txt

Como se pode ver, primeiro é executado rm prueba, dá um erro e, mesmo assim, é executado ls -lha prueba

Na forma condicional &&, se um comando não for executado com sucesso, o próximo não será executado.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!rm prueba && ls -lha
	
	Copied

>_ Output

			
				rm: no se puede borrar 'prueba': No existe el archivo o el directorio

Como se pode ver, ls -lha prueba não é executado, já que rm prueba deu um erro

Ou

Ao contrário do &&, o 'or' executará todos os processos, seja qual for o seu resultado. Deve-se utilizar o operador ||

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!rm prueba || ls -lha
	
	Copied

>_ Output

			
				rm: no se puede borrar 'prueba': No existe el archivo o el directorio
total 292K
drwxrwxr-x 2 wallabot wallabot 4,0K dic  6 01:08 .
drwxrwxr-x 7 wallabot wallabot 4,0K dic  6 00:24 ..
-rw-rw-r-- 1 wallabot wallabot 280K dic  6 00:28 2021-02-11-Introduccion-a-Python.ipynb
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 Abc
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 datos1
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 datos123
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 dot2.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 dot.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 file.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 00:56 index.html
-rw-rw-r-- 1 wallabot wallabot  182 dic  6 01:06 lista.txt
-rw-rw-r-- 1 wallabot wallabot    0 dic  6 01:08 secuential.txt

A diferença entre este e ; é que o || (or) não cria uma nova thread para cada comando

Como são gerenciadas as permissões

Quando se listam os arquivos de um diretório com a flag -l (long) aparecem alguns símbolos ao lado de cada arquivo.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!mkdir subdirectorio
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls -l
	
	Copied

>_ Output

			
				total 288
-rw-rw-r-- 1 wallabot wallabot 285898 dic  6 00:28 2021-02-11-Introduccion-a-Python.ipynb
-rw-rw-r-- 1 wallabot wallabot      0 dic  6 00:56 Abc
-rw-rw-r-- 1 wallabot wallabot      0 dic  6 00:56 datos1
-rw-rw-r-- 1 wallabot wallabot      0 dic  6 00:56 datos123
-rw-rw-r-- 1 wallabot wallabot      0 dic  6 00:56 dot2.txt
-rw-rw-r-- 1 wallabot wallabot      0 dic  6 00:56 dot.txt
-rw-rw-r-- 1 wallabot wallabot      0 dic  6 00:56 file.txt
-rw-rw-r-- 1 wallabot wallabot      0 dic  6 00:56 index.html
-rw-rw-r-- 1 wallabot wallabot    182 dic  6 01:06 lista.txt
-rw-rw-r-- 1 wallabot wallabot      0 dic  6 01:08 secuential.txt
drwxrwxr-x 2 wallabot wallabot   4096 dic  6 01:10 subdirectorio

Isto nos dá informações de cada arquivo

Primeiro, vejamos que tipos de arquivos existem

-: Arquivo normal
d: Diretório* l: Link simbólico
b: Arquivo de bloco especial. São arquivos que gerenciam as informações dos blocos de dados, como, por exemplo, um USB

Depois veremos os tipos de modo:

Proprietário			Grupo			Mundo
rwx			r-x			r-x
1	1	1	1	0	1	1	0	1
7			5			5

r: ler
w: escrever
x: executar

Modo simbólico:

u: Apenas para o usuário
g: Apenas para o grupo* o: Apenas para outros (world)
a: Para todos

Modificando as permissões no terminal

Criamos um novo arquivo

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cd subdirectorio")
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!echo "hola mundo" &gt; mitexto.txt
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!cat mitexto.txt
	
	Copied

>_ Output

			
				hola mundo

Vamos ver as permissões que ele tem.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls -l
	
	Copied

>_ Output

			
				total 4
-rw-rw-r-- 1 wallabot wallabot 11 dic  6 01:10 mitexto.txt

Como vemos, ele tem permissões de leitura e escrita para o meu usuário e o grupo, e apenas permissões de leitura para o restante (world)

Alteração de permissões com `chmod` (change mode)

Para alterar as permissões de um arquivo, usamos o comando chmod (change mode), onde precisamos informar em octal as permissões do usuário, depois as do grupo e, por fim, as do restante.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!chmod 755 mitexto.txt
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls -l
	
	Copied

>_ Output

			
				total 4
-rwxr-xr-x 1 wallabot wallabot 11 dic  6 01:10 mitexto.txt

Vemos que agora meu usuário tem permissões de leitura, escrita e execução, enquanto o grupo e o resto do mundo têm permissões de leitura e execução

Vamos remover as permissões de leitura apenas do meu usuário. Para alterar apenas as permissões de um usuário, usamos o identificador simbólico, um + se quisermos adicionar permissões, um - se quisermos removê-las ou um = se quisermos redefini-las, seguido do tipo de permissão

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!chmod u-r mitexto.txt
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls -l
	
	Copied

>_ Output

			
				total 4
--wxr-xr-x 1 wallabot wallabot 11 dic  6 01:10 mitexto.txt

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!cat mitexto.txt
	
	Copied

>_ Output

			
				cat: mitexto.txt: Permiso denegado

Como vemos, ao remover permissões de leitura para o meu usuário, não conseguimos ler o arquivo.

Voltamos a conceder a permissão de leitura.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!chmod u+r mitexto.txt
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls -l
	
	Copied

>_ Output

			
				total 4
-rwxr-xr-x 1 wallabot wallabot 11 dic  6 01:10 mitexto.txt

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!cat mitexto.txt
	
	Copied

>_ Output

			
				hola mundo

Se quisermos adicionar ou remover permissões de mais de um usuário, fazemos isso separando cada permissão por uma ,

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!chmod u-x,go=w mitexto.txt
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls -l
	
	Copied

>_ Output

			
				total 4
-rw--w--w- 1 wallabot wallabot 11 dic  6 01:10 mitexto.txt

Como se pode ver, foi removida a permissão de execução para o usuário e foi estabelecida a permissão de apenas escrita para o grupo e para o resto do mundo.

Identificação de usuário com `whoami`

Para saber quem somos podemos usar o comando whoami (who am I)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!whoami
	
	Copied

>_ Output

			
				wallabot

Informações do usuário com `id`

Outra maneira, que além disso fornece mais informações, é o comando id

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!id
	
	Copied

>_ Output

			
				uid=1000(wallabot) gid=1000(wallabot) grupos=1000(wallabot),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),120(lpadmin),131(lxd),132(sambashare),998(docker)

Este comando nos diz que nosso ID de usuário é 1000, o ID de grupo é 1000 e que pertencemos aos grupos wallabot, adm, cdrom, sudo, dip, plugdev, lpadmin, lxd, sambashare e docker

Mudança de usuário com o comando `su` (switch user)

Se quisermos trocar de usuário, usamos o comando su (switch user). Dependendo do usuário, é necessário usar sudo (superuser do)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!sudo su root
	
	Copied

>_ Output

			
				root@wallabot:/home/wallabot/Documentos/web/portafolio/posts/prueba/subdirectorio#

Como vemos, muda o prompt e agora indica que somos o usuário root

Vamos para a pasta home

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!cd
	
	Copied

>_ Output

			
				root@wallabot:~#

Mas no Linux há uma pasta home para cada usuário, isso podemos ver se executarmos o comando pwd

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!pwd
	
	Copied

>_ Output

			
				/root

Vou criar um arquivo na pasta onde antes criei o arquivo *mitexto.txt*

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!touch /home/wallabot/Documentos/web/portafolio/posts/prueba/subdirectorio/rootfile.txt
	
	Copied

>_ Output

Vou voltar a mudar para o meu usuário

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!su wallabot
	
	Copied

>_ Output

			
				wallabot@wallabot:

E eu vou para o diretório onde estão os arquivos que criei.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!cd /home/wallabot/Documentos/web/portafolio/posts/prueba/subdirectorio
	
	Copied

Vemos os arquivos que existem e suas permissões

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls -l
	
	Copied

>_ Output

			
				total 4
-rw--w--w- 1 wallabot wallabot 11 dic  6 01:10 mitexto.txt
-rw-r--r-- 1 root     root      0 dic  6 01:22 rootfile.txt

Como vemos, o usuário e o grupo do arquivo *rootfile.txt* são o usuário root

Sim, agora que sou o usuário *wallabot*, tento apagar o arquivo rootfile.txt

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!rm rootfile.txt
	
	Copied

>_ Output

			
				rm: ¿borrar el fichero regular vacío 'rootfile.txt'  protegido contra escritura? (s/n)

Como vemos, ele nos pergunta se queremos apagá-lo, já que pertence a outro usuário.

Modificar a senha de um usuário

Se eu quiser modificar a senha do usuário que tenho atualmente ativo, uso o comando passwd (password)

Primeiro, verifico qual usuário sou

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!whoami
	
	Copied

>_ Output

			
				wallabot

E agora vamos testar a alteração da senha

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!passwd
	
	Copied

>_ Output

			
				$ passwd
Cambiando la contraseña de wallabot.
Contraseña actual de :
Nueva contraseña:
Vuelva a escribir la nueva contraseña

Como vemos, ele pede a senha atual para poder alterá-la

Links simbólicos

Podemos criar links simbólicos para um caminho determinado por meio do comando ln (link) seguido do flag -s (symbolic), o diretório e o nome do link

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ln -s /home/wallabot/Documentos/web web
	
	Copied

Se agora listarmos os arquivos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls -l
	
	Copied

>_ Output

			
				total 4
-rw--w--w- 1 wallabot wallabot 11 dic  6 01:10 mitexto.txt
-rw-r--r-- 1 root     root      0 dic  6 01:22 rootfile.txt
lrwxrwxrwx 1 wallabot wallabot 29 dic  6 01:28 web -&gt; /home/wallabot/Documentos/web

Vemos o enlace simbólico web que aponta para /home/wallabot/Documentos/web:

Eu agora posso ir para web

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cd web")
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!pwd
	
	Copied

>_ Output

			
				/home/wallabot/Documentos/web

Configurar as variáveis de ambiente

Ver as variáveis de ambiente com `printenv`

Com o comando printenv podemos ver todas as variáveis de ambiente

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!printenv
	
	Copied

>_ Output

			
				GJS_DEBUG_TOPICS=JS ERROR;JS LOG
VSCODE_CWD=/home/wallabot
LESSOPEN=| /usr/bin/lesspipe %s
CONDA_PROMPT_MODIFIER=(base)
PYTHONIOENCODING=utf-8
USER=wallabot
VSCODE_NLS_CONFIG={"locale":"es","availableLanguages":{"*":"es"},"_languagePackId":"b07c40c9acb9e1d7b3ca14b06f814803.es","_translationsConfigFile":"/home/wallabot/.config/Code/clp/b07c40c9acb9e1d7b3ca14b06f814803.es/tcf.json","_cacheRoot":"/home/wallabot/.config/Code/clp/b07c40c9acb9e1d7b3ca14b06f814803.es","_resolvedLanguagePackCoreLocation":"/home/wallabot/.config/Code/clp/b07c40c9acb9e1d7b3ca14b06f814803.es/6261075646f055b99068d3688932416f2346dd3b","_corruptedFile":"/home/wallabot/.config/Code/clp/b07c40c9acb9e1d7b3ca14b06f814803.es/corrupted.info","_languagePackSupport":true}
VSCODE_HANDLES_UNCAUGHT_ERRORS=true
MPLBACKEND=module://ipykernel.pylab.backend_inline
SSH_AGENT_PID=1373
XDG_SESSION_TYPE=x11
SHLVL=0
HOME=/home/wallabot
CHROME_DESKTOP=code-url-handler.desktop
CONDA_SHLVL=1
DESKTOP_SESSION=ubuntu
GIO_LAUNCHED_DESKTOP_FILE=/usr/share/applications/code.desktop
VSCODE_IPC_HOOK=/run/user/1000/vscode-26527400-1.73.1-main.sock
PYTHONUNBUFFERED=1
GTK_MODULES=gail:atk-bridge
...
QT_IM_MODULE=ibus
GIT_PAGER=cat
PWD=/home/wallabot/Documentos/web
CLICOLOR=1
XDG_DATA_DIRS=/usr/share/ubuntu:/usr/local/share/:/usr/share/:/var/lib/snapd/desktop
XDG_CONFIG_DIRS=/etc/xdg/xdg-ubuntu:/etc/xdg
VSCODE_CODE_CACHE_PATH=/home/wallabot/.config/Code/CachedData/6261075646f055b99068d3688932416f2346dd3b
CONDA_EXE=/home/wallabot/anaconda3/bin/conda
CONDA_PREFIX=/home/wallabot/anaconda3
VSCODE_PID=3897

Ver uma variável de ambiente com o comando `echo`

Para ver uma variável de ambiente específica, podemos fazer isso por meio do comando echo seguido do símbolo $ e do nome da variável

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!echo $HOME
	
	Copied

>_ Output

			
				/home/wallabot

Modificar uma variável de ambiente para uma sessão de terminal

Podemos modificar uma variável de ambiente para a sessão ativa do terminal, por exemplo, vamos adicionar um novo caminho à variável PATH. Primeiro vemos o que há nela

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!echo $PATH
	
	Copied

>_ Output

			
				/home/wallabot/anaconda3/bin:/home/wallabot/anaconda3/condabin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin

Agora adicionamos um novo diretório

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!PATH=$PATH:"subdirectorio
	
	Copied

>_ Output

Vamos ver novamente o que há dentro de PATH

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!echo $PATH
	
	Copied

>_ Output

			
				/home/wallabot/anaconda3/bin:/home/wallabot/anaconda3/condabin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:subdirectorio

Vemos que o diretório subdirectorio foi adicionado.

O problema deste método é que, ao abrirmos um novo terminal, essa alteração em PATH não será mantida.

Modificar uma variável de ambiente para todas as sessões de terminal

Vamos para a pasta home

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cd /home/wallabot")
	
	Copied

Aqui, no home, listamos todos os arquivos com o flag -a (all)

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!ls -a
	
	Copied

>_ Output

			
				.		.eclipse		       .pki
..		Escritorio		       Plantillas
.afirma		.gitconfig		       .platformio
anaconda3	.gnupg			       .profile
.audacity-data	Imágenes		       .psensor
.bash_history	.ipython		       Público
.bash_logout	.java			       .python_history
.bashrc		.jupyter		       snap
.cache		.lesshst		       .ssh
.conda		Lightworks		       .sudo_as_admin_successful
.config		.Lightworks.thereCanBeOnlyOne  .thunderbird
.cortex-debug	.local			       Vídeos
.cyberghost	logiops			       .vnc
.dbus		.MCTranscodingSDK	       .vscode
Descargas	.mozilla		       .wget-hsts
.docker		Música
Documentos	.nv

Vemos que há um arquivo chamado .bashrc, esse arquivo é o que contém a configuração do nosso bash

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cat .bashrc", max_lines_output=3)
	
	Copied

>_ Output

			
				# ~/.bashrc: executed by bash(1) for non-login shells.
# see /usr/share/doc/bash/examples/startup-files (in the package bash-doc)
# for examples
...
fi
unset __conda_setup
# &lt;&lt;&lt; conda initialize &lt;&lt;&lt;

Este arquivo é o que configura o terminal toda vez que um novo é aberto, portanto, se nele editarmos a variável PATH, essa mudança será mantida para todas as novas janelas de terminal que abrirmos

Para modificar a variável PATH dentro do arquivo de configuração, temos que adicionar a seguinte linha ao arquivo

PATH=$PATH:"subdiretório"

Criar alias para todas as sessões

Já vimos como criar aliases de comandos, mas também acontecia que eles eram perdidos toda vez que fechávamos uma sessão de terminal. Para que isso não aconteça, nós os adicionamos também ao arquivo de configuração .bashrc. Por exemplo, no meu caso, adicionei as seguintes linhas

alias ll='ls -l'
alias la='ls -a'
alias lh='ls -h'
alias lha='ls -lha'

Comandos de pesquisa

Busca de binários com `which`

O primeiro comando de busca que vamos ver é which, que nos permite encontrar o caminho dos binários

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!which python
	
	Copied

>_ Output

			
				/home/wallabot/anaconda3/bin/python

No entanto, se procurarmos algo que não esteja em algum dos caminhos do PATH, which não será capaz de nos dizer o caminho

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!which cd
	
	Copied

Busca de arquivos com `find`

Para procurar um arquivo com find, precisamos indicar desde qual caminho queremos buscar o arquivo, seguido da flag -name e do nome do arquivo que queremos buscar.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!find ~ -name "2021-02-11-Introduccion-a-Python.ipynb"
	
	Copied

>_ Output

			
				/home/wallabot/Documentos/web/portafolio/posts/prueba/2021-02-11-Introduccion-a-Python.ipynb
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb

Como vemos, está em seu diretório, além da cópia que criei neste notebook e a salvei na pasta prueba

Uma coisa muito poderosa do find é que podemos usar wildcards, por exemplo, se eu quiser procurar todos os arquivos de texto da minha pasta web.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!find ~/Documentos/web/ -name *.txt
	
	Copied

>_ Output

			
				/home/wallabot/Documentos/web/portafolio/posts/2022-09-12 Introduccion a la terminal.txt
/home/wallabot/Documentos/web/portafolio/posts/prueba/lista.txt
/home/wallabot/Documentos/web/portafolio/posts/prueba/dot.txt
/home/wallabot/Documentos/web/portafolio/posts/prueba/dot2.txt
/home/wallabot/Documentos/web/portafolio/posts/prueba/secuential.txt
/home/wallabot/Documentos/web/portafolio/posts/prueba/subdirectorio/rootfile.txt
/home/wallabot/Documentos/web/portafolio/posts/prueba/subdirectorio/mitexto.txt
/home/wallabot/Documentos/web/portafolio/posts/prueba/file.txt
/home/wallabot/Documentos/web/wordpress_api_rest/page.txt

Se não quisermos que diferencie entre maiúsculas e minúsculas, devemos usar a flag -iname. Por exemplo, se procurarmos todos os arquivos que contenham o texto FILE, mas usando a flag -iname.

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!find ~/Documentos/web/ -iname *FILE*
	
	Copied

>_ Output

			
				/home/wallabot/Documentos/web/portafolio/posts/html_files
/home/wallabot/Documentos/web/portafolio/posts/prueba/subdirectorio/rootfile.txt
/home/wallabot/Documentos/web/portafolio/posts/prueba/file.txt

Vemos que todos os resultados contêm file e não FILE, ou seja, não fez distinção entre maiúsculas e minúsculas

Podemos especificar o tipo de arquivo com a flag -type. Só admite dois tipos: f para arquivos e d para diretórios

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!find ~/Documentos/nerf -name image*
	
	Copied

>_ Output

			
				/home/wallabot/Documentos/nerf/instant-ngp/configs/image
/home/wallabot/Documentos/nerf/instant-ngp/dependencies/tiny-cuda-nn/benchmarks/image
/home/wallabot/Documentos/nerf/instant-ngp/dependencies/tiny-cuda-nn/dependencies/cutlass/media/images
/home/wallabot/Documentos/nerf/instant-ngp/dependencies/tiny-cuda-nn/dependencies/fmt/doc/bootstrap/mixins/image.less
/home/wallabot/Documentos/nerf/instant-ngp/dependencies/tiny-cuda-nn/data/images
/home/wallabot/Documentos/nerf/instant-ngp/dependencies/dlss/NVIDIAImageScaling/samples/media/images
/home/wallabot/Documentos/nerf/instant-ngp/data/nerf/fox/images
/home/wallabot/Documentos/nerf/instant-ngp/data/image

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!find ~/Documentos/nerf -name image* -type d
	
	Copied

>_ Output

			
				/home/wallabot/Documentos/nerf/instant-ngp/configs/image
/home/wallabot/Documentos/nerf/instant-ngp/dependencies/tiny-cuda-nn/benchmarks/image
/home/wallabot/Documentos/nerf/instant-ngp/dependencies/tiny-cuda-nn/dependencies/cutlass/media/images
/home/wallabot/Documentos/nerf/instant-ngp/dependencies/tiny-cuda-nn/data/images
/home/wallabot/Documentos/nerf/instant-ngp/dependencies/dlss/NVIDIAImageScaling/samples/media/images
/home/wallabot/Documentos/nerf/instant-ngp/data/nerf/fox/images
/home/wallabot/Documentos/nerf/instant-ngp/data/image

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!find ~/Documentos/nerf -name image* -type f
	
	Copied

>_ Output

			
				/home/wallabot/Documentos/nerf/instant-ngp/dependencies/tiny-cuda-nn/dependencies/fmt/doc/bootstrap/mixins/image.less

Se quisermos filtrar pelo tamanho do arquivo, podemos usar a flag -size, por exemplo, se quisermos procurar todos os arquivos com mais de 200 MB

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!find ~/Documentos/ -type f -size +200M
	
	Copied

>_ Output

			
				/home/wallabot/Documentos/kaggle/hubmap/models/13_efficientnet-b7_final_model.pth
/home/wallabot/Documentos/kaggle/hubmap/models/12_efficientnet-b7_final_model.pth
/home/wallabot/Documentos/kaggle/hubmap/models/14_resnet152_final_model.pth
/home/wallabot/Documentos/kaggle/hubmap/models/14_resnet152_best_model.pth
/home/wallabot/Documentos/kaggle/hubmap/models/12_efficientnet-b7_early_stopping.pth
/home/wallabot/Documentos/kaggle/hubmap/models/efficientnet-b7-dcc49843.pth
/home/wallabot/Documentos/kaggle/hubmap/models/13_efficientnet-b7_early_stopping.pth
/home/wallabot/Documentos/kaggle/hubmap/models/14_resnet152_early_stopping.pth
/home/wallabot/Documentos/kaggle/hubmap/models/12_efficientnet-b7_best_model.pth
/home/wallabot/Documentos/kaggle/hubmap/models/13_efficientnet-b7_best_model.pth

Se quisermos realizar operações após a pesquisa, usamos o flag -exec

Por exemplo, vou procurar todas as pastas com o nome subdirectorio

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!find ~/ -name subdirectorio -type d
	
	Copied

>_ Output

			
				/home/wallabot/Documentos/web/portafolio/posts/prueba/subdirectorio

Posso fazer com que sejam apagados com a flag -exec

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!find ~/ -name subdirectorio -type d -exec rm -r {} ;
	
	Copied

>_ Output

			
				rm: ¿borrar el fichero regular vacío '/home/wallabot/Documentos/web/portafolio/posts/prueba/subdirectorio/rootfile.txt'  protegido contra escritura? (s/n) s
find: ‘/home/wallabot/Documentos/web/portafolio/posts/prueba/subdirectorio’: No existe el archivo o el directorio

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!find ~/ -name subdirectorio -type d
	
	Copied

Por fim, se usarmos o caractere ! estaremos indicando que encontre tudo o que não corresponde ao que especificamos

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!find ~/Documentos/web/portafolio/posts/prueba ! -name *.txt
	
	Copied

>_ Output

			
				/home/wallabot/Documentos/web/portafolio/posts/prueba
/home/wallabot/Documentos/web/portafolio/posts/prueba/index.html
/home/wallabot/Documentos/web/portafolio/posts/prueba/Abc
/home/wallabot/Documentos/web/portafolio/posts/prueba/datos1
/home/wallabot/Documentos/web/portafolio/posts/prueba/2021-02-11-Introduccion-a-Python.ipynb
/home/wallabot/Documentos/web/portafolio/posts/prueba/datos123

Como vemos, ele encontrou tudo o que não é um .txt

Comando de busca `grep`

grep é um comando de busca muito potente, por isso dedicamos uma seção só para ele. O comando grep utiliza expressões regulares, então, se você quiser aprender sobre elas, deixo um link para um post onde as explico

Vamos começar a ver o poder deste comando, vamos procurar todas as vezes que aparece o texto MáximoFN dentro do arquivo 2021-02-11-Introduccion-a-Python.ipynb

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("cd /home/wallabot/Documentos/web/portafolio/posts/prueba")
	
	Copied

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("grep MaximoFN 2021-02-11-Introduccion-a-Python.ipynb", max_lines_output=20)
	
	Copied

>_ Output

			
				        "a = 'MaximoFN'
",
              "'MaximoFN'"
        "string = "MaximoFN"
",
              "'MaximoFN'"
        "string = 'MaximoFN'
",
              "'MaximoFN'"
            "Este es el blog de "MaximoFN"
"
        "print("Este es el blog de \"MaximoFN\"")"
            "Este es el blog de 'MaximoFN'
"
        "print('Este es el blog de \'MaximoFN\'')"
            "Este es el blog de \MaximoFN\
"
        "print('Este es el blog de \\MaximoFN\\')"
            "MaximoFN
"
        "print('Este es el blog de \nMaximoFN')"
            "Este es el blog de MaximoFN
"
        "print('Esto no se imprimirá \rEste es el blog de MaximoFN')"
            "Este es el blog de 	MaximoFN
"
        "print('Este es el blog de \tMaximoFN')"
            "Este es el blog deMaximoFN
"
        "print('Este es el blog de \bMaximoFN')"
...
        "funcion2_del_modulo('MaximoFN')"
            "MaximoFN
",
        "  print('MaximoFN')
",
        "  variable = 'MaximoFN'
",

No entanto, se fizermos a mesma busca para o texto maximofn

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!grep maximofn 2021-02-11-Introduccion-a-Python.ipynb
	
	Copied

Não aparece nenhum resultado, isso é porque grep é case sensitive, ou seja, procura o texto exatamente como você o introduziu, diferenciando maiúsculas e minúsculas. Se não quisermos isso, temos que introduzir a flag -i

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		terminal("grep -i MaximoFN 2021-02-11-Introduccion-a-Python.ipynb", max_lines_output=20)
	
	Copied

>_ Output

			
				        "a = 'MaximoFN'
",
              "'MaximoFN'"
        "string = "MaximoFN"
",
              "'MaximoFN'"
        "string = 'MaximoFN'
",
              "'MaximoFN'"
            "Este es el blog de "MaximoFN"
"
        "print("Este es el blog de \"MaximoFN\"")"
            "Este es el blog de 'MaximoFN'
"
        "print('Este es el blog de \'MaximoFN\'')"
            "Este es el blog de \MaximoFN\
"
        "print('Este es el blog de \\MaximoFN\\')"
            "MaximoFN
"
        "print('Este es el blog de \nMaximoFN')"
            "Este es el blog de MaximoFN
"
        "print('Esto no se imprimirá \rEste es el blog de MaximoFN')"
            "Este es el blog de 	MaximoFN
"
        "print('Este es el blog de \tMaximoFN')"
            "Este es el blog deMaximoFN
"
        "print('Este es el blog de \bMaximoFN')"
...
        "funcion2_del_modulo('MaximoFN')"
            "MaximoFN
",
        "  print('MaximoFN')
",
        "  variable = 'MaximoFN'
",

Se o que queremos é que nos devolva o número de vezes que aparece, introduzimos a flag -c

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!grep -c MaximoFN 2021-02-11-Introduccion-a-Python.ipynb
	
	Copied

>_ Output

Se não nos importa se aparece em maiúscula ou minúscula, podemos voltar a adicionar a flag -i, mas não é necessário colocá-la separada da flag -c; elas podem ser introduzidas juntas

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!grep -ci MaximoFN 2021-02-11-Introduccion-a-Python.ipynb
	
	Copied

>_ Output

Se agora queremos todas as vezes em que **não** aparece a palavra MáximoFN, introduzimos o flag -v

	
		
			< >
			Input
		
		
			Python
			
		
	
	
		!grep -cv MaximoFN 2021-02-11-Introduccion-a-Python.ipynb
	
	Copied

>_ Output

---

➡️ **Continua na Parte 2: red, compresión y procesos**, onde você aprenderá a se mover pela rede e a controlar os processos do sistema.

Série completa

Continuar lendo

Deep Research com LangGraph (3/3): agente Writer e relatório final

Terceira e última parte da série Deep Research com LangGraph. Implemente o agente Writer que redige o relatório final a partir da pesquisa, integre todo o grafo do deep researcher e execute o assistente completo de ponta a ponta.

Deep Research com LangGraph (2/3): Research Supervisor multiagente

Segunda parte da série Deep Research com LangGraph. Construa o Research Supervisor que coordena vários agentes Researche...

Deep Research com LangGraph (1/3): agentes Scope e Researcher

Primeira parte da série para criar um assistente de pesquisa com LangGraph. Conheça a arquitetura do sistema e construa ...

Últimos posts -->

Você viu esses projetos?

Gymnasia

Horeca chatbot

Naviground

Ver todos os projetos -->

>_ Disponível para projetos

Tem um projeto com IA?

Vamos conversar.

maximofn@gmail.com

Especialista em Machine Learning e Inteligência Artificial. Desenvolvo soluções com IA generativa, agentes inteligentes e modelos personalizados.

Escreva-me LinkedIn

Quer assistir alguma palestra?

Agentes do Amanhã: Descifrando os Mistérios da Planificação, UX e Memória

Agentes de IA, impulsionados por LLMs, prometem transformar aplicações. Mas eles são meros executores hoje ou futuros colaboradores inteligentes? Para...

Crie sua própria inteligência Apple

Aprenda a criar um sistema de IA para executar eficientemente em um dispositivo

Últimas palestras -->

Quer melhorar com essas dicas?

Boas práticas criando agentes com Claude Code

Palestra técnica: skills, subagentes, slash commands e MCPs no Claude Code

o1 prompt engineering

Criar prompts melhores para o1 seguindo um exemplo

Memory profiler

Ver o uso de memória de um script

Últimos tips -->

Use isso localmente

Os espaços do Hugging Face nos permitem executar modelos com demos muito simples, mas e se a demo quebrar? Ou se o usuário a deletar? Por isso, criei contêineres docker com alguns espaços interessantes, para poder usá-los localmente, aconteça o que acontecer. Na verdade, se você clicar em qualquer botão de visualização de projeto, ele pode levá-lo a um espaço que não funciona.

Flow edit

FLUX.1-RealismLora

token_hmr

Ver todos os contêineres -->

>_ Disponível para projetos

Tem um projeto com IA?

Vamos conversar.

maximofn@gmail.com

Especialista em Machine Learning e Inteligência Artificial. Desenvolvo soluções com IA generativa, agentes inteligentes e modelos personalizados.

Escreva-me LinkedIn

Você quer treinar seu modelo com esses datasets?

short-jokes-dataset

HuggingFace

Dataset com piadas em inglês

Uso: Fine-tuning de modelos de geração de texto humorístico

231K linhas 2 colunas 45 MB

Ver no HuggingFace →

opus100

HuggingFace

Dataset com traduções de inglês para espanhol

Uso: Treinamento de modelos de tradução inglês-espanhol

1M linhas 2 colunas 210 MB

Ver no HuggingFace →

netflix_titles

HuggingFace

Dataset com filmes e séries da Netflix

Uso: Análise de catálogo Netflix e sistemas de recomendação

8.8K linhas 12 colunas 3.5 MB

Ver no HuggingFace →

Ver mais datasets -->

Formato do post

Primeiros comandos para se mover pelo terminal

ls (listar diretório)

cd (mudar de diretório)

pwd (imprimir diretório de trabalho)

Informações de arquivos com file

Manipulando arquivos e diretórios

Árvore de diretórios com tree

Criar pastas com mkdir (make directory)

Criar arquivos com touch

Copiar arquivos com cp (copy)

Mover arquivos com mv (move)

Renomear arquivos com mv (move)

Excluir arquivos com rm (remove)

Eliminar diretórios com rm -r (remove recursive)

Sincronizar arquivos mediante rsync

Explorando o conteúdo dos arquivos

Cabeçalho de arquivos com head

Calda de um arquivo com tail

O visualizador de arquivos mais poderoso: less

O visualizador cat

Editor padrão do sistema xdg-open

Navegador de arquivos nautilus

Contador de palavras de um arquivo com wc (word count)

O que é um comando?

O que é um alias?

Ajuda dos comandos

Ajuda com help

Manual com man

Informação com info

Informação de um comando com whatis

Wildcards

Todos os caracteres *

Números ?

Maiúsculas [[:upper:]]

Minúsculas [[:lower:]]

Classes

Redirecionamentos: como funciona o shell

Redirecionamento da standard output

Redirecionamento do standard error

Redirecionamento de standard output e de standard error

Pipelines

Operadores de controle - encadear comandos

Comandos de maneira sequencial

Comandos de maneira paralela

Comandos de maneira condicional

E

Ou

Como são gerenciadas as permissões

Modificando as permissões no terminal

Alteração de permissões com chmod (change mode)

Identificação de usuário com whoami

Informações do usuário com id

Mudança de usuário com o comando su (switch user)

Modificar a senha de um usuário

Links simbólicos

Configurar as variáveis de ambiente

Ver as variáveis de ambiente com printenv

Ver uma variável de ambiente com o comando echo

Modificar uma variável de ambiente para uma sessão de terminal

Modificar uma variável de ambiente para todas as sessões de terminal

Criar alias para todas as sessões

Comandos de pesquisa

Busca de binários com which

Busca de arquivos com find

Comando de busca grep

Série completa

Continuar lendo

Deep Research com LangGraph (3/3): agente Writer e relatório final

Deep Research com LangGraph (2/3): Research Supervisor multiagente

Deep Research com LangGraph (1/3): agentes Scope e Researcher

Você viu esses projetos?

Tem um projeto com IA?

Quer assistir alguma palestra?

Agentes do Amanhã: Descifrando os Mistérios da Planificação, UX e Memória

Crie sua própria inteligência Apple

Quer melhorar com essas dicas?

Boas práticas criando agentes com Claude Code

o1 prompt engineering

Memory profiler

`ls` (listar diretório)

`cd` (mudar de diretório)

`pwd` (imprimir diretório de trabalho)

Informações de arquivos com `file`

Árvore de diretórios com `tree`

Criar pastas com `mkdir` (make directory)

Criar arquivos com `touch`

Copiar arquivos com `cp` (copy)

Mover arquivos com `mv` (move)

Renomear arquivos com `mv` (move)

Excluir arquivos com `rm` (remove)

Eliminar diretórios com `rm -r` (remove recursive)

Sincronizar arquivos mediante `rsync`

Cabeçalho de arquivos com `head`

Calda de um arquivo com `tail`

O visualizador de arquivos mais poderoso: `less`

O visualizador `cat`

Editor padrão do sistema `xdg-open`

Navegador de arquivos `nautilus`

Contador de palavras de um arquivo com `wc` (word count)

Ajuda com `help`

Manual com `man`

Informação com `info`

Informação de um comando com `whatis`

Todos os caracteres `*`

Números `?`

Maiúsculas `[[:upper:]]`

Minúsculas `[[:lower:]]`

Redirecionamento da `standard output`

Redirecionamento do `standard error`

Redirecionamento de `standard output` e de `standard error`

Alteração de permissões com `chmod` (change mode)

Identificação de usuário com `whoami`

Informações do usuário com `id`

Mudança de usuário com o comando `su` (switch user)

Ver as variáveis de ambiente com `printenv`

Ver uma variável de ambiente com o comando `echo`

Busca de binários com `which`

Busca de arquivos com `find`

Comando de busca `grep`