Python

Variáveis: x = 5, nome = "João"...........................................................................................................................

Comentários: # Este é um comentário...............................................................................................................

Tipos de Dados: int, float, str, list, tuple, dict, set, bool…………………………………………………………………………………

Operadores Aritméticos: +, -, *, /, %, ** (exponenciação), // (divisão inteira)..................................................

Operadores de Comparação: ==, !=, >, <, >=, <=................................................................................................

Operadores Lógicos: and, or, not.......................................................................................................................

Estruturas Condicionais: if, elif, else..................................................................................................................

Estruturas de Repetição: for, while....................................................................................................................

Funções: def minha_funcao(parametro):, return...............................................................................................

Argumentos de Função: padrão, nomeados, *args,

**kwargs............................................................................

Escopo de Variáveis: global, local, nonlocal........................................................................................................

Módulos: import, from ... import………………………………………………………………………………………………………………….

Tratamento de Exceções: try, except, finally, raise…………………………………………………………………………………………

Context Managers: with………………………………………………………………………………………………………………………………

Iteradores e Geradores: iter, next, yield............................................................................................................

Expressões Lambda: lambda x: x + 1................................................................................................................

Compreensão de Listas, Sets e Dicionários: [expressão for item in lista], {expressão for item in conjunto},
{chave: valor for chave, valor in dicionario.items()}........................................................................................

Strings: métodos como .format(), .split(), .join(), .strip(), .find(), .replace(), .startswith(), .endswith()………..

Listas: métodos como .append(), .extend(), .insert(), .remove(), .pop(), .index(), .count(), .sort(), .reverse()
……………………………………………………………………………………………………………………………………………………

Tuplas: imutáveis, métodos de acesso como indexação e fatiamento............................................................

Dicionários: métodos como .keys(), .values(), .items(), .get(), .pop(), .update().............................................

Conjuntos: métodos
como .add(), .remove(), .discard(), .pop(), .clear(), .union(), .intersection(), .difference().................................
....................................................................................................................

Expressões Regulares: módulo re para manipulação de expressões regulares...............................................

Decoradores: @decorador...............................................................................................................................

Asserções: assert..............................................................................................................................................

Assincronia: async, await, asyncio....................................................................................................................

Manipulação de Arquivos: open(), read(), write(), close()................................................................................

Classes e Objetos: class MinhaClasse:, métodos especiais como init, str, repr.................................................

Herança e Polimorfismo: class MinhaClasse(Pai):, sobreposição de métodos..................................................

Encapsulamento: _atributo (convenção de privacidade)...................................................................................

Destrutores de Objetos: del................................................................................................................................

Propriedades e Métodos de Classe: @classmethod, @staticmethod................................................................

Módulos Especiais: os, sys, math, random, datetime, json, csv, requests..........................................................

Gerenciamento de Memória: Garbage Collection..............................................................................................

Manipulação de Tempo e Data: datetime, timedelta.........................................................................................

Manipulação de Arquivos e Diretórios: os, shutil..............................................................................................

Framework web Django.....................................................................................................................................

Bibliotecas e frameworks para se usar em diferentes ocasiões/necessidades..................................................

 Como usar variáveis no python

para criar variaveis no python é muito simples, não é igual o Javascript que precisa de var, let e const, simplesmente
fazemos assim:

Como vimos, no python não possue constantes, normalmente para indicar que uma variável não pode ter seu valor
modificado, o nome da variável é criado em maiúsculo, assim:

NUMERO_QUEBRADO = 4.5

Como fazer comentários no python

 Tipos de dados no python:

Tipos de dados

Adição
Subtração

Multiplicação

Divisão

Divisão com inteiro

Resto
Exponencial

Operadores aritméticos

Igualdade

Diferença

Maior
Maior ou igual

Menor

Menor ou igual

Operadores lógicos

Operador and
Operador or

Operador not

Estruturas condicionais
If, elif e else

Exemplo:
 Estruturas de Repetição: for, while
Estrutura de repetição for:
A estrutura de repetição for é usada para iterar sobre uma sequência (como uma lista,
tupla, conjunto, dicionário ou string) ou um iterável. Aqui está a sintaxe básica:

No terminal:

Estrutura de repetição while:

A estrutura de repetição while é usada para repetir um bloco de código enquanto uma
condição específica for verdadeira. Aqui está a sintaxe básica:
No terminal:

Ambas as estruturas de repetição são muito úteis, mas a escolha entre for e while depende
da situação. Use for quando você sabe exatamente quantas vezes deseja iterar sobre uma
sequência e while quando você precisa repetir um bloco de código enquanto uma condição
específica for verdadeira, mas não necessariamente sabe quantas iterações serão
necessárias de antemão.
Função
Como usar funções no python:

No terminal:

Argumentos de Função Padrão:

Os argumentos de função padrão têm um valor padrão predefinido que é usado se o argumento não for
especificado ao chamar a função. Eles são especificados na definição da função.
Exemplo:
No terminal:

Argumentos de Função Nomeados:

Os argumentos de função nomeados permitem que você especifique os valores dos argumentos ao chamar
a função, atribuindo explicitamente os valores aos parâmetros da função pelo nome.
Exemplo:

No terminal:

Argumentos Arbitrários (*args):

