Saída e entrada

Duas ferramentas que você usará desde a primeira linha que escrever: print() mostra valores no terminal, input() obtém texto do usuário. São simples, mas conhecer seu comportamento evita algumas surpresas no início.

print() e input() são as funções padrão de E/S de terminal do Python. Ambas são mais configuráveis do que parecem à primeira vista. print() aceita argumentos que controlam como os valores são unidos e onde a saída termina. input() sempre retorna uma string, o que define como você lida com cada valor vindo de um usuário.

print() encapsula sys.stdout; input() encapsula sys.stdin. Ambas trabalham exclusivamente com texto, delegam a codificação ao codec do stream e fazem buffer da saída por padrão. A separação entre stdout e stderr, e o controle sobre o flush, são importantes em programas reais.

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. A ordem em que você escreve as coisas é a ordem em que elas rodam. Sempre.

cidade = "Brasília"
print(cidade)
print("População: 14 milhões")

cidade é atribuída primeiro. O primeiro print é executado. O segundo print é executado. Sempre nessa ordem.

Isso importa porque você não pode usar uma variável antes de atribuí-la. O Python ainda não a viu e levantará um erro:

print(pais)   # NameError: pais ainda não está definido
pais = "Brasil"

Tenha isso em mente conforme seus programas crescem: qualquer coisa que você usar precisa ser definida antes de ser usada.

O Python usa execução sequencial: cada instrução é avaliada conforme é encontrada, em uma única passagem de cima para baixo pelo arquivo. Não há uma pré-leitura do arquivo inteiro. Referenciar um nome antes de atribuí-lo levanta NameError exatamente naquela linha, não antes.

cidade = "Brasília"
print(cidade)             # funciona: cidade já está vinculado
print(pais)               # NameError: ainda não atribuído
pais = "Brasil"

A regra é simples: dependências devem ser definidas antes da linha que as utiliza.

O modelo de execução do Python é avaliação sequencial em uma única passagem. A resolução de nomes acontece no momento da avaliação, não no momento da análise sintática. O parser constrói bytecode sem resolver nomes, e é por isso que NameError é uma exceção de tempo de execução, não um erro de sintaxe. O Python não tem hoisting (ao contrário do var do JavaScript) nem declarações antecipadas (ao contrário do C). Um nome está disponível no momento em que é vinculado; antes disso, qualquer referência levanta um erro.

print(pais)   # NameError em tempo de execução, não erro de sintaxe
pais = "Brasil"

Imprimindo saída

print() é como o Python responde para você. Passe qualquer valor e ele exibirá esse valor. Ele converte automaticamente o que você passar para texto.

print() converte cada argumento em string via str(), junta-os com um separador (um espaço, por padrão) e então escreve o resultado seguido de uma nova linha na saída padrão. Entender os padrões facilita o raciocínio sobre os argumentos opcionais.

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. sep e end controlam a formatação; file redireciona a saída para qualquer stream gravável; flush força o buffer a ser descarregado imediatamente.

print("Olá")      # Olá
print(42)         # 42
print(3.14)       # 3.14
print(True)       # True

Vários valores

Você pode imprimir vários valores ao mesmo tempo separando-os por vírgulas. O Python coloca um espaço entre eles por padrão. Mude o separador com sep:

Vários argumentos posicionais são convertidos com str() individualmente e depois unidos por sep. O sep padrão é um único espaço. Sobrescrevê-lo permite produzir saída formatada sem concatenação de strings:

Cada argumento posicional é passado por str() individualmente antes da junção. A junção usa sep, depois end é anexado, e o todo é escrito em uma única chamada ao stream de saída. Sobrescrever sep é mais limpo do que construir a string manualmente:

nome = "Ana"
idade = 28
print(nome, idade)                      # Ana 28
print("Nome:", nome)                    # Nome: Ana
print("2024", "01", "15", sep="-")     # 2024-01-15
print("a", "b", "c", sep=", ")         # a, b, c

Controlando o fim da linha

Cada chamada print() termina com uma nova linha por padrão, então a próxima saída começa em uma 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 permanecer na mesma linha com um espaço, ou como qualquer outra string. Combinado com sep, você pode produzir a maioria dos formatos de saída sem construir strings manualmente:

sep e end são argumentos somente nomeados com padrões ' ' e '\n'. Definir end="" é a forma padrão de imprimir uma linha parcial e deixar a próxima chamada continuá-la. Para saída em tempo real, como indicadores de progresso ou logs, flush=True força o buffer a ser descarregado imediatamente, em vez de esperar por uma nova linha ou pelo preenchimento do buffer.

print("Carregando", end="")
print("...")
# Carregando...

print("um", end=" | ")
print("dois", end=" | ")
print("três")
# um | dois | três

Formatando saída com f-strings

A forma mais limpa de construir mensagens é com f-strings. Coloque f antes da aspa de abertura, depois envolva qualquer variável ou expressão em chaves. O Python preenche em tempo de execução. Você pode colocar qualquer valor, cálculo ou chamada de método dentro das {}.

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

