Python Funções Embutidas

Desde a primeira aula você usa funções que não escreveu: print(), input(), type(). Elas já vêm embutidas no Python (em inglês, built-in functions): funcionam em qualquer programa, sem import nem def. Nesta aula você vai conhecer as que mais aparecem no dia a dia, para contar, somar, achar o menor e o maior, arredondar, ordenar e testar uma lista inteira de uma vez. Com elas, muitos laços que você escreveria viram uma linha só.

A ideia: a caixa de ferramentas que vem com a casa

Quando a Ana se mudou, o apartamento já tinha, na gaveta da cozinha, uma caixa com martelo, chave de fenda e trena. Ela não precisou comprar nem fabricar nada: era só abrir a gaveta e usar. As funções embutidas são essa caixa. Você não precisa escrever um laço para contar os itens de uma lista, nem para achar a maior nota da turma: o Python já traz uma ferramenta pronta, testada e rápida para isso.

Você já conhece algumas delas, cada uma com aula própria:

Agora vêm as novas. Os exemplos usam o modo interativo (>>>, aula O Modo Interativo), que mostra a resposta de cada linha na hora.

1. len(): quantos itens?

len vem de length, "comprimento". Ela conta quantos itens há dentro de alguma coisa: letras num texto, itens numa lista, chaves num dicionário.

$ 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.
>>> len("Ana")
3
>>> len("pão de queijo")
13
>>> len([7.5, 8.0, 6.5])
3
>>> len({"arroz": 3, "feijão": 2})
2
>>> len([])
0

len("pão de queijo")

13: as 11 letras e os 2 espaços. Num texto, tudo conta, inclusive espaço e pontuação. O ã conta como uma letra só.

len([7.5, 8.0, 6.5])

3: numa lista, conta os itens, não importa o tamanho de cada um.

len({"arroz": 3, "feijão": 2})

2: num dicionário, conta os pares chave-valor (aula Dicionários).

len([])

0: uma lista vazia tem zero itens. Não é erro.

2. sum(): a soma, e a média

sum quer dizer "soma". Ela recebe uma lista de números e devolve o total. Junto com o len(), dá a média:

>>> notas = [7.5, 8.0, 6.5, 9.0]
>>> sum(notas)
31.0
>>> sum(notas) / len(notas)
7.75
>>> sum([])
0

sum(notas)

7.5 + 8.0 + 6.5 + 9.0 = 31.0. Como as notas são float (números com casa decimal), a soma também é.

sum(notas) / len(notas)

A média: o total dividido pela quantidade. 31.0 / 4 = 7.75.

sum([])

A soma de nenhum número é 0.

Sem o sum(), você precisaria de um laço com um acumulador, como na aula for:

total = 0
for nota in notas:
    total = total + nota

O sum(notas) faz exatamente isso, numa linha.

3. min() e max(): o menor e o maior

min é "mínimo" e max é "máximo". Elas aceitam uma lista ou vários valores separados por vírgula:

>>> min(notas)
6.5
>>> max(notas)
9.0
>>> max(3, 9, 4)
9
>>> min("banana", "abacate", "caju")
'abacate'

Com textos, "menor" quer dizer "vem primeiro na ordem alfabética": 'abacate' vem antes de 'banana' e de 'caju'. (Cuidado: para o Python, as maiúsculas vêm antes das minúsculas, e as letras com acento vêm depois de todas; a aula Ordenando Listas mostra os detalhes.)

A opção key: "o maior segundo qual critério?"

Às vezes você não quer o maior valor, e sim o maior segundo um critério: o nome mais comprido, o produto mais caro. Para isso existe a opção key ("chave"). Você passa uma função, e o max() compara o resultado dela em vez do item:

>>> nomes = ["Ana", "Bruno", "Clara", "Jo"]
>>> max(nomes, key=len)
'Bruno'
>>> min(nomes, key=len)
'Jo'

key=len

"Compare pelo len de cada nome." Repare: é len sem parênteses. Você não está chamando a função, está entregando a função para o max(), que vai chamá-la em cada item: len("Ana") = 3, len("Bruno") = 5, len("Clara") = 5, len("Jo") = 2.

'Bruno'

O maior tamanho é 5, e há dois nomes com 5 letras. No empate, o max() devolve o primeiro que encontrou.

'Jo'

O menor tamanho: 2 letras.

Com uma função lambda (aula lambda), você escolhe qualquer critério. Aqui, cada produto é uma tupla (nome, preço), e o critério é a posição 1, o preço:

