Python oferece uma rica variedade de tipos de dados embutidos, sendo os fundamentais divididos em categorias principais:

• Numéricos: Inteiros (int), de ponto flutuante (float), booleanos (bool) e complexos (complex). São imutáveis.
• Strings: Representadas por str. Armazenam sequências de caracteres e são imutáveis.
• Listas: Representadas por list. Armazenam coleções ordenadas e mutáveis de itens.
• Tuplas: Representadas por tuple. Armazenam coleções ordenadas e imutáveis de itens.
• Conjuntos (Sets): Representados por set. Armazenam coleções não ordenadas e mutáveis de itens únicos.
• Dicionários: Representados por dict. Armazenam coleções não ordenadas (ordenadas a partir do Python 3.7) de pares chave-valor e são mutáveis.

Adicionalmente, existe o tipo NoneType, representado pelo valor None, que indica a ausência de valor.

Tipos Numéricos

Os tipos numéricos em Python incluem inteiros, de ponto flutuante, booleanos e complexos. Todos são imutáveis.

Subtipos Numéricos

1. Inteiro (int): Números inteiros como 1, 12, 9999999. Em Python 3, o tamanho de inteiros é praticamente ilimitado.
2. Ponto Flutuante (float): Números com casas decimais, como 1.0, 99.99.
3. Booleano (bool): Representa valores lógicos:
   • False: Considerado falso em contextos lógicos. Além de False, os seguintes valores também são interpretados como falsos: 0 (inteiro), 0.0 (float), '0' (string), '' (string vazia), [] (lista vazia), () (tupla vazia), {} (dicionário vazio), set() (conjunto vazio).
   • True: Considerado verdadeiro em contextos lógicos. Qualquer valor que não seja avaliado como falso é considerado verdadeiro.
4. Complexo (complex): Números com parte real e imaginária (ex: 3+5j).

Observação: Listas como [''] ou [[], []] não são consideradas vazias e, portanto, são avaliadas como True em contextos lógicos.

Operadores Numéricos

• +: Adição
• -: Subtração
• *: Multiplicação
• /: Divisão (resulta em float, ex: 1/2 = 0.5)
• //: Divisão inteira (arredonda para baixo)
• %: Módulo (resto da divisão, ex: 3 % 2 = 1)
• **: Exponenciação (potência, ex: 3 ** 2 = 9)

Conversão de Tipos Numéricos

• str(): Converte outros tipos para string (ex: str(12)).
• int(): Converte strings numéricas ou floats para intiero (ex: int("12")).
• float(): Converte strings numéricas ou inteiros para float (ex: float("1.23")).

Observação: Strings que representam números decimais, como '1.23', só podem ser convertidas para float diretamente. Tentar converter com int() resultará em erro.

Conversão de Bases Numéricas

Python suporta representações de números em binário (0b), octal (0o) e hexadecimal (0x).

• bin(): Converte para binário (ex: bin(10) retorna '0b1010').
• oct(): Converte para octal (ex: oct(10) retorna '0o12').
• hex(): Converte para hexadecimal (ex: hex(10) retorna '0xa').
• int(x, base): Converte uma string x de uma determinada base para decimal (ex: int('0b1010', 2) retorna 10). Se a string já for um literal numérico (ex: 0b1010), int() a converte para decimal.

Strings (str)

Strings são sequências imutáveis de caracteres.

Métodos Comuns de String

Método	Descrição	Exemplo
len()	Retorna o comprimento da string.	len("abcdefg") retorna 7.
count()	Conta ocorrências de uma substring.	"aabcabc".count("a") retorna 3.
find() / index()	Retorna o índice da primeira ocorrência de uma substring. find() retorna -1 se não encontrado; index() lança uma exceção.	"abcdefg".find("b") retorna 1.
replace()	Substitui ocorrências de uma substring por outra.	"hello,java".replace("java", "python") retorna "hello,python".
split()	Divide a string em uma lista de substrings usando um delimitador.	"a,b,c,d".split(",") retorna ['a', 'b', 'c', 'd'].
join()	Concatena elementos de um iterável em uma string, usando a string original como delimitador.	"-".join(["a", "b", "c", "d"]) retorna "a-b-c-d".
lower() / upper()	Converte a string para minúsculas ou maiúsculas.	"AbcdeF".lower() retorna "abcdef".
isdigit() / isalpha() / isalnum()	Verifica se a string contém apenas dígitos, letras ou alfanuméricos, respectivamente.	"123".isdigit() retorna True.
strip() / lstrip() / rstrip()	Remove caracteres de espaço em branco (ou especificados) do início e fim (strip()), apenas do início (lstrip()) ou apenas do fim (rstrip()).	" abc \n".strip() retorna "abc".

