Todas as Funções Built-in do Python Explicadas

As funções built-in do Python são ferramentas prontas que vêm incluídas na linguagem. Você não precisa instalar nada extra para usá-las. Basta escrever o nome da função e ela funciona. São como ferramentas de uma caixa que já vem com você desde o primeiro dia.

Quando você começa a aprender Python, essas funções são suas melhores amigas. Elas resolvem problemas comuns de forma rápida e simples. Neste guia completo, você vai conhecer todas as funções nativas do Python com exemplos práticos.

O que são funções built-in?

Funções built-in são funções que já existem no Python desde a instalação. Elas fazem parte do núcleo da linguagem. Você pode usá-las em qualquer programa sem precisar importar bibliotecas ou módulos.

Pense assim: quando você compra um celular novo, ele já vem com alguns aplicativos básicos instalados. O Python funciona da mesma forma. Ele já vem com mais de 70 funções prontas para você usar.

A diferença entre funções built-in e outras funções é simples. As built-in não precisam de nenhum comando especial para funcionar. Basta digitar o nome e usar. Já as funções de bibliotecas externas precisam ser importadas antes.

Por que as funções built-in são importantes?

Essas funções economizam muito tempo. Imagine ter que escrever código do zero toda vez que precisasse somar números ou medir o tamanho de uma lista. As funções built-in já fazem isso por você.

Além disso, elas são muito bem testadas. A equipe do Python trabalhou anos para garantir que cada função funcione perfeitamente. Quando você usa uma função built-in, está usando código de alta qualidade.

Para quem está começando a programar, conhecer essas funções é essencial. Elas aparecem em praticamente todo código Python que você vai encontrar.

Funções de entrada e saída de dados

As funções de entrada e saída são as mais usadas no dia a dia. Elas permitem que seu programa converse com o usuário.

print()

A função print() mostra informações na tela. É provavelmente a primeira função que todo programador aprende.

print("Olá, mundo!")
print(42)
print("O resultado é:", 10 + 5)

print("Olá, mundo!")
print(42)
print("O resultado é:", 10 + 5)

Você pode passar vários valores separados por vírgula. A função vai mostrar todos eles na mesma linha.

input()

A função input() recebe dados do usuário. Ela espera a pessoa digitar algo e pressionar Enter.

nome = input("Qual é o seu nome? ")
print("Olá,", nome)

nome = input("Qual é o seu nome? ")
print("Olá,", nome)

Um detalhe importante: o input() sempre retorna uma string. Se você quer um número, precisa converter depois.

Funções de conversão de tipos

Essas funções transformam um tipo de dado em outro. São muito úteis quando você precisa fazer cálculos com dados que vieram como texto.

int()

Converte um valor para número inteiro. Funciona com strings que contêm números e com números decimais.

numero = int("42")      # Resultado: 42
inteiro = int(3.7)       # Resultado: 3 (remove a parte decimal)

numero = int("42")      # Resultado: 42
inteiro = int(3.7)       # Resultado: 3 (remove a parte decimal)

float()

Transforma um valor em número decimal, também chamado de ponto flutuante.

decimal = float("3.14")  # Resultado: 3.14
decimal2 = float(5)       # Resultado: 5.0

decimal = float("3.14")  # Resultado: 3.14
decimal2 = float(5)       # Resultado: 5.0

str()

Converte qualquer valor para string (texto).

texto = str(100)         # Resultado: "100"
texto2 = str(3.14)        # Resultado: "3.14"

texto = str(100)         # Resultado: "100"
texto2 = str(3.14)        # Resultado: "3.14"

bool()

Converte um valor para booleano (True ou False). Valores vazios ou zero viram False. O resto vira True.

bool(1)      # True
bool(0)      # False
bool("")     # False
bool("oi")   # True

bool(1)      # True
bool(0)      # False
bool("")     # False
bool("oi")   # True

list(), tuple(), set(), dict()

