A Biblioteca os do Python: para que serve o import os

✅ Artigo atualizado em Setembro 2026 Corrigimos a descrição do os.name (é um atributo, não uma função), o exemplo de variável de ambiente para funcionar em Linux, macOS e Windows, e incluímos o subprocess, recomendado pela documentação oficial no lugar do os.system(). Também adicionamos como listar, criar, renomear e remover arquivos e pastas, a comparação entre os.path e pathlib, os erros mais comuns com o traceback real e 8 exercícios resolvidos.

1
2
3
4
5
6

import os

os.makedirs('relatorios/2026', exist_ok=True)   # cria as pastas
print(os.path.join('relatorios', '2026', 'vendas.csv'))  # relatorios/2026/vendas.csv
print(os.listdir('relatorios'))                 # ['2026']
print(os.getenv('MODO', 'dev'))                 # dev (valor padrão)

Salve salve Pythonista 👋

Neste artigo, vamos explorar o módulo os do Python e como ele pode ser utilizado para obter informações do sistema operacional.

Entender como o Python interage com o sistema operacional é fundamental para desenvolver programas mais poderosos e flexíveis.

Portanto, é importante conhecer as funcionalidades que o módulo os oferece.

Então bora nessa!

Vá Direto ao Assunto…

• Introdução
• Principais funções do módulo os
• Descobrindo informações do sistema
• Navegando por diretórios
• Listando, criando e removendo arquivos e pastas
• os.path vs pathlib: qual usar
• Executando comandos no terminal
• Erros comuns
• Exercícios resolvidos

Introdução

O módulo os em Python é uma biblioteca padrão muito útil quando se trata de interagir com o sistema operacional.

Ele nos fornece uma série de funcionalidades para executar ações específicas, como navegar por diretórios, criar novos diretórios, executar comandos no terminal e obter informações do sistema.

Essas informações podem ser vitais para realizar ações específicas dependendo do sistema operacional em que o código Python está sendo executado.

Ele faz parte da biblioteca padrão, então não precisa instalar nada: basta um import os no topo do arquivo.

Principais funções do módulo os

Antes de ver cada recurso em detalhe, aqui vai o mapa das funções que você mais vai usar no dia a dia (e que mais caem em prova):

Tudo o que envolve caminhos (os.path) também pode ser feito com o módulo pathlib, que é a forma moderna. Comparamos os dois na seção os.path vs pathlib: qual usar.

Descobrindo informações do sistema

O módulo os nos fornece uma maneira fácil de obter informações do sistema operacional com apenas uma linha de código.

Por exemplo, para saber em que tipo de sistema operacional o código está rodando, podemos consultar o atributo os.name (repare que ele não é uma função: não usamos parênteses, é só uma string).

1
2
3

import os

print(os.name)

A saída desse código indica a família do sistema operacional em que o código Python está sendo executado (tecnicamente, o nome do módulo dependente de sistema que o os carregou).

Para sistemas baseados em UNIX (Linux e macOS), a saída será posix, enquanto para Windows, a saída será nt.

Se você precisar de mais detalhes, como diferenciar Linux de macOS, use platform.system() (retorna 'Linux', 'Darwin' ou 'Windows') ou sys.platform.

Essas informações podem ser úteis para realizar ações condicionais dependendo do sistema operacional.

Outro recurso importante fornecido pelo módulo os é o os.environ.

Ele é um objeto que funciona como um dicionário com as variáveis de ambiente do sistema. Podemos usá-lo para acessar variáveis específicas e seus valores.

1
2
3
4
5

import os

# USER no Linux/macOS, USERNAME no Windows
username = os.environ.get('USER') or os.environ.get('USERNAME')
print(f"Username: {username}")

Ao executar esse código, será impresso o nome de usuário do sistema operacional em que o código está sendo executado.

O nome da variável muda de um sistema para outro: no Linux e no macOS ela se chama USER, e no Windows, USERNAME. Por isso tentamos as duas. Como usamos .get(), se a variável não existir o resultado é None, em vez de um KeyError.

O atalho os.getenv('NOME', 'padrao') faz o mesmo que os.environ.get('NOME', 'padrao'). Um uso prático: ao ativar um ambiente virtual, o script de ativação define a variável VIRTUAL_ENV, então os.getenv('VIRTUAL_ENV') devolve o caminho do venv quando ele está ativo e None quando não está.

Aqui no meu PC por exemplo, a saída é:

1

Username: viniciusramos

Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

Navegando por diretórios

O módulo os também nos permite navegar pelo sistema de arquivos e manipular diretórios.