Formatação de Strings

Permite a inserção de valores e formatação em strings.

• Operador %: Estilo C (ex: "Nome: %s, Idade: %d" % ("Lily", 12)).
• Método format(): Mais flexível (ex: "Nome: {}, Idade: {}".format("Lily", 12) ou "Nome: {nome}, Idade: {idade}".format(nome="Lily", idade=12)).
• f-strings (Formatted String Literals): A forma mais moderna e legível (ex: name = "Lily"; age = 12; f'Nome: {name}, Idade: {age}').
• Template Strings (string.Template): Oferece métodos como substitute() e safe_substitute().

Exemplo: Geração de Relatório HTML com format()

tpl = '''
<title>{title}</title>

<h1>{title}</h1>
<table border="1">
   <tr>
       <th>Número</th>
       <th>Caso de Teste</th>
       <th>Resultado</th>
   </tr>
   {rows}
</table>


'''

row_template = '''<tr><td>{seq_num}</td>
<td>{test_case_name}</td>
<td>{result}</td></tr>
'''

report_title = "Relatório de Testes Automatizados"
test_results = [("1", "test_soma_normal", "PASS"),
               ("2", "test_soma_negativa", "PASS"),
               ("3", "test_soma_float", "FAIL")]

table_rows = ''
for seq, case, outcome in test_results:
   row_formatted = row_template.format(seq_num=seq, test_case_name=case, result=outcome)
   table_rows += row_formatted

final_html = tpl.format(title=report_title, rows=table_rows)

with open("report.html", "w", encoding="utf-8") as f:
   f.write(final_html)
   

Resultado esperado no arquivo report.html:

Relatório de Testes Automatizados

Número	Caso de Teste	Resultado
1	test_soma_normal	PASS
2	test_soma_negativa	PASS
3	test_soma_float	FAIL

Listas (list)

Listas são coleções ordenadas e mutáveis de itens, que podem ser de tipos diferentes e até mesmo conter outras listas (aninhamento).

Exemplo: ["a", 1, {"b": 3}, [1, 2, 3]]

Operações com Listas

• Atribuição: my_list = [1, "hello", ("a", "b")]
• Acesso: first_item = my_list[0] (acesso por índice).
• Adição:
  • append(): Adiciona ao final. my_list.append("c").
  • extend(): Adiciona múltiplos itens de um iterável. my_list.extend(["d", "e"]).
  • +: Concatena listas. my_list = my_list + ["f"].
• Remoção:
  • pop(): Remove e retorna o item no índice especificado (ou o último se nenhum índice for dado). my_list.pop(0).
  • remove(): Remove a primeira ocorrência de um valor especificado. my_list.remove("c").
• Modificação: my_list[1] = "HELLO" (altera o item no índice 1).
• Busca/Iteração: for item in my_list: print(item).

Métodos Comuns de Lista

Método	Descrição	Exemplo
append()	Adiciona um item ao final da lista.	[1, 2].append(3) resulta em [1, 2, 3].
insert()	Insere um item em um índice específico.	[1, 3].insert(1, 2) resulta em [1, 2, 3].
extend()	Adiciona todos os itens de um iterável ao final da lista.	[1, 2].extend([3, 4]) resulta em [1, 2, 3, 4].
index()	Retorna o índice da primeira ocorrência de um valor.	[1, 2].index(2) retorna 1.
count()	Conta quantas vezes um valor aparece na lista.	[1, 2, 1, 1].count(1) retorna 3.
pop()	Remove e retorna o item em um índice (ou o último se o índice não for especificado).	[1, 2].pop(0) retorna 1 e a lista se torna [2].
remove()	Remove a primeira ocorrência de um valor especificado.	[1, 2].remove(1) resulta em [2].
sort()	Ordena os itens da lista in-place (modifica a lista original).	[1, 3, 2].sort() resulta em [1, 2, 3].
reverse()	Inverte a ordem dos itens da lista in-place.	[1, 3, 2].reverse() resulta em [2, 3, 1].

Exemplo: Reverter uma String usando Lista

original_string = "abcdefg"
# Converte a string em lista, inverte a lista, junta de volta em string
reversed_string = ''.join(reversed(original_string))
# Ou usando slicing: reversed_string = original_string[::-1]
print(reversed_string) # Saída: gfedcba
   

Tuplas (tuple)

Tuplas são coleções ordenadas e imutáveis de itens. São frequentemente usadas para representar estruturas de dados fixas, como coordenadas (x, y).

