Este guia explora os principais métodos e operações para manipular as estruturas de dados built-in do Python: listas, tuplas, booleanos, dicionários e conjuntos.

1. Operações Comuns e Métodos para Listas

1.1 Operações Essenciais

Conversão de Tipo: A função list() converte iteráveis em listas.

print(list('python'))  # Saída: ['p', 'y', 't', 'h', 'o', 'n']
print(list((10, 20, 30)))  # Saída: [10, 20, 30]
print(list({7, 8, 9}))  # Saída: [8, 9, 7] (a ordem pode variar)

Ao converter um dicionário, apenas as chaves se tornam itens da lista:

meu_dict = {'nome': 'Ana', 'idade': 25, 'cidade': 'Lisboa'}
print(list(meu_dict))  # Saída: ['nome', 'idade', 'cidade']

Fatiamento (Slice): Extrai sub-sequências de uma lista.

animais = ['gato', 'cachorro', 'pássaro', 'peixe', 'hamster']
print(animais[1:4])  # Saída: ['cachorro', 'pássaro', 'peixe']
print(animais[::2])   # Saída: ['gato', 'pássaro', 'hamster']
print(animais[::-1])  # Inverte a lista: ['hamster', 'peixe', 'pássaro', 'cachorro', 'gato']

Tamanho: len() retorna o número de elementos.

Verificação de Pertinência: in e not in verificam se um elemento está na lista.

1.2 Métodos de Modificação

Adicionando Elementos:

• append(item): Adiciona ao final da lista.
• insert(index, item): Insere em uma posição específica.
• extend(iteravel): Adiciona todos os elementos de outro iterável.

frutas = ['maçã', 'banana']
frutas.append('laranja')
print(frutas)  # ['maçã', 'banana', 'laranja']

frutas.insert(1, 'morango')
print(frutas)  # ['maçã', 'morango', 'banana', 'laranja']

legumes = ['cenoura', 'batata']
frutas.extend(legumes)
print(frutas)  # ['maçã', 'morango', 'banana', 'laranja', 'cenoura', 'batata']

Removendo Elementos:

• remove(valor): Remove a primeira ocorrência do valor.
• pop(index): Remove e retorna o elemento no índice (o último por padrão).
• del lista[index]: Remove por índice.
• clear(): Remove todos os elementos.

numeros = [10, 20, 30, 20, 40]
numeros.remove(20)
print(numeros)  # [10, 30, 20, 40]

valor_removido = numeros.pop()
print(valor_removido, numeros)  # 40 [10, 30, 20]

del numeros[1]
print(numeros)  # [10, 20]

numeros.clear()
print(numeros)  # []

Ordenação e Inversão:

• sort(): Ordena a lista no local (retorna None).
• sorted(iteravel): Retorna uma nova lista ordenada sem modificar a original.
• reverse(): Inverte a ordem dos elementos no local.

valores = [3, 1, 4, 1, 5, 9, 2, 6]
valores.sort()
print(valores)  # [1, 1, 2, 3, 4, 5, 6, 9]

valores_ordenados_desc = sorted(valores, reverse=True)
print(valores_ordenados_desc)  # [9, 6, 5, 4, 3, 2, 1, 1]
print(valores)  # [1, 1, 2, 3, 4, 5, 6, 9] (original não foi alterada)

letras = ['c', 'a', 'b']
letras.reverse()
print(letras)  # ['b', 'a', 'c']

2. Métodos Embutidos para Tuplas

Tuplas são imutáveis, portanto, seus métodos são limitados a operações que não modificam a estrutura.

minha_tupla = (1, 2, 3, 4, 5)
# Acesso por índice
print(minha_tupla[2])  # Saída: 3

# Fatiamento
print(minha_tupla[1:3])  # Saída: (2, 3)
print(minha_tupla[::-1])  # Inverte: (5, 4, 3, 2, 1)

# Tamanho e verificação
print(len(minha_tupla))  # 5
print(3 in minha_tupla)   # True

# Concatenação e repetição (cria novas tuplas)
outra = (10, 20)
concatenada = minha_tupla + outra
print(concatenada)  # (1, 2, 3, 4, 5, 10, 20)

