Operações básicas em fila:

1. ENQUEUE (Inserir ou Adicionar):

- A operação “enqueue” envolve a adição de um novo elemento ao final (ou “tail”) da fila.
- É como colocar um item no final de uma fila em uma ordem sequencial.
- Geralmente, é usado para adicionar um novo elemento à fila antes de qualquer outro
elemento já existente.
- Portanto “enqueue” insere um elemento no final da fila.

2. DEQUEUE (Remover ou Retirar):

- Operação “dequeue” envolve a remoção do elemento do início (ou “head”) da fila.
- É como retirar o primeiro item da fila em uma ordem sequencial.
- A remoção é feita de acordo com a ordem em que os elementos foram adicionados (FIFO-
First-In-First-Out).
- Portanto “dequeue” remove e retorna o elemento mais antigo da fila.

class Fila:

def_init_(self):

self.items = []

def enqueue(self, item):

“””Adiciona um elemento ao final da fila.”””

self.items.append(item)

def is_empty(self):

“””Verifica se a fila está vazia.”””

return len(self.items) == 0

def is size(self):

“””Retorna o tamanho da fila.”””

return len(self.items)

def_str_(self):

“””Retorna uma representação em string da fila.”””

return str(self.items) #Retorna a representação da fila

 Introdução à Depuração e Resolução de Problemas
A depuração é um processo essencial no desenvolvimento de software, que consiste em
identificar e corrigir erros (bugs) no código. Estes erros podem variar desde erros de
sintaxe até problemas lógicos complexos que afetam o funcionamento adequado do
programa.

Importância da Depuração:
A depuração desempenha um papel crítico no processo de programação por diversas
razões:

- Garante a Funcionalidade Adequada: A depuração assegura que o programa

funcione conforme o planejado, executando tarefas de maneira precisa e sem falhas.
- Economiza Tempo e Recursos: Identificar e corrigir erros de forma eficaz economiza
tempo, recursos e esforços durante o ciclo de desenvolvimento.
- Melhora a Qualidade do Software: Através da correção de erros, é possível melhorar
a qualidade do código.

Importância da Depuração:
- Uma das estratégias mais fundamentais para identificar erros é revisar
minuciosamente o código fonte. Isso envolve

- No código fornecido, a função calcular_media foi corretamente definida para

calcular a média dos elementos em uma lista. No entanto, quando a função é
chamada com uma lista vazia (valores=[]), ocorre uma exceção de divisão por zero.
- O erro ocorre porque, ao calcular a média (media=total/len(lista)), a lista está vazia,
e a divisão por zero não é permitida em Python.
- Para lidar com esse cenário, podemos adicionar uma verificação

Uso de Impressões (Prints)

- Inserir
 Técnica de Dividir e Conquistar:
- Esta técnica envolve dividir o problema em partes menores e abordar cada parte
separadamente. Isolar subseções do código para identificar a fonte do erro pode ser

def calcular_raiz_quadrada(numero):

if numero <0:

raise ValueError("Não é possível calcular raiz quadrada de números negativos.")

else:

return numero **0.5

#Chama a função

try:

resultado=calcular_raiz_quadrada(-9)

print("A raiz quadrada é:",resultado)

except ValueError as e:

print("Erro:",str(e))

USO DAS MENSAGENS DE ERRO

Importância das mensagens de erro:

 - Mensagens de erro bem elaboradas são fundamentais para facilitar a identificação e
resolução de problemas em um programa. Elas fornecem informações cruciais sobre
o erro ocorrido…
-

Criação de Mensagens de Erro Significativas:

- Seja Descritivo: A mensagem de erro deve descrever claramente
- Forneça Contexto: Inclua informações relevantes, como a localização do erro e os
valores envolvidos.
- Sugira Soluções: Sugira possíveis ações corretivas para o erro.

Funcionalidades de um debugger
- Definir Pontos de Interrupção (Breakpoints):
- Passo a passo (Step-By-Step): Permite a execução passo a passo
- Exibição de Variáveis: Exibe os valores atuais das variáveis durante a execução.
- Avaliação de Expressões: Permite a avaliação de expressões enquanto o programa
está pausado.

import PDB: É uma biblioteca de Debugger da Python.

- Ao executar esse código, o programa será

18/10/2023
LGPD
1ª LEI: Lei número 9.279/96. foi criada em 14 de maio de 1996
Ela é bem específica.

1. Propriedade intelectual: protege os direitos autorais de quem o produziu.

Bens intelectuais nós temos:

a. Bens imateriais;
b. Bens incorpóreos;
c. Bens autorais;

3% - não é considerado plágio;

de 4% para cima - já é considerado plágio!

SITE: AUTOPSY - Destrincha todo o site, trabalho, etc.

na web assinatura é considerado como “rash”!

POO
Programação Orientada a Objeto.

1. Organização
2. trabalha com herança (reaproveitamento do código)

Dentro disso, nós temos: Classes, objetos, atributos e métodos.

ISSO LITERALMENTE É OBRIGATÓRIO EM QUALQUER CURSO DE

LÓGICA E PROGRAMAÇÃO!!

Classe: é uma coisa só. Sem dar muitos detalhes sobre.

Exemplo: Carro.
Objeto: é o que define a classe