• Imutabilidade: Uma vez criadas, tuplas não podem ser modificadas (itens adicionados, removidos ou alterados).
• Elementos Mistos e Aninhamento: Assim como listas, podem conter tipos de dados variados e outras tuplas.
• Elemento Único: Para criar uma tupla com um único elemento, é necessário usar uma vírgula: single_tuple = ("hello",). Sem a vírgula, ("hello") seria interpretado como a string "hello" dentro de parênteses para agrupamento.
• Chave de Dicionário: Por serem imutáveis, tuplas podem ser usadas como chaves em dicionários (ex: {(1, 2): "coordenada"}), o que não é possível com listas.

Nota: Strings, listas e tuplas são coletivamente chamadas de sequências e compartilham muitas operações.

Métodos de Tupla

Devido à sua imutabilidade, tuplas possuem poucos métodos embutidos, focados em consulta:

Método	Descrição	Exemplo
index()	Retorna o índice da primeira ocorrência de um valor.	t = (1, 2, 3); print(t.index(2)) retorna 1.
count()	Conta quantas vezes um valor aparece na tupla.	t = (1, 2, 3, 2, 1, 2); print(t.count(2)) retorna 3.

Operações Comuns de Sequências

Strings, listas e tuplas, como sequências, suportam as seguintes operações:

Indexação

• Positiva: Acessa elementos a partir do início (começando em 0). Ex: my_list[3].
• Negativa: Acessa elementos a partir do final (começando em -1). Ex: my_list[-1].
• IndexError: Ocorre se o índice estiver fora do intervalo válido da sequência.

Fatiamento (Slicing)

Permite extrair subconjuntos de uma sequência.

• seq[start:stop]: Cria uma nova sequência do índice start até (mas não incluindo) o índice stop. Ex: my_list = [1, 2, 3, 4, 5]; my_list[1:3] retorna [2, 3].
• seq[start:stop:step]: Permite especificar um passo (step) para a extração. Ex: my_list[::2] pega elementos a cada dois passos.
• Casos Especiais:
  • seq[:stop]: Do início até stop.
  • seq[start:]: De start até o final.
  • seq[:]: Cria uma cópia rasa da sequência.
  • seq[::-1]: Inverte a sequência.

Exemplo: Inverter String com Slicing

text = "Python"
reversed_text = text[::-1]
print(reversed_text) # Saída: nohtyP
   

Iteração

• Por Elemento: for item in sequence: ...
• Por Índice: for index in range(len(sequence)): print(sequence[index])
• Com Índice e Valor (Enumerado): for index, value in enumerate(sequence): print(f"Índice {index}: {value}")

Extensão/Concatenação

Adicionar múltiplos elementos:

• Usando extend() para listas.
• Usando o operador + para concatenar listas ou strings.

Conversão entre Tipos de Sequência

• list(sequence): Converte para lista.
• tuple(sequence): Converte para tupla.
• str(sequence): Converte para string (geralmente não o uso desejado para listas/tuplas, use join).
• Nota: Para converter listas/tuplas para string de forma controlada, use ''.join(list_or_tuple). Para converter string para lista, use list(string) ou string.split().

Funções Embutidas para Sequências

• len(sequence): Retorna o número de itens.
• max(sequence): Retorna o maior item.
• min(sequence): Retorna o menor item.
• sorted(sequence): Retorna uma *nova* lista ordenada a partir dos itens da sequência.
• reversed(sequence): Retorna um iterador reverso. Use list(reversed(sequence)) para obter uma lista invertida.
• sort() e reverse() são métodos de list que modificam a lista original in-place, diferentemente de sorted() e reversed() que operam sobre sequências em geral e retornam novos objetos.

Conjuntos (set)

Conjuntos são coleções mutáveis e não ordenadas de itens únicos. São eficientes para operações matemáticas de conjuntos (união, interseção, etc.) e para remover duplicatas.

Elementos Únicos: Conjuntos automaticamente descartam duplicatas. Se você tentar adicionar um elemento já existente, o conjunto permanecerá inalterado.

Elementos Imutáveis: Os itens dentro de um conjunto devem ser de tipos imutáveis (números, strings, tuplas).

Eficiência: Graças ao uso de tabelas hash, a verificação de pertencimento (in) e a adição/remoção de elementos são muito rápidas, independentemente do tamanho do conjunto.

Existem também os frozenset, que são imutáveis.

Criação de Conjuntos

# Usando chaves literais (não funciona para conjuntos vazios)
my_set = {'apple', 'banana', 'cherry'}

