Skip to content
This page has been auto-translated and may contain errors.View in English

Saída e entrada de dados ​

Duas ferramentas que você vai usar desde a primeira linha que escrever: print() mostra valores no terminal, input() pega texto digitado pelo usuário. São simples, mas entender como elas se comportam evita algumas surpresas no início.

print() e input() são as funções padrão de entrada e saída do Python no terminal. As duas têm mais opções de configuração do que parece a princípio. print() aceita argumentos que controlam como os valores são unidos e onde a saída termina. input() sempre retorna uma string, o que influencia como você deve tratar todo valor vindo do usuário.

Por baixo dos panos, print() escreve em sys.stdout e input() lê de sys.stdin (os fluxos padrão de saída e entrada aos quais seu terminal está conectado). Os dois trabalham apenas com texto, e a saída é bufferizada por padrão: o Python guarda o conteúdo por um instante e escreve em blocos, em vez de caractere por caractere. Duas consequências importam na prática: a saída vai para um fluxo diferente dos erros (stdout versus stderr), e você pode forçar esse buffer a ser esvaziado quando precisar que a saída apareça imediatamente.

Como o Python executa seu código ​

O Python executa seu código de cima para baixo, uma linha por vez, exatamente na ordem em que você escreveu. Sem pular partes. A ordem em que você escreve as coisas é a ordem em que elas rodam. Sempre.

python
city = "São Paulo"
print(city)
print("Population: 14 million")

city recebe o valor primeiro. O primeiro print roda. O segundo print roda. Sempre nessa ordem.

Isso é importante porque você não pode usar uma variável antes de tê-la atribuído. O Python ainda não a conhece e vai gerar um erro:

python
print(country)   # NameError: country is not defined yet
country = "Japan"

Guarde isso conforme seus programas forem crescendo: tudo que você usar precisa ser definido antes de ser usado.

O Python usa execução sequencial: cada instrução é avaliada no momento em que é encontrada, numa única passagem do arquivo de cima para baixo. Não existe uma pré-leitura de todo o arquivo antes. Referenciar um nome antes de ele ser atribuído gera um NameError exatamente naquela linha, não antes.

python
city = "São Paulo"
print(city)             # works: city is already bound
print(country)          # NameError: not yet assigned
country = "Japan"

A regra: as dependências precisam ser definidas antes da linha que as usa.

O Python executa seu arquivo em uma única passagem de cima para baixo, e ele só busca um nome no momento em que aquela linha realmente é executada, não quando lê o arquivo pela primeira vez. É por isso que um nome ausente gera um NameError em tempo de execução (quando a linha é executada), e não um erro no instante em que você salva o arquivo. Não existe hoisting (o jeito como o JavaScript move silenciosamente as declarações var para o topo do escopo) nem declarações antecipadas (como em C, onde você pode prometer um nome agora e defini-lo depois). Um nome passa a existir no momento em que é atribuído, e qualquer uso antes disso gera um erro.

python
print(country)   # NameError at runtime, not a syntax error
country = "Japan"
JunoComo o Python executa seu código O Python lê seu arquivo de cima para baixo, uma linha por vez, na ordem em que você escreveu. A pegadinha que engana todo mundo uma vez: um nome precisa existir antes da linha que o usa, senão você recebe um NameError. Sem pular partes, sem ler o arquivo inteiro antes.
JunoComo o Python executa seu código De cima para baixo, uma única passagem, em ordem. Um nome precisa ser atribuído antes de qualquer linha que o use, senão é um NameError exatamente naquela linha. Não há pré-leitura do arquivo.
JunoComo o Python executa seu código Uma única passagem de cima para baixo, com os nomes sendo buscados conforme cada linha é executada. Use um nome antes de ele ser atribuído e você recebe um NameError em tempo de execução, não um erro de sintaxe. O Python não faz hoisting e não tem declarações antecipadas, então a ordem realmente é tudo.

Exibindo saída ​

print() é como o Python conversa com você. Passe qualquer valor para ela e ela exibe esse valor. Ela converte automaticamente o que você passar para texto.