Os argumentos arbitrários (*args) permitem que uma função aceite um número arbitrário de argumentos
posicionais. Os argumentos são tratados como uma tupla dentro da função.
Exemplo:
No terminal:

Argumentos de Palavra-chave Arbitrária (**kwargs):

Os argumentos de palavra-chave arbitrários (**kwargs) permitem que uma função aceite um número
arbitrário de argumentos de palavra-chave. Os argumentos são tratados como um dicionário dentro da
função.
Exemplo:

No terminal:

Escopo de Variáveis: global, local, nonlocal

Escopo Global:
Variáveis definidas fora de qualquer função têm escopo global. Elas podem ser acessadas de qualquer lugar
no código, incluindo dentro de funções.
Exemplo:

No terminal:

Escopo Local:
Variáveis definidas dentro de uma função têm escopo local. Elas só podem ser acessadas dentro da função
onde foram definidas.
Exemplo:

No terminal:

Escopo Nonlocal:
O escopo nonlocal é usado quando queremos modificar uma variável que está no escopo de uma função
externa, mas não é global. Isso ocorre especialmente quando temos funções aninhadas (uma função
dentro de outra função) e queremos modificar uma variável da função pai.
Exemplo:

No terminal:

Usando os imports
Importando um Módulo com import:
Você pode importar um módulo inteiro usando a palavra-chave import. Isso importa todo o conteúdo do
módulo, e você precisa usar o nome do módulo para acessar suas funções, classes e variáveis.

Importando Partes Específicas de um Módulo com from ... import:

Você também pode importar partes específicas de um módulo usando a sintaxe from ... import. Isso
importa apenas as partes especificadas do módulo, e você pode usar essas partes diretamente sem usar o
nome do módulo.
Você também pode importar múltiplas partes de um módulo separando-as por vírgulas:

Importando um Módulo com um Nome Personalizado:

Você pode importar um módulo com um nome personalizado usando a palavra-chave as. Isso é útil quando
o nome do módulo é muito longo ou pode causar conflito com outros nomes no seu código.

Também é possível usar exports no python da seguinte forma:

Criação do Módulo (crie um arquivo meu_modulo.py):
Use o modulo em outro arquivo:

No terminal:

Tratamento de Exceções: try, except, finally, raise

try-except:
A estrutura try-except é usada para lidar com exceções. O código que pode gerar uma exceção é colocado
no bloco try. Se ocorrer uma exceção dentro do bloco try, o controle é transferido para o bloco except,
onde você pode lidar com a exceção.
Exemplo:

finally:
O bloco finally é usado para definir código que será executado independentemente de ocorrer ou não uma
exceção. Isso é útil para limpar recursos ou executar ações de limpeza que devem ocorrer,
independentemente de qualquer exceção.
Exemplo:

raise:
A palavra-chave raise é usada para levantar (lançar) uma exceção explicitamente. Isso pode ser útil quando
você deseja indicar que ocorreu um erro em uma situação específica dentro do seu código.
Exemplo:
 context Managers: with
Esse método abre um determinado objeto e itera sobre ele (seja esse objeto um arquivo de texto, um
banco de dados e etc), a baixo vamos ver um exemplo usando esse método pra abrir um arquivo de texto,
armazenar o valor desse arquivo em uma variável e imprimindo o valor dessa variável no terminal:

No terminal:

Agora vamos ver como usar esse método para iterar sobre um banco de dados:
No terminal:

Iteradores e Geradores: iter, next, yield

Iteradores:
Um iterador em Python é um objeto que representa uma sequência de elementos. Ele permite que você
itere sobre esses elementos um de cada vez, sem a necessidade de armazenar todos os elementos na
memória ao mesmo tempo.
iter(): A função iter() é usada para criar um iterador a partir de um objeto iterável, como uma lista, tupla,
conjunto ou string.
next(): A função next() é usada para obter o próximo elemento de um iterador. Quando todos os elementos
foram percorridos, ela gera uma exceção StopIteration.
Exemplo:

Geradores:
Um gerador em Python é uma função especial que produz uma série de valores usando a instrução yield.
Ele permite que você itere sobre a série de valores produzidos sem a necessidade de armazenar todos os
valores na memória de uma vez.
yield: A instrução yield é usada em uma função para produzir um valor e "pausar" a execução da função.
Quando a função é chamada novamente, a execução continua a partir do ponto onde foi pausada.
Exemplo:
No terminal:

A duvida que pode ter ficado é só desse range, ele funciona da seguinte forma, você
adiciona um número e ele cria uma lista do 0 até o número que você colocou nele, no nosso
exemplo colocamos o número 5, então o “for” vai criar uma lista do 0 até o 5, e a partir
disso o conseguimos usar o for para iterar sobre essa lista numérica. Sendo assim, quando o
resultado da divisão dos números de 0 até 5 der 0, vai parar no yield e retornar para a
função o valor que ela parou.

Expressões Lambda: lambda x: x + 1

As expressões lambda em Python são funções anônimas de uma única expressão. Elas são úteis quando
você precisa de uma função rápida para uma operação simples e não quer criar uma função formal usando
a declaração def.
Aqui está a sintaxe básica de uma expressão lambda:

lambda argumentos: expressão

 argumentos: Uma lista de argumentos separados por vírgulas (opcional).
 expressao: Uma única expressão que define o retorno da função.
