Transcrições
1. Vídeo 1 introdução: Bem-vindos a todos.
Neste curso, vou
te ensinar como criar seu próprio gerador de
senhas. A
linguagem de programação que
usaremos para criar esse
Op será Python, junto com algo
chamado tkinter. Tkinter é simplesmente uma
biblioteca Python que
nos permite criar uma interface gráfica de
usuário ou GUI. Isso nos permitirá
interagir com nosso gerador de senhas sem precisar digitar em
uma janela do terminal. Eu dividi o curso em algumas seções para permitir que você tenha uma melhor compreensão
do processo de
criação deste aplicativo. E eu só queria executar
o aplicativo muito rapidamente para mostrar exatamente com o que
trabalharemos quando terminarmos. Então, basicamente, temos
apenas um gerador de
senhas simples mostrado na primeira caixa, você pode inserir o número desejado de senhas que
deseja degenerar. Então, só para este
exemplo, vou inserir seis. E na segunda caixa
aqui, podemos inserir o
tamanho desejado de nossas senhas. Então, como exemplo,
acabei de inserir 12. E se eu clicar em janeiro, você verá que temos
seis senhas geradas. E cada senha
teria 12 caracteres. E se eu clicar em janeiro, novamente, obteremos um
novo conjunto de senhas. E eu poderia simplesmente clicar
continuamente em Gerar. E cada vez que eu clicar em Gerar, obteremos um novo conjunto de
senhas criado a
cada vez que fizermos isso. Esse é o
tipo geral de processo n. É isso que faremos quando terminarmos de usar o aplicativo. E espero que este
curso realmente ajude você a desenvolver suas
habilidades de codificação e ajude
você a ter um novo projeto
em seu currículo. Achei este muito interessante e divertido de
trabalhar comigo mesmo, e espero que seja algo que todos
vocês também gostem. Boa sorte com todos os vídeos. E espero que o processo seja bastante simples
e crie isso. E vejo todos vocês
no próximo vídeo.
2. Vídeo 2 conceitos básicos de GUI: Bem-vindo de volta
ao segundo vídeo. Neste segmento do curso, criaremos apenas nosso
modelo de nossa interface gráfica. Então, vamos
usar esse modelo básico para criar
nosso projeto final. Então, para começar,
abri o PyCharm, que é o ID que
vou usar para criar esse projeto. Se você preferir
usar um ID diferente, você pode fazer isso. E eu já tenho um arquivo
Python vazio aberto aqui. Se o seu IDE tiver alguns textos pré-gerados
no arquivo Python, você pode selecionar todo o texto e
excluí-lo apenas para que você tenha um arquivo
vazio exibido. Então, a primeira coisa que farei é
importar a biblioteca Tkinter. Então, vamos seguir
em frente e fazer isso. Em seguida, criaremos
uma janela que é simplesmente uma instância da cláusula
tkinter is TK. E o que quero dizer com
isso é
que teremos TK mostrado assim, e poderíamos simplesmente definir uma variável
que seja igual a isso. Então, para este exemplo, direi se root é igual a TK. Então, agora, sempre que
quisermos nos referir à nossa janela, podemos simplesmente nos referir à rota. Se eu quisesse definir o tamanho
da janela, por exemplo, eu poderia simplesmente dizer
geometria raiz, 900 por 850. Com essa linha aqui, defini o tamanho de nossas janelas para que pudéssemos mudar isso para tornar a janela
maior ou menor. Mas a ideia principal que eu
queria transmitir é que essa variável raiz é o que está se referindo à nossa janela agora. Portanto, se quisermos adicionar uma janela de
textura, por exemplo, se você quiser adicionar um título, poderíamos dizer route dot title, gerador de senha
aleatória. E isso definirá o
título da nossa janela. E a última coisa que
quero fazer é definir o loop
principal da nossa janela. Neste slide,
deixaremos o Python observar que ele deve executar o loop de eventos do
Tkinter, que escutará
coisas como, por exemplo cliques em
botões ou pressionamentos de teclas. E sem essa linha, nossa
janela não funcionará de jeito nenhum. Portanto, é importante que
tenhamos isso em nosso código para que nossa janela seja executada quando clicarmos em
Executar em nosso IDE. Então, para secretar
a linha do loop principal, tudo o que temos que escrever essa raiz. Não quero dizer. Agora, se eu clicar em Executar, veremos aqui, se eu colocar isso em foco, essa é a aparência
da nossa janela. Então, novamente, se eu quiser
mudar o tamanho, por exemplo, se eu quiser diminuir
a janela, eu poderia dizer que na geometria de
Rudolf
dirá 700 por 600 como o tamanho. E podemos reabrir
a janela dela aqui. E isso realmente tornará
a janela menor. Então, essa é a aparência da nossa
janela final. Espero que isso tenha feito sentido e vejo todos vocês no
próximo vídeo, onde
continuaremos adicionando mais
recursos à nossa interface gráfica.
3. Refinamentos de GUI em vídeo 3: Ok, bem-vindo de volta ao
próximo vídeo desta série. Vamos
continuar trabalhando na parte GUI do nosso gerador de
senhas. E então vamos
terminar essa parte. E para recapitular, no último vídeo, analisamos a criação de uma janela e adicionamos um
título à janela dela. Então, se eu executar
esse programa novamente, só para mostrar o que já
temos, essa é a
aparência do nosso programa no último vídeo. Então, neste vídeo, o que
vou fazer primeiro é criar
algo chamado rótulo. E no tkinter, o
termo rótulo se refere
à mesma coisa a que a própria
palavra rótulo se refere. Os rótulos, como o nome indica,
são simplesmente trechos de textos que podemos usar para descrever
elementos em nossa interface gráfica. E, novamente, é
bastante autoexplicativo. Eu vou criar
dois rótulos diferentes agora mesmo neste projeto. Portanto, o primeiro nível
será chamado de senha conhecida, que simplesmente
perguntará ao
usuário o número desejado de senhas que ele deseja gerar. E o segundo rótulo
será chamado de comprimento da senha, que simplesmente perguntará ao usuário
o tamanho desejado dos caracteres da senha que ele gostaria de ter
para criar um rótulo. A primeira coisa que você quer fazer é simplesmente dar um nome à sua gravadora. Então, eu direi senha se estiver
entorpecida, como se fosse igual. E então usaremos
o termo rótulo aqui para dizer ao Python que
estamos criando um rótulo. E quando estamos
criando um rótulo, há apenas dois elementos que
queremos esconder entre colchetes aqui. Então, a
primeira será nossa janela. E assim, como nossa janela é
chamada de raiz, entrará na raiz. E então o texto com vírgula é igual. E aqui é onde
podemos inserir o texto. Então, senha e,
digamos, pediremos ao usuário insira o número desejado
de senhas para gerar. É assim que sua mesa
vai ficar. Para nosso segundo nível, direi que o comprimento da senha
é igual à raiz do rótulo. E então nossos textos
serão iguais a, por favor, insira o tamanho desejado dos
caracteres da senha. Esses são dois rótulos
com sua interface gráfica. E em seguida, o que farei é adicionar esses
dois rótulos à nossa GUI. Então, primeiro definimos os rótulos. Agora, para adicioná-los, há um segundo processo
que precisamos concluir. Antes de eu começar. Vou apenas afirmar
que, para este projeto, vou usar contêineres
e sistema de crédito. Portanto, o sistema de grade basicamente
usa linhas e colunas para descrever onde você deseja colocar os elementos em uma GUI, por exemplo, se eu disser que quero colocar o
primeiro rótulo na coluna zero, linha zero e depois o segundo rótulo na
coluna zero, linha um. O que acontecerá
é que a primeira etiqueta será colocada acima
da segunda etiqueta. Tudo é relativo. Então, se eu disser que quero que o número da
senha esteja na coluna zero e o
comprimento da senha esteja na coluna um. Então o Python
saberá que, ok, preciso colocar esses dois rótulos um
ao lado
do outro, em vez de um na parte superior e outro na parte inferior. Então, vou digitar
isso aqui para ter uma ideia melhor do
que estou tentando dizer. Então, para adicionar o rótulo aqui, direi que a coluna
de uma grade de pontos de senha é igual a zero e rho é igual a um. E agora, para adicionar o tamanho da senha, que para o nosso projeto
eu quero adicionar esse comprimento de senha
sob o número da senha. Então, vou dizer que a grade
do documento com comprimento de senha, coluna é igual a zero porque eu quero que ambas
estejam na mesma coluna. E a linha é igual a um, você sabe,
na verdade, mude isso para a linha zero porque se você puder
começar com zero. E agora, se eu executar o
programa assim, os rótulos aparecerão assim. E mais uma coisa que posso fazer aqui é comentar nossa geometria de Rudolf
ou enviaremos um tamanho de janela. Usando o sistema de grade, Python saberá como
redimensionar automaticamente a janela de acordo com o tamanho de nossos textos e assim por diante. E então eu posso simplesmente
comentar isso aqui. E se eu executar nosso programa novamente, veremos que temos nossos
dois rótulos exibiremos em nossa janela aqui, exatamente como queríamos que fossem. Então, é basicamente
assim que adicionaríamos rótulos à nossa GUI
aqui usando o Tkinter. A próxima coisa que quero
revisar é adicionar uma caixa giratória. Então, quando eu giro caixas, caixas
giratórias são
simplesmente pequenas caixas que têm setas para cima e para
baixo que permitem selecionar números de um determinado intervalo ou você pode digitar o número. A razão pela qual eu quero incluir caixas
giratórias neste
projeto é alta. Poderíamos usá-los para
permitir que o usuário digite tamanho de senha desejado ou para digitar quantas senhas deseja regenerando o sonar para
criar uma caixa giratória. Posso primeiro definir um
nome para nosso spin bulk. Então, vamos chamar isso de spin. Então, para nossa primeira caixa de lixo, nós a usaremos também. Permita que o usuário
defina o número de senhas
que deseja gerar. Em seguida, a segunda caixa
giratória permitirá que o usuário insira o tamanho desejado dos
caracteres da senha. Portanto, para a primeira caixa de lixo, vou defini-la como rotação
igual à caixa giratória. E então vou inserir o
nome da nossa janela. Então, qual é a raiz. Aqui, posso definir um intervalo. Então, posso dizer que a partir de I
é igual a 02, é igual a 20. E isso significa que
a caixa giratória permitirá que o usuário
escolha números de 0 a 20 e nem
mais nem menos que isso. E, finalmente, posso definir uma
largura para a caixa giratória. Então, vou dizer que, para este
projeto, a largura é igual a cinco. E agora temos uma caixa
giratória definida aqui. E nossa segunda caixa giratória, vou dizer que gasta
uma é igual a suspender livros. E, novamente, a rota de é igual a 02, igual a 20 e a largura é igual a cinco. E deixe-me executar este
programa novamente para ter certeza de que tudo está
funcionando conforme o esperado. Ok, eu só tenho que fazer
uma pequena mudança aqui. Portanto, a partir de sublinhado igual zero seria a sintaxe
correta. E deixe-me
executar esse programa. E, como mostrado aqui, temos tudo funcionando
novamente conforme o esperado. Não adicionamos a caixa giratória, as caixas giratórias ao nosso ginecologista. Então, agora
vamos fazer isso. Então, para adicionar
a primeira caixa de ajuste, podemos simplesmente dizer spin,
porque isso é, eu estou usando spin porque esse é o nome de nossos insetos calouros. E se quiséssemos adicionar
a segunda caixa giratória, diríamos girar uma. E então eu estou dizendo grade de pontos giratórios. Aqui podemos definir a coluna. E a briga que queremos
colocar é o boxe. Então, por enquanto, vou adicionar isso à
coluna zero na linha dois. Portanto, isso estaria logo
abaixo do tamanho da senha. Suspenda a grade do cão, a coluna
é igual a zero e rho é igual a. Execute isso. Vamos ver se temos
um spin-bogs, certo? Em nossa declaração, insira o tamanho desejado dos caracteres da
senha. E, na verdade, porque eu quero essa primeira caixa vin permita que o usuário defina o número
de senhas que deseja. Janeiro. Vou mudar a linha para a linha um e alterarei o rótulo
do tamanho da senha para a linha três. Então, uma vez feito isso,
deve ficar assim. Agora, vou
adicionar essa segunda caixa giratória, que permitirá ao usuário
inserir o tamanho desejado dos caracteres da
senha. Então, vou adicionar isso à linha quatro. Então, vou dizer que girar uma coluna de grade de cães é igual a
zero e rho é igual a quatro. E se eu executar
isso, é isso
que queremos ver aqui. Então, isso é o que
esperaríamos depois de adicionar nossas caixas de sprint e
rótulos à nossa GUI. E enquanto você está
passando por isso, eu sei que você pode
estar pensando, bem, como isso se relaciona com a função real
que gera
senhas aleatoriamente e
as envia para nossa GUI. E não se preocupe se
isso for confuso. Tudo fará sentido no
final, à medida que eu passar por isso. Portanto, faça o
possível para acompanhar e você poderá entender como isso funciona. Ok, então temos nossas caixas giratórias, temos nossos rótulos. Agora, o que eu quero fazer é
definir nossa função, nossa principal função
que usaremos para gerar senhas aleatórias. Mas vou usar isso como uma
função fictícia por enquanto. Portanto, ele realmente não faz
nada no momento. Só vai dizer que vai
imprimir “olá”. Então, só para
definir a função, eu vou dizer para definir uma
chamada, ela clicou. Vou dizer apenas imprimir. Olá. A razão pela qual estou definindo
isso como uma função fictícia por enquanto é porque quero adicionar um
botão à GUI, que executará essa função
assim que for clicada. Quando realmente tivermos essa função gerando senhas
aleatórias, o que
esperaríamos é que, ao clicar nesse botão, ela execute essa função
e gere senhas e
exiba-os na GUI. Então, para adicionar um
botão à nossa GUI, o que queremos fazer primeiro
é definir um botão. Então, vou chamar nosso botão btn. E eu vou dizer que BTN é igual ao botão. Em seguida, definirei a
janela que é raiz. Os textos ou o botão VR
serão iguais a serem gerados. E aqui é onde podemos
definir qual função
queremos que o Python execute
depois de clicado. Então, eu quero executar essa função
aqui, que é clicada, que é o que definimos. Então, para que essa função seja executada ao
clicar neste botão, eu digo que comando é igual
a clicar, assim. Vou adicionar
essa ligação ao nosso gráfico. Então, vou dizer que a
coluna da grade de pontos BTN é igual a zero. E não tenha isso
na parte inferior. Então eu vou dizer rho é igual a cinco. Está bem? E eu só quero remover esses dois colchetes aqui
porque eles não são necessários. E agora, se eu executar este
programa, veja isso aqui. E se eu clicar em Gerar, veremos um pequeno console interno
pop-up. Então, em janeiro, e podemos ver que toda vez que você
clica em Gerar, vemos a palavra olá
exibida no console. Então, tudo está
funcionando conforme o esperado. E, finalmente, o que eu
quero fazer é adicionar uma caixa de texto. Portanto, essa caixa de texto será usada para que todas as
senhas geradas
sejam exibidas em nossa GUI. Então, para definir uma caixa de texto, posso dizer t, que também
será usada. Usamos o que definimos em
nossa casa de caixa de texto. Então t é igual à raiz do texto. E daremos a ela uma altura
de 15 e uma largura de 50. E eu posso simplesmente adicionar isso
à grade dizendo que a coluna da grade
T Don é igual a
zero, rho é igual a sete. E, novamente, eu não preciso
desses ponto e vírgula. E se eu clicar em executar,
podemos ver que temos uma caixa de texto exibida logo abaixo
do botão de janeiro. Então é isso que
queremos poder ver aqui. Ok, então isso é tudo o
que eu queria
ver neste vídeo. Então, só para recapitular, o que fizemos foi adicionar
rótulos a ela para você. Por quê? Nós adicionamos caixas giratórias. Adicionamos um botão
à nossa interface gráfica e programamos
para poder executar uma função com um clique. E adicionamos uma
caixa de texto à nossa interface gráfica. Então, no próximo vídeo, o que faremos é tornar
esses elementos mais funcionais
e fazer com que o Python realmente seja capaz de gerar senhas usando os valores que
definem nossas caixas giratórias e nossa tela eles em
nossa caixa de texto que criamos e que é exibida
em termos de energia. Então, espero que isso tenha feito sentido. Caso contrário, fique à vontade para
voltar atrás, tentar desacelerar o vídeo e analisar
tudo passo a passo. A primeira vez que aprendi um pouco confuso
para mim também
, demorei um pouco
de tempo para entender o que estava acontecendo. No próximo vídeo.
Vamos continuar com isso e vamos
construir a partir daqui.
4. Vídeo 4 etapas finais: Bem-vindo de volta ao último vídeo desta série
de projetos guiados. Neste vídeo,
vamos examinar a função principal que gerará nossas senhas para nós quando executarmos o aplicativo. Essencialmente, o que essa função fará é usar uma string que conterá
uma combinação de letras, números e caracteres especiais. E ele será usado para
gerar nossas senhas. E para fazer isso funcionar, nossa função
selecionará caracteres de nossa string em um
índice aleatório a cada vez e os adicionará a
uma sequência de senha até atingir o tamanho de senha
desejado. Essa função
também permitirá que o usuário escolha o número desejado de senhas que
deseja gerá-la. Em resumo, essa
função funcionará para permitir que o usuário escolha tamanho da senha desejado e também o número desejado
de caracteres
que deseja que cada
senha tenha. Voltaremos
à função fictícia que definimos anteriormente. Então foi aqui que
dissemos “imprima olá”. E dentro dessa função, vou definir
um número inteiro chamado i. E vou definir I igual a zero. Inicialmente. Eu servirei como um contador para que cada
vez que nosso laço de arame for executado, eu seja incrementado em um. Então, digamos que se o
usuário decidir que deseja 12 senhas de TV
criadas por esse programa, o loop while será executado 12 vezes para gerar 12 senhas
diferentes. E cada vez que o loop é executado, ele adiciona um a I.
E quando eu chegar,
digamos 12, por exemplo,
ele sairá E quando eu chegar, digamos 12, por exemplo do loop while e sairemos
da nossa função. E isso será quando
a parte real
geradora de senhas do
programa estiver concluída. A próxima coisa que vou fazer é adicionar um código aqui para excluir o texto da nossa caixa de texto quando a
função for chamada. Então, vou
digitar isso aqui. E, essencialmente,
o que
essa linha faz é excluir todos os textos. Temos
uma caixa de texto inerente quando a função é
executada, como eu disse anteriormente. E então você pode perguntar, bem, por que
teríamos que fazer isso? Digamos que executamos o programa e geramos algumas senhas, e o usuário decide que, Ei, eu quero gerar mais
algumas senhas. Deixe-me prosseguir e gerar
um segundo conjunto de senhas. Bem, se não excluíssemos
realmente as senhas anteriores que
foram criadas por este programa. Na verdade
, as novas senhas são impressas e logo abaixo delas. Realmente não parece muito legal. Portanto, seria melhor realmente
excluir as senhas antigas
que o programa
criou para abrir espaço
para as novas. A próxima coisa que faremos
é definir um loop while, que será usado para iniciar o processo real de
geração de cada senha. E assim podemos dizer que, embora eu seja menor que, vou pegar um número
do primeiro spinner, que é aquele
aqui onde o usuário
pode inseri-lo ali. O número de senhas
que eles desejam degenerar. Então, se você se lembra
do último vídeo, chamamos isso de spin. E aqui poderíamos dizer que, enquanto eu é menos do que
girar, fica escuro. E precisaríamos converter spin dot get em um número inteiro. Então, diríamos int e jogamos
colchetes getName de spin dot para fazer isso. Portanto, embora eu seja menor do o número que o usuário define na
primeira caixa de pinos. Podemos dizer que a senha é igual
a uma string vazia. Certo? Sob isso, poderíamos dizer Y0. O tamanho da nossa
senha é
menor que o número definido
em spin one dot get. E, novamente, essa linha está
apenas recuperando o número que o usuário inseriu
na segunda caixa giratória. Então, se voltarmos
ao nosso programa aqui, isso definirá
o tamanho desejado dos
caracteres da senha. E, novamente, queremos
converter isso em um número inteiro, então diríamos apenas em sabão e os gastos
estão entre parênteses. E aí podemos dizer que senha
dela será igual a, e vamos
dizer mais igual porque queremos acrescentar
cada caractere um ao cada caractere outro até atingirmos
o desejado. comprimento da senha. Então, diremos que senha
mais igual a caracteres, rand
aleatório int zero. Em seguida, o comprimento dos caracteres menos um. O que estamos dizendo aqui é vamos
recuperar um caractere aleatoriamente da
sequência que
definiremos que
conterá letras, números e caracteres especiais. Estamos dizendo que
vamos pegar um número aleatório que está dentro do intervalo de zero até o comprimento real da
string que criaremos, que contém nosso conjunto de
caracteres. E a razão pela qual dizemos menos
um é porque quando tomamos o comprimento de uma corda, por exemplo, ela nos dará o comprimento
real dela. Então, digamos que haja cinco
caracteres na sequência. Isso seria totalmente bom. Mas quando
trabalhamos com índices, começamos do zero e, na verdade,
não começamos de um. Então, quando procuraríamos
um índice de quatro, por exemplo, dentro dessa string. Isso
significa que, na verdade, recuperaremos o último
caractere dessa string. É por isso que
dizemos menos um aqui. E, finalmente, o que
queremos fazer é, fora do loop while, é, fora do loop while, inserir nossa nova
senha em nossa caixa de texto. Então, para fazer isso,
diríamos Te dot insert
e, em seguida, chamamos o
comando insert password. E então vamos apenas adicionar
um espaço aqui, mais. E vamos converter isso
em uma string. Então, cordão. E pegaremos a senha
atual que estamos gerando, que será I mais um, porque os índices
começarão do zero. E agora, porque estamos
falando sobre senhas, queremos começar com uma,
porque seria mais estranho dizer possivelmente
zero em vez de senha um. Então, eu mais um. E então adicionaríamos seus dois pontos
mais a senha regenerada. E depois uma nova linha. Finalmente,
gostaríamos de incrementar I. Então diríamos que I
mais é igual a 21. Ok,
acabei de remover
os pontos e vírgulas que estavam presentes em algumas dessas linhas pois na verdade você
não é necessário. Esse é apenas um hábito que tenho
de codificar em C plus plus. Mas em Python, na maioria das vezes, eles geralmente não são necessários nas linhas do seu
código que você deve, certo? Agora, o que vou
fazer é definir nossa string que
conterá letras, números e
caracteres aleatórios que serão usados para
gerar nossa senha. Então, como você pode ver na
função que criamos anteriormente, temos uma string chamada chars. E vou simplesmente ir acima dessa
função aqui e definir chars como sendo
iguais a uma string. E vou colar aqui o
conjunto de letras, números e caracteres
que tenho, que podemos usar para
gerar nossas senhas. Então, aqui está um exemplo
que você pode usar. E, em seguida, faremos alguns. Talvez tenha notado que o código aleatório aqui não
está realmente definido porque precisamos
importar aleatoriamente para o Python
para que ele seja usado. E então eu posso simplesmente ir até o topo aqui e digitar import random. E agora, se eu
continuar e executar isso, o programa deve
funcionar conforme o esperado. Então, se eu disser, por exemplo quero gerar
cinco senhas, , quero gerar
cinco senhas,
cada uma com seis caracteres. Se eu clicar em Gerar,
veremos que
temos cinco senhas que
foram geradas, cada uma com seis caracteres. Se eu clicar em Gerar novamente, veremos que as senhas
continuam mudando. E essa é a ideia
principal do que eu estava tentando obter, o programa que você deve ser capaz de criar depois de
acompanhar esses vídeos. Espero que tenha sido bastante simples e que
você tenha conseguido entender bem o processo
de criação deste aplicativo. Obrigado por assistir a
esses vídeos e espero que você tenha gostado de
criar este projeto.
Ali