print() converte cada argumento em string usando str(), junta tudo com um separador (um espaço por padrão) e, em seguida, escreve o resultado seguido de uma nova linha na saída padrão. Entender os valores padrão torna os argumentos opcionais mais previsíveis.

A assinatura completa de print() é print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False). O coletor *objects aceita qualquer número de argumentos posicionais e chama str() em cada um deles. sep e end controlam a formatação; file redireciona a saída para qualquer fluxo em que se possa escrever; flush força o buffer a ser esvaziado imediatamente.

python
print("Hello")    # Hello
print(42)         # 42
print(3.14)       # 3.14
print(True)       # True

Vários valores ​

Você pode exibir vários valores de uma vez separando-os por vírgulas. Por padrão, o Python coloca um espaço entre eles. Mude o separador com sep:

Cada argumento posicional é convertido individualmente com str() e depois unido pelo sep. O sep padrão é um único espaço. Sobrescrevê-lo permite produzir saída formatada sem concatenação de strings:

print() não monta uma string só e a escreve; ela escreve cada argumento no fluxo, um por vez (chamando str() em cada um), com sep entre eles e end no final. Como essas escritas acontecem uma a uma, e não como uma única operação bloqueada, duas chamadas de print() rodando ao mesmo tempo (em threads diferentes) podem intercalar suas saídas. Quando isso importa, monte uma única string e imprima-a de uma vez. Para o uso do dia a dia, sobrescrever sep ainda é melhor do que colar strings manualmente:

python
name = "Alice"
age = 28
print(name, age)                        # Alice 28
print("Name:", name)                    # Name: Alice
print("2024", "01", "15", sep="-")     # 2024-01-15
print("a", "b", "c", sep=", ")         # a, b, c

Controlando o final da linha ​

Por padrão, cada chamada de print() termina com uma nova linha, então a próxima saída começa numa linha nova. Mude isso com end. Definir end="" faz o próximo print continuar na mesma linha:

O parâmetro end substitui a nova linha padrão. Defina-o como "" para suprimir a quebra de linha, como " " para continuar na mesma linha com um espaço, ou como qualquer outra string. Combinado com sep, você consegue produzir a maioria dos formatos de saída sem montar strings manualmente:

sep e end são parâmetros somente por nome (você os passa nomeando-os, como end="", nunca por posição), com valores padrão de um espaço e uma nova linha. end="" é o jeito padrão de imprimir uma linha parcial e deixar a próxima chamada continuar de onde parou. Para saídas que precisam aparecer no exato momento em que acontecem, como um indicador de progresso ou um log em tempo real, adicione flush=True para que o Python escreva imediatamente, em vez de esperar por uma nova linha ou pelo buffer encher.

python
print("Loading", end="")
print("...")
# Loading...

print("one", end=" | ")
print("two", end=" | ")
print("three")
# one | two | three
JunoExibindo saídaprint() transforma o que você passar para ela em texto e exibe. Passe várias coisas separadas por vírgula e você terá um espaço entre elas; mude isso com sep. Todo print pula para uma nova linha no final; end="" mantém o próximo na mesma linha.
JunoExibindo saídaprint() executa str() em cada argumento, junta tudo com sep (um espaço por padrão) e finaliza com end (uma nova linha por padrão). Sobrescreva qualquer um dos dois para formatar a saída sem colar strings manualmente.
JunoExibindo saídaprint() escreve cada argumento passando por str(), com sep entre eles e end no final, ambos somente por nome. Use end="" para continuar uma linha e flush=True quando a saída precisar aparecer imediatamente.

Formatando saída com f-strings ​

O jeito mais limpo de montar mensagens é usando f-strings. Coloque f antes da aspa de abertura e envolva qualquer variável ou expressão em chaves. O Python preenche o valor em tempo de execução. Você pode colocar qualquer valor, cálculo ou chamada de método dentro de {}.

As f-strings avaliam qualquer expressão dentro de {} em tempo de execução e incorporam o resultado como string. Dois-pontos após o valor introduz uma especificação de formato: uma sintaxe compacta para controlar casas decimais, alinhamento e formatação de números. Elas são mais rápidas e mais legíveis do que a concatenação, e não exigem chamadas explícitas a str().

