4 |
5 | 
18 |
19 | - As codificações de transferências *gzip* e *deflate* são decodificadas automaticamente para você.
--------------------------------------------------------------------------------
/Introdução/motivacao.MD:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
20 |
21 | pip install pytest
22 |
--------------------------------------------------------------------------------
/Trabalhando-com-API's/Realizando-requisições/delete.md:
--------------------------------------------------------------------------------
1 | ## Requisição DELETE
2 |
3 | - Com a lib *requests* podemos enviar uma simples requisição __DELETE__, da seguinte forma:
4 |
5 | ```python
6 | In[]:
7 |
8 | import requests
9 |
10 |
11 | r = requests.delete("http://httpbin.org/delete")
12 | print(r)
13 | ```
14 | ```python
15 | Out[]:
16 |
17 | # Retornando o codigo 504
18 | 
24 |
25 | Dessa forma, passamos os valores de um formulário pelo headers da *URL* e criamos um novo registro na *API*.
--------------------------------------------------------------------------------
/Instruções-simples/pass.md:
--------------------------------------------------------------------------------
1 | ## Declaração pass
2 |
3 | - Essa declaração é usada quando uma instrução é requerida sintaticamente, mas você não deseja que nenhum comando ou código seja executado;
4 | - A declaração __pass__ é uma operação *null*, nada acontece quando ela é usada.
5 |
6 | ## Exemplo
7 |
8 | ```python
9 | In[]:
10 |
11 | for letra in 'Python':
12 | if letra == 'h':
13 | pass
14 | print 'Esse é um bloco usando a declaração pass'
15 | print 'Letra atual :', letra
16 | print "aaaaadeus!"
17 |
18 | ```
19 | ```python
20 | Out[]:
21 |
22 | Letra atual : P
23 | Letra atual : y
24 | Letra atual : t
25 | Esse é um bloco usando a declaração pass
26 | Letra atual : h
27 | Letra atual : o
28 | Letra atual : n
29 | aaaaadeus!
30 |
31 | ```
--------------------------------------------------------------------------------
/Expressões/introdução.md:
--------------------------------------------------------------------------------
1 | ## Expressões
2 |
3 | - Sabemos que grande parte do trabalho do computador é realizar calculos e, com base nesses calculos, executar ações que auxiliam o usuário no dia a dia;
4 | - Uma regra básica é que toda expressão calculada pelo computador deve sempre devolver o mesmo resultado. Por exemplo, a expressão 2 + 3 * 4 poderia devolver o valor 20 caso a soma 2+3 seja calculada antes da multiplicação. Felizmente o Python segue as regras de precedência dos operadores que nós estamos acostumados e o resultado devolvido é 14. Faça um teste você mesmo digitando essa expressão no Python shell como:
5 |
6 | ```python
7 | In[]
8 |
9 | 2+3*4
10 | ```
11 | ```python
12 | Out[]
13 |
14 | 14
15 | ```
16 | 
35 |
--------------------------------------------------------------------------------
/Módulo-Tkinter/interfaces_graficas_tkinter.md:
--------------------------------------------------------------------------------
1 | ## Interfaces graficas com Python e Tkinter
2 |
3 | - __Tkinter__ é a biblioteca *GUI* padrão para Python. O Python, quando combinado com o Tkinter, fornece uma maneira rápida e fácil de criar aplicativos *GUI*. O __Tkinter__ fornece uma poderosa interface orientada a objetos para o kit de ferramentas *Tk GUI*.
4 |
5 | __GUI__: abreviadamente, o acrônimo __GUI__, vem do inglês *Graphical User Interface* (*interface gráfica do utilizador*).
6 |
7 |
8 | Para utilizar tal módulo do python, o mesmo precisa ser instalado em seu OS.
9 |
10 | ``` sudo apt install python-tk ```
11 |
12 | __Obs:__ *Lembrando que, a instalação dessa biblioteca é altamente recomendada para ser usada em ambientes linux, ja que a instalação da mesma em outros OS demanda muito tempo e trabalho de configuração, que no final acabam não valendo a pena.*
13 |
14 | 
15 |
16 | Após a instalação concluida, podemos ir para o [proximo passo](/Módulo-Tkinter/hello_world.md).
--------------------------------------------------------------------------------
/Manipulando-arquivos/entendendo_manipulacao_arquivos.md:
--------------------------------------------------------------------------------
1 | ## Entendendo...
2 |
3 | 4 | A manipulação de arquivos é um trabalho muito importante para todo o desenvolvedor, seja para alterar um arquivo ou fazer um backup e muitas vezes chega a ser desafiador e, convenhamos, isso da um sabor a tudo! 5 |
6 |7 | No Python não é diferente e a manipulação de arquivos é mais simples do que você possa imaginar. Por isso, veremos neste capitulo como realizar as principais operações com arquivos utilizando o Python. 8 |
9 |10 | A manipulação de arquivos contém alguns termos importantes e que serão de conhecimento obrigatorio para dominar essa parte dos estudos. A tabela abaixo representa o que foi dito nesse tópico: 11 |
12 |
13 | 
14 |
7 |
8 |
9 | ## Operadores logicos
10 |
11 | - Há três operadores logicos, sendo eles, __and__, __or__ e __not__. Sua semantica/significado é o mesmo do que no ingles;
12 |
13 | Vejamos alguns exemplos teoricos:
14 |
15 | __and__:
16 | ```python
17 | x>0 and x<10
18 | ```
19 |
20 | A expressão acima só retornará *true* caso as duas condições forem cumpridas. Ou seja, se ambos os casos a variavel *x* for maior que zero e menor que 10.
21 | if C else y avalia primeiro a condição *C* em vez de *x*. Se *C* for verdadeiro, *x* é avaliado e seu valor é retornado; caso contrário, *y* é avaliado e seu valor é retornado.
5 |
6 | Sintaxe:
7 | ```python
8 | (if
9 |
10 | dados = (3.14,"hert developers")
11 |
12 |
13 |
14 |
15 | dados.append(75)
16 |
17 | Saída
18 |
19 |
20 | 'tuple' object has no attribute 'append'
21 |
22 |
23 |
26 |
27 | dados.remove(3.14)
28 |
29 | Saída
30 |
31 |
32 | 'tuple' object has no attribute 'remove'
33 |
34 |
36 |
37 | dados[0] = -5
38 |
39 | Saída
40 |
41 |
42 | 'tuple' object does not support item assignment
43 |
44 |
45 | ## Finalizando
46 | Você agora possui conhecimento sobre oque é uma tupla e como funcionam, em python. Prossiga nos seus estudos e pule para o próximo readme.
47 | 
21 |
22 | - O encoding do conteúdo costuma ser automatico baseada nos cabeçalhos HTTP, mas você pode descobrir qual codificação *Requests* está usando, e mudá-la, utilizando a propriedade __r.encoding__:
23 |
24 | ```python
25 | In[]:
26 |
27 | import requests
28 |
29 |
30 | r = requests.get('https://jsonplaceholder.typicode.com/todos/1')
31 | # Retornando o encode da resposta.
32 | print(r.encoding)
33 | # Alterando o tipo do econde
34 | r.encoding = "ISO-8859-1"
35 | print(r.text)
36 |
37 | ```
38 | ```python
39 | Out[]:
40 | ```
41 | 
42 |
43 | Se você mudar a codificação, *Requests* irá usar o novo valor de __r.encoding__ sempre que você chamar __r.text__.
--------------------------------------------------------------------------------
/Gerando-gráficos/pie_chart.md:
--------------------------------------------------------------------------------
1 | ## Pie Chart
2 |
3 | - O que é um __pie chart__?
4 | __R:__ *É um diagrama estatístico circular*.
5 | 
. Clique nele e a seguinte tela aparecerá:
10 |
11 | 
4 | Neste tópico, veremos como escrever dados e salvar em arquivo utilizando o Python. 5 |
6 |
42 | 
43 |
9 |
10 |
14 | 
15 |
20 | 
21 |
41 | 
42 |
Booleano, são os valores True (verdadeiro) ou False (falso). Esses valores são úteis para representar, o resultado de uma comparação.
3 | 4 | OBS1: Antes dos exemplos precisamos conferir as tabelas verdade. 5 | 6 | |and | A | B | 7 | |-----|-----|-----| 8 | |True |True |True | 9 | |False|False|False| 10 | |False|True |False| 11 | |False|False|True | 12 |
29 |
30 | a = True
31 | b = False
32 |
33 | c = a and b
34 | print(c)
35 | c = a or b
36 | print(c)
37 | c = a and a
38 | print(c)
39 | c = a or a
40 | print(c)
41 | c = b or b
42 | print(c)
43 |
44 | Saída
45 |
46 |
47 | False
48 | True
49 | True
50 | True
51 | False
52 |
53 |
54 | ## Finalizando
55 | Você agora possui conhecimento sobre oque são os booleanos e como eles funcionam, em python. Prossiga nos seus estudos e pule para o próximo readme.
56 |
18 |
19 | #Classe teste
20 | class teste():
21 |
22 | #Método de multiplicação da classe teste
23 | def metodo_multiplicacao(self,a,b):
24 | return a * b
25 |
26 |
27 | Agora no arquivo teste2 criaremos os testes.
28 |
29 |
30 |
31 | #Importando a biblioteca pytest
32 | import pytest
33 | #Importando o .py com a função de soma
34 | import teste
35 |
36 | #objeto da classe teste
37 | obj = teste.teste()
38 |
39 | #primeiro teste
40 | def teste1():
41 | assert 10 == obj.metodo_multiplicacao(2,5)
42 |
43 |
44 | Agora, basta executar o teste2 e observar o resultado.
45 | 
48 |
57 |
58 | #teste com erro
59 | def teste2():
60 | assert 11 == obj.metodo_multiplicacao(3,5)
61 |
62 | Salve e execute o arquivo teste2.
63 | 
66 | A lista é a estrutura de dados mais básica do Python ela armazena os dados em sequência,estes dados podem ser(Strings,números inteiros,números de ponto-flutuante e dados booleanos).Cada elemento na lista possui uma posição, denominada de índice. O primeiro elemento da esquerda é sempre o índice zero e o da direita o -1.
9 |A tupla é uma estrutura bastante similar a uma lista.Há apenas uma diferença é que na tupla não podemos remover os dados contidos nela.
11 |Os sets, são um coleção de dados desordenados quase imutáveis e que não contém dados iguais.Os sets, necessitam de um permissão de exclusão e de adição de dados.
13 |Os dicionários, são coleções de itens desordenados, cada elemento de um dicionário possui uma chave atrelada a ele, estas chaves devem ser únicas afinal, precisamos delas para acessar cada elemento.
15 | 16 | Você foi introduzido as estruturas de dados. 17 | Agora, para vê os exemplos, as aplicações e como fica cada estrutura, na sintaxe do python.
48 |
49 | - Ao clicar no botão *SAIR*, a ação atribuida ao mesmo é acionada e a janela se fecha, encerrando a aplicação.
--------------------------------------------------------------------------------
/Módulo-Tkinter/hello_world.md:
--------------------------------------------------------------------------------
1 | ## Hello World
2 |
3 |
4 | #### Montando a interface
5 |
6 | - Podemos criar uma interface simples com __tkinter__, da seguinte forma:
7 |
8 | ```python
9 | # importando a biblioteca.
10 | import tkinter
11 |
12 | # criando a classe principal da aplicação, onde será armazenada as configurações de execução do codigo.
13 | class Application:
14 | def __init__(self, master=None):
15 | pass
16 |
17 | root = tkinter.Tk()
18 |
19 | # Aqui passamos a variável root como parâmetro do método construtor da classe Application
20 | Application(root)
21 |
22 | # chamamos o método root.mainloop() para exibirmos a tela.
23 | root.mainloop()
24 | ```
25 | 
26 |
27 | 
56 |
57 |
58 | Agora que ja temos uma base, podemos ir para o [proximo passo](/Módulo-Tkinter/widgets_tkinter.md) e conhecer os atributos padrões do tkinter.
59 |
--------------------------------------------------------------------------------
/Instalação/Linux.md:
--------------------------------------------------------------------------------
1 | 
sudo snap install code --classic
16 |
17 | def soma(a,b):
18 | return a+b
19 |
20 |
21 | Agora, no script teste2 iremos realizar nosso primeiro teste.
22 |
26 |
27 | #Importando a biblioteca pytest
28 | import pytest
29 | #Importando o .py com a função de soma
30 | import teste
31 |
32 |
33 | #primeiro teste
34 | def teste1():
35 | assert 5 == teste.soma(3,2)
36 |
37 |
38 | Salve os dois .py e execute via terminal o teste2.
39 |
40 |
41 |
42 | pytest teste2.py
43 |
44 | Essa será sua saída:
45 | 
48 |
56 |
57 | #Importando a biblioteca pytest
58 | import pytest
59 | #Importando o .py com a função de soma
60 | import teste
61 |
62 |
63 | #primeiro teste
64 | def teste1():
65 | assert 5 == teste.soma(3,2)
66 |
67 | #teste com erro
68 | def teste2():
69 | assert 6 == teste.soma(2,2)
70 |
71 |
72 | Salve o teste2.py
77 |
78 | Um teste não passou e outro sim, ou seja, foi uma saída e esperada nossos testes funcionaram.
--------------------------------------------------------------------------------
/Gerando-gráficos/grafico_barras.md:
--------------------------------------------------------------------------------
1 | ## Grafico de barras
2 |
3 | - Os gráficos de barras são usados para exibir valores associados aos dados categóricos;
4 | - A função __plt.bar()__, recebe uma lista de posições e valores;
5 | - Os labels para *x* são fornecidos pela função __plt.xticks()__.
6 |
7 |
8 | ## Gerando um grafico de barras simples
9 |
10 | - Vamos gerar uma grafico de barras com o tema futebolistico;
11 |
12 | - Nesse grafico, mostraremos os 5 maiores campeões brasileiros de futebol.
13 |
14 | ```python
15 | In[]:
16 |
17 | import matplotlib.pyplot as plt
18 |
19 |
20 | plt.style.use('ggplot')
21 |
22 | x = ['Palmeiras', 'Santos', 'Corinthians', 'São Paulo', 'Flamengo']
23 | quant = [10, 8, 7, 6, 6]
24 |
25 | x_pos = [i for i, _ in enumerate(x)]
26 |
27 | plt.bar(x_pos, quant, color='green')
28 | plt.xlabel("Clubes")
29 | plt.ylabel("Campeonatos Brasileiros")
30 | plt.title("5 maiores vencedores do campeonato brasileiro de futebol")
31 |
32 | plt.xticks(x_pos, x)
33 |
34 | plt.show()
35 |
36 | ```
37 |
38 | ```python
39 | Out[]:
40 | ```
41 | 
Os dicionários, são estruturas de dados envolvidas por chaves {} e identificadas por uma key.
4 | 5 | ## Exemplos 6 | 7 |
8 |
9 | #nome_dicionario = {"key":"valor"}
10 | #nome_dicionario = {key:valor}
11 | telefones = {"Roberval":"3344-9090","Mônica":"1331-2020"}
12 | print("Número do Roberval: ",telefones["Roberval"])
13 | print("Número da Mônica: ",telefones["Mônica"])
14 |
15 | Saída
16 |
17 |
18 | Número do Roberval: 3344-9090
19 | Número da Mônica: 1331-2020
20 |
21 |
22 | ## Métodos
23 |
24 | Os dicionários, possuem um método que exibe uma resposta caso não seja encontrada a key.
25 |
26 |
27 |
28 | print(telefones.get("Antonio","Contato inexistente"))
29 |
30 | Saída
31 |
32 |
33 | Contato inexistente
34 |
35 |
36 | ## Adicionando valores
37 |
38 | Vamos adicionar um novo número a nossa lista telefônica.
39 | 40 |
41 |
42 | telefones["Yudi"] = "4002-8922"
43 | print(telefones)
44 |
45 |
46 | Saída
47 |
48 |
49 | {'Roberval': '3344-9090', 'Mônica': '1331-2020', 'Yudi': '4002-8922'}
50 |
51 | Pronto, o número do Yudi foi adicionado.
52 |
53 | ## Removendo valores
54 |
55 | Vamos remover o número do Roberval agora
56 | 57 |
58 |
59 | del telefones["Roberval"]
60 | print(telefones)
61 |
62 | Saída
63 |
64 |
65 | {'Mônica': '1331-2020', 'Yudi': '4002-8922'}
66 |
67 |
68 | ## Finalizando
69 | Você agora possui conhecimento sobre como funcionam os dicionários, em python. Prossiga nos seus estudos e pule para o próximo readme.
70 |
17 |
18 | #Classe mãe animal
19 | class animal():
20 | def emitir_som(self):
21 | pass
22 |
23 | #Classe cao
24 | class cao(animal):
25 | #Método em que o polimorfismo é aplicado
26 | def emitir_som(self):
27 | return "Au Au Au"
28 |
29 | #Classe gato
30 | class gato(animal):
31 | #Método em que o polimorfismo é aplicado
32 | def emitir_som(self):
33 | return "Miau Miau Miau"
34 |
35 | #Classe galinha
36 | class galinha(animal):
37 | #Método em que o polimorfismo é aplicado
38 | def emitir_som(self):
39 | return "Cocoricó"
40 |
41 |
42 |
43 | Agora, com as classes prontas vamos instanciar nossos objetos, no outro script.
44 |
45 |
46 |
47 | #Importação do script com as classes
48 | import poo
49 |
50 | #Instâncias
51 | cao = poo.cao()
52 | gato = poo.gato()
53 | galinha = poo.galinha()
54 |
55 | #Exibindo o retorno do método emitir_som
56 | print(cao.emitir_som())
57 | print(gato.emitir_som())
58 | print(galinha.emitir_som())
59 |
60 | Por fim, com os dois scripts basta executar o script com as instâncias e visualizar como ficou.
--------------------------------------------------------------------------------
/Introdução/introducao.MD:
--------------------------------------------------------------------------------
1 |
2 |
3 | 
4 |
5 |
17 |
18 | #Classe veiculo
19 | class veiculo():
20 | #Método inicializador
21 | def __init__(self,rodas,cor,modelo):
22 | #Atributos
23 | self.rodas = rodas
24 | self.cor = cor
25 | self.modelo = modelo
26 |
27 | #Método andar
28 | def andar(self):
29 | return "Andando..."
30 | #Método frear
31 | def freando(self):
32 | return "Freando"
33 |
34 |
35 |
36 | Com a classe veiculo, pronta precisamos agora aplicar a herança nas classes no moto e carro, que serão os objetos usados no nosso game.
37 |
38 |
39 |
40 | #Classe veiculo
41 | class veiculo():
42 | #Método inicializador
43 | def __init__(self,rodas,cor,modelo):
44 | #Atributos
45 | self.rodas = rodas
46 | self.cor = cor
47 | self.modelo = modelo
48 |
49 | #Método andar
50 | def andar(self):
51 | return "Andando..."
52 | #Método frear
53 | def frear(self):
54 | return "Freando"
55 |
56 | #Classe carro
57 | class carro(veiculo):
58 | pass
59 |
60 | #Classe moto
61 | class moto(veiculo):
62 | pass
63 |
64 |
65 | Agora, para conferirmos a herança funcionando crie um outro arquivo .py de qualquer nome.
69 |
70 | #Script que contém as classes
71 | import poo
72 |
73 | #Instância do objeto carro
74 | carro1 = poo.carro(4,"vermelha","Ferrari")
75 | #Instância do objeto moto
76 | moto1 = poo.moto(2,"preta","Yamaha")
77 | #Usando o método andar do objeto carro1
78 | print(carro1.andar())
79 |
80 | #Usando o método frear do objeto carro1
81 | print(carro1.frear())
82 |
83 | #Usando o método andar do objeto moto1
84 | print(moto1.andar())
85 |
86 | #Usando o método frear do objeto moto1
87 | print(moto1.frear())
88 |
89 |
90 |
91 | Execute o script com as instâncias e observe que a herança funcionou
92 | e assim não precisamos digitar o método andar para as classes moto e carro, o mesmo ocorreu para o método frear, pois eles foram ,HERDADOS da classe mãe veiculo.
--------------------------------------------------------------------------------
/POO/class.md:
--------------------------------------------------------------------------------
1 | # Classes
2 |
3 | - ***Atributo x Método:***
4 | - ***Atributo:***
5 |
6 | Podemos dizer de forma grosseira que o atributo de uma classe é uma variável de uma classe.
7 | ```python3
8 | class Personagem:
9 | mana = 200
10 | ```
11 | - ***Método:***
12 |
13 | Podemos dizer de forma grosseira que o método de uma classe é uma função de uma classe.
14 | ```python3
15 | class Personagem:
16 | def andar(self) -> None:
17 | pass
18 | ```
19 |
20 | - ***"self":***
21 |
22 | O uso do "self" como primeiro parámetro de um método é convencional segundo a [PEP8](https://peps.python.org/pep-0008/).
23 | O self é usado em classes para indicar que está referenciado alguma coisa do próprio objeto (sejam eles atributos ou métodos) - na verdade, o self é o próprio objeto em si.
24 | ```python3
25 | class Personagem:
26 | def __init__(self, name: str) -> None:
27 | self.name = name
28 |
29 | def get_name(self) -> str:
30 | return self.name
31 | ```
32 |
33 | - ***Métodos especias:***
34 |
35 | - ***\_\_init__:***
36 |
37 | É um método chamado toda vez q a classe é instanciada.
38 |
39 | ```python3
40 | class Personagem:
41 | def __init__(self, name: str) -> None:
42 | # método construtor: ele irá iniciar toda vez q a classe for chamada.
43 | self.name = name
44 |
45 | ```
46 |
47 |
48 | - ***\_\_str__:***
49 |
50 | Usado para retornar uma representação de string de um objeto.
51 | - sem o método \_\_str__:
52 |
53 | ```python3
54 | class Personagem:
55 | pass
56 | ```
57 | `
58 | out:
59 | `
60 |
61 | 
62 | - com o método \_\_str__:
63 | ```python3
64 | class Personagem:
65 | def __str__(self) -> str:
66 | return f"This is a class"
67 | ```
68 | `
69 | out:
70 | `
71 |
72 | 
73 |
74 | - ***Instanciando uma classe:***
75 |
76 | Para instanciarmos uma classe, basta fazermos como qual uma variável.
77 | ```python3
78 | class Personagem:
79 | def __init__(self, name: str) -> None:
80 | self.name = name
81 |
82 | def print_name(self) -> str:
83 | print(self.name)
84 |
85 | ```
86 | `
87 | In:
88 | `
89 |
90 | 
91 |
92 | `
93 | Out:
94 | `
95 |
96 | 
97 |
--------------------------------------------------------------------------------
/Instalação/Windows.md:
--------------------------------------------------------------------------------
1 | 
xcode-select --installsudo easy_install pipsudo pip install --upgrade pipruby -e "$(curl -fsSL https://raw.github.com/mxcl/homebrew/go)" brew install python3
7 |
8 | #Classe pc
9 | class pc:
10 | #Método inicializador
11 | def __init__(self, placaMae, cpu, memRam, hd, fonte, placaVideo):
12 | self.placaMae = placaMae
13 | self.cpu = cpu
14 | self.memRam = memRam
15 | self.hd = hd
16 | self.fonte = fonte
17 | self.placaVideo = placaVideo
18 |
19 | #Método
20 | def ligar(self):
21 | return "Ligando..."
22 |
23 | #Inicializando a classe
24 | #Objeto pc
25 | MeuPc = pc("GigaByte","Intel","Corsair","80GB","500w","Nvidia")
26 |
27 |
28 |
29 | OBS1: Essa classe, pode ter funções, que quando englobadas a ela se tornam métodos como o método ligar.
30 |
31 | OBS2: Já quando a classe possui variáveis, denominamo-as como atributos.
32 |
33 | ## Acessando os atributos e métodos do objeto
34 |
44 |
45 | print("A placa mãe do seu PC é: ",MeuPc.placaMae)
46 |
47 |
48 | Saída:
49 |
50 |
51 |
52 | A placa mãe do seu PC é: GigaByte
53 |
54 |
55 |
56 | Eu quero experimentar uma nova configuração para o meu PC.
57 |
58 | Então, vou mudar o atributo cpu.
59 |
60 |
61 |
62 | MeuPc.cpu = "AMD"
63 | print("O processador do seu PC é: ",MeuPc.cpu)
64 |
65 |
66 | Saída:
67 |
68 |
69 | O processador do seu PC é: AMD
70 |
71 |
72 |
73 | Agora eu to afim de jogar alguma coisa, quero ligar meu PC.
74 |
75 | Basta nós usarmos o método ligar do nosso objeto.
76 |
77 |
78 |
79 | print(MeuPc.ligar())
80 |
81 | Saída:
82 |
83 |
84 |
85 | Ligando...
86 |
87 |
88 |
89 | Por último, mas não menos importante eu quero saber toda a configuração do meu PC, em apenas um print.
90 |
91 | Para isso acontecer usaremos o __dict__ que é: um atributo da classe.
92 |
93 |
94 |
95 | print(MeuPc.__dict)
96 |
97 |
98 | Saída:
99 |
100 |
101 | {'placaMae': 'GigaByte', 'cpu': 'Intel', 'memRam': 'Corsair', 'hd': '80GB', 'fonte': '500w', 'placaVideo': 'Nvidia'}
102 |
103 |
104 | Temos todos os atributos do objeto MeuPc, em um dicionário quando utilizamos o atributo __dict__.
105 |
106 | ## Considerações finais.
107 |
108 | Agora, você possui uma visão básica de como trabalhar com um objeto em python.
109 | Os sets, são estruturas de dados, parcialmente imutáveis, que não podem conter itens duplicados e são envolvidos por ({}) ou inicializados com o método set.
3 | 4 | ## Exemplos 5 | 6 |
7 |
8 | set1 = ({1,2,3,4})
9 | set2 = set([2,90,8,5])
10 |
11 | print(type(set1))
12 | print(type(set2))
13 |
14 |
15 | Saída
16 |
17 |
18 |
19 |
20 |
21 |
22 | ## Adicionando dados
23 |
24 |
25 |
26 | set1.add(40)
27 | print(set1)
28 |
29 | set2.add(65)
30 | print(set2)
31 |
32 | Saída
33 |
34 |
35 | {1, 2, 3, 4, 40}
36 | {65, 2, 5, 8, 90}
37 |
38 |
39 | ## Atualizando dados
40 |
41 |
42 |
43 | set1.update([10,8,67])
44 | print(set1)
45 |
46 | set2.update([22,33,78])
47 | print(set2)
48 |
49 | Saída
50 |
51 |
52 | {1, 2, 3, 4, 67, 8, 10}
53 | {33, 2, 5, 8, 78, 22, 90}
54 |
55 |
56 | ## Remoção de dados
57 |
58 |
59 |
60 | #O método discard, só faz uma remoção por vez
61 | set1.discard(8)
62 | print(set1)
63 |
64 | set2.discard(78)
65 | print(set2)
66 |
67 | Saída
68 |
69 |
70 | {1, 2, 3, 4, 67, 10}
71 | {33, 2, 5, 8, 22, 90}
72 |
73 |
74 | ## Operações matemáticas
75 |
76 | ### União
77 | Na união, todos os dados dos dois sets serão “unidos” em um um único set com todos os elementos, não Haverá repetições.
78 | 79 | OBS: Crie dois novos sets 80 |
81 |
82 | set_novo1 = ({1,2,3})
83 | set_novo2 = set([4,5,6])
84 |
85 | print(set_novo1.union(set_novo2))
86 |
87 |
88 | Saída
89 |
90 |
91 | {1, 2, 3, 4, 5, 6}
92 |
93 |
94 | ### Interseção
95 | 96 | Na interseção, apenas os dados que estiverem nos dois sets serão exibidos. 97 |
98 | OBS2: Crie dois novos sets 99 |
100 |
101 | set_novo3 = ({4,7,8})
102 | set_novo4 = set([4,5,6])
103 |
104 | print(set_novo3.intersection(set_novo4))
105 |
106 |
107 | Saída
108 |
109 |
110 | {4}
111 |
112 |
113 | ### Diferença
114 | Na diferença, restarão apenas os dados que estiverem em um dos sets.
115 |
116 |
117 | set_novo3 = ({4,7,8})
118 | set_novo4 = set([4,5,6])
119 |
120 | print(set_novo3.difference(set_novo4))
121 |
122 | Saída
123 |
124 |
125 | {8, 7}
126 |
127 |
128 | ### Diferença simétrica
129 | Na diferença simétrica, apenas os dados que estiverem nos dois sets,não haverá repetições
130 |
131 |
132 | set_novo3 = ({4,7,8})
133 | set_novo4 = set([4,5,6])
134 |
135 | print(set_novo3.symmetric_difference(set_novo4))
136 |
137 | Saída
138 |
139 |
140 | {5, 6, 7, 8}
141 |
142 |
143 | ## Finalizando
144 | Você agora possui conhecimento sobre oque é um set e como funciona, em python. Prossiga nos seus estudos e pule para o próximo readme.
145 | 
65 |
66 | - Este operador compara duas coisas, e retorna True se forem diferentes e False se forem iguais.
67 |
68 |
69 | ## Comparando objetos com o operador <
70 |
71 | - Ao fazer: __x < y__, estamos perguntando ao Python se __x__ é menor que __y__,
72 | Se ele for menor mesmo, retorna *True*.
73 | Se for igual ou maior que __y__, retorna *False*.
74 |
75 | 
76 |
77 | ## Comparando objetos com o operador >
78 |
79 | - Quando fazemos: __x > y__, estamos querendo saber se __x__ é maior que __y__.
80 | Se for verdade, retorna *True*.
81 | Se __x__ por igual ou menor que __y__, retorna *False*.
82 |
83 | 
84 |
85 | ## Comparando objetos com o operador >=
86 |
87 | Na operação: __x >= y__
88 | Você deve ler: __x__ maior ou igual a __y__
89 |
90 | Esse operador vai retornar *True* (verdadeiro) se __x__ for igual a __y__ ou se __x__ for maior que __y__.
91 | Vai retornar *False* apenas se __x__ for menor que __y__.
92 |
93 | 
94 |
95 | ## Comparando objetos com o operador <=
96 |
97 | Na operação: __x <= y__
98 | Você deve ler: __x__ menor ou igual a __y__
99 |
100 | Retorna *True* se __x__ for igual a __y__ ou menor.
101 | Se __x__ for maior que __y__, retorna *False*.
102 |
103 | 
104 |
105 | ## Resumindo...
106 |
107 |
108 | | Operação | Comparação |
109 | | ------------- | ------------- |
110 | | __x == y__ | __x__ é igual a __y__?|
111 | | __x != y__ | __x__ é diferente de __y__? |
112 | | __x > y__ | __x__ é maior que __y__? |
113 | | __x < y__ | __x__ é menor que __y__? |
114 | | __x >= y__ | __x__ é maior ou igual a __y__? |
115 | | __x <= y__ | __x__ é menor ou igual a __y__? |
116 |
117 |
118 | ## É bom saber
119 |
120 | - todas as operações de comparação em Python têm a mesma prioridade.
121 |
122 |
123 |
124 |
125 |
126 |
--------------------------------------------------------------------------------
/Tipos/listas.md:
--------------------------------------------------------------------------------
1 | # Listas
2 | ## Definição
3 | O interpretador python reconhece como uma lista, uma sequência de objetos que estejam envolvidas por [ ] (conchetes) e separadas por vírgulas.
4 |
5 | Assim, como as Strings, as listas também tem índices.
6 |
7 | |"python"|"php"|
8 | |--------|-----|
9 | | 0 | 1 |
10 | | -2 | -1 |
11 |
12 |
13 | ## Exemplos
14 |
15 |
16 |
17 | #Estas duas listas são simples, e então denominadas de vetores.
18 | lista1 = ["python","php"]
19 | lista2 = [312.5,22 + 4j]
20 |
21 | #Esta lista é composta, e então considerada uma matriz.
22 | lista3 = [["c#","go lang"],[40,-8.980]]
23 |
24 |
25 |
26 | ## Acessando os dados de uma lista
27 |
28 |
29 |
30 | #Buscando na lista1 a palavra python
31 | print(lista1[0])
32 | print(lista1[-2])
33 |
34 | #Buscando na lista2 o número complexo
35 | print(lista2[1])
36 | print(lista2[-1])
37 |
38 |
39 | Saída
40 |
41 |
42 | python
43 | python
44 | (22+4j)
45 | (22+4j)
46 |
47 |
48 | Agora, vamos buscar na matriz
49 |
50 |
51 |
52 | #Buscando na lista3 a palavra go lang
53 | print(lista3[0][1])
54 |
55 | #Buscando o número inteiro positivo
56 | print(lista3[1][0])
57 |
58 |
59 | Saída
60 |
61 |
62 | go lang
63 | 40
64 |
65 |
66 | ## Comprimento de uma lista
67 |
68 | Para verificar o comprimento de uma lista usaremos o método len.
69 | 70 |
71 |
72 | print(len(lista1))
73 | print(len(lista2))
74 | #Número de linhas
75 | print(len(lista3))
76 | #Número de colunas
77 | print(len(lista3[0]))
78 | print(len(lista3[1]))
79 |
80 |
81 |
82 |
83 | 2
84 | 2
85 | 2
86 | 2
87 | 2
88 |
89 |
90 |
91 | ## Valores
92 |
93 |
94 |
95 | #Valor máximo da lista3 coluna 1
96 | print(max(lista3[1]))
97 |
98 | #Valor mínimo da lista3 coluna 1
99 | print(min(lista3[1]))
100 |
101 | #soma da lista3 coluna 1
102 | print(sum(lista3[1]))
103 |
104 |
105 | Saída
106 |
107 |
108 |
109 | 40
110 | -8.98
111 | 31.02
112 |
113 |
114 |
115 |
116 | ## Métodos
117 |
118 |
132 |
133 | lista1.append("java")
134 | print(lista1)
135 |
136 | Saída
137 |
138 |
139 | ['python', 'php', 'java']
140 |
141 |
143 |
144 | lista1.insert(1,"c")
145 | print(lista1)
146 |
147 |
148 | Saída
149 |
150 |
151 | ['python', 'c', 'php', 'java']
152 |
153 |
155 |
156 | lista1.remove("php")
157 | print(lista1)
158 |
159 | Saída
160 |
161 |
162 | ['python', 'c', 'java']
163 |
164 |
167 |
168 | #Vamos,criar uma nova lista e adicionar diretamente agora, para testar o sort e reverse.
169 |
170 | lista_nova = [99,-9,6.7,86,10.6]
171 | lista_nova.sort()
172 | print(lista_nova)
173 |
174 | Saída
175 |
176 |
177 | [-9, 6.7, 10.6, 86, 99]
178 |
179 |
181 |
182 | lista_nova.reverse()
183 | print(lista_nova)
184 |
185 | Saída
186 |
187 |
188 | [10.6, 86, 6.7, -9, 99]
189 |
190 |
192 |
193 | #Vamos, criar nossas últimas listas para usar o método count
194 |
195 | ultima_lista1 = [0,11,2,"python","python"]
196 | ultima_lista2 = [11,22,45]
197 |
198 | print(ultima_lista1.count("python"))
199 | print(ultima_lista2.count("python"))
200 |
201 | Saída
202 |
203 |
204 | 2
205 | 0
206 |
207 |
208 | ## Finalizando
209 | Você agora possui conhecimento sobre como funcionam as listas, em python. Prossiga nos seus estudos e pule para o próximo readme.
210 | 
39 |
40 |
41 | - Veja que nesse codigo vimos como funciona o método __pack__ e também como definir as dimensoes da janela;
42 |
43 | - A propriedade __side__ contém quatro opções:
44 |
45 | - top
46 | - bottom
47 | - left
48 | - right
49 |
50 |
51 | ## Método grid
52 |
53 | - Esse método pode ser considerado o mais importante;
54 | - O método __grid__ é costantemente usado em caixas de diálogo. O método de layout grid pode ter posições relativas estáveis de todos os widgets.
55 |
56 | O exemplo que vamos ver agora é mais extenso e complexo do que vimos até agora, mas fique tranquilo, pois será tudo explicado na sequencia:
57 |
58 | ```python
59 | In[]:
60 |
61 | import tkinter as tk
62 |
63 |
64 | app = tk.Tk()
65 | # Definindo o tamanho padrão da janela
66 | app.geometry('300x200')
67 |
68 | label_top = tk.Label(app, text="Top side", width=15)
69 | label_top.pack(side='top')
70 |
71 | label_bottom = tk.Label(app, text="bottom side", width=15)
72 | label_bottom.pack(side='bottom')
73 |
74 | app.mainloop()
75 | ```
76 | ```python
77 | Out[]:
78 | ```
79 | 
80 |
81 | - A coordenada da célula é determinada por __column__ e __row__;
82 | - A widget __labelWidth__ é colocada na célula da *posição (0, 0)*. A coordenada começa a partir do canto superior esquerdo da janela;
83 | - Em alguns casos, você precisa adicionar algum detalhe dentro ou fora do widget para que haja menos congestionamento entre os widgets, e também entre o texto do widget e os limites do widget. Agora, você precisa de opções como __padx__, __pady__, __ipadx__ e __ipadx__;
84 | - O __sticky__ determina, basicamente, como o widget irá se comportar;
85 |
86 | | Sticky | Significado |
87 | | ------------- | ------------- |
88 | | W | virar à esquerda|
89 | | E | ater-se à direita |
90 | | N | limitar-se ao topo |
91 | | S | ater-se ao fundo |
92 |
93 | - Veja esse trecho de código abaixo referente as propriedades __columnspan__ e __rowspan__:
94 |
95 | ```python
96 | In[]:
97 |
98 | labelLogo.grid(row=0, column=2, columnspan=2, rowspan=2,
99 | sticky=tk.W+tk.E+tk.N+tk.S, padx=5, pady=5)
100 | ```
101 |
102 | __columnspan=2__ e __rowspan=2__ significa que o widget tem intervalos de duas células tanto em *X* como em *Y*, começando a partir da posição do widget.
103 |
104 |
105 | ## Método place
106 |
107 | - O método __place__ coloca o widget em uma posição absoluta ou relativa na janela. Veja o trecho de codigo abaixo:
108 |
109 | ```python
110 |
111 | import tkinter as tk
112 |
113 |
114 | app = tk.Tk()
115 | app.geometry('300x300')
116 |
117 | labelA = tk.Label(app, text = "Label (0, 0)", fg="blue", bg="#FF0")
118 | labelB = tk.Label(app, text = "Label (20, 20)", fg="green", bg="#300")
119 | labelC = tk.Label(app, text = "Label (40, 50)", fg="black", bg="#f03")
120 | labelD = tk.Label(app, text = "Label (0.5, 0.5)", fg="orange", bg="#0ff")
121 |
122 | labelA.place(x=0, y=0)
123 | labelB.place(x=20, y=20)
124 | labelC.place(x=40, y=50)
125 | labelD.place(relx=0.5, rely=0.5)
126 |
127 | app.mainloop()
128 |
129 | ```
130 |
131 | - As opções *x=* e *y=* em __place__ determinam as posições absolutas do widget, medidas em pixel. Por exemplo, *lableB.place(x=20, y=20)* significa que *labelB* é colocado na coordenada de *(20, 20)*;
132 | - O problema de utilizar uma posição absoluta é que se a janela for ampliada, outros widgets na janela podem se sobrepor;
133 |
134 | Para sanar essa questão, o método __place__ conta com a opção de posição relativa, definido da seguinte forma:
135 |
136 | ```python
137 |
138 | labelD.place(relx=0.5, rely=0.5)
139 | ```
140 |
141 | - __relx__ e __rely__ estão na faixa entre 0.0 e 1.0. É a percentagem relativa da posição do widget para o tamanho da janela;
142 | - Por exemplo, __relx=0.5__, __rely=0.5__ significa que o widget é colocado nos 50% da largura da janela e 50% da altura da janela.
143 |
144 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | 
3 | 6 | Como todos os conteúdos da he4rt, esse tem o objetivo de compartilhar conhecimento 7 | de forma acessível e gratuita, atingindo todos os publicos. 8 |
9 | 10 | ## ROADMAP 11 | 12 | ### 1. Introdução 13 | 14 | [Motivação do projeto](/Introdução/motivacao.MD)Made with 💜
127 | -------------------------------------------------------------------------------- /Tipos/numbers.md: -------------------------------------------------------------------------------- 1 | # Numbers 2 | 3 | ## Tipos 4 |No python, existem três tipos de números:
5 |Os números do tipo int, são os números inteiros, ou seja, são números positivos e negativos que não possuem casa decimal.
14 | Exemplos: 15 | 16 |
17 |
18 | #Exemplos de números inteiros
19 | num1 = 300
20 | num2 = -80
21 |
22 |
23 |
24 | Façamos como no arquivo anterior e perguntemos ao python como ele define estas variáveis.
25 |
26 |
27 |
28 | print(type(num1))
29 | print(type(num2))
30 |
31 |
32 |
33 | Saída
34 |
35 |
36 |
37 |
38 |
39 |
40 | Como já era esperado, o interpretador python definiu estas variáveis como números inteiros.
41 |
42 | ### Float
43 |
44 | Os números do tipo float, são os números racionais e irracionais, ou seja, são números positivos e negativos que possuem casa decimal.
45 | Exemplos: 46 |
47 |
48 | #Exemplos de números do tipo float
49 | num3 = 300.5 #número positivo com uma casa decimal
50 | num4 = -433.6776 #número negativo com quatro casas decimais
51 |
52 |
53 | Consultemos, agora ao interpretador python.
54 |
55 |
56 |
57 | print(type(num3))
58 | print(type(num4))
59 |
60 |
61 | Saída
62 |
63 |
64 |
65 |
66 |
67 |
68 | ### Complex
69 |
70 | Os números do tipo complex, são compostos por uma parte real e outra imaginária.
71 | Exemplos: 72 | 73 |
74 |
75 | num5 = 2 + 4j
76 | num6 = 4j
77 | num7 = -10j
78 |
79 | Consultemos, agora ao interpretador python.
80 |
81 |
82 | print(type(num5))
83 | print(type(num6))
84 | print(type(num7))
85 |
86 | Saída
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 | ### Número aleatório
95 |
96 | O python, possui um módulo que gera um número aleatório.
97 | 98 |
99 |
100 | import random
101 | #Gera um número inteiro aleatório entre 0 e 10
102 | print(random.randint(0,10))
103 |
104 |
105 |
106 | ## Conversões
107 |
108 | Como vimos no arquivo anterior podiamos transformar variáveis de um tipo inicial para um novo tipo.
109 | Vejamos agora conversões com números. 110 |
111 |
112 | num8 = 80 #Número do tipo int
113 | num9 = -9.6 #Número do tipo float
114 |
115 |
116 |
117 |
118 |
119 | print(type(float(num8))) #Convertendo de int para float
120 |
121 | print(type(int(num9))) #Convertendo de float para int
122 |
123 | print(type(complex(num8)) #Convertendo de int para complex
124 |
125 | print(float(num8))
126 | print(int(num9))
127 | print(complex(num8))
128 |
129 | Saída
130 |
131 |
132 |
133 |
134 |
135 | 80.0
136 | -9
137 | (80+0j)
138 |
139 |
140 | ## Operações aritméticas
141 |
142 | | Operação | Operador |
143 | |----------------|-----------|
144 | |Adição | + |
145 | |Subtração | - |
146 | |Multiplicação | * |
147 | |Divisão | / |
148 | |Divisão inteira | // |
149 | |Exponenciação | ** |
150 | |Resto da divisão| % |
151 |
152 | ### Operações com int.
153 |
154 |
155 | print(10 + 9) #Soma de inteiros
156 | print(9 - 8) #Subtração de inteiros
157 | print(-9 * -9) # Multiplicação de inteiros
158 | print(10 / 3) # Divisão de inteiros
159 | print(10 // 3) # Parte inteira da divisão entre inteiros
160 | print(10**2) #Exponenciação entre inteiros
161 | print(10 % 2) #Resto da divisão entre inteiros
162 |
163 | Saída
164 |
165 |
166 | 19
167 | 1
168 | 81
169 | 3.3333333333333335
170 | 3
171 | 100
172 | 0
173 |
174 |
175 | ### Operações com float.
176 |
177 |
178 |
179 | print(10.5 + 8.2) #Soma com floats
180 | print(-98.66 - 8.99) #Subtração com floats
181 | print(27.5 * 3.7) # Multiplicação com floats
182 | print(99.2 / 3.2) # Divisão com floats
183 | print(99.2 // 3.2) # Parte inteira da divisão com floats
184 | print(0.25**2) #Exponenciação com floats
185 | print(5.0 % 2.5) #Resto da divisão com floats
186 |
187 | Saída
188 |
189 |
190 | 18.7
191 | -107.64999999999999
192 | 101.75
193 | 31.0
194 | 30.0
195 | 0.0625
196 | 0.0
197 |
198 |
199 | ### Operações com complex.
200 |
201 |
202 |
203 | print(3 + 4j + 3 + 4j) #Soma com complex
204 | print(2 + 4j - 2 + 8j) #Subtração com complex
205 | print(-2 + 9j * 16 + 90j) # Multiplicação com complex
206 | print(2 + 10j/ 2j) # Divisão com complex
207 | print(25 + 2j ** 3 + 2j) #Exponenciação com complex
208 |
209 |
210 | OBS1: j equivale a -1
215 |
216 | (6+8j)
217 | 12j
218 | (-2+234j)
219 | (7+0j)
220 | (25-6j)
221 |
222 |
223 | ## Finalizando
224 | Você agora possui conhecimento sobre como funcionam os números, em python e como fazer operações e conversões aos mesmos. Prossiga nos seus estudos e pule para o próximo readme.
225 |
79 |
80 | String4 = "Python é" + " muito " * 3 + " legal"
81 |
82 |
83 | Agora, basta rodar nosso script para recerbemos a seguinte saída.
84 |
85 |
86 | Python é muito muito muito legal
87 |
88 |
89 |
90 |
91 | ## Descontruindo uma String
92 |
93 | No python, todas as classes/tipos que possuem ideia de 94 | ordenação (como a classe STRING) podem ser 95 | acessadas por partes. 96 |
97 | 98 | |P|Y|T|H|O|N| 99 | |-|-|-|-|-|-| 100 | |0|1|2|3|4|5| 101 | |-6|-5|-4|-3|-2|-1| 102 | 103 | Crie uma nova variável do tipo String e atribua a ela a palavra: python 104 |
105 |
106 | String5 = "python"
107 |
108 |
109 | Agora, quero exibir apenas a letra p.
110 |
112 |
113 | print(String5[0])
114 |
115 | Ou
116 |
117 |
118 | print(String5[-6])
119 |
120 | Saída
121 |
122 |
123 | p
124 | p
125 |
126 | Agora, eu quero exibir todas as letras com exceção do P e N.
127 |
128 |
129 | print(String5[1:5])
130 |
131 | saída.
132 |
133 |
134 | ytho
135 |
136 | Agora, eu quero todas as letras com exceção do O e N
137 |
138 |
139 | print(String5[:4])
140 |
141 |
142 | saída.
143 |
144 |
145 | pyth
146 |
147 |
148 | Por fim, vamos pegar caracteres alternados
149 |
150 |
151 | print(String5[0:5:2])
152 |
153 | Saída.
154 |
155 |
156 | pto
157 |
158 |
159 |
160 | ## Métodos internos
161 | Um dos métodos internos do python é o len.
166 |
167 | String6 = "Python4Noobs"
168 |
169 | Agora, vejamos o método len em ação.
170 |
171 |
172 | print(len(String6))
173 |
174 | Saída.
175 |
176 |
177 | 12
178 |
179 |
180 | Count é mais uma destes métodos internos.
181 | A sua função é verificar quantas vezes determinado caractere aparece, em uma String.
182 |
183 |
184 | print(String6.count("o"))
185 |
186 | saída.
187 |
188 |
189 | 3
190 |
191 | Podemos definir também de onde iniciar e onde parar.
192 |
193 |
194 | print(String6.count("o",3,7))
195 |
196 |
197 | Saída.
198 |
199 |
200 | 1
201 |
202 | Entre o caractere de índice três e o de índice sete, contém apenas uma letra O, segundo a nossa saída.
205 | Outros, dois métodos são o UPPER e LOWER.
206 | Suas funções, são respectivamente, deixar a string em caixa alta e caixa baixa.
207 | Vejamos, com nossa String5.
208 |
210 |
211 | print(String5.upper())
212 | print(String5.lower())
213 |
214 | Saída.
215 |
216 |
217 | PYTHON
218 | python
219 |
220 |
221 | Por fim, temos mais três métodos.
222 | Os métodos: Isalnum, replace e split.
223 | Isalnum: Retorna true se todos os caracteres forem alfanúmericos.
224 | replace:Retorna uma nova string
225 | substituindo na string a todas
226 | as ocorrências de uma string b
227 | por uma nova string c.
228 | split:Separa a string a toda vez que
229 | for encontrada uma string b.
230 |
235 |
236 | String7 = "melancia321"
237 | String8 = "melancia321*%#"
238 | String9 = "Brasil"
239 |
240 | print(String7.isalnum())
241 | print(String8.isalnum())
242 | print(String9.replace("s","z"))
243 | print(String9.split("as"))
244 |
245 | Saída.
246 |
247 |
248 | #Isto é um comentário, ou seja, a linha não é executada pelo interpretador
249 |
250 | True #True, pois só há caracteres alfanúmericos na String7
251 |
252 | False #False, pois há caracteres que não são alfanúmericos na String8
253 |
254 | Brazil #A letra s foi substituida pela letra z
255 |
256 | ['Br', 'il'] #Foi criado um vetor para separar entre a letra a
257 |
258 |
259 |
260 | ## Finalizando
261 | Você agora possui conhecimento sobre oque é uma string, em python e como fazer manipulações com a mesma. Prossiga nos seus estudos e pule para o próximo readme.
262 | 
57 |
58 | ## Label
59 |
60 | - Um __label__ é um widget que exibe texto ou imagens, normalmente com o qual o usuário apenas visualiza, mas sem interagir com ele.
61 |
62 | #### Sintaxe
63 |
64 | ```python
65 |
66 | lbl = Label( master, option, ... )
67 | ```
68 |
69 | #### Parâmetros
70 |
71 | - __master__ − Representa a janela principal, ou janela pai.
72 | - __options__ − Esse parâmetro é uma lista de opções (como o proprio nome ja diz) para aperfeiçoar o widget.
73 |
74 | Acompanhe o exemplo abaixo:
75 |
76 | ```python
77 | In[]:
78 |
79 | from tkinter import *
80 |
81 | root = Tk()
82 | var = StringVar()
83 | label = Label(root, textvariable=var, relief=RAISED)
84 |
85 | var.set("He4rt developers!!")
86 | label.pack()
87 | root.mainloop()
88 |
89 | ```
90 | ```python
91 | Out[]
92 | ```
93 |
94 | 
95 |
96 |
97 | ## Button
98 |
99 | - Um __button__, diferentemente de um quadro ou rótulo, é muito projetado para o usuário interagir e, em particular, pressionar para executar alguma ação.
100 |
101 | #### Sintaxe
102 |
103 | ```python
104 |
105 | btn = Button(master, option=value, ...)
106 | ```
107 |
108 | #### Parâmetros
109 |
110 | - __master__ − Representa a janela principal, ou janela pai.
111 | - __options__ − Esse parâmetro é uma lista de opções (como o proprio nome ja diz) para aperfeiçoar o widget.
112 |
113 |
114 | Exemplo:
115 |
116 | ```python
117 | In[]:
118 |
119 | import tkinter
120 | import tkinter.messagebox
121 |
122 |
123 | top = tkinter.Tk()
124 |
125 | def helloCallBack():
126 | tkinter.messagebox.showinfo(message="Python4Noobs.")
127 |
128 | B = tkinter.Button(top, text ="Clique aqui!", command=helloCallBack)
129 |
130 | B.pack()
131 | top.mainloop()
132 |
133 | ```
134 | ```python
135 | Out[]
136 | ```
137 |
138 | 
139 |
140 |
141 | ## Checkbutton
142 |
143 | - Os __checkbuttons__ são como um botão comum, exceto que o usuário não apenas pode pressioná-lo, o que invocará um retorno de chamada de comando, mas também possui um valor binário de algum tipo (ou seja, uma alternância).
144 |
145 | #### Sintaxe
146 |
147 | ```python
148 |
149 | cb = Checkbutton(master, option, ...)
150 | ```
151 |
152 | #### Parâmetros
153 |
154 | - __master__ − Representa a janela principal, ou janela pai.
155 | - __options__ − Esse parâmetro é uma lista de opções (como o proprio nome ja diz) para aperfeiçoar o widget.
156 |
157 |
158 | Exemplo:
159 |
160 | ```python
161 | In[]:
162 |
163 | from tkinter import *
164 | import tkinter
165 |
166 |
167 | top = tkinter.Tk()
168 | CheckVar1 = IntVar()
169 | CheckVar2 = IntVar()
170 | C1 = Checkbutton(top, text = "Python4noobs", variable = CheckVar1, \
171 | onvalue = 1, offvalue = 0, height=5, \
172 | width = 20)
173 | C2 = Checkbutton(top, text = "anything else", variable = CheckVar2, \
174 | onvalue = 1, offvalue = 0, height=5, \
175 | width = 20)
176 | C1.pack()
177 | C2.pack()
178 | top.mainloop()
179 |
180 | ```
181 | ```python
182 | Out[]
183 | ```
184 |
185 | 
186 |
187 | https://tkdocs.com/tutorial/widgets.html
188 | https://www.tutorialspoint.com/python/tk_frame.html
189 |
190 |
191 | ## Radiobutton
192 |
193 | - Um __radiobutton__ lhe permite escolher uma opção entre varias, mutuamente exclusivas.
194 |
195 | #### Sintaxe
196 |
197 | ```python
198 |
199 | rb = Radiobutton(master, option, ...)
200 | ```
201 |
202 | #### Parâmetros
203 |
204 | - __master__ − Representa a janela principal, ou janela pai.
205 | - __options__ − Esse parâmetro é uma lista de opções (como o proprio nome ja diz) para aperfeiçoar o widget.
206 |
207 |
208 | Exemplo:
209 |
210 | ```python
211 | In[]:
212 |
213 | from tkinter import *
214 |
215 |
216 | def sel():
217 | selection = "Selecione o conteúdo " + str(var.get())
218 | label.config(text = selection)
219 |
220 | root = Tk()
221 | var = IntVar()
222 | R1 = Radiobutton(root, text="Python4noobs", variable=var, value=1,
223 | command=sel)
224 | R1.pack( anchor = W )
225 |
226 | R2 = Radiobutton(root, text="Cpp4noobs", variable=var, value=2,
227 | command=sel)
228 | R2.pack( anchor = W )
229 |
230 | R3 = Radiobutton(root, text="PHP4noobs", variable=var, value=3,
231 | command=sel)
232 | R3.pack( anchor = W)
233 |
234 | label = Label(root)
235 | label.pack()
236 | root.mainloop()
237 | ```
238 | ```python
239 | Out[]
240 | ```
241 |
242 | 
243 |
244 |
245 | ## Entry
246 |
247 | - Um __Entry__ apresenta ao usuário um campo de texto de linha única que ele pode usar para digitar um valor. Podem ser praticamente qualquer coisa: nome, cidade, senha, número do seguro social e assim por diante.
248 |
249 |
250 | #### Sintaxe
251 |
252 | ```python
253 |
254 | entry = Entry(master, option, ...)
255 | ```
256 |
257 | #### Parâmetros
258 |
259 | - __master__ − Representa a janela principal, ou janela pai.
260 | - __options__ − Esse parâmetro é uma lista de opções (como o proprio nome ja diz) para aperfeiçoar o widget.
261 |
262 |
263 | Exemplo:
264 |
265 | ```python
266 | In[]:
267 |
268 | from tkinter import *
269 |
270 |
271 | top = Tk()
272 | L1 = Label(top, text="Nome da empresa: ")
273 | L1.pack( side = LEFT)
274 | E1 = Entry(top, bd =5)
275 | E1.pack(side = RIGHT)
276 |
277 | top.mainloop()
278 | ```
279 | ```python
280 | Out[]
281 | ```
282 |
283 | 
284 |
285 |
286 | ## Combobox
287 |
288 | - Os __combobox__ combina o componente __entry__ com uma lista de opções disponíveis para o usuário. Isso permite que você escolha um conjunto de valores que você forneceu.
289 |
290 |
291 | #### Sintaxe
292 |
293 | ```python
294 |
295 | combobox = Combobox(master, option, ...)
296 | ```
297 |
298 | #### Parâmetros
299 |
300 | - __master__ − Representa a janela principal, ou janela pai.
301 | - __options__ − Esse parâmetro é uma lista de opções (como o proprio nome ja diz) para aperfeiçoar o widget.
302 |
303 |
304 | Exemplo:
305 |
306 | ```python
307 | In[]:
308 |
309 | from tkinter import *
310 |
311 |
312 | top = Tk()
313 | L1 = Label(top, text="Nome da empresa: ")
314 | L1.pack( side = LEFT)
315 | E1 = Entry(top, bd =5)
316 | E1.pack(side = RIGHT)
317 |
318 | top.mainloop()
319 | ```
320 | ```python
321 | Out[]
322 | ```
323 |
324 | 
--------------------------------------------------------------------------------
/Extras/calculadora.md:
--------------------------------------------------------------------------------
1 | # Desenvolvendo uma calculadora
2 |
3 | ## Requisitos
4 | - Python instalado no computador
5 | - Biblioteca tkinter instalada no computador
6 |
7 |
8 | pip install python-tk
9 |
10 |
11 |
12 | ## Hora do código
13 | Após, a criação do .py começamos importando a biblioteca.
14 |
15 |
16 |
17 | from tkinter import *
18 |
19 |
20 | Depois inicialize ela.
21 |
22 |
23 |
24 | tela = Tk()
25 |
26 | Vamos definir algumas configurações da nossa tela.
27 |
28 |
29 | #Importando a biblioteca
30 | from tkinter import *
31 | #Definindo um título para a janela
32 | tela.title("4noobs")
33 | #cor de fundo da tela
34 | tela.configure(background="#F4F5F4")
35 | tela.resizable(False,False)
36 | #Icone da janela
37 | tela.iconbitmap("ico.ico")
38 | #Manter a janela aberta
39 | tela.mainloop()
40 |
41 |
42 | OBS: O ícone deve estar no mesmo diretório do .py
51 |
52 |
53 | #Criando caixa de texto
54 | txt = Entry(tela)
55 |
56 | #Criando botões
57 | btn0 = Button(tela,text="0",fg="black",bg="#F4F5F4",width = 5 ,height = 2)
58 | btn1 = Button(tela,text="1",fg="black",bg="#F4F5F4",width = 5 ,height = 2)
59 | btn2 = Button(tela,text="2",fg="black",bg="#F4F5F4",width = 5 ,height = 2
60 | btn3 = Button(tela,text="3",fg="black",bg="#F4F5F4",width = 5 ,height = 2)
61 | btn4 = Button(tela,text="4",fg="black",bg="#F4F5F4",width = 5 ,height = 2)
62 | btn5 = Button(tela,text="5",fg="black",bg="#F4F5F4",width = 5 ,height = 2)
63 | btn6 = Button(tela,text="6",fg="black",bg="#F4F5F4",width = 5 ,height = 2)
64 | btn7 = Button(tela,text="7",fg="black",bg="#F4F5F4",width = 5 ,height = 2)
65 | btn8 = Button(tela,text="8",fg="black",bg="#F4F5F4",width = 5 ,height = 2)
66 | btn9 = Button(tela,text="9",fg="black",bg="#F4F5F4",width = 5 ,height = 2)
67 |
68 | btnPonto = Button(tela,text=".",fg="black",bg="#F4F5F4",width = 5 ,height = 2)
69 | btnLimpar = Button(tela,text="Limpar",fg="black",bg="#F4F5F4",width = 5 ,height = 2)
70 | btnResul = Button(tela,text="=",fg="black",bg="#F4F5F4",width = 10 ,height = 2)
71 |
72 | btnSoma = Button(tela,text="+",fg="black",bg="#F4F5F4",width = 5 ,height = 2)
73 | btnSubt = Button(tela,text="-",fg="black",bg="#F4F5F4",width = 5 ,height = 2)
74 | btnDiv = Button(tela,text="/",fg="black",bg="#F4F5F4",width = 5 ,height = 2)
75 | btnMulti = Button(tela,text="*",fg="black",bg="#F4F5F4",width = 5 ,height = 2)
76 |
77 |
78 | #Definindo como aloca-los na interface
79 |
80 | txt.grid(row = 0, columnspan = 10,padx = 10, pady = 2)
81 |
82 | btn7.grid(row = 1, column = 1, padx = 5, pady = 5)
83 | btn8.grid(row = 1, column = 2, padx = 5, pady = 5)
84 | btn9.grid(row = 1, column = 3, padx = 5, pady = 5)
85 | btnSoma.grid(row = 1, column = 4, padx = 5, pady = 5)
86 |
87 | btn4.grid(row = 2, column = 1, padx = 5, pady = 5)
88 | btn5.grid(row = 2, column = 2, padx = 5, pady = 5)
89 | btn6.grid(row = 2, column = 3, padx = 5, pady = 5)
90 | btnSubt.grid(row = 2, column = 4, padx = 5, pady = 5)
91 |
92 | btn1.grid(row = 3, column = 1, padx = 5, pady = 5)
93 | btn2.grid(row = 3, column = 2, padx = 5, pady = 5)
94 | btn3.grid(row = 3, column = 3, padx = 5, pady = 5)
95 | btnDiv.grid(row = 3, column = 4, padx = 5, pady = 5)
96 |
97 | btnPonto.grid(row = 4,column = 1, padx = 5, pady = 5)
98 | btn0.grid(row = 4, column = 2, padx = 5, pady = 5)
99 | btnLimpar.grid(row = 4, column = 3, padx = 5, pady = 5)
100 | btnMulti.grid(row = 4, column = 4, padx = 5, pady = 5)
101 |
102 | btnResul.grid(row = 5, column = 1, columnspan = 10,padx = 5, pady = 5)
103 | #Mantém a janela aberta
104 | tela.mainloop()
105 |
106 |
107 | Antes de execurtamos novamente vamos criar as funções dos botões e adiciona-las.
108 |
109 |
110 |
111 | #Importa a biblioteca
112 | from tkinter import *
113 |
114 | tela = Tk()
115 | i = 0
116 | #Título da janela
117 | tela.title("4noobs")
118 | #cor de fundo da tela
119 | tela.configure(background="#F4F5F4")
120 | #Redimensionamento da janela
121 | tela.resizable(False,False)
122 | #Icone da janela
123 | tela.iconbitmap("ico.ico")
124 |
125 | def clickEscrever(valor):
126 | global i
127 | txt.insert(i,valor)
128 | i += 1
129 |
130 | def clickLimpar():
131 | txt.delete(0,END)
132 | i = 0
133 |
134 | def clickResul():
135 | conta = txt.get()
136 | resultado = eval(conta)
137 | txt.delete(0,END)
138 | txt.insert(i,str(resultado))
139 | #Criando caixa de texto
140 | txt = Entry(tela)
141 |
142 | #Criando botões
143 | btn0 = Button(tela,text="0",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(0))
144 | btn1 = Button(tela,text="1",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(1))
145 | btn2 = Button(tela,text="2",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(2))
146 | btn3 = Button(tela,text="3",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(3))
147 | btn4 = Button(tela,text="4",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(4))
148 | btn5 = Button(tela,text="5",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(5))
149 | btn6 = Button(tela,text="6",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(6))
150 | btn7 = Button(tela,text="7",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(7))
151 | btn8 = Button(tela,text="8",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(8))
152 | btn9 = Button(tela,text="9",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever(9))
153 |
154 | btnPonto = Button(tela,text=".",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever("."))
155 | btnLimpar = Button(tela,text="Limpar",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickLimpar())
156 | btnResul = Button(tela,text="=",fg="black",bg="#F4F5F4",width = 10 ,height = 2,command = lambda: clickResul())
157 |
158 | btnSoma = Button(tela,text="+",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever("+"))
159 | btnSubt = Button(tela,text="-",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever("-"))
160 | btnDiv = Button(tela,text="/",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever("/"))
161 | btnMulti = Button(tela,text="*",fg="black",bg="#F4F5F4",width = 5 ,height = 2,command = lambda: clickEscrever("*"))
162 |
163 | txt.grid(row = 0, columnspan = 10,padx = 10, pady = 2)
164 |
165 | btn7.grid(row = 1, column = 1, padx = 5, pady = 5)
166 | btn8.grid(row = 1, column = 2, padx = 5, pady = 5)
167 | btn9.grid(row = 1, column = 3, padx = 5, pady = 5)
168 | btnSoma.grid(row = 1, column = 4, padx = 5, pady = 5)
169 |
170 | btn4.grid(row = 2, column = 1, padx = 5, pady = 5)
171 | btn5.grid(row = 2, column = 2, padx = 5, pady = 5)
172 | btn6.grid(row = 2, column = 3, padx = 5, pady = 5)
173 | btnSubt.grid(row = 2, column = 4, padx = 5, pady = 5)
174 |
175 | btn1.grid(row = 3, column = 1, padx = 5, pady = 5)
176 | btn2.grid(row = 3, column = 2, padx = 5, pady = 5)
177 | btn3.grid(row = 3, column = 3, padx = 5, pady = 5)
178 | btnDiv.grid(row = 3, column = 4, padx = 5, pady = 5)
179 |
180 | btnPonto.grid(row = 4,column = 1, padx = 5, pady = 5)
181 | btn0.grid(row = 4, column = 2, padx = 5, pady = 5)
182 | btnLimpar.grid(row = 4, column = 3, padx = 5, pady = 5)
183 | btnMulti.grid(row = 4, column = 4, padx = 5, pady = 5)
184 |
185 | btnResul.grid(row = 5, column = 1, columnspan = 10,padx = 5, pady = 5)
186 | #Mantém a janela aberta
187 | tela.mainloop()
188 |
189 |
190 |
191 | Agora, sua calculadora está pronta, basta executar e verificar como ficou. Enfim,você tem uma calculadora desenvolvida por sí mesmo, aproveite. Fique a vontade para explorar o código da calculadora e entender como cada linha funciona.
192 |
193 | ## Caso precise de ajuda
194 | Caso, tenha ficado uma dúvida sobre o conteúdo apresentado neste readme, acesse o discord da heartdevs que a comunidade fornecerá o melhor suporte para você.| Método magico | 50 |Quando é invocado (exemplo) | 51 |Explicação | 52 |
|---|---|---|
__new__(cls [,...]) |
57 | instancia = MinhaClasse(arg1, arg2) |
58 | __new__ é chamado quando criamos um instancia. |
59 |
__init__(self [,...]) |
62 | instancia = MinhaClasse(arg1, arg2) |
63 | __init__ é chamado quando a instancia que criamos será inicializada. |
64 |
__cmp__(self, other) |
67 | self == other, self > other, etc... |
68 | Chamado quando vamos realizar qualquer compração. | 69 |
__pos__(self) |
72 | +self |
73 | Sinal de "mais". | 74 |
__neg__(self) |
77 | -self |
78 | Sinal de "menos". | 79 |
__invert__(self) |
82 | ~self |
83 | Inversão de bits. | 84 |
__index__(self) |
87 | x[self] |
88 | Para ser chamado na conversão de tipo para um int quando o objeto é usado em uma slice expression. (explicado no final desse tópico). | 89 |
__bool__(self) |
92 | bool(self) |
93 | Retorna o valor booleano de um objeto. | 94 |
__getattr__(self, nome) |
97 | self.nome # nome doesn't exist |
98 | Você pode usar para dizer a uma classe como lidar com atributos que ela não gerencia explicitamente. | 99 |
__setattr__(self, nome, val) |
102 | self.nome = val |
103 | Definir um valor para um atributo. | 104 |
__delattr__(self, nome) |
107 | del self.nome |
108 | Deletar um atributo. | 109 |
__getattribute__(self, nome) |
112 | self.nome |
113 | Acessar qualquer atributo. | 114 |
__getitem__(self, key) |
117 | self[key] |
118 | Acessar qualquer item, usando um indice. | 119 |
__setitem__(self, key, val) |
122 | self[key] = val |
123 | Atribuir um valor a um item, por meio de um indice. | 124 |
__delitem__(self, key) |
127 | del self[key] |
128 | Deletar um item, por meio de um indice. | 129 |
__iter__(self) |
132 | for x in self |
133 | Interação | 134 |
__contains__(self, value) |
137 | value in self, value not in self |
138 | Usado para verificar se um item contém certo valor.in |
139 |
__call__(self [,...]) |
142 | self(args) |
143 | "Chamar" uma instancia de algo (variavel, função, etc...). | 144 |
__enter__(self) |
147 | with self as x: |
148 | with Gerenciador de contexto. |
149 |
__exit__(self, exc, val, trace) |
152 | with self as x: |
153 | with Gerenciador de contexto. |
154 |
__getstate__(self) |
157 | pickle.dump(pkl_file, self) |
158 | Serialização. | 159 |
__setstate__(self) |
162 | data = pickle.load(pkl_file) |
163 | Serialização. | 164 |
__slots__(self) |
167 | __slots__ = 'foo', 'bar' |
168 | permite que você indique explicitamente quais atributos de instância você espera que suas instâncias de objeto tenham. | 169 |
slice(inicio, fim, intervalo)
181 |
182 | | Parametro | 186 |Descrição | 187 |
|---|---|
| inicio | 190 |Opcional. Usando um numero inteiro, você poderá definir por onde o "corte" iniciará. O padrão 0 (zero). | 191 |
| fim | 194 |Usando um numero inteiro, você poderá definir por onde o "corte" terminará. | 195 |
| intervalo | 198 |Opcional. Um numero inteiro definirá o intervalo no qual a função irá percorrer. O padrão é 1 (Um). | 199 |
19 |
20 | pip install gTTS
21 |
22 |
27 |
28 | pip install playsound
29 |
30 |
31 | Agora, com todas as bibliotecas instaladas podemos iniciar a parte de desenvolvimento.
32 |
33 | ## 1° linhas de código
34 |
35 | ### Função de fala
36 | Vamos começar!!!
37 |
38 |
48 |
49 | #biblioteca de criação do áudio
50 | from gtts import gTTS
51 | #biblioteca de reprodução do áudio
52 | import playsound
53 |
54 |
55 |
56 |
57 | Agora, vamos criar a função que faz nossa assistente virtual.
58 |
59 |
60 |
61 | #biblioteca de criação do áudio
62 | from gtts import gTTS
63 | #biblioteca de reprodução do áudio
64 | import playsound
65 |
66 | #Função que faz a assistente virtual falar
67 | #O parâmetro text é o texto que desejamos que seja falado
68 | def falar(text):
69 | #Nesta linha acontece a mágica
70 | tts = gTTS(text=text,lang="pt")
71 | arquivo = "voz.mp3"
72 | #Aqui salvamos o arquivo .mp3
73 | tts.save(arquivo)
74 | #Aqui reproduzimos
75 | playsound.playsound(arquivo)
76 |
77 |
78 | A função de fala está pronta. Basta agora usarmos ela
79 |
80 |
81 |
82 | #biblioteca de criação do áudio
83 | from gtts import gTTS
84 | #biblioteca de reprodução do áudio
85 | import playsound
86 |
87 | #Função que faz a assistente virtual falar
88 | #O parâmetro text é o texto que desejamos que seja falado
89 | def falar(text):
90 | #Nesta linha acontece a mágica
91 | tts = gTTS(text=text,lang="pt")
92 | arquivo = "voz.mp3"
93 | #Aqui salvamos o arquivo .mp3
94 | tts.save(arquivo)
95 | #Aqui reproduzimos
96 | playsound.playsound(arquivo)
97 |
98 | #Fazendo falar
99 | falar("Bom dia")
100 |
101 | Agora, é só executar.
102 |
103 | ### Função para escutar
104 |
105 | Para que nossa assistente nos escute é necessário baixar mais uma biblioteca.
106 | (Use este comando no seu terminal)
107 |
108 |
109 |
110 | pip install SpeechRecognition
111 |
112 |
113 | Com ela instalada vamos criar a função escutar.
114 | Não esqueça de importar a biblioteca baixada.
115 |
116 |
117 | #biblioteca de criação do áudio
118 | from gtts import gTTS
119 | #biblioteca de reprodução do áudio
120 | import playsound
121 | #biblioteca que recebe o áudio do microfone
122 | import speech_recognition as sr
123 |
124 | #Função que faz a assistente virtual falar
125 | #O parâmetro text é o texto que desejamos que seja falado
126 | def falar(text):
127 | #Nesta linha acontece a mágica
128 | tts = gTTS(text=text,lang="pt")
129 | arquivo = "voz.mp3"
130 | #Aqui salvamos o arquivo .mp3
131 | tts.save(arquivo)
132 | #Aqui reproduzimos
133 | playsound.playsound(arquivo)
134 |
135 | #Função que faz a assistente virtual capturar áudio do microfone
136 | def escutar():
137 | #Cria "ouvidos"
138 | r = sr.Recognizer()
139 | #procura por um microfone
140 | with sr.Microphone() as s:
141 | #Configura o ambiente
142 | r.adjust_for_ambient_noise(s)
143 | #Captura o audio
144 | audio = r.listen(s)
145 | #Transforma em texto
146 | fala = r.recognize_google(audio, language="pt-br")
147 | return fala
148 |
149 |
150 | Agora, com a função escutar pronta, basta inicializarmos ela.
151 |
152 |
153 |
154 | #biblioteca de criação do áudio
155 | from gtts import gTTS
156 | #biblioteca de reprodução do áudio
157 | import playsound
158 | #biblioteca que recebe o áudio do microfone
159 | import speech_recognition as sr
160 |
161 | #Função que faz a assistente virtual falar
162 | #O parâmetro text é o texto que desejamos que seja falado
163 | def falar(text):
164 | #Nesta linha acontece a mágica
165 | tts = gTTS(text=text,lang="pt")
166 | arquivo = "voz.mp3"
167 | #Aqui salvamos o arquivo .mp3
168 | tts.save(arquivo)
169 | #Aqui reproduzimos
170 | playsound.playsound(arquivo)
171 |
172 | #Função que faz a assistente virtual capturar áudio do microfone
173 | def escutar():
174 | #Cria "ouvidos"
175 | r = sr.Recognizer()
176 | #procura por um microfone
177 | with sr.Microphone() as s:
178 | #Configura o ambiente
179 | r.adjust_for_ambient_noise(s)
180 | #Captura o audio
181 | audio = r.listen(s)
182 | #Transforma em texto
183 | fala = r.recognize_google(audio, language="pt-br")
184 | return fala
185 |
186 | print(escutar())
187 |
188 | Por fim, é só executar no script e conferir como ficou.
189 |
190 | ### Contando piadas
191 |
192 | Vamos, dar uma funcionalidade muito boa a nossa assistente virtual que é contar piadas. 193 | Para isso, busquei algumas na internet e a salvei-as num vetor. 194 |
195 | 196 |
197 |
198 | #biblioteca de criação do áudio
199 | from gtts import gTTS
200 | #biblioteca de reprodução do áudio
201 | import playsound
202 | #biblioteca que recebe o áudio do microfone
203 | import speech_recognition as sr
204 | #biblioteca que gera números aleatórios
205 | import random
206 |
207 | #Função que faz a assistente virtual falar
208 | #O parâmetro text é o texto que desejamos que seja falado
209 | def falar(text):
210 | #Nesta linha acontece a mágica
211 | tts = gTTS(text=text,lang="pt")
212 | arquivo = "voz.mp3"
213 | #Aqui salvamos o arquivo .mp3
214 | tts.save(arquivo)
215 | #Aqui reproduzimos
216 | playsound.playsound(arquivo)
217 |
218 | #Função que faz a assistente virtual capturar áudio do microfone
219 | def escutar():
220 | #Cria "ouvidos"
221 | r = sr.Recognizer()
222 | #procura por um microfone
223 | with sr.Microphone() as s:
224 | #Configura o ambiente
225 | r.adjust_for_ambient_noise(s)
226 | #Captura o audio
227 | audio = r.listen(s)
228 | #Transforma em texto
229 | fala = r.recognize_google(audio, language="pt-br")
230 | return fala
231 |
232 | escutar()
233 |
234 | #Número aleatório
235 | #Não se esqueça de importar a biblioteca random
236 | num = random.radint(0,2)
237 |
238 | #Vetor com três piadas
239 | Piadas = ["Então, porque a aranha é o animal mais carente do mundo? Por que, ela é uma ar",
240 | "Afinal, você conhece a piada do pônei? Pô nei eu kkkkkkkkkkkk.",
241 | "Afinal, o que a vaca disse para o boi? Te amuuuuuuuuuuuuuuuu."]
242 |
243 | """Se a função escutar, retornar "piadas", então nossa assistente conta uma piada"""
244 |
245 | if escutar() == "piadas":
246 | falar(piadas[num])
247 |
248 |
249 | ### Enviando e-mails
250 |
251 | Enviar e-mails é uma tarefa tão repetitiva, por que não deixarmos nossa assistente fazer isso por nós.
256 |
257 | #biblioteca de criação do áudio
258 | from gtts import gTTS
259 | #biblioteca de reprodução do áudio
260 | import playsound
261 | #biblioteca que recebe o áudio do microfone
262 | import speech_recognition as sr
263 | #biblioteca que gera números aleatórios
264 | import random
265 | #biblioteca para envio de e-mails
266 | import smtplib
267 |
268 | #Função que faz a assistente virtual falar
269 | #O parâmetro text é o texto que desejamos que seja falado
270 | def falar(text):
271 | #Nesta linha acontece a mágica
272 | tts = gTTS(text=text,lang="pt")
273 | arquivo = "voz.mp3"
274 | #Aqui salvamos o arquivo .mp3
275 | tts.save(arquivo)
276 | #Aqui reproduzimos
277 | playsound.playsound(arquivo)
278 |
279 | #Função que faz a assistente virtual capturar áudio do microfone
280 | def escutar():
281 | #Cria "ouvidos"
282 | r = sr.Recognizer()
283 | #procura por um microfone
284 | with sr.Microphone() as s:
285 | #Configura o ambiente
286 | r.adjust_for_ambient_noise(s)
287 | #Captura o audio
288 | audio = r.listen(s)
289 | #Transforma em texto
290 | fala = r.recognize_google(audio, language="pt-br")
291 | return fala
292 |
293 | escutar()
294 | #Número aleatório
295 | #Não se esqueça de importar a biblioteca random
296 | num = random.radint(0,2)
297 |
298 | #Vetor com três piadas
299 | Piadas = ["Então, porque a aranha é o animal mais carente do mundo? Por que, ela é uma ar",
300 | "Afinal, você conhece a piada do pônei? Pô nei eu kkkkkkkkkkkk.",
301 | "Afinal, o que a vaca disse para o boi? Te amuuuuuuuuuuuuuuuu."]
302 |
303 | """Se a função escutar, retornar "piadas", então nossa assistente conta uma piada"""
304 |
305 | if escutar() == "piadas":
306 | falar(piadas[num])
307 | #Envia um e-mail
308 | elif escutar() == "e-mail":
309 | email_remetente = "Digite aqui seu e-mail"
310 | senha_rementente = "Digite aqui a senha do seu e-mail"
311 | email_destinatario = "Digite o e-mail que vai receber sua mensagem"
312 | mensagem = "Digite aqui a mensagem que você deseja enviar"
313 |
314 | #Conexão com o servidor do gmail, via protocolo SMTP
315 | """Caso, deseje mudar o servidor de e-mail, verifique o endereço smtp e a porta, do novo servidor"""
316 | email = smtplib.SMTP("smtp.gmail.com",587)
317 |
318 | #Inicia conexão com protocolo TTLS
319 | email.starttls()
320 |
321 | #Faz login na sua conta de e-mail, no caso gmail
322 | email.login(email_remetente,senha_remetente)
323 |
324 | #Envia o e-mail
325 | email.sendmail(email_remetente,email_destinatario,mensagem)
326 |
327 | falar("Enviei o e-mail")
328 |
329 |
330 | OBS1: Caso, esteja usando o gmail você terá que liberar o acesso da nossa assistente nas configurações do gmail.
331 |
332 | ### Acessando sites
333 |
334 | Nossa assistente, já tem 4 funcionalidades, por que não programarmos mais uma?
340 |
341 | #biblioteca de criação do áudio
342 | from gtts import gTTS
343 | #biblioteca de reprodução do áudio
344 | import playsound
345 | #biblioteca que recebe o áudio do microfone
346 | import speech_recognition as sr
347 | #biblioteca que gera números aleatórios
348 | import random
349 | #biblioteca para envio de e-mails
350 | import smtplib
351 | #biblioteca para controlar o navegador
352 | import webbrowser as nav
353 |
354 | #Função que faz a assistente virtual falar
355 | #O parâmetro text é o texto que desejamos que seja falado
356 | def falar(text):
357 | #Nesta linha acontece a mágica
358 | tts = gTTS(text=text,lang="pt")
359 | arquivo = "voz.mp3"
360 | #Aqui salvamos o arquivo .mp3
361 | tts.save(arquivo)
362 | #Aqui reproduzimos
363 | playsound.playsound(arquivo)
364 |
365 | #Função que faz a assistente virtual capturar áudio do microfone
366 | def escutar():
367 | #Cria "ouvidos"
368 | r = sr.Recognizer()
369 | #procura por um microfone
370 | with sr.Microphone() as s:
371 | #Configura o ambiente
372 | r.adjust_for_ambient_noise(s)
373 | #Captura o audio
374 | audio = r.listen(s)
375 | #Transforma em texto
376 | fala = r.recognize_google(audio, language="pt-br")
377 | return fala
378 |
379 | escutar()
380 | #Número aleatório
381 | #Não se esqueça de importar a biblioteca random
382 | num = random.radint(0,2)
383 |
384 | #Vetor com três piadas
385 | Piadas = ["Então, porque a aranha é o animal mais carente do mundo? Por que, ela é uma ar",
386 | "Afinal, você conhece a piada do pônei? Pô nei eu kkkkkkkkkkkk.",
387 | "Afinal, o que a vaca disse para o boi? Te amuuuuuuuuuuuuuuuu."]
388 |
389 | """Se a função escutar, retornar "piadas", então nossa assistente conta uma piada"""
390 |
391 | if escutar() == "piadas":
392 | falar(piadas[num])
393 | #Envia um e-mail
394 | elif escutar() == "e-mail":
395 | email_remetente = "Digite aqui seu e-mail"
396 | senha_rementente = "Digite aqui a senha do seu e-mail"
397 | email_destinatario = "Digite o e-mail que vai receber sua mensagem"
398 | mensagem = "Digite aqui a mensagem que você deseja enviar"
399 |
400 | #Conexão com o servidor do gmail, via protocolo SMTP
401 | """Caso, deseje mudar o servidor de e-mail, verifique o endereço smtp e a porta, do novo servidor"""
402 | email = smtplib.SMTP("smtp.gmail.com",587)
403 |
404 | #Inicia conexão com protocolo TTLS
405 | email.starttls()
406 |
407 | #Faz login na sua conta de e-mail, no caso gmail
408 | email.login(email_remetente,senha_remetente)
409 |
410 | #Envia o e-mail
411 | email.sendmail(email_remetente,email_destinatario,mensagem)
412 |
413 | falar("Enviei o e-mail")
414 |
415 | elif escutar() == "google":
416 | nav.open("www.google.com.br")
417 |
418 |
419 | Enfim, projeto concluido, nomeie sua AV e divirta-se.
420 |
421 |
422 | ## Caso precise de ajuda
423 | Caso, tenha ficado uma dúvida sobre o conteúdo apresentado neste readme, acesse o discord da heartdevs que a comunidade fornecerá o melhor suporte para você.