Essas funções criam ou convertem valores para diferentes tipos de coleções. Cada uma tem suas características próprias, conforme explicamos no artigo sobre a diferença entre lista, tupla, conjunto e dicionário.

lista = list("Python")      # ['P', 'y', 't', 'h', 'o', 'n']
tupla = tuple([1, 2, 3])     # (1, 2, 3)
conjunto = set([1, 1, 2])    # {1, 2}
dicionario = dict(a=1, b=2)  # {'a': 1, 'b': 2}

lista = list("Python")      # ['P', 'y', 't', 'h', 'o', 'n']
tupla = tuple([1, 2, 3])     # (1, 2, 3)
conjunto = set([1, 1, 2])    # {1, 2}
dicionario = dict(a=1, b=2)  # {'a': 1, 'b': 2}

Funções matemáticas essenciais

O Python oferece várias funções para cálculos matemáticos básicos. Para operações mais avançadas, você pode usar a biblioteca NumPy.

abs()

Retorna o valor absoluto de um número. Em outras palavras, transforma números negativos em positivos.

abs(-5)      # 5
abs(3.14)    # 3.14
abs(-10.5)   # 10.5

abs(-5)      # 5
abs(3.14)    # 3.14
abs(-10.5)   # 10.5

round()

Arredonda um número decimal. Você pode escolher quantas casas decimais quer manter.

round(3.7)       # 4
round(3.14159, 2) # 3.14
round(2.5)       # 2 (arredonda para o par mais próximo)

round(3.7)       # 4
round(3.14159, 2) # 3.14
round(2.5)       # 2 (arredonda para o par mais próximo)

pow()

Calcula a potência de um número. É o mesmo que usar o operador **.

pow(2, 3)    # 8 (2 elevado a 3)
pow(5, 2)    # 25
pow(10, -1)  # 0.1

pow(2, 3)    # 8 (2 elevado a 3)
pow(5, 2)    # 25
pow(10, -1)  # 0.1

sum()

Soma todos os elementos de uma lista ou outra sequência.

sum([1, 2, 3, 4, 5])     # 15
sum([10, 20, 30])         # 60
sum([1.5, 2.5, 3.0])      # 7.0

sum([1, 2, 3, 4, 5])     # 15
sum([10, 20, 30])         # 60
sum([1.5, 2.5, 3.0])      # 7.0

min() e max()

Encontram o menor e o maior valor em uma sequência.

min([5, 2, 8, 1])    # 1
max([5, 2, 8, 1])    # 8
min("python")         # 'h' (menor na ordem alfabética)
max("python")         # 'y'

min([5, 2, 8, 1])    # 1
max([5, 2, 8, 1])    # 8
min("python")         # 'h' (menor na ordem alfabética)
max("python")         # 'y'

divmod()

Retorna o quociente e o resto de uma divisão ao mesmo tempo.

divmod(17, 5)    # (3, 2) - 17 dividido por 5 = 3 com resto 2
divmod(10, 3)    # (3, 1)

divmod(17, 5)    # (3, 2) - 17 dividido por 5 = 3 com resto 2
divmod(10, 3)    # (3, 1)

Funções para trabalhar com sequências

Essas funções ajudam a manipular listas, strings e outras sequências de dados.

len()

Retorna o tamanho de uma sequência. Funciona com strings, listas, tuplas, dicionários e mais.

len("Python")        # 6
len([1, 2, 3, 4])    # 4
len({"a": 1, "b": 2}) # 2

len("Python")        # 6
len([1, 2, 3, 4])    # 4
len({"a": 1, "b": 2}) # 2

range()

Cria uma sequência de números. É muito usada em loops, especialmente no for. Veja nosso guia completo sobre como funciona o range no Python.

list(range(5))           # [0, 1, 2, 3, 4]
list(range(1, 6))        # [1, 2, 3, 4, 5]
list(range(0, 10, 2))    # [0, 2, 4, 6, 8]