Cada {} numa f-string acaba chamando format(value, spec), que delega para o próprio método __format__ do valor (um dunder, o método de duplo sublinhado que o Python chama para formatar um valor). Assim, qualquer classe pode decidir como aparece dentro de uma f-string definindo __format__. As flags de conversão !r, !s e !a executam repr(), str() ou ascii() no valor antes de formatá-lo; !r é a que vale lembrar para depuração, porque mostra um valor do jeito que você o digitaria no código (aspas, escapes e tudo mais), como mostrado na prática a seguir.

python
name = "Alice"
score = 980

# concatenation: clunky, requires str() for numbers
print("Player: " + name + ", Score: " + str(score))

# f-string: readable, no manual conversion
print(f"Player: {name}, Score: {score}")

Você pode colocar qualquer expressão dentro de {}: aritmética, chamadas de método (como .upper(), cobertas com detalhes no capítulo Strings), especificações de formato:

python
price = 49.99
tax = 0.2
total = price * (1 + tax)

print(f"Total: {total:.2f}")          # Total: 59.99
print(f"Name: {name.upper()}")        # Name: ALICE
print(f"2 + 2 = {2 + 2}")             # 2 + 2 = 4

A especificação de formato depois de : controla como o valor é exibido:

python
ratio = 0.8765
count = 1234567
label = "revenue"

print(f"{ratio:.1%}")       # 87.6%
print(f"{count:,}")         # 1,234,567
print(f"{label:>12}")       # "     revenue"

:.2f significa "duas casas decimais". Você vai usar isso o tempo todo para preços e medidas. O resto fica disponível para quando você precisar. O principal a lembrar: qualquer coisa pode ir dentro de {}, não apenas nomes de variáveis.

:.2f e :.0% cobrem a maioria das necessidades de formatação. Os especificadores de alinhamento (>, <, ^) combinados com uma largura produzem uma saída tabular organizada. O padrão geral é {value:[align][width][.precision][type]}. Depois que você reconhece cada parte, qualquer especificação fica legível sem precisar memorizar todas as combinações.

A mesma especificação pode significar coisas diferentes para tipos diferentes, porque cada tipo formata a si mesmo. f"{'hi':5}" preenche o texto à direita (por padrão, texto se alinha à esquerda), enquanto f"{42:5}" preenche à esquerda (números se alinham à direita): mesmo :5, resultado oposto. Cada tipo embutido tem suas próprias regras para essa minilinguagem de formatação, e uma classe personalizada define as suas próprias regras ao implementar __format__.

JunoFormatando saída com f-strings Coloque f antes da aspa de abertura e envolva qualquer coisa em {}: uma variável, uma soma, até uma chamada de método. Dois-pontos adiciona formatação, como :.2f para duas casas decimais. Muito mais limpo do que colar strings com +.
JunoFormatando saída com f-stringsf"..." coloca o resultado de qualquer expressão direto dentro da string, sem precisar de str(). Depois dos dois-pontos vem a especificação de formato: :.2f, :,, :>12 e companhia. Mais limpo e mais rápido do que concatenação.
JunoFormatando saída com f-strings Cada {} chama o próprio __format__ do valor, então a especificação depois dos dois-pontos significa o que aquele tipo decidir. !r é a que vale lembrar: ela mostra um valor do jeito que você o digitaria, o que faz espaços em branco perdidos e outras coisas invisíveis ficarem visíveis quando você está depurando.

Obtendo dados do usuário ​

input() pausa seu programa e espera o usuário digitar algo. O que ele digitar (e confirmar com Enter) volta como valor de retorno. A string entre parênteses é o prompt que o usuário vê.

python
name = input("What's your name? ")
print(f"Hello, {name}!")

input() sempre retorna uma string, não importa o que o usuário digite. Digite 42 e você recebe "42" de volta, não o número 42. Para fazer aritmética com esse valor, converta explicitamente:

python
age = int(input("How old are you? "))
print(f"In ten years you'll be {age + 10}.")

E se o usuário digitar algo que não pode ser convertido? O Python gera um ValueError. Como tratar isso corretamente é assunto do capítulo Files and exceptions.