repetida = ('x',) * 3
print(repetida)  # ('x', 'x', 'x')

3. Comportamento dos Booleenos

A função bool() converte valores para booleano.

# Valores considerados False:
print(bool(False))      # False
print(bool(0))          # False (qualquer número zero)
print(bool(0.0))        # False
print(bool(''))         # False (string vazia)
print(bool([]))         # False (lista vazia)
print(bool(()))         # False (tupla vazia)
print(bool({}))         # False (dicionário vazio)
print(bool(None))       # False

# Valores considerados True (praticamente todo o resto):
print(bool(True))       # True
print(bool(42))         # True (qualquer número não-zero)
print(bool(-1))         # True
print(bool('texto'))    # True (string não-vazia)
print(bool([0]))        # True (lista com um elemento, mesmo que 0)
print(bool({'a': 1}))   # True

4. Métodos Embutidos para Dicionários

estudante = {
    'nome': 'Carlos',
    'nota': 8.5,
    'aprovado': True,
    'disciplinas': ['Matemática', 'Português']
}

# Acesso seguro com get()
print(estudante.get('nome'))            # Carlos
print(estudante.get('idade'))           # None
print(estudante.get('idade', 20))       # 20 (valor padrão)

# Tamanho e pertinência
print(len(estudante))                   # 4
print('nome' in estudante)              # True (verifica chaves)

# Adicionando/Atualizando
estudante['email'] = 'carlos@example.com'
estudante.update({'telefone': '123456', 'nota': 9.0})
print(estudante)

# Removendo
del estudante['telefone']
disciplinas = estudante.pop('disciplinas')
print(disciplinas, estudante)

# Removendo o último item inserido
par = estudante.popitem()
print(par, estudante)

# Acessando chaves, valores e itens
print(estudante.keys())    # dict_keys(['nome', 'nota', 'aprovado', 'email'])
print(estudante.values())  # dict_values(['Carlos', 9.0, True, 'carlos@example.com'])
print(estudante.items())   # dict_items([('nome', 'Carlos'), ...])

# Iterando
for chave, valor in estudante.items():
    print(f'{chave}: {valor}')

O método setdefault(chave, valor) retorrna o valor da chave se existir; caso contrário, insere a chave com o valor fornecido e o retorna.

config = {'tema': 'escuro'}
idioma = config.setdefault('idioma', 'pt-BR')
print(config)  # {'tema': 'escuro', 'idioma': 'pt-BR'}
print(idioma)  # pt-BR

config.setdefault('tema', 'claro')  # Não altera, 'tema' já existe.
print(config['tema'])  # escuro

5. Métodos Embutdios para Conjuntos (Sets)

Conjuntos são coleções não-ordenadas e sem elementos duplicados.

# Criação e conversão
conjunto_a = {1, 2, 3, 4, 5}
conjunto_b = set([4, 5, 6, 7, 8])
conjunto_c = set('abracadabra')  # {'a', 'b', 'r', 'c', 'd'} (sem duplicatas)

# Adicionando elementos
conjunto_a.add(6)
print(conjunto_a)  # {1, 2, 3, 4, 5, 6}

# Atualizando com múltiplos elementos (de um iterável)
conjunto_a.update([7, 8, 9])
print(conjunto_a)  # {1, 2, 3, 4, 5, 6, 7, 8, 9}

# Removendo elementos
conjunto_a.remove(9)  # Gera KeyError se o elemento não existir.
conjunto_a.discard(10) # Não gera erro se o elemento não existir.
elemento = conjunto_a.pop()  # Remove e retorna um elemento arbitrário.
print(f"Removido: {elemento}, Restante: {conjunto_a}")

Operações de Conjunto:

# União (elementos em A ou B ou ambos)
print(conjunto_a | conjunto_b)

# Interseção (elementos comuns a A e B)
print(conjunto_a & conjunto_b)

# Diferença (elementos em A que não estão em B)
print(conjunto_a - conjunto_b)

# Diferença Simétrica (elementos em A ou B, mas não em ambos)
print(conjunto_a ^ conjunto_b)