list(range(5))           # [0, 1, 2, 3, 4]
list(range(1, 6))        # [1, 2, 3, 4, 5]
list(range(0, 10, 2))    # [0, 2, 4, 6, 8]

sorted()

Retorna uma nova lista ordenada. Não modifica a lista original.

sorted([3, 1, 4, 1, 5])        # [1, 1, 3, 4, 5]
sorted("python")                # ['h', 'n', 'o', 'p', 't', 'y']
sorted([5, 2, 8], reverse=True) # [8, 5, 2]

sorted([3, 1, 4, 1, 5])        # [1, 1, 3, 4, 5]
sorted("python")                # ['h', 'n', 'o', 'p', 't', 'y']
sorted([5, 2, 8], reverse=True) # [8, 5, 2]

reversed()

Retorna um iterador com os elementos em ordem invertida.

list(reversed([1, 2, 3]))    # [3, 2, 1]
list(reversed("Python"))      # ['n', 'o', 'h', 't', 'y', 'P']

list(reversed([1, 2, 3]))    # [3, 2, 1]
list(reversed("Python"))      # ['n', 'o', 'h', 't', 'y', 'P']

enumerate()

Adiciona um contador aos elementos de uma sequência. Muito útil em loops quando você precisa do índice.

frutas = ["maçã", "banana", "laranja"]
for indice, fruta in enumerate(frutas):
    print(indice, fruta)
# 0 maçã
# 1 banana
# 2 laranja

frutas = ["maçã", "banana", "laranja"]
for indice, fruta in enumerate(frutas):
    print(indice, fruta)
# 0 maçã
# 1 banana
# 2 laranja

zip()

Combina elementos de várias sequências em pares ou grupos.

nomes = ["Ana", "Bruno", "Carlos"]
idades = [25, 30, 35]
list(zip(nomes, idades))
# [('Ana', 25), ('Bruno', 30), ('Carlos', 35)]

nomes = ["Ana", "Bruno", "Carlos"]
idades = [25, 30, 35]
list(zip(nomes, idades))
# [('Ana', 25), ('Bruno', 30), ('Carlos', 35)]

filter()

Filtra elementos de uma sequência com base em uma condição.

numeros = [1, 2, 3, 4, 5, 6]
pares = list(filter(lambda x: x % 2 == 0, numeros))
# [2, 4, 6]

numeros = [1, 2, 3, 4, 5, 6]
pares = list(filter(lambda x: x % 2 == 0, numeros))
# [2, 4, 6]

map()

Aplica uma função a cada elemento de uma sequência.

numeros = [1, 2, 3, 4, 5]
dobros = list(map(lambda x: x * 2, numeros))
# [2, 4, 6, 8, 10]

numeros = [1, 2, 3, 4, 5]
dobros = list(map(lambda x: x * 2, numeros))
# [2, 4, 6, 8, 10]

Funções para verificação de tipos

Essas funções ajudam a descobrir informações sobre os dados que você está usando.

type()

Retorna o tipo de um objeto. Muito útil para entender os tipos de variáveis em Python.

type(42)           # <class 'int'>
type("texto")      # <class 'str'>
type([1, 2, 3])    # <class 'list'>

type(42)           # <class 'int'>
type("texto")      # <class 'str'>
type([1, 2, 3])    # <class 'list'>

isinstance()

Verifica se um objeto é de um determinado tipo. Retorna True ou False.

isinstance(42, int)        # True
isinstance("texto", str)    # True
isinstance([1, 2], tuple)   # False

isinstance(42, int)        # True
isinstance("texto", str)    # True
isinstance([1, 2], tuple)   # False

callable()

Verifica se um objeto pode ser chamado como função.

callable(print)    # True
callable(42)       # False
callable(len)      # True

callable(print)    # True
callable(42)       # False
callable(len)      # True

Funções para trabalhar com objetos

id()

Retorna o identificador único de um objeto na memória.

x = 10
id(x)    # Retorna um número único

x = 10
id(x)    # Retorna um número único