input() escreve o prompt na saída padrão, lê uma linha da entrada padrão, remove a quebra de linha final e retorna o resultado como string. Não há inferência de tipo. Tudo que vem do terminal chega como texto; você declara o tipo que precisa convertendo explicitamente na entrada.

python
name = input("What's your name? ")
age = int(input("How old are you? "))

Esse padrão (receber texto, converter para o tipo que você precisa) se aplica sempre que dados externos chegam. int(), float() e str() são as ferramentas de conversão. Se a string não puder ser convertida, o Python gera um ValueError, assunto tratado no capítulo Files and exceptions.

input() é um invólucro simples: ela escreve o prompt em sys.stdout (saída padrão), esvazia o buffer para que o prompt apareça antes de o programa bloquear, lê uma linha de sys.stdin (entrada padrão), remove a quebra de linha final e devolve uma str. É sempre uma str por definição, porque o Python não tem como adivinhar se "42" era para ser um inteiro, um float ou texto literal. Então você converte na entrada. Essa é a forma fundamental da entrada e saída em Python: dados externos chegam como texto, e o seu código decide o tipo no ponto de entrada.

python
name = input("Enter your name: ")
score = float(input("Enter your score (0.0 to 1.0): "))

print(f"Name:  {name!r}")      # !r reveals any invisible whitespace
print(f"Score: {score:.1%}")
JunoObtendo dados do usuárioinput() exibe seu prompt, espera uma linha e sempre devolve isso como string, mesmo que a pessoa tenha digitado um número. Precisa de um número? Converta você mesmo com int() ou float() ao receber o valor, e depois siga com o tipo certo.
JunoObtendo dados do usuárioinput() sempre retorna um str, sem inferência de tipo. Converta na entrada com int() ou float(), e espere um ValueError se o texto não puder ser interpretado. Esse padrão de receber e depois converter aparece em todo lugar em que dados externos chegam.
JunoObtendo dados do usuário Tudo que vem de input() é um str por definição, porque o Python não tem como adivinhar o que você quis dizer. Converta no ponto de entrada e trate o ValueError quando não der para interpretar. Mesma lógica de todo outro lugar em que dados externos chegam.

Escrevendo em stderr ​

Por padrão, print() escreve na saída padrão: o fluxo que aparece no terminal e passa por pipes. O Python também tem a saída de erro padrão, um fluxo separado para diagnósticos e avisos. Eles parecem idênticos no terminal, mas são distintos: quando você redireciona a saída de um script para outro comando, só o stdout passa. O stderr sempre chega ao terminal.

Escrever no stderr usa o argumento file de print(). Isso exige importar sys, assunto do capítulo Modules. Por agora, basta saber que os dois fluxos existem e por que são separados.

Na prática ​

Um quiz que se personaliza a partir dos dados do usuário:

python
name = input("What's your name? ")
subject = input("Which subject? ")

print(f"Okay, {name}. Starting your {subject} quiz.")
print("Good luck!")

Ambas as entradas voltam como strings e vão direto para as f-strings. Não é preciso converter porque você está usando os valores como texto, não como números.

Um conversor de temperatura com saída tabular alinhada:

python
celsius = float(input("Temperature in Celsius: "))
fahrenheit = celsius * 9 / 5 + 32

print(f"{'Celsius':>12} {'Fahrenheit':>12}")
print(f"{celsius:>12.1f} {fahrenheit:>12.1f}")

float() lida tanto com números inteiros quanto com decimais digitados pelo usuário. A especificação >12 mantém as colunas alinhadas, independentemente de quantos dígitos os números tiverem. Tente digitar 100 e -40: a saída permanece organizada nos dois casos.

Usando !r para revelar exatamente o que o Python recebeu, útil quando a saída parece errada:

python
name = input("Enter your name: ")
score = float(input("Enter your score (0.0 to 1.0): "))

print(f"Name:   {name!r}")
print(f"Score:  {score!r}")
print()
print(f"Result: {name}: {score:.1%}")

{name} e {name!r} exibem o mesmo resultado quando a entrada está limpa. A diferença aparece quando há espaços extras no final ou outros caracteres invisíveis. Ter o hábito de usar !r durante a depuração torna valores inesperados visíveis imediatamente.