produtos = [("arroz", 25.9), ("café", 18.5), ("azeite", 39.9), ("sal", 3.2)]

mais_caro = max(produtos, key=lambda produto: produto[1])
mais_barato = min(produtos, key=lambda produto: produto[1])

print("Mais caro:", mais_caro)
print("Mais barato:", mais_barato)
print("Do mais barato ao mais caro:")
for nome, preco in sorted(produtos, key=lambda produto: produto[1]):
    print(f"  {nome}: R$ {preco:.2f}")

$ python3 mais_caro.py
Mais caro: ('azeite', 39.9)
Mais barato: ('sal', 3.2)
Do mais barato ao mais caro:
  sal: R$ 3.20
  café: R$ 18.50
  arroz: R$ 25.90
  azeite: R$ 39.90

O max() devolveu a tupla inteira do azeite, não só o preço: o key só muda o critério de comparação, e o resultado continua sendo um dos itens da lista. O sorted() do fim, com o mesmo key, é o assunto da seção 6.

notas = [7.5, 8.0, 6.5, 9.0, 5.5]

media = 0
print("Média:", media)

notas = [7.5, 8.0, 6.5, 9.0, 5.5]

media = round(sum(notas) / len(notas), 1)
print("Média:", media)

4. abs() e round(): mexendo com números

abs(): o valor sem o sinal

abs vem de "absoluto". Ela tira o sinal de menos: devolve a distância do número até o zero. Serve, por exemplo, para saber a diferença entre dois valores sem se importar com qual é o maior.

>>> abs(-5)
5
>>> abs(-2.75)
2.75
>>> abs(3)
3

round(): arredondar

round quer dizer "arredondar". Com um número só, arredonda para inteiro. Com um segundo número, diz quantas casas decimais manter:

>>> round(3.14159, 2)
3.14
>>> round(7.456)
7
>>> round(1234.5678, -2)
1200.0

round(3.14159, 2)

Duas casas depois do ponto: 3.14.

round(7.456)

Sem o segundo número: o inteiro mais perto, 7 (e o resultado é um int).

round(1234.5678, -2)

Com casas negativas, arredonda para a esquerda do ponto: -2 é "para a centena mais próxima", 1200.0.

>>> round(7.5)
8
>>> round(8.5)
8
>>> round(2.675, 2)
2.67

5. any() e all(): "alguém?" e "todos?"

Duas perguntas aparecem o tempo todo: "algum aluno tirou menos de 7?" e "todos passaram?". As funções any ("algum") e all ("todos") respondem com True ou False (aula Booleanos):

>>> any([False, False, True])
True
>>> all([True, True, False])
False

any([…])

True se pelo menos um item for verdadeiro. Basta um.

all([…])

True só se todos os itens forem verdadeiros. Basta um falso para dar False.

Na prática, você monta a lista de True/False com uma list comprehension (aula List Comprehension), fazendo a mesma pergunta para cada item:

>>> notas
[7.5, 8.0, 6.5, 9.0]
>>> any([nota < 7 for nota in notas])
True
>>> all([nota >= 6 for nota in notas])
True

A primeira pergunta é "alguma nota abaixo de 7?": sim, o 6.5. A segunda é "todas as notas são 6 ou mais?": sim. E com uma lista vazia?

>>> any([])
False
>>> all([])
True

Parece estranho, mas faz sentido: numa sala vazia, "algum aluno reprovou?" é falso (não há ninguém), e "todos passaram?" é verdadeiro, porque ninguém deixou de passar. Lembre disso se a sua lista puder chegar vazia.

6. sorted(): uma cópia em ordem

sorted quer dizer "ordenado". Ela devolve uma lista nova, em ordem, e não mexe na original:

>>> sorted([30, 4, 12, 8])
[4, 8, 12, 30]
>>> sorted([30, 4, 12, 8], reverse=True)
[30, 12, 8, 4]
>>> sorted(nomes, key=len)
['Jo', 'Ana', 'Bruno', 'Clara']
>>> sorted("Ana")
['A', 'a', 'n']

reverse=True

"Ao contrário": do maior para o menor.

key=len

O mesmo key do max(): ordena pelo tamanho. Bruno e Clara empataram com 5 letras e ficaram na ordem em que já estavam.

sorted("Ana")

Funciona com qualquer coisa que tenha itens, até um texto, mas o resultado é sempre uma lista. O 'A' maiúsculo veio antes das minúsculas.

