Introdução Geral

Este material consolida o conteúdo da aula de Linguagens de Programação II, ministrada pelo professor Cleiton Borges. O foco principal aborda os fundamentos teóricos e práticos das estruturas de dados na linguagem Python — como Listas, Tuplas, Dicionários, Conjuntos (Sets) e Árvores —, demonstrando suas sintaxes, características de mutabilidade, métodos de manipulação e aplicações reais no desenvolvimento de software, jogos e consultas a bancos de dados.

Nesta aula de Python, o professor Cleiton Borges explicam as principais estruturas de dados e suas aplicações práticas. São abordadas as diferenças entre estruturas mutáveis (listas) e imutáveis (tuplas), a organização em pares chave-valor nos dicionários e a eliminação de duplicatas com sets. O conteúdo também apresenta o conceito de árvores hierárquicas e fatiamento de dados. Por fim, o uso de métodos como sort, reverse, pop e len é demonstrado diretamente no código de um jogo, em consultas de banco de dados SQL e em uma série de exercícios práticos direcionados aos estudantes.

Aula 2 – Cursos de Programação II

1. Abertura e Objetivos da Aula

• Apresentação: Boas-vindas aos estudantes para a segunda aula da disciplina.
• Tópicos Abordados:
  • Tipos primitivos de dados em Python (built-in).
  • Diferença entre tipo e valor.
  • Conversão de dados / coerção de tipos (type casting).
  • Conceito, características e manipulação prática de listas.
• Objetivos: Identificar a estrutura de tipos primitivos, compreender a dinâmica de coerção e aplicar a manipulação de elementos em listas utilizando código Python prático.

2. Tipos Primitivos (Built-in) em Python

Os tipos primitivos representam as estruturas de dados mais simples e fundamentais de uma linguagem. Em Python, são conhecidos como tipos built-in (embutidos/nativos da linguagem).

• Consulta e Documentação: A documentação oficial do Python é a fonte primária recomendada para consulta de métodos e funções.

Principais Tipos Built-in:

• Inteiro (int): Representa números inteiros (positivos ou negativos).
• Ponto Flutuante (float): Representa números com casas decimais.
• Booleano (bool): Valores lógicos (True ou False).
• Texto (str / String): Sequência ordenada de caracteres.
• Lista (list): Coleção mutável e ordenada de elementos.
• Tupla (tuple): Coleção ordenada e imutável (não permite alterações após a criação).
• Dicionário (dict): Estrutura de dados organizada no formato chave-valor.
• Conjunto (set): Coleção não ordenada de elementos únicos.

3. Tipagem Dinâmica e Coerção de Tipos

Diferença entre Tipo e Valor

• Valor: Qualquer dado ou informação contida (ex.: número 10, texto "Cleiton", um vídeo, uma música).
• Tipo: A estrutura/classificação dada a esse dado pela linguagem (ex.: int, str, tuple).

Tipagem Dinâmica

• Em Python, tudo é um objeto.
• A linguagem é dinamicamente e fortemente tipada: não é necessário declarar o tipo de uma variável antes de atribuir-lhe um valor. O próprio interpretador identifica e infere o tipo automaticamente durante a execução.
• Comparação: Em linguagens estaticamente tipadas (como C ou Java), é obrigatório declarar o tipo explicitamente (ex.: int a = 10;).

Coerção de Tipos (Casting)

• É a ação de converter um dado de um tipo para outro.
• Exemplo em Python:
  • Transformar texto em inteiro: num = int("10")
  • Transformar número em texto: texto = str(10)
• Concatenação vs. Soma: Somar texto com número causa erro de tipagem. Para unir textos com números, deve-se converter o número para str (concatenação) ou manter ambos como int/float para realizar operação matemática.

4. Estrutura de Dados: Listas (list)

Conceito e Indexação

• Definição: A lista é uma sequência de elementos delimitada por colchetes [...].
• Índices:
  • Indexação Direta (Positiva): Começa no índice 0. A primeira posição de uma lista em Python é sempre o índice 0 (ex.: lista[0]).
  • Indexação Negativa: Acessa elementos a partir do final da lista (ex.: -1 acessa o último elemento, -2 o penúltimo).

Operações e Manipulação Prática