As expressões lambda podem ter qualquer número de argumentos, mas devem ter apenas uma expressão.
Elas são geralmente usadas em conjunto com funções de ordem superior, como map(), filter(), reduce() e
em situações onde funções pequenas e anônimas são necessárias.

Exemplo de uma expressão lambda que adiciona 1 a um número:

funcao = lambda x: x + 1

Exemplo de uso:

resultado = funcao(5)
print(resultado)

No terminal o resultado vai ser: 6

 Compreensão de Listas, Sets e Dicionários

Compreensão de Listas:
A compreensão de lista permite criar uma nova lista a partir de uma expressão, aplicada a cada item em
uma sequência (como uma lista, tupla ou iterável). A sintaxe básica é:

[expressao for item in lista]

Exemplo:

Compreensão de Conjuntos:
A compreensão de conjunto é semelhante à compreensão de lista, mas cria um conjunto (que é uma
coleção sem elementos duplicados) em vez de uma lista. A sintaxe é:
{expressao for item in conjunto}

Exemplo:
Compreensão de Dicionários:
A compreensão de dicionários permite criar um dicionário a partir de uma expressão aplicada a cada par de
chave-valor em um dicionário ou iterável de pares de chave-valor. A sintaxe é:
{chave: valor for chave, valor in dicionário.items()}

Exemplo:

Métodos de strings

.format()
O método .format() é usado para formatar uma string, inserindo valores de variáveis em posições
específicas na string.
Exemplo:

.split()
O método .split() divide uma string em uma lista de substrings com base em um separador especificado.
Exemplo:
.join()
O método .join() concatena os elementos de uma lista em uma única string, utilizando a string que chama o
método como separador entre os elementos.
Exemplo:

.strip()
O método .strip() remove espaços em branco (ou outros caracteres especificados) do início e do final de
uma string.
Exemplo:

.find()
O método .find() retorna a posição da primeira ocorrência de uma substring dentro de uma string. Se a
substring não for encontrada, retorna -1.
Exemplo:
.replace()
O método .replace() substitui todas as ocorrências de uma substring por outra substring em uma string.
Exemplo:

.startswith() e .endswith()
Esses métodos verificam se uma string começa ou termina com uma determinada substring, retornando
True ou False.
Exemplo:

Métodos de listas

.append()
O método .append() é usado para adicionar um elemento ao final de uma lista.
Exemplo:
.extend()
O método .extend() é usado para adicionar todos os elementos de uma lista (ou qualquer iterável) ao final
de outra lista.
Exemplo:

.insert()
O método .insert() é usado para inserir um elemento em uma posição específica em uma lista.
Exemplo:

.remove()
O método .remove() é usado para remover a primeira ocorrência de um elemento específico de uma lista.
Exemplo:
.pop()
O método .pop() é usado para remover e retornar o elemento de uma lista em uma posição específica. Se
nenhum índice for especificado, ele remove e retorna o último elemento da lista.
Exemplo:

.index()
O método .index() é usado para encontrar o índice da primeira ocorrência de um elemento em uma lista.
Exemplo:

.count()
O método .count() é usado para contar o número de ocorrências de um elemento em uma lista.
Exemplo:
.sort()
O método .sort() é usado para ordenar os elementos de uma lista.
Exemplo:

.reverse()
O método .reverse() é usado para inverter a ordem dos elementos em uma lista.
Exemplo:

Tuplas: imutáveis, métodos de acesso como indexação e

fatiamento

As tuplas em Python são sequências ordenadas de elementos, semelhantes às listas, mas com a diferença
fundamental de que elas são imutáveis, ou seja, uma vez criadas, não podem ser alteradas. As tuplas são
representadas por elementos separados por vírgulas e geralmente são delimitadas por parênteses. Aqui
está uma introdução sobre como usar tuplas em Python:

Criando uma Tupla:

tupla = (1, 2, 3, 4, 5)

Acessando Elementos:
Os elementos de uma tupla podem ser acessados utilizando índices, da mesma forma que em listas.

print(tupla[0]) # Saída: 1
print(tupla[2]) # Saída: 3

Fatiamento (Slicing):
Você pode fatiar uma tupla para obter uma parte dela, da mesma forma que em listas.

print(tupla[1:4]) # Saída: (2, 3, 4)

Imutabilidade:
Como mencionado, as tuplas são imutáveis. Isso significa que você não pode adicionar, remover ou
modificar elementos em uma tupla depois que ela é criada. Tentar fazer isso resultará em um erro.

tupla[0] = 10 # Isso resultará em um TypeError

Métodos de Tupla:
As tuplas têm poucos métodos devido à sua imutabilidade. Aqui estão alguns dos métodos mais comuns:
count(): Retorna o número de ocorrências de um determinado valor na tupla.
index(): Retorna o índice da primeira ocorrência de um determinado valor na tupla.
Exemplo:

tupla = (1, 2, 3, 2, 4, 5, 2)
print (tupla.count(2)) # Saída: 3
print (tupla.index(4)) # Saída: 4

Métodos de dicionário
Vamos aprender como usar métodos de dicionário. Vamos usar como exemplo esse dicionário a baixo:

Assim você pega o valor de cada item do dicionário:

Assim você pega o valor de todas as chaves do dicionário:

Assim você pega

apenas o valor
de cada item do
dicionário:

Assim você pega todos os itens, tanto chaves quanto valores dos itens da lista:

Aqui tem outro jeito de pegar determinado valor de um item do dicionário através da chave:
Assim você remove um item da lista:

Assim você atualiza itens da lista, adicionando ou editando

Métodos de conjuntos
Conjuntos em Python são uma estrutura de dados que armazena elementos únicos e não ordenados. Eles
são úteis quando você precisa armazenar um conjunto de itens sem se preocupar com a ordem ou a
duplicação. Aqui estão alguns dos métodos mais comuns para conjuntos em Python:

Para adicionar novos valores ao conjunto fazemos assim:

Para remover valores de um conjunto:

Para remover valores de um conjunto, mas diferente do “remove” a cima, ele não gera um erro caso o item
que você queira remover não exista:

Assim você remove e retorna um elemento aleatório do

conjunto. Se o conjunto estiver vazio, gera um erro.
Assim você remove todos os elementos do conjunto, deixando-o vazio.

Assim você retorna a união de dois conjuntos (todos os elementos que estão em qualquer um dos
conjuntos).

Assim você retorna a interseção de dois

conjuntos (todos os elementos que
estão em ambos os conjuntos).
Assim você retorna a diferença entre dois conjuntos (todos os elementos que estão em conjunto1 mas não
em conjunto2).

Expressões Regulares: módulo re para manipulação de

expressões regulares

Expressões regulares, também conhecidas como regex, são padrões utilizados para encontrar sequências
de caracteres em strings. O módulo re em Python permite trabalhar com expressões regulares de forma
eficiente. Aqui está um guia básico sobre como usar o módulo re:
Para começar, você precisa importar o módulo re, após isso vamos aprender alguns métodos desse
módulo.

re.search(): Procura por um padrão em toda a string e retorna a primeira correspondência encontrada.
Exemplo:
re.match(): Procura por um padrão apenas no início da string e retorna a primeira correspondência
encontrada.
Exemplo:

re.findall(): Encontra todas as ocorrências de um padrão na string e retorna uma lista com todas as
correspondências encontradas.
Exemplo:

re.sub(): Substitui todas as ocorrências de um padrão por outra string especificada.

Exemplo:
re.compile(): Compila um padrão regex em um objeto de expressão regular, que pode ser reutilizado
para pesquisas subsequentes.
Exemplo:

Decoradores: @decorador
Em Python, os decoradores são funções que modificam ou estendem outras funções ou métodos. Eles
permitem adicionar funcionalidades a funções existentes sem alterar seu código. Decoradores são
indicados com o símbolo “@” seguido do nome do decorador, e são colocados acima da definição da
função que será decorada. Aqui está um exemplo básico de como usar decoradores:
Neste exemplo, meu_decorador é um decorador que adiciona uma funcionalidade extra antes e depois da
execução da função decorada. A função minha_funcao é decorada com @meu_decorador, o que significa
que sempre que minha_funcao for chamada, na verdade a função funcao_decorada será chamada, que por
sua vez chama minha_funcao dentro de si mesma, mas adicionando a lógica extra definida pelo decorador.
Decoradores são comumente usados em Python para implementar funcionalidades como log,
autenticação, controle de acesso, e muito mais. Eles são uma maneira poderosa de estender a
funcionalidade de funções e métodos de forma modular e reutilizável.

Asserções: assert
Em Python, a instrução assert é usada para testar se uma condição é verdadeira. Se a condição for
verdadeira, o programa continua sua execução normalmente. No entanto, se a condição for falsa, o
programa lança uma exceção do tipo AssertionError, interrompendo a execução do programa.
A sintaxe básica da instrução assert é:

assert condição, mensagem_de_erro

 condição: Uma expressão que deve ser avaliada como verdadeira ou falsa.
 mensagem_de_erro (opcional): Uma mensagem de erro opcional que será exibida se a condição for
falsa.

Vamos ver um exemplo de como usar a asserções:

Vimos que o “print(“Após a asserção”)” nem apareceu, pois o programa deu erro e encerrou no assert pois
a comparação de 5 ser igual a 10 é falsa.
 Assincronia: async, await, asyncio
Em Python, assincronia refere-se à capacidade de escrever código que pode executar tarefas de forma
concorrente e assíncrona, permitindo que o programa continue executando outras operações enquanto
aguarda a conclusão de uma operação de entrada/saída (I/O) lenta, como solicitações de rede ou
operações de disco. O módulo asyncio fornece suporte nativo para programação assíncrona em Python.
Aqui está um resumo sobre como usar assincronia com async, await e asyncio:

async e await:
async: async é uma palavra-chave que precede a definição de uma função e a marca como uma função
assíncrona. Funções assíncronas podem conter await e podem ser chamadas de forma assíncrona.
await: await é uma palavra-chave usada dentro de funções assíncronas para indicar que uma operação
assíncrona está sendo chamada. await pausa a execução da função até que a operação assíncrona seja
concluída e o resultado esteja disponível.
Exemplo Básico:
Suponha que você tenha uma função que simula uma operação assíncrona de espera por um segundo:

Vamos ver mais propriedade dessa biblioteca asyncio.