Podemos utilizar a função os.getcwd() para obter o diretório atual em que o código está sendo executado.

1
2
3
4

import os

diretorio_atual = os.getcwd()
print(f"Diretório atual: {diretorio_atual}")

Essa função retorna o caminho completo do diretório atual, o que pode ser útil para realizar operações específicas em arquivos ou diretórios nesse local.

Além disso, podemos utilizar as funções os.chdir() e os.mkdir() para mudar o diretório atual e criar novos diretórios, respectivamente.

1
2
3
4

import os

os.chdir('caminho/para/diretorio')
os.mkdir('novo_diretorio')

Essas operações são úteis quando precisamos manipular arquivos em diretórios específicos ou criar novos diretórios para armazenar arquivos gerados pelo nosso código.

Criei o Ebookr.ai, uma plataforma que usa IA para gerar ebooks profissionais sobre qualquer tema - com capa gerada por IA, infográficos automáticos e exportação em PDF. Confere!

Listando, criando e removendo arquivos e pastas

Na prática, a maior parte do uso do os é organizar arquivos: criar a pasta de saída de um relatório, listar as planilhas de um diretório, renomear fotos, apagar arquivos temporários. Rode os exemplos abaixo numa pasta de testes para não mexer nos seus arquivos de verdade.

Para criar pastas, prefira os.makedirs() com exist_ok=True: ele cria todos os níveis que faltarem e não dá erro se a pasta já existir. Para listar o conteúdo, use os.listdir(), e para testar se algo existe, os.path.exists(), os.path.isdir() e os.path.isfile():

1
2
3
4
5
6
7
8
9
10
11
12
13

import os

os.makedirs('projeto/dados', exist_ok=True)
os.makedirs('projeto/dados', exist_ok=True)  # não dá erro na 2ª vez

with open(os.path.join('projeto', 'dados', 'vendas.csv'), 'w') as f:
    f.write('produto,valor\n')

print(os.listdir('projeto'))
print(os.listdir(os.path.join('projeto', 'dados')))
print(os.path.exists('projeto/dados/vendas.csv'))
print(os.path.isdir('projeto/dados'))
print(os.path.isfile('projeto/dados'))

Saída:

1
2
3
4
5

['dados']
['vendas.csv']
True
True
False

Repare que os.listdir() devolve só os nomes, sem o caminho completo, e não garante ordem (use sorted() se a ordem importar). Se quiser saber mais sobre o open() usado acima, veja o post sobre como escrever em arquivos no Python.

Para renomear (ou mover) use os.rename(), para apagar um arquivo os.remove() e para apagar uma pasta vazia os.rmdir():

1
2
3
4
5
6
7
8
9
10
11
12

import os

origem = os.path.join('projeto', 'dados', 'vendas.csv')
destino = os.path.join('projeto', 'dados', 'vendas_2026.csv')

os.rename(origem, destino)
print(os.listdir('projeto/dados'))

os.remove(destino)               # apaga o arquivo
os.rmdir('projeto/dados')        # apaga a pasta (precisa estar vazia)
os.rmdir('projeto')
print(os.path.exists('projeto'))

Saída:

1
2

['vendas_2026.csv']
False

O os.rmdir() só aceita pasta vazia. Para apagar uma pasta com tudo o que tem dentro, use shutil.rmtree('pasta'), do módulo shutil, com cuidado: ele não manda nada para a lixeira.

Juntando e separando caminhos com os.path

Montar caminhos concatenando strings ('dados' + '/' + nome) quebra quando o código roda no Windows, que usa \ como separador. O os.path.join() usa o separador certo para o sistema, e o os.path traz funções para desmontar um caminho:

1
2
3
4
5
6
7
8

import os

caminho = os.path.join('relatorios', '2026', 'vendas.csv')

print(caminho)                     # no Windows: relatorios\2026\vendas.csv
print(os.path.basename(caminho))   # nome do arquivo
print(os.path.dirname(caminho))    # pasta
print(os.path.splitext(caminho))   # (resto, extensão)

Saída no Linux e no macOS:

1
2
3
4

relatorios/2026/vendas.csv
vendas.csv
relatorios/2026
('relatorios/2026/vendas', '.csv')

Um detalhe que pega muita gente: se uma das partes começar com /, o join descarta tudo o que veio antes. os.path.join('dados', '/vendas.csv') resulta em '/vendas.csv', e não em 'dados/vendas.csv'.

Percorrendo subpastas com os.walk

O os.listdir() olha só um nível. Para visitar uma pasta e todas as subpastas, use os.walk(), que a cada passo entrega uma tupla com a pasta atual, a lista de subpastas e a lista de arquivos. Ele combina bem com um laço for:

1
2
3
4
5
6

import os

# estrutura: site/index.html, site/css/estilo.css, site/img/logo.png
for pasta, subpastas, arquivos in os.walk('site'):
    subpastas.sort()   # garante a visita em ordem alfabética
    print(pasta, subpastas, sorted(arquivos))

Saída:

1
2
3

site ['css', 'img'] ['index.html']
site/css [] ['estilo.css']
site/img [] ['logo.png']

Esse padrão é a base de scripts que processam uma pasta inteira de arquivos, como no post em que mostramos como automatizar planilhas do Excel com Python.

os.path vs pathlib: qual usar

Desde o Python 3.4 existe o módulo pathlib, que trata caminhos como objetos Path em vez de strings. Ele faz tudo o que o os.path faz com uma sintaxe mais legível, e é a forma recomendada para código novo. O os não ficou obsoleto: ele continua sendo o lugar das variáveis de ambiente e de funções do sistema, e todas as suas funções aceitam objetos Path.

Veja a mesma tarefa escrita dos dois jeitos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import os
from pathlib import Path

# Com os.path
os.makedirs(os.path.join('dados', '2026'), exist_ok=True)
arquivo = os.path.join('dados', '2026', 'vendas.csv')
with open(arquivo, 'w') as f:
    f.write('produto,valor\n')
print(os.path.exists(arquivo), os.path.splitext(arquivo)[1])

# Com pathlib
pasta = Path('dados') / '2026'
pasta.mkdir(parents=True, exist_ok=True)
arquivo = pasta / 'vendas.csv'
arquivo.write_text('produto,valor\n')
print(arquivo.exists(), arquivo.suffix)
print([p.name for p in pasta.iterdir()])

Saída:

1
2
3

True .csv
True .csv
['vendas.csv']

Para decidir rápido:

Automatizar tarefas do sistema é um dos usos mais práticos de Python, e evolui rápido quando funções e tratamento de erros já estão bem internalizados. É esse tipo de base que você treina na Jornada Python, do fundamento ao projeto:

Domine Python: A Linguagem da Inteligência Artificial, do Desenvolvimento Web e das Carreiras do Futuro.

A mais completa formação para você se tornar um especialista em Python, pronto para construir desde aplicações web robustas com Django até projetos de Inteligência Artificial e Ciência de Dados .

Quero conhecer!

Nota 4,9 de 5 na Hotmart O curso de Python mais bem avaliado da Hotmart!

Executando comandos no terminal

O módulo os também nos permite executar comandos diretamente no terminal. Podemos utilizar a função os.system() para isso.

1
2
3

import os

os.system('ls')  # comando do terminal no Linux ou macOS

Esse código executa o comando ls no terminal e exibe o resultado.

No exemplo acima, estamos usando o comando ls do Linux ou macOS.

Para sistemas operacionais Windows, podemos substituir o comando por algo como dir.

O os.system() devolve apenas o código de saída do comando (0 quando deu certo); a saída do comando vai direto para o terminal e não fica disponível para o seu programa.

Por isso, a própria documentação oficial recomenda usar o módulo subprocess, que é mais poderoso. Com o subprocess.run(), você passa o comando como uma lista de argumentos (sem passar pelo shell, o que evita problemas com espaços e caracteres especiais vindos de entrada do usuário) e pode capturar a saída:

1
2
3
4
5

import subprocess

resultado = subprocess.run(['ls'], capture_output=True, text=True)
print(resultado.returncode)
print(resultado.stdout)

Num diretório com os arquivos dados.csv e main.py, a saída será:

1
2
3

0
dados.csv
main.py

Aqui, returncode é o código de saída do comando e stdout guarda o texto que ele imprimiu, pronto para ser usado no seu código. Para código novo, prefira o subprocess ao os.system().

Erros comuns

Quase todo erro do módulo os é uma subclasse de OSError, e a mensagem sempre mostra o caminho que deu problema. Leia essa última linha com atenção: ela costuma dizer exatamente o que corrigir. Para tratar esses erros sem derrubar o programa, veja o post sobre tratamento de erros e exceções no Python.

1. FileNotFoundError ao listar ou abrir um caminho que não existe

1
2
3

import os

os.listdir('pasta_que_nao_existe')

1

FileNotFoundError: [Errno 2] No such file or directory: 'pasta_que_nao_existe'