• Acesso por Índice: lista[índice] retorna o elemento daquela posição. Acessar um índice inexistente gera erro (IndexError).
• Tipos Múltiplos: Uma mesma lista pode armazenar elementos de diferentes tipos (ex.: [10, "Cleiton", 3.14, True]).
• Operações Aritméticas com Elementos: É possível realizar operações de soma (+), subtração (-), multiplicação (*), divisão (/) e divisão inteira (//) utilizando os valores armazenados nas posições da lista.

Resumo da Aula

1. Tipos Primitivos (Built-in): Python possui tipos nativos essenciais (int, float, bool, str, list, tuple, dict, set). As tuplas destacam-se por serem imutáveis, enquanto as listas são mutáveis e flexíveis.
2. Tipagem Dinâmica e Coerção: Não é preciso declarar tipos de variáveis em Python; o interpretador infere o tipo automaticamente com base no valor atribuído. A conversão entre tipos (como str para int) é chamada de coerção de tipos ou casting.
3. Indexação e Listas: As listas utilizam sintaxe com colchetes [...]. A contagem de posições (índices) inicia obrigatoriamente no índice 0. Índices negativos (-1, -2) permitem percorrer a lista de trás para a frente.

Aula 3 – Cursos de Programação II

1. Transcrição Reorganizada por Tópicos

Apresentação e Objetivos da Aula

• Tema: Línguas de Programação II / Estruturas de Dados em Python.
• Objetivo: Compreender e manipular Listas, Arrays, Tuplas, Dicionários, Conjuntos (Sets) e Árvores em Python, identificando a utilização prática dessas estruturas em sistemas reais.

Aplicação Prática: Análise do Código de um Jogo

Para demonstrar onde as estruturas de dados são utilizadas por programadores, foi apresentado o código-fonte de um jogo disponibilizado no ambiente virtual de aprendizagem:

• Tuplas: Usadas para armazenar sequências fixas de elementos (ex.: coordenadas, parâmetros de botões).
• Dicionários e Listas: Utilizados para armazenar estados e elementos dinâmicos do jogo.
• Banco de Dados (SQLite): Exemplo de busca (SELECT) em que os resultados retornados do banco são acessados via índices/posições de estruturas de dados (posição 0, posição 1).

Estruturas de Dados em Python

1. Arrays / Vetores

• Sequência finita e ordenada de elementos.
• O primeiro elemento sempre ocupa o índice 0.
• Em Python, apesar da alocação dinâmica de memória, o tamanho inicial ou a estrutura delimitadora é finita.

2. Listas (list)

• Característica: São mutáveis (podem ter seus valores alterados após a criação).
• Indexação Negativa:
  • O índice -1 acessa o último elemento.
  • Os índices negativos progridem decrescendo (-1, -2, -3...).
• Fatiamento (Slicing): [início:fim:passo]
  • X (start): Índice de início (padrão é 0).
  • Y (stop): Índice de parada (padrão é o tamanho total da lista / len).
  • Z (step): Intervalo/passos do fatiamento (padrão é 1).
• Métodos Principais de Listas:
  • reverse() / [::-1]: Inverte a ordem da lista.
  • sort(): Ordena em ordem crescente/alfabética.
  • sort(reverse=True): Ordena em ordem decrescente.
  • len(): Retorna a quantidade total de elementos.
  • count(x): Conta quantas vezes o elemento x se repete.
  • index(x): Retorna a posição do elemento x.

3. Tuplas (tuple)

• Característica: São imutáveis (somente leitura; não é possível alterar ou adicionar elementos diretamente após a criação).
• Sintaxe: Delimitadas por parênteses (a, b, c). Podem armazenar múltiplos tipos de dados (strings, inteiros, booleanos).
• Técnica de Swap (Troca de Valores): Permite trocar os valores entre variáveis reatribuindo as posições na memória, contornando a limitação de imutabilidade direta do objeto.

4. Dicionários (dict)

• Característica: Estrutura baseada em pares chave: valor ({chave: valor}). As chaves devem ser únicas.
• Métodos Principais:
  • keys(): Retorna apenas as chaves.
  • values(): Retorna apenas os valores.
  • get(chave): Retorna o valor associado à chave.
  • pop(chave): Retorna e remove o par associado à chave.
  • update(): Atualiza um dicionário mesclando elementos de outro.
  • del: Exclui um elemento do dicionário.

5. Conjuntos (set)

• Característica: Coleção não ordenada e que não permite elementos duplicados (remove duplicatas automaticamente).
• Métodos Principais:
  • add(): Adiciona um elemento.
  • remove(): Remove um elemento específico.
  • clear(): Limpa todos os elementos do conjunto.

6. Árvores (Trees)

• Característica: Estrutura de dados hierárquica composta por nódulos (vértices) e arestas.
• Nomenclatura:
  • Raiz (Root): O nó principal/topo (nível 0). Toda árvore possui apenas uma raiz.
  • Pai / Filho: Relação de hierarquia (ex.: o diretório principal do sistema operacional C:\ é a raiz; pastas internas são filhas).
  • Nível: Indica a distância/quantidade de nós acima até chegar à raiz.

Exercícios Propostos na Aula

1. Script de Lista Básico: Criar lista com [10, 20, 30, 40] e exibir todas as posições/índices.
2. Operadores em Lista: Aplicar operações aritméticas (+, -, *, /, %) aos elementos da lista.
3. Listas Aninhadas / Matrizes: Criar uma lista contendo dois sub-arrays e imprimir a posição especificada.
4. Verificação de Tipo: Armazenar múltiplos valores em uma variável e exibir seu tipo (type()).
5. Dicionário e Métodos: Criar um dicionário e demonstrar o uso de len(), del, keys(), values() e add/update.

2. Resumo da Aula

Nesta aula prática de Python, os professores Cleiton e Ricardo abordaram o funcionamento e a aplicação das principais estruturas de dados:

1. Listas vs. Tuplas: As listas são mutáveis (permitem alteração via métodos como sort(), reverse(), index()), enquanto as tuplas são imutáveis (somente leitura), sendo utilizadas para conjuntos de dados fixos.
2. Dicionários: Armazenam dados no formato chave-valor, permitindo busca eficiente e manipulação através de métodos como keys(), values(), get() e pop().
3. Sets (Conjuntos): Coleções não ordenadas que eliminam elementos duplicados automaticamente.
4. Árvores: Estruturas hierárquicas baseadas em nós (raiz, pais e filhos) e arestas, comparadas à organização de pastas em um sistema operacional.
5. Demonstração Prática: O conteúdo teórico foi contextualizado na leitura do código-fonte de um jogo e em rotinas de consulta ao banco de dados SQL, finalizando com a resolução de exercícios práticos no interpretador Python.

Resumo Geral Consolidado

A aula ministrada pelo professor Cleiton aborda a fundamentação e a aplicação prática das Estruturas de Dados na linguagem Python, utilizando exemplos em código de jogos, rotinas de banco de dados SQL e exercícios de fixação.

1. Estruturas Colecionáveis Nativas

• Arrays / Vetores: Sequências finitas de elementos ordenados com índice inicial zero (0).
• Listas (list): Estruturas mutáveis que permitem adição, remoção e ordenação de dados. Suportam indexação negativa (sendo -1 o último item) e fatiamento pelo esquema [início:fim:passo]. Principais métodos: sort(), reverse(), len(), count() e index().
• Tuplas (tuple): Estruturas imutáveis (somente leitura) delimitadas por parênteses (). Utilizadas para proteger a integridade de dados fixos. A alteração de valores só ocorre indiretamente via técnica de swap (troca de referências em memória).
• Dicionários (dict): Coleções mapeadas pelo par chave: valor ({chave: valor}), onde cada chave deve ser única. Manipulados através dos métodos keys(), values(), get(), pop() e update().
• Conjuntos (set): Coleções não ordenadas que eliminam automaticamente qualquer elemento duplicado. Utilizam métodos como add(), remove() e clear().

2. Estrutura Hierárquica

• Árvores (Trees): Modelo de dados não linear organizado em níveis hierárquicos através de nós e arestas. Possui uma Raiz (topo/nível 0) e relações de Pai/Filho, funcionando de forma análoga à árvore de diretórios e pastas de um sistema operacional.

3. Prática e Contextualização

• Aplicações: Demonstração de estruturas em scripts de jogos virtuais (parâmetros e estados) e no consumo de tuplas/listas retornadas por consultas SQL (SELECT).
• Fixação: Proposição de 5 exercícios práticos envolvendo fatiamento de listas, operadores aritméticos, matrizes aninhadas, verificação de tipos (type()) e métodos de dicionário.

Autor: Professor Cleiton da Silva Borges. Publicado: Quinta-feira, 17 de Setembro de 2026, 17h24