# Usando a função set()
empty_set = set() # Cria um conjunto vazio
set_from_list = set([1, 2, 2, 3, 4]) # Cria um conjunto {1, 2, 3, 4}
   

Operações de Conjunto

Os operadores | (união), & (interseção), - (diferença) e ^ (diferença simétrica) são comumente usados.

• União (| ou union()): Elementos de ambos os conjuntos. {'a', 'b'} | {'b', 'c'} resulta em {'a', 'b', 'c'}.
• Interseção (& ou intersection()): Elementos comuns a ambos os conjuntos. {'a', 'b'} & {'b', 'c'} resulta em {'b'}.
• Diferença (- ou difference()): Elementos no primeiro conjunto, mas não no segundo. {'a', 'b'} - {'b', 'c'} resulta em {'a'}.
• Diferença Simétrica (^ ou symmetric_difference()): Elementos que estão em um dos conjuntos, mas não em ambos. {'a', 'b'} ^ {'b', 'c'} resulta em {'a', 'c'}.

Exemplo: Comparando Dados com Conjuntos

data1 = [{'name': 'Alice', 'score': 75}, {'name': 'Bob', 'score': 98}, {'name': 'Charlie', 'score': 89}]
data2 = [{'name': 'Charlie', 'score': 89}, {'name': 'David', 'score': 98}, {'name': 'Alice', 'score': 75}]

# Para usar conjuntos, os itens precisam ser imutáveis. Convertemos os dicionários em tuplas de seus valores.
set1 = set(tuple(item.values()) for item in data1)
set2 = set(tuple(item.values()) for item in data2)

print("Itens em data1 mas não em data2:", set1 - set2)
# Saída: Itens em data1 mas não em data2: set() (Neste caso, todos os itens de data1 estão em data2)

print("Itens em data2 mas não em data1:", set2 - set1)
# Saída: Itens em data2 mas não em data1: {('David', 98)}
   

Métodos de Conjunto

Método	Descrição	Exemplo
add()	Adiciona um único elemento.	s = {1}; s.add(2) resulta em {1, 2}.
update()	Adiciona múltiplos elementos de um iterável.	s = {1, 2}; s.update([2, 3, 4]) resulta em {1, 2, 3, 4}.
remove()	Remove um elemento. Lança KeyError se o elemento não existir.	s = {1, 2}; s.remove(1) resulta em {2}.
discard()	Remove um elemento. Não faz nada se o elemento não existir.	s = {1, 2}; s.discard(3) resulta em {1, 2}.
pop()	Remove e retorna um elemento arbitrário do conjunto. Lança KeyError se o conjunto estiver vazio.	s = {1, 2, 3}; element = s.pop() remove e retorna um dos elementos (ex: 1), s se torna {2, 3}.
clear()	Remove todos os elementos do conjunto.	s = {1, 2}; s.clear() resulta em set().
copy()	Retorna uma cópia rasa do conjunto.	s = {1, 2}; s_copy = s.copy().
difference()	Retorna um novo conjunto com elementos na diferença. (Equivalente a -).	s = {1, 2}; s1 = {2, 3}; print(s.difference(s1)) retorna {1}.
issubset()	Verifica se todos os elementos estão em outro conjunto.	s = {1, 2}; s1 = {1, 2, 3}; print(s.issubset(s1)) retorna True.
issuperset()	Verifica se o conjunto contém todos os elementos de outro conjunto.	s = {1, 2, 3}; s1 = {1, 2}; print(s.issuperset(s1)) retorna True.
isdisjoint()	Verifica se dois conjuntos não têm elementos em comum.	s = {1, 2}; s1 = {3, 4}; print(s.isdisjoint(s1)) retorna True.

Exemplo 1: Remover Duplicatas de Lista

duplicates = [1, 2, 3, 1, 4, 3, 2, 5]
# Converte para set para remover duplicatas, depois de volta para list
unique_items = list(set(duplicates))
print(unique_items) # Saída pode variar na ordem, ex: [1, 2, 3, 4, 5]
   

Atenção: Cnoverter para set perde a ordem original dos elementos.

Exemplo 2: Eficiência de Conjuntos vs Listas

Para buscar um item em uma coleção muito grande (milhões de elementos), um set é significativamente mais rápido que uma list. A busca em set tem complexidade O(1) (tempo constante), enquanto em list é O(n) (tempo linear), pois pode precisar percorrer toda a lista.

Dicionários (dict)

Dicionários armazenam dados em pares chave-valor. As chaves devem ser únicas e imutáveis (tipos "hashable"). Dicionários são mutáveis e, a partir do Python 3.7, mantêm a ordem de inserção.

