Python print()

Um programa que trabalha calado não serve para muita coisa: a Ana quer ver o total das compras, a lista do dia, o recado para a padaria. O jeito de um programa Python mostrar alguma coisa na tela é o print() (em inglês, "imprimir": do tempo em que a saída dos computadores saía numa impressora). Ele é, de longe, a função que você mais vai escrever no começo, e é com ele que você vai enxergar o que os seus programas estão fazendo.

Você vai aprender

A escrever um print() e o que é cada parte: o nome, os parênteses, as aspas.
A mostrar textos com aspas duplas ou simples, e textos que têm aspas dentro.
A mostrar números e o resultado de contas, e por que print(2 + 3) e print("2 + 3") são diferentes.
A mostrar vários valores num print só, separados por vírgula.
A pular uma linha com print() vazio.
A diferença entre o que o >>> mostra sozinho e o que o print mostra.
Os erros reais mais comuns: Print com P maiúsculo, aspas esquecidas, parênteses faltando e o + entre texto e número.

Todos os programas desta aula foram rodados com o Python 3.14 na máquina fictícia da Ana (usuária ana, computador notebook), na pasta pessoal dela, com o comando python3 arquivo.py (aula Rodando um Programa). Cada caixa "Experimente" roda o mesmo Python de verdade, no seu navegador.

A ideia: o alto-falante do programa

Pense no alto-falante da padaria do bairro: "Senha 42, seu pão está pronto!". Quem está no balcão escreve o recado num papel e o alto-falante anuncia exatamente o que está escrito, nem uma letra a mais.

O print() é o alto-falante do seu programa. Você entrega a ele uma coisa (um texto, um número, o resultado de uma conta) e ele mostra essa coisa na tela, numa linha. Depois de mostrar, ele pula para a linha de baixo, pronto para o próximo recado.

Na padaria	No Python
O alto-falante	A função `print`
O papel com o recado	O que vai dentro dos parênteses: `("Senha 42")`
O anúncio que todo mundo ouve	A linha que aparece na tela (a saída do programa)

1. O primeiro `print`

print("Olá, mundo!")

print: O nome da função: "mostre na tela". Uma função é um comando com nome que faz um trabalho; o Python já vem com várias prontas, e o print é uma delas. Escreve-se assim, em minúsculas.
( ): Os parênteses são o jeito de chamar (usar) a função. O que vai dentro deles é o que você entrega a ela. Sem os parênteses, o Python não faz nada (você vai ver o erro em Quando dá errado).
"Olá, mundo!": Um texto. As aspas mostram onde o texto começa e onde termina; elas não aparecem na tela. Tudo o que está entre elas, inclusive espaços, vírgulas e acentos, sai igualzinho.

$ python3 ola.py
Olá, mundo!

Na tela saiu só o que estava entre as aspas. Em programação, um texto se chama string (em inglês, "cordão": uma fileira de letras, uma atrás da outra). Os textos têm uma aula inteira só para eles: Strings.

Missão: troque o texto para que o programa mostre Padaria do Bairro. Depois clique em Rodar.

print("Olá, mundo!")

print("Padaria do Bairro")

2. Aspas duplas ou simples

O Python aceita os dois tipos de aspas: "duplas" e 'simples'. Para ele, "Bom dia" e 'Bom dia' são o mesmo texto. A única regra é fechar com a mesma aspa que abriu.

A escolha fica útil quando o texto tem aspas dentro. A padaria se chama Padaria D'Ouro, com apóstrofo (que é a aspa simples). Basta abrir e fechar o texto com aspas duplas, e o apóstrofo vira só mais uma letra. Ao contrário, se o texto tem aspas duplas dentro, use aspas simples por fora:

print("Bom dia, Ana!")
print('Bom dia, Ana!')
print("Padaria D'Ouro")
print('Ela disse: "Que pão cheiroso!"')

$ python3 aspas.py
Bom dia, Ana!
Bom dia, Ana!
Padaria D'Ouro
Ela disse: "Que pão cheiroso!"

