Transcrições
1. [NOVO] — Introdução ao curso: Olá, bem-vindo ao curso
intermediário Python Mastery Ultimate
. Sou Anna Pretorius,
freelancer de TI e professora formal de
ciência da computação, e este curso foi desenvolvido para alunos que
já entendem o básico do Python
e estão prontos para expandir seus conhecimentos de uma forma Se você está familiarizado com
variáveis, tipos de dados, loops, funções
e condicionais, está
pronto para a próxima etapa Agora, se você é completamente
novo, não se preocupe. Eu recomendo que você comece primeiro com meu curso
para iniciantes, depois possa voltar
aqui depois de construir sua base e se sentir confortável com o
básico de Pierson Agora, neste curso, trabalharemos dentro do
Visual Studio Code, um dos editores mais populares para desenvolvimento profissional Vou
orientá-lo na instalação do Python, configuração do Visual Studio Code
e na configuração de tudo
corretamente para que você esteja pronto para começar a escrever e
executar código Agora, a partir daí, vamos
mergulhar em uma ampla variedade
de tópicos intermediários. Você aprenderá sobre
tópicos como módulos, manipulação de
arquivos, decoradores, funções
lambda e aspectos mais avançados da programação orientada a
objetos como herança
e abstração, e também nos aprofundaremos
nos pacotes Além disso, muitos outros tópicos
serão abordados,
como tópicos sobre geradores, gerenciadores de
contexto, cópia profunda, recursão, JSON,
es, testes unitários, ambientes
virtuais, multithreading e multiprocessamento muitos outros tópicos
serão abordados,
como tópicos sobre geradores, gerenciadores de
contexto,
cópia profunda, recursão, JSON,
es, testes unitários, ambientes
virtuais,
multithreading e multiprocessamento. Então, como você pode ver,
há muito conteúdo para abordar e muito para trabalhar,
mas não se preocupe. Você está em boas mãos, e vamos
superar isso juntos. Agora, este curso
foi desenvolvido com um equilíbrio entre explicação clara
e prática, e você também concluirá exercícios
de laboratório para escrever código real e realizar miniprojetos projetados para
desafiar e desenvolver suas habilidades. Por fim, você reunirá
tudo em seu próprio projeto na seção de
projetos e recursos, criando algo
prático e personalizado. Agora, ao final deste curso, você terá a confiança necessária para criar
aplicativos mais avançados, escrever um código
mais limpo e escalável e entender como os recursos intermediários do
Python são usados em cenários do mundo real Agora, este curso tem mais de 10
horas de aulas estruturadas e mais de 100
aulas são abordadas, e vai
ajudá-lo a preencher
a lacuna entre um desenvolvedor iniciante
e um desenvolvedor capaz Então, confie em mim, você está
em boas mãos.
2. Processo de pensamento: Oi, Eon. E bem-vindo
à próxima lição, que será
focada no processo de classificação. Portanto, nesta palestra, vou apenas
dar alguns
conselhos, que você pode seguir se
quiser sobre
como estruturar nosso processo de sal ao realizar este curso Então, vamos
começar. Então, classifique o processo. Agora, antes de
mergulharmos no curso, precisamos estruturar
nosso processo de classificação. Então, eu só quero
te dar alguns conselhos. Então, vamos em frente e vamos direto ao assunto. Portanto, o primeiro
conselho que gostaria de dar a você
é dar um passo de cada vez. Então, faça esse curso
um passo de cada vez. Por favor, não escove,
certo? Não tenha pressa. Se você está demorando muito para aprender
uma
lição específica , não
perca a esperança. Você entenderá
isso com o tempo. Algumas pessoas entendem
vários conceitos imediatamente pela primeira vez. Outros demoram mais para
entender certos conceitos. E, como eu, como aprendiz de certos assuntos da minha
vida,
é claro que dediquei muito tempo para
entender
certas áreas de conceitos e, em outros tópicos
específicos domino quase instantaneamente Para todos, é diferente. Todo mundo enfrentará
um desafio em algum momento,
então, por favor, não
desanime e vá devagar, com
calma e com vá devagar, com
calma Outra dica que gostaria de
dar é definir um cronograma
e cumpri-lo. Agora, é claro, você não
precisa ser extremamente rigoroso e
detalhado em sua agenda O que quero dizer com isso é que você
não precisa planejar isso
pelos minutos, pelas horas exatas e pelo horário, etc O que quero dizer com isso é ter um cronograma
que não o sobrecarregue, mas que o pressione
apenas o suficiente para permanecer consistente, disciplinado
e até
motivado para
concluir o curso disciplinado
e até motivado para
concluir o Portanto, tenha isso em mente. Então, na minha experiência aqui, eu recomendo que você escolha um horário que seja
mais flexível para você. Eu mesmo não gosto de me
sentar com rigor e, exatamente como posso dizer os horários, os minutos
gastos e as horas gastas Eu não gosto de seguir
essa abordagem. Ou com datas, gosto manter as coisas mais
flexíveis e dizer: Ok, quero gastar uma certa quantia por mês
trabalhando neste curso e só quero terminar
cerca de cinco a dez aulas. Então essa seria minha
abordagem e como eu faço isso. Portanto, dependeria de como
você prefere seguir em frente. Só estou te dando um exemplo. De qualquer forma, é bom ter pelo
menos um cronograma básico
para acompanhar. Agora, o conselho mais importante que quero compartilhar com
vocês aqui é o último, que é permanecer positivo e saber que não é uma corrida para
concluir o curso, mas sim uma jornada lenta e
constante para adquirir conhecimento de longo prazo
para obter os melhores resultados aqui Isso é o que eu quero dizer aqui.
Você não quer se apressar neste curso,
mas sim tomar seu tempo, mesmo que ache que
os conceitos são muito fáceis de entender,
mas não se apresse. Mantenha-o estável e trabalhe
nele no curso
ocasionalmente ou regularmente, dependendo de seus horários Isso é uma coisa muito importante que eu quero mencionar aqui. Novamente, isso
envolve muitas coisas aqui com o objetivo de
permanecer positivo. Novamente, é claro,
se certos conceitos levarem algum tempo para serem
entendidos, trabalhe eles, faça um esforço e
você chegará lá. Mantenha-se positivo e saiba
que isso levará algum tempo, mas vá devagar, acalme-se e relaxe ao
longo do curso. Eu fiz o meu melhor
aqui para torná-lo tão
simples quanto livre de estresse
ao longo deste curso. Portanto, lembre-se
de relaxar, respirar fundo, percorrer o curso
com calma
e se divertir Tudo bem, pessoal. Então isso é
tudo que eu queria mencionar aqui em termos de processo de
pensamento.
3. Recursos do curso: Oi, todo mundo. E bem-vindo
à próxima lição, que será focada nos recursos do
curso. Então,
vamos dar uma olhada. Tudo bem, então você
provavelmente está se perguntando, ok, como vamos codificar? Então, a primeira coisa que
precisamos garantir é que
temos o Python instalado
em nosso dispositivo Então, se estamos trabalhando em um PC com Windows ou em um dispositivo macOS Em seguida, instalaremos e configuraremos o código do Visual Studio, comumente chamado de código VS, e esse é um editor de codificação
que nos
permitirá criar e executar
nossos programas PySon Agora, eu sei que isso pode parecer um pouco estressante e
preocupante, mas não Vou detalhá-lo o mais
facilmente possível para você e vou mostrar
exatamente como
vamos começar com
tudo. Então não se preocupe. Você está em boas mãos.
4. Acessando recursos do curso online: Olá a todos, bem-vindos
à próxima lição, que será focada no acesso aos recursos do nosso
curso on-line. O que quero dizer com isso é que
vou mostrar como
você pode
acessar os
sites necessários para baixar e configurar o PySON
e também para
configurar o código do Visual Studio Eu só vou te mostrar
como acessar os sites. Nas próximas aulas, vou realmente mostrar como instalá-los e configurá-los. Esta é apenas uma lição
sobre como acessá-los. Então, você pode acessar
o Google e digitar PySon Download, e então podemos simplesmente
dizer Pesquisa do Google E neste link aqui,
você verá que ele se
chamará Download PySon e
você quer clicar nele Isso o levará para
a página seguinte aqui, que é uma barra direta de download em Python ou
barra direta download em Python ou
barra Portanto, não vamos
instalar o PySon agora. Eu só quero ajudar você a
acessar o site. Em seguida, também
usaremos o Visual Studio Code Então, o que você pode
fazer é ir em frente no Google e digitar Visual
Studio Code Download. Eu vejo a pesquisa do Google. E você verá esse
link aqui que diz baixar o
Visual Studio Code, Mac Linux e Windows,
para que possamos abri-lo. E aqui está a página que
precisaremos seguir em frente e configurar código do
Visual Studio como
nosso editor de codificação Tudo bem, pessoal. É isso para
esta lição, muito simples. Eu só quero mostrar como
você pode acessar esses sites para
referência futura nas
próximas aulas.
5. Python — instalação e configuração — Windows: Oi, pessoal. Bem-vindo
à próxima lição, que se
concentrará na instalação do PySON em um dispositivo Windows.
Vamos começar. Agora, a primeira coisa que você
precisa fazer é acessar o seguinte endereço
da web,
que está em python.org, fordslash Depois de inserir
esse endereço da web, você será redirecionado
para a
página seguinte , como você pode ver aqui O que vamos fazer é
baixar o PySON para Windows agora. Agora, em termos da
versão que é fornecida quando você
acessa esta página, ela não precisa ser exatamente
a mesma versão, então não se preocupe,
desde que não esteja muito distante. Certo, o que podemos fazer é ir
em frente e ver o download do Pison. Aqui está a configuração para nós, que podemos abrir. Isso nos guiará
pelo assistente de configuração. Então, o que vamos querer
fazer é garantir que estamos usando privilégios de
administrador ao
instalar o Pit Ex e também adicionar
o PysonTeX ao nosso Agora, isso é muito
importante apenas para garantir que todos os nossos usuários em
nosso sistema possam executar o PySON em qualquer tipo de aplicativo que permita a execução do
Python Há alguma restrição? Então você quer dizer instalação
personalizada. Ok, certifique-se de que tudo esteja selecionado, como
você pode ver aqui. Então, podemos ver a seguir. E então você quer dizer que instale o PySON para todos os usuários aqui, neste caso, é 3.13 Portanto, certifique-se de selecionar
a opção a seguir, e isso
garantirá que todos os usuários seu dispositivo
possam usar o PySON Depois de fazer isso, você pode
ir em frente e dizer Instalar. Um aviso aparecerá
na sua tela, e o meu está atualmente desativado,
e você só quer dizer sim
a esse aviso de segurança Assim, podemos ver que a
configuração está em andamento. Então, vai
demorar um pouco até
que o PySON seja
instalado em nosso sistema Então, teremos
que ser um pouco pacientes até que seja
configurado e concluído. Então, vamos esperar um momento.
Tudo bem. Bem vindo de volta. Parabéns pela
configuração
bem-sucedida do PySON em seu PC com Windows Como podemos ver agora,
a configuração foi um
sucesso, muito bem. Agora podemos prosseguir e fechar isso e eu vou
minimizar isso. Agora, para garantir que tudo tenha sido instalado corretamente e que não
haja problemas, eu recomendo fortemente
que você faça isso agora reinicie o PC. Então, por favor, certifique-se de fazer
isso. Isso é muito importante. Então, o que você pode fazer
é até
o seu PC e dizer ir até
o seu PC e dizer
que
reinicie e desligue. E então, é claro, depois que
seu PC for reiniciado, eu o conduzirei pelo teste
final de confirmação para garantir que o PySON
realmente tenha sido instalado
em seu sistema e que a aprovação tenha sido a mente do
sistema em seu Então isso é o principal. Portanto,
a variável de ambiente PySON precisa ser
carregada e configurada Então, vamos seguir em frente e fazer isso. Então, vamos reiniciar os PCs
e
voltaremos assim que nossos computadores
forem reiniciados Tudo bem, então bem-vindo de volta. Então, eu acredito que agora você
tenha reiniciado seu PC. Agora, tudo o que você
vai querer fazer para
a confirmação final de
que o PySON
foi configurado corretamente em nossos sistemas é
pesquisar o prompt de comando Você pode simplesmente digitar
CMD para encontrá-lo rapidamente. Então, aqui está nosso prompt de comando. E tudo o que vou fazer
agora é
ajustar isso apenas para seu prazer visual, e vou dizer apenas a versão
PySON dash dash Então você também pode
digitar isso
e, em seguida, pressionar Enter. E se tudo foi um sucesso, ele deve gerar
a versão PySon que você instalou
em seu sistema E isso é como uma verificação final de
confirmação para
garantir que tudo correu bem e que
estamos prontos para começar. Tudo bem. Portanto, certifique-se de
ver isso e de ter instalado o PySON em sua
máquina, e pronto É assim que você
pode instalar o PySON em seu sistema e
também verificar se não
há problemas ou conflitos nem nada e se ele foi instalado corretamente Tudo bem, vá. Então,
para esta lição, é assim
que você pode
prosseguir e instalar o PySON em um dispositivo Windows
6. VS Code — instalação e configuração — Windows: Oi, todo mundo. E bem-vindo
à próxima lição, que se concentrará
em baixar e
configurar o código do Visual Studio
em um dispositivo Windows. Então, vamos começar. Agora, a primeira coisa que
você precisa fazer é acessar a seguinte URL, que você pode adicionar como código visualstudio.com
flash Download, que o levará a esta página
aqui, onde
você pode baixar o código do onde
você pode baixar Visual Studio para o sistema operacional Agora, no caso, ele estará no Windows. Podemos prosseguir e selecionar a opção aqui para o
Windows 10 e 11, que
possamos clicar nela
e
fazer o download do guia de
instalação para nós e do assistente de configuração. Podemos ir em frente
e abrir isso. Sejamos pacientes
enquanto ela se abre. Queremos aceitar o acordo. Vamos para a próxima etapa. Ele vai salvá-lo em
uma pasta de destino. Vamos para a próxima etapa. Podemos ver que é assim que
podemos acessá-lo
no menu Iniciar como código do Visual
Studio a seguir. Eu recomendo que você crie um ícone na área de trabalho por enquanto. Você sempre
pode remover isso. Podemos dizer a seguir e instalar. Agora, ele instalará código do
Visual Studio
em nosso computador. Tudo o que vamos
querer fazer agora é ser paciente enquanto o processo é concluído. Certo,
então, bem-vindo de volta. Como você pode ver, o código do Visual
Studio foi
instalado
com sucesso em nossa máquina e agora podemos iniciar o
Visual Studio Code. Portanto, se essa opção
não tiver sido marcada para você na caixa de seleção, você
pode ir em frente e marcá-la e ver a opção Concluir, e
isso abrirá código do
Visual Studio para
nós. Então, podemos dizer “termine”. E aqui estamos. Então, aqui estamos no código do Visual
Studio. Então, muito bem. Você
baixou e configurou com êxito código do
Visual Studio em seu PC com
Windows. Muito bem feito.
7. Iniciando nosso projeto: janelas: Olá a todos, bem-vindos
à próxima lição, que se
concentrará em
começar a usar o código do Visual Studio. Tudo bem. Agora, o que
vamos querer fazer é criar nosso projeto, que abrigará
nossos arquivos Python Ok, então, como você pode ver, não
temos pastas abertas
nem nada do tipo. Então, o que vamos fazer é
ir até a área de trabalho, clicar com o botão
direito dizer nova e
dizer nova pasta e dar a essa pasta um nome adequado. Então, vamos trabalhar
com nosso código Python. Então, eu acho que um nome
simples aqui se
chamaria Meu Projeto. Lá vamos nós. Agora podemos voltar
ao código do Visual Studio e
agora você pode dizer abrir pasta ou clicar no
ícone no canto superior esquerdo, ir para Arquivo e abrir pasta. Em seguida, podemos navegar até nossa área de trabalho e
selecionar meu projeto. Aqui é onde nosso
código PyCon será alojado. Podemos então dizer selecionar
pasta. Tudo bem. Perfeito. Portanto, essa é a
pasta com a qual
trabalharemos para armazenar
nossos scripts PySon Certo. Agora, a próxima
coisa que você quer fazer é destacar ou passar o mouse sobre a pasta do projeto aqui
e você verá alguns ícones Queremos clicar em Novo arquivo, e esse será
nosso arquivo de script PySON Então é aqui que adicionaremos todo o nosso código PySON
e,
em seguida,
executaremos o código com base
nos comandos que
foram definidos nesse arquivo Então, por enquanto, vou chamar
isso de ponto principal pi. Você pode dar a ele o nome que
desejar
e pressionar Enter. Agora, assim que
você pressionar Enter, você receberá um
prompt aqui que diz: Deseja instalar o PySoneTension
recomendado
da Microsoft para a linguagem PySon da Microsoft Então, eu recomendo que você faça isso. Isso o presenteará com alguns recursos extras e coisas do gênero. Então, eu recomendo ir em frente e instalá-lo. Então
você pode dizer instalar. Portanto, a instalação
dessa extensão no código do
Visual Studio levará
alguns minutos . Agora, tudo o que você precisa fazer agora
é ser um pouco paciente
e, uma vez instalado, podemos continuar a partir daí. Certo, então bem-vindo de volta, pois
podemos ver que a extensão
Python
foi instalada no código do
Visual Studio, então podemos fechar isso E o que também podemos fazer é
acessar o Explorer. E aqui podemos
prosseguir e alternar a seguinte opção para maximizar nosso script aqui chamado de torta de pontos
principais, por exemplo E se quisermos
ver nosso diretório, que abriga nosso projeto
e os arquivos associados, é claro que
podemos
simplesmente voltar. Tudo bem. Então, apenas algo que eu também
queria mencionar nessa nota. Certo. Agora, o que
queremos fazer é adicionar nosso
código Python a esse script
e, em seguida,
executar esse script e ver o
resultado da saída Agora, a primeira coisa
é
começar e criar
um programa simples. Vou apenas definir
uma variável conhecida como nome, e dizemos igual
e definimos isso o valor de não, então eu vou imprimir essa variável
e ela vai gerar o valor
associado ao nome que é Agora, há duas maneiras pelas quais você pode seguir em frente e
começar com isso. Agora, da forma manual,
vou mostrar primeiro, ou seja, você pode clicar no ícone
que flui
no canto superior esquerdo Então você quer ir para o terminal, e você quer
abrir seu terminal. Tudo bem, então
aqui está. nosso terminal aqui
no lado esquerdo. E com esse console de depuração, você pode seguir em frente e
simplesmente mudar isso E o que eu recomendo que você faça
agora é reabrir seu terminal Às vezes, a configuração demora um
pouco. Então, eu sempre dizia: Kill terminal. Então eu vou fechá-lo, e então voltamos para o terminal e depois
o abrimos novamente. E aqui vamos nós. Tudo bem, agora podemos seguir em frente
e começar Agora, o que você vai
querer fazer é executar seu arquivo de script PySON de
acordo com o nome Então, isso é chamado de Min Dot Pie, e podemos ver o diretório
que configuramos aqui. Então, atualmente, nosso terminal está examinando o usuário
aqui, que é
Ono, na área de trabalho na pasta
Meu Projeto, que é a pasta que criamos aqui
chamada Meu Projeto. E, como você pode ver, ele também está
disponível aqui, Meu Projeto, e temos o Min Dot Pi, que está dentro da pasta
Meu Projeto. que vamos fazer para
executar qualquer código que esteja
neste arquivo dot py principal
é o seguinte. Você só quer digitar Python. E então você pode simplesmente
se referir ao nome do arquivo, que é main dot py. Mas tudo o que você quer fazer é
dizer o ponto principal pi do PySon e entrar, e lá você pode ver que ele gera nosso código para Portanto, essa é a
maneira mais simples de
seguir em frente e executar seu código PySon no código do Visual Studio e
usando esse terminal. Certo. Também podemos digitar de forma clara
e isso também
ajudará a limpar o
terminal. Então essa é a primeira maneira pela
qual você pode executar código. Então, é uma
forma meio manual de se dizer. Agora, a maneira mais fácil é ocultar esse painel. Agora você verá se instalou
a extensão Python Agora
você terá a
oportunidade de passar o mouse sobre o ícone
a seguir e executar
seu arquivo Python Isso faz isso automaticamente
para você, por si só. Podemos simplesmente clicar
em Executar PysonFle clicando neste ícone, e isso
abrirá o terminal para nós e você verá que ele
executará o executará o Aqui temos a torta de pontos principal, que foi executada e a
saída aqui, que está nela. Essa é outra
maneira pela qual você pode fazer isso. Há duas maneiras. Tudo bem. É isso aí, pessoal. É assim que podemos
começar
a usar o código do Visual
Studio e
estabelecer nossas bases para
nosso projeto PySon Então, podemos ir em frente agora
e ver aqui. Tudo bem. Então é assim que podemos seguir
em frente e começar e colocar tudo, tipo,
no lugar certo.
8. Python - Instalação e configuração - MacOS: Oi, todo mundo. Bem-vindo
à próxima lição, que se
concentrará na instalação do
PySON em um dispositivo macOS A primeira coisa que você
quer fazer é acessar o seguinte URL,
que está em python.org
forwardslash Downloads forwardlas Você quer ter
certeza de acessar esse URL. Depois de inserir
isso, você será redirecionado para a página
seguinte aqui, que está na página de downloads do
Python Então você deseja baixar o PySon para poder
clicar neste botão aqui Isso fará o download
do assistente de configuração para nós e podemos prosseguir e
abri-lo da seguinte maneira. Aqui está um assistente de configuração.
Só queremos continuar, continuar, cronometrar e
concordar com os termos Então você quer dizer
instale e digite sua senha e instale
este software em seu sistema. Tudo bem Lá vamos nós.
Podemos fechar o seguinte aqui. Aí estamos. O PySon foi instalado com sucesso em nosso dispositivo Podemos simplesmente dizer perto. Podemos
apenas dizer continue, tudo bem. Agora, o que eu recomendo
que você faça é acessar
o ícone da Apple e
reiniciar o dispositivo macOS Isso é apenas para garantir
que tudo esteja configurado corretamente PySon em termos de
variáveis de ambiente e Depois de fazer isso, o que você
pode fazer é
ir até a barra de lançamento e procurar seu terminal Você pode simplesmente digitar o
terminal e abri-lo. Esse é o
equivalente do CMD no Windows para confirmar que o PySON
foi instalado e a versão
designada especificamente
que você instalou Você pode simplesmente dizer PySON três,
espaço, versão do traço e Enter Aí estamos, podemos ver que a versão que
queríamos instalar e a instalação
do PySon foram um sucesso, pois podemos ver que
a saída é a seguinte Isso é apenas uma
confirmação para mostrar que PySON foi instalado
em nosso sistema Ok, então é isso
neste vídeo, é assim
que você pode garantir que Python esteja instalado
no seu dispositivo macOS
9. VS Code — instalação e configuração — MacOS: Oi, todo mundo. Bem-vindo
à próxima lição, que se
concentrará em baixar e instalar o
código do Visual Studio em nossos dispositivos macOS Em primeiro lugar, você quer ter certeza de que está na página
seguinte aqui, que pode ser acessada se
você acessar o URL e digitar o código
visualstudio.com na barra Baixe seu URL,
no qual você será redirecionado
para no qual você será redirecionado Em seguida, o que você quer
fazer é instalá-lo em um Mac, para que
possamos clicar
no ícone a seguir. Isso fará o download do assistente de configuração que
precisamos para acessar o código do
Visual Studio. Só precisamos esperar alguns
instantes. Se por algum motivo o download
não começar para
você, você pode
clicar no link de download
direto. Espere um pouco
e veremos que está pronto e podemos prosseguir e
abrir o código do Visual Studio. Depois de clicar nele,
você verá esse prompt aqui e tudo o que você
quer fazer agora é abri-lo. Visual Studio code é um aplicativo baixado da Internet
e queremos abri-lo. Aí estamos. Aqui está. Esse é o código do Visual Studio. É assim que você pode configurar
facilmente esse editor de
codificação
10. Primeiros passos no nosso projeto — MacOS: Oi, todo mundo. Bem-vindo à próxima lição, que se
concentrará em
começar a usar o código do
Visual Studio para que possamos
configurar nosso PysonPject. A primeira coisa que
eu quero que façamos é
minimizar o
código do Visual Studio por enquanto. O que vamos fazer
é ir até
uma cobertura e criar uma nova
pasta em nosso desktop, que abrigará nosso arquivo
PySON no devido tempo Vamos clicar com o botão
direito do mouse e então podemos dizer nova pasta
e eu criei essa pasta e vou clicar nela e renomeá-la Vou chamá-lo de MP check. Você pode dar a ela
o nome que desejar, aí temos essa
pasta e queremos
abrir essa pasta no código do
Visual Studio. É para abrir o código do Visual
Studio e maximizá-lo. Em seguida, podemos
clicar em Arquivo. Navegue até abrir a pasta. Em seguida, queremos
ir para a área de trabalho porque foi aí que
criamos essa pasta. Em seguida, podemos selecionar a pasta chamada meu projeto
e dizer abrir, e podemos fechar esse
prompt e ver que agora temos acesso
a essa pasta. Perfeito. Bem feito. Agora queremos criar nosso
arquivo PysonScripting, É aqui que
adicionaremos todo o nosso código PySon e também
executaremos nosso código com base no conteúdo
do arquivo S. Isso estará na pasta do
nosso projeto aqui. Você pode passar o mouse sobre ele
e então você verá um ícone que permitirá que
você crie um novo arquivo Você quer clicar nisso.
Dê um nome ao seu arquivo aqui. Vou chamá-lo de main
dot py, por exemplo. Preciso deixar claro que o código do
Visual Studio
sabe que esse será um código do
Visual Studio
sabe que esse arquivo baseado em Python e que podemos Aí está, o arquivo
principal de pontos Pi. Agora, como é a
primeira vez que estamos usando o PySON no código do
Visual Studio, teremos um prompt sugerirá
que instalemos a extensão
Python recomendada da Microsoft para a
linguagem Python para a Essa extensão nos fornece apenas alguns recursos extras que
podemos utilizar e, em geral torna nossa experiência
com a codificação de Python no código do Visual Studio muito
mais proficiente Podemos dizer instalar.
Isso vai instalar a extensão.
Lá vamos nós. Ele foi instalado, então
podemos fechar a página a seguir aqui e navegar
até o ícone aqui,
que é o Explorer. Isso só vai mostrar
nosso diretório, que, é
claro, nossos arquivos
em nosso diretório. Também podemos fechar o
Explorer aqui para maximizar o arquivo que já
temos aqui aberto. Na verdade, é algo que eu também queria mencionar. Tudo bem executar alguns códigos e
realizar alguns testes. Agora, a primeira coisa que
eu quero, é claro, é seguir em frente e
criar um programa simples. Eu vou dizer que nome é igual, e vou dizer honra Estou criando um nome de
variável e atribuindo-o
ao valor de honra No próximo slide,
vou dizer imprimir e
quero gerar esse valor.
Vamos seguir em frente e fazer isso. Na declaração impressa,
vou colocar o nome Agora, o que você pode fazer é salvar seu código aqui, e então podemos executá-lo clicando no ícone a seguir aqui
para executar
o PISonFle Lá vamos nós. Podemos ver que ele executou o arquivo adequadamente aqui. Também posso minimizar este terminal aqui apenas para
lhe dar mais espaço. Podemos ver a saída
lá, que
não era e foi
executada com sucesso. Também podemos ver que
ele
configurou automaticamente nosso passado para nós. Estamos executando dentro do diretório
Meu projeto, e ele está executando o arquivo dot pi
principal aqui especificamente para gerar qualquer código
enviado aqui. E você também pode limpar seu
terminal aqui
digitando clear e isso
limpa para Você também pode ir em frente
e fechá-lo. Agora, essa é a maneira
automatizada de seguir em frente e executar seus programas
no Visual Studio Code. O que você também
pode fazer é clicar no diretório
do terminal
aqui e dizer novo terminal, e isso o abrirá
aqui da seguinte maneira. O que podemos fazer é, claro, simplesmente nos dar um pouco de
espaço aqui e você também pode executar os
comandos aqui . Essa é outra
maneira de fazer isso. Se você quiser prosseguir e executá-lo
no terminal aqui, em vez de
dizer executar arquivo Python, você precisa fazer isso manualmente de
acordo com o nome do arquivo Mas você vai
querer dizer PySon três,
espaço e, em seguida, o nome do seu arquivo Aqui eu vou dizer o ponto
principal pi e Enter. Lá, ele será produzido
da seguinte forma. Certo, então é assim que
você pode usar o terminal e o código do Visual Studio E podemos digitar claramente aqui e isso limpará
o terminal para nós. Agora, eu
recomendaria pelo menos que você
simplesmente clique na opção Executar PysonFle
aqui para que ela seja executada por você, depois insira tomanicamente nome
do arquivo Isso só vai te poupar
algum tempo e tal. Tudo bem, pessoal, é. É assim que podemos
começar com o PySON e como podemos começar
mais especificamente com o PySON no código do
Visual Studio
11. Melhore seu fluxo de trabalho com o Code Runner — [Opcional]: Oi, pessoal. Bem-vindo
à próxima lição, que se
concentrará em aprimorar nosso fluxo de trabalho utilizando
a extensão code runner Agora, essa vai
ser uma aula opcional. Você não precisa fazer isso
se não quiser. Mas digamos, por exemplo, que você esteja trabalhando
com seu terminal e queira ter
uma saída mais limpa. Em vez de ver
esses arquivos bagunçados toda vez e depois a saída do código que você
realmente espera, Code Runner pode
realmente ajudar a tornar isso muito
mais fácil e agradável à
vista, devo dizer Em vez de ver todos os
nomes e senhas de arquivo incluídos na saída e você quiser limpar a saída, você pode usar o code runner Então, vamos
começar. Ok, então precisamos
navegar até a extensão, que você veja designada
pelo ícone fluente Agora podemos
clicar nesse campo de entrada e eu vou
remover o que está nele. E queremos pesquisar o
executor de código. Vou apenas digitar, é
claro, o código que flui Corredor. E vamos
ver esse aqui. Então você verá que ele
terá esse logotipo dot run, então code runner, e você deseja
instalar essa extensão
específica OK. Então, vamos
esperar um pouco mais ou menos para ser instalado
e pronto. Podemos ver que ele realmente foi
instalado em nosso sistema. Certo, então podemos fechar
essa extensão agora, de
cabeça para trás, e a
colocamos no lugar. Agora, há algumas configurações
que precisamos confirmar e garantir que temos uma saída limpa. Então, vamos seguir em frente
e fazer exatamente isso. Então, você deseja navegar
até o ícone a seguir. Em seguida, você deseja ir para Arquivo e,
em seguida, pode rolar para baixo
até ver as preferências. Em seguida, você deseja passar o
mouse sobre as preferências e
clicar nas configurações Então vá em frente e clique nele. Isso o levará para
a seguinte área aqui. Então, aqui, nas configurações de pesquisa, podemos simplesmente seguir em frente
e inserir o código. OK. E podemos simplesmente colocar Runner. Tudo bem, lá vamos nós. Ok, então temos
algumas configurações aqui. Então, primeiro de tudo, temos code runner clear
previous output Portanto, queremos garantir que
isso tenha sido verificado. Isso só vai
garantir que ele mostre a saída mais recente sempre que
fizermos uma execução de código Tudo bem, então vamos
continuar. Então, queremos apenas
procurar as principais opções lá. Está bem? Assim, podemos deixar
tudo como está. Você só quer se concentrar
naqueles que eu mencionei. Aqui, também temos código
executado e executado no terminal. Está bem? Você quer ter certeza de
que isso foi desmarcado, que não está marcado, para possamos
deixá-lo em branco como está Então, esse é outro que você
deseja garantir que tenha verificado. Ok, e é claro, podemos ver que também
salvamos o arquivo antes da execução. Então, isso
garantirá que queremos salvar o
arquivo atual antes de executá-lo. E o que você quer fazer isso aqui
é
garantir que seja mantido verdadeiro. E então temos a mensagem de
execução do programa, ok? Então, não queremos ver nada parecido com correr ou descer
ou algo parecido. Queremos que seja claro, limpo
e simples. Portanto, certifique-se de que isso não
tenha sido verificado. Então, você só quer verificar
as quatro opções que eu detalhei
agora, apenas para ter certeza tudo está claro
e organizado para que o executor de código
funcione no lugar Certo, então vamos prosseguir
e fechar isso agora. Tenha nosso código aqui, mas agora,
para realmente executar o code runner, o que você pode fazer
é muito simples Também clicaremos em Executar, mas você deseja clicar
nessa seta suspensa aqui e verá agora que
temos a opção de dizer
executar código em vez de
executar Pis e arquivo. Então você quer clicar em
Executar código e pronto. Temos essa saída
limpa e simples. Você não vê mais bagunça. É muito mais fácil de usar e agora está no lugar certo
. Certo, então o que eu vou fazer agora é mudar esse valor, e eu vou apenas
dizer John. E agora, se eu
continuar e clicar manualmente na opção aqui, você verá que o código
padrão será executar código agora, e haverá Ha. Tudo bem, então vamos lá. É assim que você pode seguir em frente
e utilizar o code runner. Então, você pode ver que ele
nos dá
uma saída limpa, muito mais agradável para
os olhos
e, em
geral, muito melhor para utilizá-lo dessa
forma. Tudo bem, pessoal.
12. Expressões regulares: Olá a todos, bem-vindos
à próxima lição, que será focada em expressões
regulares.
Então, vamos dar uma olhada. Tudo bem, então expressões
regulares, comumente chamadas de rejexs Então, expressões regulares em Python são basicamente usadas para
identificar padrões em texto, como em números, palavras ou até mesmo em um
endereço de e-mail, por Agora, em vez de
pesquisar correspondências exatas, rejeite e siga regras específicas para detectar
padrões específicos em si Agora, o PySON já
nos fornece um módulo embutido chamado RE para trabalhar com
expressões regulares, chave inglesa Então, isso é suficiente para a visão geral
teórica. Vamos seguir em frente e
aplicar nosso conhecimento na utilização de
expressões regulares em PySon
13. Trabalhando com expressões regulares — [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de
laboratório, que se concentrará em trabalhar com expressões
regulares comumente chamadas de
rejec em Python Vamos começar. Vamos remover o que temos aqui e vou diminuir um pouco
o zoom. Certo. Ok, então a primeira coisa que vamos
querer fazer
é analisar os tipos de
exemplos que vamos analisar
com expressões regulares. Então, para ter uma melhor compreensão
das expressões regulares, vou passar por
alguns exemplos e exercícios com Z e eles serão
os seguintes. Vou mostrar como
você pode encontrar todos os dígitos,
em outras palavras, números em um determinado conjunto de texto, como substituir dígitos
por determinados caracteres e também como verificar se uma
string começa com o Isso ajudará você a ter uma melhor compreensão de como você pode usar as funções que vêm com o módulo RE e outros. De qualquer forma,
vamos começar. Portanto, em todos os exemplos,
precisamos primeiro importar o módulo RE, que vem com
muitas funções
integradas. Então, podemos ver Import RE. Certo. Agora precisamos
adicionar algum texto, e o primeiro
exercício se
concentrará em encontrar
todos os números ou dígitos em um determinado
conjunto de cheques Então, vou dizer ext, igual, e aqui entre aspas, vou dizer que
tenho três maçãs E dois pares.
Esse é o meu exemplo. E como você pode ver lá,
eu tenho dois dígitos. Eu tenho três e tenho dois. Então, é claro, queremos
extrair esses valores,
tecnicamente Em seguida, precisamos
especificar um padrão. Agora, o nome da variável aqui, você pode dar qualquer nome
que desejar. No entanto, estou chamando
isso de
padrão porque esse é essencialmente o padrão como vou
configurá-lo. Agora, você sempre
vai querer
começar com R para sua
expressão aqui,
o R antes de uma determinada string garantirá que a string seja uma
string bruta, o que significa que todas as barras invertidas
são tratadas normalmente em vez de sequências de escape Então, adicionaremos nossas
aspas e, em seguida, colocaremos uma barra invertida D. Essa
será a parte importante
que precisaremos adicionar Agora, essa barra invertida D
aqui, é claro, será uma expressão regular
que corresponderá a qualquer dígito de 0
a 9 Isso é o que precisamos primeiro de tudo,
especificar
a próxima coisa
que vamos querer fazer é especificar
outra variável, podemos chamar esses
números e vamos utilizar o
módulo R E de vez invocaremos a localização em quando
invocaremos a localização
ou função que vem embutida com o módulo RE, e vamos colocar
dois parâmetros Primeiro será o padrão
e depois o texto. Então, para reiterar essa
linha aqui no padrão, isso é encontrar todos os dígitos
em um determinado conjunto de texto, que
será esse texto aqui E o que estamos fazendo é usar a função find ou
para fazer exatamente isso. Portanto, a localização ou
função vai
querer saber o padrão e seguida, as verificações para
aplicá-lo também. Então, o padrão
será baseado nos dígitos, essa barra invertida D para
encontrar e combinar dígitos, e queremos encontrar
todos os dígitos neste texto que
diz que eu tenho três Você pode dizer para si mesmo,
é claro, produzindo três e
dois. Vamos confirmar isso. Depois, você pode dizer
números impressos e executar seu código. Aqui você pode ver que as
saídas três e duas. Aí está.
É assim que podemos encontrar dígitos em um
determinado conjunto de texto Agora, vamos ajustar isso agora e vou prolongá-lo. Vou dizer que
tenho três maçãs, dois pares e quatro laranjas Salve o código. Corra. Agora você pode ver que as saídas são
três, duas e quatro OK. Então você pode ver lá, ele pegará
e verificará onde pode recuperar todos
os números fornecidos utilizando a função
find all Agora, digamos que, para fins de
argumentação, queremos fazer
algo diferente. Digamos que queremos substituir
dígitos por um caractere
específico Digamos que com uma hashtag. Não queremos que o
número ou o número de telefone
de alguém vazem Só queremos ver isso, você poderia dizer,
escondido por hashtags. Então, vamos seguir em frente e
fazer isso. Então, podemos remover esse código por enquanto. Vou remover
isso e vou dizer mensagem de texto novamente. E aqui eu vou
dizer que meu número é, e eu vou dizer um, dois, três, quatro, cinco, como exemplo. Então, o padrão que
vamos definir. Então, aspas duplas, barra invertida D. Então, vamos procurar qualquer padrão
que corresponda Então, podemos dizer um novo texto de
sublinhado porque vamos modificar esse texto para dizer que meu número é
e, em seguida, vamos adicionar um caractere específico para ocultar
esses números, por exemplo OK. Então
vamos dizer RE, vamos utilizar o ponto do módulo. A função que usaremos
desta vez é chamada sub. Portanto, sub é uma função
, comumente chamada substituto
ou substituição, mas o nome real da
função é Então, queremos essencialmente
substituir um valor
alternativo para substituir um dígito em si. Portanto, precisamos aplicar o padrão que queremos usar
para combinar dígitos E onde vemos dígitos, queremos substituí-los
ou modificá-los por
uma tag de hash no texto fornecido Como você pode esperar agora, o que
vai acontecer é que ele
dirá que meu número é e mostrará hashtag, hashtag, hashtag e
hashtag Se disséssemos imprimir e depois novo
texto sublinhado e executar esse código, podemos ver aqui nas saídas que
meu número é hashtag, hashtag, hash,
hasta hashtag Agora, digamos que eu
coloque apenas um e dois. E corremos novamente, eu só
mostro as duas primeiras hashtags. Ok, então essa é uma ótima maneira se você
quiser substituir ou
substituir dígitos ou números
em um determinado conjunto de texto Você utilizaria
a subfunção
ou a função substituta ou a função substituta Agora eu também posso
prolongar e executar isso, e você pode ver
que ele fará o seguinte. Agora, eu também posso mudar isso para, digamos, o símbolo de $1, então eu posso mudá-lo para aquele e vamos colocá-lo no original,
e ele faz a mesma coisa. Então é assim que você pode
substituir adequadamente. Tudo bem, então é assim que
podemos substituir dígitos. Agora, a última coisa que
quero mostrar é como você pode verificar se uma string
começa com um dígito se começa com um
número. Então, vamos fazer isso. Vamos remover isso. Ok, mensagem. E o que vou
fazer agora é
dizer três pares na cesta. OK. Então, já podemos ver aqui que a string
está começando com um dígito Tudo bem. Então, o padrão. Ok, vamos ter R, e vamos ter que
colocar um caractere especial aqui, então vai ser uma
seta indo para cima ou como o tipo de símbolo power two E isso significará
o início da string. Então, no início da string, eu quero procurar todos os dígitos correspondentes, daí
a barra invertida e D. Então
é assim que você pode aplicar esses caracteres juntos em
termos das expressões Então, basicamente, essa linha de
código agora corresponderá
se a string começar com o dígito e
vamos aplicar isso agora. Uma declaração if. Então, eu vou dizer que eu dou uma correspondência de pontos, então estamos usando a função de
correspondência, o padrão e a verificação. Então, vamos verificar se esse padrão específico
é compatível neste texto Então, em outras palavras, se esse
texto aqui começar com um dígito, acordo com o padrão,
então vamos gerar uma resposta específica Então, como essa é uma declaração if, vou adicionar um
kern no final, e então posso dizer imprimir, sim, começa com um dígito Se por algum motivo isso não acontecer, posso dizer outra coisa e imprimir. Não, não
começa com um dígito. Ok, então vamos ver. Então, neste caso, podemos
ver que ele começa como um dígito, então ele deve retornar
a declaração aqui Sim, começa com um
dígito, pois é verdade. Então, vamos executar isso
e podemos ver aqui. Diz que sim,
começa com um dígito. Agora deixe-me trocar e remover
os três e apenas dizer, pares em uma cesta e correr. Exibirá aqui
a declaração
que, é claro, diz que não, não
começa com um dígito OK. Então é assim que também podemos usar a função match. Agora, quando estamos trabalhando
com expressões regulares, há muitas funções
que vêm com R E, mas isso é apenas uma pequena para que você
possa entender
as expressões
regulares e como
aplicá-las de expressões
regulares e como acordo com um determinado padrão que você
decide definir em seu próprio código Tudo bem, pessoal. Então, isso é tudo para este exercício
prático em particular.
14. Imprimir vários valores: Olá a todos, bem-vindos
à próxima lição, que se
concentrará na impressão de vários valores.
Vamos dar uma olhada. Certo. o que você pode fazer é utilizar a concatenação de
strings
e a concatenação de strings é essencialmente o
processo de Agora, quando estamos
imprimindo vários valores,
o que você pode fazer é utilizar a concatenação de
strings
e a concatenação de strings é
essencialmente o
processo de combinar várias strings em uma. Agora, a forma
mais comum concatenar
cadeias de caracteres é usando operador de adição e, em seguida, adicionar
espaços entre
as cadeias de caracteres para facilitar a Agora, o que você também pode
fazer é usar uma vírgula em vez de
sua função de impressão e exibir
vários valores, e isso adicionará
automaticamente esses espaços para você, pode torná-lo muito mais legível e também
economizar algum Então, deixe-me mostrar graficamente
o que quero dizer com isso. Então, digamos, por exemplo,
que temos esse programa. Muito simples. duas variáveis que
definimos aqui, nome e sobrenome,
incluindo seu nome e sobrenome, é
claro, John e Doe. Então, o que você precisará fazer
normalmente é criar
outra variável. Nesse caso, o nome completo
seria apropriado. E então, para combinar o
nome e o sobrenome, o que você precisa fazer é
dizer o primeiro nome e depois mais e depois adicionar
o espaço com aspas
e, em seguida, mais novamente, e depois o sobrenome. Isso
combinará John e Do
juntos e também
deixará um espaço entre eles, já que você adicionou
essas duas aspas. Como você pode ver, você está
adicionando o operador de adição aqui para concatenação de strings Quando você imprime o nome completo, ele imprime John
space do em um bom formato. No entanto, isso pode ser um
pouco entediante,
dependendo da situação
e do contexto Uma maneira mais fácil seria simplesmente
adicionar sua
função de impressão e , em seguida, adicionar
diretamente seu
nome e sobrenome, separá-los por uma vírgula, que também imprimirá exatamente
o mesmo resultado em uma quantidade menor de código
existente. Então, isso é apenas algo que eu
queria mencionar aqui se você estiver imprimindo seus valores e eles
estiverem sendo produzidos, você também pode torná-lo muito melhor e mais fácil
para si mesmo adicionando uma vírgula dependendo de determinadas
circunstâncias Agora, há mais algumas coisas que eu
quero mencionar sobre esse tópico. Portanto, para garantir que você se
sinta mais confortável com
o uso das duas opções, usarei
o operador plus para concatenação de
strings e também vírgula OK. Agora, a razão pela qual
estou fazendo isso é apenas para ajudar a solidificar suas habilidades em
aprender coisas novas e aplicar tudo para
que você possa aprender
mais Então, eu só quero
, você sabe, desafiá-lo um
pouco a, você sabe, realmente se concentrar nas
aulas em questão e a se sentir confortável não
apenas em usar um tipo de método, mas também seguir outros
métodos. Então, neste caso, seguir a concatenação de
strings, reconhecê-la, aplicá-la E então, em outro contexto, para dizer: Ok, neste caso, eu preciso usar uma vírgula ou tenho
vontade de usar uma vírgula, mas eu também entendo Então, isso é apenas um
pouco da minha visão em termos de como você deve
imprimir seus valores e coisas do gênero. Lição muito simples,
devo dizer? Também vou
continuar com um breve
exercício prático. É muito fácil, mas eu só
quero que pratiquemos e nos sintamos à vontade para trabalhar em
outros métodos e técnicas.
15. Trabalhando com diferentes saídas — [Lab]: Oi, todo mundo. Bem-vindo ao
próximo exercício prático de laboratório, que se concentrará
na impressão de vários valores. Vamos praticar um
pouco sobre a conformação de
strings e também sobre como
podemos utilizar uma vírgula no contexto
apropriado, apenas para economizar algumas linhas de
código e coisas do tipo e também para
melhorar a legibilidade do
nosso código Vamos começar. Vamos manter as coisas simples para começar. Vou dizer primeiro nome de
sublinhado, igual, vou dizer honra, e
vou dizer último nome de sublinhado,
e vou
dizer e vou Ok, então com a
concatenação de strings, seria melhor,
nesse caso,
definir outra variável, que chamarei de nome completo
igual a,
e então direi o primeiro
nome de sublinhado, e então direi o primeiro Então, estou usando o
operador de adição e, em seguida, adiciono um espaço com as
aspas designadas mais novamente, e quero adicionar
um sobrenome a ele, para que
não mostre nenhum espaço Pretoris Então eu posso dizer imprimir. E incluirei o
nome completo aqui dentro dos pais e isso será impresso em um Pretorius
na saída Aí está. Como podemos ver, ele está imprimindo o
seguinte e meu nome completo. Agora, digamos que eu não queira adicionar uma
concatenação de strings e quero que isso seja muito mais simples
com menos Posso simplesmente remover o seguinte e dizer na
função de impressão dentro de príncipes, primeiro sublinhado seguido
por uma vírgula e depois dizer último UnderScun e
executar o código e
ele imprime exatamente o mesmo resultado
e ele imprime exatamente o mesmo resultado e Você pode ver como
é fácil economizar muito tempo. Mas é claro que isso também
depende da situação. Vamos continuar e remover isso. Vamos dar outro exemplo. Digamos que temos Siti e aqui vou
dizer Cidade do Cabo E teremos um país, e eu direi a África do Sul. Então, eu tenho duas variáveis definidas. Então, eu tenho isso pronto. Agora, a próxima coisa que eu
vou querer fazer é especificar uma variável aqui. Então eu posso ir em frente
e dizer localização, igual, e eu posso dizer cidade mais,
adicionar o espaço, mais, e eu terei Então eu posso dizer o local da impressão. Execute o código, Cidade do Cabo, África
do Sul. Tudo bem Agora, vamos ver se
podemos simplificar isso usando apenas uma vírgula, para que possamos remover o seguinte e dizer imprimir Cidade seguida por país. Execute o código, e então
temos Kick cities of Africa. Então, vamos lá. Também salvamos algumas linhas de código
lá. Tudo bem, então você pode ver
que é muito legível
neste exemplo quando
estamos usando uma vírgula Certo, certo, vá. Então é isso para este exercício prático de
laboratório. É muito curto, mas eu só queria te dar um
pouco de prática aqui. Portanto, lembre-se aqui, analise o programa em que
você está trabalhando e os
contextos e , em seguida, decida o que
acha apropriado Tudo bem, vá. Então é isso para este exercício prático de laboratório.
16. Combinar declarações de caso: Olá a todos, bem-vindos
à próxima lição, que se concentrará nas declarações de casos de
partidas.
Então, vamos dar uma olhada. Então você provavelmente está
se perguntando: Ok, o que é uma caixa de fósforos Portanto, uma instrução match ka funciona
como uma instrução switch em Java e C se você tiver alguma experiência com essas
linguagens de programação. Então, essencialmente, essa instrução
MatchK verificará um valor em
relação a vários casos
e, em seguida, o
que ela fará, executará executará
o bloco correspondente encontrado nos
casos em que correspondeu Agora, ao contrário da declaração I ELF
que temos no PySON, ela oferecerá uma correspondência de padrões
mais limpa e legível Portanto, é muito semelhante
às condicionais I, pode-se dizer que, até
certo ponto, é claro, agora também pode combinar listas, tuplas e objetos, e
não apenas
números e sequências aleatórios Portanto, podemos ver que
há um intervalo muito grande quando você está utilizando
uma declaração de match case Agora, deixe-me explicar
isso em um formato visual, para que faça mais
sentido entender. Então, aqui está um exemplo prático. Digamos que queremos criar um programa de verificação de cores muito simples. Então, queremos verificar qual é a cor
atribuída e tal. Então, aqui neste programa, podemos ver que a cor que
foi atribuída é vermelha. Em seguida, vamos utilizar a declaração
de partida aqui Então, vamos
combinar de
acordo com o valor da cor. Agora, a cor é
vermelha. Então, teremos casos individuais. Então, primeiro, teremos
nossa combinação de cores. Então teremos um caso
e esse caso pode ser qualquer coisa. Então, neste caso, o estojo vai ficar vermelho. E se a cor corresponder à maiúscula do vermelho de
acordo com o valor associado, ela imprimirá
que a cor é vermelha. Podemos ter outro caso
aqui que seja azul para verificar se a
cor designada é azul, e também temos um tipo especial de frase-chave aqui onde temos maiúsculas e minúsculas
e depois sublinhado sublinhado é muito semelhante a uma declaração em if condicionals Se o estojo estiver
acima, não aplique, então ele imprimirá
outra opção aqui, que
será de cor desconhecida. Nesse caso, temos vermelho e estamos colocando
duas caixas separadas para verificar se a cor
é vermelha ou azul. Agora, se, por exemplo,
a cor for verde, roxa, cinza etc., ele executará
o bloco
associado ao sublinhado da caixa e
imprimirá uma cor desconhecida Experimente ver as semelhanças
com as declarações I Elef e L em
Python para ter uma ideia aproximada de
como esse caso de correspondência funciona Tudo bem. Tudo bem, pessoal. Isso é tudo para esta aula
teórica sobre afirmações match K. Vamos fazer um exercício
prático de laboratório, vamos nos
aprofundar e aprender fazendo.
17. Trabalhando com declarações de caso de correspondência — [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de
laboratório, que se
concentrará em trabalhar com
declarações de casos de correspondência no Hyson Então, vamos começar. Vamos manter nosso primeiro programa muito simples. Vou definir uma variável, chamarei essa cor e atribuirei isso
à cor vermelha. Então eu quero
configurar minha caixa de fósforos. Então, eu vou dizer match. E eu quero que isso
seja baseado na cor. Então, vou
combinar cores. E então eu quero
especificar os casos. Os casos serão
os valores explícitos que podem ser associados
à variável que está sendo correspondida aqui,
neste caso, Então, podemos dizer caso, por
exemplo, vermelho, cólon. E então, se o valor da cor
corresponder ao caso do vermelho, podemos imprimir uma
declaração aqui e dizer que imprimir a cor é vermelha. Agora, digamos, por exemplo, a cor seja azul. Então eu vou dizer caso, e vamos
resolver se é azul. Então diríamos imprimir,
a cor é azul. Agora, digamos que, para fins de
argumentação, o valor associado não
seja vermelho ou azul, e queremos atender
a qualquer outra coisa Então, é
como uma declaração. Podemos dizer maiúsculas e minúsculas, sublinhado, dois pontos e, em seguida,
podemos dizer imprimir A cor não é vermelha nem
azul. Nós podemos dizer isso. Tudo bem, então
temos isso configurado. Agora, se dermos uma olhada
aqui em nosso código, podemos ver que a saída
aqui, correta, será a cor vermelha porque
o caso aqui está definido como vermelho,
e isso corresponde ao valor
do que estamos combinando com o valor associado. Então, se eu executar esse código, podemos ver aqui
que
a saída no final é vermelha. Agora deixe-me mudar isso para azul. Salve meu código e execute-o. Agora, diz que a cor é azul. Agora, deixe-me colocar uma cor diferente que não
seja vermelha ou azul, essencialmente o que
acontecerá então é o caso aqui com esse sublinhado
especial, que então acionará
e exibirá a
seguinte declaração, que é que a cor não
é vermelha ou azul Deixe-me mudar isso para
verde, por exemplo, e executar o código,
e ele vai
dizer que a cor
não é vermelha ou azul. OK. Então é assim que
podemos implementar uma declaração de match
case muito simples e como podemos integrá-la. Tudo bem. Então é assim que podemos seguir em frente e configurar
isso adequadamente. O que eu quero que façamos agora é ir um pouco
mais longe e criar um programa que tenha um valor de entrada. Então, vamos
inserir um
valor específico e, em seguida, o
caso será exibido de acordo
com o valor que
inserimos pelos casos que configuramos
na instrução match. Certo, então vamos continuar
e criar um programa que vai verificar de
onde alguém é. Onde está baseada a nacionalidade. Então, vou criar uma
declaração impressa simples, em primeiro lugar, então vou dizer imprimir, e
vou fazer uma pergunta. Então eu vou dizer, de onde você é. Ok, muito simples. Em seguida, queremos usar uma função
de entrada
que será atribuída
a uma
variável conhecida como país, e vamos combinar país em nossas declarações de
caso de correspondência. Então eu vou dizer que
país é igual, e vou dizer entrada,
assim mesmo Então, podemos seguir em frente e
configurar nossas declarações de caso de partida. Então, vou dizer
match country. E então eu vou
colocar algumas caixas. Então, vou dizer um caso, e prevejo que teremos a África
do Sul, por exemplo, então o
resultado da impressão aqui será você é da África do Sul. Eu vou ser meio atrevido aqui, e não quero
continuar tendo casos diferentes Eu vou ter uma
espécie de caso de uso. Então, vou dizer maiúsculas e minúsculas, sublinhado, dois pontos e
vou dizer imprimir Você não é da
África do Sul. É muito simples. Como você pode ver,
teremos uma consulta que estará
na saída que diz: de
onde você é
quando executamos nosso código. Em seguida, teremos
que
inserir o país de onde somos, e esse valor que inserimos será atribuído
à variável país. Em seguida, vamos aplicar
isso ao nosso caso de partida aqui. Vamos dizer
match country. Então, o primeiro caso
que vamos verificar é se o usuário inseriu a África do Sul. Se
sim e corresponder à entrada, imprimiremos que
você é da África do Sul e se esse usuário
digitar mais alguma coisa, dirá que você
não era da África do Sul. Ok, agora, o que vamos
querer fazer neste caso é executar o PysonFle e não executar o Agora, com Executar código aqui
com o executor de código, ok? Não vai funcionar muito bem porque o código de execução só nos
dá saída, mas como temos uma entrada que queremos
inserir em alguns dados, não
temos escolha a não ser executar o arquivo PySON, mas mudaremos isso
no final novamente.
Tudo bem? Então, eu vou dizer que execute PysonFle, ele exibirá
esse console de depuração E aí está escrito, de
onde você é? Ok, então aqui, eu vou
apenas dizer, África
do Sul, diz:
Você é da África do Sul. Então, está imprimindo o que
configuramos aqui. Certo, então vamos executar o programa novamente e, desta vez, o que vou
fazer é colocar algo
diferente da África do Sul. Então, vou executar
o programa novamente. E diz, é claro, de
onde você é. Então, aqui, desta vez,
eu vou dizer EUA. Entre e diz: Você
não é da África do Sul. Então, ele avalia esse
resultado aqui, onde diz que você não é da
África do Sul neste caso, porque esse caso aqui da África do
Sul não é verdadeiro Tudo bem. Então, é assim que podemos basicamente fazer uma cobertura e integrar essa
funcionalidade, para que também possamos testar de acordo com os valores
de entrada e utilizar
nossos casos adequadamente Tudo bem, pessoal. Então é isso. Tudo o que eu quero fazer agora é
mudar isso para executar código, e podemos parar com isso
por enquanto. Aí estamos. Ok, agora vamos
executar o código e podemos apenas realizar um teste simples para
ter certeza de que está tudo bem. Eu só vou dizer o nome Sano. Então, vamos fazer um teste final aqui, e vamos
dizer match name case, podemos dizer John.
Poderia dizer impressão. Oi, John, e então eu vou
dizer o caso aqui e isso vai ser uma honra
e eu vou dizer uma honra impressa. Então, se não for nenhum deles, podemos simplesmente
dizer oi, amigo. Certo, então vamos seguir
em frente e garantir que estamos executando o código, e
aí está. A saída aqui é alta, não, porque é isso
que definimos aqui como valor
associado.
Tudo bem, pessoal. Então, isso é tudo para este exercício de laboratório específico sobre como você pode usar declarações
match K. Como você pode ver, é
muito semelhante às nossas declarações I ELF e s. No entanto, há uma
pequena diferença, mas é muito útil, e eu definitivamente recomendo utilizá-la em seus
programas, se você puder Tudo bem, então é isso para
este exercício prático de laboratório.
18. Módulos: Olá a todos, bem-vindos
à próxima aula, que será
focada em módulos. Agora, com os módulos aqui, esta será uma espécie
de lição
de atualização, ok, já que é meio ok, já que é meio amigável para iniciantes,
você poderia dizer, mas eu quero me aprofundar
um pouco mais nos exercícios práticos de laboratório quando
vou me concentrar em
criar seus próprios módulos
e depois usar os módulos integrados do Pierson Então, eu só quero mencionar o início para
que você esteja ciente Ok, então módulos. Então, para relembrar, eu só quero
passar pelo básico Portanto, um módulo é essencialmente uma extensão PYS de um único
ponto PysonFle que armazena funções, variáveis e classes para
reutilização em outros arquivos,
muito semelhante a uma caixa de ferramentas, pode-se dizer, em termos de uma pode-se dizer, em Agora, em vez de repetir o código, você pode defini-lo
em um módulo e acessá-lo sempre que precisar Agora, o que você também
pode fazer é criar seus próprios módulos ou inserir módulos integrados
que vêm com o PySON por padrão Agora, falando nisso, uma lista completa de todos os módulos
PySON integrados pode ser encontrada
na URL a seguir, e isso é algo
que abordarei brevemente
na próxima lição Mas eu só quero
te alertar aqui. Portanto, a principal coisa a
realmente levar em consideração, além da definição de um módulo, é que você
pode criar seus próprios módulos ou
usar os módulos integrados que vêm
com o PySon sozinhos Tudo bem, então isso é
tudo que eu quero mencionar nos módulos do ponto de vista
teórico
19. Navegando no índice de módulos Python: Oi, todo mundo. Bem-vindo
à próxima lição, que será uma lição muito
curta apenas para dar uma visão geral sobre o índice do módulo
PySON Agora, isso é algo
que eu mencionei
na lição anterior,
perto do final, quando você quer dar uma
olhada mais profunda em todos os módulos
integrados que vêm
com o PySON pronto para uso Aqui está o índice do módulo PySON. Aqui você pode ler tudo sobre
o módulo PySON incorporado. Também quero esclarecer um pouco em uma lição anterior
que abordamos, na qual usamos um módulo específico. Se você se lembra da aula de expressões
regulares e, mais especificamente do
exercício prático de laboratório para esse tópico, utilizamos o módulo RE
para expressões regulares. Tecnicamente, aqui,
se você fosse digitar
RE, você pode dizer go, e então você pode rolar para baixo neste
glossário e aqui você pode ver que temos esse módulo
RE PySon aqui, a operação de
expressão regular, e você pode, claro,
clicar nele Você pode ler mais sobre esse
módulo que utilizamos, que é um
módulo Python embutido, não personalizado Apenas uma pequena
informação que eu queria
compartilhar com você. É assim que você também pode ler um pouco mais para aqueles
que estão interessados em
apenas navegar um pouco por alguns dos conceitos
e módulos disponíveis.
20. Integre módulos personalizados e integrados - [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de
laboratório, que se
concentrará em trabalhar com métodos
personalizados e
também com métodos integrados. Então, vamos
começar. Agora, a primeira coisa que
você quer fazer para criar seu primeiro módulo em Python é acessar o Explorer
e, em seguida, ver
no lado esquerdo que
você tem seus projetos Então, meu projeto, e dentro dele, temos nosso arquivo dot py principal. Agora, queremos armazenar a funcionalidade do
nosso módulo em outro arquivo. Agora, dependendo da lógica
que você tem no arquivo Said, seria melhor mantê-lo adequado ao que você planeja colocar
no arquivo Said. Então, vou passar o mouse sobre meu projeto aqui
e dizer novo arquivo, e vou chamar
essa saudação de dot pi Agora você pode ver que tenho uma pilha de pontos de saudação e um arquivo principal de pontos
no meu projeto Então, vamos começar. Tudo bem. Agora, a primeira coisa que
você vai querer fazer é definir alguma lógica. Quero criar uma
função que diga olá. Vou dizer surdo e dizer,
dizer sublinhado, olá
e depois adicionar um É assim que
definiremos uma função, e então podemos simplesmente
dizer return e dizer olá, não, por exemplo. Então, vamos também
definir uma variável aqui neste arquivo enquanto adicionamos Aqui vou dizer a saudação sublinhada
favorita, e aqui vou dizer,
bem-vindo. Muito simples. Então, aqui, definimos
nosso arquivo de saudação dot pi, e isso você pode
tratar como seu módulo Já que um módulo,
é claro, será um PysonFle
existente que terá,
por exemplo, funções, classes, etc.,
métodos, tudo no módulo
S em Agora, queremos
usar nosso módulo aqui e a funcionalidade que
definimos em saudações dot pi. Assim, você pode navegar até
o arquivo dotp principal e tudo o que você precisa fazer
é dizer Importar e, em seguida, consultar o nome exato do arquivo Então aqui se chama saudação. Então eu vou dizer
saudações, e lá vamos nós. Importamos com sucesso nosso próprio módulo personalizado em pyson Agora queremos torná-lo utilizável. Assim, podemos utilizar nossa
declaração impressa e dizer imprimir. Então você quer se
referir ao modelo. Ponto, e então você pode se referir à função
que você definiu, que no nosso caso
dirá sublinhado, olá Você pode dizer ponto, dizer,
sublinhado, olá. Em parênteses, você
vai deixar como está, porque não definimos nenhum parâmetro ou qualquer
coisa do tipo, e isso retornará hello o.
Digamos que eu queira obter o
valor da saída de boas-vindas Só precisamos nos referir ao nome
da variável aqui, que é a
saudação favorita e você pode simplesmente dizer imprimir e dizer saudação,
ponto e, em seguida, dizer a saudação sublinhada
favorita Isso vai gerar o valor associado à referida variável. Agora, se executarmos o código, veremos que ele diz
bem-vindo não e bem-vindo. Ele está retornando o que eu
defini na minha função e também
imprimirá
o valor da variável associada que
foi definida anteriormente. Tudo bem, então essa é uma maneira
muito simples de
entrarmos em uma cerca viva e
arrumar tudo Mas digamos que queremos nos aprofundar
um pouco mais, queremos que isso envolva um
pouco mais. Assim, podemos remover essas linhas. Volte para a saudação
e vamos mudar isso um pouco. Pode remover isso. O que eu quero fazer é
manter a mesma
função, dizer olá, mas quero
passar por um parâmetro aqui. Vou dizer nome e seguida, com a
declaração de retorno aqui, vou usar cadeias de caracteres F. Eu vou dizer F
e vou dizer olá e depois
vou adicionar um espaço reservado
que será o nome Vamos passar pelo argumento em
nosso arquivo Pi principal, que então
tomará posse do nome aqui, que será então passado
para esse espaço reservado para o nome OK. Então, podemos ter outra função
para dizer adeus, eu
possa dizer surdo,
digamos, sublinhado, Tchau. Vamos dizer o nome novamente. Retorne e teremos uma
string F que diz adeus, adicione seu espaço reservado e teremos Name.
Assim mesmo. Então, agora, se formos para o
nosso principal ponto por arquivo, o que podemos fazer é muito semelhante ao de antes.
Podemos dizer imprimir. E, novamente, vamos nos
referir ao nosso módulo personalizado,
que é o ponto de saudação E, claro, o nome da nossa
função dirá sublinhado olá, digamos,
sublinhado E agora vamos
passar por um argumento, que substituirá
nosso parâmetro aqui
e, em seguida, ele descerá
para essa declaração de retorno no espaço reservado para
o que definimos Então, vamos definir
o argumento agora, e aqui vou dizer Jack. Em seguida, vou para o próximo slide e
digo imprimir saudação,
pontuar, dizer, e o nome
da função dizer sublinhado, Eu vou dizer, diga
sublinhado, bom, tchau. E aqui, eu só
vou dizer, Katie. Novamente, o mesmo processo
ocorrerá. Vamos invocar essa
função, passar
o argumento e substituí-lo pelo nome aqui,
o parâmetro name, e
depois passá-lo para a instrução return
dentro do espaço reservado para dizer adeus Então, vamos fazer isso agora, então ele deve dizer olá Jack e adeus Katie, já que
passamos as discussões aqui.
Vamos executar esse código. E como podemos ver, diz: Olá Jack e adeus
Katie. Tudo bem. Então é assim que
podemos contornar e adicionar nossos próprios módulos. Ch. É assim que podemos seguir
em frente e configurar isso. Podemos simplesmente mover isso e
excluir esse arquivo, para que possamos clicar com o botão direito na torta de pontos de
saudação e dizer excluir E D agora estamos trabalhando com
nosso arquivo principal de pontos Pi novamente. Ok, então esses são módulos personalizados. Digamos que você possa criar
seus próprios módulos personalizados. Agora, digamos que queremos
trabalhar com módulos integrados. Então, você já aprendeu
antes quando estávamos utilizando o módulo RE quando trabalhamos com expressões
regulares Agora, vou te
mostrar um
pouco mais só para
dar uma ideia. Então, os módulos incorporados são Python. Podemos utilizar o módulo de massa. Então, eu vou dizer importar em massa. E digamos que eu queira obter
a raiz quadrada de
um valor específico. Então, aqui vou
dizer que o número é igual a 16. Então eu posso dizer imprimir, consultar o módulo de massa, e eu quero utilizar a função raiz
quadrada, e eu quero obter
a raiz quadrada
do número que
acabei de configurar aqui. Eu quero obter a
raiz quadrada de 16 essencialmente. Então, agora, se eu executar
isso, ele vai dizer quatro, 4,0. Então, temos esse direito. Ok, então é assim que podemos utilizar o
módulo de massa, por exemplo. Digamos que queremos gerar
um número aleatório de 1 a 10. Então, o que podemos fazer para
isso, essencialmente, é seguir em frente e
utilizar o módulo aleatório. Então, vou
dizer importar aleatoriamente e depois vou dizer imprimir. Em seguida, vamos nos referir
ao módulo aleatório
e, em seguida, random tem
uma função rand int Portanto, gere um
número inteiro aleatório entre, é
claro, os
parâmetros que definimos Então, podemos dizer rand int, a função rand int, e então queremos dizer between Então, eu quero gerar um número
aleatório entre, digamos, um e dez. Então, o mínimo, pode ser um e o
máximo, pode ser dez. Você não vai conseguir 11, 12, 13 ou algo parecido. Se eu executar isso,
vai dizer seis. Agora, digamos que eu o execute
novamente, ele diz dois. É assim que podemos ver que isso vai gerar
um número aleatório de 1 a 10 Tudo bem. Este é o exemplo dos módulos integrados
. Tudo bem. Isso é tudo para este exercício
prático com lâmpadas. Espero que agora você tenha uma compreensão
de como criar seus próprios
módulos e utilizar os módulos integrados em pyson
21. Pacotes, pip e PYPI: Olá a todos, bem-vindos
à próxima lição, que será
focada em pacotes, PIP e PY PI. Então,
vamos dar uma olhada. Tudo bem, então pacotes.
Agora, no PySON, um pacote é uma
pasta que agrupa vários módulos PySON
para uma melhor organização Agora, o que os desenvolvedores
podem fazer e o que
costumam fazer é instalar pacotes usando o PIP
do PYPI, também
conhecido como
índice PysonPackage , para adicionar funcionalidades extras aos seus projetos adicionar Agora, isso é muito permanente nas áreas de desenvolvimento
web, onde
os desenvolvedores utilizam estruturas web baseadas em
PySON, como Jango ou FLASK, quando
vão ao PYPI para instalar um pacote específico e adicionar
um pequeno ajuste de funcionalidade aos seus um pequeno Você também pode utilizar isso em programas pyson
normais, também muito pequenos com um script
Python Tudo bem, então PIP e PYPI. Agora, o PIP é essencialmente uma ferramenta para instalar e
gerenciar pacotes PySON Isso ajuda a
facilitar o download e a atualização de todas as
bibliotecas externas, em vez de codificar tudo do
zero com muitos e muitos módulos
agrupados Agora, o PYPI, que é o
PysonPackage Index, é essencialmente
um repositório on-line milhares
de pacotes PySON,
que podemos baixar e utilizar em nossos programas PySon que podemos é essencialmente
um repositório on-line que bloqueia milhares
de pacotes PySON,
que podemos baixar e utilizar em nossos programas PySon. Agora, o PIP busca
pacotes do PYPI para que você possa
usá-los OK. Tudo bem, pessoal, é
isso nos pacotes, no PYPI e
na configuração de tudo de acordo com o PIP No resumo prático do laboratório, vamos nos aprofundar
e trabalhar com
alguns exemplos para aprimorar nosso programa
22. Como usar pacotes externos — [Lab]: Oi, pessoal. Bem-vindo ao
próximo exercício prático de laboratório, que será focado
em trabalhar com pacotes. Agora, este é o
site do PI, você pode acessar pypi.org e que o
levará a este É aqui que você pode navegar por milhares de
projetos e como implementar apenas um
pequeno aplicativo ou biblioteca em
seu PysonPject. Este é o Índice PysonPackage. Também podemos pesquisar
projetos aqui e depois integrá-los em
nossos aplicativos PySon Certo. O primeiro que
vou ver será simples. Quero que adicionemos alguns
emojis ao nosso código. Pelo menos é o que
vemos em nossa janela de saída. O que vou fazer é
pesquisar uma imagem e procurá-la. OK. E aqui temos um. Então emoji, que é o emoji
do PySon. E você pode ver
que podemos instalá-lo dizendo perp stallimogi Certo. Então, vamos
querer inserir alguns comandos. Agora, o que teremos que fazer por enquanto é
alternar para executar o arquivo
PySON apenas por enquanto OK. E aqui
temos tudo aqui. Vamos esclarecer isso.
Ok, vamos lá. E o que eu
também vou fazer é fechar
alguns
desses terminais aqui e reabri-los. Lá
vamos e vamos embora. Aí está. Aqui
está nosso terminal agora. Agora podemos seguir em frente
e executar alguns comandos. Digamos que queremos
instalar esse pacote de emojis. Podemos simplesmente copiar o seguinte,
acessar nosso terminal
e, é claro, clicar com o botão direito do mouse e ele será colado automaticamente para você. Podemos dizer que Pep
instala o Emoji. OK. E, como você pode ver
,
instalamos pacotes de preços
no ambiente global, que pode causar conflitos. Você pode seguir em frente e criar um ambiente virtual para
isolar sua dependência Portanto, esse é um tópico que abordaremos em detalhes posteriormente
neste curso. Portanto, não se preocupe,
chegaremos a isso em breve. Então, podemos dizer que, por
enquanto, não apareça novamente. Certo, como podemos ver agora em segundo plano, instalamos o pacote Emoji Lá vamos nós. Então,
podemos esclarecer isso agora. Tudo bem, perfeito. Então,
nós temos isso instalado. Agora vamos continuar
e integrar isso. Então, aqui temos nosso código. Agora, o que vou
fazer é
importar essas bibliotecas
específicas. Vou dizer importmoji e depois queremos adicionar
um emoji ao Então, por exemplo, eu vou ter uma declaração aqui
que diz imprimir, e vou me
referir a esse módulo de emoji, e vou dizer ponto E tem uma função
conhecida como emojis. Então é EMO J, I Z E. E dentro
dessa função aqui, vamos adicionar o que queremos adicionar nas
verificações que queremos gerar,
junto com o emote ou emoji que
queremos gerar Então, aqui, por exemplo, direi que sua senha está pronta. Certo. Agora, a próxima coisa
que você faria é adicionar seus resultados. Você pode adicionar um espaço
e, em seguida, os Imoges em pyson são determinados adicionando dois pontos e depois o
nome do seu emoji Vou adicionar a chave e
fechá-la Agora, há um site
que você pode usar aqui em copy dm dot kitp dot IO Vou me referir a esse recurso específico
na próxima lição, para que você possa
dar uma olhada aqui em todos os emoges individuais Mas, como você pode ver, eles são
ditados pelos dois pontos cada lado e o nome do valor
S bem no
meio. Tudo bem. Então é exatamente isso que
estou fazendo aqui e estou configurando isso como uma chave. Então, vamos seguir em frente
e executar nosso código. E aqui você pode ver que diz que
sua senha está pronta. Assim, podemos ver que é bom e limpo que também tenha
essa chave. Então, eu também posso esclarecer isso. E deixe-me configurar isso agora para
marcar o sublinhado
e salvar o arquivo E eu vou
executá-lo manualmente desta vez. Eu vou dizer
Python. Torta de pontos principais. E aí você pode
ver o resultado, sua senha está pronta Muito limpo e muito astuto, você poderia dizer. E lá vamos nós. Então é assim que podemos
utilizar imagens em PySON. Agora, vamos adicionar cores ao nosso terminal aqui, ao nosso texto e também
ao nosso texto
de saída. Para que possamos
voltar. E queremos pesquisar algo
conhecido como ColorRama Então você pode entrar aqui, ColorRama e depois
pressionar Enter Por favor, aqui está, um texto de terminal
colorido multiplataforma. E queremos copiar
o seguinte,
vá até o nosso terminal, clique com o botão
direito do mouse e diga Pep
e armazene ColorRama Está apenas instalando,
aí está. Foi instalado. Vamos
esclarecer isso. E o que podemos fazer é ir até uma cobertura
e remover esse código Tudo bem, então queremos
pegar
o módulo Clama, para que
possamos dizer, de Carlo Rama, então esse é o
módulo, e queremos importar Então, isso funciona como uma aula. E o que
vamos querer fazer é usar a instrução de impressão, e vamos
dizer quatro, que é a classe,
e depois vamos especificar o
atributo de tipos. Então, digamos que queremos que
nosso texto seja vermelho, simplesmente
vamos dizer vermelho. Então podemos dizer mais, e
aqui nas citações do nosso trabalho, podemos dizer que isso é texto em vermelho. Ok, então vamos seguir em frente e
executar nosso código PySNmin dot pi. E você pode ver agora
que tudo está em vermelho. Portanto, os cheques aqui que
imprimimos estão em vermelho, e a
cor do terminal também está em vermelho. Então, se eu fosse esclarecer isso, você pode ver que agora está em vermelho. Digamos que eu queira mudar
isso para verde, por exemplo, posso simplesmente alterar o
atributo aqui para verde. Salve meu arquivo e eu posso simplesmente
dizer Python main dot pi. E aí está,
podemos seguir em frente e ver agora que
está alterado para verde. Eu só preciso mudar
o texto para verde, e pronto, é um texto verde. Ok, então podemos ver que é verde. Vamos definir isso para azul, azul, e vamos
dizer que isso é azul. Texto, torta de pontos principais do MSN, e isso é texto azul Ok, então podemos ver que é assim que podemos mudar essas cores. Você pode ver como é
eficaz
utilizar pacotes
em seus programas. Vamos voltar ao padrão, que é, obviamente, branco. Então, eu vou dizer que
isso é texto branco. E você pode pressionar
a seta superior do teclado para
procurar rapidamente os comandos de um PysmminPi e depois
voltarmos ao texto em branco Então, podemos simplesmente remover
isso. Lá vamos nós. Vamos usar outro
pacote
que nos permitirá
gerar uma senha. Então, uma senha segura, e vamos determinar os caracteres que
queremos na senha. Portanto, isso pode ser útil
se você quiser fornecer uma lista de senhas
para seu amigo escolher se ele estiver com dificuldades para escolher uma senha
segura. Assim, podemos procurar o
pacote e depois é o PWN,
então a senha Gen é como
o termo abreviado Aqui está, PWGen, e
podemos copiar o seguinte,
adicionar ao seu terminal, adicionar ao seu terminal, clicar com o botão
direito do mouse e colar e
digitar Lembre-se de que o tempo de
instalação variará entre todos, então não se preocupe se a
instalação
demorar algum tempo e tudo mais para receber o seguinte aviso. Ele foi instalado, e vamos continuar
e configurá-lo. Queremos importar
o módulo PWGen. Então, o que queremos fazer
é definir uma variável, que vou
definir como senha, e então
pegar o módulo PWGen,
e então vamos nos
referir à função
de PWGen que, aliás
, também tem o mesmo nome e então vamos nos
referir à função
de PWGen que, aliás
, também tem o de PWGen que, aliás
, também tem E aqui vamos definir os comprimentos
da nossa senha Então, vou definir
isso para dez caracteres. Então eu vou para a
próxima linha e digo imprimir. Vou dizer senha
gerada,
dois pontos, e adicionarei uma vírgula e depois me referirei à
senha que estou vendo O PWG gerará
uma senha aleatória para mim associada essa saída variável e esse texto estará logo
ao lado dela Então, agora vamos dizer pysonmin dot pi. E aqui podemos ver a senha
gerada. Portanto, é uma
senha gerada aleatoriamente que foi configurada. Então também tem dez
caracteres, então um, dois, três, quatro, cinco, seis, sete, oito, nove, dez. Vamos definir isso, por
exemplo, para cinco. Vamos executar o Python main dot pi. E podemos ver
que
temos uma senha com apenas cinco
caracteres. Assim, você pode ver como
ajustá-lo e alterá-lo conforme quiser. Então, com esse pacote, você
aprenderá como gerar uma senha aleatória. Tudo bem. Então
é assim que podemos seguir em frente e configurar
isso adequadamente. Certo, então o que eu quero fazer agora é fechar isso e usar
o que fizemos antes para que
possamos clicar aqui
no ícone e executar o código,
e agora queremos
trazê-lo de volta para onde estávamos antes com
nosso executor de código, já que não estamos inserindo
nada nem instalando nada Certo, pessoal. É isso mesmo. Isso é tudo neste exercício prático de
laboratório sobre como
podemos utilizar pacotes
e como podemos instalá-los e
como podemos
utilizá-los para integrar
seu próprio conjunto de funcionalidades
personalizadas aos
nossos projetos e ao alojamento
23. Recursos úteis: Oi, todo mundo. Bem-vindo
à próxima lição, que se concentrará
em fornecer os links
especificados que mencionei na lição
anterior. Agora, o primeiro
será como acessar o PyPI.
É muito simples. Você simplesmente digitaria pypi.org
em sua URL
e isso o levará ao Índice PysonPackage, que
mostrará uma lista de todos os
pacotes de bibliotecas de terceiros que estão
disponíveis para você, como os que
usamos anteriormente, como PW Jen Agora,
em termos dos
Imoges que eu usei , é claro, parecia que eu os
estava memorizando
ou você diria, mas na verdade existe um
site onde você pode ver como integrá-los
utilizando o comando Pip in Agora você pode acessar o seguinte URL
aqui, como você pode ver, copiar e depois DM e
depois 20 paquetes do É assim que você também pode acessar
esse site. Eu só queria te dar
um pouco de clareza aqui em termos de
recursos e links. Se você quiser experimentar
mais e adicionar alguns resultados e quiser
apenas praticar um pouco,
examinar alguns
dos pacotes que estão disponíveis para você e
experimentar um pouco, é assim
que você pode
prosseguir e fazer isso
24. Gere números aleatórios: Olá a todos, bem-vindos
à próxima lição, que será focada na geração de números aleatórios. Então, vamos começar. Então, como geramos números
aleatórios? Agora, o PySON, como você sabe, vem com vários módulos
diferentes para gerar números aleatórios Agora, vamos
explorar três módulos. Agora, o primeiro módulo que
já examinamos, e esse é o módulo aleatório. E com esse módulo, podemos gerar números pseudo-aleatórios Também temos um módulo de segredos, que cria números aleatórios criptograficamente
seguros E também obtemos o módulo
numpit Random, que gera
números aleatórios em matrizes Então, o que vamos fazer
é aplicar nosso conhecimento de uma maneira de
aprender fazendo. Então, vamos continuar e
começar com os exercícios
práticos de laboratório.
25. Aprofunde-se no módulo aleatório — [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de
laboratório, que se
concentrará na geração números
aleatórios utilizando três
tipos diferentes de módulos Então, vamos utilizar
o módulo aleatório. O módulo de segredos e também
o módulo Num Pi, que instalaremos em nosso dispositivo oportunamente. Mas vamos começar com o módulo aleatório, vamos
explorá-lo o máximo que pudermos Agora, a primeira coisa que
precisamos fazer, é claro, é importar aleatoriamente para que possamos acessar
as funções necessárias. E, em primeiro lugar, queremos gerar números
flutuantes de 0 a 1 Então, podemos dizer imprimir. Ponto aleatório aleatório. E, essencialmente, o que
estamos fazendo aqui é chamar
o módulo aleatório, que tem uma função que
imprimirá floats Então, se eu fosse
executar o código aqui, ele imprimirá números
flutuantes aqui 0-1, então teremos
números decimais como resultado
dessa função aleatória que
faz parte do próprio
módulo aleatório Podemos ver que ele muda toda
vez para um número diferente. Agora, digamos que queremos
gerar um float aleatório de 1 a 10. Em vez de usar essa função
aleatória, diríamos
uniforme de pontos e você vai querer colocar os
limites, digamos de 1 E você pode executar esse código. Agora, isso vai imprimir números de ponto
flutuante. Portanto, os floats são essencialmente números em formato decimal e serão de 1 a 10 Agora, ele
será capaz de rodar 1.0, mas nunca rodará dez. Então, essencialmente, será tudo de 1
a 9 na verdade, em termos de
uma ordem decimal Certo. Agora, vamos continuar e imprimir números inteiros
aleatórios Acabamos de experimentar agora com números
aleatórios de ponto flutuante ou flutuadores, como você diria, usando a função aleatória de pontos e, em
seguida, a função uniforme Agora, digamos que queremos
imprimir números inteiros aleatórios. Podemos usar a função
rand int e digamos que queremos imprimir números de 1
a Ok, então isso
incluirá um e dez. Portanto, com o rand em função, ele permitirá o valor do limite
inferior e do limite
superior Vamos executar isso. Então,
temos três, seis, e podemos ver que é um número
inteiro porque é o número inteiro que está
sendo produzido nove,
seis, um, oito, três, dez Certo. Agora, digamos que queremos imprimir números inteiros aleatórios novamente, mas queremos que estejam
em um intervalo específico Agora, digamos que
queremos imprimir de 1 a 9, o que significa que eu
também quero imprimir nove Você iria em frente e
mudaria de rand int, você o configuraria para rand range Agora, a diferença aqui
é que vai excluir dez. Agora, o Rand It antes incluía
dez, mas neste caso, com o intervalo Rand sendo
impresso a partir do limite inferior, escolha o
limite superior menos Então, vamos seguir em frente
e executar esse código. Vamos em frente e
executá-lo. Lá vamos nós. Você notará que, se executar
isso várias vezes, notará
que nunca produzirá dez. No entanto, se você
quisesse produzir dez, tecnicamente
precisaria definir isso como 11 Então, quando você executar esse código, ele acabará por lhe dar pelo
menos uma chance de
imprimir dez. Apenas algo
para você experimentar. Lembre-se de que a
função rand in incluirá os valores do
limite inferior e superior e o intervalo Rand inclui
apenas o número do limite
inferior
e, em seguida, o número do
limite superior menos É assim que
isso vai funcionar. Analisamos números de ponto
flutuante
e números inteiros aleatórios Agora, vamos analisar a distribuição
normal para
estatísticas, por exemplo. Se você estiver interessado
em estatística ou estiver trabalhando sob essa luz, podemos utilizar o módulo
aleatório e usar a função de variável normal e podemos
passar por zero e um Agora, ele vai
pegar uma média e o desvio padrão é o que
vai acontecer Neste caso,
a média será zero e o desvio
padrão será um Se executarmos isso, veremos qual
será a variação padrão normal cada
vez que executarmos. Ainda será aleatório
porque é um módulo aleatório. Mas, como podemos ver, é assim que
podemos seguir em frente e utilizar distribuição
normal com uma
média e um desvio padrão Certo. Agora, vamos aplicar isso quando estivermos
trabalhando com listas. Então, podemos remover isso. Vou criar uma lista aqui e vou dizer carros, iguais, e vou
criar uma lista de Eu vou dizer BMW,
eu vou dizer Tesla. Eu vou dizer Ford, e o último, eu posso montar a Nissan Eu tenho minhas cartas prontas. Agora, a primeira coisa que
quero mostrar é como você pode escolher um item ou
elemento aleatório dessa lista. Para fazer isso, você pode dizer
print e queremos
fazer uso do módulo
aleatório e existe uma função
chamada choice. Vamos aplicar a
opção a essa lista aqui. E, essencialmente,
o que vai acontecer aqui é imprimir um item
aleatório dessa lista. A função
de escolha de pontos permitirá que você escolha um item aleatório da
lista que você definiu. Então, se eu executar o código, você verá
Tesla, Tesla, BMW,
BMW, Tesla, Nissa, será
completamente aleatório cada
vez que você clicar
nele completamente aleatório cada
vez Ok, então é assim que você pode utilizar essa função
específica. Agora, digamos que você queira seguir em frente e escolher dois elementos
exclusivos. Portanto, você não quer continuar selecionando apenas uma
opção de cada vez. Você deseja selecionar dois elementos
exclusivos a cada vez. Assim, você pode ajustar isso
e, em vez de
dizer a escolha do ponto, usará a função
de amostra. Vou inserir a
lista e depois duas. Então, agora, você escolherá dois elementos exclusivos
dessa lista. Então, se fôssemos executar o código, podemos ver que temos o Ford Tesla Temos BMW Tesla, Ford Nissan, Tesla Nissan,
e você verá aqui ele simplesmente prosseguirá e produzirá dois elementos ou
itens aleatórios da Então esse é todo o propósito
da função de amostra. Se eu quiser selecionar
três, por exemplo, cada iteração, posso simplesmente
substituí-la, salvar meu código
e executá-lo. Agora ele aparecerá em
três, e executá-lo. Agora ele aparecerá em escolhendo aleatoriamente quais elementos gerar e Agora, algo interessante que você pode querer analisar aqui é o fato de que você está usando a função de amostra de pontos e está enviando
três ou, digamos, por exemplo, dois,
que nunca mostrará itens duplicados Então, como podemos ver
aqui, se eu colocar dois, mostra Nissan e Ford Não vai
mostrar, por exemplo, Nissan Nissan,
Ford, Tesla, Tesla, BMW, BMW, BMW, não vai mostrar
que sempre vai seguir em frente e mostrar
algo Então, se eu simplesmente
executasse novamente o código aqui, ele sempre mostraria
algo único
cada vez que você
executasse seu Ok. Então, apenas algo
que eu queria mencionar nessa nota. Outra coisa que
você pode fazer é embaralhar sua lista também Agora, se eu fosse publicar minha lista, se eu dissesse imprimir
carros e correr, mangueiras BMW, Tess,
Ford e Nissan Ok, então se eu executar isso de novo, ele vai fazer isso
na mesma ordem, mas digamos que eu queira
embaralhar essa lista Então, o que você pode
fazer é o seguinte. Você pode dizer imprimir, e
aqui dentro da função, você pode dizer aleatório de pontos aleatórios, e você pode colocar essa
lista da seguinte forma Portanto, essa função
alterará a ordem do que
está incluído na lista Então, não será toda
vez que você dirige BMW, Tesla Ford Nissan,
então se eu dirigir, ok, você verá que ele funcionará no estado não Agora, a razão para
isso é que você precisa embaralhar a lista antes de
executar a função de impressão Então, algo que eu
queria mencionar aqui. Então você tem que fazer
isso separadamente. Como está, deixe-o embaralhar
e depois imprima. Portanto, essa função específica funciona de forma um pouco diferente. Você vai ter que
deixá-lo sozinho. Agora, mais cedo, quando
eu estava mostrando,
você pode incluir todas as
funções e os módulos juntos
na instrução de impressão
e imprimir o resultado. No entanto, ao embaralhar
a função shuffle,
ela funciona sozinha ela funciona Então, aqui precisaríamos dizer
explicitamente carros depois. Então, quando eu executo isso, vai
dizer BMW Nissan Forte, e você pode ver que ele embaralha
os itens, como podemos Embora você não possa fazer isso
em uma função de impressão. Portanto, um
ponto muito importante a ser observado. E, como você viu anteriormente, você terá um resultado de nenhum. Portanto, isso é algo
importante que você precisa ter em mente. Portanto, com a maioria dos módulos e
funções que você deseja usar, você pode adicioná-los em uma função de impressão, mas
se estiver embaralhando, ela precisa estar explicitamente
sozinha com a própria
função de reprodução aleatória e, em seguida, você pode imprimir
depois para que
ela embaralhe a lista
e, em seguida ,
você possa imprimir o resultado posteriormente você pode adicioná-los em
uma função de impressão, mas
se estiver embaralhando,
ela precisa estar explicitamente
sozinha com a própria
função de reprodução aleatória e, em seguida, você pode imprimir
depois para que
ela embaralhe a lista
e, em seguida,
você possa imprimir o resultado posteriormente. Ok, então é só uma coisa
importante para lembrar. Então, isso vai
modificar o local. Ok. Ótimo. Agora, vamos seguir em frente e ver mais
algumas funções. Agora, digamos, por exemplo, que
eu queira que
elementos aleatórios apareçam e também que
sejam repetidos. Portanto, não quero que
seja em uma situação específica em que temos as duplicatas, mas também quero
permitir que haja alguma
repetição Então, vamos seguir em frente
e fazer exatamente isso. Então, temos nosso ninho, e
podemos remover o que temos aqui, e podemos simplesmente dizer
imprimir um ponto aleatório, e vamos dizer
escolhas desta vez. Lembre-se de que antes tínhamos uma escolha, o que significa escolhas únicas. Podemos ter várias
opções, e diremos carros, e essa
será a lista que será adicionada,
e diremos que K é igual, e podemos definir isso como dois Alr. Então é isso que
queremos adicionar. E isso pode retornar valores
duplicados. Então, ao contrário de antes, quando
entramos em uma cobertura e configuramos nossa amostra
com uma função de amostra, você não pode ter duplicatas, mas com a função de escolhas, você pode ter duplicatas Então, por K igual a dois, estamos especificando quantos
elementos queremos produzir Então, se eu dissesse corra,
Nissan, Tesla Tesla. Então, aqui você pode ver que vai mostrar dois elementos
da lista, mas pode ser repetido, então você pode ver duas
coisas iguais. Então é assim que você pode ter
algum tipo de repetição. Certo. Agora, a próxima coisa
que quero mostrar é como você pode utilizar a função
triangular Agora, a função triangular é bastante única
porque retornará uma flutuação entre
baixo, alto e modo Está bem? E o modo é o pico de onde a saída
provavelmente estará mais próxima. Então, é muito parecido com
arredondar para cima, você poderia dizer. Então, deixe-me mostrar
como podemos fazer isso. Então, podemos ir até uma cerca viva e
remover o que temos aqui. E podemos adicionar nossa declaração
impressa. E eu vou dizer ponto aleatório, triangular, que
será a função E primeiro,
teremos um carro alegórico que queremos devolver
no ponto baixo O ponto baixo será um. O ponto alto pode ser dez e o modo ou
pico pode ser cinco. Então, se eu fosse executar isso, veria que a
saída aqui, é claro, é flutuante, mas você pode ver que ela estará
mais próxima do modo Então, um é o ponto baixo. Dez é o ponto alto e cinco é o
modo, ou seja, o ponto
mais provável de onde o
valor de saída estará mais próximo. Então 6,0 mais próximo de cinco,
5,1, basicamente cinco, 4,7 mais próximo de cinco, 5,4,
mais próximo de cinco, 5,2, mais
próximo de cinco, 5,6, perto de cinco Então você pode ver lá como isso está funcionando. Certo. Agora, a próxima coisa que
quero mostrar é bem semelhante à função normal
que usamos antes. Agora, digamos que estamos trabalhando com simulações e queremos
simular medições do mundo real
com variação natural Podemos usar a função de gaze. Então, também vai incluir, como posso dizer uma média e
um sigma para o desvio
padrão Então, o que você faria é
simplesmente substituir Gauze
triangular, então
podemos passar por zero e
um como média e Sigma, isso vai gerar valor
normalmente distribuído
em torno de zero, você poderia dizer, se eu executar isso, podemos ver
que a distribuição associada será produzida
usando a função Muito disso é
baseado em estatísticas, a gaze triangular e as funções variáveis normais são usadas
principalmente no
ramo de estatísticas, devo dizer Mas é apenas
algo que eu queria
mostrar para que você possa, pelo menos entender
um pouco o resultado e o que esperar. Certo. Então aí está. A
coisa mais importante que quero lembrar aqui quando você está
usando suas funções de impressão que você pode operar suas funções e módulos na
mesma função de impressão. No entanto, você não pode fazer
isso no shuffle, então tenha isso em mente Tudo bem, certo, vá. Então é isso para
o módulo aleatório. Em seguida, vamos seguir em frente e nos concentrar no módulo de segredos.
26. Explorando o módulo de segredos — [Lab]: Tudo bem, então vamos continuar
com o módulo Segredos. Ok, então o que eu quero
fazer, primeiro de tudo, é importar o módulo Secrets. E a primeira coisa que queremos fazer é retornar um número inteiro aleatório que está
abaixo de um determinado número Então, o que posso fazer aqui
é dizer imprimir e vou utilizar
o módulo de segredos. Em seguida, vou usar a função
range below e quero imprimir
um número aleatório de 0 a 9 E para fazer isso, eu
precisaria colocar apenas dez. Então, ele
imprimirá tudo de 0 a 9 e não incluirá
dez Então, se
executássemos o código aqui, podemos ver que temos oito, três, um, oito, você notará que ele não
imprimirá dez, ele fará
todo o resto além disso. Outra coisa que podemos fazer é
entrar em um hedge e produzir uma escolha específica também utilizando o módulo de segredos Agora, digamos, para fins de
argumentação, que
temos uma lista aqui de códigos
confidenciais. Vou dizer
códigos e, em uma lista, vou colocar Alpha,
Beta, Gamma Quero recuperar uma escolha
aleatória segura, por si só. Posso dizer imprimir e consultar
o módulo de segredos. E então a função que
eu usaria é escolha, e eu vou colocar códigos. Então, vou recuperar uma escolha secreta. Você
poderia dizer ou codificar. Então, se eu executar isso,
posso ver que tenho Alpha. Cada vez que eu
executo vai me dar um novo código,
então Gamma, Alpha, Beta Tudo bem. Então é
assim que você pode escolher uma escolha aleatória de
uma determinada sequência. OK. Agora, a próxima
coisa que quero mostrar é exclusiva
do módulo de segredos, e é assim que você pode
gerar um token hexadecimal seguro E isso, é claro,
terá 16 caracteres. Então, vamos seguir em frente e fazer isso. Agora, o valor que você
inserir, é
claro, será configurado em bytes. Então, é claro, será
o dobro no nosso caso. Ok, então
vamos fazer isso. Então, o que podemos fazer é
simplesmente dizer que imprimir usa o módulo de segredos, e podemos utilizar o token, a função hexadecimal de
sublinhado, e vamos dizer oito, e isso vai gerar um token hexadecimal seguro com 16 caracteres Vamos executar isso e
podemos ver aqui que temos BA ED e esse número inteiro, que
terá 16 caracteres. Agora, é claro, se eu definir
apenas 24 e
executá-lo, ele só
imprimirá oito caracteres. Porque lembre-se de que estamos
definindo os bytes aqui
e, essencialmente, isso vai
dobrá-los. Então, se eu colocasse
quatro aqui e executasse,
ele só me daria
uma saída de quatro tokens hexadecimais Isso pode ser muito útil se você precisar de tokens
em algum sentido. É assim que você pode gerar
um token hexadecimal seguro. É assim que podemos utilizar
o módulo Secrets, certo. Esse é o módulo Secrets. A próxima coisa que
veremos é o módulo NumPi e isso é
algo que
vamos querer instalar primeiro
em nosso projeto Normalmente usamos o módulo Numpi para operações aleatórias rápidas, mas mais do que isso em breve
27. Aprofundamento no módulo Numpy — [Lab]: Tudo bem, então vamos continuar. Agora, a próxima coisa em que
vamos nos
concentrar é no módulo Num Pi. E isso também é muito útil para trabalhar
com matrizes Mas falaremos mais sobre isso em breve. Então, a primeira coisa
que queremos fazer é
ir até o PYPI e ver o Pep instalar o NumPie. Então, podemos copiar isso, ou você pode realmente digitá-lo em seu terminal e no código do
Visual Studio. E o que vou fazer
agora é
trocar 30 Bug para executar o
PysonFle Podemos apagar essa saída. E você só quer
dizer Pep install num Pi, e você pode pressionar Enter. Ok. E isso só vai
instalá-lo para nós. Ok. Vamos ser pacientes
e esperar um momento, e então podemos continuar utilizando o módulo
Num Pi Ok, então vamos
esperar um pouco. Certo, então podemos ver que ele
foi instalado. Nós
podemos esclarecer isso. E não precisamos mais disso. Vamos mudar para executar o código e pronto. Certo. Agora, agora que temos
o pacote NumPi instalado, agora
podemos acessar seus módulos
específicos Então eu posso ver Import. Num Pi. Agora, de acordo com o padrão,
normalmente, Num Pi é bastante
longo para o nome de um módulo E como é
usado com bastante frequência, o que as pessoas geralmente
fazem é configurar um alias em termos
do nome do módulo Então você pode dizer a, e então podemos definir o
alias como N P. Então, em outras palavras, onde quer que definamos MP, isso significa que estamos basicamente invocando o próprio módulo Num
Pi Então, basta um
truque pesado se você quiser
configurar aliases
com Nesse caso, isso é 99% do tempo sempre seguido
quando você está usando o NumPi Ok. Agora, a primeira
coisa que quero mostrar é como você pode seguir em frente
e configurar matrizes básicas Ok. Então,
vamos dizer imprimir e vamos nos referir a NP. E vamos
utilizar submódulos. Portanto, o NumPi tem um submódulo, chamado aleatório, que tem uma função
chamada Portanto, tenha isso em mente. Então, aqui estamos usando
random como um submódulo. Portanto, o NumPi é nosso módulo. Random é nosso submódulo
e Rand é nossa função Portanto, tenha isso em mente caso esteja ficando
um pouco confuso. Portanto, há uma pequena
diferença nesse aspecto. E com a função rand agora, isso nos permitirá
gerar uma matriz de um D, e só precisamos especificar quantos
floats aleatórios queremos 0-1 Então eu quero ter.
Então, se eu executar isso, talvez precisemos ir lá. Agora, ele imprimirá uma
matriz unidimensional, como podemos ver, e terá três flutuadores
aleatórios porque, lembre-se, rand se concentrará
na saída de Então, qualquer coisa com um
decimal e serão três flutuações aleatórias no intervalo de zero a um, então podemos ver aqui 0,16,
0,93, 0,7, tudo
está Digamos que eu queira gerar
uma matriz de três por três, não apenas uma matriz,
três por três. Posso apenas dizer vírgula
e depois três, e agora podemos dizer executar código Pronto, agora temos uma matriz de
três por três. Parece muito semelhante ao que você obtém em matemática
quando obtém matriz ou qualquer coisa do
tipo, muito semelhante de certa forma. Neste caso,
estamos retornando uma matriz de
três por três com flutuações aleatórias de 0 a 1
novamente, como você pode R. Isso é o que
temos aqui. É assim que você pode
configurar suas matrizes. Agora, outra coisa que
você pode fazer é
configurar uma matriz com
números inteiros também Aqui estamos configurando
uma matriz com flutuadores. Vamos
mudar isso. Agora vou mudar
a função para rand int. Aqui vamos apenas fechá-lo e
vamos colocar. Vamos colocar
três valores aqui; nesse caso,
teremos uma baixa,
uma alta e um tamanho. Nesse caso,
teremos zero,
que é baixo, dez, que é alto e, em
seguida, o tamanho, vamos definir como três. Ok. Agora, neste caso aqui, os valores aqui serão de 0
a 10, excluindo dez, serão de
zero a nove e teremos números inteiros aleatórios,
três números inteiros
aleatórios que são 0 a 9 em Se eu fosse executar isso, podemos ver que você
tem o seguinte. Temos uma matriz unidimensional. Os valores são de 0 a 10, excluindo dez, e
temos três Então, se fôssemos executar isso novamente, você pode ver agora que ele vai
continuar e produzir esse resultado. É assim que você pode gerar uma matriz unidimensional de três números inteiros aleatórios de 0
a 9 Ok. Então, a parte baixa é, obviamente, a base
que você está começando. A parte alta é, obviamente, o limite superior,
que você exclui. Você só está no limite
superior menos um. Portanto, lembre-se de que sempre que
você ouvir falar sobre valores de limite superior
ou algo parecido, você sempre ouvirá
menos um Portanto, é um
truque bacana que eu recomendaria sempre que
você lidando com valores de
limite superior que são excludentes.
Sempre menos um É aí que a contagem real
aumentará no máximo. Ok, então é assim
que você pode trabalhar com matrizes
básicas utilizando
o módulo NumPi Ok, então o que eu quero
fazer agora é mostrar mais
algumas funções úteis
que você pode usar. Agora, a próxima coisa que
quero mostrar é como você pode gerar um conjunto de números
aleatórios a partir de uma distribuição normal padrão qual teremos a média de zero e o
desvio padrão de um Então, o que podemos dizer é imprimir, e você pode ver nenhum
ponto aleatório, ponto
Rand, e teremos N porque isso será para distribuição
normal E aqui vamos colocar quantos números aleatórios
queremos de uma distribuição normal. Isso pode ser muito útil
se estivermos simulando, por exemplo, flutuações em um mercado de ações ou alturas
ou algo parecido Corra isso, vamos lá. Você pode ver agora que
geramos três números aleatórios a partir de
uma distribuição normal. Ok. Então, temos essa configuração. A próxima coisa que quero
mostrar é o que você pode fazer se quiser escolher elementos ou
itens aleatórios com ou sem
substituição. Ok. Agora, o que quero dizer isso é que a substituição determinará se
você tem duplicatas ou se você não tem É muito semelhante ao que
expliquei antes com a função de amostra de pontos e a função de escolha de pontos em que
você adiciona K igual a dois, por exemplo, muito semelhante ao que tínhamos anteriormente
com o módulo aleatório, mas é assim que você
vai aplicá-lo com o próprio módulo Num Pi. Isso
é o que vamos fazer. Vamos primeiro
definir uma lista. Esta lista aqui vai, vamos continuar e
limpar isso. Teremos uma lista e
diremos que
frutas são iguais e podemos dizer par de maçã, uva e par de maçã, uva Temos uma lista de frutas, defina uma lista
e, em seguida, podemos dizer print e Np dot random como um submódulo, e vamos
dizer escolha de pontos Então, desta vez, usaremos a escolha e
adicionaremos três opções. Agora, digamos que eu
queira seguir em frente e escolher dois
elementos exclusivos dessa lista. Primeiro, vamos
definir a partir de qual lista. Então, nesse caso, serão frutas. Então serão dois, e então queremos dizer que
substituir é igual a Isso nos permitirá
essencialmente que esse código escolha
dois itens exclusivos e, ao dizer que substituir é igual a falso, significa
que garantiremos que não haja duplicatas Em outras palavras, quando
selecionamos dois itens dessa lista de frutas, não
queremos selecionar
maçã duas vezes, como maçã e
maçã ou uva e uva ou
laranja e laranja
ou pêra e pêra Deixe-me demonstrar isso para você. A substituição ajuda a evitar
a duplicação. Vamos seguir em frente e executar o código. Temos maçã, pêra, laranja, laranja, maçã, uva maçã, uva laranja, pêra laranja Você verá
que não haverá nenhuma duplicata desse tipo Mas, no entanto, se eu definisse replace como true, isso
permitiria duplicatas Então, se eu disser que substituir é igual a verdadeiro, salve isso e use laranja
maçã, laranja uva Papai. Lá vamos nós. Agora
temos uma duplicata em vigor Portanto, agora podemos ter
valores duplicados que estão sendo selecionados Portanto, dois valores que são iguais podem ser
selecionados. Então você terá que
substituir é igual a verdadeiro. Ok, então é assim que
podemos adicionar isso. Ok, muito
parecido, como eu disse, ao que tínhamos antes com o
módulo
aleatório aleatório. Tudo bem Então, nós temos isso.
Perfeito. Ok, então vamos ver
onde podemos ir mais longe. Agora, digamos que, para fins de
argumentação, você queira subir em uma cerca
e devolver uma série de carros alegóricos com baixa e alta Está bem? Então, o que você pode fazer é seguir
em frente e dizer imprimir. N P ponto aleatório. E você quer dizer
o uniforme de pontos. Portanto, lembre-se de que, com a função uniforme de
pontos, você
lidará com float, então a saída estará em floats E vamos considerar
três valores aqui. Então, primeiro teremos um
alto, um baixo e um tamanho. Então, primeiro, a alta, vamos dizer de um a dez. E então queremos ter cinco carros alegóricos aleatórios,
então podemos dizer cinco Ok. Então, vamos seguir
em frente e executar isso. Ok. Lá vamos nós. Vamos ver que temos
um, dois, três, quatro, cinco, vai ficar
entre, como podemos ver aqui, o baixo e o alto, então de um a dez, lembre-se, nunca será dez. Não vai ser no 10. Se executarmos isso, podemos ver que em
nenhum caso será dez. Isso é o que podemos fazer
se quisermos retornar novamente
uma matriz de flutuações
em alta e baixa Tudo bem Ok, perfeito. Então, chegamos lá,
você pode ver aqui que o máximo que pode
subir, como vemos, é 9,74 e até mesmo
tão baixo quanto 2,29, mas sem ultrapassar dez Agora, digamos que queremos
retornar uma matriz de números normalmente distribuídos. Então, usaremos algo
conhecido como função normal. Então, o que podemos fazer é
dizer mp dot random dot normal. E podemos simplesmente fechá-lo. Vamos
pegar três valores. Então, teremos zero, por exemplo, um, e podemos dizer cinco. Agora, o primeiro valor aqui
será para MU. Então teremos Sigma
e, em seguida, teremos tamanho E vamos
retornar cinco
desses números normalmente distribuídos em uma matriz. E aí podemos ver
que temos essa saída adequada, certo? Perfeito. E
é assim que também podemos seguir em frente e configurar a função
normal. Tudo bem, então aí está. Existe uma maneira pela qual
podemos utilizar todos esses três
módulos. E eu só
queria dar uma visão geral
de como você pode
usar todas elas e algumas das funções mais
populares. Agora, eu sei que alguns
deles podem estar um pouco exagerados e
um pouco fora do escopo. Algumas delas se aprofundam,
como mencionei, em algumas estatísticas, mas é importante pelo
menos estar ciente delas e ter um
pouco de contexto, para não dizer que você nunca as usará, mas é bom ter
algum conhecimento prévio, para você
saiba que elas existem, e você não está
limitado a usar apenas uma ou duas funções
disponíveis De qualquer forma, isso está
no Num Pi em termos das
funções aleatórias num Pi e coisas do gênero. E sim, isso
conclui este conjunto de exercícios práticos de laboratório em três partes
28. Decoradores: Olá a todos, e bem-vindos
à próxima aula, que será
focada em decoradores Então, o que é um decorador? Isso é provavelmente o que está
em sua mente agora. Então, simplesmente colocando um decorador em PySon, é uma função ou
classe especial que aprimora
outra função ou método sem alterar
seu Então, deixe-me fazer uma analogia
muito simples. Digamos que você esteja
se preparando para o Natal e queira
se tornar festivo e decorativo A primeira coisa que
você faz é comprar uma árvore de Natal. Então isso faz parte
da decoração. No entanto, o que as pessoas
fazem é decorar a árvore, então dão um passo adiante e colocam muitas
coisas boas na árvore. Portanto, tente ver um decorador
nesse sentido literal
de sua Você pode tratar a
árvore de Natal como uma função e os
decoradores adicionais que você coloca como uma função especial Essa é apenas uma maneira
de seguir em frente e tentar, como posso dizer, colocar isso em perspectiva. Agora, no PySon, como mencionei, um decorador pode ser uma função ou
classe especial No entanto, o decorador mais
comum é, obviamente, o decorador
de
funções 99,9% das vezes, quando
você trabalha com Pyson em qualquer ambiente
ou ecossistema, você verá
decoradores na perspectiva
de
ter perspectiva
de Agora, outra coisa que eu
quero mencionar em termos de decoradores é que ele permite modificações
dinâmicas Então, o que você pode fazer é adicionar ou alterar a
funcionalidade de suas funções e métodos de classe como um todo.
Tudo bem, pessoal. Então, isso é tudo para a visão geral
teórica. E na próxima lição, trabalharemos
em alguns exercícios para solidificar nosso conhecimento
sobre decoradores em pyson
29. Criando nosso primeiro decorador — [Lab]: Oi, todo mundo. E bem-vindo ao próximo exercício prático de
laboratório, que será focado em
trabalhar com
decoradores em PySon trabalhar com
decoradores em PySon Então, vamos manter as coisas
muito simples para
começar e depois
podemos continuar com alguns
exemplos. Então, vamos começar. Ok, então a primeira
coisa que precisamos saber é como podemos definir uma função simples em PySON e depois
construir a partir daí Certo. Então, a primeira
coisa que vou fazer é definir uma função. Eu vou dizer Def
e vou dizer aqui diga sublinhado Olá E vou deixar os
parenses vazios e não
vou passar por
nada no curlon E então o que eu vou
fazer aqui é dizer impresso, e estava na declaração
impressa aqui, eu vou dizer olá, mundo. Perfeito. Agora, o que eu quero fazer é chamar essa função
e vou dizer, digamos,
sublinhado, olá. Lá vamos nós. O que essencialmente
vai acontecer é que
vamos definir essa função. Em seguida, ele executará print hello world
assim que for chamado. Aqui estamos chamando essa função
específica e ela
executará o que estiver dentro
dessa função em si. Vamos executar o código
e podemos ver lá que ele
gera hello world Essa é a
maneira simples pela qual você pode utilizar uma função. Ótimo. Perfeito. Então, agora
que temos isso em mente, vamos continuar e
desenvolver a partir disso Então, temos essa função, e digamos que
queremos usar uma cobertura e modificar os resultados que obteremos
com essa função Ok, então
digamos que queremos incluir isso em um decorador e
queremos ter mais resultados, não apenas hello world Queremos ter um
pouco mais do que isso. Então, o que vou
fazer é definir um decorador Agora, um decorador,
é claro, como mencionei, pode ser uma
função ou uma classe agora uma
classe funcional especial para ser mais específico O que vou fazer é
diminuir um pouco o zoom aqui e vamos definir
uma função especial agora Vou dizer ef e
essa função aqui, vou chamar isso de decorador de sublinhado
M. OK. E então o que
vamos fazer é
passar pelo funk OK. Agora, você pode tratar o
funk aqui como um parâmetro, ok, para outra função que vamos ver,
como posso dizer absorver? Agora, essa função que
ele absorve será absorvida quando adicionarmos o decorador em cima
da Então, digamos que eu queira prosseguir e modificar
essa função aqui. O que eu precisaria fazer é adicionar o decorador de arte e esse decorador fará
referência a essa função
aqui chamada Meu Meu decorador de sublinhado e agora funk aqui é o parâmetro, e isso agora vai incluir essa função específica
que temos Porque temos funk aqui, e a razão pela qual ele
sabe que
será essa função é porque
anexamos o decorador Com esse decorador,
ele vai
pegar essa função e
passá-la aqui automaticamente porque
esse decorador que adicionamos aqui
era o símbolo at, ele vai passar
por Agora, essa é essencialmente a função do decorador e
essa é a nossa função original Podemos adicionar dois pontos ali mesmo. Então, a próxima coisa que precisamos
fazer é embrulhar. Precisamos incluir essa função
original em nosso decorador Você poderia dizer em
nossa nova função. Você precisaria dizer morte. Embrulhe, abra e feche os parênteses e Essa será
a nova função que
envolverá a função
original agora. A próxima coisa que
vamos querer fazer
é fazer é fazer um teste simples e apenas
executar algum código aqui. Então, vou executar uma
instrução de impressão simples que
dirá que a função
está prestes a ser executada. Está bem? Então, essa
instrução será executada antes de executarmos
essa função aqui, que foi
passada pelo funk Então, para chamar essa função, precisaríamos seguir em
frente e dizer funk, certo? E isso então
executará essa função aqui, que vai
dizer olá mundo. Depois que isso for executado, podemos então configurar outra instrução de
impressão aqui que
diz que a função
terminou de ser executada. Então, isso é executado após a
função ter sido chamada. Agora, a última coisa que
precisamos fazer é
retornar essa saída por meio
da nova função encapsulada. Então, para fazer isso, podemos escrever aqui, indentar e dizer
return wrapper, e isso executará tudo adequadamente para OK. É assim que podemos
simplesmente configurar um decorador Está bem? Tudo bem, então deixe-me continuar e mostrar
o que vai acontecer agora Então, o que vai acontecer
é o seguinte. Então, a primeira coisa que
vai acontecer é essa instrução de impressão
será executada. Em seguida, o decorador assumirá essa
função original que tínhamos
e, como você pode ver, a
modificará Isso não altera nada que foi definido nele. Ele passará aqui o parâmetro
e, em seguida, vamos
chamá-lo dentro do wrapper
e, em seguida, imprimiremos uma declaração de saída
para dizer que ele
terminou de executar aches e retornaremos esse wrapper
para garantir que ele
tenha sido Então, agora, se eu fosse executar meu código, agora
posso ver que minha saída dirá que a
função está prestes a ser executada, hello world, e a função
terminou de ser executada. E você pode ver
que tudo foi executado como deveria. OK. Então é
assim que podemos seguir em frente e
configurar tudo para funcionar como deveria. Certo, então deixe-me dar um pouco mais de detalhes para que você entenda
tudo perfeitamente. Então, aqui temos M
underscore decorator funk. Então, novamente, o funk
será a função que
está sendo decorada Nesse caso, será say hello, que está sendo decorado pelo decorador at my underscore Então é assim que você
decora uma função. Você coloca o
símbolo em forma de arroba e depois segue a
função decorada, devo dizer? OK. E meu decorador, Frank, aqui
receberá a função
e colocará código
extra em volta dela, que acontece com esse invólucro Então, ele adicionará
essa declaração de saída aqui que diz que a função
está prestes a ser executada e esta aqui que diz que a função
terminou de ser executada. Então, temos esse
invólucro aqui, ok? E essa é uma nova função
em nosso decorador. E, como você pode ver, isso
adiciona um comportamento extra,
ou seja, aqui
e aqui. Então, antes e executando a função original
definida pelo funk. OK. Agora, o invólucro aqui
vai chamar funk inside. Portanto, a função original
ainda estará em execução. Em seguida, temos a embalagem de devolução. Então, em vez de
devolver o funk em si, ok, vamos
devolver a embalagem, Agora, sempre que ligarmos para dizer olá, na verdade
ligaremos para o remetente. Na verdade, vamos ligar
para wrapper. Isso é essencialmente
o que faremos. Tudo bem. Aí está. Existe a
maneira mais simples de integrar um decorador
em Python Vamos trabalhar em
mais alguns exercícios práticos, mas esse é o básico para configurar seu primeiro
decorador e como você pode aplicá-lo a um determinado conceito Certo, o que podemos
fazer é retirá-lo por enquanto e depois continuaremos momentaneamente
30. Trabalhando com decoradores — [Lab]: Tudo bem Então, vamos continuar trabalhando em
alguns exercícios práticos. Agora, a próxima coisa
que queremos
fazer é trabalhar em um programa que
converta a
saída da função em maiúsculas. Então, vamos seguir em frente
e aplicar isso. Ok, então a primeira
coisa é configurar uma função simples. Então, vamos dizer definitivamente,
raça e, em seguida, aqui
vamos dizer retorno, e eu vou dizer lá,
digamos, bom dia Muito simples. Então eu
vou dizer imprimir. Cumprimente. E se eu executar esse código, ele vai dizer bom dia. Então, aí está, é muito simples. Então, nesse caso, eu removi a instrução print
de dentro da função. Eu mudei isso para fora e estou apenas retornando
o texto fornecido
, ou seja, bom dia, e então estou chamando a
função aqui. Ela estava na
instrução print para executar
o valor de Wister que foi
retornado na função Agora, lembre-se de qual é o
nosso caso de uso. Queremos converter a saída da
função em maiúsculas. Aqui, quando estamos imprimindo e
executando essa função, queremos que ela esteja em maiúsculas Vamos seguir em frente e
fazer isso acontecer. Portanto, precisaríamos ter um decorador
de maiúsculas para isso. Esse seria um bom tipo
de caso de uso, digamos morte aqui
e podemos dizer decorador de
sublinhado em maiúsculas Então vamos
passar pelo funk. Agora, para
absorver essa função, precisaríamos adicionar o
decorador, que estará em,
e esse será o
decorador de sublinhado em
maiúsculas aqui, e então ele passará por
essa função como
está agora essa função como Em seguida, precisamos definir o
wrapper IO, podemos dizer def wrapper. Então, queremos chamar
a função original e vamos atribuí-la
a uma variável. Eu vou dizer que
aqui o resultado é igual, e isso vai ser funk Estou armazenando essa função
específica, que será
passada aqui como funk e vou armazená-la
nessa variável chamada result Aqui é onde eu estou chamando
a função original. Então, a próxima coisa que
eu quero fazer é converter
a saída em maiúsculas. Então, seja qual for o resultado
aqui do funk, que é essencialmente
bom dia, eu quero converter esse
resultado para maiúsculas Então, posso dizer que retorne
o resultado com o ponto superior. Então, vou aplicar esse método
específico aqui,
o método em maiúsculas,
e isso vai converter
a saída em maiúsculas. E então, tudo o que preciso
fazer agora para retornar a nova função é
retornar o invólucro Só posso dizer aqui,
devolva a embalagem. E aí está. Agora, o que podemos fazer é entrar em um hedge e executar o código Vamos fazer Zach e podemos ver que
a saída agora está mostrando bom dia e,
na verdade, está em maiúsculas Podemos ver
que agora está muito mais limpo e conciso agora que adicionamos
esse decorador Certo. É assim que
podemos criar um programa simples que converte a
saída da função em maiúsculas e minúsculas Assim, podemos ver onde é útil. Portanto, ele formata automaticamente texto sem alterar a função
original em si. Portanto, você pode ver que essa função
não foi alterada em nada. E, como podemos ver,
isso também pode ser muito útil se estivermos
exibindo títulos, mensagens ou qualquer tipo de entrada do
usuário de alguma forma
padrão, devo dizer? Ok. Então é assim que
podemos seguir em frente e fazer isso. Borda. Esse é um exemplo que podemos pegar uma cerca
e seguir. Tudo bem Vamos dar uma
olhada em outro exemplo. Agora, vamos continuar e
criar outro programa. Neste programa, o caso
de uso se concentrará em garantir que nossas senhas tenham pelo menos oito
caracteres. Agora, vamos definir uma
função simples para começar. Vou dizer, D, gerar senha de sublinhado como minha função básica nos dois pontos, e aqui vou
dizer return, Muito simples. Portanto,
isso seria visto como uma senha muito fraca
para começar. Não só é genérico
porque é ABC, mas também está no
lado negativo em termos de personagens Ok. Então, o que
faremos é dizer imprimir, e vamos apenas
imprimir essas funções específicas. Eu direi gerar, sublinhar senha, abrir
e fechar parênteses E se executarmos isso, ele
produzirá ABC, já que é isso que
estamos retornando nesta função. Certo. Então é assim que podemos seguir em frente e iniciar essa função. Agora, vamos continuar e tornar isso um
pouco mais complexo. Agora, para
verificar se uma senha está muito nítida e
garantir que a senha analisada
tenha pelo menos oito caracteres, precisaremos usar alguns módulos Então, vamos usar o módulo aleatório e
o módulo string. Portanto, até esse estágio,
ele deve ter bastante conhecimento dos módulos
e estar bastante confiante com eles Então, vamos
começar com isso. Eu diria importar aleatoriamente, e então podemos
dizer Importar string. Rico. Ok. Agora,
o que podemos fazer é definir nossa
função decoradora para começar Então, eu vou dizer uma senha surda e
forte com sublinhado. Eu vou passar pelo funk. E antes de podermos realmente
utilizar essa função, precisamos adicionar nosso
decorador e dizer, e será uma senha forte de
sublinhado Exatamente desse jeito. Rico. A próxima coisa que queremos fazer é definir nosso invólucro. Então, vamos dizer invólucro para surdos e podemos simplesmente
ajustá-lo assim Então, queremos chamar
nossa função original, que está aqui,
gerar senha. Então, para fazer isso, podemos simplesmente
dizer que senha é igual a funk e vamos atribuí-la
à variável Então, o que for retornado no resultado
aqui será ABC, que será
definido como a senha, que atualmente é ABC Em seguida, queremos definir um WLLoop para verificar se a
senha é muito curta e,
em seguida, queremos
executar uma ação Então, o que podemos fazer aqui
é dizer enquanto o comprimento. Então, vamos
usar a função ng para verificar o tamanho
da senha e se ela é menor que oito. O que eu quero fazer é
pegar minha senha. E então eu quero
incrementá-lo em um dígito aleatório a cada vez Vou usar o
módulo aleatório e dizer escolha de pontos. Lembre-se de que a escolha do ponto é uma, e vamos dizer
aqui os dígitos dos pontos da sequência Agora, os dígitos de pontos de string aqui
basicamente
vão para uma cobertura e
vão para esse valor, se eu
disser que dígitos de
pontos de string
serão de 0 a 9 serão de 0 dígitos de pontos de string são, obviamente, o dígito de zero a nove
em uma string inteira E essa
função de escolha aleatória de pontos aqui escolherá um dígito aleatório de 0 a 9 no formato de
string e o adicionará
à senha Teremos ABC, e então
podemos ter ABC dois. Isso vai
aumentar e ser executado novamente. Isso vai ser o ABC sete. Isso será incrementado e executado novamente e
será AB 274 assim, e
adicionará outro dígito A próxima coisa que
vamos querer
fazer é uma vez que isso avance e alcance
o limite superior aqui. Embora seja, como posso
dizer mais do que oito. Embora não seja mais
do que oito, ele quebrará o loop while e, em
seguida, podemos dizer return password e, em
seguida,
ele
retornará a senha final Depois de fazer isso, queremos
retornar essa
função modificada que temos. Para fazer isso, precisaríamos
dizer, no final, devolver o invólucro Ok, então
temos tudo definido agora Então, o que vamos
fazer agora é executar o código. E como podemos ver agora, temos essa saída,
que diz ABC 66507 Então, se pudermos contar isso,
temos quatro e temos quatro. Então, isso tem, é claro,
oito caracteres. Portanto, nossa senha agora está
um pouco mais segura. Não é perfeitamente seguro,
mas está muito melhor
do que era antes. E, como você pode ver
, adicionamos a funcionalidade para modificar
nossa função para que
possamos garantir que
nossas senhas tenham pelo
menos oito
caracteres e funcionem
bem como deveriam Podemos ver que incorporamos
tudo isso nessa função. Então, se eu apenas diminuísse
um pouco mais o zoom para que você possa ver o resultado geral que
temos aqui e a
saída que temos. Tudo bem Isso é tudo para
os exercícios sobre decoradores Espero que você esteja
ficando um pouco mais confiante e que
esteja integrando-o bem Analisamos
alguns exemplos. Podemos remover
isso e aí temos
decoradores em Bison
31. E/S de arquivos: Olá a todos, bem-vindos
à próxima lição, que será
focada na E/S de arquivos. Então, vamos começar. Então você provavelmente está
se perguntando o que significa IO no arquivo IO? Portanto, IO significa simplesmente entrada e saída. Daí a parte IO. Portanto, o arquivo IO se refere
ao processo de leitura e
gravação em arquivos. E isso permite que seu programa funcione como arquivos
em seu computador, e isso nos permite
abrir a gravação para leitura
e, em seguida, fechar
esses arquivos conforme necessário. Assim, em termos simples, ele permite trabalhar com
arquivos como ler textos de um arquivo ou
salvar dados em um. Ok, então vou
mostrar alguns trechos de código
de algumas das ações mais
populares
com gerenciamento de arquivos no Então, digamos que queremos
abrir um arquivo. Então, digamos que temos um arquivo
chamado person dot TXT. Então, o que
podemos fazer é definir uma variável, por exemplo, chamar arquivo de pessoa
e, em seguida, dizer igual, abrir
o arquivo TXT de pontos pessoais
e
associá-lo ao
nome da variável do arquivo pessoal e
associá-lo ao nome da variável do Então, digamos
que abrimos esse arquivo e agora
queremos ler esse arquivo. Então, o que podemos fazer é definir
outra variável chamada texto
e, em seguida, queremos
associá-la ao arquivo person, o
que, obviamente, é como
posso dizer que ele tem acesso ao arquivo person dot txt, já que abrimos anteriormente
no comando open file O que vamos
fazer agora é usar o método Red
para ler os primeiros cem caracteres
do arquivo TXT com pontos pessoais, e vamos imprimir esses primeiros cem caracteres na janela de saída
dizendo texto impresso Agora, não se preocupe se isso ainda
não faz sentido, vamos praticá-lo, mas eu só quero dar
uma visão geral para que você possa ter uma melhor compreensão
dos métodos usados e outros. Ok, agora, digamos que queremos
criar nosso próprio arquivo. Então, o processo para
fazer isso seria, obviamente,
definir uma variável A, para obviamente,
definir uma variável A, que
possamos dizer que
arquivo de carro é igual a aberto, e então você quer
especificar o ponto de carro TXT, e então você quer
especificar outro valor que é W. Então isso
vai significar escrever E isso também pode ser interpretado
como uma forma de criar. Então, escreva um arquivo, crie um arquivo, e isso
deve ser car dot TXT Agora, digamos que
criamos esse arquivo e agora queremos realmente
gravar no arquivo. Então,
usaríamos o método write. Então, nos referiríamos
à variável
que definimos anteriormente para
criar o arquivo, arquivo car. Então diremos não escreva, e aí podemos
dizer, por exemplo, que meus carros favoritos são um Ford e um hessla e isso será
gravado no arquivo E uma
coisa muito importante a ter em mente é que sempre que você estiver
gravando em um arquivo no PySon, você sempre precisa se certificar que, depois de gravar em
um arquivo, você o feche Está bem? Portanto, você precisa dizer car
file dot close no final, pelo
menos neste exemplo. Então, dot close é o
método que você precisa. Agora, há algo
no PySON conhecido como gerenciadores de
contexto em que isso é feito automaticamente para você, mas esse é um tópico que
abordaremos posteriormente no curso Mas, por enquanto, precisamos dizer
manualmente o ponto próximo. Agora, digamos que queremos
adicionar algo a esse arquivo. Não podemos dizer escrever novamente porque isso
substituirá o que
estava no arquivo Queremos adicionar ao arquivo, e esse será o próximo problema que precisamos resolver e,
para resolvê-lo, podemos resolvê-lo
anexando a um arquivo Basicamente, vamos
abrir o arquivo, como você pode ver aqui,
definimos nossa variável. Vamos utilizar
a função aberta. Em seguida, abriremos
o arquivo set, que será
cart txt é o primeiro, você pode dizer parâmetro
e depois vírgula e depois A. Isso
significa acrescentar Vamos
anexar a esse arquivo. Estamos abrindo o arquivo Set que
possamos
anexá-lo para que possamos adicioná-lo Então você pode seguir em frente
e dizer o ponto certo do carfle. Então, como você pode ver, eu
adiciono um espaço e digo, eu também gosto da Honda Isso será adicionado a esse arquivo específico com o código que
mostrei anteriormente, onde encaminhamos para o arquivo. Quando estamos escrevendo ou anexando
qualquer tipo de ação, precisamos dizer car
file close no final Portanto, lembre-se de enfatizar
o método de fechamento por pontos. Agora, digamos que temos uma quantidade excedente de arquivos e precisamos
começar a excluí-los Agora, para fazer isso, o que
você pode fazer é usar o módulo OS
que vem com o Python E o módulo do sistema operacional tem uma
função conhecida como remover, e tudo o que você precisa fazer é colocar no arquivo que
deseja excluir. Portanto, nesse caso,
podemos, por exemplo, excluir o
arquivo TXT com pontos do cartão apenas inserindo-o entre aspas
na função de remoção Então, é tão simples
quanto isso, é
assim que você também pode excluir
um arquivo. Tudo bem, pessoal. É isso em termos da visão geral
teórica da análise da entrada
e saída de arquivos no PySON Na próxima lição, vamos nos concentrar no exercício
prático de laboratório e vamos trabalhar na
prática de trabalhar com arquivos em PySON Tudo bem, pessoal. Isso é tudo
para a visão geral teórica.
32. Como realizar operações de arquivo: [Lab]: Todos, e bem-vindos ao
próximo exercício prático de laboratório, que será
focado em I/O de arquivos e PySON Vamos começar. Agora,
a primeira coisa que eu quero que você faça é
navegar para explorar aqui. Em nosso diretório,
queremos criar um arquivo TXT simples com pontos pessoais Vou navegar até
aqui e dizer novo arquivo, vou chamar
essa pessoa de dot TXT Aqui está meu arquivo TXT. O que eu posso fazer é
realmente adicionar alguns dados. Vou seguir em frente e
dizer: John, Smith, e vou colocar
uma data de nascimento,
por exemplo, digamos 12 oh 2-1990 Dois. Só um pouco
de informação aqui. Existem alguns dados,
pelo menos presenciais, dot TXT. Vamos para a torta de pontos principal agora
e o que vamos
querer fazer é abrir o TXT com pontos pessoais Podemos dizer arquivo pessoal,
que será uma variável, por exemplo, e vamos usar a
função open para abrir esse arquivo. Então, o nome desse
arquivo é person dot TXT. Então, eu vou dizer
person dot TXT, e isso abrirá
o arquivo para nós Então, agora que o arquivo está aberto, teoricamente falando,
precisamos realizar alguma ação Digamos que queremos
ler esse arquivo. Podemos então definir uma
variável chamada texto e queremos nos referir ao arquivo da
pessoa porque, de
acordo com essa variável, o valor aqui será o arquivo aberto. E o que queremos fazer com esse arquivo agora que ele está aberto? Queremos ler a partir dele, que
possamos usar o método
read e , em seguida, você deseja especificar
quantos caracteres do arquivo deseja ler. Eu sempre gosto de fazer
isso um pouco alto, então vou dizer 100
e isso será basicamente tudo
neste arquivo, então você pode ver que está quase
ocupando tudo. E então, como o que
foi lido em caracteres agora
está associado a ext e armazenado nele, podemos imprimir texto
para ver a saída. Então, eu vou dizer texto impresso. Então, agora, se eu executar o código, ele exibirá os primeiros 100 caracteres
desse arquivo. Agora, digamos que eu altere
a conta do arco aqui para apenas, digamos, cinco
caracteres e eu execute isso. Eu só vou
imprimir John. Claro, podemos ver que há um espaço lá quando eu destaco. Se eu dissesse 12, por exemplo, e corresse
, diria o traço de
John Smith Só chega a esse ponto. Você pode ver que pode limitar a quantidade de caracteres
que
deseja ler do seu próprio
programa. Ok, perfeito. É assim que podemos seguir em frente
e garantir isso. Então essa é a maneira básica de
abrir um arquivo que já existe e como você pode
ler a partir de um arquivo em si. Então, dominamos a abertura de um arquivo existente e a
leitura dele Agora, digamos que queremos
dar um passo adiante e queremos criar um
arquivo e gravar nele. O que vou fazer agora é
remover esse código e eu quero criar um arquivo. Para fazer isso, eu vou dizer car file como se minha variável fosse igual, e eu vou dizer open
eu vou dizer car dot TXT e depois na vírgula e eu vou dizer W. Como
eu quero criar um arquivo,
eu vou dizer W. Agora, antes que esse arquivo realmente
exista e seja criado, nós realmente precisamos escrever nele,
então precisamos escrever algo, mas esse é o primeiro passo para mas esse é criando seu arquivo,
teoricamente falando. A próxima coisa que precisamos fazer é
realmente gravar nesse arquivo, e então ele será
criado e aparecerá aqui em nosso diretório aqui
em nosso diretório base. O que você vai querer
fazer é dizer arquivo de carro, cachorro. Aqui entre
parênteses, podemos dizer que meus carros favoritos são
uma forja e um xadrez Então, queremos dizer arquivo do carro, fechar, e isso fechará o arquivo para nós. Agora, se executássemos nosso código, poderíamos ver que nada será gerado, mas se formos para o nosso diretório, você verá agora que
temos um arquivo TXT de carrinho que foi criado e temos algum texto nele porque
escrevemos no arquivo Podemos ver que escrevemos minhas cartas
favoritas, uma Ford e uma Tesla,
e podemos ver
que elas foram escritas
e, claro, esse arquivo
foi criado por si mesmo Não esperávamos nenhuma declaração de saída
impressa. É por isso que não havia nada aqui, mas precisávamos
executar nosso código para que
pudéssemos executar as
seguintes linhas de código. Mas podemos ver
que foi criado. carrinho TXT existe
agora. Certo, perfeito. Agora, digamos que você queira continuar lendo
agora do car dot TXT Você quer ler um
pouco desse arquivo. Então, vamos nos referir
ao que fizemos anteriormente. Então, deixe-me
continuar e só isso. Então, queremos
voltar a ler um arquivo. Então eu vou dizer que texto é igual, e vou dizer arquivo de
carro ponto vermelho E eu vou ler um
pouco desse arquivo. Então, eu vou dizer 15 caracteres. E eu vou dizer cheques impressos. Então, agora, se eu executar a saída, ela vai me
dar um código aqui para que você
possa ver que a operação IO
estava em um arquivo fechado. Portanto, lembre-se de que sempre que
estiver fechando um arquivo, você precisará reabri-lo novamente. Portanto, isso é algo
muito importante a se ter em
mente ao
trabalhar com seus arquivos. Então, o que você precisa fazer agora é abri-lo
antes de continuar. Assim, você pode definir sua
variável aqui novamente, arquivo de carro. É igual a abrir, e você quer
abrir o ponto TXT do carro, e agora você E agora, se você executar seu código, verá que
diz minha CA favorita. Está bem? Porque estamos
limitando apenas 15 caracteres, mas se eu aumentar um pouco
mais para 100, por exemplo, ele
imprimirá a linha inteira dizendo: “
Meus carros favoritos são a Ford”
e um teste, lembre-se disso Muito importante. É
por isso que os gerenciadores de contexto serão, como posso dizer,
muito mais úteis mais tarde. Então, isso é apenas algo que
eu queria mencionar
para que você esteja ciente de todo
esse processo. Portanto, lembre-se de que, depois de fechar, você não poderá realizar
uma ação até abri-la novamente. Muito importante. Eu queria demonstrar
isso para que você possa ver o que acontecerá
se você não fizer isso. Você vai se deparar com
um erro como eu mencionei. Depois de fechar, você
precisa abrir novamente. Certo. A próxima coisa que quero mostrar é como
você pode anexar a um arquivo Agora, digamos que já
temos o texto em car dot TXT. Meus carros favoritos são Ford e Chess e queremos
adicionar a este arquivo. Podemos usar append. O que você vai
querer fazer é apenas reestruturar um pouco seu
código aqui, para que possamos remover parte
do código antigo aqui E, claro, precisamos
abrir o arquivo, mas precisamos
abri-lo no apêndice Para fazer isso, precisamos adicionar
uma vírgula aqui e dizer, A, porque estamos dizendo ao
Pyson que queremos abrir esse arquivo e anexá-lo Agora, para acrescentar a ele, é claro, precisamos usar
o método certo novamente, mas nosso foco é anexá-lo
e não escrevê-lo Se eu disser arquivo do carro, escreva, OK. Entre aspas, preciso
adicionar um espaço e dizer, eu também gosto da Honda, por exemplo Então eu posso simplesmente dizer que o arquivo do
carro está fechado. Então, sempre que você estiver escrevendo,
você precisa fechar. Então essa é uma boa medida. Então, agora se eu seguir em frente e executar esse código, é
claro, nada
vai sair lá. Mas se eu for ao carro dox, você verá que ele acrescentou uma textura adicional que diz: “Eu também gosto da Honda Então é assim que você pode anexar a um arquivo que você já tem Ok, perfeito. É assim que você pode ir em frente e
configurá-lo adequadamente. Agora, você não pode continuar
e simplesmente dizer gravar um arquivo, caso contrário, ele removerá tudo o que está no seu arquivo e começará
do início. Deixe-me demonstrar. Se eu
substituísse
isso por W e dissesse, vou apenas
gravar no arquivo. Digamos, eu também gosto da Honda, ela vai substituir
tudo isso e
mostrar que eu também gosto da Honda Porque quando você estiver escrevendo
, será uma ruptura limpa. Uma caneta será adicionada a um arquivo. Nós, vai começar do
zero. Então, deixe-me te mostrar. Se eu correr agora e
for para Cardo txty, isso vai mostrar que
eu também gosto da É por isso que você
precisa
ter certeza de que tem o símbolo A, que é definido quando você
abre o arquivo para especificar o modo que
você pretende utilizar. Então, eles são conhecidos como moda. O W está no modo de escrita. A é o modo apêndice,
lembre-se disso. Temos dois arquivos aqui, mas eu só quero manter um. Quero manter o ponto TXT da pessoa, que eu possa remover o ponto TXT do carro Você provavelmente está se perguntando,
como eu faço isso? Muito simples. Você
só precisa dizer que importar sistema operacional e o módulo do sistema operacional tem uma função de remoção e
isso se aplica aos arquivos. Você pode dizer Os dot
remove e, em seguida, tudo o que você precisa fazer é colocar
o nome exato do arquivo
e, no nosso caso, é car dot
TXT, que podemos ver aqui Você pode dizer car dot TXT. E eu vou recomendar apenas
fechar esse arquivo por enquanto. E se você executar esse código, poderá acessar seu
explorador e ver que o cartão dot txt foi de
fato excluído Não existe mais. Desgraçado. Então aí está. É assim que você
pode entrar em um hedge e realizar E/S de arquivos básicos, seja,
entrada e saída de arquivos Então, você aprendeu agora como abrir arquivos,
ler arquivos, criar arquivos, gravar em arquivos, anexar a
um arquivo e excluir um Em
breve, entraremos em
mais detalhes em termos de
obtenção de metadados de arquivos Então, isso é algo que
abordaremos em breve. Certo. Agora, em termos
desse arquivo TXT com pontos pessoais, geralmente limpamos tudo após cada próximo tamanho prático, mas vamos fazer o
acompanhamento neste caso,
pela primeira vez Então, eu recomendaria
manter tudo como está. Teremos algumas visões gerais
teóricas no próximo conjunto de aulas
e, em seguida, voltaremos
para explorar um pouco
mais a fundo o tratamento de arquivos Tudo bem, então é isso por enquanto.
33. Obtendo metadados de arquivo: Olá a todos, bem-vindos
à próxima lição, que será focada
na obtenção de metadados de arquivos. Então, vamos dar uma olhada. OK. Agora, quando
estamos executando operações de entrada e saída de
arquivos como
já fizemos neste curso, talvez também
precisemos saber mais detalhes sobre o processamento e
detalhes mais precisos de um arquivo, conhecidos como metadados Agora, esses metadados podem
incluir o nome do arquivo, o estado de um arquivo, se ele está aberto ou fechado, e o modo em que
o arquivo está aberto Se estiver atualmente
no modo de gravação, se estiver no modo caneta, então A para o modo caneta, W para o modo de gravação, são algumas informações
que talvez precisemos saber, não necessariamente,
mas apenas algo que pode ser importante. Então, em qualquer caso,
isso é apenas uma visão geral teórica. Vamos nos aprofundar em algumas das opções em que
podemos nos aprofundar para obter
essas informações. Então, vamos mergulhar
nisso em apenas um momento.
34. Atributos para produzir metadados do arquivo - [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de laboratório, que se concentrará
na obtenção de metadados de arquivos. Agora, continuamos
de onde paramos, então ainda temos nosso arquivo TXT de pontos
pessoais que tínhamos antes e
temos nosso arquivo principal de pontos pi O que eu quero que
façamos é seguir em frente e abrir nosso arquivo no
modo, por exemplo. Eu vou dizer pessoa, arquivo é igual a abrir, e vou
abrir pessoa ponto E vamos definir isso
por enquanto no modo de gravação, então o modo será W. Ótimo. Vamos pegar algumas informações e eu também vou
produzi-las. Vou dizer imprimir e vou adicionar
algumas texturas, vou dizer nome O que eu quero fazer é
obter o nome do meu arquivo. Para fazer isso, posso simplesmente
dizer arquivo pessoal. Como atribuímos
essa variável ao valor aqui do conteúdo
do arquivo, posso então dizer nome do ponto. Agora, o nome do ponto aqui será um atributo
que estamos utilizando. Ok. A próxima coisa
que eu quero fazer é verificar se o arquivo está no estado de abertura ou fechamento, e isso retornará um valor Bool ou um
valor booleano Então, vou dizer imprimir e vou
verificar se está fechado. Eu vou dizer que está fechado. Ok, então na vírgula. Novamente, precisamos
referenciar o arquivo, então vou dizer person file dot, e o atributo para
isso seria fechado. Então, vamos
verificar se está fechado. E se estiver fechado, se
o arquivo estiver fechado aqui, ele retornará verdadeiro. Se não estiver fechado
, retornará falso. Então, estamos verificando
se está fechado, o que não está. Está aberto. A próxima coisa que queremos fazer é
verificar o modo. Então eu vou dizer
impressão, e aqui, eu vou dizer modo atual. Espaço, e precisamos nos
referir ao arquivo, ponto do arquivo
pessoal e
vamos dizer modo. Então, vamos seguir em frente e
prever o que teremos. O nome do arquivo aqui, estamos nos referindo ao
atributo do arquivo, que
será person dot TXT E vamos
verificar se está fechado. Podemos ver que a última coisa
que fizemos foi abri-lo. Dizer que está fechado
resultará em falso, então não será verdade. Então, temos o modo de ponto de
arquivo pessoal aqui. O modo atual é W para a direita. Vamos seguir em frente e executar esse código aqui, podemos ver que
o nome é pessoa, não TXT status fechado,
podemos ver que é falso e o modo atual é W. Mas vamos
mudar isso. Vamos ajustar o modo para A. Tudo bem. E
o que queremos fazer agora é
fechar o arquivo. Então, eu vou dizer
pessoa, arquivo, ponto, fechar. Então, vamos executar o código. E podemos ver que o nome aqui
é a pessoa que Dtxty está fechada, é verdade porque eu
fechei o arquivo utilizando
a mensagem E o modo atual é A
para acrescentar e o nome, é
claro, ainda
permanece o Portanto, isso é muito
útil se você quiser obter alguns metadados
de seus arquivos Portanto, ainda está
no nível superficial, mas é assim que você pode seguir em frente e referenciar de
acordo com vários atributos que estão disponíveis
para obter apenas alguns metadados em seus arquivos Então é isso para
este exercício de laboratório, muito simples e direto ao ponto. Vamos excluir arquivo para
que eu possa clicar com o botão direito do mouse. E exclua. Lá vamos nós. Certifique-se de que você ainda tenha
seu arquivo dot pi principal intacto e isso é tudo o que
precisamos por enquanto Isso é tudo para este exercício.
35. Parâmetros e argumentos: Olá a todos, bem-vindos
à próxima lição, que será focada
em parâmetros e argumentos. Então, vamos
começar. Certo, então parâmetros
e argumentos. Agora, um parâmetro pode ser visto
como um espaço reservado que definirá quais
entradas uma função espera Agora, por outro lado, argumentos são os valores reais que você passa para uma
função ao chamá-la. Então, vamos dar uma olhada em uma
analogia simples para que
possamos diferenciar
entre um parâmetro
e um argumento de forma mais Certo, então vamos dar uma
olhada. Agora, digamos que você esteja em um restaurante e o garçom ou garçom
venha até você e faça algumas perguntas sobre o que você gostaria de comer
no Então, ele pode fazer
algumas perguntas como o que você gostaria
para começar. Então ele pode perguntar: o que você gostaria de comer
no prato principal e se
gostaria de algum tipo de sobremesa
depois do prato principal. Então, digamos, por exemplo, que você esteja com muita fome e
diga ao garçom que
sim, eu gostaria que minha entrada fosse composta por
pão de alho Para o meu prato principal,
quero uma pizza
e, como sobremesa,
gostaria de tomar um sorvete. Vamos continuar e mergulhar mais fundo. Agora, neste exemplo específico, ao analisar
parâmetros e argumentos, você pode tratar os
parâmetros como, neste caso,
os espaços em branco em um formulário de
pedido, I E,
a entrada, o
prato principal, a sobremesa Então, nesse caso, eles
definem o que pode ser pedido, mas ainda não têm valores
específicos. Por outro lado,
com nossos argumentos, essas são as escolhas reais
que um cliente faz. Em outras palavras, pão de
alho, pizza, sorvete e estes
preenchem os espaços em branco ao
fazer o pedido É assim que você pode
diferenciar entre seus parâmetros e
seus argumentos Certo? Então, vamos aplicar isso em um
programa Python simples, por exemplo Então, usando exatamente o
mesmo exemplo aqui, por exemplo, como você pode ver, temos uma função e
nossos parâmetros que são colocados dentro dessa função entre os parênteses
incluem entrada, prato principal E isso vai definir quais entradas a
função espera Então, esses são os parâmetros. Então, como você pode ver, temos uma
instrução de impressão aqui que diz ordenada
e, em seguida, ela absorve os valores que serão vinculados
ao parâmetro inicial, ao parâmetro do curso principal
e ao parâmetro do deserto Isso vai gerar
um resultado específico. Agora, para chamar essa função, o que vamos fazer é referir ao nome da função
, que é colocar ordem. Então, entre parênteses,
o que vamos fazer é chamar a
função Esses são os valores
que basicamente serão vinculados
aos
parâmetros que temos. Aqui você pode ver
que temos pão de alho , pizza e
sorvete. Essencialmente, o que
vai acontecer agora é que vamos inserir valores, esses valores de argumentos,
onde estão nossos parâmetros. O pão de
alho vai substituir a entrada. pizza substituirá o prato
principal e nossa sobremesa, nesse caso,
tomaremos
sorvete alinhado com a sobremesa. Então, é claro, como
estamos chamando a função, ela executará o que definimos
na função. Nesse caso, a declaração
impressa vai aparecer no final, você pediu pão de alho. Pizza e sorvete para sobremesa. É assim que podemos
racionalizar por meio de uma analogia, como podemos usar parâmetros e argumentos
com nossas funções em Agora, vamos nos
aprofundar nisso sobre como você pode
utilizar funções
e como você pode utilizar mais
especificamente parâmetro
arguments,
devo dizer, em PySon De qualquer forma, essa é a essência para
que você tenha
uma ideia geral entre qual é a diferença
entre um parâmetro
e um argumento e em um contexto
36. Diferenciando entre parâmetros e argumentos - [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de
laboratório, que será focado
em parâmetros e argumentos. Portanto, neste exercício de laboratório, vou ensinar os fundamentos
dos
parâmetros e argumentos que você possa pelo menos entender a ideia geral
antes de nos
aprofundarmos nos parâmetros e argumentos
no próximo conjunto de Então, vamos começar. Ok, digamos, por exemplo, eu queira criar uma função
simples, que
eu queira criar uma função
simples,
focada em alguém pedindo um determinado conjunto de
alimentos em um restaurante Então, digamos que eles queiram almoçar e
decidam que eu quero uma entrada, um prato principal e uma sobremesa Vamos ver onde
podemos começar a partir daí. Então, a primeira coisa que normalmente
faríamos é definir nossa função. Então, vou dizer Dev e vou dizer
colocar ordem de sublinhado, e esse
será o nome da minha função E dentro da minha função dentro do parenessT para
ser mais específico, preciso definir Nesse caso, como
estamos comendo uma entrada, um prato principal e
uma sobremesa, isso seria apropriado
para os parâmetros Isso definirá
as entradas que nossa função esperará Então, vamos seguir em frente
e fazer exatamente isso. Teremos um motor de partida. Teremos o prato principal de
sublinhado e vamos comer a sobremesa Certo. Agora, uma vez que
tenhamos os valores associados conectados ao
prato principal inicial e à sobremesa, queremos gerar algum
tipo de funcionalidade Então, neste caso,
aqui, eu só quero imprimir o pedido em si. Então, aqui vou dizer print, e vou
dizer espaço ordenado, e vou usar concatenações de
strings, vou dizer mais, e vou
adicionar Então eu vou adicionar
uma vírgula e um espaço, e depois vamos adicionar
o prato principal, certo? E o que vou fazer
é diminuir um pouco o zoom aqui para maior clareza e, em seguida, adicionar minha vírgula, dizer
e espaço, e então eu vou comer uma sobremesa Muito simples. Eu só
ia dizer que pedi, vou dizer a
sobremesa, o prato principal
e, claro, o que
temos aqui. Ótimo. Agora, fora
dessa função ,
é claro que queremos chamá-la e executar essa linha de código. Então, o que vamos querer
fazer é chamar essa função
e, para fazer isso, você deve se referir ao nome
da função em si,
que é ordem de colocação. E aqui está entre parênteses que
você
chamará a função inserindo os
argumentos. Essencialmente, os argumentos
aqui serão substituídos quando você tiver
definido seus parâmetros Deixe-me seguir em frente e
dar um exemplo. Agora, se eu colocar uma mistura de alho
, coloco pizza E eu coloquei sorvete. Esses
serão meus argumentos e serão
inseridos adequadamente Pão de alho
no lugar da entrada, pizza no
lugar do prato principal O sorvete
substituirá a sobremesa. Então, você pode ver que
o seguinte terá
os valores de pão de alho, pizza e sorvete,
que serão
reduzidos para o que estiver
dentro da função aqui. entrada então
se tornará pão de alho, prato
principal se tornará pizza e o sorvete
se tornará sobremesa Esses valores serão
transmitidos para nossa função. E o resultado final
será que você pediu pão de
alho, pizza
e sorvete. Ok, então vamos seguir em frente
e executar esse código. OK. E aí você
pode ver a saída. Então você pediu pão de alho, pizza e sorvete. Tudo bem, então essa
é uma
maneira simples de você
ver praticamente a diferença entre parâmetros e argumentos
e como eles funcionam juntos. Tudo bem. Então aí está. Agora, digamos que queremos ir
um pouco mais no GitL. Então, a melhor
maneira é praticar um pouco mais, e vamos ver
outro exemplo. Então, deixe-me ampliar. E vamos continuar
trabalhando em um segundo exemplo. Tudo bem, então vamos
continuar e trabalhar com
nosso segundo exemplo. Então, novamente, eu vou
definir uma função, e isso vai ser chamado de morte e eu
vou dizer localização. Muito simples. Em seguida, vou
colocar em dois parâmetros. Então, ou seja, terei a cidade
e, em seguida, terei o
país como meus parâmetros. E aqui na minha declaração impressa, vou dizer impressa. Eu vou dizer que você é
de adicionar o espaço de dois pontos,
adicione, é claro,
um sinal positivo para concatenação de strings, eu direi cidade mais e depois vou adicionar um conjunto de aspas e,
em seguida
,
adicionarei dois pontos aqui, e então adiciono o espaço e, em seguida, a concatenação de strings para o país Agora eu precisaria
chamar a função, então eu diria localização. E com inferências,
adicionarei os argumentos. Aqui vou dizer que o
primeiro parâmetro estaria
no primeiro tipo de como posso dizer na primeira
definição que fazemos aqui. Vou dizer Cidade do Cabo
e, na minha vírgula, o
segundo argumento se
referirá ao país e será vinculado, e eu direi
à África do Sul Agora eu posso seguir em frente
e executar esse código. Como você pode ver,
diz que agora você é
da Cidade do Cabo, África do Sul O que eu posso fazer, na verdade, é
simplesmente me mover. Ok, vamos lá. Isso parece um pouco mais limpo. Ah, você também pode fazer isso, talvez
uma vírgula pareça mais bonita. Então, eu estou apenas fazendo
pequenos negócios aqui. Então, desculpe-me.
Você é da cozinha. Lá vamos nós. Muito mais limpo. Tudo bem. Então é assim que podemos integrar parâmetros e
argumentos de forma muito simples. Então, novamente, vou
reiterar o que
definimos aqui dentro de
nossos parênteses Está bem? Esses serão nossos parâmetros. Então, nossos parâmetros,
também podemos chamá-los dentro
da própria função. No entanto, o que precisaríamos
fazer é adicionar os argumentos
aqui que digamos,
substituirão nossos parâmetros em
nossas lentes de funções, que serão então
passadas para qualquer lógica que
tenhamos dentro da função
designada Certo, pessoal, isso é tudo para este exercício prático de laboratório
sobre parâmetros e argumentos.
37. Argumentos posicionais e de palavra-chave: Olá a todos, bem-vindos
à próxima lição, que será focada em argumentos
posicionais e de palavras-chave. Então, vamos dar uma olhada. Ok, então vamos diferenciar
entre os dois. Os argumentos posicionais são passados em uma ordem específica, com sua posição determinando a
qual parâmetro eles são atribuídos Agora, se você
mudar a ordem, isso
mudará o significado. Agora, também recebemos argumentos de
palavras-chave, e argumentos de palavras-chave usam
nomes para atribuir valores, então a ordem não importa. Então, vamos dar
uma
olhada em outra analogia
como exemplo
e, em seguida,
mostrarei como você pode aplicar argumentos posicionais
e de palavras-chave Então, vamos dar uma olhada. Tudo bem. Então, digamos que
queremos comprar um carro e vamos a
uma concessionária de carros, e digamos que queremos
comprar, sei lá,
um Ford, um Tesla ou um Mercedes Então, vamos à
concessionária de carros e nos encontramos com
uma concessionária de carros lá e estamos perguntando
sobre a compra de um Agora, depois de
conhecermos as pessoas, é
claro, vamos
nos fazer algumas perguntas. Ele vai nos perguntar qual
marca você gostaria? Qual modelo você também
gostaria e de que cor? Dizemos que eu gostaria de um Mercedes. Quero comprar a classe S
e ela precisa ser preta. Vamos ver como
aplicaríamos isso em um programa PySON de
uma forma muito simples Portanto, ao aplicar esse cenário
específico, podemos criar um programa da
seguinte forma , utilizando argumentos
posicionais Então, como você pode ver
aqui, estamos definindo nossa função que é de carro. Temos os parâmetros, marca, modelo e cor. E então nossa
instrução de impressão aqui para executar a função
dirá que você comprou A e,
em seguida, adicionaremos os valores de sage
associados a ela Agora, como podemos ver aqui, argumentos
posicionais, o que eu
mencionei antes,
a ordem é importante Então, como podemos ver aqui,
temos Mercedes, temos classe S
e temos preto Agora, a Mercedes
será substituída em marca, classe
S, em modelo
e preto em cor Então, no final,
vai dizer que você comprou e vai
dizer que você comprou um
Mercedes S class preto Ok, então é assim que vai funcionar no processo. Então você pode ver aqui os argumentos
posicionais, a ordem é importante porque
se você trocasse o Mercedes aqui pela
classe S e substituísse os dois, você obteria
a marca como classe S e obteria,
por exemplo, como posso dizer que
o modelo é por exemplo, como posso dizer que
o modelo Pode haver alguma confusão. Então, argumentos posicionais,
a posição importa. Então, a Mercedes, é claro, vai para a marca, a classe S para o
modelo e o preto para a cor OK. O que você define aqui foi concatenação de
strings,
isso é totalmente diferente Esse é um tipo diferente de caso de uso. Então isso realmente
não importa. Mas argumentos posicionais,
quais valores você coloca aqui são importantes
porque corresponderão
à ordem em que você
define seus parâmetros OK. Então, deixe-me mostrar outro exemplo para
solidificar esse conhecimento. Se mudássemos isso, usássemos o mesmo cenário e
usássemos argumentos de palavras-chave, você notaria aqui que temos uma pequena diferença. O modelo está configurado para a classe S, marca está configurada para Mercedes
e a cor está definida para preto Agora, neste caso,
você pode ver que eu mudei a ordem dos parâmetros, que diz marca, modelo e cor. Aqui, com os
argumentos que você pode ver, a ordem não importa,
porque o que estou fazendo aqui, estou definindo explicitamente o argumento
da palavra-chave dizendo: Ok, o modelo será uma classe S, a marca será Mercedes e a cor
será preta Ele assumirá
automaticamente os parâmetros. Como posso dizer de uma forma
muito gradual e dinâmica? Brand saberá automaticamente que
se trata de um Mercedes A cor
será automaticamente definida para preto e o modelo
será automaticamente definido para a classe S. Você pode ver aqui que, tecnicamente a ordem é diferente de certa forma, mas isso não importa porque
estamos atribuindo explicitamente os parâmetros, como podemos ver aqui, de acordo com Portanto, isso seria visto como argumentos de
palavras-chave em que
a ordem não importa. Ao contrário de antes, se
voltarmos, tínhamos
argumentos posicionais em que
os valores que você poderia dizer em código rígido ou a ordem no
padrão são importantes Portanto, lembre-se de que temos argumentos
posicionais e argumentos de palavras-chave.
OK. Então, isso é apenas algo que
eu queria mencionar e discutir com vocês em termos de
uma visão geral teórica. Vamos praticar isso nos exercícios práticos de
laboratório, então fique atento a isso
38. Argumentos posicionais e palavras-chave do mapa — [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de
laboratório, que se concentrará
na diferenciação entre argumentos
posicionais e de palavras-chave partir de uma perspectiva prática Agora, no exercício de
laboratório anterior, nos concentramos em entender o conceito central de
parâmetros e argumentos. Agora, indiretamente,
você deve ter notado que utilizamos argumentos
posicionais se você puder entender a lição anterior,
que foi sobre como obter que foi sobre como obter uma visão geral seriada sobre argumentos
posicionais posicionais Portanto, com argumentos posicionais, você insere os
argumentos diretamente ao chamar a
função S. Tudo bem Portanto, a primeira parte deste exercício será como
uma atividade de revisão porque você
entenderá a maneira padrão
pela qual
lidamos com
argumentos posicionais anteriormente De qualquer forma,
vamos começar. Vou criar uma
função e quero dizer que a pessoa
surda sublinha as informações. O nome da minha função será informações pessoais. Então eu quero
passar por alguns parâmetros. Vou ter, digamos,
nome , cidade e país. Esses serão meus parâmetros. Em seguida, quero definir uma declaração impressa e
vou dizer imprimir, e vou
começar dizendo, eu sou e vou dizer, vou dizer IM e depois
vou usar concatenação de
strings
e dizer Então, é claro, entre aspas, vou adicionar
um espaço e dizer, então você dirá IM
e, por exemplo, nor e eu sou de. E então o que eu posso fazer é
ir em frente e dizer mais, e então podemos dizer Siti plus, e então podemos ir
em frente e adicionar uma vírgula e Lá vamos nós. Então essa
será a declaração. Agora, precisaríamos
passar por alguns argumentos. Mas antes de tudo, precisamos
chamar nossa função, a primeira coisa que
precisaríamos fazer é dizer informações de sublinhado
da
pessoa, e isso é, obviamente, a função
que definimos aqui, o nome da função, e então
podemos passar nossos argumentos Ok, então primeiro,
eu vou ter o nome, então vai ser honra, cidade eu posso dizer Cidade do Cabo, e depois país, eu
vou dizer África do Sul Esses são vistos como meus argumentos
posicionais. Nome, cidade e país, como sabemos, são nossos parâmetros. Agora, com argumentos posicionais, a posição de seus
argumentos precisa
corresponder à ordem ou posição
de seus parâmetros Em outras palavras,
o nome, é claro, será substituído
no lugar da honra Nem vai ser nome, Capetown será cidade África do Sul será um país
e, em seguida, será utilizada
como o programa é em termos de
funcionalidade aqui
, onde absorverá os
valores que são passados para ela Agora, a coisa importante
que eu quero que você veja em todo
esse tipo de argumentos
posicionais de estruturas é que se você definir seus argumentos
posicionais aqui e
codificá-los, eles serão vinculados aos Então, veja dessa forma. O argumento um pertence ao parâmetro um. Argumento dois, parâmetro dois, argumento três, parâmetro três. Então, deixe-me prosseguir agora
e executar esta função. Vou chamar essa função.
Vai dizer, eu sou Ono, sou da Cidade do
Cabo, África do Sul. Como você pode ver, o resultado
será o
seguinte: o que eu
vou fazer, na verdade, é subir em uma cerca viva e
colocar um ponto final e
podemos colocar um ponto final espaço da Cidade do Cabo, lá Apenas a
mudança de pontuação aí. Tudo bem, lá
vamos nós. Agora, deixe-me, por exemplo, mudar alguma coisa. Se eu trocasse,
o primeiro valor aqui seria a Cidade do Cabo
e o segundo valor. Então, meu segundo argumento,
devo dizer não, e eu escrevo isso. Vai dizer que sou da Cidade do Cabo,
sou de Anno Então você pode ver o problema aqui. Então é por isso que
os argumentos posicionais são importantes, ok, porque você
pode ver, é claro, Capetown é o primeiro argumento, e agora pertence e está anexado ao primeiro
parâmetro que é o Arno, que é o segundo argumento
posicional pertence à cidade agora
e, claro, então a África e o
país ainda são os mesmos Mas em nossa
declaração impressa, você pode ver aqui a diferença de
que agora está dizendo que sou Cabo, sou de
Arno porque Arno está
tecnicamente ligado à cidade Arno porque Arno está
tecnicamente Você pode ver o problema aqui e por que é importante que, ao definir definir seus argumentos posicionais, a ordem
seja importante A ordem dos seus
argumentos precisa corresponder à ordem dos parâmetros
em sua função. Esse é um mergulho mais profundo nos argumentos
posicionais. Agora eu quero movê-lo de volta. E nós podemos fazer isso. Lá vamos nós. Eu sou Ano. Sou da Cidade do
Cabo, África do Sul Perfeito. Argumentos posicionais Agora, digamos que queremos usar o
argumento de palavra-chave. Ao contrário dos argumentos posicionais
em que a ordem é importante, os argumentos de
palavra-chave não O que você faria
essencialmente aqui é que,
ao definir
seus argumentos, você pode atribuí-los diretamente aos seus
parâmetros aqui. Portanto, temos nome,
cidade e país, mas podemos
atribuí-los aqui diretamente. E nesse caso,
a ordem não importará. Portanto, não importa se eu
fosse trocar o primeiro
argumento aqui
por, por exemplo,
Cape
Down, segundo Anno,
e deixar o *** da África,
isso não importaria
porque você
atribuirá os parâmetros
aqui de antemão trocar o primeiro
argumento aqui
por, por exemplo,
Cape Down, segundo Anno, e deixar o *** da África, isso não importaria
porque você
atribuirá os parâmetros
aqui de antemão atribuirá os parâmetros
aqui Portanto, a ordem aqui não terá
nenhuma consequência. Deixe-me mostrar o que
quero dizer com isso. Se eu apenas
diminuísse o zoom por enquanto e me deixasse configurá-lo da seguinte maneira. Anno, é claro,
será o nome. Posso dizer que nome é igual,
e depois Arno. Então, é claro,
teremos a Cidade do Cabo. Precisamos dizer que cidade é igual à Cidade
do Cabo e à África do Sul. Podemos dizer que país é
igual à África do Sul. Ok. Agora, se eu
executasse esse código agora e executasse, como podemos ver aqui,
ele diria, não, sou da
Cidade do Cabo, África do Sul. Funciona exatamente
como deveria ser. É assim que você pode
alterná-lo com argumentos de palavras-chave, mas na verdade não estamos vendo a diferença
aqui como ordem, não importa
porque, tecnicamente, pode-se argumentar que Ono está
aqui e esse é o nome, Capetown é o segundo argumento
e, portanto, a África em terceiro lugar e está
separada pelo comércio Isso é o que se poderia argumentar. Mas deixe-me te mostrar uma coisa. Deixe-me mudar agora de
cidade em primeiro lugar da
discussão. Deixe-me fazer isso. Ok, deixe-me remover isso
e apenas trocá-lo. Agora, tecnicamente falando,
você pensaria que, em primeiro
lugar, a Cidade do
Cabo deveria ser o nome A segunda aqui é não e
isso deve estar na configuração. Tecnicamente, as posições
estavam em ordem. Mas neste caso, ainda
vai funcionar como deveria. Se eu executar o código, ele ainda
vai dizer, eu sou Arno. Eu sou da Cidade do Cabo, África do Sul. Embora tecnicamente
tenhamos trocado o pedido, você pode ver que o pedido
não importa em Então, estamos definindo os valores dos
parâmetros em si. Em vez de substituir
diretamente os parâmetros definidos
na função, estamos declarando o
valor com antecedência Portanto, o parâmetro procurará automaticamente
o que foi definido aqui neste argumento
nesta chamada de argumento
que estamos configurando. Então é assim que
podemos seguir em frente e definir seus argumentos de palavra-chave. Portanto, o pedido não
importará. Ok. Agora, eu não mencionei isso em detalhes estritos nas palestras
teóricas, então você provavelmente está
se perguntando: Ok, temos países iguais,
nomes iguais e cidades iguais Então, como chamamos isso em
Como chamamos isso em Payson? Porque sabemos que África
do Sul, Arno e Cidade do Cabo são essencialmente o argumento, mas como
chamamos o resto Agora, não há um termo
real em pyson para essas formas de declaração Ok, então não há
um nome real para isso. Mas o nome mais próximo que
seria o mais preciso seria digitado nos nomes dos
seus parâmetros Portanto, temos cidade igual,
nome igual, país igual. Então você pode chamar esses nomes de
parâmetros, ok, que é essencialmente o que você
tem aqui. Então é assim que você
pode realmente chamá-lo diretamente. Você também pode se referir a
eles como rótulos de parâmetros. Esse é outro termo que
eu também ouvi antes. Então,
depende de nós como você
deseja reformulá-lo Mas os nomes dos parâmetros
estão bem claros aqui. E tudo o que você pode realmente
ver aqui é que você está associando
estritamente seu
parâmetro aos seus argumentos É assim que você pode
ver o que está fazendo aqui
com argumentos de palavras-chave. Ok. Então, sim, é assim que
podemos utilizar argumentos posicionais
e de palavras-chave Ok. Então, o que eu vou fazer também
é mudar isso. Vou mudar o país para cá e vou movê-lo
para
a frente agora, só para
mostrar a diferença aqui. Então, se eu executar o código, ainda
vou executar o mesmo. Mas agora,
deixe-me mudar isso, e não vamos mais
configurar isso como argumentos de palavras-chave. Está bem? Agora vamos
defini-lo como argumentos posicionais Portanto, lembre-se do formato
nesse formato aqui, eles são vistos como argumentos de
palavras-chave. Se apenas
adicionássemos os valores como estão,
isso seria visto como argumentos
posicionais Portanto, lembre-se da estrutura
entre os dois. Agora, se eu executar meu código aqui, vai ficar tudo louco aqui porque a
África do Sul tem nome, Cidade
do Cabo é a cidade e
nu é o país. Ok, então argumentos posicionais
e de palavras-chave. Agora, o que eu quero que façamos
é seguir em frente e trabalhar em outro exemplo apenas para
praticar, para que possamos ter uma ideia melhor dos argumentos posicionais
e de palavras-chave Tudo bem, então vamos continuar e
praticar um pouco mais. Ok. Então, vamos começar
com a função que se
concentrará em argumentos
posicionais e depois trabalharemos em argumentos de
palavras-chave Ok. Então eu vou dizer Def, e essa vai
ser uma função chamada assistir filme com sublinhado
. Muito simples. Serão necessários
dois parâmetros. Primeiro teremos o nome do filme. Então eu vou dizer filme, e depois vou dizer
a pessoa. Então, com quem eu estou assistindo o
filme no meu cólon, e então eu vou dizer Print Fui assistir e depois espaço, e vou adicionar o plus, e depois vou
ter o filme, espaço, e depois vou dizer whiz and plus e depois
teremos pessoa Ok. Então aí está, então eu vou ter uma inteligência como essa Talvez eu o ajuste. Fui
assistir, você pode dizer, por exemplo, Star Wars com
Jane. Simplesmente muito simples. Em seguida, vou chamar
essa função, e vou dizer assista ao filme de
sublinhado e aos argumentos
posicionais Primeiro, vou
ter o nome do filme. Então, aqui vou
dizer Star Wars. Segundo argumento, vou
dizer Jane. Muito simples. Então, deve seguir em frente
e passar as estrelas para o cinema, Jane para a pessoa. Então
, vai para a impressora. Fui assistir Star
Wars com a Jane. Então, vamos seguir em frente
e executar esse código. Às vezes, só
precisamos executá-lo novamente. Lá vamos nós. Fui
assistir Star Wars com a Jane. E isso produzirá isso para você adequadamente, assim. Ok, então esses são argumentos
posicionais. Agora, digamos que eu
mudasse de posição, digamos Jane, Star Balls, e eu acidentalmente cometesse um
erro e executasse esse programa Eu vou dizer que fui
assistir Jane with Stars. Isso não faz sentido. Então, como o argumento de palavra-chave pode
resolver esse problema para nós? Agora, se codificarmos dessa forma, não
precisaremos alterá-lo. Podemos simplesmente usar um argumento de
palavra-chave. Portanto, consulte o nome do parâmetro. Então diga explicitamente:
Ok, a pessoa é Jane. E filme é igual a Star Wars. Agora, dessa forma, se
eu executar o código, deixe-me salvar se eu executá-lo, eu fui para
Starwars com Jane Dessa forma, isso o ajudará
a resolver qualquer tipo de problema que você possa ter com o argumento posicional, e você pode simplesmente se ajustar sem precisar fazer uma alteração
significativa aqui Então,
esse ajuste será feito. Então, agora nós o substituímos por argumentos de palavras-chave. Agora, embora
eu tenha mencionado anteriormente que podemos
chamá-los
de nossos nomes de parâmetros, outro motivo que
eu também quero adicionar
a esse processo
aqui, conhecido como argumentos de
palavras-chave, é
que você também pode tratar esses
nomes de parâmetros aqui que estão sendo declarados como palavras-chave. É também por isso que, em Python, eles chamam isso de argumentos de palavras-chave Portanto, lembre-se de
que a razão pela qual eu não quero me concentrar
muito em chamar essas palavras-chave é porque elas são essencialmente
nossos parâmetros aqui. Ok, então eu só quero
que você mantenha uma boa mente aberta e uma perspectiva sobre a lógica
e a formatação aqui Portanto, a melhor maneira de realmente solidificar seu conhecimento aqui
é examinar o formato Se você estiver definindo os nomes dos parâmetros e
dizendo que é igual a um argumento, significa
que isso é
visto como argumentos de palavra-chave Se você adicionar argumentos diretamente
para codificar valores, serão
argumentos posicionais. Tudo bem, pessoal Então, eu sei que foi um
pouco detalhado, mas eu só
queria me
aprofundar um pouco mais para que você
entenda o processo. Agora, vou fazer
um exercício de laboratório bônus, mas ela vai se
concentrar em misturar tipos de argumentos. Então, isso vai
ser puramente prático. Não vamos analisar
o lado teórico porque abordamos
isso tecnicamente Então, acho que é melhor
que você aprenda
visualmente como misturar tipos de
argumentos. Então,
esse será um
próximo exercício opcional que
faremos. Então, eu não vou remover o
código nem nada ainda. Isso deve ser continuado. Mas se você quiser
seguir em frente e pular para a próxima aula
oficial, que será sobre
argumentos padrão, você pode fazer isso Então, é apenas algo que eu
queria mencionar para que
você esteja ciente disso. Então, para aqueles que querem aprender mais sobre como misturar tipos de argumentos, será uma lição única, mas não será
tão formal. Você pode
continuar comigo do jeito que está. Caso contrário, você pode simplesmente excluir
o código que você tem e passar para a
próxima aula oficial
39. Misturando tipos de argumentos — [Laboratório opcional]: Oi, todo mundo. Bem-vindo ao
próximo exercício prático de laboratório, que será uma aula bônus
opcional que você poderá ver, e basicamente
aprenderemos como misturar tipos de
argumentos. Neste exemplo,
vamos misturar nossos argumentos posicionais e argumentos palavras-chave quando
estamos chamando uma função
específica De onde paramos foi como podemos
mapear argumentos posicionais e de
palavras-chave Desta vez, vou
mostrar como você pode misturar e combinar os dois. No entanto, há um conjunto de regras que você
precisará seguir e tal. Ok, então vamos começar com o exemplo anterior
e de onde paramos pela última vez. Como você pode ver aqui, eu tenho
essa função que diz, eu fui assistir, e então ela vai dizer
o filme e a pessoa. Agora, se eu publicar esse código, vai dizer que
fui em direção às estrelas com Jane Agora, as posições aqui. Então, como podemos ver,
temos Jane e Starwars, e o parâmetro é pessoa
esperada, primeiro filme e depois O motivo pelo qual esse
código funciona é porque estamos usando
argumentos de palavras-chave e declarando
explicitamente o nome
do parâmetro e atribuindo o Esse é o uso de argumentos de palavras-chave
no formato das coisas. Agora, se eu removesse esses argumentos de palavras-chave e os substituísse pelos argumentos
posicionais brutos, em outras palavras, se eu dissesse
pedras e, digamos , Jane, e executasse o código Fui assistir Jane with Sows, o que não faz sentido porque agora a
funcionalidade padrão de argumentos posicionais está em vigor Então Jane vai ao cinema e
Stows vai pessoalmente. Ok, então essa foi a
razão pela qual
usamos nossos
argumentos de palavras-chave para alterá-los e enviamos a pessoa Ok, como Jane e depois um
filme como Star Wars. E então, quando executarmos isso, isso será corrigido para nós porque os argumentos da palavra-chave se ajustam e atribuem o valor
aqui diretamente para nós, então ele se
ajustará bem e procurará o nome do parâmetro onde foi definido o
argumento nessa chamada de função, onde especificamos os Agora, também podemos
misturar os tempos de discussão, o que não é algo que
eu recomendaria que você fizesse. Eu recomendo que você se
atenha aos argumentos
posicionais ou aos argumentos de
palavras-chave como estão Mas também é bom ter uma maior noção de
funcionalidade adicional. Ok. Agora,
infelizmente, existem regras para isso. Agora, a ideia de todo
o argumento posicional e dos argumentos de palavra-chave é que você só pode
fazer isso de determinadas maneiras Se, por exemplo, aqui eu
mudasse uma das opções aqui, um desses
argumentos de palavra-chave para posicional, funcionaria
em alguns casos, em alguns casos, não
funcionaria Como sabemos agora, a
pessoa está vinculada
ao segundo parâmetro aqui e o filme está vinculado
ao primeiro parâmetro. Se eu removesse o argumento
da palavra-chave. No segundo, como posso dizer estado
no segundo conjunto? Você pode ver que
haverá um erro que diz que posicional não pode
aparecer após o argumento da palavra-chave Agora temos esse argumento de
palavra-chave aqui e temos esse argumento
posicional,
então você nunca pode ter
um argumento então você nunca pode ter posicional
após um argumento de palavra-chave Você sempre precisará
ter pelo menos seus
argumentos posicionais primeiro
e, mais tarde, poderá
ter seus argumentos de palavra-chave Ok. Agora, outra coisa que
quero mencionar é se você fez o
contrário e digamos que eu
troquei isso por, é
claro, era filme,
igual a teles, tudo Agora deixe-me fazer o que
ele disse antes. Agora eu vou ter Jane,
por exemplo, esse é meu argumento
posicional,
e então eu tenho meu argumento de
palavra-chave Agora, tecnicamente
falando, você diria que isso funciona perfeitamente bem Isso é o que se poderia supor. Mas se prosseguirmos,
salvarmos e
executarmos esse código, receberemos um erro
dizendo que Watch movie tem vários valores para
argumento de filme. Esse é o problema que estamos tendo. Agora, aqui está a
razão para isso. Aqui temos Jane e Jane
está seguindo, é claro, a regra do argumento posicional, que será
atribuída ao filme, mas também temos filme aqui Precisamos atribuir
algo à pessoa. É aí que todo o
truque nessa área começa. Ok. Então, para você
misturar efetivamente esses tempos de discussão, você precisa fazer algumas
manobras aqui Então, a primeira regra
que mencionei é que seus argumentos posicionais,
ok, devem sempre ser os primeiros, e então você pode usar
um argumento de palavra-chave E em segundo lugar, você precisa observar o que estava
atribuindo aqui O que teremos que
fazer nessa situação é mudar o que tínhamos antes
e fazer com que faça sentido. Então, aqui precisaríamos
dizer Star Wars, para que satisfaça o filme primeiro E então, aqui,
vamos querer alterá-lo para
o nome da pessoa. E precisamos definir isso como
pessoa para que seja
ajustado aqui adequadamente. Agora, se eu fosse salvar
isso e executar meu código, ele diz: “Fui até as
barracas com J. Ok?” Agora, é assim
que você integraria os dois tipos de argumentos. Então, as barracas vão ao cinema
e a pessoa vai ao J. E é assim que esse
processo funcionaria Está bem? Agora, algo que
eu quero mencionar aqui
no resultado aqui é que você sempre
terá que seguir seus argumentos
dessa forma se quiser
integrar os dois. Então, vamos continuar e trabalhar em outro exemplo
completamente diferente. Deixe-me prosseguir e
remover esse código. Certo. Então, vamos continuar
com o próximo exemplo. Ok, então digamos que eu defina uma função
chamada sequência. Eu digo De sequence. Eu tenho A, B e C. Eu posso então simplesmente imprimir os valores associados na instrução de impressão e dizer,
A, B, C. Então eu quero
chamar a sequência da função, eu
possa dizer sequência. Então eu posso
passar por algum vale. Vamos fazer uma verificação simples aqui. Eu quero dizer um, dois, três. Aqui estou usando argumentos
posicionais. Deixe-me salvar e executar esse código. Saídas um, dois e três. Agora, deixe-me prosseguir e trocar isso por argumentos de
palavras-chave agora. Vou simplesmente
trocar as posições. Vou continuar e dizer,
digamos, A é igual a dois,
C é igual a três
e B é igual a um C é igual a três
e B é igual Salve Zach, runach,
eu tenho dois, um, três porque podemos ver que A, claro,
será B será um
e C é igual a três, e a ordem aqui
é A, B e C, será dois, como
você pode ver, um e Aí temos os argumentos da
palavra-chave. Vamos
colocar isso de volta na posição um, dois, três. Vamos ver como podemos misturar
esses tempos de discussão. Com as regras que
mencionei antes, lembre-se você não pode ter um argumento de
palavra-chave na frente de um posicional Se eu definir isso como A igual a um, veremos que dois e três
terão um problema porque argumentos
posicionais não podem
aparecer após os argumentos aparecer após Lembre-se de que você não pode ter esses
argumentos de palavra-chave primeiro, sempre posicionais,
sempre posicionais Portanto, precisamos ter um como
argumento posicional. Então, o que podemos fazer é definir
tecnicamente B igual a dois, mas então temos que
fazer C igual a três, porque não podemos ter o argumento
posicional sozinho posicional Então, se eu fosse executar
isso, seria a mesma coisa e essa é uma maneira pela qual podemos misturar nossos tempos de discussão. Mas você notará aqui que,
fazendo isso um pouco, como posso dizer desnecessário? Porque você está adicionando código
extra para algo que você pode conseguir
com argumentos posicionais Porque tecnicamente, um, dois e três já
correspondiam ao pedido Se você simplesmente os removesse, teria
obtido o resultado desejado. Você está apenas adicionando um código extra aqui, onde isso não está
realmente ajudando você. Então, se você colocar B e C, é apenas um código extra e tecnicamente está
na mesma ordem A única utilidade
na fase de argumentação de palavras-chave é se você quiser
trocá-las. Então, tecnicamente, você pode
prosseguir e mudar o valor. Sabemos que C é igual a três
e B é igual a dois. O que você pode fazer tecnicamente
é simplesmente mudar a ordem . Exatamente desse jeito. Então, se você executá-lo, é claro, obterá um,
dois e três novamente. Então você ainda está seguindo
as mesmas regras que
foram mencionadas. Está bem? Certo, pessoal. Então, é isso neste exercício de laboratório extra
prático sobre como você pode seguir em frente e misturar seus
tipos de argumentos. Certo, pessoal. Então é isso.
40. Argumentos padrão: Olá a todos, bem-vindos
à próxima lição, que será focada
no argumento padrão. Então, vamos dar uma olhada. Tudo bem, então você
provavelmente está se perguntando:
Ok, o que diabos é
um argumento padrão? Portanto, um argumento padrão é um parâmetro com um valor
predefinido em uma definição de função que é usado quando nenhum valor é fornecido
durante a chamada da função Agora, eu sei que os sons um pouco confusos,
mas não se preocupe Eu prometo, isso
vai fazer sentido. Agora, uma coisa importante a
saber é que os argumentos padrão devem ser colocados no final da lista
de parâmetros, o que significa que você não pode ter
um argumento padrão e depois ter seus
parâmetros regulares. Deve estar sempre de acordo
com seus parâmetros regulares. Em outras palavras, sua lista de
parâmetros. Agora, isso fará
mais sentido quando trabalharmos nos exercícios
práticos, então não se preocupe com
isso ainda. Ok, então vamos
dar uma olhada em um exemplo simples. Novamente, vamos nos referir a um exemplo típico aqui
de alguém comprando um carro. Teremos uma função aqui
que diz comprar carro e que incluirá
os seguintes parâmetros. Temos marca, modelo
e, em seguida, temos um argumento
padrão
, conhecido como
cor igual OK. Agora, se você der uma olhada na função
que está sendo Cladie, estamos chamando a
função e
inserindo apenas dois argumentos
em Então, estamos adicionando a Mercedes, que substituirá o parâmetro da
marca, e a classe S, que substituirá
o parâmetro do modelo E em vez de adicionar um argumento SRD para referenciar
a cor diretamente, estamos utilizando um argumento padrão que atribuímos,
que é definir
a cor Agora, esse resultado
produzirá
a seguinte declaração
com a declaração
impressa que diz: Você comprou um
Mercedes S class preto Portanto, essa é uma maneira
pela qual você pode utilizar um
argumento padrão no sentido de omitir o argumento direto
que você define na
função que está
chamando e, em vez disso, apenas configurá-lo no nível do
parâmetro que você pode Então você define isso como
um argumento padrão. OK. Certo. Agora, algo
que eu também quero mencionar, é muito semelhante a
um argumento de palavra-chave. É meio que
invertido, você poderia dizer. Então, em vez de tê-lo
na chamada da função, você o tem em sua lista de parâmetros
regulares entre parênteses
da própria Então, apenas uma maneira rápida de referenciá-lo para tentar
entendê-lo melhor. Então, isso é chamado de argumento
padrão em si. No momento, outra situação
que quero mostrar é o que acontece
se, por exemplo, você tiver seu
argumento padrão como antes, mas alterar
sua chamada de função para incluir a lista de argumentos. Então você tem Mercedes, você tem classe S
e você tem vermelho Então, agora, tecnicamente falando, você não
precisaria
realmente desse argumento padrão, que é cor igual a
preto, porque você tem um conjunto completo de argumentos em
sua função de chamada aqui e seus
parâmetros Você provavelmente vai dizer, Ok,
o que vai acontecer agora? Haverá um conflito? Haverá um erro? Bem, o resultado é o seguinte, vai aparecer no código, você comprou um
Mercedes a class vermelho Agora, o argumento
que você define que estava em sua
função de chamada basicamente substituirá ou
substituirá o
argumento padrão que você especifica junto com seus
parâmetros na lista de parâmetros É muito
importante
ter em mente que , ao trabalhar
com seus argumentos
padrão há uma preferência
disponível aqui que será utilizada Tudo bem, pessoal. Digamos que, no lado teórico
dos argumentos padrão, entraremos em mais detalhes, e há
mais algumas coisas que eu gostaria mencionar em termos
do parâmetro,
menos do que onde você pode definir argumentos
padrão e se há algum tipo de ordem ou preferência que
você precisa seguir. Mas essa é a parte principal que
acabei de abordar em termos do núcleo principal em termos de teoria dos argumentos
padrão.
41. Trabalhando com argumentos padrão — [Lab]: Olá a todos, bem-vindos ao próximo exercício prático de
laboratório, que será
focado em argumentos padrão. Então, vamos começar. Então, vamos definir nossas funções. Vou dizer Df por carro sublinhado. Então eu quero
passar pelos meus parâmetros. Então eu vou
dizer marca, modelo. E, por enquanto,
vou manter as coisas simples. Ainda não vou usar um argumento
padrão .
Eu vou dizer cor. Então, o que vou fazer
é dizer imprimir, e vou dizer “ou
A”, e depois vou dizer “mais”. Está adicionando a cor aqui
e nas aspas mais. Então eu quero adicionar
ramificação mais espaço, e podemos então adicionar o
modelo no final. Lá vamos nós. Então eu quero
chamar a função. Vou dizer
por sublinhado, e quero passar pelo
seguinte argumento Eu vou ter Mercedes
e depois vou ter classe
S e depois
vou ter preto Nós temos esse conjunto. Vamos
executar nosso código agora. Diz: Você comprou um Mercedes S class
preto. Mercedes escolheu a marca, classe
S para o modelo, o
preto para o colorido, e depois os incluímos
em nossa declaração impressa OK. Perfeito. Portanto, temos uma função padrão com os
argumentos e parâmetros posicionais regulares Agora vamos ver onde um
argumento padrão pode se tornar útil. Então, digamos que você não queira declarar explicitamente
um argumento aqui Foi na sua função que você está ligando. Você
pode simplesmente remover isso. O que você pode então usar
é um argumento padrão e você pode
simplesmente dizer que a cor é igual
e, entre aspas, você
pode dizer preto Agora, se você
executasse seu código, agora
ele dirá, ainda assim, que você comprou um
Mercedes a class preto É assim que você pode usar
um argumento padrão. Você pode simplesmente seguir em frente e configurar o seguinte,
como você pode ver. Tudo o que você está fazendo aqui é
basicamente especificar explicitamente seu parâmetro aqui na lista
de parâmetros dessa função Agora, isso pode ser
útil, por exemplo, se você não tem um argumento específico que
deseja passar por sua função gesto
e, entretanto, concorda com um valor padrão OK. Agora, a coisa
útil que você deve ter em
mente aqui é que, se você fornecer um argumento em si
na chamada da função, ainda
poderá manter
seu argumento padrão aqui sem que ocorra nenhum tipo
de conflito. Então, se eu
colocasse explicitamente o argumento para
o terceiro parâmetro, que é tecnicamente cor, embora já tenha
sido atribuído Se eu fosse rodar
isso, diria
Mercedes S class vermelha Agora, a razão para isso é que qualquer argumento
definido na função qual substituirá qualquer argumento
padrão definido
aqui nessa
lista de parâmetros, devo dizer Então, isso é algo
importante que você ter em mente ao
trabalhar com isso. Agora, outra coisa que eu também
quero mencionar são as regras de colocar argumentos padrão no final da lista de
parâmetros. Então é mais ou menos isso
que eu quero dizer com isso. Se eu fosse continuar e
digamos que eu definisse isso como preto e removesse esse argumento
padrão, não poderia, no início aqui, por exemplo, da lista de
parâmetros, dizer marca
e, se eu
dissesse ,
digamos , mais SDs Então, isso vai se
deparar com um problema. Então você pode ver se eu passar o mouse sobre o parâmetro aqui
no modelo aqui, ele diz argumentos não padrão, não padrão
segue argumento padrão Então, o que você pode ver
aqui é que você tem um parâmetro regular ou argumento
não padrão que segue um argumento padrão. Então você não pode ter
isso no pedido, mesmo que se executássemos
esse código,
ok, tecnicamente ainda mostraria a
Mercedes E se eu colocasse esse Ford, por exemplo, apenas como um teste simples para o argumento
padrão, ele não funcionaria. Como
posso dizer que ainda
persisto
em dizer Mercedes,
mesmo que tenhamos definido
um argumento padrão, como
mencionei antes,
você não pode colocar esse argumento padrão na frente de nenhum outro. Como posso dizer que o
argumento está em Vou te mostrar uma
maneira pela qual isso funcionará. Portanto, é muito parecido
com se você assistisse ao exercício prático de laboratório e continuasse
misturando os tipos de argumentos, você pode ter algo semelhante aqui com
seus parâmetros. Então, vou te mostrar
o que quero dizer com isso. Se eu voltasse
para a marca, temos a cor e a
executamos. Está bem? Isso é bom. O que você pode fazer é
definir argumentos padrão. Está bem? Se você estiver
trabalhando com, como posso dizer qualquer coisa depois do seu parâmetro
inicial. Portanto, você deve se certificar de
que sempre tenha seu primeiro parâmetro para não ter
um argumento padrão. Você não deve começar com um argumento padrão
ao
configurar seu. Como posso
dizer seus parâmetros A menos que você esteja trabalhando apenas
com um parâmetro. Mas se você estiver trabalhando
com vários, não funcionará muito bem. Tudo bem. Então, deixe-me
mostrar o que quero dizer. Portanto, podemos definir os padrões aqui, para que eu possa definir a cor para crista
e o modelo para a classe F. E eu posso remover
esses argumentos, salvar o código e executá-lo. Eu vou dizer que você comprou
um Mercedes F class vermelho. Então, aqui está usando
argumentos padrão, como você pode ver, e está apenas
substituindo-os, como você pode ver e obtendo todos os
valores necessários e Ok, então é assim que podemos usar argumentos
padrão. Agora, eu só quero te mostrar mais
algumas coisas extras. Então, vamos seguir em frente e fazer isso. Digamos que eu defina
outra função, vou dizer morte
e vou dizer pessoa, e ela só vai receber um parâmetro que é nome. Eu só vou
dizer nome impresso. Eu quero chamar a
função e ela diz não. Então, isso é muito simples
para a função, vamos executar o código.
A saída não Agora, o que eu posso fazer é definir um
argumento padrão aqui para dizer, eu só vou dizer John. E antes que eu possa realmente colocar meu, vou colocar
John Dove, na verdade E digamos que eu não acrescente um argumento específico
aqui na chamada. Vai produzir John Doe. Portanto, nesse caso,
funcionará ter um argumento padrão
aqui em vigor. Está bem? Mas não pode ser o início
da sua lista de parâmetros. Quando você tem outros parâmetros, como você viu anteriormente, ele não pode acompanhar uma
situação em que você terá um
argumento não padrão posteriormente. Portanto, só
funcionará se você tiver, devo dizer, uma
situação em que você tenha apenas
um parâmetro, mas geralmente não é
o caso em Python, geralmente ele terá a maioria
dos parâmetros com os quais
você trabalha É por isso que mencionei
neste exemplo aqui onde você pode permitir isso
. Vamos continuar. O que vou fazer é
dar outro exemplo. Vamos criar uma função simples. Eu direi que a pessoa surda
sublinha as informações, que incluirão
dois parâmetros Eu vou dizer
nome e país. Eu vou dizer impresso
e vou dizer sou, e isso vai ser
para o nome. Então eu vou dizer, e eu sou de, e então eu vou dizer
país. Muito simples. Então eu quero
chamar essa
pessoa funcional em Square Info, e podemos passar por honra e podemos dizer
África do Sul, muito simples. Vamos salvar isso
e executar nosso código. Diz que sou honrado e sou da
África do Sul, muito simples. Ok, perfeito. Então,
temos isso pronto. Agora, vamos usar um argumento
padrão. Então, podemos definir o
padrão aqui, por exemplo, e eu vou dizer que o país
é a África do Sul, e eu posso executar o código, e ele vai
executar Eu sou da África do Sul usando
esse argumento padrão. Agora, digamos
que esse não seja o caso, e na verdade eu sou do Reino Unido. E aqui eu simplesmente me ajustaria. Na verdade, isso não
faria todo o sentido. Digamos, Inglaterra. Aqui vamos nós. Guarde isso e corra, e diz: “Sou honrado e sou da Inglaterra”. Então, agora ele está aceitando o argumento explicitamente definido que está sendo usado na chamada Agora, digamos que eu
não queira adicionar nenhum argumento explicitamente Então, o que eu posso fazer é
remover tudo aqui. Eu posso simplesmente chamar a função, e vou definir isso para honrar. E eu posso executar o código, e ele diz, eu estou nele,
e eu sou da África. Então, tecnicamente, você
não precisa nem mesmo apresentar nenhum argumento
específico aqui Em vez disso, você pode simplesmente utilizar argumentos
padrão. Então, isso é algo que
você pode
fazer e adicionar esse valor
predefinido E, novamente, lembre-se do
que eu disse antes em termos da regra em termos de onde
os argumentos padrão são colocados. Então, se eu quisesse usar um hedge e defini-lo
de uma maneira diferente e apenas defini-lo como
tendo meu argumento, se eu fosse definir o argumento uma maneira diferente e começar com o argumento
padrão, você verá
se eu removo isso Ok, vamos
ter uma espécie de erro. OK. Então lembre-se, argumentos não
padrão, ok? Eles não podem seguir os argumentos
padrão. Então, novamente,
lembre-se dessa regra. Tudo bem, pessoal. Então, esse
é o argumento padrão. Espero que tenha sido um exercício de laboratório
valioso para você e que
tenha aprendido muito. Ok, então é isso.
42. Argumentos de comprimento variável: Olá a todos, bem-vindos
à próxima lição, que será focada
no argumento de comprimento variável. Então, vamos começar. Certo, então o que são argumentos de
comprimento variável? Tudo bem Argumentos de comprimento variável
permitem que uma função exclua mais argumentos do
que aqueles que estão explicitamente definidos, e isso permite maior flexibilidade
no número de entradas que são Agora, existem dois tipos de
argumentos de comprimento
variável que obtemos em Pierson, a saber, arcos Portanto, é um asterisco
e, em seguida, denotado por arcos E isso permite que você passe
um número variável de argumentos
posicionais sem
especificar a contagem exata Então chegamos aos quarks, e isso é definido por
dois asteris de antemão
e depois E isso permite que você
passe um dicionário de argumentos de palavras-chave em
um formato de par de valores-chave sem limite fixo. Tudo bem, vamos simplificar
arcos e quarks. Args é usado quando você não sabe quantos argumentos posicionais podem ser passados para a função, e isso coleta argumentos
posicionais extras quantos argumentos posicionais
podem ser passados para a função,
e isso coleta argumentos
posicionais extras em uma tupla. Depois, temos quarks, que são usados quando
você não sabe quantos argumentos de palavra-chave
podem ser passados, e isso coleta argumentos de
palavras-chave extras em um Lembre-se dos pontos-chave. Quando você vê arcos, ele coleta
argumentos posicionais extras em uma tupla
e o Quarks coleta argumentos e o Quarks coleta extras Lembre-se da diferença
entre os dois. Vá em frente e veja uma analogia. Então, digamos, por exemplo, que estamos configurando ingredientes. Podemos criar uma função
chamada ingredientes. Em seguida, podemos passar vários argumentos posicionais,
como farinha, açúcar e manteiga, conforme os
chamamos em nossa chamada de função aqui E podemos simplesmente,
em vez de seguir em
frente e inserir parâmetros
específicos, podemos simplesmente adicionar o
asterisco seguido por arcos e depois passá-lo para a função em
que queremos usá-lo,
como na
declaração print e, como na
declaração print e Observe que, quando estamos
passando por arcos ou quarks, não
adicionamos os asterixs Só adicionamos os asteriscos
quando os
passamos como parâmetro em nossa função, algo
importante saber As edições mostram como
podemos fazer isso com quarks. Agora, eu também quero
mostrar de antemão a saída para que você possa ver
os ingredientes aqui Ele será
produzido em uma tupla, como mencionei antes, para que possamos ver farinha,
açúcar e manteiga Ok. Então essa
seria sua saída. Então você veria os ingredientes
e, em seguida, lembre-se de
que estarão em uma tupla Agora, o outro
exemplo é se estamos trabalhando em termos
de uso de quarks. Então, aqui queremos passar
vários argumentos de palavras-chave. Então, aqui temos a bebida é café, tamanho é grande, o leite é amêndoa Está bem? E o que faríamos
então é, na lista de parâmetros, simplesmente
adicionarmos os asteris
duplos
e depois passarmos e depois passarmos Depois disso, imprimiremos os detalhes
do pedido
e passaremos pelos quarks sem
os asteriscos que
resultarão na saída a seguir, que serão os detalhes do pedido, que estarão em formato de dicionário Então, isso vai se correlacionar com o que
eu mencionei antes, se você quiser simplificar toda
a ideia de
utilizar args e quargs Tudo bem, pessoal, então
é isso em termos das explicações teóricas
da utilização de argumentos de comprimento variável Portanto, lembre-se novamente, se você estiver usando argumentos de
comprimento variável, usará e quarks
asterix
duplos
43. Utilizando argumentos de comprimento variável — [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de laboratório, que se concentrará
no argumento de comprimento variável. Então, vamos começar. Ok. Então, vamos criar
uma função simples. Então eu vou dizer surdo e isso vai ser
chamado de ingredientes Então, o que você vai
querer fazer é, se quiser
gerar tudo em uma tupla, usar os argumentos do Asterix Está bem? Então, isso vai gerar todos os dados que você
passa para arcos como uma tupla Em seguida, você precisa adicionar
dois pontos, digamos, imprimir. E eu vou
dizer, por exemplo, que em dience adicione dois pontos Y, então você precisará adicionar sua vírgula e então
você pode Agora, se você
quiser produzir e usar args
em sua função, basta remover
esse asterisco, mas precisa mantê-lo
nessa Ok. Agora, queremos passar
vários argumentos posicionais Deixe-me ir em frente e chamar a função para que eu
possa dizer ingredientes, e aqui eu posso passar,
por exemplo, farinha. Lembre-se de que você pode colocá-lo entre aspas simples
ou aspas duplas, não importa,
açúcar e veja manteiga. Você pode até mesmo colocar uma variedade. Podemos prosseguir
e executar o código, e podemos ver que a saída
aqui será em farinha, açúcar e manteiga, e tudo isso
está dentro de uma tupla E a vantagem aqui de
usar args é que você pode passar
quantos argumentos quiser, quantos argumentos posicionais Devo ser claro quanto
você quiser Então, se eu tivesse que
passar por apenas um
argumento específico, ele faria exatamente isso. E se eu
colocasse múltiplos, açúcar,
manteiga, leite, O, economize e corra Ele produzirá
tudo isso dentro de uma tupla. Vamos fazer outro exemplo. Digamos que a morte e
eu direi informações pessoais. Vou imprimir arcos. Vou dizer dois pontos com informações, adicionar uma vírgula e depois
vou dizer Vamos chamar essas funções. Vou dizer informações pessoais. E aqui eu posso passar
tudo. Eu quero dizer John Doe. Digamos que DOB. Então, por exemplo,
direi 140295, por exemplo, como uma string, e depois direi África do Sul Apenas como exemplo, vamos
executar esse código,
e aqui podemos ver que ele imprime
as informações para John Doe,
DOB, da data de nascimento, 140295 E tudo isso,
novamente, como você pode ver, está sendo produzido como uma tupla e são todos argumentos
posicionais Então pense em argumentos
posicionais,
arcos, argumentos de teclado,
quarks Então, vamos agora dar uma
olhada nos quarks. Ok. Então, outro exemplo, e isso será
em quarks. Então eu vou dizer, Jeff, e aqui vou dizer ordem, eu vou marcar detalhes, e vou passar pelo asterisco
duplo para quarks Impressão de dois pontos. E aqui podemos dizer detalhes do
pedido, quark de cólon Então, agora vamos utilizar quarks e simplesmente
omitir o asterixis, já que usamos isso apenas
dentro da definição aqui, e então podemos prosseguir
e E agora vamos
usar argumentos de palavras-chave, e podemos passar por quantos
argumentos de palavras-chave quisermos. Eu vou dizer que beber é igual, e entre aspas,
vou dizer café Tamanho grande e amêndoa de leite. Então, vamos continuar
salvando e produzindo isso. Então, aqui podemos ver que a saída
estará em um dicionário e utilizamos os vários argumentos de
palavras-chave para
utilizar quarks para gerar
tudo dentro de um dicionário Ok. Então é
assim que podemos fazer isso. E, novamente, não
importa quantos temos. Agora, é muito
útil que isso esteja sendo produzido em um
dicionário e também desempenhe um papel mais próximo aqui
do que você está definindo. Aqui, onde estamos definindo, você pode dizer os nomes dos parâmetros, temos sinais de bebida e leite. Isso se forma como as chaves em seu dicionário, onde os valores são os próprios argumentos, como você pode ver, está
sendo gerado aqui. Se você puder consultar as
aulas de dicionários para iniciantes, poderá ver a combinação aqui e como tudo se
relaciona com a Se eu fosse trocar a
bebida aqui por bebida, guarde isso e fuja Você verá
que a chave
aqui na saída do
dicionário mudará. Basta lembrar essa estrutura. Ótimo. Isso é quarks. Vamos fazer outro
exemplo para quags. Vamos
configurá-lo para comprar um carro,
novamente, então digamos que surdo e
comprar carro seja a função Em seguida,
passaremos por quarks, e isso estará
dentro de um dicionário É por isso que estamos dizendo quarks e eu quero dizer impressão Não pudemos dizer os detalhes do pedido. Podemos dizer que, mesmo
assim, os detalhes do pedido, e queremos
passar pelos quargs naturalmente Então, podemos prosseguir
e chamar a função, e podemos
especificar o seguinte. Antes de tudo, quero
dizer que eu diria uma filial, e isso
será igual à Ford. E podemos então
dizer modelo classe F, e então podemos dizer, então
será Ford classe F, e podemos dizer cor. Isso vai ser azul. Lá vamos nós. Então, vamos salvar e
executar esse programa. Então, podemos ver aqui que ele retornará um dicionário porque
estamos lidando com quarks. Adicionamos os argumentos da
palavra-chave e vários argumentos da palavra-chave, e isso produzirá o
seguinte, como podemos ver. Então, a marca, forja, modelo classe F, cor azul Novamente, se eu adicionasse apenas um argumento e executasse o código, ele faria
exatamente isso. Lembre-se de que
não há limitação aqui, então você pode passar vários argumentos de
palavras-chave. Ch. Então aí está. É assim que você pode
basicamente entrar em uma cobertura e trabalhar com tipos de comprimento
variável Mais uma vez, vou dizer isso de novo
só para que você esteja ciente. Lembre-se de que, com args, você trabalha com argumentos posicionais que transformam em quarks de tupla, trabalha com
argumentos de palavras-chave que
se transformam em um dicionário após
a saída em ambos E você define o astérix com arcos e o
asterisco duplo com quarks somente quando está dentro função na lista de
parâmetros Ao exibi-lo
dentro da
funcionalidade de funções,
por exemplo, basta
remover esses asteriscos dentro da
funcionalidade de funções,
por exemplo, basta
remover esses asteriscos Certo, pessoal. Então é isso para este exercício prático de laboratório.
44. Como desembalar o recipiente: Olá a todos, bem-vindos
à próxima lição, que será focada
na desembalagem de contêineres Então, vamos começar. Ok, então você
provavelmente está se perguntando: o que diabos é o
contêiner desempacotando Simplificando, a
descompactação do contêiner permite que você passe elementos
de uma tupla de lista ou dicionário como
argumentos separados para uma função usando asterix para listas e
tuplas ou asterisco duplo para tuplas ou Então, vamos dar uma olhada
aqui, ainda mais simples. Então, o Asterix descompacta
uma lista ou duas em posicionais e
o Asterix descompacta um dicionário em argumentos argumentos
posicionais e
o Asterix descompacta um dicionário em argumentos de palavras-chave. Ok, então isso é apenas
algo que você pode precisar revisar
novamente para maior clareza. Mas, de qualquer forma,
vamos ver como podemos visualizar todo
esse processo Tudo bem, então digamos que eu
mesmo, por exemplo, e eu deveria criar um programa para me descrever
como um exemplo simples Então, eu teria minha função descrever uma pessoa. Eu teria três parâmetros, como nome, idade e cidade. Eu teria uma
declaração impressa que diz nome e depois idade. E então, é claro, todos os anos seguintes moram e
moram na cidade, seguidos pela cidade. Agora, o que posso fazer é adicionar todos esses dados e
armazená-los em uma tupla e, em seguida, descompactar a
tupla em Então, tecnicamente, o que eu
faria seria
utilizar o asterisco único
e depois me referir à tupla, que E isso vai
descompactar, você poderia dizer, todos esses
argumentos em nome, idade e cidade, desde
que estejam na mesma ordem Então, aqui podemos ver
os argumentos reais, e é assim que
chamaríamos essencialmente a função e
inseriríamos esses argumentos. E isso
nos dará a impressão de que não
tem 29 anos e
mora Então, essencialmente, desde que
tenhamos tudo nessa ordem específica,
como no 29 Capetown, e que faça referência à ordem dos
parâmetros aqui,
que é o nome da cidade do agente, ela será chamada
dentro dessa
função de descrição de pessoa e será vista como
informação de sublinhado da pessoa de
Asterix, pois está em uma tupla E na ordem em que estava
na tupla, refletirá a ordem que
substituiremos
nos parâmetros
dessa função Então, uma vez que o descompactamos aqui
pelas informações pessoais do Asterix, a ordem que
tínhamos na tupla
irá para os irá para Então não é primeiro, depois 29
anos e depois
certifica que Capetown é SRT Então, não seria o nome. Como está na mesma posição, 29 anos iriam para a idade e a Cidade
do Cabo para a cidade. Ok. Então é
assim que podemos ver isso. Tudo bem. Agora, digamos que estamos nos
concentrando em algo relacionado à educação ou universidade como exemplo
em termos de um programa. Então, alguém que foi para a
universidade ou se formou. Nosso programa seria um
pouco diferente. Então, neste caso aqui,
como você pode ver, temos uma função que diz graduação
ou informações de graduação. Ele considera os
parâmetros de nome,
grau, universidade
e ano de graduação Em seguida, temos uma declaração impressa que menciona uma pessoa e que ela se formou em qual universidade
no ano da graduação, e os dados serão
armazenados em um Você pode ver os detalhes da
educação,
aqui, em pares de
valores-chave, porque lembre-se de que um dicionário
funciona em pares de valores-chave. Então, teremos o
nome, o diploma,
o ano de
graduação universitária como chaves
e, em seguida, os valores do BSC em tecnologia da
informação, Universidade da Cidade do Cabo, 2019 Em seguida, vamos descompactar o dicionário em argumentos de
função Essencialmente
, garantiremos que
adicionemos asteriscos duplos desta vez porque estamos trabalhando
com um dicionário, como você pode ver aqui, e então todos os
valores serão conectados aos parâmetros,
como você pode Então, nome, diploma, universidade e
ano de graduação serão adicionados Ok. Então é assim que
seguiríamos em frente e faríamos isso. E o resultado, é claro, você verá que será
obtido um BSE em tecnologia da
informação pela Universidade
da Cidade do
Cabo Agora, você também notará aqui que o nome coincidirá com
o parâmetro do nome, grau com parâmetro do grau, parâmetro da
universidade, ano da
graduação, ano da graduação, configurado
com esse parâmetro
e, em seguida, os valores aqui
serão conectados aos parâmetros associados
que configuramos Cara. Eu sei que pode ser um pouco difícil de
entender, mas não se preocupe, vamos ter
muita prática
nos exercícios práticos de laboratório.
Então, vamos ao que interessa.
45. Como desembalar o recipiente — [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de
laboratório, que será focado na desembalagem de
contêineres.
Vamos começar. Vamos definir nossa função. Vou dizer surda e quero chamar
essa pessoa que descreve o sublinhado Essa vai ser minha função. Então eu quero passar
três parâmetros. Eu vou ter um nome. Idade e cidade, acrescente meu cólon. Em seguida, adicionarei minha declaração
impressa e vou
dizer o nome desta vez, vou
usar vírgulas simples Não vou usar a
concatenação de strings apenas para variar um pouco, adicionar a vírgula, depois vou dizer é idade, depois vou dizer
anos
e Temos tudo o que está
sendo aprovado adequadamente. Agora, vamos
definir uma tupla e
queremos armazenar todos os nossos dados que queremos
substituir por nome,
idade e cidade Vamos
definir uma tupla. Vou dizer que as
informações de sublinhado da pessoa fora da função são iguais e a tupla, vou dizer RNO que substituirá o 29 isso vai
substituir H e Capetown, isso vai substituir a Em seguida, o que precisamos fazer
é chamar nossa função para que
possamos descrever a pessoa
sublinhada, que será nossa função, e então queremos descompactar os
dados na tupla que está aqui nos parâmetros da
função aqui Então, podemos simplesmente dizer,
lembre-se, como é uma tupla, podemos ir em frente e
adicionar um asterisco,
e podemos dizer que
a informação de sublinhado da pessoa sublinhado Ok, então é assim que podemos seguir em frente e definir o seguinte. Portanto, a produção final
deve ser não. Tem 29 anos e
mora Então, vamos seguir em frente e
executar esse programa. Aí está. Anu tem 29 anos e
mora na Cidade do Cabo, então podemos ver que agora temos designado
que queremos.
Ok, perfeito. Tudo bem, então é assim que podemos seguir em frente e fazer o seguinte. Então, vamos continuar e praticar mais um pouco
novamente. Tudo bem. E deixe-me ir em frente e
remover tudo isso. Vamos pensar em outro exemplo. Digamos que estamos nos concentrando em
um com, digamos, um almoço, por exemplo, em um restaurante. Então, aqui eu vou
dizer local da morte, sublinhar a ordem,
e vamos passar por alguns parâmetros Eu vou dizer inicial. Prato principal e sobremesa. Posso então simplesmente dizer imprimir, e vou dizer aqui, vou passar para manter
a simplicidade de dizer
para começar. Vou usar concatenação de
strings, prato principal. E sobremesa. Tudo bem,
talvez possamos melhorar isso. Ótimo. Então, agora
precisaríamos inserir as informações. Então, digamos que as informações de
sublinhado da comida estejam em uma tupla Então, vou colocar
os argumentos aqui. Então, para começar, digamos que temos uma ponte de alho O prato principal seria
pizza e sobremesa. Podemos apenas dizer sorvete. Agora, queremos descompactar essa
tupla no argumento da função. Vou chamar a função, que é colocar ordem de sublinhado Em seguida, entre parênteses,
adicionaremos a estrela e, em
seguida, diremos comida, sublinhamos as informações, e
isso as conectará a esses parâmetros e as
exibirá nesta declaração impressa Agora podemos executar nosso código, que diz pão de alho, pizza e sorvete. Perfeito. O que podemos fazer para
limpar isso, na verdade, é apenas adicionar uma vírgula
entre eles. Lá vamos nós. Essa
saída necessária. Tudo bem, então é assim que podemos seguir em frente e utilizar o
desempacotamento de contêineres quando
estamos utilizando o único asterisco para descompactar uma lista ou Então, aqui estávamos utilizando uma tupla. Ok, então
essa é a primeira parte. A seguir, veja como podemos descompactar e
descompactar um dicionário
em argumentos de palavras-chave Agora, antes de continuarmos com isso, uma última coisa que
quero mencionar, lembre-se de que quando estamos usando essa estrela singular aqui, astérix, além do fato de ela
descompactar a tupla listal,
lembre-se da principal coisa que ela faz isso Portanto, você precisa estar ciente do fato de que o que
você coloca aqui, os valores ou os argumentos
que você coloca aqui, uma vez que adicionamos o asterisco à tupla aqui quando a
definimos,
ele vai ficar na ordem
que você especificou originalmente
em que você especificou originalmente sua tupla,
tornando-o um argumento posicional Agora precisamos fazer isso
para argumentos de palavras-chave. Então, podemos ir em frente
e remover isso. Tudo bem, então vamos continuar. Então, vamos definir
nossa próxima função para continuar com a desembalagem do
contêiner Então, queremos transformar nossos dados em um dicionário
em argumentos de palavras-chave. Então, vou
definir minha função como morte e vou
dizer informações de sublinhado de grau, e então vou
passar por vários parâmetros Terei nome, diploma,
UNI, e
direi sublinhado de graduação
para ano de graduação. Então, queremos ter
a declaração impressa, e vou
simplificar. Vou literalmente digitar o
nome, dizer mais
e adicionar
o coma, depois vou me formar, vou fazer UNI e me
formar em Perfect. Temos tudo configurado. Agora vamos continuar e armazenar
nossos dados em um dicionário. Vou chamar
meu dicionário de educação para sublinhar detalhes, e isso estará
dentro do meu colchete. Agora, é aqui que os
argumentos das palavras-chave entram em jogo. As chaves do dicionário serão
os nomes dos parâmetros
, que serão iguais a nome,
diploma, universidade e ano de graduação. Vamos querer
dizer aqui o nome. Para começar, e isso
será equivalente a você poderia dizer o valor ou,
no nosso caso, o argumento Então eu vou dizer não, vírgula. Em seguida, teremos o diploma, já que é o que temos a
seguir na lista aqui, e isso será definido como
BC em TI, podemos dizer. Então, o próximo parâmetro aqui
será a universidade, então podemos dizer que a UNI será igual
à da cidade da Cidade do Cabo
e, finalmente, temos o sublinhado de graduação, que será equivalente a 2019 Certo. Agora, como 2019 é um int e estamos usando a concatenação de strings,
a regra é que precisamos
convertê-lo em uma
string a regra é que precisamos
convertê-lo em uma Você precisa dizer mais
STR, então talvez seja necessário fazer um pouco de
casting, desse jeito Seremos capazes de
gerenciar esse número inteiro. Apenas um pequeno ajuste
que você precisa fazer. Vou apenas ampliar o
zoom para você. Lembra quando eu disse que isso se concentraria
em argumentos de palavras-chave. Nome no dicionário, isso seria visto como nossas chaves e o que associamos
são nossos valores, como você pode ver aqui. Agora, quando estivermos trabalhando
com argumentos de palavras-chave,
os parâmetros serão tratados
como nome, grau, interface do usuário e graduação abaixo do
ano quadrado. Esses serão nomes de parâmetros e serão iguais
aos argumentos que seriam Ano Bety University
of Cape Town 2019 Tente visualizar esse
processo em questão. OK. Então, quando estiver
satisfeito com tudo isso, você pode
ligar para sua função. Então, no final, podemos seguir
em frente e fazer exatamente isso. Portanto, a função aqui é
grau abaixo da informação quadrada. Então eu vou dizer grau abaixo quadrado de informação, e então
queremos chamá-lo. Lembre-se de descompactar
o dicionário, você precisa adicionar dois asteriscos e depois consultar o nome
do dicionário, que é educação
em Assim. E quando estiver
satisfeito com tudo, você pode seguir em frente e executar
esse código. Aí está. Podemos ver que isso diz homenagear a BSE e IT University of Capetown, 2019.
Bem feito. É assim que você pode criar uma barreira e descompactar um dicionário em argumentos de
palavras-chave Vamos fazer outro exemplo. Podemos ir em frente e
remover tudo isso. Outra maneira de
fazer uma cobertura e começar tudo
isso é
configurar algo para os detalhes do
pedido, como exemplo Vou definir o
seguinte. Eu direi que o DF Order sublinha os detalhes.
E podemos dizer, vamos
em frente e coloque, eu vou tomar uma bebida. Tamanho e leite. Podemos ter um tipo de
leite, por exemplo. Podemos ter leite de vaca, leite de
amêndoa, etc. Perfeito. Agora, a declaração
impressa. O que vou
fazer aqui é apenas
dizer os detalhes do pedido, e podemos seguir em frente
e repassar o que precisamos. Aqui eu vou dizer
bebida Adicione as aspas, eu vou ter citações
e leite. Ótimo. Agora, o que podemos fazer é seguir em frente e
definir nosso dicionário. Então,
vou dizer, vamos chamar
isso de bebidas alcoólicas. Ok, vamos lá. Chame isso assim. Então, primeiro, lembre-se de que estamos
usando argumentos de palavras-chave, então bebida, tamanho e leite. Portanto, precisamos nos referir
aos nomes dos parâmetros. Então, vamos beber cólon, e isso vai
ser, digamos, café Tamanho, grande e leite. Eu vou dizer amêndoa. Lá vamos nós. Então, temos itens para beber. Também podemos simplesmente remover
algum espaço em cada lado. Ok, agora precisamos
chamar nossa função, que eu possa dizer a
ordem, sublinhar os detalhes E dentro de parenses, ok, você vai dizer
Asterix asterix,
drink King, drink Isso vai seguir
em frente e atribuí-lo como bebida é igual a café,
tamanho é igual a grande, leite é igual Ok, então é assim que tudo isso vai se encaixar e
podemos executar o programa. Podemos ver aqui todos os
detalhes, café, grandes olmos. Então, talvez seja
necessário agitar esse espaço. Lá vamos nós. E
aí está. Então, também podemos tornar isso um pouco mais limpo. Tudo bem,
aí estamos. Então, agora podemos ver
que está um pouco mais claro. Tudo bem, pessoal. Então é essencialmente isso. É assim que podemos
desempacotar nosso contêiner. Portanto, você pode ver que é uma maneira muito
útil se você quiser
simplificar o gerenciamento de seus argumentos e passá-los para
sua função, etc Tudo bem, pessoal. Então, isso é tudo para esses exercícios práticos de
laboratório.
46. Argumentos locais e globais: Olá a todos, e bem-vindos
à próxima lição, que será focada na discussão
local e global. Então, vamos dar uma olhada. Certo. Portanto, os argumentos globais se referem a onde uma variável
está acessível em um programa. Agora, vamos dar uma olhada, em primeiro lugar
, nos argumentos locais. Agora, essas são
essencialmente variáveis criadas
dentro de uma função. Eles só podem ser usados nessa
função específica e em nenhum outro lugar,
e desaparecem depois a função termina de ser executada ou
executada Argumentos
globais, por outro lado, são variáveis
criadas fora da função
ou de uma função. Eles podem ser usados
dentro e fora das funções e
persistem durante todo o programa Podemos ver que há muito mais vantagens argumentos
globais, como
podemos ver aqui. No entanto, tudo vai depender dos
requisitos e necessidades do seu projeto. Agora, vamos dar uma
olhada na analogia simplificar ainda mais isso para nós Agora, eu quero que você
pense em uma cidade como escopo local e um
país como escopo global. Digamos que escolhemos a
cidade da Cidade do Cabo como exemplo de escopo local e o país África do Sul
como escopo global. Então, a Cidade do Cabo
, em geral , é uma cidade, então uma cidade pode receber seus próprios fundos
locais do prefeito, e isso pode ser
considerado um argumento funcional. Agora, esses fundos pertencem
apenas a essa cidade, e tudo bem, isso não afeta
o orçamento nacional. Agora, se olharmos para um
país, por exemplo, podemos imaginar que o país
fornece um orçamento nacional para todas as cidades e que cada cidade
tem acesso a esse orçamento, mas se uma cidade o modifica,
isso afeta todo o
país como resultado Então, espero que essa analogia
ajude a entender um pouco melhor os argumentos
locais e globais Vamos nos concentrar no exercício
prático sobre isso. É um
conceito bastante simples de entender. Eu também posso adicionar um exercício prático
adicional,
mas isso é apenas algo que
eu queria mencionar em termos de analogias
47. Analisando o escopo dos argumentos - [Lab]: Olá a todos, e
bem-vindos ao próximo exercício prático de laboratório, que será focado em argumentos
locais e globais. Então, vamos começar. Primeiro, queremos
começar com o global. Ok. Agora, argumentos globais
e locais são essencialmente parte do
trabalho com variáveis. Então, definiríamos
algo conhecido
como variável global em termos
de argumentos globais. Então, se eu definisse uma
variável e dissesse que nome é igual, eu gostaria de dizer: Isso pode ser
visto como uma variável global Se prosseguirmos e o
chamarmos de dentro de nossa função. Então, se eu agora definir uma
função, muito simples, ela é definida por def Grit Portanto, a função é Grit. Eu posso dizer impresso.
Eu posso dizer olá. E então eu posso simplesmente usar a concatenação de
strings e dizer mais nome, e isso
vai pegar essa variável que é nome e utilizá-la diretamente
na E é assim que podemos
acessar uma variável global. Então, quando chamamos a função, apenas dizendo greet, ela dirá olá e depois RNO Agora, se eu prosseguir
e executar esse código, ele vai dizer olá RNO Então é assim que
podemos entrar em um hedge e definir uma variável global Portanto, a variável global
pode ser acessada dentro de uma função ,
a menos que esteja sendo
modificada de alguma forma. Agora, deixe-me mostrar como
uma variável local é executada. Então, basta remover
isso aqui e fazer alguns ajustes. Ok. Podemos manter nossa função
Greet por enquanto E foi em nossa função que podemos dizer que mensagem
é igual a hello aro. E eu posso dizer mensagem impressa. A mensagem aqui,
há uma variável, estava na minha função que diz
mensagem e o valor é hello honor e estamos
dizendo mensagem impressa. Então, quando eu cumprimento, ele emitirá hello nem
porque a impressão, como posso dizer que a funcionalidade de
impressão está dentro da função, e estamos usando essa variável localmente dentro da função Não está lá fora. Então, se eu
fosse executar esse programa, ele daria
o mesmo resultado. Mas, para maior clareza, posso simplesmente mudar isso para que você possa
realmente ver a mudança. Olá, John, ele vai
dizer olá, John. Mas se eu
quisesse enviar essa mensagem e quisesse
acessá-la fora
da minha função, se eu dissesse imprimir, mensagem. Você vai ver aqui
quando eu destacar, diz
que a mensagem não está definida. Então é isso que eu quero dizer
com local e global. Agora é uma variável local. As variáveis locais
existem somente dentro da função e não podem
ser acessadas externamente. A razão pela qual estamos
recebendo uma área aqui dizendo mensagem impressa é porque a variável
de mensagem, obviamente, é local. Certo. É assim que podemos seguir
em frente e ver as diferenças em termos de argumentos locais e
globais. Eles se
referem a onde uma variável está acessível em um programa
específico. Você pode ver a
diferença aí, temos global e o local. Lembre-se de que tudo o
que
você define nessa função como variável
permanece na função. Qualquer coisa fora
dessa
variável, por exemplo, estará
acessível em qualquer lugar. Lembre-se de que há um
escopo onde ele pode ser
utilizado e tal Certo. Isso é tudo para este exercício
prático de laboratório. Eu sei que foi muito
curto e breve, mas é um tópico
bem simples de entender. Mas de qualquer forma, queria
cobrir isso, então é isso.
48. Como utilizar a palavra-chave global — [Laboratório opcional]: Olá a todos, bem-vindos
ao próximo exercício prático, que se concentrará na utilização da
palavra-chave global em funções Agora, isso é um bônus, devo dizer, exercícios práticos com
lâmpadas. Você não precisa fazer
isso, mas é algo extra em que eu estava
pensando e vi que pode
ser útil adicionar, mas é definitivamente
algo que
às vezes surge no PySon em um espectro
intermediário Então, vamos dar uma olhada.
Então, a palavra-chave global. Então, deixe-me mostrar por
padrão se quisermos apenas utilizar uma
variável global apenas para leitura. Está bem? Então, o que quero
dizer com isso é o seguinte. Se eu dissesse que contar é igual a cinco, um
número, por exemplo Então eu deveria definir
uma função e dizer show, underscore count No meu cólon. Então,
digamos que eu tenha uma declaração de impressão
e eu diga que a contagem é, e eu apenas adiciono a contagem lá, e então eu chamo a função
dizendo show count. Ele executará essa linha, que dirá que a contagem
é e o valor da contagem é cinco e veremos isso
quando chamarmos essa função. Ok. Agora, isso, é claro, está usando uma
variável global porque
estamos referenciando-a externamente e podemos utilizá-la
dentro dessa função Deixe-me seguir em frente
e executar esse código. E diz que a contagem é cinco. Ok. Certo. Então
essa é essa parte. Agora, a
palavra-chave global é utilizada se você quiser modificar
sua variável Então, se alterássemos
esse código, digamos eu queira ajustar esse valor que está anexado
a essa variável O que eu posso fazer é dentro
da função aqui, posso dizer, global. E
essa é a palavra-chave que precisamos. E vou
anexar isso à contagem
porque a contagem é tratada
como uma variável global, então dizemos contagem global, e isso é necessário porque
estamos alterando a contagem explicitamente E o que queremos
fazer é incrementar. Só queremos adicionar um a ele, para que eu
possa dizer contar, e
espaço mais é igual Então, ele pegará
o valor atual e adicionará um a ele para anexá-lo Então será, é claro, como posso dizer que
serão seis. Ok. Então, o que podemos fazer é
mostrar a contagem agora
e, em seguida,
a saída será seis aqui. Está bem? Então essa
será a contagem que ajustamos aqui
dentro desta função. Então, se eu fosse executar esse código, agora
podemos ver que a contagem é seis proveniente dessa função. Então, pegamos
aquela variável específica, adicionamos uma a ela e
imprimimos o resultado
transportando essa
variável global e ajustando-a Portanto, se quisermos modificar uma variável global dentro uma função e não
apenas lê-la, precisaríamos
especificar explicitamente essa palavra-chave global, e esse é o
objetivo principal de
modificar uma variável global
dentro de uma função, e isso geralmente é restrito
se não tivermos isso Então, se, por exemplo, eu decidir fazer isso
sem dizer Global, e eu simplesmente tirar isso. E digamos que contar mais é igual a
um e depois contar, você verá que, se eu executar
isso, mostrará
um erro Erro local não vinculado. Agora está tratando isso como uma variável local,
em certo sentido, porque essa
é a suposição, porque estamos fazendo alguns ajustes aqui em jogo Estamos apenas dizendo que
contar mais mais é igual um e ele não consegue ler de onde vem
essa contagem É por isso que você
precisaria seguir em frente e
declarar explicitamente a contagem global, e isso permitirá que você prossiga e obtenha
a saída designada Tudo bem, pessoal. É isso em termos desse exercício de bônus. Então, um pouco mais sobre toda
a perspectiva do escopo global e
local. Então vá em frente e retome
isso. Tudo bem
49. Enviar variáveis como argumentos: Olá a todos, bem-vindos
à próxima lição, que será focada no envio de variáveis como argumentos. Então, vamos dar uma olhada. Tudo bem. Agora, você nem
sempre precisa definir um valor codificado com
nossas chamadas de função Em vez disso, também podemos passar por
variáveis, então é um conceito muito simples. Então, vamos dar uma olhada no que fizemos anteriormente
no curso. Então, anteriormente,
definimos nossas funções,
definindo um parâmetro. Por exemplo, nomeie
e, em seguida, adicione o argumento diretamente à
função que estamos chamando. Nesse caso, por
exemplo, saudação. Estamos passando não
com um valor codificado
para, em seguida, substituir o parâmetro
name e , em seguida, sermos levados à instrução de impressão, onde dizemos olá no
nome, que será nu O que você também pode fazer é
definir uma variável externa. Assim, você pode criar um programa
como esse em que tudo o que você faz é definir uma variável
fora da sua função
e, em seguida, definir esse valor. E em vez de inserir não
diretamente, como podemos ver aqui, simplesmente
passamos por essa variável
específica, que é a primeira no nome
do quadrado, que substituirá o
nome aqui como rno É por isso que eu
coloquei o comentário lá, e ele vai imprimir exatamente
os mesmos resultados. Então, isso é apenas algo que eu
quero mencionar para que você esteja ciente. Você pode simplesmente passar pelas variáveis, desde que as tenha
atribuído de antemão Ele executará
os mesmos programas, a mesma saída, exatamente semelhante à que
mostrei aqui
no lado esquerdo, que estava codificada Só para mencionar que é uma coisa muito fácil
e simples aprender e entender. Isso é algo
importante que eu acho que
você deve saber, e é assim que podemos enviar
variáveis como argumentos.
50. Trabalhando com variáveis como argumentos — [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de
laboratório, que se
concentrará no envio variáveis como argumentos
em funções. Então, vamos começar. Então, esse vai ser um exercício
bem simples, então não vai
ser tão extenso. Então, vamos seguir em frente e
praticar um pouco. Então, vamos definir uma função
simples. Eu vou dizer uma saudação para surdos. Quero definir o nome do meu
parâmetro como nome. Em seguida, quero gerar a
seguinte declaração que diz olá e, em seguida, podemos adicionar uma
vírgula e passar o nome Agora, o que estamos
acostumados a fazer é chamar a função e depois adicionar
diretamente o valor. Podemos, por exemplo,
simplesmente inserir,
digamos, Katie executar o código
e ele diz olá Katie Agora, digamos que não queremos
adicionar os valores diretamente,
mas, em vez disso, queremos atribuí-los primeiro
a uma variável. O que você pode fazer é
dizer, por exemplo, o
primeiro nome, e
podemos definir
isso como, digamos, Katie Então aqui, onde você está
chamando seu argumento, basta colocar o primeiro nome,
novamente, eu só
quero configurar isso. Agora, se você executar, seu código mostrará exatamente
os mesmos resultados. Digamos que você possa seguir
em frente e enviar suas variáveis como argumentos. Vamos fazer outro exemplo. Diga surdo e eu
vou dizer aqui, por
favor, beba, vou passar por aqui a declaração impressa da
bebida, e vou dizer, eu gosto de beber E vamos colocar uma bebida. Depois, lá fora, posso dizer a bebida
sublinhada favorita, chamar a função e
conectá-la, por exemplo, executar o código Diz, eu gosto de beber. Ok. Vamos
mudar isso. Vamos definir uma variável
externa e vamos definir isso pois podemos até dizer
isso como bebida é igual Nós o definimos
aqui e então
podemos passar pela própria bebida. Isso vai virar uma
barreira e substituir o que temos aqui
no parâmetro. Se fôssemos executar o código,
eu também gosto de beber. OK. Então essa é outra maneira pela qual
podemos seguir em frente e fazer isso. Então, mesmo que os
nomes estejam definidos aqui, então drink aqui levará
em conta a variável
aqui, substitua drink aqui, que é um parâmetro,
e isso é muito importante porque
às vezes você código e vários programas e xadrez onde eles os
mantêm iguais apenas
para testar seus conhecimentos. Então lembre-se, a bebida
aqui é um parâmetro, o, e isso vai
gerar esse valor. Beber aqui é uma variável. Lembre-se de que, se você destacar, poderá ver a variável
e o parâmetro. Tenha isso em mente. Mas o que você pode fazer para
ajudá-lo a distinguir, especialmente se estiver
começando, possível
diferenciar claramente os dois para saber que é possível
diferenciar claramente
os dois para saber que
essas são minhas variáveis,
esses são meus parâmetros Novamente, é claro, se eu
correr, gosto de tomar chá. Isso é apenas um
pouco mais de prática em enviar argumentos
como nossos argumentos. Isso é nesse exercício.
51. Parâmetro que passa por valor ou referência: Olá a todos, bem-vindos
à próxima lição, que será focada
na passagem de parâmetros por valor ou referência.
Então, vamos dar uma olhada. Tudo bem. Agora, quando você passa
uma variável para uma função, Pyson a manipula de
duas maneiras Passe por valor ou
passe por referência. Agora, vamos dar uma
olhada em cada um deles começando com o valor de
passagem. Agora, com a passagem por valor, a função obtém uma cópia
da variável original e as alterações dentro
da função
não afetam a variável
original. Agora, isso funciona para tipos de dados
imutáveis
e, para isso, temos int,
então integer, float, SDR, para Portanto, é muito importante lembrar que, ao
passar por valor, isso funcionará para tipos de dados
imutáveis
e, necessariamente, para esses
quatro tipos de dados Em seguida, passamos por referência. Agora, nesse caso, a função obtém uma referência ou um endereço
de memória dessa variável, e qualquer alteração dentro
da função
afetará a
variável original que foi definida. Agora, isso funciona para tipos de dados
imutáveis, não imutáveis, mas tipos de dados
mutáveis,
que incluirão uma lista, um
ditado e um ditado Isso seria em termos
de aprovação por referência. Rapazes. Isso é tudo para a visão geral
teórica. Vamos seguir em frente e mergulhar
na prática.
52. Explore valores e referências de parâmetros — [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de laboratório, que será focado na passagem de parâmetros por
valor ou por referência. Então, a primeira coisa que
vamos fazer é focar na passagem por valor, que se
concentrará em tipos de dados imutáveis, como números inteiros Portanto, imutável, o que significa que
não pode alterar o valor depois de configurado,
passado e atribuído Ok, então vamos começar. Então, o que eu quero fazer
é definir uma função. Eu vou dizer Def, mude o número do
sublinhado. Esse será o nome da minha função. Então eu quero passar por
X ou definir X como meu parâmetro. Então eu vou dizer imprimir. E vou
adicionar algum texto para dizer função interna, dois pontos Em seguida, adicionarei espaço,
vírgula e, em seguida, X. seguida, quero chamar
minha função e dizer alterar o número do sublinhado E o que vou fazer é passar por
valores codificados Eu vou dizer
cinco, por exemplo. Então, quando eu executar esse código, ele dirá
dentro da função cinco. Então, podemos ver que esse
argumento foi passado e substituiu X, e então X foi coletado e adicionado
à função de impressão aqui, e eu imprimo cinco no final Ótimo. Agora, vamos definir
isso como uma
variável por enquanto. Defina um número igual a cinco, e agora
vou passar uma variável
aqui para uma variável aqui para uma variável como argumento para
substituir o parâmetro Agora, o que posso fazer
é executar o código dentro da função
cinco e podemos ver que foi passado
como deveria ter sido. Perfeito. É aqui que a parte interessante
entra em jogo. Agora, digamos, por exemplo, que eu vá para minha
função e diga que X agora será dez. Pensando consigo mesmo
sobre o que vai acontecer. Lembre-se do que eu disse:
Imutável, sem mudanças. Então, se eu fosse continuar configurando isso
e executando o código, ele diria dez. Agora, o que está acontecendo aqui é o valor numérico
que
está sendo definido é como
posso dizer que está sendo
passado para o parâmetro X, mas depois estamos redefinindo
X e configurando-o para dez Portanto, o valor que
será mantido
na função local sempre
será dez. Agora, a parte que
vou mencionar em Immutable é que o original permanecerá inalterado Então, o
que quero dizer com isso é que se eu disser print
e sair da função
lateral, e eu disser num, você
verá que a
função externa não muda. Então isso vai
ser imutável, então não muda lá fora, não
importa que o que façamos aqui na
própria função localmente Não vai
fazer nenhuma mudança. Portanto, não há efeito em num
fora da função. Então isso é imutável. Agora, se configurássemos isso forma que se
tornasse mutável, as mudanças
seriam afetadas externamente O que podemos fazer é
testar isso, por exemplo, com uma lista. Então, agora vou
mostrar como
podemos passar por referência
ao tipo mutável Então, vamos fazer isso
agora. Portanto, o principal a ser visto aqui é que ele não mudou fora do valor
numérico, independentemente do ajuste que
fizemos na função,
ele não Então, deixe-me mostrar
onde isso
mudará de acordo com um
tipo mutável, como uma lista Portanto, as alterações afetarão
o resultado original. Deixe-me
definir uma nova função, def ad no item de pontuação, e vou definir o
parâmetro como minha lista Ok, o que vou
fazer por enquanto é dizer que imprime dentro da função
dentro da função. Com isso, vou
ter minha lista de pontuações, e só queremos
adicionar essa vírgula Então, queremos chamar essa função
específica, mas precisamos adicionar algumas
informações a uma lista. Então, vou dizer números, iguais, e vou
dizer um, dois, três Então, podemos ver a adição
abaixo do item quadrado e vamos dizer números. Então, vamos passar por essa lista específica
aqui para a minha lista aqui, e então vamos
seguir em frente e gerar o que está sendo executado
dentro da função. Então, podemos prosseguir
e executar isso agora,
está escrito dentro da função
um, dois, três. É exatamente isso que passamos. Eu também quero te mostrar
o que isso mostra lá fora. Então, se eu disser impressão, função
externa. E se eu dissesse números, dentro da função um, dois, três, fora da função
um, dois, três. Então, deixe-me prosseguir e modificar a lista original
dentro da função. Então, o que eu posso fazer é
pegar minha lista, que estou pegando aqui
do parâmetro, que tem um valor atribuído
definido em números como um,
dois, três, e eu posso
acrescentar a essa lista, por exemplo, eu posso usar um método de caneta, então
eu posso dizer caneta de ponto
e Então isso significa que a função agora vai mudar para um,
dois, três, quatro, mas queremos
ver se ela muda do lado de fora. Se eu executar isso, G
para três agora que a função interna agora é 1234 e a
função externa é 1234 Portanto, embora
estejamos configurando essa lista
dentro da função, ela também terá
consequências externas. Em outras palavras, como você
pode ver, a lista é modificada fora
da função. Como também estava
na função. Então, isso o torna mutável. Portanto, as mudanças afetam o original. Então, o original eram
os números um, dois, três. Como vimos antes
e analisamos o final, você não pode
alterá-lo porque é imutável. Tudo bem. Então, espero que isso lhe dê uma ótima compreensão do
que quero dizer com mutável, imutável em termos
de mudanças e como todas elas se juntarão Certo. Agora, vamos fazer mais
alguns exemplos. Ok, agora o próximo que
eu quero
fazer será do
tipo imutável desta Então, isso significa que não há mudança, e isso vai ser uma string. Então, vou dizer surdo,
mudar, sublinhar
texto, apenas uma função Vou passar pelo texto. E eu vou dizer, por
enquanto, função lateral de impressão. Texto. Então eu posso dizer
mudar, sublinhar o texto E o que vou fazer
por enquanto é apenas dizer oi. Ok, vamos lá.
Esse é o básico. Vamos agora atribuir uma
variável. Vou dizer mensagem. Olá. Agora vou passar
por uma variável por meio do argumento. Execute isso agora. Olá. Bom. Estou fazendo isso em incrementos para que você possa aprender em cada parte como
estou configurando tudo isso Agora, a parte externa funciona, então eu vou primeiro
dizer impressão, função
externa. E essa será a mensagem. Agora, o que eu quero fazer é fazer uma atualização na função, mas antes de fazer isso,
deixe-me executar esse código novamente. Então você pode ver a função interna, olá, função externa, olá. Agora, se eu
fizesse uma alteração aqui na
função local e dissesse: Ok, o
texto agora vai
ser adeus. Então, agora vai cair em
uma cerca viva e se despedir. Então essa será
a mudança, e eu vou em frente
e executo esse código. Você verá que será adeus na função interna
e, lá fora, será olá Então, você pode ver, mudando o
texto dentro da função, e o original que
tínhamos aqui, é claro, permanece inalterado e
não há nenhum impacto ou alteração
nele Então você pode ver
aqui que há uma diferença no tipo. Gretch. Rico. Agora, vamos seguir em frente e passar
pela referência novamente. Então, tipo mutável, e um
deles é um dicionário. Esse é um tipo mutável. Então, vamos
definir nossas funções. Eu vou dizer Def, atualize de
acordo com o ditado escolar. E podemos seguir em frente e definir as parenses
e podemos colocar aqui,
podemos ir em frente e colocar
o primetro de M dict no meu
dicionário Então, podemos dizer imprimir por enquanto, e eu quero dizer
dentro da função, dois pontos, e vamos
passar pelo meu dicionário Agora, o que eu quero
fazer é consultar o dicionário de
atualização
e seguir em frente e mantê-lo aberto
por enquanto em seguida,
posso definir um dicionário Vou dizer pessoa, igual, e vou definir o valor-chave aqui,
os
pares de valores-chave, como singulares Vou dizer o nome de Colon Alice. Eu queria passar por isso? Então eu vou dizer pessoa, e pessoa vai
substituir meu ditado, e vai
dizer função interna, e então meu ditado será pessoa,
que
mostrará o nome Alice
dentro da Vamos executar isso.
Função interna, nome Alice Perfeito. Certo, então vamos
fazer nossos ajustes. Então, função externa,
eu vou dizer impressão, função
externa. C no espaço. Eu tenho uma pessoa. Veja que é o mesmo por dentro e
por fora , porque não
fizemos nenhum ajuste. A funcionalidade
da instrução de impressão é apenas ler de
fora do meu código. Deixe-me seguir em frente e fazer a
diferença dentro da
própria função e dizer meu
sublinhado.
Aqui, vou adicionar um novo par
de valores-chave Eu vou definir a idade e
vou definir isso para 28. Agora teremos um
novo par de valores-chave adicionado para nomear Alice Também teremos
28 anos e isso ajustará
e mudará a função interna e
esse resultado também afetará o que vemos
na função externa. Então, deixe-me seguir em frente
e executar o código. E aí está, podemos
ver que essa mudança é,
como você pode ver, mutável, mudanças
após mudanças que afetam
o original Então, pessoa, a lista de
pessoas foi alterada. Como podemos ver fora
da função, ela também mudou. Tudo bem, então aí está. É assim que você pode passar
por valor e passar por referência e a
diferença entre tipos mutáveis e mutáveis Lembre-se de que mudanças mutáveis afetam o original e mudanças
imutáveis não afetam Tudo bem. Então aí está.
53. O operador asterisco: Olá a todos, e bem-vindos
à próxima aula, que será focada
no operador Asterix Então, vamos dar
uma olhada. Certo, operador Asterix. Agora, o
operador asterix, como podemos ver, indicado por um Asterix é um operador
especial que tem usos
diferentes dependendo de
onde Agora, é claro, neste curso, e se você já fez um curso
PySON para iniciantes antes, você pode ter visto esse operador quando está, por exemplo,
multiplicando e tal, e também aprendemos um pouco mais em
termos de arcos e quarks como Mas eu só quero dar mais
alguns casos de uso e cenários de onde ele é usado e como
é usado, etc Então, vamos continuar e mergulhar. Agora, vou te
dar uma lista das formas mais comuns. Então, aqui estão os mais
comuns de uma forma simples. Então, podemos usar asterix
para multiplicação,
então, em matemática, podemos usá-lo empacotando listas e
tuplas Pode usar arcos Asterix para
vários argumentos de função. Podemos usar
quarks de asterisco duplo para argumentos
nomeados em
funções e
podemos usar um único asterisco e um asterisco duplo para
passar listas e dicionários para Como você pode ver,
há muitos casos de uso nos quais
podemos utilizar asterixs Certo. Eu só queria te dar um pequeno resumo, para que
você tenha uma visão geral Vamos fazer um exercício
sobre o operador de asterisco, que será um
pouco mais diversificado
e integrado apenas para
algumas práticas e coisas e integrado apenas para
algumas práticas e Mas isso é tudo que eu
queria mencionar sobre o operador asterix
54. Aplicando o operador asterisco — Parte 1 — [Lab]: Oi, todo mundo. E bem-vindo ao próximo exercício prático de laboratório, que se
concentrará na aplicação do operador Asterix a
vários casos de uso em Agora, é claro, existem
inúmeros casos de uso disponíveis. No entanto, vou abordar a maioria dos problemas comuns
que você enfrentará e também adicionarei um ou dois singles
extras em termos de conteúdo bônus
extra que está um pouco disponível. Então, vamos começar.
Em primeiro lugar, o caso de uso mais comum em matemática é a
multiplicação. Então, podemos dizer, por
exemplo, que o resultado é igual, e eu posso dizer quatro multiplicado ou esse é o asterisco Então, em matemática, o
símbolo asterix significa multiplicador. Posso dizer impressão, resultado.
E eu ganho oito. Ótimo. Agora,
vamos um pouco mais longe. Digamos que eu tenha um número igual,
digamos, quatro, número dois, cinco. Então, posso dizer que o
resultado final é igual ao número um, multiplicado pelo E vamos continuar
imprimindo o resultado final. E é rodar este 20. Ok, essa é outra
maneira de fazer isso. O que também podemos
fazer é fazer isso com base nos resultados para
obter um resultado final. Então, o que posso dizer
aqui é o resultado um, e isso implicará
quatro multiplicado por O resultado dois implicará
três multiplicado por três, e então o resultado final será
essencialmente o resultado um e, novamente, multiplique pelo Então, vamos
obter esse resultado, armazená-lo neste resultado
variável um. Vamos obter
esse resultado,
armazená-lo no resultado variável dois. Em seguida, obtemos outra variável e multiplicamos os resultados
do que temos lá Salve isso e execute o código. Oh, eu preciso dizer
impressão, desculpe-me. Impressão, resultado final. E obtemos 144. Então é assim que podemos fazer isso
com matemática para multiplicar números O que também podemos fazer é repetir sequências de caracteres
e listas Então, por exemplo, se eu disser que
texto é igual a alto, John. Lá fora, posso adicionar o
asterisco e dizer três. Então eu posso dizer imprimir texto. Então, agora, se eu seguir em frente
e executar esse código, ele dirá: Oi,
John, oi, John. Oi, John. Ok. Então é isso
que podemos fazer nesse sentido. Agora, o que eu quero
fazer é realmente adicionar um espaço lá. Aqui vamos nós. Oi John, Hijon está um
pouco mais claro de ver agora. E só vai
multiplicá-lo por três. Agora, como estamos
trabalhando com cordas, vamos
repetir isso três vezes É assim que esse asterisco
se aplica com cordas. Ao contrário dos números, ele
realmente executará
a funcionalidade em si em
termos de multiplicação bruta Agora, na verdade, podemos ajustar
isso. Então, o texto um é alto. Os outros dois são John Doe. E podemos dizer que o
resultado final é igual. E o que vou fazer aqui
é dizer vezes duas vezes duas. E então eu vou dizer
texto um mais texto dois. Então, estamos usando a
concatenação de strings aqui, e isso funcionará bem porque atualmente
estamos Então, o texto um terá
o resultado de altas vezes dois, e depois John Doe,
John Doe vezes E então nós apenas combinamos
os dois juntos. E podemos simplesmente imprimir isso, então eu posso dizer imprimir o
resultado final e executar esse código. Alto, alto, Jon Do, Jon. Então é assim que podemos lidar
com sequências repetidas. Certo. Agora, também podemos trabalhar
com listas repetidas. Então, se eu disser números iguais, e na minha lista, eu tenho um, dois, posso dizer vezes três, então imprima a lista e você
notará que , se executarmos
isso, ela terá um,
dois, um, dois, um, dois Então, em vez de
criar , digamos, três listas
separadas, ele modificará
o que está na lista
três vezes e ainda o três vezes e ainda manterá em uma
lista singular, como podemos ver aqui. Então é isso que a
multiplicação fará por você. Agora, podemos tornar
isso um pouco mais complexo, devo dizer? Podemos ter números dois, e vamos colocar
aqui, por exemplo, quatro, cinco vezes dois. E então podemos dizer que o
resultado final novamente é igual. E como estamos
lidando com uma lista, precisamos convertê-la primeiro em uma string,
para que
possamos dizer SDR,
números, mais, então estamos
fazendo concatenação de strings,
convertendo uma string, convertendo uma string E agora, se
imprimirmos o resultado final, obtemos um, dois, um, dois, um, dois, quatro, cinco, quatro, cinco. Agora, podemos ver que está
tudo aqui junto, mas neste caso está separado. Então, quando você estiver usando a concatenação de strings
entre as duas listas, você notará que, nesse caso,
ela será separada Tão diferente de quando você
está fazendo isso sozinho. Então, se eu fosse
imprimir números como você viu anteriormente e
obtivesse esse resultado, ele multiplicaria
e somaria Bem, neste caso, multiplique por três, então
mostrará uma,
duas, uma , duas e
uma, duas, três vezes Se fôssemos realizar a concatenação de
strings nele, o que aconteceria é que
ele se separaria em suas duas entidades
e
executaria seus tipos separados de funcionalidades
em Certo. Então aí temos isso. Então, a multiplicação é feita e a massa, repetição de sequências
e menos Certo, a seguir, desempacotar
listas e tuplas. Então, essa é bem simples. Então, muitas das
coisas que também
veremos agora também abordamos, então será uma boa
revisão para você também. Digamos que eu tenha alguns
números e um,
dois, um, três e quatro. Ok. Digamos que eu diga imprimir, e o que
podemos fazer é adicionar o asterisco, e isso vai revelar nossa lista para Então, eu vou dizer números. Portanto, lembre-se de que, ao
desempacotar sua lista, você adicionará o
único asterisco E podemos seguir em frente
e dizer executar código, e temos um,
três e quatro. Agora, isso também se aplica se você estiver trabalhando
com tuplas Então, se eu gradualmente
mudar isso para tuplas, adicione o singular, o asterisco singular,
desculpe-me e diga executar Também
retornará o mesmo. Então é assim que você
desempacotaria suas listas e tuplas. Portanto, expandir os elementos
da lista da impressão ou da
passagem para funções é
aqui que
será realmente útil. Agora, digamos que eu queira
coletar vários argumentos usando a notação Asterix args Então, o que podemos fazer para atingir esse objetivo é
criar uma função, então eu quero dizer que a morte mostra
números e vou
passar dois pontos Rx e imprimir Então eu quero chamar minha função e vou
passar por elas em uma, duas e três. E tudo isso
será reunido dentro do parâmetro args
e será
gerado aqui em args
sem esse Seria assim que também podemos utilizá-lo em uma
perspectiva de função com arcos. Então, podemos seguir em frente
e executar o código. Temos um, dois, três
e, desta vez, está em formato
de tupla, como você pode
ver como foi gerado Certo. Então é
assim que podemos fazer isso. É assim que podemos pegar
os vários argumentos e armazená-los como uma tupla Agora, também podemos coletar argumentos de
palavras-chave e armazená-los como um dicionário
utilizando quarks Então, podemos remover isso e dizer surdo, mostrar, sublinhar informações E aqui eu posso simplesmente dizer
quarks, adicionar com dois pontos, e lembrar quando digo imprimir, quarks, e então queremos
chamar Então, vamos dizer
mostrar e sublinhar informações, e dentro dos parênteses
podemos seguir em frente e passar adiante Lembre-se de que, desta
vez, com argumentos de palavra-chave , já que você está
trabalhando com quarks de carros ,
vou dizer
nome é igual a, não ,
e podemos dizer que idade e podemos dizer que é igual a 29, e podemos executar
esse código. Lá vemos a saída do
dicionário. Portanto, temos a
chave do nome da honra e a chave da idade de 29.
Então aí está. É assim que também podemos
utilizá-lo com quarks. Então, aqui temos asteriscos duplos
que precisamos aplicar. Ótimo. Agora, a próxima coisa é algo muito novo
que ainda não analisamos. É assim que podemos descompactar
com o símbolo do asterisco. E, por exemplo, se quisermos pular valores médios na
lista, por exemplo Então, se eu dissesse primeiro e eu pudesse adicionar meu
asterisco para o meio, então eu poderia adicionar Posso atribuir isso a
uma lista que tenha um, dois, três, quatro e cinco. Agora, se eu imprimisse
cada uma dessas variáveis, primeira, média e última, você verá o que obterá a saída. Se eu disser imprimir, primeiro, imprimir, e eu quiser dizer
meio, imprimir, por último. É rodar isso. Vamos
ver aqui que temos um, e depois temos dois,
três, quatro e cinco. Este asterisco aqui
aplicado ao meio coletará
todos os valores médios Se você olhar aqui,
um é o primeiro s, cinco está no final, dois, três e quatro estarão no meio. Ele coletará todos os valores
médios da lista,
deixando o primeiro e o último
como variáveis separadas
e, como podemos ver
ao
imprimi-lo, ele estará dentro da
própria lista e os números
separados aqui, neste caso, serão apenas números
inteiros sozinhos Então é assim que podemos desempacotar com o asterisco em um determinado
contexto Certo. Agora, vamos seguir em frente
e aplicar isso para durar. E nós executamos isso. Agora podemos ver o
primeiro valor aqui, um e meio, que
se estende até dois A última opção aqui agora vai ditar
que serão
três, quatro e cinco Vai ser um
pouco diferente aqui se você definir isso para a
última opção aqui. Isso vai
mudar um pouco. Vai continuar com
os últimos valores e vai
continuar depois que os
dois primeiros forem atribuídos,
você poderia dizer. Primeiro, tecnicamente,
você diria que vai ser emparelhado com um meio, é claro, seria emparelhado com o
próximo e o último, é
claro, será o último
conjunto de valores em uma lista. Certo. Em seguida, vamos
mesclar as listas e garantir
que também as descompactemos em uma Então, eu vou, por exemplo,
dizer que a lista um é igual, e dentro da lista,
eu vou ter um, dois, lista dois,
vamos ter três,
quatro, e então
podemos mesclá-los Então, eu vou
dizer que mesclar é igual, e criaríamos um tipo
de lista aqui, você diria,
adicione seu operador aritmético, e você pode dizer Lista um e, em
seguida, adicionar o operador aritmético e dizer lista dois E então, quando você
prosseguir e imprimir mesclado verá que tudo foi
mesclado em uma lista Portanto, esse asterisco antes da lista, como você pode ver, separado
pela vírgula em
uma lista aqui, o mesclará em uma Então é assim que você pode mesclar sua lista e, no final, descompactá-las em uma lista aqui, para que fique tudo em um Ok. Então é assim que você pode combinar sua lista com muita facilidade. Agora, digamos que você queira
mesclar dicionários, é
claro que você também
seguiria o No entanto, é apenas
um pouco diferente. Você precisaria
adicionar dois asteriscos desta vez em vez de um
para mesclar dicionários Então, deixe-me ir em frente
e dizer o primeiro. E aqui, eu vou
atribuir, é claro, uma chave, então A, é claro, vai ser um, morreu dois. Nós vamos ter B, e podemos definir isso como dois. Então, podemos dizer que mesclados são iguais
e, dentro de parênteses, podemos simplesmente
colocar asteriscos duplos e
dizer jct um, vírgula dizer jct E agora, se
disséssemos imprimir e você disser mesclado, obtemos A um, B dois, então podemos
ver que isso foi mesclado em
um dicionário, então temos dois pares de
valores-chave Então, duas instâncias. Então, A um e B dois
foram produzidos. Então é assim que podemos
mesclar dicionários. Então, lembre-se. Se você
quiser mesclar uma lista, exceto a lista estar
entre colchetes, você só fará um asterisco para
mesclar com um dicionário, você Portanto, lembre-se dessa distinção fundamental quando estiver trabalhando com sabedoria. H. A próxima coisa que queremos
fazer é passar,
por exemplo, nossas listas
ou tuplas para funções Isso é algo que
queremos analisar agora. Digamos que queremos
seguir em frente e adicionar valores, por exemplo,
em nossas funções. Se eu disser D, some, e estamos esperando A e B, e vamos
dizer retorno A mais B. O que podemos fazer é ir em frente e
definir os valores em uma tupla Então eu vou dizer números
para números iguais, e em cima eu vou
dizer três Então eu vou dizer imprimir. E neste caso,
vou me referir a eu vou chamar
essa função add here. Estou imprimindo a
declaração externa em vez de usar a devolução interna. Eu posso então seguir em frente e simplesmente passar e dizer números, e isso vai
automaticamente ser
associado a A sendo três,
e B cinco, já que opera com argumentos
posicionais,
já que estamos trabalhando com apenas um asterisco
singular Então, agora podemos seguir em frente e dizer executar código, e
ele retorna oito. Mas o que posso fazer aqui
apenas para simplificar é dizer adicionar números.
E não
queremos voltar. Podemos simplesmente dizer imprimir, e eu
vou realmente dizer A mais, vamos colocar o resultado final
igual a A mais B, e então eu quero
imprimir, resultado final Ok, então você também pode fazer
isso dessa maneira. Então, ele vai seguir
em frente e obter o mesmo resultado. Então, apenas outra maneira de fazer isso. Então é assim que podemos passar, por exemplo, para uma lista ou
uma tupla para uma função Agora, digamos que façamos isso com uma tupla. Então, vamos seguir em frente e
configurá-lo dessa forma. Mas desta vez, o que
eu vou fazer
é não fazer isso com a missa aqui. Vou fazer algumas
junções de uma forma específica, então vamos encerrar e
focar na lista.
55. Aplicando o operador asterisco — Parte 2 — [Laboratório]: Certo. Então, o que podemos fazer
é definir nossa função, digamos def ad e teremos A e B. Então eu quero dizer print, e B. Em seguida, defino meus
dicionários, direi E aqui na lista,
vou dizer olá, anúncio no espaço da vírgula e depois uma vírgula
para a próxima parte, que será mundo Então eu posso chamar a
função, que é Adicionar, e então precisamos adicionar um asterisco singular aqui
e podemos dizer palavras Então, vamos passar pelos valores-chave
do dicionário pares de valores-chave
do dicionário para AB e, em seguida,
vamos imprimir AB. Então, se executarmos esse código, precisamos obter hello world. Então é assim que podemos
seguir em frente e passar a lista para nossas funções. Agora, queremos aprender
como podemos passar dicionários para funções,
então vamos fazer isso Ou revisar, devo dizer? Então eu vou dizer DF, criar. Nome e idade como meus parâmetros. Então eu vou dizer imprimir. Desta vez, vou usar strings
F e utilizar
espaços reservados Eu vou ter um nome e depois
diremos que tem anos de idade. Então eu posso especificar meus
dados para o dicionário. Aqui eu vou
simplesmente dizer o nome. Cólon, não, e depois
vírgula e depois idade, cólon e Então eu posso chamar a função GET e
passar pela seguinte, que será um asterisco duplo
para o dicionário aqui Então, agora podemos executar esse código, e agora temos 29 anos de Então, eu defini
minha função aqui. Estou usando uma string F para atuar como um espaço reservado para os
valores que estão chegando Então, os dados aqui são um dicionário. Estamos passando o dicionário aqui para os parâmetros,
nome e idade
e, essencialmente, estamos
apenas imprimindo quais valores foram definidos,
como nome e idade. E então, para obter esses dados do
dicionário para nossa função, estamos adicionando asteris duplos
para substituí-los adequadamente Rico. Então é assim que podemos seguir em frente e
começar isso também. Perfeito. Certo. Então é assim que podemos
começar e configurar tudo isso. Agora, outra coisa
que eu também quero mostrar é como você pode seguir em frente e usar o asterisco
para ignorar valores, ou se você também quiser pular
vários valores, e isso também pode funcionar em tangente com um Certo, então digamos que queremos extrair apenas o primeiro
elemento da lista. O que podemos fazer, por
exemplo, é dizer A, e então adicionaríamos o asterisco com o
sublinhado e E na lista,
digamos que temos dez, 20, 30 e 40. Nós diríamos que imprima A, e ela produz dez O que acontece aqui é
que A será associado ao primeiro
item da lista,
e o uso combinado do asterisco e do
sublinhado
ignorará todos os valores
adicionais que estão disponíveis Ok. O que também podemos fazer é extrair talvez os dois
primeiros elementos. Então, o
que podemos fazer para fazer isso é dizer adicionar B agora e
podemos dizer imprimir A, B. Então A será
associado a dez. B será
associado a 20, e a saída será
dez e, claro, 20. E o sublinhado de Asterix
ajudará a ignorar 30 e 40. Então, se eu executar isso, temos
dez, e nós temos 20. Digamos que você possa extrair
os dois primeiros elementos. Digamos que queremos
obter o último elemento, que é 40 aqui. Vamos mudar
o que estamos definindo aqui e
ignorar tudo no
início e então podemos dizer, adicionar uma variável que é a última e adicionar o ano
passado, e significa que o asterisco
e a subescala aqui
ignorarão 1020
e seti
e somente 40 serão preservados para a última variável e produzirão Se eu executar isso, obtemos 40. Digamos que você possa
extrair o último item. Digamos que queremos ir até uma cobertura e extrair o
primeiro e o último elemento Então, o que podemos fazer
nesse caso é dizer que primeiro adicione seu asterisco
e sublinhado e
diga que E aqui, digamos que temos um, dois, três e quatro. Podemos então dizer imprimir
primeiro e por último. Então, obtemos apenas um
e quatro com todos os valores médios ignorados
pelo asterisco seguido
pelo sublinhado Agora, deixe-me dar
mais algumas informações sobre o
asterisco e o sublinhado Então, o sublinhado é
essencialmente um espaço reservado, ok, e você pode ver isso como um
tipo de variável ignorada O asterisco que
temos aqui, certo? Isso faz com que o sublinhado colete vários valores ou
elementos ignorados , você poderia
dizer, da lista E se não tivermos
o asterisco, ok, esse sublinhado
só conterá um único valor em vez
da própria lista Então, isso é apenas uma
coisa extra que podemos fazer quando queremos
ignorar valores e coisas do gênero. Podemos combinar o
operador asterix com o sublinhado. Tudo bem, então aí está. há vários casos de
uso aos quais você pode Agora, há vários casos de
uso aos quais você pode se inscrever com o operador
Asterix
56. Funções Lambda: Olá a todos, bem-vindos
à próxima lição, que será focada nas funções do
Lambda. Então,
vamos dar uma olhada. Então você provavelmente está
se perguntando: Ok, o que diabos é a função
Lambda Portanto, uma função Lambda é uma função curta e
anônima que
usa vários argumentos, mas contém apenas uma
única expressão, que
significa que você definirá sua função Lambda
em uma única linha Ao contrário das funções regulares, nas
quais, é claro, você precisaria ter pelo menos algumas linhas para
colocar tudo em funcionamento. Mas com uma função Lambda, ela conterá uma única expressão em termos
de ordem e padrão E uma função lambda
é frequentemente usada para operações
curtas e simples, nas quais definição de uma função completa
é desnecessária Então, se você está pensando
consigo mesmo, ok, eu preciso criar uma função, mas será uma função
bastante curta. Então é aí que entra
o valor
da utilização de uma função Lambda Se, no entanto, você tiver uma função bastante longa com
muitos requisitos, muitos argumentos, parâmetros e funcionalidades
que precisa ser
adicionada ou uma função que geralmente é mais complexa
em seu caso de uso geral, opte por funções Mas, como eu disse, qualquer coisa
curta e rápida ou qualquer coisa que você simplesmente não precise
de muitas funcionalidades, então as funções
são a melhor opção, e eu
recomendo fortemente que você as utilize
porque elas podem ser muito úteis em
determinadas situações. Sim, em qualquer caso, isso é
tudo que tenho a mencionar teoricamente em
termos de funções Lambda Em seguida, vamos nos concentrar
nos exercícios práticos de laboratório,
onde vou começar com suavidade e facilitar a leitura e apenas ensinar a diferença entre uma
função e uma função Lambda,
especialmente e principalmente, devo dizer, em sua sintaxe Mas abordaremos isso
nos exercícios de laboratório. Mas, de qualquer forma, isso é tudo para
uma visão geral teórica.
57. Execute operações com Lambda — [Lab]: Oi, pessoal. Bem-vindo ao próximo
exercício prático de laboratório, que se
concentrará na utilização das funções
Lambda no Agora, é claro, para manter isso muito simples
no começo, vou mostrar
como você pode comparar funções
regulares com funções Lambda
para que você
possa entender a
sintaxe e como você pode utilizar as funções Lambda adequadamente e desde o Vamos começar. Primeiro de tudo, vamos definir uma função regular. Vou apenas
adicionar um comentário e dizer função normal. Então,
é claro, você começaria com sua palavra-chave, que é Jeff Em seguida, você definiria o nome da
função, que seria, digamos, sublinhado
olá, por exemplo Então, na próxima linha, podemos simplesmente dizer print e podemos dizer hello world como exemplo. Então, isso será o que a função
produzirá quando for chamada. Então, podemos chamar nossa função, que é dizer sublinhado olá, e isso
chamará essa função e imprimirá hello world
no terminal Então, se eu salvar isso
e executar o código, ele vai dizer Olá, mundo. Perfeito. Agora vamos
ver como podemos aplicar isso quando estamos trabalhando
com uma função Lambda O que vou fazer
não é remover esse código, mas
vou simplesmente comentá-lo
para que você possa entender sintaxe e
a
lógica com mais facilidade Vou adicionar um comentário
aqui que diz a função Lam D. E a primeira coisa que
você quer fazer é definir o nome da função. Agora, com as funções do Lambda, o que você faria é
defini-las como iguais Então, por exemplo, nesse caso, você pode dizer
sublinhado olá, e esse é o
nome da sua função no Lambda, muito semelhante ao que tínhamos na função regular em que
dizemos sublinhado
olá. A mesma coisa. É assim que você define
uma função no Lambda, depois diz igual
e a define E então eu quero saber
se Lambda here equals é a expressão para configurar
uma função Lambda muito semelhante a dizer morte
para Tente ver isso como a mesma coisa. Em seguida, podemos adicionar nossos dois pontos e definir
o que queremos fazer Então, nessa função say hello, definimos que queríamos
imprimir hello world. Mas fizemos isso
dentro da função. Com a função Lambda
com a função Lambda, estamos fazendo isso na mesma linha Portanto, esse
mundo de impressão gráfica estará aqui na
mesma linha da função Lambda Isso é o que eu quis dizer
nas palestras teóricas quando
mencionei que, com o Lambda, será uma expressão
única Então, podemos simplesmente dizer imprimir
e dizer olá, mundo. Lá vamos nós. Então, queremos
chamar nossa função, que será exatamente como nossa
função regular que tínhamos
aqui e também
teremos os parênteses,
para que possamos apenas dizer
sublinhado, para que possamos apenas dizer
sublinhado Então, agora podemos executar esse código, e podemos ver aqui que ele
gera hello world Muito bem, é assim que você pode utilizar uma função Lambda, e espero que isso
faça sentido com a sincronização e o uso em comparação Mas não se preocupe,
vamos ver
alguns exemplos aqui
e vamos passar alguns exemplos aqui
e vamos passar por outra comparação
direta entre uma função regular e
uma função Lambda Certo. Então, vamos remover tudo aqui, exceto
o comentário acima, e agora queremos
adicionar dois números. Portanto, uma função regular para fazer
isso e uma função Lambda. Agora, algo que eu quero
mencionar é que quando você está trabalhando
com funções Lambda, normalmente não
é adequado para definir variáveis dentro de
uma função Lambda Agora, eu sei que em funções
regulares, você pode fazer isso com variáveis
locais, mas na verdade não é uma coisa
boa em Lambda Então, muitas vezes, se
quiser retornar um resultado, você preferiria dizer return em vez de definir uma variável
e depois imprimi-la. Então, apenas algo que eu
quero mencionar com antecedência. Ok, essas são as funções
regulares finais. Eu direi que Def adicione números de
sublinhado. Desta vez, vamos trabalhar com
parâmetros. Eu terei X e Y, por exemplo, e então eu vou ter uma instrução de retorno
simples que diz return X mais Y. Então eu quero
utilizar a instrução print
outside
e dizer print, e então eu quero
envolver o nome da função que é adicionar os números
quadrados, e então precisamos
colocar os argumentos que queremos enviar
para os parâmetros de e Y para que possamos retornar o resultado por meio da
função de impressão do que é X mais Y. Aqui eu vou
dizer apenas cinco e sete. Ele retornará
cinco mais sete, e isso
será impresso como
saída , que deve ser 12. Vamos seguir em frente e
executar esse código. Então, podemos ver 12.
Então, vamos lá. É assim que podemos
definir uma função
regular simples para adicionar números. Agora, vamos aplicar essa
função aqui como uma função Lambda
ou retransformá-la Então, vou adicionar um comentário
e dizer função Lambda. Então, tudo o que você precisa
fazer é lembrar novamente que você precisa se referir ao nome da sua função
Lambda Então, aqui usamos adicionar números para a função regular.
Nós podemos fazer o mesmo. Em seguida, você quer dizer
iguais e Lambda. Agora, o que você quer fazer
é, ao lado do Lambda, garantir que você vá em frente e adicione
seus parâmetros Aqui temos X e Y, e tudo o que precisamos fazer é adicionar um espaço ao lado do
Lambda e dizer X, Y, e esses são seus parâmetros Em seguida, ao lado disso, você
deseja adicionar seu cólon. Portanto, é muito parecido
com o que temos aqui. Então, temos X, Y, mas aqui não
temos parênteses e adicionamos
dois pontos no final,
e fazemos a mesma coisa
com nossa função Lambda Você quer definir
o que você realmente quer fazer na sua função
Lambda Então, em nossa função regular, estamos dizendo return X mais Y. Então, aqui, tudo o que
precisamos fazer é dizer o que realmente
queremos fazer diretamente Eu vou dizer X mais Y, sem
mais nem menos. Em seguida, diremos
imprimir como fizemos antes
e, em seguida, você deseja
passar o nome da função. Então, no nosso caso, ele adiciona números de
sublinhado. E, assim como quando você
envia seus argumentos
, será
exatamente o mesmo tipo de estilo das funções regulares. Você terá
seus parênteses e posição ou
nas palavras-chave, colocará o que
deseja devolver Eu vou dizer cinco e sete. Então, temos isso pronto. Então, agora, se executarmos nosso
código, obteremos 12. Certo, perfeito. Lá vamos nós. Então é assim que você pode utilizar uma função Lambda
e, o mais importante, como você pode utilizar
a sintaxe da função
regular para
ajudá-lo a aprender rapidamente as funções do
Lambda e como
utilizá-las em comparação o funcionamento de uma função regular.
Certo. Perfeito. Assim, podemos remover essa caneta. Tudo bem, então essa
é a primeira parte na utilização das funções do Lambda Vamos trabalhar em mais
alguns tipos extras de como posso dizer
atividades e exercícios. Então não se preocupe.
Temos mais chegando. Tudo bem. Então, agora vamos
trabalhar com o Lambda, já que
agora estamos bastante confiantes em entender a definição de como
usamos uma sintaxe e Então, vou trabalhar na
criação de alguns programas. Então, primeiro, percebemos
para nós mesmos: Ok, como posso criar um pequeno
programa que seja útil e rápido de resolver com uma função Lambda que pode ser entediante com Então, digamos que queremos
elevar um número ao quadrado. Precisamos definir os nomes
das funções. Eu vou dizer quadrado é igual. Então, precisamos dizer que isso será uma função Lambda Precisamos decidir,
vou colocar quaisquer valores. Vou colocar um valor para que
seja igual a
um parâmetro. Posso simplesmente definir o
parâmetro como, digamos, Num. O que eu quero fazer? Eu quero devolver alguma coisa? O que eu quero fazer é,
na verdade, retornar qualquer número multiplicado por NUM Então, vou garantir que eu
imprima os resultados. Vou dizer imprimir e
quero inserir o nome da função que
é quadrado e,
em seguida, colocar o argumento que será passado para
o parâmetro aqui como NUM e, em seguida, vou pegar esse número associado e
multiplicá-lo por si mesmo Então, quatro vezes quatro. Agora, se executarmos o código, podemos ver se obtemos 16, e é exatamente assim que podemos quadrado um número com
uma função Lambda Certo, vamos fazer
outro. Digamos que queremos dobrar um número. Então, criaríamos uma função e poderíamos chamar isso de duplo, por exemplo, e isso será
uma função Lambda, então precisamos definir
isso adequadamente Vamos considerar
um parâmetro aqui. Então, vou definir
isso como X, por exemplo. E o que eu quero fazer? Eu quero retornar,
seja qual for o resultado de X multiplicado por dois OK. Então eu
quero imprimir isso, eu vou dizer imprimir e
eu quero imprimir qualquer que seja o resultado
da função, então eu preciso chamar a função
para que isso ocorra e seguida, passar pelo argumento, que substituirá X e
então X vai
para o próximo código dentro da função
Lambda
e diga X vezes dois Nesse caso, seis vezes dois. Agora podemos executar esse
código. E nós temos 12. Perfeito. Isso é dobrar um
número. Vamos mudar isso. Vamos entrar na lista. Agora, digamos que queremos obter o primeiro elemento de uma lista. Vamos definir o nome da
nossa função,
você poderia dizer. Vou definir isso como, eu diria que primeiro é igual, esse
será o nome da minha função Será uma função
Lambda. Vamos
esperar um parâmetro, então posso simplesmente chamar
essa lista LST,
por exemplo, com dois pontos E o que eu
realmente quero fazer? O que eu realmente
quero devolver? Então, eu quero retornar o
primeiro elemento na lista. E agora lembre-se de que, na
lista PySon, comece em zero. Então eu vou dizer, OK, a lista aqui, e eu
quero olhar para zero. OK. Então, o que eu quero
fazer é dizer print, referir-me ao primeiro nome da
função
e, dentro de parênteses, quero
definir uma lista como está Eu vou dizer que dentro
da lista dez, 20, 30. Agora, o que vai
acontecer é que eu vou passar por essa lista aqui, que está aqui definida
na minha desculpa, está definida aqui dentro
do argumento aqui Eu tenho dez, 20 e 30, primeiro vou
abrigar tudo isso. Ele será
passado para o parâmetro. Toda essa lista que eu
defini primeiro. Então, o que vai
acontecer é que vamos
chamar a lista e
procurar o primeiro item, que será dez, e
isso será a saída. Se eu executar esse código, veremos que
ele produz dez Estamos apenas
passando por essa lista como um argumento em si dentro
da primeira função. Ok, então é assim que
podemos fazer exatamente isso. Agora, digamos que queremos obter o segundo elemento de uma lista. Em outras palavras, isso
vai ser zero, um. Então, podemos dizer que segundo
é igual a Lambda, e podemos dizer
lista novamente, dois pontos, e então podemos dizer lista, e o resultado que queremos
retornar É o segundo
elemento, tecnicamente
da lista, mas indicado por Podemos dizer imprimir, passar
pela função e pelos
argumentos da função, que vamos definir
como uma única lista com itens de 15, 21, 87. Portanto, agora ele deve imprimir 21, então passaremos essa lista aqui, para a lista aqui
como parâmetro, e então vamos consultá-la no processamento e
procurar o segundo elemento,
que será 21. Então, vamos executar isso.
E então temos 21. Perfeito. Tudo bem, pessoal Então,
isso é essencialmente sobre como
nos apresentarmos às funções Lambda e como podemos usá-las
e, o mais importante, como podemos distingui-las
entre uma função regular Agora, não terminamos
com as funções Lambda, há mais algumas funções
incorporadas que eu quero usar com funções
Lambda que são bastante populares
para muitos desenvolvedores, e eu quero me aprofundar mais
na função Lambda, então vamos fazer apenas a ideia geral das funções
Lambda e como você pode Agora você pode praticá-lo
e
utilizá-lo no básico, pelo menos para
saber como
passar pelos parâmetros, como gerar
dados e coisas assim Isso é tudo para este exercício
prático de laboratório.
58. Aplique funções lambda a outras funções: Olá a todos, bem-vindos
à próxima lição que se
concentrará na aplicação funções
Lambda a
outras funções Assim, podemos incorporar funções em nossas funções do Lambda,
dependendo do que gostaríamos de fazer.
Mas vamos dar uma olhada. Portanto, as funções Lambda
funcionam bem com funções
integradas,
como a função map, e isso basicamente aplica uma função a cada
elemento em um iterável, retornando
assim um novo iterável
com Também temos a função de filtro e ela seleciona
elementos de um iterável com base em
uma função que retorna verdadeiro ou falso, para que possamos ver uma
situação ousada de dois estados Finalmente, uma função muito popular para utilizar com o Lambda
é a função de redução Isso aplica repetidamente
uma função para combinar todos os elementos em um iterável em um único valor.
Então aí está. Portanto, as funções do Lambda também
podem funcionar com outros tipos
de funções integradas No entanto, essas são as
mais comuns que maioria dos desenvolvedores usaria ao
trabalhar com o Pison,
a função de mapa,
a função de filtro
e a função reduzida
com uma função Lambda. Normalmente,
elas são a função de mapa,
a função de filtro
e a função reduzida
com uma função Lambda. Normalmente, incorporadas a ela para executar uma determinada consulta de código
que é adicionada ao local Tudo bem, pessoal. Então, isso é tudo para a visão geral
teórica. Agora vamos nos
concentrar em integrar essas funções em
nossas funções do Lambda e juntar
59. Incorpore lambda com outras funções — [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de
laboratório, que se
concentrará em utilizar
o filtro de mapas e reduzir as funções dentro da própria
função Vamos integrar
tudo junto. Vamos começar
com a função de mapa. Essa é a primeira coisa
com
a qual vamos querer começar. Vamos seguir em frente e fazer exatamente isso. Agora, a primeira coisa
que vamos querer fazer é definir
uma lista de números. Eu vou dizer números. É igual, e eu
vou dizer um,
dois, três, quatro e cinco Agora, o objetivo principal de
utilizarmos a função map
nesse caso de uso é porque
queremos modificar cada item em
uma lista e, em seguida, queremos
retornar uma lista modificada que executará
alguma funcionalidade Então, o que podemos fazer a seguir é ir uma cobertura e
configurar o seguinte Então, vamos fazer uma cobertura e definir uma variável aqui Então, vou
dizer que resultado é igual, e vamos definir
isso para nossa função de mapa E vamos
usar map para aplicar
uma função a cada
elemento em nossa lista,
ou seja, um, dois, três, quatro e cinco de
forma independente a cada vez. E dentro da nossa função de mapa, vamos adicionar a função Lambda Então, vamos dizer que sou D e vamos
passar por um parâmetro. Eu vou ter X, por exemplo. E então, a ação
que eu quero realizar, eu quero multiplicar cada
item por dois na lista Vou dizer X asterisco dois
ou multiplicar por dois. E para fazer isso,
vamos usar a lista
de números. Então, vamos seguir em frente e nos referir
aos números variáveis. Ok, então temos
isso em prática. Perfeito. Então, deixe-me dar uma visualização do
que vai acontecer Então, temos um, dois,
três, quatro, cinco. Agora vamos aplicar números
aqui
a essa função Lambft
e, essencialmente,
você deve vê-la
como se fosse proveniente de números Então, um substituirá X, e então um vezes dois
será dois, e isso será armazenado e processado com nossa lógica aqui que temos em vigor
com o mapa e a função Lambda, e isso será armazenado
até que possamos posteriormente
enviá-lo para uma lista Em seguida, vamos para o próximo item da
lista, que será dois,
dois serão de números
e, em dois serão de números
e, seguida, substituiremos
X dois e, em seguida, digamos
duas vezes dois, e isso
será quatro. Fazemos a mesma coisa com
o resto dos números para que, eventualmente,
seja o resultado de dois, quatro, seis, oito e dez. Então, o que queremos
fazer é ir até uma cerca e converter
nosso objeto de mapa Esse
será nosso objeto de mapa, que armazenamos no resultado
da variável. Podemos criar uma variável aqui,
agora chamada de números duplicados, e vamos converter a lista do
resultado final que obtemos aqui O resultado do processo de saída que obtemos
dessa funcionalidade. O resultado agora, neste caso, não é uma função Lambda, como
demonstramos ou referenciamos, como
na atividade prática anterior sobre funções do Lambda porque quando você está lidando com funções
incorporadas ao Lambda, como mapear, reduzir e filtrar, a variável que
você atribuiu a ela, como neste caso, resultado aqui não será
a função Essencialmente, será
apenas uma variável que
será armazenada. O valor que
foi processado, pois tudo é
executado aqui e não em uma função
Lambda separada De qualquer forma, armazenaremos os resultados aqui na
lista para que possamos converter o objeto de mapa
que temos agora em uma lista para que possamos
ver os valores modificados. Então, para fazer isso, agora podemos dizer imprimir e nos referir a números duplicados Tudo bem, perfeito. Agora
podemos executar esse código e ver se
obtemos a saída dois,
quatro, 6810. Perfeito. É assim que podemos seguir em frente
e configurar isso como deveria. Certo. Agora,
vamos dar uma olhada na função do filtro. Então, mais uma vez, teremos
alguns números. Vou apenas adicionar,
digamos, um número extra
e, em seguida, vamos utilizar a função de filtro. Agora, planejamos usar a função de filtro para
manter somente números pares. Então, vamos seguir em frente
e definir uma variável, que serão resultados para que possamos armazenar o resultado aqui que
temos do nosso valor aqui
do objeto de filtro. Então, vamos armazenar o
resultado do objeto de filtro. E vamos dizer filtrar e incorporar a função Lambda E, novamente, teremos um
parâmetro, que podemos chamar de X. O que queremos fazer é usar uma defunção am
para verificar se cada número ou X é
divisível por dois para,
em outras palavras, manter apenas
alguns itens de Em outras palavras, devemos
gerar números pares. Podemos seguir em frente e
fazer isso dizendo X, e então podemos adicionar nosso símbolo de
porcentagem, digamos dois, equivalente a zero, e vamos trabalhar
com a variável de números, que é essencialmente a
lista com a qual trabalharemos. Vamos continuar
nos conectando aqui.
Vamos pegar um. Em seguida, vamos
passar o substituto um
para X e, em seguida, vamos verificar aqui
se um é dividido por dois, se por algum motivo, o número não
for par, vamos apenas omiti-lo
da lista que
vamos gerar e depois salvar
apenas o que será
par e divisível OK. Depois desse processo, e novamente, como
a função de mapa, verificaremos cada
item ou elemento que você poderia dizer cada vez e, em seguida, armazenaremos os resultados
necessários à medida que avançamos. Em seguida, queremos converter
nosso objeto de filtro em uma lista para que possamos
ver nossos valores filtrados, para que possamos encontrar uma variável
conhecida como números pares, por exemplo, e usar uma lista para gerar resultados
aqui, essa variável E então o que podemos fazer é imprimir
a lista filtrada Então, podemos dizer imprimir
e podemos
dizer números pares de sublinhado E que imprimiremos 24 e seis, que é exatamente o que
queremos como resultado. É assim que podemos seguir em
frente e garantir que possamos filtrar para que possamos manter
apenas alguns itens
da nossa lista. Certo, perfeito. Agora, a última função
que queremos ver é como podemos utilizar
a função de redução. Então, essencialmente, o que queremos
fazer é combinar todos os itens que
temos em um valor, então vamos resumir e somar, você poderia dizer. E para fazer isso, precisamos
importar a função reduzida, que vem
do módulo funk tools Portanto, está embutido. Então, podemos dizer que, a partir do funk tools, que é o módulo, eu
quero importar a função reduzida Agora, também queremos ter uma lista de números com os quais
queremos trabalhar. Então eu vou dizer números, e eu vou ter um, dois, três, quatro e cinco. Em seguida, vou garantir que utilizo reduce para somar
todos os números. E, novamente, precisamos
ter uma variável para que
possamos armazenar o resultado, é
claro, então é necessário
chamá-la de result. E podemos então usar
a função reduce, que incorporará o Lambda E, novamente, teremos desta vez dois parâmetros
porque estamos somando, estamos somando números.
Então, teremos X e Y. E então a ação que
queremos realizar e o que
queremos retornar é o
resultado de X e Y aqui. E em que vamos
basear isso? Do que vamos
obter nossas informações que queremos adicionar a partir
da variável de números aqui, que podemos simplesmente
associar, assim. Ok, então a função and, pegaremos dois números, X e Y dos números, e ela os somará, e depois continuará somando até obtermos
o resultado final. Então, com os números aqui,
o que vai acontecer é que
vamos seguir em frente e somar os números adequadamente até obtermos o resultado final. Então
, vai ser um. Então era X e Y, será
um mais dois igual a três. Três mais três é igual a seis,
seis mais quatro é igual a dez
e, em seguida, dez mais
cinco é igual a 15 E é assim que vamos seguir em frente e ver a sequência de
operações à medida que avançamos. Agora, o resultado final, é
claro, deve ser 15, mas vamos imprimir o resultado para que
possamos esclarecer. Lá vamos 15 e
aí está. É assim que podemos combinar todos os itens em um
valor como exemplo de soma. Tudo bem, pessoal. Isso é tudo para este exercício prático de laboratório. Sei que isso pode ter
sido um pouco difícil, mas é assim que podemos seguir em frente se quisermos
combinar funções diferentes e utilizá-las com nossa função
Lambda Agora, uma coisa importante
que eu também
quero apenas reiterar Lembre-se de que, quando estávamos usando funções com lamb,
como map reduce e filter,
anteriormente, quando
trabalhávamos com funções, você podia ditar e
se referir ao que
associamos à função
Lambda como o
nome da função, digamos Mas neste caso aqui,
isso simplesmente será
uma variável para armazenar o
resultado do que está ocorrendo. Se esse resultado será especificamente um objeto de filtro ou se
ele retornará um valor específico de tipos ou se
retornará o objeto de mapa,
isso é algo para o qual o
estamos utilizando, não como um nome de função Tudo bem. Então aí está. Então, a última coisa que
quero mencionar é
lembrar também, mais
uma coisa, que
quando estivermos trabalhando com o objeto de mapa,
estaremos armazenando. Quando estamos trabalhando com
a função map, armazenamos o objeto map, quando trabalhamos com
a função filter, armazenamos um objeto de filtro
e quando trabalhamos, claro, com reduce e especificamente neste caso, com
a função reduced, armazenamos um valor específico que, é claro
,
geraremos se quisermos
imprimi-lo. Ok, vá. É isso mesmo. É assim que podemos integrar outras
funções com o Lambda
60. O que é programação orientada a objetos?: Oi, pessoal. Bem-vindo
à próxima lição, que se
concentrará
em analisar o que é
programação orientada a objetos. Agora, esta lição
fará parte de uma série de aulas, então tudo
estará conectado. será
distribuído um
pouco próximo conjunto de aulas será
distribuído um
pouco, mas agora está tudo
junto e parte como um só. Portanto, a
programação orientada a objetos é uma abordagem
de programação centrada no conceito de
classes e objetos Então, sua próxima pergunta
provavelmente é o que são
classes e objetos? Então é isso que discutiremos em detalhes
na próxima lição, que se
concentrará em observar classes
e objetos de
uma perspectiva de definição e
também de uma perspectiva de analogia. Vou
diferenciar os dois e ver, em geral, como isso acontece
no foco da
programação orientada a objetos como um todo Portanto, fique ligado
na próxima lição, vamos mergulhar nas
classes e nos objetos
61. Classes e objetos: Oi, pessoal. Bem-vindo
à próxima lição, que se concentrará em classes e objetos.
Vamos dar uma olhada. O que é uma classe e um objeto? Simplificando, uma classe é um modelo para
criar um objeto, enquanto um objeto é uma instância específica
dessa classe específica Agora, eu sei que isso pode ser
um pouco confuso no começo, mas vamos dar uma olhada em uma analogia
para ilustrar melhor Então,
digamos que temos uma pessoa. Podemos chamar uma pessoa de classe. Agora, uma pessoa tem um
conjunto de atributos. Assim, uma pessoa terá, por
exemplo, um primeiro nome. Eles terão um sobrenome. Eles terão sua
idade, sua nacionalidade. Então, esses são vistos
como atributos no PySon, onde a própria
pessoa, como a estrutura, a
pessoa é a classe Agora podemos ir um
pouco mais longe e dar uma olhada nos objetos. Agora, os objetos, como
mencionei, são, obviamente, as próprias
instâncias. Podemos, por exemplo, ter
um objeto que
pertença a uma pessoa única
e essa pessoa única,
por exemplo, pode ser
chamada de Lucy Johnston, 22
anos e sua
nacionalidade Ela é da Alemanha. Digamos que temos outro objeto,
outra instância específica. Então, temos outra pessoa
única. Essa pessoa é Mark Smith. Ele tem 21 anos e é da Áustria. Então é assim que tudo se
relaciona com a
classe, o projeto,
os atributos para seguir em relaciona com a
classe, o projeto,
os frente
e descrever essa classe aqui e, em seguida, os objetos que
são as instâncias específicas Vamos dar uma olhada em
outra analogia para solidificar nossa compreensão
de classes e Digamos que temos um carro. Agora, o carro pode ser visto como
uma classe e como um modelo. Agora, um carro terá vários atributos,
como a marca, a cor, o modelo, o ano do modelo, por exemplo, e terá um conjunto de instâncias
únicas em
termos de objetos. Podemos ter um carro exclusivo
em particular que é da marca GMC A cor Sage, é o modelo GMC E two e
o modelo Y é 2007. Então, também temos outro exemplo
específico, que será o
de um BMW, por exemplo. A cor é azul,
é o BMWX três, e o modelo E é 2011. Tudo bem. Então é assim que eu quero que você entenda
o processo de programação orientada a
objetos quando estamos trabalhando com nossa classe, os atributos associados
dessa classe e os objetos que são instâncias específicas que
estão correlacionadas Ch. Então, tente ver
tudo junto como Zach E o que eu também recomendaria,
se também estiver ficando um
pouco confuso, basta revisar mais
algumas vezes as analogias e com a definição que eu dei
e tentar vinculá-las Mas não se preocupe. Depois de
praticarmos isso nos exercícios práticos de laboratório, você verá com que facilidade aprenderá. E é assim que eu quero que você
veja enquanto trabalhamos com programação orientada a
objetos
e, especificamente com as classes e
os objetos em questão.
62. Criando nosso primeiro curso e objeto — [Lab]: Oi, todo mundo. Bem-vindo ao
próximo exercício prático de laboratório, que será focado em aulas e objetos.
Vamos começar. Agora, a primeira coisa
que precisamos fazer é definir nossa classe. Agora, lembre-se, uma aula
é como uma planta, vamos criar uma
classe de uma pessoa Eu vou dizer pessoa da classe. Em seguida, podemos ir para a
próxima linha e recuar. E a próxima coisa
que vamos
querer fazer é definir nosso método init Agora, o método innit é
essencialmente um método especial, também
conhecido como
método Dunder, e é chamado quando um
novo objeto é criado e ajuda a inicializar os atributos
do nosso Agora, os atributos
incluem, por exemplo, o ID da pessoa,
seu primeiro nome, seu sobrenome, sua idade, sua nacionalidade, etc Então, o que podemos fazer é seguir em frente e dizer D double underscore init E dentro de nossos
parênteses, precisamos
passar por, em primeiro lugar
, self, e self representará
a instância de nossa classe, e isso permitirá o acesso aos atributos e métodos da
instância,
se tivermos algum método, é
claro Agora, queremos definir
nossos parâmetros. Agora, isso
incluirá, por exemplo, as informações da pessoa, ou
seja, seu nome, sobrenome,
nacionalidade asiática, etc E primeiro vamos
configurá-lo como parâmetros, ok? Então, isso será
temporário
e, em seguida, será
atribuído como uma
variável permanente com self, mas chegaremos a
isso em um momento. Então, podemos seguir em frente e
definir, por exemplo, ID. Teremos o primeiro nome de
sublinhado, teremos o último nome de sublinhado, teremos idade e Tudo bem Então, deixe-me ampliar
aqui para maior clareza. E então nós só queremos adicionar dois pontos, e vamos continuar Tudo bem. Agora, a próxima
coisa que vamos querer
fazer é
atribuir nossos parâmetros aos atributos de
nossa instância. Então, o que vamos fazer é
dizer ID de ponto próprio. É igual a ID. Então, o que estamos fazendo aqui é essencialmente atribuir,
por exemplo, o parâmetro ID ao atributo
de instância de self dot ID E essa
será essencialmente a identificação exclusiva da pessoa, e fazemos o mesmo para o resto, o mesmo tipo de processo. Vamos dizer self dot,
primeiro nome de sublinhado. Isso será igual ao
primeiro nome do sublinhado. Em seguida, faremos ponto próprio, último sublinhado, igual ao nome do
último E você pode vê-lo sendo
configurado de
acordo com o uso. Então, podemos ver que o
ponto próprio g é igual à idade. Nacionalidade própria é igual a
nacionalidade, sem mais nem menos. Temos tudo isso instanciado. Agora, só para dar um
pouco mais de clareza aqui com a
palavra-chave self que estamos usando. Lembre-se de que é uma referência
à instância atual
dessa classe e
nos permitirá acessar e modificar nossos atributos específicos para cada objeto que temos. Apenas lembre-se disso.
Então, quando temos aqui, identificação de ponto
próprio,
nome próprio, eu, o sobrenome,
idade do ponto próprio e nacionalidade própria Você pode vê-los como atributos, e cada atributo é
uma variável que armazena dados específicos
do objeto. Então, aqui, é claro, será o D da pessoa, seu primeiro nome,
sobrenome, idade e
nacionalidade Então, isso é essencialmente
o que estamos fazendo lá. Agora, a próxima coisa que precisamos fazer é
criar uma instância do nosso objeto
da classe person. Então, vamos fazer isso. E precisamos garantir que ajustemos
onde estamos fazendo isso. Portanto, ele precisa estar na
mesma linha da nossa classe aqui. Então, vamos criar um objeto
da classe pessoa. Portanto, podemos dar a essa variável
o nome que quisermos. Eu vou dizer que a
pessoa um é igual, e então precisamos
referenciar a classe de pessoa E dentro dessa classe, basicamente
vamos
adicionar nossos valores ou argumentos, você poderia dizer, dos
atributos que temos. Ok, então podemos ir em frente
e colocar o valor. Então, primeiro, teremos ID, nome, sobrenome,
idade e nacionalidade Eu vou ignorá-los. Vou dizer um para a identificação. Então temos o primeiro nome. Vou dizer Ono, depois
temos o sobrenome, direi Pretorius e depois
teremos idade, LLC,
29, e então
teremos nacionalidade,
diz da África, sem Então é assim que podemos criar um objeto da classe person. Em seguida, queremos imprimir
os atributos da pessoa. Portanto, lembre-se de que temos nossos
atributos configurados adequadamente. Então, ID, nome,
sobrenome, idade e nacionalidade. Agora queremos imprimi-las, então vou mostrar
como podemos fazer isso. Podemos então, por exemplo, dizer
imprimir e, em seguida, queremos nos referir
à variável que definimos aqui que está atribuída
ao seguinte, e podemos apenas dizer pessoa
um e você pode simplesmente dizer ponto e, em seguida, seguir
pelo atributo. Assim, podemos dizer ID por enquanto, imprimir
primeiro um ponto da pessoa e sublinhar o nome E imprima a pessoa com um ponto e
teremos o último nome de sublinhado. Isso vai
continuar e
imprimir o valor que foi
atribuído ao nosso atributo. Nós temos um, temos Arno
e Pretors e é isso que será impresso em nossa
saída Vamos continuar
produzindo e executando esse código. Vamos fazer isso. Vamos lá, então pegamos um, ganhamos honra e
temos Pretorius É assim que podemos fazer uma cobertura e garantir que tenhamos a
produção como deveria ser Vamos deixar isso um pouco
mais claro para que você possa ver a saída ideal, o primeiro nome e
o sobrenome É assim que podemos
essencialmente criar nossa classe, como podemos definir
nosso método innit, configurar nossos parâmetros e como podemos entrar em uma
cobertura e configurar o resto e como
nossos parâmetros se tornam
essencialmente atributos Tudo bem Isso é tudo para
este exercício prático de laboratório, muito
bem como criar sua primeira classe e também definir seu primeiro
objeto aqui e também todos os dados
necessários fazendo referência dizendo
ponto seguido pelo nome do
atributo e, em seguida, obtendo todos os dados que foram
vinculados ao objeto S. Então é isso.
Vou adicionar exercício prático
extra de
laboratório aqui, que será mais
focado na explicação. Então, vou
explicar um pouco mais, e podemos praticar um
pouco, um pouco mais de
prática também. Assim, você pode ficar atento
ao próximo exercício ou passar
para a próxima lição Depende realmente de você
o que você quer fazer. Mas é isso, eu direi, para este exercício de
laboratório em particular.
63. Aprofunde-se nas aulas e objetos — [laboratório opcional]: Oi, pessoal. E bem-vindo ao próximo exercício prático de laboratório, que basicamente também
será opcional. Portanto, se você quiser pular uma
cerca viva, é mais do que bem-vindo a fazê-lo e seguir para
a próxima lição Caso contrário, o que
vamos fazer é continuar com classes e
objetos com mais detalhes. Certo, então eu quero
mencionar um pouco mais sobre parâmetros
e atributos. Assim, podemos ver os campos
importantes que
definimos e que queremos utilizar, como ID, nome,
sobrenome, idade e nacionalidade Agora, nisso, como posso dizer, parênteses aqui
do método int, eles
são vistos como
nossos parâmetros, são vistos como
nossos parâmetros, e eles só existem dentro
desse método int temporariamente Em seguida, utilizando self dot. O que estamos fazendo aqui
essencialmente é
configurar nossos atributos,
como ID, nome,
sobrenome, idade e
nacionalidade, dizendo ponto
próprio e , em seguida referindo-se
à nacionalidade, idade, sobrenome, nome e ID, pertencem ao objeto
e podem ser Nossos atributos pertencem ao nosso objeto e podem
ser acessados posteriormente. Então, é claro, como sabemos,
estamos criando um objeto, também conhecido como criação de
nossa instância. E o que faremos
aqui depois com nossas instruções de impressão
aqui é acessar nossos
atributos porque agora
eles estão declarados
em nosso objeto. Outra coisa que também
deve ser mencionada aqui com os parâmetros que
definimos aqui é que eles não existem
fora do nosso método innit Somente nossos atributos, que
definimos, permanecerão e poderão ser chamados
fora de nossa classe Então, apenas algo que
eu queria mencionar para que você esteja ciente do
que estamos configurando. Ok, e uma última coisa, saiba que nossos
parâmetros aqui, novamente, são temporários e existem
apenas enquanto o innit é executado, e nossos atributos, que
definimos usando self dot, são permanentes e
viverão dentro do nosso objeto Tudo bem. Então,
isso é tudo que eu queria
mencionar para que você tenha uma
compreensão mais profunda de como podemos utilizar as duas opções. Tudo bem. Agora, a próxima
coisa que vamos fazer é fazer outro exercício
prático. Então, vou mostrar como podemos criar outra turma, para
praticarmos mais com ela. Tudo bem, então vamos continuar
e praticar mais. Então, agora queremos
definir outra classe, configurar nossos atributos, criar
nosso objeto, etc Então, vou deletar isso
e vamos começar. Então, eu quero dizer aula, e vamos trabalhar
com um carro, por exemplo. Então, queremos seguir em frente e
configurar nossa mensagem inata. Vou dizer de double
underscore init, pass through self e, seguida,
com o que
vamos trabalhar e o que queremos, em última análise, como nossos atributos no Então, teremos marca, ano do
modelo e cor. No cólon. Em seguida, definimos nossos parâmetros
que são temporários. Agora, queremos
configurar nossos atributos, que serão armazenados
em nosso objeto. Então, para nos ajudar,
utilizaremos a marca self e digamos, a marca self dot,
é igual Então, teremos modelo de ponto próprio,
modelo igual a modelo, ponto
próprio aqui é igual a aqui
e cor de ponto próprio é e cor de ponto próprio Lá vamos nós. Então,
definimos isso adequadamente. Agora, queremos criar nosso objeto ou nossa instância
de nossa classe car e precisamos
ter certeza de fazer isso acordo com nossa classe, e não dentro desse método init Então, quero ter certeza de que estou
alinhado com a aula aqui. Então, o que eu vou
fazer é um carro, por exemplo, definir uma variável. Então eu vou criar
esse objeto da minha classe de carros. Eu quero me referir à classe, então eu posso
passar pelos valores. Aqui vou dizer,
por exemplo, Ty Yota. Então eu vou tomar Cola
e depois posso dizer 2021. E podemos ver o azul. Você pode ver que isso combina. Primeiro, é claro,
podemos ver que temos marca, então será Toyota, Corolla,
teremos modelo, teremos modelo, ano 2021 e cor azul.
Temos tudo isso definido. Agora, queremos acessar os
atributos do nosso objeto. Vou rolar para baixo agora e deixar eu realmente diminuir o zoom aqui. E digamos imprimir, e queremos nos referir
a essa variável. Então, vamos dizer carro com um ponto, e podemos apenas nos
referir ao atributo,
que será marca. Então podemos dizer
imprimir carro com um ponto, e então podemos dizer modelo, imprimir carro com um ponto, e teremos, e
depois imprimir carro com um ponto, e isso será cor. Então, eventualmente,
produziremos os valores
que temos aqui marca do ponto será a Toyota, modelo do
ponto será Corla, ponto será 2021 e a cor do ponto será azul Vamos seguir em frente e
executar esse código. E aqui podemos ver que
obtemos o seguinte resultado aqui, conforme o esperado. Tudo bem. Então é assim que podemos seguir em frente e trabalhar com nossas classes, nossos objetos, parâmetros
e nossos atributos, e como podemos juntar tudo
isso. Mas, em última análise, isso se
concentrou principalmente em classes e objetos. Tudo bem, pessoal. Então é isso. Vi que vou me esforçar um pouco possamos praticar um pouco
mais, mas isso será o suficiente para este exercício de laboratório
em particular, então podemos simplesmente mover
isso e pronto.
64. Métodos personalizados: Olá a todos, bem-vindos
à próxima lição, que será focada no método
personalizado.
Vamos dar uma olhada. O programa o que
é um método personalizado? Simplificando, envolve métodos que podemos
definir por nós mesmos dentro de uma classe para determinar as ações que seus
objetos podem realizar. Então, se fôssemos
fazer uma analogia, vamos utilizar uma com a qual
trabalhamos anteriormente Então, criamos anteriormente uma classe baseada
no plano da pessoa Os atributos que
temos, é claro, incluiriam ID,
nome, sobrenome, idade, nacionalidade e,
com nossos objetos, por exemplo, podemos criar
quantos objetos quisermos Mas, por exemplo, aqui
temos dois objetos, e eles pertencem a
cada pessoa única O que também podemos fazer
é adicionar um método a esses objetos . Portanto, nesse caso,
os métodos apropriados incluiriam, para a aula de uma pessoa,
comer, estudar e dormir. Por exemplo, se você
tivesse uma aula de carros, provavelmente
faria sentido ter métodos como carro de serviço,
dirigir carro, quilometragem ou algum tipo de método ou
ação, devo dizer De qualquer forma, você pode
tratar a mensagem como uma ação que pode ser incluída no caso de uso de acordo a natureza da sua classe e os objetos associados
que você cria. Tudo bem. Então, isso é tudo para
a visão geral teórica. Agora vamos começar a trabalhar nos exercícios de laboratório e aplicar essa lógica
a uma determinada classe.
65. Integrando métodos personalizados (instâncias) - [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de
laboratório, que se concentrará na utilização de métodos personalizados com
nossas aulas e objetos Vamos começar
com o básico primeiro definindo nossa classe, configurando nossa estrutura e depois criando nosso objeto Vamos escolher um exemplo mais familiar para facilitar a ideia de métodos
personalizados. Então, primeiro de tudo, vamos
definir nossa classe. Então, vamos
usar a pessoa novamente. Então, o que queremos
fazer é seguir em frente e definir nosso método init junto com
os parâmetros necessários Em seguida, vamos
dizer defunds init, seguido por um
sublinhado duplo novamente Em seguida, precisamos
passar por self e depois por ID. Primeiro nome de sublinhado, último nome de sublinhado e depois teremos idade e Vamos apenas diminuir o zoom aqui
e aumentar nosso k no final. Tudo bem Agora
podemos usar self para armazenar os valores em nosso objeto. Então, agora queremos
configurar nossos atributos. Então, vou dizer que ID de
ponto próprio é igual a ID, ponto próprio, primeiro nome de sublinhado é igual ao
primeiro nome de sublinhado, depois ponto próprio, nome do último sublinhado é igual depois ponto próprio último nome de sublinhado Então, a idade do ponto próprio é igual idade e a nacionalidade do ponto próprio é igual à nacionalidade. Perfeito. Nós temos essa configuração. Agora, fora do nosso método
aqui em linha com nossa classe, precisamos criar nosso objeto. Vou dizer que a
pessoa um é igual e, em
seguida, referir-me à classe da pessoa Então eu posso transmitir
meus valores. Eu vou ter um. John, depois Doe, então 28 anos e nacionalidade, podemos apenas dizer Ok, aí está. Então
, temos tudo definido. Há identificação, nome, sobrenome, idade e nacionalidade. Agora, vamos imprimir esses valores de acordo com os atributos
que referenciamos. Então, o que vou fazer é rolar um pouco para baixo e
podemos dizer imprimir. Refere-se à pessoa um, ponto, e então esse é o atributo. Teremos, é claro, o
primeiro nome sublinhado, e então podemos dizer pessoa
impressa um, ponto, e podemos dizer
nacionalidade, por Agora podemos seguir em frente
e executar esse código. Aí vamos às saídas, como
podemos ver John e USA. Definimos nossa
classe básica. criamos um
objeto e produzimos os valores que queremos de acordo com o
atributo que foi definido, e ele pega os valores do primeiro nome e da
nacionalidade de acordo Perfeito. Hora da mensagem personalizada. Certifique-se de que você tenha
implementado isso e que
tenha entendido. Agora praticamos muito
com aulas e objetos. Agora vamos aplicar a mensagem. Por enquanto, podemos simplesmente remover a declaração impressa e agora vamos
definir nossos mesods. Certo. Vamos continuar. Agora, quando você está configurando seus métodos, eles precisam estar alinhados
com seu método inato. Estará
em sua classe de acordo com a mensagem init Como você pode ver aqui,
há uma linha com recuo. Eu precisaria
fazer o seguinte. Esteja alinhado com
seu método init
e, em seguida, você poderá
definir seu método Eu vou dizer morte e
vou chamar isso de apresentação. Eu serei uma introdução para
que você possa dizer. Então eu preciso passar self
aqui como parâmetro. E estamos usando self para que
possamos acessar nossos atributos
armazenados. Portanto, temos, como você
pode ver, nome, sobrenome, idade e nacionalidade E o que queremos
fazer a seguir
é configurar uma declaração
impressa simples que apenas diga olá. Meu nome é espaço de dois pontos
e, em seguida, vou usar a concatenação de strings,
porque vamos
lidar com um valor de
string porque vamos
lidar com Então, eu vou dizer o nome do primeiro sublinhado com
ponto próprio. Certo. É assim que podemos
definir um método simples como esse. Agora self dot Fn
procurará o atributo e o valor que foi configurado para o objeto vinculado
a esse atributo Nesse caso,
será
que John sairá no final. Agora, tudo o que queremos fazer
agora é chamar esse método. Agora que esse método é
chamado de introduzir,
vamos aplicá-lo à primeira pessoa,
que, obviamente, está definida como essa em particular. Isso é definido como um objeto com o valor
de John como o primeiro nome. Então é assim que poderemos
dizer o primeiro nome de Seles, e ele será vinculado a esse objeto aqui
que estamos criando e
ao objeto
que criamos atributo de
primeiro nome,
que é John Então, para fazer isso,
precisamos invocá-la, e para invocar essa função, você pode simplesmente ir em frente
e dizer pessoa Suco de pontos e introdução, abrindo e fechando os parênteses E aqui, o que vai
acontecer é que vamos usar o acesso automático
ao
nosso primeiro nome, e isso vai imprimir
essa declaração, já que
estamos chamando isso de mesod E o que podemos fazer agora é
seguir em frente e executar o código. E diz: Olá,
meu nome é John. Ok, então é simples assim. Então é assim que podemos simplesmente seguir em frente e
criar um método. Tudo bem Agora vamos continuar
e criar outro método. Quero criar um que
diga feliz aniversário. Podemos ver que John Doe
tem atualmente 28 anos, então preciso criar um novo
método. Deixe-me rolar para baixo. Eu vou dizer que este
será DF e
terá underscore birthday
the mess a name Vou passar por self para que possamos acessar os atributos
e, em seguida, precisamos adicionar algumas funcionalidades. Então, podemos dizer que a
idade do ponto próprio mais é igual a um, e isso atualizará o atributo de idade que está armazenado no objeto
e adicionará um a ele John então terá
29 anos tecnicamente. Então, agora
vamos
imprimir isso . Eu
vou dizer impresso. Feliz aniversário, e eu vou dizer
espaço entre vírgulas, concatenação de strings Eu vou dizer self,
e vou
dizer self dot first
underscore name Então diz feliz aniversário. E eu também vou
dizer que, no final,
direi que você está agora. E então o que eu quero
fazer é ir em frente e converter,
porque lembre-se, o g aqui é tratado
como um inteiro, então eu preciso convertê-lo
em uma string aqui, e isso porque estamos usando
alguma concatenação de strings Eu quero dizer string. Precisamos dizer mais aqui. E vai ser self dot H. E isso
vai dizer que agora. E a razão pela qual eu adiciono o sinal positivo aqui
é porque estamos usando concatenação de strings e
vamos converter em uma
string . Está bem? E isso vai funcionar. Se eu
não adicionei o sinal de adição,
ocorrerá um erro, então precisamos ter certeza de que
adicionamos o sinal a seguir aqui. Agora eu posso simplesmente chamar essa mensagem
para dizer “pessoa um ponto e ter
sublinhado aniversário”, e podemos abrir e fechar os parênteses que vão
dizer, feliz aniversário, John, você está agora e
ela vai ficar em uma cerca e pegar a idade e lembrar que
estamos adicionando mais um, então vai pegar a
idade e adicionar mais um a ela,
então será 29, então será 29 ele deve imprimir
essa estrutura completa. Agora, se eu executar o código, agora
podemos ver que o
temos da seguinte maneira. Parece um pouco feio porque
eu não adicionei o espaço. Eu posso simplesmente adicionar o espaço
lá. Lá vamos nós. Pronto, estamos muito mais limpos agora. Agora você pode ver que diz:
Olá, meu nome é John. Feliz aniversário, John, agora
você tem 29 anos. Certo. Então é assim que
podemos criar e utilizar métodos
em nossas classes e nossos objetos e também
como podemos chamar mensagem. Portanto, lembre-se de que isso
dependeria do caso de uso
que você está usando. Então, aqui está o
código completo para que você possa ver. Portanto, dependerá do caso de
uso que você está utilizando e a mensagem seria apropriada
com base nisso Então, neste caso, aqui,
apresentamos e temos o aniversário como nossa mensagem, porque é
apropriado que uma pessoa
apresente uma pessoa e diga parabéns
a ela também. Certo. Isso é tudo para este exercício de laboratório
em particular. Vou adicionar
outro exercício de laboratório
que será
focado em métodos, mas com um pouco mais de
detalhes, e abordaremos isso
no próximo exercício
prático de laboratório. Mas esse é o básico para a
utilização de métodos personalizados.
66. Trabalhando com métodos estáticos e de classe — [Lab]: Oi, todo mundo. Bem-vindo ao
próximo exercício prático de laboratório, que continuará
focado nos métodos. Agora, algo que quero
mencionar é que, anteriormente,
estávamos aprendendo a
utilizar métodos personalizados. Eles também são
conhecidos na esfera de classes e objetos
como métodos de instância, pois estamos trabalhando com nós mesmos para trabalhar com os atributos de nossos
objetos. Agora, também existem dois
outros métodos que obtemos. Eles são conhecidos como
métodos estáticos e também métodos de classe. Também vamos trabalhar e
enfatizar isso. Certo, então vamos começar
com métodos estáticos. Ok. Portanto, um
método estático não usa self porque não interage com os atributos de nossos
objetos e se comporta de maneira muito semelhante
a uma função normal, você poderia dizer, mas está dentro da nossa classe apenas para ser
melhor organizado E podemos chamá-lo sem
precisar criar um objeto. Então, vamos continuar e criar
um método estático simples. Certo. Ok. Então, aqui apresentamos
nossos métodos personalizados
e temos aniversário
, também chamados
de métodos de instância. Vamos definir um método estático e ele também terá um
decorador Precisamos estar dentro de
nossa classe, é claro, e alinhados novamente
com nosso método init, e precisamos garantir
que estamos configurados dessa forma Precisamos adicionar um pouco de espaço. E vou criar
uma mensagem estática que vai verificar se a
pessoa é adulta ou não. Então, vou dizer que a morte
é um sublinhado para adultos. E o que podemos fazer
é seguir em frente e passar
diretamente pelo atributo em si, que será a idade. Então, podemos simplesmente dizer a idade como está. E lembre-se, nós
não usamos a nós mesmos, ok? E isso garantirá que tenhamos acesso aos
atributos de forma direta. Ok. Agora, depois de definirmos isso, precisamos adicionar nosso Cerlon
e, em seguida, queremos
executar a funcionalidade Então, vamos dizer que eu tenho
mais de 18 anos, então podemos dizer retornar
verdadeiro, senão retornar E lembre-se, para tornar isso
um mesod estático no final, você precisa adicionar
o decorador, que está no método estático E agora configuramos nosso primeiro método
estático. Ok. Agora, outra coisa que eu
queria mencionar aqui sobre o método estático que
criamos é que ele pertence à classe, mas não acessa nossos atributos instantâneos. Está bem? Então, apenas algo
que eu quero mencionar. E o que simplesmente fazemos aqui é que
estamos passando pela idade e vamos
verificar se a pessoa é adulta com base em sua idade. Agora podemos chamar esse
método de adulto e aplicar isso a uma classe
específica. E no nosso caso, nossa
classe é pessoal. Assim, podemos rolar para baixo.
Ok, adicionando um pouco de espaço. Agora, o que queremos
fazer é dizer print e
vamos chamar
o mesod estático e
vamos nos referir à classe
da pessoa, e você quer dizer que ponto é sublinhado adulto e vamos chamar a mensagem estática
aqui, como você pode ver, então aqui podemos passar um
valor específico Então, aqui eu vou dizer 25, por exemplo, e vou verificar se a pessoa
é adulta ou não. Então, podemos executar esse código. E aqui podemos ver que é
verdade aqui na parte inferior. Se eu for até aqui, podemos ver que a saída
foi verdadeira. Ok. E vamos seguir em frente
e fazer outro. Digamos que uma pessoa seja adulta, e deixe-me colocar 17. E podemos ver que somos falsos
aqui na parte inferior, certo? Então é assim que
podemos entrar em uma cobertura e chamar nosso método estático
e como podemos colocá-lo Então, foi apenas uma verificação explícita
muito simples que utilizamos. Ok. Então, isso é apenas
algo que eu
queria mencionar apenas para maior clareza. Ok. Agora, a
próxima coisa que queremos ver é
um método de classe. Ok, então temos
nosso método estático. Agora, um método de classe funciona
com a própria classe, ok, não com um
objeto individual, pode-se dizer. E ele usa CLS em vez de
self para se referir à nossa classe, e podemos usá-lo para criar nossos objetos de uma
maneira diferente Em outras palavras, o que
podemos realmente fazer é adicionar valores padrão. Portanto, de certa forma, é muito semelhante
se você estiver acompanhando
os argumentos padrão e verá o que quero
dizer em apenas um momento. Está bem? Então, vamos primeiro definir um método de classe. Vou criá-lo logo
abaixo aqui, método estático. E o que vamos fazer é começar com o decorador, e eu vou dizer método de classe Ok. E então podemos
dizer morte. E eu estou aqui. Vou especificar
o nome do método como WIS,
sublinhado padrão, sublinhado Ok. E o que
queremos fazer então é passar pelo CLS,
como primeira coisa E lembre-se, o CLS se refere
ao objeto de classe
à própria classe, e estamos criando um novo
objeto com ele. Ok. E, essencialmente, o que
queremos garantir é que, em vez de
pedir uma nacionalidade, ela automaticamente
a defina com um valor específico que
será definido como desconhecido Ok. Então, o que vamos passar
é subir em uma cerca viva e
passar por nossos campos Então, teremos uma identificação.
Teremos o primeiro nome do sublinhado Teremos o
sobrenome do sublinhado e teremos a idade omitindo, é claro,
a nacionalidade Então, o que queremos
fazer é, como mencionei,
criar uma pessoa com nacionalidade desconhecida Posso dizer retornar CLS
e, em seguida, retornaremos ID, primeiro nome de sublinhado,
último nome de sublinhado, idade
e, em seguida, para o
bloco de nacionalidade, podemos inserir desconhecido se não houver um valor específico que
tenha sido adicionado Agora, o que podemos fazer é criar um objeto usando
nossa mensagem de classe. Então, isso vai
ser muito específico. Então, por enquanto, vou
remover isso por enquanto, e você verá aqui, vou
chamar essa pessoa de dois iguais, e vamos
dizer pessoa ponto E vamos utilizar
essa mensagem de classe. Então, aqui eu vou dizer W sublinhado
padrão sublinhado padrão sublinhado Ok. E dentro disso, vou
passar por meus valores. Aqui vou definir as duas ideias, nome, vou dizer Jane
Smith, vou dizer 24. Você vai ver que vou
omitir a nacionalidade agora. Então, deixe-me prosseguir e fazer isso adequadamente
e verificar os resultados. Vou dizer imprimir,
referir-me à pessoa dois, a variável, digamos ponto, e então vou simplesmente
dizer o primeiro nome do sublinhado, e digo imprimir a pessoa dois, e é exatamente o que é isso aqui, Dot e eu vamos dizer nalidade Agora você pode ver que eu não coloquei
uma nacionalidade específica, então ela
voltará para a Agora vamos executar isso. E aqui
temos Jane e o desconhecido. E como você pode ver,
esse é o caso quando eu me referi
ao atributo de nacionalidade, mas eu não defini um valor aqui, então ele
mudou esse mesod E como você pode ver aqui, estou devolvendo o
nome, sobrenome,
idade, identidade, mas estou deixando a
nacionalidade como desconhecida aqui Está bem? Portanto, essa pode ser uma mensagem de classe muito
útil e, nesse caso,
queríamos outra maneira de
criar um objeto. Então, essa é outra maneira pela qual
você pode criar um objeto. E, por exemplo, se você
quiser definir um valor padrão, se um usuário não fornecer
um determinado valor em si, como a nacionalidade, como você pode ver, OK E isso é muito útil
se quisermos modificar nossos
próprios atributos de nível de classe. Tudo bem Portanto, essas são as
maneiras simples pelas quais você pode usar seus métodos estáticos e também seus próprios métodos de classe. Ok. Agora, a última coisa
que vou fazer, é claro, é apenas querer
me aprofundar
nesse exercício em particular. Vou passar
algum tempo explicando mais sobre o método estático e a mensagem
da classe, com um
pouco mais de detalhes, apenas para solidificar seu conhecimento para que você aprenda adequadamente, devo dizer Então, vamos
explorar um
pouco mais sobre isso. Certo. Então, a próxima
coisa que eu quero explicar é que aqui, com nosso método
estático, temos a idade. Agora, a idade aqui está apenas agindo
como um parâmetro normal, e estamos transmitindo como fazíamos antes desse valor
específico. Então, se eu fosse continuar e
reiterar que, se eu dissesse impresso, vou
me referir
a ela de acordo dizendo que o
ponto da pessoa é sublinhado adulto, e vamos colocar
, por exemplo, 19 Para executar o código, e
temos aqui verdadeiro. Essencialmente, é muito semelhante à forma como teríamos funções, mas você poderia tratar
o método estático como uma função dentro de uma classe, digamos, em termos
de sua organização. Estamos chamando aqui
o método estático e estamos apenas retornando o
argumento ou valor que você poderia dizer, que será passado aqui e substituído por age aqui, que está atuando como o parâmetro que estamos de fato verificando Isso é apenas algo que eu
queria mencionar para maior clareza aqui. Tentar ver
métodos estáticos
são funções que acabam de ser definidas dentro de uma classe. É assim que eu quero que você veja. Ok. Agora, a
pessoa está aqui. Então, a pessoa é, na verdade esse tipo de toque
que eu mencionei é porque isso é um
tipo de função porque essa é uma função
dentro de uma classe aqui, e estamos nos referindo
à classe. É assim que precisaríamos nos
referir a ele primeiro. Nós nos referimos primeiro à classe
e depois, é claro,
ao mesodname Ok, agora, um pouco mais de clareza
sobre o método de classe aqui. Então, essencialmente, o que está
acontecendo aqui com nosso método
de classe, é claro, neste caso, estamos usando CLS em vez de self é o que
estamos fazendo aqui, e isso se refere à própria classe de
pessoa E então ID, primeiro nome, sobrenome H são essencialmente apenas os parâmetros que
precisamos para criar uma pessoa. Como podemos ver, a nacionalidade não
é passada porque
queremos defini-la desconhecida por padrão quando
estamos realizando a declaração de
devolução Está bem? Certo. Como podemos ver
posteriormente, retornamos o CLS, o que
estamos basicamente
fazendo aqui é chamar
a classe construtora, que é definitivamente init aqui, e ela nos
ajudará a criar um novo objeto pessoal com
os detalhes fornecidos e essencialmente, aqueles
detalhes que podemos ver adicionamos aqui quando
chamamos a classe mesod e na
funcionalidade padrão a nacionalidade será definida como desconhecida, então não precisamos nos
preocupar em
definir um valor extra
que queremos
transmitir quando
estivermos configurando os
parâmetros aqui adequadamente Tudo bem, pessoal. Só um
pouco mais de detalhes sobre isso, só para explicar um
pouco mais. Mas em outras palavras, pessoal, eu diria, é isso. Agora aprendemos como
usar métodos personalizados,
em outras palavras, métodos de
instância, métodos
estáticos e também como utilizar métodos de
classe. É isso para esta palestra
em particular, e vamos nos concentrar na próxima
lição sobre herança
67. O que é herança?: Olá a todos, e bem-vindos
à próxima lição, que será
focada em herança Então, vamos dar uma olhada. Rico. A herança nos permite
criar uma classe secundária que herda todos
os atributos e
métodos de uma Então, vamos dar uma
olhada nisso visualmente. Portanto, temos uma classe principal
e, em seguida, duas
classes filhas, por exemplo, e
essas classes filhas essencialmente herdarão atributos e métodos dessa classe principal Agora vamos dar uma
olhada em uma analogia para consolidar nosso conhecimento
sobre herança Então, digamos que temos um pai. Então, digamos que temos uma mãe
e ela tem dois filhos. Agora, poderíamos dizer que
com a genética e com a reprodução e tudo
o que as crianças herdarão, por exemplo, digamos cabelos
loiros e Digamos que a criança, o homem,
herda o cabelo loiro
e a mulher, a menina,
herda os olhos verdes Então isso é herança. Digamos que os
pais ou a mãe também os ensinem a
falar e a andar. Então, as crianças
agora estão herdando esses métodos
de falar e andar E isso solidificaria todo
o conceito de
herança em Python. Então teríamos a aula para
pais e
teríamos as aulas para crianças.
Tudo bem, pessoal. Então, isso é sobre herança em termos de
visão geral teórica Agora vamos nos aprofundar no exercício prático de laboratório.
68. Como utilizar a herança — [Lab]: Todos, e bem-vindos ao
próximo exercício prático de laboratório, que será focado na herança. Vamos começar. A primeira coisa que
precisamos fazer é criar nossa classe principal ou
classe base, você poderia dizer. Vamos continuar e utilizar
um exemplo com o qual
já estamos familiarizados apenas para
nos familiarizar
com todo o
conceito de herança Certo. Em primeiro lugar, vou definir minha turma como pessoa. Em seguida, queremos definir
nosso método innit, também
conhecido como método
construtor, e ele será chamado quando um novo
objeto de pessoa for criado e, em seguida, inicializará os atributos
e inicializará os atributos as variáveis
de instância de Então, podemos dizer De underscore
init, double underscore. Em seguida, passaremos sublinhado
próprio do IGF, nome do último sublinhado,
idade e nacionalidade. Ótimo. No momento, queremos definir
e associar nosso atributo. Então, ID, nome,
sobrenome, idade e
nacionalidade com eu Então, posso dizer que ID de
ponto próprio é igual a ID. Então eu posso dizer nome do
primeiro sublinhado com ponto próprio,
e esse será o nome do
primeiro sublinhado, o sobrenome do ponto
próprio Ok, e então self dot g
e self dot nacionality. Certo, perfeito. Ótimo. Agora, o que eu
também quero fazer é criar uma mensagem para que
você saiba como herdar mensagens e atributos Certo, então, de acordo com
sua mensagem inicial, vou dizer morte
e, novamente, apresentar Vou
passar por um autocorte. E lembre-se de que esses métodos
personalizados que estamos criando são mensagens de
instância. Então, quando estivermos lidando com nós mesmos, será um método de
instância. Então, tecnicamente, você poderia
dizer método personalizado. Certo. Então, essa instância mesod permitirá que
a pessoa se apresente, e queremos retornar uma string
com o nome da pessoa, com o nome
da pessoa, tudo bem Então, podemos dizer “volte”.
E vamos usar cordas
F desta vez só para mudar um pouco,
e eu vou dizer oi Eu sou, e então
vou colocar
meus espaços reservados para as strings do nome do primeiro sublinhado,
e então teremos o nome do último sublinhado com ponto
próprio,
desse e então teremos jeito E no final.
Aí está. Nosso método também está vinculado a essa classe específica Eu só quero. Lá vamos nós. Vamos torná-lo um pouco mais limpo. Tudo bem, então nós
temos esse conjunto. Agora, a próxima coisa
que queremos fazer é definir nossa turma infantil. Então aqui temos
nossa classe pessoal, e essa classe infantil será
a classe
derivada essencialmente da classe
pessoal, ok. E herdará todos os atributos existentes e
todos os métodos existentes Então, podemos ver nossos
atributos aqui e podemos ver esse
método introduzido. Ok, então quando você está
trabalhando com herança, você herdará
da sua classe principal, e isso precisa ser
algo que Portanto, você não pode ter, por exemplo, uma turma infantil que seja carro, e você tem uma turma
para pais que seja presencial. Isso não faz sentido.
Pessoa e carro. É um pouco confuso. Portanto, um exemplo adequado
nesse caso seria empregado. Portanto, o funcionário é
derivado da classe de pessoas. Isso faz sentido. Então, vamos
seguir em frente e fazer isso. Agora, vamos ter que
definir outra classe agora. Então, de acordo com
a classe pessoa, queremos criar outra classe. Então, vou rolar para baixo
e dizer aula. E isso
será chamado de funcionário, que herdará todos os atributos e
todos os métodos
da pessoa E podemos simplesmente nos referir
à classe de pessoas
aqui entre parênteses para realizar a
herança. E então queremos
prosseguir e fechar isso, e então precisamos
definir nosso método init, isso estenderá
a classe person e também
adicionaremos novos atributos Ele manterá
todos os atributos e mesodos da classe de pessoas e também
adicionaremos atributos adicionais Deixe-me mostrar o que quero dizer. Podemos dizer Def e podemos
dizer double underscore init, double underscore
e diremos self Para facilitar isso,
podemos simplesmente copiar tudo o
que já existe aqui. E você quer colar isso. Em seguida, você pode adicionar atributos
adicionais. Por exemplo, o que
vou fazer é dizer que cargo sublinha o título e o salário, lembre-se de adicionar
dois pontos no final Aqui estão os
atributos extras que adicionaremos. Ok. Ótimo. Agora podemos
entrar e continuar. E agora o que precisamos
fazer é
utilizar algo conhecido
como superfunção. Ok. Agora, a superfunção é usada para chamar a pessoa do construtor da nossa classe mãe Então esse será, é
claro, nosso construtor aqui E o que vamos
fazer é garantir que façamos
isso,
para que não precisemos redefinir os atributos que
já existem pessoalmente Não queremos redefinir
isso, vamos
chamar nosso construtor
de nossa classe mãe,
que, obviamente, será E então o que podemos fazer aqui
é ir até uma cerca viva e garantir que dizemos príncipes que se
abrem e fecham,
e você quer dizer
ponto, sublinhado duplo
no KIT, sublinhado duplo no KIT, E então o que você
vai fazer aqui é
passar por ID,
primeiro nome sublinhado, primeiro nome sublinhado sobrenome sublinhado,
idade e Então, esses serão
os atributos herdados da pessoa É aqui que você está
herdando os atributos. E então queremos definir nossos novos atributos que são específicos para a classe de
funcionários. E isso
seguirá o que fizemos aqui antes com self dot, self dot, etc E isso
será, como você pode ver, para cargo e salário. Assim, você pode ver que eles
não foram destacados. Então, o que você pode
fazer é abaixo disso, você pode dizer self,
e nós podemos dizer ponto, e você vai dizer
cargo sublinhado título, é
igual a cargo sublinhado título, e então ponto próprio, salário é igual a
salário, igual a
salário Então, agora definimos
nossos atributos que são exclusivos
dessa classe de funcionários. No momento, podemos definir uma função que seja apenas
para a classe de funcionários. Aqui, de acordo com
seu método inicial, o que você pode fazer é
sublinhar informações detalhadas e
passar por si mesmo, e forneceremos esse método para que ele
possa
nos fornecer que ele
possa
nos fornecer informações relacionadas ao trabalho
sobre o funcionário, e
retornaremos uma string informando o Então, eu vou dizer return, e vamos utilizar uma
string F
, eu vou dizer F,
e eu vou dizer que eu trabalho como A,
e então para
que o
parâmetro seja passado,
self dot job, sublinhado
título e dot there Tudo bem, então aí está. Portanto, há a mensagem que diz respeito apenas
ao funcionário Certo. Então, entendemos que
agora podemos seguir em frente e criar uma instância
ou objeto de funcionário. Então, vamos fazer isso. Novamente,
isso vai estar na fila da classe
aqui na primeira linha. Então, assim
, para que possamos ver que está
alinhado como deveria estar. Eu só quero adicionar um pouco
de espaço. Ok. Agora podemos simplesmente criar uma variável e chamar
esse funcionário de um igual Queremos ligar e utilizar
a classe de funcionários. Qual pessoa herdada e
todos os atributos. Então, agora podemos
passar os valores, ok, que dizem respeito ao
nome, sobrenome, idade e nacionalidade do documento de identidade, cargo e salário Então, o que vou
fazer é
abrir minhas prensas e dizer que o ID será uma delas Nomeie John Joe, e
então teremos idade. Eu direi 28 e
direi nacionalidade, serão os EUA, e então
teríamos o título do trabalho Eu vou dizer engenheiro de software, e então eu vou
definir o salário. Eu vou dizer 80.000. Lá vamos nós. Temos tudo
isso no lugar. Assim, você pode ver os
valores extras que serão definidos para os
atributos associados e , em seguida, todos os valores
que serão definidos para os atributos que
foram definidos na pessoa
da classe. Ok. Então, aqui temos esse objeto e podemos ver que
herdamos os primeiros e os últimos
que são nativos
para herdar nossa classe
que herdará de uma pessoa, ou seja,
de Agora, o que podemos fazer é
dizer impressão e podemos dizer funcionário um e
podemos dizer o primeiro nome, que será
essencialmente
da classe principal , e então
podemos dizer impressão,
funcionário um ponto, funcionário um ponto, e aqui podemos dizer título de sublinhado do
trabalho Isso será nativo
da classe de funcionários. Certo, então vamos seguir em frente
e executar esse código. Então pegamos John e, claro, temos engenheiro de software.
Então, vamos lá. Então, bom trabalho, se você
chegou a esse ponto, você configurou com sucesso herança e a
configurou bem Agora, queremos chamar os
métodos que definimos. Então, o primeiro método,
que
será introduzido pela pessoa
da classe, e depois o método de informações de trabalho
da classe do funcionário. Então, o que podemos fazer aqui é simplesmente dizer imprimir, e você vai dizer funcionário um, ponto,
e você pode
dizer apresentar, e depois imprimir funcionário um ponto, e você pode dizer
trabalho, sublinhado,
informação, abertura e fechamento de parênteses Certo, então aí está, e vou
comentar os dois primeiros por enquanto. E podemos executar o código. Aqui, diz: Oi, eu sou John Doe. Eu trabalho como engenheiro de software. O primeiro método
foi chamado. Olá, sou John Doe
e, em seguida, trabalho como engenheiro de
software, que vem do método de
informações de trabalho que definimos Podemos ver ao nos referirmos
à variável que está essencialmente
criando esse objeto. Podemos nos referir a ele e
, em seguida, chamar os métodos que são exclusivos de
cada classe e podemos ver que
herdamos
o método da classe pessoa porque podemos acessá-lo e fazer uso dessa
função adequadamente Tudo bem, pessoal, então aí
está. Então, como você pode ver, isso mostra como você pode
utilizar a herança e também é muito
útil. Como você pode ver,
você não precisa
reconstruir o testamento e definir
classes separadas e Você pode realmente
economizar muito tempo
utilizando essa superfunção
que temos aqui para configurar
automaticamente os atributos
da classe anterior que
temos e,
em seguida, começar e , essencialmente,
permitir que atribuamos nossos próprios atributos que
dependem da classe mais recente, que é nativa somente
dessa classe Ok. Perfeito. Tudo bem, pessoal. É isso mesmo. Vamos
continuar e remover isso. Isso é tudo para este exercício prático de laboratório
específico sobre herança
69. Abstração: Olá a todos, e bem-vindos
à próxima lição, que será
focada na abstração Vamos dar uma olhada.
Você provavelmente está se perguntando o que
diabos é abstração abstração é simplesmente
o processo de ocultar detalhes
desnecessários e mostrar
apenas as partes importantes Isso ajuda a simplificar sistemas
complexos,
concentrando-se no que algo faz e não
em como funciona. Agora, se fôssemos utilizar isso em OOP, programação
orientada a objetos, abstração
significaria simplesmente criar
interfaces
simples e amigáveis ao mesmo tempo em que ocultava todos os detalhes complexos da
implementação Agora, se eu lhe desse uma analogia simples para ajudar a ilustrar meu ponto de vista
sobre abstração, seria uma tão
simples quanto Digamos que temos um controle remoto de TV
e queremos assistir TV. Agora, para
mudar o canal, precisaríamos
clicar no controle remoto
e, em seguida, ele enviaria
um sinal para a TV para dizer:
Ok, eu quero que você
vá para este canal. Eu quero que você vá
para aquele canal. E é assim que eu
quero que você tente racionalizar todo o
ponto de abstração Então, para resumir isso, basicamente, não
precisamos
entender ou
saber como o controle remoto
muda de canal ou por quê. Só queremos assistir TV. Agora, se fôssemos aplicar
isso à abstração, a ideia toda é
que não precisamos
entender como algo funciona internamente, assim
como uma Nós apenas o usamos para obter
o resultado que queremos. Tudo bem Tudo bem, pessoal. Então, é isso na lição de abstração em termos de
uma visão geral teórica Vamos nos aprofundar na aplicação disso aos exercícios
práticos de laboratório. Então, vamos
direto ao assunto.
70. Trabalhando com abstração — [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de
laboratório, que será focado na abstração. Vamos começar. Agora, a primeira coisa que
precisamos fazer é chamar o módulo ABC E do módulo ABC, vamos
importar ABC e caps, que significa a classe base
abstrata Então, vamos usar uma classe base
abstrata e também o método
abstrato associado. Agora, para importar um método
abstrato, basta adicionar
uma vírgula e dizer Appstrct mesode desse jeito.
Ok, perfeito. Agora queremos criar
uma classe abstrata. Agora, vou dizer aula e vou me referir a
isso como pessoa. Em seguida, entre parênteses, você deseja passar por ABC, que significa Agora, a principal coisa aqui
com a abstração é que, se você considera uma classe abstrata, ela não pode ser Em outras palavras, você não pode
criar uma instância aqui. Você não pode criar nenhum objeto. Essa é a principal coisa aqui
que eu também vou testar no
final
deste exercício de laboratório para provar a vocês o que
quero dizer com isso. Certo. Agora, já que estamos
criando uma classe, vamos fazer a
mesma coisa de antes. Vamos definir
nosso método init com nossos parâmetros e, em seguida, configurar e armazenar nossas variáveis mais
permanentes que, obviamente, serão
atributos Então, vou dizer que a pontuação interna da
Deere abordaremos o
eu, o nome e a idade Então, queremos dizer que o nome do ponto
próprio é igual ao
nome e a idade própria é igual
à idade. Muito simples. Então, na mesma linha, queremos definir
nosso método abstrato. Agora eu me pergunto o que
é um método abstrato? O método abstrato é essencialmente um método que
será utilizado como
decorador e anexado decorador e anexado a um método específico, e fará com que todas as
subclasses ou classes filhas, digamos, implementem esse método. É um
método obrigatório que você define para todas as suas
subclasses ou classes secundárias O que vou fazer é dizer
DF e vou dizer que a descrição do sublinhado do
trabalho será meu mesod abstrato e que vamos
passar por O que você precisa fazer
é, logo acima disso, adicionar
seu decorador e dizer o método abstrato do aplicativo Isso é baseado no que
importamos aqui
do módulo ABC. Certo, perfeito. Agora, esse método,
como mencionei, deve ser implementado por
todas as nossas classes, e não vamos
definir como ele é usado. Vamos apenas
tornar isso obrigatório. Em cada classe que
criamos agora, as subclasses que
criamos, ok? Essencialmente, o que
vai acontecer é que podemos adicionar nossa própria
funcionalidade,
mas o método em si precisa ser utilizado Essa é realmente a principal coisa
aqui com métodos abstratos. Agora, como você pode ver aqui, eu tenho uma linha vermelha e isso significa, é
claro, que vamos
receber um erro. Não podemos simplesmente deixar
esse método vazio. O que você vai
querer fazer é
passar pela
palavra-chave pass, bastante irônica, na verdade, apenas para que não
haja erros e isso signifique que
não há implementação em nossa classe abstrata No momento, a próxima coisa que
queremos fazer é
definir uma mensagem normal aqui. Então, um que podemos chamar e
utilizar, o que faremos, mas não terá
nenhum tipo de noção
estrita em
termos de mensagem abstrata. Então, vai ser muito
simples e eu
vou dizer de e vou
dizer introduzir como o
nome do mesod Queremos passar por nós mesmos e vamos fazer
um tipo fixo de declaração. Vou dizer return F, e vou dizer que
aqui está minha string, meu nome é e parênteses zen, vou dizer nome de ponto próprio E eu sou e podemos dizer que
envelhecemos por anos.
Deixe-me um pouco aqui. Esse será um método
padronizado que utilizaremos
quando invocarmos nossos
objetos criados em nossas OK. Agora, na mesma
linha de pessoa da classe, queremos definir nosso
primeiro filho ou subclasse Então, o que eu vou fazer é
ir em frente e dizer aula, e eu vou
chamar esse professor, e ele vai
herdar a classe abstrata
conhecida como pessoa agora Então, estamos realizando
uma herança agora e eu vou
dizer pessoa. Vá lá. E então, como antes, precisamos definir
nossa mensagem inata, passar por eu, nomear a idade, e então podemos colocar
algo exclusivo nessa classe, que
será o assunto Portanto, o nome e a idade serão herdados da classe da pessoa Ok, agora o que queremos
fazer é chamar o construtor da
pessoa Então, queremos garantir
que chamemos isso. E o que vamos fazer
para fazer isso é utilizar Super, e então podemos dizer pontuação loira de superpontos, pontuação de
loira em D. E então vamos
passar aqui parênteses o que
vamos herdar Então, herdaremos nome e idade. Está bem? E você
vai ver aqui que o assunto é nativo
da classe de professores. Certo. Agora podemos simplesmente
dizer que assunto com ponto próprio
é igual a assunto é igual Então, apenas um desafio regular aqui, definindo
regularmente, devo dizer o atributo que é
nativo dessa classe R. A próxima coisa que você quer
fazer agora é chamar esse método
abstrato que definimos aqui
e que precisamos utilizar, e também vamos defini-lo nós mesmos
neste caso. Então, o que vou
fazer aqui é, digamos,
descrição do sublinhado do trabalho por meio Agora podemos adicionar
nossa própria descrição de trabalho específica, por exemplo, para um professor. Vou
dizer, volte, use cordas S, vou dizer que ensino disciplinas de
autopontos em uma escola Muito simples. Certo, lá vamos nós. Então nós temos esse conjunto.
Agora podemos seguir em frente e criar nossa
segunda turma aqui. Então, temos o
professor da turma e vamos criar outra turma, e podemos ir em frente e chamar
esse médico, por exemplo. Então, você pode ver o padrão aqui, temos pessoas ou pessoas
e, em seguida, temos funções de trabalho que estamos analisando
com subclasses Agora, queremos passar e herdar todos os
atributos de uma pessoa,
ou seja, nome e idade Então, podemos passar
por isso dessa forma. E então queremos
definir nosso método init. Vamos ver a estrutura.
Sim, adicionamos espaço lá. Digamos, definitivamente, sublinhado duplo,
nit, sublinhado duplo, e ainda teremos nome
próprio e idade, mas o que será exclusivo
dessa
classe em particular será dessa
classe em particular Lá vamos nós. E então
pausaremos Superterscore, NTBLescore. Assim, podemos pegar e
herdar o nome e idade de acordo com os que
definimos em nossa classe pessoal, assim como fizemos com
a classe de professores OK. Certo. Agora, queremos armazenar a
especialidade médica como um atributo, para que possamos dizer que espacialidade é igual a
espacialidade Ok, vamos lá. Então, temos esse conjunto agora
na mesma linha. Precisamos nos referir à descrição do trabalho do
método. Então, posso dizer, definitivamente, a descrição do
sublinhado do trabalho. Tudo por você mesmo. E
o que queremos fazer aqui? Podemos dizer return F.
Vou dizer que sou médico especializado em e podemos dizer aqui em nossos espaços reservados a especialidade
self dot Assim mesmo, e vamos
colocar um ponto no final. Então é assim que podemos
chamar essa descrição. Tudo bem, então aí está. Portanto, certifique-se de ter adicionado
tudo da seguinte maneira. Então, agora vamos em frente e
adicionamos tudo muito bem. Também vou arrumar
o código, torná-lo um pouco mais limpo Tudo bem, então é disso
que precisamos para começar tudo. Tudo bem. Então, vamos continuar e realizar alguns testes
para que possamos realmente entender o valor das classes
abstratas e como
tudo está funcionando em conjunto. Então, vamos em frente
e eu vou
mergulhar bem fundo nisso.
Então, vamos ao que interessa. Tudo bem. Então, na parte inferior agora, podemos apenas nos referir
às nossas duas classes. Então, temos professor
e temos médico, então nossas subclasses, devo dizer? Vou criar instâncias
e vou testá-las. Vou dizer que professor
um é igual a, professor, esse é o nome da turma
e quero passar os valores que vou
definir como meus atributos Aqui eu vou ter Ale, e depois eu vou ter 28, e então eu vou
dizer Msmatics Então eu terei o Doctor One que se vincula à subclasse de
médicos Aqui vou
colocar Bob, ele tem 31 anos e é apenas um clínico geral OK. Então, agora o que eu quero
fazer é ir em frente e imprimir de
acordo com o método de introdução
que eu defini anteriormente. E o que eu quero fazer é
ver como isso é aplicado ao professor
e ao médico. Então, o que eu posso fazer é dizer
print e podemos referir ao professor que o professor
instancia dot intro DoS Então eu posso fazer o
mesmo e dizer print, doctor one introduce Vamos continuar e fazer isso, entendeu. Meu nome é Alis
e tenho 28 anos Meu nome é Bob e
tenho 31 anos. Então, essencialmente, o que
aconteceu aqui foi chamamos esse método de introdução, que
chamamos esse método de introdução, que
espera que você insira o nome e a idade onde quer que você os defina. Agora, estabelecemos nossos valores aqui nesta
instância que configuramos. Depois ensinamos um
e doutor um. Em seguida, aplicou esse método
específico a cada um desses
objetos e, em seguida, executou essa função para
coletar de acordo com os valores que foram definidos
nesse objeto específico,
ou seja, o nome e a idade deles. Essa é uma
maneira muito útil de usar o método introduzido. Está bem? Certo, perfeito. Agora, a próxima coisa
que quero mostrar é a parte da descrição do trabalho. Então,
vamos ver isso. Então, agora eu quero chamar
meu método abstrato, que eu utilizei
tanto na minha aula de médico quanto na de
professores Então, podemos simplesmente dizer imprimir. E, novamente, queremos nos
referir às nossas instâncias. Então, professor 1, ponto, descrição do sublinhado do
cargo, abertura e parênteses de vestimenta Então eu quero dizer print, doctor
one dot, descrição do sublinhado do trabalho E podemos
comentá-los só por enquanto. E corra. Eu ensino
matemática em uma escola. Sou médico especializado em GP,
portanto, clínico geral,
etc. Tudo bem, então aí está. Então, agora podemos ver
que está produzindo o que precisamos, como
você pode ver agora Certo. É assim que
podemos utilizar a abstração Agora, vou entrar em um
pouco mais de detalhes para que
possamos entender o objetivo principal do
que estamos fazendo aqui. Vamos começar aqui
no topo. A classe person é
uma classe abstrata, que significa que não podemos instanciá-la
diretamente O que quero dizer com isso
é que você não pode criar um objeto ou pessoa. Vou te
mostrar o que quero dizer. Aqui estamos criando objetos do professor e do médico. Se eu dissesse pessoa igual a
um e dissesse pessoa e
colocasse os valores que temos aqui,
teríamos nome e idade Eu vou dizer John e 24. Você notará que se
eu dissesse o nome de uma pessoa
impressa com um ponto, verá que
receberemos um erro agora. Eu só quero
comentar isso por enquanto. E execute o código. Você pode ver aqui que obtemos
um rastreamento em
que diz que você não pode instanciar uma pessoa de classe
abstrata sem uma implementação para
o método abstrato, que é a descrição do trabalho Isso é o que
utilizamos antes de
utilizarmos nossa
descrição de trabalho aqui, um método abstrato, para
que possamos essencialmente prosseguir e
utilizá-lo em nossas subclasses Você não pode criar uma instância, como você pode ver em
um método abstrato. Se eu
removesse esse método abstrato e apenas o
mantivesse como uma classe regular, ou se fosse uma subclasse, estaria perfeitamente bem Essa é uma das principais
coisas aqui que eu quero mencionar aqui com
abstração aqui Você não pode seguir em frente e
simplesmente fazer uma coisa dessas. Agora, outra coisa que
quero mencionar aqui é
que, como você pode ver, precisamos obrigatoriamente usar a descrição do
trabalho aqui.
Esses dois métodos. Agora, a vantagem ter uma descrição do trabalho
nesses dois métodos e utilizar o
método abstrato aqui é
que ele reforça a estrutura com nossas subclasses secundárias de
barra Está nos dizendo que
eles devem implementar esses métodos. Como você pode ver. Agora, se você omitir, por exemplo, os métodos
em suas classes, você encontrará
um erro Então, tenha isso em mente. Você precisa garantir que
tenha essas classes abstratas às quais se referiu em
suas subclasses Ok, então é muito importante
ter isso em mente. Agora, outra coisa que
você provavelmente está se perguntando é: por que todo esse
processo é abstrato Onde você realmente vê isso? Além do fato de que,
com o aluno aqui, simplesmente subindo em uma cerca viva e jogando uma flecha, se você
tentar instanciar uma classe, por que Agora, uma coisa a ter
em mente aqui é que o usuário
não precisa saber como a descrição do trabalho
funciona internamente Está bem? Então é aqui que o
argumento que eu estava tentando enfatizar nas aulas teóricas é que seu usuário não precisa saber como a descrição do trabalho
funciona internamente Está bem? Então, como você pode ver aqui, estamos passando, não estamos passando nenhuma informação
ou funcionalidade. Estamos apenas dizendo, eu
quero uma descrição do trabalho, professor,
aula de médico, faça você mesmo. Está bem? E esse é o ponto em
que eu estava tentando fazer a analogia com o
controle remoto da TV e a TV aqui, ok? Você não precisa saber os detalhes
extras e tudo mais. Assim, você pode ver que uma
classe abstrata tenta tornar tudo muito mais
fácil de gerenciar sem todos
os detalhes extras. Portanto, você pode ver isso
simplificando para
nós, utilizando um método abstrato
. Tudo bem. Agora, outra coisa que eu também
quero mencionar que é importante são nossos usuários, claro, quando estamos
definindo nossos objetos aqui e criando as
instâncias, devo dizer? Eles só interagirão com nosso método de introdução
e nosso método de descrição
de trabalho aqui, e nosso método de descrição
de trabalho aqui sem precisar se preocupar com todos os detalhes de
implementação. Você pode ver até mesmo aqui
o método de introdução. Já o
configuramos aqui. Não está usando um método
abstrato, mas já o adicionamos
a uma classe abstrata, que pode ser vista como
um código inicial ou um código formatado para
prepará-lo sem precisar
fazer isso sozinho Você pode ver aqui que
não precisávamos colocar isso manualmente em cada uma
dessas classes. Eles já foram feitos para nós. Novamente, para resumir a abstração. Escondendo a complexidade ao mesmo tempo em que impõe
uma estrutura muito limpa. OK. Certo. Ok, pessoal, então é isso em termos de como você pode utilizar a
abstração no PySon Tudo bem, então o que
podemos fazer
agora é copiar isso
e retirá-lo. E aí está.
71. Coleções: Olá a todos, e bem-vindos
à próxima aula, que será
focada em coleções. Então, vamos dar uma olhada. Você provavelmente está se perguntando:
o que diabos são coleções? O módulo fornece acesso a
tipos de dados especializados em PySON Você pode ver as coleções
como um módulo específico, e isso permitirá que você
acesse esses tipos de dados
especializados. Agora, diferentemente dos tipos de dados
incorporados com os quais
já estamos familiarizados, como SDR para string, bull list set e dit, eles devem ser
importados antes do uso
e, por sua vez, oferecerão
funcionalidades aprimoradas além nossas estruturas de dados padrão Agora, alguns dos principais tipos de dados
especializados incluem um contador chamado
Tuple order dit, default dit e DQ Então, vamos dar uma
olhada nisso graficamente para fazer mais sentido, basicamente Então, quais tipos de dados obtemos? Agora, obtemos, como mencionei
antes, SDR para string, Tuple, int, set, float range,
bull, dict Agora, eles são conhecidos como tipos de dados
integrados
no PySON Esses são os
tipos de dados comuns que usamos no dia a dia
e o tempo todo Em seguida, obtemos o nome do contador tuple, order dict, default dict e DQ, que são vistos como nossos
tipos de dados especializados que precisam ser importados para que
possam ser utilizados Essas são as
diferenças. Tente visualizar a diferença entre
os dois e agrupá-los. Quando estivermos trabalhando
com coleções, poderemos
importar esses tipos de dados
especializados. Agora, vamos nos
aprofundar nos tipos de dados que obtemos. Contador. Nenhum contador é essencialmente
uma ferramenta que vai contar com que frequência cada item
aparece em uma determinada lista. Em seguida, nomeamos tuple. Agora, esse é um
tipo especial de tupla em que os elementos terão
nomes para facilitar o acesso Então pedimos o ditado. Agora, o dicionário ordenado é essencialmente um
dicionário que manterá a ordem na
qual os itens foram adicionados. Em seguida, temos uma dieta padrão. Agora, default dict é essencialmente um dicionário que fornecerá um valor padrão para qualquer chave ausente
que esteja disponível. E, finalmente, temos o DQ. Então, isso é
como uma
estrutura em forma de lista, você poderia dizer, que vai permitir adições e
remoções
rápidas de ambas as extremidades Então, basta uma
pequena visão
dos conceitos teóricos
dos seguintes tipos de dados
especializados.
72. Explore o módulo de coleções — [Lab]: Oi, pessoal. E bem-vindo ao próximo exercício prático de
laboratório, que se
concentrará na utilização
dos
tipos de dados especializados que
vêm do módulo da coleção Tudo bem. Agora, eu também
quero mencionar com antecedência aqui que esses tipos de dados
especializados são normalmente utilizados
na forma de uma classe
ou função Então, isso é apenas
algo que eu queria
mencionar para que você esteja
ciente antes de começarmos. OK. Agora, vamos
, em primeiro lugar, utilizar a classe de contador. Neste exemplo específico, mostrarei como
você pode usar a
classe counter, por exemplo,
para contar quantas vezes cada
item aparece em uma lista. Precisamos dizer que, a partir do módulo de
coleções, eu quero importar
a classe de contador. Quero definir uma
lista e vou definir uma lista de
frutas, por exemplo. Eu vou dizer que frutas são iguais. Em uma lista aqui, vou
adicionar alguns itens. Vou comer maçã, vou comer pêra. E eu também vou adicionar
os mesmos itens, devo dizer? Vou adicionar duas maçãs
ou duas peras ou duas
laranjas, etc. Vou repetir algumas
coisas para que possamos contar o número de ocorrências em todos
os itens aqui Então, eu também vou adicionar outra
maçã, laranja e um par. Lá vamos nós. Então, isso
é bom por enquanto. A próxima coisa que quero
fazer é criar um contra-objeto para contar as
ocorrências de cada fruta Então, vou apenas
definir uma variável que
diz que o sublinhado da fruta
conta, é igual, e vou utilizar
uma contra-classe, será anexada
à Agora, o que vou fazer é
imprimir o dicionário do contador, que mostrará
a contagem de cada fruta. Então, se eu dissesse imprimir, sublinhado de
frutas conta
e executar o código, vamos ir um pouco mais abaixo Vamos ver aqui que
diz contra maçã dois, par dois, laranja um. Você pode ver que ele conta
as ocorrências. Eu posso ver que tenho duas maçãs, uma, dois pares e uma laranja, e isso foi contado para mim na saída, como
você pode ver aqui. Podemos ver que é produzido como um contra-dicionário, como
podemos ver aqui. Agora, digamos, por exemplo, que eu queira acessar contagens
individuais, certo? E para fazer isso, o que posso fazer
é dizer imprimir,
e podemos dizer que o
sublinhado da fruta conta E aqui, podemos simplesmente adicionar os colchetes e
nos referir ao item específico Então, aqui eu quero dizer Apple. Agora, se executarmos isso, você pode ver aqui que obtemos
o resultado anterior
e, em seguida, podemos ver a Apple aqui. Ok, podemos ver que
a saída aqui é duas porque a Apple
apareceu duas vezes. Ok, então é assim que você pode
obter o valor direto de
quantas repetições elas
existiram ou
quantas vezes elas foram
chamadas na lista Então, para o par, é claro, também são
dois, mas laranja, há apenas uma
ocorrência, então vamos ver
se vai ser uma,
o que deveria ser. E podemos ver que é um.
Perfeito. Tudo bem. Lá vamos nós. Então é assim que você pode
utilizar a contra-classe. Agora, a próxima coisa que
queremos fazer é utilizar a tupla nomeada Agora, a tupla nomeada é
essencialmente uma função e podemos usá-la para criar uma classe muito leve
com atributos nomeados É por isso que estamos
fazendo coleções agora, para que você já se
sinta confortável com as aulas. Isso deve ajudá-lo a entender
melhor o assunto. Ok, então, novamente,
do módulo de coleções, eu quero importar a função de tupla
nomeada Eu quero criar uma pessoa de tupla
nomeada com campos ou
atributos nomeados, você poderia dizer Eu vou dizer que pessoa é igual, tupla
nomeada passará por
pessoa, na Então, aqui, teremos
, por exemplo, nome, idade e cidade. Agora, isso é muito semelhante aos
atributos que você poderia dizer, mas nos referimos a eles
aqui como campos, mas é muito semelhante
aos atributos que definimos em nossa classe. Certo, lá vamos nós. Agora, queremos criar
uma instância de pessoa. Então, vou dizer que pessoa
um é igual a pessoa. Então podemos seguir em frente
e dizer que o nome é igual a John. Idade é igual a 24 e cidade é igual à Cidade do
Cabo, sem mais nem menos. É assim que você
associaria
os valores e criaria
essa instância. Agora, digamos que queremos acessar os valores usando os nomes. O que podemos fazer é dizer,
por exemplo, imprimir, e eu vou
dizer pessoa, ponto, nome, e também vou dizer
imprimir pessoa com um ponto na cidade. Vou adiantar isso então. Vamos seguir em frente e
ver o resultado. Então, temos John e Cape no chão. Então, isso se refere ao
valor associado
ao nome e ao valor associado à
cidade. Tudo bem. você pode ver, é
muito, como mencionei, uma maneira muito fácil de criar
uma classe leve, você poderia dizer com atributos
nomeados. OK. Perfeito. Certo.
Agora, o que você também pode fazer é entrar em uma cobertura e
produzir de uma maneira diferente Portanto, as tuplas de nomes também se comportam
como uma tupla normal. Então, eu posso mudar isso e
dizer imprima uma pessoa. E dentro das impressões digitais, eu posso colocar
zero e depois a pessoa um, e eu posso colocar um. E se eu executar isso,
vai dizer John e 24. Portanto, ele
funcionará de forma muito semelhante ao comportamento
de um tupur ou de uma lista,
digamos, imprimindo
o primeiro valor de, como
podemos ver, na instância Então, temos John aqui, e então temos 24. Se eu quiser obter o último valor aqui que está
entre parênteses, posso simplesmente mudar para E então ele produz
cape down para mim. Rapazes. É assim que você pode
utilizar uma tupla nomeada Ótimo. Nós temos isso configurado. A próxima coisa que
vamos
querer fazer é usar o ditado
ordenado. Agora podemos simplesmente remover
isso e
dizer importar ou podemos dizer, eu acredito que é EnCapsiao Lá vamos nós. Então,
queremos criar um ditado ordenado,
vamos fazer isso. Quero dizer que
dados unsca ordenados, apenas uma variável. Vamos
atribuí-lo à classe aqui de Ordered Dict. Então, o que vou
fazer é definir os valores associados aqui e neste
dicionário ordenado, você poderia dizer. Ordenamos dados sem pontuação, e diremos que A
será igual a um, e podemos simplesmente compô-los e
defini-los
para B igual a E veja é. Agora, queremos imprimir o
ditado de ordem em que as chaves estarão
na ordem de inserção. Primeiro, A era um, B é dois e C é três. Não será impresso
em uma ordem diferente. Então, agora eu posso dizer imprimir. Dados de sublinhado ordenados. Agora, se eu executar
isso, vai dizer
order dict A um, B dois, C e três. OK. Então é assim que você pode seguir em frente e utilizar a classe de dicionário
ordenado. Agora, digamos, por exemplo, que
você queira adicionar uma nova chave, temos as três chaves aqui, mas você quer
adicionar uma nova, então você quer dizer que D é igual a O que você pode fazer, é bem simples, é simplesmente seguir em frente e dizer ou sublinhar os dados G é igual a quatro, e
vamos dizer que a impressão ordenou os dados
escolares. OK. Eu também quero, para melhores propósitos de
aprendizado, eu também vou deixar isso. Vamos definir isso como. Lá vamos nós. Ok, então agora você verá
a diferença. Ok, então podemos ver aqui
antes de termos A um, b2c3, e então adicionamos de acordo,
adicionamos uma nova chave
que D é igual a quatro, e você pode ver agora
que está anexada
D D é D D OK. Então é assim que podemos seguir em frente e utilizar
um ditado ordenado. Então, essa seria
uma aula específica. Certo. A próxima coisa que queremos fazer é dar uma
olhada no ditado padrão. Agora, isso fornece um
valor padrão para as chaves ausentes e default
fornecerá automaticamente um valor padrão para qualquer chave ausente, em vez
de gerar um erro, para que você possa ver onde seria
o uso. Do módulo de coleções, quero importar o dict padrão. Acabou de ser definido assim. Tudo bem. E então
o que podemos fazer é criar um dicionário padrão em os valores
ausentes serão números inteiros
e, claro,
o padrão será zero Então, podemos dizer fruit, underscore counter
equals, default dict, e podemos simplesmente dizer Então, queremos adicionar algumas frutas. Então eu vou dizer contador de
sublinhado de frutas, e isso vai ser maçã E podemos dizer que mais é igual a um. Então, podemos dizer contador de
sublinhado de frutas
e, em seguida, vamos
dizer par mais é igual Agora, queremos imprimir
nossas chaves existentes, então elas devem ser colocadas em uma cobertura e produzir uma e
uma para nós dois Então, se eu disser imprimir, contador de
sublinhado de frutas, e eu me referir à
Apple, podemos executar isso e ver que a saída é uma, e o mesmo deve
ocorrer se eu disser par.
A mesma coisa deveria acontecer. Salve o código, corra, nós temos um. Mas vamos seguir em frente
e diferenciá-lo. S três e dois, e vamos
mantê-los em pares. Recebemos dois por par e, com
appn, devemos obter três. Recebemos três, exatamente
como deveria ser. Perfeito. Agora, digamos que
essa é a parte importante. Digamos, por exemplo,
que eu queira acessar uma chave ausente e eu queira acessar a laranja, por exemplo, que você pode
ver aqui que não existe. Se eu dissesse imprimir, contador de sublinhado de
frutas e disser laranja, você pode ver
que
o padrão aqui é zero Se faltar algum
número inteiro e colocarmos nível para garantir que, é
claro, trabalharemos com nossos números inteiros,
podemos ver que ele tem zero Isso não gerará
um erro, então você pode ver como a escavação
padrão pode ser útil. Se você estiver trabalhando com um
programa e não tiver
necessariamente um
tratamento de erros e quiser apenas uma solução mais curta
ou mais simples, você pode utilizar o
dickie padrão, como você pode ver para permitir que você forneça um valor padrão caso
tenha uma chave ausente Como você pode ver,
havia uma tarefa antes, mas o laranja não existe
para uma chave Certo. Ótimo. Agora, a última aula que eu quero
mostrar a vocês será DQ Nós diríamos Import D
Q, mais ou menos assim. OK. Essencialmente, isso
nos permitirá adicionar e
remover
rapidamente das duas extremidades de um Q,
DQ é a abreviação de Q de ponta dupla, isso
nos permitirá
adicionar e remover rapidamente da esquerda e
da direita
do nosso Q. Tudo bem. Então, vamos criar um DQ
com alguns números. Eu vou dizer que D é igual a DQ, e dentro de parênteses
vamos adicionar uma lista,
então eu vou ter um, então eu vou ter um Então eu quero
acrescentar à direita,
o mesmo que
acrescentar lista, você poderia Eu quero dizer
D acrescentar isso,
e digamos que eu coloque quatro,
e digamos que eu imprima D. Vamos continuar
e ver a Vai ter um,
dois, três e quatro. Então, podemos ver que esse método
de caneta anexará o número à lista que
designamos aqui, digamos que também queremos
acrescentar à OK. Agora, essencialmente, o
DQ aqui, como podemos ver, é que atribuímos uma maneira especial de lidar com
listas, como podemos ver aqui Agora, o que não é
possível com listas, claro, sozinhas, é que você não pode acrescentar à esquerda Então, deixe-me demonstrar. Se eu dissesse Dt,
acrescentasse à esquerda, dissesse zero e dissesse imprimir D, você pode ver que agora
temos zero, um, dois, três e OK. E isso é muito útil para seguir em frente e
se ajustar adequadamente. Digamos que agora queremos
remover da direita. Está bem? Então, vamos fazer isso.
Então eu posso dizer Dt Pop, Ar e então podemos dizer print G. Então vamos
ver onde estamos. Agora temos zero, um, dois e três desse último pop, modo que removemos
do lado direito. Agora, digamos que
queremos remover
da esquerda, eu posso simplesmente
dizer D não estoure para a esquerda
e, em seguida, imprimir D. Tudo
bem, vamos lá. Agora podemos ver que não
temos mais zero. Temos um, dois e três. Certo, então aí está. É assim que você também pode
utilizar o DQ. Tudo bem, pessoal, é
isso em termos de utilização
desses tipos de dados especializados
do módulo de coleções Então, como você pode ver,
eles são muito úteis e são muito úteis. Mas sim, pessoal, isso é tudo para este exercício prático de laboratório.
73. Itertools: Oi, pessoal. Bem-vindo
à próxima lição, que será
focada em ferramentas de IR. Então, vamos dar uma olhada.
Então, o que são ferramentas de IR? Agora, o modelo de ferramentas do Iter oferece funções para
trabalhar com iteradores Agora, posso colocar isso de uma
forma simples iteradores são tipos de dados que podem ser usados seguir, com a lista sendo
o exemplo mais comum Agora, aqui estão algumas das
principais funções que você pode importar do
módulo de ferramentas de IR e elas incluem. Permutações,
combinações, acumulação,
agrupamento e iteradores infinitos de produtos agrupamento e iteradores infinitos de Agora, vamos examinar mais detalhadamente
essas funções-chave. Certo. Portanto, temos o produto. Agora, o produto calcula o produto cartesiano dos iteráveis
de entrada, gerando todas as combinações e permutações possíveis Isso cria todas as ordenações
possíveis de elementos em um Então temos combinações. Isso gera
conjuntos exclusivos de elementos a partir de um iterável sem
qualquer repetição Em seguida, acumulamos, e isso calcula somas
cumulativas ou aplica outras
funções binárias Então temos o grupo i,
que agrupa elementos
consecutivos em um iterável com base em
uma função chave Certo. Então, isso é tudo para
a visão geral teórica. Vamos nos aprofundar no exercício
prático de laboratório.
74. Trabalhando com Itertools — [Lab]: Primeiro, e bem-vindo ao próximo exercício
prático de laboratório, que se
concentrará em trabalhar com ferramentas de
IR e as funções
associadas que podem ser utilizadas a partir Certo. Agora, a primeira coisa
que queremos fazer é seguir em frente e
utilizar
a função de produto das ferramentas do Iter Então, podemos dizer que,
a partir das ferramentas do iter, podemos dizer importar
produto, sem mais nem menos Só para explicar um pouco
mais, as ferramentas I são essencialmente um módulo com ferramentas para trabalhar
com iteradores E vamos usar especificamente agora a função
do produto. Agora, no nosso caso, o que queremos fazer é gerar todos os
pares possíveis de elementos
de duas listas neste
caso de uso para a função do produto. Então, vou definir
duas pequenas listas. Eu vou dizer que A
é igual a um e dois, B é igual Agora, no nosso caso aqui, o que vamos fazer é definir uma variável e chamar
isso de prod equals Então vamos dizer lista
porque queremos gerar uma lista porque queremos gerar uma lista no final e
podemos agrupá-la em torno da função do produto,
que vai incluir
A e B.
Agora, os produtos A e B
gerarão um iterador que cria todas as combinações de
pares e estamos agrupando isso em
uma lista que vai
convertê-la em uma lista para que possamos ver todos os valores de uma vez Agora, se eu dissesse
print prod e execute isso. Agora posso ver
que tenho o que pretendia, um, três, um, quatro,
dois, três, dois, quatro. Dê uma olhada aqui, um a três, um a quatro, dois a
três, dois a quatro. É assim que podemos utilizar
a função do produto. Certo. Agora, ainda queremos ter certeza de que estamos
utilizando ferramentas iter, mas desta vez o que
queremos fazer é utilizar a
permutação utilizar a
permutação Queremos criar todas as
ordenações possíveis dos elementos. Eu vou dizer permutações
de importação. Ok. E vamos definir uma lista. Vou dizer que números são iguais e terei de um a três,
por e terei de um a três,
por exemplo. Tudo bem Agora vou definir uma variável. Vou chamar
isso de permanente. Novamente, quero
listar e inserir permutações e aplicar
isso à minha lista chamada Novamente, a permutação é numérica. Vamos adicionar a
lista aqui e gerar um iterador
que produzirá todos os
pedidos possíveis de nossos itens Como você pode ver, novamente, estamos agrupando tudo em uma lista, e isso transformará, é
claro , a saída em uma lista Então, vamos continuar
e produzir perm. E agora podemos ver uma
lista completa de permutações. Podemos ver um, dois, três,
um, três, dois, dois, um, três, dois, três, um, três, um, dois,
três, dois, um. Podemos ver que temos
todas as variações aqui. Agora, acho que isso está um pouco fora do escopo, mas é útil, especialmente em áreas de estatística ou se você está
trabalhando com muitos
dados e precisa
trabalhar com a
função de dados e precisa
trabalhar com a permutações e Certo. A próxima coisa
que quero mostrar é como você pode usar o módulo de
combinações, a
função de combinações, desculpe-me Isso é usado para selecionar grupos exclusivos
de elementos ou itens, devo dizer, e a ordem em
que isso é feito
não importa. Podemos apenas dizer combinações. A partir do modelo itertools, queremos importar o módulo de
combinações Novamente, quero definir uma lista
e definirei isso como um, dois e três, por exemplo. Novamente, vou definir uma variável. Vou dizer C e queremos
converter a saída em uma lista. Vamos envolvê-lo com
a função de combinações e vamos
engessar em números e dois. Combinação de números e dois. Isso nos permitirá gerar um iterador e esse iterador escolherá todas as
duas combinações de números Podemos ver novamente que está
incluído em nossa lista, para que possamos obter a
saída da lista como fizemos antes. Podemos dizer imprimir C.
Vamos executar o código. E aqui podemos ver que obtemos as combinações designadas
que definimos. Então, temos dois aqui em cada conjunto. Se fôssemos fazer
um,
teríamos apenas um em conjuntos separados. E se
disséssemos três, vamos colocar o conjunto
inteiro em um. Certo. Então é assim que podemos
utilizar combinações aqui. Ok. Agora, se
fôssemos executar isso, podemos ver que obtivemos
os mesmos resultados, então estamos gerando corretamente. Ótimo. Tudo bem Agora, a próxima coisa
que veremos é acumular. Agora, essa é uma pergunta interessante. Podemos, por exemplo, realizar a adição
cumulativa. Isso é algo
que analisamos em algum momento
no início do curso, mas deixe-me mostrar como
você pode fazer
isso com a função de acumular Isso é muito útil
, então você pode importar a função de acumulação Então, o que você quer fazer é
definir uma lista de números. Eu vou dizer um, dois,
três e quatro. Então, o que você quer fazer é, novamente, definir uma variável, adicionar sua lista para
que você possa convertê-la e converter
a saída da
função de acumulação e
do emplaster em números aqui para sua função de
acumulação, e a saída estará em
uma lista Então, eu vou dizer
imprima A e pronto. Agora podemos ver que
temos um, três, seis e dez. Agora,
o que acumular. Vou explicar o que
acontece. Começamos com o primeiro item ou
elemento da nossa lista, depois dizemos que um mais
dois é igual Essa é a próxima parte
dessa lista. Então temos três mais
três, o que nos dá seis. Então temos seis mais
quatro, o que nos dá dez. Esse é o processo
de acumulação, como podemos acumular
adequadamente Se eu mudasse
isso agora para dois, três, quatro, 25, quatro, oito ,
por exemplo, código,
obteremos o seguinte. Então você começa às duas. Dois
mais três dá cinco. Cinco mais cinco dá dez, dez mais oito dá 18. Tudo bem, assim por
diante e assim por diante. Você pode ver que é uma função
muito útil. Eu gosto dessa da maioria das ferramentas
do Iter porque é extremamente simples
e muito útil Certo. Agora, o que
vamos fazer agora é focar no
grupo por função. Então, vou fazer o
seguinte e podemos começar com o Grupo B. Ok. Agora, com o grupo
B, basicamente, o que vamos
fazer novamente é, novamente, criar um iterador e ele
vai gerar
grupos um por um Ok, então vamos continuar e
começar o processo. Certo. E outra coisa que eu
também quero mencionar é que, ao utilizar a função do
grupo B, vamos agrupar essencialmente
itens com base em uma chave Mas isso será resolvido antes de
realmente fazermos isso Antes de tudo, precisamos configurar uma lista de tuplas
com categorias, agrupando a chave e
os valores associados Podemos dizer dados e
vamos colocar isso em uma lista. Eu vou fazer com que, por exemplo, seja
um. Então, na próxima,
podemos ter A, e serão dois. Então, podemos ter
outro que é B e três. Então podemos ter, por
exemplo, B e quatro, e então podemos ter a e seis. Lá vamos nós. Perfeito. Então, agora temos essa configuração. Agora, queremos classificar
pelo primeiro valor, isso
garantirá que a função group by funcione corretamente. Então eu vou
dizer ponto de dados SOT, com esse método dentro dele, eu vou dizer K, vai ser igual a Usaremos o Lambda aqui
com um parâmetro de X, e então ele
terá X e zero aqui Ok. Ok, então aí está. Agora, a próxima coisa
que queremos fazer é
definir uma variável e podemos chamar esse grupo
e configurá-lo para o grupo B. Essa é a função do grupo B. Aqui, passaremos pelos dados
que foram classificados e
diremos que K é igual a X, X e zero. Então, o que estamos fazendo agora está essencialmente dentro do
que estamos fazendo ,
é
garantir que possamos agrupar nossos elementos
adequadamente. De acordo com a função Lambda que estipulamos de
acordo com a chave Agora podemos ir de cabeça para baixo
e montar um loop. Então, vamos ver quatro
grupos-chave agrupados Ok. E então podemos dizer print, key
e, em seguida, queremos
converter a lista em grupo. Ok. Certo. Então, dentro
desse loop, essencialmente, vamos converter
dentro do loop, vamos converter
cada grupo em uma lista para ver todos os elementos de uma vez. Então, vamos seguir em frente
e executar esse código. E aqui podemos ver
as categorias. Podemos ver para A,
temos A um, A dois, seis, para B, temos B três e B quatro. Tudo bem, então é
assim que podemos seguir em frente e agrupar nossas categorias,
como você pode ver. Ok. Então, aí
está, essencialmente, em vigor. Agora, eu também quero
mencionar aqui conosco definindo e classificando de
acordo com o Lambda Basicamente,
vamos adicionar os valores adequadamente por meio nossa função
Lambda para classificá-los, depois
agrupá-los e, em
seguida, imprimir
cada iteração, e ela aparecerá da
seguinte forma no agrupamento Ok. Então esse é o grupo por função
que utilizamos. Está bem? Agora, quero mencionar um pouco mais
e mais detalhes, especialmente com a função
Lambda Então, vamos falar um
pouco mais sobre isso e , em seguida, veremos
o conjunto final de iteradores em termos
das funções
de contagem, ciclo e repetição Então, chegaremos a isso em breve, mas vamos
terminar no grupo B. Certo, então vamos
entrar em mais detalhes aqui. Uma classificação de dados. Agora já sabemos que
os dados são uma lista de tuplas
e, claro, você os envolveu
em um formato de lista Então, queremos classificar aqui
os dados
que definimos,
essencialmente, o
método de classificação por pontos classificará
a lista no local com
base em nossa função principal. Ok. Temos K igual a Lambda X, dois pontos e depois X e zero aqui O que vamos fazer
é pegar cada tupla e, claro,
ela será substituída, como você pode ver por X.
Cada tupla,
é claro, por exemplo,
pode ser A um, A dois, P Vamos prosseguir
e substituir isso. Em seguida, vamos extrair
o primeiro elemento aqui, que será um A
ou um B e , em seguida, classificaremos
a lista com base
no primeiro elemento. Ok. Em seguida, o que
vamos fazer, como você pode ver aqui, que
agrupamos é igual ao grupo B. Estamos apenas definindo
uma variável para atribuir o resultado da função do
grupo B aqui, e o grupo
basicamente agrupará os números consecutivos
que têm a Está bem? Então temos, é claro, a função chave aqui, que vai extrair
o primeiro elemento. Então A ou B. Não vai classificar os
dados neste caso aqui, ok? Suponho que
você possa dizer que os itens ou elementos semelhantes
estão próximos uns dos outros, é por isso que os classificamos primeiro. Em seguida, temos
aqui os quatro loops com os quais estamos trabalhando, e sabemos que a função grupo por que
temos aqui retornará pares de chave e grupo em que a chave
é a chave do grupo. A ou B neste caso, temos um grupo, certo? E isso é um iterador
dos itens que
pertencem ao grupo Ok. Tudo bem Então, o que vamos fazer
basicamente é seguir em frente e garantir a conversão
do grupo em nossa lista. Assim, podemos imprimir todos
os itens de uma só vez, certo. Então essa foi a exposição mais profunda de como podemos utilizar
esse grupo por função. Agora, este é um pouco complicado, então não se preocupe
muito com isso É um pouco exagerado, mas é bom pelo menos ter contexto sobre o que você está
fazendo e com o que você está trabalhando Tudo bem Esse é o grupo B. Ok, então vamos
continuar com o resto das funções com as quais
estamos trabalhando. Então, agora o que podemos fazer
é seguir em frente e trabalhar com os iteradores
infinitos Portanto, esses iteradores continuam
gerando valores para sempre
e, é claro, precisam ser interrompidos manualmente Ok. Portanto, temos um
ciclo de contagem e repetição. Então, vamos importar
os moldes,
contar, rodar e repetir Contar vai
continuar contando para sempre, como um ciclo de
quatro que nunca termina. Por exemplo, podemos
dizer quatro I na contagem, e aqui podemos dizer cinco. Agora, o que eu recomendo que você faça
é me ver fazer isso. Eu não quero que você esteja
em uma situação em que tenha um programa que continua rodando e nunca acaba
. Se você tiver esse problema,
então, por favor, eu o aconselho
a dar então, por favor, eu o aconselho uma olhada no que estou
fazendo nesta Vamos começar a
contar a partir de cinco. Então podemos dizer imprimir I. Então o que queremos
fazer é dizer que I I é igual a dez, então eu quero
parar manualmente o loop Eu vou dizer
pausa. Vamos executar isso. Então, podemos ver aqui que
vamos até 5-10, e então dissemos pausa, e isso impede que o
loop seja executado Se eu não seguir em frente
e entrar, o que pode acontecer é que podemos ter uma situação interessante com o ciclo acontecendo
para todo o sempre. Então é assim que você pode
usar a função de contagem. Ok, então continua
contando para sempre e continua e não
vai
parar a menos que tenhamos
um ancinho instalado Também temos a função de ciclo, que é repetir uma lista
infinitamente, como você poderia dizer Vamos
definir a contagem como zero, e podemos dizer quatro
itens em um ciclo, e vamos passar uma lista de itens ou
elementos, você poderia dizer. E queremos adicionar o cólon. Em seguida, queremos imprimir cada item. Em seguida, diremos que
mais é igual a um, e isso vai continuar girando e
girando. E se chegarmos
à contagem de seis, ele vai quebrar. Vá em frente e execute o ciclo. Aqui temos A, B, C, A, B, C. É assim
que podemos seguir em frente e utilizar a função de ciclo. Ok. O último que
vamos
ver será repetido. Está bem? Então, queremos
repetir um valor, um número específico de vezes. Ok, então podemos dizer REP,
por exemplo, como uma variável. Queremos dizer lista porque queremos converter
a saída em uma lista. Queremos incluir a função
de repetição. E aqui eu quero
dizer olá, e três. Então eu quero dizer imprimir, ap. Ok. Então, se eu fosse executar isso, ele diria olá, olá, olá. Estamos optando por repetir o primeiro valor que colocamos
aqui nas análises e à direita, é onde definimos
quantas vezes queremos repetir o que definimos
no lado esquerdo aqui O primeiro parâmetro
que você poderia dizer é, obviamente, o que você
deseja repetir. O segundo parâmetro
que você poderia
dizer tecnicamente é quantas vezes você
deseja que ele seja repetido Se eu dissesse, gosto da missa e quero repetir
isso cinco vezes. Vai repetir a missa “Eu
gosto” cinco vezes. E como a
convertemos em uma lista saída
que
obtemos aqui
dessa função de repetição aqui, ela a
colocará em uma lista e
exibirá os dados dentro da lista e
acabamos de imprimi-la. Então é assim que podemos
usar uma função de repetição. Agora, obviamente, eu diria que a
contagem e o ciclo estão bem, mas eu diria que a repetição é mais útil como uma das ferramentas Tudo bem, pessoal. É isso mesmo. Entramos em detalhes sobre
as funções que você pode
utilizar com as ferramentas do Iter
75. Gerenciadores de contexto: Olá a todos, bem-vindos
à próxima lição, que será focada
em gerenciadores de contexto. Então, vamos dar uma olhada. Então você provavelmente está se perguntando o que
diabos é um gerenciador de contexto. Portanto, um gerenciador de contexto em Python
manipula a configuração e a
limpeza de recursos automaticamente, como abrir e fechar arquivos
usando a Agora, a declaração WI
simplifica o gerenciamento de recursos, tornando nosso código mais seguro
e mais legível Então, deixe-me mostrar uma
diferença aqui em termos de gerenciamento manual de
arquivos, como aprendemos anteriormente no curso, e como você pode fazer isso de forma mais simples e eficiente Eu prefiro dizer que é um gerenciador de
contexto. Aqui está o arquivo básico
IO sendo executado. Estamos abrindo um arquivo conhecido como car dot TXT e
queremos gravar nele Portanto, o modo W está em vigor. Em seguida, nos referiremos a esse objeto de arquivo
específico e diremos o ponto certo
do arquivo do carro e, em seguida diremos que minhas cartas favoritas
são Forward e Tesla, e então precisamos
fechar nosso arquivo No entanto, podemos simplificar
isso com um gerenciador de contexto, que abrirá
e gravará em nosso arquivo. Como você pode ver, é muito
mais simples, com menos linhas de código. Então, temos o WIS
Open, car dot txt, o mesmo modo, e
vamos configurá-lo como arquivo car Isso seria o que
definiríamos em termos de
configuração da variável. E então vamos dizer arquivo de carro, certo, e escrever normalmente. Agora, uma coisa boa que você
pode ver aqui é que você não precisa fechar o
arquivo depois de escrever, e isso pode resolver
um grande problema. Também é um pouco mais suave em termos de como está escrito Você não precisa ser tão
simplificado e definir uma variável e dizer
ponto, escrever ponto, fechar. É um pouco mais limpo
e eficiente. Além disso, o que
você pode fazer é seguir em frente
e aplicar
isso no próximo exemplo,
em que abriremos um arquivo novamente para anexá-lo Então, aqui temos o arquivo car
igual a open cartXT e depois A, e podemos ver que estamos escrevendo
e fechando o arquivo, podemos seguir em frente e,
com nosso gerenciador de contexto, podemos simplesmente simplificar isso
para substituí-lo por W open e, em seguida, dizer como arquivo car,
seria Tudo bem, pessoal. Portanto, isso é apenas uma pequena
visão para você, que você
possa ver como os gerenciadores de
contexto nos
poupariam
pelo menos
do trabalho de fechar o arquivo, e é muito mais fácil e limpo utilizar gerenciadores de
contexto, especialmente quando
você está executando ILO de
arquivos com
entrada e saída de arquivos
76. Trabalhando com gerenciadores de contexto — [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de laboratório, que se concentrará na
utilização do gerenciador de contexto.
Vamos começar. Agora, a primeira coisa
que quero fazer
é fazer é revisão com
todos vocês e
passar pelo IO
básico do arquivo novamente, peso
manual, sem
usar um gerenciador de contexto. Certo, seguindo dessa forma, você aprenderá a ver
as diferenças e a
aplicar os dois casos. Queremos definir uma variável e eu posso chamar esse arquivo car, e vamos atribuí-lo
ao nosso objeto de arquivo, essencialmente, que é criado
utilizando nossa função open e passaremos em carxts o arquivo que queremos abrir ou criar se ele não existir,
e queremos gravar
nesse arquivo, portanto o modo W. Em seguida, queremos nos referir à chamado arquivo e adicionado
na mensagem de gravação, queremos gravar no arquivo. Aqui eu quero dizer que
gosto de cartões vermelhos. Em seguida, queremos fechar o
arquivo e dizer carflet close. Vamos executar o código. Vamos ao nosso diretório. E aqui você pode ver
que o ponto TxDfle foi criado no diretório do nosso
projeto Se eu puder clicar nisso,
posso ver que parece que gosto de
carros vermelhos como deveria Tudo bem, perfeito.
Agora, o que vou fazer a seguir é comentar esse código,
para você
possa ver e
aprender as diferenças
entre o tratamento regular de arquivos e como fazê-lo com
um gerenciador de contexto. Então, vou clicar com o botão direito do mouse
no ponto TXT do carro e excluí-lo. E mova isso para
a lixeira. Ótimo. Agora, o gerenciador de
contexto, diríamos Wi open e utilizamos a função
open. Queremos criar um arquivo car dot txt com a intenção de
gravar no arquivo, e isso
será armazenado como arquivo car E essa é a variável à qual
atribuímos esse objeto de arquivo. Então podemos dizer carfle
dot logo abaixo dela, e essa será exatamente a mesma mensagem que
usamos antes E aqui eu quero dizer que gosto carros
azuis e eles
executam esse código. Vamos ao nosso diretório. Aqui podemos ver que temos o Card at TXT que agora diz:
Eu gosto de carros azuis Perfeito. Espero que agora você possa ver a distinção
entre os dois Agora, antes de
prosseguirmos e testarmos isso com o modo de acréscimo, o que eu quero fazer é examinar outro exemplo com
você com a gravação de arquivos que você possa começar a aprender
a distinção
entre os dois métodos Podemos remover isso,
vamos seguir em frente e fazer o próximo exemplo e
depois acrescentar. Tudo bem Agora, o que vou fazer
é basear isso em uma pessoa. Eu vou dizer que o arquivo da pessoa
é igual, e eu vou dizer aberto. Isso
criará um arquivo chamado person dot GXT e eu
quero gravar nesse arquivo Agora vou dizer
Person file dot R, e eu quero escrever Oi. Eu sou Auto. Em seguida, preciso fechar
o arquivo dizendo person file dot close. Vamos seguir em frente e executar o
código. Vá para o diretório. E aqui podemos ver que
temos uma pessoa com pontos TXT. Se clicarmos nisso,
podemos ver, Oi, Amano. Ótimo. Então, agora eu ainda posso ver
que temos os arquivos TXT do carrinho Então, o que vou
fazer é excluir
os
dois arquivos a partir de agora. Então, podemos comentar esse
código no momento. E vamos fazer exatamente
a mesma coisa para um arquivo pessoal. Então, vou usar o gerenciador de
contexto agora
e vou
dizer Wi, vou dizer aberto. E aqui, o que vou
fazer é criar um arquivo
TXT com pontos pessoais com a
intenção de
gravar nele como um arquivo pessoal Vou dizer
Person file dot right, e vou escrever Hi iMou Vamos executar o código agora. Posso ver uma pessoa nos arquivos TXT criados que diz oi, eu não sou Simples Aí está. Agora temos essa
prática fundamental em vigor agora. Agora, a próxima coisa que
queremos fazer é agora que temos essa
pessoa no arquivo TXT, vamos realmente abri-la e anexá-la
usando o arquivo IO básico Sabemos que isso existe, então podemos prosseguir e
remover tudo. Guarde esse arquivo.
Agora vamos abri-lo. partir deste momento, apenas diz:
Oi, eu sou Ro. O que podemos fazer é abrir esse arquivo novamente
e anexá-lo Vou chamá-lo de arquivo pessoal. Veja aberto, e isso é chamado ponto de
pessoa TxD e nossa intenção é acrescentar a ele. de ponto de
pessoa TxD e
nossa intenção é acrescentar a ele.
Esse é o
modo que vamos definir. Então, queremos
dizer “pessoa”, “arquivo”, ponto à direita, e eu quero adicionar um espaço e dizer “
oi Ana”, foi o que disse, e eu gosto de filmes. Muito simples. E podemos
dizer que o arquivo da pessoa está próximo. Vamos seguir em frente e
executar esse código. Vamos ao diretório,
prisão. Se disser:
Oi, eu não sou, e eu gosto de filmes. Perfeito. Então, podemos
ver que é assim que podemos utilizar um método pen
com IO de arquivo básico. Vamos continuar e
configurar isso com um gerenciador de contexto. É o que diz, e eu gosto de filmes, vamos ajustar isso. Então, eu vou
comentar isso. Vamos acrescentar
novamente a esse arquivo. Queremos ver o WIS aberto aqui no Parenss.
Vou me referir a esse arquivo
, chamado person dot Minha intenção é
anexar a esse arquivo como
um arquivo pessoal. Então,
podemos escrever para ele. Vou dizer ponto de arquivo pessoal, certo. Vamos ver o que
temos neste momento. Olá, eu sou e gosto de filmes. Então eu vou dizer
algo externo que diz, eu sou da África do Sul. Isso deve ser anexado depois, e eu quero colocar um
espaço aqui. Lá vamos nós. Então, vamos
ver se isso se acrescenta a ele. Então, se eu executar o código, vá para person dot TXT
e pronto Podemos ver Olá, eu sou
Ano e gosto de filmes. Eu sou da
África do Sul. Lá vamos nós. Simples Então é assim que podemos utilizar gerenciadores de contexto quando estamos trabalhando com nossos arquivos. Portanto, você pode ver que é muito eficaz se quisermos
simplificar e omitir o medo de fechar nossos arquivos depois de
reescrevê-los, pois pode ser um pouco entediante, você pode esquecer
e cometer erros Mas com os gerenciadores de contexto, ele cuida de tudo
para você. Tudo bem, pessoal Então, é isso neste exercício
prático de laboratório sobre gerenciadores de contexto.
77. Gerenciadores de contexto integrados vs. personalizados: Olá a todos, bem-vindos
à próxima lição, que se concentrará na comparação do gerenciador de contexto integrado com o
personalizado. Então, vamos dar uma olhada. Tudo bem. Agora, com o gerenciador de
contexto incorporado, você normalmente
usaria com open, e usaríamos
a instrução Wi com a função open
para abrir um arquivo. OK. Agora, esse é um gerenciador de
contexto integrado que gerencia
automaticamente nossos recursos, como arquivos para abri-los
e fechá-los, e é
com isso que
trabalhamos , como na lição
anterior. Também temos um gerenciador de
contexto personalizado. Um exemplo de como isso
seria utilizado é que um
gerenciador de contexto personalizado é basicamente uma classe que você cria
que definirá métodos de
entrada e saída
dentro da classe para executar e
gerenciar recursos ou
ações quando entrarmos ou sairmos de
um determinado bloco de código Agora, o que vamos
fazer é seguir em frente e trabalhar com um gerenciador de contexto
personalizado. Já temos experiência com um gerenciador de contexto integrado, com o
qual trabalhamos no exercício
prático anterior de laboratório, mas agora vamos criar nosso próprio gerenciador de contexto personalizado. Vou mostrar como você pode gerenciar tudo
com seus arquivos, por exemplo, se você for
trabalhar com uma determinada classe. Então, vamos direto ao assunto.
78. Crie um gerenciador de contexto personalizado — [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de
laboratório, que se
concentrará na criação um gerenciador de contexto personalizado
para manipulação de arquivos. Vamos começar. Agora, já temos
experiência com aulas, então vamos
fazer uso de uma aula. A primeira coisa que
queremos fazer é definir nossos nomes de classe. Eu vou dizer classe e
vou chamá-la de gerenciador de arquivos. Então eu preciso seguir em frente
e definir minha mensagem inicial. Vou dizer Derescore, então precisamos passar por
nossos parâmetros, então teremos self, nome
do arquivo e Agora queremos inicializar nossa
classe de gerenciador de arquivos e o que
vamos fazer é especificar os atributos Vamos dizer que o nome do arquivo self
dot é igual a, e esse será o nome do arquivo Então, teremos
o modo automático, e isso
será igual ao modo. Vamos armazenar
o nome do arquivo aqui com o nome do arquivo self dot
e também vamos
armazenar o modo como
modo, que pode ser R para leitura, pode ser W para, é
claro, escrever e
pode ser A para acrescentar OK. Em seguida, o que queremos fazer é
definir nossos métodos. Lembre-se de que, com
as mensagens, elas
precisam estar alinhadas ao
seu método de inicialização Em primeiro lugar, vou
dizer Defunderce enter, sublinhar
duas vezes, e aqui
vamos Essencialmente, o que queremos
fazer é inserir o contexto de tempo de execução
relacionado ao nosso objeto, e esse método
será chamado quando a execução entrar no Wispblock, que
definiremos posteriormente, e ele abre o arquivo e
retorna o objeto do arquivo OK. Então, o que
queremos fazer é dizer que o arquivo de ponto próprio é igual Vamos dizer nome do
arquivo com ponto próprio e modo com ponto próprio. Então, queremos abrir o arquivo no
modo designado fornecido. Então, queremos dizer
return, self dot file. OK. Agora, o arquivo próprio
aqui, é claro, será nosso objeto de arquivo, e esse será o arquivo aberto que pode ser usado
no bloco WIS. Então é isso que
vamos fazer aqui. E, como podemos ver,
isso é
atribuído como variável em inteligência. Está bem? Em seguida, o que precisamos fazer é
especificar nosso método de saída, que sairá do contexto de tempo de execução e limpará os recursos. Esse método é chamado quando a execução sai
do bloco With. Vou dizer apenas Jeff, sublinhado
duplo na saída
e sublinhado duplo Vou passar por
alguns parâmetros. Primeiro, teremos o eu. Então, teremos o tipo de sublinhado
EX. Esse é o tipo de exceção,
caso ocorra uma exceção. Caso contrário, ele simplesmente não
retornará nenhum. Então, temos o valor do
sublinhado EXC. Essa é a instância de exceção
se ocorrer um erro
e, claro,
se
nada ocorrer, não será nada. Então,
teremos o rastreamento de volta. Esse é o objeto de rastreamento
que contém detalhes do erro. Podemos prosseguir e
fechar o seguinte. No momento, o que queremos fazer
é primeiro verificar se o arquivo está aberto. Eu vou dizer que eu mesmo pontuo o arquivo. Então, se esse arquivo for aberto
e, nesse caso, se tiver sido,
o que eu quero fazer é fechar o arquivo para
liberar recursos. Então, isso é sobre sair. Então, vamos verificar se
o arquivo está aberto inicialmente
e, quando essa saída, se
esse método de saída
for executado, poderemos fechar
esse arquivo específico. Está bem? Porque você não pode fechar algo que
ainda não esteja aberto. OK. Portanto, o método de saída será
chamado quando
quisermos sair do
nosso arquivo e fechá-lo. Em seguida, o método
verificará se esse arquivo está
realmente aberto no momento, se há algo muito próximo
e, em seguida, o fechará. Então, diríamos self
dot file, dot close. Então, vamos
fechar o arquivo e isso vai ajudar
a liberar recursos. OK. Perfeito. Agora, o que
queremos fazer é seguir em frente e, aqui fora
do nosso gerenciador de arquivos de classes, o que queremos fazer é usar nosso gerenciador de
contexto personalizado. Isso será o
que usamos antes com a lógica que
usamos anteriormente Vamos
continuar e dizer, Whiz, vamos chamar
nossa turma aqui, que é gerenciador de arquivos E então vamos gostar
de antes, definir o que queremos
abrir ou criar. Então, aqui, eu vou
dizer car dot TXT, e então eu quero escrever para ele, então eu vou colocar o modo W, e eu vou dizer como
CarfLE. Vá em frente. OK. Então, como podemos ver aqui, temos essa declaração aqui, e isso vai acabar chamando nosso método de gerenciamento de arquivos,
que é Enter, que abrirá o
arquivo e o retornará,
e o
objeto do arquivo de retorno será atribuído Para o arquivo do carro e ele é
usado dentro do bloco. Então, o que queremos
fazer é garantir que estamos
escrevendo em nosso arquivo. Para aqui, eu vou
dizer carfle dot. Aqui vou
dizer que gosto da Honda. Ok, então escrevemos
no arquivo. Então, o arquivo agora que está aberto, ele também vai
gravar no arquivo. E automaticamente, quando
tivermos executado a ação
necessária, quando o bloco terminar,
em outras palavras, com a instrução WIS
que configuramos aqui, ele chamará o
gerenciador de arquivos em termos do método de saída
designado aqui
e o
chamará automaticamente
para fechar o arquivo OK. Esse é o processo aqui e a execução com o que
estamos configurando aqui. Vou apenas diminuir o zoom
aqui. Como você pode ver, definimos nossa classe, a
adicionamos aos
parâmetros e declarações necessários. E então, aqui
no final do lado de fora, estamos apenas chamando nossa
turma e, em seguida, indo até uma cerca, criando um arquivo
e depois nos deparando com ele Na verdade, podemos ir em frente
e testar isso. Então, o que vou fazer agora
é testá-lo. Então, se eu executar meu código, não
haverá uma saída, mas se eu for até aqui, posso ver que
tenho
esse arquivo TXT com pontos de cartão que diz: Eu gosto da Honda E você pode ver que tudo foi
gerenciado automaticamente para nós e como deveria
ser. Tudo bem, ótimo. É assim que você pode
seguir em frente e essencialmente, criar um gerenciador de
contexto personalizado para manipulação de arquivos
e, o mais importante,
estamos
usando-o via Visa por meio de uma classe aqui, como você pode ver,
chamada gerenciador de arquivos. Ok, então todo o
processo, como você pode ver, funciona de forma muito semelhante
à forma normal em que
seguimos em frente e trabalhamos
com nossas aulas. OK. Isso é tudo
na parte principal. O que vou fazer
agora é analisar mais e mostrar
o que mais você pode fazer. Tudo bem. Vamos continuar. Agora, a próxima coisa que
vamos querer fazer é seguir em frente e personalizar ainda mais nossos métodos enter
e except. Agora, antes de continuarmos, o que eu quero
fazer é fazer uma pequena limpeza Vou para o Explorer
e quero excluir esses arquivos que tenho,
exceto o arquivo principal dot pi. A pessoa doTXT e o
carro doTXT. Lá vamos nós. Apenas certifique-se de não ter excluído o arquivo de pontos principal. É com isso
que estamos trabalhando. O que podemos fazer agora é
seguir em frente e fazer
algumas personalizações
dentro do nosso método provisório O que eu quero fazer é que,
uma vez aberto um arquivo, eu quero imprimir algum texto para
dizer o nome do arquivo que foi aberto e também
ir em frente e mostrar o
modo em que ele foi aberto Neste caso,
quero imprimir
que o cdTxt foi aberto ou criado e que o
modo de escrita foi habilitado para Então, aqui estava na
minha mensagem Enter. Vamos mover isso para lá.
Eu posso dizer impresso. Vou usar strings S
para dizer o arquivo. E aqui vou colocar no meu lugar
o nome do arquivo em si. Então, ele
chamará o nome do arquivo, que será chamado em
txt, e depois o modo, que será W. Eu quero dizer que
o nome do arquivo é o arquivo, está aberto,
e o modo é, e então eu posso dizer modo de ponto
próprio Vá. Agora, digamos que eu queira adicionar uma declaração pouco
antes do fechamento do arquivo, eu
possa utilizar o método de
saída para isso e ajustá-lo. Eu posso dizer impresso. O arquivo está prestes a
ser fechado. Tenha isso. Agora vou recriar aquele arquivo TXT que eu tinha antes
e ele aparecerá Vamos executar o código, mas agora devemos ver a saída em nosso console sendo exibida. Vamos salvar
e executar esse código. Lá vamos nós. Como podemos
ver aqui, diz que o cartão de arquivo TXT está
prestes a abrir e o modo é W e o arquivo
está prestes a ser fechado Podemos ver que nosso método enter executado e imprimiu a
seguinte declaração, que foi a primeira aqui.
Com nosso método de saída, ele
imprimiu o arquivo está prestes a ser fechado e o seguinte, como
podemos ver aqui. Perfeito. Bem feito. É assim que você pode
seguir
em frente e adicionar funcionalidades extras
aos seus métodos. Certo. Agora, vamos prosseguir
e realizar o tratamento de erros. Agora, digamos que temos um
erro ao sair do nosso arquivo. Por exemplo, aqui, eu
quero continuar e substituir esse arquivo
que temos atualmente, e vou
mudar um texto para dizer que eu gosto dele como exemplo Então eu vou,
por exemplo, ligar para Afle. Eu vou dizer aqui
carfle dot random. Ok, e isso vai ser uma mensagem
aleatória,
algo aleatório aqui. Então, digamos que queremos
chamar um método aleatório, algo que não existe, haverá um erro
ao fechar o arquivo,
porque lembre-se de que, ao
abrirmos
o arquivo, tudo bem, garantiremos que possamos acessá-lo, que podemos fazer, e
podemos gravar nele, que podemos fazer aqui. E vamos gravar
no arquivo ao abri-lo, e ele será gravado. E então ele só será
fechado quando estivermos
executando a mensagem de saída. Então, depois de
gravarmos no arquivo,
fecharmos o arquivo, mas
antes que ele possa ser fechado, adicionamos
esse método inválido, que
acionará um erro
nesse método de saída porque é onde estamos no
estágio atual do programa Essencialmente, o que eu quero
fazer é ir até uma cobertura e
imprimir uma exceção Então,
o que vou fazer é manter as coisas muito simples
e declarar que, e declarar se eu tivesse
uma exceção, direi aqui, se meu
chip de sublinhado de exceção não for nenhum Então, se eu tiver uma exceção, quero imprimir
temporariamente a
exceção que está sendo tratada.
Tudo bem, desse jeito E a próxima coisa
que eu quero fazer é dizer saia daqui para fora, e eu quero voltar a ser verdade. OK. Agora, deixe-me explicar
o que estou fazendo aqui. Portanto, esta declaração de impressão
aqui diz que a exceção sendo tratada significa que eu quero imprimir uma mensagem se ocorrer uma
exceção Portanto, esse tipo de exceção diz:
I, o tipo de exceção não é nenhum, o que significa que, se houver
uma exceção, quero imprimir a
exceção que está sendo tratada Está bem? Tudo o que estou fazendo aqui, fora dessa declaração é dizer saída para impressão. Isso
imprimirá essa mensagem independentemente de haver
uma exceção ou não Retorne verdadeiro aqui, é muito importante porque
isso
suprimirá qualquer exceção
que tenha ocorrido dentro do bloco WIS aqui Isso garantirá que
não haja mais erros. Eu vou te mostrar
o que vai
parecer quando eu estiver lidando com
a exceção primeiro. Estou fazendo isso ao
contrário. Então, se eu fosse executar esse código, poderíamos ver: Ok, está aberto. Podemos ver que está sendo fechado. Então, podemos ver a exceção
sendo tratada e sair. Agora, digamos que eu
removesse esse tratamento de exceções, deixe-me ir até
uma cerca e apenas comentar para soar
e remover isso E agora o que vou
fazer é executar exatamente
a mesma coisa
e dizer executar código. OK. E podemos ver aqui o arquivo está prestes a
ser fechado e sair. Agora, o que
você verá aqui é
que ele ainda não está lançando flechas, e isso é porque eu retornei
verdadeiro aqui, e isso suprime suas
exceções Então, o que você vai
querer fazer é
adicionar sua hashtag aqui e
apenas adicioná-la no comentário, e podemos seguir em frente
e executar o código Agora você pode ver que ocorre um erro de
rastreamento. Podemos ver agora
que temos esse erro, então é um
erro de atributo e o objeto tem um atributo aleatório, então
podemos ver onde esse erro
ocorreu de podemos ver onde esse erro acordo com o rastreamento Podemos ver uma mensagem aleatória de carfle
dot, e foi aqui
que o erro ocorreu Isso é algo que eu
queria mencionar. Esse é o erro que
você receberá se não tiver o
tratamento de erros em vigor. Agora, se você quiser que
seja um pouco mais conciso e específico, o que você pode
fazer essencialmente é o seguinte Vamos dizer que retorne verdadeiro. Queremos obter esse tipo de
exceção. Mas dentro dessa declaração aqui, queremos ver os
detalhes de forma mais concisa. Não queremos o manipulador de
exceções padrão. Queremos estilizá-lo nós mesmos. Quero ver o
tipo e o valor da exceção, e quero ver o rastreamento aqui nesta
declaração
impressa O que eu vou fazer é ir em frente
e adicioná-los. Eu vou dizer, tipo de
exceção. O que vou fazer é
achar que vou usar strings F, então posso simplesmente
voltar para elas. Eu vou dizer tipo de exceção. Então teremos valor e eu
quero ver o rastro de volta. Eu também vou mudar o texto. Isso é para ter minhas próprias mensagens de erro
personalizadas. Rastreamento. Agora, vamos executar isso. Então eu recebo minhas próprias mensagens de erro
personalizadas, e isso é muito útil. Tipo de exceção, podemos ver erro do
atributo, o valor da
exceção, podemos ver que não há nenhum atributo
aleatório relacionado a isso
e também podemos ver um rastreamento em termos do
objeto de Esse é o erro
aí. Lá vamos nós. Acho que essa é uma maneira mais útil Se você também quiser lidar com o tratamento de
erros, basta
verificar com calma se o
tipo de exceção não é nenhum
e, em seguida, retornar true
para poder suprimir qualquer exceção que ocorra, é claro,
como mencionei, no Wistblock, isso
também garantirá que não acione o erro padrão no
console e, ao lidar com isso sozinho,
observando manualmente o tipo, o valor do traceback também pode
ser muito eficaz,
porque, como você pode ver,
ele também está em um tipo
de saída muito limpo de saída Tudo bem, então é assim que você
também pode lidar com o tratamento de erros ao
lidar com seu gerenciador de contexto
personalizado Então, outro
ponto muito útil a ser mencionado aqui é que, quando você está trabalhando
com gerenciadores de contexto, você tem mais opções
para alterar a forma como deseja, por exemplo, o processo de
tratamento de arquivos. Tudo bem, pessoal. Então,
isso é tudo para este exercício de laboratório sobre a utilização de gerenciadores de
contexto personalizados com manipulação de arquivos
neste caso específico
79. Geradores: Olá a todos, e bem-vindos
à próxima lição, que será focada em geradores, vamos começar Tudo bem, então você
provavelmente está se perguntando o que diabos é um gerador. Um gerador é essencialmente
uma função exclusiva que retém seu estado e produz uma sequência de
valores, um por
vez, em vez de
retorná-los todos de uma vez Agora, você provavelmente está se perguntando,
é bom saber, mas como eles realmente funcionam? Em vez de retorno, os geradores
usam a palavra-chave yield. Agora, isso significa que eles
não são executados de uma só vez, mas pausam no rendimento E isso torna os geradores eficientes em termos de
memória, já que eles não armazenam
toda a saída na memória Agora, os efeitos
que você vê não são algo que você
verá imediatamente. Você realmente não
verá isso no código, mas é em termos de processamento de
back-end. Está bem? É assim que você
mede a eficiência, mas eu tenho uma lição sobre
isso: vamos explicar isso para dar mais
sentido à eficiência da memória. De qualquer forma, vamos continuar
e focar nos geradores. Mas agora o que eu quero
fazer é
explicar uma analogia simples para explicar uma analogia simples que você
possa
entender melhor os geradores, e essa analogia
será focada em assistir será focada em Portanto, no conceito de
rendimento em geradores, podemos compará-lo no Netflix com
o botão de pausa Portanto, o rendimento é o botão de pausa. Depois de terminar um episódio, Netflix faz uma pausa em vez de
reproduzir tudo de uma vez A Netflix também tem
a opção de clicar no
botão Avançar para ir em seguida. E quando estamos trabalhando
com geradores, às vezes
tendemos a
usar a próxima função Então, o próximo é um botão play. Então, quando estiver pronto, pressione Play para assistir ao próximo episódio, e isso também pode
ocorrer com geradores Podemos utilizar a
próxima função para ir para o próximo resultado que
está sendo gerado Agora, outra coisa importante é que ele salve de
onde você parou. Você não precisa começar
do início cada vez que assiste
a um episódio na Netflix. Sempre se lembra de
onde você foi pela última vez. A mesma coisa com a utilização de
geradores e a utilização do rendimento. Vai lembrar
onde você esteve pela última vez. Ok. Agora, vamos aplicar
isso a um programa. Então eu crio uma função, que é um programa da Netflix, e depois vou produzir, por exemplo, três episódios. Então, produza o episódio um, episódio dois e o episódio três. Em seguida,
vou armazenar essa
função show do Netflix em uma variável,
e essa variável acabará sendo um objeto gerador que está sendo armazenado porque estamos
utilizando a palavra-chave yield Então, o que podemos fazer
é imprimir cada episódio em ordem,
utilizando a próxima função Podemos dizer imprimir em seguida e
depois encapsular o episódio. Isso vai
imprimir o primeiro episódio. Em seguida, utilizamos a
próxima função, inserimos o episódio e isso resultará
no episódio dois. Vai
lembrar o estado. Não vai imprimir os
episódios um, dois e três. Se você simplesmente continuar
exibindo o episódio, precisaríamos
dizer o próximo e ele o
fará em iteração. Ok. Agora, esse será o caso se
estivermos pulando manualmente,
assim como na Netflix, se estivermos pulando
manualmente um episódio Está bem? Continuaríamos usando a próxima função
todas as vezes para fazer isso. Agora, o que também podemos fazer é automatizar isso para que
seja um pouco mais rápido Podemos usar um loop de quatro. Está bem? Então comece o programa de TV e
dê uma olhada nos episódios. Então, usamos quatro loops dizendo quatro episódios no programa da Netflix, episódio
impresso, e
isso imprimirá tudo na ordem
designada. Ok. E isso seria pular
automaticamente. Certo. É assim que podemos aplicar
e utilizar geradores. Vamos praticar e em frente e fazer alguns exercícios práticos de laboratório para
trabalhar com geradores.
Fique ligado.
80. Trabalhando com geradores — [Lab]: Olá a todos, e bem-vindos ao próximo exercício prático de
laboratório, que será
focado em geradores Agora, como mencionei
nas aulas teóricas
que mencionei, um gerador é uma função
única que retém seu estado e produz uma sequência de
valores, um por
vez, em vez de
retorná-los todos de uma vez Agora, eu só quero
mostrar e
provar que um gerador não é apenas uma
função normal e que é uma função única. Então, vamos definir uma função normal para começar. Vou apenas dizer
morte e ainda
teremos a mesma
ligação que recebemos antes. Eu vou dizer que o
sublinhado da Netflix aparece como nome
da função, em ambos os
lados, parênteses vazios Vou, por exemplo,
pegar uma cerca e dizer Imprimir o
primeiro episódio, e isso é tudo Então eu vou pegar uma
variável e vou
dizer que o episódio é igual ao programa de sublinhados
da Netflix Então, se eu disser episódio impresso, veremos aqui
que ele não retorna nenhum. Esse é apenas um teste muito
simples para ver se estamos lidando
com uma função. Mas se eu removesse
print e dissesse yield, usasse a palavra-chave yield e
quisesse dizer episódio um, e eu fizesse a mesma coisa e executasse, ele geraria
um objeto gerador. Então, isso é uma indicação para
mostrar que, ao adicionar o rendimento, estamos dizendo a Pison
que queremos transformar essa função
em um gerador, em outras palavras, uma função
única Então, apenas algo
que eu queria mencionar aqui para que possamos ter alguma clareza sobre a diferença.
Então, vamos voltar. De qualquer forma, precisamos
definir uma função. Vai ser um programa da Netflix, e então queremos
produzir alguns resultados. Então, eu vou
apresentar, primeiro de tudo, episódio um, e ele vai dizer
algo aleatório, o moinho. Rendimento. Agora vou dizer episódio dois. A vila do
episódio 3 de ban and yield. Agora, você pode adicionar algum
espaço aqui, se quiser, ou pode mantê-lo apertado. Depende realmente de você o
que você quer fazer, mas certifique-se de ter
três declarações de rendimento. Em seguida, queremos associar a função aqui, Netflix show, que agora é um gerador
a uma variável para que nossa variável contenha esse objeto
gerador. Então, eu vou dizer que o
episódio é igual, e vai ser um programa de sublinhados da
Netflix E atribuímos
esse objeto gerador. Perfeito. Agora podemos imprimir os
episódios um por um. Então, se eu disser imprimir, posso
usar a próxima função e posso simplesmente dizer episódio. E vamos seguir em frente e executar isso. E você pode ver aqui que
diz Episode one the Mill. Deixe-me executar o código aqui.
Episódio um: o ML. Então, não vai continuar
produzindo todos os
episódios que temos. Ele vai fazer isso em segmentos. Então, para eu ver
o próximo episódio, terei que utilizar
a próxima função novamente,
então vou para o episódio dois,
depois para o episódio três e
assim por diante. Então, deixe-me fazer isso. Você pode simplesmente
imprimir a declaração impressa três vezes. Então, o primeiro episódio
será impresso primeiro. Episódio dois a seguir e
episódio três compartilhado. Então, vamos seguir em frente e executar isso. E, como você pode ver agora,
agora está produzindo o Episódio 1. Para responder em ordem. Não se trata apenas de produzir todos
eles tão repentinamente Está bem? Então é assim que podemos seguir em frente e configurar um gerador
simples. Agora, digamos que queremos
automatizar isso. Não queremos ter que usar constantemente
a próxima função todas as vezes. Então, o que
podemos fazer é remover isso. Tudo bem. E queremos remover
isso também e podemos dizer quatro episódios na Netflix. Underscore Show Colon, e
queremos dizer episódio impresso. E se rodarmos isso,
teremos o episódio um,
o moinho, o episódio dois, o
celeiro e o episódio
três, o Vella Agora, você provavelmente está
se perguntando: Ok, o que há de tão único em todo
o processo, que tem a ver com a eficiência dos geradores nos bastidores, e isso não é algo que você
verá inerentemente em seu código, mas é algo que
acontecerá em segundo E, como mencionei, essa é
uma lição que vou abordar na próxima lição, devo dizer, sobre como
prosseguir com esse processo. Mas, de qualquer forma,
vamos seguir em frente e fazer outro exemplo simples
de gerador, e vamos fazer isso. Tudo bem. Em seguida, vou dizer D
e depois vou dizer, vamos usar,
digamos , DF e quero
dizer que itens com DF e quero
dizer que sublinhado do
rosário
seriam Agora, para
transformar isso em um gerador, precisarei dizer rendimento, ter pelo
menos uma declaração. Aqui eu vou dizer maçã. Produza leite. Rendimento, e podemos dizer
carne. Lá vamos nós. Agora, queremos seguir em frente e atribuir nosso gerador a uma
variável, nosso objeto gerador. Vou continuar e
dizer que produto é igual,
e vamos dizer que itens de
supermercado sublinham Agora, o produto agora é
um objeto gerador. Então, agora vamos
testar o processo. Então, se eu dissesse imprimir, posso dizer próximo, usar a função seguinte
e, em seguida,
adicionar esse
objeto gerador, ou seja, produto. Então, agora, se eu executar isso, ele
produzirá Apple. E se eu continuar
executando-o, ele não vai mais longe, ele só vai fazer o próximo valor
específico definido aqui. Eu precisaria fazer isso
pelo número de vezes que
tenho esses itens específicos se
eu comesse maçã, leite e carne. Perfeito. Vamos automatizar isso Então, vamos remover o seguinte. Podemos simplesmente ir
em frente e adicionar um flop. Então, vou dizer que para produtos em itens de supermercado sublinhados. E podemos simplesmente
imprimir o produto. Então, cada declaração específica que temos aqui,
é executada. E aqui temos
maçã, leite e carne. Tudo bem, então
vamos lá. É assim que podemos simplesmente seguir em frente e utilizar um
gerador em Bison Vou passar pela
próxima lição agora, a
parte de eficiência de memória, para que você possa entender o
benefício real dos geradores Tudo bem, pessoal. Então, é isso em particular neste exercício de laboratório
em particular.
81. Eficiência da memória do gerador: Oi, pessoal. E bem-vindo à próxima lição
, que se
concentrará em entender a eficiência da
memória em termos de gênero. Tudo bem, então entendendo a eficiência da
memória. Uma função regular armazena todos os
valores na memória de uma só vez, o que pode ser ineficiente
para grandes conjuntos Por outro lado, um
gerador
produzirá um valor vez sem reter os
anteriores, torna muito
mais eficiente em termos de memória Então, digamos, por exemplo, que estamos trabalhando com
uma função regular. E nessa função regular, definimos uma função
conhecida como show da Netflix. Estamos retornando uma
lista de episódios
e, em
seguida, o que estamos
fazendo
basicamente é em atribuir esses episódios a essa
função específica aqui, e essa lista inteira será criada na memória, e depois poderemos
continuar e repetir esses episódios, muito semelhante ao que
fizemos com os gêneros No entanto, é aqui que o
problema entra em jogo. O problema é que
a função cria instala a lista inteira
na memória antes de fazer um loop Por exemplo, se houvesse
milhões de episódios, isso ocuparia
muita memória. Agora, uma função normal, se ela estiver
retornando, por exemplo, listas compostas por
muitos valores, ela carregará tudo
na memória de uma só vez. Esse é o problema que temos aqui com uma função regular. No entanto, um gerador
pode resolver esse problema. Se olharmos para um gerador
neste exemplo, estamos apenas cedendo, como você pode ver, nossos valores Produza o episódio um, produza o episódio
dois, produza o episódio três. Você provavelmente está se perguntando
por que isso é melhor? Como você pode ver,
apenas um episódio, como você pode ver, é mantido
na memória por vez. Assim que um
episódio é impresso, ele é descartado e isso
ajuda a liberar memória Então, a
função geradora, temos yield, ao contrário de uma função normal teremos retorno
utilizando yield, ela carregará
um valor por vez, e isso ajuda a
manter o uso de memória baixo Tudo bem. Então, espero que
agora você entenda melhor
a
eficiência da memória com geradores, e é assim que você
pode ver o valor
de usar geradores
com a de usar geradores
com a Então, como eu disse, sei que
na primeira aula e com
o imposto prático de laboratório, não
parecia muito importante,
porque isso é
essencialmente algo que ocorre nos bastidores e ajuda É aqui que será útil se você estiver lidando
com aplicativos mais tarde ou
atualmente e quiser
observar o uso da memória Os geradores podem realmente
ajudar nesse sentido
82. Cópia superficial e profunda: Oi, Ron. Bem-vindo
à próxima lição, que se concentrará
em cópias superficiais e profundas Vamos dar uma olhada na
diferença entre os dois. Uma cópia superficial, essencialmente, cria um novo objeto, mas retém referências aos elementos originais,
o que
significa que as alterações nos objetos
aninhados
afetam Também temos uma
cópia profunda e, nesse caso, uma cópia profunda cria uma duplicata totalmente
independente, incluindo todos os objetos
aninhados, garantindo que as alterações em uma
cópia não afetem a Então, aqui estão as diferenças entre cópia superficial e profunda, e vamos fazer um exercício
prático de laboratório
sobre elas para que você possa ver como essa série será
aplicada aos exercícios de laboratório Então, basta falar sobre as definições
de cópia superficial e profunda, vamos mergulhar nos exercícios
de laboratório
83. Utilize cópia superficial e profunda — [Lab]: Oi, pessoal. E bem-vindo
ao próximo exercício de laboratório, que se concentrará em cópias
superficiais e profundas Então, vamos trabalhar com
alguns exemplos para que possamos consolidar
melhor nosso
conhecimento sobre cópia. Então, vamos
começar. Agora, neste primeiro exemplo, aprenderemos como
podemos atribuir sem copiar. Então, ainda não estamos fazendo
uma cópia, apenas para nos aprofundar em toda
a ideia Então, primeiro, eu
quero definir uma lista. Eu vou dizer lista de
sublinhados original. Vou dizer que um, três e cinco estão na lista. Quero atribuí-lo
a outra variável. Eu direi que a nova lista de sublinhados é igual à
lista original. E com isso, tudo o que estou
fazendo, como mencionei, é atribuir a lista original aqui a uma nova variável
chamada nova lista, e não estou realmente fazendo uma cópia. Estou apenas atribuindo isso. Agora, digamos que eu queira modificar
a nova lista e, digamos, nova lista, e eu vou dizer que em zero, eu quero definir isso para 99. Agora, o que eu quero fazer
é imprimir a lista de postagens. Eu vou dizer impresso,
e vou
dizer aqui a lista original. E está aí e então eu
quero dizer imprimir uma nova lista, e então podemos
passar pela nova lista. Vamos executar isso. Podemos ver
aqui na lista original, temos 99 e temos
três e temos cinco. Então, na nova
lista, temos 99, temos três e
temos cinco aqui. Agora, vamos seguir em frente e entender o
processo aqui em questão. Agora, aqui podemos ver que a nova lista não é uma
cópia da lista original. Ambas as variáveis apontam para
a mesma lista na memória. Quando alteramos uma nova lista,
como podemos ver aqui, zero, a lista original também muda porque
são o mesmo objeto. Como você pode ver
aqui, 993-59-0935. É assim que podemos simplesmente atribuir uma lista que
não cria uma cópia. Certo. Essa é a primeira
coisa que quero mencionar. Agora, o que vamos fazer
é nos aprofundar em uma cópia superficial. Isso é copiar apenas
a lista externa. Com uma cópia superficial, ela
criará um novo objeto, mas não copiará objetos
aninhados.
Vamos nos
aprofundar nisso a Então, vamos seguir em frente
e fazer exatamente isso. Certifique-se de que
você está confortável com o que acabamos de passar. Tudo bem. Então, vamos continuar e nos concentrar em uma cópia superficial Lembre-se de que uma cópia superficial
cria uma nova lista externa, mas as listas internas
permanecem as mesmas Eles não são copiados, apenas
referências, vamos começar. Para fazer isso, precisamos
importar o módulo de cópia. OK. Em seguida,
queremos primeiro criar uma lista original
com listas aninhadas Então, podemos dizer que
as listas originais são variáveis, e aqui vamos
ter uma lista
e, em seguida, teremos uma lista em uma lista que terá um, dois,
três, adicionaremos uma vírgula
e, em seguida, queremos ter
quatro, cinco e seis OK. Então, agora temos uma
lista com listas aninhadas Então, uma lista em a está OK. Agora, queremos criar
uma cópia superficial. Vou atribuir isso
à minha variável chamada cópia
superficial para criar
essa cópia superficial Você precisaria chamar o módulo de cópia e
o módulo de cópia tem uma
função chamada cópia, e podemos simplesmente colocar na lista
original dentro dela Isso criará
uma cópia superficial para nós. Agora, queremos modificar
a lista interna que
ambas as listas compartilham. Para fazer isso, diríamos uma cópia
rasa de sublinhado. Nós diríamos zero, zero, e podemos definir isso como 99. O que
isso basicamente fará
é abrir uma cobertura e alterar o valor do primeiro elemento da lista
interna Aqui, você poderia tratar isso como a lista que
temos do lado de fora, e essa
será essa lista aqui, e então indicaríamos
essa lista aqui como zero e essa lista aqui como um Então, estamos dizendo zero, isso significa que queremos
trabalhar com este. E então, dentro dessa lista, vem em segundo lugar, vem
o segundo argumento aqui. Queremos seguir em frente
e
referenciar o primeiro elemento dessa
lista, este aqui. Isso
mudará e passará para 99, e isso
se refletirá tanto em nossa lista original quanto em
nossa cópia superficial Então, vamos imprimir
a declaração para que possamos
ver isso. Eu vou dizer impresso. Eu vou dizer lista original. E depois uma cópia superficial. Cópia superficial. Lá vamos nós. Então, agora vamos em frente e
queremos imprimir nossa lista. Aí está. Temos 99, dois, três, quatro, cinco, seis, e podemos ver
que tivemos uma mudança aqui na
lista original e, claro, a lista superficial por padrão, é
claro, teria ocupado 99 Mas você pode ver que
a lista original também mudou junto com ela,
e isso porque a lista
original aqui por zero
e, claro, em
nossa cópia superficial em zero
em termos da posição
do elemento, se refere à mesma
lista na memória Isso prova que cópias superficiais copiam apenas a lista externa
e não os objetos aninhados dentro dela Essa é a razão pela qual estamos
obtendo o seguinte resultado. Certo. Agora vamos nos concentrar na cópia profunda, e isso
garantirá que a cópia profunda tenha
uma cópia totalmente independente
que não altere a lista original em si. Então, o que queremos
fazer é usar uma cobertura e remover o que
temos aqui e vamos
trocar isso por cópia profunda, e vamos
chamar o módulo de cópia, e vamos dizer
cópia profunda, utilizar essa função Em seguida, queremos
passar pela lista original. E isso
criará uma cópia profunda. Então, queremos modificar a lista
interna na cópia profunda, para que possamos dizer cópia com
sublinhado profundo, e 00 é a mesma
coisa que fizemos antes E podemos dizer impressão,
e vamos dizer lista original. Seguido por uma cópia profunda e profunda. Lá vamos nós. Então,
agora temos isso em prática, e vamos executar isso.
E lá vamos nós. Agora você pode ver que
a lista original aqui foi mantida intacta, então ainda
temos um,
dois, três, quatro, cinco, seis E nesse
posicionamento, o efeito não ocorreu
no primeiro elemento aqui. Eu continuei o mesmo.
No entanto, em uma cópia profunda, essa alteração foi ajustada. Você pode ver aqui que 99 está agora no lugar de onde
se costumava estar. Então você provavelmente está
se perguntando: Ok, por que lista
original desta
vez permaneceu inalterada Porque a cópia profunda
era zero, ok? E a lista original em zero, também, ok, não é mais
a mesma lista. cópia profunda
duplica totalmente tudo, então as alterações na cópia profunda não
afetam a lista original OK. Então, isso é algo muito
importante de lembrar. Portanto, lembre-se de que você está
usando a atribuição, como mostrei anteriormente, e se estiver usando
a função de cópia, as alterações afetarão o
original em termos da lista Mas se você estiver usando cópia profunda, ela será totalmente
copiada para a outra lista, por exemplo. Tudo bem, pessoal. Isso é cópia superficial, cópia profunda e a tarefa geral em termos de como você
presumiria que a cópia funcionaria Tudo bem, pessoal. Isso é tudo para este exercício prático de
laboratório.
84. Registro: Olá a todos, bem-vindos
à próxima lição, que será
focada na exploração madeireira. Então, vamos dar uma olhada.
Então, o que é registro? O registro em log é a prática
de capturar eventos, mensagens ou erros
em um aplicativo Agora, ele ajuda os desenvolvedores a depurar, rastrear problemas e também a
monitorar o comportamento do sistema Agora, os registros também podem ser
armazenados em arquivos, bancos ou serviços externos
e
também são categorizados
por níveis de registro Então, vamos dar uma olhada nesses níveis de
login que obtemos. Então, obtemos os seguintes níveis. Eles incluem o TBug, que fornece
informações detalhadas de diagnóstico para solução de problemas Em seguida, temos informações,
que fornecem mensagens operacionais
gerais
confirmando as informações normais Advertência. Isso
ocorrerá sob qualquer indicação de
possíveis problemas que possam exigir atenção. Em seguida, obtemos um erro, que, obviamente, se concentra na
saída
de informações sobre
quaisquer problemas significativos que afetem a funcionalidade do
aplicativo , e o
essencial, é claro, é gerar informações
que indicam que
há erros graves que levam à falha ou instabilidade
do sistema Então, esses são os níveis
que obtemos no login. Depuração, informação, aviso,
erro e crítica. Tudo bem. Então, agora
que isso foi feito, vamos
mergulhar na prática.
85. Implementar mensagens de log - [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de
laboratório, que será
focado no registro. Então, o primeiro exemplo
que veremos é como podemos
implementar o registro básico, e isso é útil para
substituir a função de impressão. Agora, você provavelmente está se perguntando:
Ok, a
função de impressão é ótima. Isso realmente pode nos ajudar a produzir certas declarações, dependendo onde as colocamos em nosso código. Embora isso seja verdade,
podemos usar o registro em log, que pode rastrear os eventos
do nosso programa de
forma mais eficiente com suas funções, estruturas
e tudo mais. Então, vamos
começar. Primeiro, queremos importar
o módulo de registro. Agora, queremos configurar o registro
básico. Então, vamos
definir nossa função. Portanto, precisamos nos referir ao nosso
módulo, digamos, ponto de registro. Em seguida, vamos nos
referir à função
chamada configuração básica Agora, essa é uma função
que configura o registro. Ele configura como
os registros se comportam. E dentro disso,
queremos dizer que o nível
é igual ao registro de informações de pontos, certo Portanto, o nível é essencialmente um parâmetro que define o nível de registro
mais baixo a ser registrado, e isso será,
obviamente, informações e muito mais. Em seguida, ele é
atribuído ao registro de informações de pontos, e esse é um atributo ou constante que representa
o nível de informação. OK. Agora, o que queremos fazer é registrar uma mensagem
informativa Então, eu vou dizer
logando informações de pontos. E então aqui
estava entre parênteses. OK. Quero continuar e
dizer que o programa começou. Ok, então isso registra uma mensagem
com o nível de informação. OK. Então, isso é apenas algo
importante que eu acho importante
entender. Tudo bem. Agora, essa é a
função específica em que estamos usando a função info
para que possamos seguir em frente e executar a
seguinte declaração. Então, se eu executar isso, indo
para a rota de informações, o programa será iniciado. Muito bem, essa é a maneira mais básica de integrar o
registro. Ok, então é assim que
podemos seguir em frente e
começar com isso. Certo. Agora que estamos
familiarizados com as informações, queremos aprender como podemos registrar erros
com o traceback Portanto, isso pode ajudar a depurar erros sem
interromper nosso programa Então, vamos
ajustar o seguinte. Novamente, vamos fazer
uso do módulo de registro. Mas desta vez,
queremos configurar o registro para mostrar
erros e superiores. Em outras palavras,
erro e crítica. Então, vou prosseguir e
chamar o módulo de registro. Então eu quero executar a configuração básica. Eu quero adicionar isso, então essa é a função que
eu quero usar. Vou definir o nível de erro
de ponto de registro. Ok, então é exatamente o mesmo
processo que fizemos antes. Tudo o que estamos fazendo agora é querer gerar e mostrar o erro do
erro, devo dizer? Nenhuma informação ou qualquer coisa do tipo. Agora podemos simplesmente criar
um programa simples. Eu vou dizer tentar e
vou dizer que o resultado é igual a 10/0. Isso causará
um erro de divisão zero. O que eu quero fazer então é dizer exceto e o que eu
vou dizer é registrar o ponto E. E
aqui eu vou
dizer que você tentou dividir por zero. Então, no final, quero dizer que
a exceção E XC, informações de
sublinhado serão
verdadeiras OK. Então, vamos dar
uma olhada aqui. Então, estamos definindo
o módulo de login e
usaremos a função de erro para gerar uma mensagem que diz que
você tenta dividir por zero, e queremos fornecer uma informação de exceção
aqui sobre esse erro. Portanto, registrar um erro de ponto, é claro, é essencialmente a função
que registra uma mensagem de erro. E então, quando temos informações de
sublinhado EXC iguais a verdadeiras, esse é o parâmetro que adiciona nossos detalhes de rastreamento OK. Então, vamos seguir em frente
e executar esse código. E aqui vamos nós.
Podemos ver a raiz do erro. Você tenta dividir por zero, que
possamos ver isso
surgindo da seguinte forma,
e podemos ver que estamos
recebendo um traçado aqui para que possamos ver a
tela EXC em focais verdadeiros. Então esse é o
rastreamento que eu mencionei, e ele nos dá todos
esses detalhes aqui. Diz zero divisão de
erro de divisão por zero. Então é assim que você também pode habilitar
o traceback. Certo. Então é isso que
precisamos garantir que temos, e isso pode ser muito
útil para depuração Tudo bem. Ok, perfeito. Então é assim que
podemos seguir em frente e nos concentrar no registro de mensagens
de erro. Chave inglesa. Agora, a próxima coisa em
que vamos nos concentrar é em como podemos registrar
avisos sobre possíveis problemas Isso pode ser muito útil
porque, é claro, os desenvolvedores querem ser alertados sobre possíveis problemas
antes de decifrarem o código Portanto, isso não vai
quebrar um código, mas é apenas uma espécie de
aviso para nos avisar. OK. Então, o que
vamos querer fazer é dizer logging, dot, e vamos
dizer configuração básica, e agora queremos
definir o nível, e isso
será um aviso de log OK. Agora vamos
criar um programa. Eu vou dizer que idade é igual
e vou dizer menos cinco. Essa vai ser uma idade
inválida, é claro. Então eu quero verificar se
há entrada inválida. Eu vou dizer que eu
envelheço menos de zero. Em seguida, quero
dizer que o aviso de pontos de registro usa a função de aviso aqui
e dirá que a idade não pode ser negativa. Então eu quero dizer recebido. Vou adicionar o
símbolo de porcentagem e D aqui
e, em seguida, adicionarei apenas
alguma formatação para que a idade
seja anexada aqui
à própria string Temos um aviso de registro
aqui, essencialmente, o que vai acontecer
aqui é que ele registrará mensagens de aviso. Então aqui esse
símbolo de porcentagem e o G aqui é o
especificador de formato que vai inserir o valor
inteiro da idade,
que, é claro, neste
caso, enviamos para menos cinco O que podemos fazer é seguir
em frente e executar esse código. Aqui recebemos um aviso
dizendo que idade não pode ser negativa
recebida menos cinco É assim que podemos registrar avisos
sobre possíveis problemas que possamos receber Certo. Ótimo. Agora, a próxima coisa que eu acho que
você vai
gostar é realmente muito interessante, devo dizer, que é como
podemos salvar os registros em um arquivo. Podemos manter um
registro permanente dos registros em vez de apenas
imprimi-los, como você pode ver aqui. Agora, isso será
muito benéfico, especialmente se você trabalha
para uma empresa que gosta
de acompanhar os registros e fazer auditorias ou qualquer coisa do tipo Podemos ir em frente e remover
tudo como está. Agora vamos aprender
como salvar registros um arquivo. Tudo bem. Então, o que queremos
fazer antes configurar o
login para gravar em um arquivo. Então, o que vamos
fazer é dizer
log e precisamos
dizer configuração básica,
primeiro de tudo, depois
vamos especificar um nome de arquivo, e esse
será essencialmente o parâmetro que
define o nome do arquivo Então, vou dizer
nome do arquivo. Esse é o parâmetro. E então aqui vou
chamá-lo de app dot log. OK. E então a próxima coisa que eu quero fazer é definir o nível. Então, vou dizer que
nível é igual e vou dizer
registrar informações de pontos Vou adicionar uma vírgula e
depois só quero dizer
Enter para ir para uma nova linha aqui Vou apenas dizer formato
e vou especificar
o formato em que
quero defini-lo. Esse formato aqui
será essencialmente o parâmetro
que define o formato do log. Em outras palavras, o timestamp, nível e a mensagem, e é assim que
vamos querer fazer isso Vamos
querer adicionar nossas aspas, o símbolo
apresentado e, em seguida, aqui, podemos simplesmente adicionar nossos
parênteses e dizer a hora de perguntar E isso vai ser S, e
então quando você diz Dasher
e, em seguida, símbolo centid, inferências queremos
adicionar no E podemos dizer S e então adicionar
o símbolo de porcentagem e fazer com que a mensagem também seja colocada
aqui com S. Deixe-me diminuir o zoom para que você possa
ver e podemos simplesmente colocar isso volta e agora está tudo em
uma linha para você. Tudo bem. Ótimo. Nós temos
isso configurado agora. Queremos registrar uma mensagem
informativa. Vou dizer que, registrando as informações dos
pontos aqui,
quero passar pelo programa
iniciado com sucesso. Ah. Lá vamos nós. Agora, queremos verificar
o registro do aplicativo de arquivos para ver os registros e, em seguida,
veremos o exemplo de entrada de registro. Então, vamos seguir em frente e fazer isso. Agora, antes de fazermos
isso, eu só quero
mencionar aqui que temos o nome
do arquivo app log. Mais uma vez, eu só quero explicar
para que você esteja ciente. Esse é um parâmetro
que
definirá o arquivo para salvar nossos registros. Então, temos o nível
igual às informações dos pontos de registro. Em seguida, estamos apenas definindo o nível que
vamos utilizar aqui. Será
no nível da informação. Então, novamente, basta
reiterar que
o nível é o parâmetro que
define, é claro, neste caso, o nível
mais baixo a ser registrado, neste caso, o nível
mais baixo a ser registrado,
que será informação OK. E lembre-se de que
registrar informações
de pontos será o
atributo que representa o nível de informação
que estamos definindo. Certo. Ok, então vamos seguir
em frente e executar nosso código. Então, nós o executamos e agora você
quer ir para o seu diretório. E aqui temos um arquivo de
log de pontos do aplicativo que foi criado. Ele mostrará
a data, a hora e também mostrará
as informações que
dizem que o programa foi
iniciado com sucesso. Então, é assim que podemos seguir
em frente e garantir que
salvamos nossos registros em um arquivo. OK. Então é assim que podemos fazer isso. Perfeito. Então,
temos essa configuração. Agora podemos simplesmente mover tudo para cá e continuar. Bem feito. Agora, a última coisa que
queremos ver é como podemos adicionar níveis de tempo e
log para depuração Precisamos ter
certeza de que importamos o módulo de registro e vamos
configurar o registro com registros de hora e níveis de gravidade Nós também temos, como
posso dizer debug. Isso é muito útil
para quando queremos como você diria,
depurar nosso código Vamos começar. Agora, a primeira coisa que
queremos fazer é dizer registro. E queremos definir
a configuração básica. O nível aqui, vamos
dizer que o nível é igual ao registro, e vamos
definir isso como T bug. OK. Então, esse é um parâmetro que permite todas as
mensagens de log, depuração e versões posteriores OK. Certo. Então, agora o que podemos
fazer é simplesmente adicionar nossa vírgula e agora precisamos
adicionar nosso formato Então, aqui
vou dizer formato, adicionar meu símbolo de
porcentagem de aspas e queremos encapsular
o formato da mensagem de log Então, queremos que ele mostre a SKT primeiro. Poderíamos adicionar o S. Em seguida ,
queremos adicionar nosso símbolo de
porcentagem e também queremos
gerar o nome do nível. Então, isso é o que você
normalmente vê no arquivo, por exemplo, e então s, vá para o próximo símbolo de
uma porcentagem, inferências de mensagem e, em
seguida, S aí está Então, agora temos esse
formato em vigor. Deixe-me mover isso aqui. Então, agora você sabe como
definir isso. Certo. Perfeito. Esse é o formato de mensagem de
log que agora queremos registrar mensagens com diferentes
níveis de severidade. Vamos fazer isso. Ok, então eu vou dizer logging dot e
teremos o Dbug primeiro Eu vou dizer que esta
é uma mensagem de D Bug. Então eu vou dizer que registrando
informações de pontos, então eu vou
dizer que tudo está
funcionando sem problemas. Vou dizer logar ponto e vou dizer aviso. Isso vai dizer que
cuidado com possíveis problemas. Então, podemos dizer erro de ponto de
registro aqui. Vou dizer que
algo deu errado. Então, podemos dizer que o
registro é crítico. Eu quero dizer
falha crítica. Lá vamos nós. Então, agora vamos pegar
nossa saída, salvar esse arquivo, executar o
código e aqui está. Podemos ver aqui que
configuramos a hora. Configuramos
o nome do nível e também
configuramos a mensagem, e tudo isso em uma,
duas e três seções. Então, isso vai encapsular. Você pode tratar isso como
os
parênteses dos símbolos do centúrio com o formato
que estamos definindo Podemos tratá-los
como nossos espaços reservados para cada segmento ao qual
estamos nos referindo Agora, o nome do nível virá de debug, se a função que
esclarecemos aqui, como você pode ver, e a
mensagem
virá do que você
declara nessa E foi assim que
tudo foi produzido. E podemos ver que o
formato está no horário ASC, então isso mostrará
o ano, os meses, o dia
e, em seguida, a hora em que
foi registrado, de
acordo com as informações de depuração,
aviso de erro e acordo com as informações de depuração,
aviso de erro Tudo bem, então aí está. É assim que podemos
implementar o registro. Vá. Isso é tudo para
esta lição sobre utilização de registros e como podemos gerar vários registros,
dependendo de nossas situações
86. JSON: Olá a todos, e bem-vindos
à próxima lição, que será focada
no JSO. Vamos dar uma olhada. JSON significa JavaScript
Object Notation e é um formato leve para armazenar e trocar Agora, ele também usa pares de
valores-chave de
uma forma estruturada e
legível por humanos e
também é amplamente usado em
APIs e aplicativos da web E outra
coisa importante a ser observada aqui é que JSON suporta
vários tipos de dados, como strings, números,
matrizes, objetos
e Então, vamos nos concentrar no JSON e em como podemos
aplicá-lo no Hisen Então, vamos começar.
87. Trabalhando com JSON — [Lab]: Olá a todos, e bem-vindos ao próximo exercício prático de
laboratório, que
será focado no JSO Então, vou mostrar
três exemplos de como você pode implementar
melhor o
JSON no PySON Agora, o primeiro será focado na conversão de um dicionário em uma
string JSON Em seguida,
aprenderemos como converter uma string JSON em um dicionário
PySON E a última coisa que
faremos é salvar JSON em um arquivo e
ler o JSON de um E essa será
a questão realmente importante, já que também usaremos gerenciadores de
contexto aqui para
realizar esse processo. Certo,
então vamos começar. Então, vamos
começar de forma muito simples e converter um dicionário
em uma string JSON Primeiro, precisamos
importar o módulo JSON e depois
criar nossos dicionários Eu vou dizer dados, e meu dicionário vai
ter os seguintes pares de
valores-chave. Primeiro, diremos o nome
como a primeira chave, e isso
será definido para honrar. O segundo
par de valores-chave
consistirá em Ele é a chave e o valor 29, então teremos a cidade, e eu definirei isso
como um símbolo, certo Então aí está.
Aí temos nosso dicionário. Agora, o que podemos fazer é converter esse dicionário em uma string JSON E para fazer isso, precisamos
primeiro definir uma
variável para que possamos atribuir o resultado que obteremos no final
da conversão. Eu vou dizer que a string
JSON é igual. Em seguida, vou me
referir ao módulo JSON, digamos ponto, e depois vou
usar o método dumps, que converterá meu dicionário em uma string JSON Então, eu só preciso
passar os dados, eles
os converterão para mim, e tudo que eu preciso
fazer é dizer imprimir e depois vou dizer a string de sublinhado
JSON E isso será
produzido adequadamente em uma string JSON para mim. Então, agora eu
posso seguir em frente e executar meu código, e
aí está. Portanto, agora ele está em um formato JSON
adequado. Certo. Perfeito. Portanto,
lembre-se de que o JSON está sempre entre aspas duplas e não entre aspas simples
tradicionais E isso pode ser muito útil se você quiser enviar
seus dados JSON para uma API da web ou
armazenar JSON como texto Certo, então é assim que podemos
ir em frente e configurá-lo. Você pode ver aqui o
código completo que foi utilizado. Você pode ver como seguir em frente e converter seu dicionário
em uma string JSON A próxima coisa que
faremos é converter
sua string JSON em um dicionário Python Tudo bem,
vamos fazer isso. Então, o que eu vou fazer
é remover esse código. Ainda queremos utilizar o módulo
JSON. Mas o que vamos fazer
agora é especificar nossos dados JSON como uma string
formatada como Vou dizer JSON em
scare string into equals, e o que vamos
querer fazer é, antes de tudo, adicionar Precisamos adicionar
aspas simples e, dentro disso, podemos definir nosso dicionário
com nossos dados JSON É exatamente assim que
a string precisa ser se você quiser
convertê-la em um dicionário. Vou definir
o
par de valores-chave para que tenhamos um nome. E isso será RNO, então teremos idade, cólon e isso será 29,
e então teremos cidade, e então isso será
Cidade do Cabo. Aí está. Aí está nossa string JSON. Lembre-se de que as aspas
no final são muito importantes e certifique-se de que você tenha tudo configurado.
Lá vamos nós. Estamos bem. Ok, agora queremos converter o JSOString em um E o que vamos fazer é armazenar
tudo isso
na variável de dados. Vamos nos referir
ao módulo JSON e , em seguida, à mensagem de carregamento
que vem dele, e vamos
passar pela string JSON Ok, então o JSON que carrega nos permitirá converter esse JSOMString agora
em Então é isso que
vai acontecer agora. Passamos por
essa string JSON e ela será
convertida em um dicionário Então, tudo o que queremos fazer agora
é imprimir os dados, primeiro lugar, vou
dizer imprimir dados. E execute esse código. Aqui podemos ver que temos um dicionário regular em
PySon, como você pode ver Agora, o principal detalhe
disso é que agora você pode ver que está entre aspas simples. Tecnicamente, enquanto estiver no PySon, você pode configurar seu dicionário em
termos de aspas duplas Você pode fazer isso, mas geralmente o padrão com PySON está
entre aspas simples e é um bom teste para ver se agora está em PySON e foi
configurado corretamente que podemos fazer agora é acessar valores
individuais
do dicionário, para que você não precise
dizer os dados como estão. Você pode simplesmente adicionar seus colchetes e
escolher entre eles Você se referiria às suas chaves
e, em seguida, recuperaria o valor. Se eu quiser obter o valor
real do meu nome não, precisaria colocar um
nome aqui e executar o código. As saídas diretamente
para o meu nome. Se eu quiser pegar uma cidade,
que é a Cidade do Cabo, e eu administrá-la, ela
produzirá e eu administrá-la, ela
produzirá Cidade do Cabo. Aí vamos nós. É assim que você pode
converter uma string JSON um
dicionário Python Agora, o mais importante e o
mais divertido,
eu diria, é salvar JSON um arquivo e ler
JSON de um Vamos começar e criar
um dicionário, antes de tudo. Vou dizer que dados são iguais, e vou abrir isso, adicionar meu par de valores-chave, Contra não. Então teremos
idade, cólon, 29. Então vamos
ter o cólon da cidade. Teremos a Cidade do Cabo, e todos os nossos dados
estão neste Agora, a próxima coisa que
queremos fazer é ascie. Queremos salvar nossos dados
em um arquivo, é claro, e vamos dizer Wi open e, em
seguida, o arquivo que
queremos criar. Eu vou dizer com
bastante pontos de dados JSON. E eu quero
escrever neste arquivo. Então, o modo será W. E eu
vou dizer como arquivo,
vou chamá-lo de. Então, ele também abrirá
o arquivo no modo de gravação. E então queremos nos
referir ao JSON e usar o método
dump aqui despejo JSON é uma
mensagem que gravará os
dados JSON E para fazer isso, precisamos
passar os dados e depois o arquivo porque
queremos pegar esses dados e
gravá-los em nosso arquivo. E isso vai
gravar os
dados JSON no próprio arquivo. Ok. Então, vamos
escrevê-lo primeiro no arquivo, verificar nosso diretório e
depois lê-lo. Então, agora podemos executar o código. Vamos ao nosso Explorer. E aqui você pode ver que
temos dados JSON e podemos ver que eles foram salvos
em nosso arquivo JSON de pontos de dados Assim, podemos ver o nome aos 29 anos, estudar a Cidade do Cabo e aí
temos tudo guardado Agora, digamos que queremos ler esses dados de volta do arquivo
e lê-los no terminal, por exemplo, aqui mesmo
no terminal de saída. Feche isso, vá para
nossa próxima declaração, e podemos seguir em frente
e dizer, Wiz, abra Queremos abrir esse
arquivo. O arquivo que queremos abrir é chamado de
data dot JS on e queremos lê-lo. Em nossa cortesia, diremos R, diremos como arquivo, e podemos então definir uma variável chamada dados de sublinhado
carregados, e vamos definir
isso como JS dot load Estamos usando o método dot load, que nos
permitirá ler dados JSON do arquivo e também serão
convertidos em um dicionário Eu vou dizer arquivo. Ok. Então, tudo o que queremos fazer no final é imprimir
os dados carregados. Eu vou dizer que imprima dados de sublinhado
carregados. Vamos seguir em frente e executar
esse código. Lá vamos nós. Podemos ver que temos os
dados e também voltamos versão padrão
dos
dicionários em Como eu disse anteriormente,
ele estará entre aspas
simples e
isso é
uma boa indicação de que foi convertido em um dicionário para nós para equivalentes em
Python Certo, pessoal,
é basicamente isso. É assim que podemos utilizar o JSO. Tudo bem Aí está. Vou continuar
e remover esse código. Tudo bem Lá vamos nós.
88. Filas: Oi, todo mundo. Bem-vindo
à próxima lição, que
será focada em es. Então, vamos começar.
Então, o que é um Q? Um Q é essencialmente
uma estrutura de dados que segue o princípio do primeiro a
entrar, primeiro a sair. Você já deve ter ouvido falar de
um princípio conhecido como FIFO, que significa primeiro a entrar,
primeiro a sair, e é isso que segue um Q. Agora, pode ser muito
útil se você estiver se
concentrando em agendamento de caracteres,
armazenamento em buffer, manipulação e dados de
sequenciamento, e também
pode ser implementado usando qt iss Agora, as principais operações
incluem NQ. Isso é para adicionar e
DQ, que é remover, e isso vai se referir
a certos elementos Vamos dar
uma olhada no exemplo aqui,
então uma analogia e, em seguida, dar uma olhada no
PysonPgram associado para obter um Q. Right.
Então, digamos que temos muitas pessoas
na fila para votar Então, todo mundo está
na fila e você pode
ver isso como um sistema FIFO Então, primeiro a entrar, primeiro a sair. Então, a pessoa que esteve lá
pela primeira vez às 3:00 da manhã em frente à cabine de votação
foi a primeira a sair A segunda pessoa, é claro, acabou se tornando
a primeira pessoa, e eles
também saíram. Então, uma fila. Se fôssemos criar
um programa em Python, criaríamos
algo com o seguinte, onde
iríamos pegar o módulo Q. Então, podemos importar a classe Q. Então, podemos criar um Q, então criamos uma instância de um Q. votação Q será igual
a Q. Então, se as pessoas se juntarem
ao Q, que é NQ, podemos simplesmente nos referir à nossa
instância e dizer ponto a ponto, podemos utilizar o método ponto, que basicamente
executará E adicione pessoas à fila. E isso vai
estar na ordem. Então, Alice, Bob e Charlie. E então digamos que essas pessoas
tenham votado. Eles vão
sair da fila, isso será um ato de DQ
para possamos imprimir
a ordem em que estão Assim, podemos nos referir
à instância que
criamos de Q e utilizar
o método dot get. E isso vai aparecer na ordem
de quem foi o primeiro
a entrar e quem foi o primeiro a sair, e vai ser
na ordem de Alice, Bob Charlie, quem
foi o primeiro a entrar, e vai sair
exatamente o mesmo quando
dizemos que fulano votou
. Certo. Então, essa é uma
analogia muito simples que podemos utilizar para entender
o conceito de pistas Então, isso está na visão geral
teórica.
89. Buscando filas — [Lab]: Oi, pessoal. Bem-vindo ao
próximo laboratório de exercícios práticos, que será focado
em Qs. Vamos começar. O primeiro programa
que vamos
fazer consolidará nosso conhecimento sobre
como podemos criar um Q básico e, o mais importante, como podemos utilizar o
put e a mensagem
para o NQ para adicionar um Q e o
DQ para remover de um Q. A primeira coisa que quero
fazer é
obter os módulos obter os Vou dizer de Q e quero importar a classe
Q desse módulo, e ela precisa ser um Q maiúsculo aqui que indique que
é a classe. Então, o que eu quero fazer
é criar uma instância do meu Q.
Vou definir uma variável chamada sublinhado de
votação Q. Vou defini-la para a classe Q
com
parênteses de abertura e
fechamento Em seguida, quero adicionar ao meu Q. Vou dizer que votar
sublinha Q dot PUT Então, aqui entre parênteses eu vou acrescentar
ao Q eu vou dizer e votar
sublinhado Q ponto p, eu vou colocar
John e depois votar sublinhado Q ponto
p. Vou colocar Sarah. Lá vamos nós. Agora, o que
eu quero fazer é seguir em frente e deque Então, eu quero remover
da fila e ver o que estou obtendo cada vez na fila,
quem está sendo Então, eu adicionaria
uma declaração impressa, e posso simplesmente dizer, votando abaixo da loja Q.
Quero me referir a essa variável específica
aqui que temos quando criamos uma instância
da classe Q. Então o que eu
quero fazer é dizer ponto G. Estou usando o método G. Depois de definir o método G, posso adicionar uma vírgula
e, em seguida,
dizer votar Essencialmente, o que vai
acontecer é seja qual for o valor
da pessoa que foi colocada pela primeira vez no Que,
que é Ro, ela obterá um voto negativo, não vai
dizer nenhum caso. Se eu fosse
fazer isso, seria um voto cauteloso. Mas mesmo que eu a
publicasse repetidamente, continuaria dizendo
ono car say vote porque você precisa continuar
imprimindo e executando explicitamente a mensagem dot get aqui três vezes ou a
quantidade total de vezes que
você colocou na fila Portanto, você pode ver o primeiro a
entrar, primeiro a sair, tipo de lógica. Então, agora, se eu fosse copiar a primeira
declaração pela segunda vez, eu diria que não votaria em Carros, depois em John Cars votaria. E eu precisaria fazer um
SRT para pegar a última pessoa, então essa será Sarah E podemos ver Ana Cars votar, John Carsey votar e
Sarah Cars votar Aí está, e
isso é executar o DQ. Tudo bem, então vamos lá. Então é assim que você pode realizar o básico da fila
com colocar e Certo. Ok, agora vamos explorar
os outros
métodos que vêm com um Q. Então, o que vou
fazer é remover o seguinte e
aqui, votando em Q, vou
ajustar isso para ter Q. E você pode definir um
parâmetro no seu Q OK. E vou
definir isso como tamanho máximo, e é aqui que você determina o tamanho máximo que seu Q pode ter. Agora queremos adicionar
itens à pergunta,
vou dizer sublinhado da
tarefa Q, e vou dizer ponto por ponto, e
vou definir aqui a tarefa um Vou copiar
isso mais duas vezes. E podemos dizer dois,
e podemos ter três. Temos três itens em
nosso Q ou três tarefas. Digamos que eu queira obter
o tamanho da minha tarefa aqui. O que posso fazer é dizer
imprimir e posso dizer espaço de dois pontos de tamanho
Q aqui, então quero me referir
à tarefa Q e usar o método de tamanho de ponto Q que mostrará
quantas tarefas eu tenho Eu vou dizer executar código. Eu posso ver os tamanhos Q agora. Isso não
imprimirá o tamanho máximo. Vai ser do tamanho
da sua fila que
você configurou aqui. Se eu removesse
uma tarefa e a executasse, ela também mostraria que tamanhos. Eu analiso quantos
itens foram colocados na fila usando o método PUT
. Certo, lá vamos nós. Agora, digamos que eu queira
verificar se o Q está cheio. Posso simplesmente dizer imprimir,
e direi que o Q está cheio. Eu posso dizer sublinhado da tarefa, Q, e quero continuar
e dizer ponto cheio OK. E é executado. E aqui, o tamanho da fila
é três e o Q está cheio porque o tamanho máximo
foi atingido em três Mas se eu fosse remover
um item e executá-lo, tamanho
Q é dois e
o Q não está cheio, é falso, então não está. Tudo bem. Então, quando
você está chamando a tarefa ,
Q aqui, quando você a chama,
ela automaticamente lembra o que você tem em seu e quantos
itens você tem em seu u. Então, essa variável vai
acompanhar isso,
e tudo o que estamos fazendo
é estratificá-la
examinando e aplicando
esses métodos a ela Ch, está tudo bem, e eu só quero adiar a
fila final. Agora, o que eu quero fazer é remover e processar tarefas. Eu vou dizer impresso.
A tarefa sublinha um ponto Get Estamos usando a
mensagem Get e eu vou
dizer que está concluída,
logo ao lado dela. Essencialmente, ele obterá o que colocarmos como primeiro item aqui na mensagem de envio,
essa é a primeira tarefa Então, será que a
primeira tarefa será concluída. Então, se obtivermos a
próxima, ela dirá que
a tarefa dois foi concluída. Eu vou fazer isso
nos dois primeiros. OK. E então o que eu quero
fazer é ir em frente e verificar
se a fila está vazia Então eu posso dizer imprimir
e podemos dizer, o Q
está vazio. Vou adicionar a vírgula e vou me referir à tarefa q dot. E vamos
continuar e executar isso E aqui podemos ver que a
primeira tarefa foi concluída. A tarefa dois foi concluída e o Qu vazio é falso Porque todos
os itens não foram
concluídos na fila Somente as duas primeiras,
tarefas um e dois. Não fizemos
três. É por isso que não está vazio e
está retornando falso. Certo, então o que podemos
fazer é usar a seguinte declaração para que a
tarefa três seja concluída. E agora, se executarmos isso,
podemos ver que a tarefa três foi concluída. Então, agora podemos prosseguir e verificar novamente usando o método vazio. Salve isso e corra. Agora podemos ver que a tarefa
três foi concluída antes de ser falsa
porque não foi concluída. Agora, a fila está vazia porque
todas as tarefas foram concluídas, ela está vazia e está disponível.
Aí está. Apenas mais alguns métodos
para você utilizar. Lembre-se de que, em cima de
do e dot g, você obtém o ponto vazio para verificar
se a fila está vazia Você também recebe o ponto quatro para
verificar se um Q está cheio, tamanho da
fila para mostrar
o tamanho atual da fila Você também pode definir aqui o
parâmetro
do tamanho máximo da
fila que você deseja definir Tudo bem. Então, isso é um
pouco mais sobre Qs. Então, vamos continuar e
remover o seguinte. Tudo bem, pessoal. Então é
isso no Qs.
90. Recursão: Olá a todos, bem-vindos
à próxima lição , que será focada na recursão. Vamos dar uma olhada. Recursão. A recursão é
essencialmente uma técnica em que uma função se chama para
resolver subproblemas menores Agora, ele se repete até que um caso
base seja alcançado, e isso ajuda a evitar que chamadas
infinitas ocorram Agora, uma coisa importante
a observar aqui é que a recursão pode ser
aplicada em muitos contextos Quero dizer, você pode utilizar
na reversão de árvores, computação
fatorial e também
em vários algoritmos em Certo. Então, na visão geral
teórica, vamos nos aprofundar
nos exercícios de laboratório.
91. Como realizar chamadas recursivas — [Lab]: Todo mundo. E bem-vindo ao
próximo exercício prático de laboratório, que será
focado na recursão. Então, vamos começar. Ok, então com a recursão, geralmente
teremos um caso base, e é isso que
vamos
avaliar dentro de uma função, e então teremos
nosso caso recursivo,
ou nossa chamada recursiva ou nossa E é isso que vamos
seguir em frente e
avaliar em relação a isso. Então, vamos utilizar o caso base e
igualá-lo ao núcleo recursivo Ok,
então vamos começar. Vamos criar um
programa simples para começar, e vamos chamar
essa função de contagem regressiva. Vamos ter
N como parâmetro. E vou colocar isso nos comentários para que
você comece a aprender. Então, teremos um caso base, e isso será
neste caso, se N for igual a zero. Vou imprimir,
digamos, blast off. Então, uma vez que ele imprima o blast off, eu quero parar as funções, vou dizer return,
e isso vai ser executado e impedir que a
função continue Então eu quero definir
minha chamada recursiva. Essencialmente, aqui eu quero
imprimir meu número atual. Também quero chamar a função
novamente com N menos um. Para fazer isso, posso simplesmente me referir
à função aqui
e dizer N menos um Então eu preciso passar por um argumento externo
chamando a função, para que eu possa dizer contagem regressiva e
passar por cinco, e isso é o que
vai acontecer. Vou pegar
cinco como argumento,
passar como parâmetro
por N. Verifique o caso base, que é se N for igual a zero,
imprimir blast off e, em seguida,
retornar e parar No entanto, não é o caso, então ele
não executará essa instrução
if e,
em vez disso, imprimirá N, qualquer que seja o
argumento associado, que é cinco, então ele chamará
a função novamente, fará contagem regressiva e digamos cinco menos um, que será Em seguida, ele repete todo o
processo novamente e faz quatro, quatro não é igual a zero Então ele vai
imprimir quatro, contagem regressiva, quatro menos um, que vai
ser três, agora é três Se três for igual a zero, o que não é, imprima N, que é três, conte
três menos um, dois, volte N, é claro,
vai ser dois, então o que vai
fazer é dizer que I N é igual a dois, não vai então imprimir N, que vai
ser dois, contagem regressiva, dois menos um, isso
vai ser um, e então
vamos até chegar a zero e, uma vez zero, vai dizer print blast
off e depois terminar a off e É assim que um programa
recursivo básico funciona. Você tem seu caso base e
sua chamada recursiva. Agora vamos
salvar isso e correr. Então você pode ver
aqui que temos cinco, quatro, três, dois, um
e depois decolamos Então você pode ver aqui
quando diz imprimir N, que será
cada vez que for um número depois de ter
sido subtraído Então, primeiro, será cinco, cinco menos um
vai ser quatro Comece a avaliação com
quatro, quatro e depois
quatro, imprima e continue com o
mesmo processo até que possamos decolar e retornar
à função definida Então é basicamente
assim que esse programa funciona. Borda. Então esse é o essencial
da recursão. Tudo bem. Agora vamos fazer
mais alguns exemplos para que possamos desenvolver nosso conhecimento sobre
recursão. Tudo bem. Agora, o próximo programa aqui, o que vou fazer é
configurar uma função de contagem progressiva. Então, vamos seguir em frente
e fazer exatamente isso. Eu vou dizer Def count up, e podemos realmente colocar
o sublinhado aqui, e ele vai receber Bem, ele vai ter um
parâmetro que está recebendo, mas também vamos ter
um argumento padrão definido aqui, e eu vou defini-lo
como atual igual a OK. Então, meu caso base, quero dizer que se a
corrente for maior que N, quero dizer que a impressão está concluída. Então, quando chegarmos a N, eu
quero imprimir pronto, e então eu quero retornar, o
que vai
parar a função. Agora vou
dizer imprimir corrente, e vou chamar a
função, que é contagem regressiva, e vou passar por N, e vou dizer
corrente mais um. OK. Então, aqui o que estamos fazendo é chamar
a função novamente com current mais um
e precisamos
passar por um argumento para
começar com a contagem regressiva,
vou dizer cinco. Vamos ter
cinco e lembrar que essa é nossa chamada recursiva Estou passando de cinco é uma discussão. Temos cinco aqui e
temos uma corrente que é definida como
um, se a corrente for
maior que N, temos cinco. Não é o caso, vamos para a chamada recursiva Vamos imprimir a
corrente atual,
é claro, será uma. Então, o que vamos
fazer é
ainda passar por cinco aqui. Então, vamos
dizer atual mais um, o que significa que serão essencialmente dois. Agora, nada acontece com
o valor N aqui porque, essencialmente,
o valor N ainda será cinco. Mas o atual,
é claro, agora serão dois. Então,
a corrente será dois e o valor aqui da
corrente agora será dois. Então, se dois forem maiores que
N, imprima, não é. Então, vamos imprimir a corrente, e
será duas contagens a mais. Ainda vamos ter
cinco e a corrente mais um, agora vamos repetir
,
e a corrente
vai ser três, e vai ser três aqui, e sempre vai ser cinco
e depois a corrente mais um, agora
vamos ter quatro, e até seis, ok, a impressão será feita até o fim
quando chegar a seis. Também quero imprimir N para você
, para que você possa ver
que permanece em cinco. Então, se eu dissesse imprimir N, você também verá esse resultado. Então, talvez eu deva colocar alguma
textura para facilitar. Então, deixe-me definir isso em
uma string F, na verdade. E eu vou dizer que o atual é. E eu vou seguir em frente
e pronto, NN está e aí vamos nós Então, vamos continuar e executar isso. Ok, então podemos ver aqui. A corrente é uma porque
isso é o que dissemos
no padrão N é cinco.
Vai ser adicionado a um. A corrente é dois e é cinco, corrente é três e é cinco, corrente é quatro e
é cinco e pronto. OK. Então, quando tivermos seis, ok? Então, se a corrente for seis, que é maior que N,
a impressão será concluída. Portanto, não vai ter a
chance de imprimir
aqui para mostrar que o atual é cinco. Então, tecnicamente falando, podemos realmente chamar isso e dizer aqui, a corrente final foi E se executarmos isso, você pode ver aqui que diz que a corrente
final foi seis. Foi aí que chegou
no final, pois era
maior que cinco. Se fosse maior do que igual a, isso teria
sido outra história. Mas é assim que
também podemos usar um caso base, configurar nossa chamada recursiva e como podemos seguir em frente e criar um programa
que conta Essa é outra maneira de fazer isso. Agora, vamos seguir em frente e fazer
outro exemplo, que é repetir uma mensagem
com recursão Definiremos nossa função, que é repetir a mensagem de sublinhado, e
passaremos por dois parâmetros, mensagem e N, e
nosso caso base Se N for igual a zero, eu quero retornar Eu vou parar quando N chegar a zero. Isso é
tudo que eu vou fazer. Então, minha chamada recursiva
é imprimir a mensagem, e queremos chamar
a função de repetição de mensagem,
e queremos repetir isso, e vamos chamar
a função novamente com mensagem e menos Então, agora chamamos a
função externa, repetimos a mensagem e
passamos por nosso argumento, então teremos hello
que vai para message, e então teremos três, que vai para N. Então,
vamos resolver isso. Então, olá é a mensagem. N é três. Se N for
igual a zero, Não é o caso.
Então, vamos imprimir uma mensagem, então
vai ser olá. Em seguida, realizamos
a chamada recursiva e passamos a
mensagem, que é olá E então dizemos menos um. OK. Então, o que temos agora é que três agora
vai se tornar dois. Então, avaliamos.
Se N for igual a zero, retorne, imprima olá,
repita Vou dizer que você
passa por olá e menos um. Isso vai então passar para um. Retorne, repita a
função novamente, execute-a novamente, imprima
a mensagem, olá novamente. Execute a função novamente
e, em seguida, ela começará
novamente no caso base. Então, eventualmente, chegará a um
ponto em que é zero. Em seguida, ele retornará
e você verá aqui que a mensagem hello será
impressa três vezes aqui, dissemos menos um, e
acabamos de repetir a função ir novamente e novamente Tudo bem. Então é assim que podemos usar essa
chamada recursiva neste caso Certo. Ok, então é
isso em recursões, como você pode ver, você terá seu caso base e sua
chamada recursiva E esses e a implementação
da recursão, como eu disse, têm muitos campos
nos quais você pode
utilizar e usar casos, mas é muito útil
se você quiser repetir sua função e executá-la até que um
determinado caso seja alcançado Certo, pessoal. Então é
isso na recursão.
92. Compreensões: Oi, todo mundo. E bem-vindo
à próxima lição, que será
focada na compreensão. Então, vamos dar uma olhada. Tudo bem Então, temos dois tipos
de compreensão. Obtemos compreensões de listas, e uma compreensão de lista é essencialmente uma forma abreviada
ou abreviada de criar uma nova lista
em uma única linha transformando ou
filtrando os elementos
ou itens ou Agora, a sintaxe
será a seguinte. Você terá sua expressão, depois terá quatro HM na
coceira e, é claro, também
poderá ter uma condição de
if Você pode ver que está tudo
escrito em uma linha para você. Você não precisa definir,
por exemplo, seus quatro loops,
sua declaração if e fazer tudo
isso de forma
sequencial Agora você pode ir
em frente e colocar
tudo isso em uma única expressão. Também temos
compreensões de dicionário e uma compreensão de dicionário funcionará de maneira semelhante e
gerará pares de valores-chave em uma única linha ao aplicar filtros ou Agora, ele tem uma sintaxe similar. Você terá sua expressão-chave,
sua expressão de valor, e
serão quatro itens nela, você
também terá seu loop e a
instrução if opcional em termos
da condição I que
você deseja utilizar. Compreensões. Você
quase pode tentar compará-lo no sentido de como o
Lambda funciona Podemos ver as compreensões com as compreensões dicionário e da lista Podemos ver
que também
será uma abordagem mais simples
quando quisermos ter expressões de linha
única nas
quais queremos
aplicar loops
e instruções if , além de garantir
que possamos gerá-las
configurando-as como uma lista ou dicionário
no processo
93. Usando compreensões de lista — [Lab]: Oi, pessoal. Bem-vindo ao
próximo exercício prático de laboratório, que será focado
na compreensão da lista Lembre-se, na compreensão da lista,
temos nossa expressão, depois temos nosso fol, que será para
o item no iterável, e então também podemos
adicionar uma condição if, que também é algo
que você pode adicionar se quiser adicionar OK. Então, a parte da expressão,
que vai
modificar ou transformar cada item e
geralmente em uma lista. E então os quatro
itens em cada parte, que
percorrerão a lista. E isso fornecerá os valores para nossa expressão. Certo. Então, vamos
continuar e começar com alguns exemplos. Digamos que eu tenha uma
lista de números e eu tenha um, dois, três, quatro e cinco. Então eu quero criar uma nova lista onde cada número é quadrado Então, vou
definir essa variável
chamada números quadrados, que será
essencialmente a nova lista E para fazer isso, vamos realizar
uma compreensão da lista. Agora, a primeira coisa
que precisamos fazer é definir a expressão.
Então, o que queremos fazer? Eu quero dizer Num
multiplicado por Num. Então, eu quero multiplicar
dois números. Isso virá
dos itens na lista de números
pelo loop de quatro, que diz
quatro números em números. É assim que
obteremos nossos valores ou itens. Vamos executar esses quatro
loops e Num,
é claro, extrairá cada valor e
, em seguida,
poderemos utilizá-lo em
nossa expressão aqui, que
armazenará cada valor com cada iteração
na lista por vez Deixe-me mostrar o que quero
dizer. Em um comentário aqui. Então, temos um, dois,
três, quatro e cinco. Então, quatro números em números. Primeiro, vamos pegar um. Esse será
o primeiro número que
será repetido. Então vamos pegar um e
dizer um multiplicado por um Vai ser um.
Em seguida, vamos passar para o segundo item,
que será dois. Então, pegamos dois aqui desse loop de quatro,
e então podemos dizer, com a expressão
aqui à esquerda, dois multiplicado por dois, isso
nos dará Então vamos em frente e
olhamos para isso novamente. Então temos três,
percorremos e coletamos três, e agora vamos dizer que
três multiplicado por três, isso nos dará nove Em seguida, passamos para quatro, já que esse é o próximo item
no loop de quatro, vamos pegar quatro e
dizer quatro multiplicado por quatro Isso vai nos dar 16. Então, com nossos quatro laços,
vamos percorrê-lo e pegar cinco. Então, podemos dizer cinco multiplicado por cinco, o que nos dá 25 Se fôssemos imprimir números
quadrados, que agora serão uma lista com base no resultado que
definimos adequadamente aqui, podemos prosseguir e executar o
código e aqui obtemos um, quatro, nove, 16 e 25 Essa é a
maneira mais simples de realizar a compreensão da lista Para elaborar novamente, à esquerda, temos nossa expressão e
isso vai elevar ao quadrado cada número, como vimos
no lado direito, temos nossos iteradores
que estamos definindo
como nossos quatro loops para escolher números um por um e o resultado é todo armazenado na
variável de números quadrados, que será
essencialmente do tipo de dados de uma lista, e então imprimimos a
saída e tudo serão armazenados um
por um na nova lista. Vamos fazer outro exemplo. Digamos que temos palavras
e temos olá, temos mundo e
temos pyson Vamos
criar uma lista em que cada palavra precisa ter um ponto de
explicação no final. Vou apenas definir uma variável
chamada palavras excitadas. Precisamos primeiro
definir nossa expressão, que eu prefiro fazer primeiro. Vou dizer palavra mais e colocamos o ponto de
explicação. Isso será
baseado no loop, que percorrerá todas as palavras por palavra em palavras. Ok, então vamos lá de novo. Então, vamos
executar isso para loop, e vamos
armazenar temporariamente olá e, em seguida,
vamos pegá-lo e
utilizá-lo aqui em nossa
expressão e dizer olá,
mais, e depois o ponto de
explicação. Em seguida,
isso o armazenará em uma nova lista que
dirá olá. Em seguida, vamos
executar esse programa novamente, palavra em palavras
, e depois vamos pegar bem. Ele será armazenado
na palavra variável word, e então podemos
simplesmente dizer palavra mais, e isso será
o seguinte. Em seguida, vamos executar
nosso ciclo de quatro voltas novamente. O Word será
armazenado no PySon. Podemos então
dizer apenas PySON plus e será o seguinte Vamos fazer nossa lista agora. Excited Words tem uma nova lista. Isso vai dizer
olá, mundo e PySon. Isso deveria ser o caso. E essa será
a sua saída. Você deve conseguir ter uma
ideia do padrão aqui. Ok, ótimo. Agora vamos
continuar e fazer outro. Este vai ser convertido
para maiúsculas. Vou comer frutas e vou
comer maçã Pare orange. Agora eu quero ir em frente
e criar uma nova lista. Então, vou chamar esse sublinhado
maiúsculo de frutas. Tudo bem. Então, podemos seguir em frente e definir qual seria nossa
expressão, eu diria fruta com ponto superior. E nosso ciclo seria de
quatro frutas em frutas. Então, vamos dar uma olhada no
que estamos fazendo aqui. Então, quatro frutas e frutas, examinaremos cada um dos itens de forma independente. Então, maçã, vamos
armazenar maçã, e então vamos
dizer maçã com ponto superior com esse mesod de ponto superior
e isso vai
transformá-la em maçã, que
armazenaremos em nossa lista Em seguida, continuamos com
frutas e frutas. As frutas serão então
armazenadas como um par de peras no ponto superior, que será uma pera Execute nossos quatro loops novamente e seguida, pegaremos a laranja, que será
armazenada em nossa variável, e então podemos dizer laranja e maiúscula. Vai ser laranja. Agora, se imprimirmos frutas com
sublinhado em maiúsculas e
executarmos isso, podemos ver que temos maçã, pêra e laranja em
maiúsculas em nossa nova Essa é a maneira mais simples
de prosseguirmos e começarmos a entender
listas. Lembre-se de que o lado esquerdo
é sua expressão. O lado direito aqui serão seus quatro loops. Certo. Então, temos
isso em prática. Agora, a próxima coisa
que vamos
querer fazer é trabalhar com uma
declaração if a esse respeito. Então, vamos dar
uma olhada nisso. Certo, então vamos adicionar
uma chave inglesa em andamento. Então, queremos trabalhar agora também com
nossas condicionais if. Então, vamos definir uma
lista de números, e eu vou dizer um, dois, três, quatro, cinco, seis, sete, oito, nove, dez. Agora, queremos manter apenas
números pares para que
possamos definir nossa nova lista
pela variável números pares. E vamos
continuar e dizer que num,
num, neste caso, funcionará
apenas como um espaço reservado para
ser passado para nossa
lista em termos
do resultado final por
iteração que é Então, vamos dizer
quatro números em números. Se num, e vamos adicionar o módulo
dois é igual Então, queremos verificar se há
números pares , é o que
estamos fazendo aqui. Ok, então vamos seguir em frente
e explicar
como estamos fazendo isso. Temos todos os itens aqui em nossa lista aqui e vamos
dizer quatro números em números, e vamos procurar um. Temos um aqui
e, em
seguida, verificaremos se for condicional Se um for, obviamente,
um número par, o que vamos
fazer é armazená-lo
no espaço reservado aqui de num e depois
adicioná-lo à lista Esse é o processo
aqui desta vez, a expressão aqui
à esquerda está agindo mais como um pedido feito antes,
mas antes de
prosseguirmos e executarmos ações
reais e depois
armazenarmos o resultado final, mas agora é como um
pedido feito para armazenar o resultado final que
passaremos para nossa lista. Então, neste caso aqui, não
é o caso, então não vamos
armazenar nada no NUM porque
ele falhará. Se for verdade, ele armazenará
o resultado que você poderia dizer em NUM, que será passado como uma lista, mas, nesse caso,
isso não
acontecerá .
Então vamos
para a próxima. Então, dois. Então, quatro
números numéricos, temos dois. Em seguida, verificaremos se dois é um número par e é, para que possamos armazená-lo
em um e dizer dois. Então vamos para quatro, e vamos dizer
quatro números
numéricos, e então
vamos para três, desculpe-me Em seguida, vamos verificar
se três é um número par. Se não for, ele
falhará
e, em seguida,
executará
nosso acompanhamento novamente, o
que não acontece Em seguida, veremos quatro e diremos
se quatro é um número par. Ele é armazenado no
resultado para num. Podemos dizer quatro. Temos cinco e continuamos fazendo o mesmo
resultado até obtermos quatro, seis, oito e dez. Vamos fazer
o mesmo padrão. Vamos imprimir isso
para ver se estamos corretos. Posso dizer que imprima até mesmo números de
sublinhado
e execute isso Lá vamos na nossa
lista, temos dois, quatro, seis, oito e dez. É assim que podemos seguir
em frente e utilizá-lo. Agora, digamos que queremos tornar isso mais interessante
e
queremos manter as palavras com
mais de cinco letras. Eu posso definir uma lista de palavras. Eu vou dizer maçã
e vou dizer banana e kiwi e
uva e abacaxi E par. Portanto, temos
muitas coisas na nossa lista. Agora queremos definir uma nova variável que será
essencialmente uma lista. Queremos manter somente
palavras mais de cinco
letras nesse caso. Então, vamos ter palavra como nossa expressão para
palavra em palavras. Então, vamos dar uma
olhada em todos esses itens armazená-los temporariamente
como palavra aqui. E então o que
vamos fazer é verificar se o comprimento com
a função aqui da palavra é
maior que cinco
e, se for, vamos nos referir à palavra aqui como espaço reservado
e depois adicionar à nossa lista Tudo bem, então
vamos começar
com nossos testes. Quatro palavras em palavras.
Nós temos a Apple. Se o comprimento da palavra
for maior que cinco, podemos então
armazená-la. Podemos utilizar a
palavra aqui como um soldado local
para armazená-la em nossa lista. A Apple é um, dois, três ,
quatro, e nós
vamos ter cinco. Portanto, não é maior do que,
passamos para a próxima, banana. Quatro palavras em palavras.
Em seguida, banana. Se o comprimento da palavra
for maior que cinco, você pode usar o Word como soldado local e podemos
colocá-lo, então um, dois, três, quatro, cinco,
maior que, mas não. KV é quatro, então isso
não vai funcionar. Uva. Isso vai ser cinco, não vai funcionar, abacaxi Quatro palavras e palavras,
examinamos cada uma
e, se elas falharem, não
usamos o Word como um espaço reservado para
armazená-lo em nossa lista Vamos dar uma
olhada no abacaxi. Sim, isso vai
ser maior do que cinco. Use a palavra como espaço reservado
e podemos misturá-la. Então temos o par,
que não
terá apenas em nossa
saída o seguinte. Se eu disser imprimir palavras longas de
sublinhado, isso resultará banana e abacaxi e é
isso que o resultado
obterá no final Certo, perfeito. Então
aí está. É assim que
também podemos utilizar um if condicional, se quisermos,
se quisermos realizar a compreensão da
lista Então aí está. Aqui estão os exemplos:
a expressão, nossos quatro loops, o iterável e nosso if condicional Tudo bem. Então é assim que podemos realizar compreensões de listas
94. Usando compreensões de dicionário — [Lab]: Oi, pessoal. E bem-vindo ao próximo exercício prático de
laboratório, que se concentrará na utilização de
compreensões de dicionários Portanto, também
seguiremos a mesma
estrutura que fizemos com as compreensões de listas
para começar primeiro com nossas expressões e
nosso loop for
e, posteriormente, também utilizar
uma instrução if Tudo bem, então vamos simplificar e começar. Então, primeiro, vou
encontrar uma lista de palavras. Então eu vou dizer olá. Bom. Tchau. E eu
vou dizer, bem-vindo. Então eu quero definir
meu dicionário. Vou dar a ela o
nome da variável da palavra Links dict. Então, basicamente, o que
vou fazer é criar um
dicionário com tintas de palavras Está bem? Então, teremos nosso
dicionário aberto da seguinte forma. Teremos
nosso par de valores-chave
e, em seguida,
teremos nosso loop for. Agora vou dizer que
minha chave será a palavra. Em seguida, vou usar
a função Lang para obter o tamanho total dos
caracteres da palavra, e isso
será concluído depois de executarmos nosso
loop for da seguinte maneira Então, novamente, vou colocar uma opção aqui para que
possamos rastrear tudo. Então, aqui estão outros itens ou elementos aos quais você pode se
referir a eles em nossa lista. Então, vamos
correr, primeiro de tudo, palavra
por palavra. Então, temos uma palavra aqui e vamos armazenar
temporariamente o hello. Em seguida, vamos mover o
olá aqui para a chave, e essa chave vai para nosso novo dicionário e
será como olá. Em seguida, coloque dois pontos aqui para
separar o valor. Então, vamos
obter o comprimento ou o comprimento do olá
em caracteres, que serão cinco
caracteres. Execute nosso loop novamente. Palavra. Vamos nos
despedir, armazená-lo como palavra e, em
seguida,
armazená-lo permanentemente em nossa lista Vamos enviá-lo
para nossa expressão aqui. Nossas expressões aqui são
essencialmente os espaços reservados. Vamos pegá-lo
do loop quatro aqui, armazená-lo temporariamente no Word e, em seguida, movê-lo para nossas expressões. Nesse caso, vamos movê-lo para o nosso
dicionário. Aqui em nosso espaço reservado, vamos nos despedir antes de movê-lo para nossa lista Aqui podemos dizer bem por quê? Então, qual é a
duração do adeus? Serão
sete personagens. Então, para palavras e palavras, pegaremos as boas-vindas e depois as moveremos
para nosso espaço reservado de palavra, que então será
bem-vindo Em seguida, vamos inseri-lo aqui para obter o valor
dos comprimentos de boas-vindas, que serão sete Agora, se dissermos imprimir, sublinhamos os comprimentos,
sublinhamos Temos esse dicionário aqui, esse novo dicionário, olá cinco. Adeus, sete. Bem-vindo, sete. Portanto, está na parte fundamental do valor. Então, as chaves são olá,
adeus e bem-vindo. E o valor está sendo
cinco, sete e sete. Certo. Então, essa é uma
maneira simples de como podemos fazer isso. Vamos seguir em frente e praticar
um pouco mais. Digamos que queiramos seguir em frente e fazer uma
representação de números em strings, por exemplo. Então, eu vou ter
uma lista de números. E eu vou ter um, dois, três, quatro e cinco. Em seguida, vou criar
um dicionário onde os números são chaves e
os valores são cadeias OK. Então, vamos fazer isso. Vou dizer palavras com
sublinhado numérico, e teremos um
dicionário delas Então, primeiro teremos a chave. Isso vai ser
num e depois
vamos converter em string, o número em si,
e vamos dizer quatro números em números. Ok, então vamos dar uma olhada
aqui. Quatro números numéricos. Tudo isso é, como podemos ver,
números inteiros em formato inteiro. Vamos dizer
quatro números numéricos e vamos coletar Num, passá-lo para num aqui e vamos armazená-lo em
nosso dicionário, exatamente como está. Teremos uma como nossa chave. Então, o valor aqui também
será tecnicamente um, mas vamos
convertê-lo em uma string, isso significa que esse valor
estará entre aspas Então temos quatro números numéricos. Vá para o segundo
resultado, que é dois, pegue dois, passe para o espaço reservado para que possamos armazená-lo em nosso novo dicionário. Serão dois. Em seguida, vamos convertê-lo
aqui em uma string para o valor e isso ficará
apenas entre aspas dois. Fazemos a mesma coisa para três, então vamos fazer isso. Então, para números
numéricos, a seguir, temos três, pegue três, passe para o nosso
espaço reservado aqui, e isso vai
ser três, é a chave. Em seguida, vamos
inseri-lo aqui no valor, então queremos
convertê-lo em uma string
e, em seguida, obtemos três. Acho que você entendeu a ideia agora, e vamos fazer a
mesma coisa para quatro e cinco. Então, quando
imprimimos
palavras com números sublinhados , obtemos esse dicionário, como você pode ver aqui
a seguir, um, dois, dois, três, 44, cinco,
cinco, cinco,
cinco, com a chave
permanecendo como um número inteiro em sua forma bruta e os valores são convertidos um telefone
de string É assim que podemos seguir
em frente e configurar isso. Ok, agora vamos seguir em frente
e fazer outro exemplo aqui, e aqui queremos mapear
números para seus cubos. Ok, então
vamos fazer isso. Então, números são iguais, e
teremos um,
dois, três, quatro e Ok, agora queremos
criar um dicionário onde as chaves são números e
os valores são seus cubos. Então, vou definir uma
variável como cube dict. OK. E isso vai
ser um dicionário. Vamos ter um
como chave e depois um número e, em seguida
, asteriscos duplos Então, isso vai garantir que
tenhamos o resultado em cubos, que será dois, três,
quatro, num em números OK. Então, vamos seguir em frente
e fazer exatamente isso. Para números numéricos, precisamos ter certeza de que
temos nosso formato de explicação de como
posso dizer? Um número de quatro números. Primeiro, temos um, pegue um. Em seguida, vamos
passá-lo aqui para num e esse será
um como chave. E o
cubo de um a um nos
dará essencialmente o resultado de um Tudo bem. Então,
para um número em números ,
ok, vamos ter dois. Então, temos dois aqui, transportados para lá como a chave, dois e o valor lá Então, dois cubos basicamente nos darão o resultado
de oito como valor Vá novamente, quatro números numéricos. Vamos trabalhar
com três agora. Pegue três, mova-a
para o espaço reservado, para que possamos prepará-la
para o nosso dicionário Vamos até lá e isso basicamente
nos dará três e, em seguida,
diremos três, é
claro, em cubos, e isso
nos dará 27 Isso vai continuar e fazer o mesmo resultado
para quatro e cinco. Podemos obter a
saída final dizendo print,
cube dink, aí
obtemos o seguinte Tínhamos um, oito, 27 e, claro,
temos 64 e 125,
cinco ao cubo, quatro ao cubo,
etc., e é
assim que podemos
mapear números em seus cubos etc., e é
assim que podemos
mapear números Certo. Acho que agora devemos confiar
na ideia de que, à esquerda, temos nossa expressão
e, à direita, temos nosso loop for e
o iterável e só
vamos utilizar nossas expressões
depois de obtermos um resultado Se tivermos que realizar
algum cálculo, esse resultado final
entrará em nosso dicionário, neste caso ou se estivermos trabalhando com listas na lista. Se não precisarmos
realizar um cálculo, podemos simplesmente ir em
frente e inseri-lo. Certo. Perfeito. Ok,
então isso é bom. Agora, a próxima coisa que
vamos fazer é trabalhar com nossas condições if. Então,
vamos começar. Então, vou dizer palavras
,
e vamos comer maçã, pêra, laranja e morango E grep. Há todos
os itens na minha lista. Agora, quero criar
um dicionário em que as chaves sejam palavras e os
valores sejam seu tamanho, mas somente para palavras com
mais de cinco letras. Vamos definir esse dicionário. Vou chamá-la de palavras longas, iguais aqui no
meu dicionário, teremos uma
palavra como chave e seguida, o comprimento da
palavra aqui seria o valor, e isso
será por palavra em palavras se o comprimento da palavra
for maior Ok, então vamos continuar
e trabalhar nesse processo. Então, primeiro, precisamos
examinar nossos quatro loops. Então, quatro palavras em palavras. Então, vamos percorrer todos esses itens na lista. Então, primeiro, temos a Apple.
Apple, podemos ver que é um, dois, três, quatro, cinco. Podemos ver que
são cinco caracteres. Portanto, se o comprimento da
palavra for maior que cinco, podemos
seguir
em frente e fazer uso dessa expressão específica. Se não for o
caso, se for falso, passaremos para
o próximo item do loop. Ok, tão falso,
não continuamos. Se for verdade, só adicionamos verdadeiro ao nosso novo
dicionário nesse caso. Nós nos mudamos para emparelhar. Podemos ver
que o par não é cinco, então podemos pular laranja, um,
dois, três, quatro,
cinco, seis, laranja Por palavras e palavras,
temos laranja. Se o comprimento for
maior que cinco, é seis. Em seguida, vamos definir que vamos substituí-lo
ou enviá-lo para o Word como espaço reservado para passar pelo nosso novo
dicionário que estamos criando e que estará essencialmente entre aspas Vamos comer laranja. Cólon. E então precisamos do
comprimento da palavra lá. Então, no nosso caso aqui,
serão seis. Então, podemos adicionar nossa vírgula. Depois vamos para o morango. Já podemos ver
que é maior cinco, então podemos ver
um, dois, três, quatro, cinco, seis, sete,
oito, nove, dez. Então, quatro palavras e palavras. Agora estamos comendo morango. É maior que
cinco, é dez. Então, essa palavra em particular, vamos
passar aqui para palavra aqui, e agora podemos realmente adicionar a palavra ao nosso
dicionário, morango E o valor aqui,
seu comprimento,
é de dez caracteres,
então podemos dizer dez. Certo, vamos enganar. Então temos uva, e a uva é só cinco,
então isso não vai funcionar. Então, só teremos
esses dois itens. Então, podemos dizer imprimir.
Palavras longas. E aí está. Temos nosso novo dicionário
com nosso par de valores-chave, nossa chave aqui sendo
laranja, valor seis, chave sendo morango, valor dez. Tudo bem,
aí está. Ok, vamos continuar
e fazer outro. E isso vai filtrar os números
pares e dobrá-los. Então, teremos uma lista dos
números um, dois, três, quatro, cinco, seis, sete, oito, nove e dez. Então, queremos configurar um dicionário em que números
pares sejam chaves e os valores tenham o
dobro de seu valor. Então, vou definir a variável
como pares duplos. Isso
será essencialmente um dicionário, então teremos Num. Então, teremos Num multiplicado
por dois para o valor
e, em seguida, nosso loop
será quatro num em números
se num somar o módulo
dois duplo for igual Vamos verificar se,
é claro, também está certo. Esse é o filtro em Vamos prosseguir e fazer
os cálculos. Quatro números em números.
Vamos examiná-los. Nós temos um. Agora,
se num for par, podemos ir para a expressão, mas não é para que possamos pular Quatro números em números,
vamos para dois. Se o número for par, é dois, então
podemos seguir em frente. O número será dois, essa será a chave porque estamos trabalhando
com um dicionário, e isso vai ser dois, duas vezes dois, isso
vai nos dar quatro. Oito. Vamos para a próxima. Três, três não é nem mesmo. Então, o que você pode fazer é saber que, se observar
a condicional I, poderá verificar automaticamente se ela corresponde
a um determinado caso e se
não precisa se
preocupar em concluir tudo
e atribuí-lo preocupar em concluir tudo
e atribuí-lo Quatro serão iguais. Quatro números nominais, verificamos três,
vamos ver quatro É até mesmo de
acordo com nosso if condicional. Vamos colocar
quatro como chave. Então vamos
dizer quatro vezes dois. Esse será o resultado
final que
armazenamos aqui e
ali temos quatro. Cinco é ímpar, seis é par. Podemos dizer quatro números em números. Se o número for par, seis é. Então, podemos mover seis aqui
para o espaço reservado de num, o que significa que podemos
colocá-lo em nosso novo dicionário, que
será seis como chave Então diríamos seis vezes dois, e isso nos dará 12. Ok, então esse é um processo que
seguimos indefinidamente. Só temos oito e
dez para avaliar. Então, vamos imprimir
isso para ver o resultado. Então, pares duplos. E vamos seguir em frente e executar isso. E aqui podemos ver que
temos esse resultado. Então fizemos o primeiro
até seis aqui, e depois temos
oito, 16, dez e 20. Então, pudemos ver que oito
e dez
serão enviados para a ordem
de posição de Num passada para
o novo dicionário
e, em seguida, 16 e 20 também. Ok, então 16 e 20, podemos ver que foi derivado
multiplicando oito por dois e depois dez por dois
também. Certo, pessoal. É isso mesmo. É assim que podemos utilizar a
compreensão do dicionário Como você pode ver, é um processo
bastante simples e como podemos
utilizá-lo. É isso mesmo.
95. Linhas e processos: Olá a todos, bem-vindos
à próxima lição, que será focada em tópicos e processos.
Então, vamos dar uma olhada. Certo, então a primeira
coisa que precisamos entender é
o que é um tópico. Portanto, um encadeamento é essencialmente
uma unidade leve de execução que
é executada de forma independente enquanto compartilha memória
com outros encadeamentos. Assim, você pode tentar
pensar em uma linha como um trabalhador em uma linha de
montagem em que cada linha executa uma tarefa e várias linhas podem
trabalhar simultaneamente para acelerar o processamento. Agora vamos dar uma olhada
nos benefícios dos fios. Portanto, os encadeamentos de um processo
usavam a mesma memória. Eles consomem menos recursos
e são eficientes. Eles também são ideais
para tarefas específicas que exigem espera pela
entrada ou saída. E outra coisa importante
a saber é que iniciar um tópico é mais rápido do que
iniciar um processo Agora vamos dar uma olhada nas limitações
dos fragmentos. Agora, os encadeamentos
se revezam devido
ao bloqueio global do interpretador comumente chamado de GIL Os encadeamentos não podem ser
interrompidos à força depois de iniciados, então essa é a infelicidade no que diz respeito aos encadeamentos, ao contrário de um processo
que Uma vez iniciado, um tópico não pode. E uma coisa importante
a saber aqui é que dados
compartilhados podem causar problemas
imprevisíveis Em outras palavras, crie
condições que podem ocorrer se os dados estiverem
sendo compartilhados. Agora, também não há melhoria de
velocidade para nenhum trabalho intensivo de CPU que
esteja ocorrendo com threads. Agora, vamos dar uma olhada nos
processos. Então, um processo. Um processo é um programa ativo com sua própria memória
e recursos. Agora, uma maneira mais simples de ver um processo é pensar nele como um aplicativo separado
no seu computador ou como um
tipo específico
de utilitário em segundo plano, em
que cada
um
é executado de forma independente, que cada
um
é executado de forma independente sem compartilhar
memória com os outros Agora, em termos dos aplicativos aqui, estou me referindo, por exemplo, digamos que você tenha o
Microsoft Word aberto, que seria contado como um aplicativo, ou se você também tivesse um
aplicativo como o Discord aberto ou se você tivesse Spotify aberto ou Steam ou o Google Chrome
ou algo parecido, você pode ver isso
nesse tipo de aspecto Agora, há muitos
benefícios dos processos,
então vamos dar uma olhada. Assim, eles podem utilizar totalmente
várias CPUs e núcleos. Cada processo tem sua própria memória, então isso ajuda a manter
seus dados separados. Também é muito ideal
para tarefas que exigem processamento
pesado de CPU,
ao contrário de threads. É importante observar
que os processos podem ser executados de forma independente, sem
depender uns dos outros E eles podem ser interrompidos ou
interrompidos a qualquer momento, que é um dos
melhores benefícios que você pode ter em relação
aos processos Cada processo tem seu próprio gel, GIL, evitando os
limites de segmentação impostos pelo Python Agora, é claro, também existem algumas limitações
de processos. Podemos ver que os processos usam mais recursos do sistema em comparação com os threads
que usam menos. Além disso, se você quiser criar um processo, levará
mais tempo do que iniciar um tópico. Outra coisa lamentável
é que cada processo requer mais memória, pois
eles não a compartilham A comunicação entre
processos é bastante complexa e, infelizmente, requer
tratamento extra. E a última coisa que quero
mencionar sobre uma limitação de processos é que
alternar entre processos
pode ser muito lento, e isso terá um impacto no desempenho
devido à sobrecarga Rapazes. Então, isso é tudo para
a visão geral teórica. Eu só queria mostrar
a você
a supervisão teórica em
termos do que são tópicos, quais são os processos
e fornecer algumas informações sobre seus
benefícios e limitações E, como você pode ver, é quase
como se onde um sofre, o outro prosperasse,
pode-se Mas, de qualquer forma, isso é
tudo para esta lição.
96. Multiprocessamento: Olá a todos, e bem-vindos
à próxima lição, que será focada no multiprocessamento. Então,
vamos dar uma olhada. Certo, então o
multiprocessamento permite que um programa execute vários
processos de forma independente, cada um com sua própria
memória e recursos Agora, ele também maximiza o uso
da CPU distribuindo cálculos
pesados em vários núcleos para
97. Multi-threading: Olá a todos, bem-vindos
à próxima lição, que será
sobre multisegmentação Então, vamos dar uma olhada. Certo, então o multiencadeamento é um sistema que
permite que um programa execute vários encadeamentos
no mesmo processo para que você possa compartilhar suas memórias e
também seus recursos Ele também permite que as tarefas sejam
executadas simultaneamente sem a sobrecarga de criar processos
separados Tudo bem Então, vamos
continuar e mergulhar
na prática da fragmentação múltipla
98. Integração do multiprocessamento - [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de
laboratório, que se concentrará na utilização do multiprocessamento Então, vamos começar. Primeiro, queremos importar o módulo de processamento
múltiplo. Em seguida, queremos importar o módulo de tempo para que possamos
utilizar a função de sono. Em seguida, queremos definir a função que será
executada em um processo separado. Eu vou dizer, trabalhador surdo, vai ser uma função Tudo o que vou fazer é
chamar o módulo de tempo e definir minha função de
sono e
manter o processo ativo por pelo
menos 20 segundos para que
possamos vê-lo no gerenciador de tarefas ou
em nosso gerenciador de atividades. momento, a próxima
coisa que precisamos
fazer é garantir que o código seja executado apenas quando esse
arquivo for executado diretamente, e isso
será visto como um processo. E para garantir que esse
seja o caso, podemos utilizar esta
declaração if que diz I double underscore name,
double underscore é
igual ou equivalente a double underscore main, double underscore Ok, deixe-me explicar. Então você provavelmente está
se perguntando o que é nome de sublinhado duplo Portanto, essa é uma variável especial embutida
que obtemos em Python que conterá
o nome do nosso
script ou módulo Em seguida, temos o sublinhado
principal, o sublinhado duplo. E isso vai verificar
se o script está sendo executado diretamente e se
não foi importado como um módulo. Certo. Portanto, é muito
importante que tenhamos isso sem essa verificação
que estamos realizando aqui, o script pode
continuar criando novos processos indefinidamente
e falhar no final Portanto, é muito importante
que o tenhamos. Isso será visto como
nosso primeiro processo, nosso script Python e, em seguida, nosso segundo processo
será essa função de trabalho Então, já podemos definir isso. Eu vou dizer processo um. E podemos dizer isso como
processo. Vamos continuar. Agora, a próxima coisa que
vamos querer fazer é
criar um novo processo que executará nossa função de
trabalho. Eu vou dizer que processo é igual, e vou dizer processamento
múltiplo Vamos nos
referir a esse ponto do módulo e vamos nos
referir à classe do processo e, em seguida,
passaremos parâmetro target
e
o definiremos como worker. Vamos dar uma olhada
aqui. Agora , o processo aqui
é uma classe do módulo de
multiprocessamento e
será usado para criar um novo processo, o que está sendo executado atualmente,
procurando por um alvo, que funcionará como o processo escolhido que será realizado Agora, o alvo, como mencionei
antes, é um parâmetro, que especificará
a função que deve ser
executada no novo processo, que funcionará Eles provavelmente estão se perguntando,
se isso é uma função, por que não a chamamos ou
adicionamos os parênteses Então, estamos passando essa função de
trabalho sem parênteses porque queremos passar
a função em si e não o resultado
de realmente chamá-la Ok. Agora, esse processo
aqui que
definimos será armazenado
nessa variável chamada processo. Ok. Agora, o que queremos fazer é seguir em frente
e iniciar o processo. Eu vou dizer que
processe o amido pontilhado usando o método do amido, e isso
iniciará o processo, e
isso fará com que ele seja executado em segundo plano. Agora, assim que esse
processo for iniciado, queremos apenas adicionar uma declaração de impressão para
nos dizer que o processo foi iniciado e que precisamos
verificar o gerenciador de tarefas,
pois lembre-se que só o
veremos por 20 segundos. Tudo bem Então, o que podemos fazer
é simplesmente dizer imprimir, e vamos
dizer que o processo começou. Então, podemos dizer
verifique o gerenciador de tarefas. E se você estiver utilizando o macOS, ele será chamado de
Gerenciador de Atividades, que você pode verificar Em seguida, precisamos
dizer processo de junção de pontos, e esse é um método de junção, que aguardará
a conclusão do processo
antes de continuar. Portanto, isso bloqueará qualquer execução adicional de
código no final Queremos dizer que o
processo de impressão foi concluído. Lá vamos nós. Tudo bem, então isso é tudo o que precisamos
ter em mente aqui. Então, teremos nosso processo
padrão em segundo plano
para o script Python
e, em seguida, o processo que realmente
criamos agora, que
será uma função que estamos configurando aqui adequadamente Tudo bem, então é isso que
temos aqui
e pronto para começar. Tudo bem Agora, se
você estiver no Windows, basta abrir
seu gerenciador de tarefas. Você pode simplesmente
procurá-lo no gerenciador de tarefas e abri-lo. Já está aberto,
e o que você pode fazer é
clicar nos processos aqui à esquerda e simplesmente digitar
Pierson e pressionar Andrew Agora, a partir de agora, não mostraremos nada
porque não
executamos nosso script, uma vez que o script aqui será
executado como um processo
e, em seguida, ele também criará
um novo processo aqui adicionando essa função
específica. Tudo bem, então certifique-se de que
você está bem com tudo isso, e então podemos seguir
em frente e continuar. Certo. Agora podemos seguir
em frente e executar nosso código. Aqui diz que o processo
declarou o gerenciador de tarefas de verificação. Você pode ver que temos um processo em
segundo plano e dois processos em execução
e cada um deles, é claro, faz parte do script
Python Essa função que
criamos também
foi implementada e também
podemos ver algumas informações aqui em termos de quanto está sendo usado
em termos de Você pode ver que parou, mas
podemos executá-lo novamente. E volte e podemos seguir em frente e ver o
quanto está sendo usado. Então, vimos que, por
um momento, o uso da CPU foi de 0,2%, então está muito, muito
baixo e desapareceu. E podemos ver algumas
informações aqui na seção de memória
aqui em termos de quanto megabyte
está sendo usado e geral, para os processos em
segundo plano e também separadamente Certo. Então aí está. É assim que podemos utilizar o
multiprocessamento em pyson. Tudo bem, então é isso.
99. Integração de múltiplas threads — [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de
laboratório, que será
focado em multithreading Agora, é claro, o que
vou fazer é apenas me adaptar ao código que tínhamos antes para
multiprocessamento Muitos dos programas que estamos
criando aqui terão semelhanças com quando
utilizamos multiprocessamento Vamos fazer alguns ajustes e
vou contar a vocês as novidades aqui que
tornarão o encadeamento distinto Você pode simplesmente seguir em frente
e manter seu código
igual ao que está, e o que
vamos fazer é apenas ajustá-lo. Obviamente, vamos trabalhar
com multiencadeamento agora. Podemos simplesmente remover
esse módulo no multiprocessamento
e
substituí-lo pelo módulo de segmentação Isso
nos permitirá criar tópicos. Novamente, vamos
usar o módulo de tempo para que possamos utilizar
a função de sono. Teremos uma
função de trabalho como antes e garantiremos
que
definamos o temporizador de sono
para 20 segundos. Claro, ainda vamos
usar
nosso nome de sublinhado, sublinhado, nossa
variável especial embutida, devo dizer Vou utilizar isso. Novamente, vamos utilizar sublinhado
duplo, o sublinhado
duplo principal e, como
mencionei antes, garantiremos que o script esteja em execução e, em geral
,
garantiremos , com essa declaração if que não tenhamos falhas
ou algo A próxima coisa que queremos
fazer é criar um tópico. Em vez de dizer processo,
vamos dizer thread e
vamos substituir o multiprocessamento pelo módulo de
threading que temos Então, o que vamos
fazer é substituir a classe de processo por uma classe
de encadeamento. Nessa linha de código,
faremos a mesma coisa, mas criaremos
um novo encadeamento que
executa a função de trabalho
como fizemos antes. Então, em vez de
iniciar o processo, vamos iniciar o tópico. Vamos dizer que leia
amido aqui no final, também
vamos até uma cerca viva e diremos shred dot join Podemos simplesmente alterar aqui o
texto para dizer que o tópico começou. E o tópico terminou. Ok, então esses são os
ajustes que temos aqui, e podemos simplesmente remover
o que temos aqui. Tudo bem E resolvemos
isso agora. Então, temos tudo como está. Agora, não há
muita diferença aqui, então com thread dot start, só para reiterar, ele
iniciará o tópico Vai ser executado
em segundo plano. E com thread dot join
aqui, ok, basicamente, vamos esperar que
o thread termine antes continuarmos com
o resto do nosso código. Ok. Agora, outra
coisa que eu também quero mencionar
aqui é um pouco mais detalhadamente com essas mensagens
dot start e dot Join. Agora, é muito
importante que esteja no
lugar certo, porque se não
especificarmos o ponto Start, o encadeamento começará a ser executado. Se não tivermos a junção de pontos
, o programa
será encerrado
antes que o thread
conclua sua tarefa Esses são os
motivos pelos quais precisamos dele neste caso de uso específico. Ok. E o que podemos fazer
agora é entrar em um hedge executar o código
e ver a saída
à medida que ela avança Tudo bem Então, vamos executar isso
e
ver o que ocorre. Agora, eu quero fazer
isso um pouco mais longo, então vou definir
isso para 30 segundos. Vou executar
o código. Verifique. Como você pode ver, temos apenas
um processo em execução aqui. Essa é uma boa indicação que estamos usando a
trituração, porque lembre-se de que, na aula
teórica, eu disse que, quando você trabalha com vários encadeamentos do
ShreadInGo,
como resultado, haverá
apenas um processo e esses encadeamentos compartilharão um processo Embora tenhamos
dois tópicos aqui, eu tenho um que definimos com nossa função e
nosso script padrão um com todos os scripts do Python em si,
será incluído como Essa é a
razão disso. Vá em frente e corra
, é por isso que o temos. Podemos ver, é claro, que também
temos alguma memória
aqui em termos de 3,9 megabytes e
podemos ver que ela não é muito
pesada na CPU, no disco ou na rede, como neste momento com esse
processo específico Como você pode ver, é assim
que coisas
estão
acontecendo, uma vez que temos apenas um
processo para compartilhar memória com
o processo principal que isso seja eficiente. A razão pela qual substituímos apenas
um processo é o
fato de Pison estar usando o gel,
o GIL que mencionei antes Esse é o bloqueio global do
intérprete. Isso garantirá
que apenas um thread seja executado por vez em um único processo
PySON Embora tenhamos
vários tópicos aqui, temos dois deles,
eles não aparecerão como um processo separado
no gerenciador de tarefas. Como você viu nesse processo, eles compartilharão o
mesmo espaço de memória e trabalharão no mesmo processo PySon É assim que também podemos diferenciar a diferença entre nossos encadeamentos e nossos processos com processamento múltiplo
e processamento múltiplo Tudo bem O que queremos
fazer agora é limpar nossos recursos para que possamos destacar todo o
código aqui e excluí-lo. O que também podemos
fazer é simplesmente excluir todos os outros arquivos que temos,
exceto a torta de pontos principal, que
possamos prosseguir e
limpá-los. Ok. E o último. Lá vamos nós. Até
termos o doppie principal Então, se você tiver mais alguma coisa,
vá em frente e limpe-a. curso Enquanto isso, estamos apenas realizando
uma espécie
de limpeza de recursos
do Há mais por vir,
mas só queremos limpar tudo o que temos aqui. Tudo bem, então é isso.
100. Testes unitários: Oi, todo mundo. Bem-vindo
à próxima lição, que será
focada em testes unitários. Vamos dar uma olhada. Testes unitários. Em Python, o teste unitário
envolve testar componentes
individuais do código para verificar se eles
funcionam conforme Agora, uma unidade
normalmente é uma função ou método que executa
uma tarefa específica. E a próxima pergunta que provavelmente
estamos nos perguntando é: por que você deveria realizar
esses testes unitários? Então, eu tenho alguns motivos pelos quais devemos
fazer isso, e eles incluem detectar
bugs cedo para melhorar legibilidade
do código
e também para tornar as alterações no
código muito mais seguras, pessoal Então, essa é apenas uma visão geral teórica em termos de
testes unitários, testes unitários. E agora, nas dicas
práticas de laboratório que surgirão, vamos nos
aprofundar em como podemos
realmente aplicar isso
101. Realize testes de unidade padrão - [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de
laboratório, que será
focado em testes unitários. Agora, a primeira coisa que
vamos fazer antes aprofundarmos
demais no
teste unitário é criar um teste unitário muito padrão só para ver como o
processo funciona, certo? Tudo bem. Agora, a
primeira coisa que você quer fazer é importar o módulo de teste unitário, que é um módulo
incorporado usado para testes. Em seguida, queremos definir a
função que queremos testar. Essa função será uma função de adição simples
para adicionar dois números. Ele receberá dois parâmetros e retornará A mais B depois de ser chamado. Agora, essa função
adicionará dois números e retornará a
soma de A e B. Queremos testar essa função. Agora, para fazer isso, o que
precisaríamos
fazer é criar uma
classe de teste para testes unitários. Podemos dizer aula, teste. Missa. Agora, toda
caixa de xadrez deve ser herdada da caixa
de xadrez de teste unitário Para fazer isso,
precisaríamos seguir em frente e passar pela unidade baú, ponto e estojo. Essa é essencialmente uma
classe pyson embutida que utilizaríamos Isso será essencialmente herdado do caso de
teste de unidade Agora temos isso em vigor. A próxima coisa que
precisamos fazer é definir um método de teste agora. Nesta classe,
precisamos dizer
surdo e podemos dizer peito, sublinhado Agora, algo que você
precisa ter em mente aqui com o
sublinhado de suas mensagens de teste precisa ser sempre a primeira parte
da declaração aqui está sua função
em todos os momentos O que você veste depois
, depende realmente de você
o que você quer fazer. Vamos
passar por nós mesmos. Agora, esse será um método de
teste que verificará se a função de adição está funcionando corretamente e se
o nome da função, como mencionei, precisa
começar com peito e sublinhado para que nosso teste unitário
a reconheça como um baú Essa é a razão pela qual
precisamos adicioná-lo dessa forma. Temos self novamente aqui porque
isso representará
a instância da nossa classe de caso de
teste e dará acesso a todos os métodos fornecidos
pela classe de teste que
estamos herdando aqui A próxima coisa que
queremos fazer é definir nosso método aqui
dizendo self dot,
e vamos
usar um método especial
conhecido como assert equal,
e vamos
passar pela função,
que será chamada
add, que vamos reproduzir
aqui dois e
três como amostra,
e então queremos ter cinco. definir nosso método aqui
dizendo self dot, e vamos
usar um método especial conhecido como assert equal, e vamos
passar pela função, que será chamada
add, que vamos reproduzir aqui dois e
três como amostra, e então queremos ter cinco Então, o que vamos colocar aqui entre parênteses será o que realmente
queremos esperar, e do lado de fora será
o resultado real OK. Portanto, o método self assert
equal verificará o resultado
esperado e o real para verificar se os
valores são iguais Neste caso aqui, com o que está sendo esperado,
temos dois e três, por exemplo, e dois
mais três é
igual a cinco, e o real será cinco. Isso é
o que deveria ser. OK. Agora, se às duas e três, retorna cinco, então
o baú passa. Se retornar outra coisa
, o baú falhará. OK. Tudo bem. Então, vamos seguir em
frente e continuar. Então, temos essa configuração. Agora, a próxima coisa que precisamos fazer é aqui
no lado esquerdo, queremos seguir em frente
e jogar o xadrez. Então, para fazer isso, precisamos
garantir que o script executado somente quando o tivermos
executado diretamente. Então, para fazer isso, vamos
dizer que eu sublinho o nome. A pontuação é igual a, no sublinhado duplo principal OK Agora, o que estamos fazendo
aqui é verificar se havia essa linha aqui, basicamente vamos
verificar se estamos utilizando
esse script Pierson, e não é um módulo ou qualquer coisa que estamos importando,
nada parecido, e é visto como uma condição especial que
normalmente utilizamos E é algo
que também utilizamos com processamento e segmentação se também estivermos lidando com processamento
múltiplo e
segmentação Isso garantirá
que o teste de unidade principal seja executado somente quando o script for executado diretamente,
como mencionei antes, e é por isso que precisamos fazer isso. Agora, o
que podemos fazer depois disso é definir o teste unitário, e precisamos nos
referir a ele como principal aqui, e essa será uma função
incorporada
que precisaremos usar e que encontrará todos os métodos de teste que
definimos. Ele os executará
um por um e
procurará
especificamente a mensagem de teste que começa com peito
e sublinhado Em seguida, ele
relatará quais testes foram aprovados e quais falharam. Essa mensagem principal que estamos
adicionando ao teste unitário é apenas um método simples
do
módulo de teste unitário que temos aqui que inicia
o executor do teste Então, isso é essencialmente
o que está acontecendo aqui. Então, podemos apenas diminuir
o zoom para que possamos ver o código completo e
salvar esse arquivo. Vamos em frente e executá-lo. Aqui podemos ver que temos o ponto, as linhas e fizemos um teste, e eu vou mover isso para
cima, e ele diz: Ok, então vamos debugar
como isso está realmente funcionando Então, o que temos aqui é um ponto e o ponto significa
que o baú foi passado Executou um teste aqui, significa que um
caso de teste foi executado. Então, testamos essa mensagem simples aqui
sobre matemática. Então OK, aqui significa que todas as
afirmações foram bem-sucedidas. Temos uma afirmação
aqui, por exemplo, e isso prova
que foi um sucesso Tudo bem, então essa é a maneira mais simples de você entrar em um hedge e executar seus
testes em Python Então, vamos fazer mais
alguns exemplos. Então, vamos seguir em frente
e fazer exatamente isso. Precisaremos
ter certeza de que
utilizamos o módulo de teste unitário,
então vamos
continuar utilizamos o módulo de teste unitário, . Tudo bem. Então, o que vamos fazer agora é testar uma função para verificar se um número é par.
Vamos seguir em frente e fazer isso. Eu vou dizer que D
é até mesmo sublinhado. Vamos passar pelo
parâmetro numérico e queremos retornar verdadeiro se
o número for par,
caso contrário, falso. Vamos dizer o número de
retorno
e, no módulo dois, o dobro é igual Os números pares não têm resto quando são divididos por dois Isso é essencialmente
o que está acontecendo aqui para verificar se há um número par. Vamos fazer nossas caixas de xadrez. Novamente, precisamos definir
uma classe e
vamos chamar esse
teste de números pares. Precisamos passar pelo teste
unitário Dot Test K precisamos passar por
essa classe a partir do módulo. Isso criará
uma classe de caso de teste. Então, precisamos definir
nossos casos de xadrez. Aqui eu vou
dizer surdo, peito, sublinhado par, sublinhado número,
e aqui vamos dizer eu mesmo e aqui vamos E então precisamos
adicionar nossas afirmações. Vou dizer self jot assert true, e aqui vamos
passar por nossa função, que será
seu sublinhado par, e diremos quatro, Então, queremos
testar um número
ímpar para ver se ele falha,
então ele deve falhar Você pode dizer de, testar
sublinhado, número ímpar
e, em seguida,
passaremos E vamos dizer que você
mesmo faz uma busca. É verdade, e vamos
sublinhar até mesmo
a função e cinco Então vamos dizer
que o teste sublinhou zero. Por meio de self, podemos
dizer self dot search. Verdadeiro. E então queremos verificar a função se
passarmos por zero. Então, o que fazemos acordo com o classificador
que definimos executar o teste quando
o script é executado, para possamos dizer que I double
underscore name,
double underscore, é
igual Então, estamos utilizando esse script
específico. Em seguida, podemos executar o teste unitário. Ponto principal, e isso
executará tudo o que tem o início do peito
sublinhado como apêndice da mensagem em Como podemos ver aqui,
ao passar em quatro, obteremos um passe
por satélite adicionando cinco, o que é estranho, obteremos
um baú que falhou
e, ao passar em zero, que será par, também
receberemos um passe Temos tudo isso
pronto aqui. Vamos seguir em frente e executar nosso código. Tudo bem, então temos uma variedade. Agora, vamos analisar a saída. Então, chegamos aqui ponto F. Então, esse F
indicará falha no teste. OK. E isso significa que
o primeiro baú foi aprovado, o segundo teste foi reprovado e o terceiro baú foi aprovado. Então é assim que você
pode analisá-lo. E podemos ver
aqui qual
foi a falha e testar o número ímpar, podemos ver aqui que falhou
porque passamos por cinco aqui O que você pode ver aqui falhará porque quando passarmos cinco e verificarmos
se é um número par, ele essencialmente
não será executado corretamente e gerará um erro de rastreamento,
como podemos ver aqui, podemos ver que o
erro de sessão false não é verdadeiro. Fizemos três testes. Tivemos uma falha, e essa foi a segunda. Você pode ver que é muito bom aqui. Isso mostra que
falhamos aqui ao inserir F, mas também mostra por
posição qual O ponto é um, F é o segundo
e o terceiro é passado. Rapazes. É assim que
também podemos utilizar nossos casos de teste para que possamos fazer uma cobertura e verificar se há aprovações e reprovações
em termos de nossos testes É assim que podemos implementar o
teste unitário básico em Python Você pode aplicar isso às suas
funções, por exemplo, se quiser conferir
seu código e ver se tudo funciona e se
funciona conforme o esperado. Por exemplo, nesse caso de uso
específico, se você estiver configurando
a funcionalidade para testar em algo uniforme, é muito útil
adicionar casos de teste aqui, pois estamos fazendo aqui para provar o fato de que ele está
fazendo o que deveria fazer. É aqui que
entra o valor com o teste unitário. Certo, então podemos ir em frente e fechar a palha e aí
está o teste unitário
102. Ambientes virtuais: Oi, pessoal. Bem-vindo
à próxima lição, que será focada no ambiente
virtual.
Vamos dar uma olhada. Certo, um ambiente virtual, você provavelmente está se perguntando o que
é um ambiente virtual. Simplificando, um
ambiente virtual é um espaço de trabalho
ou ambiente Python isolado que permite instalar e
gerenciar seus pacotes ou dependências separadamente Agora, isso garante que seus diferentes projetos
não interfiram
uns nos outros em
termos de pacotes nem causem conflitos. Isso é tudo que eu quero mencionar
sobre ambientes virtuais. É um processo bastante
simples, então vamos nos
aprofundar exercícios práticos de laboratório, então fique ligado
103. Criando um ambiente virtual — [Lab]: Olá a todos, bem-vindos
ao próximo exercício prático de laboratório, que será focado no trabalho com ambientes
virtuais. Agora, o ambiente virtual é muito útil porque, é claro, você aprende boas práticas
paralisando todos os seus pacotes em
um ambiente virtual em vez de instalá-los
globalmente em seu sistema Isso realmente ajuda a
garantir que cada um de seus projetos tenha seu
próprio ambiente virtual com seus próprios pacotes
e dependências Isso só ajuda a manter as coisas fluidas, precisas
e funcionais. Vou mostrar como
você pode criar seu ambiente virtual, como ativá-lo e também como desativá-lo Eu vou te mostrar
tanto para Windows quanto para MCO Linux. Eu recomendo que você me assista primeiro antes de
acompanhar diretamente, porque vou demonstrar
como você pode configurá-lo para os dois dispositivos.
Vamos começar. Agora, a primeira coisa
que quero mencionar é que você precisa mudar
agora para executar um PysonFle Você pode clicar na
seta suspensa, dizer Executar PysonFL e você pode simplesmente limpar E a primeira coisa que
queremos fazer é entender o conceito de pacotes
globalmente em nosso sistema. Quando digitamos a Lista PIP, isso listará
todos os pacotes que instalamos via PIP Por exemplo, quando instalamos
o loama, o
PWGen ou o Emoji ou todos
os pacotes que
foram instalados na
lição de os pacotes que
foram instalados na pacotes relevantes. Tudo isso
aparecerá globalmente em nosso sistema quando
digitarmos a lista PIP. Você verá uma lista de todos os pacotes que você instalou. Aqui, por exemplo,
eu posso ver Colorama, Emoji, eu posso ver Num Pi, eu posso ver PEP, eu
posso ver P no WGN, tudo
isso foi instalado
globalmente Agora, o PEP em si, é claro, é algo que precisa
ser instalado globalmente, mas todo o resto, você pode ver, é
que está em todo lugar Queremos que ele seja
instalado apenas em um ambiente
virtual, não globalmente, como vemos aqui. Então, para fazer isso, podemos criar um ambiente virtual
para resolver isso. Certo. Então, novamente, como eu disse, observe o que eu faço
antes de você fazer isso. Vou mostrar primeiro o caminho do
Windows
e, para criar um
ambiente virtual para Windows, você digitaria seu
terminal, Python, VNV Isso significa que queremos criar um ambiente virtual para o ENV O nome do seu ambiente
virtual, você pode dar a ele qualquer nome agora, mas eu também vou chamá-lo VENV e você pode pressionar Enter, e isso criará seu
ambiente virtual para você Você só precisa ser paciente
e, uma vez criado, ele deve recuar em uma nova linha Vamos esperar
por esse processo. Depois,
mostrarei o comando para instalá-lo
no macOS ou Linux. Sejamos pacientes.
Tudo bem, muito bem. Então, podemos ver que
foi um sucesso e inventamos uma nova linha. Isso significa que nosso
ambiente virtual foi criado. Agora, o que você
também pode fazer é ir em frente e verificar seu diretório
no Explorer e você pode ver que agora temos essa pasta de Ambiente
Virtual aqui dentro do meu projeto, para que você possa ver que ela está
situada aqui. E todos os nossos
pacotes a partir de agora, uma vez ativados,
nosso ambiente virtual será armazenado aqui. E isso também vai aparecer
mesmo se você estiver no macOS. Para que o macOS crie um ambiente
virtual, você deve
digitar PySon three M, VNV VENV exatamente como Você só quer
adicionar PySon três. Essa é a diferença de configurá-lo em
um dispositivo Macaws Você pode seguir em frente e fazer
isso se estiver no MacComs. Certo. Vamos esclarecer isso. Agora queremos ativar
nosso ambiente virtual. No Windows, você se referiria
ao nome do seu
ambiente virtual na
segunda opção. Eu tinha o VE NV, então
podemos dizer barra invertida,
scripts, barra invertida ativada e isso Agora você pode ver no
lado esquerdo o nome que você deu ao seu ambiente virtual entre parênteses aqui e podemos ver que é bonito e verde no nosso caso Portanto, você deve sempre
executar seus programas agora. ativar
seu ambiente virtual, Depois de ativar
seu ambiente virtual, você pode executar a instalação do Pip ou seguir em frente
e executar o PysonFle Então, digamos que o Python main dot pie, neste caso, você
deve sempre fazer isso dentro do seu ambiente virtual Ok, agora, se você quiser
ativá-lo em um dispositivo macOS, o que você vai
fazer é
dizer Source VE NV, pino de barra para dizer Source VE NV, frente e
para frente Ativar Este é o comando,
você precisa
ativá-lo no seu dispositivo macOS Fonte VNV para frente, pino, barra para
frente, Ativar.
Isso é macOS Certo. Já temos isso
pronto e
está claro. Se você quiser desativar seu ambiente virtual
para
desativá-lo, será o mesmo
no Windows e no macOS, então você só precisa dizer que
desativar isso funcionará para ambos e você
verá que estará fora dele e agora ele Certo. Então, outra distinção que
quero mencionar é se ativamos nosso
ambiente virtual, então ele é ativado. E digamos que eu
diga a lista de PIP agora, você verá no ambiente do seu ambiente virtual que só
temos o PIP,
que é, obviamente, o pacote geral que estará em seu ambiente
virtual,
mas não temos
esses outros pacotes
que você vê globalmente,
como mostrei anteriormente,
e isso porque
não está dentro mas não temos
esses outros pacotes que você vê globalmente, como mostrei anteriormente, do ambiente virtual. E é por isso que e
como mencionei, tudo
precisa ser separado em um ambiente virtual
para seu projeto e não globalmente
em sua máquina. Então você pode ver aqui
a diferença. OK. Podemos dizer claramente agora. Tudo bem, então vamos
lá. É assim que você deve sempre instalar seus
pacotes e bibliotecas. Por exemplo, se eu quiser utilizar o
pacote Colama, posso copiar match Então, Pep, instale o
Clarama. Tudo bem. Você pode ver que está sendo
instalado e aí está. Então, vamos verificar
onde ele está instalado. Então, se eu disser Pip LLS, agora
podemos ver que o
instalamos em nosso ambiente
virtual Então aqui está Clarama. Perfeito. Então, agora
podemos esclarecer isso. E agora o que queremos
fazer é seguir em frente e pegar os módulos
Colama Eu vou dizer do mapa de cores. Quer importar as quatro classes. Então eu vou dizer imprimir, e eu vou dizer que eu
quero separar as quatro cores,
quatro pontos e vermelho
sendo o atributo Eu quero que isso seja definido como vermelho. Eu vou dizer que
isso são cheques vermelhos. Eu serei minha saída e a cor
do meu terminal também seguirá. Então, aqui no ambiente
virtual, posso simplesmente dizer
Pison main dot pi Você pode ver que funciona
perfeitamente bem. Tudo bem. Aí está. E
podemos dizer com clareza. Podemos simplesmente repetir
isso e dizer branco. Isso nos dará um padrão. E lá vamos nós. Tudo bem, então é assim que devemos,
para obter as melhores práticas, utilizar o PySon utilizando um ambiente
virtual ao instalar
todos os nossos pacotes Portanto, observe que, novamente,
mencionarei
que , quando você utiliza MacAWS, há uma pequena
diferença na forma como você ativa e cria
seu ambiente virtual, mas todo o resto funcionará exatamente como deveria,
especialmente com
a desativação do virtual Tudo bem, pessoal. Então é assim que podemos trabalhar com nossos ambientes
virtuais. E quando terminar,
você pode simplesmente desativar. Mas lembre-se: sempre use
as melhores práticas para ativá-lo
e, a
partir daí, utilizá-lo. Tudo bem, pessoal. Então é isso. Isso tudo é para ambientes
virtuais.
104. Criar seu próprio projeto: Oi, todo mundo. Bem-vindo à próxima mensagem
, que será focada na criação de nossos próprios
projetos. Vamos dar uma olhada. Muito.
Chegou a hora e agora que você adquiriu todas
essas novas habilidades, é hora de
colocar tudo isso uso e criar seu
próprio projeto. A próxima coisa que você precisa
fazer é acessar
a seção de projetos e
recursos
deste curso para obter
mais informações Lá, vou detalhar e delinear algumas ideias que
você pode criar para o seu projeto e também dar algumas sugestões sobre
como você pode realizar o processo de criação
do projeto Oh, isso é tudo que vou
dizer por enquanto e boa sorte. E estou ansioso para
ver seus projetos.
105. Obrigada!: Oi, todo mundo. E bem-vindo à lição final
deste curso, onde eu só quero agradecer por decidir concluir
este curso Foi um prazer
ensinar você e espero que você tenha obtido algum conhecimento valioso com isso. Então, muito
obrigado. Se você tiver algum tempo, eu
agradeceria muito se você considerasse deixar um comentário. Como melhorar meus cursos e fazer o melhor que posso
é sempre positivo que
você tenha algum tempo, eu agradeceria
muito isso. Caso contrário,
tudo bem, desde que você tenha uma ótima experiência de
aprendizado, e pronto para
mim e boa sorte em sua jornada de desenvolvimento,
e desejo a você tudo de bom. Adeus e obrigado novamente.