Exemplo: Cor, tipo de motor, modelo, placa e marca. São tudo aquilo que vai definir
a classe (no exemplo, carro).
 19/10/2023

Atributos e Métodos
São os principais componentes de uma classe em programação orientada a
objeto.

Atributos: São as características ou propriedades dos objetos. Eles representam dados que um objeto
pode ter.

Esses dados podem ser variáveis que mantém informações sobre o objeto.

Exemplo 01 : Sangue (Classe), O (objeto), +/- (atributos);

Exemplo 02 : carro (classe), pneu (objeto), aro / calibragem (atributos);

cada cor é um atributo diferente!!!

Exemplo 03 : carro (classe), combustível (objeto), álcool, gasolina ou flex (atributos);

Métodos: São ações ou operações que os objetos podem realizar. Eles representam o comportamento
do objeto e podem ser usados para manipular os atributos do objeto. Ou seja, os métodos definem o
que o objeto pode fazer e como ele responde a certa ação.

Exemplo 01 : CARRO: Ligar, Desligar

Exemplo 02: SERVER (classe) - COMPUTADOR (objeto) - IP (atributos) - DHCP (métodos)

REDE

192.168.0. 1

HOST
A programação orientada a objeto é baseada na ideia de modelar entidades do mundo real em
forma de classes, onde as classes definem os atributos que caracterizam essas entidades e os
métodos que descrevem suas ações. Essa abstração facilita a organização, manutenção e
reutilização de códigos em sistemas de softwares.

Encapsulamento: é um conceito que se refere à restrição de acessos aos atributos de uma classe. Ela
ajuda a controlar a visibilidade e proteger os dados de uma classe. O encapsulamento é implementado
por meio de modificadores de acesso que geralmente são:

1. Public (público): Atributos e métodos públicos que podem ser acessados a partir de
qualquer lugar, tanto dentro da classe quanto de fora da classe.
2. Private (privado): Atributos e métodos privados que só podem ser acessados de dentro da
classe. Na Python, para tornar um atributo ou método private, você pode adicionar um
sublinhado duplo (Ex: __atributo_privado) antes do nome da classe.
3. Protected (protegido): Atributos e métodos protegidos podem ser acessados apenas a
partir de dentro da classe e de sua subclasse (herança). Na Python, para tornar um atributo
ou método protected, você pode adicionar um sublinhado duplo (Ex:
__atributo_protegido).

class MinhaClasse:

def __init_(self):

self.__atributo_protegido = 10

self.__atributo_privado = 20

def __atributo_protegido(self):

print("Esse é um método protegido.")

def __atributo_privado(self):

print("Esse é um método privado.")

objeto = MinhaClasse()

print(objeto.__atributo_protegido)
objeto = MinhaClasse()

print(objeto.__atributo_privado)

class MinhaClasse:

def __init_(self):

self.__atributo_protegido = 10

self.__atributo_privado = 20

def __metodo_protegido(self):

print("Esse é um método protegido.")

def __metodo_privado(self):

print("Esse é um método privado.")

objeto = MinhaClasse()

print(objeto.__atributo_protegido)

objeto = MinhaClasse()

print(objeto.__atributo_privado)
 20/10/2023

Heranças e Polifórmios
HERANÇA (subclasses ou classes derivadas)
Herança é um conceito chave na programação orientada a objeto que permite que uma classe
(subclasse ou classes derivadas) herdam propriedades de outra classe (superclasse ou classe
base);

POLIFORMISMO
É a capacidade de um objeto se comportar de maneira diferente com base no contexto em que
é usado. Isso é alcançado por meio de herança e sobrescrita de método.

Polimorfismo de sobreposição: Ocorre quando uma subclasse subscreve um método da

superclasse, permitindo que o mesmo método seja chamado em instância de diferentes
subclasses, mas com comportamentos específicos.

Polimorfismo de sobrecarga: Ocorre quando várias classes têm métodos com o mesmo
nome, mas assinaturas diferentes. O método chamado dependerá dos argumentos passados.

Obs: As aplicações do poliformismo incluem:

1. A capacidade de criar interfaces genéricas, permitindo que diferentes objetos se

comportem de maneira uniforme em diferentes situações, facilitando a manutenção
e extensão do código.
https://docs.google.com/forms/d/e/
1FAIpQLSe7TG3GQIvGJukEimYL2S1sw5GptjwQbxbzByEwsjiXE9UyaQ/viewform
TSUKI

https://docs.google.com/forms/d/e/
1FAIpQLSel7ZpomNRUT02XqnniBBgKCarNmrAgWdajmT4dspYGF8iRAQ/
viewform ESFERIC

https://docs.google.com/forms/d/e/1FAIpQLSd9GB3y3nIrcIRo5ai0BUavXD--
A1TSrkGD0oSwkrTu-qImvQ/viewform PETECO

https://docs.google.com/forms/d/e/1FAIpQLScjKTqfH6inwKh2zpfhRAyPHTM-
mHaUi1CkpYX-uuapjM-Fgg/viewform CUT’Z

https://docs.google.com/forms/d/e/
1FAIpQLSduzcO2NvAhEaRkGDEATjvg7vzEQZPPQBkg3K0p-8ShRPquaA/viewform
TALENTTA
tá arisca hoje né?
FALO MAIS NADA!