Repare em duas coisas. As duas primeiras linhas saíram idênticas: o tipo de aspa não muda nada no resultado. E o programa tem quatro print, então a saída tem quatro linhas, uma por print, na ordem em que aparecem no arquivo: o Python lê o programa de cima para baixo.

Qual aspa usar?

Qualquer uma, desde que você seja coerente. Este guia usa aspas duplas na maioria dos exemplos, e simples só quando o texto tem aspas duplas dentro. Existe ainda um terceiro jeito, a barra invertida (\"), que você vai ver em Caracteres de Escape.

3. Números e contas: sem aspas

Números se escrevem sem aspas, do jeito que você escreveria num papel. E, quando você põe uma conta dentro do print, o Python primeiro calcula e depois mostra o resultado:

print(42)
print(3.5)
print(2 + 3)
print("2 + 3")
print(10 * 4)

$ python3 numeros.py
42
3.5
5
2 + 3
40

print(42): Um número inteiro. Sai como está.
print(3.5): Um número com casas decimais. No Python, a casa decimal se separa com ponto, nunca com vírgula (a vírgula tem outro trabalho, que você vai ver na seção 4).
print(2 + 3): Uma conta. O Python faz a soma e entrega o resultado, 5, para o print.
print("2 + 3"): Entre aspas, 2 + 3 não é conta: é um texto com cinco caracteres (o 2, um espaço, o +, outro espaço, o 3). O print mostra o texto como está.
print(10 * 4): O * (asterisco) é a multiplicação. 10 * 4 dá 40. As outras contas estão em Operadores Aritméticos.

Com aspas é texto, sem aspas é valor

Essa é a regra mais importante desta aula. "2 + 3" é um recado escrito num papel; 2 + 3 é uma conta que o Python resolve. A diferença entre texto e número volta muitas vezes no guia; a aula Tipos de Dados conta a história inteira.

4. Vários valores num `print` só

Dentro dos parênteses cabe mais de uma coisa: separe cada uma com uma vírgula. O print mostra todas, na mesma linha, e coloca um espaço entre elas por conta própria. Assim dá para misturar texto e número sem dor de cabeça:

print("Pão francês:", 12, "unidades")
print("Preço do quilo:", 18.9)
print("Total:", 2 + 3, "itens")

$ python3 virgula.py
Pão francês: 12 unidades
Preço do quilo: 18.9
Total: 5 itens

"Pão francês:": O primeiro valor, um texto.
,: A vírgula separa os valores. Ela não aparece na tela; no lugar dela, o print coloca um espaço.
12: O segundo valor, um número.
"unidades": O terceiro valor. Repare que você não precisou escrever espaço nenhum dentro das aspas: "Pão francês:" termina no dois-pontos e, mesmo assim, saiu Pão francês: 12, com espaço.

Na terceira linha, a conta 2 + 3 foi feita antes de o print mostrar tudo. Cada valor separado por vírgula é resolvido primeiro e só depois vai para a tela.

Quer outro separador, ou ficar na mesma linha?

O espaço entre os valores e o pulo de linha no fim são o comportamento padrão. Os dois podem ser trocados: é o assunto da próxima aula, As Opções sep e end.

Missão: a Ana fez 8 pães de queijo. Mude o programa para mostrar Pão de queijo: 8 unidades, escrevendo o 8 como número, entre vírgulas (sem aspas em volta dele).

print("Pão francês:", 12, "unidades")

print("Pão de queijo:", 8, "unidades")

5. Linha em branco: `print()` vazio

Um print() sem nada dentro dos parênteses não mostra texto nenhum, mas ainda faz a outra metade do trabalho: pula a linha. O resultado é uma linha em branco, ótima para separar partes da saída:

print("Lista de compras")
print()
print("- pão")
print("- leite")
print("- café")

$ python3 linhas.py
Lista de compras

- pão
- leite
- café

Os parênteses continuam obrigatórios, mesmo vazios: é o que diz ao Python "use a função agora".

6. O `>>>` mostra sozinho, o programa não

No modo interativo (aula O Modo Interativo), o Python mostra o valor de qualquer coisa que você digita, mesmo sem print. Mas ele mostra de um jeito um pouco diferente:

$ python3
Python 3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> "Bom dia, Ana!"
'Bom dia, Ana!'                    « sem print: o valor, com aspas
>>> print("Bom dia, Ana!")
Bom dia, Ana!                      « com print: só o texto
>>> 2 + 3
5
>>> print(2 + 3)
5
>>> print()

>>> exit()

Sem print, o >>> mostra o valor do jeito que você o escreveria no código, com aspas, para você saber que aquilo é um texto. Com print, aparece o texto "limpo", como o usuário do programa veria.

E tem mais: esse "mostrar sozinho" só existe no modo interativo. Num arquivo .py, uma linha com "Bom dia, Ana!" ou 2 + 3 sozinha não mostra nada; o Python calcula e joga fora. Num programa, quem mostra é sempre o print.

Formas diferentes de mostrar texto e valor juntos

As três linhas abaixo mostram a mesma coisa:

print("Bom dia, " + "Ana!")
print("Bom dia,", "Ana!")
print(f"Bom dia, {'Ana'}!")

$ python3 juntar.py
Bom dia, Ana!
Bom dia, Ana!
Bom dia, Ana!

A primeira junta dois textos com + e entrega ao print um texto só. Repare que o espaço depois da vírgula teve de ser escrito à mão, dentro das aspas: o + não coloca espaço. E o + só junta texto com texto (o erro com número está logo abaixo). Detalhes em Juntar e Repetir Textos.
A segunda entrega dois valores separados por vírgula, e o print põe o espaço sozinho.
A terceira é uma f-string (o f antes das aspas): um texto com "buracos" entre chaves, que o Python preenche. Aqui parece exagero, mas, quando você conhecer as variáveis, ela vai ser o jeito mais prático de todos. Tem aula própria: f-strings.

Forma	Quando usar
`print("Total:", 5)`	Para começar e para mostrar rápido vários valores. Mistura texto e número sem problema e põe o espaço sozinho
`print("Bom dia, " + "Ana!")`	Só quando todos os pedaços já são texto. Com número no meio, dá `TypeError`
`print(f"Total: {5}")`	É o jeito preferido dos programadores Python para montar frases com valores. Você vai usá-lo muito depois da aula de f-strings

Quando dá errado

Errar faz parte. O importante é saber ler o que o Python responde. As mensagens saem em inglês; abaixo, cada uma explicada em português. A aula Lendo uma Mensagem de Erro aprofunda o assunto.

Print com P maiúsculo

Print("Olá, mundo!")

$ python3 maiuscula.py
Traceback (most recent call last):
  File "/home/ana/maiuscula.py", line 1, in <module>
    Print("Olá, mundo!")
    ^^^^^
NameError: name 'Print' is not defined. Did you mean: 'print'?

É a primeira mensagem de erro do guia, então vamos ler linha por linha. Uma mensagem dessas se chama traceback ("rastro de volta": o caminho que o Python fez até o erro).

Traceback (most recent call last):: "Rastro (a chamada mais recente por último)". Avisa que o programa parou por causa de um erro e que, a seguir, vem onde ele aconteceu.
File "/home/ana/maiuscula.py", line 1, in <module>: O arquivo e a linha do problema: linha 1 de maiuscula.py. O <module> quer dizer "no corpo principal do programa" (fora de qualquer função sua).
Print("Olá, mundo!"): A própria linha, copiada do arquivo.
^^^^^: Os acentos circunflexos apontam o pedaço exato que deu problema: a palavra Print.
NameError: name 'Print' is not defined.: O tipo do erro e a explicação: "erro de nome: o nome Print não está definido". O Python não conhece nada chamado Print.
Did you mean: 'print'?: "Você quis dizer print?" O Python achou um nome parecido e deu a dica.

O Python diferencia maiúsculas de minúsculas: print, Print e PRINT são três nomes diferentes, e só o primeiro existe. Como consertar: escreva print, tudo minúsculo. Repare também que a última linha do traceback é a mais importante: comece a ler por ela.

Texto sem aspas

print(Olá)

$ python3 sem-aspas.py
Traceback (most recent call last):
  File "/home/ana/sem-aspas.py", line 1, in <module>
    print(Olá)
          ^^^
NameError: name 'Olá' is not defined

Sem aspas, Olá não é um texto: o Python acha que é o nome de alguma coisa (uma variável, como você vai ver na aula Variáveis) e não encontra nada com esse nome. Desta vez não veio "Did you mean", porque não existe nenhum nome parecido. Como consertar: print("Olá").

Aspas que não fecham

print("Olá, mundo!)

$ python3 aspas-abertas.py
  File "/home/ana/aspas-abertas.py", line 1
    print("Olá, mundo!)
          ^
SyntaxError: unterminated string literal (detected at line 1)

SyntaxError é "erro de sintaxe": o código não está escrito do jeito que o Python entende, então ele nem começa a rodar o programa (por isso não aparece a linha Traceback). A explicação: "texto não terminado (percebido na linha 1)". O ^ aponta a aspa que abriu o texto: dali em diante, o Python procurou outra " para fechar e a linha acabou sem ela. O ) virou parte do texto.

A mesma mensagem aparece quando você abre com uma aspa e fecha com outra, como em print("Olá, mundo!'): a aspa simples do fim não fecha um texto que começou com aspa dupla. Como consertar: feche com a mesma aspa que abriu.

Esqueceu os parênteses

print "Olá, mundo!"

$ python3 sem-parenteses.py
  File "/home/ana/sem-parenteses.py", line 1
    print "Olá, mundo!"
    ^^^^^^^^^^^^^^^^^^^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(...)?

"Faltam os parênteses na chamada de print. Você quis dizer print(...)?" Esse jeito sem parênteses era o do Python 2, uma versão antiga que deixou de ser mantida em 2020. Você ainda vai encontrá-lo em tutoriais velhos da internet; no Python 3, o print sempre leva parênteses. Como consertar: print("Olá, mundo!").

Parêntese que não fecha

print("Olá, mundo!"
print("Tchau!")

$ python3 parentese-aberto.py
  File "/home/ana/parentese-aberto.py", line 1
    print("Olá, mundo!"
         ^
SyntaxError: '(' was never closed

"O ( nunca foi fechado". O ^ aponta o parêntese que abriu na linha 1. Nenhuma das duas linhas foi mostrada: com erro de sintaxe, o programa inteiro não roda, nem a parte que estava certa. Como consertar: feche o parêntese no fim da linha 1.

Juntar texto e número com +

print("Total: " + 10)

$ python3 juntar-erro.py
Traceback (most recent call last):
  File "/home/ana/juntar-erro.py", line 1, in <module>
    print("Total: " + 10)
          ~~~~~~~~~~^~~~
TypeError: can only concatenate str (not "int") to str

Agora o erro é outro: TypeError, "erro de tipo". A explicação: "só dá para concatenar (juntar) str com str, e não int". str é o nome do Python para texto e int para número inteiro (aula Tipos de Dados). Os ~~~ sublinham as duas coisas que o + tentou juntar, e o ^ aponta o próprio +. O texto "Total: " e o número 10 não se somam: o Python não adivinha se você quer uma conta ou uma frase.

Como consertar: use a vírgula, print("Total:", 10), que aceita qualquer mistura. (Outros caminhos, como a f-string e a conversão com str(), estão nas aulas f-strings e Conversão de Tipos.)

Vírgula no lugar do ponto decimal: não dá erro, dá resultado errado

print(18,9)

$ python3 virgula-decimal.py
18 9

A Ana queria mostrar dezoito e noventa. Saiu 18 9, sem nenhuma mensagem de erro. Para o Python, a vírgula separa valores: ele entendeu dois números, o 18 e o 9, e mostrou os dois com um espaço no meio (seção 4). Esse é o pior tipo de erro, o que não avisa. Como consertar: decimal com ponto, print(18.9).

Missão: este programa tem dois erros e não roda. Clique em Rodar, leia a mensagem, conserte e rode de novo até aparecer o recado inteiro.

print("Padaria do Bairro")
Print("Pão saindo às 7h)

print("Padaria do Bairro")
print("Pão saindo às 7h")

Repare na ordem em que os erros aparecem. Primeiro vem o SyntaxError da aspa (o Python confere a escrita do arquivo inteiro antes de rodar). Só depois de consertar a aspa o programa começa a rodar, mostra a primeira linha e para no NameError do Print.

Referência rápida

Escrita	O que mostra
`print("Olá")`	`Olá` (o texto, sem as aspas)
`print('Olá')`	`Olá` (aspas simples funcionam igual)
`print("D'Ouro")` / `print('Ela disse "oi"')`	Texto com aspas dentro: use o outro tipo de aspa por fora
`print(42)` / `print(3.5)`	Um número; decimal com ponto
`print(2 + 3)`	`5` (o resultado da conta)
`print("2 + 3")`	`2 + 3` (texto, sem conta)
`print("Total:", 5, "itens")`	`Total: 5 itens` (vários valores, com espaço entre eles)
`print()`	Uma linha em branco

Mensagem	Causa provável
`NameError: name 'Print' is not defined. Did you mean: 'print'?`	`print` escrito com maiúscula
`NameError: name 'Olá' is not defined`	Texto sem aspas
`SyntaxError: unterminated string literal`	Aspa que não fecha, ou fechada com a aspa do outro tipo
`SyntaxError: Missing parentheses in call to 'print'`	`print` sem parênteses (o jeito do Python 2)
`SyntaxError: '(' was never closed`	Faltou fechar o parêntese
`TypeError: can only concatenate str (not "int") to str`	`+` entre texto e número: use a vírgula
Saiu `18 9` em vez de `18.9`, sem erro	Vírgula no lugar do ponto decimal

Exercícios

1. Complete o comando

Complete para mostrar o texto Bom dia na tela:

("Bom dia")

2. Qual é a saída?

O que aparece na tela com print(7 * 3)?

Saída:

3. E agora?

O que aparece na tela com print("7 * 3")?

Saída:

4. O que mostra print("Pães:", 6)?

Pães:6 Pães: 6 "Pães:", 6 Dá TypeError, porque mistura texto e número

5. Qual destas linhas mostra Padaria D'Ouro sem erro?

print('Padaria D'Ouro') print(Padaria D'Ouro) print("Padaria D'Ouro") Print("Padaria D'Ouro")

6. Num arquivo .py, a linha 2 + 3 sozinha (sem print) faz o quê?

Mostra 5 Mostra 2 + 3 Dá SyntaxError Calcula, mas não mostra nada

Missão final: o quadro da padaria

Missão: monte o quadro de avisos da padaria. Ele deve mostrar Padaria do Bairro, depois uma linha em branco, depois Pão francês: 12 e, na última linha, Bolo de fubá: 3. Os números devem ir como números, depois de uma vírgula.

print("Padaria do Bairro")

print("Padaria do Bairro")
print()
print("Pão francês:", 12)
print("Bolo de fubá:", 3)

Resumo

print(...) mostra na tela o que está dentro dos parênteses e depois pula para a próxima linha. Cada print é uma linha da saída.
Textos vão entre aspas, duplas ou simples (feche com a mesma que abriu); as aspas não aparecem na tela.
Números e contas vão sem aspas, e o Python calcula antes de mostrar. Decimal com ponto: 3.5.
Com aspas é texto ("2 + 3"); sem aspas é valor (2 + 3 → 5).
Vários valores separados por vírgula saem na mesma linha, com um espaço entre eles, e podem misturar texto e número.
print() vazio mostra uma linha em branco.
O >>> mostra valores sozinho (texto com aspas); num arquivo .py, só o print mostra.
Erros comuns: Print → NameError; aspa ou parêntese sem fechar e print sem parênteses → SyntaxError; "texto" + 10 → TypeError. Leia o traceback pela última linha.