HOWTO · Python

Obtenha o número de linhas em um arquivo em Python

Este tutorial explica como obter o número total de linhas em um arquivo em Python.

Nesta página

Para contar as linhas de um arquivo de texto, percorra o arquivo aberto e some uma unidade para cada linha. A leitura é incremental, por isso essa é uma boa opção geral mesmo quando o arquivo é grande demais para caber na memória. O iterador de arquivos de texto do Python reconhece os finais de linha e também considera uma linha final sem terminador.

Execute este exemplo:

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as directory:
    path = Path(directory) / "notes.txt"
    path.write_text("alpha\nbeta\ngamma\n", encoding="utf-8")

    with path.open(encoding="utf-8") as file:
        line_count = sum(1 for line in file)

    print(line_count)
3

A instrução with fecha o arquivo mesmo se ocorrer um erro durante a leitura. sum() consome o gerador à medida que o arquivo é lido; não cria uma lista com todas as linhas. Se o arquivo for fornecido por um usuário, substitua o caminho temporário pelo caminho desse arquivo. Se não for possível abri-lo, o Python informa o erro correspondente, como FileNotFoundError. (open())

Conte linhas percorrendo um arquivo

Um loop for oferece o mesmo comportamento incremental quando você quer fazer algo com cada linha enquanto conta. O objeto de arquivo fornece uma linha de texto por vez, incluindo o terminador de linha quando houver. A linha final também é contada se não terminar com uma nova linha.

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as directory:
    path = Path(directory) / "records.txt"
    path.write_text("first\nsecond\nthird", encoding="utf-8")

    line_count = 0
    with path.open(encoding="utf-8") as file:
        for line in file:
            line_count += 1

    print(line_count)
3

Essa abordagem usa memória para a linha atual, em vez de para o arquivo inteiro. Em geral, é a opção mais clara para arquivos de texto comuns. A forma com gerador acima é mais curta quando a única tarefa é contar.

Conte linhas com readlines()

readlines() lê todas as linhas e retorna uma lista. O comprimento da lista corresponde à quantidade de linhas, mas a lista e suas strings ocupam memória proporcional ao tamanho do arquivo. Use essa opção quando também precisar das linhas depois e o arquivo couber confortavelmente na memória; para apenas contar, a iteração evita mantê-las todas na memória.

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as directory:
    path = Path(directory) / "records.txt"
    path.write_text("first\nsecond\nthird\n", encoding="utf-8")

    with path.open(encoding="utf-8") as file:
        lines = file.readlines()

    print(len(lines))
3

Conte linhas em blocos com read()

Para um arquivo grande que precise ser lido em blocos de tamanho limitado, abra-o em modo binário e conte os bytes que representam finais de linha em cada bloco. Este exemplo trata LF, CRLF e CR isolado como finais de linha, inclusive quando um par CRLF fica dividido entre dois blocos. Um byte final que não seja um terminador inicia uma última linha sem terminação. Essa abordagem orientada a bytes pressupõe uma codificação compatível com ASCII, como UTF-8; para texto em outra codificação ou para obter o comportamento de linhas de texto decodificadas pelo Python, prefira a iteração em modo texto.

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

from pathlib import Path
from tempfile import TemporaryDirectory

chunk_size = 4
with TemporaryDirectory() as directory:
    path = Path(directory) / "records.txt"
    path.write_bytes(b"one\r\ntwo\nthree\rfour")

    line_count = 0
    previous = None
    last = None
    with path.open("rb") as file:
        while chunk := file.read(chunk_size):
            for byte in chunk:
                if byte == 10:
                    if previous != 13:
                        line_count += 1
                elif byte == 13:
                    line_count += 1
                previous = byte
                last = byte

    if last is not None and last not in (10, 13):
        line_count += 1
    print(line_count)
4

O estado carregado (previous e last) preserva as informações necessárias nas fronteiras entre blocos e no fim do arquivo. Cada leitura é limitada a chunk_size, mantendo o uso de memória limitado. Escolha um bloco maior para reduzir o número de operações de leitura. Se o arquivo puder mudar durante a contagem, o resultado talvez reflita uma mistura do conteúdo anterior e do novo; coordene o acesso quando precisar de uma captura consistente.

Conte linhas com mmap.mmap()

mmap.mmap() cria uma visualização do arquivo mapeada na memória; não é uma função de contagem de linhas. O mapeamento pode ser útil quando uma carga de trabalho exige acesso direto a um arquivo grande, mas envolve considerações de configuração e compatibilidade com a plataforma. Para uma contagem simples, a iteração em fluxo costuma ser mais fácil. O exemplo usa um mapeamento somente para leitura e conta bytes LF: cada LF encerra um registro, e uma sequência final de bytes sem terminador acrescenta mais um. Como CRLF contém LF, ele é tratado como um único terminador; CR isolado não é considerado final de linha.

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

import mmap
from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as directory:
    path = Path(directory) / "records.txt"
    path.write_bytes(b"first\nsecond\nthird")

    with path.open("rb") as file:
        if path.stat().st_size == 0:
            line_count = 0
        else:
            with mmap.mmap(file.fileno(), 0, access=mmap.ACCESS_READ) as mapped:
                line_count = 0
                position = 0
                while True:
                    position = mapped.find(b"\n", position)
                    if position == -1:
                        break
                    line_count += 1
                    position += 1
                if mapped[-1] != 10:
                    line_count += 1

    print(line_count)
3

Um arquivo de tamanho zero não pode ser mapeado com comprimento zero, então verifique o tamanho antes. Os gerenciadores de contexto aninhados liberam tanto o mapeamento quanto o identificador do arquivo. O suporte e o comportamento do mapeamento dependem do sistema operacional e do arquivo; use uma leitura em fluxo comum se o mapeamento não estiver disponível ou se a configuração não compensar. Este exemplo baseado em bytes conta registros delimitados por LF, inclusive um registro final sem LF; bytes CR isolados não são contados como finais de linha. Use a iteração em modo texto quando precisar de texto decodificado e do tratamento de novas linhas universais do Python.

Escolha um método para contar linhas

Use sum(1 for line in file) ou um loop for para uma contagem direta com baixo uso de memória. Escolha readlines() quando a própria lista for útil e couber na memória. Use read() em blocos quando precisar especificamente de leituras binárias limitadas e puder definir como os bytes representam os finais de linha. Considere mmap.mmap() somente quando o mapeamento na memória fizer sentido para a carga de trabalho mais ampla; ele não torna a contagem inerentemente mais rápida e exige um arquivo não vazio e a liberação confiável dos recursos.

A iteração em modo texto aplica o tratamento de novas linhas universais do Python: \n, \r\n e \r são reconhecidos como finais de linha quando o arquivo é aberto no modo texto padrão. Um terminador de linha no fim do arquivo não cria uma linha em branco adicional após o registro final. Um arquivo vazio resulta em uma contagem igual a zero, enquanto um texto não vazio sem terminador final ainda tem uma última linha. Esse comportamento difere de uma simples contagem de b"\n", que não detecta finais CR isolados nem considera uma última linha sem terminador. Escolha o método adequado à codificação do arquivo e à definição exata de linha exigida pela sua aplicação.