Operações com Dicionários

• Atribuição: my_dict = {"name": "Alice", "age": 30}
• Acesso:
  • value = my_dict["name"] (lança KeyError se a chave não existir).
  • value = my_dict.get("name") (retorna None ou um valor padrão se a chave não existir).
• Adição/Modificação: my_dict["city"] = "New York" ou my_dict["age"] = 31.
• Remoção:
  • my_dict.pop("city"): Remove a chave e retorna seu valor.
  • del my_dict["age"]: Remove o par chave-valor.
  • my_dict.clear(): Remove todos os itens.
• Busca/Iteração:
  • Iterar sobre chaves: for key in my_dict: ... ou for key in my_dict.keys(): ...
  • Iterar sobre valores: for value in my_dict.values(): ...
  • Iterar sobre pares chave-valor: for key, value in my_dict.items(): ...

Métodos Comuns de Dicionário

Método	Descrição	Exemplo
get(key, default=None)	Retorna o valor da chave, ou default se a chave não existir.	d = {'a': 1}; print(d.get('b', 0)) retorna 0.
setdefault(key, default)	Retorna o valor da chave. Se a chave não existir, insere a chave com o valor default e retorna default.	d = {'a': 1}; d.setdefault('b', 2); print(d) resulta em {'a': 1, 'b': 2}.
keys()	Retorna uma view dos nomes das chaves.	d = {'a': 1, 'b': 2}; print(d.keys()) retorna dict_keys(['a', 'b']).
values()	Retorna uma view dos valores.	d = {'a': 1, 'b': 2}; print(d.values()) retorna dict_values([1, 2]).
items()	Retorna uma view dos pares (chave, valor).	d = {'a': 1, 'b': 2}; print(d.items()) retorna dict_items([('a', 1), ('b', 2)]).
copy()	Retorna uma cópia rasa do dicionário.	d = {'a': 1}; d2 = d.copy().
update(...)	Atualiza o dicionário com pares chave-valor de outro dicionário ou iterável.	d = {'a': 1, 'b': 2}; d.update({'b': 3, 'c': 4}) resulta em {'a': 1, 'b': 3, 'c': 4}.
pop(key)	Remove e retorna o valor associado à chave. Lança KeyError se a chave não existir.	d = {'a': 1, 'b': 2}; val = d.pop('b'); print(d) resulta em {'a': 1} e val é 2.
popitem()	Remove e retorna o último par (chave, valor) inserido (em Python 3.7+). Em versões anteriores, removia um par arbitrário.	d = {'a': 1, 'b': 2}; item = d.popitem(); print(d) resulta em {'a': 1} e item é ('b', 2).

Métodos de Criação de Dicionário

• dict(key1=value1, key2=value2, ...): Cria um dicionário. Ex: d = dict(a=1, b=2) é equivalente a d = {'a': 1, 'b': 2}.
• dict.fromkeys(iterable, value=None): Cria um dicionário com chaves do iterable e um valor padrão. Ex: d = dict.fromkeys(['a', 'b', 'c'], 0) resulta em {'a': 0, 'b': 0, 'c': 0}.

Exemplo: Atualizar Parâmetros de API

api_config = {
   "url": "/api/user/login",
   "data": {"username": "john_doe", "password": "secure_password"}
}

# Atualizar o nome de usuário
api_config["data"]["username"] = "jane_doe"
# Ou usando update:
# api_config["data"].update({"username": "jane_doe"})

print(api_config["data"]["username"]) # Saída: jane_doe
   

Hash e Elementos "Hashable"

1. Hashing: É um processo que mapeia um dado para um valor de tamanho fixo (hash). Em Python, objetos "hashable" têm um valor de hash que não muda durante seu tempo de vida e podem ser comparados com outros objetos. Dicionários e conjuntos usam hashing para acesso rápido.
2. Elementos Hashable: Para garantir que o valor de hash seja consistente, os elementos devem ser imutáveis. Tipos como números (int, float), strings e tuplas (contendo apenas elementos hashable) são hashable. Listas e dicionários não são hashable porque são mutáveis.

Resumo das Características dos Tipos Fundamentais

• Tipos Imutáveis: Numéricos (int, float, bool, complex), Strings (str), Tuplas (tuple), Frozensets.
• Tipos Mutáveis: Listas (list), Conjuntos (set), Dicionários (dict).
• Tipos Ordenados: Sequências (str, list, tuple). Dicionários são ordenados por inserção a partir do Python 3.7.
• Tipos Não Ordenados: Conjuntos (set).