Suponha que queremos fazer três solicitações de API assíncronas para diferentes recursos da web e, em
seguida, reunir os resultados. Aqui está como você pode fazer isso com asyncio:
Primeiro precisamos instalar um pacote de gerenciamento http para python, o “aiohttp”, através do
gerenciador de pacotes padrão do python, o “pip”:

pip install aiohttp

Após isso vamos ver como fazer esse projeto:

No terminal:

Neste exemplo:

fetch_data(url): é uma função assíncrona que faz uma solicitação assíncrona à URL
fornecida usando o módulo aiohttp para solicitações assíncronas HTTP.
main(): é a função principal assíncrona que cria tarefas assíncronas para cada URL em uma
lista e, em seguida, aguarda todas as tarefas serem concluídas usando asyncio.gather().

asyncio.create_task(fetch_data(url)): cria uma tarefa assíncrona para cada solicitação de

API.

asyncio.gather(*tasks): espera que todas as tarefas assíncronas fornecidas como

argumentos sejam concluídas e retorna uma lista dos resultados dessas tarefas.

Manipulação de Arquivos: open(), read(), write(), close()

Para abrir um arquivo, você usa a função open() e passa o caminho do arquivo e o modo de
abertura como argumentos. O modo de abertura determina se o arquivo será aberto para
leitura ('r'), escrita ('w') ou anexação ('a'), entre outros modos.
Exemplo de abertura de um arquivo para leitura:

Você pode ler o conteúdo de um arquivo usando o método read() do objeto de arquivo. Isso
retornará o conteúdo do arquivo como uma string.
Exemplo:
Para escrever em um arquivo, você precisa abrir o arquivo no modo de escrita ('w'). Você
pode escrever dados no arquivo usando o método write() do objeto de arquivo.
Exemplo:

É importante fechar um arquivo depois de terminar de usá-lo para liberar recursos do

sistema operacional. Você pode fechar um arquivo chamando o método close() do objeto
de arquivo.
Exemplo:

Uma maneira mais segura e conveniente de trabalhar com arquivos em Python é usando o
gerenciador de contexto with. Isso garante que o arquivo seja fechado corretamente,
mesmo se ocorrerem exceções durante a execução do código.
Exemplo:
 Classes
Vamos aprender alguns conceitos, métodos e a como usar classes no python.
Classe é uma estrutura que representa um conjunto de objetos que compartilham características comuns.
Em Python, você pode definir uma classe usando a palavra-chave class, seguida pelo nome da classe. Aqui
está um exemplo básico de uma classe em Python:

No terminal:

Além do método __init__, existem outros métodos especiais em Python, conhecidos como métodos
mágicos ou dunder (double underscore methods). Aqui estão dois dos mais comuns:
__str__(self): Define a representação de string do objeto. Este método é chamado quando você usa a
função str() ou print() para exibir o objeto.
__repr__(self): Define a representação do objeto. É chamado quando o objeto é representado no shell
interativo ou quando a função repr() é usada.
Aqui está um exemplo que usa esses
métodos:
No terminal:

Herança e Polimorfismo

Herança:
Herança é um mecanismo que permite que uma classe herde atributos e métodos de outra classe. A classe
que está sendo herdada é chamada de classe pai ou classe base, e a classe que herda é chamada de classe
filha ou classe derivada.
Em Python, você pode definir uma classe filha usando a sintaxe class
NomeDaClasseFilha(NomeDaClassePai):. A classe filha então herda todos os métodos e atributos da classe
pai.
Exemplo:

Neste exemplo, Cachorro é uma classe filha de Animal. Ela herda o método fazer_som() da classe pai, mas o
sobrescreve para fornecer uma implementação específica para cachorros.

Polimorfismo:
Polimorfismo é a capacidade de objetos de diferentes classes responderem ao mesmo método de maneira
diferente. Isso permite que um método se comporte de maneira diferente com base no objeto que o está
chamando.
Em Python, o polimorfismo é alcançado por meio da sobreposição de métodos. Quando um método é
chamado em um objeto, o interpretador Python verifica primeiro a classe do objeto para determinar qual
implementação do método deve ser usada.
Exemplo:

No terminal:

Sobreposição de Métodos:
Sobreposição de métodos ocorre quando uma classe filha redefine um método que já foi definido em sua
classe pai. Isso permite que a classe filha forneça uma implementação específica do método, substituindo a
implementação herdada da classe pai.
Exemplo:

Aqui, a classe Gato herda o método fazer_som() da classe Animal, mas o substitui com uma
implementação específica para gatos.
 Encapsulamento
Encapsulamento é um dos princípios da programação orientada a objetos que promove a ideia de esconder
os detalhes de implementação de uma classe e expor apenas uma interface pública para interagir com os
objetos dessa classe. Em Python, o encapsulamento é alcançado principalmente através da convenção de
privacidade usando underscores (_).
Existem duas formas de convenção de privacidade em Python:
1. Um único underscore no início do nome do atributo ou método indica que ele é uma "variável ou
método protegido". Isso significa que ele não deve ser acessado diretamente de fora da classe, mas
ainda é acessível para subclasses. No entanto, nada impede que esses membros sejam acessados
externamente, é apenas uma convenção para indicar que são membros internos da classe.
2. Dois underscores no início do nome do atributo ou método indica que ele é "privado". Isso significa
que ele não deve ser acessado ou modificado de fora da classe. Python realiza uma transformação
de nome chamada "name mangling" (alteração de nome) para evitar o acesso direto a esses
membros de fora da classe.
Vamos ver um exemplo:

No terminal:
É importante observar que, embora o acesso direto a membros privados seja desencorajado em Python,
não há nada que impeça que esses membros sejam acessados de fora da classe. A convenção de
privacidade é uma diretriz para os programadores, não uma restrição imposta pelo interpretador Python.

destrutores de Objetos
Em Python, você pode definir um método especial chamado __del__() que atua como o destrutor de um
objeto. O destrutor é chamado automaticamente quando um objeto não tem mais referências a ele e está
prestes a ser removido da memória. No entanto, o momento exato em que o destrutor é chamado não é
garantido e depende da implementação do coletor de lixo do Python.
Aqui está um exemplo simples de como usar o destrutor em Python:

No terminal:

É importante observar que o uso do destrutor em Python é menos comum do que em outras linguagens de
programação, como C++ ou Java. Isso ocorre porque o gerenciamento de memória em Python é feito
automaticamente pelo coletor de lixo, o que significa que, na maioria dos casos, você não precisa se
preocupar com a liberação explícita de recursos. No entanto, o destrutor pode ser útil para executar ações
de limpeza específicas antes que um objeto seja removido da memória, como fechar arquivos ou conexões
de banco de dados.

Métodos de Classe: @classmethod, @staticmethod

Em Python, você pode definir métodos de classe e métodos estáticos usando os decoradores
@classmethod e @staticmethod, respectivamente. Ambos os tipos de métodos estão associados à classe
em vez de instâncias individuais da classe. Aqui está como você pode usá-los:

Diferenças entre Métodos de Classe e Estáticos:

Métodos de classe (@classmethod) têm acesso à classe através do parâmetro cls e podem acessar/alterar
atributos de classe.
Métodos estáticos (@staticmethod) não recebem automaticamente a classe ou a instância como
parâmetro e, portanto, não podem acessar/alterar atributos de classe ou instância.
Ambos os tipos de métodos podem ser chamados diretamente na classe, sem a necessidade de criar uma
instância da classe. Eles são úteis para operações que são relacionadas à classe, mas não dependem do
estado de uma instância específica

Métodos de Classe (@classmethod):

Um método de classe é um método que opera na própria classe, em vez de em instâncias específicas da
classe. Ele recebe automaticamente a classe como o primeiro argumento, por convenção chamado de cls.

No terminal:

Métodos Estáticos (@staticmethod):

Um método estático é um método que não opera em instâncias da classe nem na classe em si. Ele não
recebe automaticamente a instância da classe ou a classe como argumento. Pode ser útil para funções
utilitárias relacionadas à classe.
No terminal:

Gerenciamento de Memória: Garbage Collection

Em Python, o gerenciamento de memória é tratado automaticamente pelo coletor de lixo (garbage
collector). O garbage collector é responsável por recuperar a memória alocada por objetos que não estão
mais sendo utilizados, liberando essa memória para ser reutilizada pelo programa.
O garbage collector em Python usa uma estratégia de contagem de referência para determinar quando um
objeto pode ser coletado. Quando a contagem de referência de um objeto chega a zero, isso significa que
não há mais referências para aquele objeto em uso, e o garbage collector pode liberar a memória alocada
por esse objeto.
Embora o garbage collector em Python seja eficiente na maioria dos casos, ainda é importante entender
alguns conceitos para evitar vazamentos de memória e garantir que seu código seja otimizado em termos
de uso de memória:
Referências Circulares: O garbage collector pode ter dificuldade em coletar objetos que estão em
referências circulares, ou seja, quando dois ou mais objetos se referenciam mutuamente. Para evitar
vazamentos de memória, é importante quebrar essas referências circulares quando elas não forem mais
necessárias.
Objetos Imutáveis: Objetos imutáveis, como strings e tuplas, geralmente são mais eficientes em termos de
gerenciamento de memória, pois não podem ser modificados após a criação. Isso permite que o garbage
collector otimize a alocação e liberação de memória para esses objetos.
Contextos de Uso: Em certas situações, como a leitura e processamento de grandes arquivos, é importante
usar contextos de uso (with) para garantir que os recursos sejam liberados corretamente após o uso. Por
exemplo, ao ler um arquivo, você deve usar um contexto de uso para garantir que o arquivo seja fechado
automaticamente após a leitura.
Uso de Gerenciadores de Contexto: Além dos arquivos, você pode usar gerenciadores de contexto (with)
para outros recursos, como conexões de banco de dados, para garantir que eles sejam fechados
corretamente após o uso, liberando assim os recursos associados.
Em resumo, embora Python tenha um garbage collector automático que cuida da maioria dos aspectos do
gerenciamento de memória, ainda é importante entender esses conceitos para escrever código eficiente e
evitar vazamentos de memória em situações específicas.

Manipulação de Arquivos e Diretórios: os, shutil

Em Python, os módulos os e shutil são usados para manipulação de arquivos e diretórios no sistema de
arquivos. Aqui está um resumo sobre como usar esses módulos:

Módulo os:
O módulo os fornece uma interface para interagir com o sistema operacional, permitindo operações como
navegação em diretórios, manipulação de arquivos, obtenção de informações sobre o sistema e muito
mais.
Algumas funções úteis do os:
os.getcwd(): Retorna o diretório de trabalho atual.
os.chdir(caminho): Muda o diretório de trabalho atual para o caminho especificado.
os.listdir(caminho): Retorna uma lista dos arquivos e diretórios no caminho especificado.
os.path.exists(caminho): Verifica se o caminho especificado existe no sistema de arquivos.
Exemplo:

No terminal:

Módulo shutil:
O módulo shutil fornece operações de alto nível para manipulação de arquivos e diretórios, permitindo a
cópia, movimentação e exclusão de arquivos e diretórios de forma eficiente.

Algumas funções úteis do shutil:

shutil.copy(origem, destino): Copia um arquivo da origem para o destino.
shutil.move(origem, destino): Move um arquivo da origem para o destino.
shutil.rmtree(caminho): Remove um diretório e todo o seu conteúdo de forma recursiva.
shutil.make_archive(base_name, format, root_dir): Cria um arquivo compactado contendo o conteúdo do
diretório especificado.
Exemplo:

módulos especiais: sys, math, random, json, csv, requests

Módulo sys:
O módulo sys fornece acesso a algumas variáveis e funções usadas ou mantidas pelo interpretador Python
e interage fortemente com o ambiente em execução.
Exemplo de uso:
No terminal:

Módulo math:
O módulo math fornece acesso a funções matemáticas padrão para realizar operações matemáticas mais
avançadas.
Exemplo de uso:

No terminal:

Módulo random:
O módulo random é usado para gerar números aleatórios e realizar operações relacionadas à
aleatoriedade.
Exemplo de uso:
No terminal:

Módulo json:
O módulo json é usado para trabalhar com dados JSON (JavaScript Object Notation), permitindo a
serialização e desserialização de dados.
Exemplo de uso:

No terminal:

Módulo csv:
O módulo csv é usado para ler e escrever
arquivos CSV (Comma-Separated Values),
comumente usados para armazenar dados
tabulares, estilo dados do excel.
Exemplo de uso:
Módulo requests:
O módulo requests é usado para enviar solicitações HTTP em Python, facilitando a interação com APIs da
web e serviços web.
Esse não é um módulo do próprio python, sendo assim precisamos baixa-lo:
pip install requests

Exemplo de uso:

Manipulação de Tempo e Data: datetime, timedelta

Módulo datetime:
O módulo datetime fornece classes para manipulação de datas e horas de forma eficiente. Alguns dos
objetos principais fornecidos pelo módulo datetime são:
datetime: Representa uma data e hora.
date: Representa uma data.
time: Representa uma hora.
Exemplo de uso:

No terminal:

Módulo timedelta:
O módulo timedelta é usado para representar uma diferença entre duas datas ou horas. Isso é útil para
calcular operações como adição ou subtração de dias, horas, minutos, etc.
Exemplo de uso:
No terminal:

Django
Vamos aprender um pouco a como usar o Django framework de desenvolvimento web do python.
O diretório do nosso projeto deve ser assim:

meuprojeto/
│
├── meuprojeto/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
│
└── meuapp/
├── migrations/
├── templates/
│ └── meuapp/
│ └── index.html
├── __init__.py
├── admin.py
├── apps.py
├── models.py
├── tests.py
└── views.py

Para isso você deve seguir o passo a passo a baixo:

Vou criar um exemplo prático simples para ilustrar como você pode usar HTML, CSS e lógica de site em um
projeto Django. Vou criar um aplicativo Django chamado meuapp com uma página inicial que exibe uma
lista de itens.

1. Criando um projeto e um aplicativo Django:

Primeiro, crie um novo projeto Django e um aplicativo dentro dele. No terminal, execute os seguintes
comandos:

2. Definindo o modelo:

Abra o arquivo meuapp/models.py e defina um modelo simples para os itens que queremos exibir na
página:

3. Criando alguns itens no banco de dados:

Vamos criar alguns itens no banco de dados para exibir na página inicial. No terminal, execute:

Agora, vá para o shell do Django:

E adicione alguns itens:

 4. Criando a view:

Abra o arquivo meuapp/views.py e defina uma view para renderizar a página inicial com a lista de itens:

5. Criando
o template HTML:
Crie um diretório chamado templates dentro do diretório do aplicativo meuapp. Dentro dele, crie uma
pasta chamada meuapp e dentro dela crie um arquivo chamado index.html e adicione o seguinte
conteúdo:

6. Criando o arquivo de estilo CSS:

Crie um diretório chamado static dentro do diretório do aplicativo meuapp. Dentro dele, crie um diretório
chamado meuapp e um arquivo chamado style.css dentro dele. Adicione o seguinte conteúdo ao style.css:

7. Template

Em “settings.py” devemos procurar pela propriedade “TEMPLATES” e adicionar o caminho da pasta

“templates” onde ta os arquivos html que queremos exibir no site, pois assim o Django vai poder
identificar, ler e renderizar esses arquivos html na tela.
Primeiro precisamos pegar o caminho da pasta templates (da forma que preferir, pode ser pelos “meus
arquivos” também) e adicionar na propriedade “DIRS” dentro de TEMPLATES, assim:

8. Configurando URLs:
Abra o arquivo meuprojeto/urls.py e adicione uma
rota para a view index do aplicativo meuapp:
Em seguida, crie um arquivo urls.py dentro do diretório meuapp e adicione o seguinte conteúdo:

9. Executando o servidor de desenvolvimento:

No terminal, execute:

Agora você pode abrir um navegador e ir para http://127.0.0.1:8000/ para ver sua página inicial com a lista
de itens. Este é um exemplo simples de como usar HTML, CSS e lógica de site em um projeto Django.

Casting

Em Python, o "casting" refere-se à conversão de um tipo de dado para outro. Existem várias funções
embutidas que permitem fazer isso. Aqui estão algumas das principais funções de "casting" em Python:

1. **int():** Converte um valor para um inteiro.

```python
x = int(5.6) # Resultado: 5
```
2. **float():** Converte um valor para um número de ponto flutuante.
```python
x = float("3.14") # Resultado: 3.14
```

3. **str():** Converte um valor para uma string.

```python
x = str(123) # Resultado: "123"
```

4. **bool():** Converte um valor para um booleano.

```python
x = bool(0) # Resultado: False
```

5. **list():** Converte um iterável para uma lista.

```python
x = list((1, 2, 3)) # Resultado: [1, 2, 3]
```

6. **tuple():** Converte um iterável para uma tupla.

```python
x = tuple([1, 2, 3]) # Resultado: (1, 2, 3)
```

7. **set():** Converte um iterável para um conjunto.

```python
x = set([1, 2, 3, 2]) # Resultado: {1, 2, 3}
```

8. **dict():** Converte um iterável de pares chave-valor para um dicionário.

```python
 x = dict([(1, 'um'), (2, 'dois')]) # Resultado: {1: 'um', 2: 'dois'}
```

9. **chr():** Converte um número inteiro Unicode para um caractere.

```python
x = chr(65) # Resultado: 'A'
```

10. **ord():** Converte um caractere para seu valor inteiro Unicode.

```python
x = ord('A') # Resultado: 65
```
1. Interfaces Gráficas: tkinter, PyQt, PyGTK

2. Desenvolvimento Web: Django, Flask, Bottle

3. Testes Unitários: unittest, pytest

4. Serialização e Desserialização: pickle, json, xml

5. Comunicação de Rede: sockets, urllib, requests

6. Bancos de Dados: SQLite3, MySQL, PostgreSQL, MongoDB

7. Logging: módulo logging

8. Análise de Dados: NumPy, Pandas, Matplotlib

9. Machine Learning e Inteligência Artificial: TensorFlow, Keras, PyTorch

10.Manipulação de Imagens: Pillow (PIL)

11.Processamento de Texto: NLTK, spaCy

12.Criptografia e Segurança: hashlib, cryptography

13.Geração de Números Aleatórios: Random

14.Geração de Gráficos e Visualização de Dados: Seaborn, Plotly

15.Integração com APIs: requests, urllib

16.Manipulação de XML e JSON: xml.etree.ElementTree, json

17.Interpretação de Expressões Matemáticas: eval()

18.Programação Funcional: map(), filter(), reduce()

19.Manipulação de Áudio: PyDub

20.Manipulação de Vídeo: OpenCV

21.Interpretação de Código Dinâmico: exec(), eval()

22.Internacionalização e Localização: gettext

23.Concorrência: threading, multiprocessing

24.Caching e Memória Cache: functools.lru_cache

25.Serialização de Objetos: pickle

26.Desenvolvimento de Jogos: Pygame

27.Integração com Bancos de Dados NoSQL: pymongo (MongoDB)

28.Programação Orientada a Aspectos: AspectLib

29.Framework para Testes de Desempenho: locust

30.Scripting de Sistemas Operacionais: subprocess

31.Implementação de Serviços RESTful: Flask-RESTful, Django REST framework

32.Validação de Dados e Schemas: Pydantic, Marshmallow

33.Simulação e Modelagem: SimPy

34.Automação de Tarefas: Automate, PyAutoGUI

35.Análise de Sentimentos: TextBlob, VaderSentiment

36.Processamento de Linguagem Natural Avançado: transformers, Gensim

37.Integração com Serviços em Nuvem: boto3 (AWS), google-cloud-python (Google

Cloud)

38.Desenvolvimento de Aplicativos Desktop: PyQt, PyGTK

39.Geração de Documentação: Sphinx

40.Escrita e Leitura de Arquivos CSV: csv

41.Manipulação de Arquivos Excel: openpyxl, xlrd, xlwt

42.Framework para Computação Distribuída: Dask

43.Framework para Desenvolvimento Web Assíncrono: Quart

44.Criação de APIs GraphQL: Graphene

45.Manipulação de Dataframes: Pandas

46.Gerenciamento de Dependências e Ambientes Virtuais: pip, virtualenv, conda

47.Monitoramento e Logging de Aplicações: Prometheus, Grafana

48.Testes de Integração: pytest

49.Transformação de Dados: scikit-learn

50.Otimização e Álgebra Linear: SciPy

51.Soluções de Big Data: PySpark, Dask

52.Desenvolvimento de Aplicativos Móveis: Kivy

53.Implementação de Algoritmos de Aprendizado de Máquina: scikit-learn

54.Framework para Web Scraping: BeautifulSoup, Scrapy