├── .env-example
├── .gitignore
├── .vscode
├── keybindings.json
├── launch.json
└── settings.json
├── aula1.py
├── aula10.py
├── aula100.py
├── aula101.py
├── aula102.py
├── aula103.py
├── aula104.py
├── aula105.py
├── aula106.py
├── aula107.py
├── aula108.py
├── aula109.py
├── aula11.py
├── aula110.py
├── aula111.py
├── aula112.py
├── aula113.py
├── aula114.py
├── aula115.py
├── aula116.py
├── aula116.txt
├── aula117.json
├── aula117.py
├── aula118.py
├── aula119.json
├── aula119.py
├── aula12.py
├── aula120.py
├── aula121.py
├── aula122.py
├── aula123.py
├── aula124.py
├── aula125.py
├── aula126.py
├── aula127.json
├── aula127_a.py
├── aula127_b.py
├── aula128.py
├── aula129.py
├── aula13.py
├── aula130.py
├── aula131.py
├── aula132.py
├── aula133.py
├── aula134.py
├── aula135.py
├── aula136.py
├── aula137.py
├── aula138.py
├── aula139.py
├── aula14.py
├── aula140.py
├── aula141
├── eletronico.py
├── log.py
├── log.txt
└── main.py
├── aula142.py
├── aula143.py
├── aula144.py
├── aula145.py
├── aula146.py
├── aula147.py
├── aula148.py
├── aula149.py
├── aula149.txt
├── aula15.py
├── aula150.py
├── aula150.txt
├── aula151.py
├── aula152.py
├── aula153.py
├── aula154.py
├── aula155.py
├── aula156
├── documentando_class.py
├── documentando_funcoes.py
├── main.py
├── uma_linha.py
└── varias_linhas.py
├── aula157.py
├── aula158
├── banco.py
├── contas.py
├── main.py
└── pessoas.py
├── aula159.py
├── aula16.py
├── aula160.py
├── aula161.py
├── aula162.py
├── aula163.py
├── aula164.py
├── aula165.py
├── aula166.py
├── aula167.py
├── aula168.py
├── aula169.py
├── aula17.py
├── aula170.py
├── aula171.py
├── aula172.py
├── aula173.py
├── aula174.py
├── aula175.json
├── aula175.py
├── aula176.py
├── aula177.json
├── aula177.py
├── aula178-ex.csv
├── aula178-gs.csv
├── aula178.py
├── aula179.csv
├── aula179.py
├── aula18.py
├── aula180.csv
├── aula180.py
├── aula181.py
├── aula182.py
├── aula183.py
├── aula183.txt
├── aula184.py
├── aula185.html
├── aula185.py
├── aula186.py
├── aula186_compactado.zip
├── aula186_descompactado
├── arquivo_0.txt
├── arquivo_1.txt
├── arquivo_2.txt
├── arquivo_3.txt
├── arquivo_4.txt
├── arquivo_5.txt
├── arquivo_6.txt
├── arquivo_7.txt
├── arquivo_8.txt
└── arquivo_9.txt
├── aula187.py
├── aula188.py
├── aula189.py
├── aula19.py
├── aula190_site
├── index.html
└── style.css
├── aula191.py
├── aula192.py
├── aula193
└── main.py
├── aula194.py
├── aula195-2.ipynb
├── aula195.ipynb
├── aula195.py
├── aula196.py
├── aula197
├── arquivos_novos
│ ├── MERGED.pdf
│ ├── X5.png
│ ├── page0.pdf
│ └── page1.pdf
├── main.py
└── pdfs_originais
│ └── R20230210.pdf
├── aula198.py
├── aula199
├── creating.py
├── reading.py
└── workbook.xlsx
├── aula2.py
├── aula20.py
├── aula200
├── new.JPG
├── main.py
└── original.JPG
├── aula201
├── aula0001.py
├── aula0002.py
├── aula0003.py
├── aula0004.py
├── aula0005.py
└── aula0006.py
├── aula202-calculadora
├── buttons.py
├── display.py
├── files
│ └── icon.png
├── info.py
├── main.py
├── main_window.py
├── styles.py
├── utils.py
└── variables.py
├── aula203-qtdesigner
├── src
│ ├── main_window.py
│ └── window.py
└── ui
│ ├── ui_window.py
│ └── window.ui
├── aula204
├── main.py
├── ui_workerui.py
└── workerui.ui
├── aula205
├── main.py
└── select.py
├── aula206
├── .env-example
├── docker-compose.yml
└── main.py
├── aula207_ola_django
├── base
│ ├── global
│ │ ├── base.html
│ │ └── partials
│ │ │ ├── head.html
│ │ │ ├── menu.html
│ │ │ └── postblock.html
│ └── static
│ │ └── global
│ │ └── css
│ │ └── style.css
├── blog
│ ├── __init__.py
│ ├── admin.py
│ ├── apps.py
│ ├── data.py
│ ├── migrations
│ │ └── __init__.py
│ ├── models.py
│ ├── templates
│ │ └── blog
│ │ │ ├── exemplo.html
│ │ │ ├── index.html
│ │ │ └── post.html
│ ├── tests.py
│ ├── urls.py
│ └── views.py
├── home
│ ├── __init__.py
│ ├── admin.py
│ ├── apps.py
│ ├── migrations
│ │ └── __init__.py
│ ├── models.py
│ ├── templates
│ │ └── home
│ │ │ └── index.html
│ ├── tests.py
│ ├── urls.py
│ └── views.py
├── manage.py
└── project
│ ├── __init__.py
│ ├── asgi.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
├── aula21.py
├── aula22.py
├── aula23.py
├── aula24.py
├── aula25.py
├── aula26.py
├── aula27.py
├── aula28.py
├── aula29.py
├── aula3.py
├── aula30.py
├── aula31.py
├── aula32.py
├── aula33.py
├── aula34.py
├── aula35.py
├── aula36.py
├── aula37.py
├── aula38.py
├── aula39.py
├── aula4.py
├── aula40.py
├── aula41.py
├── aula42.py
├── aula43.py
├── aula44.py
├── aula45.py
├── aula46.py
├── aula47.py
├── aula48.py
├── aula49.py
├── aula5.py
├── aula50.py
├── aula51.py
├── aula52.py
├── aula53.py
├── aula54.py
├── aula55.py
├── aula56.py
├── aula57.py
├── aula58.py
├── aula59.py
├── aula6.py
├── aula60.py
├── aula61.py
├── aula62.py
├── aula63.py
├── aula64.py
├── aula65.py
├── aula66.py
├── aula67.py
├── aula68.py
├── aula69.py
├── aula7.py
├── aula70.py
├── aula71.py
├── aula72.py
├── aula73.py
├── aula74.py
├── aula75.py
├── aula76.py
├── aula77.py
├── aula78.py
├── aula79.py
├── aula8.py
├── aula80.py
├── aula81.py
├── aula82.py
├── aula83.py
├── aula84.py
├── aula85.py
├── aula86.py
├── aula87.py
├── aula88.py
├── aula89.py
├── aula9.py
├── aula90.py
├── aula91.py
├── aula92.py
├── aula93.py
├── aula94.py
├── aula95.py
├── aula96.py
├── aula97.py
├── aula97_m.py
├── aula98.py
├── aula98_m.py
├── aula99.py
├── aula99_package
├── __init__.py
├── modulo.py
└── modulo_b.py
├── aula_186_diretorio_zip
├── arquivo_0.txt
├── arquivo_1.txt
├── arquivo_2.txt
├── arquivo_3.txt
├── arquivo_4.txt
├── arquivo_5.txt
├── arquivo_6.txt
├── arquivo_7.txt
├── arquivo_8.txt
└── arquivo_9.txt
├── dados
├── __init__.py
└── produtos_modulo.py
└── requirements.txt
/.env-example:
--------------------------------------------------------------------------------
1 | BD_USER="CHANGE-ME"
2 | BD_PASSWORD="CHANGE-ME"
3 | BD_PORT=CHANGE-ME
4 | BD_HOST="CHANGE-ME"
5 |
6 | FROM_EMAIL="CHANGE-ME"
7 | EMAIL_PASSWORD="CHANGE-ME"
--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
1 | {
2 | // Use IntelliSense to learn about possible attributes.
3 | // Hover to view descriptions of existing attributes.
4 | // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
5 | "version": "0.2.0",
6 | "configurations": [
7 | {
8 | "name": "Python: Arquivo Atual",
9 | "type": "python",
10 | "request": "launch",
11 | "program": "${file}",
12 | "console": "integratedTerminal",
13 | "justMyCode": true
14 | }
15 | ]
16 | }
17 |
--------------------------------------------------------------------------------
/aula1.py:
--------------------------------------------------------------------------------
1 | """
2 | DocString
3 | E escrever o que eu
4 | quiser
5 |
6 |
7 | asdfasdfd
8 | """
9 |
10 | ''' Usar para escrever suas notas '''
11 |
12 | # Permite escrever um comentário
13 | print(123) # Na frente
14 | # Abaixo
15 | print(456)
16 |
--------------------------------------------------------------------------------
/aula10.py:
--------------------------------------------------------------------------------
1 | concatenacao = 'Luiz' + ' ' + 'Otávio'
2 | print(concatenacao)
3 |
4 | a_dez_vezes = 'A' * 10
5 | tres_vezes_luiz = 3 * 'Luiz'
6 | print(a_dez_vezes)
7 | print(tres_vezes_luiz)
8 |
--------------------------------------------------------------------------------
/aula100.py:
--------------------------------------------------------------------------------
1 | import copy
2 |
3 | from dados import produtos
4 |
5 | # copy, sorted, produtos.sort
6 | # Exercícios
7 | # Aumente os preços dos produtos a seguir em 10%
8 | # Gere novos_produtos por deep copy (cópia profunda)
9 | novos_produtos = [
10 | {**p, 'preco': round(p['preco'] * 1.1, 2)}
11 | for p in copy.deepcopy(produtos)
12 | ]
13 |
14 | # print(*produtos, sep='\n')
15 | # print()
16 | # print(*novos_produtos, sep='\n')
17 |
18 | # Ordene os produtos por nome decrescente (do maior para menor)
19 | # Gere produtos_ordenados_por_nome por deep copy (cópia profunda)
20 | produtos_ordenados_por_nome = sorted(
21 | copy.deepcopy(produtos),
22 | key=lambda p: p['nome'],
23 | reverse=True
24 | )
25 | # print(*produtos, sep='\n')
26 | # print()
27 | # print(*produtos_ordenados_por_nome, sep='\n')
28 |
29 |
30 | # Ordene os produtos por preco crescente (do menor para maior)
31 | # Gere produtos_ordenados_por_preco por deep copy (cópia profunda)
32 | produtos_ordenados_por_preco = sorted(
33 | copy.deepcopy(produtos),
34 | key=lambda p: p['preco']
35 | )
36 |
37 | # FINAL
38 |
39 | print(*produtos, sep='\n')
40 | print()
41 | print(*novos_produtos, sep='\n')
42 | print()
43 | print(*produtos_ordenados_por_nome, sep='\n')
44 | print()
45 | print(*produtos_ordenados_por_preco, sep='\n')
46 |
--------------------------------------------------------------------------------
/aula101.py:
--------------------------------------------------------------------------------
1 | # Exercício - Adiando execução de funções
2 | def soma(x, y):
3 | return x + y
4 |
5 |
6 | def multiplica(x, y):
7 | return x * y
8 |
9 |
10 | def criar_funcao(funcao, x):
11 | def interna(y):
12 | return funcao(x, y)
13 | return interna
14 |
15 |
16 | soma_com_cinco = criar_funcao(soma, 5)
17 | multiplica_por_dez = criar_funcao(multiplica, 10)
18 |
19 | print(soma_com_cinco(10))
20 | print(multiplica_por_dez(10))
21 |
--------------------------------------------------------------------------------
/aula102.py:
--------------------------------------------------------------------------------
1 | # Variáveis livres + nonlocal (locals, globals)
2 | # print(globals())
3 | # def fora(x):
4 | # a = x
5 |
6 | # def dentro():
7 | # # print(locals())
8 |
9 | # return a
10 | # return dentro
11 |
12 |
13 | # dentro1 = fora(10)
14 | # dentro2 = fora(20)
15 |
16 | # print(dentro1())
17 | # print(dentro2())
18 | def concatenar(string_inicial):
19 | valor_final = string_inicial
20 |
21 | def interna(valor_a_concatenar=''):
22 | nonlocal valor_final
23 | valor_final += valor_a_concatenar
24 | return valor_final
25 | return interna
26 |
27 |
28 | c = concatenar('a')
29 | print(c('b'))
30 | print(c('c'))
31 | print(c('d'))
32 | final = c()
33 | print(final)
34 |
--------------------------------------------------------------------------------
/aula103.py:
--------------------------------------------------------------------------------
1 | # Funções decoradoras e decoradores
2 | # Decorar = Adicionar / Remover/ Restringir / Alterar
3 | # Funções decoradoras são funções que decoram outras funções
4 | # Decoradores são usados para fazer o Python
5 | # usar as funções decoradoras em outras funções.
6 |
7 | def criar_funcao(func):
8 | def interna(*args, **kwargs):
9 | print('Vou te decorar')
10 | for arg in args:
11 | e_string(arg)
12 | resultado = func(*args, **kwargs)
13 | print(f'O seu resultado foi {resultado}.')
14 | print('Ok, agora você foi decorada')
15 | return resultado
16 | return interna
17 |
18 |
19 | def inverte_string(string):
20 | return string[::-1]
21 |
22 |
23 | def e_string(param):
24 | if not isinstance(param, str):
25 | raise TypeError('param deve ser uma string')
26 |
27 |
28 | inverte_string_checando_parametro = criar_funcao(inverte_string)
29 | invertida = inverte_string_checando_parametro('123')
30 | print(invertida)
31 |
--------------------------------------------------------------------------------
/aula104.py:
--------------------------------------------------------------------------------
1 | # Funções decoradoras e decoradores
2 | # Decorar = Adicionar / Remover/ Restringir / Alterar
3 | # Funções decoradoras são funções que decoram outras funções
4 | # Decoradores são usados para fazer o Python
5 | # usar as funções decoradoras em outras funções.
6 | # Decoradores são "Syntax Sugar" (Açúcar sintático)
7 |
8 | def criar_funcao(func):
9 | def interna(*args, **kwargs):
10 | print('Vou te decorar')
11 | for arg in args:
12 | e_string(arg)
13 | resultado = func(*args, **kwargs)
14 | print(f'O seu resultado foi {resultado}.')
15 | print('Ok, agora você foi decorada')
16 | return resultado
17 | return interna
18 |
19 |
20 | @criar_funcao
21 | def inverte_string(string):
22 | print(f'{inverte_string.__name__}')
23 | return string[::-1]
24 |
25 |
26 | def e_string(param):
27 | if not isinstance(param, str):
28 | raise TypeError('param deve ser uma string')
29 |
30 |
31 | invertida = inverte_string('123')
32 | print(invertida)
33 |
--------------------------------------------------------------------------------
/aula105.py:
--------------------------------------------------------------------------------
1 | # Decoradores com parâmetros
2 | def fabrica_de_decoradores(a=None, b=None, c=None):
3 | def fabrica_de_funcoes(func):
4 | print('Decoradora 1')
5 |
6 | def aninhada(*args, **kwargs):
7 | print('Parâmetros do decorador, ', a, b, c)
8 | print('Aninhada')
9 | res = func(*args, **kwargs)
10 | return res
11 | return aninhada
12 | return fabrica_de_funcoes
13 |
14 |
15 | @fabrica_de_decoradores(1, 2, 3)
16 | def soma(x, y):
17 | return x + y
18 |
19 |
20 | decoradora = fabrica_de_decoradores()
21 | multiplica = decoradora(lambda x, y: x * y)
22 |
23 | dez_mais_cinco = soma(10, 5)
24 | dez_vezes_cinco = multiplica(10, 5)
25 | print(dez_mais_cinco)
26 | print(dez_vezes_cinco)
27 |
--------------------------------------------------------------------------------
/aula106.py:
--------------------------------------------------------------------------------
1 | # Ordem dos decoradores
2 | def parametros_decorador(nome):
3 | def decorador(func):
4 | print('Decorador:', nome)
5 |
6 | def sua_nova_funcao(*args, **kwargs):
7 | res = func(*args, **kwargs)
8 | final = f'{res} {nome}'
9 | return final
10 | return sua_nova_funcao
11 | return decorador
12 |
13 |
14 | @parametros_decorador(nome='5')
15 | @parametros_decorador(nome='4')
16 | @parametros_decorador(nome='3')
17 | @parametros_decorador(nome='2')
18 | @parametros_decorador(nome='1')
19 | def soma(x, y):
20 | return x + y
21 |
22 |
23 | dez_mais_cinco = soma(10, 5)
24 | print(dez_mais_cinco)
25 |
--------------------------------------------------------------------------------
/aula107.py:
--------------------------------------------------------------------------------
1 | # Exercício - Unir listas
2 | # Crie uma função zipper (como o zipper de roupas)
3 | # O trabalho dessa função será unir duas
4 | # listas na ordem.
5 | # Use todos os valores da menor lista.
6 | # Ex.:
7 | # ['Salvador', 'Ubatuba', 'Belo Horizonte']
8 | # ['BA', 'SP', 'MG', 'RJ']
9 | # Resultado
10 | # [('Salvador', 'BA'), ('Ubatuba', 'SP'), ('Belo Horizonte', 'MG')]
11 |
12 | # def zipper(l1, l2):
13 | # intervalo = min(len(l1), len(l2))
14 | # return [(l1[i], l2[i]) for i in range(intervalo)]
15 | from itertools import zip_longest
16 |
17 | l1 = ['Salvador', 'Ubatuba', 'Belo Horizonte']
18 | l2 = ['BA', 'SP', 'MG', 'RJ']
19 | print(list(zip(l1, l2)))
20 | print(list(zip_longest(l1, l2, fillvalue='SEM CIDADE')))
21 |
--------------------------------------------------------------------------------
/aula108.py:
--------------------------------------------------------------------------------
1 | # count é um iterador sem fim (itertools)
2 | from itertools import count
3 |
4 | c1 = count(step=8, start=8)
5 | r1 = range(8, 100, 8)
6 |
7 | print('c1', hasattr(c1, '__iter__'))
8 | print('c1', hasattr(c1, '__next__'))
9 | print('r1', hasattr(r1, '__iter__'))
10 | print('r1', hasattr(r1, '__next__'))
11 |
12 | print('count')
13 | for i in c1:
14 | if i >= 100:
15 | break
16 |
17 | print(i)
18 | print()
19 | print('range')
20 | for i in r1:
21 | print(i)
22 |
--------------------------------------------------------------------------------
/aula109.py:
--------------------------------------------------------------------------------
1 | # Combinations, Permutations e Product - Itertools
2 | # Combinação - Ordem não importa - iterável + tamanho do grupo
3 | # Permutação - Ordem importa
4 | # Produto - Ordem importa e repete valores únicos
5 | from itertools import combinations, permutations, product
6 |
7 |
8 | def print_iter(iterator):
9 | print(*list(iterator), sep='\n')
10 | print()
11 |
12 |
13 | pessoas = [
14 | 'João', 'Joana', 'Luiz', 'Letícia',
15 | ]
16 | camisetas = [
17 | ['preta', 'branca'],
18 | ['p', 'm', 'g'],
19 | ['masculino', 'feminino', 'unisex'],
20 | ['algodão', 'poliéster']
21 | ]
22 |
23 | print_iter(combinations(pessoas, 2))
24 | print_iter(permutations(pessoas, 2))
25 | print_iter(product(*camisetas))
26 |
--------------------------------------------------------------------------------
/aula11.py:
--------------------------------------------------------------------------------
1 | # 1. (n + n)
2 | # 2. **
3 | # 3. * / // %
4 | # 4. + -
5 | conta_1 = (1 + int(0.5 + 0.5)) ** (5 + 5)
6 | print(conta_1)
7 |
--------------------------------------------------------------------------------
/aula110.py:
--------------------------------------------------------------------------------
1 | # groupby - agrupando valores (itertools)
2 | from itertools import groupby
3 |
4 | alunos = [
5 | {'nome': 'Luiz', 'nota': 'A'},
6 | {'nome': 'Letícia', 'nota': 'B'},
7 | {'nome': 'Fabrício', 'nota': 'A'},
8 | {'nome': 'Rosemary', 'nota': 'C'},
9 | {'nome': 'Joana', 'nota': 'D'},
10 | {'nome': 'João', 'nota': 'A'},
11 | {'nome': 'Eduardo', 'nota': 'B'},
12 | {'nome': 'André', 'nota': 'A'},
13 | {'nome': 'Anderson', 'nota': 'C'},
14 | ]
15 |
16 |
17 | def ordena(aluno):
18 | return aluno['nota']
19 |
20 |
21 | alunos_agrupados = sorted(alunos, key=ordena)
22 | grupos = groupby(alunos_agrupados, key=ordena)
23 |
24 | for chave, grupo in grupos:
25 | print(chave)
26 | for aluno in grupo:
27 | print(aluno)
28 |
--------------------------------------------------------------------------------
/aula111.py:
--------------------------------------------------------------------------------
1 | # map, partial, GeneratorType e esgotamento de Iterators
2 |
3 | from functools import partial
4 | from types import GeneratorType
5 |
6 |
7 | # map - para mapear dados
8 | def print_iter(iterator):
9 | print(*list(iterator), sep='\n')
10 | print()
11 |
12 |
13 | produtos = [
14 | {'nome': 'Produto 5', 'preco': 10.00},
15 | {'nome': 'Produto 1', 'preco': 22.32},
16 | {'nome': 'Produto 3', 'preco': 10.11},
17 | {'nome': 'Produto 2', 'preco': 105.87},
18 | {'nome': 'Produto 4', 'preco': 69.90},
19 | ]
20 |
21 |
22 | def aumentar_porcentagem(valor, porcentagem):
23 | return round(valor * porcentagem, 2)
24 |
25 |
26 | aumentar_dez_porcento = partial(
27 | aumentar_porcentagem,
28 | porcentagem=1.1
29 | )
30 |
31 | # novos_produtos = [
32 | # {**p,
33 | # 'preco': aumentar_dez_porcento(p['preco'])}
34 | # for p in produtos
35 | # ]
36 |
37 |
38 | def muda_preco_de_produtos(produto):
39 | return {
40 | **produto,
41 | 'preco': aumentar_dez_porcento(
42 | produto['preco']
43 | )
44 | }
45 |
46 |
47 | novos_produtos = list(map(
48 | muda_preco_de_produtos,
49 | produtos
50 | ))
51 |
52 |
53 | print_iter(produtos)
54 | print_iter(novos_produtos)
55 |
56 | print(
57 | list(map(
58 | lambda x: x * 3,
59 | [1, 2, 3, 4]
60 | ))
61 | )
62 |
--------------------------------------------------------------------------------
/aula112.py:
--------------------------------------------------------------------------------
1 | # filter é um filtro funcional
2 | def print_iter(iterator):
3 | print(*list(iterator), sep='\n')
4 | print()
5 |
6 |
7 | produtos = [
8 | {'nome': 'Produto 5', 'preco': 10.00},
9 | {'nome': 'Produto 1', 'preco': 22.32},
10 | {'nome': 'Produto 3', 'preco': 10.11},
11 | {'nome': 'Produto 2', 'preco': 105.87},
12 | {'nome': 'Produto 4', 'preco': 69.90},
13 | ]
14 |
15 |
16 | def filtrar_preco(produto):
17 | return produto['preco'] > 100
18 |
19 |
20 | # novos_produtos = [
21 | # p for p in produtos
22 | # if p['preco'] > 100
23 | # ]
24 | novos_produtos = filter(
25 | # lambda produto: produto['preco'] > 100,
26 | filtrar_preco,
27 | produtos
28 | )
29 |
30 |
31 | print_iter(produtos)
32 | print_iter(novos_produtos)
33 |
--------------------------------------------------------------------------------
/aula113.py:
--------------------------------------------------------------------------------
1 | # reduce - faz a redução de um iterável em um valor
2 | from functools import reduce
3 |
4 | produtos = [
5 | {'nome': 'Produto 5', 'preco': 10},
6 | {'nome': 'Produto 1', 'preco': 22},
7 | {'nome': 'Produto 3', 'preco': 2},
8 | {'nome': 'Produto 2', 'preco': 6},
9 | {'nome': 'Produto 4', 'preco': 4},
10 | ]
11 |
12 |
13 | # def funcao_do_reduce(acumulador, produto):
14 | # print('acumulador', acumulador)
15 | # print('produto', produto)
16 | # print()
17 | # return acumulador + produto['preco']
18 |
19 |
20 | total = reduce(
21 | lambda ac, p: ac + p['preco'],
22 | produtos,
23 | 0
24 | )
25 |
26 | print('Total é', total)
27 |
28 |
29 | # total = 0
30 | # for p in produtos:
31 | # total += p['preco']
32 |
33 | # print(total)
34 |
35 | # print(sum([p['preco'] for p in produtos]))
36 |
--------------------------------------------------------------------------------
/aula114.py:
--------------------------------------------------------------------------------
1 | # Funções recursivas e recursividade
2 | # - funções que podem se chamar de volta
3 | # - úteis p/ dividir problemas grandes em partes menores
4 | # Toda função recursiva deve ter:
5 | # - Um problema que possa ser dividido em partes menores
6 | # - Um caso recursivo que resolve o pequeno problema
7 | # - Um caso base que para a recursão
8 | # - fatorial - n! = 5! = 5 * 4 * 3 * 2 * 1 = 120
9 | # https://brasilescola.uol.com.br/matematica/fatorial.htm
10 | # import sys
11 |
12 | # sys.setrecursionlimit(1004)
13 |
14 |
15 | # def recursiva(inicio=0, fim=4):
16 |
17 | # print(inicio, fim)
18 |
19 | # # Caso base
20 | # if inicio >= fim:
21 | # return fim
22 |
23 | # # Caso recursivo
24 | # # contar até chegar ao final
25 | # inicio += 1
26 | # return recursiva(inicio, fim)
27 |
28 |
29 | # print(recursiva(0, 1001))
30 |
31 | def factorial(n):
32 | if n <= 1:
33 | return 1
34 |
35 | return n * factorial(n - 1)
36 |
37 |
38 | print(factorial(5))
39 | print(factorial(10))
40 | print(factorial(100))
41 |
--------------------------------------------------------------------------------
/aula115.py:
--------------------------------------------------------------------------------
1 | # Ambientes virtuais em Python (venv)
2 | # Um ambiente virtual carrega toda a sua instalação
3 | # do Python para uma pasta no caminho escolhido.
4 | # Ao ativar um ambiente virtual, a instalação do
5 | # ambiente virtual será usada.
6 | # venv é o módulo que vamos usar para
7 | # criar ambientes virtuais.
8 | # Você pode dar o nome que preferir para um
9 | # ambiente virtual, mas os mais comuns são:
10 | # venv env .venv .env
11 | #
12 | # Como criar ambientes virtuais
13 | # Abra a pasta do seu projeto no terminal
14 | # e digite:
15 | # python -m venv venv
16 | #
17 | # Ativando e desativando meu ambiente virtual
18 | # Windows: .\venv\Scripts\activate
19 | # Linux e Mac: source venv/bin/activate
20 | # Desativar: deactivate
21 | #
22 | # pip - instalando pacotes e bibliotecas
23 | # Instalar última versão:
24 | # pip install nome_pacote
25 | # Instalar versão precisa
26 | # (tem outras formas também não mencionadas)
27 | # pip install nome_pacote==0.0.0
28 | # Desinstalar pacote
29 | # pip uninstall nome_pacote
30 | # Congelar (ver pacotes)
31 | # pip freeze
32 | #
33 | # Criando e usando um requirements.txt
34 | # pip freeze > requirements.txt
35 | # Instalando tudo do requirements.txt
36 | # pip install -r requirements.txt
37 |
--------------------------------------------------------------------------------
/aula116.txt:
--------------------------------------------------------------------------------
1 | Atenção
2 | Linha 1
3 | Linha 2
4 | Linha 3
5 | Linha 4
6 |
--------------------------------------------------------------------------------
/aula117.json:
--------------------------------------------------------------------------------
1 | {
2 | "nome": "Luiz Otávio 2",
3 | "sobrenome": "Miranda",
4 | "enderecos": [
5 | {
6 | "rua": "R1",
7 | "numero": 32
8 | },
9 | {
10 | "rua": "R2",
11 | "numero": 55
12 | }
13 | ],
14 | "altura": 1.8,
15 | "numeros_preferidos": [
16 | 2,
17 | 4,
18 | 6,
19 | 8,
20 | 10
21 | ],
22 | "dev": true,
23 | "nada": null
24 | }
--------------------------------------------------------------------------------
/aula117.py:
--------------------------------------------------------------------------------
1 | import json
2 |
3 | pessoa = {
4 | 'nome': 'Luiz Otávio 2',
5 | 'sobrenome': 'Miranda',
6 | 'enderecos': [
7 | {'rua': 'R1', 'numero': 32},
8 | {'rua': 'R2', 'numero': 55},
9 | ],
10 | 'altura': 1.8,
11 | 'numeros_preferidos': (2, 4, 6, 8, 10),
12 | 'dev': True,
13 | 'nada': None,
14 | }
15 |
16 | with open('aula117.json', 'w', encoding='utf8') as arquivo:
17 | json.dump(
18 | pessoa,
19 | arquivo,
20 | ensure_ascii=False,
21 | indent=2,
22 | )
23 |
24 | with open('aula117.json', 'r', encoding='utf8') as arquivo:
25 | pessoa = json.load(arquivo)
26 | # print(pessoa)
27 | # print(type(pessoa))
28 | print(pessoa['nome'])
29 |
--------------------------------------------------------------------------------
/aula118.py:
--------------------------------------------------------------------------------
1 | # Problema dos parâmetros mutáveis em funções Python
2 | def adiciona_clientes(nome, lista=None):
3 | if lista is None:
4 | lista = []
5 | lista.append(nome)
6 | return lista
7 |
8 |
9 | cliente1 = adiciona_clientes('luiz')
10 | adiciona_clientes('Joana', cliente1)
11 | adiciona_clientes('Fernando', cliente1)
12 | cliente1.append('Edu')
13 |
14 | cliente2 = adiciona_clientes('Helena')
15 | adiciona_clientes('Maria', cliente2)
16 |
17 | cliente3 = adiciona_clientes('Moreira')
18 | adiciona_clientes('Vivi', cliente3)
19 |
20 | print(cliente1)
21 | print(cliente2)
22 | print(cliente3)
23 |
--------------------------------------------------------------------------------
/aula119.json:
--------------------------------------------------------------------------------
1 | [
2 | "tomar café",
3 | "ler"
4 | ]
--------------------------------------------------------------------------------
/aula12.py:
--------------------------------------------------------------------------------
1 | nome = 'Luiz Otávio'
2 | altura = 1.80
3 | peso = 95
4 | imc = peso / altura ** 2
5 |
6 | print(nome, 'tem', altura, 'de altura,',)
7 | print('pesa', peso, 'quilos e seu imc é',)
8 | print(imc)
9 |
10 | # Luiz Otávio tem 1.80 de altura,
11 | # pesa 95 quilos e seu IMC é
12 | # 29.320987654320987
13 |
--------------------------------------------------------------------------------
/aula120.py:
--------------------------------------------------------------------------------
1 | # Introdução ao método __init__ (inicializador de atributos)
2 | # As classes geram novos objetos (instâncias) que
3 | # podem ter seus próprios atributos e métodos.
4 | # Os objetos gerados pela classe podem usar seus dados
5 | # internos para realizar várias ações.
6 | # Por convenção, usamos PascalCase para nomes de
7 | # classes.
8 | # string = 'Luiz' # str
9 | # print(string.upper())
10 | # print(isinstance(string, str))
11 | class Pessoa:
12 | def __init__(self, nome, sobrenome):
13 | self.nome = nome
14 | self.sobrenome = sobrenome
15 |
16 |
17 | p1 = Pessoa('Luiz', 'Otávio')
18 | # p1.nome = 'Luiz'
19 | # p1.sobrenome = 'Otávio'
20 |
21 | p2 = Pessoa('Maria', 'Joana')
22 | # p2.nome = 'Maria'
23 | # p2.sobrenome = 'Joana'
24 |
25 | print(p1.nome)
26 | print(p1.sobrenome)
27 |
28 | print(p2.nome)
29 | print(p2.sobrenome)
30 |
--------------------------------------------------------------------------------
/aula121.py:
--------------------------------------------------------------------------------
1 | # Métodos em instâncias de classes Python
2 | # Hard coded - É algo que foi escrito diretamente no código
3 | class Carro:
4 | def __init__(self, nome):
5 | self.nome = nome
6 |
7 | def acelerar(self):
8 | print(f'{self.nome} está acelerando...')
9 |
10 |
11 | string = 'Luiz'
12 | print(string.upper())
13 |
14 | fusca = Carro('Fusca')
15 | print(fusca.nome)
16 | fusca.acelerar()
17 |
18 | celta = Carro(nome='Celta')
19 | print(celta.nome)
20 | celta.acelerar()
21 |
--------------------------------------------------------------------------------
/aula122.py:
--------------------------------------------------------------------------------
1 | # Entendendo self em classes Python
2 | # Classe - Molde (geralmente sem dados)
3 | # Instância da class (objeto) - Tem os dados
4 | # Uma classe pode gerar várias instâncias.
5 | # Na classe o self é a própria instância.
6 | class Carro:
7 | def __init__(self, nome):
8 | self.nome = nome
9 |
10 | def acelerar(self):
11 | print(f'{self.nome} está acelerando...')
12 |
13 |
14 | fusca = Carro('Fusca')
15 | fusca.acelerar()
16 | Carro.acelerar(fusca)
17 | # print(fusca.nome)
18 | # fusca.acelerar()
19 |
20 | celta = Carro(nome='Celta')
21 | celta.acelerar()
22 | Carro.acelerar(celta)
23 | # print(celta.nome)
24 |
--------------------------------------------------------------------------------
/aula123.py:
--------------------------------------------------------------------------------
1 | # Escopo da classe e de métodos da classe
2 | class Animal:
3 | # nome = 'Leão'
4 |
5 | def __init__(self, nome):
6 | self.nome = nome
7 |
8 | variavel = 'valor'
9 | print(variavel)
10 |
11 | def comendo(self, alimento):
12 | return f'{self.nome} está comando {alimento}'
13 |
14 | def executar(self, *args, **kwargs):
15 | return self.comendo(*args, **kwargs)
16 |
17 |
18 | leao = Animal(nome='Leão')
19 | print(leao.nome)
20 | print(leao.executar('maçã'))
21 |
--------------------------------------------------------------------------------
/aula124.py:
--------------------------------------------------------------------------------
1 | # Mantendo estados dentro da classe
2 | class Camera:
3 | def __init__(self, nome, filmando=False):
4 | self.nome = nome
5 | self.filmando = filmando
6 |
7 | def filmar(self):
8 | if self.filmando:
9 | print(f'{self.nome} JÁ está filmando...')
10 | return
11 |
12 | print(f'{self.nome} está filmando...')
13 | self.filmando = True
14 |
15 | def parar_filmar(self):
16 | if not self.filmando:
17 | print(f'{self.nome} NÃO está filmando...')
18 | return
19 |
20 | print(f'{self.nome} está parando de filmar...')
21 | self.filmando = False
22 |
23 | def fotografar(self):
24 | if self.filmando:
25 | print(f'{self.nome} não pode fotografar filmando')
26 | return
27 |
28 | print(f'{self.nome} está fotografando...')
29 |
30 |
31 | c1 = Camera('Canon')
32 | c2 = Camera('Sony')
33 |
34 | c1.filmar()
35 | c1.filmar()
36 | c1.fotografar()
37 | c1.parar_filmar()
38 | c1.fotografar()
39 |
40 | print()
41 |
42 | c2.parar_filmar()
43 | c2.filmar()
44 | c2.filmar()
45 | c2.fotografar()
46 | c2.parar_filmar()
47 | c2.fotografar()
48 |
--------------------------------------------------------------------------------
/aula125.py:
--------------------------------------------------------------------------------
1 | # Atributos de classe
2 | class Pessoa:
3 | ano_atual = 2022
4 |
5 | def __init__(self, nome, idade):
6 | self.nome = nome
7 | self.idade = idade
8 |
9 | def get_ano_nascimento(self):
10 | return Pessoa.ano_atual - self.idade
11 |
12 |
13 | p1 = Pessoa('João', 35)
14 | p2 = Pessoa('Helena', 12)
15 |
16 | print(Pessoa.ano_atual)
17 | # Pessoa.ano_atual = 1
18 |
19 | print(p1.get_ano_nascimento())
20 | print(p2.get_ano_nascimento())
21 |
--------------------------------------------------------------------------------
/aula126.py:
--------------------------------------------------------------------------------
1 | # __dict__ e vars para atributos de instância
2 | class Pessoa:
3 | ano_atual = 2022
4 |
5 | def __init__(self, nome, idade):
6 | self.nome = nome
7 | self.idade = idade
8 |
9 | def get_ano_nascimento(self):
10 | return Pessoa.ano_atual - self.idade
11 |
12 |
13 | dados = {'nome': 'João', 'idade': 35}
14 | p1 = Pessoa(**dados)
15 | # p1.nome = 'EITA'
16 | # print(p1.idade)
17 | # p1.__dict__['outra'] = 'coisa'
18 | # p1.__dict__['nome'] = 'EITA'
19 | # del p1.__dict__['nome']
20 | # print(p1.__dict__)
21 | # print(vars(p1))
22 | # print(p1.outra)
23 | # print(p1.nome)
24 | print(vars(p1))
25 | print(p1.nome)
26 |
--------------------------------------------------------------------------------
/aula127.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "nome": "João",
4 | "idade": 33
5 | },
6 | {
7 | "nome": "Helena",
8 | "idade": 21
9 | },
10 | {
11 | "nome": "Joana",
12 | "idade": 11
13 | }
14 | ]
--------------------------------------------------------------------------------
/aula127_a.py:
--------------------------------------------------------------------------------
1 | # Exercício - Salve sua classe em JSON
2 | # Salve os dados da sua classe em JSON
3 | # e depois crie novamente as instâncias
4 | # da classe com os dados salvos
5 | # Faça em arquivos separados.
6 | import json
7 |
8 | CAMINHO_ARQUIVO = 'aula127.json'
9 |
10 |
11 | class Pessoa:
12 | def __init__(self, nome, idade):
13 | self.nome = nome
14 | self.idade = idade
15 |
16 |
17 | p1 = Pessoa('João', 33)
18 | p2 = Pessoa('Helena', 21)
19 | p3 = Pessoa('Joana', 11)
20 | bd = [vars(p1), p2.__dict__, vars(p3)]
21 |
22 |
23 | def fazer_dump():
24 | with open(CAMINHO_ARQUIVO, 'w') as arquivo:
25 | print('FAZENDO DUMP')
26 | json.dump(bd, arquivo, ensure_ascii=False, indent=2)
27 |
28 |
29 | if __name__ == '__main__':
30 | print('ELE É O __main__')
31 | fazer_dump()
32 |
--------------------------------------------------------------------------------
/aula127_b.py:
--------------------------------------------------------------------------------
1 | import json
2 |
3 | from aula127_a import CAMINHO_ARQUIVO, Pessoa, fazer_dump
4 |
5 | # fazer_dump()
6 |
7 | with open(CAMINHO_ARQUIVO, 'r') as arquivo:
8 | pessoas = json.load(arquivo)
9 | p1 = Pessoa(**pessoas[0])
10 | p2 = Pessoa(**pessoas[1])
11 | p3 = Pessoa(**pessoas[2])
12 |
13 | print(p1.nome, p1.idade)
14 | print(p2.nome, p2.idade)
15 | print(p3.nome, p3.idade)
16 |
--------------------------------------------------------------------------------
/aula128.py:
--------------------------------------------------------------------------------
1 | # Métodos de classe + factories (fábricas)
2 | # São métodos onde "self" será "cls", ou seja,
3 | # ao invés de receber a instância no primeiro
4 | # parâmetro, receberemos a própria classe.
5 | class Pessoa:
6 | ano = 2023 # atributo de classe
7 |
8 | def __init__(self, nome, idade):
9 | self.nome = nome
10 | self.idade = idade
11 |
12 | @classmethod
13 | def metodo_de_classe(cls):
14 | print('Hey')
15 |
16 | @classmethod
17 | def criar_com_50_anos(cls, nome):
18 | return cls(nome, 50)
19 |
20 | @classmethod
21 | def criar_sem_nome(cls, idade):
22 | return cls('Anônima', idade)
23 |
24 |
25 | p1 = Pessoa('João', 34)
26 | p2 = Pessoa.criar_com_50_anos('Helena')
27 | p3 = Pessoa('Anônima', 23)
28 | p4 = Pessoa.criar_sem_nome(25)
29 | print(p2.nome, p2.idade)
30 | print(p3.nome, p3.idade)
31 | print(p4.nome, p4.idade)
32 | # print(Pessoa.ano)
33 | # Pessoa.metodo_de_classe()
34 |
--------------------------------------------------------------------------------
/aula129.py:
--------------------------------------------------------------------------------
1 | # @staticmethod (métodos estáticos) são inúteis em Python =)
2 | # Métodos estáticos são métodos que estão dentro da
3 | # classe, mas não tem acesso ao self nem ao cls.
4 | # Em resumo, são funções que existem dentro da sua
5 | # classe.
6 | class Classe:
7 | @staticmethod
8 | def funcao_que_esta_na_classe(*args, **kwargs):
9 | print('Oi', args, kwargs)
10 |
11 |
12 | def funcao(*args, **kwargs):
13 | print('Oi', args, kwargs)
14 |
15 |
16 | c1 = Classe()
17 | c1.funcao_que_esta_na_classe(1, 2, 3)
18 | funcao(1, 2, 3)
19 | Classe.funcao_que_esta_na_classe(nomeado=1)
20 | funcao(nomeado=1)
21 |
--------------------------------------------------------------------------------
/aula13.py:
--------------------------------------------------------------------------------
1 | nome = 'Luiz Otávio'
2 | altura = 1.80
3 | peso = 95
4 | imc = peso / altura ** 2
5 |
6 | "f-strings"
7 | linha_1 = f'{nome} tem {altura:.2f} de altura,'
8 | linha_2 = f'pesa {peso} quilos e seu imc é'
9 | linha_3 = f'{imc:.2f}'
10 |
11 | print(linha_1)
12 | print(linha_2)
13 | print(linha_3)
14 |
15 | # Luiz Otávio tem 1.80 de altura,
16 | # pesa 95 quilos e seu IMC é
17 | # 29.320987654320987
18 |
--------------------------------------------------------------------------------
/aula130.py:
--------------------------------------------------------------------------------
1 | # method vs @classmethod vs @staticmethod
2 | # method - self, método de instância
3 | # @classmethod - cls, método de classe
4 | # @staticmethod - método estático (❌self, ❌cls)
5 | class Connection:
6 | def __init__(self, host='localhost'):
7 | self.host = host
8 | self.user = None
9 | self.password = None
10 |
11 | def set_user(self, user):
12 | self.user = user
13 |
14 | def set_password(self, password):
15 | self.password = password
16 |
17 | @classmethod
18 | def create_with_auth(cls, user, password):
19 | connection = cls()
20 | connection.user = user
21 | connection.password = password
22 | return connection
23 |
24 | @staticmethod
25 | def log(msg):
26 | print('LOG:', msg)
27 |
28 |
29 | def connection_log(msg):
30 | print('LOG:', msg)
31 |
32 |
33 | # c1 = Connection()
34 | c1 = Connection.create_with_auth('luiz', '1234')
35 | # c1.set_user('luiz')
36 | # c1.set_password('123')
37 | print(Connection.log('Essa é a mensagem de log'))
38 | print(c1.user)
39 | print(c1.password)
40 |
--------------------------------------------------------------------------------
/aula131.py:
--------------------------------------------------------------------------------
1 | # @property - um getter no modo Pythônico
2 | # getter - um método para obter um atributo
3 | # cor -> get_cor()
4 | # modo pythônico - modo do Python de fazer coisas
5 | # @property é uma propriedade do objeto, ela
6 | # é um método que se comporta como um
7 | # atributo 🤯 🤯 🤯
8 | # Geralmente é usada nas seguintes situações:
9 | # - como getter
10 | # - p/ evitar quebrar código cliente
11 | # - p/ habilitar setter
12 | # - p/ executar ações ao obter um atributo
13 | # Código cliente - é o código que usa seu código
14 | class Caneta:
15 | def __init__(self, cor):
16 | self.cor_tinta = cor
17 |
18 | @property
19 | def cor(self):
20 | print('PROPERTY')
21 | return self.cor_tinta
22 |
23 | @property
24 | def cor_tampa(self):
25 | return 123456
26 |
27 | ###########################
28 |
29 |
30 | caneta = Caneta('Azul')
31 | print(caneta.cor)
32 | print(caneta.cor)
33 | print(caneta.cor)
34 | print(caneta.cor)
35 | print(caneta.cor)
36 | print(caneta.cor)
37 | print(caneta.cor_tampa)
38 |
39 | #####################################
40 |
41 | # class Caneta:
42 | # def __init__(self, cor):
43 | # self.cor_tinta = cor
44 |
45 | # def get_cor(self):
46 | # print('GET COR')
47 | # return self.cor_tinta
48 |
49 | # ###########################
50 |
51 |
52 | # caneta = Caneta('Azul')
53 | # print(caneta.get_cor())
54 | # print(caneta.get_cor())
55 | # print(caneta.get_cor())
56 | # print(caneta.get_cor())
57 | # print(caneta.get_cor())
58 |
--------------------------------------------------------------------------------
/aula132.py:
--------------------------------------------------------------------------------
1 | # @property + @setter - getter e setter no modo Pythônico
2 | # - como getter
3 | # - p/ evitar quebrar código cliente
4 | # - p/ habilitar setter
5 | # - p/ executar ações ao obter um atributo
6 | # Atributos que começar com um ou dois underlines
7 | # não devem ser usados fora da classe.
8 | # 🐍🤓🤯🤯🤯🤯
9 | class Caneta:
10 | def __init__(self, cor):
11 | # private protected
12 | self.cor = cor
13 | self._cor_tampa = None
14 |
15 | @property
16 | def cor(self):
17 | print('ESTOU NO GETTER')
18 | return self._cor
19 |
20 | @cor.setter
21 | def cor(self, valor):
22 | print('ESTOU NO SETTER')
23 | self._cor = valor
24 |
25 | @property
26 | def cor_tampa(self):
27 | return self._cor_tampa
28 |
29 | @cor_tampa.setter
30 | def cor_tampa(self, valor):
31 | self._cor_tampa = valor
32 |
33 |
34 | caneta = Caneta('Azul')
35 | caneta.cor = 'Rosa'
36 | caneta.cor_tampa = 'Azul'
37 | print(caneta.cor)
38 | print(caneta.cor_tampa)
39 |
--------------------------------------------------------------------------------
/aula133.py:
--------------------------------------------------------------------------------
1 | # Encapsulamento (modificadores de acesso: public, protected, private)
2 | # Python NÃO TEM modificadores de acesso
3 | # Mas podemos seguir as seguintes convenções
4 | # (sem underline) = public
5 | # pode ser usado em qualquer lugar
6 | # _ (um underline) = protected
7 | # não DEVE ser usado fora da classe
8 | # ou suas subclasses.
9 | # __ (dois underlines) = private
10 | # "name mangling" (desfiguração de nomes) em Python
11 | # _NomeClasse__nome_attr_ou_method
12 | # só DEVE ser usado na classe em que foi
13 | # declarado.
14 | from functools import partial
15 |
16 |
17 | class Foo:
18 | def __init__(self):
19 | self.public = 'isso é público'
20 | self._protected = 'isso é protegido'
21 | self.__exemplo = 'isso é private'
22 |
23 | def metodo_publico(self):
24 | # self._metodo_protected()
25 | # print(self._protected)
26 | print(self.__exemplo)
27 | self.__metodo_private()
28 | return 'metodo_publico'
29 |
30 | def _metodo_protected(self):
31 | print('_metodo_protected')
32 | return '_metodo_protected'
33 |
34 | def __metodo_private(self):
35 | print('__metodo_private')
36 | return '__metodo_private'
37 |
38 |
39 | f = Foo()
40 | # print(f.public)
41 | print(f.metodo_publico())
42 |
--------------------------------------------------------------------------------
/aula134.py:
--------------------------------------------------------------------------------
1 | # Relações entre classes: associação, agregação e composição
2 | # Associação é um tipo de relação onde os objetos
3 | # estão ligados dentro do sistema.
4 | # Essa é a relação mais comum entre objetos e tem subconjuntos
5 | # como agregação e composição (que veremos depois).
6 | # Geralmente, temos uma associação quando um objeto tem
7 | # um atributo que referencia outro objeto.
8 | # A associação não especifica como um objeto controla
9 | # o ciclo de vida de outro objeto.
10 | class Escritor:
11 | def __init__(self, nome) -> None:
12 | self.nome = nome
13 | self._ferramenta = None
14 |
15 | @property
16 | def ferramenta(self):
17 | return self._ferramenta
18 |
19 | @ferramenta.setter
20 | def ferramenta(self, ferramenta):
21 | self._ferramenta = ferramenta
22 |
23 |
24 | class FerramentaDeEscrever:
25 | def __init__(self, nome):
26 | self.nome = nome
27 |
28 | def escrever(self):
29 | return f'{self.nome} está escrevendo'
30 |
31 |
32 | escritor = Escritor('Luiz')
33 | caneta = FerramentaDeEscrever('Caneta Bic')
34 | maquina_de_escrever = FerramentaDeEscrever('Máquina')
35 | escritor.ferramenta = maquina_de_escrever
36 |
37 | print(caneta.escrever())
38 | print(maquina_de_escrever.escrever())
39 | print(escritor.ferramenta.escrever())
40 |
--------------------------------------------------------------------------------
/aula135.py:
--------------------------------------------------------------------------------
1 | # Relações entre classes: associação, agregação e composição
2 | # Agregação é uma forma mais especializada de associação
3 | # entre dois ou mais objetos. Cada objeto terá
4 | # seu ciclo de vida independente.
5 | # Geralmente é uma relação de um para muitos, onde um
6 | # objeto tem um ou muitos objetos.
7 | # Os objetos podem viver separadamente, mas pode
8 | # se tratar de uma relação onde um objeto precisa de
9 | # outro para fazer determinada tarefa.
10 | # (existem controvérsias sobre as definições de agregação).
11 | class Carrinho:
12 | def __init__(self):
13 | self._produtos = []
14 |
15 | def total(self):
16 | return sum([p.preco for p in self._produtos])
17 |
18 | def inserir_produtos(self, *produtos):
19 | # self._produtos.extend(produtos)
20 | # self._produtos += produtos
21 | for produto in produtos:
22 | self._produtos.append(produto)
23 |
24 | def listar_produtos(self):
25 | print()
26 | for produto in self._produtos:
27 | print(produto.nome, produto.preco)
28 | print()
29 |
30 |
31 | class Produto:
32 | def __init__(self, nome, preco):
33 | self.nome = nome
34 | self.preco = preco
35 |
36 |
37 | carrinho = Carrinho()
38 | p1, p2 = Produto('Caneta', 1.20), Produto('Camiseta', 20)
39 | carrinho.inserir_produtos(p1, p2)
40 | carrinho.listar_produtos()
41 | print(carrinho.total())
42 |
--------------------------------------------------------------------------------
/aula136.py:
--------------------------------------------------------------------------------
1 | # Relações entre classes: associação, agregação e composição
2 | # Composição é uma especialização da agregação.
3 | # Mas nela, quando o objeto "pai" for apagado, todas
4 | # as referências dos objetos filhos também são
5 | # apagadas.
6 | class Cliente:
7 | def __init__(self, nome):
8 | self.nome = nome
9 | self.enderecos = []
10 |
11 | def inserir_endereco(self, rua, numero):
12 | self.enderecos.append(Endereco(rua, numero))
13 |
14 | def inserir_endereco_externo(self, endereco):
15 | self.enderecos.append(endereco)
16 |
17 | def listar_enderecos(self):
18 | for endereco in self.enderecos:
19 | print(endereco.rua, endereco.numero)
20 |
21 | def __del__(self):
22 | print('APAGANDO,', self.nome)
23 |
24 |
25 | class Endereco:
26 | def __init__(self, rua, numero):
27 | self.rua = rua
28 | self.numero = numero
29 |
30 | def __del__(self):
31 | print('APAGANDO,', self.rua, self.numero)
32 |
33 |
34 | cliente1 = Cliente('Maria')
35 | cliente1.inserir_endereco('Av Brasil', 54)
36 | cliente1.inserir_endereco('Rua B', 6745)
37 | endereco_externo = Endereco('Av Saudade', 123213)
38 | cliente1.inserir_endereco_externo(endereco_externo)
39 | cliente1.listar_enderecos()
40 |
41 | del cliente1
42 |
43 |
44 | print(endereco_externo.rua, endereco_externo.numero)
45 | print('######################## AQUI TERMINA MEU CÓDIGO')
46 |
--------------------------------------------------------------------------------
/aula137.py:
--------------------------------------------------------------------------------
1 | # Exercício com classes
2 | # 1 - Crie uma classe Carro (Nome)
3 | # 2 - Crie uma classe Motor (Nome)
4 | # 3 - Crie uma classe Fabricante (Nome)
5 | # 4 - Faça a ligação entre Carro tem um Motor
6 | # Obs.: Um motor pode ser de vários carros
7 | # 5 - Faça a ligação entre Carro e um Fabricante
8 | # Obs.: Um fabricante pode fabricar vários carros
9 | # Exiba o nome do carro, motor e fabricante na tela
10 | class Carro:
11 | def __init__(self, nome):
12 | self.nome = nome
13 | self._motor = None
14 | self._fabricante = None
15 |
16 | @property
17 | def motor(self):
18 | return self._motor
19 |
20 | @motor.setter
21 | def motor(self, valor):
22 | self._motor = valor
23 |
24 | @property
25 | def fabricante(self):
26 | return self._fabricante
27 |
28 | @fabricante.setter
29 | def fabricante(self, valor):
30 | self._fabricante = valor
31 |
32 |
33 | class Motor:
34 | def __init__(self, nome):
35 | self.nome = nome
36 |
37 |
38 | class Fabricante:
39 | def __init__(self, nome):
40 | self.nome = nome
41 |
42 |
43 | fusca = Carro('Fusca')
44 | volkswagen = Fabricante('Volkswagen')
45 | motor_1_0 = Motor('1.0')
46 | fusca.fabricante = volkswagen
47 | fusca.motor = motor_1_0
48 | print(fusca.nome, fusca.fabricante.nome, fusca.motor.nome)
49 |
50 | gol = Carro('Gol')
51 | gol.fabricante = volkswagen
52 | gol.motor = motor_1_0
53 | print(gol.nome, gol.fabricante.nome, gol.motor.nome)
54 |
55 | fiat_uno = Carro('Uno')
56 | fiat = Fabricante('Fiat')
57 | fiat_uno.fabricante = fiat
58 | fiat_uno.motor = motor_1_0
59 | print(fiat_uno.nome, fiat_uno.fabricante.nome, fiat_uno.motor.nome)
60 |
61 | focus = Carro('Focus Titanium')
62 | ford = Fabricante('Ford')
63 | motor_2_0 = Motor('2.0')
64 | focus.fabricante = ford
65 | focus.motor = motor_2_0
66 | print(focus.nome, focus.fabricante.nome, focus.motor.nome)
67 |
--------------------------------------------------------------------------------
/aula138.py:
--------------------------------------------------------------------------------
1 | # Herança simples - Relações entre classes
2 | # Associação - usa, Agregação - tem
3 | # Composição - É dono de, Herança - É um
4 | #
5 | # Herança vs Composição
6 | #
7 | # Classe principal (Pessoa)
8 | # -> super class, base class, parent class
9 | # Classes filhas (Cliente)
10 | # -> sub class, child class, derived class
11 | class Pessoa:
12 | cpf = '1234'
13 |
14 | def __init__(self, nome, sobrenome):
15 | self.nome = nome
16 | self.sobrenome = sobrenome
17 |
18 | def falar_nome_classe(self):
19 | print('Classe PESSOA')
20 | print(self.nome, self.sobrenome, self.__class__.__name__)
21 |
22 |
23 | class Cliente(Pessoa):
24 | def falar_nome_classe(self):
25 | print('EITA, nem saí da classe CLIENTE')
26 | print(self.nome, self.sobrenome, self.__class__.__name__)
27 |
28 |
29 | class Aluno(Pessoa):
30 | cpf = 'cpf aluno'
31 | ...
32 |
33 |
34 | c1 = Cliente('Luiz', 'Otávio')
35 | c1.falar_nome_classe()
36 | a1 = Aluno('Maria', 'Helena')
37 | a1.falar_nome_classe()
38 | print(a1.cpf)
39 | # help(Cliente)
40 |
--------------------------------------------------------------------------------
/aula139.py:
--------------------------------------------------------------------------------
1 | # super() e a sobreposição de membros - Python Orientado a Objetos
2 | # Classe principal (Pessoa)
3 | # -> super class, base class, parent class
4 | # Classes filhas (Cliente)
5 | # -> sub class, child class, derived class
6 | # class MinhaString(str):
7 | # def upper(self):
8 | # print('CHAMOU UPPER')
9 | # retorno = super(MinhaString, self).upper()
10 | # print('DEPOIS DO UPPER')
11 | # return retorno
12 |
13 |
14 | # string = MinhaString('Luiz')
15 | # print(string.upper())
16 |
17 | class A(object):
18 | atributo_a = 'valor a'
19 |
20 | def __init__(self, atributo):
21 | self.atributo = atributo
22 |
23 | def metodo(self):
24 | print('A')
25 |
26 |
27 | class B(A):
28 | atributo_b = 'valor b'
29 |
30 | def __init__(self, atributo, outra_coisa):
31 | super().__init__(atributo)
32 | self.outra_coisa = outra_coisa
33 |
34 | def metodo(self):
35 | print('B')
36 |
37 |
38 | class C(B):
39 | atributo_c = 'valor c'
40 |
41 | def __init__(self, *args, **kwargs):
42 | # print('EI, burlei o sistema.')
43 | super().__init__(*args, **kwargs)
44 |
45 | def metodo(self):
46 | # super().metodo() # B
47 | # super(B, self).metodo() # A
48 | # super(A, self).metodo() # object
49 | A.metodo(self)
50 | B.metodo(self)
51 | print('C')
52 |
53 |
54 | # print(C.mro())
55 | # print(B.mro())
56 | # print(A.mro())
57 | c = C('Atributo', 'Qualquer')
58 | # print(c.atributo)
59 | # print(c.outra_coisa)
60 | c.metodo()
61 | # print(c.atributo_a)
62 | # print(c.atributo_b)
63 | # print(c.atributo_c)
64 | # c.metodo()
65 |
--------------------------------------------------------------------------------
/aula14.py:
--------------------------------------------------------------------------------
1 | a = 'AAAAA'
2 | b = 'BBBBBB'
3 | c = 1.1
4 | string = 'b={nome2} a={nome1} a={nome1} c={nome3:.2f}'
5 | formato = string.format(
6 | nome1=a, nome2=b, nome3=c
7 | )
8 |
9 | print(formato)
10 |
--------------------------------------------------------------------------------
/aula140.py:
--------------------------------------------------------------------------------
1 | # Herança Múltipla - Python Orientado a Objetos
2 | # Quer dizer que no Python, uma classe pode estender
3 | # várias outras classes.
4 | # Herança simples:
5 | # Animal -> Mamifero -> Humano -> Pessoa -> Cliente
6 | # Herança múltipla e mixins
7 | # Log -> FileLog
8 | # Animal -> Mamifero -> Humano -> Pessoa -> Cliente
9 | # Cliente(Pessoa, FileLog)
10 | #
11 | # A, B, C, D
12 | # D(B, C) - C(A) - B(A) - A
13 | #
14 | # método -> falar
15 | # A
16 | # / \
17 | # B C
18 | # \ /
19 | # D
20 | #
21 | # Python 3 usa C3 superclass linearization
22 | # para gerar o mro.
23 | # Você não precisa estudar isso (é complexo)
24 | # https://en.wikipedia.org/wiki/C3_linearization
25 | #
26 | # Para saber a ordem de chamada dos métodos
27 | # Use o método de classe Classe.mro()
28 | # Ou o atributo __mro__ (Dunder - Double Underscore)
29 | class A:
30 | ...
31 |
32 | def quem_sou(self):
33 | print('A')
34 |
35 |
36 | class B(A):
37 | ...
38 |
39 | # def quem_sou(self):
40 | # print('B')
41 |
42 |
43 | class C(A):
44 | ...
45 |
46 | def quem_sou(self):
47 | print('C')
48 |
49 |
50 | class D(B, C):
51 | ...
52 |
53 | def quem_sou(self):
54 | print('D')
55 |
56 |
57 | d = D()
58 | d.quem_sou()
59 | # print(D.__mro__)
60 | print(D.mro())
61 |
--------------------------------------------------------------------------------
/aula141/eletronico.py:
--------------------------------------------------------------------------------
1 | from log import LogFileMixin
2 |
3 |
4 | class Eletronico:
5 | def __init__(self, nome):
6 | self._nome = nome
7 | self._ligado = False
8 |
9 | def ligar(self):
10 | if not self._ligado:
11 | self._ligado = True
12 |
13 | def desligar(self):
14 | if self._ligado:
15 | self._ligado = False
16 |
17 |
18 | class Smartphone(Eletronico, LogFileMixin):
19 | def ligar(self):
20 | super().ligar()
21 |
22 | if self._ligado:
23 | msg = f'{self._nome} está ligado'
24 | self.log_success(msg)
25 |
26 | def desligar(self):
27 | super().desligar()
28 |
29 | if not self._ligado:
30 | msg = f'{self._nome} está desligado'
31 | self.log_error(msg)
32 |
--------------------------------------------------------------------------------
/aula141/log.py:
--------------------------------------------------------------------------------
1 | # Abstração
2 | # Herança - é um
3 | from pathlib import Path
4 |
5 | LOG_FILE = Path(__file__).parent / 'log.txt'
6 |
7 |
8 | class Log:
9 | def _log(self, msg):
10 | raise NotImplementedError('Implemente o método log')
11 |
12 | def log_error(self, msg):
13 | return self._log(f'Error: {msg}')
14 |
15 | def log_success(self, msg):
16 | return self._log(f'Success: {msg}')
17 |
18 |
19 | class LogFileMixin(Log):
20 | def _log(self, msg):
21 | msg_fomatada = f'{msg} ({self.__class__.__name__})'
22 | print('Salvando no log:', msg_fomatada)
23 | with open(LOG_FILE, 'a') as arquivo:
24 | arquivo.write(msg_fomatada)
25 | arquivo.write('\n')
26 |
27 |
28 | class LogPrintMixin(Log):
29 | def _log(self, msg):
30 | print(f'{msg} ({self.__class__.__name__})')
31 |
32 |
33 | if __name__ == '__main__':
34 | lp = LogPrintMixin()
35 | lp.log_error('qualquer coisa')
36 | lp.log_success('Que legal')
37 | lf = LogFileMixin()
38 | lf.log_error('qualquer coisa')
39 | lf.log_success('Que legal')
40 |
--------------------------------------------------------------------------------
/aula141/log.txt:
--------------------------------------------------------------------------------
1 | Success: Que legal (LogFileMixin)
2 | Error: qualquer coisa (LogFileMixin)
3 | Success: Que legal (LogFileMixin)
4 | Error: qualquer coisa (LogFileMixin)
5 | Success: Que legal (LogFileMixin)
6 | Error: qualquer coisa (LogFileMixin)
7 | Success: Que legal (LogFileMixin)
8 | Success: Galaxy S está ligado (Smartphone)
9 | Error: iPhone está desligado (Smartphone)
10 | Success: Galaxy S está ligado (Smartphone)
11 | Error: iPhone está desligado (Smartphone)
12 | Success: Galaxy S está ligado (Smartphone)
13 | Error: iPhone está desligado (Smartphone)
14 |
--------------------------------------------------------------------------------
/aula141/main.py:
--------------------------------------------------------------------------------
1 | from eletronico import Smartphone
2 |
3 | galaxy_s = Smartphone('Galaxy S')
4 | iphone = Smartphone('iPhone')
5 |
6 | galaxy_s.ligar()
7 | iphone.desligar()
8 |
--------------------------------------------------------------------------------
/aula142.py:
--------------------------------------------------------------------------------
1 | # Classes abstratas - Abstract Base Class (abc)
2 | # ABCs são usadas como contratos para a definição
3 | # de novas classes. Elas podem forçar outras classes
4 | # a criarem métodos concretos. Também podem ter
5 | # métodos concretos por elas mesmas.
6 | # @abstractmethods são métodos que não têm corpo.
7 | # As regras para classes abstratas com métodos
8 | # abstratos é que elas NÃO PODEM ser instânciadas
9 | # diretamente.
10 | # Métodos abstratos DEVEM ser implementados
11 | # nas subclasses (@abstractmethod).
12 | # Uma classe abstrata em Python tem sua metaclasse
13 | # sendo ABCMeta.
14 | # É possível criar @property @setter @classmethod
15 | # @staticmethod e @method como abstratos, para isso
16 | # use @abstractmethod como decorator mais interno.
17 | from abc import ABC, abstractmethod
18 |
19 |
20 | class Log(ABC):
21 | @abstractmethod
22 | def _log(self, msg): ...
23 |
24 | def log_error(self, msg):
25 | return self._log(f'Error: {msg}')
26 |
27 | def log_success(self, msg):
28 | return self._log(f'Success: {msg}')
29 |
30 |
31 | class LogPrintMixin(Log):
32 | def _log(self, msg):
33 | print(f'{msg} ({self.__class__.__name__})')
34 |
35 |
36 | l = LogPrintMixin()
37 | l.log_error('Oi')
38 |
--------------------------------------------------------------------------------
/aula143.py:
--------------------------------------------------------------------------------
1 | # abstractmethod para qualquer método já decorado (@property e setter)
2 | # É possível criar @property @property.setter @classmethod
3 | # @staticmethod e métodos normais como abstratos, para isso
4 | # use @abstractmethod como decorator mais interno.
5 | # Foo - Bar são palavras usadas como placeholder
6 | # para palavras que podem mudar na programação.
7 | from abc import ABC, abstractmethod
8 |
9 |
10 | class AbstractFoo(ABC):
11 | def __init__(self, name):
12 | self._name = None
13 | self.name = name
14 |
15 | @property
16 | def name(self):
17 | return self._name
18 |
19 | @name.setter
20 | @abstractmethod
21 | def name(self, name): ...
22 |
23 |
24 | class Foo(AbstractFoo):
25 | def __init__(self, name):
26 | super().__init__(name)
27 | # print('Sou inútil')
28 |
29 | @AbstractFoo.name.setter
30 | def name(self, name):
31 | self._name = name
32 |
33 |
34 | foo = Foo('Bar')
35 | print(foo.name)
36 |
--------------------------------------------------------------------------------
/aula144.py:
--------------------------------------------------------------------------------
1 | # Polimorfismo em Python Orientado a Objetos
2 | # Polimorfismo é o princípio que permite que
3 | # classes deridavas de uma mesma superclasse
4 | # tenham métodos iguais (com mesma assinatura)
5 | # mas comportamentos diferentes.
6 | # Assinatura do método = Mesmo nome e quantidade
7 | # de parâmetros (retorno não faz parte da assinatura)
8 | # Opinião + princípios que contam:
9 | # Assinatura do método: nome, parâmetros e retorno iguais
10 | # SO"L"ID
11 | # Princípio da substituição de liskov
12 | # Objetos de uma superclasse devem ser substituíveis
13 | # por objetos de uma subclasse sem quebrar a aplicação.
14 | # Sobrecarga de métodos (overload) 🐍 = ❌
15 | # Sobreposição de métodos (override) 🐍 = ✅
16 | from abc import ABC, abstractmethod
17 |
18 |
19 | class Notificacao(ABC):
20 | def __init__(self, mensagem):
21 | self.mensagem = mensagem
22 |
23 | @abstractmethod
24 | def enviar(self) -> bool: ...
25 |
26 |
27 | class NotificacaoEmail(Notificacao):
28 | def enviar(self) -> bool:
29 | print('E-mail: enviando - ', self.mensagem)
30 | return True
31 |
32 |
33 | class NotificacaoSMS(Notificacao):
34 | def enviar(self) -> bool:
35 | print('SMS: enviando - ', self.mensagem)
36 | return False
37 |
38 |
39 | def notificar(notificacao: Notificacao):
40 | notificacao_enviada = notificacao.enviar()
41 |
42 | if notificacao_enviada:
43 | print('Notificação enviada')
44 | else:
45 | print('Notificação NÃO enviada')
46 |
47 |
48 | notificacao_email = NotificacaoEmail('testando e-mail')
49 | notificar(notificacao_email)
50 |
51 | notificacao_sms = NotificacaoSMS('testando SMS')
52 | notificar(notificacao_sms)
53 |
--------------------------------------------------------------------------------
/aula145.py:
--------------------------------------------------------------------------------
1 | # Positional-Only Parameters (/) e Keyword-Only Arguments (*)
2 | # *args (ilimitado de argumentos posicionais)
3 | # **kwargs (ilimitado de argumentos nomeados)
4 | # 🟢 Positional-only Parameters (/) - Tudo antes da barra deve
5 | # ser ❗️APENAS❗️ posicional.
6 | # PEP 570 – Python Positional-Only Parameters
7 | # https://peps.python.org/pep-0570/
8 | # 🟢 Keyword-Only Arguments (*) - * sozinho ❗️NÃO SUGA❗️ valores.
9 | # PEP 3102 – Keyword-Only Arguments
10 | # https://peps.python.org/pep-3102/
11 | def soma(a, b, /, *, c, **kwargs):
12 | print(kwargs)
13 | print(a + b + c)
14 |
15 |
16 | soma(1, 2, c=3, nome='teste')
17 |
--------------------------------------------------------------------------------
/aula146.py:
--------------------------------------------------------------------------------
1 | # Notas das exceptions em Python (add_notes, __notes__)
2 | # https://docs.python.org/3/library/exceptions.html
3 | # Levantando (raise) / Lançando (throw) exceções
4 | # Relançando exceções
5 | # Adicionando notas em exceções (3.11.0)
6 | class MeuError(Exception):
7 | ...
8 |
9 |
10 | class OutroError(Exception):
11 | ...
12 |
13 |
14 | def levantar():
15 | exception_ = MeuError('a', 'b', 'c')
16 | exception_.add_note('Olha a nota 1')
17 | exception_.add_note('você errou isso')
18 | raise exception_
19 |
20 |
21 | try:
22 | levantar()
23 | except (MeuError, ZeroDivisionError) as error:
24 | print(error.__class__.__name__)
25 | print(error.args)
26 | print()
27 | exception_ = OutroError('Vou lançar de novo')
28 | exception_.__notes__ = error.__notes__.copy()
29 | exception_.add_note('Mais uma nota')
30 | raise exception_ from error
31 |
--------------------------------------------------------------------------------
/aula147.py:
--------------------------------------------------------------------------------
1 | # Exemplo de uso de dunder methods (métodos mágicos)
2 | # __lt__(self,other) - self < other
3 | # __le__(self,other) - self <= other
4 | # __gt__(self,other) - self > other
5 | # __ge__(self,other) - self >= other
6 | # __eq__(self,other) - self == other
7 | # __ne__(self,other) - self != other
8 | # __add__(self,other) - self + other
9 | # __sub__(self,other) - self - other
10 | # __mul__(self,other) - self * other
11 | # __truediv__(self,other) - self / other
12 | # __neg__(self) - -self
13 | # __str__(self) - str
14 | # __repr__(self) - str
15 | class Ponto:
16 | def __init__(self, x, y):
17 | self.x = x
18 | self.y = y
19 |
20 | def __repr__(self):
21 | class_name = type(self).__name__
22 | return f'{class_name}(x={self.x!r}, y={self.y!r})'
23 |
24 | def __add__(self, other):
25 | novo_x = self.x + other.x
26 | novo_y = self.y + other.y
27 | return Ponto(novo_x, novo_y)
28 |
29 | def __gt__(self, other):
30 | resultado_self = self.x + self.y
31 | resultado_other = other.x + other.y
32 | return resultado_self > resultado_other
33 |
34 |
35 | if __name__ == '__main__':
36 | p1 = Ponto(4, 2) # 6
37 | p2 = Ponto(6, 4) # 10
38 | p3 = p1 + p2
39 | print(p3)
40 | print('P1 é maior que p2', p1 > p2)
41 | print('P2 é maior que p1', p2 > p1)
42 |
--------------------------------------------------------------------------------
/aula148.py:
--------------------------------------------------------------------------------
1 | # __new__ e __init__ em classes Python
2 | # __new__ é o método responsável por criar e
3 | # retornar o novo objeto. Por isso, new recebe cls.
4 | # __new__ ❗️DEVE retornar o novo objeto❗️
5 | # __init__ é o método responsável por inicializar
6 | # a instância. Por isso, init recebe self.
7 | # __init__ ❗️NÃO DEVE retornar nada (None)❗️
8 | # object é a super classe de uma classe
9 | class A:
10 | def __new__(cls, *args, **kwargs):
11 | instancia = super().__new__(cls)
12 | return instancia
13 |
14 | def __init__(self, x):
15 | self.x = x
16 | print('Sou o init')
17 |
18 | def __repr__(self):
19 | return 'A()'
20 |
21 |
22 | a = A(123)
23 | print(a.x)
24 |
--------------------------------------------------------------------------------
/aula149.txt:
--------------------------------------------------------------------------------
1 | Linha 1
2 | Linha 2
3 | Linha 3
4 |
--------------------------------------------------------------------------------
/aula15.py:
--------------------------------------------------------------------------------
1 | # nome = input('Qual o seu nome? ')
2 | # print(f'O seu nome é {nome}')
3 |
4 | numero_1 = input('Digite um número: ')
5 | numero_2 = input('Digite outro número: ')
6 |
7 | int_numero_1 = int(numero_1)
8 | int_numero_2 = int(numero_2)
9 |
10 | print(f'A soma dos números é: {int_numero_1 + int_numero_2}')
11 |
--------------------------------------------------------------------------------
/aula150.py:
--------------------------------------------------------------------------------
1 | # Context Manager com função - Criando e Usando gerenciadores de contexto
2 | from contextlib import contextmanager
3 |
4 |
5 | @contextmanager
6 | def my_open(caminho_arquivo, modo):
7 | try:
8 | print('Abrindo arquivo')
9 | arquivo = open(caminho_arquivo, modo, encoding='utf8')
10 | yield arquivo
11 | except Exception as e:
12 | print('Ocorreu erro', e)
13 | finally:
14 | print('Fechando arquivo')
15 | arquivo.close()
16 |
17 |
18 | with my_open('aula150.txt', 'w') as arquivo:
19 | arquivo.write('Linha 1\n')
20 | arquivo.write('Linha 2\n', 123)
21 | arquivo.write('Linha 3\n')
22 | print('WITH', arquivo)
23 |
--------------------------------------------------------------------------------
/aula150.txt:
--------------------------------------------------------------------------------
1 | Linha 1
2 |
--------------------------------------------------------------------------------
/aula151.py:
--------------------------------------------------------------------------------
1 | # Funções decoradoras e decoradores com classes
2 |
3 | def meu_repr(self):
4 | class_name = self.__class__.__name__
5 | class_dict = self.__dict__
6 | class_repr = f'{class_name}({class_dict})'
7 | return class_repr
8 |
9 |
10 | def adiciona_repr(cls):
11 | cls.__repr__ = meu_repr
12 | return cls
13 |
14 |
15 | @adiciona_repr
16 | class Time:
17 | def __init__(self, nome):
18 | self.nome = nome
19 |
20 |
21 | @adiciona_repr
22 | class Planeta:
23 | def __init__(self, nome):
24 | self.nome = nome
25 |
26 |
27 | brasil = Time('Brasil')
28 | portugal = Time('Portugal')
29 |
30 | terra = Planeta('Terra')
31 | marte = Planeta('Marte')
32 |
33 | print(brasil)
34 | print(portugal)
35 |
36 | print(terra)
37 | print(marte)
38 |
--------------------------------------------------------------------------------
/aula152.py:
--------------------------------------------------------------------------------
1 | # Funções decoradoras e decoradores com métodos
2 |
3 | def meu_repr(self):
4 | class_name = self.__class__.__name__
5 | class_dict = self.__dict__
6 | class_repr = f'{class_name}({class_dict})'
7 | return class_repr
8 |
9 |
10 | def adiciona_repr(cls):
11 | cls.__repr__ = meu_repr
12 | return cls
13 |
14 |
15 | def meu_planeta(metodo):
16 | def interno(self, *args, **kwargs):
17 | resultado = metodo(self, *args, **kwargs)
18 |
19 | if 'Terra' in resultado:
20 | return 'Você está em casa'
21 | return resultado
22 | return interno
23 |
24 |
25 | @adiciona_repr
26 | class Time:
27 | def __init__(self, nome):
28 | self.nome = nome
29 |
30 |
31 | @adiciona_repr
32 | class Planeta:
33 | def __init__(self, nome):
34 | self.nome = nome
35 |
36 | @meu_planeta
37 | def falar_nome(self):
38 | return f'O planeta é {self.nome}'
39 |
40 |
41 | brasil = Time('Brasil')
42 | portugal = Time('Portugal')
43 |
44 | terra = Planeta('Terra')
45 | marte = Planeta('Marte')
46 |
47 | print(brasil)
48 | print(portugal)
49 |
50 | print(terra)
51 | print(marte)
52 |
53 | print(terra.falar_nome())
54 | print(marte.falar_nome())
55 |
--------------------------------------------------------------------------------
/aula153.py:
--------------------------------------------------------------------------------
1 | # Método especial __call__
2 | # callable é algo que pode ser executado com parênteses
3 | # Em classes normais, __call__ faz a instância de uma
4 | # classe "callable".
5 | class CallMe:
6 | def __init__(self, phone):
7 | self.phone = phone
8 |
9 | def __call__(self, nome):
10 | print(nome, 'está chamando', self.phone)
11 | return 2134
12 |
13 |
14 | call1 = CallMe('23945876545')
15 | retorno = call1('Luiz Otávio')
16 | print(retorno)
17 |
--------------------------------------------------------------------------------
/aula154.py:
--------------------------------------------------------------------------------
1 | # Classes decoradoras (Decorator classes)
2 | class Multiplicar:
3 | def __init__(self, multiplicador):
4 | self._multiplicador = multiplicador
5 |
6 | def __call__(self, func):
7 | def interna(*args, **kwargs):
8 | resultado = func(*args, **kwargs)
9 | return resultado * self._multiplicador
10 | return interna
11 |
12 |
13 | @Multiplicar(2)
14 | def soma(x, y):
15 | return x + y
16 |
17 |
18 | dois_mais_quatro = soma(2, 4)
19 | print(dois_mais_quatro)
20 |
--------------------------------------------------------------------------------
/aula156/documentando_class.py:
--------------------------------------------------------------------------------
1 | """Este é um módulo de exemplo
2 |
3 | Este módulo contém funções e exemplos de documentação de funções.
4 | A função soma você já conhece bastante.
5 | """
6 | variavel_1 = 1
7 |
8 | # def soma(x, y):
9 |
10 |
11 | class Foo:
12 | """Este é um módulo de exemplo
13 |
14 | Este módulo contém funções e exemplos de documentação de funções.
15 | A função soma você já conhece bastante.
16 | """
17 |
18 | def soma(self, x: int | float, y: int | float) -> int | float:
19 | """Soma x e y
20 |
21 | Este módulo contém funções e exemplos de documentação de funções.
22 | A função soma você já conhece bastante.
23 |
24 | :param x: Número 1
25 | :type x: int or float
26 | :param y: Número 2
27 | :type y: int or float
28 |
29 | :return: A soma entre x e y
30 | :rtype: int or float
31 | """
32 | return x + y
33 |
34 | def multiplica(
35 | self,
36 | x: int | float,
37 | y: int | float,
38 | z: int | float | None = None
39 | ) -> int | float:
40 | """Multiplica x, y e/ou z
41 |
42 | Multiplica x e y. Se z for enviado, multiplica x, y, z.
43 | """
44 | if z is None:
45 | return x * y
46 | return x * y * z
47 |
48 | def bar(self) -> int:
49 | """O que ele faz
50 |
51 | :raises NotImplementedError: Se o método não for definido
52 | :raises ValueError: Se o método não for definido
53 | """
54 | raise NotImplementedError('Teste')
55 |
56 |
57 | variavel_2 = 2
58 | variavel_3 = 3
59 | variavel_4 = 4
60 |
--------------------------------------------------------------------------------
/aula156/documentando_funcoes.py:
--------------------------------------------------------------------------------
1 | """Este é um módulo de exemplo
2 |
3 | Este módulo contém funções e exemplos de documentação de funções.
4 | A função soma você já conhece bastante.
5 | """
6 | variavel_1 = 1
7 |
8 | # def soma(x, y):
9 |
10 |
11 | def soma(x: int | float, y: int | float) -> int | float:
12 | """Soma x e y
13 |
14 | Este módulo contém funções e exemplos de documentação de funções.
15 | A função soma você já conhece bastante.
16 |
17 | :param x: Número 1
18 | :type x: int or float
19 | :param y: Número 2
20 | :type y: int or float
21 |
22 | :return: A soma entre x e y
23 | :rtype: int or float
24 | """
25 | return x + y
26 |
27 |
28 | def multiplica(
29 | x: int | float,
30 | y: int | float,
31 | z: int | float | None = None
32 | ) -> int | float:
33 | """Multiplica x, y e/ou z
34 |
35 | Multiplica x e y. Se z for enviado, multiplica x, y, z.
36 | """
37 | if z is None:
38 | return x * y
39 | return x * y * z
40 |
41 |
42 | variavel_2 = 2
43 | variavel_3 = 3
44 | variavel_4 = 4
45 |
--------------------------------------------------------------------------------
/aula156/main.py:
--------------------------------------------------------------------------------
1 | # import uma_linha
2 | # import varias_linhas
3 | # import documentando_funcoes
4 | import documentando_class
5 |
6 | # print(dir(uma_linha))
7 | # print(uma_linha.__doc__)
8 | # print(uma_linha.__file__)
9 | # print(uma_linha.__name__)
10 | help(documentando_class)
11 |
--------------------------------------------------------------------------------
/aula156/uma_linha.py:
--------------------------------------------------------------------------------
1 | """O que seu módulo faz"""
2 |
3 | variavel = 'valor'
4 |
5 |
6 | def funcao():
7 | return 1
8 |
--------------------------------------------------------------------------------
/aula156/varias_linhas.py:
--------------------------------------------------------------------------------
1 | """O que seu módulo faz
2 |
3 | Lorem ipsum dolor sit amet. Et praesentium nisi non quam mollitia At saepe
4 | quisquam qui quae voluptatem. Eum laudantium impedit qui velit quia ea
5 | galisum nihil. Sed consequatur culpa qui corrupti officia eos odit tenetur
6 | cum corrupti beatae At provident error cum eveniet consectetur qui perferendis
7 | placeat. Non quibusdam blanditiis est rerum repellat aut facere rerum in
8 | nihil reiciendis ut maxime galisum qui error accusamus.
9 |
10 | Ut cumque enim ut possimus ullam non magni doloribus!
11 | Ut quasi doloremque aut itaque molestiae eos fugiat
12 | deleniti sed voluptates nisi At eveniet quia et quasi
13 | vero ea fugiat delectus! In beatae perferendis in modi
14 | possimus eum quaerat maiores ab autem natus ab ullam
15 | itaque hic nobis autem ad harum tempore. Qui dolore eius
16 | et quasi aliquid et praesentium fuga sed deserunt adipisci eos
17 | dolor nemo qui animi dolore et odio libero.
18 | """
19 |
--------------------------------------------------------------------------------
/aula157.py:
--------------------------------------------------------------------------------
1 | # Enum -> Enumerações
2 | # Enumerações na programação, são usadas em ocasiões onde temos
3 | # um determinado número de coisas para escolher.
4 | # Enums têm membros e seus valores são constantes.
5 | # Enums em python:
6 | # - são um conjunto de nomes simbólicos (membros) ligados a valores únicos
7 | # - podem ser iterados para retornar seus membros canônicos na ordem de
8 | # definição
9 | # enum.Enum é a superclasse para suas enumerações. Mas também pode ser usada
10 | # diretamente (mesmo assim, Enums não são classes normais em Python).
11 | # Você poderá usar seu Enum com type annotations, com isinstance e
12 | # outras coisas relacionadas com tipo.
13 | # Para obter os dados:
14 | # membro = Classe(valor), Classe['chave']
15 | # chave = Classe.chave.name
16 | # valor = Classe.chave.value
17 | import enum
18 |
19 | # Direcoes = enum.Enum('Direcoes', ['ESQUERDA', 'DIREITA'])
20 |
21 |
22 | class Direcoes(enum.Enum):
23 | ESQUERDA = enum.auto()
24 | DIREITA = enum.auto()
25 | ACIMA = enum.auto()
26 | ABAIXO = enum.auto()
27 |
28 |
29 | print(Direcoes(1), Direcoes['ESQUERDA'], Direcoes.ESQUERDA)
30 | print(Direcoes(1).name, Direcoes.ESQUERDA.value)
31 |
32 |
33 | def mover(direcao: Direcoes):
34 | if not isinstance(direcao, Direcoes):
35 | raise ValueError('Direção não encontrada')
36 |
37 | print(f'Movendo para {direcao.name} ({direcao.value})')
38 |
39 |
40 | mover(Direcoes.ESQUERDA)
41 | mover(Direcoes.DIREITA)
42 | mover(Direcoes.ACIMA)
43 | mover(Direcoes.ABAIXO)
44 |
--------------------------------------------------------------------------------
/aula158/pessoas.py:
--------------------------------------------------------------------------------
1 | import contas
2 |
3 |
4 | class Pessoa:
5 | def __init__(self, nome: str, idade: int) -> None:
6 | self.nome = nome
7 | self.idade = idade
8 |
9 | @property
10 | def nome(self):
11 | return self._nome
12 |
13 | @nome.setter
14 | def nome(self, nome: str):
15 | self._nome = nome
16 |
17 | @property
18 | def idade(self):
19 | return self._idade
20 |
21 | @idade.setter
22 | def idade(self, idade: int):
23 | self._idade = idade
24 |
25 | def __repr__(self):
26 | class_name = type(self).__name__
27 | attrs = f'({self.nome!r}, {self.idade!r})'
28 | return f'{class_name}{attrs}'
29 |
30 |
31 | class Cliente(Pessoa):
32 | def __init__(self, nome: str, idade: int) -> None:
33 | super().__init__(nome, idade)
34 | self.conta: contas.Conta | None = None
35 |
36 |
37 | if __name__ == '__main__':
38 | c1 = Cliente('Luiz', 30)
39 | c1.conta = contas.ContaCorrente(111, 222, 0, 0)
40 | print(c1)
41 | print(c1.conta)
42 | c2 = Cliente('Maria', 18)
43 | c2.conta = contas.ContaPoupanca(112, 223, 100)
44 | print(c2)
45 | print(c2.conta)
46 |
--------------------------------------------------------------------------------
/aula159.py:
--------------------------------------------------------------------------------
1 | # Valores padrão e field em dataclasses
2 | # doc: https://docs.python.org/3/library/dataclasses.html
3 | from dataclasses import dataclass, field
4 |
5 |
6 | @dataclass
7 | class Pessoa:
8 | nome: str = field(
9 | default='MISSING', repr=False
10 | )
11 | sobrenome: str = 'Not sent'
12 | idade: int = 100
13 | enderecos: list[str] = field(default_factory=list)
14 |
15 |
16 | if __name__ == '__main__':
17 | p1 = Pessoa()
18 | # print(fields(p1))
19 | print(p1)
20 |
--------------------------------------------------------------------------------
/aula16.py:
--------------------------------------------------------------------------------
1 | # if / elif / else
2 | # se / se não se / se não
3 | entrada = input('Você quer "entrar" ou "sair"? ')
4 |
5 | if entrada == 'entrar':
6 | print('Você entrou no sistema')
7 |
8 | print(12341234)
9 | elif entrada == 'sair':
10 | print('Você saiu do sistema')
11 | else:
12 | print('Você não digitou nem entrar e nem sair.')
13 |
14 | print('FORA DOS BLOCOS')
15 |
--------------------------------------------------------------------------------
/aula160.py:
--------------------------------------------------------------------------------
1 | # namedtuples - tuplas imutáveis com nomes para valores
2 | # Usamos namedtuples para criar classes de objetos que são apenas um
3 | # agrupamento de atributos, como classes normais sem métodos, ou registros de
4 | # bases de dados, etc.
5 | # As namedtuples são imutáveis assim como as tuplas.
6 | # https://docs.python.org/3/library/collections.html#collections.namedtuple
7 | # https://docs.python.org/3/library/typing.html#typing.NamedTuple
8 | # https://brasilescola.uol.com.br/curiosidades/baralho.htm
9 | # from collections import namedtuple
10 | from typing import NamedTuple
11 |
12 |
13 | class Carta(NamedTuple):
14 | valor: str = 'VALOR'
15 | naipe: str = 'NAIPE'
16 |
17 |
18 | # Carta = namedtuple(
19 | # 'Carta', ['valor', 'naipe'],
20 | # defaults=['VALOR', 'NAIPE']
21 | # )
22 | as_espadas = Carta('A')
23 |
24 | print(as_espadas._asdict())
25 | print(as_espadas)
26 | print(as_espadas[0])
27 | print(as_espadas.valor)
28 | print(as_espadas[1])
29 | print(as_espadas.naipe)
30 |
31 | print()
32 | print(as_espadas._fields)
33 | print(as_espadas._field_defaults)
34 |
35 |
36 | for valor in as_espadas:
37 | print(valor)
38 |
--------------------------------------------------------------------------------
/aula161.py:
--------------------------------------------------------------------------------
1 | # Implementando o protocolo do Iterator em Python
2 | # Essa é apenas uma aula para introduzir os protocolos de collections.abc no
3 | # Python. Qualquer outro protocolo poderá ser implementando seguindo a mesma
4 | # estrutura usada nessa aula.
5 | # https://docs.python.org/3/library/collections.abc.html
6 | from collections.abc import Sequence
7 |
8 |
9 | class MyList(Sequence):
10 | def __init__(self):
11 | self._data = {}
12 | self._index = 0
13 | self._next_index = 0
14 |
15 | def append(self, *values):
16 | for value in values:
17 | self._data[self._index] = value
18 | self._index += 1
19 |
20 | def __len__(self) -> int:
21 | return self._index
22 |
23 | def __getitem__(self, index):
24 | return self._data[index]
25 |
26 | def __setitem__(self, index, value):
27 | self._data[index] = value
28 |
29 | def __iter__(self):
30 | return self
31 |
32 | def __next__(self):
33 | if self._next_index >= self._index:
34 | self._next_index = 0
35 | raise StopIteration
36 |
37 | value = self._data[self._next_index]
38 | self._next_index += 1
39 | return value
40 |
41 |
42 | if __name__ == '__main__':
43 | lista = MyList()
44 | lista.append('Maria', 'Helena')
45 | lista[0] = 'João'
46 | lista.append('Luiz')
47 | # print(lista[0])
48 | # print(len(lista))
49 | for item in lista:
50 | print(item)
51 | print('---')
52 | for item in lista:
53 | print(item)
54 | print('---')
55 |
--------------------------------------------------------------------------------
/aula162.py:
--------------------------------------------------------------------------------
1 | # Criando datas com módulo datetime
2 | # datetime(ano, mês, dia)
3 | # datetime(ano, mês, dia, horas, minutos, segundos)
4 | # datetime.strptime('DATA', 'FORMATO')
5 | # datetime.now()
6 | # https://pt.wikipedia.org/wiki/Era_Unix
7 | # datetime.fromtimestamp(Unix Timestamp)
8 | # https://docs.python.org/3/library/datetime.html
9 | # Para timezones
10 | # https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
11 | # Instalando o pytz
12 | # pip install pytz types-pytz
13 | from datetime import datetime
14 |
15 | # from pytz import timezone
16 |
17 | data = datetime.now()
18 | print(data.timestamp()) # Isso está na base de dados
19 | print(datetime.fromtimestamp(1670849077))
20 | # data_str_data = '2022/04/20 07:49:23'
21 | # data_str_data = '20/04/2022'
22 | # data_str_fmt = '%d/%m/%Y'
23 |
24 | # data = datetime(2022, 4, 20, 7, 49, 23, tzinfo=timezone('Asia/Tokyo'))
25 | # data = datetime.strptime(data_str_data, data_str_fmt)
26 |
--------------------------------------------------------------------------------
/aula163.py:
--------------------------------------------------------------------------------
1 | # datetime.timedelta e dateutil.relativetimedelta (calculando datas)
2 | # Docs:
3 | # https://dateutil.readthedocs.io/en/stable/relativedelta.html
4 | # https://docs.python.org/3/library/datetime.html#timedelta-objects
5 | from datetime import datetime
6 |
7 | from dateutil.relativedelta import relativedelta
8 |
9 | fmt = '%d/%m/%Y %H:%M:%S'
10 | data_inicio = datetime.strptime('20/04/1987 09:30:30', fmt)
11 | data_fim = datetime.strptime('12/12/2022 08:20:20', fmt)
12 | # delta = timedelta(days=10, hours=2)
13 | delta = relativedelta(data_fim, data_inicio)
14 | print(delta.days, delta.years)
15 | # print(data_fim - delta)
16 | # print(data_fim)
17 | # print(data_fim + relativedelta(seconds=60, minutes=10))
18 |
19 | # delta = data_fim - data_inicio
20 | # print(delta.days, delta.seconds, delta.microseconds)
21 | # print(delta.total_seconds())
22 | # print(data_fim > data_inicio)
23 | # print(data_fim < data_inicio)
24 | # print(data_fim == data_inicio)
25 |
--------------------------------------------------------------------------------
/aula164.py:
--------------------------------------------------------------------------------
1 | # Formatando datas do datetime
2 | # datetime.strftime('DATA', 'FORMATO')
3 | # https://docs.python.org/3/library/datetime.html
4 | from datetime import datetime
5 |
6 | # data = datetime(2022, 12, 13, 7, 59, 23)
7 | data = datetime.strptime('2022-12-13 07:59:23', '%Y-%m-%d %H:%M:%S')
8 | print(data.strftime('%d/%m/%Y'))
9 | print(data.strftime('%d/%m/%Y %H:%M'))
10 | print(data.strftime('%d/%m/%Y %H:%M:%S'))
11 | print(data.strftime('%Y'), data.year)
12 | print(data.strftime('%d'), data.day)
13 | print(data.strftime('%m'), data.month)
14 | print(data.strftime('%H'), data.hour)
15 | print(data.strftime('%M'), data.minute)
16 | print(data.strftime('%S'), data.second)
17 |
--------------------------------------------------------------------------------
/aula165.py:
--------------------------------------------------------------------------------
1 | # Exercício solucionado: calculando as datas e parcelas de um empréstimo
2 | # Maria pegou um empréstimo de 1.000.000
3 | # para realizar o pagamento em 5 anos.
4 | # A data em que ela pegou o empréstimo foi
5 | # 20/12/2020 e o vencimento de cada parcela
6 | # é no dia 20 de cada mês.
7 | # - Crie a data do empréstimo
8 | # - Crie a data do final do empréstimo
9 | # - Mostre todas as datas de vencimento e o valor de cada parcela
10 | from datetime import datetime
11 |
12 | from dateutil.relativedelta import relativedelta
13 |
14 | valor_total = 1_000_000
15 | data_emprestimo = datetime(2020, 12, 20)
16 | delta_anos = relativedelta(years=5)
17 | data_final = data_emprestimo + delta_anos
18 |
19 | data_parcelas = []
20 | data_parcela = data_emprestimo
21 | while data_parcela < data_final:
22 | data_parcelas.append(data_parcela)
23 | data_parcela += relativedelta(months=+1)
24 |
25 | numero_parcelas = len(data_parcelas)
26 | valor_parcela = valor_total / numero_parcelas
27 |
28 | for data in data_parcelas:
29 | print(data.strftime('%d/%m/%Y'), f'R$ {valor_parcela:,.2f}')
30 |
31 | print()
32 | print(
33 | f'Você pegou R$ {valor_total:,.2f} para pagar '
34 | f'em {delta_anos.years} anos '
35 | f'({numero_parcelas} meses) em parcelas de '
36 | f'R$ {valor_parcela:,.2f}.'
37 | )
38 |
--------------------------------------------------------------------------------
/aula166.py:
--------------------------------------------------------------------------------
1 | # Usando calendar para calendários e datas
2 | # https://docs.python.org/3/library/calendar.html
3 | # calendar é usado para coisas genéricas de calendários e datas.
4 | # Com calendar, você pode saber coisas como:
5 | # - Qual o último dia do mês (ex.: monthrange)
6 | # - Qual o nome e número do dia de determinada data (ex.: weekday)
7 | # - Criar um calendário em si (ex.: monthcalendar)
8 | # - Trabalhar com coisas específicas de calendários (ex.: calendar, month)
9 | # Por padrão dia da semana começa em 0 até 6
10 | # 0 = segunda-feira | 6 = domingo
11 | import calendar
12 |
13 | # print(calendar.calendar(2022))
14 | # print(calendar.month(2022, 12))
15 | # numero_primeiro_dia, ultimo_dia = calendar.monthrange(2022, 12)
16 | # print(list(enumerate(calendar.day_name)))
17 | # print(calendar.day_name[numero_primeiro_dia])
18 | # print(calendar.day_name[calendar.weekday(2022, 12, ultimo_dia)])
19 | for week in calendar.monthcalendar(2022, 12):
20 | for day in week:
21 | if day == 0:
22 | continue
23 | print(day)
24 |
--------------------------------------------------------------------------------
/aula167.py:
--------------------------------------------------------------------------------
1 | # locale para internacionalização (tradução)
2 | # https://docs.python.org/3/library/locale.html
3 | # https://learn.microsoft.com/fr-fr/powershell/module/international/get-winsystemlocale?view=windowsserver2022-ps&viewFallbackFrom=win10-ps
4 | import calendar
5 | import locale
6 |
7 | locale.setlocale(locale.LC_ALL, '')
8 |
9 | print(calendar.calendar(2022))
10 |
--------------------------------------------------------------------------------
/aula168.py:
--------------------------------------------------------------------------------
1 | # O módulo os para interação com o sistema
2 | # Doc: https://docs.python.org/3/library/os.html
3 | # O módulo `os` fornece funções para interagir com o sistema operacional.
4 | # Por exemplo, o módulo os.path contém funções para trabalhar com caminhos de
5 | # arquivos e a função os.listdir() pode ser usada para listar os arquivos em um
6 | # diretório. O método os.system() permite executar comandos do sistema
7 | # operacional a partir do seu código Python.
8 | # Windows 11 (PowerShell), Linux, Mac = clear
9 | # Windows (antigo, cmd) = cls
10 | import os
11 |
12 | os.system('clear')
13 | os.system('echo "Hello world"')
14 |
15 | print('a' * 80)
16 | print('a' * 80)
17 | print('a' * 80)
18 | print('a' * 80)
19 | print('a' * 80)
20 | print('a' * 80)
21 |
--------------------------------------------------------------------------------
/aula169.py:
--------------------------------------------------------------------------------
1 | # os.path trabalha com caminhos em Windows, Linux e Mac
2 | # Doc: https://docs.python.org/3/library/os.path.html#module-os.path
3 | # os.path é um módulo que fornece funções para trabalhar com caminhos de
4 | # arquivos em Windows, Mac ou Linux sem precisar se preocupar com as diferenças
5 | # entre esses sistemas.
6 | # Exemplos do os.path:
7 | # os.path.join: junta strings em um único caminho. Desse modo,
8 | # os.path.join('pasta1', 'pasta2', 'arquivo.txt') retornaria
9 | # 'pasta1/pasta2/arquivo.txt' no Linux ou Mac, e
10 | # 'pasta1\pasta2\arquivo.txt' no Windows.
11 | # os.path.split: divide um caminho uma tupla (diretório, arquivo).
12 | # Por exemplo, os.path.split('/home/user/arquivo.txt')
13 | # retornaria ('/home/user', 'arquivo.txt').
14 | # os.path.exists: verifica se um caminho especificado existe.
15 | # os.path só trabalha com caminhos de arquivos e não faz nenhuma
16 | # operação de entrada/saída (I/O) com arquivos em si.
17 | import os
18 |
19 | caminho = os.path.join('Desktop', 'curso', 'arquivo.txt')
20 | # print(caminho)
21 | diretorio, arquivo = os.path.split(caminho)
22 | nome_arquivo, extensao_arquivo = os.path.splitext(arquivo)
23 | # print(nome_arquivo, extensao_arquivo)
24 | # print(os.path.exists('/Users/luizotavio/Desktop/curso-python-rep'))
25 | # print(os.path.abspath('.'))
26 | print(caminho)
27 | print(os.path.basename(caminho))
28 | print(os.path.basename(diretorio))
29 | print(os.path.dirname(caminho))
30 |
--------------------------------------------------------------------------------
/aula17.py:
--------------------------------------------------------------------------------
1 | # if / elif / else
2 | # se / se não se / se não
3 |
4 | condicao1 = True
5 | condicao2 = True
6 | condicao3 = True
7 | condicao4 = True
8 |
9 | if condicao1:
10 | print('Código para condição 1')
11 | print('Código para condição 1')
12 | elif condicao2:
13 | print('Código para condição 2')
14 | elif condicao3:
15 | print('Código para condição 3')
16 | elif condicao4:
17 | print('Código para condição 4')
18 | else:
19 | print('Nenhuma condição foi satisfeita.')
20 |
21 | if 10 == 10:
22 | print('Outro if')
23 |
24 | print('Fora do if')
25 |
--------------------------------------------------------------------------------
/aula170.py:
--------------------------------------------------------------------------------
1 | # os.listdir para navegar em caminhos
2 | # /Users/luizotavio/Desktop/EXEMPLO
3 | # C:\Users\luizotavio\Desktop\EXEMPLO
4 | # caminho = r'C:\\Users\\luizotavio\\Desktop\\EXEMPLO'
5 | import os
6 |
7 | caminho = os.path.join('/Users', 'luizotavio', 'Desktop', 'EXEMPLO')
8 |
9 | for pasta in os.listdir(caminho):
10 | caminho_completo_pasta = os.path.join(caminho, pasta)
11 | print(pasta)
12 |
13 | if not os.path.isdir(caminho_completo_pasta):
14 | continue
15 |
16 | for imagem in os.listdir(caminho_completo_pasta):
17 | print(' ', imagem)
18 |
--------------------------------------------------------------------------------
/aula171.py:
--------------------------------------------------------------------------------
1 | # os.walk para navegar de caminhos de forma recursiva
2 | # os.walk é uma função que permite percorrer uma estrutura de diretórios de
3 | # maneira recursiva. Ela gera uma sequência de tuplas, onde cada tupla possui
4 | # três elementos: o diretório atual (root), uma lista de subdiretórios (dirs)
5 | # e uma lista dos arquivos do diretório atual (files).
6 | import os
7 | from itertools import count
8 |
9 | caminho = os.path.join('/Users', 'luizotavio', 'Desktop', 'EXEMPLO')
10 | counter = count()
11 |
12 | for root, dirs, files in os.walk(caminho):
13 | the_counter = next(counter)
14 | print(the_counter, 'Pasta atual', root)
15 |
16 | for dir_ in dirs:
17 | print(' ', the_counter, 'Dir:', dir_)
18 |
19 | for file_ in files:
20 | caminho_completo_arquivo = os.path.join(root, file_)
21 | print(' ', the_counter, 'FILE:', caminho_completo_arquivo)
22 | # NÃO FAÇA ISSO (VAI APAGAR TUDO DA PASTA)
23 | # os.unlink(caminho_completo_arquivo)
24 |
--------------------------------------------------------------------------------
/aula173.py:
--------------------------------------------------------------------------------
1 | # os + shutil - Copiando arquivos com Python
2 | # Vamos copiar arquivos de uma pasta para outra.
3 | # Copiar -> shutil.copy
4 | import os
5 | import shutil
6 |
7 | HOME = os.path.expanduser('~')
8 | DESKTOP = os.path.join(HOME, 'Desktop')
9 | PASTA_ORIGINAL = os.path.join(DESKTOP, 'EXEMPLO')
10 | NOVA_PASTA = os.path.join(DESKTOP, 'NOVA_PASTA')
11 |
12 | os.makedirs(NOVA_PASTA, exist_ok=True)
13 |
14 | for root, dirs, files in os.walk(PASTA_ORIGINAL):
15 | for dir_ in dirs:
16 | caminnho_novo_diretorio = os.path.join(
17 | root.replace(PASTA_ORIGINAL, NOVA_PASTA), dir_
18 | )
19 | os.makedirs(caminnho_novo_diretorio, exist_ok=True)
20 |
21 | for file in files:
22 | caminho_arquivo = os.path.join(root, file)
23 | caminnho_novo_arquivo = os.path.join(
24 | root.replace(PASTA_ORIGINAL, NOVA_PASTA), file
25 | )
26 | shutil.copy(caminho_arquivo, caminnho_novo_arquivo)
27 |
--------------------------------------------------------------------------------
/aula174.py:
--------------------------------------------------------------------------------
1 | # os + shutil - Apagando, copiando, movendo e renomeando pastas com Python
2 | # Vamos copiar arquivos de uma pasta para outra.
3 | # Copiar -> shutil.copy
4 | # Copiar Árvore recursivamente -> shutil.copytree
5 | # Apagar Árvore recursivamente -> shutil.rmtree
6 | # Apagar arquivos -> os.unlink
7 | # Renomear/Mover -> shutil.move ou os.rename
8 | import os
9 | import shutil
10 |
11 | HOME = os.path.expanduser('~')
12 | DESKTOP = os.path.join(HOME, 'Desktop')
13 | PASTA_ORIGINAL = os.path.join(DESKTOP, 'EXEMPLO')
14 | NOVA_PASTA = os.path.join(DESKTOP, 'NOVA_PASTA')
15 |
16 | shutil.rmtree(NOVA_PASTA, ignore_errors=True)
17 | shutil.copytree(PASTA_ORIGINAL, NOVA_PASTA)
18 | # shutil.move(NOVA_PASTA, NOVA_PASTA + '_EITA')
19 | shutil.rmtree(NOVA_PASTA, ignore_errors=True)
20 |
21 | # os.makedirs(NOVA_PASTA, exist_ok=True)
22 |
23 | # for root, dirs, files in os.walk(PASTA_ORIGINAL):
24 | # for dir_ in dirs:
25 | # caminnho_novo_diretorio = os.path.join(
26 | # root.replace(PASTA_ORIGINAL, NOVA_PASTA), dir_
27 | # )
28 | # os.makedirs(caminnho_novo_diretorio, exist_ok=True)
29 |
30 | # for file in files:
31 | # caminho_arquivo = os.path.join(root, file)
32 | # caminnho_novo_arquivo = os.path.join(
33 | # root.replace(PASTA_ORIGINAL, NOVA_PASTA), file
34 | # )
35 | # shutil.copy(caminho_arquivo, caminnho_novo_arquivo)
36 |
--------------------------------------------------------------------------------
/aula175.json:
--------------------------------------------------------------------------------
1 | {
2 | "title": "O Senhor dos Anéis: A Sociedade do Anel",
3 | "original_title": "The Lord of the Rings: The Fellowship of the Ring",
4 | "is_movie": true,
5 | "imdb_rating": 8.8,
6 | "year": 2001,
7 | "characters": ["Frodo", "Sam", "Gandalf", "Legolas", "Boromir"],
8 | "budget": null
9 | }
10 |
--------------------------------------------------------------------------------
/aula175.py:
--------------------------------------------------------------------------------
1 | # O que é JSON - JavaScript Object Notation
2 | # JSON - JavaScript Object Notation (extensão .json)
3 | # É uma estrutura de dados que permite a serialização
4 | # de objetos em texto simples para facilitar a transmissão de
5 | # dados através da rede, APIs web ou outros meios de comunicação.
6 | # O JSON suporta os seguintes tipos de dados:
7 | # Números: podem ser inteiros ou com ponto flutuante, como 42 ou 3.14
8 | # Strings: são cadeias de caracteres, como "Olá, mundo!" ou "12345"
9 | # As strings devem ser envolvidas por aspas duplas
10 | # Booleanos: são os valores verdadeiro (true) ou falso (false)
11 | # Arrays: são listas ordenadas de valores, como [1, 2, 3] ou
12 | # ["Oi", "Olá", "Bom dia"]
13 | # Objetos: são conjuntos de pares chave/valor -> {"nome": "João", "idade": 30}
14 | # null: é um valor especial que representa ausência de valor
15 | #
16 | # Ao converter de Python para JSON:
17 | # Python JSON
18 | # dict object
19 | # list, tuple array
20 | # str string
21 | # int, float number
22 | # True true
23 | # False false
24 | # None null
25 |
--------------------------------------------------------------------------------
/aula176.py:
--------------------------------------------------------------------------------
1 | # json.dumps e json.loads com strings + typing.TypedDict
2 | # Ao converter de Python para JSON:
3 | # Python JSON
4 | # dict object
5 | # list, tuple array
6 | # str string
7 | # int, float number
8 | # True true
9 | # False false
10 | # None null
11 | import json
12 | # from pprint import pprint
13 | from typing import TypedDict
14 |
15 |
16 | class Movie(TypedDict):
17 | title: str
18 | original_title: str
19 | is_movie: bool
20 | imdb_rating: float
21 | year: int
22 | characters: list[str]
23 | budget: None | float
24 |
25 |
26 | string_json = '''
27 | {
28 | "title": "O Senhor dos Anéis: A Sociedade do Anel",
29 | "original_title": "The Lord of the Rings: The Fellowship of the Ring",
30 | "is_movie": true,
31 | "imdb_rating": 8.8,
32 | "year": 2001,
33 | "characters": ["Frodo", "Sam", "Gandalf", "Legolas", "Boromir"],
34 | "budget": null
35 | }
36 | '''
37 | filme: Movie = json.loads(string_json)
38 | # pprint(filme, width=40)
39 | # print(filme['title'])
40 | # print(filme['characters'][0])
41 | # print(filme['year'] + 10)
42 |
43 | json_string = json.dumps(filme, ensure_ascii=False, indent=2)
44 | print(json_string)
45 |
--------------------------------------------------------------------------------
/aula177.json:
--------------------------------------------------------------------------------
1 | {
2 | "title": "O Senhor dos Anéis: A Sociedade do Anel",
3 | "original_title": "The Lord of the Rings: The Fellowship of the Ring",
4 | "is_movie": true,
5 | "imdb_rating": 8.8,
6 | "year": 2001,
7 | "characters": [
8 | "Frodo",
9 | "Sam",
10 | "Gandalf",
11 | "Legolas",
12 | "Boromir"
13 | ],
14 | "budget": null
15 | }
--------------------------------------------------------------------------------
/aula177.py:
--------------------------------------------------------------------------------
1 | # json.dump e json.load com arquivos
2 | import json
3 | import os
4 |
5 | NOME_ARQUIVO = 'aula177.json'
6 | CAMINHO_ABSOLUTO_ARQUIVO = os.path.abspath(
7 | os.path.join(
8 | os.path.dirname(__file__),
9 | NOME_ARQUIVO
10 | )
11 | )
12 |
13 | filme = {
14 | 'title': 'O Senhor dos Anéis: A Sociedade do Anel',
15 | 'original_title': 'The Lord of the Rings: The Fellowship of the Ring',
16 |
17 | 'is_movie': True,
18 | 'imdb_rating': 8.8,
19 | 'year': 2001,
20 | 'characters': ['Frodo', 'Sam', 'Gandalf', 'Legolas', 'Boromir'],
21 | 'budget': None
22 | }
23 |
24 | with open(CAMINHO_ABSOLUTO_ARQUIVO, 'w') as arquivo:
25 | json.dump(filme, arquivo, ensure_ascii=False, indent=2)
26 |
27 | with open(CAMINHO_ABSOLUTO_ARQUIVO, 'r') as arquivo:
28 | filme_do_json = json.load(arquivo)
29 | print(filme_do_json)
30 |
--------------------------------------------------------------------------------
/aula178-ex.csv:
--------------------------------------------------------------------------------
1 | Nome,Idade,Endereço
2 | Luiz Otávio,32,"Av Brasil, 21, Centro"
3 | João da Silva,55,"Rua 22, 44, Nova Era"
--------------------------------------------------------------------------------
/aula178-gs.csv:
--------------------------------------------------------------------------------
1 | Nome,Idade,Endereço
2 | Luiz Otávio,32,"Av Brasil, 21, ""Centro"""
3 | João da Silva,55,"Rua 22, 44, Nova Era"
--------------------------------------------------------------------------------
/aula178.py:
--------------------------------------------------------------------------------
1 | # CSV (Comma Separated Values - Valores separados por vírgulas)
2 | # É um formato de arquivo que armazena dados em forma de tabela, onde cada
3 | # linha representa uma linha da tabela e as colunas são separadas por vírgulas.
4 | # Ele é amplamente utilizado para transferir dados entre sistemas de diferentes
5 | # plataformas, como por exemplo, para importar ou exportar dados para uma
6 | # planilha (Google Sheets, Excel, LibreOffice Calc) ou para uma base de dados.
7 | # Um arquivo CSV geralmente tem a extensão ".csv" e pode ser aberto em um
8 | # editor de texto ou em uma planilha eletrônica.
9 | # Um exemplo de um arquivo CSV pode ser:
10 | # Nome,Idade,Endereço
11 | # Luiz Otávio,32,"Av Brasil, 21, Centro"
12 | # João da Silva,55,"Rua 22, 44, Nova Era"
13 | # A primeira linha do arquivo define os nomes das colunas da, enquanto as
14 | # linhas seguintes contêm os valores das linhas, separados por vírgulas.
15 | # Regras simples do CSV
16 | # 1 - Separe os valores das colunas com um delimitador único (,)
17 | # 2 - Cada registro deve estar em uma linha
18 | # 3 - Não deixar linhas ou espaços sobrando
19 | # 4 - Use o caractere de escape (") quando o delimitador aparecer no valor.
20 |
--------------------------------------------------------------------------------
/aula179.csv:
--------------------------------------------------------------------------------
1 | Nome,Idade,Endereço
2 | Luiz Otávio,32,"Av Brasil, 21, ""Centro"""
3 | João da Silva,55,"Rua 22, 44, Nova Era"
--------------------------------------------------------------------------------
/aula179.py:
--------------------------------------------------------------------------------
1 | # csv.reader e csv.DictReader
2 | # csv.reader lê o CSV em formato de lista
3 | # csv.DictReader lê o CSV em formato de dicionário
4 | import csv
5 | from pathlib import Path
6 |
7 | CAMINHO_CSV = Path(__file__).parent / 'aula179.csv'
8 |
9 | with open(CAMINHO_CSV, 'r') as arquivo:
10 | leitor = csv.DictReader(arquivo)
11 |
12 | for linha in leitor:
13 | print(linha['Nome'], linha['Idade'], linha['Endereço'])
14 |
15 | # with open(CAMINHO_CSV, 'r') as arquivo:
16 | # leitor = csv.reader(arquivo)
17 |
18 | # for linha in leitor:
19 | # print(linha)
20 |
--------------------------------------------------------------------------------
/aula18.py:
--------------------------------------------------------------------------------
1 | # if / elif / else
2 | # se / se não se / se não
3 |
4 | condicao1 = False
5 | condicao2 = False
6 | condicao3 = True
7 | condicao4 = True
8 |
9 | if condicao1:
10 | print('Código para condição 1')
11 | print('Código para condição 1')
12 | elif condicao2:
13 | print('Código para condição 2')
14 | elif condicao3:
15 | print('Código para condição 3')
16 | elif condicao4:
17 | print('Código para condição 4')
18 | else:
19 | print('Nenhuma condição foi satisfeita.')
20 |
21 | if 10 == 10:
22 | print('Outro if')
23 |
24 | print('Fora do if')
25 |
--------------------------------------------------------------------------------
/aula180.csv:
--------------------------------------------------------------------------------
1 | Luiz Otávio,"Av 1, 22"
2 | João Silva,"R. 2, ""1"""
3 | Maria Sol,"Av B, 3A"
4 |
--------------------------------------------------------------------------------
/aula180.py:
--------------------------------------------------------------------------------
1 | # csv.writer e csv.DictWriter para escrever em CSV
2 | # csv.reader lê o CSV em formato de lista
3 | # csv.DictReader lê o CSV em formato de dicionário
4 | import csv
5 | from pathlib import Path
6 |
7 | CAMINHO_CSV = Path(__file__).parent / 'aula180.csv'
8 |
9 | lista_clientes = [
10 | {'Nome': 'Luiz Otávio', 'Endereço': 'Av 1, 22'},
11 | {'Nome': 'João Silva', 'Endereço': 'R. 2, "1"'},
12 | {'Nome': 'Maria Sol', 'Endereço': 'Av B, 3A'},
13 | ]
14 |
15 | with open(CAMINHO_CSV, 'w') as arquivo:
16 | nome_colunas = lista_clientes[0].keys()
17 | escritor = csv.DictWriter(
18 | arquivo,
19 | fieldnames=nome_colunas
20 | )
21 | escritor.writeheader()
22 |
23 | for cliente in lista_clientes:
24 | print(cliente)
25 | escritor.writerow(cliente)
26 |
27 |
28 | # lista_clientes = [
29 | # ['Luiz Otávio', 'Av 1, 22'],
30 | # ['João Silva', 'R. 2, "1"'],
31 | # ['Maria Sol', 'Av B, 3A'],
32 | # ]
33 | # with open(CAMINHO_CSV, 'w') as arquivo:
34 | # # nome_colunas = lista_clientes[0].keys()
35 | # nome_colunas = ['Nome', 'Endereço']
36 | # escritor = csv.writer(arquivo)
37 |
38 | # escritor.writerow(nome_colunas)
39 |
40 | # for cliente in lista_clientes:
41 | # escritor.writerow(cliente)
42 |
--------------------------------------------------------------------------------
/aula181.py:
--------------------------------------------------------------------------------
1 | # random tem geradores de números pseudoaleatórios
2 | # Obs.: números pseudoaleatórios significa que os números
3 | # parecem ser aleatórios, mas na verdade não são. Portanto,
4 | # este módulo não deve ser usado para segurança ou uso criptográfico.
5 | # O motivo disso é que quando temos uma mesma entrada e um mesmo algorítimo,
6 | # a saída pode ser previsível.
7 | # doc: https://docs.python.org/pt-br/3/library/random.html
8 | import random
9 |
10 | # Funções:
11 | # seed
12 | # -> Inicializa o gerador de random (por isso "números pseudoaleatórios")
13 | # random.seed(0)
14 |
15 | # random.randrange(início, fim, passo)
16 | # -> Gera um número inteiro aleatório dentro de um intervalo específico
17 | r_range = random.randrange(10, 20, 2)
18 | # print(r_range)
19 |
20 | # random.randint(início, fim)
21 | # -> Gera um número inteiro aleatório dentro de um intervalo "sem passo"
22 | r_int = random.randint(10, 20)
23 | # print(r_int)
24 |
25 | # random.uniform(início, fim)
26 | # -> Gera um número flutuante aleatório dentro de um intervalo "sem passo"
27 | r_uniform = random.uniform(10, 20)
28 | # print(r_uniform)
29 |
30 | # random.shuffle(SequenciaMutável) -> Embaralha a lista original
31 | nomes = ['Luiz', 'Maria', 'Helena', 'Joana']
32 | # random.shuffle(nomes)
33 | # print(nomes)
34 |
35 | # random.sample(Iterável, k=N)
36 | # -> Escolhe elementos do iterável e retorna outro iterável (não repete)
37 | novos_nomes = random.sample(nomes, k=3)
38 | # print(nomes)
39 | # print(novos_nomes)
40 |
41 | # random.choices(Iterável, k=N)
42 | # -> Escolhe elementos do iterável e retorna outro iterável (repete valores)
43 | novos_nomes = random.choices(nomes, k=3)
44 | print(nomes)
45 | print(novos_nomes)
46 |
47 | # random.choice(Iterável) -> Escolhe um elemento do iterável
48 | print(random.choice(nomes))
49 |
--------------------------------------------------------------------------------
/aula182.py:
--------------------------------------------------------------------------------
1 | # secrets gera números aleatórios seguros
2 | import secrets
3 |
4 | # import string as s
5 | # from secrets import SystemRandom as Sr
6 |
7 | # print(''.join(Sr().choices(s.ascii_letters + s.digits + s.punctuation, k=64))) # noqa: E501
8 | # python -c "import string as s;from secrets import SystemRandom as Sr; print(''.join(Sr().choices(s.ascii_letters + s.punctuation + s.digits,k=12)))" # noqa: E501
9 |
10 | random = secrets.SystemRandom()
11 |
12 | # print(secrets.randbelow(100))
13 | # print(secrets.choice([10, 11, 12]))
14 |
15 | # Funções:
16 | # seed
17 | # -> NÃO FAZ NADA
18 | random.seed(10)
19 |
20 | # random.randrange(início, fim, passo)
21 | # -> Gera um número inteiro aleatório dentro de um intervalo específico
22 | r_range = random.randrange(10, 20, 2)
23 | print(r_range)
24 |
25 | # random.randint(início, fim)
26 | # -> Gera um número inteiro aleatório dentro de um intervalo "sem passo"
27 | r_int = random.randint(10, 20)
28 | print(r_int)
29 |
30 | # random.uniform(início, fim)
31 | # -> Gera um número flutuante aleatório dentro de um intervalo "sem passo"
32 | r_uniform = random.uniform(10, 20)
33 | print(r_uniform)
34 |
35 | # random.shuffle(SequenciaMutável) -> Embaralha a lista original
36 | nomes = ['Luiz', 'Maria', 'Helena', 'Joana']
37 | # random.shuffle(nomes)
38 | print(nomes)
39 |
40 | # random.sample(Iterável, k=N)
41 | # -> Escolhe elementos do iterável e retorna outro iterável (não repete)
42 | novos_nomes = random.sample(nomes, k=3)
43 | print(nomes)
44 | print(novos_nomes)
45 |
46 | # random.choices(Iterável, k=N)
47 | # -> Escolhe elementos do iterável e retorna outro iterável (repete valores)
48 | novos_nomes = random.choices(nomes, k=3)
49 | print(nomes)
50 | print(novos_nomes)
51 |
52 | # random.choice(Iterável) -> Escolhe um elemento do iterável
53 | print(random.choice(nomes))
54 |
--------------------------------------------------------------------------------
/aula183.py:
--------------------------------------------------------------------------------
1 | # string.Template para substituir variáveis em textos
2 | # doc: https://docs.python.org/3/library/string.html#template-strings
3 | # Métodos:
4 | # substitute: substitui mas gera erros se faltar chaves
5 | # safe_substitute: substitui sem gerar erros
6 | # Você também pode trocar o delimitador e outras coisas criando uma subclasse
7 | # de template.
8 | import locale
9 | import string
10 | from datetime import datetime
11 | from pathlib import Path
12 |
13 | CAMINHO_ARQUIVO = Path(__file__).parent / 'aula183.txt'
14 |
15 | locale.setlocale(locale.LC_ALL, '')
16 |
17 |
18 | def converte_para_brl(numero: float) -> str:
19 | brl = 'R$ ' + locale.currency(numero, symbol=False, grouping=True)
20 | return brl
21 |
22 |
23 | data = datetime(2022, 12, 28)
24 | dados = dict(
25 | nome='João',
26 | valor=converte_para_brl(1_234_456),
27 | data=data.strftime('%d/%m/%Y'),
28 | empresa='O. M.',
29 | telefone='+55 (11) 7890-5432'
30 | )
31 |
32 |
33 | class MyTemplate(string.Template):
34 | delimiter = '%'
35 |
36 |
37 | with open(CAMINHO_ARQUIVO, 'r') as arquivo:
38 | texto = arquivo.read()
39 | template = MyTemplate(texto)
40 | print(template.substitute(dados))
41 |
--------------------------------------------------------------------------------
/aula183.txt:
--------------------------------------------------------------------------------
1 | Prezado(a) %nome,
2 |
3 | Informamos que sua mensalidade será cobrada no valor de %{valor} no dia %data. Caso deseje cancelar o serviço, entre em contato com a %empresa pelo telefone %telefone.
4 |
5 | Atenciosamente,
6 |
7 | %{empresa},
8 |
--------------------------------------------------------------------------------
/aula184.py:
--------------------------------------------------------------------------------
1 | # Variáveis de ambiente com Python
2 | # Para variáveis de ambiente
3 | # Windows PS: $env:VARIAVEL="VALOR" | dir env:
4 | # Linux e Mac: export NOME_VARIAVEL="VALOR" | echo $VARIAVEL
5 | # Para obter o valor das variáveis de ambiente
6 | # os.getenv ou os.environ['VARIAVEL']
7 | # Para configurar variáveis de ambiente
8 | # os.environ['VARIAVEL'] = 'valor'
9 | # Ou usando python-dotenv e o arquivo .env
10 | # pip install python-dotenv
11 | # from dotenv import load_dotenv
12 | # load_dotenv()
13 | # https://pypi.org/project/python-dotenv/
14 | # OBS.: sempre lembre-se de criar um .env-example
15 | import os
16 |
17 | from dotenv import load_dotenv # type: ignore
18 |
19 | load_dotenv()
20 |
21 | # print(os.environ)
22 | print(os.getenv('BD_PASSWORD'))
23 |
--------------------------------------------------------------------------------
/aula185.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | Arquivo para o e-mail
8 |
9 |
10 | Olá ${nome},
11 |
12 | Estou testando
13 | este e-mail
14 | em HTML.
15 |
16 |
17 |
18 |
19 | Atenciosamente,
20 |
21 | Luiz Otávio.
22 |
23 |
24 |
25 |
--------------------------------------------------------------------------------
/aula185.py:
--------------------------------------------------------------------------------
1 | # Enviando E-mails SMTP com Python
2 | import os
3 | import pathlib
4 | import smtplib
5 | from email.mime.multipart import MIMEMultipart
6 | from email.mime.text import MIMEText
7 | from string import Template
8 |
9 | from dotenv import load_dotenv # type: ignore
10 |
11 | load_dotenv()
12 |
13 | # Caminho arquivo HTML
14 | CAMINHO_HTML = pathlib.Path(__file__).parent / 'aula185.html'
15 |
16 | # Dados do remetente e destinatário
17 | remetente = os.getenv('FROM_EMAIL', '')
18 | destinatario = remetente
19 |
20 | # Configurações SMTP
21 | smtp_server = 'smtp.gmail.com'
22 | smtp_port = 587
23 | smtp_username = os.getenv('FROM_EMAIL', '')
24 | smtp_password = os.getenv('EMAIL_PASSWORD', '')
25 |
26 | # Mensagem de texto
27 | with open(CAMINHO_HTML, 'r') as arquivo:
28 | texto_arquivo = arquivo.read()
29 | template = Template(texto_arquivo)
30 | texto_email = template.substitute(nome='Helena')
31 |
32 | # Transformar nossa mensagem em MIMEMultipart
33 | mime_multipart = MIMEMultipart()
34 | mime_multipart['from'] = remetente
35 | mime_multipart['to'] = destinatario
36 | mime_multipart['subject'] = 'Este é o assunto do e-mail'
37 |
38 | corpo_email = MIMEText(texto_email, 'html', 'utf-8')
39 | mime_multipart.attach(corpo_email)
40 |
41 | # Envia o e-mail
42 | with smtplib.SMTP(smtp_server, smtp_port) as server:
43 | server.ehlo()
44 | server.starttls()
45 | server.login(smtp_username, smtp_password)
46 | server.send_message(mime_multipart)
47 | print('E-mail enviado com sucesso!')
48 |
--------------------------------------------------------------------------------
/aula186.py:
--------------------------------------------------------------------------------
1 | # ZIP - Compactando / Descompactando arquivos com zipfile.ZipFile
2 | import os
3 | import shutil
4 | from pathlib import Path
5 | from zipfile import ZipFile
6 |
7 | # Caminhos
8 | CAMINHO_RAIZ = Path(__file__).parent
9 | CAMINHO_ZIP_DIR = CAMINHO_RAIZ / 'aula_186_diretorio_zip'
10 | CAMINHO_COMPACTADO = CAMINHO_RAIZ / 'aula186_compactado.zip'
11 | CAMINHO_DESCOMPACTADO = CAMINHO_RAIZ / 'aula186_descompactado'
12 |
13 | shutil.rmtree(CAMINHO_ZIP_DIR, ignore_errors=True)
14 | Path.unlink(CAMINHO_COMPACTADO, missing_ok=True)
15 | shutil.rmtree(str(CAMINHO_COMPACTADO).replace('.zip', ''), ignore_errors=True)
16 | shutil.rmtree(CAMINHO_DESCOMPACTADO, ignore_errors=True)
17 |
18 | # raise Exception()
19 |
20 | # Cria o diretório para a aula
21 | CAMINHO_ZIP_DIR.mkdir(exist_ok=True)
22 |
23 |
24 | def criar_arquivos(qtd: int, zip_dir: Path):
25 | for i in range(qtd):
26 | texto = 'arquivo_%s' % i
27 | with open(zip_dir / f'{texto}.txt', 'w') as arquivo:
28 | arquivo.write(texto)
29 |
30 |
31 | criar_arquivos(10, CAMINHO_ZIP_DIR)
32 |
33 | # Criando um zip e adicionando arquivos
34 | with ZipFile(CAMINHO_COMPACTADO, 'w') as zip:
35 | for root, dirs, files in os.walk(CAMINHO_ZIP_DIR):
36 | for file in files:
37 | # print(file)
38 | zip.write(os.path.join(root, file), file)
39 |
40 | # Lendo arquivos de um zip
41 | with ZipFile(CAMINHO_COMPACTADO, 'r') as zip:
42 | for arquivo in zip.namelist():
43 | print(arquivo)
44 |
45 | # Extraindo arquivos de um zip
46 | with ZipFile(CAMINHO_COMPACTADO, 'r') as zip:
47 | zip.extractall(CAMINHO_DESCOMPACTADO)
48 |
--------------------------------------------------------------------------------
/aula186_compactado.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/luizomf/cursopython2023/8a9fdecb25ef06775d25cd8b6a387a7241aab4e8/aula186_compactado.zip
--------------------------------------------------------------------------------
/aula186_descompactado/arquivo_0.txt:
--------------------------------------------------------------------------------
1 | arquivo_0
--------------------------------------------------------------------------------
/aula186_descompactado/arquivo_1.txt:
--------------------------------------------------------------------------------
1 | arquivo_1
--------------------------------------------------------------------------------
/aula186_descompactado/arquivo_2.txt:
--------------------------------------------------------------------------------
1 | arquivo_2
--------------------------------------------------------------------------------
/aula186_descompactado/arquivo_3.txt:
--------------------------------------------------------------------------------
1 | arquivo_3
--------------------------------------------------------------------------------
/aula186_descompactado/arquivo_4.txt:
--------------------------------------------------------------------------------
1 | arquivo_4
--------------------------------------------------------------------------------
/aula186_descompactado/arquivo_5.txt:
--------------------------------------------------------------------------------
1 | arquivo_5
--------------------------------------------------------------------------------
/aula186_descompactado/arquivo_6.txt:
--------------------------------------------------------------------------------
1 | arquivo_6
--------------------------------------------------------------------------------
/aula186_descompactado/arquivo_7.txt:
--------------------------------------------------------------------------------
1 | arquivo_7
--------------------------------------------------------------------------------
/aula186_descompactado/arquivo_8.txt:
--------------------------------------------------------------------------------
1 | arquivo_8
--------------------------------------------------------------------------------
/aula186_descompactado/arquivo_9.txt:
--------------------------------------------------------------------------------
1 | arquivo_9
--------------------------------------------------------------------------------
/aula187.py:
--------------------------------------------------------------------------------
1 | # sys.argv - Executando arquivos com argumentos no sistema
2 | # Fonte = Fira Code
3 | import sys
4 |
5 | argumentos = sys.argv
6 | qtd_argumentos = len(argumentos)
7 |
8 | if qtd_argumentos <= 1:
9 | print('Você não passou argumentos')
10 | else:
11 | try:
12 | print(f'Você passou os argumentos {argumentos[1:]}')
13 | print(f'Faça alguma coisa com {argumentos[1]}')
14 | print(f'Faça outra coisa com {argumentos[2]}')
15 | except IndexError:
16 | print('Faltam argumentos')
17 |
--------------------------------------------------------------------------------
/aula188.py:
--------------------------------------------------------------------------------
1 | # argparse.ArgumentParser para argumentos mais complexos
2 | # Tutorial Oficial:
3 | # https://docs.python.org/pt-br/3/howto/argparse.html
4 | from argparse import ArgumentParser
5 |
6 | parser = ArgumentParser()
7 |
8 | parser.add_argument(
9 | '-b', '--basic',
10 | help='Mostra "Olá mundo" na tela',
11 | # type=str, # Tipo do argumento
12 | metavar='STRING',
13 | # default='Olá mundo', # Valor padrão
14 | required=False,
15 | action='append', # Recebe o argumento mais de uma vez
16 | # nargs='+', # Recebe mais de um valor
17 | )
18 | parser.add_argument(
19 | '-v', '--verbose',
20 | help='Mostra logs',
21 | action='store_true'
22 | )
23 | args = parser.parse_args()
24 |
25 | if args.basic is None:
26 | print('Você não passou o valor de b.')
27 | print(args.basic)
28 | else:
29 | print('O valor de basic:', args.basic)
30 |
31 | print(args.verbose)
32 |
--------------------------------------------------------------------------------
/aula189.py:
--------------------------------------------------------------------------------
1 | # (Parte 2) Básico do protocolo HTTP (HyperText Transfer Protocol)
2 | # HTTP (HyperText Transfer Protocol) é um protocolo usado enviar e receber
3 | # dados na Internet. Ele funciona no modo cliente/servidor, onde o cliente
4 | # (seu navegador, por exemplo) faz uma requisição ao servidor
5 | # (site, por exemplo), que responde com os dados adequados.
6 | #
7 | # A mensagem de requisição do cliente deve incluir dados como:
8 | # - O método HTTP
9 | # - leitura (safe) - GET, HEAD (cabeçalhos), OPTIONS (métodos suportados)
10 | # - escrita - POST, PUT (substitui), PATCH (atualiza), DELETE
11 | # - O endereço do recurso a ser acessado (/users/)
12 | # - Os cabeçalhos HTTP (Content-Type, Authorization)
13 | # - O Corpo da mensagem (caso necessário, de acordo com o método HTTP)
14 | #
15 | # A mensagem de resposta do servidor deve incluir dados como:
16 | # - código de status HTTP (200 success, 404 Not found, 301 Moved Permanently)
17 | # https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
18 | # - Os cabeçalhos HTTP (Content-Type, Accept)
19 | # - O corpo da mensagem (Pode estar em vazio em alguns casos)
20 |
--------------------------------------------------------------------------------
/aula19.py:
--------------------------------------------------------------------------------
1 | """
2 | Operadores de comparação (relacionais)
3 | OP Significado Exemplo (True)
4 | > maior 2 > 1
5 | >= maior ou igual 2 >= 2
6 | < menor 1 < 2
7 | <= menor ou igual 2 <= 2
8 | == igual 'a' == 'a'
9 | != diferente 'a' != 'b'
10 | """
11 | maior = 2 > 1
12 | maior_ou_igual = 2 >= 2
13 | menor = 1 < 2
14 | menor_ou_igual = 2 <= 2
15 | igual = 'a' == 'a'
16 | diferente = 'a' != 'b'
17 | print('Olha meu print aqui')
18 |
--------------------------------------------------------------------------------
/aula191.py:
--------------------------------------------------------------------------------
1 | # requests para requisições HTTP
2 | # Tutorial -> https://youtu.be/Qd8JT0bnJGs
3 | import requests
4 |
5 | # http:// -> 80
6 | # https:// -> 443
7 | url = 'http://localhost:3333/'
8 | response = requests.get(url)
9 |
10 | print(response.status_code)
11 | # print(response.headers)
12 | # print(response.content)
13 | # print(response.json())
14 | print(response.text)
15 |
--------------------------------------------------------------------------------
/aula192.py:
--------------------------------------------------------------------------------
1 | # + Web Scraping com Python usando requests e bs4 BeautifulSoup
2 | # - Web Scraping é o ato de "raspar a web" buscando informações de forma
3 | # automatizada, com determinada linguagem de programação, para uso posterior.
4 | # - O módulo requests consegue carregar dados da Internet para dentro do seu
5 | # código. Já o bs4.BeautifulSoup é responsável por interpretar os dados HTML
6 | # em formato de objetos Python para facilitar a vida do desenvolvedor.
7 | # - Doc: https://www.crummy.com/software/BeautifulSoup/bs4/doc.ptbr/
8 | # + Instalação
9 | # - pip install requests types-requests bs4
10 | import re
11 |
12 | import requests
13 | from bs4 import BeautifulSoup
14 |
15 | url = 'http://127.0.0.1:3333/'
16 | response = requests.get(url)
17 | bytes_html = response.content
18 | parsed_html = BeautifulSoup(bytes_html, 'html.parser', from_encoding='utf-8')
19 |
20 | # if parsed_html.title is not None:
21 | # print(parsed_html.title.text)
22 |
23 | top_jobs_heading = parsed_html.select_one('#intro > div > div > article > h2')
24 |
25 | if top_jobs_heading is not None:
26 | article = top_jobs_heading.parent
27 |
28 | if article is not None:
29 | for p in article.select('p'):
30 | print(re.sub(r'\s{1,}', ' ', p.text).strip())
31 |
--------------------------------------------------------------------------------
/aula194.py:
--------------------------------------------------------------------------------
1 | # Usando subprocess para executar e comandos externos
2 | # subprocess é um módulo do Python para executar
3 | # processos e comandos externos no seu programa.
4 | # O método mais simples para atingir o objetivo é usando subprocess.run().
5 | # Argumentos principais de subprocess.run():
6 | # - stdout, stdin e stderr -> Redirecionam saída, entrada e erros
7 | # - capture_output -> captura a saída e erro para uso posterior
8 | # - text -> Se True, entradas e saídas serão tratadas como texto
9 | # e automaticamente codificadas ou decodificadas com o conjunto
10 | # de caracteres padrão da plataforma (geralmente UTF-8).
11 | # - shell -> Se True, terá acesso ao shell do sistema. Ao usar
12 | # shell (True), recomendo enviar o comando e os argumentos juntos.
13 | # - executable -> pode ser usado para especificar o caminho
14 | # do executável que iniciará o subprocesso.
15 | # Retorno:
16 | # stdout, stderr, returncode e args
17 | # Importante: a codificação de caracteres do Windows pode ser
18 | # diferente. Tente usar cp1252, cp852, cp850 (ou outros). Linux e
19 | # mac, use utf_8.
20 | # Comando de exemplo:
21 | # Windows: ping 127.0.0.1
22 | # Linux/Mac: ping 127.0.0.1 -c 4
23 | import subprocess
24 | import sys
25 |
26 | # sys.platform = linux, linux2, darwin, win32
27 |
28 | cmd = ['ls -lah /']
29 | encoding = 'utf_8'
30 | system = sys.platform
31 |
32 | if system == "win32":
33 | cmd = ['ping', '127.0.0.1']
34 | encoding = 'cp850'
35 |
36 |
37 | proc = subprocess.run(
38 | cmd, capture_output=True,
39 | text=True, encoding=encoding,
40 | shell=True,
41 | )
42 |
43 | print()
44 |
45 | # print(proc.args)
46 | # print(proc.stderr)
47 | print(proc.stdout)
48 | # print(proc.returncode)
49 |
--------------------------------------------------------------------------------
/aula195.py:
--------------------------------------------------------------------------------
1 | # Jupyter Notebook - Instalação e teste
2 |
3 | # Essa linha cria uma variável a
4 | a = 2
5 |
6 | # Essa linha tem o valor da variável `a` em dobro
7 | b = a * 2 # 4
8 |
9 | # Essa linha mostra o valor de `a` + `b`
10 | print(a + b) # 6
11 |
--------------------------------------------------------------------------------
/aula197/arquivos_novos/MERGED.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/luizomf/cursopython2023/8a9fdecb25ef06775d25cd8b6a387a7241aab4e8/aula197/arquivos_novos/MERGED.pdf
--------------------------------------------------------------------------------
/aula197/arquivos_novos/X5.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/luizomf/cursopython2023/8a9fdecb25ef06775d25cd8b6a387a7241aab4e8/aula197/arquivos_novos/X5.png
--------------------------------------------------------------------------------
/aula197/arquivos_novos/page0.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/luizomf/cursopython2023/8a9fdecb25ef06775d25cd8b6a387a7241aab4e8/aula197/arquivos_novos/page0.pdf
--------------------------------------------------------------------------------
/aula197/arquivos_novos/page1.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/luizomf/cursopython2023/8a9fdecb25ef06775d25cd8b6a387a7241aab4e8/aula197/arquivos_novos/page1.pdf
--------------------------------------------------------------------------------
/aula197/main.py:
--------------------------------------------------------------------------------
1 | # PyPDF2 para manipular arquivos PDF (PdfMerger)
2 | # PyPDF2 é uma biblioteca de manipulação de arquivos PDF feita em Python puro,
3 | # gratuita e de código aberto. Ela é capaz de ler, manipular, escrever e unir
4 | # dados de arquivos PDF, assim como adicionar anotações, transformar páginas,
5 | # extrair texto e imagens, manipular metadados, e mais.
6 | # A documentação contém todas as informações necessárias para usar PyPDF2.
7 | # Link: https://pypdf2.readthedocs.io/en/3.0.0/
8 | # Ative seu ambiente virtual
9 | # pip install pypdf2
10 | from pathlib import Path
11 |
12 | from PyPDF2 import PdfMerger, PdfReader, PdfWriter
13 |
14 | PASTA_RAIZ = Path(__file__).parent
15 | PASTA_ORIGINAIS = PASTA_RAIZ / 'pdfs_originais'
16 | PASTA_NOVA = PASTA_RAIZ / 'arquivos_novos'
17 |
18 | RELATORIO_BACEN = PASTA_ORIGINAIS / 'R20230210.pdf'
19 |
20 | PASTA_NOVA.mkdir(exist_ok=True)
21 |
22 | reader = PdfReader(RELATORIO_BACEN)
23 |
24 | # print(len(reader.pages))
25 | # for page in reader.pages:
26 | # print(page)
27 | # print()
28 |
29 | page0 = reader.pages[0]
30 | imagem0 = page0.images[0]
31 |
32 | # print(page0.extract_text())
33 | # with open(PASTA_NOVA / imagem0.name, 'wb') as fp:
34 | # fp.write(imagem0.data)
35 |
36 |
37 | for i, page in enumerate(reader.pages):
38 | writer = PdfWriter()
39 | with open(PASTA_NOVA / f'page{i}.pdf', 'wb') as arquivo:
40 | writer.add_page(page)
41 | writer.write(arquivo) # type: ignore
42 |
43 |
44 | files = [
45 | PASTA_NOVA / 'page1.pdf',
46 | PASTA_NOVA / 'page0.pdf',
47 |
48 | ]
49 |
50 | merger = PdfMerger()
51 | for file in files:
52 | merger.append(file) # type: ignore
53 |
54 | merger.write(PASTA_NOVA / 'MERGED.pdf') # type: ignore
55 | merger.close()
56 |
--------------------------------------------------------------------------------
/aula197/pdfs_originais/R20230210.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/luizomf/cursopython2023/8a9fdecb25ef06775d25cd8b6a387a7241aab4e8/aula197/pdfs_originais/R20230210.pdf
--------------------------------------------------------------------------------
/aula199/creating.py:
--------------------------------------------------------------------------------
1 | # openpyxl - manipulando as planilhas do Workbook
2 | # Com essa biblioteca será possível ler e escrever dados em células
3 | # específicas, formatar células, inserir gráficos,
4 | # criar fórmulas, adicionar imagens e outros elementos gráficos às suas
5 | # planilhas. Ela é útil para automatizar tarefas envolvendo planilhas do
6 | # Excel, como a criação de relatórios e análise de dados e/ou facilitando a
7 | # manipulação de grandes quantidades de informações.
8 | # Instalação necessária: pip install openpyxl
9 | # Documentação: https://openpyxl.readthedocs.io/en/stable/
10 | from pathlib import Path
11 |
12 | from openpyxl import Workbook
13 | from openpyxl.worksheet.worksheet import Worksheet
14 |
15 | ROOT_FOLDER = Path(__file__).parent
16 | WORKBOOK_PATH = ROOT_FOLDER / 'workbook.xlsx'
17 |
18 | workbook = Workbook()
19 | # worksheet: Worksheet = workbook.active
20 |
21 | # Nome para a planilha
22 | sheet_name = 'Minha planilha'
23 | # Criamos a planilha
24 | workbook.create_sheet(sheet_name, 0)
25 | # Selecionou a planilha
26 | worksheet: Worksheet = workbook[sheet_name]
27 |
28 | # Remover uma planilha
29 | workbook.remove(workbook['Sheet'])
30 |
31 | # Criando os cabeçalhos
32 | worksheet.cell(1, 1, 'Nome')
33 | worksheet.cell(1, 2, 'Idade')
34 | worksheet.cell(1, 3, 'Nota')
35 |
36 | students = [
37 | # nome idade nota
38 | ['João', 14, 5.5],
39 | ['Maria', 13, 9.7],
40 | ['Luiz', 15, 8.8],
41 | ['Alberto', 16, 10],
42 | ]
43 |
44 | # for i, student_row in enumerate(students, start=2):
45 | # for j, student_column in enumerate(student_row, start=1):
46 | # worksheet.cell(i, j, student_column)
47 |
48 | for student in students:
49 | worksheet.append(student)
50 |
51 | workbook.save(WORKBOOK_PATH)
52 |
--------------------------------------------------------------------------------
/aula199/reading.py:
--------------------------------------------------------------------------------
1 | # openpyxl - ler e alterar dados de uma planilha
2 | # Com essa biblioteca será possível ler e escrever dados em células
3 | # específicas, formatar células, inserir gráficos,
4 | # criar fórmulas, adicionar imagens e outros elementos gráficos às suas
5 | # planilhas. Ela é útil para automatizar tarefas envolvendo planilhas do
6 | # Excel, como a criação de relatórios e análise de dados e/ou facilitando a
7 | # manipulação de grandes quantidades de informações.
8 | # Instalação necessária: pip install openpyxl
9 | # Documentação: https://openpyxl.readthedocs.io/en/stable/
10 | from pathlib import Path
11 |
12 | from openpyxl import Workbook, load_workbook
13 | from openpyxl.cell import Cell
14 | from openpyxl.worksheet.worksheet import Worksheet
15 |
16 | ROOT_FOLDER = Path(__file__).parent
17 | WORKBOOK_PATH = ROOT_FOLDER / 'workbook.xlsx'
18 |
19 | # Carregando um arquivo do excel
20 | workbook: Workbook = load_workbook(WORKBOOK_PATH)
21 |
22 | # Nome para a planilha
23 | sheet_name = 'Minha planilha'
24 |
25 | # Selecionou a planilha
26 | worksheet: Worksheet = workbook[sheet_name]
27 |
28 | row: tuple[Cell]
29 | for row in worksheet.iter_rows(min_row=2):
30 | for cell in row:
31 | print(cell.value, end='\t')
32 |
33 | if cell.value == 'Maria':
34 | worksheet.cell(cell.row, 2, 23)
35 | print()
36 |
37 | # worksheet['B3'].value = 14
38 |
39 | workbook.save(WORKBOOK_PATH)
40 |
--------------------------------------------------------------------------------
/aula199/workbook.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/luizomf/cursopython2023/8a9fdecb25ef06775d25cd8b6a387a7241aab4e8/aula199/workbook.xlsx
--------------------------------------------------------------------------------
/aula2.py:
--------------------------------------------------------------------------------
1 | # \r\n -> CRLF
2 | # \n -> LF
3 | print(12, 34, 1011, sep="", end='#')
4 | print(56, 78, sep='-', end='\n')
5 | print(9, 10, sep='-', end='\n')
6 |
--------------------------------------------------------------------------------
/aula20.py:
--------------------------------------------------------------------------------
1 | primeiro_valor = input('Digite um valor: ')
2 | segundo_valor = input('Digite outro valor: ')
3 |
4 | if primeiro_valor >= segundo_valor:
5 | print(
6 | f'{primeiro_valor=} é maior ou igual '
7 | f'ao que {segundo_valor=}'
8 | )
9 | else:
10 | print(
11 | f'{segundo_valor=} é maior '
12 | f'do que {primeiro_valor=}'
13 | )
14 |
--------------------------------------------------------------------------------
/aula200/ new.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/luizomf/cursopython2023/8a9fdecb25ef06775d25cd8b6a387a7241aab4e8/aula200/ new.JPG
--------------------------------------------------------------------------------
/aula200/main.py:
--------------------------------------------------------------------------------
1 | # Pillow: redimensionando imagens com Python
2 | # Essa biblioteca é o Photoshop do Python 😂
3 | from pathlib import Path
4 |
5 | from PIL import Image
6 |
7 | ROOT_FOLDER = Path(__file__).parent
8 | ORIGINAL = ROOT_FOLDER / 'original.JPG'
9 | NEW_IMAGE = ROOT_FOLDER / ' new.JPG'
10 |
11 | pil_image = Image.open(ORIGINAL)
12 | width, height = pil_image.size
13 | exif = pil_image.info['exif']
14 |
15 | # width new_width
16 | # height ??
17 | new_width = 640
18 | new_height = round(height * new_width / width)
19 |
20 | new_image = pil_image.resize(size=(new_width, new_height))
21 | new_image.save(
22 | NEW_IMAGE,
23 | optimize=True,
24 | quality=70,
25 | # exif=exif,
26 | )
27 |
--------------------------------------------------------------------------------
/aula200/original.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/luizomf/cursopython2023/8a9fdecb25ef06775d25cd8b6a387a7241aab4e8/aula200/original.JPG
--------------------------------------------------------------------------------
/aula201/aula0001.py:
--------------------------------------------------------------------------------
1 | # PySide6 para GUI (interface gráfica) com Qt em Python - Instalação
2 | # - A seção original desse curso usou PyQt5 (estamos atualizando para PySide6)
3 | # - Essas bibliotecas (PySide e PyQt) usam a biblioteca Qt
4 | # - Qt é uma biblioteca usada para a criação de GUI (interface gráfica
5 | # do usuário) escrita em C++.
6 | # - PySide e PyQt conseguem fazer a ponte (binding) entre o Python e a
7 | # biblioteca para a criação de interfaces gráficas sem ter que usar outra
8 | # linguagem de programação.
9 | # - PySide6 é uma referencia à versão 6 da Qt (Qt 6)
10 | # - Qt é multiplataforma, ou seja, deve funcionar em Windows, Linux e Mac.
11 |
12 | # Por que mudei de PyQt para PySide na atualização?
13 | # - PySide foi desenvolvido pela The Qt Company (da Nokia), como parte do
14 | # projeto Qt for Python project - https://doc.qt.io/qtforpython/
15 | # - Por usarem a mesma biblioteca (Qt), PySide e PyQt são extremamente
16 | # similares, muitas vezes os códigos são idênticos. Portanto, mesmo que você
17 | # ainda queira usar PyQt, será muito simples portar os códigos. Muitas vezes
18 | # basta trocar o nome de PySide para PyQt e vice-versa.
19 | # - A maior diferença entre PyQt e PySide está na licença:
20 | # PyQt usa GPL ou commercial e PySide usa LGPL.
21 | # Em resumo: com PySide, você tem a permissão uso da biblioteca para fins
22 | # comerciais, sem ter que compartilhar o código escrito por você para o
23 | # público.
24 | # Licenças são tópicos complexos, portanto, se oriente sobre elas
25 | # antes de usar qualquer software de terceiros.
26 | # https://tldrlegal.com/license/gnu-lesser-general-public-license-v3-(lgpl-3)
27 | import PySide6.QtCore
28 |
29 | # Prints PySide6 version
30 | print(PySide6.__version__) # type: ignore
31 |
32 | # Prints the Qt version used to compile PySide6
33 | print(PySide6.QtCore.__version__) # type: ignore
34 |
--------------------------------------------------------------------------------
/aula201/aula0002.py:
--------------------------------------------------------------------------------
1 | # QApplication e QPushButton de PySide6.QtWidgets
2 | # QApplication -> O Widget principal da aplicação
3 | # QPushButton -> Um botão
4 | # PySide6.QtWidgets -> Onde estão os widgets do PySide6
5 | import sys
6 |
7 | from PySide6.QtWidgets import QApplication, QPushButton
8 |
9 | app = QApplication(sys.argv)
10 |
11 | botao = QPushButton('Texto do botão')
12 | botao.setStyleSheet('font-size: 40px;')
13 | botao.show() # Adiciona o widget na hierarquia e exibe a janela
14 |
15 | app.exec() # O loop da aplicação
16 |
--------------------------------------------------------------------------------
/aula201/aula0003.py:
--------------------------------------------------------------------------------
1 | # QWidget e QLayout de PySide6.QtWidgets
2 | # QWidget -> genérico
3 | # QLayout -> Um widget de layout que recebe outros widgets
4 | import sys
5 |
6 | from PySide6.QtWidgets import QApplication, QGridLayout, QPushButton, QWidget
7 |
8 | app = QApplication(sys.argv)
9 |
10 | botao = QPushButton('Texto do botão')
11 | botao.setStyleSheet('font-size: 80px;')
12 |
13 | botao2 = QPushButton('Botão 2')
14 | botao2.setStyleSheet('font-size: 40px;')
15 |
16 | botao3 = QPushButton('Botão 3')
17 | botao3.setStyleSheet('font-size: 40px;')
18 |
19 | central_widget = QWidget()
20 |
21 | layout = QGridLayout()
22 | central_widget.setLayout(layout)
23 |
24 | layout.addWidget(botao, 1, 1, 1, 1)
25 | layout.addWidget(botao2, 1, 2, 1, 1)
26 | layout.addWidget(botao3, 3, 1, 1, 2)
27 |
28 | central_widget.show() # Central widget entre na hierarquia e mostre sua janela
29 | app.exec() # O loop da aplicação
30 |
--------------------------------------------------------------------------------
/aula201/aula0004.py:
--------------------------------------------------------------------------------
1 | # QMainWindow e centralWidget
2 | # -> QApplication (app)
3 | # -> QMainWindow (window->setCentralWidget)
4 | # -> CentralWidget (central_widget)
5 | # -> Layout (layout)
6 | # -> Widget 1 (botao1)
7 | # -> Widget 2 (botao2)
8 | # -> Widget 3 (botao3)
9 | # -> show
10 | # -> exec
11 | import sys
12 |
13 | from PySide6.QtWidgets import (QApplication, QGridLayout, QMainWindow,
14 | QPushButton, QWidget)
15 |
16 | app = QApplication(sys.argv)
17 | window = QMainWindow()
18 | central_widget = QWidget()
19 | window.setCentralWidget(central_widget)
20 | window.setWindowTitle('Minha janela bonita')
21 |
22 | botao1 = QPushButton('Texto do botão')
23 | botao1.setStyleSheet('font-size: 80px;')
24 |
25 | botao2 = QPushButton('Botão 2')
26 | botao2.setStyleSheet('font-size: 40px;')
27 |
28 | botao3 = QPushButton('Botão 3')
29 | botao3.setStyleSheet('font-size: 40px;')
30 |
31 | layout = QGridLayout()
32 | central_widget.setLayout(layout)
33 |
34 | layout.addWidget(botao1, 1, 1, 1, 1)
35 | layout.addWidget(botao2, 1, 2, 1, 1)
36 | layout.addWidget(botao3, 3, 1, 1, 2)
37 |
38 |
39 | def slot_example(status_bar):
40 | status_bar.showMessage('O meu slot foi executado')
41 |
42 |
43 | # statusBar
44 | status_bar = window.statusBar()
45 | status_bar.showMessage('Mostrar mensagem na barra')
46 |
47 | # menuBar
48 | menu = window.menuBar()
49 | primeiro_menu = menu.addMenu('Primeiro menu')
50 | primeira_acao = primeiro_menu.addAction('Primeira ação')
51 | primeira_acao.triggered.connect( # type:ignore
52 | lambda: slot_example(status_bar)
53 | )
54 |
55 |
56 | window.show()
57 | app.exec() # O loop da aplicação
58 |
--------------------------------------------------------------------------------
/aula202-calculadora/files/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/luizomf/cursopython2023/8a9fdecb25ef06775d25cd8b6a387a7241aab4e8/aula202-calculadora/files/icon.png
--------------------------------------------------------------------------------
/aula202-calculadora/info.py:
--------------------------------------------------------------------------------
1 | from PySide6.QtCore import Qt
2 | from PySide6.QtWidgets import QLabel, QWidget
3 | from variables import SMALL_FONT_SIZE
4 |
5 |
6 | class Info(QLabel):
7 | def __init__(self, text: str, parent: QWidget | None = None) -> None:
8 | super().__init__(text, parent)
9 | self.configStyle()
10 |
11 | def configStyle(self):
12 | self.setStyleSheet(f'font-size: {SMALL_FONT_SIZE}px;')
13 | self.setAlignment(Qt.AlignmentFlag.AlignRight)
14 |
--------------------------------------------------------------------------------
/aula202-calculadora/main.py:
--------------------------------------------------------------------------------
1 | import sys
2 |
3 | from buttons import ButtonsGrid
4 | from display import Display
5 | from info import Info
6 | from main_window import MainWindow
7 | from PySide6.QtGui import QIcon
8 | from PySide6.QtWidgets import QApplication
9 | from styles import setupTheme
10 | from variables import WINDOW_ICON_PATH
11 |
12 | if __name__ == '__main__':
13 | # Cria a aplicação
14 | app = QApplication(sys.argv)
15 | setupTheme()
16 | window = MainWindow()
17 |
18 | # Define o ícone
19 | icon = QIcon(str(WINDOW_ICON_PATH))
20 | window.setWindowIcon(icon)
21 | app.setWindowIcon(icon)
22 |
23 | # Info
24 | info = Info('Sua conta')
25 | window.addWidgetToVLayout(info)
26 |
27 | # Display
28 | display = Display()
29 | window.addWidgetToVLayout(display)
30 |
31 | # Grid
32 | buttonsGrid = ButtonsGrid(display, info, window)
33 | window.vLayout.addLayout(buttonsGrid)
34 |
35 | # Executa tudo
36 | window.adjustFixedSize()
37 | window.show()
38 | app.exec()
39 |
--------------------------------------------------------------------------------
/aula202-calculadora/main_window.py:
--------------------------------------------------------------------------------
1 | from PySide6.QtWidgets import QMainWindow, QMessageBox, QVBoxLayout, QWidget
2 |
3 |
4 | class MainWindow(QMainWindow):
5 | def __init__(self, parent: QWidget | None = None, *args, **kwargs) -> None:
6 | super().__init__(parent, *args, **kwargs)
7 |
8 | # Configurando o layout básico
9 | self.cw = QWidget()
10 | self.vLayout = QVBoxLayout()
11 | self.cw.setLayout(self.vLayout)
12 | self.setCentralWidget(self.cw)
13 |
14 | # Título da janela
15 | self.setWindowTitle('Calculadora')
16 |
17 | def adjustFixedSize(self):
18 | # Última coisa a ser feita
19 | self.adjustSize()
20 | self.setFixedSize(self.width(), self.height())
21 |
22 | def addWidgetToVLayout(self, widget: QWidget):
23 | self.vLayout.addWidget(widget)
24 |
25 | def makeMsgBox(self):
26 | return QMessageBox(self)
27 |
--------------------------------------------------------------------------------
/aula202-calculadora/styles.py:
--------------------------------------------------------------------------------
1 | # QSS - Estilos do QT for Python
2 | # https://doc.qt.io/qtforpython/tutorials/basictutorial/widgetstyling.html
3 | # Dark Theme
4 | # https://pyqtdarktheme.readthedocs.io/en/latest/how_to_use.html
5 | import qdarktheme
6 | from variables import (DARKER_PRIMARY_COLOR, DARKEST_PRIMARY_COLOR,
7 | PRIMARY_COLOR)
8 |
9 | qss = f"""
10 | QPushButton[cssClass="specialButton"] {{
11 | color: #fff;
12 | background: {PRIMARY_COLOR};
13 | }}
14 | QPushButton[cssClass="specialButton"]:hover {{
15 | color: #fff;
16 | background: {DARKER_PRIMARY_COLOR};
17 | }}
18 | QPushButton[cssClass="specialButton"]:pressed {{
19 | color: #fff;
20 | background: {DARKEST_PRIMARY_COLOR};
21 | }}
22 | """
23 |
24 |
25 | def setupTheme():
26 | qdarktheme.setup_theme(
27 | theme='dark',
28 | corner_shape='rounded',
29 | custom_colors={
30 | "[dark]": {
31 | "primary": f"{PRIMARY_COLOR}",
32 | },
33 | "[light]": {
34 | "primary": f"{PRIMARY_COLOR}",
35 | },
36 | },
37 | additional_qss=qss
38 | )
39 |
--------------------------------------------------------------------------------
/aula202-calculadora/utils.py:
--------------------------------------------------------------------------------
1 | import re
2 |
3 | NUM_OR_DOT_REGEX = re.compile(r'^[0-9.]$')
4 |
5 |
6 | def isNumOrDot(string: str):
7 | return bool(NUM_OR_DOT_REGEX.search(string))
8 |
9 |
10 | def converToNumber(string: str):
11 | number = float(string)
12 |
13 | if number.is_integer():
14 | number = int(number)
15 |
16 | return number
17 |
18 |
19 | def isValidNumber(string: str):
20 | valid = False
21 | try:
22 | float(string)
23 | valid = True
24 | except ValueError:
25 | valid = False
26 | return valid
27 |
28 |
29 | def isEmpty(string: str):
30 | return len(string) == 0
31 |
--------------------------------------------------------------------------------
/aula202-calculadora/variables.py:
--------------------------------------------------------------------------------
1 | from pathlib import Path
2 |
3 | ROOT_DIR = Path(__file__).parent
4 | FILES_DIR = ROOT_DIR / 'files'
5 | WINDOW_ICON_PATH = FILES_DIR / 'icon.png'
6 |
7 | # Colors
8 | PRIMARY_COLOR = '#1e81b0'
9 | DARKER_PRIMARY_COLOR = '#16658a'
10 | DARKEST_PRIMARY_COLOR = '#115270'
11 |
12 | # Sizing
13 | BIG_FONT_SIZE = 40
14 | MEDIUM_FONT_SIZE = 24
15 | SMALL_FONT_SIZE = 18
16 | TEXT_MARGIN = 15
17 | MINIMUM_WIDTH = 500
18 |
--------------------------------------------------------------------------------
/aula203-qtdesigner/src/main_window.py:
--------------------------------------------------------------------------------
1 | import sys
2 | from typing import cast
3 |
4 | from PySide6.QtCore import QEvent, QObject
5 | from PySide6.QtGui import QKeyEvent
6 | from PySide6.QtWidgets import QApplication, QMainWindow
7 | from window import Ui_MainWindow
8 |
9 |
10 | class MainWindow(QMainWindow, Ui_MainWindow):
11 | def __init__(self, parent=None):
12 | super().__init__(parent)
13 | self.setupUi(self)
14 |
15 | self.buttonSend.clicked.connect(self.changeLabelResult) # type: ignore
16 |
17 | self.lineName.installEventFilter(self)
18 |
19 | def changeLabelResult(self):
20 | text = self.lineName.text()
21 | self.labelResult.setText(text)
22 |
23 | def eventFilter(self, watched: QObject, event: QEvent) -> bool:
24 | if event.type() == QEvent.Type.KeyPress:
25 | # Tenho certeza que o tipo é KeyPress
26 | event = cast(QKeyEvent, event)
27 | text = self.lineName.text()
28 | self.labelResult.setText(text + event.text())
29 |
30 | return super().eventFilter(watched, event)
31 |
32 |
33 | if __name__ == '__main__':
34 | app = QApplication(sys.argv)
35 | mainWindow = MainWindow()
36 | mainWindow.show()
37 | app.exec()
38 |
--------------------------------------------------------------------------------
/aula204/workerui.ui:
--------------------------------------------------------------------------------
1 |
2 |
3 | myWidget
4 |
5 |
6 |
7 | 0
8 | 0
9 | 400
10 | 300
11 |
12 |
13 |
14 |
15 | 40
16 |
17 |
18 |
19 | Form
20 |
21 |
22 | -
23 |
24 |
-
25 |
26 |
27 | L2
28 |
29 |
30 |
31 | -
32 |
33 |
34 | L1
35 |
36 |
37 |
38 | -
39 |
40 |
41 | B1
42 |
43 |
44 |
45 | -
46 |
47 |
48 | B2
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
--------------------------------------------------------------------------------
/aula205/select.py:
--------------------------------------------------------------------------------
1 | import sqlite3
2 |
3 | from main import DB_FILE, TABLE_NAME
4 |
5 | connection = sqlite3.connect(DB_FILE)
6 | cursor = connection.cursor()
7 |
8 | cursor.execute(
9 | f'SELECT * FROM {TABLE_NAME}'
10 | )
11 |
12 | for row in cursor.fetchall():
13 | _id, name, weight = row
14 | print(_id, name, weight)
15 |
16 |
17 | print()
18 |
19 | cursor.execute(
20 | f'SELECT * FROM {TABLE_NAME} '
21 | 'WHERE id = "3"'
22 | )
23 | row = cursor.fetchone()
24 | _id, name, weight = row
25 | print(_id, name, weight)
26 |
27 | cursor.close()
28 | connection.close()
29 |
--------------------------------------------------------------------------------
/aula206/.env-example:
--------------------------------------------------------------------------------
1 | MYSQL_ROOT_PASSWORD = 'CHANGE-ME'
2 | MYSQL_DATABASE = 'CHANGE-ME'
3 | MYSQL_USER = 'CHANGE-ME'
4 | MYSQL_PASSWORD = 'CHANGE-ME'
5 | MYSQL_HOST = 'CHANGE-ME'
6 |
--------------------------------------------------------------------------------
/aula206/docker-compose.yml:
--------------------------------------------------------------------------------
1 | version: '3.9'
2 | services:
3 | mysql_206:
4 | env_file:
5 | - .env
6 | container_name: mysql_206
7 | hostname: mysql_206
8 | image: mysql:8
9 | restart: always
10 | command:
11 | - --authentication-policy=mysql_native_password
12 | - --character-set-server=utf8mb4
13 | - --collation-server=utf8mb4_unicode_ci
14 | - --innodb_force_recovery=0
15 | volumes:
16 | - ./mysql_206:/var/lib/mysql
17 | ports:
18 | - 3306:3306
19 | environment:
20 | TZ: America/Sao_Paulo
21 |
--------------------------------------------------------------------------------
/aula207_ola_django/base/global/base.html:
--------------------------------------------------------------------------------
1 | {% include 'global/partials/head.html' %}
2 | {% include 'global/partials/menu.html' %}
3 |
4 | {% if text %}
5 | {% block texto %}{% endblock texto %}
6 | {% endif %}
7 |
8 |
9 | {% block posts %}{% endblock posts %}
10 | {% block home %}{% endblock home %}
11 |
12 |
13 |
14 |