O caminho relativo é resolvido a partir da pasta atual (os.getcwd()), que nem sempre é a pasta do seu script. Confira com print(os.getcwd()), use caminhos absolutos ou teste antes com os.path.exists(). O mesmo erro aparece em os.mkdir('dados/2026') quando a pasta dados ainda não existe: nesse caso, troque por os.makedirs().

2. FileExistsError ao criar uma pasta que já existe

1
2
3
4

import os

os.mkdir('saida')
os.mkdir('saida')   # rodou o script pela 2ª vez

1

FileExistsError: [Errno 17] File exists: 'saida'

Na segunda execução a pasta já está lá. Use os.makedirs('saida', exist_ok=True) (ou Path('saida').mkdir(exist_ok=True)), que simplesmente segue em frente se a pasta existir.

3. OSError ao remover uma pasta que não está vazia com os.rmdir()

1
2
3
4
5

import os

os.makedirs('saida', exist_ok=True)
open('saida/log.txt', 'w').close()
os.rmdir('saida')

1

OSError: [Errno 39] Directory not empty: 'saida'

O os.rmdir() só apaga pasta vazia (a mensagem acima é a do Linux; no Windows o texto muda, mas a causa é a mesma). Apague os arquivos antes com os.remove() ou use shutil.rmtree('saida') para remover a pasta com todo o conteúdo. E se tentar apagar uma pasta com os.remove(), o Linux responde IsADirectoryError: [Errno 21] Is a directory: 'saida'.

4. PermissionError ao acessar uma pasta sem permissão

1
2
3

import os

os.listdir('/root')   # rodando como usuário comum no Linux

1

PermissionError: [Errno 13] Permission denied: '/root'

Seu usuário não tem permissão de leitura ou escrita naquele caminho. Trabalhe dentro da sua pasta pessoal ou de uma pasta temporária (tempfile.gettempdir()). No Windows, esse erro também aparece ao apagar ou renomear um arquivo que está aberto em outro programa (como uma planilha aberta no Excel): feche o arquivo e tente de novo.

5. KeyError ao ler variável de ambiente com os.environ[...]

1
2
3

import os

print(os.environ['API_KEY'])

1

KeyError: 'API_KEY'

O os.environ se comporta como dicionário: chave inexistente gera KeyError. Se a variável for opcional, use os.getenv('API_KEY'), que devolve None, ou os.getenv('API_KEY', 'sem-chave'), que devolve o valor padrão. Deixe o os.environ[...] para variáveis obrigatórias, em que parar com erro é o comportamento certo.

Exercícios resolvidos

Todos os exercícios que criam arquivos usam tempfile.TemporaryDirectory(), que cria uma pasta temporária e a apaga sozinha ao sair do bloco with. Assim você pode rodar à vontade sem sujar o seu computador.

Exercício 1. Crie, numa pasta temporária, os arquivos notas.txt, dados.csv e fotos.zip (vazios) e imprima a lista dos nomes em ordem alfabética.

1
2
3
4
5
6
7

import os
import tempfile

with tempfile.TemporaryDirectory() as tmp:
    for nome in ['notas.txt', 'dados.csv', 'fotos.zip']:
        open(os.path.join(tmp, nome), 'w').close()
    print(sorted(os.listdir(tmp)))

Exercício 2. Numa pasta com jan.csv, fev.csv, leia-me.txt e mar.CSV, liste apenas os arquivos CSV, sem diferenciar maiúsculas de minúsculas na extensão.

1
2
3
4
5
6
7
8
9
10

import os
import tempfile

with tempfile.TemporaryDirectory() as tmp:
    for nome in ['jan.csv', 'fev.csv', 'leia-me.txt', 'mar.CSV']:
        open(os.path.join(tmp, nome), 'w').close()

    csvs = [nome for nome in os.listdir(tmp)
            if os.path.splitext(nome)[1].lower() == '.csv']
    print(sorted(csvs))

Exercício 3. (Questão de prova) Qual comando cria a pasta dados/2026 mesmo que a pasta dados ainda não exista, sem dar erro se ela já existir?

a) os.mkdir('dados/2026')
b) os.makedirs('dados/2026', exist_ok=True)
c) os.chdir('dados/2026')
d) os.path.join('dados', '2026')

1
2
3
4
5
6
7

import os
import tempfile

with tempfile.TemporaryDirectory() as tmp:
    destino = os.path.join(tmp, 'dados', '2026')
    os.makedirs(destino, exist_ok=True)
    print(os.path.isdir(destino))

Exercício 4. (Questão de prova) Um estudante executou import os e depois print(os.name) num computador com Linux. O que aparece na tela?

a) Linux
b) posix
c) Um erro, porque o correto é os.name()
d) nt