dir()

Lista todos os atributos e métodos de um objeto. Muito útil para explorar o que você pode fazer com cada tipo de dado.

dir("")    # Lista todos os métodos de strings
dir([])    # Lista todos os métodos de listas

dir("")    # Lista todos os métodos de strings
dir([])    # Lista todos os métodos de listas

help()

Mostra a documentação de uma função ou objeto. É como ter um manual sempre disponível.

help(print)    # Mostra toda a documentação da função print
help(len)      # Mostra como usar a função len

help(print)    # Mostra toda a documentação da função print
help(len)      # Mostra como usar a função len

getattr(), setattr(), hasattr(), delattr()

Essas funções manipulam atributos de objetos de forma dinâmica. São muito usadas em programação orientada a objetos.

class Pessoa:
    nome = "João"

p = Pessoa()
getattr(p, "nome")      # "João"
hasattr(p, "nome")      # True
setattr(p, "idade", 25)  # Adiciona atributo idade
delattr(p, "idade")      # Remove atributo idade

class Pessoa:
    nome = "João"

p = Pessoa()
getattr(p, "nome")      # "João"
hasattr(p, "nome")      # True
setattr(p, "idade", 25)  # Adiciona atributo idade
delattr(p, "idade")      # Remove atributo idade

Funções para arquivos

open()

Abre um arquivo para leitura ou escrita. É a principal função para trabalhar com arquivos em Python.

# Leitura
arquivo = open("dados.txt", "r")
conteudo = arquivo.read()
arquivo.close()

# Escrita
arquivo = open("novo.txt", "w")
arquivo.write("Olá, mundo!")
arquivo.close()

# Leitura
arquivo = open("dados.txt", "r")
conteudo = arquivo.read()
arquivo.close()

# Escrita
arquivo = open("novo.txt", "w")
arquivo.write("Olá, mundo!")
arquivo.close()

A forma recomendada é usar o bloco with, que fecha o arquivo automaticamente:

with open("dados.txt", "r") as arquivo:
    conteudo = arquivo.read()

with open("dados.txt", "r") as arquivo:
    conteudo = arquivo.read()

Funções para conversão de caracteres

ord() e chr()

A função ord() retorna o código Unicode de um caractere. A função chr() faz o contrário.

ord("A")    # 65
ord("a")    # 97
chr(65)     # "A"
chr(97)     # "a"

ord("A")    # 65
ord("a")    # 97
chr(65)     # "A"
chr(97)     # "a"

bin(), oct(), hex()

Convertem números inteiros para diferentes bases numéricas.

bin(10)    # '0b1010' (binário)
oct(10)    # '0o12' (octal)
hex(255)   # '0xff' (hexadecimal)

bin(10)    # '0b1010' (binário)
oct(10)    # '0o12' (octal)
hex(255)   # '0xff' (hexadecimal)

Funções avançadas

eval() e exec()

Executam código Python a partir de uma string. Use com cuidado, pois podem ser perigosas se usadas com dados de usuários.

eval("2 + 2")      # 4
eval("len([1,2,3])")  # 3

exec("x = 10")
exec("print(x)")   # 10

eval("2 + 2")      # 4
eval("len([1,2,3])")  # 3

exec("x = 10")
exec("print(x)")   # 10

compile()

Compila código fonte em um objeto de código que pode ser executado.

codigo = compile("print('Olá')", "<string>", "exec")
exec(codigo)  # Olá

codigo = compile("print('Olá')", "<string>", "exec")
exec(codigo)  # Olá

globals() e locals()

Retornam dicionários com as variáveis globais e locais, respectivamente. São úteis para entender o escopo de variáveis.

x = 10
print(globals())  # Mostra todas as variáveis globais

def teste():
    y = 20
    print(locals())  # Mostra variáveis locais

x = 10
print(globals())  # Mostra todas as variáveis globais

def teste():
    y = 20
    print(locals())  # Mostra variáveis locais

