Python

 Python é uma linguagem de programação interpretada de alto nível e

que suporta múltiplos paradigmas de programação: imperativo,
orientado a objetos e funcional. É uma linguagem com tipagem
dinâmica e gerenciamento automático de memória.
 Isso significa que a implementação da linguagem python em cada
computador é feita através de um processo no qual um dos principais
componentes é o interpretador.
 Python librarie general
 https://docs.python.org/3/library/index.html
 Python librarie for string
 https://docs.python.org/3/library/stdtypes.html
 TOP 20 Python libraries for Data Science
 https://www.simplilearn.com/top-python-libraries-for-data-science-
article#top_20_python_libraries_for_data_science
Possui maior proximidade com a linguagem humana do que com a
linguagem de máquina (binário).

Paradigmas de Programação são as diferentes abordagens

que um programador pode utilizar para desenvolver um código
e resolver uma questão específica.
 Imperativo ou Procedural: As instruções são passadas ao computador na
sequência que devem ser executadas.

 Orientado a Objetos: Talvez o mais popular dos paradigmas. Utiliza
estruturas denominadas classes e objetos e sua principal característica é
permitir uma programação multiplataforma.

 Funcional: Possui como principal característica o uso de estruturas
chamadas de funções. Essas funções separam o código em blocos nos
quais cada um tem uma tarefa específica.

O Python constantemente realiza uma manutenção ou “limpeza” da

memória não utilizada através de mecanismos como o garbage
collector (coletor de lixo) e a Reference Counting (Contagem de
Referência). Dessa forma, o programador não tem que se preocupar em
fazer um gerenciamento manual de memória.

Desenvolvimento Web
A área de Desenvolvimento web engloba todas as atividades usadas para criar
websites e aplicativos web-based. Existem duas subcategorias quando falamos em
desenvolvimento web: O Front-end e o Back-end.

A linguagem Python entra nessa história através dos seus frameworks de

desenvolvimento web back-end, o Django e o Flask. Esses frameworks
são estruturas que facilitam a criação lógica do back-end, mapeando
URLs, auxiliando a integração com bancos de dados e a criação de APIs.

>>>
print(*args, sep=' ', end='\n', file=None, flush=False)

2
 Prints the values to a stream, or to sys.stdout by default.

sep
string inserted between values, default a space.
end
string appended after the last value, default a newline.
file
a file-like object (stream); defaults to the current sys.stdout.
flush
whether to forcibly flush the stream.
Para criar uma variável, basta apenas citar entre aspas:
>>> nome = “Yuri”
Type (nome) = class str (stream)

>>> idade = 19
Type(idade)= class int (inteiro)
>>> media = 9.8
Class= (float)

Estrutura:
-Tudo que é necessário ser digitado e imprimido no python, é necessário
estar entre aspas, antecedido do comando o print.
Para realizar o comando print, é necessário saltar quatro espaços.
É essencial a utilização de parênteses para realizar o complemento de
alguma função, como: print(), if(), else();
Tudo que for digitado entre aspas, é considerado como str.
Para criar uma variável, basta apenas, digitar a igualdade , sem ser entre
aspas.