Exercício 5. Dada uma pasta com subpastas (img/a.png, img/b.png, docs/c.pdf, docs/antigos/d.pdf, docs/antigos/e.txt e leia-me.txt na raiz), conte quantos arquivos existem de cada extensão, incluindo as subpastas.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import os
import tempfile
from collections import Counter

with tempfile.TemporaryDirectory() as tmp:
    os.makedirs(os.path.join(tmp, 'img'))
    os.makedirs(os.path.join(tmp, 'docs', 'antigos'))
    arquivos = ['img/a.png', 'img/b.png', 'docs/c.pdf',
                'docs/antigos/d.pdf', 'docs/antigos/e.txt', 'leia-me.txt']
    for rel in arquivos:
        open(os.path.join(tmp, rel), 'w').close()

    contagem = Counter()
    for pasta, subpastas, nomes in os.walk(tmp):
        for nome in nomes:
            extensao = os.path.splitext(nome)[1]
            contagem[extensao] += 1

    print(dict(sorted(contagem.items())))

Exercício 6. Leia a variável de ambiente MODO_APP usando 'desenvolvimento' como valor padrão. Depois, defina-a como 'producao' dentro do programa e leia de novo.

1
2
3
4
5
6

import os

print(os.getenv('MODO_APP', 'desenvolvimento'))

os.environ['MODO_APP'] = 'producao'   # vale só para este processo
print(os.getenv('MODO_APP', 'desenvolvimento'))

1
2

desenvolvimento
producao

Exercício 7. Reescreva com pathlib: crie a pasta saida/logs (com os níveis intermediários), grave iniciado no arquivo app.log e mostre se ele existe, o nome, a extensão e o conteúdo.

1
2
3
4
5
6
7
8
9
10
11
12

import tempfile
from pathlib import Path

with tempfile.TemporaryDirectory() as tmp:
    pasta = Path(tmp) / 'saida' / 'logs'
    pasta.mkdir(parents=True, exist_ok=True)

    arquivo = pasta / 'app.log'
    arquivo.write_text('iniciado\n')

    print(arquivo.exists(), arquivo.name, arquivo.suffix)
    print(arquivo.read_text().strip())

1
2

True app.log .log
iniciado

Exercício 8. Numa pasta com foto1.jpg, foto2.jpg e notas.txt, renomeie só as fotos acrescentando o prefixo ferias_.

1
2
3
4
5
6
7
8
9
10
11
12
13

import os
import tempfile

with tempfile.TemporaryDirectory() as tmp:
    for nome in ['foto1.jpg', 'foto2.jpg', 'notas.txt']:
        open(os.path.join(tmp, nome), 'w').close()

    for nome in os.listdir(tmp):
        if nome.endswith('.jpg'):
            os.rename(os.path.join(tmp, nome),
                      os.path.join(tmp, 'ferias_' + nome))

    print(sorted(os.listdir(tmp)))

Quer praticar esse tipo de automação com projetos guiados, do básico ao avançado? Conheça o nosso curso de Python completo, a Jornada Python.

Conclusão

O módulo os em Python é extremamente útil para interagir com o sistema operacional de maneira eficiente.

Com ele, podemos obter informações do sistema, navegar por diretórios, criar novos diretórios e executar comandos no terminal (neste último caso, preferindo o módulo subprocess).

Com isso, podemos criar aplicativos mais poderosos e flexíveis, adaptando-os às necessidades específicas do ambiente em que serão executados.

Neste artigo, exploramos apenas algumas funcionalidades básicas do módulo os.

No entanto, existem muitas outras funcionalidades disponíveis para você explorar.

Recomendo que você consulte a documentação oficial do módulo os para conhecer as outras funções, e que experimente o pathlib nos seus próximos scripts.

Agora que você possui esse conhecimento, aproveite para melhorar suas habilidades em Python e desenvolver aplicações ainda mais robustas!

Por Vinícius Ramos em 07/07/2023

Engenheiro de Computação pela UnB com especialização em Inteligência Artificial. Sr. Software Engineer com 10+ anos de experiência desenvolvendo sistemas críticos em Python e Django. Atuei no Banco do Brasil liderando equipes para monitoramento de mainframe, trabalhei como desenvolvedor sênior em projetos forenses para a Polícia Federal, e atualmente sou engenheiro de software na Labcorp (Estados Unidos), desenvolvendo soluções escaláveis para testes genéticos. Fundador da Python Academy, compartilhando conhecimento técnico com a comunidade brasileira desde 2018.

Bora se conectar no LinkedIn! vinicius-aramos

Minhas redes:

• 
• 
•