Funções para iteradores e geradores

iter() e next()

Criam e manipulam iteradores manualmente.

lista = [1, 2, 3]
iterador = iter(lista)
next(iterador)  # 1
next(iterador)  # 2
next(iterador)  # 3

lista = [1, 2, 3]
iterador = iter(lista)
next(iterador)  # 1
next(iterador)  # 2
next(iterador)  # 3

all() e any()

Verificam condições em sequências. A função all() retorna True se todos os elementos forem verdadeiros. A função any() retorna True se pelo menos um elemento for verdadeiro.

all([True, True, True])   # True
all([True, False, True])  # False

any([False, False, True])  # True
any([False, False, False]) # False

all([True, True, True])   # True
all([True, False, True])  # False

any([False, False, True])  # True
any([False, False, False]) # False

Tabela completa das funções built-in

Aqui está uma tabela de referência rápida com todas as funções built-in do Python:

Vídeo recomendado

Curso em Vídeo: Funções em Python

O professor Gustavo Guanabara, do canal Curso em Vídeo, explica de forma didática como funcionam as funções em Python. Seu curso gratuito é uma referência para quem está começando a programar.

Dicas para usar funções built-in

Aqui estão algumas dicas para aproveitar melhor as funções nativas do Python:

Use a função help() sempre que tiver dúvidas. Ela mostra a documentação completa de qualquer função. Basta digitar help(nome_da_funcao) no terminal.

Combine funções para resolver problemas complexos. Por exemplo, você pode usar len(list(filter(…))) para contar quantos elementos passam em um filtro.

Prefira funções built-in a código manual. Elas são mais rápidas e já foram testadas por milhares de programadores.

Aprenda as funções aos poucos. Não tente decorar todas de uma vez. Comece pelas mais comuns como print(), input(), len(), type() e int().

Conclusão

As funções built-in do Python são ferramentas essenciais para qualquer programador. Elas economizam tempo, deixam o código mais limpo e são extremamente confiáveis.

Começar dominando as funções mais básicas como print(), input(), len() e type() já vai fazer uma grande diferença nos seus projetos. Com o tempo, você vai descobrir funções mais avançadas como map(), filter() e zip() que tornam seu código ainda mais elegante.

Lembre-se: não é preciso decorar todas as funções de uma vez. O importante é saber que elas existem e onde encontrar a documentação quando precisar. A função help() está sempre disponível para te ajudar.

Continue praticando e explorando essas funções nos seus projetos. Quanto mais você usar, mais natural vai se tornar. E se quiser se aprofundar ainda mais, confira nosso roadmap completo para aprender Python.

Perguntas Frequentes (FAQ)

1. O que são funções built-in em Python?

São funções que já vêm prontas com o Python. Você não precisa importar nada para usá-las.

2. Quantas funções built-in existem no Python?

O Python 3 possui mais de 70 funções built-in disponíveis para uso imediato.

3. Qual a diferença entre funções built-in e métodos?

Funções são independentes. Métodos pertencem a objetos específicos, como str.upper() para strings.

4. Como descobrir todas as funções disponíveis?

Use dir(__builtins__) no terminal Python ou consulte a documentação oficial.

5. Posso criar minhas próprias funções built-in?

Não diretamente. Mas você pode criar funções personalizadas usando a palavra-chave def.

6. As funções built-in são mais rápidas que código manual?

Sim, na maioria dos casos. Elas são otimizadas e escritas em C internamente.

7. Qual é a função built-in mais usada?

A função print() é provavelmente a mais usada, seguida por len(), type() e input().

8. Preciso decorar todas as funções built-in?

Não. Aprenda as mais comuns e consulte a documentação quando precisar de outras.

9. As funções built-in funcionam em todas as versões do Python?

A maioria sim, mas algumas foram adicionadas ou modificadas entre versões. Verifique a documentação.

10. Onde posso praticar o uso dessas funções?

Recomendamos nossos exercícios de Python para iniciantes para praticar.