A diferença entre sorted(lista) e o método lista.sort() (que muda a própria lista) é o assunto da aula Ordenando Listas.

Tudo junto: o boletim da turma

notas = [7.5, 8.0, 6.5, 9.0, 5.5]

print("Quantidade de notas:", len(notas))
print("Soma:", sum(notas))
print("Média:", round(sum(notas) / len(notas), 1))
print("Menor nota:", min(notas))
print("Maior nota:", max(notas))
print("Em ordem:", sorted(notas))
print("Alguém abaixo de 6?", any([nota < 6 for nota in notas]))
print("Todos acima de 5?", all([nota > 5 for nota in notas]))

$ python3 boletim.py
Quantidade de notas: 5
Soma: 36.5
Média: 7.3
Menor nota: 5.5
Maior nota: 9.0
Em ordem: [5.5, 6.5, 7.5, 8.0, 9.0]
Alguém abaixo de 6? True
Todos acima de 5? True

Oito perguntas sobre a turma, nenhum laço escrito à mão.

Formas diferentes de fazer a mesma coisa

Achar a maior nota, de três jeitos:

maior = notas[0]
for nota in notas:
    if nota > maior:
        maior = nota

maior = sorted(notas)[-1]

maior = max(notas)

Quando dá errado

notas = [7.5, 8.0, 6.5]
sum = 0
for nota in notas:
    sum = sum + nota
print("Total:", sum)

media = sum(notas) / len(notas)
print("Média:", media)

$ python3 sombra.py
Total: 22.0
Traceback (most recent call last):
  File "/home/ana/sombra.py", line 7, in <module>
    media = sum(notas) / len(notas)
            ~~~^^^^^^^
TypeError: 'float' object is not callable

notas = [7.5, 8.0, 6.5]
sum = 0
for nota in notas:
    sum = sum + nota
print("Total:", sum)

media = sum(notas) / len(notas)
print("Média:", media)

notas = [7.5, 8.0, 6.5]
total = 0
for nota in notas:
    total = total + nota
print("Total:", total)

media = sum(notas) / len(notas)
print("Média:", media)

>>> len(5)
Traceback (most recent call last):
  File "<python-input-0>", line 1, in <module>
    len(5)
    ~~~^^^
TypeError: object of type 'int' has no len()

>>> max([])
Traceback (most recent call last):
  File "<python-input-2>", line 1, in <module>
    max([])
    ~~~^^^^
ValueError: max() iterable argument is empty
>>> max([], default=0)
0

>>> sum(["pão", "leite"])
Traceback (most recent call last):
  File "<python-input-1>", line 1, in <module>
    sum(["pão", "leite"])
    ~~~^^^^^^^^^^^^^^^^^^
TypeError: unsupported operand type(s) for +: 'int' and 'str'
>>> max(3, "10")
Traceback (most recent call last):
  File "<python-input-4>", line 1, in <module>
    max(3, "10")
    ~~~^^^^^^^^^
TypeError: '>' not supported between instances of 'str' and 'int'

Referência rápida

O Python tem muitas outras funções embutidas: enumerate() e zip() (aula enumerate() e zip()), map() e filter() (aula map() e filter()) e dezenas de outras. A lista completa, para consulta, está em Referência: Funções Embutidas.

Exercícios

Missão final: o item de nome mais comprido

itens = ["arroz", "sal", "macarrão", "feijão", "café"]

mais_comprido = itens[0]
print("Mais comprido:", mais_comprido)

itens = ["arroz", "sal", "macarrão", "feijão", "café"]

mais_comprido = max(itens, key=len)
print("Mais comprido:", mais_comprido)

Agora troque o max por min: qual item aparece? E se você tirar o key=len e deixar só max(itens)? Repare que aí a resposta é o último item em ordem alfabética.

Resumo

• Funções embutidas já vêm com o Python: nada de import nem def.
• len() conta itens; sum() soma números; sum(x) / len(x) é a média.
• min() e max() acham o menor e o maior; com key=, segundo um critério (key=len, sem parênteses); com default=, não quebram com lista vazia.
• abs() tira o sinal; round() arredonda, e no meio vai para o par (round(8.5) é 8).
• sorted() devolve uma lista nova em ordem, sem mexer na original.
• any() = "algum é verdadeiro?"; all() = "todos são verdadeiros?".
• Nunca dê a uma variável o nome de uma função embutida (sum, list, max): a função fica escondida e aparece … object is not callable.