f-strings (PEP 498) compilam cada {} em bytecode que chama format(value, spec), que delega para value.__format__(spec). Qualquer classe que implemente __format__ controla sua própria exibição dentro de uma f-string. As flags de conversão !r, !s, !a aplicam repr(), str() ou ascii() antes da chamada de formatação. !r é a mais útil: mostra aspas em volta de strings e torna caracteres invisíveis visíveis.

nome  = "Ana"
pontos = 980

# concatenação: desajeitada, exige str() para números
print("Jogador: " + nome + ", Pontos: " + str(pontos))

# f-string: legível, sem conversão manual
print(f"Jogador: {nome}, Pontos: {pontos}")

Você pode colocar qualquer expressão dentro de {}: aritmética, chamadas de método, specs de formato:

preco = 49.99
imposto = 0.2
total = preco * (1 + imposto)

print(f"Total: {total:.2f}")          # Total: 59.99
print(f"Nome: {nome.upper()}")        # Nome: ANA
print(f"2 + 2 = {2 + 2}")             # 2 + 2 = 4

A spec de formato após : controla como o valor é exibido:

proporcao = 0.8765
contagem  = 1234567
rotulo    = "receita"

print(f"{proporcao:.1%}")    # 87.7%
print(f"{contagem:,}")       # 1,234,567
print(f"{rotulo:>12}")       # "     receita"

:.2f significa "duas casas decimais". Você o usará constantemente para preços e medidas. O resto está aí quando você precisar. O importante: qualquer coisa pode ir dentro de {}, não só nomes de variáveis.

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

A string de spec é passada literalmente para value.__format__(spec). Tipos embutidos implementam a mini-linguagem de formatação em C. Classes personalizadas podem definir __format__ para aceitar strings de spec arbitrárias. !r chama repr() antes da formatação: f"{nome!r}" transforma uma string com espaço em branco no final em um repr com aspas, tornando visíveis caracteres invisíveis. Use-o sempre que o valor de uma variável parecer estranho e você precisar ver exatamente o que há nela.

Obtendo entrada do usuário

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

nome = input("Qual é o seu nome? ")
print(f"Olá, {nome}!")

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

idade = int(input("Quantos anos você tem? "))
print(f"Em dez anos você terá {idade + 10}.")

E se o usuário digitar algo que não pode ser convertido? O Python levanta um ValueError. Tratar isso adequadamente é abordado no capítulo Arquivos e exceções.

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

nome  = input("Qual é o seu nome? ")
idade = int(input("Quantos anos você tem? "))

Esse padrão (receber texto, converter para o tipo necessário) se aplica em todo lugar onde chegam dados externos. int(), float() e str() são as ferramentas de conversão. Se a string não puder ser convertida, o Python levanta ValueError, abordado no capítulo Arquivos e exceções.

input() é uma interface fina: chama sys.stdout.write(prompt), faz flush do stdout, lê uma linha de sys.stdin, remove a nova linha do final e retorna o resultado como str. O retorno é sempre str por design: o Python não tem como inferir se "42" foi pretendido como inteiro, float ou caracteres literais. A conversão de tipo na fronteira é explícita. Esse é um padrão fundamental na E/S do Python: todos os dados externos chegam como texto, e seu código declara o tipo no ponto de entrada.

nome  = input("Digite seu nome: ")
pontos = float(input("Digite sua pontuação (0.0 a 1.0): "))

print(f"Nome:  {nome!r}")      # !r revela qualquer espaço em branco invisível
print(f"Pontuação: {pontos:.1%}")

Escrevendo em stderr

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

Escrever em stderr usa o argumento file de print(). Isso exige importar sys, o que é abordado no capítulo Módulos. Por enquanto, saber que os dois streams existem e por que são separados é suficiente.

Na prática

Um quiz que se personaliza a partir da entrada do usuário:

nome     = input("Qual é o seu nome? ")
materia  = input("Qual matéria? ")

print(f"Beleza, {nome}. Começando seu quiz de {materia}.")
print("Boa sorte!")

Ambas as entradas voltam como strings e entram diretamente nas f-strings. Sem conversão necessária, porque você está usando-as como texto, não como números.

Um conversor de temperatura com saída tabular alinhada:

celsius    = float(input("Temperatura em Celsius: "))
fahrenheit = celsius * 9 / 5 + 32

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

float() lida tanto com inteiros quanto com decimais vindos do usuário. A spec >12 mantém as colunas alinhadas independentemente de quantos dígitos os números têm. Tente digitar 100 e -40: a saída permanece organizada de qualquer forma.

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

nome  = input("Digite seu nome: ")
pontos = float(input("Digite sua pontuação (0.0 a 1.0): "))

print(f"Nome:   {nome!r}")
print(f"Pontos: {pontos!r}")
print()
print(f"Resultado: {nome}: {pontos:.1%}")

{nome} e {nome!r} exibem-se de forma idêntica quando a entrada está limpa. A diferença aparece quando há espaços no final ou outros caracteres invisíveis. Adquirir o hábito de usar !r durante a depuração torna valores inesperados imediatamente visíveis.

Practice output and input in PythonWork through hands-on exercises on print, f-strings, and user input in the Scrimba course.Start the course →