JOGO DE ADVINHAÇÃO:
No jogo de adivinhação, desenvolvido por mim, é notório que, ao inserir
( um número secreto= 42 e colocar um input ( tag que pede ao usuário

3
para digitar algo) = chute e associar os dois, chute = número secreto, é
sempre reconhecido como false.
Isso se dá pelas duas funções apresentarem classes diferentes, sendo:
-- chute= str.
-- número secreto= int.
Isso acontece pois a tag input, sempre classifica uma fução como str, pois
o que será colocado, pode ser universal, tanto um número quanto uma
letra. (também se dá pelo uso de aspas)
--enquanto a tag int, sempre classifica um número inteiro.
Então ao associar, str= int, é impossível o resultado ser true.

4
No pyhton 2 a função input era muito primitiva, então os programadores da
época utilizavam a função raw_input, a qual viria futuramente se tornar o
input do python 3.

JS VS PYTHON
https://cursos.alura.com.br/course/python-introducao-a-
linguagem/task/24459
No python, tudo que está entre “aspas”, é convertido para a classe
str, e isso pode prejudicar na conversão de diversas contas como:
numero1 = 10
numero2 = 20
produto = numero1 * numero2
print(produto)
200
numero1 = 10

5
numero2 = "20"
produto = numero1 * numero2
print(produto)
2020202020202020202020202020

Artigo sobre prompt do Windows para python:

nesse artigo com dicas para trabalhar no prompt do windows.
O Python é uma linguagem muito rígida, apesar de simples, você
sempre deve tomar cuidado com a estrutura do texto:
print( "*************************")
print ("Bem vindo no jogo de adivinhação!")
print ("*************************")

numero_secreto = 42

chute_str = input("Digite o seu numero: ")

print ("Você digitou" , chute_str)

chute = int(chute_str)

if(numero_secreto== chute):
print("Você acertou!")
else:
if(chute > numero_secreto):
print("Você errou! Seu chute foi maior do que o número secreto")
if(chute < numero_secreto):
print("Você errou! Seu chute foi menor do que o número secreto")
estrutura correta (print sempre mais afastado da margem, dois
pontos sempre após alguma tag ).

print( "*************************")
print ("Bem vindo no jogo de adivinhação!")
print ("*************************")

numero_secreto = 42

chute_str = input("Digite o seu numero: ")

print ("Você digitou" , chute_str)

chute = int(chute_str)

if(numero_secreto== chute):
print("Você acertou!")
else:
if(chute > numero_secreto):
print("Você errou! Seu chute foi maior do que o número secreto")
if(chute < numero_secreto):
print("Você errou! Seu chute foi menor do que o número secreto")

6
Estrutura incorreta, if alinhado com os prints, o código não irá
funcionar.

DEFINIÇÃO DE VARIÁVEIS:
else:
if(chute > numero_secreto):
print("Você errou! Seu chute foi maior do que o número secreto")
elif(chute < numero_secreto):
print("Você errou! Seu chute foi menor do que o número secreto")

print("Fim do jogo")

acertou= numero_secreto == chute

maior = chute> numero_secreto
menor = chute< numero_secreto

if(acertou):
print("Você acertou!")

else:
if(maior):
print("Você errou! Seu chute foi maior do que o número secreto")
elif(menor):
print("Você errou! Seu chute foi menor do que o número secreto")

print("Fim do jogo")
No caso o resultado será o mesmo, porém foi facilitado a escrita
definindo as variáveis:
Maior =Chute> numero secreto
Menor =Chute < numero secreto
Acertou =Chute = numero secreto

idade_str = input("Digite sua idade: ")

idade = int(idade_str)

if (idade > 18):

print("Você é maior de idade.")
else:
if (idade < 12):

7
 print("Você é uma criança.")
elif (idade > 12):
print("Você é um adolescente.")

Quando o usuário digitar 12, nenhuma condição será satisfeita! Repare que:
 12 não é maior que 18 (idade > 18).
 12 não é menor que 12 (idade < 12).
 12 não é maior que 12 (idade > 12).
É preciso testar a igualdade através do ==.
Saiba também, que além do == (igualdade), > (maior) e < (menor), também
temos >= (maior ou igual), <= (menor ou igual) e != (diferente).

Seguem todas as operadores de comparação:

 < - menor que

 > - maior que
 <= - menor ou igual a
 >= - maior ou igual a
 == - igual a
 != - diferente de

BOOL:
acertou = (chute == numero_secreto)

A variável acertou é do tipo bool.

Uma variável do tipo bool pode ter apenas dois valores, True ou False, que
podemos usar diretamente:

passou = True
errou = False

8
No curso sempre seguimos a forma que usa parênteses, pois deixa
mais claro qual é a condição, principalmente quando há várias
condições a avaliar através das operações lógicas AND ou OR. Veremos
mais para frente um exemplo concreto com as operações lógicas!

Ambos, if e while, possuem uma condição de entrada. A

diferença é que o if executa o bloco apenas uma vez, mas
o while repete o bloco enquanto a condição for verdadeira.
O interessante é que o Python não possui um laço com uma condição
de saída, que outras linguagens chamam de do-while.

-String Interpolation:
Dentro da string, devemos utilizar as chaves ({}) para definir onde o valor da
variável deve ser inserido. E logo após a definição da string, chamamos a
função format, que recebe as variáveis/parâmetros na ordem de inserção:

"Em {} o Carnaval acontece em {} do dia {} até o dia {}".format(ano, mes,

dia_ini, dia_fim)

Função For:
A função range possui os seguintes parâmetros:
range(start, stop, [step]

Onde o step é opcional. Como queremos "pular" de 3 em 3, começando com 1

(start) até 10 (stop), podemos escrever:
for contador in range(1,11,3):
print(contador)

1,4,7,10

Break e continue:

9
Para controlar melhor os laços, existem os comandos break e continue, que são
utilizados dentro de um laço (for ou while). Ambos fazem parte do controle de
fluxo (control flow).
A diferença é que o break, quando for executado, sai do bloco do laço
abruptamente, enquanto continue apenas pula para próxima iteração.

i = 1
while(i <= 7):
print(i)
i = i + 1
if(i == 5):
break

A saída será:
1
2
3
4

Se você achou que o 5 seria impresso, errou. Isso porque a condição if, que
executa o break (que rompe o laço da iteração), é executada após o incremento da
variável i, sendo assim, quando o valor dela for 5, paramos a repetição antes que o
programa tenha chance de imprimir o valor 5.

O for é uma alternativa interessante ao while, muito utilizado para iterar por uma
sequência de valores. Lembrando que break e continue também podem ser
utilizados com while.

Interpolação de string na formatação de

números:
>>> print("R$ {:7.2f}".format(1234.50))
R$ 1234.50
>>> print("R$ {:7.2f}".format(1.5))
R$ 1.50

Para definir um número float: (:f)

Através disso vc define os parâmetros: (:7.2f)

10
Quero que o número tenha no máximo sete caracteres. E que sejam
dois depois da vírgula.

EXERICIO:
Um desenvolvedor Python está tendo que adaptar um sistema americano de
cadastro de clientes americanos para os clientes brasileiros. Ele está esbarrando em
um problema, pois lá as pessoas têm o costume de se referir pelo sobrenome antes
do primeiro nome, por exemplo: Smith, John .

Ele deseja adaptar as mensagens do sistema para o padrão brasileiro, mas sem
alterar a estrutura de dados que ele recebe do banco de dados.

Digamos que ele queira exibir a seguinte mensagem: "Ola Sr. Leonardo Cordeiro",
como ele pode formatar a string para obter o resultado desejado?

print("Ola Sr.{1} {0}".format("Cordeiro","Leonardo"))

Com o .format(), podemos especificar a ordem em que os parâmetros aparecem

na string, basta apenas colocar entre as chaves ({}) da string formatada qual
parâmetro você quer exibir. É válido lembrar também, que o primeiro parâmetro é
o zero, pois tradicionalmente na computação começamos contando de zero, ou
seja, no nosso caso:
O primeiro parâmetro, representado pelo 0** é Cordeiro, e o segundo, que é o
**1, é o Leonardo. Assim, formatando a string, na hora de imprimir será exibido:

Round e int(random)
Random, é uma tag que gera um número aleatório, na casa dos decimais de 0 a
1.
Para sofisticar esse código um pouco mais, você deve definir alguns
parâmetros.
Tais parâmetros como: int --- definir um numero inteiro
*100 – definir um valor entre 0 e 100
Ao definir tais parâmetros:

11
Número_random = random.random() *100
Int(numero_random)

Esse código irá gerar um numero interio random, entre 0 e 100

*A função random, não é uma função built-in, ou seja, ela não está
automaticamente disponível no código python, tendo que importá-la, (import
random)
E se vc quiser definir uma intercessão, o comando é, random.randrange( **,
**)

import random

sorteado = random.randrange(0,4)

print(sorteado)

if sorteado == 1:
print( "Paulo")
elif sorteado == 2:
print("Juliana")
else:
print("Tamires")

O sorteio foi injusto, afinal os possíveis números retornados são 0, 1, 2 e 3 , e como o

Paulo e a Juliana estão associadas a apenas um número cada sobram ainda outros dois
para Tamires poder ganhar.

/= DIV FLOAT
//= DIV INT

O resultado é 1, um valor inteiro (int).

12
O operador // também é chamado integer division e sempre devolve o valor
inteiro (sem arredondar).
Para realmente concluir o tópico, saiba que o Python 2 só tem integer division,
mesmo tendo os dois operadores / e // ! No Python 2 não existe diferença entre os
dois operadores, veja o exemplo:

DECLARANDO UMA FUNÇÃO

Para declarar uma função, devemos usar a palavra chave def do mundo Python,
seguida pelo nome da função.
def nome_da_funcao():
# todo o código identado faz parte da função
print("aprendendo funções")

Repare que uma função pode chamar uma outra função. print também é uma
função e usamos ela dentro da nossa própria função.

Executando funções

Para chamar a nossa própria função, usamos o nome dela seguido pelos parênteses,
por exemplo:

nome_da_funcao()COPIAR CÓDIGO

Podemos chamar uma função quantas vezes quisermos:

nome_da_funcao()
nome_da_funcao()
nome_da_funcao()COPIAR CÓDIGO

Isso é a principal vantagem de funções, reaproveitar o código escrito nela!

Parâmetros e retorno

Uma função também pode receber parâmetros e retornar algum valor, por exemplo:

def soma(a, b):

return a + bCOPIAR CÓDIGO

13
A função soma recebe dois parâmetros (a e b) e retorna a soma. Ao chamar a
função, podemos capturar o retorno:
s = soma(3, 4)

Definir uma função é muito relevante, pois com ela é possível, definir uma
função e ao importar, não será executada automaticamente.

# arquivo a.py
print('executando a')
# arquivo b.py
print('executando b')

# principal.py

import a
import b
Nesse caso, a execução é automática, pois a importação não veio de uma
função

Definindo arquivos como principal:

Outra maneira de impedir que a importação execute um programa

automaticamente, é definindo qual arquivo é o principal:
Para isso, existe o código
If(__name__ == __main__)
Principal()

Com isso vc cria uma função: def principal no seu arquivo principal

PYTHON VS C

14
A primeira diferença que vemos é que no C precisamos importar mais bibliotecas,
isso porque algumas funções no C não são built-in, como a de imprimir (printf)
e a de capturar entrada do usuário (scanf), por isso para utilizá-las é necessário
importar algumas bibliotecas.
Outra diferença é que no C somos obrigados a definir a função main, que é
considerada o início de qualquer programa, sem ela nada vai funcionar. Ao
contrário do Python, já que nós só criamos a função jogar() quando precisamos
importar o arquivo em outro, mas antes nós conseguíamos executar diretamente o
jogo sem problemas.

O Python, como já sabemos, é uma linguagem que possui a tipagem dinâmica, já

que o tipo da variável varia de acordo com o valor que ela recebe, por isso que em
Python não podemos declarar variáveis vazias, só definindo o seu nome, porque se
não atribuirmos um valor a uma variável, o Python não saberá o seu tipo.

O resto do código é bem parecido, com algumas diferenças de sintaxe e

nomenclatura, como por exemplo a sintaxe dos blocos, para definir um bloco no C
devemos colocá-lo entre chaves e a indentação não é obrigatório, apesar de todos
os desenvolvedores utilizarem por conta da formatação do código, já no Python só
precisamos colocar os dois pontos e indentar o código do bloco; o C também te
obriga a colocar ponto e vírgula ao final das instruções.

E com o C não existe um comando, algo como um cexecuter, para executarmos

um arquivo.

O ambiente do C exige que primeiramente devemos passar o código fonte (o

arquivo .c) para um compilador. O compilador lê o código fonte e faz uma análise
da sintaxe, se esquecemos algum ponto e vírgula, ou de tipar alguma variável, etc.
E feita essa análise, o compilador cria um outro arquivo, e é esse arquivo que
podemos executar.

O Python é realmente uma linguagem estritamente

interpretada?

Para finalizar, falamos que o Python utiliza o conceito de interpretação, ou seja,

passamos o código fonte e ele é interpretado, mas não é bem assim. Podemos
executar o arquivo jogos.py e reparar na pasta que é criada dentro do diretório,
a pycache. Se formos ver o que tem dentro da sua pasta, vemos que há dois

15
arquivos referentes aos módulos importados no jogos.py, ou seja, um arquivo
referente à adivinhacao e outro à forca. Mas o que são esses arquivos?

O que o Python faz ao vivo é ler os módulos importados e os compila para

bytecode. Esse código foi criado ao mesmo tempo em que executamos o
arquivo jogos.py. Apesar do Python ter um ambiente de interpretação, ele compila
os módulos importados para melhorar o desempenho, a execução do ambiente,
apesar de não ter esse processo de compilação explícito.

"Python é uma linguagem interpretada, em oposição às compiladas, embora a

distinção possa ficar desfocada devido à presença do compilador de
bytecode."

True or false
Devemos utilizar o tipo bool para representar verdadeiro (True) e falso.
>>> existe = True
>>> type(existe)
<class 'bool'>

FUNÇÕES: CONTADOR DE VOGAIS

def contador_vogais (string):
inicia o contador de vogais
contador= 0
vogais= [‘a’,’e’,’i’,’o’,’u’]
definindo vogais
string=string.lower()

for char in string:

itera sobre cada caractere na string
if char in vogais:
contador +=1

16
return contador

texto= input(“”)
numero_de_vogais=contador_de_vogais(texto)
print(f”O numero de vogais na string é: {numero_de_vogais}
("Encontrei a letra {} na posição{}".format(letra,index))

Formatando strings. Format(letra, index): vai me indicar primeiro a letra e

depois o index.

palavra.find("b") # resultado é -1
Correto! Quando a busca nada encontra, o resultado é sempre -1.

A função find encontra a primeira ocorrência do texto que estamos procurando

e devolve o índice. Lembrando também que o índice começa com 0.
O find também aceita um segundo parâmetro, que define a partir de qual posição
gostaríamos de começar, por exemplo:

>>> palavra = "aluracursos"

>>> palavra.find("a",1) #procurando "a" a partir da segunda posição
4

palavra = "Alura"
for letra in palavra:
if(letra == "l"):
print("Achou!")

17
Errado! Repare que a instrução print não está indentada, logo, não faz parte do bloco if. É um
erro muito comum para quem está começando com Python.

palavra = "Alura"
for letra in palavra:
if(letra == "l"):
print("Achou!")
Correto! Respeita a indentação do Python.
PRINT ESTÁ DESLOCADO CORRETAMENTE.
FORMATAÇÃO DE STRINGS

a = "Cavalo"
b = "Calopsita"
print("{} e {}".format(b, a))

'Calopsita e Cavalo'

Correto! Nossa string possui duas lacunas definidas com {}. Os parâmetros passados para a
função format são passados na mesma ordem para preencherem a lacuna.

Listas:
Romeu fez quase tudo corretamente, errando apenas na linha:
campeao = colocacao[1]Apesar dele querer o primeiro colocado de seu torneio, ele
deve pedir o primeiro elemento da lista, que é o elemento de índice 0** e não de
índice **1.
A FUNÇAO LISTAS, ASSIM COMO STRINGS, TUPLAS E RANGE, SÃO SEQUENCIAS
Entre essas sequências, list é a única que é mutável. tuple, str e range são
imutáveis.

Algumas funções
A função min nos retorna o menor item de uma lista.

String.lower() transforma a string em letra minúscula

String.upper() transforma a string em letra maiúscula

A função len() retorna a quantidade de itens das listas

18
Importante saber que existem algumas funções que funcionam com todos os tipos
de sequências como os built-ins: len, min e max.
O del também é uma função built-in, mas só funciona para sequências mutáveis
como listas. Como o tuple é imutável, não podemos remover seus elementos, e
logo o código dá erro.

TUPLAS
As tuplas, são uma função parecida com a lista, porém dentro delas contém
dados dos quais não podem ser alterados, são imutáveis
Diferente das listas que usam []
As tuplas utilizam ()

Lembrando que para transformar um tuple em uma lista, temos a função list(..).
Se queremos transformar de list para tuple devemos usar tuple(..) Ambas são
funções built-in.

lista = [for fruta in frutas fruta.upper() ]

Errado! Primeiro devemos chamar a função fruta.upper() e depois usar o laço for.

qual seria o código para obter a lista de quadrados?

quadrados = [n*n for n in inteiros]

A função open() recebe um ou mais parâmetros. Em uma determinada ordem,

quais são eles?
 Alternativa correta
O nome do arquivo e o modificador de acesso.
Correto! Precisamos informar qual é o nome do arquivo que queremos abrir, e podemos
também informar qual modificador de acesso válido.

19
Marque todas as alternativas abaixo que são modificadores de acesso da
função open():
r
Correto! Utilizamos o modificador r para o modo de leitura

a
Correto! Utilizamos o modificador a para modo de append, adicionando conteúdo a um arquivo
pré existente

w
Correto! Utilizamos o modificador w para modo de escrita.

Além do r, w e a existe o modificador b que devemos utilizar quando queremos

trabalhar no modo binário. Para abrir uma imagem devemos usar:
imagem = open("foto.jpg", "rb")

Por exemplo, o código abaixo cria uma cópia de uma imagem:

#arquivo copia.py
logo = open('python-logo.png', 'rb')
data = logo.read()
logo.close()

logo2 = open('python-logo2.png', 'wb')

logo2.write(data)
logo2.close()

arquivo = open('nome.txt', 'w')

arquivo.close()
Correto! A função close é responsável por fechar o arquivo.

 arquivo = open('pessoas.txt', 'r')

 linha = arquivo.readline()
 print(linha)
Correto! A função readline lê apenas uma linha do arquivo.

Se desejamos ler linha a linha de nosso arquivo, podemos utilizar a

função readline(). Ela nos retorna uma linha por vez, e faz com que a nossa

20
leitura seja feita de modo mais controlado. Também existe a função read() que
por sua vez lê o arquivo inteiro.

arquivo = open('frutas.txt','r')
conteudo = arquivo.read()
print(conteudo)
conteudo = arquivo.read()
print(conteudo)
COPIAR CÓDIGO
A primeira vez é exibida corretamente o conteudo, porém na segunda não é
exibido nada. Por quê?

Pois o comando read() lê o arquivo inteiro de uma vez, colocando o ponteiro de

leitura no final do mesmo. Se chamarmos a função read() novamente, como o
ponteiro de leitura está no final, nada será lido.Correto! Se desejarmos ler o arquivo
novamente, devemos fechá-lo com o comando .close(), reabri-lo com o comando .open() e ai
sim conseguiremos lê-lo por inteiro novamente.

JORNADA PYTHON
AULA 1- AUTOMATIZAÇÃO DE TAREFAS
Criar bots de automatização

Pandas—pacote de códigos que trabalha muito eficiente com milhares de dados

Pyautogui.PAUSE : DEFINE UM INTERVALO DE PAUSA APÓS CADA COMANDO

Time.sleep: um intervalo de tempo de um ciclo

BANCO DE DADOS
SQL, que significa Structured Query Language, é uma linguagem de programação usada para
gerenciar e manipular bancos de dados relacionais. Existem duas principais categorias de
comandos SQL: DDL (Data Definition Language) e DML (Data Manipulation Language).
Cada uma dessas categorias tem um propósito específico dentro do gerenciamento de bancos
de dados.

21
DDL (Data Definition Language): DDL é usada para definir a estrutura do banco de dados,
ou seja, para criar, alterar e excluir objetos de banco de dados. Alguns dos comandos DDL
mais comuns incluem:
CREATE: Usado para criar novos objetos de banco de dados, como tabelas, índices, visões,
procedimentos armazenados, etc. ALTER: Utilizado para modificar a estrutura de objetos
existentes, como adicionar, renomear ou excluir colunas de uma tabela. DROP: Usado para
excluir objetos de banco de dados, como tabelas, índices, visões, etc. TRUNCATE: Remove
todos os dados de uma tabela, mas mantém a estrutura da tabela. RENAME: Usado para
renomear objetos de banco de dados.
Exemplo de comando DDL para criar uma tabela:

CREATE TABLE clientes (

id INT PRIMARY KEY,
nome VARCHAR(255),
email VARCHAR(255)
);

DML (Data Manipulation Language): DML é usada para manipular os dados armazenados no
banco de dados. Os comandos DML permitem que você insira, atualize, consulte e exclua
dados de tabelas. Alguns dos comandos DML mais comuns incluem:

SELECT: Usado para recuperar dados de uma ou mais tabelas. INSERT: Utilizado para
adicionar novos registros a uma tabela.
UPDATE: Usado para modificar registros existentes em uma tabela.
DELETE: Usado para excluir registros de uma tabela. Exemplo de comando DML para
inserir dados em uma tabela:

INSERT INTO clientes (id, nome, email)

VALUES (1, 'João Silva', 'joao@email.com');
SELECT * FROM clientes;

Em resumo, os comandos DDL são usados para definir a estrutura do

banco de dados, enquanto os comandos DML são usados para manipular
os dados dentro do banco de dados. Ambos desempenham um papel
fundamental na administração e utilização de bancos de dados relacionais.

22
SQLITE3

A biblioteca sqlite3 em Python permite que você trabalhe com bancos de

dados SQLite. SQLite é um banco de dados embutido que não requer um
servidor de banco de dados separado e é amplamente utilizado em
aplicativos desktop, móveis e da web. Abaixo estão alguns exemplos de
como você pode usar o sqlite3 para criar, consultar, inserir e atualizar
dados em um banco de dados SQLite em Python:
Conectar-se a um banco de dados:

import sqlite3

# Conecta-se ao banco de dados (ou cria um novo se não existir)

conn = sqlite3.connect("exemplo.db")

# Cria um cursor para executar comandos SQL

cursor = conn.cursor()

# Cria uma tabela (caso não exista)

cursor.execute('''CREATE TABLE IF NOT EXISTS produtos
(id INTEGER PRIMARY KEY,
nome TEXT,

23
 preco REAL)''')

# Insere dados na tabela

cursor.execute("INSERT INTO produtos (nome, preco) VALUES (?, ?)",
("Produto A", 10.99))
cursor.execute("INSERT INTO produtos (nome, preco) VALUES (?, ?)",
("Produto B", 20.99))

# Executa uma consulta para recuperar todos os dados da tabela

cursor.execute("SELECT * FROM produtos")

# Recupera todas as linhas da consulta

linhas = cursor.fetchall()

# Exibe o conteúdo da tabela

print("Conteúdo da tabela:")
for linha in linhas:
print(linha)

# Atualiza o preço de um produto

cursor.execute("UPDATE produtos SET preco = ? WHERE nome = ?",
(25.99, "Produto B"))

# Exclui um produto da tabela

cursor.execute("DELETE FROM produtos WHERE nome = ?", ("Produto
A",))

# Salva as alterações no banco de dados

conn.commit()

24
# Exibe o conteúdo atualizado da tabela
cursor.execute("SELECT * FROM produtos")
linhas = cursor.fetchall()
print("\nConteúdo atualizado da tabela:")
for linha in linhas:
print(linha)
# Fecha a conexão com o banco de dados
conn.close()

Orientação a objetos

o paradigma da Orientação a Objetos está relacionado com a organização do

código, no mundo procedural, não somos obrigados a adotar OO, não há algo que
reforça a necessidade de utilizarmos essa maneira mais organizada de escrever o
código. Ou seja, cabe ao desenvolvedor decidir se quer adotar o paradigma OO.

Em um sistema maior, é grande a chance de que as funções fiquem separadas em

arquivos e módulos diferentes do projeto. No entanto, pode ser trabalhoso
encontrar onde está cada trecho do código e isso, pode resultar em retrabalho e
escrever funções já existentes. O paradigma Orientado a Objetos nos incentiva a
agrupar funcionalidades relacionadas em um mesmo lugar.

Antes de criar um objeto devemos criar uma class (através de um novo arquivo)

Ao criar uma class, é necessário que o nome da classe seja em letra maiúscula,
seguido por outro substantivo se necessário, também com letra maiúscula

Toda classe possui métodos e atributos, definidos por parênteses ou no bloco do

código

Ex: class ContaCorrente:

(pass: A instrução pass diz ao programa para desconsiderar essa condição e continuar
executando o programa como sempre. A instrução pass pode criar classes mínimas, ou agir

25
como um espaço reservado enquanto estamos trabalhando em novos códigos e pensando em
um nível algorítmico antes de construir detalhes.)

Objeto:
conta.Conta = (novo objeto criado)

conta= Conta(...)

conta2= Conta(...)

2 objetos criados

vc cria objetos baseados em classes, assim como fazemos bolos baseados em receitas

class Livro:
pass

livro1 = Livro()
1. Nádia declarou uma classe chamada Livro e instanciou essa classe criando um
objeto chamado livro1.
2. No código desenvolvido, ela declarou uma classe chamada Livro e criou um objeto
chamado livro1 a partir dessa classe.

FUNÇÃO CONSTRUTORA: Adicionaremos dois caracteres _ antes e depois do

nome da função construtora, para criarmos __init__. O Python constrói o
objeto, cria um lugar na memória e depois chama a função __init__. Essa
função ira funcionar automaticamente, na hora de construir o objeto. Como
demonstração, segue o código:
class Conta:
def __init__(self):
print("Construindo objeto...")

26
Criamos uma função, mas a ideia é definir os atributos e as características. Para
isso, precisaremos da variável self, que está dentro da função __init__().

self é a referência que sabe encontrar o objeto construído em memória.

Agora que temos o endereço, utilizaremos self para acessar o objeto e definir seus
atributos e características.
class Conta:

def __init__(self):
print("Construindo objeto...{}".format(self))

self.numero = 123
self.titular = "Nico"

self.saldo = 55.0
self.limite = 1000.0

Em self.numero, o caractere "ponto" (.) é um comando de ida ao objeto

e numero, titular, saldo e limite são atributos.

class Conta:

def __init__(self, numero, titular, saldo, limite):

print("Construindo objeto...{}".format(self))
self.numero = numero
self.titular = titular

27
 self.saldo = saldo
self.limite = limite

Desta forma, o limite do objeto (self.limite) será o limite recebido do

parâmetro da função __init__(). E qual é a origem dos dados? O valor
do self é passado pelo Python, responsável pela criação final do objeto em
memória. No entanto, os valores dos parâmetros como numero deverão ser
definidos usando a aplicação.

>>> from conta import Conta

>>> conta = Conta(123, "Nico", 55.5, 1000.0)

Construindo objeto ... <conta.Conta object at 0x11077bcc0>

class Video:
def __init__(self, titulo, duracao, views):
self.titulo = titulo
self.duracao = duracao
self.views = views
Esse código define a classe Video com um método construtor __init__, que faz a criação dos
atributos de título, duração e views da maneira correta.

Vinicius precisa criar um objeto da classe Mesa para uma nova cliente chamada
"Lais", que possui o número da mesa 1234, com a capacidade de 6 pessoas e
encontra-se vazia. Como ele deve fazer isso usando o código que ele escreveu?
 Alternativa correta
Lais = Mesa(numero=1234, capacidade=6, ocupada=False)
Ela cria um objeto da classe Mesa chamado Lais, passando os valores 1234, 6 e False
como argumentos para os parâmetros número, capacidade, e ocupada,
respectivamente. Dessa forma, o objeto Lais será inicializado com esses valores.

28
O parâmetro self é uma convenção usada nas definições de métodos de uma classe, que
representa a própria instância da classe. No entanto, ao criar um objeto da classe Mesa, não é
necessário passar o parâmetro self. O parâmetro self é automaticamente preenchido pelo Python
quando o método é chamado em um objeto.

Class Conta(nome,saldo,limite)
conta= Conta(“Pedro”,55,2000)
conta.saldo
55
Conta.nome
Pedro

O diagrama da classe Conta contém novos dados: os

métodos extrato(), deposita(), saca() foram incluídos juntos com seus
parâmetros. Normalmente, não incluímos a função construtora __init__,
considerando que ela é chamada de forma implícita.

29
Depois, criamos a classe Conta, usamos parâmetros, dentro da referência conta —
como vemos na segunda parte do diagrama. O resultado é o objeto Conta criado
em memória, com os parâmetros passados para a função construtora, como é
ilustrado na parte verde do diagrama.

Quando falamos anteriormente sobre atributos, mostramos que as referências são

utilizadas para acessar o objeto e imprimir um valor. Vimos que o
método extrato() pode ser utilizado para impressão de valores, como
em conta.extrato(). Desta vez, a referência foi usada para a chamada do método,
assim o objeto será passado automaticamente.

Em algumas linguagens como Java, a palavra private define o atributo como

privado e é chamado como modificador de visibilidade. Porém, em Python, foi
convencionado o uso __. Com isso, nós renomeamos os atributos seguindo uma
nomenclatura especial, por exemplo, numero passou a se chamar __numero.

30
Nós continuamos a ter acesso aos atributos, ainda que eles tenham mudado de
nome — o Python adicionou a classe antecedido por _. Ao
escrevermos conta._Conta__limite, o Python informará ao desenvolvedor que
o atributo __saldo não deve ser acessado.

O Python avisa que o atributo foi criado para ser usado dentro da classe, por meio
dos métodos. Porém, continuaremos a ter acesso aos valores. Mas se o
desenvolvedor decidir acessar o atributo igualmente, ele será alertado de que está
fazendo algo inapropriado, ou seja, está "brincando com fogo".

A ação de tornar privado o acesso aos atributos, no mundo Orientado a Objetos,

chamamos de encapsulamento. Com isso, definimos que o acesso deve ocorrer
apenas por meio dos métodos.

O prefixo __ indica que o atributo foi criado para ser usado dentro da classe, por meio
dos métodos, o tornando privado.
O encapsulamento refere-se ao ato de tornar os atributos privados e permitir seu acesso apenas
por meio dos métodos da classe, usando o prefixo __.

Atributos:
Com o uso do return, sempre nos será retornado o valor de um atributo.
Escrevemos métodos específicos que nos devolvem os dados solicitados. É comum
utilizarmos funcionalidades como estas para gerar relatórios, que nos mostre os
dados principais da conta. Por serem recorrentes, existe uma nomenclatura padrão
para esses métodos: getters (que nos dão um dado). Ou seja, a forma mais
apropriada de nomear os métodos seria usando o nome get.

def transfere(self, valor, destino):

self.saca(valor)
destino.deposita(valor)

def get_saldo(self):
return self.__saldo

def get_titular(self):

31
 return self.__titular

O uso do getters é um dos primeiros conceitos aprendidos pelos desenvolvedores

Java. Além desses métodos usados apenas para retornar, existem aqueles
que modificam. No caso, falamos dos setters.
Nós já temos métodos para acessar saldo, mas ainda temos que criar as formas de
trabalhar com limite. O objetivo é podermos aumentar o limite por meio
de set_limite().

def set_limite(self, limite):

self.__limite = limite

Aqui foram criados 3 construtores, o construtor raiz, com o __init__, e 2

construtores com atributos de nome, porém um com o recurso get.

Método sacar

32
def pode_sacar(self, valor_a_sacar):
valor_disponivel_a_sacar = self.__saldo + self.__limite
return valor_a_sacar <= valor_disponivel_a_sacar

def saca(self, valor):

if(self.pode_sacar(valor)):
self.__saldo -= valor
else:
print("O valor {} passou o limite".format(valor))

class Conta:

def __init__(self, numero, titular, saldo, limite):

print("Construindo objeto ... {}".format(self))
self.__numero = numero
self.__titular = titular
self.__saldo = saldo
self.__limite = limite
self.__codigo_banco = "001"

@staticmethod
def codigos_bancos():
return {'BB': '001', 'Caixa': '104', 'Bradesco':'237'}

Colocamos a chamada para o método dentro de uma variável. Outra maneira de

acessarmos um código específico é por meio de colchetes ([]):
>>> codigos['BB']
'001'
>>> codigos['Caixa']
'104'
. Orientação a Objetos é um dos paradigmas mais utilizados entre as linguagens de
programação.

Existem linguagens que continuam sendo procedurais, como linguagem C, assim

como outros paradigmas funcionais. Inclusive, em alguns casos, os dois começam
a misturar.

É possível afirmar que o paradigma OO domina o mercado de desenvolvimento.

Isto significa que se você tem uma boa base de OO vista no curso de Python,
também já terá aprendido sobre Java, PHP, C++, além de outras linguagens que
seguem o mesmo paradigma.

33
Podemos perceber isso, comparando o arquivo conta.py e o Conta.java. A
diferença entre os dois são os detalhes da sintaxe, mas o paradigma é o mesmo. Por
exemplo, os dois terão uma classe Conta, que em Java está assim:
class Conta {

//atributos
private int numero;
private String titular;
private double saldo;
private double limite;

//construtor
Conta(int numero, String titular, double saldo, double limite) {
this.numero = numero;
this.titular = titular;
this.saldo = saldo;
this.limite = limite;
}
}

class Conta:

def __init__(self, numero, titular, saldo, limite):

print("Construindo objeto ... {}".format(self))
self.__numero = numero
self.__titular = titular
self.__saldo = saldo
self.__limite = limite

No entanto, a principal diferença é a parte superior no arquivo Conta.java, em

que precisamos definir os atributos explicitamente e especificamos que eles são
privados. No conta.python, usamos a convenção __ para fazer o mesmo. Tanto
no Python, quanto no Java, existem formas de acessar um atributo, mesmo que
definindo como privado.
Se seguirmos comparando os dois arquivos, veremos que ambos têm o
método extrato(), mas o Java não receberá self.

Mas também existe o self no mundo Java: this, que é disponibilizado

implicitamente, mesmo não estando declarado. Veremos que o uso do . também é
correspondente, assim como os métodos privados.
Vemos em conta.py, que definimos as propriedades para acessar o saldo. No
mundo Java, escrevemos um método para cada ação, como foi feito
no getSaldo() de Conta.java — que precisa
do getTitular(), getNumero() e getLimite().

Em Java, ou utilizamos a tipagem estática, ou definimos o tipo da variável.

34
Perceba que quando aprendemos sobre o paradigma Orientado a Objetos, podemos
aplicar o conceito em diversas linguagens, porque ele é seguido da mesma forma,
mudando apenas as sintaxes específicas de cada linguagem.

SELF- PYTHON/ THIS- JAVA

35
Conta contaDoNico = new Conta(123, "Nico", 55.5, 1000.0);
contaDoNico.deposita(100.0);

Criagem de objeto em java( tipagem estática)

REVISAO
A classe é a menor unidade de organização no mundo OO. Colocamos os
elementos dentro, com os referentes de atributos e os diferentes métodos.
Colocamos dentro da classe, tudo o que está relacionado a ela. No caso,
os atributos relacionados com a classe Conta são:
 numero
 titular
 saldo
 limite
Os métodos relacionados são:
 extrato(self)
 deposita(self, valor)
 saca(self, valor)

Isto significa que evitaremos colocar na Conta o código relacionado com impostos
da nota fiscal, porque as duas coisas não estão relacionadas. Seria mais apropriado
criar a classe notaFiscal e adicionar o código relacionado.
Vimos como escrever uma classe no mundo Python, adicionamos um construtor e,
além disso, mostramos como ele é executado. Usamos o nome da classe, depois,
passamos os parâmetros como vemos no conteúdo do quadro azul do diagrama:
conta = Conta(123, "Nico", 55.5, 1000.0)
conta.extrato()
conta.deposita(100.0)
conta.saldo

36
E o resultado será um objeto:
objeto Conta

numero = 123
titular = "Nico"
saldo = 55.5
limite = 1000.0

A responsabilidade de criar o objeto fica por conta do Python. Sabemos que um

espaço é alocado para representar os atributos e o resultado da execução devolve a
referência.

Essa referência sabe onde está guardado o objeto. Tendo esse endereço, podemos
interagir com a classe, trabalhando com o objeto. Ou seja, quando
escrevemos conta.extrato() vai executar o elemento do extrato. Com ele,
acessaremos o objeto por meio do self.

o self é uma referência que sempre assume o valor da referência que fez a
chamada. Por exemplo, se a referência é conta, o self será um equivalente na linha
em que for utilizado: deposita(self, valor).

No arquivo conta.py, implementamos vários métodos,

como extrato() e deposita(), mostramos ainda como tornar um método
privado. Ao adicionarmos os dois uderscores (__) como em __pode_sacar(), o
desenvolvedor é alertado que só deve utilizá-lo dentro da classe Conta.

Criamos atributos privados usando a mesma nomenclatura,

como __numero e __titular.

Os métodos podem crescer e ficar ainda maiores e mais complexos, mas para quem
faz as chamadas do deposita(), a quantidade de linhas de um método é irrelevante.
def deposita(self, valor):
self._saldo += valor
Isto ocorre, porque o código está encapsulado

No curso, falamos sobre propriedades (properties). Quando digitávamos no

console conta.saldo, parecia que acessávamos simplesmente um atributo, porque
não usamos parênteses dos métodos. Mas por baixos dos panos, o método anotado
com @property. Também temos properties que podem alterar os setters.

37
Uma classe pode ter diversos objetos. Usando a analogia da receita, ela pode ter
diversos elementos. Basta repetir a linha que constrói o objeto, passando os novos
valores.

Se temos um novo objeto de memória, teremos uma nova referência que guardará o
valor do endereço do objeto.

Mostramos que é possível zerar uma referência, com o uso do None.

conta = None
conta2 = None

Interpolação de string (básico)

print('''
░██████╗░█████╗░██████╗░░█████╗░██████╗░
███████╗██╗░░██╗██████╗░██████╗░███████╗░██████╗░██████╗
██╔════╝██╔══██╗██╔══██╗██╔══██╗██╔══██╗
██╔════╝╚██╗██╔╝██╔══██╗██╔══██╗██╔════╝██╔════╝██╔════╝
╚█████╗░███████║██████╦╝██║░░██║██████╔╝
█████╗░░░╚███╔╝░██████╔╝██████╔╝█████╗░░╚█████╗░╚█████╗░
░╚═══██╗██╔══██║██╔══██╗██║░░██║██╔══██╗
██╔══╝░░░██╔██╗░██╔═══╝░██╔══██╗██╔══╝░░░╚═══██╗░╚═══██╗
██████╔╝██║░░██║██████╦╝╚█████╔╝██║░░██║
███████╗██╔╝╚██╗██║░░░░░██║░░██║███████╗██████╔╝██████╔╝
╚═════╝░╚═╝░░╚═╝╚═════╝░░╚════╝░╚═╝░░╚═╝
╚══════╝╚═╝░░╚═╝╚═╝░░░░░╚═╝░░╚═╝╚══════╝╚═════╝░╚═════╝░
''')

print('1. Cadastrar restaurante')

print('2. Listar restaurante')
print('3. Ativar restaurante')
print('4. Sair\n')

opcao_escolhida = input('Escolha uma opção: ')

print(f'Você escolheu a opção {opcao_escolhida}')

print(f ...{})
você colocar um f dentro do print permita que vc coloque uma variável
dentro de uma string através das chaves

38
print('''Camiseta Unissex
Tamanho: P, M, G, GG
Material: 100% algodão
Cores disponíveis: Preto, Branco, Vermelho''')

As aspas triplas (''' ou """) são usadas para criar strings que abrangem várias linhas. Elas são úteis
quando você precisa incluir quebras de linha e manter o formato do texto.

DICIONARIOS
restaurantes = [{'nome':'Praça', 'categoria':'Japonesa', 'ativo':False},
{'nome':'Pizza Superma', 'categoria':'Pizza',
'ativo':True}]

dicionários dentro da nossa lista de restaurantes. Ou seja, cada um vai assumir o

valor de restaurante, então precisamos separar esses dicionários por vírgula (,).
Outro ponto é que, assim como a lista, cada uma dessas chaves ou valores pode
assumir tipos diferentes, podendo ser uma string, um inteiro, um decimal, e assim
por diante.

39