Transcrições
1. Apresentação: Bem-vindo a esta introdução
à programação em Python. Meu nome é Fernando Ortega. Sou diretor técnico
na indústria de animação e
efeitos visuais, além de ex-animador 3D. Neste curso, vou te
ensinar o básico da codificação em Python
criando uma série de diversão. Você mencionou ferramentas
dentro do Maya. Mas mesmo que os
projetos que
criaremos estejam focados em
animação no Maya, nas habilidades que você aprenderá, nossas habilidades de programação que são altamente aplicáveis
a outros departamentos, outros softwares e até mesmo
outras linguagens de programação. Ao final deste curso, você terá as habilidades
e a capacidade de criar suas próprias ferramentas e tornar seu próprio fluxo de trabalho
muito mais eficiente. Obrigado por se juntar a
nós. Vamos começar.
2. Visão geral do editor de script: Vamos nos familiarizar com o editor de
scripts do Maya. Primeiro, como podemos encontrá-lo? A propósito, este é meu anúncio de 2020. Mas o que vou
mostrar é praticamente o mesmo em
todas as minhas aversões. Para abrir o editor de scripts, podemos fazer isso por meio desse botão no canto
inferior direito ou no menu do Windows. Editores gerais e
raspeie-o ou qual é esse erro descritivo é ferramenta do
Maya para
escrever, executar. Ou estou mostrando a
saída do código que você escreve ou codifica ou comandos que estão sendo executados quando
você está usando o Maya. Portanto, há duas partes principais nisso. A primeira é
a janela Script, que é essa
aqui embaixo onde está meu cursor. É aqui que você escreve o número
do código aqui. Essa é a
janela de saída que
mostrará o resultado desse código. Então, vamos escrever algo. Vamos fazer um pouco de matemática. Dois mais dois,
algo muito simples. Agora isso é um pouco pequeno. Podemos pressionar a tecla
Control a roda e a massa para torná-la
um pouco maior É o mesmo
que aparece
na janela de saída que
mostrarei em um segundo. Então, para executar seu código, digamos que queremos fazer
essa parte da matemática aqui. Há algumas opções, algumas maneiras de executar o código. Uma delas é por meio
desse botão Play. É chamado de executar. Agora você vê, mais uma vez, vou tornar isso um
pouco maior com a tecla Control, o mouse
e a roda do mouse. Você verá que o
Maya sempre mostra o código que você executa. E então o resultado
desse código. Isso pode ser um
pouco confuso no começo, mas você se
acostumará rapidamente. Então você percebe que seu
código desapareceu aqui embaixo. Se isso acontecer com
você, não se preocupe, basta pressionar Control Z ou
Control Z para recuperá-lo. Agora, a maneira mais fácil evitar isso é apenas
destacar seu código. Eu costumo usar as teclas
de atalho Control a para selecionar tudo e depois clicar no
botão Executar. Para executar sem
clicar nesse botão. Você pode usar a tecla Enter
no teclado numérico ou clicar em Controlar e Enter.
Essa combinação de teclas executará esse código. Outra forma de executar o
código sem que nenhum desapareça é por meio
do botão Double Play. Parece jogar ícones. Ele fará o mesmo, mas
não removerá seu código. Dito isso,
como você geralmente está com as mãos no teclado, acho fácil pressionar
Control a Control
Enter para executar o código. Agora, já que estamos destacando, deixe-me escrever outra
linha de código aqui. Só mais uma peça de matemática. Quando Maya, você pode executar
tudo, como você pode ver. Mais uma vez, ele me deu o
decodificador e corri até aqui. E então o resultado
para cada código de linha. Mas você também pode simplesmente
destacar uma única linha, por exemplo, aqui, Control Enter
para executar essa linha. E está apenas
executando essa linha. Portanto, a janela de saída,
como você está vendo, mostra o código
que você está executando, mas também mostra o que
está acontecendo dentro
do Maya. Então, por exemplo se eu fosse criar um cubo
e depois selecionar o cubo, por exemplo ,
você verá que tudo o que
estou fazendo
está sendo exibido
nesta janela de saída.
O que é ótimo. É uma forma de
descobrir os comandos que o Maya precisa para
criar um cubo,
por exemplo, em algum momento, essa janela de saída
ficará um
pouco confusa. Como você pode ver. Limpe isso com este botão
aqui, limpe o histórico. E antes de seguirmos em frente, quero te mostrar isso. Como eu disse, o que você
faz dentro do Maya está
sendo exibido aqui, mas nem tudo
está sendo mostrado. Por exemplo, se eu mudar meu
modo de sombreamento por meio deste menu aqui, você verá que ele
muda na tela. Eu faço isso de novo. Mudanças na janela de exibição, desculpe. Mas isso realmente não
te diz o que aconteceu. Existe uma maneira de mostrar mais
informações do Maya. É chamado de Echo all commands. É esse botão aqui. E o que isso fará é mostrar ainda mais coisas que podem
se tornar um pouco prolixo. Como você pode ver, tudo o que estou fazendo está sendo exibido aqui. Pode ser um pouco
prolixo, como eu disse, mas às vezes é útil saber o que está acontecendo
dentro do capô. Então, eu vou
desligá-lo por enquanto. Limpe minha janela de saída
novamente com este botão. Aqui embaixo, você provavelmente
notou essas guias, são guias MEL. Mais uma vez, estamos nos
concentrando em Python. Então, vamos nos
ater à guia Python. Você pode criar novas guias
com esse botão de adição aqui. Vamos criar outra guia em Python. Vamos apenas pulverizar uma função. Se você não sabe
o que é uma função, não se preocupe, abordaremos
isso em breve. Então, vamos tornar isso um
pouco maior novamente. Você pode ver que meus presentes você colore para coisas diferentes. Por exemplo, isso é amarelo, isso é uma string,
isso é um comentário. Isso é chamado de destaque de
sintaxe. Esta é minha maneira S de
ajudá-lo a ler seu código um pouco melhor,
o que é muito bom. Então, temos essa guia. Essa é uma ótima maneira de
organizar seu código. E você pode nomear essas etapas no
menu de comando. Você pode renomear essa guia. Vamos chamar essa guia de
número dois, por exemplo, vamos chamá-la de
guia número um. Agora você pode reconhecer
facilmente o que cada guia tem. E você também pode excluir o tipo que as
guias usam aqui. E o que é realmente bom
nisso é que quando você fecha o Maya
e o abre novamente, ele se lembra das guias e do código que você tinha nele. Então você não perde nada disso. Às vezes você faz, mas geralmente
não? Normalmente meu sim. Muito bom em guardar
esse código para você. A última coisa que
quero mostrar é como colocar código em uma prateleira. Então, por exemplo, eu sei que para criar um cubo, tive que usar esse comando. Nós nos familiarizaremos com
esses comandos muito em breve. Isso é só para,
estamos no exemplo. Então eu sei que, hum, que se eu executar esse
comando mais uma vez, eu estou pressionando Control a e Enter ou Control Enter
para executar o código. Estou criando esses cubos. Isso é ótimo. E se eu quisesse
colocar isso em uma prateleira? Você pode destacar seu código, clicar nele e simplesmente
arrastá-lo para a prateleira. E o Maya lhe dará essa
opção de criar um botão. Vamos clicar
na opção Python. Quando clicarmos no botão, ele criará o cubo para nós. Isso é ótimo. Então, se quando formos
editar esse botão, você vê que seu código está aqui e
no modo Python. E também não se esqueça de guardar suas prateleiras toda vez que
fizer uma troca na prateleira. Hum, e isso é que geralmente há muito mais opções. Como você pode ver, há
muitos outros botões, há muitos outros menus aqui. Há muitas coisas que
você pode fazer em qualquer roteiro ou o que eu mostrei
será o que você precisará. 95, 99% do tempo. Se você está fazendo
um script simples ou mais complexo,
digamos, desenvolvimento. Essas são as principais opções de
que você precisará. Então, vamos escrever
seu primeiro trecho de código.
3. Seu primeiro programa em Python: Hello Maya: Ok, vamos criar seu
primeiro programa em Python. Então, uma das primeiras
coisas que podemos fazer, uma das
coisas mais simples que podemos fazer é exibir algo também
conhecido como corrida. Então digite comigo, imprima
parênteses
abertos, abra uma aspa e vamos escrever nossa mensagem. Olá, mundo. Agora fechando as aspas
e fechando os parênteses. Agora vamos executar esse código. Mais uma vez, eu
posso, vou pressionar Control
a para destacar tudo. E eu vou clicar no
botão Executar. E, como mencionei antes, o Maya imprimirá ou produzirá o código
que você está executando. E então os resultados reais
ou a saída desse código. E, a propósito, se a
fonte for muito pequena, lembre-se de que você pode
clicar na tecla Control e na roda do mouse para
torná-la menor ou maior. Então, vamos
detalhar isso um pouco. Primeiro, temos as declarações
impressas. Agora. Você me ouvirá dizer
declarações e funções. Eles significam coisas diferentes. Mas, por enquanto, vamos pensar
em uma impressão como uma função. Essa é uma palavra especial em
Python que simplesmente
exibirá algo no console ou na janela de saída aqui em cima. Em seguida, o parêntese, usamos um parêntese para
executar algo, chamar funções para ação
ou executar funções. Portanto, lembre-se sempre de abrir
e fechar parênteses. E depois no meio
aqui em amarelo. E lembre-se de que o
Maya destacará coisas para você, a fim de
facilitar sua fala saber rapidamente
o que está em seu código. Isso é uma corda. Uma string é basicamente um pedaço
de texto sob o capô. É um pouco
mais complicado do que apenas um pedaço de texto. Mas você pode pensar nisso
apenas como uma sequência de caracteres. Pode ser uma sequência,
desculpe, uma frase. Pode ser uma ala ou um símbolo, ou um único caractere, de um
único dígito. Nesse caso. Uma string sempre será criada ou criada
usando aspas. Você pode usar aspas
simples ou duplas. Não importa, desde que você use o mesmo tipo no
início e no final. Há outro tipo especial de string que usa três
aspas. Mas vamos reservar isso para documentação e
falaremos sobre isso mais tarde. Portanto, se você já fez isso antes, pode ter visto a impressão feita sem parênteses. Então, vamos experimentar isso.
Vou clicar em Controlar a. E agora, desta vez,
vou clicar em Controlar Enter para
executar meu código. Portanto, é o mesmo resultado. Então, o que está acontecendo aqui? O que está acontecendo é que
as inversões de impressão para o Maya 2020, que é o que estamos usando aqui. O Maya usa uma versão do
Python que é 2.7. E nessa versão do Python, print é um tipo especial de
função chamada declarações que você pode usar com ou sem
parênteses, nesse caso. Agora, começando no Maya 2022, que é a próxima versão, porque a Autodesk
decidiu pular Tony, Tony One, começando com
meu advogado, 22 Python. A versão do Python
será Python três. E nesse caso, impressão só poderá
ser executada com parênteses. É por isso que você me
verá usando parênteses. Nossa convenção. Acho que é um bom hábito. Mas saiba que, para a versão mais
atual do Maya, você terá a opção de
fazer isso com ou sem ele. Desde que você deixe
um espaço entre a declaração de impressão
e a string. Agora, deixe-me esclarecer. A diferença
entre declarações e funções é um pouco técnica e você realmente não
precisa se preocupar com isso. Neste momento. Você não precisa se preocupar com isso, então não
pense muito nessa distinção. Então, vamos tornar isso um
pouco melhor. Vamos armazenar isso
dentro de uma variável. Então, vamos abrir algum espaço aqui. Agora, variáveis, vou
chamar essa variável de minha mensagem. As variáveis são contêineres de valor e
o nome da variável depende de você. Você pode nomear suas
variáveis como
quiser atribuir valor a elas, por meio do sinal de igual,
sinal de igual único. E então eu vou atribuir essa string que temos aqui. Então HelloWorld em uma variável
chamada por mensagem. E agora, em vez de imprimir
essa string diretamente, vou imprimir minha forma controlada por variáveis
para destacar tudo, Control Enter para executar. E aí está. Então, o que está acontecendo aqui? Mais uma vez, como eu disse, uma variável é um
contêiner de valor, o que significa que você pode atribuir qualquer valor que quiser,
desde que seja válido para Python, é
claro, a qualquer
variável que você quiser. Então, por exemplo,
o valor dez , o número dez, que funciona, você pode atribuir o
resultado de algo. Então, vamos fazer um
pouco de matemática novamente. Três mais três. Seis, aí está. Agora, por que estou usando
um sublinhado? Essa é simplesmente uma
convenção que eu gosto de
usar , chamada de invólucro Snake. Quando você separa palavras
usando sublinhados. Algumas pessoas gostam de
usar invólucro de camelo, o que significa que usam uma letra maiúscula
para separar as palavras, qual delas usar. Isso não importa. Depende de você ou da equipe com a qual
você está trabalhando. Eu costumo usar isso e
me limito a isso. Eu diria que há apenas
duas regras sobre variáveis. Uma delas é que
elas deveriam fazer sentido. O que quero dizer com isso? Quero dizer que você poderia
nomear sua variável x. E o Python não se importa. Ainda funcionará da
mesma forma. Mas quando você
voltar ao seu código, digamos que daqui a seis meses, x não fará
muito sentido para você. Mas vou nomear uma variável
como minha mensagem, por exemplo faremos um
pouco mais de sentido ou algo assim se você a chamar
apenas de MSG, mesmo que seja um nome
melhor do que x ou simplesmente mensagem. E a outra regra é manter sua
nomenclatura consistente. Por exemplo, se você tiver isso, desculpe, devido ao erro de digitação, você está
misturando convenções. Você está usando
sublinhado aqui em diante, você está usando
letras maiúsculas aqui. Isso não é um
problema para o Python, mas é uma boa prática para
manter seu código limpo e legível
para seguir as mesmas convenções
que você estabeleceu. Mas falaremos sobre
isso um pouco mais tarde. Então isso é ótimo, mas não é muito empolgante. Tudo o que estamos fazendo é imprimir. Mesmo que
a impressão seja muito poderosa e você a use
muito quando estiver codificando. Mas agora, agora que
estou respondendo aos nossos
comandos de certa forma, vamos aproveitar isso. Vamos usar meu um
pouco mais diretamente. Então, vou digitar do
Maya Important CMBS. Falaremos sobre
isso um pouco mais detalhadamente
nas próximas lições. Mas saiba que essa
é a biblioteca CMBS, também
conhecida como biblioteca
de comandos
ou biblioteca de comandos do Maya. E o que isso faz é nos dar
acesso a muitos comandos
que o Maya entenderá. Um deles é chamado
de mensagem de visualização. Agora observe que meu outro parafuso datou ou apenas
os destacou em azul. E há uma
renderização bonita
e metálica na fonte. Isso porque o Maya
o reconhece como um comando que está disponível
na biblioteca de comandos. Então, esse comando
também é conhecido como função, e eu o chamarei de
função porque esse é o termo adequado
em, em Python. Então, isso é uma função. E observe que estamos
usando essa notação de pontos. Veremos isso com mais detalhes,
como já mencionei. Mas a explicação simples
é que estamos acessando essa função dessa biblioteca que estamos importando aqui. Portanto, a biblioteca Commands
tem essa função e
acessamos as funções a partir dela
por meio da notação de pontos. Agora, usamos os parênteses
para chamar essa função. E as funções podem,
e geralmente
têm, opções especiais que podemos usar para modificar a
saída da função. E essas opções são
chamadas de argumentos. Nesse caso, essa função tem um argumento chamado mensagem de
assistência. Agora, eu sei que eu disse que
você deve manter as coisas consistentes quando se
trata de nomear suas variáveis. E você está dizendo que isso tem invólucro de
camelo ou letras
maiúsculas. Isso porque Maya decidiu
que essa é a convenção dos maias. Você pode se limitar a isso, se
quiser, ou criar o seu próprio. Mas quando se trata de
usar as funções do Maya, você precisa usar o que
meus desenvolvedores aéreos decidiram usar. Portanto, esta é a
mensagem meso assist que aceitará uma string. Nesse caso,
gostaria que você
usasse a variável que eu
já criei. E deixe-me voltar
a dizer Olá, mundo. Depois, há outro
argumento chamado pago. Eu direi que isso é
verdade e
veremos em um segundo por que
estou fazendo isso. E há outro
argumento chamado posição que usa
outra string. E eu vou dizer que quero que
isso esteja no centro superior. Coloque-o um pouco mais para o centro e torne-o
um pouco maior. Então, vamos executar esse código
e ver o que acontece. Você vê essa pequena mensagem aqui e ela vai desaparecer um pouco porque
temos essa opção
de desvanecer é igual a verdadeiro. Agora, como você viu, estamos usando esses argumentos para modificar o comportamento
da função. Se eu quiser que apareça
no lado direito, por exemplo, eu. Basta dizer no canto superior direito. Se eu quiser modificar a mensagem, simplesmente
modifico minha variável. E essa variável
está sendo usada aqui. E agora temos a mensagem
diferente. Você já viu isso antes. Bem, eu não sei
se você tem, é muito provável que você já tenha visto. Por exemplo, quando você alterna o modo de
sombreamento neste menu, você verá esta
mensagem sob o capô, meus olhos usando exatamente o mesmo
comando que estamos usando. Com alguns argumentos diferentes. É claro. Falaremos sobre as funções
em detalhes em breve. Aprenderemos como podemos descobrir os argumentos
que temos disponíveis para cada uma
das funções que existem
na mesma biblioteca ds. Por enquanto, eu sei disso de memória apenas por
uma questão de exemplo. Mas mostraremos como encontrar isso na
recomendação deles. Mas agora você está pronto para começar
seu primeiro projeto no Maya. Então, vamos em frente e fazer isso.
4. Biblioteca e importações de cmds: Antes de entrarmos
no primeiro projeto, precisamos falar sobre
a biblioteca Maya CMBS. Então, o que é uma biblioteca? Uma biblioteca é uma
coleção de código, uma coleção de funções. Exemplo perfeito de
que já o usamos. Esta é a mensagem de visualização. Vamos apenas refrescar sua
memória sobre como isso funciona. Pronto, você recebe uma pequena
mensagem na janela de exibição. Portanto, uma biblioteca, neste caso
o MIS him, a biblioteca, também
conhecida como biblioteca de comandos
malloc, tem uma coleção de funções. E funções. Você pode pensar neles como caixas pretas, pois você não sabe como
funcionam por baixo do capô, mas sabe como
obter um resultado com isso. Então, neste caso, sabemos que a mensagem de
imbuição pode ser acessada por meio da notação
de pontos da cena, essa biblioteca. E podemos modificar a saída
com esses argumentos. Não sabemos como ele exibe
uma mensagem por baixo do capô. Mas, honestamente, não
nos importamos. O resultado é com o qual nos importamos. Então isso é uma biblioteca, basicamente uma coleção de código. Então, agora, para ter acesso a
uma biblioteca, antes de tudo, você precisa
ter certeza de que Python
, talvez, tenha acesso
ao código que está
dentro da biblioteca. Porque, no final
das contas, as bibliotecas são basicamente arquivos de texto com código Python dentro delas. A segunda coisa que você
precisa fazer é importante, que é o que estamos fazendo aqui. Então, o que eu estava
fazendo, o que estou fazendo
aqui é da Maya, essa é
outra biblioteca. Então, estou dizendo
da biblioteca Meyer, importe a biblioteca CMBS. E aqui embaixo eu estou dizendo que,
da biblioteca da C&DH, acesse a função de
mensagem de entrevista. Então, você verá essa
importação feita de forma diferente. Algo como importar Maya, o ponto obsceno é CMBS. Isso lhe dará
exatamente o mesmo resultado que você pode ver aqui. Agora, você nem precisa inserir C e D, pois você pode acessar bibliotecas de outras bibliotecas
por meio da notação de pontos. Poderíamos simplesmente dizer maya
importante, assim. Agora, temos que dizer,
da biblioteca Meyer, acesse a biblioteca C&DH
por meio dessa notação de pontos. E a partir disso, nesta biblioteca, acessar sua função de mensagem, é muita digitação. É por isso que preferimos
fazer isso a partir do meu CMBS de entrada. Agora, você também verá isso feito
de uma maneira diferente. Algo parecido com isso. Isso é muito comum se
você ver scripts online, você os verá, essa forma de importar o que está acontecendo aqui. Isso é chamado de namespaces. Então, ainda estamos importando
da Biblioteca Meyer. Estamos importando esse tema, essa biblioteca, mas
estamos chamando isso de MC. É por isso que eles são MC. Agora, o AMC
é como uma variável. Você está basicamente armazenando
a biblioteca CMBS em uma variável de sua escolha. Você pode chamar esses comandos. Funcionará da mesma forma. Você pode ver aqui o resultado. Muitas pessoas optam por
fazer MC porque
acham que é mais rápido digitar
e mais conveniente. Se esse é
o seu caso ou não. Isso depende de você. Você pode pensar no espaçamento entre nomes da mesma forma que quando você coloca um
namespace em um personagem ;
ao importar um
equipamento na cena, você está importando sua
referência ao rakefile. Você está dando a ele um nome de espaço para que ele funcione
dentro da cena. Agora, nesse caso, para mim, cmd é simples o suficiente para digitar, então eu costumo me limitar a isso. Mas você decide se quer ou não usar
o espaçamento entre nomes. E eu uso
namespace com frequência, mas geralmente é quando a biblioteca que estou
importando é muito longa para
digitar do que eu opto por algo mais eficiente ou
mais conveniente. Então aí está. Esse é o meu SEM, essa biblioteca, só para
esclarecer o assunto. Vamos acessar outra
função que eu conheço de memória, o cubo de poliéster. Isso simplesmente criará um cubo. Então, mais uma vez, estamos acessando a função de cubo
de polietileno desta biblioteca por meio
dessa notação de pontos. E o que acontece
apenas como exemplo, o que acontece se eu executar isso? Lembre-se de que você pode executar linhas
únicas de código
destacando o código e
clicando em Controlar Enter. Se eu executar isso, o Python
está simplesmente me dizendo que esse é um método
também conhecido como função. Mas nada está acontecendo, como eu disse antes, com a ação ou com a
execução de uma função. Você tem que
chamá-lo entre parênteses. E aí está. Isso criará um cubo para você. Acabamos de mudar meu modo de
sombreamento. Perfeito. Então, deixe-me
dar antes de
prosseguirmos com mais um
exemplo de biblioteca. Há uma
biblioteca embutida em Python. Isso não é do, meu conselho
é do próprio Python. Receberá o passe. E get pass tem uma função muito útil
chamada getUser. O que isso vai fazer, e vamos na verdade, deixe-me
atribuí-las à minha variável aqui. Então, na minha variável de mensagem, em vez de dizer olá Maya, quero obter o
resultado delas, chamando essa função. O que isso fará é me dar o nome de usuário que está
registrando meu computador. Deixe-me limpar minha janela de saída. Vou me livrar
dessa função de cubo de poliéster. Agora vamos executar isso. Mais uma vez, lembrando
que estou armazenando a saída de getUser. Na verdade, vamos deixar
isso mais óbvio primeiro, vamos imprimir a
saída de getUser. Em primeiro lugar, vou
inserir essa biblioteca aprovada. E então eu vou
imprimir a saída
da função getUser
dessa biblioteca. Aí está. Então esse é o nome de usuário
dentro da minha máquina. Se você executar essas linhas de código, elas serão
diferentes para você, é
claro, porque seu computador tem um nome de usuário diferente. Então, agora vamos executar
esse código que está atribuindo o resultado de
getUser, essa variável aqui. E aí está. Agora eles imbuem a mensagem. A função está exibindo
meu nome de usuário na janela de exibição. Aí está. Então, agora estamos realmente prontos para começar
o primeiro projeto.
5. Projeto 1 - Ferramenta de rigging para aderência: introdução: Você está pronto para criar
sua primeira ferramenta Python. Vamos começar
com algo simples. Essa será a ferramenta apropriada. Deixe-me mostrar o que quero dizer. Esse é o resultado. Acabei de colocá-lo aqui
na prateleira como exemplo. Portanto, ele fornecerá uma peça
simples de geometria. Nesse caso, é um cubo, mas pode ser outra coisa. Isso lhe dará um controlador. Assim, você pode animar seu adereço e imaginar que está bloqueando um
tiro e
precisa de algo com o qual seu
personagem possa interagir. Ou imagine que você está criando uma peça anterior
e precisa
traçar sua foto para calcular o
tempo da sequência ou calcular o
enquadramento da câmera. Há muitos usos para
esse tipo de ferramenta. Portanto, é muito útil. Mas o mais importante
é que ele mostrará os princípios do Python de que você precisa para criar
suas próprias ferramentas. Ele mostrará os fundamentos
da interação com meu aplicativo. E isso ajudará
você a descobrir como ações
muito simples, como
criar um cubo e um círculo, podem rapidamente resultar na
criação de ferramentas muito poderosas.
6. Repartição de ferramentas: Então, um resumo do
que está acontecendo aqui. Se olharmos aqui à
esquerda, no contorno, temos nossa curva para um
círculo chamado controle. E abaixo disso, temos uma peça de geometria que é um cubo. É chamado de adereço. O suporte está sob
controle parenteral para que
possa ser animado. Essa é uma configuração muito simples
e, na verdade, podemos
fazer isso manualmente. E, de fato, essa geralmente
é uma
das melhores maneiras de começar a desenvolver uma ferramenta quando você
não sabe por onde começar. Vamos, deixe-me mostrar o
que quero dizer. Vamos abrir o editor de scripts. E você se lembrará de
que, nas
primeiras aulas,
mostramos que
a janela de saída não só mostra a
saída do seu código, mas também mostra
o que meus olhos estão fazendo. Então, vamos ver isso em ação. Deixe-me limpar a janela de saída. Deixe-me excluir esse código para que não
precisemos mais dele. Vamos começar
criando um círculo. Agora, vamos começar a
treinar o cubo. E então eu quero selecionar
o cubo e o círculo. E vou clicar na
tecla P para ver os pais. Agora obtemos resultados muito
semelhantes. Claro que não é a mesma coisa. Não temos os nomes
e queremos que o círculo seja um pouco menor do que o
que a ferramenta está nos fornecendo. Mas é um bom começo e
nos ajudou muito ao executar
essas etapas manualmente. Agora, se você notar aqui
na janela de saída, o
Maya nos forneceu
muitas informações. Agora vamos fazer isso de novo e
observar a janela de saída. Enquanto eu crio meus objetos. Comece com o círculo, cubo. Selecione, desloque, selecione
o círculo e crie o pai. Ótimo. Então você vê que Maya recebeu todos os comandos de que
precisamos para criar isso. Agora esse é Malcolm, esses são comandos MEL. Este é o código Mel. Como mencionei antes, não
vamos usar o MEL. Mas saber ler um pouco de
e-mail será muito útil porque você pode
traduzir esse Python. Então, vamos tentar fazer isso. Esses códigos que o Maya fornece nem sempre
são limpos. Você vê que
há muitas opções aqui
das quais provavelmente não precisamos. E você também notará
que está criando dois círculos. exemplo, se eu executasse esse
código como está, ele criou a
configuração que queremos. Como você pode ver aqui, há o cupom impresso
no registro, mas ele também criou objetos
extras. Por que minha Aggie recebeu comandos
repetidos? Honestamente, eu não
sei. Mas sabemos que simplesmente
temos que
ignorar a primeira. E mais uma vez, isso
é apenas uma diretriz. Esse não será o trecho de código
resultante, embora não possa ser. Se você precisa fazer algo
tão simples como isso, talvez isso seja tudo o
que você precisa fazer. Mas, para nossos propósitos,
isso não é suficiente. A principal conclusão disso serão os comandos
que o Maya está executando. Nesses casos, o comando
circle, o comando poly cube e o comando parent. Além disso,
vamos ter que fazer uma
pequena limpeza. Como mencionei, a nomenclatura não
é exatamente o que precisamos e o tamanho do círculo é considerado tão fácil de usar quanto
gostaríamos que fosse. Então, vamos traduzir
esses comandos para o Python e começar a criar
a ferramenta nós mesmos.
7. Criar a ferramenta: Vamos começar traduzindo
esses comandos para o Python. Então, tudo o que precisamos é dos nomes
dos comandos em si. Círculo, cubo. Podemos ou não
precisar do comando select. Então, vamos
ignorar isso por enquanto. E o comando de impressão. Então, vamos copiar isso e
trazê-lo para um laboratório de Python. Isso tornará a
fonte um pouco maior. Controle no
volante, no mouse. Deixe-me excluir essa configuração
que tínhamos antes. Então, sabemos que esses comandos, e geralmente quando você vê
essas cores azul e itálico, significa que eles
vêm da biblioteca do MIS
. Então, mais uma vez, se você se lembra, precisamos importar essa biblioteca
e você as aprenderá. Esses de cor. Você digitará
a partir da importação do Maya, consulte MDS. Ótimo. Agora vamos acessar
essas funções da Biblioteca CMBS
por meio dessa notação de pontos, TMDLs, o círculo
aparentemente como um cubo de poliéster. Agora observe o caso aqui, A capitalização.
Isso é importante. Se você não tiver
esse C maiúsculo
, não será o comando
correto. Cmd como um perdão. Então, vamos começar com um
círculo primeiro. Lembre-se de que, para
executar uma função, vou simplesmente limpar
o histórico daqui, para que fique menos confuso. Para executar uma função, você precisa usar os parênteses de abrir
e fechar. Vamos seguir em frente e fazer isso. E vamos executar essas três
primeiras linhas de código. Então, obtemos, obtemos um círculo. Excelente. Agora,
vamos fazer o mesmo, mas com um cubo, um cubo de poliéster. Vamos executar essa linha de código. Na verdade, vamos
executar os comandos
ou funções
do círculo e do cubo de poliéster. Excelente. É um bom começo. Temos um cubo e
temos um círculo. Agora observe que não estamos
apresentando nenhum argumento. Então, meu S está adicionando
o nome para nós. Eu sei que você
descobrirá muito em breve como descobrir esses argumentos. Mas eu sei que há um argumento de
nome na maioria
dessas funções que você pode usar para passar uma string
que será usada para nomear
o objeto resultante. Então, nesse caso, dissemos que queremos que o
círculo seja chamado de controle. Dissemos que
queremos que o cubo ou qualquer geometria que
usaremos seja chamado de suporte. Então, deixe-me fazer isso. E vamos executar isso mais uma vez. Excelente, parece
um pouco melhor. Agora temos um
círculo chamado controle e temos uma peça de
geometria ou cubo chamada suporte. Agora, eles ainda não são pais. Então, para imprimi-los, vamos usar
o comando print. Agora vou
te mostrar como cuidar deles. E logo depois disso, mostrarei
como descobrir o que cada comando precisa e isso será feito usando
sua documentação. Mas agora o que queremos
fazer é controlar
o suporte. Então, agora observe o que
estou fazendo aqui. Sabemos que isso é um cubo e o nó dos cubos é chamado de adereço. E vamos reforçar
isso dizendo o nome aqui na caixa
do canal. Então, quantos
desses comandos do Maya, você vai usar
o nome dos nós. E os nomes desses
nós serão cadeias de caracteres. Então lembre-se, mais uma vez, as cadeias de caracteres são criadas
usando aspas. Você pode usar aspas
simples ou duplas. Essa escolha é sua. Vou usar
aspas simples. Então eu vou dizer que vou pedir ao
nodo pai para o poder
policial e
o adereço, desculpe, usei como
função principal para policiar o pai, o nó auxiliar para
o nó de controle. Então, se eu fosse executar
essa linha de código, ela realmente funcionaria por mim. Deixe-me, deixe-me mostrar que
eles ainda não são pais. E vamos fazer isso. E aí está. Esse é
o resultado que queremos. E agora aqui você pode
ver os pró-negócios, eles estão sob o controle. Então, vamos executar todo esse
trecho de código do zero. Excelente. Então, agora é parental. E é meio
que fazer o que queremos? Ainda há algumas
coisas que precisamos modificar. Você provavelmente notou
que o círculo não
está na mesma posição
que tínhamos antes. É vertical e queremos que
fique plano no chão. E também não é, não é
do tamanho que queremos. Então, vamos limpar isso. Mas você também deve ter
notado que, antes de
corrigirmos
esses pequenos detalhes, devemos limpar nosso código. Então você
deve ter notado que estamos
codificando os nomes que
queremos aqui por meio do marketing, seja, escrevendo as cadeias diretamente e repetindo
esses nomes aqui. Portanto, uma boa maneira de saber
que você precisa começar a usar variáveis é
começar a se repetir,
seja repetindo a si mesmo
ou copiando e colando. Se você se encontrar, por exemplo, copiando e colando esse nome, prop é uma boa indicação que você provavelmente pode
usar uma variável. Então, vamos fazer isso. Digamos que o nome do
controle seja controle. Agora, digamos que o nome
da geometria será adereço. Agora observe também
como sou cuidadoso com as variáveis mínimas para que elas não façam sentido
ao lê-las. E vamos substituir
essas cadeias de caracteres,
essas cadeias de caracteres codificadas por essas variáveis. Portanto, esse será seu
nome associado ao nome do controle. Excel. Vamos executar isso novamente apenas
para ter certeza de que está tudo bem. É excelente. Agora, mais uma vez, o poder das variáveis. Se você quiser nomear esse
controle em vez de CTRL. E se você quiser
chamá-los de algum adereço, por exemplo ,
ou qualquer outra coisa, ele
ainda funciona e você só precisa fazer isso em um lugar vez de em
vários lugares. Excelente. Então, vamos continuar
limpando isso.
8. Modificando o controle: Queremos fazer alguns
ajustes no círculo. Uma delas é que queremos
que seja um pouco maior. E também queremos que ele fique voltado para cima na direção do eixo Y. Então, como podemos fazer isso? Como mencionamos anteriormente,
vamos excluir isso agora mesmo, vamos executar as primeiras
linhas para criar o círculo. Como mencionamos anteriormente, podemos pedir à Maya que nos
diga como fazer isso. Vou limpar a história. Poderíamos simplesmente girar
isso de forma aproximada,
esperançosamente apontando para cima. Também poderíamos torná-lo
um pouco maior. Então, como dissemos, isso poderia funcionar, poderíamos roubar o comando de rotação
e escala. Vamos fazer
algo um pouco mais limpo, se você puder, um pouco mais, mais fácil de controlar. Para isso. Precisamos entrar
no comando circular. Então, vamos dar uma olhada. Ainda assim, vamos pedir a Maya que nos
ajude um pouco. Vamos criar um círculo
a partir desse botão aqui no menu de modelagem e
dos círculos e superfícies. E eu vou
criar um círculo de protuberâncias. Então, o que está acontecendo aqui? Deixe-me tornar isso um
pouco maior. Meus olhos, é claro, usando o comando circular que já
estamos usando. E está usando mais
alguns argumentos. Agora, não precisamos
de todos esses argumentos, mas precisamos de alguns deles. Agora isso pode ser,
isso pode parecer um pouco confuso. Mas eu sei com certeza
que r é o raio. Então, r, neste caso é alguém que pode querer seja um
pouco mais de um, que seja um
pouco mais de um,
mas tudo bem por enquanto. E n are, assume três valores. E quando você está, quando você está convertendo de masculino para Python, se você vê três valores, isso significa que esta é uma lista. E você precisará
separá-los com vírgulas. Então, vamos executar isso. Vamos executar esse comando circular
sozinho. Isso é ótimo. Vamos ver se aumentarmos
o, o, nosso argumento. Deixe-me deletar este. Então, novamente, execute o código. E agora isso é um
pouco maior. Então, como eu sei isso e como eu sei que nosso raio médio? Que você precisa
examinar a documentação? A maneira mais fácil de fazer isso é por meio do menu de ajuda
no editor de scripts e clicando
na referência do comando do Python. Agora, depois de clicar
nele, ele será levado para esta documentação de
Ajuda. Agora, esta é a implementação da minha aberração 2020. E esses são todos
os comandos que você tem disponíveis no Maya. Então, o que nos
preocupa
agora é o comando circular. Você pode usar essa barra de
pesquisa aqui. E encontramos o comando circular. Agora, algumas coisas a serem observadas. Aqui no canto superior
direito desta seção. Você pode ter
a versão masculina ou a versão Python. E queremos estar na versão
Python, é claro. Essa sinopse aqui é
uma espécie de resumo dos comandos
que estão disponíveis para você, desculpe, dos argumentos
que estão disponíveis para você. Agora, todas essas são as opções de
argumentos que você pode aplicar a esse comando. Agora, se você rolar um pouco
para baixo, eu gostaria de poder me livrar disso aqui, mas não
posso agora. Ela está rolando um
pouco para baixo. Você vê fluxo. Fluxo é outra
palavra para argumentos. Você pode ver todos eles. Então, algo a notar
também é que cada flor, cada discussão tem um
nome longo e um nome curto, é por isso
que vimos que são NR, o que é um pouco
enigmático na minha opinião. Então, se rolarmos um pouco para
baixo, vamos tentar descobrir para nossos curadores se o
nome longo de r é raio. Agora, se você vê aqui, isso indica
o tipo de valor, argumento, tipo, tipo de valor que meus olhos esperam para
esse argumento específico. Abordaremos a maior parte disso. O booleano é basicamente verdadeiro
ou falso ou sim ou não. No caso do
raio, linear. Linear significa um número, um número inteiro, que
é um número inteiro, ou um flutuante, que
em termos de
flutuação em Python é basicamente um número
com pontos decimais. Então, neste caso, se você quiser, na
verdade está dizendo
aqui que o argumento do raio tem
um valor padrão de 1,0. Isso porque tem
números decimais, está à tona. Mas, por enquanto, você pensa em
linear como um número. É um pouco
lamentável que o Maya não use o vocabulário que o
Python usa, mas tudo bem. Você resolverá isso
neste caso em seções. Então, ele espera um
int quando é linear, na
verdade significa float ou int um inteiro em
abreviação de inteiro. Então esse é o primeiro. Agora, o outro
que nos interessa. Como mencionei, é um R. Agora, N-R significa normal. Normal é essencialmente um vetor. É a frase que, deixe-me voltar ao meu anúncio, explica isso um
pouco melhor. É a linha paralela ao plano com a
qual estamos lidando. Nesse caso, o normal é
basicamente subir dessa maneira. Não vamos entrar detalhes
de como
criar vetores e em todos esses detalhes mais específicos. Mas, por enquanto, observe que
isso exige três valores. Você pode pensar nesses
valores geralmente como seus eixos x, y e z. E observe que ele
tem esses colchetes. Agora, esses colchetes
significam que é uma lista. Vamos
entrar nas listas muito em breve. Mas pelo menos é basicamente uma lista de valores ou
coleção de valores. Nesse caso, ele espera
três valores específicos. Então, agora que sabemos disso, vamos voltar para Maya. Oh, desculpe. Antes que eu esqueça, se você
rolar até o fim, geralmente terá exemplos
e isso é muito legal. Isso é muito útil porque
minha outra recomendação
fornece exemplos de como usar o comando. Portanto, você pode facilmente executar isso e ver
como as coisas funcionam. Nesse caso, isso está
usando o argumento normal, que é o que nos
importa agora. E se você mudar
para a versão masculina, verá esses mesmos
exemplos no livro didático de Nelson. Estamos usando Python agora, então vamos continuar comprando. Ok, então vamos voltar. Na verdade, vamos mudar para o nome completo
desses argumentos. Agora, no caso
dos comandos do Maya, você pode usar o nome curto ou o nome longo
que depende de você. Muitas pessoas
preferem o nome longo. Mas quando é fácil digitar, prefiro ser um pouco mais explícito e simplesmente
digitar o jogo longo. Vou tornar o raio
um pouco maior do que o padrão, que é 1,0. Eu vou fazer isso também. Eu poderia digitar dois, 2.0 ou
2,5, qualquer coisa que você quiser. Nesse caso, vou
deixar isso como verdade. Agora, para o normal. Vamos, vamos
brincar um pouco. Digamos
que queremos que ele
olhe para o eixo x. Agora, se você notar aqui, caso não esteja familiarizado com esse eixo aqui embaixo
no canto inferior esquerdo. Isso está te dizendo o que, quais atos você está vendo. Então isso é x, isso será z, e depois para cima, esse
será o eixo y. O que acontece se executarmos isso? Bem, nosso círculo estará
apontando para o eixo x. Mas, mais uma vez, queremos que ele esteja apontando para o eixo y. Agora, como mencionei, esses valores representam um vetor, então não é exatamente o eixo. Mas, por enquanto, neste exemplo, para nossos propósitos, você pode
pensar neles apenas como os eixos x, y e z. E, mais uma vez, lembre-se disso
menos esperar uma lista, e isso é feito por meio dessa notação de colchetes
que temos aqui. Mas abordaremos
isso muito em breve. Então, vamos executar esse controle
oito, destacar tudo. Controle Enter para executar meu código. Excelente, isso parece
um pouco melhor. Então esse círculo é um
pouco maior, mais fácil de selecionar. Agora podemos animá-lo. E, claro, está
dirigindo o cubo. Excelente. Então, o que mais podemos fazer? Vamos ver se há algum
bug que possamos encontrar. Existe um e é
um bug meio grave. O que acontece se
executarmos o mesmo código? Mais uma vez, recebemos um
erro. É ótimo. Erros são bons porque dizem exatamente o que está errado. Então, isso indica que
mais de um objeto corresponde ao nome prop. Como isso é possível? Então você vê aqui que temos duas geometrias que
têm o nome prop. Este é esse cubo aqui. E parece que temos
duas curvas diferentes. Agora lembre-se de que
mencionamos que sempre que Maya, sempre que damos
o argumento do nome, Maya tentará usar o
nome que lhe demos. Mas se já existir, ele adicionará um número
, ou seja, como é o
caso aqui, ele adicionou um. Então, isso significa
que nosso, quando estamos
tentando controlar e sondar ou desculpar, controle
produtivo. Controle. É enganoso porque esse é um modelo anterior
que criamos. Na verdade, não é o mais novo que tem o número um. Agora, vamos ver um
exemplo claro disso. E se eu simplesmente criar
alguns círculos diferentes? Deixe-me destacar um
pedaço do círculo maluco da Kodak. Vamos executar esse código três vezes. Três. Veja, o primeiro
tem o nome que eu, aquele eu, que eu quero ter
ou dar ao círculo. Mas agora os outros
terão esse sufixo, esse número extra. Podemos evitar isso? Não, não podemos. Maya tem uma maneira de garantir que os
nomes dos nós sejam exclusivos. No caso anterior. Acho que eu deveria esclarecer isso. No caso anterior, vou
executar o código duas vezes, ele falhará novamente. Prob tem o mesmo nome. Isso ocorre porque, como você percebe, propriedade está, na verdade,
aninhada sob outro nó. Então, neste caso, meu permite que isso aconteça. Mas não se preocupe com isso. Esse é um detalhe que não
o afetará
muito por enquanto. Então, como podemos lidar com esse caso quando meu SID e números
extras extras estão
em nossos nomes. Vamos começar com isso.
9. Mergulho profundo - Ajuda e documentação: Antes de continuarmos, vamos
dar um passo atrás e falar um pouco mais
sobre documentação. Então, vamos voltar para
a página de documentação aqui mais uma vez Para acessá-la, você pode ir do editor de scripts
no menu de ajuda. Clique na referência do
comando Python. E eu vou trazer você
para esta página aqui. Agora, todos eles executam
outros comandos que estão disponíveis para você na
biblioteca de comandos
do Maya , a biblioteca CMBS. Eles são organizados por
categorias. Então, por exemplo você tem os de
animação aqui. Você
os usará bastante. Ou você tem a parte
de pesquisa aqui. Então, vamos dar uma olhada no outro
comando que estamos usando. Oh, na verdade, talvez vamos
dar uma olhada no cubo. Agora. Mais uma vez, um resumo rápido. Aqui,
no canto superior direito
desta seção, você pode alternar entre as versões
masculina e Python. Vamos ficar com
a versão Python. Sinapse. Synapsis tem um resumo
dos argumentos que você pode ter disponíveis
neste comando. Há uma pequena descrição. E o mais importante,
na parte inferior ,
há
exemplos. Isso será mais útil para você quando estiver começando
a usar um novo comando. Às vezes, você pode obter
todas as informações de que precisa experimentando
agora esses exemplos. Ótimo. Então, a maior
parte disso é a bandeira, a seção de fluxo,
também conhecida como argumentos. Cada bandeira ou argumento
tem um nome longo. Assim,
histórico de construção ou um nome curto he H. Depende de você
se deseja usar um nome curto ou longo. Eu geralmente recomendo nomes longos porque são mais explícitos, mas cada pessoa tem
preferências por isso. Você tem as
descrições dos comentários aqui. Agora, um tipo de argumento,
como eu disse antes, é um pouco lamentável
que o Maya nem sempre use os nomes que correspondem
ao tipo Python. Nesse caso, linear
na verdade significa flutuante, que é um número com
casas decimais. Não existe em Python
nesta abreviação de inteiro, que é basicamente um número sem decimais, neste caso, um por si só
seria um número inteiro, um ponto algo
seria um flutuador. Sempre que você vê esses colchetes, isso significa uma
lista ou uma tupla. Chegaremos a isso em breve. Você vai, você provavelmente está
percebendo que existem, existem essas cartas
aqui. O que isso significa? Nas propriedades? Isso significa que você pode usar esses comandos
ao criar, consultar ou editar o nó ou o objeto para o
qual está usando isso. Nesse caso, a construção do histórico de construção de pilha
fixa é usada
apenas para criar
e consultar. A maioria dos outros
argumentos pode ser usada para edição. O que isso significa? Isso significa que você pode usar o mesmo argumento
no mesmo comando, neste caso, um cubo de poliéster. Você pode usá-lo
para criar um novo cubo. Você pode usá-lo para consultar informações de
um cubo existente ou para editar
um cubo existente, por exemplo, se quiser alterar a largura
do seu cubo, você usará o sinalizador de
edição para isso, mas
também abordaremos isso em outros projetos. Agora, há outras maneiras de
obter ajuda da Maya. A principal delas, para ser sincero, é essa página que acabamos de ver. Provavelmente, o segundo melhor lugar
para fazer isso é o próprio Google. E o Google por si só pode ser uma habilidade que você vai
querer desenvolver. Mas eu recomendo normalmente digitar o que você
quiser fazer. E, por exemplo digamos que você queira
encontrar o comando atual que eu criei no meu Python. Isso geralmente fornece um bom exemplo ou um bom resultado, seja na
documentação. Observe que às vezes você
obtém uma versão mais antiga do Maya ou ela pode direcioná-lo para
alguns outros sites. Um deles que é muito,
muito útil
será o StackOverflow. Essa é uma comunidade
para desenvolvedores. E há muita ajuda para perguntas
muito específicas
respondidas aqui. Portanto, eu recomendo
procurar ajuda no StackOverflow, diretamente no Google do que na TI, ou na barra de pesquisa
de um StackOverflow. Sempre há muitos fóruns. Não posso recomendar
nenhum específico. Há muitos fóruns de artistas
técnicos que
ajudarão você. Então, definitivamente, não tenha
medo de pesquisar no Google suas informações ou erros
que você possa ter porque o Google
será seu melhor amigo em sua carreira de desenvolvimento. Então, de que outra forma podemos obter ajuda? Deixe-me abrir uma nova guia do Python. Uma forma de obter ajuda é
literalmente digitar saúde. Agora, help é uma função embutida dentro do Python que
assume uma função. E, se a função tiver alguma documentação
dentro
dela, fornecerá
essas informações. Então, vamos a importante biblioteca CMBS. Na verdade, vamos executar a ajuda do
CMBS diretamente. Para executar isso. Agora, você vê que ele
lhe deu todas essas informações. Isso é muito. Isso é basicamente
o que os desenvolvedores
da biblioteca CMBS colocaram dentro dessa recomendação
da biblioteca, e tudo isso está
disponível para você. Para ser honesto, não é muito completo, mas é algo que realmente diz onde você pode encontrá-lo em seu computador. Esses casos, esse caminho e todas as funções
que estão dentro dele. Poderíamos, por exemplo, verificar que ABC é importante
em olímpico importante. Agora, observe que, para
verificar a ajuda, não
estou executando a função. Desculpe por isso. Não estou adicionando o parêntese porque
não quero executar a função. Eu só quero obter
a ajuda dele. Ok? Bem, este
tem muita ajuda, o que é lamentável, mas às vezes você
receberá ajuda
dessa função de ajuda. Deixe-me, deixe-me, deixe-me encontrar uma função
que possa ser útil. Este talvez tenha uma
ajuda melhor. Sim, aí está. Ele apenas deu uma
pequena descrição, mas é útil o suficiente. Ele até fornece
uma recomendação que é ótima, excelente. Outra forma de obter ajuda, especialmente com a biblioteca de comandos do
Maya, é habilitando a ajuda rápida. Agora isso está no menu de comando. Mostrar ajuda rápida. Você obterá essa pequena, essa pequena seção aqui. Você pode encontrar informações,
encontrar seus comandos. Digamos que vamos encontrar o
cubo de poliéster novamente. Agora, isso não
tem detalhes, mas terá os argumentos
que você tem disponíveis. Por exemplo, estamos usando. Voltamos a essa guia. Estamos usando o argumento
do nome. Então você sabe que isso
vem daí. 11. 11 diz
que é uma corda, o que é muito bom. Aparentemente, outro está acontecendo. Isso é ótimo. Portanto, não é muito detalhado, mas é suficiente para
que você possa
pelo menos saber rapidamente quais argumentos você tem à sua
disposição. Eu não costumo usar isso, especialmente porque ele
ocupa espaço
do editor de scripts, mas é útil
de tempos em tempos. Então eu vou desligá-lo. Outra forma de obter ajuda é
por meio desta ajuda da dica de ferramenta Mostrar. Agora, a forma como isso funciona é, digamos que eu comece a digitar
o comando do círculo. Quando eu abro o parêntese, você verá essas dicas de ferramentas. Agora, isso é semelhante
a quando você passa o
mouse como um botão de prateleira. Isso fornecerá algum tipo
de dica de ferramenta de rolagem para cima, ajuda com
dicas de ferramentas que acontece
quando você passa o mouse sobre algo. Isso permitirá que você
tenha um pouco
mais de informações. E tem os tipos de
argumento. E também os argumentos são bandeiras que estão
disponíveis para esse comentário. Este, pessoalmente,
é um pouco intrusivo
porque cobre meu código e eu realmente não gosto disso. Mas é uma boa opção. Muitas pessoas gostam e
é uma boa opção
para conhecer. Eu geralmente desisto,
mas, mais uma vez, tudo se
resume à preferência pessoal. Então, essa é uma boa visão geral
das formas de obter ajuda. Vamos voltar ao código.
10. Trabalhar com nomes e listas de nós: Para descobrir qual nome é Maya,
usaremos ou usaremos depois de
criarmos nossas anotações. Vamos ver o resultado
dessa função aqui. Então, vamos começar com o resultado em
uma variável chamada controle. Agora, não se confunda
entre o nome
dessa variável e
esse controle de string ,
porque eles
são muito diferentes. Eles não têm nada a
ver um com o outro. Na verdade, evito confusão. Vou mudar essas
duas etapas de controle. Então, vamos fazer isso. E vamos imprimir a
saída do controle. Essa, essa variável em que
estávamos armazenando a saída, a saída do comando do círculo ou a função do círculo
nessa variável. Vamos apenas executar isso. Só para deixá-lo um
pouco mais limpo. Vamos deletar isso. Deixe-me esclarecer minha história. E aí está. Então essa é a saída. Agora observe que há dois, mais
uma vez, temos
esses colchetes. Isso significa que é uma lista. Agora esta célula está com
duas cordas dentro delas. Não se preocupe com o
u. U significa Unicode, mas para esses propósitos é essencialmente o
mesmo que uma string. Portanto, não se preocupe com a UE. Você percebe que temos o controle. Temos outra coisa
chamada Faça um círculo nervoso. Um é um pouco enigmático. Agora, vamos executar isso mais
algumas vezes. Agora, você verá que a
segunda vez que o executamos é aqui. Na verdade, temos o nome
do nodo que Maya criou. Então, o que isso significa? Digamos que deixe-me
copiar e colar isso
aqui embaixo só para deixar
um pouco mais claro. Agora, o primeiro item da lista, esse é o nome real
do nó que eu criei, que é o que
queremos saber, certo? Deixe-me me livrar da U. Mais
uma vez, a UE não
importa. Você pode deixá-lo
lá se quiser. Mas, por enquanto,
vou me livrar disso. E depois tem essa coisa. Este é o, este é
o construtor
do nó que os maias
usam para criá-lo. O que isso significa? Vamos dar
outro exemplo. Fazendo a mesma
coisa com o cubo. Acho que isso pode ser um
pouco mais claro. Então, vamos armazenar o
resultado do cubo. Essa variável chamada prop. Deixe-me deletar esse
círculo que eu criei. Agora vou destacar
apenas essas duas linhas de código. Você está percebendo que eu não estou
destacando os outros. Isso ocorre porque, depois de
executar essas linhas de código, uma vez que o Maya as capture, maya basicamente armazenará o último valor
dessas variáveis, o que pode ser muito conveniente. Então, neste caso,
já uma
vez, depois de executar essas
três linhas de código,
eu já armazenei o nome dessa variável ou o
valor dessa variável. Então, agora eu posso simplesmente executar
essas duas linhas de código. E funcionará,
funcionará da mesma forma. Então, vamos fazer isso. Vamos fazer isso três vezes também. Então, mais uma vez, observe que minhas mãos usam o
nome que eu sugeri, que está armazenado na variável
de nome geográfico, que é prep, essa é
a cadeia de valores. Mas como está descobrindo que qualquer um deles já foi criado, está adicionando esses nomes
e o resultado de cada um, cada um desses comandos. Mais uma vez, é o
nó real que foi criado. E então esse construtor. Agora, não se
preocupe com isso a partir de agora. Por que nos
preocupamos com esse primeiro valor? Então, como acessamos esse valor? Bem, como eu disse, deixe-me colar novamente. Deixe-me colar isso
novamente aqui, apenas para tornar um
pouco mais fácil ver e se livrar dos EUA porque eles não estão necessariamente no
momento. Isso é uma lista. Como mencionei antes, você sabe que é Alice
por causa desses colchetes. E uma lista é basicamente
uma lista de itens, uma coleção de valores. Você pode ter números inteiros, que são apenas números. Você pode ter cordas, você pode ter uma mistura delas. Agora, nesse caso, é
apenas uma lista de sequências de caracteres. Como faço, como faço
para obter o primeiro item? Fazemos isso usando
outra notação de colchetes. Agora, quando se trata de
contar em programação, e isso vale para a
maioria das linguagens de programação, mas especialmente em Python, começamos a contar em zero. Então, o índice ou a posição, ou digamos que o número
desse item seja zero, então essa é a posição zero
e, em seguida, essa é a posição um. Agora, abordaremos menos
do que mais detalhes em breve. Mas, por enquanto, saiba que para obter o primeiro item dessa lista, vamos fazer com que ele
passe pelo índice zero. Começamos a contar em zero
por vários motivos. É um padrão muito comum,
um padrão em linguagens
de programação. Então, vamos executar essa linha de código. Vamos imprimir isso. Agora lembre-se, estou
imprimindo o primeiro item, o item na lista, e pronto. É isso
que estamos recebendo. Então, vamos tentar fazer isso
de forma um pouco limpa. Então, vamos chamar isso de, vamos
mudar essa variável. Vamos chamar isso de controle. Vamos chamar isso de controle. Agora, mais uma vez, sabemos que o resultado disso é a lista com o nome do nó
e depois com o construtor, qual não nos
importamos no momento. Vamos chamar que o nó de controle
será o primeiro, o primeiro item, o item da lista de
controle. E agora o
nodo será o primeiro item nesse resultado que
estamos obtendo do Maya. Agora, se isso for
confuso, não se preocupe. explicaremos Em breve, explicaremos
as listas novamente
com mais detalhes. Agora, como você pode imaginar, não
usaríamos mais esses nomes. Essas se tornaram
sugestões para Maya usar o máximo possível de quatro, mas tem que adicionar
números ao nome. Então, vamos imprimir essas
duas variáveis aqui. As novas variáveis
que criamos, então nó de controle e depois nó. Então, agora essas duas variáveis representam os
nós reais que foram criados. Aí está. Então, nós controlamos e praticamos é a primeira
vez que os criamos. Se executarmos isso novamente,
controle uma sonda, outra, execute isso muitas mais vezes. Você vê que o número
aumenta à medida que executamos o código. Isso é exatamente o que queremos. Agora. Vamos fixar nosso poder no comando. Então, agora queremos criar
o nó de controle criativo. Queríamos ser pais
da sonda. Nota. Deixe-me excluir
essas duas linhas, remover algumas linhas e executar esse código. Excelente. Então, esses são os resultados com
os quais estamos familiarizados. Na verdade. Não funcionou
, não funcionou. Oh, eu fiz isso da maneira
errada. Queremos associar o
nó de suporte ao nó de controle. Queremos que o controle seja
o pai do problema. O que faz sentido. Me desculpe por isso. Depurando à medida que avançamos. A partir disso, novamente. Excelente. Então, agora é o que esperamos, se movermos isso para o lado, vamos executar nosso código novamente apenas para garantir
que isso funcione. Ótimo. Agora, isso é
controlado um e solte. Mais uma vez, como eu disse, porque esses cubos são criados
sob alguma coisa, meu permite que o nome seja
repetido, mas tudo bem. Não nos importamos com
isso porque, lembre-se, estamos recebendo o nome
diretamente de Maya. Não estamos adivinhando nenhum nome. Meu strlen, você está nos dizendo exatamente o nome que usou
para criar aquele cubo de poliéster? Só para verificar a sanidade, vamos fazer isso de novo. terceira vez é o charme, como
dizem. E lá vamos nós. Agora temos tudo isso. Agora temos vários adereços
trabalhando ao mesmo tempo. Vamos fazer um pequeno ajuste antes de passarmos
para a próxima lição. O pequeno ajuste
que eu quero que você faça é essencialmente um ajuste do
fluxo de trabalho. Não seria bom se,
ao criar seu equipamento, não
quiséssemos
animar o cubo diretamente. Provavelmente queremos
animar a plataforma. Então, vamos fazer com que ele
selecione esse controle. Nós temos, esses são os comandos de
seleção que são ótimos. Então, vamos ver. Nós
podemos simplesmente fazer isso. Cmbs Dot selecione isso,
isso está funcionando. E queremos selecionar o nó de controle que
criamos, certo? Então, está passando o
nó de controle para essa função. Deixe-me esclarecer isso
ao longo da minha história. E vamos executar o
código mais uma vez. E aí está. Agora, assim que você
criar sua preparação, você pode começar a animar.
11. Ampliar a ferramenta com declarações "if": Nosso trabalho consiste em fazer
essencialmente o que precisamos. Mas vamos tornar isso um
pouco mais interessante. Eu disse no começo que o suporte não
precisava ser apenas um cubo. Vamos acrescentar um pouco, vamos
manter mais algumas opções. E vamos apresentar
também um novo conceito. E essa é a declaração if. Se perguntado a ele se
algo acontece, faça outra coisa ou
faça outra coisa, o que significa que você pode fazer uma troca e escolher uma opção diferente,
dependendo da condição. É assim que as
declarações iif funcionam. Então, como fazemos isso? Primeiro, vamos identificar onde essa condição
mudaria. Nesse caso, estaria aqui, que é como o cubo. Sabemos que o controle, não
queremos mudar
isso,
pois você só quer que seja um círculo simples. Só queremos
mudar a geometria. Então, vamos começar
mudando a geometria. Em vez de ser um cubo. Vamos fazer uma esfera, por exemplo, vamos, mais uma vez, deixar Maya nos dizer o que precisamos. Esta caixa parece
poliesferas, tudo o que precisamos. Então, vamos digitar
isso antes de
adicionarmos a afirmação que
significa “limpar isso”. Então, vamos digitar
mais uma vez Pauli maiúsculo S. Agora vamos executar esse código. Agora observe que o código é
exatamente o mesmo que tínhamos. Todos nós mudamos o
cubo ou a esfera de uma pessoa. E aí está.
O código funciona perfeitamente. Bem, o mesmo que tínhamos antes. Agora, digamos que queremos,
digamos, um cone. Fácil, basta digitar
cone em vez de esfera. Veja a beleza da consistência que o Maya
fornece e fornece. Desculpe, eu queria digitar cone. Vamos escrever isso. Perfeito. Então, vamos nos ater
a essas três opções. Agora sabemos que tudo o
que precisamos depende da
opção que queremos. Queremos mudar isso,
esse comando ou essa função. Agora, vamos adicionar uma variável que nos ajudará a
decidir a opção. Vamos chamá-lo de tipo. E isso também será
uma corda. Pode ser o que
você quiser, pode, também pode ser um número se
você quiser decidir dessa forma. Mas para torná-lo mais
fácil de usar, vamos usar uma string. Digamos que o padrão
seja em cubos. Agora, observe que eu o
chamo
intencionalmente tipo de adereço, não apenas de tipo. A razão para isso
é porque há uma função embutida no
Python que é tipo. E geralmente não é
uma boa ideia criar variáveis com o
mesmo nome das funções integradas. Isso porque, se você fizer isso, seu código não será interrompido, mas você basicamente
substituirá
a função incorporada ao Python e não
terá acesso a ela. Nesse caso, não
precisamos dessa função, então não há problema em fazer isso. Mas, em geral, é uma boa prática
não fazer isso. Eu vou dizer protótipo. Eu vou dizer
redefina-o como cubo. Por enquanto. Vamos dizer que se o
tipo de adereço é igual, é igual a qb. Agora preste atenção aqui e
eu estou dizendo que o dobro é igual. Em vez de um único igual, ao usar um único igual, você está atribuindo um
valor a uma variável. Você está usando um duplo igual, você está fazendo uma comparação. E agora vem
algo novo chamado indentação para trabalharmos dentro
dessa declaração if. Vamos ter que
recuar isso dentro dela. O recuo padrão
em Python é quatro espaços ou mais
que, novamente, 1234. Ou você também pode usar a aba, neste caso, a parte superior
logo acima do caps lock, ao lado da tecla Q. Nesse caso, Maya escrito
ou traduzido em Maya, se traduz em
tocar em quatro espaços. Lembre-se de
que, em geral, é uma boa prática ter as bases de força no Python 1234. Agora vou usar uma guia
porque é equivalente, porque estamos dentro do Maya. Se estivéssemos dentro de
algo como o Notepad, por exemplo isso aqui, a guia. Deixe-me fazer isso um pouco. Digamos que apenas para um, então isso é uma guia. São quatro espaços, 1234. Eles não são os mesmos. Então, essa é uma distinção muito importante. indentação é algo
que torna o Python muito fácil de ler porque você não precisa
de muita sintaxe extra, mas precisa estar
ciente da indentação. Se menos indentação
for reduzida em um espaço, você receberá um erro. Podemos ver isso daqui a pouco. Então, mais uma vez, se o tipo de
adereço for igual, igual a cubo, então
faremos isso. Na verdade. Eu digito um cone. Então, digamos cubo. Agora, digamos l. Se isso é o equivalente
a dizer else if. Mas, neste caso, você precisa
digitar LF prop type equals, b ou, por exemplo, Poland. Agora observe que, no
final da declaração if, estou escrevendo uma coluna. Isso é muito importante.
Se você não fizer isso, Python apresentará um erro. E também observe que depois dos dois pontos, quando eu
digito, insira o Maya, script ou no Maya automaticamente me dá
esse espaçamento porque ele sabe que eu tenho que
inventar algo lá que outra declaração seja. Então, neste caso,
vamos copiar isso. Agora. Esfera em vez de cubo
ou esfera, perfeita. E agora a última opção sobre a
qual falamos foi um cone. Então, o protótipo LA é
igual, igual a cólon, cólon. Vamos copiar e colar isso. E talvez você já veja
uma redundância nesse código, o que é ótimo se você fez o
bem para você. Muito bem. Se não, mencionarei
isso em um segundo. Então, cone de poliéster. Excelente. Agora, o que acontece se, agora lembre-se, desculpe,
essa variável, estamos comparando essa string com o valor
dessa variável aqui em cima. Agora, o que acontece se
não houver nenhuma opção que aceitemos? Vamos ter um
valor padrão, digamos. Então, para isso, você pode
dizer mais, senão. Vamos atribuir. Digamos que o
valor padrão seja cubo. Vamos também dizer ao usuário que ele não
forneceu um valor em, que estamos usando
um valor padrão. Portanto, há uma função chamada
aviso, a mesma do embarque. E o aviso nos permite simplesmente
dar uma opção
inválida de mensagem usando cubo x. Portanto, essa poderia ser
uma mensagem melhor, mas na verdade uma opção de tipo
prop inválida usando cube como padrão. Aí está. Isso é um
pouco mais claro. Excelente. Então, vamos executar esse código antes de nos
aprofundarmos um pouco mais nele. Deixe-me limpar
um pouco meu espaçamento e
talvez mais um espaço, mas ficamos um
pouco mais fáceis de ler. Aí está. Tudo bem,
então vamos executar esse código e obtemos um cubo. Agora, vamos adicionar
outra opção. Digamos que uma esfera. Lá vamos nós, temos uma esfera. Agora, o que aconteceria se
fizéssemos uma mesa, por exemplo, isso? Agora fique à vontade para
pausar o vídeo agora mesmo e tentar adivinhar
o que vai acontecer. Então, vamos executar isso. Aí está. Então você vê
que temos esse aviso aqui. opção de tipo de adereço inválido está em Cuba como padrão
e temos um cubo. Então, o que aconteceu lá
é que, como o valor não correspondia a nenhuma
dessas opções
que nós, que
colocamos lá, estamos usando o else como padrão. Agora, observe também que
isso diferencia maiúsculas de minúsculas. Então, se eu digitar esfera com S, S
maiúsculo em vez
de S minúsculo, obteremos outro cubo. E eles estão chateados porque compensados porque eu mudei
o outro anteriormente. Então, vamos testar nossa última
opção, que é um cone. Excelente. Aí está. Então, agora o total é um
pouco mais robusto. Temos mais opções. E isso é ótimo. Você
poderia até ter feito três botões de prateleira
e simplesmente alterar essa variável e ela
fornecerá três formas
diferentes. Então, vamos nos aprofundar um pouco no
código. Uma vez que percebo
que estamos usando a declaração if para
validar ou condicionar. Isso é chamado de condição. Você está, você está
fazendo uma comparação. Você está dizendo que se essa
variável for igual a esse valor, então vamos
criar um polígono. Caso contrário, se essa variável for igual a
esse outro valor, usaremos
essa outra função. E, no final, temos, digamos, uma declaração
em branco. Não temos uma condição
específica que estamos verificando, como nesta
outra declaração. Isso é basicamente dizer contrário, se alguma
outra coisa acontecer, embora isso, agora isso não
seja necessário. Você pode ter uma declaração
if sozinha e ela funciona, funciona, funciona bem. Isso está apenas dando a você
mais flexibilidade para ter condições extras ou um tipo
de situação um pouco abrangente , o que é o
resto neste caso. Ótimo. Então eu mencionei que havia uma
redundância nesse código. E essa é essa linha aqui. Então, lembramos mais
uma vez que se você executar o comando poly cube
e me deixar fazer isso. Se eu simplesmente selecionar essa
função e executá-la, você verá o resultado. Maya te dá o resultado. Esse é o nome do nodo. E há essa
outra forma que é a coisa que está construindo
o cubo nesse caso, mas não nos importamos com ela para esses propósitos.
Mas é assim que eu listo. Mais uma vez, lembre-se de que a
lista está entre colchetes. E o fato é que
o que nos
importa é o primeiro
item dessa lista, nesse caso, o nome
do nó que foi criado. E acessamos isso
por meio dessa indexação. Então, nessa notação,
começamos a contar em zero quando se
trata de listas em Python. Então acessamos o primeiro índice, o índice de zeros, e o
atribuímos a essa variável. Agora, há redundâncias que estamos fazendo a mesma
coisa todas as vezes. Então, isso não importa. Não importa
qual comando executamos. Ainda estamos armazenando esse
resultado no mesmo nome de variável, certo? Então, só precisamos fazer isso uma vez. Então, vamos remover esse recuo e tirá-lo das instruções
if else. E agora não precisamos
dessas linhas aqui. Agora, preste atenção aqui
ao recuo. Recuo,
mais uma vez, observe que essa variável da barra de suporte está
recuada sob o if. Caso contrário, se forem declarações. E o verdadeiro
nó final que estamos recebendo está fora
dessas declarações. Isso é importante. Porque mais uma vez,
se recuarmos aqui, se recuarmos isso, agora isso será executado somente
dentro da instrução else. E se inserirmos a declaração if no início, nunca
chegaremos a isso. E podemos até receber um erro. Vamos tirar isso
dessas declarações. E também, se
ainda não era óbvio , eles têm, eles têm uma declaração. As instruções if-else
funcionam como um switch. Na primeira vez que você detectar a
condição pela primeira vez, ela parará por aí, não passará para as
próximas condições. Se essa condição não for verdadeira, ele tentará passar para
a próxima, caso contrário. Então, caso contrário, até
a última barra, se você puder, se a condição
for atendida em qualquer uma
das etapas anteriores,
ela parará por aí. Ótimo. Então, vamos executar isso apenas para ter
certeza de que
não quebramos o código. Aí está. Cone. Mais uma vez. Esfera. Excelente, está
funcionando como esperávamos. Agora, vamos ver o que acontece
se você cometer algum erro. E há uma
boa chance de você ter feito isso. E se você fez isso, é
incrível porque os erros permitem que você
aprenda muito mais rápido. Então, digamos
que sua indentação
aqui foi um pouco,
ou, na verdade, isso pode estar bem porque é
a mesma afirmação if. Para provar esse ponto. Vamos adicionar algumas declarações
impressas. Cubo auxiliar de impressão. Deixe-me mudar isso
aqui para o cubo a, então inserimos a declaração IF. Então, agora, quando inserimos
isso, ele deve imprimir a nota
em um cubo lá. Excelente. Agora, para provar meu ponto de vista
sobre a indentação, vamos remover um espaço
para esse convite. Agora, observe que essas duas
linhas de código não estão alinhadas. Aí está, você
recebe esse erro. Essa é a importância
da indentação. Sempre que você tem
várias linhas de código, uma após a outra,
o recuo nelas deve coincidir. E, em geral, basta
manter quatro espaços. Ou se você estiver trabalhando em
um editor de texto para codificação, o
que
será feito em breve. Usar a guia
será mais do que suficiente. Vamos fazer com que volte
ao normal. Excelente. Na verdade, vou me livrar
dessa linha porque realmente
não precisamos dela. E a outra coisa que
mencionei foi a coluna. Se você não tiver essa
coluna por algum motivo, deixe-me limpar a janela de saída. Isso lhe dará um erro de sintaxe. Sintaxe significa que
você não recebe a sintaxe ou
o tipo de caracteres que o
Python espera de você. O que é ótimo, e isso
vai ser muito útil. Observe que você
tem tudo isso. Isso é chamado de rastreamento de pilha. Stack rastreia as etapas que levaram ao erro que
você encontrou. E o Maya fornece de forma muito
conveniente
a linha em que seu código falhou. Nesse caso, é
linha por linha 13. Agora diz a linha 13, mas na verdade é a
linha anterior. Mas isso realmente mostra
o lugar onde falhou. Nem sempre fará
isso nesse caso, é muito claro e na verdade não diz o
que está faltando, mas indica
a área geral. Assim, você pode voltar e examinar seu código
e tentar encontrar o erro. Então isso será muito útil. Agora, antes de terminarmos o vídeo, vamos fazer
outra coisa que
tornará nosso código um
pouco melhor. Vamos adicionar alguns comentários. Então, por exemplo, aqui na linha sete, pouco antes de
criarmos esse círculo, esse é o nosso tipo de controle, a tecla da libra ou o sinal
numérico ou hashtag, você
quiser chamá-lo. E basta escrever uma nota. Vou apenas escrever
create control for break,
por exemplo, isso é um comentário. Este não é um código que
será executado. O Python essencialmente o ignora. Isso é apenas
para você digitar uma nota para si mesmo ou para quem mais executará seu código. Agora, vamos aqui, digamos que
criar geometria deveria dizer que geografia com base no tipo seria clara o suficiente e rolaria até aqui. É aqui que obtemos o nó
real que foi criado. Nó criado. E aqui não estão, GO TO Troll. Em seguida, selecionamos. Vou selecionar isso
muito autoexplicativo. Eu diria que os pais também são
muito autoexplicativos, então não me importo com
o outro comentário, mas vamos deixar isso aí. Não existe uma regra geral
quando se trata de comentários. Fica a seu critério. Muitos comentários podem aparecer
sobre o código do wafer. Mas nenhum comentário também pode
dificultar a compreensão do que está
acontecendo em seu código. Portanto, encontre seu próprio equilíbrio quando se trata de
escrever comentários. Às vezes, nossa
variável bem nomeada, por exemplo protótipo, pode não precisar de
um comentário cosseno em si. É muito autoexplicativo, então,
assim como o nome do controle, o nome GO, uma função bem nomeada, e criaremos
nossas próprias funções certeza também podem evitar a
necessidade de comentários, por exemplo, pai é muito
autoexplicativo. Selecione. Não há necessidade de dizer
o que os selecionados
farão porque você sabe
exatamente o que eles farão. Então, sim,
talvez pudéssemos adicionar mais alguns, mas acho que isso é
bom o suficiente por enquanto.
12. Mergulho profundo - "se" declarações e booleanos: Vamos falar sobre as declarações if. Se as declarações são muito simples e para
compreendê-las completamente, você precisa estar familiarizado
com dois conceitos. Uma delas são as condições, também
conhecidas como declarações
condicionais. E essa é a base
de uma declaração if, porque a declaração
IF basicamente diz que, se essa condição for verdadeira, faça alguma coisa, caso contrário,
faça outra coisa. Qual é essa condição
ou, ou não faça nada se
você quiser. E essas
declarações de condição se resumem a algo chamado tipo
de dados booleano, chamado booleano,
também conhecido como tigela. É um tipo de
dados muito simples que pode ter um dos dois valores, verdadeiro
ou falso. É chamado de valor binário, pode ser como zero ou um, essencialmente um
valor sim ou não, verdadeiro ou falso. Verdadeiro. Esteja ciente da letra T maiúscula. Essa é a sintaxe
para Python ou false. Então, vamos dar um exemplo. Vamos criar uma variável, apenas um número simples,
num é igual a dez. Só para dar um exemplo. Vamos dizer que
se um é igual dez, vamos
imprimir sim, por exemplo, caso contrário, vamos imprimir. Não. Excelente. Vamos apenas executar esse código.
Ok, desculpe, isso foi culpa minha. Na verdade, não estou
imprimindo nada. Deixe-me consertar isso. Lá vamos nós. Aí está. Agora estamos imprimindo. Sim. Agora, se mudarmos
isso para nove ou impressão
e não, excelente. Então, vamos detalhar
o que está acontecendo aqui. Esta é a sua
condição aqui. Num é igual a dez. Agora observe, bem, antes de tudo, vamos observar, existe
a intenção aqui? E no caso desse erro, toda vez que eu pressionar enter, ele me dará esse
recuo automaticamente. Mas lembre-se de que o Python precisa de inundação e geralmente
tem quatro espaços. Ou, no caso do meu editor de
programação agora, será uma guia, que
equivalerá a quatro espaços. Isso é muito importante. Se não tivermos isso, o
Python gerará um erro. Observe também a coluna
no final das declarações if e else. Mas isso é muito importante. Então, agora, voltando a isso. Essa é a sua condição.
O que estamos fazendo é dizer, basicamente perguntando,
o número é igual? Agora igual, igual,
isso é uma comparação. É chamado de comparação
ou por operador. E um único sinal de igual
é um operador de atribuição. Então, basicamente, significa que um único sinal de igual
atribuirá um valor a algo, neste caso, uma variável. E um
sinal de igual duplo tentará
fazer uma comparação entre
dois valores diferentes. Excelente. Portanto, há diferentes tipos
de operadores de comparação. Não vamos mencionar todos eles porque o foco
deste vídeo será nas declarações
If e nos booleanos. Mas deixe-me
mostrar mais algumas. O oposto dos
iguais, é igual a não igual. Isso é um sinal de exclamação. E um único igual
é chamado de zero igual e verifica
o contrário. Então está perguntando se o
número ou o é variável não é igual a dez? Então, se você executar esse código, sim, nove não é igual a
dez, cerca de 20. Então, é verdade que 20 não é
igual a dez ou dez. Bem, agora isso não é verdade
porque dez é igual a dez, então não atende a
essa condição. Excelente. Então, vamos
fazer mais um exemplo. Digamos que estamos verificando
uma série de números. Digamos que seja perguntado se o número
é menor que zero. Digamos que queremos que
nosso intervalo seja de
0 a 100 se o número
for menor que zero. Muito baixo, vamos baixar muito baixo. Se tiver uma sintaxe específica l, se permitir que você verifique
outra condição, L, se o número for
maior que 100, dirá muito alto. Caso contrário, não
verificaremos nenhuma
condição específica, caso contrário. O que vamos dizer é
número dentro de rich, que é um erro de sintaxe porque não
temos os parênteses
aqui.
Excelente. Número obtido dentro do intervalo. O que acontece se chegarmos a 100? Número dentro do alcance? 101? Alto, e só por
uma questão de conclusão, menos cinco é muito baixo. Excelente. Então, lembre-se de que eu disse que as declarações
condicionais basicamente se
resumem a um booleano, verdadeiro
ou falso. Então, vamos ver isso. Vamos ver esse exemplo.
Deixe-me deletar tudo isso. E vamos atribuir isso, essa comparação a uma variável. Vamos chamar uma impressão de. Então, o que
estamos fazendo aqui? Na verdade, não
existe mais, então não posso fazer isso porque
excluímos essa variável. Vamos fazer algo simples que fizemos no começo. Então, cinco é igual a cinco. Então, estamos atribuindo o resultado
dessa comparação
a essa variável. Agora, tente pensar no
que vai acontecer. Está jogando isso. E é verdade. Cinco é igual, é igual a cinco. Ótimo. Agora, digamos que
seja cinco ou menos, ou igual a cinco. É verdade. Cinco, menos ou igual a seis. Bem, não. Não, é. É verdade. Desculpe. Sim, é cinco, menos ou é igual a quatro. Não, não é, isso é falso. Então, observe como estamos
obtendo esse resultado. Verdadeiro ou falso quando
se trata dessa condição. Agora, deixe-me desfazer um
pouco para
voltar às nossas
declarações if anteriores. Isso é exatamente o que está
acontecendo aqui. Então, a afirmação
deles é basicamente avaliar
essa condição
, basicamente avaliar
essa condição
, resumindo-a em verdadeira ou falsa. Então, agora você pode estar se perguntando podemos simplesmente
dizer verdadeiro ou falso? E você estará correto se
dissermos que, se for verdade, imprimir, sim. Caso contrário, imprima,
não. Aí está. Então, nesse caso, não
precisamos mais da
variável num. Nesse caso, a verdade sempre
será verdadeira. Ótimo. Agora, que tal falso? O falso sempre será falso. Então, vamos
imprimir neste caso. Agora deixe-me mostrar mais
uma coisa. Você pode inverter. Você também pode fazer operações
com booleanos. Você pode dizer que pode fazer o
oposto para que não seja falso. E vamos, na verdade, executar isso
em um exemplo isolado. Não vamos imprimir bolas. Agora, mais uma vez, pause
o vídeo e
pense por alguns segundos no que isso
vai imprimir. Agora vamos fazer com que seja verdade. Agora, se não formos verdadeiros, o que será impresso como falso? Porque não ser verdadeiro é
essencialmente falso. Ótimo. Então, vamos dizer que, se
não for falso, imprimir, SIM. Caso contrário, imprima, isso pode ser um pouco artificial, um pouco confuso. Mas quando você pensa sobre isso, faz todo o sentido. Não é falso é verdadeiro. Então, vamos imprimir sim. E se eu disser que se não é verdade, não é verdade, não é verdade é falso. Então, essa pode ser a
divisão que não será cumprida. Isso será falso. Então, vamos
acabar nessa outra coisa. Então. Aí está. Espero que, se as declarações estiverem
um pouco mais claras agora, elas sejam extremamente poderosas. Eles são muito simples, mas você os usará como opções para orientar o
fluxo do seu código e permitir que seu
código seja muito versátil e
elegante de certa forma.
13. Introdução a funções: Tudo bem, então você percorreu um
longo caminho apenas em
seu primeiro projeto. E, na verdade, em
poucas linhas de código, você pode ver que
são apenas 31 linhas e há muito espaço
vazio entre elas. Você adquiriu algumas habilidades muito poderosas e muito úteis, habilidades
que permitirão
criar algumas variáveis. Chegar a esse ponto é
uma conquista muito boa. Você deveria se orgulhar de si mesmo. Então, parabéns por isso. Mesmo que algumas delas ainda estejam
um pouco confusas, observe
que, embora isso seja normal, isso é esperado, de certa forma, que sejam muitas informações e não se preocupe, porque e não se preocupe, porque
vamos reutilizar
todo esse conhecimento, todas essas informações
nos próximos exemplos e
nas próximas aulas. Mais uma vez, esse é um progresso
muito bom e isso significa que você está
pronto para subir de nível. Então, o que precisamos para
aprimorar nossas habilidades de codificação? Uma coisa que precisamos fazer é sair desse grupo
doado ou em Maya. E quero dizer, isso
é ótimo o suficiente. É bom o suficiente digitar coordenadas, como temos
feito até agora. Mas
deveríamos realmente usar um editor de texto ou, com habilidades de programação, funcionalidade
de programação. Isso não só permitirá que você
escreva código fora do Maya, mas também tornará sua experiência de
codificação um pouco
mais agradável e agradável. E será o primeiro passo
para aprender como criar seus próprios módulos ou
suas próprias bibliotecas para que
você possa importar seu próprio código, assim como fazemos com a biblioteca CMBS
menos própria. Mas antes de chegarmos a isso, precisamos aprender mais
um conceito. E esse é um dos conceitos
mais importantes que é conhecido como programação
orientada a objetos. E isso permitirá que você
aprenda a criar código escalável
e organizado. E isso realmente liberará o poder da
programação para você. E esse é o
conceito de funções. Vamos
sair do Maya por um
segundo para falar sobre funções. E espero que não se
importe que eu use tinta. Sei que não é a
melhor ferramenta de desenho, mas é boa o suficiente para
o que precisamos agora. Então, funções, há duas maneiras de pensar sobre funções. Um deles que
já mencionamos, que é pensar
neles como uma caixa preta. Deixe-me desenhar. Tentei fazer uma caixa aqui. Portanto, é uma caixa misteriosa
no sentido de que não
sabemos e realmente não nos
importamos com o que está acontecendo
dentro dela. Tudo o que sabemos e nos preocupa
é que isso requer uma contribuição. E isso, bem, as entradas
são funções. Nem sempre aceito uma entrada. Muitas vezes o fazem, mas não
é obrigatório, mas eles sempre, sempre
devolvem alguma coisa. E isso é uma palavra-chave. Retornar. As funções sempre
retornarão um valor que é a
saída da função. E, como já vimos, podemos armazenar esse
valor em uma variável. Agora, se o valor de retorno de
uma função não estiver definido, o padrão será fornecer
algo chamado nun, que é basicamente um valor nulo. Vamos aprender
sobre isso muito em breve. Então, vamos dar
um exemplo que deveria
ser familiar para nós. A função do cubo de poliéster. Então, mais uma vez, nós
realmente não sabemos e não nos
importamos com a forma como meu olho está realmente
criando esse cubo, certo? Tudo o que importa é que
ele precise de algumas entradas, como sabemos que ele precisa um nome para que possamos nomear o cubo. Perdoe minha caligrafia? E com base na documentação, também
sabemos que eles qualquer outro número de argumentos que usamos
para modificar a saída. E então o resultado
disso é, obviamente, um cubo. Mas, como já vimos, o valor retornado dessa
função é na verdade uma lista. E essa lista contém
dois itens. Um deles é o nome
do nó e o outro é
outro objeto, outra forma que é a construção real
do cubo. Mas até agora
só nos
importamos realmente com o primeiro
item dessa lista. Novamente, é assim
que você pensa sobre uma função
quando a está usando. Agora, a outra maneira de
pensar sobre isso é quando você está realmente
criando a função. E nesse caso, você será quem definirá o que está dentro
dessa caixa azul, dentro dessa caixa misteriosa. E isso é simplesmente código. Muito parecido com o código
que você está escrevendo até agora, com algumas
pequenas exceções, mas é basicamente um
conjunto de instruções. Basicamente, é uma coleção de etapas ou uma coleção
de instruções que podem ou
não receber uma entrada, fazer algo com a entrada
e, em seguida, dar a
quem está chamando a função, retornar um valor. Ou agora eles podem então armazenar em
uma variável, se quiserem. Por exemplo, vamos ver alguns
exemplos muito simples. Digamos que queremos
fazer uma receita de bolo funcionar. Receita de bolo. E digamos que quiséssemos incluir o número de pessoas. Digamos que n. N significa que o número de pessoas para as quais
queremos o bolo, a função assumirá
n, que é um número. Nesse caso, é um número inteiro. Um número inteiro é apenas
um número inteiro, como falamos antes. E então ele calculará
as quantidades,
os ingredientes e tudo o que for necessário para dar uma receita para esse
número de pessoas. E então, por exemplo digamos que ele
retorne uma string, que é apenas o texto, serão os textos, mas
a receita dentro dela. Agora, quando alguém estiver
usando essa função, chamará cake. Receita de bolo. Sabemos que ele está esperando n, que é um número inteiro. Agora n é você, você, você decide qual nome. Isso se tornará uma variável. Você decide como chamá-lo, mas sabemos que é um número inteiro, então ele precisa de um número. Então, digamos que queremos um
bolo para quatro pessoas. Agora, quem está
chamando essa função, pode simplesmente dizer
que pode simplesmente armazenar o
resultado disso em uma variável. Nesse caso, estou chamando
isso de receita variável. Então, o que está acontecendo
aqui é que estamos voltando
a pensar na função
como uma caixa que
não sabemos o que
está acontecendo dentro de você como
desenvolvedor, é claro, você sabe o que
está acontecendo lá dentro, mas outra pessoa usando a função
não precisa saber. Você pode até mesmo alterar
as instruções dentro
da função. E eles ainda simplesmente chamarão receita de
bolo com os argumentos que você define
a nova função. Então, o que vai acontecer é sua função receberá
essa entrada. Ele fará algum tipo de
codificação dentro dela para processar a receita e, em seguida, devolverá esse valor
ao usuário para que ele possa ser ignorado ou
armazenado, neste caso, nessa
variável chamada receita. Então, espero que isso esteja
claro o suficiente. Agora, vamos
criar algumas funções reais. Então, quando você está
criando uma função, na verdade
ela é chamada de definição. Uma função. Tipo
significaria morte, cena definida mais na
definição, espaço D, E ,
F e depois o
nome de sua função. Vamos fazer algo simples. Digamos que vamos criar uma
função que diga olá. Então digite, diga sublinhado Olá, agora abra e feche os parênteses. E vamos começar de forma simples. Vamos ter uma função que não
receba nenhum argumento,
nenhuma entrada. E depois dois pontos, pressione Enter. Você notará que meu automaticamente
me deu esse recuo. Sempre que você estiver
criando uma função, qualquer coisa que entre na
função precisa ser recuada. Lembre-se de que são quatro espaços. Ou, no caso do editor de
scripts, pode haver uma guia em todo o código,
todas as instruções, como mencionamos anteriormente, que queremos ter
na função serão
recuadas dessa forma. Então, vamos enviar uma mensagem, e essa mensagem
será mantida muito simples. Vamos apenas dizer olá. Agora, não vamos devolver
nada
agora , vamos simplesmente
imprimir esta mensagem. Excelente, então vamos
experimentar isso. Vamos executar esse código. Sem erros, mas nada aconteceu. Acabamos de
recuperar nosso código constitucional. Digamos, vamos escrever
uma função aqui embaixo. Agora, não vamos ligar para ele ainda. Vamos escrever isso,
ver o que acontece. Nada está acontecendo. Agora vamos imprimir a função
real apenas para inspecioná-la um pouco. Interessante,
temos essa coisa estranha. Diz função: diga olá em algum número aleatório, aparentemente
aleatório. Então, o que está acontecendo aqui é que, como mencionei antes, mencionei a ideia de programação orientada a
objetos. Uma função, e quase tudo em Python, é chamada de objeto. Agora, não se preocupe muito com essa definição de objeto. Mas, basicamente, saiba que essa função agora
existe na memória, é por isso que obtivemos esse número. Sua função é basicamente
salva em um novo rum. Novamente, não se
preocupe muito com esses detalhes técnicos. Mas saiba que essa
função existirá, mas ela
ainda não está nos dando seu valor até chamarmos a função. Então, vamos chamar essa
função e executar o código. Excelente. Agora, na verdade, está dizendo olá. Agora falamos sobre valores de
retorno. Então, vamos verificar o que essa
função está retornando. Vou digitar resultado igual a, dizer olá, abrir e
fechar parênteses. Agora vamos armazenar o
resultado ou o valor
de retorno dessa função nessa
variável chamada resultado. Vamos imprimir isso. Imprima os resultados. Excelente. Então, ainda estamos dizendo olá, como você pode ver aqui. E temos essa
coisa chamada none. Como mencionei antes, desconhecido é que é como um valor nulo, mais ou menos como um valor vazio
ou vazio. Você pode tratar um não
semelhante a um falso,
o que, de certa forma, é
como um falso em um booleano. Mas é seu próprio tipo
especial de valor. Na verdade, é muito útil. de não estar vazio
é, na verdade, muito útil para verificar
se você está
recuperando ou não um valor de uma função, como veremos em breve. Mas se você se lembra, eu disse que as funções sempre retornam um valor. Agora, como não estamos retornando nada
explicitamente, python assumirá como padrão
o retorno desconhecido. Portanto, isso é semelhante a dizer
explicitamente não retornar nenhum. Então, vamos mudar
isso um pouco. E em vez de
imprimir a mensagem, vamos devolvê-la. Agora observe que
não há parênteses aqui, é apenas uma mensagem
espacial retornada. Agora, uma coisa a notar é que retorno significa o fim
da função. Ele não só
retornará o valor, mas também
encerrará a função. Ou vamos ver
isso em um segundo. Vamos executar isso. Vou me livrar dos resultados
da impressão por enquanto. E vamos executar esse código. Deixe-me limpar a janela de saída primeiro. Vamos executar esse código. Nada acontece de forma semelhante. Por que não? Bem, a razão é porque não
estamos mais imprimindo. Estamos simplesmente
retornando a mensagem em vez de exibi-la. Agora, se realmente imprimirmos o
resultado que temos aqui, atribuímos novamente, mais uma vez, o valor de retorno
da função a essa
variável chamada resultado. Vamos executar esse código. Agora, a palavra imprimindo
algo excelente. Agora dizemos olá. Ótimo. Então, vamos expandir a função. Mas antes de fazermos isso,
eu queria
mostrar como o retorno significa
o fim da função. Vamos imprimir após a devolução,
vamos imprimir algo. Digamos que depois do Retorno. E vamos apenas executar esse código. Você vê que
ainda estamos imprimindo olá, mas na verdade
não estamos chegando a esse ponto, mais
uma vez é porque
return significa o fim da função e ela
retornará esse valor. Só para deixar isso
ainda mais claro, o que acontece se, em vez
de retornar uma mensagem, eu retornar um número. Vamos devolver 100. Agora. Faça uma pausa e imagine
o que vai acontecer aqui. Mas acho que está muito claro. Vai imprimir
100 e estamos ignorando
completamente
essa mensagem aqui em cima. Ótimo. Então, vamos voltar à mensagem de
retorno. E vamos expandir um pouco essa
função. Agora, vamos torná-lo um
pouco mais sofisticado. E vamos adicionar um
argumento por meio disso. Digamos que quiséssemos
dizer olá para alguém. Digamos, bem, você
aceitaria uma variável ou um argumento chamado nome e
gostaríamos de dizer olá ao nome. Agora, vamos esperar que o
nome seja uma sequência de caracteres, assim como esse sujeito aqui. Então, quando você tem duas sequências, você pode
juntá-las simplesmente dizendo mais, podemos dizer olá mais nome. Vamos executar esse código novamente. Oh, ótimo, nós temos,
nós temos um erro. Por que ele, vamos ver
o que está acontecendo lá. erro diga olá, aceita
exatamente um argumento, zero dado exatamente, porque agora estamos
esperando uma discussão. Então, vamos passar um nome. Digamos que Adam. E eu, mais uma vez, como dissemos, o nome será uma string. Então, agora nome. Depois de executarmos isso, observe como o nome assumirá a
forma de anime. Basicamente, estamos dizendo, ok, então essa variável chamada
nome será Adam. Então agora deveríamos
dizer olá e Adam. Agora vamos fazer isso
e ver o que acontece. Excelente. Estamos perdendo um espaço. Vamos apenas adicionar esse espaço depois do Hello e executar
esse código novamente. Linda. Isso é excelente. Uma coisa a notar
também é que essa variável aqui só existe dentro do
escopo dessa função. Agora, há outra
palavra específica que estou usando. Estou usando isso intencionalmente. Escopo. Escopo significa que essa
função, desculpe, essa variável, seja a
variável de nome ou até mesmo essa variável de
mensagem. Isso existirá somente dentro
do escopo da função. Eles, basicamente, vivem
enquanto a função funciona. Então, só para esclarecer esse ponto, para transmitir o ponto, vamos imprimir o nome
no que acontece. Temos um erro
porque o nome não está definido porque o nome não existe fora da função. Quando nos lembramos novamente, tudo o que está dentro
da função vive após esse recuo. Quando sairmos
dessa indentação, terminamos. Não temos mais acesso
a isso. Agora, se eu colocasse essa impressão dentro da
função, o que aconteceria? Agora estamos imprimindo átomo
aqui, que é o nome. E se mudarmos o nome
aqui também, como George, por exemplo, agora estamos imprimindo George. Excelente, então vamos expandir
isso um pouco mais. E vamos começar uma segunda discussão. Digamos que
quiséssemos dizer olá
para o nome completo da pessoa. Vamos adicionar mais uma variável. Vamos chamar isso de sobrenome.
Vamos executar isso. Agora, temos outro erro porque são necessários dois argumentos. Só estamos passando em um. Isso faz todo o sentido. Digamos George Smith, sobrenome
muito comum. Então, vamos passar
esse sobrenome. E vamos, vamos executar este. A única maneira
de dizer olá para George, é claro, porque
não adicionamos o sobrenome. Agora, poderíamos fazer isso, poderíamos fazer mais o LastName. E isso vai funcionar. Mas, novamente, não
temos espaço. Poderíamos criar outra string com apenas um espaço nela e continuar
adicionando um sinal de adição. Isso vai funcionar. Mas isso está ficando um
pouco prolixo. Isso é digitar demais. Então, vamos aprender outra maneira
de juntar cordas. Deixe-me me livrar de todas
essas variáveis positivas. Agora, digite comigo aqui, vamos dizer Olá,
espaço, abra e feche
colchetes. Para deixar isso claro,
esses colchetes não são parênteses, são
colchetes, tipo de espaço. E então colchetes ondulados novamente. Agora vamos dizer no final
da string, vamos dizer formato de ponto. Abra e feche parênteses,
vamos dizer nome, vírgula, sobrenome, sobrenome. Então, pare um segundo para fazer uma pausa e imaginar o que
vai acontecer aqui. Pode ser um
pouco confuso ou pode ser muito claro. Mas o que vai acontecer
é que esse colchete, então essas chaves se tornarão espaços reservados quando usarmos
essa função de formato de pontos, Python sabe que espera que algo substitua a largura desses
colchetes. Nesse caso, há
dois colchetes e duas variáveis. Então, o nome será, se esses colchetes
serão substituídos pelo nome e esses colchetes de segunda cor serão substituídos pelo sobrenome. Vamos tornar nossa mensagem
um pouco melhor. Dizer olá ao nome e
sobrenome. Excelente. Agora, nossa mensagem ou resultado é
dizer olá ao julgamento. Ótimo. Espero que esteja claro até agora, mas só para deixar
um pouco mais claro, vamos ver
outro exemplo. Eu estava pensando em algo
completamente não relacionado à animação para tentar torná-la
um pouco interessante, divertida e talvez mais clara vamos fazer algo
relacionado às suas finanças. Se você já ouviu falar desse movimento de
pagamentos chamado Fire, que significa
independência financeira, se aposente cedo. É claro que não
vamos falar
sobre finanças. Eu não sou um especialista financeiro. Isso não é de forma alguma
nenhum tipo de conselho. Este é apenas um exemplo um pouco
divertido. Existe esse tipo
de cálculo de que essas pessoas demitidas basicamente dizem, ok, se você quer saber quanto
dinheiro precisa investir para se aposentar mais cedo ou
se aposentar em algum
momento, elas basicamente dizem: pegue quaisquer que sejam suas despesas
anuais e faça com que
sejam quatro por cento de seus investimentos
ou você está economizando. A ideia por trás disso é
que o mercado em geral, como o mercado de ações ou
algo como títulos ou algum tipo de investimento,
proporcionará um retorno de 4% a cada ano. Então, se você pode viver com
esse retorno de 4% a cada ano, você pode basicamente viver desses investimentos por
alguns anos. Então, por exemplo digamos que
suas despesas anuais sejam de $40.000, por exemplo , $40.000 são
4% de $1 milhão. Isso é muito dinheiro. Mas, novamente, isso não é
uma classe financeira. Isso significa que você
precisa
investir $1 milhão e todo ano
receberá 4% disso, ou seja
, seus 40,
$40.000 necessários para cobrir suas despesas como
quaisquer que sejam suas despesas. Então, vamos escrever essas
calculadoras apenas como exemplo. Mais uma vez, digite comigo definição
def com a
descoberta do espaço da função. E vamos nomear a função,
digamos, disparar,
sublinhar, sublinhar, calculadora, abrir parênteses,
fechar parênteses. Excelente. Então, agora, qual é a nossa contribuição? Queremos despesas, certo? Queremos calcular
quanto investimento você precisa. Amor, vamos receber as despesas e
devolver quanto dinheiro você precisa investir para viver dos 4% desses
investimentos, certo? Então, digamos que
o valor será igual e
essas serão as
despesas de cálculo divididas por 4/100. E vamos devolver esse valor. Então, vamos simplesmente imprimir o
resultado dessa função. Agora, as despesas, é claro, precisamos
substituí-las por um número. Serão 40.000. E vamos apenas executar esse código. Nós temos 100. Agora, isso está claramente errado. Vamos ver o porquê. Na verdade, parte do motivo pelo qual eu queria que um
exemplo com números mostrasse outro aspecto
peculiar dessa versão do Python. Deixe-me abrir uma nova
guia e vamos fazer isso. Vamos fazer esse
cálculo juntos. Então, digamos que estamos
dividindo quatro por 100. Vamos dizer,
basta armazená-los em uma variável chamada R.
Vamos imprimir esse resultado. Oh, desculpe, isso
não é uma divisão. Um personagem que fez
mal a mim é a
barra para frente para dividir. Ótimo. Então, novamente, isso está claramente errado. Então, o que esperamos
dessa divisão se você
dividir quatro por 100, ou estamos esperando 0,04, certo? Então, o que está acontecendo aqui é que estamos dividindo
dois números inteiros. E agora, a
qualquer momento, para qualquer versão abaixo de qualquer
versão do Python abaixo de Python três, quando você divide dois números inteiros, você recebe um inteiro de volta, o
que significa que o valor
está sendo truncado. O que isso significa
se eu tiver 1,5, por exemplo, lembre-se de que eu disse
antes disso um número inteiro. Basicamente, um número inteiro que não tem pontos decimais. Então, como estamos dividindo
dois números inteiros, se isso for um resultado 1,5, esse número será truncado e teremos apenas um. Basicamente, estávamos apenas
removendo os decimais. Agora, quando é
difícil quando você tem um ponto decimal que
é chamado de flutuação. Agora, mais uma vez, isso é int, é apenas um número inteiro. E um flutuador tem decimais. Então, o que precisamos
fazer para obter esse resultado? Bem, precisamos dividir
um número inteiro por float. Aí está. Isso é mais
parecido com o que estamos esperando. Isso também funciona ao
contrário. A propósito, também podemos dividir um flutuador por um inteiro,
desde que um dos
números esteja flutuando, o Python fornecerá
o valor correto. Mas se não for um número flutuante, mais
uma vez, se for
apenas um número inteiro, ele o truncará, na verdade, está
dando a você o resultado. E então ele o
trunca porque acha que você está
pedindo uma grade de números inteiros. Então, essa é uma peculiaridade
importante que você encontrará em Python. E se você está
tentando fazer cálculos e se deparar com esse problema, pode ser extremamente confuso, mas saiba que geralmente é uma boa ideia simplesmente usar 0,0 para transformar um número em um flutuador evitar completamente esse
problema. Então, sabemos que precisamos de outra. Esse é o
valor real de que precisamos. Vamos substituí-lo aqui. Mais uma vez, isso é
apenas matemática e você
realmente não precisa aprender muita matemática ou o que precisamos fazer? Portanto, não se preocupe com
as especificidades disso. Saiba que estamos
basicamente calculando o que é, o que é isso. Os quatro por cento das excelentes
despesas divididas por 0,40, 0,04 nos levarão até lá o valor
final de que precisamos. E isso é $1 milhão. E observe que aqui temos um
carro alegórico, o que é ótimo. Não importa se é um número flutuante e um número inteiro
nesse caso. Vamos testá-lo novamente. Digamos que você precise de $80.000
para sobreviver um ano inteiro. Então você precisaria, é claro, 2 milhões de dólares. Aí está. Mais uma vez, isso não é
uma discussão financeira. Isso é só um exemplo. Mas eu queria te mostrar
esse lado peculiar do Python. Somos cargas e
divisões inteiras podem ser um
pouco complicadas. Agora, antes de prosseguirmos, há uma última
coisa sobre a qual quero falar, e isso é extremamente importante. E há uma
documentação que mencionei antes de que não há
outra para criar strings. Você pode usar
aspas simples, aspas duplas ou pode usar aspas triplas. Agora, eu também mencionei
que aspas triplas são reservadas para algo
chamado docstrings. Docstrings é basicamente a
documentação de uma função. O que quero dizer com isso? Tipo significaria aspas
triplas, 123. A propósito, são três
aspas duplas. E então vamos digitar uma mensagem. Digamos que isso
calcule quanto
você precisa para calcular o valor da
aposentadoria, por exemplo, o valor aposentadoria. Agora digite e outras três aspas, 123, mas três aspas duplas.
E vamos executar esse código. Mesmo resultado. Portanto, isso é apenas uma string
e isso não está realmente afetando seu código de forma alguma. Mas é extremamente útil para algo que já
vimos antes. Agora vamos lembrar
esse comando de ajuda. Vimos essa ajuda funcionar. Vamos executar nossa função dentro
dessa função de ajuda. Então, agora, mais uma vez, preste atenção, não estou
chamando essa função. Não estou abrindo e fechando os parênteses e simplesmente escrevendo o nome
da função. Então, vamos executar esse código. Ajude a abrir parênteses,
calculadora distante, parêntese fechada. E você vê que diz para ajudá-los a funcionar para uma calculadora
no Módulo principal. Isso significa apenas que você está dentro. Sempre que você não tiver um módulo que é basicamente
um arquivo Python, veremos
isso em breve. Isso apenas chama isso de malvado, então não se preocupe muito com
essa parte, mas ela está basicamente dizendo
o nome da função. E você pode ver aqui que está te mostrando uma
pequena ajuda. Então,
se alguém estiver usando sua função
, poderá ajudar nela. E eles podem receber uma
pequena mensagem de você, o desenvolvedor dizendo a eles o que fazer ou o que a
função está fazendo. Agora, outra coisa que é muito importante quando
se trata de docstrings. E vamos
usar isso. Vamos fazer
isso de agora em diante, dizendo que R
está mencionando o que é
esperado nesta entrada. Então, agora lembre-se,
mais uma vez, por causa do escopo, essa ou essa
variável só existe dentro da função. E como é Python, podemos estar transmitindo, fixando qualquer coisa
que quisermos, essa função. Portanto, é importante mencionar na documentação
o que
se espera que seja, o que quer que essa função
espere receber. Para fazer isso, você pode simplesmente
dizer despesas ou queimar, fechar parênteses e digitar o corpo que espera
receber esse caso, digamos que seja um número inteiro. Na verdade, há
maneiras diferentes de escrever isso. Vou me limitar
a um, ou seja,
é um
padrão convencional do Google. E o que eles fazem é dizer args, o que tem sido argumentos de dois pontos. E então vamos
recuar isso nos argumentos. Vamos escrever mais uma vez
as despesas. Entre parênteses. Vamos escrever o
tipo dessa variável, e isso será um número inteiro porque estamos esperando
um número, certo? Em seguida, vamos escrever
um pequeno comentário sobre isso. Digamos que suas despesas anuais. Mais uma vez, tudo isso
é apenas documentação, mas ajudará quem
estiver usando essa função, que poderá ser você mesmo
em alguns meses, saber o que se espera. Agora, outra
coisa útil
é mencionada sobre qual é
o valor de retorno. Vamos
digitar retorno de dois pontos. E então eu vou digitar o valor que
foi retornado. Nesse caso, sabemos
que é uma bóia. Vamos executar isso de novo. Ótimo. Mais uma vez, a
função de ajuda está nos fornecendo todas essas informações
aqui. Depois de executar a ajuda
de alguém que está usando sua função
saberá, ok, ela tem uma variável
que espera um número inteiro. E posso esperar uma flutuação
em troca de um valor
de retorno. Então, espero que isso ajude a esclarecer quais funções
são um pouco mais. Esta foi apenas uma breve
introdução a eles. Agora, vamos transformar nosso
código em uma função.
14. Transformar código em uma função: Ok, voltando ao nosso código. Agora vamos transformar todo
esse código em uma função para que seja um
pouco mais reutilizável. Agora que sabemos quais
são as funções, como criá-las, podemos facilmente transformar esse trecho de código
em uma delas. Pode parecer muito, mas na verdade é muito fácil transformar tudo isso
em uma função. Mas primeiro vamos pensar, vamos pensar no que
precisamos que a função faça? Vamos começar com os
argumentos da entrada, o que você gostaria que fosse
a entrada? Provavelmente queremos
deixar quem está usando a função ao lado que tipo de PrEP
deseja fazer, certo? Imagino que
também queiramos que eles decidam o nome do
controle e a nova geometria. Mas vamos manter as coisas
simples por enquanto. Digamos que tomamos
a decisão executiva de simplesmente sair,
dar
a eles o controle sobre
o tipo de empunhadura. Vamos fazer isso. Digamos que criemos uma
função novamente para começar a definir uma função
que você digita def space. Agora vamos nomear a função que
vou nomear. Ela
cria sublinhado, sublinhado, reg, abre
e fecha parênteses. Deixe-me tornar isso um
pouco maior. Agora, precisamos da entrada. Bem, é muito fácil. Podemos simplesmente reutilizar
esse nome aqui. Já que estamos, já que já
estamos usando esses nomes
em todo o código. Aqui embaixo. O que estamos realmente
ouvindo são declarações. Por que não reutilizar isso e
facilitar as coisas para nós mesmos? Sublinhado do suporte. E então fecharemos
parênteses e depois dois pontos. E agora sabemos que essas instruções para estarem
dentro da função, precisamos recuá-las. Como nós, como
criamos essa indentação? Podemos destacar todo esse código e simplesmente
pressionar a tecla Tab. Aí está. Isso é tudo. Isso é tudo que você precisa. Acabamos
de transformar tudo isso em função. Ótimo. O que fazemos com isso aqui em cima? Nós realmente não precisamos
mais dele, então podemos excluí-lo. Agora todo esse código
está dentro de uma função, então vamos executá-lo e
ver o que acontece. Bem, nada está
acontecendo e me desculpe, isso está ficando um pouco
difícil de ler porque o código está crescendo,
mas é ótimo porque você está
escrevendo mais código. Então, nada realmente aconteceu. Isso é um, tudo isso é apenas a definição
da nossa função. Lembre-se de que precisamos chamar essa função para
poder usá-la. Bem, vamos, vamos
fazer isso aqui embaixo. Vamos chamá-lo aqui embaixo. Crie o apropriado,
deixe-me digitar, isso cria um parêntese aberto e
fechado do equipamento. E agora lembre-se de que
estamos esperando uma contribuição. Nesse caso, é
chamado de tipo de adereço. Estamos esperando uma
string e, na verdade, vamos escrever um pouco
de documentação para
nossa função por meio de cadeias de caracteres de documentos. Uma vez que eu me lembre de aspas
triplas. E, a propósito, também
podem ser
aspas simples. Aspas simples triplas, aspas
simples ou
três aspas duplas. Eu prefiro os duplos. Vamos escrever uma carta
de recomendação. Vá sem controle. Então, eu vou apenas
escrever, criar um pedaço
de geografia com controle. Agora, vamos escrever
nos argumentos que são
necessários args, dois pontos. E então estamos
esperando o tipo de adereço. Sabemos que isso é uma corda. E sabemos
que pode ser um cubo, uma esfera ou um cone. Mais uma vez, tudo isso é
apenas documentação. Isso é apenas para
quem precisa usar a função para obter um
pouco de ajuda. Não é necessário que
o código funcione, mas é extremamente útil. E eu diria que é um hábito
muito, muito útil, porque ele
facilitará muito a
vida útil do seu revestimento. Depois de ter a documentação, honestamente, você se
diferencia de qualquer pessoa, de muitas pessoas, que o código é tão útil e é muito apreciado
por outros programadores. Eu recomendo que você adquira o
hábito disso. Às vezes pode ser frustrante, às vezes é um trabalho extra. Mas, a longo prazo,
vale muito a pena. E retorne, bem, ainda não
devolvemos nada. Portanto, não vamos adicionar o valor de
retorno agora. Vamos deixar como está. Ótimo. Então, sabemos que estamos esperando uma corda e sabemos que
temos essas opções:
cúbica, esfera ou cone. Vamos digitar, na verdade, desculpe, sabemos que o padrão é cube. Então, vamos acrescentar isso ao
ouvir a sequência de documentos. Vamos digitar cubo, por exemplo vamos apenas executar esse código. Aí está. Excelente. Excelente. Agora, vamos
criar outra coisa. Agora você vê como
é lindo ter uma função. Você não precisa copiar e
colar todo esse código. Você simplesmente pode copiar
essa função e colá-la na linha abaixo. Agora, digamos que
também
queremos ter um cone . Isso é tudo que precisamos fazer. Basta executar esse código. Agora você tem um cubo, agora você tem um cone. Excelente. Isso é tudo que você precisa fazer. Você tem uma função
e agora pode reutilizar seu código com muita facilidade. Digamos que, só por
um motivo, vamos criar uma esfera
também. Porque por que não? Porque nós podemos fazer isso. Aí está, esfera, cubo e conta. Linda. Agora, por uma questão de conclusão e curiosidade, deixe-me executar esse código novamente. Está ficando um
pouco mais confuso. Gosto de sempre que você cria a sonda
se sobrepõe à anterior. E se pudéssemos
nos organizar um pouco? Agora você vê que temos
essa função de movimento. Vamos,
vamos passar para as instruções à medida que
as criamos. Então, vamos pegar isso e
transformá-lo em Python bem rápido. Eu sei que esses são
muitos argumentos. Mais uma vez, como Maya
nos deu, obtenha o comando malloc. Vou
improvisar um pouco. Estou apenas
transformando isso em um comando Python. Mas antes de fazer isso, precisamos saber
o que estamos movendo, certo? O que estamos movendo? O controle? Bem, não temos, não
estamos realmente
devolvendo o controle. Por exemplo, se eu armazenar isso como em
uma variável chamada cubo, deixe-me me livrar da esfera de Conan, aquele cubo de impressão simples. Nenhum, é claro que não se sabe porque não
devolvemos nada. O que seria
bom devolver? Acho que eles controlam o nome
do controlador
criado. Seria bom que
ele retornasse para que, uma vez criado
o bloco, o usuário saiba quais são
os controladores para que
possa manipulá-lo. Esta é uma adaptação que estou fazendo agora, à medida que avançamos. Então, o que queremos retornar é na verdade, o nó do
controlador criado por West, certo? Então, nó de controle, retorne
o nó de controle. Antes que esqueçamos, já
que estamos devolvendo isso, vamos adicioná-lo
à documentação. Volte e, na verdade, estamos
voltando. Então, vamos apenas adicionar o
tipo que está sendo retornado. Sabemos que esse é o
nome do controle. Então esse é o nome
da string do nó de controle criado. Esta é apenas uma nota para
torná-la um pouco mais óbvia. Excelente. Então, deixe-me deletar esses
dois raios aqui. Vamos executar esse
código mais uma vez. Controle. Eu me sinto correndo de
novo, controle um. Aí está. Então, agora
estamos recebendo o nome disso,
esses controles. Agora, deixe-me ser mais explícito. Deixe-me renomear essa
variável chamada cubo. Deixe-me renomeá-lo como kube, control. Ótimo. Agora podemos usar a função
move. Então, vamos pegar isso
e colar aqui. Se isso ficar confuso, tente acompanhar. Estou improvisando aqui, mas sei que poderíamos mover esse
objeto depois de criado. Então, digamos, suponhamos que o ponto S se mova. Isso parece correto.
Está destacado aqui. Agora, o que estamos movendo? Bem, vamos mover
o controle Kube. Então, vamos usar isso
como um primeiro argumento. Controle de Kube, sem espaço. Agora eles, o valor que é movido é isso,
isso aqui. Vamos usar esse argumento
e ver o que acontece. Vamos nos
livrar desse traço r. Eu vou me
livrar desse traço 0 S. Vou usar esse W, D. Não
tenho muita certeza do que é. Mas lembre-se de que temos
nomes longos e nomes curtos, então vou
presumir que esse é o
nome abreviado de uma discussão. Vou remover
o traço nele. E lembre-se de
que, em Python , usamos iguais, então
vamos dizer que w d é igual a. E, como vimos antes, esses são três valores. O que fazemos quando
vemos três valores? Bem, presumimos
que seja uma lista. E uma lista é um grupo de itens separados por uma
vírgula, como já fizemos. Então, vamos aplicar esse e
aquele número por uma vírgula. E então o próximo
número será uma vírgula. Imaginei que esses são, esses são o eixo, isso é x, y e z, ou z, coma, coma. E depois feche a lista. Não precisamos do ponto e vírgula. Agora precisamos fechar a
função para podermos chamá-la. Excelente. Então, use esse valor. Apenas tenha paciência comigo
enquanto eu improviso isso, mas isso é bom para você. Você está me vendo experimentar coisas, a vida de certa forma. Vou me
livrar dessa impressão digital. Vamos apenas criar esse lag necessário passar um argumento
booleano. Ok, interessante. Digamos que w d é igual a verdadeiro. Na verdade, deixe-me,
deixe-me remover isso. Como eu disse, eu estava improvisando. Vamos tentar a mesma função sem nenhum desses argumentos. Vamos passar três
valores para essa função. Vamos ver o que acontece. Vou passar
esses valores sem que seja uma lista. São basicamente
três argumentos. Então, remova isso. Aí está. Isso funciona. Ok. Então, eu estava completamente errado. Peço desculpas por isso e
peço desculpas se isso foi um
pouco confuso. Eu não tentei isso com antecedência, mas acho que foi
bom para você me
ver tentar todas
essas vidas, porque será parte de sua experiência
experimentar coisas
até que funcionem. Às vezes, algo
pode
parecer um pouco óbvio, mas,
como você viu neste caso, claramente não era óbvio. Sim. Então essa função de movimentação, do jeito que está funcionando, está trabalhando na última
coisa que selecionamos. Agora sabemos que selecionamos esse nó de controle
antes de ser criado. Desculpe, depois de ter sido criado. Então isso estava sendo selecionado. Então, tudo o que estamos dizendo é mover o objeto selecionado,
seja ele qual for. E essa função de
movimento é usada nesses três valores, que serão x, y e z. Claro, como vimos, deixe-me fazer isso de novo
só para mostrá-la. Tem mais, mais argumentos. Isso provavelmente significa relativo. Isso, eu não tenho certeza do que é, mas não é
importante agora. Então, vamos pegar, vamos
continuar com isso. Deixe-me fazer desta
uma boa sexta rodada. Sabemos que funciona. Então, digamos que quiséssemos
criar um cone cúbico. Vamos criar um cone. E você provavelmente está
pensando que se não estamos mais
usando esse controle, não
precisamos mais dele. Isso está correto. Isso está correto. Nós
realmente não precisamos mais disso, então eu vou me livrar disso. Mas acho que ainda é
uma boa ideia manter o valor de retorno para
que eles controlem. Mas de qualquer forma, isso é, esta é a sua ferramenta,
essa é a sua função. Portanto, sinta-se à vontade para modificar
isso da maneira que quiser. No final do dia,
você tem controle total de tudo isso: criar um cubo. Vamos criar um cone. A menos que
não seja realmente mover o cubo. Nós vamos nos livrar deles. Siga em frente no cubo. Vamos criar um cone, vamos mover o cone. Tudo o que queremos é
a distância entre eles. E então vamos criar uma esfera. E vamos mover esse medo
duas vezes mais do que o cone. Então, vamos movê-lo para 12 unidades,
menos 12ª unidades. Ok, vamos
terminar com isso. Vamos executar esse trecho de código. E aí está. Cubo, cone, esfera,
todos distantes. Bem apresentado, pronto para ser animado por você ou por qualquer outra pessoa. Ótimo, então, obrigado
novamente por me acompanhar em
todas essas experiências. Espero que tenha sido
útil para você, e nos vemos
na próxima lição. Obrigada.
15. PyCharm - Instalar e configurar: Vou te mostrar como
instalar o Unsetted by charm porque é isso que
você vai me
ver usar no
resto deste curso. Obviamente, você pode usar qualquer outro IDE ou
editor de texto que desejar. Se você quiser usar o Sublime, seja uma nota de código do VS, mas se quiser, são todas ferramentas. Todos eles fornecem
esse resultado final. Eu recomendo o PyCharm. É muito bom para
Python e foi realmente feito para desenvolvedores de
Python. O
site deles será jet, brains.com, dash
pie, same PY, charm. Eu vou fornecer um
link para isso, é claro. Ou com muita facilidade também. Você pode simplesmente pesquisar novamente o
PyCharm no Google, charme PY. E o primeiro link que
você obtiver deve estar lá. O mesmo resultado
na primeira página. Clique no botão Download. Você terá duas opções. Escolha a versão da comunidade. Há uma
versão profissional pela qual você pode pagar. Mas, honestamente, a integração
da comunidade é mais do que suficiente. Então, vamos baixar isso. Depois que o arquivo for baixado,
basta clicar nele. Isso abrirá o instalador. Agora clique em Avançar. Próximo. Eu recomendo criar um atalho e eu recomendo criar
essas associações. Dot p-y é simplesmente a
extensão para arquivos Python. Então, eu recomendo usar isso. Você pode deixar todo o
resto desmarcado. Clique em Avançar. Instalar. Ok, e no final da instalação
você terá essa janela. Clique em executar PyCharm Community
Edition e clique em Concluir. Se você tem essa janela, estou recebendo isso porque
eu tinha uma versão anterior, mas só vou clicar em, não importe as configurações. Clique em OK. E devemos
abrir o pycharm agora. Depois que o PyCharm for aberto,
você verá essas janelas. Você pode simplesmente abrir
arquivos com ele. Mas eu recomendo a criação
de um novo projeto porque geralmente é feito
para trabalhar com, com projetos. Embora você também recomende fazer este
passeio pelo shopping, se quiser. Por enquanto, vamos
fazer a configuração básica. Então, vamos clicar em novos projetos. A localização deles. Eu recomendo que você use
a pasta de scripts do Maya. Então, isso estará na unidade
UC, sua pasta de usuários. Mais uma vez, veja os usuários, seu nome de usuário e você
pode acompanhar aqui o caminho que estou seguindo
e depois ir para Documentos. Agora, em vez de
documentos terá sua pasta Maya. E então, dentro dessa pasta,
há uma pasta de scripts. Vamos usar
isso um pouco. Então, vamos clicar em OK nisso. Aqui embaixo você
tem mais algumas opções. Escolha um novo ambiente
usando um ENV virtual e virtual. Esse é um ambiente virtual, mas não se preocupe
muito com isso. Isso é algo que o
pycharm criará, mas não
vamos realmente usar agora. Então, tudo isso nos
deixa uma série. Desculpe, eu não
queria verificar isso. Deixe
todo o resto. A série na parte inferior. Crie o PY principal, script de boas-vindas. Vou marcar essa caixa
para que você possa ver algo quando iniciarmos
um projeto, clique em Criar. E o PyCharm vai
começar a preparar algumas
coisas para você. Pode levar alguns minutos. Apenas espere um pouco. Uma vez feito isso,
você verá rápido tour do que
você vai ver. Esta é a janela
do seu projeto. E essa é realmente a pasta em que seu projeto
ficará. Deixe-me mostrar uma coisa,
o que está acontecendo aqui. Se você entrar no Explorador de Arquivos, se for para a pasta
Documentos, vá para o Maya e depois para os scripts. Isso é o que você está
vendo aqui, que é o mesmo gráfico circular de
pastas e criou essa pasta
chamada idea dot idea. Você pode ignorar isso. Ele também criou essa pasta
v, v ENV. Você pode ignorar isso. Na verdade, você pode
excluí-lo se quiser, mas por enquanto isso
realmente não nos incomoda, então podemos deixá-lo lá. E como
marcamos essa última caixa, temos esse arquivo main.py. A única razão pela qual verifico isso é apenas para criar um
arquivo Python para você ver. Mas vamos
excluir isso muito em breve. Mais uma vez, isso está dentro da pasta de
scripts do Maya de
seus documentos. Você pode criar esse
projeto em qualquer lugar que quiser. Mas, como
trabalharemos dentro dessa
pasta de scripts em breve, recomendo usar esse local. Mais uma vez, essa é
basicamente sua árvore de arquivos. É só para ajudar você a navegar. Este é o arquivo Python que
vamos excluir em breve
porque realmente não precisamos. Então, vamos definir algumas
configurações antes de começarmos. Vá para o menu Arquivo e,
em seguida, vá até as configurações. Você também pode pressionar Control Alt, Alt S para abrir a janela
Configurações. Agora, há duas configurações que
queremos atualizar. Vamos manter as coisas simples. O primeiro está
na seção anterior. Expanda isso em seu general. A primeira caixa de seleção que você vê alterar o tamanho da fonte
controlaria esses modos. Vamos apenas marcar essa caixa. Isso é apenas para imitar a funcionalidade
em que podemos aumentar ou diminuir o
tamanho da fonte e sair com controle e a
roda do mouse. Agora, a próxima configuração, vá até a seção Ferramentas, expanda-a e, em seguida role para baixo até as ferramentas
integradas do Python. Agora, na parte inferior há um boato
na seção docstring de que uma docstring é uma string
que podemos colocar em uma função que atua
como documentação, daí o nome docstring. No formato docstring,
vou escolher o Google. Esse é um padrão
que eu gosto de usar. Mais uma vez, a escolha é
sempre sua. Você pode escolher outro
formato se quiser, mas
vou usar esse para o resto desses exemplos. Depois de escolher
isso, clique em Aplicar, clique em OK ou enviando
o que alteramos. Vamos testá-lo. controle no volante e as notas do mouse o tornam maior e menor,
o que é muito bom. Deixe-me excluir todo esse código porque realmente não precisamos dele. Por exemplo, vamos
criar uma função, apenas uma função de exemplo, exemplo
de espaço definido, parênteses
abertos. Vamos adicionar dois argumentos. Só porque eu queria
te mostrar o que as docstrings farão. Assim argumentou um, apenas
para o exemplo, ou dois, por exemplo, feche os parênteses. Agora observe que,
assim que abro um parêntese, pycharm completou o segundo
parêntese, o que é ótimo. Está fazendo muito
desse trabalho para mim. Então, vamos fazer isso novamente com um ou dois pontos que eu
apresento mais uma vez, observe que o Python
me dá esse recuo
automaticamente, o que também é muito bom. Agora, para as docstrings mencionadas
anteriormente, vou digitar três
aspas duplas, 123. Observe como o PyCharm também
preenche isso automaticamente para mim. Se eu pressionar Enter, preencha automaticamente esses
argumentos para mim. Isso me dá um espaço para meus argumentos e uma
seção para meus retornos, e também um pouco de espaço aqui para nossa descrição,
o que é ótimo. Então me dê uma descrição
desse exemplo de função. Precisamos adicionar os
tipos manualmente. O Pycharm não é inteligente o suficiente
para saber disso agora. Então, mais uma vez, esta é apenas
uma convenção que eu sigo. Eu vou dizer que
isso é uma string. Digamos uma sequência de caracteres de exemplo. Agora, este,
digamos que seja um número inteiro e um número inteiro de amostra. E digamos que
ele retornará um booleano. Só um exemplo. Isso não é realmente algo que
vamos usar. Observe como também há
destaque na sintaxe. As cores são
diferentes das do Maya, mas ainda é bom ver
de relance o que
está acontecendo. Nesse caso. Observe que esses
argumentos são cinzentos. Eles podem até ser um
pouco difíceis de ver. Isso porque o PyCharm está dizendo que você
não os usou. Pycharm faz muitas coisas muito
inteligentes para você que
ajudam você a inspecionar seu código. Como você vê aqui embaixo, na verdade, no
dia à direita você
tem esse marcador. É como um aviso. E aqui também, está dizendo que
há dois avisos. Na maioria das vezes, não se
preocupe muito com isso agora, mas às vezes é bom
ver o que está acontecendo. Está simplesmente dizendo
que você não usou esses argumentos.
Então, vamos corrigir isso. Vamos imprimir um
deles para usá-lo. Agora você vê que
não está mais acinzentado. E também se você perceber que
assim que eu começar a digitar, PyCharm está
me oferecendo uma sugestão. Nesse caso, é
o outro argumento que eu não usei. Então, se eu pressionar Enter,
aí está. Faz isso por mim,
o que é ótimo. Ele preenche automaticamente o formulário. Lá vamos nós. O mesmo de antes. Está fechando os
parênteses para mim. Portanto, digitar no PyCharm
será muito mais rápido. Vamos devolver
algo aqui. Assim que eu começar a digitar F, sei que quero um booleano, então ele me oferecerá as falhas
ou, se eu começar a digitar t, ele permitirá true
como sugestão. Excelente. Não vou entrar
em muitos detalhes sobre o PyCharm. Há muitas
funcionalidades que você pode explorar ou há
muitos tutoriais, muita documentação
na Internet. Mas para o que precisamos agora, isso deve ser mais do que suficiente. Agora, antes de irmos, vamos fazer uma
pequena limpeza. Como mencionei antes, esse arquivo main.py
é apenas um exemplo. Nós realmente não precisamos disso, então vamos nos livrar dele. Você pode excluí-lo do seu navegador de arquivos
ou simplesmente acessar aqui. Quando este Explorer estiver
aqui ao lado, clique na tecla Delete, ele perguntará se
você não está pronto para fazer isso, você pode dizer Sim, aí está. Temos uma ficha limpa. Então, vamos
criar alguns arquivos Python.
16. Criar um módulo: Vamos falar sobre
bibliotecas e módulos. Como dissemos antes, um módulo é uma conexão, uma coleção de funções e uma biblioteca é uma
coleção de módulos. Um módulo, na verdade,
o núcleo dele é apenas um arquivo. É um arquivo que contém código exatamente como
escrevemos até agora. Podemos criar nossos próprios e importar, assim como
fazemos com meu próprio CMBS. Então, vamos em frente e fazer isso. Em um navegador de arquivos. Navegue até documentos, maya e sua pasta de scripts. Usamos o mesmo para criar o mesmo local para
criar o projeto PyCharm. Então você já deve ter isso
do vídeo anterior. Então, dentro daqui,
podemos criar nossos módulos. Maya sabe ler o código
desse local. Como ele sabe disso? Vamos descobrir isso primeiro para saber de onde meus dados
estão obtendo código, podemos usar um módulo chamado sits, SAS, como no sistema. E no sistema há uma variável de lista que na verdade é
uma lista chamada caminho. E isso contém todo o diretório ou os
blocos de pastas do meu lado. Python em geral, para esta sessão do Maya, está
obtendo o código de. Então, vamos simplesmente imprimir isso. Ótimo. Portanto, você obterá essa
lista com muitas cadeias de caracteres, que são apenas caminhos de diretório para pastas que existem
em sua máquina. Eles terão uma aparência diferente
para você porque eu tenho alguns plug-ins que
você talvez não tenha, mas muitos deles
serão iguais. Por exemplo, este, Maya 2020. Esta é uma pasta que serve apenas
para a versão Maya, Maya. Então, se você tem um código
que deve ser usado apenas em uma
versão específica do Maya. Você pode colocá-lo aqui, por exemplo, estamos usando um local mais
genérico porque nosso código foi criado
para ser mais genérico. É para ser usado por
todas as minhas aversões, na verdade. Então é isso que estamos usando no final, aqui
temos esse caminho. Vamos tentar tornar isso um
pouco mais fácil de ler. Podemos usar nosso módulo
chamado pretty print. Na verdade, é chamado de impressão pwd. Vamos dizer: Desculpe, deixe-me desfazer isso do Pip
print, import p, print. É um pouco redundante,
mas foi assim que eles decidiram chamá-la de estrela brilhante. Significa novamente uma
estampa bonita. Tudo o que ele faz é fornecer um resultado mais legível por humanos. Então, vamos executar esse código
que é muito melhor. Em vez de ter essa
longa lista que precisamos
rolar para ver, simplesmente a entendemos. Ainda é uma lista que
ainda tem o mesmo resultado. É apenas impresso de uma forma
mais legível por humanos. Mais uma vez, você pode criar módulos em qualquer lugar aqui
em qualquer um desses caminhos. Mas, por enquanto, vamos nos limitar aos documentos, aos scripts do
Maya. Você pode estar se
perguntando se eu quisesse usar uma pasta separada para
que outras pessoas,
digamos, em seu
pipeline ou em sua equipe, quisessem que elas acessassem
seu código. Nós podemos fazer isso. Podemos editar essa lista e
adicionar mais partes a ela. É chamado de anexar caminhos. Mas abordaremos isso em outra lição.
Vamos voltar aqui. Scripts, documentos do
Maya, scripts do Maya. Vamos criar um arquivo. Clique com o botão direito Vá para Novo e crie
um novo documento de texto. Agora vamos dar a ele um
nome que faça sentido. Nesse caso, queremos, por exemplo prop underscore reg. Agora, o formato desse
arquivo é TXT por padrão, mas queremos que seja ponto p-y, como em python, ponto p-y. O Windows perguntará
se queremos
alterar a extensão, queremos dizer que sim, excelente. Agora você pode
abrir esse arquivo se eu clicar com o botão direito do mouse e
abrir com o Notepad, podemos escrever código diretamente. Observe que isso é
apenas um arquivo de texto com uma extensão diferente. Mas já
configuramos o PyCharm, então vamos usá-lo. Agora, quando navegamos para o termo
pi, porque estamos usando o mesmo local
para nosso projeto. O arquivo aparece aqui. Então você deve ver esse arquivo
que está vazio, é claro Vamos criar uma
função apenas para testá-la. Então, o tipo encontraria surdos. Espaço, teste, abertura,
parêntese fechada, cólon. Vou pular
as docstrings por enquanto porque este é
apenas um teste rápido. Vamos simplesmente retornar uma string. É só dizer que isso é um teste. Capitalize isso. Excelente. Então, como usamos isso? Vamos excluir esse código. Deixe-me esvaziar a janela de saída. Vamos simplesmente inserir
esse importante equipamento. Vamos executar isso. Vamos
ver o que acontece. Sem erros. Isso é ótimo. Isso é uma boa notícia. Vamos simplesmente imprimir isso. Veja o que acontece. Imprimir, adereço Break. Excelente. Então, ao vender, você usa
apropriadamente um módulo proveniente de documentos, manuscritos, um problema
adequado com ovos chamado rig dot p-y. Excelente, esse é o nosso módulo. Como podemos usá-lo? Para? Bem, sabemos que temos uma função
que se chama teste. Então, vamos fazer um teste de pontos. E vamos simplesmente
chamar a função. Sabemos que está
retornando um valor. Então, vamos armazenar esse valor
em uma variável por enquanto e chamá-lo de t. Vamos imprimir. Aí está. Este é um teste que é
o valor que estamos obtendo de nossa
função em nosso módulo. Excelente,
parabéns, você criou seu primeiro módulo. Como você pode ver, é muito fácil. Os módulos são mais do que isso. O que vamos
fazer com isso em breve. A próxima coisa que precisamos fazer é criar algo que realmente
precisamos, que é converter nosso código
adequado em módulo, o que diz que você
dirá que será tão fácil
quanto basicamente copiar e colar
isso em nosso módulo. Então, vamos, na verdade,
ir em frente e fazer isso. Deixe-me levar tudo, desde a declaração de importação
na parte superior até o
final da minha função. Vou pressionar o controle C. Vamos para o nosso módulo
de tecido. Vamos excluir esse código. E eu vou colar
isso aqui. Excelente. Portanto, temos o íon brometo presente. Sim, você percebe que o PyCharm
está me dando um erro. Se eu passar o mouse sobre ele, verificarei
os erros aqui. Está me dizendo uma
referência não resolvida a Maya, referência
não resolvida ao CMBS. Isso é bom. Isso ocorre porque o
PyCharm não
conhece a biblioteca CMBS. Existem maneiras de
contornar isso e na verdade, age como um
código fora do Maya, mas você realmente não precisa disso. Então você pode ignorar isso
para sempre, por enquanto. Todo o resto é exatamente
o mesmo que tínhamos antes. Nós literalmente copiamos e colamos dentro deste módulo. Vamos voltar para Maya. E vamos aqui. Então, digamos, deixe-me
excluir esse código. Vamos simplesmente criar
um equipamento, digamos, suporte, equipamento sublinhado, criar um equipamento de colheita. Na verdade, vamos imprimir isso
diretamente e ver o que acontece. Temos um erro, um módulo de erro de
atributo interessante, o que significa que Propp Rick não tem o atributo
create prop brick. Por que isso? Isso porque
já importamos o módulo e o modificamos
depois de importar, depois de importá-lo, adicionamos tudo isso. Esse código não é sua
função depois de
já termos importado para o Maya. Maya, embora o estejamos
importando novamente, maya tenta ser inteligente
e meio que armazena o módulo em sua memória
e simplesmente o reutiliza. Então, como podemos pedir ao
Maya que atualize, atualize ou recarregue esse
módulo? Muito fácil. Podemos simplesmente digitar, há
uma função chamada recarregar. Portanto, o tipo encontraria
a recarga, o equipamento adequado. Mas isso vai acontecer
se forçar Maya a ler o arquivo novamente. E quando eu conseguir armazenar em cache, clique Salvar seu
conteúdo na memória. Portanto, só precisamos realmente recarregar uma vez sempre que fazemos uma alteração. Então, vamos executar esse código. E agora deixe-me executar esta
declaração impressa novamente. Excelente. Então imprimiu algo, uma
pequena função enigmática, criou probabilística,
adicionou algum número aleatório. Isso é uma boa notícia. Isso significa que ele sabe que
existe uma função. Na verdade, vamos usá-lo. Eu sei que estou examinando
isso um pouco devagar, mas vamos simplesmente
criar um regular. Sabemos que precisamos
de um desses três valores. Então, vamos dizer, vamos chamar essa função. E passando o valor
que já sabemos que ele espera, vamos criar um cubo. Vou apenas executar
essa linha de código. Excelente. Tudo isso é muito
familiar para você. Criou um cubo em, deu a você o nome do
controle que foi criado. Vamos criar
outra coisa é criar um cone. mesmo acordo deu a você a
variável que foi criada, que é vinho controlado,
e ele criou um cone. E agora todas essas
vidas fora do meu sim, não
estamos escrevendo todo esse
código no editor de scripts. Você tem seu próprio módulo
copiado pelo seu sistema de arquivos. É muito mais fácil trabalhar com ele. E agora tudo o que você precisa fazer é que não
precisamos
recarregar agora porque não estamos
fazendo nenhuma alteração. Tudo o que você precisa fazer para
chamar suas funções são essas quatro linhas de código, limpas, fáceis e
muito, muito escaláveis. Parabéns, você
terminou seu primeiro projeto. Espero que os módulos façam sentido. Vamos usar isso
muito mais daqui para frente. Vamos continuar
usando módulos,
continuar usando o PyCharm, você vai continuar
criando funções. Então, tudo isso se tornará
ainda mais familiar para você. Mais uma vez, parabéns. Vamos passar para a próxima etapa.
17. Mergulho profundo - funções: Vamos nos
aprofundar um pouco na função. Eu disse antes que
você pode considerar uma função como um contêiner. Um recipiente com o quê? Vamos desenhar um
recipiente bem rápido. Um contêiner de
instruções está sendo, instruções sendo código executado dentro
dessa função. Agora, sendo um contêiner, também
significa que
há um escopo. Esse é um termo importante. Escopo significa basicamente
as limitações de onde algo pode existir. E isso será especialmente importante quando
se trata de variáveis. Existem variáveis
que ficarão
fora do escopo
da função e variáveis que ficarão
dentro do escopo
da função. Às vezes, isso pode ser confuso para as pessoas, mas veremos um
exemplo daqui a pouco. Portanto, a principal coisa que você quer saber sobre as funções
é o que elas realmente fazem. Portanto, como mencionamos anteriormente, uma função pode, opcionalmente,
receber uma entrada. Então imagine que isso
é apenas um contêiner que está executando um conjunto de instruções e
recebe uma entrada. Opcionalmente, nem toda
função recebe uma entrada, mas você pode criar suas
funções que possam ser inseridas. Ainda mais importante,
sempre
há uma saída
e essa saída, se não for definida explicitamente, será um valor chamado None. Nenhum é como um objeto nulo. Mas você também pode
usá-lo como uma forma de verificar
a existência de
um valor válido, por exemplo, mas
sempre, sempre uma função
retornará no mínimo, nenhum ou algo que tenha sido definido explicitamente
como seu valor de retorno. Então, como uma entrada, como o vocabulário adequado,
haverá argumentos. Os argumentos serão a entrada
e a saída
será um valor de retorno. Então, quando você está
chamando uma função, veremos
isso em código muito em breve. Estou apenas desenhando isso
para ter uma visão geral, como
uma visão de cima para baixo
do que as funções fazem. Digamos que você tenha
uma função chamada, vamos chamá-la de minha função. Só por uma questão de exemplo, para executar uma função, ela está chamando a função coef. Esse é o nome da execução de uma função que você diz que
chamaria uma função. Temos que usar parênteses. E em vez desse
parêntese um desses
argumentos desaparecerá. Se houver algum argumento,
se houver alguma entrada
, os parênteses
conterão essa entrada. Depois de executar a função, você receberá um valor de retorno. Às vezes, isso é confuso
para as pessoas porque a forma como as funções
retornam um valor. Bem, assim que
você chamar uma função fornecendo esse parêntese, você receberá
um valor em troca. E geralmente você vai
querer armazenar isso
em uma variável, a menos que em uma variável, a menos não
se importe com
o que ela foi retornada, a menos que queira apenas que a
função seja executada. As instruções são
um conjunto de funções e depois esqueça-as. Mas normalmente você vai querer
armazenar isso em uma variável. Um amigo meu me disse que é fácil visualizar esse tipo de pessoa recebendo uma moeda no
final da execução. Então imagine que você está
executando a função. E então você ganha uma moeda, meio leve quando
você joga Mario Bros, ganha uma pequena moeda. Tentamos jogar uma moeda. Moeda muito feia, mas imaginei que você
obtivesse essa moeda como resultado. E então você pode depositar essa
moeda em sua variável. Mais uma vez, as variáveis são
simplesmente contêineres de um valor. Então você pode pensar nisso.
Dessa forma, se isso te ajudar, você obtém essa pequena moeda depois
de executar a função. E isso pode ser usado como você
quiser, normalmente como um valor a ser
armazenado nessa variável. Então, vamos criar uma função. Vamos criar uma função
chamada exemplo. A criação de uma função em Python é chamada de definição de uma função. E a maneira de fazer
isso é digitando def D-E-F, define espaço. Você pode chamar a função como
quiser. E vamos
chamar o meu exemplo abrir e fechar parênteses. Por enquanto, não vou fazer com que minha função receba nenhum
argumento ou entrada, depois dois pontos e
pressione enter. Agora observe como eu obtive
esse recuo. Isso é basicamente quatro espaços. Isso é muito importante. Esse recuo
é o que determina o que está dentro
da função. Então, por enquanto,
vou apenas escrever um passe. Pass é basicamente dizer pular qualquer execução
ou não fazer nada. E eu vou
escrever uma variável. Vou imprimir
algo aqui. Na verdade, em vez de escrever
isso, você diz alguma coisa. Isso está fora do
escopo da função. Esse caminho está dentro do
escopo da função. Agora, falamos sobre o
escopo de quatro variáveis. Vamos deixar isso um pouco
mais claro com um exemplo. Vamos lá, vamos criar
uma variável chamada bar. E eu vou
atribuir um número a ele. Digamos que dez. E vamos criar
outra variável. Vamos chamar isso de interior, porque está dentro
da função. E vamos atribuir
o número três, o absoluto como arbitrário, mas é só para um exemplo. Vamos imprimir var. Ótimo. Então, obtivemos a saída de dez, que é exatamente
o valor da barra. Isso é ótimo. Isso porque isso está fora do escopo da função. Agora, o que acontece se
tentarmos imprimir essa variável aqui? Recebemos o erro de nome. Diz que o nome interno não
está definido. Não está definido porque
está dentro dessa variável, dessa função, e vamos
imprimi-la dentro da função. Vamos imprimir essa impressão por dentro. Deixe-me deletar essa linha. Agora nada aconteceu. Claro, isso é
porque nós
realmente não esfriamos a função. Então, mais uma vez, lembre-se de executar uma
função que você precisa chamá-la. Eles abririam e
fechariam parênteses? Vamos fazer isso. Aí está. Agora estamos imprimindo
o valor três, que é a variável
da variável dentro
dessa função. Agora, se você está curioso, quer ver o que acontece. Se você simplesmente imprimir a
função sem chamá-la. Você pode fazer isso. E isso é o mesmo. O Python dirá
que é uma função. É chamado de exemplo
e vive
nesses números aleatórios, aparentemente
aleatórios. Isso é chamado de
ponteiro para a memória. Você diz que a função não está em nenhum
arquivo no momento, ela está apenas na memória desta sessão com a qual
você está trabalhando. Não se preocupe
muito com isso. É um detalhe um pouco mais
técnico. Mas saiba que você pode, você pode usar essa função como
ela é, mas eu a chamo. Mas para obter o valor disso,
você precisa ligar para ele. Agora eu mencionei que
as funções sempre, sempre retornam um valor. Então, deixe-me armazenar esse valor dentro
dessa variável de saída. Vamos falar sobre isso. Aí está. Então, esses três são desta
declaração impressa aqui embaixo. Então, deixe-me remover essa declaração impressa para torná-la um
pouco menos detalhada. Aí está. Então, estamos
imprimindo o resultado da saída. E isso não é nada. Isso ocorre porque não
estamos definindo nenhum valor
de retorno da função. E nenhum é o
valor padrão. Como mencionei antes. Agora, digamos que, em vez
de não retornar nada, nós realmente queremos
retornar esse valor aqui. Digamos que queremos retornar
essa variável para dentro. Agora podemos
retornar três diretamente, o que seria basicamente ignorar essa, essa
variável aqui. Ou você pode retornar essa variável. Por enquanto. Vamos manter as coisas simples
e retornar esse valor três. Aí está. Agora estamos imprimindo três
dessa variável de saída. Mais uma vez, ou seja ,
como eu disse, como
meus amigos disseram, ajuda imaginar que você está recebendo
aquela pequena moeda e depositando esse valor ou aquela
moeda em uma variável. Foi o que aconteceu aqui. Você obtém pouco valor
que estou colocando na saída. Você não
precisa necessariamente colocar essa barreira, armazenar esse valor em uma variável, como mencionei antes, você pode simplesmente
imprimi-la diretamente. Então, vamos fazer isso. Observe como estou
chamando a função. E estou apenas apontando
isso diretamente. E é exatamente
o mesmo resultado. Isso é porque
vamos obter esse valor. Isso é
basicamente equivalente a fazer isso. Imprima três, porque
nesse caso, três é o valor
retornado por essa função. Então, espero que esteja claro. Agora, vamos fazer algo um
pouco mais complexo. Vamos adicionar argumentos
ou entradas a essa função. Vamos adicionar um argumento chamado a e
um argumento chamado B. Vamos retornar, vamos
chamar essa função de
add, de função add, porque vamos somar
esses valores. Digamos que o resultado
seja uma lésbica. Muito simples e vamos
devolver seus resultados. Podemos chamar a função. Então, o que acontece se
ligarmos para eles agora? Você recebe um erro, é claro, porque diz que a função add aceita exatamente dois
argumentos, dado zero. Então, agora temos que
apresentar argumentos. Temos que dar alguns valores, digamos dois e
depois duas vírgulas três. É assim que você fornece essas teses de
argumentos em ordem. Portanto, o argumento e dois
corresponderão ao argumento a, e então três
corresponderiam ao argumento be. Nada aconteceu porque não
estamos armazenando esse valor. Vou dizer
saída mais uma vez. Vou
imprimir isso, mas excelente. Agora obtemos o
resultado que é cinco, porque é dois mais três. Se fôssemos fazer dez mais três, é
claro que seria 13. Há um tipo diferente de
argumento chamado argumento de palavra-chave. O que vimos agora? Esses são chamados de argumentos
posicionais. Isso ocorre porque esses argumentos não têm um valor padrão, eles são basicamente variáveis. E mais uma vez,
isso é importante. Essas são variáveis que existem dentro do escopo
dessa função. Agora, observe como a
ajuda realmente não existe em nenhum outro lugar
fora da função. A, é meio que uma caixa vazia. Eu penso nisso como uma
caixa vazia e um recipiente vazio. Isso está apenas sendo chamado de a com o propósito de usá-lo
dentro de nossa função. Basicamente, estamos dizendo
que sempre que você obtém um valor, armazene esse valor dentro
dessa caixa em um contêiner chamado de
e, em seguida, use-o dentro
da função. E o escopo de uma variável ou desse argumento que
basicamente se torna uma variável ou está sendo
tratado como uma variável, é apenas o escopo do
, dessa função. Quando a função sai, sai, que é quando retornamos ou sempre que terminamos a
função ou estamos lá. Eles não tiveram paciência, então essa variável basicamente não existe
mais. E também o nome
dessa variável, é
claro, depende de nós. Poderíamos chamar isso de. E, oh, por exemplo, estamos
adicionando números. Então, podemos dizer, poderíamos
até dizer primeiro e segundo. Então, faríamos o
primeiro mais o segundo. E o resultado
será exatamente o mesmo. Então, tudo depende de nós, cabe a você, como desenvolvedor decidir como
chamar essas variáveis. Então, novamente, eles estão em ordem. Dez pertencerão à
explosão neste caso, e três pertencerão à segunda. Há um tipo diferente de argumento que é chamado de argumento
de palavra-chave. É chamado de
argumento de palavra-chave porque , em
vez de passar os
argumentos em ordem, eles
os passarão pelo nome. Então, por exemplo ,
vamos criar
um novo exemplo. Digamos que
queremos que a função determine se
alguém sabe dirigir ou não, se alguém tem idade
suficiente para dirigir ou não. Então, mais uma vez, vamos
definir uma função, vamos chamá-la de can drive. Seja um
pouco descritivo. Agora, queremos saber
a idade da pessoa. Queremos saber qual é o limite de idade para
poder gostar
de uma espécie de limite, certo, para poder dirigir. Então, vamos chamar isso de idade mínima. E vamos adicionar um valor padrão. Valor padrão. Digamos que você precise ter 16 anos
para dirigir, por exemplo, depois cólon. Sem os dois pontos, você
receberá um erro. Então, dois pontos, pressione Enter, e agora estamos dentro
dessa função. Então, digamos que se h for
menor que mínimo h, mínimo h,
diremos não. Não vamos dizer não,
vamos retornar false, vamos retornar false, que é um valor booleano
neste caso, basicamente dizendo Não, essa pessoa não pode acionar parafusos. Caso contrário,
vamos voltar. Sim. Porque isso significa que
a pessoa pode experimentar. Excelente. Então, vamos
chamar essa função. Agora, observe novamente que, como eu
forneci um
valor padrão
para esse número, para esse argumento, não preciso fornecer
necessariamente um valor para isso. Então, digamos que
alguém tenha 25 anos. 25, sim, sabe dirigir. Alguém tem três anos. Eles não podem dirigir. Excelente. Agora, e se quiséssemos
mudar a idade mínima? Mas você pode mudar
isso aqui ou você pode. Há duas
maneiras de fazer isso, já que há apenas
dois argumentos. Você poderia simplesmente tratá-lo como um argumento posicional,
ou seja, em ordem. Então você poderia dizer, ok,
vamos fazer com que a nova
idade mínima seja de um ano, um ano de idade. Agora essa pessoa pode dirigir, mas nós também podemos fazer isso. Podemos dizer que o mínimo h é igual a um. Aí está o fato de
que estamos adicionando, atribuindo ao argumento, tornando-o uma palavra-chave. Argumentos. Ao adicionar uma palavra, ao trocar argumentos
como argumento de palavra-chave, você pode ignorar a ordem, que pode ser um
pouco confuso. Mas, por exemplo, se eu dissesse que H igual a 20 e a idade
mínima para dirigir é, vamos mudar isso para 22, por exemplo, agora observe como h agora vem depois do segundo e do segundo lugar e a idade mínima está
chegando em primeiro lugar. Mas, como estamos usando
palavras-chave, argumentos de palavras-chave, o funcional saberá
como atribuí-los
ao argumento ou variável correspondente. Portanto, nesse caso, é falso, conforme o esperado. Agora, se mudarmos isso para 19, é verdade como esperado. Mas se
removermos essas palavras-chave, simplesmente deixe-as como argumentos
posicionais. Agora eles estão invertidos. Agora, 19 pertencerão a H e 20 representarão o mínimo H. Espero que isso esteja claro. Se não, vamos tentar mais
um exemplo para
tentar deixar isso um
pouco mais claro. Vamos criar um
tipo diferente de função. Vamos criar uma função
que receba tudo, que tenha todos os argumentos totalmente
opcionais, o que significa que todos os
argumentos têm um valor padrão. Então, vamos definir isso. É chamado de surdo. Digamos que seja uma função
que cumprimentará as pessoas. Vou chamá-lo de saudação. Agora. Ele terá uma mensagem. A mensagem terá um valor
padrão chamado not cold, mas diremos apenas saudações, que é uma sequência de caracteres
que diz saudações. Agora, ele
aceitará o primeiro nome. O primeiro nome terá um valor padrão de
uma string vazia. Então, talvez não queiramos
ter um argumento de nome e sobrenome que
também tenha uma string vazia
como um valor do tipo dois-pontos. E entraríamos
na função. Agora vamos
dizer a mensagem de leitura. Vamos começar uma nova variável. A mensagem será,
será uma string. Vamos dizer,
vamos dizer que
abrir e fechar
colchetes abrem e fecham espaço entre colchetes
curvos abrem e fecham
colchetes. E então vamos
digitar no final do formato de ponto de string. Agora, o que vai
acontecer aqui é cada um desses
colchetes será substituído por qualquer coisa que colocarmos dentro
dessa função de formato de ponto. Então, vamos dizer que
o primeiro colchete
será substituído pela mensagem, o segundo pelo
primeiro nome e o terceiro pelo último. E então simplesmente
retornou a mensagem. Agora, é claro,
poderíamos retorná-los diretamente em vez de ter
que distorcê-los em uma variável totalmente válida. Mas acho que é um
pouco mais limpo
criar uma variável
com nossa mensagem. Deixe-me tornar essa janela
um pouco maior. Crie uma variável
que seja nossa mensagem
e, em seguida, retorne esse valor. Então, vamos ver o que acontece aqui. Agora. Novamente, temos três
argumentos nessa função. Para criar outra
variável chamada saída. Vamos
armazenar a saída
dessa função nessa variável. Vou imprimi-lo. Então, vamos ver o que acontece se
chamarmos essa função sem nenhum argumento, mas sem passar nenhum
argumento. Nós, diz
saudações, excelentes. Portanto, ele tem
alguns espaços vazios porque adicionamos
alguns espaços vazios. Mas está tudo bem por enquanto. Isso é só um exemplo. O que acontece agora se apresentarmos um único argumento? Bem, isso será, isso
substituirá
a primeira discussão aqui. Vamos apenas dizer, diga olá. Em vez de saudações. Aí está. Olá. E se aprovarmos
uma segunda discussão? Vamos dizer
Primeiro Nome, digamos Josh. Olá, juiz. Agora o que acontece? Acontece se passarmos argumentos de
uma palavra-chave? Então, observe como esse é
o segundo argumento. Barbaric, na verdade,
colunata LastName. Basicamente, estamos dizendo, ok, use esse valor, essa string
no lugar ou LastName. Aí está. Agora, é difícil ver porque
só há um espaço vazio. Então, se mudarmos o valor
padrão do nome da
pessoa para um traço simples. Mas veremos o que acontece aqui. Observe como estamos passando
nosso primeiro nome, pulando
direto para o sobrenome. E então temos
olá Josh. Ótimo. Agora, se passarmos o primeiro nome, mesmo que o façamos fora de ordem, desde que usemos
a palavra-chave para isso. Diga. Júnior. Eu sei. Eu sei que isso
é meio invertido. O sobrenome, juiz, não
é um sobrenome. Mas digamos que Junior
será seu primeiro nome. Olá, janeiro Josh. Então, observe que, embora
isso esteja fora de ordem, FirstName, porque estamos
usando as palavras-chave. Está tomando o
lugar do nome e o sobrenome está substituindo
o sobrenome. Agora, se nos livrarmos
dessas palavras-chave simplesmente removendo o sobrenome, o
primeiro nome é igual a. Voltamos aos argumentos
posicionais, o que
significa que a ordem
importará nesse caso. Então, vamos executar isso. Agora você vê que a
saída está invertida. Excelente. Eu queria voltar a
retornar valores porque
mencionei que o retorno marca
o fim de uma função. E esse é um
dos aspectos mais importantes de uma função e algo que causa alguma confusão,
confusão para as pessoas. Então, deixe-me tentar voltar e fazer muita coisa e voltar ao
meu exemplo anterior. Aí está, pode drapear. Então, aqui estamos usando
a declaração if else para seguir a decisão ditar o fluxo
dessa função, certo? Então, para relembrar,
estávamos perguntando se a pessoa com esse h é a
pessoa abaixo do mínimo h.
Diremos que diremos que o
nó não pode dirigir. Caso contrário, sim, eles podem dirigir. Portanto, podemos realmente ler que
essa outra afirmação
não é totalmente necessária. A razão para isso é porque quando você atinge
o valor de retorno, esse é o fim da função. Então, deixe-me fazer isso de novo. Digamos que essa pessoa 10 anos e tenha no mínimo h. Vamos simplesmente remover
esse argumento e nos ater
ao valor padrão. Então, alguém com
10 anos não pode dirigir. É excelente. Então, o que acontece se
eu devolver mais isso? David, e eu também simplesmente removemos o recuo
nesta declaração de devolução. Bem, o resultado é o mesmo. Essa pessoa não pode dirigir. está acontecendo aqui, basicamente,
estamos dizendo que, se essa pessoa estiver abaixo
do limite mínimo de idade, retornou falso, quando
você atinge esse ponto, a função está concluída. Eu não vou continuar. Aqui embaixo. Vamos dar uma olhada em outro exemplo. Deixe-me criar uma nova
função que simplesmente diz: vamos chamá-la de teste por enquanto. E eles pegarão um número. Vou apenas dizer o argumento num dois-pontos,
insira a função. Vamos dizer que se
um é igual a, é igual a um, vamos, vamos voltar. Vamos devolver um. Só uma corda que diz um. Se num for igual a
dois, isso será retornado. Caso contrário, vamos voltar. Mais. essa disfunção
é apenas um exemplo, não faz muito sentido. Então, vamos executar isso. Digamos que teste. Vamos primeiro e eu
vou imprimir os resultados. Não vou
armazená-lo em uma variável, vou imprimi-lo diretamente. Então 12, desculpe por isso. Se eu disser 20, ele
retornará mais. Excelente. Então, isso é o equivalente
a dizer se mais, se mais, retorna mais. Mas, mais uma vez, a instrução return
marca o fim, basicamente sai da função. Esse último outro não é necessário. Isso é muito poderoso
porque significa que você pode, você pode ditar o fluxo
de sua função dessa maneira. Podemos ter muitas condições, muitas instruções. E uma vez que você atinge uma
determinada condição, você pode dizer, ok,
isso é tudo que precisamos. Saia da função
para retornar um valor, qualquer valor que você
quiser, ou seja, aqui estamos retornando valores
diferentes. Aqui. Você não precisa retornar
o mesmo tipo de valor. Você pode até mesmo
retornar um NAN, por exemplo, e neste caso o 20
não é um ou dois.
Então, não devolvendo nenhum. Agora, isso é,
mais uma vez a escolha é sua,
que depende de você. Espero que isso tenha feito sentido. As funções podem ser um
pouco confusas e, especialmente, as declarações de
retorno podem ser um pouco
confusas para as pessoas. Mas quanto mais você o usar, mais familiares
eles se tornarão. Uma última coisa antes de nós. Vamos encerrar isso. E esse é um tópico muito
importante, que é documentação. São docstrings. Mais uma vez, como
mencionei antes, uma docstring é basicamente
uma string que podemos usar dentro de uma função que
atua como documentação, daí o nome dark strip. Docstring é uma aspa tripla. Elas podem ser
três aspas simples apenas para abri-las
e fechá-las. Ou três aspas duplas,
vou
usar aspas duplas
neste caso. Agora, o que os docstrings fazem
é fornecer documentação, como já
mencionei, vou
fornecer uma explicação simples. Aqui. É uma descrição, desculpe,
não uma explicação. Essa função. E agora é
algo muito importante incluir
na sequência de caracteres do seu documento. Não importa que tipo
de convenção você siga em docstrings, é
muito importante fornecer. Seus argumentos. Ou a convenção que
eu gosto de seguir é tocar em args colon. E, abaixo disso,
forneceremos os argumentos
que fazem a óptica funcionar, neste caso, é esse argumento numérico. Eu sei que num
será um número inteiro. E eu gosto de fornecer
uma descrição simples para o segundo ano, o lado bom, por exemplo
, se a
função estiver retornando, algo que eu
também gosto de adicionar são os retornos. Assim como uma seção
no lado direito, o tipo que está sendo
retornado nesse caso, sabemos que é uma string. Então, digamos que ele
retornará uma
string, string inteira passada. Isso é apenas uma descrição
desse valor de retorno. Agora, escrever as docstrings
pode ser um pouco entediante. Muitas pessoas não fazem isso. Mas acredite em mim, é extremamente importante e vai te
beneficiar muito. E apenas o fato de você
escrever docstrings pool. Se você gostaria de continuar essa carreira de script ou
programação, isso o ajudará
imensamente em sua carreira. Então, qual é o benefício
dessas docstrings? Bem, uma delas é que relance, quando você está
examinando uma função, você pode ver
a documentação quando voltar a ler seu
código daqui a um ano. Você sabe o que
acontece quando
outra pessoa quer usar sua função. Eles sabem o que se espera
como entrada e saída. Além disso, mesmo que você não tenha acesso direto à
função em si, você pode acessá-la, mesmo
que não tenha acesso para ler o código-fonte ou o que está
dentro da função. Vamos imaginar que
estamos aqui embaixo. Nós realmente não sabemos
o que está dentro do teste. Há uma função embutida
no Python chamada Help. Você pode passá-lo em sua
função sem chamá-lo. Perceba que eu não estou
colocando a marca, isso, eu não estou chamando isso apenas passando o nome
da função. Deixe-me limpar minha janela de saída. Vamos executar isso. E o resultado
dessa função de saúde é exatamente a docstring. Então diz teste. Aqui, diz Help one
function tests in Module main. Não se preocupe com
o que isso significa. Significa apenas que y , na verdade, significa apenas que não
há módulo. Estamos apenas chamando
isso no Maine, que é meio que o
local padrão para executar código. Agora, o nome da
função é testes. Eu aceito uma
discussão chamada num. Essa é a descrição que
colocamos no início, e esses são os argumentos e o tipo de retorno
que fornecemos. Agora, você pode ver como isso pode ser
útil se
não inseríssemos isso, tivéssemos a docstring
e executássemos os testes executássemos ajuda no teste. Vamos ver o que acontece. Diz Help on
function tests and more domain que fornece o
nome da função, o argumento que espera
e, em seguida, nada, o que não
é nada útil. É muito mais útil ter essas informações para você
ou para outra pessoa que possa
estar usando sua função. Portanto, é um ótimo
hábito se dedicar um pouco
mais de tempo,
mas na verdade não
é muito mais demorado . E você e
muitas outras pessoas agradecerão imensamente
por escrever a documentação. Espero que sejam funções
muito mais familiares para você. Eles são extremamente úteis, extremamente importantes
na programação. E eles tornarão
sua vida muito mais fácil quando você se
sentir mais confortável com eles.
18. Projeto 2 - Ferramenta de transferência de pose: introdução e repartição: Bem-vindo ao seu próximo
projeto para este projeto, e criaremos
uma ferramenta que
nos ajudará a traduzir a postagem
entre caracteres. Deixe-me dar uma demonstração disso. A propósito, para esta demonstração, estou usando um equipamento
chamado Morpheus. Este é um equipamento gratuito, é um incrível Rick. Fui
criado por Judge Burden. Você pode obtê-lo no site dele. Judge horton.com corta
projetos e corta Morpheus o mais rápido possível. É um Reagan incrível,
recomendo vivamente. Eu vou usar
isso para esta demonstração. Mas você pode usar
o que quiser. Essas ferramentas devem funcionar com
diferentes tipos de pausas. Vamos usá-los
porque os judeus tiveram a
gentileza de me deixar
usá-los para esses projetos. Como você pode ver, eu tenho
três características, três plataformas, elas são
todas a mesma plataforma. Eles parecem um
pouco diferentes. Morpheus me
permite modificar o equipamento, criar versões diferentes
do personagem, mas
é o mesmo equipamento. Todos eles foram
referenciados na cena. E esse aqui
já foi postado. Então, vamos transferir essa pose
para as outras duas matrizes. Vamos selecionar, digamos esses controladores e
talvez a cabeça também. Então, vamos transferir esses valores. Só deveria ser para esses
outros personagens. Vou selecionar um
deles e executar os dois. Aí está. Agora os dois fizeram a pose. Digamos que eu queira me
transferir agora, vamos fazer uma mudança e esse
personagem aqui, logo à frente. Então, vou selecionar, direi que quero transferir isso para esses dois personagens. Não importa o que eu selecione, porque sei que
vou transferir isso, os controles que selecionei
no primeiro personagem para os outros dois personagens que
selecionei . E aí está. Excelente. E, claro, também funciona para
um único personagem. Se você quisesse. Vamos tentar isso bem rápido. Excelente. Então, são dois. Agora, precisamos fazer um
pouco de configuração. Porque uma vez que mencionei antes, esses são todos o mesmo equipamento. A razão pela qual isso
funciona e é uma forma muito comum
de trabalhar com esse tipo de ferramenta
é que as ferramentas são feitas na plataforma ou ao redor dela. E quando você está
trabalhando em um estúdio ou um projeto com outras
pessoas em uma equipe. Normalmente, os riscos são os mesmos. A geometria pode ser diferente, o personagem pode parecer
completamente diferente. Como você pode ver, entre esses dois personagens,
eles são muito diferentes. Mas os controladores da
plataforma são basicamente os mesmos. E isso é o que está
acontecendo aqui. É assim que a ferramenta é
capaz de transferir uma animação ou uma postagem que são apenas valores
de uma semana para a outra. Como estamos trabalhando com referências
de aluguel, temos namespaces. Como você pode ver,
esses controladores, cada controle tem um namespace. Esse personagem aqui,
e depois ser Severus. A próxima aqui é Minerva, e a última é Luna. Então, vamos criar essa configuração que você
precisará para isso Não
vou falar
muito sobre o conceito
de namespaces. Se você não está familiarizado com
referências e namespaces, recomendo que você faça um rápido tutorial on-line, pois
serei muito importante e também é muito útil
saber como animador ou como trabalhar com
referências e namespaces. Então, vamos prosseguir
e fazer a configuração. Estou começando com uma
nova cena em Maya. Essa é uma cena completamente nova. Quando você acessa o menu Arquivo
e o editor de referência. Mais uma vez, para que isso funcione, usaremos referências porque as taxas
são todas iguais, então precisamos referenciá-las
e colocá-las por trás
desse namespace. Vou jogar um
clique no botão de adição. E eu já tenho essas
tarifas em uma pasta. Eu tenho a versão feminina,
a versão masculina. Então, eu vou usá-los. Já está aqui. Mas digamos que o primeiro, o masculino primeiro. A ordem não importa. É tudo a mesma coisa. Vou apenas fazer esta primeira referência
que interessa. Agora, o Maya me dá o
namespace automaticamente, que é mais um e-mail
sublinhado. Você pode deixar
isso como está, se quiser. Vou chamá-lo de Severus. É um pouco mais divertido. E então vamos fazer o outro. Pensando um pouco de tempo. É uma plataforma pesada. Mas, novamente, é um Rick
muito bom. Agora, a próxima, vamos chamá-la de Minerva. Mais uma vez, o namespace não
importa.
Isso depende de você. Só estou escolhendo fazer isso para torná-lo um pouco
mais interessante. Excelente. Temos as duas plataformas,
Severus e Minerva. Só vou fazer isso agora. Mas essa ferramenta funcionará com
duas ou mais tarifas até você. Não tenho a textura
carregada, mas tudo bem. Não vou me preocupar
muito com as texturas. Neste caso, só nos preocupamos com
os controladores Para qualquer coisa que você decida usar, você pode carregar as
texturas ou não. A ferramenta não se
importa com isso. Vou usar o material
padrão apenas para dar um sombreamento uniforme. E, por
algum motivo, são pretos. Então, vamos ativar a iluminação
dupla face e frente e verso. Aí está. Eles não parecem tão bonitos, mas Tool. Só vai funcionar
no controlador, então tudo bem. Aí está. Deixe-me aumentar isso. E vamos fazer um teste
rápido na ferramenta. Vamos partir de Minerva. Apenas separa. Aí está. Está funcionando. Excelente. Essa é a configuração que você precisa. Mais uma vez, se você
não está muito familiarizado com namespaces e referências
dentro do Maya, eu recomendo que você passe alguns minutos
aprendendo sobre isso. Não é muito complicado, mas é muito útil. Então, vamos seguir em frente e
entrar no código. Na verdade, antes de
entrarmos no código, vamos detalhar
o que está acontecendo aqui. Vamos ver como, vamos ver as etapas que estamos
tentando automatizar. Então, deixe-me reunir
essas restrições. Deixe-me zerar isso. Ok. O que significa
transferir postagens? Vamos usar esse controle de
tórax, por exemplo, para que, como você pode ver, os dois
sejam iguais. Então, coluna vertebral, zero pele,
ombro, ombros, e é um nome um
pouco longo, mas o importante é
que ambos sejam iguais. Eles estão logo atrás
desse namespace. Então, para esses controles, seus servidores e, por meio disso,
rake os namespaces Minerva. Então, vamos mudar a
rotação desse personagem. Digamos que 90. Perfeito. Para transferir essa pose, basicamente
queremos aplicar o mesmo valor a esse
controlador aqui, que novamente é o
mesmo controlador,
está logo abaixo de um espaço de nome
diferente. Como faríamos para fazer
isso? Vamos abrir o editor de scripts. Mais uma vez, vamos pedir a Maya que nos
dê algumas
informações valiosas. Mais uma vez, vou
mudar esse valor,
que é girar x e
ver o que acontece. Ok, perfeito. Meus olhos
nos dizem que existe, este é o comando que
ele está executando, disse adder. Em seguida, o nome do controlador, que é o nome do objeto, pontilhe o nome do atributo. Ok, então esse é o
nome completo do atributo. Isso significa que a rotação x e esse controlador
têm esse nome, que é um controlador, que
é um namespace, dois pontos. Desculpe, eu não queria fazer isso. Um namespace, dois pontos, o
nome do controle
e, em seguida, um ponto e, em seguida, o
nome do atributo. E existe esse comando set R. Vamos traduzir
isso para Python. Eu vou, eu preciso
importar esta biblioteca. Então, a partir da minha biblioteca CMBS de entrada farei CMV como somador de conjunto de pontos. E depois entre parênteses. Lembre-se de que o sub
aqui é o código de cheiro, então nós o usamos apenas como um
guia, como um modelo. Não precisamos do
ponto e vírgula em Python. Vamos abrir
e fechar parênteses. O primeiro argumento
será o nome, o nome completo desse atributo. E o segundo argumento
será o valor que
queremos definir nesse
atributo. Então aí está. Essa é a base de nossa configuração de ferramentas e
obtenção de atributos. Vamos definir esse atributo com outra
coisa, digamos 80. Deixe-me fazer isso de novo. Então você pode ver a
mudança aqui. Me desculpe. Eu sei que isso parece muito
doloroso. Desculpe, eu sou Nerva. Por favor, me perdoe. Vamos voltar ao zero. Vamos dar a ela um alívio nas
costas. Aí está. Agora, vamos fazer o mesmo apenas alterando
o namespace. Agora, o outro
namespace está separado e vamos configurá-lo como 80. Vamos executar esse código. Aí está. Como você pode ver, tudo o que estamos
mudando é o namespace. Agora, precisamos saber qual é
o valor de um
controlador. Podemos aplicá-lo ao
próximo controlador, certo? Deixe-me zerar isso. Mais uma vez. Vamos
trazê-los de volta à pose padrão. Deixe-me aplicar um valor
nessa rotação. E acontece que existe uma maneira de obter esse
valor e é muito intuitiva. É chamado Get outer. Trabalharíamos da
mesma forma que eu disse, adder, mas é claro que não estamos
definindo um atributo, então não precisamos passar
nenhum argumento extra. Tudo o que fazemos é pegar um somador. Digamos que queremos obter
o atributo, o valor desse
atributo de rotação, Minerva. Então, temos que mudar
esse namespace Minerva. E diremos que a
rotação é igual a isso. Vamos imprimir isso.
Vamos ver o que acontece aqui. Vamos imprimir a rotação. Deixe-me tornar isso um
pouco maior
aqui e limpar meu histórico
de produção. Ok, aí está. Bom. somador com o nome completo
do atributo basicamente
fornecerá o valor que
estamos procurando. Como você provavelmente está adivinhando, tudo o que precisamos fazer é definir
o atributo. Devo, vou
chamar essa rotação de x porque é isso que estamos fazendo. Ótimo. Então, estamos armazenando
esse valor na rotação x. Então, tudo o que precisamos fazer é
aplicar o mesmo controlador, mesmo atributo nos servidores. Aí está. Ou seja, essa é basicamente
a base da nossa ferramenta. É muito simples, o que é bom, simples, é sempre bom. Só precisamos fazer tudo
isso programaticamente, o que significa que precisamos
saber qual
é o personagem que estamos selecionando, quais controladores
estamos selecionando. Precisamos obter os
atributos disso, desses controladores, e aplicá-los ao próximo personagem. Espero que isso faça sentido. Agora, vamos dar
uma olhada no código.
19. Namespaces e listas: Vamos
cortar o meu, principalmente no PyCharm. Se você ainda não viu
o vídeo padrão, assista-o, a menos que esteja usando
sua própria escolha de texto, etc.
Nesse caso, tudo bem. Mas no vídeo do PyCharm, eu explico como
configurar o projeto. Configuramos o projeto na pasta de
scripts do Maya de
seus documentos. E a razão para isso
é porque o Maya já sabe ler o código
dessa pasta. Então, vamos
escrever nossos módulos ou código aqui para
facilitar o acesso do Maya. Vamos tentar com nosso módulo. Vou criar um novo arquivo,
aquele arquivo de texto simples. Podemos fazer isso dentro
do PyCharm, é claro, mas eu já mostrei
isso manualmente primeiro. Isso é o que
vamos importar. Vou chamá-lo de posts
Transfer dot em vez de dx, dy dot p-y ou Python. O Windows pedirá que eu
confirme. Eu vou dizer que sim. Agora, se eu for para o PyCharm e isso não for
gráfico circular, esse é o termo pi. Você verá esse
arquivo aparecer aqui. E, claro, está vazio. Mas agora podemos começar a codificar. O que precisamos fazer primeiro? Bem, a essência
da ferramenta é basicamente, como mencionei, que estamos
trabalhando muito com namespaces. Little está basicamente
dizendo que a transferência é oposta de um namespace para
outro namespace. Portanto, precisamos ser capazes de obter os namespaces com os quais
queremos trabalhar. Esse é um dos primeiros
passos. Para poder fazer isso. Precisamos trabalhar com a
seleção porque estamos
entendendo que o namespace
é baseado na seleção. Eu seleciono um personagem
e depois o próximo
e, em seguida,
transfiro as postagens selecionadas do personagem
um para o personagem. Então, vamos começar a trabalhar para
obter esse namespace. E então trabalharemos para
conseguir essa eleição. Como obtemos o namespace? Se você selecionar algo? Você verá aqui
na caixa do canal que estão até aqui, como eu
já exibi isso. O nome do
controlador é uma string. Ou podemos pensar
nisso como uma corda. Pelo menos. Ele contém o namespace
, tem dois pontos e, em seguida, contém o
nome do controlador. Então, vamos colocar isso em uma variável. Basicamente, precisamos entender
a primeira parte disso. E para fazer isso, podemos dividir
a string por essa coluna. Podemos controlar a divisão de pontos. Essa é uma função que
vem com cadeias de caracteres. Podemos dizer controle que divide. Queremos
dividi-lo na coluna. Vamos imprimir isso. Vá em frente e imprima isso
diretamente. Ótimo, aí está. Como você pode ver,
temos a primeira parte e depois a segunda parte. Agora, costumava levar
o exemplo para casa. E se dividirmos
os sublinhados? Bem, então você obtém mais peças. Você obtém tudo o que está antes e depois de
cada sublinhado. Mas, para nossos propósitos, tudo o que precisamos é
dividi-lo pelo, pelo cólon. Então, obtemos uma lista, o resultado dessa função
dividida. É uma lista com todas
as partes que foram divididas. E aquela que nos
preocupa é a primeira parte. Como mencionei antes. Aprenderemos sobre a
lista neste projeto. Nossa lista é apenas uma
coleção de objetos, itens, qualquer coisa
que você puder, você quiser. Podem ser cadeias de caracteres, podem ser números inteiros, podem ser
funções em si, podem ser qualquer coisa que você quiser. E começamos a contar
esses itens em zero. Então, esse primeiro item, então deixe-me pintar
para isso. Você pode ver uma lista. Você pode, você pode
imaginar uma lista como essa. Também é chamado de matriz. A propósito, algumas pessoas os
chamarão de matriz, mas nós os
chamaremos de listas. Então imagine que isso é uma lista. Vamos simplificar as coisas. Esta é uma lista com
quatro itens. Também. 3.4. Começamos a contar até zero. Isso é zero, o elemento, isso é um, isso é dois. Isso é verdade. E se você quiser
obter o segundo elemento de uma lista enquanto usa o
índice número um, quais deles
são chamados de índices? Se você quiser obter o
primeiro elemento de uma lista, use o índice zero. Se você quiser obter uma lista diferente do segundo
elemento, use o índice um, e
assim por diante. Então, vamos fazer isso. A sintaxe para obter
um elemento da lista é outro colchete aberto e
fechado. Então, digamos que queremos obter o
primeiro, que é um. Vamos fazer isso e
obteremos um. Excelente. Digamos que queremos
obter o terceiro. Mais uma vez, estamos
começando do zero. Então, obteremos o segundo índice. Excelente. Vamos salvar
essa divisão em uma variável. Vamos chamá-lo de peças de controle. E agora vamos imprimir, deixe-me deletar isso. Vamos imprimir essa variável. Meses excelentes,
novamente, são uma lista. Agora vamos pegar o primeiro item, que mais uma vez,
colchetes de pontuação, zeros, índice. E é isso que
estamos procurando. Isso significa que o espaço principal
do nosso namespace será o primeiro índice. Podemos combinar tudo isso. Dessa forma. Podemos dizer que o namespace será o
primeiro item dessa divisão. Ótimo, então é assim que
obtemos o namespace. Agora, o que precisamos obter
antes de podermos obter o
namespace são esses controladores
baseados na seleção? Então, vamos em frente e fazer isso.
20. Loops de seleção e "para": Seleção. Precisamos dessa biblioteca CMBS novamente. Então, deixe-me
colocar isso por impulso, sim, existe uma função chamada
ls que significa lista. Observe em uma lista de Python como
vimos até agora. Mas eu vi uma função
que fornece uma lista de objetos
na cena, por exemplo, se você quiser colocar todas
as câmeras na cena, você pode importar a biblioteca.
Vamos executar isso. Você vê que as
câmeras entram em cena a partir dos respectivos resultados da câmera. Com algumas câmeras, você
pode obter luzes, por exemplo, que eu não tenho nenhuma
luz no momento. Então essa é uma lista vazia. Vamos esperar isso. Você pode obter a seleção. Como não tenho nada selecionado, tenho uma lista vazia. Mas assim que eu
selecionar algo, deixe-me limpar minha janela de saída. Assim que seleciono algo, recebo uma lista com esses objetos
elétricos selecionados. E como você pode ver, esse é o nome que
estamos procurando. Então, se eu selecionar mais de um, digamos que este braço
me controla, basta imprimir. Aí está. Então, eu recebo uma lista
de todos esses controladores com seu namespace
e o controle. Agora podemos começar a
aplicar essa técnica para extrair o namespace de
toda a seleção. Então, vamos passar para o termo pi para
começar a fazer isso. Em nosso módulo pós-transplante, a parte que acabamos de criar, vamos criar uma função def space definiu a
função, get selected. Namespaces, abrir, fechar
parênteses, coluna. Mas antes de tudo, vamos começar
obtendo a seleção. Assim, podemos armazenar
essa seleção como
mostrei antes em uma
variável chamada seleção. A seleção será igual. E, na verdade, eu não importei minha biblioteca do Maya,
importante CMBS. Eles serão mostrados em vermelho. Isso ocorre porque o Python não sabe de onde obter o
CMB como biblioteca. Mas isso não importa porque o PyCharm não está executando o código. Nesse caso, o maya
executará esse código. Então, desde que Maya tenha
acesso a isso, tudo bem. Portanto, a seleção é igual a
Cmd S dot ls. Seleção é igual a verdadeira. Isso nos fornecerá os controles
selecionados. Então, o que acontece se
nada for selecionado? Podemos verificar o
tamanho de uma lista. Então, mais uma vez, isso
será uma lista. Podemos verificar
por quanto tempo eu listei com uma
função de retorno de chamada funcional chamada Len L-E-N. A seleção de
lentes basicamente
dirá quantos itens
estão em uma lista. Agora, eu mencionei antes que
você começa a contar até zero. Mas no caso do tamanho, na
verdade
está informando o número de coisas dentro da lista. Portanto, não
contará em zero se a lista tiver três
elementos. Land, nós lhe daremos três. Queremos dizer se len é igual a zero, o que significa que não
há nada
dentro da lista. Bem, não podemos obter nenhum namespace do nada,
então não podemos continuar, então podemos voltar aqui. Mas estamos criando uma função
que retornará namespaces. Então, vamos nos manter consistentes
e retornar uma lista vazia. Antes de continuarmos, vamos
definir as expectativas dessa função
na docstring. Mais uma vez, vou
pressionar 33 aspas duplas. Nós diríamos que vou escrever uma pequena descrição
para a função. Obtenha uma lista dos selecionados. Agora, obtenha uma lista de namespaces
para a raça selecionada. E ele retornará uma lista. Excelente. Portanto, se não
houver nada selecionado, retornaremos uma lista vazia. Caso contrário, teremos
que passar por essa seleção para
poder obter os
namespaces que acabamos de ver. Como fazemos isso? Precisamos
usar um loop for para isso. A sintaxe para isso é for, vamos chamá-lo de item. Na seleção. Vamos pegar nosso
código que acabamos de ter. Nós tínhamos aqui em cima. Deixe-me colá-lo aqui. Na verdade, vamos
chamar isso de controle. Vamos chamar isso de controle
em vez de item. Nesse caso, não
precisamos disso aqui porque
está codificado. Não queremos trabalhar
com esse único controle. Trabalhe em qualquer coisa
que tenha sido selecionada. Para controlar a seleção. Obtenha o namespace, o que
mais uma vez fazemos dividindo o controle por dois pontos e
, em seguida, obtendo o primeiro item. E agora, para armazenar nossos namespaces, vamos começar
uma lista vazia. Namespaces equivalem a uma lista vazia. Então, como adicionamos esse namespace a esses namespaces de
listagem, vamos chamar isso
realmente na lista de espaços. Um pouco mais explícito. Você pode dizer namespace, list, dot append e namespace. Agora, algo que
você provavelmente está percebendo é que as listas
podem ser modificadas. Isso é chamado de mutabilidade. A lista é imutável, o que significa
que ela pode ser modificada. Há outro tipo de dado, esse tipo de dado chamado
tupla, que funciona como uma lista, mas não pode ser modificado. É imutável. Mas vamos abordar
isso um pouco mais tarde. Por enquanto, é importante
saber que
pelo menos pode ser modificado no local. Então, toda vez que estamos
anexando um namespace aqui, na verdade
estamos modificando
essa lista aqui em cima. Então, uma vez feito isso, vamos retornar essa lista de
namespaces. Deixe-me adicionar alguns comentários. Deixe-me dizer aqui que vamos
extrair o namespace do controle. Aqui, vamos analisar
a seleção. Agora, isso é muito redundante, mas é a primeira vez que
estamos procurando loops. Então, vamos adicionar alguns
comentários e depois adicionar namespace para
listar os namespaces. Mais uma vez, muito redundante. Você não precisa
adicionar esses comentários, mas apenas para ser um
pouco mais explícito. Excelente. Então, vamos ver o que
essa função está nos dando. Vamos importar esses
módulos de transferência de
postagens e simplesmente
usar nossa função. Então, vamos voltar para Maya. Vamos abrir uma nova guia do Python. E agora vamos importar
pose, transferir. Eu, faça a fonte
um pouco maior. Vamos simplesmente executar isso. Agora, se eu destacar o
nome do módulo e executá-lo, você sabe
que é, é, ele diz que está vindo documentos
de localização, script
Maya, suponha transferência, excelente ou está no caminho certo. Vamos simplesmente usar nossa função. Vamos armazenar o
ajuste do resultado nessa variável. Vai
chamá-lo de pós-transferência. Primeiro, eu vou
chamá-la, vamos chamar a função após
a
transferência e ela se
chama obter namespaces selecionados. Então, vamos primeiro testar o caso
em que nada está selecionado. Desculpe, eu não o imprimi. Então, vamos imprimir espaços de nomes. Ótimo, uma
lista vazia, como esperado. Agora, se eu selecionar um controle, obteremos esse namespace. Se eu selecionar dois caracteres, vamos selecionar o
primeiro e o segundo REG. Ok, estamos recebendo todos
os namespaces, mas
eles são repetidos. Então, isso é, isso não é
necessariamente redundante. Temos um bug. Vamos ver
o que está acontecendo lá. Então, digamos que eu selecione um
controle em cada personagem. Agora, esse é o
resultado que queremos. O que está acontecendo agora é
que estamos recebendo
o namespace várias
vezes por personagem. Então, vamos em frente e consertar isso. Vamos voltar ao PyCharm. Isso é verdade. Portanto, estamos anexando o namespace
todas as vezes. Mas o que queremos é
anexar a essa lista apenas
a lista de namespaces, se ela ainda
não estiver na lista. Portanto, podemos simplesmente dizer que,
se não for um namespace na lista de namespaces, o
que você pretendia, então você está
realmente trabalhando. Isso está correto, mas
geralmente mais comum
escrevê-lo dessa maneira. Caso contrário, é um namespace,
não um especialista. Essa é uma verificação muito simples para ver se algo está
dentro da lista inteira. Se não for,
acrescentamos: excelente. Vamos voltar para Maya. Deixe-me recarregar este módulo
porque fizemos algumas alterações. Vamos recarregar isso. Vamos executar esse código mais uma vez. Excelente. Então, agora,
o que acontece se selecionarmos vários controladores? Você ainda recebe apenas um único
namespace por personagem. Incrível, é
exatamente isso que queremos. É selecionar
algumas outras coisas. Então, vou
desligar tudo , exceto as curvas nervosas
para seleção. Ótimo, é
exatamente isso que queremos. Então, nossa primeira função está pronta. O Docstring está pronto. Ótimo, vamos passar
para a próxima função.
21. Visão geral de "para": Antes de passarmos para
a próxima função, quero esclarecer
o que o loop for está fazendo, porque esse é um conceito novo e vamos
usá-lo muito mais. Então, vai ser
muito familiar para você. Mas vamos dar uma olhada rápida no que realmente está acontecendo. Mais uma vez, tínhamos nossa lista. Vamos criar uma lista de exemplos. Vou chamá-la de lista de testes. Agora, estou evitando
ligar para essa lista. É válido. Você pode chamar
essa lista de variáveis. Mas pelo menos na verdade é um tipo embutido em
Python ou uma função, o que significa que você pode transformar
algo em uma lista. Ao fazer isso, por exemplo, você pode transformar uma
corda na mais alta, ignorando-a nessa função. É por isso que estou evitando
ignorar isso, porque se eu chamar
minha lista de variáveis, vou
substituí-la e geralmente é uma má ideia. Talvez não seja uma má ideia,
mas não é uma boa ideia substituir
tipos integrados em Python. Então, vou
chamá-la dessa lista, e será apenas
uma lista simples de cadeias de caracteres. Vamos dar o mesmo
exemplo de antes, 123. Agora, o loop for, ele percorrerá
esses itens ou iterará sobre cada
um desses itens. Vamos dizer para número na lista, lista, número impresso. Vamos executar esse código. Excelente. Então, como você vê, é simplesmente imprimir cada um
desses itens dentro dessa lista. Agora, número é uma
variável que eu escolhi, que você escolha o
nome dessa variável. E você está basicamente dizendo para cada um desses elementos, então essa lista armazena isso
nesse número variável. E então, dentro
desse loop for, você pode usar esse número. Por exemplo, podemos, podemos fazer alguns
números inteiros, digamos 235. Vá falar sobre isso. Mas também podemos dizer imprimir
número vezes dois, por exemplo, esses devem ser impressos
ou 6.10, certo? Aí está. Então é isso,
o que está acontecendo. Basicamente, estamos dizendo store, analise cada um desses
itens armazenados em uma variável, então essa variável acessível para você
dentro desse loop for. E estamos basicamente
fazendo isso
a partir da seleção que funciona
na biblioteca CMBS. Para concluir este exemplo, vamos usar o
que precedeu a onda S. Vamos deixar o número da
variável. Não é um bom nome para o que estamos usando aqui,
mas é válido. Aí está. Então, como você pode ver,
é simplesmente iterar sobre cada
elemento que será selecionado. Espero que esteja claro,
mas não se preocupe, continuaremos usando for-loops ao longo
deste curso. Então, vamos passar para
a próxima função.
22. Obter atributos: A próxima coisa que precisamos fazer é obter os atributos que
queremos transferir, certo? Então, essa ferramenta está basicamente dizendo: pegue os controladores selecionados,
obtenha os atributos. Também teremos que
armazenar os valores de cada um
desses atributos. Vamos falar sobre isso a seguir. Mas primeiro precisamos
obter os atributos para que possamos transferi-los
para a próxima semana. Então, como
transferimos atributos? Ok, bem, vamos
trabalhar com esse controle novamente. Vamos colocá-lo aqui. Digamos que estamos trabalhando
com esse controle. Agora, o nome do nó
inclui o namespace. Isso é importante
porque é assim que Maya sabe qual personagem é. controle pertence ao que são os pulmões
controláveis por si só. Esse é o nome da base, o nome base do controle. Mas dentro da cena, ele vive sob esse namespace. Portanto, é importante
manter isso lá. Há uma função
chamada list adder. E vamos dar uma olhada no que ele faz na documentação. Eu o tenho aqui. Adicionador de lista, você pode
simplesmente procurar. Diz que esse comando lista
os atributos de um nó. Se não houver fluxo ou for especificado, todos os atributos serão listados. Ok, vamos
ver os exemplos. Parece que, se você não
der o nome de nenhum nó, ele listará os atributos
das notas selecionadas. Mas se você der
o nome de um nó, ele listará os
atributos desse nó. Então, vamos experimentar isso. É chamado de nó de controle. Nodo. Vamos chamá-lo de armazenar isso em uma
variável chamada atributos, e vamos imprimir essa variável. Ok, ótimo. Então, isso é um monte de atributos,
uma lista muito longa. Alguns deles são o que
vemos aqui em amplitude. Provavelmente
veremos rotação, translação. Mas também vemos
muitas coisas que
provavelmente são herdadas
de outra coisa. Agora, na verdade, existem
limitações, é
claro que há algumas restrições com as quais devemos
nos preocupar, por exemplo , não queremos obter
atributos bloqueados. Por exemplo, só
queremos obter atributos
que possamos definir. Então, se você estiver acessando
a documentação, você realmente
verá que existem algumas opções que você pode
passar para esse comando. Você pode se livrar apenas dos atributos do
ato. Você pode obter atributos que
são ração, que estão bloqueados. E você pode obter
os que são. Então, aqui, configurável. Vamos dar uma olhada no
que isso nos dará. Configurável é igual a verdadeiro. Ok, isso não
parece muito diferente. Eu mostrei, eu sei que é diferente. Começa com o pagamento em
vez de uma mensagem. Isso ainda é muito. Uma
lista menor, como você pode ver, ainda é grande e
há coisas com as talvez não nos
importemos. Então, que tal focarmos nos atributos na caixa
do canal? Para isso, há
outra função. É uma função chamada CMBS, totalmente feita de uma tigela. Agora vamos ver isso
na lista de documentação animável, como encontrei esse bônus
para pesquisar fóruns na internet e procurar a melhor maneira de obter atributos
da caixa do canal. Eu fiz esse trabalho antecipadamente para você e agora estou apenas
lhe dando a resposta. Caso contrário, ele
levaria muito tempo. Portanto, esse comando lista os
atributos animáveis de um nó, permite a filtragem pelo manipulador ou
nó
atual . Ok? Provavelmente podemos usar esse
ativo sem nenhum argumento. Nós realmente não nos
importamos com as formas. Nós não nos importamos. Tipo. Eles saem sólidos,
não são mais suportados. Não precisamos nos
preocupar com isso. Afetado apenas pelo manipulador
atual. Definitivamente não
quero fazer isso. Isso significa que, se o
manipulador estiver no modo de
tradução, você
obterá apenas os atributos de tradução. Definitivamente, não
queremos fazer isso. Vamos simplesmente passar
esse nó e substituir nosso somador de lista por
nossa função animável de lista. Vamos imprimir isso. Ok, isso parece muito diferente. Para facilitar
a leitura. Na verdade, vamos dar uma olhada
nessa lista. Então, digamos que para lontra em
atributos, imprima mais quente. Agora, isso é apenas para fins
de visualização. Eu só queria ver a lista em vez de ter a lista plana. Sim, aí está. É apresentada
como uma lista real. O que estamos vendo aqui, na verdade, estamos vendo
o caminho completo
desses atributos
ou o caminho
completo desses controladores. Então, como você vê, está iniciando todos
esses nodos de anime. E então
entra no grupo de plataformas. E então há outro
grupo chamado Butter Regroup até o fim. Ao final de cada um deles, haverá o nome
do controlador. E no final estará o
nome do atributo. É com isso que
realmente nos preocupamos. E isso é o que vemos
na caixa do canal, translação x ,
y e z, rotação e
largura ou largura. Isso é ótimo. Isso é o que realmente queremos. Nós realmente não nos
importamos com tudo isso. Honestamente, isso é muito detalhado e um pouco irritante,
se estou sendo honesto. Então, vamos limpar isso. Se você observar esse
caminho com cuidado, podemos fazer algumas coisas. Mas algo que
já aprendemos a fazer é como dividir cordas. Então, podemos simplesmente
dividir pelo ponto. Observe que
não há outros pontos aqui. Então, isso será salvo para fazer se houver uma porta em seu equipamento. Esse pode ser um caso um pouco
diferente. Nesse caso, ainda podemos obter o último item da string. Ok, vamos imaginar
que esse seja o caso. Então, vamos trabalhar com esse exemplo. Digamos que queremos
obter o nome
desse atributo
dessa lista muito longa. Tudo bem, então normalmente
trabalhe em uma guia separada do
Python e cole-a aqui. Tudo isso é externo. O nome será igual a
essas sequências muito longas. Então, o que acontece se
dividirmos por pontos? Vamos seguir em frente e
fazer tudo isso. Deixe-me tornar essa variável um pouco mais curta, apenas ruim. Para facilitar a digitação. Completo. Divisão de pontos do somador. Que, em vez de
dividir por dois pontos, vamos dividir pelo ponto. Vamos chamar isso de partes. Vamos
imprimir essas peças,
que, como sabemos, serão uma lista das
peças antes e depois qualquer dúvida que ela encontre
nas peças excelentes. E vamos realmente ver
quantas peças temos. Podemos imprimir o
tamanho dessa lista. Peças da lente. Tudo bem, há dois deles. Portanto, há uma primeira parte muito
longa aqui, que é o nome
do controlador. Então, no final,
esse é o nome do atributo
que nos preocupa. Agora, eu mencionei
o que acontece se houver outro.nesse
nome por algum motivo. Vamos colocar a.in aqui apenas
por uma questão de exemplo. Tudo bem, vamos executá-lo. Agora. O tamanho da nossa lista é três. Isso porque, claro,
encontramos outro ponto
e outro ponto. E agora temos três partes. Mas ainda assim, aquele que nos
importa é aquele que está
no final. Se assumirmos que não há, há apenas um. No nome, podemos simplesmente dizer, ok, dar o nome do
atributo que será o segundo. O que acontece se
houver mais de um? Bem, precisamos obter
o último índice, certo? Como fazemos isso? Há duas maneiras de fazer isso. De uma forma, já sabemos
quantos itens estão na lista. Então, podemos simplesmente dizer, ok, há três itens que queremos o terceiro item, porque
começamos a contar até zero. Na verdade, podemos dizer, ok, queremos o número
de itens menos um. Porque o terceiro item, se você estiver contando até zero, será o número 20 será o primeiro, 11 será o segundo, 12 será o terceiro, certo? Então, podemos usar isso
a nosso favor. Peças. Digamos que o número das peças
seja o tamanho da lista de
cadeias de peças. E depois o nome do atributo. Vamos chamá-lo apenas de somador. O somador será arts e o número do índice será o último índice possível, que é o
número de partes menos um. Então, vamos imprimir a manteiga. Aí está. É isso. É com isso
que nos preocupamos. Agora, há uma
maneira mais fácil de conseguir isso. E isso é simplesmente
dizendo menos um. Sem nem mesmo saber
quantos itens estão na sua lista. Podemos simplesmente dizer:
dê-me o índice menos um, que será o último índice. Como isso está funcionando? Vamos detalhar isso
antes de continuarmos. Como eu te mostrei antes. Vamos imaginar novamente com quatro itens, como
mostrei antes. O primeiro item é índice zero, o segundo item é índice um. O terceiro serão dois. Um para frente será
três, etc., etc. Também há índices negativos. Portanto, o último índice da lista será
índice menos um. Desculpe, é assim que o índice
inverso é menos um. O penúltimo
será menos dois. O terceiro último, é
claro menos três, e assim por diante. Dessa forma, sem saber quantos
itens estão na lista, você pode simplesmente dizer, ok, me
dê o último. Ou se você quiser que eu seja
o penúltimo. Então, deixe-me mostrar
um exemplo disso. Vamos voltar para Maya. Vamos abrir uma nova guia do Python. Vamos fazer uma nova lista de exemplos. Vamos chamar isso de exemplo. Digamos 123. Como sempre, já estamos acostumados com
esse exemplo. Então, se eu disser exemplo, me
dê o índice de zeros. Bem, deixe-me descobrir
isso. É impresso. O índice zero do
exemplo será um. Vamos trazer o terceiro. O segundo índice será, o que equivale
ao terceiro item. Isso é três. Agora, se eu disser, me
dê o último, índice menos um,
é a mesma coisa. Agora me dê um índice menos dois. Isso é equivalente, o mesmo. Então essa é outra maneira de
você obter o último
item desta lista, não importa quantos pontos
você tenha aqui. é um pouco
mais
de prova falhada De certa forma, é um pouco
mais
de prova falhada, porque sabemos que a última parte disso
serão nossos atributos. Aí está. Vamos juntar tudo isso muito
rapidamente. Vou copiar
esse trecho de código. Já sabemos como obter esses
nomes de atributos longos de um controle. E vou colar
o resto do nosso código aqui. Torne isso maior. Ok? Sabemos que os atributos
conterão esses nomes muito longos. E já sabemos como
obter o nome simples
ou o nome abreviado desse atributo dividindo suas partes e obtendo
a última parte dividida. Ok, vamos, vamos,
vamos combinar esses. Como dissemos, não precisamos
realmente saber quantos itens estão
na lista do sprint. Podemos fazer tudo isso
dentro desse loop. Como já
temos esse código aqui. Vamos colocar esse código e
colá-lo dentro do loop for. Agora sabemos que a
lista de atributos terá esses
nomes longos de atributos. Então, vamos chamar isso de somador completo. E então os verbos estão basicamente
circulando sobre cada um
desses nomes muito longos que obtivemos
da função animável da lista
ou dividindo-os em partes. Estamos recebendo o nome abreviado, que é a última
parte que dividimos, e esse é o nome
dos nossos atributos. Então, vamos ser mais explícitos. Vamos chamar esse nome. Remova isso. Ok, aí está. Isso é um pouco mais limpo. Podemos ativar isso no
nome, eu não menciono. Na verdade, podemos criar uma lista
desses outros nomes
da mesma forma com
os namespaces. Podemos dizer
nomes de somadores, acrescentar pontos. Se você está se perguntando,
precisamos verificar se já temos o
atributo em outros nomes? Nós poderíamos. Mas essa função fornecerá uma lista
de atributos,
atributos e um
controlador exclusivos , geralmente exclusivos. Portanto, eu não me preocuparia verificar se eles
já estão na lista ou não, porque há uma chance muito boa de serem únicos. Ok, vamos, vamos, vamos, vamos ver o fluxo disso. Mais uma vez, começamos
com um controlador. Nesse caso, estamos codificando o nome
do controlador. Obtemos esses nomes longos de atributos da função
mensurável de escuta. Começamos uma lista vazia para
armazenar nossos nomes curtos. Eles são apenas os
nomes simples dos atributos? Agora iteramos, percorremos
todos esses nomes longos e começamos a dividir. Então, simplesmente, quando chegamos
ao nome abreviado de que
gostamos, adicionamos aqui,
anexamos a essa lista. E então, por enquanto, podemos
simplesmente imprimir essa lista. Aí está. Essa é a
lista que nos preocupa. Então, vamos transformar
isso em função que não
codifica os nomes, mas pegaremos qualquer
nó de controle
arbitrário e forneceremos os
atributos dele. Deixe-me copiar isso e colocá-lo em nosso módulo
no gráfico circular. Mas ainda assim
Clara, a função final, obtém exteriores do node. Ok, vamos colar isso
dentro dessa função. Como queremos ser capazes de
fazer isso para qualquer nó, podemos realmente usar uma
passagem de entrada como entrada. Então isso significa que
não precisamos mais disso. Vamos passar
pelo nó de controle. Nós obteremos os atributos. Agora, o que acontece se não
houver atributos? Bem, essa é uma boa pergunta. Assim como estamos fazendo aqui, se não houver nada selecionado, retornaremos uma lista vazia. Vamos seguir em frente e fazer isso. Se os atributos len forem
iguais a zero, retornaremos uma lista vazia, mesma forma que fizemos com
os namespaces. Às vezes, essas
funções no Maya,
se não houver nada que retorne
, retornam um valor diferente de zero. O que não é ótimo. Eu, para ser honesto,
deveria ser consistente. O valor de retorno deve
ser uma lista vazia. Mas às vezes isso acontece. Então, se for esse o caso, nenhum deles realmente
falhará se você tentar fazer isso. Então, precisamos de outra alternativa. Como podemos verificar se
algo está, que não está lá,
algo que está vazio é algo
falso. Vamos dizer o que vimos antes. Podemos dizer que, se não forem atributos, retornarão uma lista vazia, isso
funcionará para ambos, se não for um atributo. Então, se, se isso for, se os atributos retornarem
um não, isso funcionará. Mas também se o atributo
retornar uma lista vazia, isso também funcionará,
o que é ótimo. E coincidentemente, essa
é uma string vazia,
por exemplo, isso funcionará. Então, a sintaxe
é realmente muito útil porque você não precisa saber exatamente que tipo
você está esperando. Você pode simplesmente dizer que, se for do tipo
vazio,
faça alguma coisa. O que estou dizendo, se não estiver
vazio, então faça alguma coisa. Isso significa que
também poderíamos fazer o mesmo aqui. Poderíamos estar dizendo:
Se não for seleção, retorne uma lista vazia. Nos dois sentidos em um piloto, se você sabe com certeza
que
será uma lista, você pode usar o Len. Caso contrário, você
não poderá usar a variável. Sabemos que a seleção
é de fato uma lista, então não vamos nos
preocupar com isso. Vamos deixar
isso como está. Mais uma vez, obtemos os atributos
do nó de controle. Se não houver atributos, retornará uma lista vazia. Caso contrário, inicializaremos
uma lista vazia para armazenar nossos atributos. Vamos em frente e dividimos
os nomes
desses atributos e
simplesmente obtemos o nome
que nos interessa. Você provavelmente está
pensando: poderíamos combinar essas duas
linhas em uma? Sim, nós poderíamos. Poderíamos simplesmente dizer: pegue o último item diretamente dessa divisão e dizer que o
nome real do atributo será esse. E remova essa linha completamente. Aí está. Agora, aqui embaixo,
em vez de imprimir, queremos retornar essa
lista de atributos. E antes de prosseguirmos, vamos adicionar nossa docstring. Obtenha nomes de atributos do node. Na verdade, desculpe, isso
é de um único nó, não sei se é um nó de
controle plural. Estamos esperando uma corda. Nó aberto. Nós retornaremos uma string, não, desculpe, uma lista. Ou retorne uma lista com base em nomes de atributos
simples. Na verdade, digamos luas de atributos
curtos. Isso é o que é. Tudo bem, perfeito. Vamos testar
rapidamente nossa função. Nós importamos esse módulo aqui. Então, vamos recarregar a
pós-transferência
mais uma vez porque
fizemos algumas mudanças. E então segure. Obtenha erros do nó, obtenha setas do nó. Vamos passar por esse nodo. Por enquanto. Mais uma vez, estamos esperando uma string
chamada somadores. Vamos imprimir. E aí está. Isso é o que esperávamos. Excelente.
23. Armazenar o pose - Introdução aos dicionários: Agora que estamos obtendo os
atributos que nos interessam, a próxima etapa é
obter um mapeamento
desses atributos com os valores que queremos definir neles. Porque, mais uma vez,
o objetivo dessa ferramenta, e deixe-me definir alguns
valores e esse controlador, o objetivo dessa ferramenta é
obter os atributos
nos controladores. Selecionamos os valores
desses atributos e aplicamos esses atributos
e esses valores ao
controlador equivalente em outra plataforma. Então, como geramos
esse mapeamento? Com base no que vimos? Uma maneira de fazer isso,
podemos simplesmente usar duas listas. Digamos que temos uma
lista de atributos. Vamos chamar isso de lontras
traduzem X, por exemplo, ardósia. Por quê? Vamos
usar apenas dois agora. Então, podemos ter
uma lista de valores. Poderíamos dizer que isso será, estou apenas copiando esse valor
aqui para traduzir que x será aquele valor menos dez
pontos alguma coisa. Então, traduzir Y
será -3,90, 54. Então, nós poderíamos, isso poderia funcionar. Podemos dizer, ok, bem, o primeiro item
na lista de valores
pertencerá ao primeiro item
na lista de endereços.
O mesmo acontece com o segundo. E essa é uma forma de
criar um mapeamento, certo? No entanto, há uma
maneira melhor de fazer isso. Há um tipo de dados em
Python chamado dicionários. Um tipo de dados é simplesmente um tipo que
permite armazenar dados, pelo
menos aqui. Esse é um tipo de dados. String é um tipo de dados. O dicionário, ou
um ****, para abreviar, é um tipo
de dados como uma lista, mas cada item
no dicionário
conterá um mapeamento entre
uma chave e um valor. Agora, a forma como
criamos um dicionário é usando chaves. Você pode ver um
dicionário mais ou menos
como uma lista telefônica. Então deixe-me, deixe-me deletar isso. E antes de criarmos
um dicionário real, digamos que quiséssemos
criar uma lista telefônica maior. Ou Ashley, quero dizer, como um dicionário em si. O dicionário tem uma palavra
e depois uma descrição. Descrição do mundo. Ou mais uma vez, o exemplo da lista
telefônica. Digamos que temos Rachel
e temos o número dela. Digamos que temos linhas
e temos o número dele. Agora, para traduzir isso em
um dicionário Python real, vamos chamá-lo de telefones. Mais uma vez, vamos
usar os colchetes, a lista usa os
colchetes. Vamos usar
o colchete encaracolado aqui. Como eu disse, cada item
do dicionário terá uma chave. Nesse caso, a chave
será Rachel, depois dois pontos
e, em seguida, o valor, que será o número dela, depois a vírgula, para
separar os itens. Então, este aqui é o
primeiro item do dicionário. O segundo item, obviamente,
será cólon de
Ross para separá-lo. E então 9876. Aí está. Então, este é o equivalente Este exemplo de lista telefônica
que criamos aqui. Como acessamos o número de
telefone da Rachel? Vamos chamar isso. Vamos desenhar isso em uma
variável chamada número. É uma sintaxe semelhante à da lista que abrimos e
fechamos colchetes. Mas, em vez de usar um índice, você usará
a chave da qual deseja
obter o valor. Esse caso será Rachel. Vamos trazer isso. Aí está. Nós recebemos o número. Agora. Nós pegamos Ross. Entendemos que
Ross é o número. Excelente. Então,
é assim que você pode criar mapeamentos em Python. Antes de criarmos nosso dicionário de
atributos real, que seria mais ou menos
assim. Este caso será Translate. X seria esse valor aqui
que estou criando manualmente, mas é claro que
faremos isso com base na seleção. Y será esse valor aqui. E então vamos chamar isso de dicionário de atributos de
lontras. E deixe-me obter o
valor disso. Estou apenas mudando os
nomes das variáveis. Isso não importa. Só estou tentando tornar isso
um pouco mais óbvio. Tudo bem, isso é ótimo. Eu cometi um erro. Ross não é uma chave
nesse dicionário, é
claro, porque
mudamos as chaves. Se você tentar obter um valor de um tipo que não existe,
você receberá esse erro. Então, deixe-me pegar um
que eu deveria existir. Aí está. Antes de criarmos nosso dicionário
real, algumas coisas a ressaltar
sobre os dicionários é que as chaves precisam ser exclusivas. O que quero dizer com isso? Digamos que eu queira
adicionar uma nova chave Translate Y. E o valor será, vamos chamá-lo de 100. Agora, se eu ficar interessado em você, pegue apenas um deles e o
primeiro será ignorado. Mais uma vez, isso
ocorre porque se você adicionar a mesma chave mais de uma vez, ela será substituída
porque as chaves
precisam ser exclusivas. Excelente. Então, acho que devemos examinar algumas das
funcionalidades dos dicionários. Mais uma vez, para obter um valor, você usa os colchetes. Deixe-me remover essa chave, aquela chave, colchete central
e, em seguida, você usa a chave da qual
deseja obter o valor. Se você quiser obter todas
as chaves em um dicionário, basta
dizer teclas de pontos do
dicionário. Isso lhe dará
uma lista das chaves. Agora, se você quiser obter
uma lista dos valores, faça os valores de pontos do
dicionário. Em seguida, você obtém uma lista de valores. Mas, na maioria das vezes, você simplesmente usará o nome da chave
aqui para obter os valores. Agora, como você adiciona
itens a um dicionário? É a mesma, a mesma sintaxe, da mesma forma que você obtém um valor. Mas, em vez de apenas
escrever o valor do cosseno, adicionaremos um
valor parecido forma como armazenamos valores
em uma variável. Você armazenará um valor
em uma chave em um dicionário. Da mesma forma, você
especificará uma chave. Deixe-me dizer, deixe-me
chamá-la de uma nova chave. E diremos que o valor
será 123, por exemplo, se eu fosse imprimir a célula
do dicionário, ela já foi impressa antes. Em seguida, vamos adicionar um
novo valor de Cuba e depois imprimi-lo. Como você vê, temos nossa nova chave, mas o novo valor, e depois as duas crianças
mais velhas que já tínhamos. Você também está percebendo que
isso não está em ordem ou uma nova chave foi aparentemente
adicionada no início. Na verdade, não foi
adicionado naquele começo. Os dicionários não
têm nenhuma ordem. Eles não acompanham as listas
de pedidos. Acompanhe a ordem em que você adiciona itens a eles. Os dicionários não. Isso ocorre porque você
acessa itens por meio da chave. Há outras razões para isso. É porque os dicionários
são, na verdade muito eficientes quando se trata de
acessar os dados
dentro deles
por meio de algo
chamado HashMap. Mas não se preocupe com isso. Esses são detalhes técnicos e realmente
não importam no momento. Saiba que os dicionários não
estão em ordem, mas isso não
importa, porque você sempre obtém os valores
por meio das teclas. Agora, o que acontece se
você substituí-lo aqui? Se você quiser anular, eu mantenho, basta dar o
nome dessa chave. Então, em vez de -3,90, 54, vamos sobrescrever
esse valor para 123. Como você pode ver aqui. Agora, neste caso, esses dois são impressos
na mesma ordem, mas não necessariamente não
há como ordenar o dicionário. Então, aqui nós adicionamos e
substituímos isso, esse
valor para aquela chave. Ok, espero
que isso faça sentido. Os dicionários são muito
divertidos e muito úteis. Vamos criar um
com nossos atributos. Vamos criar um
dicionário que
realmente queremos que se pareça com esse atributo
e depois com o valor. Mas lembre-se de que
vamos usar, e deixe-me remover
essas linhas de código. Vamos usar
as funções externas e
externas definidas. Deixe-me definir um atributo
para que minha perna fique quieta, essa informação muito útil. Lembre-se de que Maya estará grávida ou Masaryk
partirá. Nossa função estará esperando o nome completo do
atributo e, em seguida, o valor. Parece que é
isso que precisamos
definir, certo? Portanto, nosso dicionário pode ser mais
parecido com isso, mas há algo que
precisamos considerar é que queremos armazenar
o controlador seus atributos e seus valores,
independentemente do namespace porque queríamos
transferir valores de um equipamento em nosso
namespace para outro equipamento. Na verdade, o dicionário em si
não quer nem precisa saber
sobre o namespace. Isso significa que nosso dicionário
ficará mais parecido com isso, que será o nome
do controlador depois o nome do atributo. Alguém poderia argumentar
que isso é redundante, então não precisamos fazer isso. Poderíamos simplesmente dizer que poderíamos simplesmente armazenar
os atributos que
queremos e adicionar o nome do
controlador posteriormente. Isso também pode funcionar, mas acho que é mais simples
fazer dessa maneira. Nome do controle, nome
dos atributos sem
o namespace. Assim que estivermos definindo
os atributos, forneceremos o nome completo dos atributos,
incluindo o namespace. Assim, podemos sempre
colocar o namespace por parentesco, fornecer o nome completo
do atributo
e, em seguida, simplesmente usá-lo para obter o valor do
nosso dicionário, que será mais ou menos
assim. linha de código muito longa, mas será mais ou menos
assim. Basicamente, acho que
você entendeu. Vamos apenas obter esse valor
e aplicá-lo ali mesmo. Ok, este é o dicionário
que realmente queremos. Vamos começar a construir isso.
24. Armazenar o pose - construir o dicionário de pose: Para obter o
dicionário que
queremos, precisamos considerar
algumas coisas. Sabemos o que queremos
obter com base na seleção. Mas temos que ter cuidado porque sabemos
que queremos obter o dicionário dos atributos e
dos controladores somente
a partir
do primeiro caractere
que selecionamos. Porque decidimos
que o fluxo de trabalho
da ferramenta consistirá selecionar os controladores que
você deseja transferir
e, em seguida, selecionar qualquer controle
em sua plataforma ou nervuras de destino. Portanto, precisamos de alguma forma filtrar os controladores que são apenas parte da primeira
semana que selecionamos. Como fazemos isso? Há algumas maneiras de fazer isso. Vou
entrar no PyCharm e começar a bloquear minha função. Então, deixe-me criar uma função, vamos chamá-la de get pose
dictionary ou apenas o deck. Vamos fazer um
bloqueio rápido antes de
escrevermos qualquer código. Sabemos que precisamos
obter a seleção. Ou ele nos será
fornecido ou
podemos nos inserir
nessa função. Sabemos que precisamos obter
os atributos que
já
desenvolvemos aqui. Então, isso é feito. Precisamos montar
a seleção. Juntos, uma seleção com
os atributos que obtivemos. E então precisamos criar um dicionário e depois
devolver o dicionário. Portanto, precisamos obter a seleção, mas também precisamos
filtrar a seleção. A propósito, só um passe rápido. Nós, essa é uma boa maneira
de começar a bloquear. Sua função é decidir o que você quer que seja o fluxo
de sua função. Outra coisa que você
pode estar percebendo é que estamos mantendo funções
muito especializadas, muito separadas umas das outras. E isso geralmente é uma boa
maneira de organizar seu código. Torne suas funções tão simples, quase tão necessariamente
especializadas quanto possível. Eu não deveria dizer desnecessariamente, mas torne-os o mais
especializados possível. Então, se você notar aqui, essa função aqui em cima, tudo o que ela está fazendo é
obter namespace. Não é nada mais.
Essa função aqui, tudo o que ela faz é
fornecer uma lista de atributos. Agora, você pode argumentar
que minha primeira função, o namespace, é a função,
não é apenas entrar em espaços, mas também obter uma seleção. E eu diria que uma boa
maneira de tornar isso ainda
mais simples é por Ashley fornecendo
a seleção
da função para que a função não precise funcionar com nenhuma seleção. Acho que essa é realmente uma boa maneira de melhorar
essa função. Mas não se preocupe com isso,
agora podemos
voltar e refatorar. Essa refatoração significa
reescrever a função. Então, reorganizar ou codificar é algo
importante de se saber. É muito bom planejar com antecedência como você deseja
estruturar seu código
e suas funções. E geralmente tente
bloquear seu código ou organizá-lo de forma que suas funções
sejam muito especializadas, como eu já disse, mas
você também não precisa se preocupar nem tentar
aperfeiçoá-las na primeira vez. Porque você sempre pode
voltar e
reorganizá-los e melhorá-los. professor meu me disse
na universidade que uma
das melhores
coisas de trabalhar com 3D é que a
tinta nunca seca, o que
significa que quando você está trabalhando com mídias tradicionais, por exemplo, pintura, você não pode
voltar um mês depois e consertar algo muito pequeno
porque a tinta já
está seca e é
mais difícil consertá-la. Mas com o 3D, a
tinta nunca seca. Você sempre pode fazer alterações. E é o mesmo
caso com código, tinta e nunca seca. Você sempre pode voltar
e melhorar seu código. Especialmente quando você está
aprendendo no início, seu objetivo deve ser
fazer algo, mesmo que não seja ótimo, mesmo que não seja perfeito, basta fazê-lo, fazê-lo funcionar e depois
voltar e consertá-lo. Isso não significa que você não
deva planejar. Você deve planejar o aço com antecedência. Mas não se limite a
fazer algo perfeito. Dito isso, como eu disse, posso melhorar isso
fornecendo seleção, mas vou deixar
assim por enquanto. E, mais tarde,
talvez possamos
voltar e melhorá-lo. De qualquer forma. Voltando à nossa função de
dicionário, como fazemos a filtragem? Poderíamos obter a seleção aqui, já filtrada e simplesmente
confiar que ela foi filtrada. Ou podemos obter
a seleção e os namespaces e simplesmente usar o namespace do primeiro nome
em nossa seleção. Então, podemos basicamente obter os namespaces e usar o
primeiro como filtro. Mas acho que poderíamos tornar
isso ainda mais simples recebendo um namespace. Portanto, essa função estará
esperando um namespace. Vamos
receber a seleção. E então vamos
filtrar a seleção
pelo namespace fornecido.
Vamos experimentar isso. Pode não ser o melhor design, mas vamos experimentá-lo. Primeiro passo, vamos
conseguir essa eleição. Já sabemos como
obter a seleção. Nós fizemos isso aqui em cima. Então, vamos digitar isso novamente. Combs, ls, a seleção é igual a verdadeira. Agora sabemos que
queremos fazer uma verificação. Se nada foi selecionado, então não há nada
para fazermos. Então, vamos digitar,
se não seleção. Estamos fazendo algo
um pouco diferente antes de verificarmos a
duração da seleção. Você pode fazer isso se
quiser ou pode fazer a mesma
coisa que fizemos aqui, simplesmente dizendo: Se não for
algo, então volte. Mas como estamos
esperando um dicionário, vamos manter nosso tipo de retorno consistente e retornar
um dicionário vazio. O dicionário vazio é
apenas dois colchetes. E é isso. Ótimo. Então, se não há nada selecionado, não
há nada para fazermos. Vamos continuar. Poderíamos dizer else e depois continuar seu código
dentro do else Bob, porque sabemos que o retorno é o fim da função. Nós realmente não precisamos
da outra declaração. Podemos simplesmente continuar aqui. Porque se inserirmos
a instrução if, retornaremos uma função de saída. Portanto, ele não acessará quem não alcançará nada
após esse retorno. Isso significa que podemos
simplesmente continuar nesse
nível de indentação. Então, a próxima coisa que
precisamos fazer é trabalhar com essa eleição. Vamos usar outro
loop for para controle na seleção. Agora, aqui é onde
vamos fazer o resto de nossas etapas. Sabemos que precisamos
filtrar a seleção, obter atributos e
criar um dicionário. Então, vamos fazer tudo
isso dentro do nosso loop for. Como filtramos por, pelo namespace fornecido? Como os controladores
na seleção ou strings, as strings têm uma função
especial que verifica se algo
começa com uma substring, que é outra string, ou termina com outra string. Deixe-me dar um exemplo
aqui dentro do Maya. Vou pegar essa
string, por exemplo, excluir isso. Por exemplo, aqui, quero
verificar se isso
começa com Minerva, que é
o namespace que temos aqui. Eu só vou imprimir isso. Essa função
retornará um booleano, verdadeiro
ou falso, que
começa com Minerva. Sim, exatamente. Também podemos dizer que
começa com MI,
por exemplo, e isso será verdade. Mas se quiséssemos dizer, começa com LA
Example, não dirá falso. Vamos usar isso para
filtrar nossos namespaces. Se o controle começar com o namespace que
nos foi fornecido. Vamos fazer o resto
de nossa lógica dentro disso. Isso significa que
tudo
o que está construindo o dicionário precisará acontecer dentro
dessa declaração if. Agora, isso não é um problema, mas geralmente prefiro
ter menos indentação. Acho que é mais limpo e geralmente
é mais fácil de ler. Então, como podemos evitar
esse recuo? Há uma palavra-chave que funciona para for-loops ou loops em geral, chamada continue. O que isso significa é que, se
você estivesse basicamente dizendo que, se inserir esse for-loop, continue com o próximo
item na lista, na lista selecionada, o que
significa que qualquer coisa
que esteja depois
da continuação será
completamente ignorada. E isso também significa que
precisamos reverter essa lógica. Basicamente, estamos dizendo que, se não, o
controle começa com o namespace e depois passa para o próximo
item desta eleição. E não se preocupe com
o que está acontecendo abaixo. E isso significa que
podemos simplesmente continuar sem precisar
recuar dentro
dessa declaração if. Portanto, já
filtramos a seleção. E deixe-me, deixe-me colocar
alguns comentários aqui. Seleção, espaço. Boa seleção, isso é ótimo. A próxima etapa é
obter os atributos. Esse deve ser fácil. Já temos uma
função para isso. Então, podemos simplesmente
copiar essa função, o nome dessa função. E podemos dizer
animado, animável. Os atributos são que as lontras
receberão o endereço do nó. E então saiba com o qual estamos
trabalhando é o controle. Para acompanhar isso, caso seja um pouco confuso. Lembre-se de que a
seleção está fornecendo a
você, o comando de seleção, está fornecendo exatamente isso, o namespace mais o
nome do controle. Deixe-me agrupar isso rápido. Vamos imprimir, selecionar um controlador. Quando imprimir o comando ls. É
com isso que estamos trabalhando dentro do loop for. Deixe-me colocar isso
em gráficos circulares para que
possamos acompanhar o
que está acontecendo aqui. Sabemos que esse controle, cada controle será algo
como esse namespace, nome da
praça do controlador. Mais uma vez, é
por isso que eles começam com cheque, vai funcionar. E agora estamos obtendo
os atributos
desse nó controlador que
basicamente se parecem com isso. Excelente. Agora
precisamos de outro cheque. Bem, deixe-me entrar
aqui e obter atributos. Precisamos de outra verificação para dizer
se não há atributos, porque sabemos que, se não
houver nenhum atributo, obteremos
uma lista vazia. Nós poderíamos fazer isso de duas maneiras. Podemos dizer que se o comprimento dos
atributos animáveis for zero, podemos
continuar novamente. Então, a mesma ideia acima. Se não houver nenhum atributo, vamos simplesmente quebrar
as verificações no
loop for e passar para o próximo
item na seleção. Agora, para simplificar, não
vou usar
o tamanho da lista. Vou simplesmente dizer que, se não forem atributos numéricos, se não houver nada lá, pule o que vier depois e continue com o próximo
item da seleção. Excelente. Bem, o próximo passo é montar o dicionário. E para isso, precisamos
inicializar um dicionário vazio. Caso contrário, não temos nada
para preencher, certo? Vou chamá-lo de dicionário
de posturas. E será um dicionário
vazio. Mais uma vez, um dicionário
vazio tem apenas dois colchetes. Deixe-me dar o exemplo. Precisávamos saber exatamente o que
estamos tentando construir. O que estamos tentando construir
é algo assim. Basicamente, a chave, deixe-me
colocar isso por trás de um comentário. A chave será o
nome do controlador sem um ponto de namespace
no nome do atributo. E então o valor
dessa chave
será o valor desse atributo. E, mais uma vez, estamos trabalhando com controladores da seleção
parecida com essa. Então, vamos continuar, vamos manter isso aqui apenas para
usar como referência. Embora precisemos fazer isso, é examinar os atributos
que temos aqui. Para adicionar outros animáveis, é um nome de variável muito longo, mas está tudo bem. Algum erro
médico? A primeira coisa que precisamos
fazer é pegar esse nome. Precisamos retirar o nome
do atributo real, desculpe, o nome
do controlador separado do namespace. Vamos chamar esse troll de nome. Será a divisão de pontos de controle. Como já fizemos antes. Podemos fazer essa placa
no, nesta coluna. Então, novamente,
vamos dividi-lo. Lembre-se de que a divisão
basicamente nos
dará o primeiro item e o último item da
mesma forma que fizemos com os namespaces aqui em cima. Mas agora, em vez de obter
o primeiro item que
queremos, queremos o último item. Vamos dizer, nos dê o último item dessa divisão. Esse será o nome do controle. Em seguida, queremos montar o nome completo do atributo,
que é esse aqui. E isso será, vamos chamá-lo de somador completo. Agora será basicamente o
nome do ponto de controle, o nome do atributo. Então, mais uma vez, podemos usar
essa função de formato para substituir esses espaços reservados
por outra coisa. Vamos
substituí-los por um nome controlado. E o segundo serão os atributos ou o outro dos
atributos animáveis que já temos. Excelente. Portanto, a próxima parte será obter o valor
do atributo. Agora, para isso, vamos
usar como já temos. Então, vamos usar get outer. Bud. Lembre-se de que, se eu voltar
ao meu aplicativo por um segundo, get adder realmente espera
que ele esteja melhorando. Ok, bem,
vamos escrever isso. Saia ou espere o nome completo do controle com o,
com os atributos. Claro, porque
ele precisa saber a qual namespace o
atributo pertence. Então, precisamos construir todo
esse nome do controle mais
o atributo. Então, precisamos passar
isso para get adder. Vamos seguir em frente e fazer isso. Que façamos um
padrão semelhante ao do formato. Mas agora, neste caso,
precisamos passar o controle total que
veio da seleção, que está sob essa
variável chamada controle. E então vamos dizer ponto. E depois os atributos, certo? Mesma ideia, formato de pontos. Agora vamos
usar o controle total, não o nome do controle
que separamos. Vamos usar
um controle total. E vamos usar
o editor de atributos, que é o atributo
que obtivemos. O valor será
basicamente que, se
isso for um pouco
confuso, deixe-me separá-lo. Deixe-me colocá-lo em uma nova variável. Vamos chamar isso
de controle com absoluto. E vamos pegar o
nome. É isso. Vamos obter o valor
dessa largura, sai do controle. Caminho. Aí está. Agora temos o valor.
Agora, a única coisa que resta a fazer é preencher
o dicionário real. Lembre-se de que nosso dicionário
se chama post decked. Então, digamos pose. Agora, a chave, lembre-se, será o atributo padrão nomeado sem o namespace. Então isso seria isso aqui. Se isso for um pouco confuso, podemos torná-lo ainda
mais explícito. Sem NS, sem namespace. Esse é o nome da variável bread
long. Mas está tudo bem
para esses propósitos. Full Adder sem
realmente me deixar dar um nome. O
namespace completo conhece o somador. Aí está. É um pouco mais curto. Conheça o namespace. E o valor dessa chave será o
valor do atributo. Vamos tornar isso um
pouco mais explícito também. E vamos destacar ou
sublinhar, sublinhar o valor. Esse será o
valor do nosso valor t. Mais uma vez, estamos
construindo isso aqui. É isso que essa linha está fazendo. Deixe-me adicionar um comentário aqui. Basicamente, diremos que essa será a largura do controle,
os atributos. E a chave será
o valor do atributo. Excelente. Estamos preenchendo
nosso dicionário. Deixe-me deletar isso aqui porque não
precisamos mais dele. Eu vou dizer que
vou adicionar um comentário aqui apenas dizendo preencher o dicionário
ou construir o dicionário. E no final, a única coisa que resta a
fazer é devolver o dicionário, que se chama pose score, que vamos voltar ao
Maya e testá-lo. Antes de voltarmos e
adicionarmos nossas docstrings, deixe-me copiar o nome
dessa função. Vamos voltar para Maya. E eu tenho aqui após a transferência. Então, vamos fazer isso do zero. Postagens importantes
ressaltam a transferência. Agora, se você ainda não
reiniciou o Maya, lembre-se de que meu
tipo de cache ou mantém a última
entrada que você fez. Então, se quisermos atualizar
isso ou recarregar isso, podemos dizer Recarregar após a transferência. Desde que fizemos isso, fizemos
algumas mudanças nele. Então podemos dizer pose, mas este é o dicionário. Então, vamos dizer que
pose enfeitada é igual a pose, sublinhado, transferência,
transferência, ponto, GET, post. Mais uma vez, o nome
da variável depende de você. Você poderia chamar isso de pausas. Você pode simplesmente chamá-lo de
posts, se quiser. Isso depende de você. Vou ser mais explícito
e chamar isso de pose. Vamos, vamos imprimir isso. Ambos sublinham. Vamos apenas executá-lo e
ver o que acontece. Ah, claro que é preciso
exatamente um argumento. Então, vamos
dizer que queremos
filtrar por meu nome nervoso. Então, vamos dizer Nerva. E eu vou selecionar apenas
um controle nesse equipamento. E aí está. Isso é exatamente o que
esperávamos. Como você vê, há apenas três atributos
nesse controle
que selecionei a tradução
e todos eles estão em zero. Portanto, controlamos o nome, traduzimos z, x e y, e todos eles estão em zero. Agora vamos testar
nossa filtragem. Então, mais uma vez,
vou selecionar esse controlador e
vou selecionar alguns
controladores no outro equipamento. Então, agora selecionamos um controlador em Minerva
e alguns em Severus. Mas lembre-se de que estamos
filtrando por Nerva, então o resultado
deve ser o mesmo. Portanto, estamos recebendo apenas
os controladores que pertencem a esse namespace. E, claro, isso é agnóstico, como se o resultado fosse
um dicionário com os controladores e
os atributos desse controlador, desculpe, desse personagem, mas é independente do espaço do nome desse
personagem. Porque agora podemos
usar isso e aplicá-lo a qualquer outro personagem que
tenha os mesmos atributos. Se você quiser ver isso um
pouco melhor, na verdade não vou. Deixe-me selecionar
mais alguns controladores para obter um dicionário maior. Aí está. Portanto, essa é uma força muito maior. Eu te mostrei antes. A função de impressão,
podemos dizer que Pip print, print, p, print
significa impressão bonita. Podemos dizer imprimir, postar. Tudo isso é impresso
de forma legível por humanos. Ou seja, desculpe, eu não o importei. O que só vai tornar a leitura
mais fácil e agradável. Então esse é o dicionário que
estamos esperando. Agora podemos usar isso
e aplicar todos esses valores a
outro personagem. Agora, só para ter certeza de que isso está realmente obtendo os
valores que nos interessam. Eu vou mudar isso para
que não seja apenas zero. Aí está. Portanto, há alguns valores
diferentes. Agora, se eu executar esse trecho de
código novamente, aí está. Esses são os valores que pertencem a esse
controle. Excelente. A próxima etapa será aplicar essa postagem ao
outro personagem. Mas antes de fazermos isso, não
vamos esquecer
as sequências de caracteres do documento. Mais uma vez, códigos triplos e
duplos, descrição
pequena, pose a pose, dicionário
sem namespaces. O namespace que
sabemos que estamos esperando uma string. Então, vou digitar string e uma pequena descrição do que esse argumento está realmente fazendo. Seleção de filtros
por esse namespace. Excelente. E então
o valor de retorno, é
claro, será um dicionário. Vamos deixar por isso
mesmo. Bem, eu adicionei uma descrição acima, então vamos ser consistentes,
a menos que esse dicionário de controles com atributos e
seus valores. Excelente.
25. Aplicando o pose: Ok, então estamos quase terminando com a função
apenas para seus dois. Agora que podemos salvar uma pose na forma
de um dicionário. O próximo passo é
aplicar essa pose. Vamos ver rapidamente o
que isso implicaria. Se fôssemos fazer isso manualmente, deixe-me limpar minha janela de saída. Vou selecionar o
controle, esse controle de peito. Mais uma vez, só vou ver como é o
dicionário de poses. Mais uma vez, temos os
atributos com os controladores, com os atributos
e os valores. Então, o que precisaríamos fazer para aplicar isso a esse personagem? Bem, na verdade, tudo o que precisamos
fazer se estivéssemos fazendo isso manualmente
seria definir um atributo. Então, Cmd S, vamos definir o somador. Sabemos o que queremos. Digamos que estamos definindo o valor de rotação e precisamos
definir os valores reais. Então esse é esse valor que
temos aqui. Eu normalmente digo uma
coisa que é dizer ao comando quais
namespaces aplicam isso verdadeiro. Então, tudo o que precisaríamos fazer é
qual é o novo namespace? Seu namespace de destino. E deixe-me tornar
isso um pouco menor e executar
essa linha de código. E aí está. Nós aplicamos
esse valor à rotação. Deixe-me aplicar algo um
pouco mais extremo, uma mudança um pouco maior
que será rotacionada em y. Pronto. Agora estamos aplicando esse volume. Excelente. Então, isso é basicamente
o que vamos fazer. Pegue os atributos
desse dicionário da pose. Salvamos o namespace nele
e depois aplicamos o valor. Vamos entrar no PyCharm
e começar a mapear, bloqueando nossa próxima função. Vamos chamar isso de postagens aplicadas. Sabemos que,
para fazer uma pose, precisamos conhecer os valores reais
da pose que vêm na
forma de um dicionário. Então, vamos chamá-lo de pós-ditado para
manter a consistência com os nomes. E sabemos quando
ele não precisava
conhecer o namespace de destino. Você pode nomear esse
namespace de destino ou simplesmente alvos. Mas acho que o Namespace
por si só faz sentido. E então, na docstring, podemos especificar um pouco mais sobre
isso, o que isso está fazendo. Excelente. Então, vamos começar a
bloquear a função. Sabemos que precisamos obter
os nomes dos atributos. Sabemos que precisamos adicionar
o namespace a ele. E então simplesmente precisamos
definir o atributo. Mas agora pode
haver um problema aqui. Um segundo e tente
ver se você consegue pensar no que pode
dar errado aqui. O que poderia ser um bug em potencial? O que acontece se
os personagens
não forem exatamente iguais ou se
a raça não for a mesma. No meu exemplo, sei que esses dois são exatamente iguais porque usei
a mesma taxa. Mas agora imagine
que, digamos,
meu personagem original
tenha um suporte extra. Digamos que ela tenha um chapéu e nós selecionamos o chapéu. E tentamos aplicar esse
valor ao outro personagem. E os outros personagens que
tinham o chapéu que falhariam causariam um erro
porque meu, eu diria, ei, esse, esse controlador ou
esse objeto não existe. Por que eles
atribuíram está bloqueado? Por exemplo, se estiver bloqueado,
podemos configurá-lo. Então, Maya também nos
dará um erro. Isso significa que precisamos fazer uma
pequena verificação de erros. Vamos escrever isso, apenas verificação de erros ou verificações de erros. E vamos pensar
nos cheques em um segundo. Vamos começar a escrever a funcionalidade
básica primeiro. A primeira coisa que queremos fazer
é obter os nomes dos atributos. E isso significa que precisamos
passar por cima das chaves
no dicionário que
basicamente representam
o nome desses atributos. Então, digamos que vamos
chamá-los pelo nome dela, cada um deles por sigla
no ditado pós-sublinhado. Agora, os dicionários
têm uma função. Teclas frias. As teclas fornecerão uma lista das
chaves no dicionário. Deixe-me te mostrar isso bem rápido. Dentro do meu, eu, exclua isso aqui e vamos pegar um novo
dicionário para jogar. Vou selecionar
esse controlador. Sabemos que esse controlador tem
apenas três atributos. Então, será
um pequeno dicionário. E vou
imprimir muito bem esse dicionário. Aí está. Então, se eu fosse imprimir as teclas de ditado
pós-sublinhado, como você pode ver, obtenho
uma lista dessas chaves, que é basicamente
apenas o controlador. Os nomes dos controladores
com os atributos. Há outra
função chamada valores,
que, como você provavelmente pode adivinhar, simplesmente me dará uma
lista desses valores. Agora há
outro chamado itens, que me dá, vai
me dar pelo menos os alunos. Agora, como eu disse antes, um pólo a polo é como uma lista que você não pode modificar e é feita usando parênteses
regulares. E os itens do dicionário
basicamente fornecem uma lista com os pares de chave e valor para cada
item no dicionário. Mas, por enquanto, queremos
usar chaves para analisar todos esses nomes de controle
com seus atributos. Passe por cima dessa lista de chaves. Vamos obter o valor
dessa chave. Lembre-se de obter um valor, você usa um dicionário e
obtém o valor de uma chave. Então, abra e feche os
colchetes. E usaremos o outro nome, que é a chave que
estamos examinando. Então esse será o
valor do atributo. Então, na verdade, vamos chamar isso de valor
externo. Aí está. Estamos recebendo a chave e
obtendo o valor. Agora lembre-se,
precisamos juntar o namespace e
o nome do atributo. Vamos chamar esse somador de nome completo. E esse será o namespace
seguido por dois pontos, porque essa é a
convenção no Maya. E faremos o formato de pontos. Será um namespace. E então o segundo
colocado será substituído pelo nome. Aí está. A próxima coisa a fazer é
que já fizemos isso. Precisamos adicionar namespace. Então deixe-me, deixe-me
mover isso para cá. A propósito, bem rápido, se você
se pergunta como estou me movendo
tão rapidamente entre as linhas, existem algumas chamadas
teclas que funcionam em qualquer lugar no Windows. Se você pressionar a tecla Control, poderá alternar entre as palavras. Ele deve pressionar
Control e Shift. Você pode fazer isso, mas
destacando ao mesmo tempo. E se você pressionar a tecla tab,
você recuará. Mas se você fizer o Shift Tab,
fará o oposto. Isso acontecerá ao contrário. Então é assim que eu consigo me
movimentar tão rapidamente. Mas essas são apenas teclas de atalho. Não se preocupe muito com eles. Porém, é muito útil, por isso
permite que você digite um
pouco mais rápido. Mas de qualquer forma, voltando ao
nosso código, temos apelidos. Adicionamos o espaço do nome e agora precisamos
definir o atributo. Vamos colocar isso, vamos
definir o atributo. O atributo que sabemos é que temos que
fazer conjunto de pontos CMBS, somador. E então passamos o
nome completo
do atributo, nome do erro. E o valor que
queremos definir, que é o nosso valor. E aí está. Lá você está basicamente aplicando sua postagem ao seu novo personagem. Agora estamos, estamos perdendo
as verificações de erros. Mas, por enquanto,
vamos testar isso para
ver o que está acontecendo, para ver se está realmente funcionando. Vamos voltar para Maya desta vez. Como fiz algumas
alterações no código, vou recarregar o módulo. Aí está. Vamos usar um novo controlador. Estamos usando muito esse controle de
xadrez. Vou usar esse braço,
esse controle de cotovelo aqui. Vamos apenas aplicar
alguns valores a ele. Vamos começar o dicionário de posts. Vamos conseguir postagens para Minerva do controle
selecionado. Vamos imprimir
para ver o que temos. Lá vamos nós. Essa é a pose que estamos tentando transferir. Então, vamos aplicar essa pose
ao outro personagem. Publique o sublinhado, transfira. Aplique a pose. E sabemos que estamos esperando um dicionário de postagens
e um namespace. Vamos fornecer um dicionário de poses
que já criamos. E o namespace
tem como alvo o espaço, que neste caso
será Severus. Lá. Agora, isso é
outra coisa que podemos verificar. Se o namespace for mesmo válido. E se eu
fornecesse uma corrida, por exemplo isso não existe na cena, então eles poderiam falhar. Mas talvez possamos verificar isso diretamente
nos controles. Então, vamos
testar isso por enquanto. Deixe-me mostrar o braço desse
outro personagem para que
possamos aplicar essa pose.
Todo esse código. E aí está. Como você pode ver,
aplicamos os valores. Nesse caso, é apenas rotação, mas tudo bem porque
é apenas um controle de cotovelo. Então agora isso está funcionando. Agora você pode parar aqui
porque já está funcionando. Mas, como eu disse, imagine que
esses atributos estavam bloqueados, ou não existissem, ou talvez o personagem não
tivesse esse controle. Precisamos fazer esse
tipo de verificação. Então, vamos simular
esse tipo de erro para ver como podemos evitar
ou como podemos verificar, antecipar esse tipo de problema. Eu adicionei
um adereço a esse personagem. Eu adicionei o
arquivo base para o equipamento. Então, agora o que precisamos fazer
é recarregar essa referência. O que, como você já sabe, é a beleza das referências. Você pode fazer alterações na plataforma si e em qualquer coisa que
faça referência a essa plataforma. Receberemos essas atualizações, o que é muito bom. Deixe-me recarregar essa referência. E devemos ver um novo adereço, um chapéu novo aparecer
aqui em um segundo. Aí está. Nós temos o suporte. Então agora, claramente,
isso, esse outro personagem
não tem. Esse mesmo controle. Há um novo controlador chamado Hat sob o namespace nervosa. Agora vamos tentar transferir a
pose
desses controladores para os outros personagens assim como fizemos com o braço. E vamos ver o que acontece. Deixe-me abrir mais espaço aqui. Então, vamos comprar um novo dicionário de
postagens. E agora esse é o chapéu. Agora vamos tentar aplicar
isso a Severus. Aí está. Esse é o erro que
estamos esperando. O erro é que nenhum
objeto corresponde ao nome, várias horas de rotação do ponto. Isso porque
nem todo mundo tem cabeça. Então, vamos tentar
lidar com esses tipos de erros. A primeira coisa a
verificar é ver se o controlador em si
existe, certo? Mas também há outros tipos
de verificações que podemos fazer. Então, vamos
mapear isso. Vamos bloqueá-lo aqui. Portanto, verifique se objeto,
objeto, cistos. Verifique se o atributo
é separável. Podemos verificar diretamente
se não está bloqueado, podemos verificar
se é animável. Mas acho que se estivermos verificando
se é configurável, isso é mais do que suficiente para
o que precisamos fazer aqui. Mas antes mesmo de verificarmos se
um atributo pode ser definido, precisamos verificar se o
atributo existe. Então, digamos que o
atributo check exista. Tudo bem? Portanto, verificar se um
objeto existe
é muito simples no Maya. Vamos começar com isso.
Existe uma função nesta biblioteca chamada
Cmd S dot OBJ. Muito simples. E o motivo pelo qual você faz isso é fornecer
o nome desse objeto. Então, vamos ver se Severus
recebeu um alerta de spoiler. Sabemos que não, não funciona. Mas vamos imprimir o
resultado desses parafusos de função. Agora, se fizermos isso com Minerva, bem, a resposta
é sim, excelente. Então, podemos fazer isso. Mas para isso precisamos
do nome do objeto em si sem os atributos, certo? Bem, não é. O objeto é, mais
corretamente, é o nó. Vamos seguir em frente e
pegar esse nó. Agora que sabemos que estamos recebendo, temos o nome completo do
atributo aqui. Então, basicamente, fazemos isso sem o nome do
atributo real no final, que é separado por um duto. Mais uma vez, apenas para referência, vamos trazer isso aqui. É basicamente com isso que
estamos trabalhando. Retirar o nome dela
é basicamente esse, que é o namespace mais
um atributo de ponto do controlador. Então, queremos extrair
a primeira parte disso. Podemos fazer isso de forma muito simples
com nosso amigo dot split. Como já fizemos
várias vezes. Podemos dizer que o nó
será um nome externo completo, dividido, dividido pelo ponto. E sabemos que isso
dividirá a lista em duas partes. Então, queremos obter
a primeira parte, que é o namespace mais o dia. Eu controlarei o nome
e esse é o nodo. Portanto, o primeiro item da lista
será o índice número zero. Então esse é o nome do nodo. Poderíamos dizer que se o Cmd
S dot OBJ existe, verificar se existe, sabe
que existe. Ashley, desculpe, queríamos
verificar o contrário, certo? Bem, mais uma vez, podemos fazer isso dependendo de como você
deseja que a lógica funcione. Se você quiser aplicar apenas essa lógica ou definir o atributo
se o objeto existir, poderíamos simplesmente na dentina
e isso funcionará. Se o objeto existir, defina o atributo. Vamos fazer isso por enquanto. Deixe-me escrever um comentário aqui. A propósito, se você
também está se perguntando como eu chego ao
final da linha, estou usando o N E, que você encontrará
no seu teclado. E a tecla Início levará você ao início de uma linha. Se você usar isso junto
com a tecla Shift, poderá selecionar
a luz inteira. É muito saudável. Então, vamos dizer
que estamos verificando aqui. Excelente. Estamos verificando se
o objeto existe, se ele define o atributo, vamos testar isso. Vou remover
essa linha aqui. E vou mover
esses dois cheques extras para cá porque
essa ainda é nossa tarefa. É como nossa lista de
tarefas por enquanto. Então, vamos testar
isso primeiro. Mais uma vez porque
fiz algumas mudanças. Estou recarregando após a transferência. Vamos ter certeza de que está
selecionado e está. Aí está. Nada aconteceu, o que
é exatamente o que
queremos porque o único controle que selecionamos
realmente não existe. Agora, vamos tentar
com dois controladores. É um pouco
mais complicado. Vamos mover o braço. Vamos selecionar o chapéu e aplicar o
poste mais uma vez. Agora, apenas o braço
foi aplicado e a alça foi ignorada
porque ela não existe. Excelente. Como verificamos se um
atributo realmente existe? Porque o objeto pode
existir como estamos verificando aqui, mas pode não ter o
atributo que estamos tentando definir. Então, como sempre, a biblioteca de símbolos tem um comando ou função
que pode nos ajudar com isso. É chamado de consulta de atributos. Então, vamos ver como usá-lo
usando a documentação. Vamos para a consulta de atributos de
estilo de documentação. Aí está. Então, na descrição
, diz que retorna informações sobre a
configuração de um atributo. Parece que é isso
que queremos fazer. Vamos seguir em frente e ver
os exemplos na parte inferior. Determine o status oculto
do atributo seletor.
Determinou isso. Ok, então parece você está passando o
atributo que
deseja e depois determina se
um atributo é curável. Embora isso possa
realmente ser algo que
queremos fazer. Potencialmente. Você está passando o
nome do nó e, em seguida, passa os
atributos que deseja. Portanto, está um pouco atrasado em relação à forma como Get out or
works, o que é lamentável. Eu gostaria de manter isso um
pouco mais consistente. Mas
lembre-se de sair ou ele receberá o nome completo
do atributo, que é o
ponto controlador no atributo. Nesse caso,
precisamos separá-lo. Precisamos obter o nó ou o controlador e o
atributo separadamente e, em seguida, verificar
o que você deseja testar ou verificar
no atributo. Então, nesse caso, eu
sei que há uma bandeira ou um argumento para ver se existe
um atributo. Deveria existir. Sim, aí está. É um atributo booleano, retornará verdadeiro se
o atributo existir, ok, então basicamente precisamos obter o único nome do atributo. Em seguida, passando o
nó em que queremos obter, verifique o atributo. Ótimo, então, onde quer que a galinha denote dividindo-se
neste fim de semana, agora precisamos obter
apenas o nome do atributo. Vamos chamá-lo de nome abreviado
do atributo, em vez do nome completo
do atributo. Sabemos que dividindo o nome
completo do somador, na verdade
estamos
obtendo os dois, certo? Estamos dividindo pelo ponto, o que significa trabalhar
nesta parte. E também estamos
recebendo essa parte, que é o nome abreviado
do atributo que queremos. Então, poderíamos simplesmente fazer isso. O nome abreviado externo é igual a cópia, isso é igual a essa divisão. Mas agora, em vez de
obter o primeiro item, queremos obter o segundo item. Então esta é a nota, e esse é o nome abreviado
do atributo. Mas há uma maneira
melhor de fazer isso. Como sabemos que estamos obtendo
uma lista com dois itens, você pode realmente atribuir
esses dois itens da lista
a duas variáveis ao
mesmo tempo em uma única linha em Python Você faz isso fazendo isso. O nome abreviado externo é igual à lista que
obtivemos da divisão. Então, vamos ver como
isso está funcionando no Maya, caso seja um
pouco confuso. Então, vamos aqui. Vamos pegar, bem, vamos seguir
o exemplo que estamos usando. Vamos usar esse
nome completo do atributo. Vamos usar uma nova guia do Python. Sabemos que queremos dividir essa
divisão de pontos pelo nome
da divisão de pontos. Vamos chamar isso, vamos, na verdade, vamos chamá-lo de lista dividida. Vamos imprimir a lista de pontuação da
divisão de células. Aí está. Então você
obtém os dois itens. Como eu disse, você
pode atribuir isso às variáveis dizendo que
o primeiro nó, esse primeiro é o nó e o segundo é
o atributo real igual à lista dividida. E agora você pode imprimir o nó. Você completa o atributo de impressão C. Pronto. Agora, isso funciona porque
sabemos que a lista
tem dois itens. Se a lista tivesse mais itens. E isso é, por exemplo, vamos
substituir a lista
dividida uma lista própria. Eles apenas dizem 12,3. Se executarmos isso agora, a lista tem três itens. Estamos tentando atribuir a um segmento de 22 variáveis
em duas variáveis. O que vamos
ter é mais restrito porque há
muitos valores para desvendar. Isso só funciona porque sabemos que a divisão está
nos dando dois itens. Ótimo. Vamos
verificar se o atributo existe. Deixe-me trazer essa
linha até aqui, que é onde precisamos dela. Vamos começar a consultar isso. Essa é a
existência dos atributos. Então, digamos que se o
CMBS dispara, deixe-me digitá-lo. Atribua, consulte, abra
e feche parênteses. Agora lembre-se de que passamos o nome abreviado
dos atributos. E, mais uma vez, estamos seguindo
a documentação aqui. seguir, esse exemplo mostra o nome do
atributo e, em seguida, o nó. Agora, se quiséssemos ver o
que essa nota argumenta fazendo, vamos, deixe-me procurá-la. Vamos ao assunto. Anote o nome das pessoas. Use todos os atributos
do nó chamado nome. Ok, isso é um
pouco enganador. Não há nenhum nó chamado nome. E está
nos dizendo que precisa um valor do tipo name
que não existe. Na verdade, isso significa uma corda. Portanto, é um pouco
lamentável que às vezes a documentação em meu
S não seja muito consistente. Há algumas suposições fundamentadas de que você precisa fazer
algumas vezes assim. Neste caso, o nome só precisa adivinhar ou assumir
que isso significa string. Com isso dito, porém,
a documentação ainda
é extremamente valiosa, é por isso que continuo
voltando a ela. Digamos que node seja igual a nome. Não, desculpe, desculpe,
nó é igual a nó, que é o nó que
obtivemos da divisão. E então, o que precisamos
verificar é ver
se o atributo
existe, se existe é igual a verdadeiro ou consultar a existência
do atributo. Certo? Aí está. Ligue por muito tempo para terminar
a declaração IF. E agora vamos recuar isso. Algo que você
provavelmente está percebendo é que o recuo
está ficando demais. Temos 12 níveis de indentação
e teremos mais
um porque precisamos verificar se o atributo
é separável. Vamos limpar isso antes de
fazermos a última verificação. Algo que você pode fazer
em vez de recuar. Evitamos,
imitando aqui, usando a palavra-chave continue, continue. Nós poderíamos fazer isso. Poderíamos
dizer se nenhum objeto existe. Continuar. E então
deixe-me soltar isso. Mais uma vez, a mesma coisa. Se nenhum atributo existir
, podemos simplesmente dizer Continuar. E então, como estamos pulando, estamos usando continuado
para evitar recuos. Podemos simplesmente adicionar o mesmo nível de tudo
o que
dizem que eles atribuem. E agora, vamos fazer
nossa última verificação. Precisamos verificar se um
atributo é configurável. Agora, você pode
pensar que pode conhecer essas informações a
partir da consulta de atributos. Essa é uma suposição muito boa. Infelizmente, esse não
é o caso. Para ver se um atributo
é um conjunto de todos, precisamos usar o conjunto, desculpe, eles recebem a função de adição. Então, vamos dar uma olhada
nisso na documentação. Saia ou você pode verificar
se algo é escalável. Você também pode verificar se
algo está configurável. E mais uma vez, isso retornará um booleano ou
um que, neste caso,
podemos negociar como booleano. Então, vamos em frente e fazer isso. Vamos sair ou você basicamente quer esse nome de atributo
get adder. Mas agora, ao contrário da função de consulta de
atributos, na verdade
precisamos do
nome completo do atributo. Mais uma vez, às vezes
essas funções não são muito
consistentes entre si. Mas tudo bem. Você só precisa confiar
na documentação
ou na sua experiência. Quanto mais você
executa essas funções, mais você sabe
como usá-las. E isso deixa de ser um problema. Nunca é realmente
um problema. Ótimo. Então, vamos fazer isso. Digamos que saia ou o nome do atributo e
defina double igual a
true para verificar se nosso
atributo é separável. Então, se o CMBS não ficar mais somado. Agora lembre-se que, nesse caso,
queremos o nome completo
do atributo. Então, ele dirá o nome completo. Homer, configurável é igual a verdadeiro. Então, se não, o atributo
é saturável
; portanto, se o atributo não
for separável, queremos continuar. Portanto, não queremos,
queremos basicamente pular tudo o que vem
antes ou depois
disso e passar para o
próximo valor no loop. Ótimo, então vamos
testar isso e ver se isso
está realmente funcionando. Uma vez e deixe-me
voltar para minha conta. Deixe-me, já que
fizemos algumas alterações, vou recarregar meu módulo. É ótimo. E
vou aplicar alguns valores no braço novamente. Mais uma vez. Então pegue a pose, o
dicionário de poses, e aplique essa pose
à nossa carta-alvo. Aí está. Somente o braço foi
aplicado e foi ignorado porque
é claro que ele não existe. Isso é ótimo. Agora está tudo bem, isso funciona, mas há mais uma
maneira de condensar esse código e torná-lo
um pouco mais limpo. Deixe-me mostrar como fazer isso
usando o operador OR. Operador. O operador
basicamente permite que você encadeie esse tipo de cheque. Portanto, podemos dizer que se nenhum
objeto existe ou não, consulta de
atributo existe ou
não, o atributo é configurável. Agora, isso se tornou
uma fila muito longa, o que também pode não ser ótimo. Mas deixe-me mostrar
como está funcionando. Então, basicamente, estamos dizendo que se o objeto não
existe, continue. Então, se essa condição for atendida, basicamente
inserimos
a instrução if. Mas digamos que o
objeto é que os conjuntos existem. Então o objeto existe, ótimo. Ou se o atributo
não existir. Então faça isso. Então, digamos que
o objeto existe e o atributo existe. Em seguida, partiremos, faremos nossa próxima verificação na
próxima ou qual seria, ou se o atributo não for
separável, continuaremos. Isso é o mesmo que nossas verificações
de três níveis, mas tudo em uma linha. Agora, há outra versão disso que é o oposto, que é, então você pode dizer que, se pudéssemos inverter a lógica, eu só queria
mostrar essas duas para que você conheça suas opções. Poderíamos reverter a lógica das listas. O objeto existe. Eu não vou, na verdade, vou
digitar o código correto. Então, podemos dizer se o
objeto dois existe e o atributo existe, por exemplo, vamos imaginar que essas são todas
as verificações que queremos fazer. Podemos dizer que se o objeto existe
e o atributo existe, então podemos fazer nosso somador de
conjunto, por exemplo, isso está revertendo a lógica
usando o operador AND. Mas estamos tentando
evitar a indentação. Então, estamos fazendo o oposto
usando o operador OR. Se o objeto não existir, ou se o atributo
não existir, ou se o atributo não
for separável, continuamos pulando
a configuração do atributo e indo para
o próximo item no loop. Ok, para terminar essa
função, precisamos limpá-la. Limpe tudo. Sabemos que não
precisamos dessa linha. Este é apenas um momento
em que estamos nos desenvolvendo para nos ajudar. Vamos remover
esses comentários aqui, mas vamos colocar um
comentário aqui dizendo cheque. Basta chamar isso de verificação de atributos. E então definimos o atributo. Excelente. Agora, antes de esquecermos as sequências de documentos de
nossos amigos, é
muito importante. Então, vamos definir a docstring, digamos aplicar a pose fornecida para
fornecer seu namespace, por exemplo, agora sabemos que se
espera que pose seja um dicionário. Dicionário com
valores de pose ou dados de pose, digamos, dados de postagem, que são as chaves, os valores
e o namespace. Sabemos que é uma corda. Mas, na verdade, vamos ser
explícitos aqui e dizer namespace de
destino ao qual nos aplicar. Talvez um pouco prolixo, mas sinta-se à vontade para condensar
essa frase se quiser. E, nesse caso,
não estamos devolvendo nada. Então, eu vou
remover essa linha. E isso é o suficiente. Perfeito. Nossa função é agradável e arrumada. É muito pequeno, o que é ótimo. Posso, como eu disse, funções
pequenas e especializadas geralmente
são a melhor opção. Vamos testar isso. Antes de prosseguirmos com a junção de
tudo isso. Vou remover a impressão. Mais uma vez, vou
recarregar minhas desculpas. Não é o que eu pretendia fazer. Vamos recarregar meu módulo. E eu vou me
opor ao dicionário. Vamos fazer mais alguns
controladores dessa vez. Então, o oposto, o braço. Vamos fazer os quadris, por exemplo ,
quadris, peito e braço. E eu selecionei mais alguns
controladores, mas tudo bem. E o chapéu, só para
conferir o teste, são verificações. E ótimo, então vamos
pegar o dicionário postal a partir disso e depois aplicá-lo
ao Cerberus. Lá vamos nós. Excelente, está funcionando. Então, estamos quase terminando. Enquanto seu código está
basicamente pronto. Agora, a próxima coisa que
precisamos fazer é montá-lo completamente para o
fluxo de trabalho que queremos. Agora, neste momento, você tem todas as
funcionalidades separadas em funções especializadas e
pequenas. Então, agora você está livre para decidir
qual fluxo de trabalho
você quer, você quer fazer com isso, o que você quer usar com
isso, com essa ferramenta. Estamos fazendo algo
muito válido, que é apenas digitar o
nome do nosso namespace de destino. Se é assim que você quer
que funcione, é ótimo. Digamos que você
queira criar uma interface de usuário. Você quer que o usuário digite o namespace com o qual
ele se relaciona, faça
isso se quiser. Mas o que queremos, como mencionei no
início, é a seleção de uso. E isso é que ele usa a
seleção para obter os namespaces e
se opor ao mesmo tempo. Então, vamos criar uma
função que faça isso. E basicamente reúne tudo
isso em uma única função que
fará tudo isso por nós.
26. Construir a função principal de "transferência": Tudo bem, vamos criar uma função que reúna tudo. Então, a primeira pergunta é: onde colocamos essa função
na parte superior do arquivo, no meio do arquivo,
no final do arquivo. Até agora, estamos
fazendo isso de cima para baixo. E isso é bom. Podemos simplesmente colocá-lo no final e
não há problema. Mas há
algo que eu quero mencionar sobre Python. É um fato interessante. Ou, se não for interessante, é pelo menos bom saber. Então, python é uma linguagem
interpretada. Deixe-me escrever isso aqui. Interprete-o em vez de
ser uma linguagem compilada. Você provavelmente já ouviu
esse termo ser compilado antes. O que isso significa é que
seu código-fonte, que é realmente o código, o texto que você escreve. Todo esse
código-fonte é
traduzido em algo que a
máquina pode realmente executar. Nos níveis mais baixos de
execução no meu computador. O computador está realmente entre
zeros e uns. Entre esses zeros e uns. E no código-fonte
que você escreve, há algumas etapas de
diferentes tipos de código. É chamado de
código objeto ou código de máquina. E esses são
diferentes níveis de tradução para chegar a
esses zeros e uns. Portanto, em linguagens como
C ou C plus plus, antes de executar seu código, você precisa
compilá-lo e executar essa etapa manualmente ou,
às vezes, automatizá-la, mas precisa executar a etapa antes de
executar seu código. Mas isso significa que
o código que está sendo executado está mais próximo
do que a máquina realmente lê
no nível mais baixo de execução, o que significa que é mais rápido. Portanto, esse código que
você executa ao compilar algo é mais rápido. Por outro lado, como
mencionei, o Python é interpretado. Isso significa que você não
precisa compilá-lo. Você pode simplesmente fazer
uma alteração e
executá-la exatamente como temos
feito até agora. Devo dizer que não
é 100% verdade. O fato de o Python
ser interpretado não significa exatamente
que ele não esteja compilado. Ainda há um nível de
conclusão acontecendo, mas há diferenças
que são feitas para você toda vez que você
executa o código. Isso significa que você pode simplesmente fazer alterações
e executar o código. Mas isso também significa que o
código que você está executando Python geralmente será mais lento do que o código
que você executa no C
plus, além disso, a mesma
operação no Python será mais lenta do que a mesma
operação no C plus plus. Pelo simples fato de que o C plus plus é compilado com antecedência. E o código está sendo executado mais diretamente de acordo com o que o
computador entende. Dito isso,
a diferença da maior parte do que
fazemos em animação não
importará muito. É por isso que,
em todos os pipelines
de qualquer estúdio que
você possa visitar, usaremos Python. Porque como você não
precisa fazer essa etapa de compilação, é muito rápido
desenvolvê-la com ela. Você pode fazer alterações
muito rapidamente. A sintaxe é muito
semelhante à do inglês. Então você viu até agora e
não precisa compilá-lo. Como mencionei, o
fato de ser um pouco mais lento do que outros idiomas realmente
não
faz diferença. E é agilidade no desenvolvimento. É um benefício em relação
à falta de velocidade. O que, novamente, é algo
que você nunca notará. O Espírito não é
muito perceptível
por humanos, a menos que
você faça algo muito, muito pesado
computacionalmente. Por que estou mencionando isso? É porque o fato de o
Python ser interpretado, significa que o código
está sendo lido e executado de cima para baixo. Então, uma prática que
muitas pessoas fazem é escrever a função
stop the bottom. Então, se eu precisar
dessa função mais tarde, vou tê-la primeiro
e depois chamá-la aqui, por exemplo, agora, embora isso seja
logicamente verdadeiro, com o caso de funções, não
é necessariamente, eu poderia
ser se eu tivesse uma função. Então, por exemplo, se eu chamar essa função aqui, isso falhará. Até por charme está me dizendo que a função não existe. Isso falhará porque a função ainda não
foi declarada. Mas se eu colocá-lo dentro
de outra função, não
é mais o caso. Isso porque o Python
examinará primeiro os
nomes das funções, registrará todos eles
e, em seguida, você terá acesso a qualquer função, mesmo esteja abaixo da
que você está chamando, porque está dentro
de outra função. Isso quer dizer que você pode colocar a função que estamos prestes a
escrever em qualquer lugar que quiser. Como prática geral, eu, essa é uma função com a
qual vamos interagir, esse é o
ponto de entrada para nossa ferramenta. Eu costumo colocar esse tipo de
função no início
do arquivo para que a primeira coisa você veja seja essa função. E a partir daí você começa a entender o que está acontecendo no
resto da pilha. Então, mas dito isso, depois de todo esse discurso, espero que tenha sido interessante,
útil e pouco claro. Mas vamos
escrever a função real. Esta é uma função que funciona
como nosso botão para nós, onde ele executará
todo o fluxo de trabalho. Lembre-se de que dissemos que queremos selecionar dois ou mais
caracteres e aplicar a postagem
do primeiro aos outros
personagens-alvo. Então, vou
chamá-la de transferência selecionada. Sem entradas no momento. Vamos começar a bloqueá-lo. A primeira coisa que precisamos fazer
é obter namespaces selecionados. Depois disso, precisamos
validar a seleção. Porque, como eu disse, precisamos selecionar
pelo menos dois personagens. Portanto, seleção de data válida. Em seguida, precisamos obter o dicionário de pose
do primeiro caractere, espaço
FirstName para
o primeiro caractere. Porque Rick, digamos, então aplica a pose aos namespaces de
destino, direciona os medicamentos. Então, vamos chamar esse
dicionário do código-fonte e aplicar metas. Tudo bem, acho
que isso faz sentido. Acho que esse é o fluxo que
estamos buscando. Então, vamos começar a preenchê-lo. Vamos pegar os namespaces. Essa é fácil, já
temos uma função para ela. Agora. Na verdade, temos uma função para tudo o que precisamos
fazer nessa função. Ou talvez vamos chamar essa
variável de namespaces iguais, obter namespaces selecionados, que
é nossa função aqui embaixo. Nomes excelentes. É por isso que está
falhando. Namespaces. Aí está. Agora, precisamos
validar nossa seleção. Como dissemos,
queremos operar em dois ou mais caracteres
selecionados nos namespaces selecionados. Então, digamos que se eu for
usar a função de comprimento L-E-N, namespaces
len sejam menores que dois. Podemos simplesmente sair da função
deles aqui e não fazer nada de volta. Mas eu gostaria de torná-lo um pouco mais fácil de usar. Gostaria de dizer ao
usuário por que nada aconteceu, em vez de
deixá-lo no escuro. Portanto, podemos usar a biblioteca C&DH
para que o aviso de pontos CMBS, nome
muito conveniente,
nos dê um
nome
muito conveniente,
nos dê a capacidade de avisar
o usuário. Tudo o que ele faz é pegar uma string como mensagem e
ser exibida para o usuário. Portanto, podemos dizer:
Selecione duas ou mais tarifas. Agora deixe-me te mostrar isso. Tenho certeza de que você já viu esse
tipo de aviso antes. Simplesmente parece assim. É aquele aviso amarelo que aparece na parte inferior
do Maya. Excelente. Então, poderíamos melhorar
isso um pouco. Na verdade, podemos fazer com
que , se não houver
nada selecionado, você peça ao usuário que
selecione algo. Se houver apenas um. Deixe-me fazer isso, por favor. Portanto, se o tamanho dos
namespaces for zero, podemos dizer
Selecione algo. Caso contrário. contrário, se o tamanho
dos namespaces for um, podemos dizer manhã. Selecione mais de um. Certo? Se for esse o caso, podemos simplesmente retornar
e sair da função. Então, depende de você. Você pode fazer a declaração if
simples ou a declaração if dupla. O if e o elif são Terminus. Eu fiz isso aqui. Eu vou ficar com este. Então, novamente, se meus
cheques não forem aprovados, retornaremos e não faremos nada. Caso contrário, queremos
obter a fonte, o dicionário da fonte e depois aplicar aos alvos. Como temos namespaces, esse namespace de origem, source, vamos chamá-lo de source. Na verdade, não, desculpe,
vamos ser mais explícitos. Espaço do nome da fonte. Sabemos que será o
primeiro namespace selecionado. Então, podemos simplesmente dizer namespaces, abrir e fechar
colchetes, colchetes. O índice zero
será o primeiro. E então queremos aplicar
isso ao resto
dos namespaces antes de
chegarmos a isso, porque isso
realmente introduzirá um novo conceito em enlist. Deixe-me fazer isso com
apenas um alvo. Então, vamos ignorar qualquer
coisa, qualquer coisa que não seja
duas plataformas selecionadas Por enquanto,
vamos corrigir isso. Muito em breve. Vou chamar isso de
espaço alvo, serão espaços. O índice número um, que é o segundo
item da lista. E sabemos que temos o suficiente
porque estamos verificando se temos
pelo menos mais de um, pelo
menos dois nesse caso. Ótimo. Então, vamos pegar o dicionário de
postagens. Vamos chamá-lo de post dict
igual a GET post deck. Como nós, como sabemos, estamos solicitando um
namespace para essa função. E esse será nosso
namespace de origem ,
namespace de origem, dicionário. E então tudo o que precisamos
fazer é aplicar a pose. Forneça, aplique a pose. Podemos fornecer o dicionário de
postagens e fornecer o namespace de
destino. Tudo bem, vamos testar isso. E então podemos voltar e fazer isso em mais de
duas plataformas, se estiver funcionando. Tudo bem, vamos para Maya. Mais uma vez, porque
fizemos algumas mudanças. Vamos
recarregar o módulo. Deixe-me limpar meu editor de scripts porque é um
pouco confuso. E não precisamos mais armazenar nenhuma dessas variáveis. Então, vamos dizer
transferência, não, desculpe, transferência de
postes, tanto nessa transferência
portuária, transferência. Selecione-o. E então vamos chamar
essa função. Então, vamos testar nossas
verificações primeiro. Deixe-me executar esse trecho de código. Os índices estão organizados. Ok, eu tenho um bug
agora. Jogando 13. O índice está fora do alcance. Ok, eu vejo o que está acontecendo. Você cometeu um erro,
mas isso é ótimo. Então, como você pode ver meu
aviso, eles disparariam. Mas então meu código continuou sendo executado. E estamos tentando obter o espaço do primeiro nome
da lista de namespaces. Mas o Python está me dizendo que o índice da lista está fora do intervalo. Isso significa que
não há nada nos namespaces. E eu estou tentando
obter algo essencialmente do nada, o que
, claro, não vai funcionar. Então, vamos corrigir isso. Volte ao termo pi. Então isso é um problema, é que nós chegamos
a esse ponto. O tamanho dos
namespaces era zero. Nós lançamos um aviso. E ainda fomos aqui porque não
retornamos
nesta declaração. Então, deixe-me mostrar
que, se eu selecionar apenas um namespace,
entraremos aqui. Vamos receber esse aviso
e depois sairemos
sem erros. Deixe-me fazer isso bem rápido. Selecione um deles e execute isso. Aí está. Recebemos o
aviso, mas sem erros. Então, como podemos corrigir isso? Muito simples, podemos
simplesmente retornar aqui, sair da função aqui. Isso também significa que a declaração
if não é
realmente necessária. Podemos simplesmente dizer que, se agora
isso não significa que seja errado, funcionará nos dois sentidos. Mas agora, como estamos
saindo da função de qualquer maneira, não
sabemos, não precisamos
do resto, nesse caso. Tudo bem, então isso
deve corrigir nosso bug. Deixe-me desmarcar tudo
para recebermos o primeiro aviso. Selecione algo. Excelente. Agora selecione
apenas uma coisa. Diga: Por favor, selecione
mais de um Rick. Excelente. E agora vamos fazer a transferência
real. Deixe-me mover os quadris para trás. Aí está. Deixe-me selecionar meu
personagem-alvo. E aí está, a
postagem é transferida. Agora dissemos, bem, deixe-me testá-lo com o suporte que não existe
no alvo. Pronto, nenhum erro ocorreu. A pose é a mesma. Sons. Está funcionando. Ótimo. Agora, vamos fazer
isso funcionar com
vários personagens. E para isso, preciso adicionar mais
um personagem
à cena. Eu segui em frente e dupliquei
nosso personagem Minerva. Então, há outro equipamento de
referência na cena, e eu vou mudar
seu namespace para baixo. Agora. Vamos me dar um
segundo para responder. Lá vamos nós. Então, agora temos
três personagens referenciados na cena. Deixe-me mover esse aqui. E vamos aplicar uma postagem novamente. Mas agora vamos tentar aplicá-lo
a dois caracteres
em vez de apenas um. Aí está. Então, como esperado, só
funcionou no segundo que
selecionamos porque implementamos
essa limitação. Mas agora vamos
torná-lo mais versátil para que possamos aplicar a postagem a
quantos caracteres quisermos. Para que isso funcione, precisamos obter uma lista
dos namespaces de destino. Então, vou mudar
isso para namespaces de destino. Agora, em vez de
ser uma única string, tem
que ser uma lista de strings. E fazemos isso fazendo
algo chamado fatiamento de listas. Temos que cortar uma lista e pegar tudo, exceto o
primeiro item da lista. E podemos fazer isso
usando essa sintaxe. Portanto, ainda está dentro desses
colchetes de pontuação. Usaremos essa coluna. Isso estará no lado esquerdo. Deixe-me abrir um espaço
aqui. No lado esquerdo. Esse será o primeiro
item ou o primeiro índice no qual você deseja iniciar a cópia da
lista que está criando. Então isso será
indexado como número um. E aqui, esse será o último índice no qual
você deseja parar. Agora, o problema
é que não é inclusivo. Isso significa que, se você
quiser parar no índice número dois, você realmente precisa
fornecer o índice três. Isso pode ser um
pouco confuso. Isso significa que
vamos começar no índice um e terminar no índice dois. Ou, neste caso, agora, queremos ir
até o final da função. Então você pode simplesmente
deixar isso vazio. Então, para nosso propósito, podemos usar deixar isso vazio. Então, isso significa que
vamos obter tudo do segundo item, que é o índice número um, até o final da lista. Deixe-me mostrar isso em
Maya antes de continuarmos. Porque isso pode ser um
pouco confuso. Então, vamos, na verdade,
obter uma lista de namespaces. Namespaces são iguais a
postar, sublinhar, transferir e ser selecionado. Há um espaço coordenado que diz deixe-me mover isso para
cá, nomeie espaços. E vamos imprimir
isso. Ok, aí está. Então, temos três, esses
três namespaces. Então, na verdade,
vamos colocar essa
lista aqui para que
fique mais óbvia. Ok? Então, imprimimos essa lista. Temos esses três namespaces. Se eu imprimir, se eu fizer isso, por exemplo, estou cortando a lista. Mas se eu não
incluir nenhum índice, isso vai desde o
início
da lista até o
final da lista. Então, basicamente, fazer uma cópia
completa da lista. Agora, lembre-se de
que antes eu disse
que as listas podem ser modificadas. Isso significa que você pode modificar espaços de Britney do
nome
repetidamente. Quando você faz isso, você
está fazendo uma cópia. Então, é como uma lista separada. E se você estiver
modificando a cópia, você não afetará
a original. Então, nesse caso, estamos basicamente imprimindo
uma cópia dessa lista. Agora, como mencionei, queremos
tudo menos o primeiro. Assim, podemos começar no índice, no segundo item, que é o índice número um porque
começamos a contar em zero. Então, vamos ver o que isso nos dá. Aí está. Pegamos Severus e Linda. Agora, e se quiséssemos
apenas o último? Bem, para AC, podemos começar no índice dois e só
temos essa maravilha. Agora, eu mencionei que você pode, você pode fazer com que
o corte da lista funcione até parar. Então, nesse caso, se quiséssemos parar? Número dois,
digamos que queremos tudo do zero
até o segundo item. O segundo item logicamente
deve ser o índice número um. Mas se eu fizer isso,
eu só tenho um. Isso porque, como eu disse, o segundo lugar aqui depois
do cólon não é inclusivo. Isso significa que você
tem que passar por cima. Então, se eu fizer
o índice número dois entre eles, basicamente
obterei o índice número zero e o
índice número um até
um antes do número dois. Eu sei que isso pode ser um
pouco confuso. Até para mim. Às vezes eu
esqueço qual é inclusivo, qual é exclusivo? Mas é assim que o Python
funciona e
há algumas razões por trás disso, mas não precisamos
entrar nisso agora. Mas, mais uma vez, se
eu deixar isso vazio, vou conseguir, na verdade, vou começar no índice um. Eu vou até
o fim. Então, vou deixá-lo vazio. Aí está. Se você estiver curioso,
se puder usar o índice menos um, você pode. Funciona da mesma forma que, como se você estivesse escrevendo
o índice número quatro nesse caso. Então esse é o índice 01.2, desculpe, índice número três. Se você estiver escrevendo o
índice número três aqui, obterá 12,3. Será ignorado menos um? Porque, como
dissemos, menos um é
igual ao último índice. Menos um
é basicamente o mesmo que três. Então você receberá
um. E é isso. De qualquer forma, ela receberá apenas servidores. Espero que não tenha sido muito confuso. Examinaremos as listas
com mais detalhes após este projeto. Por enquanto, tudo o que precisamos é saber que
queremos uma cópia da lista, pulando o primeiro item, para manter o índice zero. Então, começando no índice um até
o final da lista. Vamos voltar e fazer isso. Bem, nós já,
já não o fizemos. Temos uma nova lista de destinos, de namespaces, que são
os namespaces de destino. Então,
o que podemos fazer agora percorrer
esses namespaces de destino. Então, eu vou chamar isso, vou dizer “alvo”. Em namespaces de destino. Vamos
simplesmente analisar isso e aplicar a postagem de cada um
dos namespaces de destino. Em vez dos
namespaces do espaço de argumentos. Aí está. Então, vamos
testar isso. Como de costume, vou recarregar o módulo porque
fiz algumas alterações. Não precisamos mais disso,
então vou excluí-lo. E vamos
testar nossa função. Vamos fazer, vamos revisar
nosso teste novamente. Então, se eu não tiver nada selecionado, receberemos o aviso. Se eu tiver apenas um selecionado, receberemos o aviso. E agora, se formos, vamos fazer uma mudança na pose. Digamos isso. Na verdade, vamos selecionar
o chapéu também. Vamos aplicar todos
os controladores
que eu selecionei. 21.2 plataformas. Execute o código. Está passando por essas homenagens
e, perfeito, aí está. Então, até mesmo o chapéu na outra
referência é fornecido, porque descobriu
que o controlador
encontrou esse atributo. Vamos manter o chapéu desse
personagem aqui. Então, peço desculpas pelas
minhas postagens horríveis. Eu sei que isso não é
muito atraente, não é uma silhueta muito boa. Mas, como você pode ver, todas as poses são
exatamente iguais, é isso que estamos procurando. Então aí está. Você criou o
back-end da sua ferramenta. Back-end significa a
funcionalidade da ferramenta. Agora, eu disse que vamos
criar uma interface de usuário que será o front-end da ferramenta porque, por mais divertido
que seja executar código, é ainda mais divertido
apertar um botão. Então, vamos falar sobre como abordaremos
a interface do usuário.
27. Introdução às UIs: Vamos voltar a pintar
e projetar ou UI. Portanto, precisamos de uma janela que seja o contêiner principal
para nossas ferramentas. Vamos desenhar isso rapidamente. Isso será uma janela. Agora, o que precisamos. Na verdade, não precisamos
muito dessa ferramenta. Precisaremos de um botão, mas isso é muito simples. Então, vamos adicionar um pouco mais do que
um botão Esse botão aqui
terá um título pequeno. É chamado de rótulo que diz “ suponha transferência”,
algo assim. Precisa ser perfeito? É só uma maquete do fio. Então, vamos tentar
replicar isso em código. Como mencionei, o começo é
você, você precisa de uma janela. Então, há um comando
da mesma biblioteca. Deixe-me importar isso como de costume. Minhas entradas no S, há um comando de janela que podemos usar para
criar uma janela
e, em seguida, você tem que
mostrar uma janela. Então, antes de prosseguirmos com isso, vamos dar uma olhada
na documentação. Este layout de janela para esta função de
janela, desculpe. Ok, então esta é uma função de
janela. Vamos ver os exemplos e ver se
podemos obter algo deles. Ok, aqui mesmo,
faça uma nova janela. Parece assim,
empolgante. Alguns botões. Vamos copiar esse código e ver se podemos
começar daqui. E colamos o código aqui. Vamos seguir em frente e
executá-lo. Tudo bem, lá vamos nós. Temos uma janela, temos
alguns botões. Temos um título sobre eles
que não está fazendo nada e um botão que está
fechando a interface do usuário. Ok, então vamos ver
o que está acontecendo aqui. Vamos ignorar os
argumentos por enquanto. Voltaremos a
eles em um segundo. Em primeiro lugar, estamos
criando uma janela e armazenando essa janela
nessa variável de janela. Então, vamos ver o
que é essa variável de janela, ela simplesmente executará o comando window e
imprimirá a variável. Ok? Então isso é um pedaço de corda. Isso porque, assim como
objetos são notas no Maya, por exemplo, se você estiver trabalhando
com um controlador, se eu selecionar esse controlador, interagimos com o
controlador por meio de seu nome. Esse nome representa
qualquer objeto que esteja acontecendo dentro do Maya. Isso é semelhante conosco. Vocês têm um nome
e interagem com esses dois olhos através do nome
deles, neste caso, sem dar um nome, nome explícito, o homem deu
sua creatinina para nós. Em seguida, começamos esse nome
na variável window, que na verdade
será apenas uma string. E no final desse código, mostramos essa janela
usando seu nome. Podemos, se você quiser, dar um nome a ele, por exemplo, minha interface de usuário. E se eu rodar
isso e imprimir, ele imprimirá o
nome que eu dei. Mas, por enquanto,
não vamos nos preocupar com isso. Não é necessário
para este exemplo. Ok,
vamos continuar e ver o que mais
está acontecendo aqui. Em seguida, vamos
criar um layout. O layout é muito importante. layouts são basicamente o
que os contêineres
gerenciam a interface do usuário. E deixe-me tentar
explicar esse conceito. Aqui são independentes. Portanto, há dois
tipos principais de layouts. Há layouts de coluna
e há Layout de linha. Há mais tipos,
mas esses são os principais que você
usará. Um layout de coluna
fluirá para baixo como uma coluna
de cima para baixo. Então, se você adicionar um widget com o de Jerry, algo
parecido com um botão, como um pedaço de texto do TextField. Portanto, se você adicionar um layout de coluna, fluirá para baixo. Se você adicionar widgets
a um layout de linha, fluirão da
esquerda para a direita horizontalmente. Então, esse conceito
é basicamente como
as interfaces de usuário são gerenciadas no Maya, mas também como elas funcionam em outras estruturas de interface do usuário,
como q, D, por exemplo, elas entenderão que serão chamadas de horizontais e
verticais em seus olhos, mas é um conceito
semelhante aos layouts de colunas e linhas. E como é importante
saber que você pode colocar layout dentro de todos
os outros layouts. E é assim que você pode
criar interfaces de usuário mais complexas. Então imagine que você tem
um layout de coluna grande, por exemplo, você tem um layout de coluna. Está fluindo novamente de cima para baixo e você está
adicionando botões a ele. E então, de repente,
deixe-me mudar a cor. Você adiciona um layout de linha a ele. E então você está adicionando
botões a esse layout de linha. Então, mais uma vez, isso
fluirá da esquerda para a direita. Os botões
virão por aqui. E então você adiciona
outro layout de linha. E agora é aqui
que as coisas estão ficando complicadas. E dentro desse layout de linha, você adiciona layouts de coluna. Você adiciona três layouts de coluna que fluem
da esquerda para a direita. Mas quando você adiciona botões ou widgets dentro
desses layouts de coluna. Esses widgets
fluirão novamente de cima para baixo. Então, é assim que você cria esse fluxo nessas interfaces de usuário
mais complexas dentro do Maya. Portanto, lembre-se
desse conceito ao trabalharmos com layouts. Vamos voltar para Maya. Então, estamos adicionando um layout de coluna. Agora, dentro desse layout de
coluna, temos dois botões. Então, estamos definindo o pai. Vamos, vamos manter isso por enquanto. Vou voltar a isso
em apenas um segundo. Em seguida, estamos mostrando a janela. Então, o que acontece se executarmos tudo sem
mostrar a janela? Sua interface de usuário será criada. Mas isso não foi mostrado. Você pode mostrá-lo mais tarde, mas nesse caso você precisa executar show window para exibi-lo. Então, como você pode ver,
como mencionei
, como estamos em
um layout de coluna, os botões estão fluindo de
cima para baixo. Então, se eu adicionar mais alguns botões, eles fluirão para baixo. Agora, e se eu
inserisse um layout de linha aqui, layout linha de pontos
cmd S. Vamos adicionar isso. Layout de muitas crianças. Ok, acho que temos que definir o número de itens
para o layout da linha. Vamos dar uma olhada nisso
na documentação. Lançando. Aí está. Ok, vamos ver. Os exemplos geralmente
são uma boa
indicação do que fazer. Layout da linha, número de colunas. Ok, lá vamos nós.
Acho que o número de colunas é o que
estamos procurando. Então, estamos adicionando Vamos apenas adicionar dois botões. Só para provar. Para mostrar esse exemplo, digamos que o número de
colunas seja igual a. Mostre isso. Ok, aí está. Portanto, temos o primeiro layout, o layout da coluna de cima para baixo e,
em seguida, um layout de linha indo
da esquerda para a direita. Agora vamos adicionar outro
layout de coluna logo depois disso e depois mais dois botões. Deixe-me deixar um pouco de espaço
para que seja um pouco mais fácil ver e
adicionar alguns comentários. Então isso será uma linha, isso será uma coluna. E o primeiro aqui em cima, esse será,
também é uma camada de coluna. Ok, vamos maximizar isso. Mas veja o que acontece aqui. Layout de muitas crianças. É porque estamos adicionando o layout da coluna
a esse layout de linha. Portanto, esse layout de coluna é outro filho
desse layout de linha. Portanto, se dissermos que queremos três
colunas nesse layout de linha, ele deve acomodar
essas crianças extras. Criança extra. Aí está. Então isso é o que está
acontecendo aqui. Deixe-me fazer uma
captura de tela rápida para que eu possa fazer, eu possa desenhar sobre ela. O que está acontecendo aqui é que primeiro temos um layout de
coluna, indo de cima para
baixo, layout de coluna. E então temos o layout da linha, que é esse aqui, que vai da
esquerda para a direita. Mas agora, dentro
desse layout de linha, para inserir outro layout de coluna, que flui novamente
de cima para baixo. Isso remonta a
essa ideia sobre a
qual falei de layouts
dentro de outros layouts. Agora, o que acontece com essa função principal
definida aqui? Sempre que você criar um layout, sem layout será
o pai atual. Então, tudo o que você adicionar depois, logo após
o layout será colocado na última camada
que você criou. Então, esse layout de linha, na
verdade, foi adicionado
a esse layout de coluna. E esse layout de coluna está
sendo adicionado a esse rolo. Sim, então a
parte atual do momento é esse layout de
coluna. Então, vamos imaginar,
deixe-me executar isso de novo. Digamos que queremos
esse layout de coluna. Então, esses dois botões
continuam fluindo para baixo dessa forma, são o layout
de pular a linha. A maneira de fazer isso é
usando essa função de conjunto. Então, primeiro criamos
nosso layout de coluna, adicionamos dois botões e depois criamos um layout de linha. A controladora atual
está sendo lançada. Agora, antes de adicionarmos o layout da
próxima coluna, queremos alterar o
pai atual para que já esteja lá. O layout da primeira coluna
, onde
queremos adicionar um novo. Então é isso que isso está fazendo. Se eu disser set
parent dot-dot, essa é a sintaxe muito
específica do Maya. Para voltar à parte anterior. Portanto, você pode dizer ignorar
o pai atual e
pular
o último layout e fazer com que o pai atual
seja o anterior. Então, vamos apontar que o pai atual é
o layout da coluna. Portanto, agora esse novo layout de
coluna deve ser adicionado ao layout original, original ou de primeira coluna. Vamos ver como isso parece. Aí está. Então, deixe-me fazer
outra captura de tela. Perfeito. Então, mais uma vez, só para deixar
isso o mais claro possível. Temos um layout de coluna. Ashley. Estou exagerando aí. Desculpe, não estou exagerando.
Eu não estou muito certo. Como se tudo isso fosse
um layout de coluna. Então, dentro disso
, adicionamos esses botões. E então, dentro
desse layout de coluna, adicionamos esse layout de linha. Então, nós, o
pai atual quando
criamos esse layout de linha,
é esse layout, mas o layout da linha é
o pai atual. Mas lembre-se de que, ao usar
set parent aqui, mudamos o pai atual
para o layout principal novamente. E é aí que criamos
outro layout de coluna. E é aí que
adicionamos os novos botões. Então, espero que isso faça sentido. Pode ser um
pouco confuso. Mas, novamente, uma vez que você tenha
a ideia de layouts, a maneira como você cria UIs
será muito mais eficiente. Então, agora vamos voltar e ver o que esses
argumentos estão fazendo. Então, na janela, temos um título, que é o nome do título da janela. Vamos chamar isso. Vamos mudar isso para o
título da janela que é simplesmente uma string. Então temos o nome do ícone. Veja o que é isso
na documentação. Oh, interessante. Na verdade,
não aparece. Isso é muito lamentável,
para ser honesto, eu nunca usei esse
argumento antes, então não tenho
certeza do que ele faz. Parece que não nos
dá nenhum tipo de ícone na janela. Então, eu
vou simplesmente removê-lo. Agora, com altura, isso é, eu mencionei antes,
isso é uma tupla. Isso é simplesmente uma lista que não pode ser modificada
com dois itens. Essa será a largura,
essa será a altura. Ou seja, esses são pixels que dizem
que a janela terá 200 pixels de comprimento
e 55 pixels de altura. É por isso que, quando
criamos pela primeira vez, ele não mostra
todos os botões porque estamos restringindo que, se eu remover esse argumento, não
haverá restrições
de tamanho e ele
simplesmente mostrará todos esses botões. Excelente. Então, eu só tenho
todas as colunas iguais a verdadeiras. O que acontece se isso for falso? Vamos simplesmente defini-lo como falso
e ver o que está fazendo. Ok, bem, nossos botões
não estão se expandindo com a janela. Eles não são de tamanho fixo. Então é isso que eu acabei de
fazer uma coluna dupla. Está fazendo com que os botões ou widgets internos
sejam ajustáveis. Exceto pelo layout da linha. Porque o layout da linha
precisa gerenciar seus próprios widgets expansíveis. Então, vamos continuar. Onde está minha janela aqui? Feche todas essas cópias. Ok, agora temos os botões. O rótulo é simplesmente o texto que vai
aparecer no botão. E o comando é uma
parte do código que será executado
quando você pressionar o botão. Agora, um comando pode
ser uma string
e, no exemplo, eles estão
usando parênteses, mas isso não é necessário. Pode ser uma string,
nesse caso é uma string que está
excluindo a janela. Esse é um comando
para excluir uma interface de usuário. E estamos passando o nome
da janela que criamos. Então, estamos basicamente
diluindo essa janela. Digamos, vamos fazer esse
botão aqui em cima, fazer alguma coisa. Vamos ligar para isso, fazer alguma coisa. E eu vou adicionar
um comando a ele. O comando será
simplesmente uma instrução de impressão, mas agora estará
no formato de uma string. Então, é uma espécie de trecho de código enrolado dentro de uma string. Então, vamos dizer que
imprima fazendo alguma coisa,
por exemplo, vamos fazer isso. Agora. Observe que estou usando os
dois tipos de aspas, aspas
simples e aspas duplas. Isso porque se eu
usasse aspas simples aqui, Maya pensaria que esse
é o fim da minha string. Então, o que estou fazendo, lembre-se que mencionei que,
para criar uma string, você tem que combinar o início e o final da string, o tipo que deve
ser o mesmo. Então eu estou basicamente dizendo, ok, dentro dessa corda, está essa corda externa. Há uma sequência dentro dela, que é
basicamente o que estou passando para aquela declaração impressa de que
estou usando um sacramento. Então, vamos executar isso. Deixe-me clicar no botão
que diz fazer alguma coisa. E agora você está
correndo, fazendo alguma coisa. Agora, para esse comando. Você também pode transmitir uma função. Então, deixe-me mostrar o
que isso, o que isso parece. Se eu chamar minha função,
faça algo, por exemplo que não seja isso,
vamos
chamá-la apenas de teste, teste de função. E eu vou
fazer essa impressão, apenas imprimir, fazendo algo
de dentro da função. Ok, então, em vez de
passar uma string, eu posso realmente passar
uma função. Mas eu posso passar a função sem chamar a função. Observe como eu não estou
usando o parêntese. Se eu usar um parêntese, estou chamando a
função e fornecendo o argumento do comando, o resultado, a saída, o retorno dessa função, que neste caso é um não, porque não estou
retornando nada. O que eu queria fazer era fornecer argumentos para
esse comando por função
real,
sem dois pontos. Isso significa que quando
eu pressiono o botão, o
Maya assume minha função
e a chama sozinha. Então, vamos ver o que
acontece nesse caso. Antes de fazer isso,
deixe-me limpar isso. Acho que não precisamos desses
botões extras , pois
já examinamos o exemplo. Vamos manter as coisas simples.
Faça alguma coisa. Ok, está fazendo alguma coisa,
mas não é exatamente
o que esperávamos. Vamos ver o que está acontecendo aqui. Está dizendo que a
função de teste não aceita argumentos, mas um deles foi fornecido. Deixe-me fechar a janela. Então isso é verdade. Não estou aceitando nenhuma discussão. Mas, de alguma forma, quando eu
pressiono o botão, meus olhos transmitem um argumento para minha
função de teste, apenas uma. Então, vamos inspecioná-lo
e ver o que é. Eu posso simplesmente entender esse argumento passando um
argumento para minha função. Vamos chamá-lo de x. Vamos simplesmente imprimir,
vamos imprimir x. Vamos ver o que é, o
que o meu está fazendo. É que está impresso em falso. Então parece meu sim, passando um booleano
para a função. Por algum motivo.
Não tenho certeza do porquê. Agora, o problema é
que nós realmente não precisamos disso. Nós realmente não nos importamos com isso. Portanto, há duas maneiras de
conseguir lidar com
essa situação. Uma delas, assim
como fiz aqui, é aceitar uma discussão
porque, você sabe, você estará esperando isso
de Maya e a ignorará. Simplesmente não faça nada a respeito. Você pode aceitá-lo, mas não usá-lo dentro
da função. Como você vê. Pronto, meu botão
estará funcionando. Outra forma de fazer isso é usar uma sintaxe especial
semelhante a esta. Você faz um asterisco ou uma estrela, uma estrela, uma estrela, um novo tipo, args. Agora, essas podem ser
qualquer palavra que você quiser,
mas, por convenção, você
verá pessoas fazendo argumentos. O que isso está fazendo. Isso é mais ou menos como um argumento genérico
para qualquer argumento que você
descarte da função. Você tem acesso a
eles, se quiser. Muitas vezes, as pessoas
usam isso para ignorar quaisquer argumentos que possam ser
esperados, mas não necessários. Então, deixe-me mostrar como essa
sintaxe de argumento em estrela está funcionando. Então, se eu disser que se eu chamar
meu teste de função e passar 1234 argumentos, vai funcionar. Então, essa sintaxe está basicamente capturando
qualquer coisa que eu uso nela. E eu realmente não estou usando isso. Mas agora vamos ver o que, o
que realmente está acontecendo. Vamos imprimir esses
argumentos. Ok, muito bom. Então isso é o que está acontecendo. Então,
essa sintaxe de arco estelar está basicamente capturando qualquer
argumento que eu lhe dê. Estou colocando-os
dentro de uma tupla. Mais uma vez, lembre-se de
que uma tupla é como uma lista de ciclistas, mas você não pode modificá-la. Isso significa que eu posso
realmente obter, por exemplo o primeiro argumento
que foi passado, que foi passado, neste
caso, será o número um. Eu posso simplesmente imprimir
isso. Aí está. Então, em casos como
esse, em que a interface do usuário, por algum motivo,
Maya está lhe dando uma discussão e
você não precisa dela. Eu recomendo usar esse índice. Você pode usar essa sintaxe
junto com outros argumentos, como se estivesse esperando
uma discussão real, claro, esperando um bebê e, em seguida, qualquer coisa que possa ser
usada em sua função. Isso também é válido. Ok? Então, com isso
dito, vamos voltar. Vamos voltar a simplesmente usar esse tipo de
argumento estelar abrangente e passá-lo para o
nosso comando do botão. Isso é fazer alguma coisa. Ok, perfeito, então vamos usar isso como um começo
para nossa interface de usuário real.
28. Criar uma IU: Ok, não precisamos mais dessa função
de teste. Não precisamos desse comentário. Acho que esse é um
bom ponto de partida. Vamos mudar o
título da nossa janela. Digamos que seja uma ferramenta de
transferência. Esse será o
nome da nossa janela. E vamos fazer com
que as colunas sejam todas “sim”, porque queremos que os
botões possam
se expandir com as colunas. Não precisamos de dois botões, precisamos apenas de um. E digamos que o rótulo
deva ser transferido. Ok, e comando,
vamos deixar o
comando de fora por enquanto. Vamos adicionar uma função
por meio dela em um segundo. Na verdade. Vamos chamar
essa transferência de selecionada. Ok, aí está,
um único botão. Não podemos ver o nome, o título da janela. Então, seria bom ver isso. Podemos usar o argumento de largura e altura que tínhamos antes. Ou também sei que
a janela tem argumentos
de peso e altura individualmente. Então, podemos simplesmente adicionar a largura. Podemos dizer, vamos fazer com
que seja 300 pixels, por exemplo, talvez um pouco
maior para 100. Isso foi demais,
digamos 350. Ok, isso parece ótimo. Então agora temos nosso botão. O botão é um pouco fino. Então, vamos também tornar o
botão um pouco maior. Podemos ter um
argumento de altura no botão. Vamos fazer com que tenha 20 pixels de altura. Não é suficiente. Vamos dobrar 40. Ok, isso parece um
pouco melhor. Agora, eu também disse que
queríamos adicionar um pequeno rótulo na
parte superior, como um pedaço de texto. Há um componente de interface de usuário de texto aqui
nesta biblioteca que
é chamado simplesmente de texto. Digamos isso. Vamos
ver os exemplos. Aí está. Parece que é tudo
o que precisamos sobre isso. Assim, podemos adicionar um rótulo e
alinhar o texto. Vamos, vamos pegar esse exemplo. Vamos copiar esse exemplo. Vou adicionar
esse pedaço de texto. E o rótulo será,
digamos, após a
transferência, em maiúsculas. E vamos alinhá-lo à
esquerda e dois, o que acontece? Isso não é ótimo. Vamos
mantê-lo no centro. E também é muito pequeno. O texto é muito pequeno. Vamos ver se podemos fazer
algo sobre isso. Talvez possamos mudar a
altura dele também. Digamos que 60 pixels. Digamos que 50. E vamos tornar o botão um
pouco menor. Vamos fazer o botão 30. O texto está um pouco bom. Desculpe. Vou colocar o bastão
novamente neste momento. Só estou mexendo
com os números. Isso não é tão importante, mas fique à vontade para brincar com
os tamanhos que desejar. Acho que está
muito feliz com isso. Então, temos nossos textos,
temos nosso botão. E antes de passarmos
isso para o PyCharm, quero mostrar algo que será
muito útil. E isso são dicas de ferramentas. Agora, uma dica de ferramenta, também
conhecida como clipe de ferramenta, mas o nome oficial
está inclinado para os textos que acontecem quando você passa o mouse
sobre algo na interface do usuário. Como você pode ver quando eu
passo o mouse sobre esses botões, você recebe um pouco de ajuda. E também aqui
nesta barra de status, você obtém um pouco
de ajuda , basicamente dizendo o que
o botão vai fazer. Portanto, podemos adicionar isso em
todos os nossos elementos de interface do usuário. E isso é chamado
de anotação. Portanto, o argumento para isso
é chamado de anotação, mas o nome real é dica de ferramenta ou clipe de ferramenta
também é chamado no Maya. Então, se você não
vê isso como eu, como quando você passa o mouse
sobre algo, se você não vê isso,
você tem que ir para Windows, configurações,
preferências, preferências. Agora, nos elementos da interface do usuário, desculpe pela saúde deles,
há ajuda na interface. Em sua ajuda pop-up. Você verá isso
exibir dois clipes. Você quer que essa caixa seja marcada. Se você não tiver isso verificado,
você não verá isso. Ok, então aí está. Então, podemos adicioná-los. Mais uma vez com a anotação. Argumento. Então, a anotação é igual a,
vou pressionar Enter aqui. A propósito, isso é
válido. Se eu pressionar Enter, é válido e o Python não
reclamará. Eu vou dizer anotação,
transferência entre caracteres. Essa será a
anotação no texto. Na verdade, eu vou voltar, voltar para esta única linha. E depois a anotação
no botão. Seremos uma anotação igual a
selecionar dois ou mais caracteres. Então essa é a ajuda. Então, nesse caso, como esse é o tipo de
instrução para o total, vou escrever
algo um pouco mais detalhado. Transfira postes do tijolo selecionado na
floresta para o resto da seleção. Ok, isso pode não demorar um
pouco , mas tudo bem. Agora, quando passarmos
o mouse sobre esses botões, você verá que o
pedágio ajuda um pouco. E você também vê isso
aqui embaixo na barra de status. Ok, perfeito, então nosso botão não
está fazendo nada. Vamos mover isso para uma
função no PyCharm em nosso módulo para
que fique no arquivo. E então podemos
conectar o botão. Tudo bem, deixe-me copiar isso e
criar uma função aqui em cima. Na parte superior do arquivo. Vou chamá-lo de Show UI. Aliás, geralmente é uma boa ideia manter
seu back-end,
como mencionei anteriormente, que é sua funcionalidade separada do
front-end, que é sua interface de usuário. Normalmente, eu teria
essa função em um módulo separado ao lado
desse módulo de pós-transferência. Nesse caso, por
ser uma interface de usuário muito simples, vou deixá-la aqui e é só para esse
primeiro projeto. Mas na próxima,
você verá a separação entre
a
funcionalidade e a interface do usuário, que geralmente é uma
boa prática. Assim, você pode chamar suas
funções diretamente e ter sua interface de usuário
completamente separada, completamente independente de
sua funcionalidade real. Mas por enquanto, vamos como eu
disse, vamos mantê-lo aqui. Vou simplesmente colar
meu código de interface de usuário aqui. E vamos
testá-lo bem rápido. Digamos importar,
posar, transferir. Ok, e se você não
reiniciou seu Maya, mais
uma vez, você
quer recarregar o módulo. Deixe-me recarregar isso. Ok, aí está. E eu posso dizer que os posts
sublinham a transferência, os pontos mostram outra interface de usuário de pontuação. E vamos chamar isso de
função. Aí está. Ok. Agora, a etapa final é
conectar o botão. E o botão aqui
aceitará esse comando. Vou pressionar Enter, como eu disse antes, se você tiver algo em várias linhas, não
importa. Python não reclamará. Você pode colocar cada argumento em uma linha diferente, se quiser. Então, vamos fazer isso apenas por causa
do exemplo. Comando igual a esta
será minha função de transferência
selecionada. Aí está. Agora vamos testar isso. Transferência de erro selecionada. Ok, OK. Claro que
acabamos de falar sobre isso. Nós precisamos, eu vou
usar esses argos estelares. Essa é uma espécie de sintaxe
abrangente para
capturar o argumento. E já que estou fazendo isso, vou adicionar uma docstring
que esqueci de escrever. Transfira o
equipamento selecionado pela floresta de pose para o resto da seleção. Agora, star args é especial, não
precisamos realmente adicionar
uma descrição para isso, mas Ashley, bem, fazemos isso porque
há um propósito nisso. Vamos chamar isso de pegadinha. Todos os quatro argumentos transmitidos por mim, não estamos
retornando nada. Portanto, não deixamos
isso passar. Sim. Ok. E agora, mais pobre para você, posso simplesmente
adicionar uma sequência de documentos simples. Mostre a interface do usuário da
ferramenta baseada em uma, mxnet, menos explicação, mas ainda
vamos adicioná-la lá. Ok, vamos fazer isso. Deixe-me fechar essa ferramenta. Lá vamos nós. Agora está funcionando. Selecione mais de um equipamento. Se não tivermos nada selecionado, ele nos diz para jogar,
selecione algo. E por último, deixe-me criar uma postagem melhor
para testar adequadamente nossa ferramenta. Ok, temos uma pose um pouco
melhor,
não é uma obra-prima neurológica incrível. Tenho certeza de que sei que você
pode fazer melhor do que eu, mas é melhor do que a coisa
horrível que tínhamos antes. Então, vamos testar a ferramenta de forma
mais útil do que melhor. Então, vamos selecionar
todos esses controladores. Não quero
selecionar a função do porão porque isso
apenas moverá os personagens
para essa posição. E aí está, selecione todos os meus controles, alvo, um, alvo também. Vamos transferir. O processo que está
passando por muitos controladores no momento
é um pouco lento. Mas aí está. Nossas poses, deixe-me
ativar as curvas. Parece exatamente o mesmo. Então aí está ele para
roubar seu primeiro ano, eu compartilho isso com seus amigos, uso quando você trabalha. Essa é uma ferramenta de trabalho real da
qual você pode se beneficiar.
29. Reap de projeto: Agora, para encerrar o projeto, gostaria de fazer uma pequena
recapitulação do que aprendemos. Deixe-me escrever isso aqui. Então, aprenderemos muitas coisas. Aprenderá sobre
listas e tuplas. Aprenderemos sobre dicionários, aprenderemos sobre por loops, como iterar
elementos em uma lista. Aprenderemos mais sobre
como lidar com cordas. Aprenderemos mais
sobre se as declarações aprenderão mais sobre funções. Aprendemos como avaliar
seus olhos sobre como lidar como gerenciar
elementos de interface do usuário usando layouts. Aprenderemos como interagir com objetos e
notas na cena. Como definir e obter atributos, como interagir com equipamentos e realmente como
separar as coisas para
que possamos obter as informações e os dados de que precisamos. Agora, essa é uma das principais
conclusões deste projeto. Isso agora usa esses
dois tipos de dados e esses são os principais
tipos de dados para armazenar dados. Agora você sabe como consultar, armazenar e manipular dados para qualquer finalidade
que precisar. Agora lembre-se de que usamos a lista para consultar e
armazenar seleções, para fazer listas de controles, fazer listas de namespaces,
atributos, etc. Podemos usar
dicionários para criar um mapeamento entre atributos
e seus valores? Portanto, esses são conceitos muito
simples, mas são extremamente poderosos
e se
traduzirão em casos de
uso mais complexos para você. Então, parabéns por
concluir o projeto, e agora você está pronto
para o próximo.
30. Mergulho profundo - cordas: Vamos aprender
mais sobre cordas. Sequências de caracteres em termos simples são
uma sequência de caracteres. Você pode pensar neles como texto. Assim, você pode criar
sequências de caracteres com aspas. Podem ser aspas simples, aspas duplas ou aspas triplas. Nesse caso, há
três aspas triplas, três aspas simples
ou três aspas duplas. Então, por exemplo ,
isso é uma string e três aspas simples também
são uma string. Mas as aspas triplas
geralmente são reservadas para blocos de
texto ou docstrings. Normalmente, eles são reservados
apenas para docstrings. Mas você pode criar, criar blocos de textos. Então, quando você tem aspas
simples e duplas,
string um, por exemplo ,
string dois, você só pode criar essa string
como uma única linha. Mas quando você tem cadeias de caracteres de um documento, desde que elas abram
e fechem essa string, você pode escrever dentro dela. E aí as novas linhas
serão preservadas para você. Então, isso é
como um bloco de texto. E esse será o mesmo caso com as cordas triplas e simples. Então, eu meio que vejo aqui, desde que a aspa inicial e a final sejam
do mesmo tipo de tempo, a string será válida. E com a mesma, a mesma lógica. Se você quiser ter aspas
dentro de sua string. Então deixe-me,
deixe-me imprimir isso. Primeiro. Vamos imprimir essa sequência. Então, como você vê, ele imprime
sem as aspas. Digamos que eu queira
imprimi-lo com botas. Eu posso colocar aspas duplas
dentro dele. Aí está. Se eu quisesse com aspas simples, há duas maneiras de fazer isso. Primeiro, eu posso mudar
as aspas. Ou dois, eu posso pular as aspas. Deixe-me mostrar o que
isso, o que isso significa. O que acontece se eu
colocar uma cotação aqui? Bem, Python pensará que você está na
nova string aqui. Isso será, basicamente uma string vazia e
causará um erro. Então, como posso fazer com
que eu possa ter aspas simples e ainda
ter aspas simples dentro. Você pode escapar dessas
aspas simples usando uma barra invertida. E isso funcionará da
mesma forma. Então você está basicamente
dizendo ao Python esse não é o
fim da minha string, e isso também não é
o fim da minha string. Você está escapando ignorando
essas, aquelas citações. Mas, tanto quanto você puder, é mais fácil simplificar a
mistura dos tipos de aspas. Essa barra invertida serve a
outro propósito. Há um tipo especial de
personagens chamados caracteres de fuga. Essas barras invertidas e apenas observe
que não é uma barra invertida, é uma barra invertida que define
o caractere de
escape. Deixe-me mostrar o que
quero dizer com isso. O
caractere de pular mais comum é a barra invertida n, e isso criará
uma nova linha para você. Então, deixe-me mostrar o que quero dizer. Vamos digitar linha um, barra invertida n linha para
eliminar a impressão. Então você vê que não
estamos imprimindo a barra invertida onde estamos
recebendo uma nova linha. Se eu não tivesse
a barra invertida de backup, teria uma única linha. Então esse é um dos personagens de fuga mais
comuns. Outra é a barra invertida
d, que significa tab. Você está meio que
recuando como se
estivesse pressionando a tecla Tab. Você também pode misturá-los. Podemos ter uma nova linha, barra invertida n e uma aba,
barra invertida, barra invertida t. E então você terá
algo assim. Se ela quiser ter
mais indentação, é
claro que você pode fazer
mais chá e outros
T. E se você quiser
realmente imprimir a barra invertida n? Digamos que você queira que
essas sequências exatas sejam impressas. Então, agora, se eu executá-lo, vou obter uma
nova linha entre, entre essas duas substrings. Uma substring é simplesmente
um pedaço de uma corda. Portanto, a linha dois neste
caso é uma substring. linha um é uma subcadeia de caracteres, e o caractere de escape
n também é uma substring. Então, digamos que queremos
imprimir exatamente isso. Bem, você pode realmente escapar, escapar do personagem e fazer isso usando a mesma barra invertida. O que vai acontecer
é essa barra invertida. A primeira barra invertida dirá
ao Python que não leia
isso, pois o caractere de escape é um caractere especial simplesmente
como um, como uma string bruta. Então, se eu imprimi,
agora, você entendeu. Então é assim que você
pode escapar disso. Agora, há outra maneira de pular escapar
ou ignorar
um caractere especial. Então, se eu imprimir isso de
novo, recebo uma nova linha. Se eu digitar um R
antes dessa string, isso me dará
o mesmo resultado. Agora, eles são geralmente reservados para algo
chamado rejeição. Que é um tipo especial de expressão para
pesquisar cadeias de caracteres. Mas eles estão nesse caso, isso significa que essa
é uma sequência de linha. Isso significa que não
haverá interpretação de caracteres especiais. Ele será rho, simplesmente o que estiver dentro
da corda será
impresso como está. Então essa é outra
maneira de escapar disso. Portanto, isso é especialmente
útil
quando você está lidando com partes dentro do Windows, o caminho do arquivo pode ter
a seguinte aparência. Por exemplo, deixe-me criar uma nova variável. Um caminho de arquivo pode
parecer algo como C, dois pontos, traçar um caminho para um arquivo, ponto dx dy, por exemplo, aí está. Digamos que seja um caminho de
pasta ou arquivo. Então, algumas pastas ou
diretórios e, em seguida, nosso arquivo, se eu fosse imprimir
isso, imprimiria exatamente o que eu digitei. E a razão é porque
eu estou usando a barra para frente. Então esse foi meu erro. Desculpe por isso. Deixe-me mudar rapidamente
a barra invertida. Então, como você pode ver,
a barra para frente é totalmente segura de usar, mas a barra invertida será
interpretada de uma maneira diferente. Então você vê que meu, meu a foi alterado. Vamos nos transformar nesses personagens. Depois de path, temos
a aba que é t. Então a barra invertida F estava virando
para esse outro caractere. Isso claramente não é o que queremos. Então você poderia simplesmente
escapar desses personagens, mas você meio
que precisa adivinhar ou saber quais. Precisamos pular. R, não precisamos escapar do P-I. Precisamos escapar de t
e precisamos escapar de f. Então esse é o
resultado que queremos. Ou poderíamos usar cordas brutas. Basta colocar um RB bem atrás da corda e
obtemos o mesmo resultado. Portanto, as cadeias de caracteres são usadas
para muitas coisas, para acessar caminhos de arquivos, para criar variáveis, para declarar nomes ou
rotular coisas. Mas a operação mais comum
que você fará com cadeias de caracteres, ou uma das operações mais
comuns é chamada de concatenação, o que basicamente significa
juntar cadeias de caracteres. Então, deixe-me mostrar como
isso pode parecer. Vamos chamar isso de ter
uma variável chamada S. Vamos
iniciá-la como uma string vazia. E eu vou dizer que
S mais é igual a olá. E eu vou dizer isso aqui
embaixo que mais é igual espaço e o S
mais é igual a mundo. Agora deixe-me imprimir S. Agora diz olá, mundo. Então, o que está acontecendo aqui? Essa notação mais é igual a, isso é basicamente equivalente
a dizer S perdido, olá. Isso é o que está acontecendo aqui, é que obtemos o
valor anterior de S, que é uma string vazia, e adicionamos hello a ela. E então armazenamos isso. Basicamente, substituímos
a variável S. Então, aqui embaixo, isso será o equivalente a dizer
a mesma coisa novamente, pegue o valor anterior de S, que é o que acabamos de fazer. E, novamente,
contar histórias, ou seja, que basicamente substitui
essa mesma variável. Então, usando o sinal de mais, você pode juntar as cordas, mas há outras maneiras de
juntar as cordas. Uma das formas mais comuns, e eu diria que a
mais poderosa de concatenar cadeias de caracteres é usar a função de formato de pontos. Vamos ver como isso funciona. Então, vamos criar uma string. Deixe-me usar dois aparelhos ondulados, depois um sublinhado, depois um aparelho curvo
tumoral. Então, o que vai acontecer é esses colchetes se tornarão espaços reservados ou
substituirão algo. Agora, se eu fosse
imprimir S agora, obteremos exatamente isso, que é o
que acabamos de digitar. Mas se, em vez disso, eu faço o formato de pontos, esse formato é uma função
embutida em cadeias de caracteres. E eu passo duas variáveis,
digamos, duas sequências, olá e mundo novamente. Agora vamos imprimi-lo. Então, como você pode ver nesse
formato, usaremos os colchetes como espaços reservados para substituir por
qualquer coisa que eu coloque aqui. E isso pode ser algo, algo mais que não
seja uma string. Isso pode ser um número, por exemplo, se eu digitar o número 100
, esse formato será substituído. É inteligente o suficiente
saber que pode, pode fazer isso com cordas. Se eu adicionasse
usando o sinal de adição, uma string e um número 100, receberia um erro
porque o Python não pode concatenar uma
string e um número inteiro. Mas a função de formato de pontos
é inteligente o suficiente para saber disso. Outra forma de usar o formato de ponto é
usando variáveis. Podemos especificar variáveis
dentro dessas chaves. Posso dizer que a variável
um será alta. A variável dois será,
digamos apenas o número. Digamos que esteja entorpecido. Então, se eu executar isso agora, receberemos um erro porque ele vai
reclamar de um erro de chave porque basicamente não estamos
dizendo à função qual, qual desses dois
valores pertence a qual chave. Então, vamos corrigir isso. Posso dizer que
oi, olá será alto, então alto é igual a olá
e num será 100. Aí está. Então, isso significa que, como estamos usando esses argumentos de palavra-chave, isso significa que, mesmo que invertamos a ordem, você começará a trabalhar. Olá, cem. Agora, o que é muito legal
sobre isso é que você pode reutilizar as mesmas variáveis que
você tem aqui. Então, digamos que você queira dizer oi algumas vezes
nessa sequência. Você pode simplesmente dizer que não precisa
ser sublinhado. Vamos apenas colocar um espaço.
E eu vou usar a altura. Então, agora estamos substituindo
quatro lugares diferentes. Mas estamos usando
apenas duas variáveis. Então, a variável oi,
bem, basicamente colocamos
dentro desses espaços reservados. Se não tivéssemos essas
palavras-chave, o python reclamaria. Então, deixe-me voltar a como
tínhamos isso originalmente. Diga, olá. Cem. O Python reclamará
porque não fornecemos substitutos
suficientes para
esses espaços reservados. Então, nesse caso,
teríamos que dizer olá e olá, o que é muita digitação. Assim, você pode ver o poder
de usar as palavras-chave. Agora, há mais uma maneira de
usar a função de formato. E isso é usando,
usando índices. Então, deixe-me voltar
rapidamente para
apenas dois espaços reservados. Então, eu poderia fazer isso mais
uma vez e ele será
substituído em ordem. Mas eu poderia usar,
também usar índices. E o que esses números
representarão. Isso representará a ordem em que você coloca suas
variáveis aqui. E começamos a contar em zero da mesma forma
que fazemos com as listas. Você pode ver isso como
o mesmo resultado. Agora, se eu fosse
inverter esses índices, agora estamos invertendo a ordem. E agora podemos fazer a mesma
coisa com as palavras-chave. Posso dizer que quero
dizer olá aqui. Por lugar que colocou um índice zero. Vamos dizer olá novamente. Vamos colocar o número 100. Aí está. Então, mais uma vez, simplesmente usando duas variáveis, podemos misturar e combinar
usando os números do índice. Agora, deixe-me mostrar mais uma maneira de concatenar cadeias de caracteres. E essa é a maneira
clássica de fazer isso. Vou escrever sinais
percentuais s, vou deixar um
espaço e vou simplesmente digitar mundo. Agora, esse será
nosso espaço reservado. E para substituí-lo,
vou deixar um espaço, colocar um sinal de porcentagem e depois vou
digitar outra coisa. Vamos dizer olá novamente. Agora você pode ver que tudo o que eu
digitar aqui à direita
será substituído por este sinal de
porcentagem s. Por digite um número que
será substituído. Agora, eu também poderia fazer vários. Estamos vendo o seno S. Mas, neste caso, preciso
fornecer uma lista ou uma tupla. Então, vou usar uma tupla. Eu posso dizer olá. Planetas Palmer, neste caso. E cada um deles
será substituído por h, um desses itens na tupla. Então, todos eles meio
que dão o mesmo resultado. Minha preferência é usar o formato de
pontos porque ele
permite que você faça muitas combinações diferentes e oferece um
pouco mais de flexibilidade. Mas você pode escolher
o que funciona para você, dependendo do código
que está escrevendo. Agora, por baixo do capô, uma sequência de caracteres é um pouco
mais do que apenas uma sequência
de caracteres. É um objeto iterável. Isso significa que você
pode repetir isso da mesma forma
que fazemos com as listas. Então, deixe-me mostrar o que quero dizer. Deixe-me criar outra string. Vamos chamá-lo de Barcelona, por exemplo ,
agora, semelhante ou da
mesma forma que fizemos com as listas, eu posso. Forneça um índice usando
esses colchetes. E eu obtenho, se eu
fornecer o índice zero porque começamos a contar em
zero, obtenho a letra b. Se eu fizer o índice número dois, obterei o pequeno r
porque é o segundo índice. Se eu pedisse meu
índice menos um, que é o último índice da lista ou, neste
caso, a string. Então eu vou pegar a letra a. Agora, pela mesma lógica, podemos iterar sobre a
string usando um loop for. Então, podemos dizer por ins, imprima i, e ele imprimirá cada uma
das letras dessa sequência. Então, por baixo do capô, uma string é mais parecida com
uma matriz ou uma lista. Acontece que cada item dentro
dele é um personagem. E também é especial porque
podemos fazer
tipos específicos de operações, assim como vimos com a
concatenação e outras. Operações específicas que
são incorporadas para cadeias de caracteres. Então, deixe-me mostrar algumas
dessas operações. Uma coisa que você pode
fazer com cadeias de caracteres é verificar ou substrings. A substring é
basicamente uma parte de uma string ou
algo que você esperaria que estivesse
dentro de uma string. Deixe-me renomear essa string
variável. Deixe-me criar uma nova
variável chamada sub string. Vamos chamar, vamos
fazer essa substring, ter a substring, é um empréstimo ou caída
nesse caso. Então, posso usar a
palavra-chave in para fazer uma comparação. Eu posso dizer sub-string
em uma string. Portanto, esta operação me
dará um booleano. Nós diremos verdadeiro se a substring estiver nessa
string ou falso se não estiver. Então, deixe-me armazenar esse resultado
em uma variável chamada resultado e imprimir esse resultado. Aí está. É verdade porque a substring
está dentro de Barcelona. Agora Barcelona não tem um
H. Então deixe-me ver isso. Não há h em Barcelona, então eu recebo parafusos. Outra forma de verificar se
há subcadeias de caracteres é com uma função embutida em
cadeias de caracteres chamada start with. Então, deixe-me
me chamar de bar de agitação. E deixe-me substituir essa
operação por uma string que começa com substring. Então, isso verificará se a string Barcelona
começa com barra. Mais uma vez, obtemos um
booleano a partir disso. Isso é verdade. Se eu
substituí-lo por alto, por exemplo , ele dirá falso
porque não começa com isso. Agora, observe que isso
também diferencia maiúsculas de minúsculas. Então, se eu usar a barra minúscula, você dirá falso porque ela
não é instalada com isso. E há a extremidade oposta
dessa equação
que termina com. Agora, deixe-me fazer isso. É falso porque Barcelona
não termina com bar, mas Barcelona termina com NA,
por exemplo, então isso será verdade. Portanto, essas são duas
funções integradas para cadeias de caracteres. Você também pode alterar
a caixa em uma corda. Existem dois outros pontos
embutidos. Há muitas
funções integradas para cadeias de caracteres, mas estou apenas mostrando as
mais comuns e úteis. Outro é o Opera. Isso transformará sua
string em maiúscula. Então, vamos desenhar isso
na mesma variável. O Opera estará em maiúsculas e minúsculas farão o oposto,
que é minúsculo. Então, nesse caso, há
apenas uma letra maiúscula. Então, isso transformará isso
em minúsculas, em minúsculas. E pela mesma convenção, existe uma função
chamada título. Isso fará com que sua string tenha a
forma de um título. Isso é muito útil para
coisas como FirstName, por exemplo se quisermos dizer John Smith, título que cada
letra maiúscula ou cada primeira
letra na string. É inteligente o suficiente
saber sobre espaços. Por exemplo, terá uma letra maiúscula. Como mencionei, há muitas funções
integradas em cadeias de caracteres, mas
deixe-me mostrar mais algumas. Antes de encerrarmos isso. Você pode substituir
partes de uma string. Você pode dizer string dot replace. Essa função receberá
dois argumentos. A coisa que você deseja substituir, digamos que queiramos
substituir esse sobrenome. E a substring que você
deseja substituir por essa largura. Digamos que vamos
substituir isso por Williams, por exemplo, substituir isso. Isso é muito útil para remover
coisas como espaços, por exemplo, se você quiser substituir um espaço, pode digitar um espaço. Apenas elimine o espaço. Você pode substituí-lo por
uma string vazia, por exemplo, e eu simplesmente
eliminarei o espaço. A última coisa
que quero mostrar é como dividir as cordas. Então, vamos imaginar que
queremos dividir o nome por sinal,
esse espaço aqui. Vamos usar essa função de divisão. E como primeiro argumento, ele usará o personagem pelo qual
você deseja se dividir,
que é um espaço. Então, vamos dar um espaço a ele. Vamos executar o código. Então eu recebo uma string,
desculpe, eu recebo uma lista. Tenho que listar
tudo o que foi antes e depois daquele espaço. Agora, se eu tiver mais espaços, digamos que eu digite outra
coisa aqui. Agora temos três espaços, o que significa que temos
quatro seções. Agora, se não houvesse
nenhum espaço, ele não encontrará nada
para dividir. Então, ele simplesmente
me dará a mesma string, a string original,
mas como uma lista. E isso funcionará com qualquer personagem com o qual você
escolher se separar. Digamos que eu tenha alguns períodos e queira
dividi-los usando eles. Agora eu recebo as mesmas
quatro seções. Agora, há mais um argumento
que essa função aceita, que é o número de ocorrências que
você deseja dividir. Então, por padrão, eles
farão todas elas. Cada período
encontrado
neste caso
será dividido. Mas posso pedir que você
simplesmente faça o primeiro, por exemplo, ele dividirá o primeiro
e depois ignorará o resto. Eu posso pedir que ele faça apenas dois. E aí está. Os dois primeiros serão
divididos e o último, vamos ficar como está. Então, esta foi apenas uma breve
introdução às cordas. Há muito mais
que você pode fazer com eles. Eu realmente encorajo você a
experimentar e brincar com eles. E eu também
recomendo fortemente que você leia a documentação
on-line do Python, há muitas coisas lá dentro. Mais uma vez, essa foi apenas
uma introdução simples, mas mostrei o que
eu acho que são algumas
das operações mais comuns que você pode fazer com
cadeias de caracteres que o
ajudarão na codificação do
dia-a-dia. Então, espero que você esteja
mais familiarizado com as cordas e espero que
tenha
ficado claro que você se sentirá muito mais confortável
trabalhando com elas.
31. Mergulho profundo - Loops: Tudo bem, vamos aprender mais
sobre loops em Python. um loop basicamente significa fazer algo várias vezes
repetidamente. Há dois tipos principais
de loops em Python. Um deles é um loop for, outro é um loop while. Então, vamos passar
pelo loop for. Aluno da primeira série por ciclo. É muito fácil. Você usa
a palavra-chave para você. Diremos para algo
ou para cada item. Então, digamos que para o item na lista, vamos criar uma lista. Vamos apenas ter uma
lista de números, 12,3, e então você tem dois pontos. E então, dentro desse loop,
você tem esse recuo. Dentro desse loop, você fará algum
tipo de operação. Então, agora, vamos imprimir o item, por exemplo, deixe-me fazer isso. Então, como você pode ver,
estamos imprimindo 123. Então, o que está acontecendo é que estamos basicamente dizendo que
cada item dentro dessa lista será armazenado dentro dessa
variável chamada item. Agora eu escolhi essa variável, você pode chamá-la de outra coisa. Normalmente você verá
algo como I. Então, para I na lista,
podemos imprimir I. Aí está. Então, o que isso está fazendo é simplesmente examinar cada
um deles e substituí-lo pelo valor
desse item dentro da lista. Vamos mudar isso um
pouco e dizer 12,3. Agora, mesmo resultado. Agora, digamos que queremos
imprimir os números de 1 a 100. Portanto, há uma função chamada intervalo que basicamente
fornece uma variedade de números. Digamos que queremos 100 números. Vamos imprimir I na faixa 100. Vamos imprimir algo
que aconteceu, estamos recebendo 99. Vamos ver o porquê. Na verdade, vamos tornar essa
chave um pouco menor. Digamos que cinco, por exemplo, estamos obtendo os números de 0 a 4. Isso ocorre porque
a função de intervalo começa a contar em zero. Nós poderíamos consertar isso. Poderíamos dizer que
poderíamos usar uma chave inglesa real. Se você
passar apenas um único número, ele começará a contar de zero até o número anterior, aquele número
que você forneceu. Mas se fornecermos de
1 a 5, nesse caso, obteremos de um a
quatro porque esse número, o segundo número,
não é, é exclusivo. Isso significa que você
precisa adicionar um para chegar
ao número desejado
do intervalo desejado. Então, se dissermos que o intervalo de um a seis realmente
nos dará de um
a cinco, pode ser um
pouco confuso, mas é assim que essa
função funciona. Há razões para
isso, é claro, mas você realmente só precisa saber
que é assim que funciona. Excelente. Então, a filial nos
dará de um a cinco. Agora, se você quiser ver
o que as chaves estão realmente fazendo, tudo o que estão fazendo é criar
uma lista desses números, ainda
estamos simplesmente
trabalhando com uma lista. Excelente. Então, estamos armazenando esse valor de cada um desses números
na variável I, mas isso não significa que
precisamos usá-la. Digamos que queiramos
imprimir olá amigo 100 vezes. Podemos simplesmente dizer: dê-me um intervalo de 100 números. Eu não me importo com o que eles são
porque eu não preciso deles. Eu só preciso que a lista
seja capaz de repeti-la 100 vezes e imprimir
essa string 100 vezes. Olá, imprima, aí está. Mas também poderíamos fazer
um pouco de matemática. Poderíamos dizer Oi vezes dois, por exemplo, para que cada item no intervalo
seja multiplicado por dois. Nós imprimimos isso. E aí está. Então você obtém esse resultado.
Portanto, o for-loop usará um objeto iterável, algo pelo qual ele
pode iterar. Geralmente pode ser uma lista de LEDs, pode ser uma tupla
também, por exemplo, em vez de uma lista,
vamos criar uma tupla, que é como uma lista, mas
você não pode modificá-la. Então, ele o imprimirá três vezes. Ou também podemos
usar uma string, por exemplo podemos dizer a, b, c, d. Podemos, podemos iterar
sobre uma string. E o que vai acontecer? Deixe-me imprimir r neste caso, pois ele simplesmente
passará por cada um desses caracteres
na string. Pela mesma lógica,
podemos realmente imprimir quisermos e
usar essa string como a, como a coisa que nos
dará o número de loops que
faremos com nosso for-loop. Então é assim que o loop
for funciona. Agora, o loop while não
pega algo que você pode, um objeto sobre o qual eu
possa iterar, ele exige uma condição. Então, o que isso quer dizer é: enquanto uma condição é verdadeira, enquanto algo é verdade. Faça algo dentro
desse loop. Então, neste caso, eu poderia imprimir mais
uma vez, olá amigo. Agora, se eu fizer isso, se eu executar esse código agora, inseriremos algo
chamado loop infinito. Isso porque a verdade sempre
será verdadeira. Portanto, isso nunca interromperá algo que você precisa levar em consideração. E você deve ter cuidado com isso ao
usar loops while, precisa se
certificar de atualizar sua condição em algum momento. Então, vamos fazer algo
que possamos atualizar. Digamos que queremos
começar a contar números. Começaremos a contagem em zero. E vamos dizer que,
embora a contagem seja menor, desculpe. Enquanto contar, sim, enquanto a
contagem for menor que cinco,
por exemplo, imprima olá amigo. Agora, como na série atual, esse código
será executado para sempre novamente. Será outro loop
infinito porque contagem desses casos
sempre será menor que cinco. A menos que eu atualize minha variável. Posso dizer que contar é igual a
contar mais um. Basicamente, estou adicionando
um à contagem. Toda vez que terminarmos, faremos um loop,
entraremos nesse loop. Então, o que vai acontecer aqui é que o loop inteiro
verificará a contagem, contará menos de cinco. Sim. Então faça essas operações aqui. Agora, depois de imprimir olá amigo, vamos adicionar um para contar. Isso fará com que a conta
seja uma, certo? Então, vamos
entrar no loop novamente, ou o loop while
verificará novamente se contagem
é menor que cinco? Sim, imprima olá amigo. Em seguida, adicionaremos mais
um para contar, e assim por diante
até chegarmos a cinco. E então o loop while
verificará sua contagem menor que cinco. Não. Em seguida, ele sairá e continuará com
o que estiver após o loop. Então, deixe-me imprimir algo
depois do loop. Só para deixar esse exemplo
um pouco mais claro. E vamos simplesmente executar esse código. Deixe-me limpar minha janela
de saída aqui. Vamos executar esse código. Como você pode ver,
nada aconteceu. Por que isso? Bem, porque eu esqueci de reiniciar a conta porque a
contagem é cinco. Então, o pacote cumulativo
está perguntando se conte menos de cinco? Não, na verdade
não faz nada. E vai direto para a
impressão do loop inteiro. Então, vamos colocar a contagem de volta em zero e executar o código novamente. Aí está. Agora estamos imprimindo
olá amigo 12345 vezes e depois saímos. Então, vamos verificar essa variável
de contagem. Você pode ver que vai de 01234. A última vez que ele será
executado será cinco, que significa que o
loop não entra. Excelente. E então imprimimos o, o que vem depois do loop. A propósito, eu posso, posso tornar essa linha de
código um pouco mais simples. Mas dizer que dizer
mais é igual a um, isso é uma forma abreviada
de dizer simplesmente adicione um a essa variável e
ela funciona da mesma forma. Então, esses são loops inteiros. Mais uma vez, eles trabalham
com essa condição. Portanto, você deve ter o
cuidado de atualizar essa condição toda vez estiver dentro do loop while. Caso contrário, você
correrá o risco de criar um loop infinito, o que basicamente
travará seu aplicativo. Porque depois de um tempo, ele
ficará sem memória ou entrará em algo
chamado falha de segmentação, o que significa que ele está
tentando acessar uma
memória à qual você não deveria
ter acesso, então simplesmente travará. Não é o fim do
mundo, acontece com todo mundo, vai
acontecer com você em algum momento. Você só precisa
reiniciar seu trabalho. Portanto, a maneira de interromper
o loop while é novamente usando a condição. Mas há outra maneira
de interromper o ciclo completo. Digamos que, por algum motivo, queiramos
parar na conta. Se a conta for igual a três, queremos parar. Então, poderíamos simplesmente dizer que se a contagem for
menor que quatro, pare. Mas também podemos dizer se a
contagem é igual a três pausas. Agora vamos executar isso. Aí está. Então, agora
estamos parando às três. Então você pode estar pensando que isso
significa que não
precisamos da condição. Poderíamos simplesmente dizer: Embora seja verdade. Execute tudo isso. Se a contagem for igual a 33, simplesmente
quebramos. Agora, enquanto ainda estivermos incrementando a
variável de contagem, isso funcionará. Agora isso é estranho. Esse não é realmente
um bom loop de tempo, mas estou apenas usando isso como
um exemplo para mostrar a você. Tecnicamente, isso
deve durar para sempre. Mas a pausa, essa declaração de pausa,
basicamente sairá do circuito. Vamos ver isso em ação. Aí está. Imprimimos e imprimimos
olá amigo três vezes. Isso porque removi minha instrução de impressão para
a variável count. Deixe-me adicionar isso.
Portanto, não queremos 0123 e simplesmente paramos. Então não, não
imprimimos três depois disso. Agora podemos usar a
mesma instrução break para interromper o ciclo ascendente. Então, deixe-me repetir 100 números novamente
para I no intervalo 100. E vamos imprimir isso. Eu deixo, deixe-me fazer 20, para que não
demore muito. Então, vamos imprimir a
partir dos números de 0 a 19. E então
imprimiremos essa string. Ele trocou isso para dizer. Então, se quisermos interromper o ciclo
for em um número de resort, podemos dizer se I
é igual a dez,
por exemplo, podemos quebrar. Aí está. Então, quando chegarmos a nove, o próximo eu serei dez, e então
saímos do circuito. Então, essa é outra maneira de colocar
um ponto final no circuito. Outra
palavra-chave muito útil é a chave, essa declaração, e é uma declaração
contínua. Agora, isso vai funcionar
tanto para loops quanto para loops while. O que a
instrução continue
faz é interromper a
execução do código
nesse ponto , voltar
ao loop e entrar na
próxima iteração do loop. Então, o que essa inclinação deveria estar
fazendo
é um sprint a
cada número 0-19. Mas vamos verificar se I é que a
iteração atual é dez, continue, o que significa que não
vamos entrar
nessa declaração de impressão. Então, vamos ver como isso funciona. Lá vamos nós. Vamos para 01 234-567-8910
e vamos para 11. Agora, vamos tornar isso um
pouco mais óbvio. Digamos que só queremos
imprimir números
divisíveis por dois. Então, digamos que se eu módulo
dois não é igual a zero, isso significa que o número não
é divisível por dois. Vamos continuar
na próxima iteração, não imprimir esse número. Aí está. Portanto, temos 0246810. Você vê que basicamente
todos os outros números são ignorados porque
não são divisíveis por dois. Agora, isso
equivale a dizer que se o número é
divisível por dois, se eu módulo dois, o resultado disso é zero. Aluguel. Caso contrário, eu não faço nada. Sim, você pode ver que
é o mesmo resultado. Portanto, é o mesmo resultado. Estamos apenas usando a instrução
continue para reverter essa lógica. E você pode estar se
perguntando por que, por que fazemos isso? Bem, imagine que você queira continuar escrevendo
algum código aqui. Então, mais código e,
em seguida, mais e mais. Portanto, isso permite que você
não
precise lidar com
a indentação e simplesmente fazer uma verificação
rápida para interromper
a execução do código
em qualquer ponto que você quiser. E volte e passe para
o próximo item, seja qual for a doença, neste
caso, é uma lista de números. Então aí está. Para loops e while loops, são conceitos muito simples, basta fazer algo
repetidamente. Mas eles são extremamente
úteis, extremamente poderosos e você os usará
bastante em sua jornada de codificação.
32. Mergulho profundo - listas, tuplos, conjuntos: Vamos falar sobre listas. As listas são uma coleção
de objetos. E o que quero dizer com objeto é
qualquer tipo de objeto Python. Pode ser uma string, pode ser uma função,
um número inteiro, um float. Pode até ser outra lista. Você pode ter listas aninhadas umas
nas outras. Eu vou te mostrar isso. E eu também queria falar sobre dois outros tipos que
são tuplas e conjuntos. Então, vamos falar
sobre esses três. Todos esses três
podem ser vistos como semelhantes, pois todos eles armazenam uma
coleção de objetos. E o que você pode fazer
com tuplas e conjuntos. Você também pode
fazer isso com listas. Na maioria das vezes, você
pode simplesmente usar listas. E eles são realmente um
dos tipos de dados mais usados em Python para lidar com
coleções de objetos. Assim, você pode se limitar a
menos do que pode realizar. A mesma coisa que você pode fazer com um parafuso e conjuntos. Dito isso, nos bastidores, eles se comportam de
maneira muito diferente e têm casos de uso
muito exclusivos. Então, deixe-me começar com listas e depois vamos
entrar em tuplas e conjuntos. Vamos criar nossa lista. Há duas maneiras
de criar uma lista. Vou criar uma
variável chamada mylist. Agora, eu propositalmente não estou
chamando minha lista de variáveis porque list é o tipo de
lista real no Python I, e eu não
quero substituir isso. Eu vou te mostrar
isso em um segundo. Então, vou
chamar isso de minha lista. E eu vou
criar a lista. Então, para criar um alias, você usa colchetes e depois separa seus
itens por uma vírgula. Então, de repente, eles
forneceram números. Medidor da Irlanda
, corra aquela MyList. Aí está. Agora, a outra forma de
criar uma lista é
colocando algo em uma lista. Da mesma forma que você pode fazer isso com strings ou com um número inteiro, por exemplo, existe um tipo de lista e você pode colocar algo
dentro de uma lista. Então, como você já deve saber, nos bastidores, as sequências de caracteres
se comportam como listas. Então, podemos realmente converter
uma string em uma lista. Vamos
armazená-lo em uma variável chamada a. Eu só
vou trazer isso. O que vai acontecer é
que a string será dividida em suas partes, em sua característica, e
o resultado será uma lista. Então, essas são duas maneiras
de criar uma lista. É por isso que estou evitando
chamar minha lista de variáveis. Porque se eu fizesse isso, eu simplesmente estaria ignorando isso e, em seguida, ele estaria
essencialmente quebrado. A propósito, existem maneiras de corrigir
isso:
deixe-me mostrar que, se eu fizer isso, receberei um
erro porque agora
basicamente anulei a funcionalidade dessa palavra-chave
da lista. Se isso acontecer com você, você pode dizer excluir lista. Eles listarão. E agora eles devem estar funcionando novamente porque podemos
redefinir essa funcionalidade. Ótimo. Então, o que
podemos fazer com as listas? A primeira coisa que podemos fazer
com as listas é
percorrê-las ou repetir
sobre seus membros. Então, podemos dizer “I” na lista, imprimir “I” e aí está. Podemos acessar cada um de
seus membros simplesmente
usando um for-loop. Isso será algo
muito comum. A
propósito, você estará fazendo um loop sobre listas. Mas você também pode verificar se algo está dentro da nossa lista. Podemos dizer que vamos criar
uma variável chamada resultado. E digamos, vamos verificar
se o número dois está na lista. Para se alistar. Podemos imprimir o resultado. Aí está. Portanto, essa verificação nos
dará um booleano, verdadeiro
ou falso. Também podemos usar isso em uma declaração
if. Podemos dizer se dois estão na minha lista. Vamos simplesmente imprimir a lista. Agora, se verificarmos se
há algo mais, digamos que o número dez, que não esteja na lista. Não imprimirá nada.
Então, digamos, vamos adicionar outra declaração
e dizer imprimir, não na lista. Ótimo. Agora, como mencionei, sua lista pode ter
qualquer tipo de objeto. Você pode ter números,
você pode ter uma string, você pode ter flutuadores. Por exemplo, você pode até ter uma
lista dentro dessa lista. Então, deixe-me criar outra lista
com apenas dois números. Na verdade, vamos dar uma olhada nessa lista. Ou na minha lista. Oi. Aí está. Então, como você pode ver, temos
essa string e até a lista dentro
dessa outra lista. Verificar se algo
está dentro da sua lista será muito útil. Mas você também pode obter itens
de dentro da sua lista. Então, deixe-me criar uma lista mais simples porque essa ficou
um pouco confusa. Deixe-me adicionar três sequências, 1, s, e então apenas o número
três, que compõe tudo. Então, para obtermos um
item de uma lista, fazemos isso usando o índice, seja, usando
os colchetes. Deixe-me explicar os índices
de uma forma mais visual. Então imagine que você tem
sua lista aqui. Digamos que temos uma lista
com quatro itens. Cada item tem um índice, e tudo está basicamente em
ordem da esquerda para a direita, e começamos a contar até zero. Agora, isso pode ser
confuso às vezes, mas o primeiro item
na lista é o número de índice zero
é o item zero. O segundo será um. O terceiro será
pagar um será três. Agora, há outra maneira de obter índices usando números
negativos. Então, deixe-me desfazer isso. Deixe-me colocar esses índices
na parte inferior aqui. Podemos fazer isso
na ordem inversa. Podemos dizer que o último
da lista será
índice menos um. Então, o
penúltimo será menos dois. O terceiro último menos
três. Menos quatro. Não começamos do zero
porque não podemos dizer menos zero, é claro. Então, se você quiser obter o primeiro índice ou o
primeiro item da lista, basta dizer zero. Se você quiser obter o
último item da lista, você pode saber
qual é o último índice, que seria o número de itens na lista.
Nesse caso, é quatro itens menos um porque
começamos a contar em zero. E esse será
seu último índice, que será o último item. Ou você também pode
simplesmente digitar menos um sem saber
quantos itens estão na lista. Então, vamos voltar ao nosso código para obter os
itens usando os índices. Usamos a notação de
colchetes. E dentro desse
colchete, colocamos o índice e queremos,
então, se quisermos nosso elemento, deixe-me armazená-lo em uma variável. Na verdade, deixe-me
imprimi-lo diretamente. Vou imprimir o
primeiro elemento da lista, que será a string 10. Se eu quiser o segundo elemento, ele será o primeiro número de
índice, um por um. O terceiro
será o índice número dois. Agora, se eu examinar os índices, digamos que eu queira o quarto, mas não há
um quarto na lista, então eu vou receber
um erro dizendo que o índice é rico em ferro. Agora, pela mesma lógica
que acabei de mostrar,
você pode obter o último, que será menos
um, ou seja, três. Vamos para o
penúltimo, que será menos dois, e assim por diante. Existe uma, existem duas maneiras de conhecer
os limites da sua, chegar ao limite ou
até o final da sua lista. Isso é, obviamente,
obter, obter
apenas o último item usando o índice menos um. Mas você também pode verificar
o tamanho da sua lista. Posso dizer que posso usar a
função chamada Len L-E-N. Passe minha lista para ela. Deixe-me imprimir o comprimento do resultado. Isso me dará três, porque há
três itens na lista. Se eu adicionar mais um, agora serão quatro. Portanto, você também pode usar isso para
obter o último item ou simplesmente para saber
quantos itens estão esperando. Porque às vezes
você tem uma lista com centenas ou milhares de itens e nem sempre consegue
acompanhar isso. Portanto, essa é uma maneira de sempre
consultar isso, esse valor. Então, o que podemos fazer
agora é dizer minha lista. Para obter o último item, posso obter o comprimento menos um porque estamos começando
a contar em zero. Então, isso nos dará quatro. Aí está. Você também pode obter não apenas
um item da lista, Bora, um pedaço de itens da lista que você pode,
é chamado de fatiamento. Você pode dividir sua lista e obter uma parte dessa lista como uma cópia para que eu
mostre como isso funciona. Para isso, também usamos a notação de colchetes e também usamos índices que
começam a contar em zero. Mas agora, como
estamos usando um intervalo, usamos os dois pontos em dois pontos
dentro dos colchetes. Então, vamos solicitar: Vamos
pegar uma cópia ou vamos obter uma lista de listas que são os
três primeiros itens da nossa lista. Isso significa que queremos do índice
zero ao índice número dois. Então, vamos solicitar
do índice zero como o primeiro índice e
passar para o índice número dois. Agora vamos armazenar isso em
uma variável chamada range. Agora, propositalmente, não estou
chamando essa variável de chave inglesa porque existe
outra função chamada range e ela está
embutida no Python. Deixe-me te mostrar bem
rápido, mas isso funciona. Isso é chamado de chave inglesa. E vou solicitar
um intervalo de cinco números. Então, ele me dará uma lista
de cinco números de
zero a quatro, porque
começamos a contar até zero. Então, se eu chamasse
esse intervalo variável
, eu o estaria substituindo. E geralmente não, não
é um problema. Se
eu realmente não preciso a função range em meu
código não é um problema, mas geralmente é recomendável
não substituí-la. As funções integradas são tipos
integrados em Python. Então, vamos voltar ao nosso corte. Deixe-me imprimir em laranja. Então, mais uma vez, estamos
solicitando do índice zero até o índice dois. Então, devemos obter esses três itens que, logicamente
, fazem sentido, certo? Mas nós fizemos isso. Nós temos os dois primeiros. A razão para isso
está nesse corte, o primeiro índice que você
fornecer será incluído. Mas o segundo índice que você fornecer não será inclusivo, mas será exclusivo,
o que significa que você obterá tudo até o
item anterior ao índice. Então, se quisermos obter o terceiro
item que é o índice dois, temos que adicionar um a isso. E agora conseguimos o que queremos. Às vezes, isso pode ser um pouco
confuso. E há, é claro, vários motivos pelos quais
isso funciona dessa maneira. Mas com a prática, isso
se tornará uma segunda natureza para você. Há mais um elemento
que podemos adicionar ao corte, que é a etapa. Se adicionarmos outra coluna
aqui entre colchetes, por padrão, sua etapa será
uma e a etapa é
como retornar a cópia da lista que
você está solicitando. Por exemplo, deixe-me fazer isso. Portanto, por padrão, essa etapa é uma, o que significa que
obteremos todos os itens da faixa solicitada. Se eu fizesse a segunda etapa, basicamente
obteremos
cada segundo item. Então também é assim que você
pode lidar com esse corte. Algo que eu também queria
mostrar é que você não precisa
necessariamente fornecer
índices por padrão. Se você não souber, se você
não fornecer um número de índice. Em primeiro lugar aqui, esse será o
primeiro índice. E, por padrão, esse
será o fim da lista. Então, se eu simplesmente fizesse isso, obteria uma cópia
da lista com
cada elemento nela. Aí está. Agora, se eu dissesse que quero tudo, exceto o primeiro, eu poderia começar no
índice um e deixar este no segundo vazio e simplesmente acender a luz
no final da lista. E o inverso é o mesmo. Podemos simplesmente digitar
três e
subiremos até o
segundo índice da lista. Ok, vamos falar sobre uma
das principais propriedades das listas. Algo que torna uma lista muito única é que elas
são imutáveis. Agora, o que significa mutável
é que eles podem ser modificados no local. E há algo
que você precisa ter cuidado com essa
propriedade e ter isso em mente. Então, deixe-me criar uma lista vazia, esses colchetes,
que é uma lista vazia. E deixe-me acrescentar
algo a essa lista. Para adicionar algo à lista, você pode acrescentar pontos. Vamos adicionar uma sequência de caracteres mais simples. Eu posso, digamos que um. E vamos imprimir esse
resultado. Está impresso. Então, vamos imprimir uma lista. Antes de adicionarmos um número, estamos antes de adicionar um elemento e depois de
adicionar o elemento. Depois de esclarecer isso,
executamos o código novamente. Então, como você pode ver, primeiro
obtemos uma lista vazia. E então temos essas listas
com um único elemento. Isso faz sentido, certo? Agora. O que acontece se eu adicionar outra variável e
atribuir a a a essa variável? Agora, vamos imprimir
a e B. A e B. Vamos adicionar algo a a, e vamos imprimir a e B novamente. Então deixe-me, vamos imprimir, vamos dar uma pequena etiqueta. Então, sabemos qual
é qual, digamos B, B. E vamos fazer o mesmo aqui em cima. Mais uma vez, estou
criando uma lista vazia. Estou atribuindo essa variável entrelaçada
chamada a. E então eu crio uma
variável chamada B e atribuo a a B. Até agora
tudo bem, certo, então tanto a quanto B devem ser
essencialmente listas vazias. Então eu imprimo esses centralistas. Deixe-me limpar minha janela de saída. Em seguida,
paro por um segundo e penso no
que você acha que
acontecerá quando imprimirmos
a e B novamente. Agora a tem, tem um
elemento nele. Mas o que está acontecendo? Interessante. Portanto, a e B no início estão vazios, e então a e
B têm um elemento. Agora, vamos deixar isso
ainda mais claro. Agora vou acrescentar
algo para ser. Só vou apontar para isso, desculpe, uma sequência que diz dois. Vamos imprimir isso novamente. Portanto, tanto a quanto B são iguais. Isso é estranho porque você
pensaria que a e B
seriam independentes. Agora, isso é algo que
você deve considerar
com muito cuidado ao usar listas pois elas podem
pegá-lo de surpresa. É chamado de ponteiro. Sempre há um ponteiro na memória para a lista
que você criou. Então, a se torna um ponteiro de lagoa. E o que quer que você faça com a, mesmo que você a atribua a
b, b basicamente
não é uma lista nova. B está apontando para a. Então, o que quer que aconteça com a
será refletido em B. Porque B está simplesmente voltando
para o ponteiro original a. Isso é muito útil
porque permite que você
acompanhe muitos dados, modifique,
modifique seus dados
em qualquer lugar que quiser e ainda tenha a mesma
lista de elementos na memória. Mas pode ser confuso
se você espera que duas listas diferentes funcionem com duas listas
diferentes. Agora, para corrigir isso, se você
quiser duas listas diferentes , basta
criar duas listas vazias. E então isso é o que
você esperaria. Agora, a e B estão
se comportando separadamente. Então, isso é mutabilidade. Como você viu, estamos
começando com
uma lista vazia e depois
a modificando. Isso significa que podemos adicionar coisas a ele
anexando coisas a ele. E isso também significa que podemos
remover coisas da lista. Vamos voltar para uma única lista
vazia chamada a. Vamos, na verdade, não, não
vamos deixá-la vazia. Vamos colocar algumas
cordas dentro dela. Então agora a tem duas cordas. Podemos remover coisas de mim usando a função Remover. Vamos remover dois e
depois imprimir. Ok. Aí está. Então, agora a só tem
11 cordas. Agora, se você tentar remover algo que não está
na lista, por exemplo, remover essa string três, ocorrerá um erro
porque diz que x, que é o que você está
tentando remover, não
está no símbolo da lista. Verifique. Ou uma maneira simples de evitar
esse erro é dizer se há três em uma lista removê-la,
caso contrário, não faça nada. Então, digamos que, em vez disso,
queremos remover um. Aí está. Agora um se foi. Quero mostrar mais
duas funções que são muito úteis em uma lista. Então, vamos voltar à nossa
lista a e digitar. Vamos adicionar
mais algumas sequências de caracteres a ele. Isso é um zero. Adicione um nome,
digamos que John sample. Você pode encontrar o
índice no qual você um elemento que
está procurando se houver uma função
chamada index. E você passa o elemento
que está tentando encontrar. Por exemplo, se estivermos
procurando a string zero, mesmo que
seja chamada de zero, ela não estará
no índice zero, certo? É o índice número dois porque é o terceiro
elemento da lista. Mas se você não
soubesse disso, você poderia consultá-lo. Você poderia dizer, ok, índice zero. Vamos desenhar esse resultado em
uma variável chamada resultado. E imprima. Aí está. Número dois, se eu perguntar por John e obtivermos o
índice número três. Agora, se eu pedir outra
coisa, algo que não existe, recebemos o mesmo erro porque algo não
está na lista. Nesse caso, também
faríamos uma declaração if para verificar se algo está em a e, em
seguida, faríamos isso de forma
semelhante, da mesma forma que
fizemos antes. Agora, a última função que
eu quero
mostrar é semelhante a append. Uma lista menor que esse
caso, um ponto acrescentado. Adicionaremos um novo item à
lista no final da lista. Então, se eu fizer isso e imprimir um, você verá que o novo item
estará no final. E se eu quiser
adicioná-lo no início? Existe outra
função chamada Inserir. E então você fornece
o índice no qual
deseja inserir e, em seguida, os itens. Então, eles inserirão o
novo item no início. Agora, se você quiser
em segundo lugar, digamos que queremos depois de um. Então podemos dizer, ok, insira no índice número um. E agora será um e depois o novo item e depois
o resto da lista. É assim que você
pode inserir as coisas, o que quiser na lista. E pelo mesmo método, outra
coisa que eu poderia mostrar é que você pode remover coisas da lista por índice. Então eu te mostrei lá,
remova a função remota, que removeria um
item usando seu nome. Então, nesse caso, removeremos
a string chamada one. Mas se você quiser
remover por índice, você pode usar a
função chamada pop. Por padrão, pop removerá
o último elemento da lista. Então, nesse caso, o último
elemento da lista é john. Pub removerá John. Nós estouramos duas vezes, removemos John e depois removeremos zero. Portanto, devemos ficar
com esses dois elementos. Aí está. Mas agora você também pode passar
um argumento para pop, e esse será o índice. Digamos que você queira remover o primeiro elemento,
que é essa string. Isso diz uma coisa,
o índice zero. E agora trabalhe com isso. Então, se você quiser remover
dois dos primeiros elementos, os dois primeiros
elementos da lista. Você pode fazer pop duas vezes
com o índice zero porque na primeira vez que ele
removerá o número um, ficamos com isso, essa lista. Agora, o primeiro item
será escrever, então colocamos zero novamente e dois, ou
seja, agora o primeiro
item desaparecerá. Então, agora ficamos com
zero e John, ligado. Lá vamos nós. E, claro, pela mesma lógica, você poderia simplesmente remover, digamos que quiséssemos remover
essa string que é duas. Estouramos o índice número um e ficamos com esse resultado. Tudo bem, antes de encerrarmos isso, eu queria
te mostrar algo que pode ser confuso para algumas pessoas. Ter uma lista dentro de uma lista. Porque, como mencionei,
qualquer coisa pode ser colocada dentro de uma lista
, incluindo outra lista. Então, deixe-me ir em frente e fazer isso. Digamos que temos uma lista com um elemento e depois temos outra lista com
outro elemento. Então, o que está acontecendo aqui? Nossa lista principal. Assim, você pode ver
nesses colchetes que há dois elementos, e cada um desses
elementos é uma lista. E se eu quiser
acessar a primeira lista? Muito simples. Eu simplesmente digo, ok, me
dê o primeiro
item da lista a. E esse item, é claro, será a lista que contém
essa string que diz um. Agora, e se eu quiser obter o primeiro item dessa lista? Você pode simplesmente seguir
a mesma convenção. Você pode obter o primeiro
item dessa lista, e agora esse será um. Agora, se eu fosse modificar, deixe-me modificar
essa lista para sua lista inicial. Eu coloquei três itens nele, apenas três números, 12,3. O que você acha que
vai ser impresso? Isso? Imprime um. Agora, e se eu
quisesse o número dois? Então eu recebo, estou recebendo o, eu tenho que pegar a primeira lista
na Lista Principal,
ignorando o índice zero. E depois de obter essa lista, quero obter o primeiro
item dessa lista,
que será esse número
dois. E aí está. Agora, e se eu quisesse
pegar essa string aqui? Bem, eu preciso pegar o
segundo item na lista principal, que seria a lista
que eu estou tentando acessar. Então esse será o
índice número um. E dessa lista eu quero
obter o primeiro item, o único item, que seria o alto
índice número zero. Agora, isso funciona com
quantos níveis você quiser, e é aí que pode
ficar um pouco confuso. Agora, imagine que essa lista
interna tenha outra lista dentro dela com
outro elemento, apenas um único número. Agora, para chegar a isso, precisamos obter a primeira lista e depois o tipo do
primeiro item em nossa lista principal
e, em seguida, o primeiro item
nessa lista de pedidos. Isso é apenas recursão, estamos indo nível após nível. Então, agora obtemos o primeiro
item da lista principal, que será essa lista aqui. Em seguida, pegue o primeiro
item dessa lista, o qual estaremos lá, o próximo nível da lista. E então obtemos o
primeiro item disso, que é a string
que queremos, que é essa aqui. Aí está. Eu
queria te mostrar isso porque faz
sentido logicamente. Mas ver esse tipo de sintaxe pode ser um
pouco confuso. E será confuso até que você tenha
mais prática com isso. Portanto, não tenha medo disso. Não, não
desanime de experimentá-lo. Só porque é um
pouco enigmático. Faz todo o sentido depois de
fazer isso algumas vezes. Então essa é a lista. Agora, deixe-me mostrar
rapidamente o que tuplas e conjuntos farão. Semelhante às listas. Eles armazenam elementos
dentro deles. Então você pode fazer
coisas muito parecidas, mas uma tupla. A diferença agora é que
uma tupla usará parênteses em vez
de colchetes. Então, deixe-me imprimir, deixe-me pegar o primeiro
elemento dessa tupla. mesma convenção da lista de colchetes
obterá o primeiro elemento. A principal diferença é
que as tuplas não podem ser modificadas e não podem, não temos o
mesmo conceito ponteiros com topo. Então, se eu
atribuísse uma variável b, o valor de a,
que é nossa tupla. Basicamente, seriam
duas cópias diferentes da mesma tupla. Agora, como eu disse antes, as listas podem ser modificadas no
local, mas as tuplas não. Portanto, se você tentar acrescentar
algo a uma tupla, basicamente gerará
um erro se for corrigido meu erro de digitação, porque as tuplas
não têm atributo, anexar. Portanto, use uma tupla sempre
que souber que não
precisa modificar sua lista. Caso contrário, analista simplista de
dualidade. Agora, o outro elemento que
eu quero
te mostrar é algo chamado conjunto. Agora, você pode inicializar
um conjunto dessa forma. Ou com colchetes encaracolados. Isso pode ser confuso
porque colchetes também são dicionários
úteis. Então, eu recomendo que você
digite em set. Agora isso é um conjunto vazio. Deixe-me imprimir isso. Isso é um conjunto vazio. Agora
diria que você pode modificá-los, você também pode adicionar algo. Eu disse que não existe um
método chamado anexar. Se eu tentar isso,
vai te dar um ou. Existe outro
método chamado add. Você pode adicionar algo a um conjunto. Aí está. Então eu adicionei um. Agora, a diferença com os conjuntos, o que o torna único é que cada valor dentro
deles tem que ser único. Se eu tivesse uma lista, vamos fazer uma lista vazia. Deixe-me acrescentar o mesmo
valor duas vezes em uma lista. Vamos imprimir isso. Então, minha lista se chama B e
deve ter duas sequências, digamos uma nelas. Aí está. Isso é válido em listas. Se eu tentar fazer
o mesmo com conjuntos, você verá que eu só
recebo 11 itens. E isso é muito útil para
manter um conjunto exclusivo de elementos. Agora você pode replicar essa
largura com listas, por exemplo, digamos que você esteja
adicionando algo a uma lista. Digamos que você tenha sua lista e tenha algum valor que
esteja tentando agregar. Digamos que o valor seja a string com esses
números dentro dela. Você pode imitar o que eu disse que
está fazendo dizendo que se o
valor não estiver na lista, que é a lista a
, você pode adicioná-lo. Você só adicionará esse valor
se ele não estiver na lista. Então, esse é um
comportamento semelhante ao que os conjuntos fazem. Mas outra coisa
que você pode fazer com um conjunto é dar a ele uma lista. E isso reduzirá
a lista até que haja apenas valores exclusivos nela. Então, deixe-me te mostrar isso. Digamos que eu dê uma lista. E eu
direi que vou dar uma lista com
alguns valores duplicados, um a dois. Aí está. Então, uma vez que eu imprimi, deixe-me me livrar
dessas petições. Depois de imprimir isso, você restringirá minha árvore de
pesquisa e reduzirá minha lista a apenas
valores exclusivos. Então, mais uma vez, isso pode
ser muito útil
quando você não quer
ter que repetir valores dentro de sua
coleção de elementos. E você também pode, na verdade, não, desculpe, você não pode. Outra coisa única sobre
conjuntos
é que você não pode obter elementos de um conjunto da mesma forma que faz com listas e tuplas. Você pode iterar por meio de
um conjunto válido. Você pode verificar
cada elemento em um conjunto usando um for-loop, mas não pode obter elementos
em um conjunto usando índices. A razão para isso é que,
assim como os dicionários, os conjuntos não são ordenados. Há uma
razão técnica por trás
disso , na verdade,
chamada de HashSets. E eles usam ponteiros. Mas são basicamente
muito eficientes. Você pode encontrar elementos em um conjunto muito
mais rápido do que em uma lista. Mas isso também significa
que você não acompanha, não
acompanha os índices. Então você não pode fazer isso, esse tipo de operação. Portanto, se você precisar acessar
algo por meio de um índice, use uma lista. Se você não quiser. Mas você quer manter uma coleção
muito grande de elementos e quer que todos
sejam únicos, então você pode usar um
conjunto para essa finalidade. Aí está,
listas, tuplas e conjuntos. Esses são tipos de dados muito
poderosos que ajudarão
muito na hora de codificar. E espero ter sido capaz de ajudá-lo
a se
familiarizar mais com eles.
33. Mergulho profundo - dicionários: Vamos falar sobre dicionários de
Python. Agora você pode pensar
em um dicionário, como um
mapeamento entre duas coisas, entre uma chave e um valor. É semelhante a um
dicionário real em que você prêmio e tem uma
definição para essa palavra. A chave seria a ala, a definição seria
o valor dessa chave. Ou como uma lista telefônica, por exemplo, digamos que temos um nome. Temos Rachel e temos o número de telefone da
Rachel. Temos fileiras, temos rosas. Número de telefone, por exemplo,
Rachel seria a chave, e Ross seriam as
linhas seriam outra chave e os números de telefone ou os valores de cada
uma dessas chaves. Então, vamos traduzir isso em
um dicionário Python real. A sintaxe para criar dicionários
é usar colchetes. Então, deixe-me traduzir isso. Rachel Rose transforma
números de telefone em um dicionário. Portanto, você deve usar os
colchetes ou colchetes. E então, dentro disso, você
terá cada item em um dicionário, que será um par
de chave e um valor. E isso é separado
por dois pontos. Você tem um valor chave de dois pontos. Esse será o primeiro
item do dicionário. E então você separa cada item, item por uma vírgula. Vá. E se quiséssemos adicionar mais
um número de telefone em que não precisássemos
fazer isso em suas linhas. A propósito, tudo isso pode estar em uma única linha. Então,
vamos fazer dessa maneira. Vamos adicionar um novo
número de telefone e um comentário triste, Monica, e depois
mais um número de telefone. Então, isso seria um dicionário. E vamos armazená-lo em
uma variável chamada telefones. Deixa eu imprimir e ver como fica. Parece exatamente o mesmo
que acabamos de digitar. Então, o que há
de especial nos dicionários? A primeira coisa é
que, como
dissemos, podemos ter um mapeamento deles, oferta de chaves e valores. E você pode acessar
essas chaves e valores. Assim, você pode acessar esses valores simplesmente acessando a chave. Então, digamos que queremos o número de telefone da
Rachel. Digamos que Rich e
queremos o número de telefone dela. Você pode acessar o valor de um número de telefone usando a chave. Então, para fazer isso, usamos a notação de
colchetes, semelhante à forma como acessamos
os índices na lista. Mas em vez de um número, em vez de um índice,
fornecemos uma chave. Então, vamos fornecer Rachel, por exemplo, deixe-me chamar esse número de
Rachel, por exemplo vamos imprimir esse número. E aí está. É assim que
atendemos o número de telefone. Podemos fazer a mesma
coisa com Ross. E isso diferencia maiúsculas de minúsculas.
A propósito. Este é o número de telefone falso de Ross. Se eu não seguir a letra maiúscula, se for minúscula, por exemplo vou receber um erro
dizendo que não há chave, chave chamada Ross
nesse dicionário. Mais uma vez, devido
à distinção entre maiúsculas e minúsculas, é assim
que você lê
os valores de uma chave. Como escrevemos uma nova chave? Digamos que queiramos adicionar um
novo número de telefone a isso. Digamos que queiramos, vamos imprimir o
dicionário agora mesmo. Primeiro, deixe-me limpar
minha janela de saída. Vamos adicionar um novo número de telefone. Então, os telefones
usarão a mesma sintaxe, a sintaxe de colchetes
que usamos para obter valores. Mas agora você pode
escrever sua nova chave. Então, vamos adicionar Joey. Agora, se fizermos isso agora, tentaremos obter um
valor da chave de junção. Mas se você fizer iguais e , em seguida, um novo
número de telefone nesse caso, criaremos uma
nova entrada no dicionário. Vamos criar uma
nova chave e um novo valor. Então, vamos adicionar alegria. Então, vamos imprimir o
dicionário mais uma vez. Isso foi antes de adicionarmos Joey, e
depois de adicionarmos Joe. Agora, Joe está aqui, Joe está agora no final. Você está percebendo
que o dicionário não
está necessariamente na
ordem em que o estamos criando. Por exemplo, adicionamos Rachel
no início, mas aparecendo em segundo lugar. Por que isso? O motivo
é porque os dicionários são criados de uma forma que os
torna muito eficientes. Eles não precisam acompanhar o pedido porque há um mapeamento e, por
baixo do capô, isso é chamado de ponteiro. As chaves. Estão apontando diretamente para
o valor que eles têm. E há uma explicação técnica que
não precisamos abordar agora. Mas o que isso significa é
que você não precisa da ordem das chaves, mas não
precisa mantê-las em ordem porque você pode simplesmente acessar o
valor pela chave, não importa onde ela esteja no
dicionário. Dito isso, há três
propriedades principais que os dicionários possuem e que os tornam
muito exclusivos em Python. Uma delas é que, como acabei de dizer, elas não estão ordenadas,
o que significa que as chaves não estão em ordem. A outra é que as
chaves dizem que não está em ordem. A outra é que
as chaves são únicas. Vamos ver um exemplo disso. Vamos adicionar Joey novamente. Na verdade, vamos tentar
adicionar uma nova, uma nova Rachel. Eu só vou digitar
0000 para deixar isso óbvio. Agora vamos executar esse
trecho de código. Como você pode me ver, não
precisamos. Rachel,
só há uma Rachel. O que fizemos foi ignorar isso. E nesse caso, isso
se tornou um número inteiro. Portanto, é apenas um
único zero porque vários zeros não fazem sentido. Então esse é um número real. Mas se eu
transformar isso em uma string
, veremos todos os
zeros que adicionamos. Então, como você pode ver, o que
fizemos foi sobrescrever Rachel, não
criamos
uma nova chave Rachel. Então essa é a segunda
propriedade importante do dicionário. As chaves são únicas e a terceira propriedade importante é que os dicionários são mutáveis, o que significa que podemos, podemos modificá-los à medida que avançamos. Como vimos agora, criamos um dicionário
e depois estamos modificando o dicionário
original. É isso que
os torna mutáveis, que você pode alterar,
adicionar remover chaves e
valores em um dicionário. Agora, outra coisa a que prestar atenção quando
algo é mutável. Se você viu como
as listas são mutáveis e está
sempre apontando para aquele lead
que está modificando. Vamos, deixe-me mostrar
outro exemplo disso. Vou criar um dicionário
vazio chamado a, vou armazená-lo em uma variável a. E vou criar
uma nova variável B. Vou dizer que B é igual a a. Então a é um dicionário vazio. E um dicionário vazio simplesmente esses dois colchetes ondulados. Ou você também pode digitar,
ditar, digitar marcado e abrir
e fechar parênteses. Isso
lhe dará o mesmo resultado. Então, a é um
dicionário vazio, b é igual a a. Agora vamos adicionar um valor, uma chave e um valor a a. Digamos que a seja igual a um. E vamos imprimir a,
e vamos imprimir B. Então, o que você acha? Reserve um momento para tentar pensar no que
vai acontecer. Mas adicionando uma chave e um
valor a um ou ao OneNote, tecnicamente não estamos
fazendo nada para estar certos. Então, vamos executar esse
código e imprimir o resultado. Agora, como você pode ver, a
e B são exatamente iguais. Outro aspecto
importante da mutabilidade
dos dicionários é que eles são criados uma vez e você está sempre
acompanhando o mesmo dicionário. Então, mesmo se atribuirmos isso
a várias variáveis, mesmo que eu atribua, crie uma variável chamada c
e atribua a V2 isso. E então eu imprimo c. Eles ainda são
o mesmo dicionário, mesmo que você tenha
três variáveis, eles têm o mesmo dicionário. Por exemplo, se agora
eu pegar C e adicionar uma nova chave a ela, e eu disser C. Então, três, desde a terceira letra
do alfabeto, deixe-me imprimir isso novamente. Como você pode ver, todos a, B e C receberam a mesma atualização porque estão todos rastreando
o mesmo dicionário. Se você quiser evitar isso, se quiser que eles sejam dicionários
independentes, basta
inicializar ou criar um dicionário para cada
uma dessas variáveis. Aí está. Você pode ver que agora tem
uma chave exclusiva, B está vazia e depois ver, porque
adicionamos uma chave a
C com seus próprios valores. Então, essas são as
três principais propriedades que você deve se lembrar
sobre os dicionários. Mais uma vez, as chaves não
estão em ordem. Isso ocorre porque você obtém valores dos nomes das
chaves limpas, não da ordem
do dicionário. As chaves são exclusivas, é assim
que você pode
obter um valor de uma chave. Se você tem várias chaves e não sabe realmente qual valor obter
das chaves, certo? Portanto, temos que mantê-los únicos. E mutável significa que você pode mudar o
dicionário rapidamente. Por isso, para cada dicionário
exclusivo, há apenas uma cópia que está
sempre sendo modificada, mesmo que você a atribua
a outras variáveis. Ok, agora deixe-me mostrar algumas operações comuns
sobre dicionários. Deixe-me criar um novo
dicionário com alguns. Chaves e valores nele. Vamos ter a, um, b, dois e c. O valor
de c será três. Excelente. Assim, você pode verificar se algo
está em um dicionário. Da mesma forma que podemos verificar se
algum analista de notícias, podemos perguntar se, por exemplo, a. Dicionário a, na verdade, deixe-me mudar o nome
desse dicionário. Vamos chamá-lo, vamos chamá-lo
simplesmente de dicção, dicionário. Dicionário. Se a estiver no dicionário, imprima. Sim. Caso contrário, imprima. Não. Vá. Então, a está nos
dicionários e obtemos sim. Digamos f. Se não, não é um dicionário,
então diremos Não. Excelente. Então, o que
acontece se você tentar obter o valor de uma chave
que não existe? Já vimos isso, digamos que se o que sabemos não
está no dicionário. Vamos tentar imprimir
esse valor diretamente. Vamos receber um erro. E esse erro é um erro fundamental porque F não está
no dicionário. Há duas maneiras de
verificar se há uma chave no dicionário
e, se estiver, obter o valor dela. Uma maneira é se nós, como já fizemos aqui, podemos dizer se f está
no dicionário e imprimir o valor de
f.
Então, imprimir o valor de
f.
Então deixe-me me livrar
da declaração else. Portanto, só tentaremos acessar o valor se f estiver
no dicionário. Agora podemos fazer isso com um que sabemos que já está
no dicionário. E então obtemos o valor. Agora, há outra
maneira de obter um valor. E à prova de balas
é um pouco. Os dicionários têm uma
função chamada get. Agora get é o mesmo, faz essencialmente a
mesma coisa que a notação de colchetes. Posso dizer que vamos armazenar isso
em uma variável chamada valor. Eu posso obter o valor da chave. E eu posso imprimi-lo, que é um, como já
sabemos. Mas se a chave não existir, get fornecerá
um valor padrão. Então, nesse caso, como f não existe, obteremos um
valor padrão de None. Mas você também pode fornecer
um valor padrão para isso. Então, isso é
como um interruptor e digamos, se a chave existe, me
dê o valor da chave,
caso contrário, me dê
outro, outro valor. Nesse caso, eu poderia dizer que os valores
padrão serão uma string com
um único traço,
por exemplo, e pronto. Então, como f não está
no dicionário, obteremos
o valor padrão, que é o traço. Agora estamos imprimindo
este aqui por causa da
declaração if aqui em cima. E aí está,
temos o painel. Então, só para esclarecer isso. Isso é semelhante a dizer, digamos que temos uma chave e
queremos que as crianças sejam f.
Pode dizer que, se a tecla puder, dicionário imprimir o valor dessa chave do nosso dicionário. Agora, a chave será essa
variável que criamos. Caso contrário, imprima
um valor padrão, que, nesse caso, vamos
criá-lo como uma variável, o valor padrão
será um traço. Portanto, se as chaves
no dicionário imprimirem o
valor dessa chave, caso contrário, imprima o
valor padrão. Vamos executar isso. Obteremos um valor padrão. Essa função de obtenção de pontos faz exatamente a mesma coisa que
essas poucas linhas de lógica. Grade. É assim que podemos
acessar valores de chaves e escrever
novas chaves em um dicionário. Agora, como excluímos
chaves de um dicionário? Vamos simplificar esse
dicionário aqui. Vamos deixar a chave A. E deixe-me, por exemplo, adicionar uma nova
chave que será B. Agora, novamente, a mesma, a
mesma sintaxe. Mas agora fazemos o mesmo. Então, agora a chave B será igual a. Agora, deixe-me remover a
do dicionário. Para remover uma chave, há uma função chamada pop. Pop removerá uma, receberá o nome de uma chave e nós a removeremos
do dicionário. Então, vamos imprimir esse dicionário. Agora lembre-se de que inicializamos o dicionário com uma
única chave, que é a. Nós adicionamos b e depois clicamos, ele removerá a dessa chave. Então, agora nosso novo
dicionário está sendo. Agora, há um pequeno
efeito colateral no bombeamento. Ou seja, você obtém o valor da chave que você
remove, que você removeu. Então, se eu armazenar o resultado
de pop nessa variável, obterei o valor de a, que é o que removemos
do dicionário. Esse é o valor um. Agora, há algo que você deve
saber é que, se você fornecer ao pop uma chave
que não existe, por exemplo, f. Novamente, pop
apresentará um erro de chave
porque a chave não existe. Então, quando você estiver usando o
Pub, é bom verificar se sua chave está
no dicionário, então você pode removê-la. Mas pop tem outra
funcionalidade que permite que você não precise verificar se uma chave está
no dicionário. E isso é fornecendo
um argumento separado. Segundo argumento, desculpe. Mais uma vez, se
executarmos isso sozinho, obteremos um erro porque F não
está no dicionário. Mas se fornecermos
um segundo argumento, da mesma forma que GET
tem um valor padrão, pub obterá um
valor padrão de quatro. Então, se eu digitar non, por exemplo, I. Imprimir
removido, imprimo a variável remota. Não vai reclamar
e, na verdade, vai me dar
esse valor padrão. Estamos tentando fornecê-lo. Portanto, não há uma chave chamada f. Portanto, o padrão é
esse valor padrão. Se eu mudar isso
para outro traço,
por exemplo, o mesmo de antes. Bem, uma
vez que f não existe, esse será o valor padrão. Mas se estivermos tentando tirar a, obteremos
o valor de a porque a realmente existe. Isso não funcionou porque eu não
executei o código inteiro. Desculpe, preciso
executar o código inteiro. Aí está. Então, agora removido o valor por
sprint é o valor de a. Segunda impressão, o resultado no
dicionário depois de abrir um. Mas, mais uma vez, agora
podemos executar todo o código. Se eu remover F, o dicionário
resultante ainda terá a e
depois o Beta que adicionamos. E então imprimimos o valor padrão da
chave que não conseguimos remover. A última coisa que
quero mostrar sobre dicionários é como você obtém uma lista de chaves e valores. Então, deixe-me excluir o resto
desse código e adicionar
mais algumas chaves ao meu dicionário. O mesmo exemplo novamente. Então, digamos que eu queira
saber quais teclas estão
no dicionário. Imagine que esse dicionário tenha milhares de itens dentro dele. Os dicionários têm uma
função chamada teclas. E o que
isso fará é fornecer uma lista dos valores
dessas chaves. Agora, desculpe, ele
lhe dará uma lista das chaves no dicionário. Então, se armazenarmos isso em uma
variável e depois imprimirmos, deixe-me limpar minha janela de saída. Aí está. Então você obtém uma lista das chaves
dentro desse dicionário. Para que você possa usar essa lista para acessar
valores a partir dela. Ou se você quiser uma lista simples de valores
sem as chaves, há uma função
chamada valores. E eu simplesmente lhe darei uma lista dos valores
no dicionário. Agora, lembre-se de que
os dicionários não têm ordem. Portanto, a ordem desses valores, assim
como a
ordem das chaves, não
funcionará, não
seguirá nada do
que você possa esperar. Nesse caso,
imprimimos os valores, mas você pode ver que eles não
estão na ordem em que os
trouxemos, o que é bom. Essa é apenas uma lista de valores, mas geralmente queremos
consultar valores de uma chave, não diretamente daqui. E há mais uma
função que eu quero mostrar que
é chamada de itens, mas as ilhas farão
é fornecer uma lista pares de chaves e valores na forma de tuplas. Então, deixe-me salvar isso
em uma variável chamada items e imprimir isso. Então você tem uma chave, desculpe, você tem uma lista. E dentro dessa lista você tem esses pares, que são tuplas. E você tem a chave e
o valor dessa chave. Chave e valor, chave e valor. Dessa forma, você pode realmente repetir todas
as chaves do dicionário. Teclas do dicionário. Então, serão quatro teclas
nas teclas de pontos do dicionário. E imprimiria todas as
teclas do dicionário. Agora, se fizermos um valor
e dissermos para valor,
em valores, o valor é ordenado e
não o estilo de volume como o meu. Qual é o meu erro? Para valores de volume? Em seguida, repetimos esses valores. Agora você também pode fazer
o mesmo com itens. Mas agora lembre-se desses itens. Se eu simplesmente imprimir itens, lembre-se de cada item,
cada elemento na lista, a chave e o valor. Você pode desempacotar isso. Isso se chama desempacotar. Quando você tem vários
valores em uma tupla ou lista, você pode descompactá-los
diretamente no for-loop. Você pode dizer o valor da vírgula chave. Então, basicamente, para cada
item da lista. Na verdade, deixe-me
mostrar isso primeiro. Vamos imprimir cada
item da lista. Então, como você me viu remover isso. Como você pode ver, cada item
é um par, um par
de chave e um valor. Então, podemos dizer que podemos
descompactá-los para o valor da vírgula chave. Em cada item do dicionário. Na verdade, podemos imprimir
isso separadamente. Valor do ponto G. Então temos um e temos um. Vamos ver onde estão três. Ou podemos colocá-los juntos
na declaração impressa. Assim. E embora obtenhamos o mesmo resultado porque
estamos imprimindo uma tupla. Mas deixe-me fazer isso
na forma de uma string, valores
d e c para que possamos
usar uma função de formato de ponto. E deveria ser um
pouco mais claro. Portanto, as chaves a e o
valor de a são um. Então, mais uma vez, isso é usar
a função do ferro e desempacotar cada um desses
itens como uma chave e um valor. Isso são dicionários. Acredito que mostrei algumas
das principais coisas que você
pode fazer com eles. Mas é claro que há muito
mais neles do que isso. Eles são uma
ferramenta incrível para lidar com dados. Eu recomendo fortemente que você brinque um
pouco mais com eles. Mas, com isso dito, você deve ter conhecimento suficiente agora para poder usá-los com
mais eficiência em
sua codificação diária.
34. Projeto final - Biblioteca de pose: introdução: Neste projeto,
criaremos uma biblioteca de postagens. Para esta biblioteca de postagens, que tem esta aparência. Já escrevemos
a funcionalidade que precisaremos que foi feita a partir do projeto
anterior. Você
aprenderá como criar uma ferramenta completamente nova que
aproveita o código
escrito por você ou por outra pessoa
para outro projeto. A principal coisa que precisamos
criar em cima
desse outro código é a capacidade de
salvar poses em arquivos. Então, você
aprenderá a lidar com arquivos. A segunda parte do trabalho será
a criação da interface do usuário. A interface do usuário é um
pouco mais complexa. Tem uma seção dobrável. Receberemos informações
do usuário e haverá uma lista de poses preenchidas
a partir de arquivos no disco. Agora, a vantagem
de salvar
dois arquivos do processo é que agora
podemos compartilhá-los em minhas sessões ou até mesmo com outras pessoas em computadores
diferentes. Então, deixe-me mostrar
como essa ferramenta funciona. Eu já salvei
algumas postagens com antecedência. Podemos aplicá-las a um único caractere, como
já vimos antes, ou a vários caracteres. Eu tenho postes para sentar. E também podemos salvar
poses da cena. Então, digamos que nós, digamos que queremos
guardar uma pose para esse adereço. Vamos colocar o chapéu no chão. Vamos dar um nome
, tinha no chão. Salve a pose. E quando eu salvo essa pose, você vê que ela
apareceu aqui imediatamente. E isso é salvo em um arquivo. Então, mais uma vez, ele
pode ser compartilhado entre sessões ou entre computadores
com outras pessoas. Então eu posso seguir em frente
e aplicar essa pose a esses personagens. Então, essa é uma ferramenta
que vamos criar.
35. Criar o pacote Python: A primeira coisa que
faremos é criar a estrutura de arquivos para nosso código. Então, vamos voltar ao PyCharm e temos
aqui os outros módulos de nossos outros projetos. Agora vou
criar um novo,
mas vou criar um diretório porque isso
precisará de mais partes do que
os outros projetos. Então, vou clicar com o botão direito do mouse
na raiz do nosso projeto e clicar em Novo. Vou criar um
novo pacote Python. Em seguida, damos um nome a ele. Vou chamá-la de biblioteca de sublinhados de
pose. Agora, o PyCharm criou
uma nova pasta ou um novo diretório com
um arquivo dentro dela. Vou voltar a
esse arquivo daqui a pouco. Mas se você olhar para a
pasta em si, simplesmente, este é um diretório de scripts para o seu Maya na pasta Maya de seus
documentos. E dentro disso,
há esse diretório com um único arquivo
chamado underscore, underscore init, underscore,
underscore dot PY. Então eu vou
criar outro arquivo, apenas um único arquivo Python. Lá,
vamos estruturar esse código ou esse projeto manterá a funcionalidade separada da interface do usuário. Isso geralmente é
uma boa prática. Algo que fizemos antes
para a pós-transferência foi criar a interface do usuário diretamente
no módulo de pós-transferência, que contém uma funcionalidade. Eu escolhi fazer isso
porque houve uma primeira ferramenta que usamos na
qual criamos uma interface de usuário. Além disso, era um
pouco mais simples, mas geralmente é recomendável manter sua interface separada
de sua funcionalidade. Isso permite que você reutilize a funcionalidade, que é o que faremos
com este projeto, e manter sua interface de usuário
completamente separada. Isso também
permite
criar várias interfaces de usuário que aproveitam
a mesma funcionalidade
em um único local. Então, vou
criar um arquivo Python. Vou chamá-lo de núcleo. Estou ligando, estou chamando
isso de núcleo porque esse será o núcleo
funcional da biblioteca. E eu vou criar
outro arquivo chamado UI goes. Nosso código de interface de usuário ficará aqui. Agora, vamos voltar. Vamos adicionar algo
ao módulo principal. Vamos simplesmente adicionar uma
função de teste para que
possamos testá-la e ter
certeza de que está funcionando. Vou digitar hello
core four, pose library. Ótimo. Agora, o que um arquivo está fazendo? Se olharmos para ele,
na verdade está completamente vazio. É simplesmente um arquivo de texto chamado double
underscore init, double underscore dot p-y. Se eu não tivesse esse arquivo, Maya nos daria um erro ou o Python
nos daria um erro porque esse é o arquivo que diz
ao Python que trate o diretório como um módulo. Então, deixe-me excluir esse arquivo. Isso se
refletirá aqui no PyCharm. Vamos tentar importar
essa função. Deixe-me voltar para Maya. Vamos abrir o editor de scripts. Chamamos isso de biblioteca postal. Então, vamos dizer, da biblioteca de
poses, núcleo de importação. E sabemos que o core tem uma função chamada hello que simplesmente
imprime nossa mensagem de olá. Então, deixe-me tornar isso
um pouco maior. Vamos executar o código. Você pode ver Python está dizendo que nenhum módulo
chamado biblioteca pose. Agora, o que acontece se adicionarmos
esse arquivo init por parentesco? Vamos criar
um novo arquivo Python. Não vou criar
um pacote Python. A propósito, quando
você diz pacote Python, pycharm parece simplesmente criar um diretório com esse arquivo init. Mas, nesse caso, vou
criar um arquivo Python. Vou
chamá-lo apenas de sublinhado, sublinhado init,
sublinhado, ponto p-y. Vamos tentar executar
isso mais uma vez. Aí está. Agora nosso código está funcionando
e estamos recebendo essa mensagem de nossa função. Então, isso é o que é importante
nos arquivos inuítes. Você não precisa colocar
nada dentro deles. Você pode, se quiser. Mas eles precisam estar lá para que o diretório seja
tratado como um módulo. Se você tiver submódulos
, será o mesmo caso. Vamos chamá-lo, vamos chamar esse novo módulo.
Esse é um exemplo. Você vê que há um
arquivo init dentro disso. E então você pode adicionar mais arquivos
Python em seu novo módulo. Então, mais uma vez, está apenas dizendo ao Python
que trate esse diretório como um
módulo para que eles possam, para que ele possa ser importado. Ótimo, deixe-me deletar isso. E aí está. Portanto, temos a estrutura que
vamos usar para criar nossos dois núcleos que terá
todas as funcionalidades
e a interface do usuário terá todos os elementos
da interface do usuário.
36. Trabalhar com arquivos: Como mencionei antes, vamos
reutilizar a maior parte
do código do projeto
anterior. Mas uma coisa importante que
precisamos acrescentar é a capacidade de salvar arquivos. Então, vamos aprender
a trabalhar com arquivos. Antes de começarmos a salvar poses. Eu criei um diretório aqui. Isso está logo abaixo do meu drive C. Há uma pasta de demonstração do python e, em seguida, uma pasta de pós-biblioteca. Vou
salvar meu arquivo aqui. Vamos começar com um arquivo de
texto simples para que possamos aprender a criar
arquivos do zero. Vou ligar,
vou dizer que meu caminho para o
meu diretório é o caminho deles. Vou adicionar um r aqui. Não acredito que nenhum desses
personagens escapará. Conheça. Mas se você tivesse, por exemplo uma biblioteca nasal semelhante a N, seu personagem escapará. Como você pode ver, o
traço é uma barra invertida, n é o caractere de retorno. Isso lhe dará uma nova linha. Então, na verdade, está
dividindo o caminho em duas linhas. Portanto, se por algum motivo
seu caminho
em seu diretório tiver um caractere especial chamado
caractere de escape. E outro deles
seria T, por exemplo, biblioteca. Isso te daria uma conta. Ou um a lhe dará
um caractere extra. Então, uma maneira de evitar isso é escapar desses personagens de
fuga. Por exemplo, voltar para a biblioteca nose, que novamente volta à
barra invertida n é uma nova linha. Se eu adicionar uma nova barra invertida, ela escapará disso. Ou você pode fazer uma barra para frente. E isso também
evitará o problema. No entanto, ao copiar
e colar partes do Windows, geralmente
você
obtém essa barra invertida. Portanto, substituir tudo por
duas barras pode ser um pouco
entediante às vezes. Então, uma maneira fácil de fazer isso é simplesmente colocar um r na
frente dessa corda. E isso o transformará no
que é chamado de string bruta. sequência de setas basicamente
significa ignorar quaisquer caracteres de escape.
Esses propósitos. Agora, o R também é usado para
algo chamado rejeitos, que é uma linguagem de expressão que você pode usar
para analisar cadeias de caracteres. Mas não íamos
tocar nisso aqui. Só que é
bom saber que R é, na verdade, destinado a rejeições. Mas podemos usá-lo para
evitar problemas
como, por exemplo, ter que a nova linha são aqueles personagens de fuga. Ok, então deixe-me colocar isso de
volta no meu caminho real. E agora eu preciso de um nome de arquivo. Nome do arquivo, vamos
chamá-lo de ponto de texto TXT. E isso precisa
ser uma corda, certo? Então, na verdade, podemos, vamos unir isso. Eu vou te mostrar uma coisa. Vou usar o módulo OS. Então, vou digitar import OS. E eu vou dizer que o
caminho completo é igual ao caminho dos pontos do sistema operacional. Então, sempre significa sistema
operacional. Portanto, essa é uma biblioteca que lida com ações do sistema operacional. Há um módulo de caminho nele que ajuda você com os caminhos dos arquivos. E há uma função de junção que permite
unir vários caminhos. Então, se você tiver
vários diretórios e quiser
juntá-los, poderíamos simplesmente fazer isso, por exemplo
, testar esse dx dy. Ou também podemos
dizer que você perdeu o caminho. Por exemplo, estamos perdendo a
barra invertida e o nome do arquivo adicional. Mas eles sempre disseram que
o Path Join nos fornecerá essa barra invertida automaticamente e garantiremos que
o caminho seja válido. E se houver algum personagem de
fuga, ele também escapará deles para nós , para que não precisemos preocupar com nada estranho
acontecendo com o caminho. Eu vou dizer que o
caminho deles é coma, nome do arquivo. Junte esses dois para mim. Vamos imprimir o
caminho completo. E aí está. Este é um caminho completo
para o nosso arquivo, arquivo. Então, eu vou realmente
chamar esse caminho de arquivo. Ótimo. Então, agora esse arquivo obviamente ainda
não existe. Nós vamos criá-lo. Para criar um arquivo, usamos uma função chamada open. Vamos chamar isso. Vamos chamar isso de F. Vamos chamar o arquivo f. Não
estou chamando-o de file porque o arquivo é outra função
embutida no Python. E eu não
quero sobrescrevê-lo. Então, eu poderia chamá-lo de arquivo
sublinhado, mas neste caso
vou chamá-lo f. Agora queremos
abrir por um caminho. E então, quando você está
abrindo um arquivo, você tem que escolher o modo, o modo no qual
você deseja abri-lo, e isso é uma única string. Os principais modos que você deseja. Decidi escrever no
arquivo ou ler o arquivo. Então, neste caso, queremos
escrever um novo arquivo. Então, vamos dizer File Open,
abra o caminho do arquivo
no modo de gravação. Então vamos
dizer ponto F, certo? Então, o que você obtém ao
abrir um novo arquivo é, na verdade, um objeto de arquivo. Então, vamos ver como
isso parece. Se eu simplesmente imprimir f vai me dizer que
este é um arquivo aberto. Seria o modo de gravação em
algum endereço na memória. Se eu disser, me dê o tipo, aí está, essa função
lhe dará o tipo de um objeto. Isso me dirá
que esse tipo é arquivo, é por isso
que eu não
queria nomear meu arquivo, meu arquivo variável, porque eu
estaria substituindo esse horário. Ótimo. Agora sabemos que
f é um objeto de arquivo. Um objeto é realmente qualquer
tipo em Python, por exemplo, strings são objetos,
listas são objetos. Então, assim como esses, esses objetos de arquivo têm uma
função chamada write. A função de gravação será kin, algum texto ou alguma
string com algum texto e alguns textos para meu arquivo. Excelente. Agora, algo muito
importante a lembrar com os arquivos é que, depois abrir um arquivo, você
precisa fechá-lo. Para fechar um arquivo. Você pode fazer f nesse caso, fechar um
ponto e
chamar essa função. Caso contrário, seu arquivo pode permanecer aberto, você
pode ser corrompido e quebrado. Por isso, geralmente diz que é sempre uma boa ideia, boa prática
fechar seus arquivos. Então, deixe-me executar esse código. E vamos
ver o que aconteceu. Excelente, então temos um novo arquivo de texto com os textos que
escrevemos dentro dele. Ótimo. A próxima etapa é ler os arquivos. Então, deixe-me modificar esse arquivo com alguns novos textos para
que eles sejam lidos em Python. Vamos escrever um novo texto. Leia em Python. Vamos salvar esse arquivo. Agora, para ler, é muito
parecido com escrever. Tudo isso permanece o mesmo. Ainda queremos abrir o arquivo, mas queremos
abri-lo no modo de leitura. Esse seria nosso mesmo caminho de
arquivo aberto ou como modo. E agora, em vez de escrever, queremos ler esse arquivo. Então, vou excluir tudo isso e usar a função
dot right. Bem, desculpe, função de leitura. E eu vou armazenar o vermelho, tudo o que lemos do arquivo em uma variável chamada content. E a leitura fornecerá uma string com o conteúdo do arquivo. E então, mais uma vez ,
depois de ler,
queremos fechar esse arquivo. Então eu vou
imprimir continentes. E aí está. Então, o conteúdo é
exatamente
aquela string que obtivemos do arquivo. Esse é o básico do
trabalho com arquivos. É muito fácil,
é muito simples. A principal coisa a lembrar
é fechar o arquivo. Agora, se você não quiser
se preocupar em fechar o arquivo, porque é muito
fácil esquecê-lo. Existe outra
maneira de fazer isso, e eu realmente recomendo
que você faça dessa maneira. Vou usar algo
chamado gerenciador de contexto. Agora, vamos digitar largura, caminho do arquivo
aberto. Isso é a
mesma coisa que falamos acima. Vamos abrir o
arquivo no modo radiano. Você digita como f e depois dois pontos. E dentro dessa declaração de
largura, vou dizer que o conteúdo é igual a f ponto lido,
assim como antes. Então, o que está acontecendo aqui é que ainda estamos abrindo
o arquivo no modo radiano, onde ele ainda está salvando
isso na variável f. Mas estamos fazendo isso dentro
desse gerenciador de contexto. Um gerenciador de contexto
garante que algo aconteça antes que seu
código seja executado. Então, antes de lermos o arquivo,
algo vai acontecer. E também garante que,
após a execução do código, algo
aconteça antes de
passar para as próximas linhas de código. Portanto, nesse caso, não
precisamos
mais fechar o arquivo porque o gerenciador de
contexto o fechará para nós. E então também não
precisamos desse slide. Agora, vamos ver se obtemos os
mesmos resultados que obtivemos. Obtivemos exatamente o mesmo resultado. Portanto, podemos fazer o mesmo
ao gravar em um arquivo. Podemos mudar isso
para o modo correto. E, claro, não precisamos
usar f como variável. Podemos usar FYI se quisermos
ou qualquer outra coisa que você quiser, contanto que isso seja,
isso depende de você. Desde que, é claro, você reutilize essa variável em seu código. Então abra o arquivo e
chame-o de algo, faremos algo
que estamos escrevendo agora. Então, vamos escrever um novo texto. Vamos executar esse código. E se verificarmos o arquivo, nosso novo texto foi
gravado no arquivo. Então você pode fazer isso de qualquer maneira. Você pode abrir o arquivo manualmente e fechá-lo
manualmente, se quiser. Mas eu recomendo fortemente
simplesmente usar
esse padrão, que é
o Gerenciador de Contexto.
37. Salvar poses para arquivos JSON: Sabemos como criar arquivos. Então, agora estamos prontos para
começar a salvar poses. Vamos usar um formato especial para
arquivos chamado Jason. Jason, o formato JSON é muito parecido com a aparência
dos dicionários. Há uma biblioteca
em Python
projetada para funcionar especificamente com esse tipo de arquivo. Então, vamos nos levantar da
pose de que podemos economizar. Vamos usar nosso código de transferência de
postagens. E vamos manter
todas essas séries. Deixe-me fazer uma pausa aqui
e dizer transferência de pose. E nossa função se
chamava GET post deck. E precisamos
passar o namespace. Ótimo, então
vamos colocar a postagem
desse chapéu aqui. E o namespace desse
personagem é Luna, um. Esse é um novo personagem
que acabei de adicionar. Então, vamos chamar isso de pose. Pose é igual à pós-transferência
que é publicada. Vamos ver como isso parece. Deixe-me trazer essa pose. Ok, aí está. É um dicionário com alguns valores. Este
pequeno dicionário. Isso é ótimo, só para o chapéu. Então, agora queremos
salvar esse arquivo. Agora, como estamos usando
o formato JSON, vou
prosseguir e
deixar isso como o
nome da extensão desse arquivo. E vamos fazer isso, também
usaremos o Gerenciador de
Contexto. Vou chamar isso de F, novamente, para simplificar. Mas agora, em vez de
usar epitáfios, certo, vamos usar
alguma coisa. Vamos usar a
biblioteca JSON que importamos. Então, mais uma vez, importe JSON e isso é Jason
sem um JSON. E vamos usar essa
biblioteca para escrever o arquivo. Agora, a biblioteca JSON
chama isso de despejado. Eles vão despejar basicamente
um dicionário em um arquivo. Agora precisamos, precisamos
passar pelo correio. Deixe-me ser mais explícito
e chamá-lo de pós-ditado. Vamos colocar o
post dict nele enquanto ainda precisamos abrir o arquivo e
fechá-lo. Agora, vamos
passar esse objeto
de arquivo para json dot dump. Vamos fazer isso e
ver como fica. Vamos para nossa pasta aqui. Temos esse arquivo de texto, novamente com nosso dicionário. E é exatamente isso que queremos. Então, agora temos nossas
postagens salvas em um arquivo. Agora, outra coisa
que eu gostaria de fazer é formatar o arquivo um
pouco melhor agora. Mas a vantagem de usar
a biblioteca JSON é que
você pode fazer exatamente isso. Existe um argumento
chamado indentação. Eu vou dizer que quero ou
participar da suplementação. Então, se eu executar esse código novamente, ele escreverá esse
dicionário novamente no arquivo. Desta vez, bem formatado. Há quatro espaços
de indentação aqui, e é mais
fácil ler dessa forma. Então, vamos criar o código
que será salvo. Ou talvez a forma como
vamos trabalhar
com isso seja o
nome do arquivo, seja o nome das postagens. E, claro, o
contexto do arquivo
serão os
valores reais da postagem. Então, vamos para o PyCharm e
vamos para o nosso módulo principal. Vamos começar do zero. Vamos precisar,
precisaremos do módulo
OS. Vamos precisar
da biblioteca JSON ou elas sempre serão uma biblioteca
e uma biblioteca JSON. Na verdade, vamos colocar tudo
isso em um gráfico circular. Ótimo. Então, precisamos saber, já que esse será o código, o código da nossa ferramenta, vamos querer saber onde estamos salvando as poses. Então, vou fazer
disso uma variável global. Você chama isso de raiz lá. Agora, o que quero dizer com variável
global é que essa variável estará acessível a tudo dentro
desse módulo. Mesmo se criarmos uma função. Digamos que temos
essa função aqui. Podemos usar uma
variável global dentro
dessa função porque
ela está fora
do escopo dessa função. Agora, se eu fosse criar
outra variável aqui, essa variável só está disponível dentro
dessa função porque,
novamente, por causa do escopo. Então, isso é ótimo
sobre variáveis globais. E como são globais, a convenção é fazer com que todas
elas sejam capitalizadas. Agora isso não é necessário. Isso não
quebrará seu código se
você tiver letras minúsculas aqui. Mas, como uma convenção para deixar óbvio que é
uma variável global, é uma variável importante define um valor que
você deseja que seja constante. Nós fazemos isso. Letras maiúsculas. Ótimo. Então, também queremos
saber a extensão. Então, vamos
escrever extensão. Vamos apenas fazer EXT. A extensão será dot json. Excelente. Portanto, precisamos criar uma
função para escrever bytes. Vamos digitar def,
certo, pose to file. Agora precisamos saber qual será o nome da
postagem. Vamos aceitar uma
discussão chamada pós-natal. Precisamos saber o conteúdo
do arquivo, certo? Então, precisamos desses dicionários. Excelente. Então, dentro disso, basicamente
faremos o que fizemos no Maya com algumas modificações. Portanto, o caminho do arquivo
será o diretório raiz, que é uma espécie de diretório
global para nossos propósitos
, definido aqui. Então, quem usa essa função não precisa saber
onde salvar as postagens. Estamos definindo isso na ferramenta. Mas precisamos saber o nome. Agora, o nome da pose
não contém
a extensão, porque não
queremos que quem esteja usando dessa forma. Só queremos que eles
nos dêem o nome das postagens. Nós cuidaremos
dessa extensão. Então, vamos chamar, vamos criar uma
nova variável chamada filename. E vamos simplesmente juntar esse nome e a
extensão. Deixe-me me livrar do
período aqui e da extensão. Nós cuidaremos disso
dentro desta função. Então, isso será o nome da postagem, extensão do
ponto, nome da
pose em
primeiro lugar e, em seguida, extensão EXE do
ponto. Ótimo. E agora podemos unir o
diretório raiz e o nome do arquivo, e esse será o caminho do nosso arquivo. Excelente. Em seguida, estamos recebendo
o dicionário postal. Não precisamos obtê-lo. Em seguida, simplesmente salvamos o arquivo. E é isso. É ótimo. Vamos testá-lo bem rápido. Então, vamos voltar para Maya. E vamos criar uma nova guia em Python. Vamos importar da biblioteca
de fotos. Importar núcleo. Na verdade, vou nomear seu
núcleo como núcleo de biblioteca, apenas para torná-lo um
pouco mais explícito, núcleo
da biblioteca
escreve postagens em File. E precisamos obter um
dicionário oposto. Então deixe-me, deixe-me, deixe-me importar, importar
Posts underscore transfer. E vamos pegar os dois dicionários
da mesma forma que fizemos antes. Faça algumas
colagens aqui. Então, precisamos nomear a
pose que será, vamos chamá-la de primeira pose. E precisamos fornecer o
ditado do dicionário. Ótimo. Então, deixe-me ter certeza de que minha seleção ainda
está lá. Selecione o chapéu. Vamos pegar
o dicionário de poses. Pode então gravar isso em um arquivo. O objeto não tem nenhum atributo,
certo? Arquivo de postagem. É claro que, como não
temos, não recarregamos isso. Vamos recarregar.
Como adicionamos código, precisamos recarregar esse módulo. Aí está. Agora, se verificarmos nosso arquivo, temos um novo erro
de digitação, desculpe,
primeiro, suponho que deveria ser o primeiro, mas o que temos é o
conteúdo da postagem dentro dele. Ótimo. Então, agora podemos escrever dois arquivos
postados.
38. Ler poses de arquivos JSON: Agora precisamos ler as poses de um arquivo ou uma
postagem de um arquivo. Então, vamos criar uma nova função
chamada red hose a partir do arquivo. E tudo o que precisamos
aqui, aliás, manter dois espaços
entre minhas funções apenas para torná-las um pouco
mais organizadas e organizadas. Tudo o que precisamos para essa
função é um caminho de arquivo. Agora, isso é feito de forma
semelhante à escrita de arquivos, mas precisamos fazer o oposto. Claro, precisamos lê-lo. Então, vamos usar o Gerenciador
de Contexto. Vamos abrir o
arquivo no modo radiano. E vamos usar
a biblioteca JSON mais uma vez,
mas para ler o arquivo. Agora, dump despejará
um dicionário em um arquivo e load carregará
um dicionário de um arquivo. Agora, tudo o que precisamos fornecer
à função de carregamento é
o arquivo do qual queremos carregar. E vamos salvar isso
em uma variável que podemos chamar extrai dados porque é isso
que é. Ou poste o ditado. Vamos pegar um
dicionário com isso. O Gerenciador de Contexto se
encarregará de fechar o arquivo para nós, é
claro, e então
poderemos retornar a pose. Agora, algo interessante
sobre os gerenciadores de contextos é que, mesmo que você
retorne dentro deles, que significa que estamos
encerrando a função, ele ainda fechará o arquivo
antes de sair da função. Então, essa é
a melhor coisa
sobre os gerenciadores de
contexto Não importa o que você faça, eles garantirão que tudo o que precisar ser
feito quando você terminar a execução do código
dentro deles, acontecerá. Ótimo. Então estamos,
agora podemos ler um arquivo. Vamos testar isso rapidamente. Então, queremos ler. Vamos fazer isso aqui. Pose a partir do arquivo, será
igual ao núcleo da biblioteca. Leia prosa, postagens de arquivos. E o caminho do arquivo,
é claro, são esses arquivos aqui que
queremos ler no primeiro post
, por exemplo , então deixe-me copiar isso. Vamos fornecer esse caminho de arquivo. Eu só vou escrever isso. Para um cônjuge, incluindo meu erro de digitação. Devemos usar o dot json. E então podemos imprimir
pose a partir da bile. E, claro, como
fizemos algumas alterações, precisamos recarregar nosso módulo. E então eu posso usar minha função. Agora, diz nome de arquivo inválido. Ok, é meu personagem de fuga. Ok, deixe-me adicionar
o r na frente
dessa string para evitar caracteres
de escape. E aí está. Agora, post from file
is the director é um dicionário
vindo diretamente do conteúdo desse arquivo. Excelente, então agora podemos
ler e gravar arquivos. Antes de seguir em frente, não
quero esquecer de fazer minhas sequências de documentos. Desculpe por isso. Então, vamos
fazer uma viagem que deve os dados ao arquivo. Em seguida, o nome da postagem será uma
string do arquivo resultante. Exemplo. Mais uma vez, o que você coloca no
documento depende de você. Desde que seja
descritivo e útil o suficiente. Pausar o ato será um
dicionário e diremos conteúdo da pose. E não estamos devolvendo
nada nesse caso. Então, vamos fazer o mesmo com
a função de leitura. Faça uma ponte, posicione dados. Arquivo. O caminho do arquivo
será uma string. Eu acho que esse é
muito autoexplicativo. Vamos, vamos apenas
adicionar um arquivo para ler. E então o valor de retorno
será um dicionário. Um dicionário. A próxima coisa que precisamos
fazer é saber quais poses
temos
no diretório, para que possamos preencher a biblioteca com elas. Isso significa que precisamos
colocar todos os arquivos dentro desse
diretório raiz que escolhemos. Então, como eu disse,
o nome do arquivo será o
nome da pose e o conteúdo
do arquivo
serão os valores da postagem. Então, vamos prosseguir e colocar os arquivos dentro
desse diretório. Podemos usar a
biblioteca do sistema operacional novamente. Deixe-me voltar aqui. Deixe-me excluir todo
esse código para que não
precisemos mais dele. Vamos simplesmente deixar
a biblioteca do sistema operacional. O diretório com o qual estamos
trabalhando. Vamos colocá-lo de volta aqui. Há uma função dentro da biblioteca
do sistema operacional
chamada list lá. O que é necessário é
um caminho de diretório e ele fornecerá
uma lista de todo o conteúdo dentro
desse diretório. Então, podemos dizer que, como é uma lista,
podemos percorrer essa lista. Podemos dizer que para o item está
sempre impensado. Vamos simplesmente imprimir esse item. Aí está. Então, o que é que
os três arquivos que
criamos até agora são
duas poses e um arquivo TXT. Agora não queremos que seja o arquivo C, queremos apenas os arquivos JSON. E também queremos saber
os caminhos de arquivo desse, desse arquivo, certo? Então, agora temos o arquivo, o nome do arquivo, mas queremos obter o caminho
completo do arquivo. Então, o que eu vou fazer
é criar uma função que terá um dicionário com
o nome da pose,
digamos, nome do post. E também terá o caminho para o arquivo que contém
o conteúdo dessa postagem. Vamos voltar ao PyCharm e
começar a escrever essa função. Vamos colocá-lo aqui no topo. Eu vou, já que
vamos
pegar um dicionário dessa pose, vou chamá-lo de dicionário de
obter poses. Agora, mais uma vez
, vou adicionar a docstring porque
sei o que estou esperando. Bom dicionário
com um nível muito alto. Moisés. E eu vou dar um exemplo. O dicionário será mais ou menos
assim. Teremos o
nome do post como chave e o caminho para a pose
como um valor, cinco. Mas agora
isso também significa que os
arquivos precisam ser exclusivos, pois confiamos no nome
do arquivo para ser o
nome da pose. Também estamos limitando a ferramenta para não poder
duplicar poses. Mas eu acho que está tudo bem. Desculpe, não pulsos duplicados. Você pode duplicar
a pose, você não pode duplicar o nome da pose. Vamos
devolver um dicionário. Ok, então, mais uma vez ,
queremos listar todo o conteúdo em
nosso diretório raiz. Então, vamos
dizer que, mais uma vez, item em nossa lista, vamos usar
nosso diretório raiz. Na verdade, vou
chamar esse nome de arquivo. Já que é com isso que
estamos trabalhando. Estamos trabalhando com volumes. Agora. Vamos inicializar um dicionário
vazio. Vamos chamar isso de “pose”
de ser um dicionário vazio. E precisamos primeiro obter
o nome das postagens. O nome do host
será, como eu disse, o nome do
arquivo sem a extensão. E também, como eu disse, só
queremos obter as poses que terminem com dot json porque esse
é o formato que escolhemos. Então, nesse caso, se
tivermos esse arquivo TXT, queremos ignorá-lo. Então, vamos colocar
esse cheque primeiro. Digamos que se o
nome do sublinhado do arquivo terminar com a extensão, que é x, na verdade
vamos fazer o inverso. Se não for o nome do arquivo e extensão de
suor que
escolhemos, que é Jason. Vamos simplesmente
continuar e pular esse arquivo. Excelente. Então, agora podemos
postar o nome desse arquivo. Esse é mais uma vez o nome
do arquivo sem a extensão. Portanto, podemos fazer isso
dividindo a divisão de pontos do nome do arquivo. Vamos dividir pelo período
pelo ponto. Isso nos dará o
nome do arquivo, combinado com o nome do
arquivo e a extensão. E só queremos o
nome do arquivo, que é o primeiro
item dessa lista. Então, temos o nome da postagem e agora queremos o caminho
completo para o arquivo. Queremos que o caminho do arquivo
seja juntarmos o diretório e
o nome do arquivo. Portanto, sempre
haverá um caminho de pontos na junta, como
fizemos antes. Vamos nos juntar
ao diretório raiz. E o arquivo, o arquivo que obtivemos ao inspecionar o conteúdo
desse diretório raiz. Aí está. Então esse será o caminho do arquivo. Então, digamos que espero que não
estejamos indo muito rápido. Vamos imprimir
o que temos até agora. Digamos que o nome do host será, vamos ver o que
obtemos pelo nome da postagem. Deixe-me duplicar essa linha. Vamos imprimir uma pose. O caminho do arquivo será o caminho do arquivo. E aqui, vamos ter certeza de que
estamos pulando corretamente. Então, vamos
dizer que está pulando. E digamos o nome do arquivo. O que estamos pulando. O que estou fazendo aqui é fazer dentro da declaração
impressa. Estou colocando uma vírgula e você pode imprimir várias coisas
juntas dessa forma. Então, vamos voltar para Maya. Vamos usar nossa função
que é chamada de boas postagens que a têm carregada aqui. Mais uma vez, já que
fizemos algumas alterações, vamos recarregar nosso módulo. E vamos simplesmente executar biblioteca no círculo,
sublinhado, ponto central, ser postado. Eu não preciso de
pós-transplante agora. Ótimo. Aí está. Então, estamos obtendo, suponha, aquele JSON ou obtendo o
nome da postagem a partir dele
dividindo o nome
do arquivo e
pegando apenas a primeira parte. E também estamos pulando test.txt porque não
termina com Jason, certo? Então, esses são os valores que
queremos para o dicionário. Queremos o nome da
pose que estamos fazendo. E queremos o caminho para o
arquivo que tem o conteúdo. Então, tudo o que resta a fazer é excluir essas duas linhas e
também essa declaração impressa. Tudo o que resta a fazer é
preencher nosso dicionário. Então, nosso
dicionário vazio aqui apresenta. Agora, as chaves do dicionário
serão os nomes do nome
da postagem e o valor de cada chave será o caminho sublinhado
do arquivo. Isso é tudo que precisamos fazer. E então precisamos
devolver esse dicionário. Então, vamos testar isso. Vamos executar esse código, recarregar o módulo
e executar a função. Nada aconteceu porque
não estamos imprimindo, é claro. Então, podemos mostrar isso em uma
variável chamada poses. E imprima essa variável. Deixe-me, deixe-me esvaziar
minha janela de saída. Aí está. Agora temos um dicionário
com vários valores, que são apenas as políticas
com as quais nos preocupamos. Então, pose de teste, um
caminho para o arquivo. Primeira pose e o
caminho para o arquivo. Agora você pode ver que estamos
recebendo barras duplas. Isso porque estamos usando a função,
o 0 é um caminho
para unir a função. Portanto, isso
garantirá que você obtenha um caminho de arquivo válido e que não
cause problemas. Portanto, ter
essas barras duplas não
é um problema. Podemos ler arquivos deles. Aí está. Então,
agora podemos saber, podemos usar isso para
preencher nossa biblioteca.
39. Criar uma IU: Agora que temos a
funcionalidade de que precisamos, podemos seguir em frente
e criar a interface do usuário. Agora, essa interface de usuário é
diferente da anterior. Além disso, é um
pouco mais complexo, mas nem tanto. Mas principalmente porque estamos recebendo
informações do usuário agora, tanto por meio da seleção dessa lista quanto de uma entrada de texto. Quando sérvios, eles recebem o nome
da postagem para salvar. Vamos detalhar rapidamente
como essa interface de usuário é composta. Vou fazer uma captura para poder desenhar em cima dela. Lembre-se de que falamos
sobre layouts e como layouts basicamente compõem
o que as interfaces de usuário realmente são. Então, neste caso, temos a lista de poses e
temos esse botão aqui. Isso significa que precisamos de um layout que
flua de cima para baixo. Isso seria um layout de coluna. Essa primeira seção
será um layout de coluna. Então temos essa seção
dobrável. E esse é outro layout que tem um layout dentro dele. Agora, a razão pela qual precisamos
dessas coisas em seu layout é porque a próxima seção também
está fluindo
de cima para baixo. Como você pode ver, temos
essa linha aqui. E então temos a pose, o botão de pose segura. Então esse será
outro layout de coluna. Mas dentro desse layout de
coluna, temos esse texto ao lado. Temos esse campo de entrada que
precisará de um layout de linha porque está fluindo
da esquerda para a direita. Portanto, não é realmente
tão complicado. São apenas alguns layouts que
criam o fluxo dessa ferramenta. Basicamente, temos um
layout de coluna para layouts de coluna, um layout de linha e, em seguida, um layout
extra dobrável. Na verdade, isso é apenas para os layouts tenham essa
ferramenta concluída. Vamos comprar um termo e
começar a trabalhar em nosso código. Então, mais uma vez, a forma como
organizamos nosso código é que temos esse módulo principal
que tem a função principal. E temos um módulo completamente
separado que será para a interface do usuário. Portanto, tudo o que for necessário
apenas para a interface do usuário estará aqui. Qualquer coisa que tenha a ver com funcionalidade e, na verdade,
qualquer coisa que possa ser usada independentemente da interface do usuário deve ficar fora
desses módulos de interface. Provavelmente vou
entrar no núcleo. Então, algo que precisamos
fazer que também é diferente
para esse tipo de interface de usuário, é porque estamos
consultando informações ou recebendo informações
do usuário por meio da interface. Precisamos nomear nossos elementos de interface muito
específica, não especificamente, mas exclusivamente. Precisamos dar um nome exclusivo à nossa
janela para que possamos consultar as
coisas dessa janela. E precisamos dar um nome
específico a
todos os elementos da interface do usuário para que possamos
obter informações deles. Vamos começar criando
a janela que precisamos. Os maias invadem esta biblioteca,
esse é o seu ombro. Então, a partir da entrada do Maya, da biblioteca
CMBS, estamos vendo o S.
E eu vou
criar uma função
chamada show you why. Agora estou usando esse nome para me manter consistente com a outra
função em nossas outras duas. Dentro dela, temos que
criar uma janela, mesma da última vez. Vamos dar um título a ele. Título é igual à biblioteca de poses. E então, como você se lembra, temos que mostrar essa janela. Então Cmd S dot show window. Deixe-me ter certeza de que
não tenho certeza da janela. E então precisamos passar o nome da janela
que estamos mostrando. Então, da última vez com a outra ferramenta, deixamos que minha outra janela lateral, o nome interno da janela, e deixamos que o Maya a entregasse para nós, começasse a armazená-la
nessa variável. Então, simplesmente mostramos isso. Agora, a maneira como
essa ferramenta funciona é
que você pode realmente abrir várias cópias
dessa janela. E isso é bom. Mas, para a biblioteca de correios, queremos que ela seja única. Queremos que ele tenha apenas uma cópia da janela
aberta por vez. Então, por esse motivo, vou dar um nome exclusivo à nossa
janela. Vou criar
outra variável global, tudo
bem, variável de nível. Vou
chamá-lo de nome de janela. Esse será o
nome interno da biblioteca de interface do usuário. Ui. Agora, como mencionei antes, estou escolhendo todas as letras maiúsculas para
as variáveis globais porque isso indica que é um valor constante
em todo o código. Então, vamos
criar nossa janela usando esse nome exclusivo
em vez de deixar que eu escolha um nome para nós. E então eu vou
mostrar o nome da janela. Correto. Então, vamos até Maya e ver como
isso parece. Então, vamos importar da biblioteca
de postagens, importar a interface do usuário e
fazer alterações nela. Então, vamos ter nosso comando de
recarga pronto. Digamos que eu não
mostre, sublinhe a interface. Aí está. A janela está vazia, é claro, mas temos o
título que escolhemos. Agora, se eu executar isso de novo. Sem fechar a janela, você verá que
recebemos um erro. Dizemos que a
interface de usuário da pós-biblioteca não é exclusiva. O que está acontecendo aqui
é que quando eu fecho essa janela, o nome desaparece. Mas quando eu o abro e
tentei iniciá-lo novamente, não
consigo criar a janela. Você pode ver que quando estamos tentando
criar a janela, ela reclama que
o nome já existe. Portanto, há algo que
podemos fazer sobre isso,
que é simplesmente excluir a interface do usuário. Assim, podemos adicionar um cheque
antes de criar uma janela. Podemos verificar se a interface do usuário existe. Podemos dizer se a janela de pontos CMBS
e, em seguida, o nome da
janela, desculpe, o nome
da janela entre parênteses existe. Porque é verdade. Então, estamos consultando, na verdade,
temos que consultar esse valor. Ou posso simplesmente dizer que
consulta é igual a verdadeira. Você também pode escrever q
igual a verdadeiro se quiser, mas eu vou escrever o nome
completo do argumento. A consulta é igual a verdadeira. Basicamente, se a janela existir, vamos
excluir essa janela. Isso é feito por meio do comando
CMBS Dot Delete UI. E vamos deletar
o nome dessa janela. Nome da janela. Ótimo. Então, o que vai acontecer é que,
se essa janela já existir, vamos excluí-la
completamente e criar
uma nova do zero. Então, vamos ver como isso
funciona. Aí está. Agora podemos executar esse
código várias vezes. Não recebemos erros. Excelente. Em seguida, precisamos
criar a parte superior, que é a parte
usada para aplicar as poses. Portanto, precisamos de uma lista e de um
botão que
estejam dentro de uma grade de layout de
coluna. Então, vamos chamar esta seção de seção de postagens
aplicadas. Precisamos de um layout de coluna. Suponha o layout da coluna de pontos S. Se você se lembra da última vez, estávamos fazendo uma coluna ajustável
igual a verdadeira para que
os widgets se expandam
automaticamente com a janela. Então, vamos usar isso também
neste caso. Eu apenas uma
coluna dupla é igual a verdadeiro. E lembre-se de que,
quando criamos uma interface de usuário, eu defino que esse layout se torna o atual parlamento principal de qualquer outra coisa que
criamos depois disso. Então, sabemos que precisamos
criar um botão. Essa é fácil.
Nós conhecemos o fundo. Sabemos que o texto na parte inferior está abaixo do argumento
do rótulo. Então, vamos dizer que
rótulo é igual a pose aplicada. E precisamos adicionar um
comando ao botão, mas nossa abordagem será criar primeiro o esqueleto
da interface do usuário. E então fazemos todas as conexões para a
funcionalidade real que temos. Então, temos um botão
e precisamos de uma lista. Agora, para criar esse tipo
de lista que queremos, existe um comando
chamado Lista de rolagem de texto. Agora, como eu sei disso? Eu pesquisei na internet, encontrei alguns exemplos on-line. E esse foi o
melhor widget que encontrei para o que queremos fazer. Então, vamos ver
os exemplos disso. Scroll is tech scroll
é essa documentação. Veja o que podemos fazer. Somente o número de linhas, seleção
múltipla. Talvez possamos
simplesmente criá-lo vazio. Então,
vamos simplesmente criar a lista
e ver como ela fica. Então, esta será a CMBS, a lista de rolagem de texto artístico. Próxima lista de rolagem,
vamos chamar isso. E vamos ver como isso
parece até agora. O código, aí está. Temos uma lista e temos lâmpadas
com tampa de botão. Excelente. Vamos deixar essa seção assim por enquanto. Vamos passar para a
próxima seção da sessão. Mais uma vez, estamos tentando terminar
o esqueleto o mais
rápido possível. E então nós voltávamos
e os poliríamos. A funcionalidade de qualquer outro detalhe de
que possamos precisar. Para nossa próxima seção, precisamos esclarecer isso em
nossa próxima seção precisamos desses layouts
dobráveis. Agora, esse é um tipo de
layout chamado layout de quadro. Quadro disposto. Vamos ver a documentação
para isso. Vou mais uma vez
direto aos exemplos. Geralmente, essa é a
maneira mais rápida de obter um exemplo desse layout de quadro. Com um rótulo. Precisamos de
um rótulo porque queremos, queremos que ele permaneça para
nos dar o nome desta seção. Portanto, esse
rótulo de layout de quadro é igual a uma string. Portanto, esta seção será salva. Seção de pose. Excelente. Então, layout de quadro de
pontos CMBS. E vamos ligar para
a gravadora por segurança. Pose. Excelente. E então, dentro desse layout, falamos sobre ter
um layout de coluna. Vamos criar o layout da
coluna que vamos usar
na segunda seção. E, na verdade,
vamos reutilizar o que temos aqui. Porque precisamos do
mesmo tipo de layout. Também queremos que seja ajustável
para que se expanda
automaticamente. Agora, abaixo disso, sabemos que
queremos esse
layout de linha com um nome, rótulo chamado nome
e um campo de texto. Então, o perdão atual é
esse layout de coluna, certo? Então, queremos adicionar um layout de linha
sob esse layout de coluna. E queremos que ele tenha dois
elementos dentro dele. Na verdade, lembre-se mais uma vez ,
do nosso anterior, na
verdade não estava nas fezes
, estava em outro exemplo. Precisamos, precisamos
especificar o número de
elementos que estão, o número de colunas que
estarão no layout da linha. Vamos ver como isso é feito. Vamos ao lançamento da
mostra de documentação. Nós fizemos. Diz o número de colunas. O número de colunas
é igual ao número de itens que queremos nessa camada. Excelente. Portanto, o número de colunas
será igual a dois porque
precisamos apenas de um texto, um trecho de texto e também
do campo de texto. Ótimo. Agora que nosso layout de linha
é o pai atual, podemos adicionar nosso rótulo
ou um pedaço de texto. E se você se lembrar
mais uma vez da ferramenta anterior, podemos roubá-la. Assim, podemos roubar o
comando de textos com o rótulo. Podemos manter as coisas simples. Texto simples com um
rótulo e o rótulo dirá o nome. Ótimo. E depois ao lado desse
texto, rotule, isso aí. Ao lado desse rótulo de texto, precisamos de um campo de texto. Para o campo de texto, há um widget com um nome muito
conveniente
chamado campo de texto, que é este aqui. Tudo o que ele faz é dar a
você um espaço para digitar. E também podemos consultar informações desse campo
de texto. Então, vamos dar uma
olhada rápida nos exemplos. Parece que podemos simplesmente
chamá-lo e ele
nos fornecerá esse campo de texto. Então, vamos seguir em frente e
fazer esse campo de texto. Aí está. Então, vamos
ver o que está acontecendo, como está até agora. Vamos voltar ao Maya
e executar novamente nossa interface de usuário. Ok, ótimo. É como se estivesse vendo algum
progresso, não é incrível. Nossa seção dobrável
não está realmente desmoronando. Parece apenas
mais um pedaço de etiqueta. E, por alguma razão,
nosso campo de texto não
está, não está ocupando todo
o espaço. Ok, podemos consertar isso. Mas vamos
terminar de adicionar todos
os botões e depois
voltaremos e tornaremos
essa seção dobrável. Portanto, a última coisa que precisamos
adicionar é o botão de postagem segura. Isso deve ser fácil. Podemos dizer que
botão de ponto CMBS, rótulo é igual a salvar. Agora, se executarmos isso agora e vamos
ver como é. Muitas crianças no
layout, no layout da linha. Ok? Então, mais uma vez, como mencionei, o atual pai
está sendo lançado. Então, poderíamos corrigir isso dando
ao Rowley adicionar mais um filho
ou mais uma coluna para adicionar. E isso nunca mais acontecerá. Mas agora o botão de pausa segura está aqui e não o
queremos lá. Queremos isso
nessa seção, certo? Então, o que precisamos fazer é mudar o layout principal de linha atual
para a parte anterior, que é o layout da coluna. Como fazemos isso? Fazemos isso usando este comando,
toupper e função atuais definidos. E há uma notação muito
específica que minhas pernas são dois pontos. Vou fazer
um comentário aqui. Layout como novos pais. Mais uma vez, o layout atual
ou atual. O pai atual
é o layout da linha. Então, definimos o novo pai como o layout da
coluna anterior. E agora nosso botão deve
estar na coluna e não na linha. De novo. Aí está. Isso se parece mais com
o que estamos procurando. Então, agora vamos voltar e fazer com que essa seção realmente colapse. Mais uma vez, essa
seção dobrável é o layout da moldura. Então, se formos até a
documentação, vamos procurar esse layout de quadro. Existe um argumento
chamado Collapse. Na verdade, desculpe, é
chamado de dobrável. Ele lida com a flexibilidade
do layout da moldura. Isso faz sentido. Então,
podemos simplesmente usar um booleano. Então, podemos simplesmente
dizer dobrável. Dobrável é igual a verdadeiro. E isso
deve resolver isso. Recarregue nosso código
e execute-o novamente. E aí está. Agora nós estamos
entrando em colapso. uma seção que pode ser desmontada. Excelente. Então, isso está funcionando
porque, mais uma vez, o layout da coluna
é colocado sob esse layout de quadro
e tudo o mais nessa seção fica
sob esse layout de coluna. Então, estamos realmente colapsando
essa camada de coluna. Agora, a próxima coisa que
temos aqui é essa seção, essa seção clássica
tem uma cor diferente. Ainda não temos
isso em horas, então vamos mudar isso. E então queremos corrigir esse
TextField sendo muito curto. Queremos que ocupe todo
o espaço disponível. Vamos ver como mudar a cor
do nosso layout de moldura. Voltar para a documentação. Existe um argumento
chamado Cor de fundo. E diz que essa é a cor de
fundo do controle. Controlar esse caso
significa elemento de interface do usuário. Os argumentos correspondem
a vermelho, verde e azul, já que os valores RGB cada componente
variam de 0 a 1. Então, como você sabe, ou como você deve saber, RGB vai de 0 a 255,
faz , faz, faz uma faixa
de valores para RGB. Maya quer que você traduza isso em um intervalo de zero a um, o que é muito fácil de fazer. E está pedindo uma lista. Nesse caso, pode ser uma
lista ou uma tupla com os valores R, G e B, vermelho G e B, vermelho,
verde e azul. Então, vamos usar
esse argumento de fundo. Plano de fundo, cor igual,
vou usar uma tupla. Agora, esses valores serão de
0 a 1 e eles são flutuantes, como você pode ver aqui
na documentação, é um valor flutuante porque há
um ponto decimal nele. Então, a primeira coisa
que vou fazer é escolher uma cor com a qual
eu esteja feliz. Você pode escolher
qualquer conjunto de valores RGB. O que eu gosto de fazer é procurar
online por um seletor de cores RGB. Por exemplo, o Google tem um aqui. Eu escolhi um pouco como
uma cor azul clara. Então, deixe-me encontrar
algo assim. E esses são os valores RGB. Assim, podemos pegar esses valores
e convertê-los a partir de, mais
uma vez, o
intervalo é de 255. Portanto, esse é o valor máximo e o menor
valor será zero. Assim, podemos converter
esses números
desse valor para transformar essa chave
em um intervalo de zero a um. Deixe-me copiar e
colar isso no Maya. Vou usar o Python
para fazer essa conversão. Então, precisamos fazer um pouco de matemática, pois isso é compressão, mas é matemática muito simples. Então, digamos que se nosso
valor para o valor RGB for zero, o equivalente no intervalo de zero a um
seria zero, certo? Se seu valor RGB for, o valor máximo é 255, o equivalente no intervalo de zero
a um seria um
ou, nesse caso, 1,1. Isso significa que
tudo o que precisamos fazer é dividir nosso valor por 255, e isso
nos dará esse intervalo. Então, neste caso, eu tenho isso. Esses três números aqui. Tudo o que preciso fazer se quiser
saber o equivalente disso
na faixa de zero a um, posso simplesmente dividir por 255,0 porque quero que isso me
dê uma flutuação resultante. E esse é o resultado. Então, vamos fazer isso com
mais eficiência e fazer um simples loop for
para esses valores. Então, para o valor neste lugar
através dessa tupla de números, vou dizer valor de impressão dividido por, dividido por 255,0. Isso me dará os valores que
queremos , isso ou aquilo, essa árvore. Vamos copiá-los e
trazê-los para o nosso código. Agora, eles têm
muitas casas decimais, mas na verdade não
precisamos de tudo isso. Nós apenas fazemos isso. Os locais de e-mail devem ser suficientes. Então esse será o nosso vermelho. Este será o nosso azul. Desculpe, nosso verde, G ,
vermelho, verde e azul. Aí está. Vamos voltar para Maya e
ver como isso parece. Esse é o código errado. Esse é o código
que eu quero executar. Aí está. Então, agora essa seção parece
um pouco melhor. Não gosto de como
fica com o texto. Então, vou escolher
uma cor um pouco mais escura. E como já temos o código para fazer essa tradução, podemos simplesmente fazê-lo aqui, executá-lo. Vamos colocar isso muito rapidamente
em nosso código. Então, vou pegar as duas
primeiras casas decimais. Eu só vou
tocá-lo com a mão. Então, são dez. O
próximo é 0,54 e o próximo será 0,67. Vá, volte, tente novamente. E isso é melhor. Agora
podemos ver o título desta seção e temos
uma cor diferente nela. Claro, você pode escolher a cor
que quiser. Esta é a sua ferramenta,
você está no controle. Agora, a próxima coisa
que queremos cuidar é o tamanho desse TextField. Agora, uma maneira fácil de fazer isso
seria dar uma largura fixa, digamos 400 pixels. E isso resolve tudo. O problema é que agora não
podemos, não podemos redimensionar
a janela para menos 400 pixels agora,
o que é um problema. Então, em vez disso, podemos lidar com o dimensionamento
por meio do layout. Na maioria das vezes, quando
você precisa lidar
com tamanhos e como os
widgets são ajustados
na interface de usuário
controlada por layouts. Portanto, há uma boa chance de
que, no layout da linha, tenhamos algo para nós. Está aqui mesmo. É o primeiro argumento que
vemos, coluna ajustável. Então, vamos ver o que diz. Especifique, especifica
qual coluna tem um tamanho ajustável que muda com o
tamanho do layout. Isso é
exatamente o que queremos e é preciso um número inteiro como argumento. Então, vamos usar isso. Acabei de dobrar a coluna igual
ao número de colunas. Então, digamos, vamos remover
isso do campo de texto. Não queremos fixar o
tamanho no layout da linha. Queremos dizer que a
coluna ajustável é igual. Agora,
os layouts começarão a contar
em um, não em zero. Então essa será
a primeira coluna. O primeiro item estaria aqui. O segundo seria o que
queremos que seja ajustável. Então, vamos
dizer que uma
coluna dupla é igual a verdadeiro é igual a dois. A segunda coluna
deve ser redimensionável, saiba, e pronto. É isso que queremos
alcançar. Excelente. A interface do usuário está tomando forma. Podemos deixar assim, se você quiser, mas acho que podemos fazer alguns ajustes para
torná-lo um pouco mais agradável. Eles aplicaram o botão de pausa. Pode ser um pouco maior, já que esse é o
botão principal que temos. Pode haver um pouco de espaçamento entre nossos elementos. Então, vamos ajustar o espaçamento, o layout da coluna como um
argumento chamado espaçamento entre linhas. Vamos configurá-lo para dez pixels, por exemplo, isso é um pouco demais. Vamos cortá-lo ao meio para cinco. E para o botão, digamos uma altura de 60 pixels. Vamos ver como isso parece. Isso é demais, mas
acho que o espaçamento é
um pouco melhor. Então, vamos chamá-la de
altura em meio 30. Ok, isso é um
pouco melhor. E acho que o botão de postagem segura também
poderia ser um pouco
maior. Então, vou pegar esse argumento e adicioná-lo
a esse botão de pausa segura, mas vou fazer com que
ele tenha 25 pixels de altura. É uma pequena mudança, mas acho
que é muito bom. A última coisa que queremos fazer antes de passarmos a
conduzir
a funcionalidade para a interface do usuário é garantir
que a lista tenha
apenas um
item por vez. Agora, vamos ver como
isso funciona agora. Portanto, podemos preencher previamente essa
lista para fins de teste. Se você olhar os exemplos, podemos acrescentar,
vamos roubar esse
argumento, por exemplo, anexar. Certamente, vamos pegar
os três primeiros itens. Então, se dissermos que anexar
é igual a pelo menos de itens, vamos adicioná-los , vamos
anexá-los à lista na interface do usuário. Então, se eu fosse atualizar isso, agora temos todos esses itens. Então, acontece que já
é preciso apenas um. Então, a seleção 11
por vez, o que é ótimo. Se você quisesse que fosse uma
seleção múltipla, duas vezes. Existe uma opção para o que é permitido, a
seleção múltipla é igual a verdadeira. Agora, se por algum motivo
para esta ou para outra ferramenta, você queria que ela fosse múltipla. Ter uma seleção múltipla. Você pode permitir que a
seleção múltipla seja igual a verdadeiro. E quando consultarmos a seleção na
consulta, você obterá uma lista
dos objetos selecionados. Mas, no caso dessa ferramenta, queremos aplicar apenas
uma postagem por vez. Então, na verdade, vou
ser explícito e dizer que permitir seleção múltipla
é igual a falso. Agora, o comportamento padrão
é obviamente falso, mas acho que ter isso
explicitamente
será uma boa adição. Vamos colocá-lo lado a lado. Eu acho que isso parece muito parecido. É
basicamente o que queremos. Então, vamos deixar a interface do usuário assim. Vamos começar a conectar
a função. Tudo o que fazemos.
40. Conectar a funcionalidade e compartilhar suas ferramentas: Ok, podemos começar a trabalhar
na funcionalidade da interface agora. Deixe-me atualizar meu código. Então, agora, para fins de
teste, estamos anexando itens, faça isso, mas não
queremos fazer isso. Queremos preenchê-lo com base nos
arquivos existentes que temos. Íamos criar uma
função chamada Add Pose. E, a propósito, me desculpe, eu não adicionei uma docstring
à minha função show UI. Mostrar pose, biblioteca, URL. Este é mais
autoexplicativo para células, então ele realmente não
precisa da sequência de documentos, mas quero ter certeza de
manter os bons hábitos. Então, vamos adicionar uma
pose à lista de rolagem. E do jeito que fazemos isso, vamos obter ou postar o nome. E vamos
adicionar isso à lista. Como fazemos isso? Bem, podemos usar
o mesmo comando. Muitos desses comandos para nós, mas também para lidar com
nós, permitem criar, editar e consultar informações
usando tudo isso e comandos. Então, vou usar
o mesmo comando. Mas agora precisamos saber qual lista estava sendo
modificada, certo? Então, do jeito que eu vou fazer isso, será semelhante à forma como estamos negociando a janela. Vamos criar
um nome exclusivo para essa lista de rolagem para
que possamos usá-lo
em todo o código. Então,
eu vou criar uma
nova variável global chamada nome da lista de texto. E eu vou dar a
ele um nome único. Esses nomes, textos e listas que
devem ser exclusivos o suficiente. E desculpe, esqueci
de atribuir o valor. Agora, quando eu criar
a lista de rolagem de texto, vou criá-la
com esse nome exclusivo. E isso é feito simplesmente
passando o nome como primeiro argumento para
essa função de lista. O que significa que, quando estou
tentando editar essa lista, posso usar o mesmo nome para
direcionar a mesma grade da lista. Agora, quando eu estiver editando uma lista, se eu fizer isso agora, Maria tentará criar uma
nova lista com o mesmo nome. O que queremos para editar essa lista, vou dizer que
Editar é igual a verdadeiro. E como você sabe, na verdade eu vou deixar, então vamos terminar isso
e então eu vou
te mostrar algo
na documentação. O que eu quero editar é o, o, os elementos na lista. Então, eu quero acrescentar novos
elementos à lista. O que eu quero fazer é
acrescentar esse nome de pose. Agora, isso é o que eu
quero te mostrar. Vamos até a
documentação e dar uma olhada nesse argumento. Estamos na documentação das
listas técnicas roladas. E se procurarmos
o argumento anexo, podemos ver que ele tem essas cores e
essas letras aqui. C é para criar. Você pode criar uma lista enquanto
acrescenta algo a ela. Você pode editar, o que
significa que você pode acrescentar itens a
uma lista existente. E m é multiuso. Vamos ver o que isso significa. Isso significa que o voo pode ter vários argumentos passados, seja como uma tupla ou uma lista. Ok, isso faz sentido porque
estamos esperando uma lista. E se vemos, vemos
o tipo esperado. Na verdade, isso é
muito enganador. Está esperando uma corda. Mas, no exemplo,
vemos que é uma lista. Acontece que
você pode fazer as duas coisas. Você pode fornecer uma lista de elementos ou
fornecer um único elemento. Então, nesse caso, vamos fornecer um
único elemento como uma string. E vamos apenas testá-lo. Mas antes disso, vamos
adicionar a docstring. Você posta o nome na lista. Sabemos que o
nome da postagem é uma string. E eu acho que o nome é
muito autoexplicativo, então vou pular
a descrição para isso. Aí está. Então, vamos testá-lo. Então, vamos adicionar algumas poses. Uma vez que eles, uma vez que tudo
esteja criado, na verdade ,
mesmo depois de mostrar a janela ,
podemos adicionar algumas poses, vamos adicionar a próxima. Vamos adicionar um
teste também, por exemplo, vamos garantir que isso esteja funcionando. Então, quando eu
recarrego, eu tenho essas duas poses. Excelente. Então esse é o primeiro passo. Agora sabemos como
editar nossa lista. E quero dizer, nós
também poderíamos fazer o mesmo aqui. Podemos fazer, podemos dizer UI, o Add Pose e
chamar isso de outro teste. E isso atualiza a
lista para você. Ótimo. Então, agora queremos
criar uma função que preencha automaticamente
todas as poses para nós
quando iniciarmos a biblioteca. A primeira coisa que queremos fazer é limpar essa lista para que
possamos preenchê-la de forma nova. É como
uma função de recarga. Portanto, há um argumento
chamado remover tudo. Remova tudo. Isso simplesmente
limpará a lista. Então, vamos fazer isso. Vamos, na verdade,
chamamos essa função. Podemos chamar isso de poses de preenchimento. Poses, ou podemos chamar isso de recarga. Reload é um nome novo e melhor. Recarregar. Recarregue poses. A primeira coisa
que queremos fazer é
limpar a lista para que fique vazia. E deixe-me roubar
essa linha de código. Então, mais uma vez, vamos
focar na mesma lista. Nós vamos editá-lo. Mas agora queremos remover tudo. E, como você pode ver,
podemos usar esse argumento ao criar a lista
ou ao editar a lista. Então, vamos remover
tudo igual a verdadeiro. E isso deve limpar
a lista, fazer um comentário. E agora que queremos reunir os nomes das
postagens que
salvamos neste sistema. Então, para isso, já
temos uma função. Lembre-se de que criamos
essa função que fornece um
dicionário com todas as políticas
disponíveis para você. Portanto, precisamos importar
nosso módulo principal. Então, podemos dizer de uma biblioteca, importe Core, que
será esse aqui. Agora, a partir desse módulo principal, queremos obter o dicionário de
pós-dicção. Este dicionário
será igual a core, dot, get poses,
detect, get poses. E como você pode ver, o PyCharm
é preenchido automaticamente para mim porque estou dentro
do mesmo projeto. Excelente. Então, se você se lembrar, esse dicionário terá
o nome das postagens como chave e, em seguida, o
caminho do arquivo para essa postagem. Então, o que nos importa neste caso é o
nome dessas poses. Como fazemos isso? Ao obter todas as
chaves do dicionário. Ambos os nomes são iguais a
poses, ditam chaves. Então, isso nos dará uma lista
de chaves desse dicionário, que serão todos os
nomes que nos interessam. Excelente. Então, tudo o que precisamos fazer agora é adicioná-los à nossa lista para que
possamos fazer um loop for para, vamos chamá-lo de nome
por nome em nomes. Adicione postagens sublinhadas. E vamos passar
esse nome de string. E eles deveriam, eles
deveriam cuidar deles. Popular em depósitos
significa que
não precisamos mais desse código de
teste. E podemos simplesmente, vou adicionar um comentário,
chamá-lo de preenche poses. Quando podemos simplesmente chamar nossa função de recarga,
recarregar, postar isso. Depois de tudo ter sido
criado. Aí está. Vamos testá-lo. E aí está. Essas
são as políticas que tínhamos anteriormente em nossos testes. Agora, se você quiser que
eles estejam em ordem alfabética. Existe outra
função chamada sorted. Ou você também pode dizer nomes de
pose, ordenar pontos. A diferença
é que a espada de pontos classificará sua lista no mesmo lugar. E a função de classificação fornecerá uma lista
completamente nova. Então, vamos usar esse. Classifiquei esses nomes. Vou chamar
isso de lista ordenada. Na verdade, ordenadas
posiciona certos nomes, vou
chamá-las de certos nomes. Agora, queremos
repetir os nomes ordenados. Agora eles devem estar em ordem
alfabética. Refere-se ao código. Oh, na verdade, estamos vendo esse outro teste porque eu o estou
adicionando aqui por acidente. Então isso não deveria estar lá. Mas agora, quando eu atualizo o código, não
devemos ver outro teste porque
houve um acidente. Mas devemos ver as
outras políticas que
vêm dos arquivos em ordem
alfabética. Agora você vê que a primeira
pose com meu erro de digitação vem primeiro e depois o
teste. Então, agora estamos preenchendo a interface do usuário. Antes de prosseguirmos,
a docstring reúne poses de arquivos e
preencha, liste-as com elas. Não devolvemos nada. Então, eu posso simplesmente
deixar isso como uma única luz. Aí está. A próxima coisa que
precisamos fazer é obter a seleção
do usuário para que possamos aplicar essa pose
ao personagem. Há um argumento
chamado selecionar item na lista de rolagem que você pode usar
ao consultar editar
ou criar. Isso significa que podemos consultar esse argumento diretamente
dessa lista. Então, eu vou criar uma
nova função aqui embaixo, que vai
chamá-la de pose selecionada. Então, agora, em vez de
editar a lista, queremos continuar
segmentando a mesma lista, mas agora queremos
consultar algo. E o que queremos
consultar será o item removido. Então, quando você está
consultando algo, você simplesmente queria dizer
ao meu pai que sim, você quer consultar
remover, desculpe, não remover a escrita do item selecionado. Podemos usar isso para selecionar algo de forma dinâmica
ou programática. Mas, nesse caso, vamos
consultar a seleção. Então, vamos consultar se o item
selecionado é igual a verdadeiro, simplesmente para dizer sim,
selecione o item. Então, vamos desenhar isso em uma
variável chamada seleção. Agora, vamos simplesmente
retornar essa variável. Então, vamos ver o que
obtemos com isso. Vamos enrolar o código. Ok, então agora não
há nada selecionado. Se imprimirmos você, eu não serei selecionado, poso. Oh, desculpe, eu preciso
chamar essa função. Nós vamos receber um nenhum.
Então é bom saber isso. Nada está selecionado.
Não chegamos a nenhum. Se algo for selecionado, obteremos uma lista com
a seleção. E como estamos
permitindo apenas uma seleção única, só obteremos
uma lista com um único item. Então é bom saber isso. Deixe-me adicionar isso na docstring. Vamos dizer que
retorna uma string ou, na verdade, deixe-me mantê-la consistente
e torná-la uma string. Sempre retorne uma string, obtenha o item selecionado da lista. E poderíamos fazer com
que, se obtivéssemos nenhum, retornássemos uma string vazia. Que pensar nisso novamente, isso pode significar,
pode ser enganoso. Então, vamos realmente fazer com
que possamos voltar. De novo. Desculpe, estou
mudando de ideia em uma corda ou em nenhuma. Vamos, faremos, adicionaremos uma pequena
descrição dizendo como não, se nada foi
selecionado, caso contrário, nome
oposto,
selecionado, nome da pose. Ótimo. Então, seleção. Se a seleção não for nenhuma. Vimos o retorno None. Mais uma vez, se retornarmos, o python retornará um non de qualquer maneira. Mas estou explicitando isso
neste caso porque
queremos devolvê-lo. Caso contrário, se não inserirmos essa instrução if e
não sairmos da função. Queremos devolver o único
item da nossa seleção, certo? Então, eu vou dizer que o
item selecionado será a seleção, e será o
único e o primeiro e único
item nessa seleção. Eu vou devolver
isso. Excelente. Agora vamos, vamos testá-lo. Deixe-me recarregar e
executar novamente o código. Ótimo. Então, se eu imprimir a
seleção agora, não é. Se eu selecionar algo
que imprimi
, recebo o nome da
pose que foi selecionada. Ótimo, é
exatamente isso que queremos. Agora que sabemos como
obter uma seleção, podemos começar a aplicar as postagens. Porque podemos obter a postagem
do item selecionado na lista. Então, vou criar
uma nova função chamada aplicar a mangueira selecionada aqui. Na verdade, vou criá-lo acima dessa função
que estou usando. Para obter a seleção. Ótimo. Então, a primeira coisa que
precisamos obter é uma pose selecionada. E obtemos isso da
função que acabamos de criar. Selecione os dois. Uma vez que
essa é a função que aplicará as poses quando você adicionar
algumas verificações a ela. Portanto, se nada foi selecionado, você pode dizer se a pose não selecionada ou se a pose selecionada não for nenhuma, qualquer uma delas
será válida se pose
selecionada for conhecida
ou se não for selecionada. Vamos avisar o usuário. Digamos que seja a manhã. Selecione um pulso e simplesmente saia da
função retornando. A próxima coisa que precisamos fazer, já que estamos aplicando poses
para selecionar o personagem, é garantir que o usuário selecionado algo,
selecionado um personagem. Portanto, podemos dizer namespace ou namespaces
selecionados porque podem ser
vários iguais. E foi aqui que começamos a usar o código do
nosso projeto anterior. Se você se lembra, nosso módulo de
pós-transferência tem uma boa
função de seleção de namespaces, que podemos usar. Nesse caso, vou
importar após a transferência de sublinhado. Agora, após a transferência, posso obter a função de obter
namespaces selecionados. Mais uma vez, sabemos que,
se nada for selecionado, obteremos uma
lista vazia dessa função. Então, posso dizer que, se não,
selecione os namespaces, adicionamos outro aviso
ao usuário, dizendo: Selecione pelo menos um rake e saímos da função. O próximo passo é conseguir
a pose que queremos, o que significa que precisamos
obter o arquivo que corresponde à
postagem que escolhemos. Para fazer isso, precisamos obter os pôsteres que
já foram salvos. Poses salvas. Sabemos que podemos obter isso de uma função que já
usamos e que para preencher nossa interface de usuário está
no módulo principal. Obtenha um ditado de poses. Agora, como usamos esse mesmo dicionário
para preencher nossa lista, sabemos que a
seleção dessa lista deve corresponder a uma
das chaves do dicionário. Mas há uma chance de que enquanto trabalhamos com uma ferramenta, esse arquivo tenha sido excluído e, nesse caso, não
conseguiremos obtê-lo. Portanto, devemos adicionar uma verificação
rápida para isso. Podemos dizer que, se a
pose selecionada não estiver em poses salvas, estamos basicamente dizendo que
se essa pose
não estiver na chave
do dicionário, podemos fazer isso
diretamente dessa forma ou
podemos dizer teclas de pontos ou delimitar
a lista de teclas diretamente. O que eu vou
deixar é assim. Então, se a
pose selecionada não estiver, eles salvaram o dicionário de poses, o que significa que não é uma
chave no dicionário, então não temos nada
para aplicar, certo? Então, podemos enviar
outro aviso para o usuário que está dizendo essa pose. Agora vou adicionar
o nome da pose. Entre aspas. Vou adicionar
aspas duplas colchetes como espaço reservado. Digamos que não exista. Então eu vou
dizer formato de pontos. E então mostre ao usuário a
pose que foi selecionada. E depois do aviso, saia da função retornando. E, finalmente, quando
passamos, passamos por todas
as verificações e tudo
parece estar em ordem. Temos uma seleção
na lista de poses. Temos uma seleção na cena para um ou mais personagens. Sabemos que as postagens existem. Agora podemos obter o
arquivo dessa pose. O arquivo de pose é igual,
mais uma vez, às poses salvas. Vou renomear
isso para salvar, para postar como ditado, para torná-lo mais
explícito para você. Salvos os dois colados,
podemos simplesmente obter, agora que sabemos que essas
chaves no dicionário, podemos obter o valor delas,
que mais uma vez
será o caminho do arquivo. Então, essa pose seria selecionada é a chave nesse dicionário. Haverá o arquivo. Em seguida, precisamos obter as
informações desse arquivo. Essa seria a pose que queremos aplicar
aos nossos personagens. Agora, para fazer isso, já
temos a
funcionalidade central. Chamamos isso de ler postagens
do arquivo, ler do arquivo. E isso usará um caminho de arquivo, que é sua pose
enquanto variável. Excelente. Agora, tudo o que precisamos fazer é reutilizar
novamente a
funcionalidade pós-transplante e aplicá-la a todos os
namespaces que selecionamos. E isso serão postagens aplicadas. Usamos um
dicionário de postagens e um namespace. Como estamos permitindo
vários namespaces, podemos simplesmente
percorrer essa lista. Portanto, para namespaces em
namespaces selecionados, poste sublinhado, transfer dot apply
pose
usará o dicionário oposto
e o namespace para aplicá-lo ao ego deles. E antes de testá-lo, deixe-me fazer minha docstring. E digamos que aplique
as políticas selecionadas para selecioná-la. E não estamos
devolvendo nada. Portanto, isso pode ser uma docstring de uma
única linha. Portanto, não o
conectamos a um botão, mas podemos testá-lo
sem ter a conexão.
Vamos entrar em Maya. Vamos recarregar a interface do usuário. Aí está. É chamado de aplicar a pose selecionada. Então, podemos fazer, podemos dizer que eu não
aplique a pose selecionada. Vamos fazer alguns testes. Precisamos selecionar uma pausa. Faz sentido. Precisamos selecionar pelo menos um personagem que faça sentido. Agora, se selecionarmos o personagem em que
entramos, essa postagem
deve ser aplicada. Agora. Agora, essa é provavelmente
a mesma pose que salvamos. Vamos mudar um pouco esse
personagem. E vamos aplicar
isso. Aí está. Então, a primeira pose a
ser salva foi para o chapéu, que significa que está apenas
movendo o controle. Mas aí está. Agora que temos
essa função, podemos começar a conectá-la ao botão
do poste que no momento não
está fazendo nada. Vamos voltar ao PyCharm e
podemos aplicar o botão de arcos. Podemos simplesmente dizer que comando
é igual a aplicar postagens selecionadas. Agora lembre-se de que estamos passando a função
em si. Não queremos
chamá-lo porque então estaríamos fornecendo
o argumento do comando, o resultado dessa função. E não é isso que queremos. Queremos dar a ela
a função para que ela possa chamar a
função em si. Agora, se recarregarmos nosso código e clicarmos no
botão, teremos um erro. Aceita argumentos com
um argumento fornecido. Agora, se você se lembra
de nossa ferramenta anterior, do botão que conectamos, do botão de transferência selecionado, tivemos que considerar um argumento aleatório
extra. Então meu N é dado para nós. E usamos esse argumento
star args, uma espécie de abrangente para os
argumentos transmitidos pelo meu. Então, podemos simplesmente fazer isso de novo. Isso não mudará a
funcionalidade da ferramenta. Isso simplesmente nos permitirá resolver
o que Maya está nos dando. Suprimentos. Eu gostaria de posar,
nem estamos usando. Estamos apenas usando isso
como uma rede para capturar
esse argumento extra. Agora, se eu mover esse controlador
e aplicar essa postagem novamente. Agora isso está funcionando. E, claro,
podemos aplicar essa pose vários personagens,
desde que tenham um chapéu. Nesse caso. Lá vamos nós. A última parte restante de nossa ferramenta é a
capacidade de salvar poses. E o primeiro passo para fazer
isso é fazer com que
o usuário escolha o nome da pose que
vamos salvar. Então, para fazer isso, vamos
usar o campo de texto. E se você
acha que precisamos dar
a ele um nome exclusivo,
como fizemos com a janela. Fizemos com as listas roladas. Você está exatamente certo. Então, deixe-me seguir em frente e criar
uma nova variável global. Vamos chamá-lo de campo de texto. Nome é igual a pose. Vamos chamá-lo de salvar
esses campos de texto. Agora, o nome real não
importa , desde
que seja único o suficiente. Ótimo. Então, quando criamos
nosso campo de texto, precisamos
fornecer esse nome, novamente como o primeiro argumento
nessa função de campo de texto. E para poder
colocar
o texto digitado
nesse campo. Há uma discussão. Entramos na documentação. Durante o TextField,
há um argumento chamado texto. Deveria estar por aqui. Aí está, mande uma mensagem. Assim, podemos usá-lo quando
criamos um campo de texto, para que ele seja pré-preenchido. Podemos editá-lo, editar o texto no campo de texto ou fazer uma consulta. Então, vamos
provar esse texto. Vamos criar uma nova função chamada save pose. Podemos fazer tudo dentro
dessa mesma função. E como sabemos,
vamos conectar isso ao botão de pausa segura. Vamos acrescentar que os argumentos estelares são meio que genéricos para o argumento que sabemos que o meu nos será dado. Então, para obter
o nome da pose do, do usuário, vamos chamá-la. Vamos chamar essa variável
chamada nome da postagem. Desculpe por isso. O primeiro nome é igual. Vamos lidar com a função
TextField. Mais uma vez,
vamos segmentar exatamente
o mesmo
campo de texto que criamos. Vamos consultar
informações a partir dele. Diremos que consulta é igual a verdadeira. Agora você pode digitar q é igual a verdadeiro ou a
consulta passa, desculpe, consulta, ambas são válidas. E agora, sempre que
estiver consultando, você usará um booleano para o argumento que
deseja consultar. Se você olhar a
documentação, está solicitando uma string. Mas quando estiver
consultando algo, mais
uma vez, ignore
esse argumento, ignore essa parte
da documentação e simplesmente digite um booleano. Então, apenas como um teste, vamos retornar o nome da postagem
e ver o que obtemos dela. Então, vou recarregar nosso código. E podemos dizer “dot save pose”. Nós sabemos disso agora. Enquanto isso,
simplesmente nos dá o nome das postagens
ou o que quer que digitemos. Esse campo de texto, seguro de
impressão, Bose. Não há nada nela, o que significa que é uma sequência vazia. Mas se eu digitar
o nome do post, minhas postagens, por exemplo, eu vou receber isso. Então isso é ótimo. Então, sabemos que se nada
for digitado lá, obteremos uma string vazia. Podemos adicionar um cheque para isso. Ainda há maneiras de fazer isso. Podemos dizer que
se o nome for igual string vazia,
daremos um aviso
ou uma string vazia
poderá ser negociada como não ou como uma lista
vazia e vazia. Portanto, você poderia dizer que, se não for o nome sublinhado das
postagens, fazemos um aviso. E diremos, por favor,
oi, nome oposto. Mais uma vez, saímos da
função retornando. Então, eu gosto de ser um
pouco mais explícito. Então, vou mudar isso
novamente para se o nome da postagem for igual a, igual a uma string vazia significa que nada foi
digitado pelo usuário. E então lançamos o
aviso e retornamos. E vou remover essa devolução aqui porque era apenas para testes
temporários. O próximo passo é fazer a
pose de que vamos
dizer que precisamos fazer a, verifique a seleção
nesta cena. Então, como sabemos, vamos
salvar os
controladores selecionados. E estamos limitando
isso a um personagem. Na verdade, poderíamos permitir vários personagens e simplesmente salvar todos esses controladores. E suponha que, se você quiser, a escolha
seja sua. Nesses casos, porém, vou limitá-lo
a um único caractere. Então, para fazer isso, podemos roubar parte
do código daqui. Ainda podemos selecionar
um namespace. Na verdade, deixe-me
roubar tudo isso. Isso é um cheque. Vou copiá-lo aqui. A propósito, estou roubando candidatos
selecionados. Porque na
pose selecionada aplicada, também estamos
verificando a seleção de
namespaces ou equipamentos. Então, selecionando espaços.
Agora, neste caso, queremos ter certeza de
que temos apenas um equipamento selecionado. Assim, podemos digitar se len of selected in
spaces não for um. Podemos lançar um aviso
dizendo Selecione, selecione o único equipamento na cena. Mostramos o aviso deles
e depois retornamos. Depois disso, precisamos de
outro cheque. Lembre-se de que
dissemos que queremos que
as
poses sejam exclusivos. Portanto, se a oposição já existe, não
podemos substituí-la. Talvez você, talvez você
queira ignorá-lo. Está perfeitamente bem.
Mas, nesse caso, vamos dizer que
vamos lançar
um aviso para o usuário dizendo
que a postagem já existe. Escolha outro nome. Para isso. Nós vamos conseguir. A pose é dicionário. Mais uma vez. Da pose selecionada aplicada, vamos roubar
esse dicionário
mais uma vez , as poses salvas, o ditado. E deixe-me adicionar alguns
comentários aqui apenas
para acompanhar o que
está acontecendo. Aqui. Estamos verificando,
verificando , validando ou
invalidando esses nomes. Aqui vamos
validar a seleção vista. Seleção. E eu estou deixando
espaço entre eles, apenas dê a eles um
pouco de respirabilidade para que seja um
pouco melhor de ver. Aqui, valide a mangueira exclusiva. Então, obtemos as poses do arquivo. Também poderíamos tirar as poses
da lista. Mas obtê-los dos
arquivos é mais confiável ou confiável porque realmente os
obtemos da fonte. Portanto, se
a ferramenta não for atualizada, ainda
podemos verificar a verdadeira
origem dos pôsteres, que é o sistema de arquivos. Então, podemos dizer, se pudermos escrever, desculpe, se o nome do post já é
uma chave no dicionário. Portanto, se o nome da pose em
estiver em pausas salvas, dict igual a name is
impulse será marcado. Mais uma vez, avisamos o usuário. Vamos dizer pose. Vamos colocar o nome
das citações
posando entre colchetes, pois os ocupantes são o que
vou dizer que já existe. Escolha outro nome. Lá vamos nós. E então eu vou
dizer formato de ponto e dizer ao usuário o nome
da pose que ele forneceu. Nome do post. Mais uma vez,
saímos retornando. Agora, finalmente, depois de
termos todas as
verificações de que precisamos, podemos salvar nossas postagens por muito tempo. Então, a primeira coisa que
precisamos fazer é pegar o dicionário postal que era outra pose
selecionada na cena. Portanto, os controladores
que são selecionados
pelo usuário na forma
de um dicionário. Mais uma vez, temos essa
funcionalidade de nosso projeto
anterior
em post transfer, post transfer, get, pose, dict. Agora, essa função
receberá um único namespace. Como sabemos que nossos namespaces
selecionados devem
conter
pelo menos um namespace. Podemos dizer com segurança,
ou podemos dizer, fornecer
com segurança o primeiro item
dessa lista,
espaços selecionados para nossa função. Portanto, haverá um
único namespace. E agora que temos
o dicionário, tudo o que precisamos fazer é
salvá-lo em nosso arquivo. E já temos
essa função também. Então, isso será o
ponto central de escrever postagens em um arquivo. E essa função receberá o nome das postagens ou o nome do arquivo que
queremos salvar, que é o nome
da pose e os valores ou o dicionário
que queremos armazenar. Suponha nome, pose, ditado. E vamos
imprimir , mas não usamos a pose de
informação salva. Vamos dizer pose salva
com sucesso. Mais uma vez,
deixe-me corrigir esse erro de digitação. Mais uma vez,
os colchetes são espaços reservados, formato de
ponto e nome da postagem para
mostrar o nome das postagens. E, finalmente, depois de salvar a postagem, queremos recarregar ou
atualizar a ferramenta. Portanto, podemos dizer Reload poses para mostrar as
postagens mais recentes que salvamos. Excelente. Então, vamos
testar isso em nossa cena. Oh, bem, antes de fazermos isso, podemos simplesmente nos
conectar ao botão. Já passamos por
isso várias vezes. Portanto, comando é igual a pose segura. Mais uma vez, basta
fornecer uma função, não chame a função
porque isso dará o resultado para esse argumento de
comando. Queremos, queremos que o botão chame
a função para nós. Então, vamos vir aqui. E vamos deletar essa
linha que estava protestando. Vamos recarregar nosso código. Vamos tentar salvar o oponente. Deixe-me fazer uma mudança no braço
desses personagens. Aí está. Está um pouco quebrado, mas ficará muito
óbvio quando nos inscrevermos. Na verdade, vamos chamar
isso de braço quebrado. Não precisamos que o
sublinhado também seja um espaço. Braço quebrado, salve a pose. Ambos aparecem aqui. E temos aqui a concentração que é uma postagem salva
com sucesso. E podemos aplicar isso
a esse personagem. E aí está. Se
você quiser ser mais explícito com sua
confirmação, poderíamos, em vez de simplesmente
imprimir uma mensagem, mostrar ao
usuário uma pequena janela. Há uma função
em C em que,
nesta biblioteca chamada diálogo
confirmado, que
recebe uma mensagem, pode digitar mensagem igual. E podemos passar essa
mensagem aqui. Aí está. Confirme a caixa de diálogo. Nós temos essa mensagem. Podemos recarregar nosso código. Podemos salvar uma nova postagem,
novas postagens da Bose que ele salvou. Recebemos essa
caixa de diálogo de confirmação do usuário. Portanto, cabe a você decidir se deseja o diálogo ou simplesmente
imprimir a declaração. E terminamos, agora você tem uma ferramenta de publicação
funcional que pode ser usada para salvar e aplicar poses em minhas
suposições, que são desiguais, podem ser compartilhadas com outras
pessoas, seus amigos, colegas de trabalho, qualquer pessoa
que use o Maya. Parabéns, esse foi o maior projeto
do curso. Agora, antes de irmos, eu queria mencionar
algo sobre módulos. Até agora, trabalhamos dentro desses documentos, na pasta de scripts do
Maya. E isso porque sabemos que o Maya pode obter código a partir daí. Agora, deixe-me ir até aquele local. Está aqui. Nosso código está todo aqui. Há outros locais de
onde eu posso obter o código? O outro. A mais popular está dentro
da versão maia. Há outra pasta de scripts. Portanto, isso é apenas para
minha média em 2020. E aquele com o qual estamos
trabalhando é pouco mais global para
todas as minhas aberrações. Mas agora isso levanta a questão: como sabemos exatamente de onde
estou obtendo o código? Isso? Há outro módulo ou biblioteca chamado sits ASIS. Asis, That's significa sistema. Há uma lista chamada path. Então, se eu imprimir sys.path, obtenho uma lista dos caminhos dos quais o Python e o Maya
podem obter código. Então, como é uma lista, deixe-me dar uma olhada nela. Pois eu entro é um caminho. Oi, aí está. Essas são todas as partes.
Há muitos deles. Se você tiver plug-ins instalados.
Deixe-me fazer isso de novo. Se você tiver algum
plug-in instalado, alguns dos caminhos para esses
plug-ins estarão aqui. E também há aqueles que estamos usando
aqui na parte inferior. Portanto, os scripts de 2020 para a migração
estão usando scripts do Maya, que é aquele em que
temos nosso código no momento. Então, você pode colocar
seu código em qualquer lugar aqui. Mas se você quiser adicionar
um local diferente, já que se trata de uma lista, basta adicionar a
esse caminho que você pode acrescentar. Então, vamos imaginar que temos
uma pasta personalizada e personalizada em. Digamos que você esteja
trabalhando em um estúdio ou em um projeto
com seus amigos e
queira ter seu código
e caixa de depósito ou em um local comum compartilhado onde todos possam
acessar o código. Eu criei uma
pasta como exemplo. Agora, vamos começar. Vamos imaginar que
essa seja uma pasta qual muitas pessoas em sua rede
possam ter acesso. Você pode, você quer
ter seu código aqui? Então, vamos mover nosso código ou
copiar nosso código da
localização dos scripts do Maya
dos documentos scripts do Maya
dos documentos para essa outra pasta. Para postar, a biblioteca foi transferida. Vamos usar uma
biblioteca de correio simples e uma pós-transferência. Vou copiar
isso aqui. Do jeito que está no momento, Meier não tem ideia sobre
esse local, certo? O que podemos fazer é simplesmente
modificar essa lista. Deixe-me desenhar isso em uma
variável chamada path. E vou colocar o R
no início,
caso o que possamos fazer é verificar
se o caminho já existe. Então, se ou se ele não
existe, na verdade, se não existe um caminho, não em série, o caminho do ponto, nós simplesmente adicionamos a esse caminho, diz caminho do ponto, adição de ponto. Aí está. Por exemplo,
como já carregamos os módulos do local dos
scripts, não
quero
confundir você. Então, deixe-me criar um módulo
totalmente novo chamado Hello path, por exemplo, e vamos chamar isso. Vamos renomear a extensão
TXT do ponto para ponto p-y. Excelente. E eu simplesmente
vou abrir isso com o
Notepad para edição rápida. Aí está. Vou adicionar uma função simples chamada hello. Olá, ou especialmente
, além disso, e vamos simplesmente
imprimir o caminho personalizado Hello. Ótimo. Então, agora, se eu tentar
importar hello path, vou para um
novo console Python. Se eu importar, olá. Claro que meus outros
sabem disso. Ele dirá que não há nenhum
módulo chamado Hello path. Mas se eu adicionar meu, meu caminho personalizado que
diz caminho de pontos. E mais uma vez, se
eu passar por cima dele, impresso para mim no Bloco de Notas, vou ver que nosso
caminho está no final dele. Então, código curto, ótimo. Agora que está no caminho do Python, posso importar o caminho Hello. Se eu imprimir hello, hello underscore
path, você pode ver que é um módulo
vindo desse local compartilhado. E agora podemos usar essa função
que eu escrevi que se chama
simplesmente olá. E está imprimindo
nossa string personalizada. Então aí está. Eu queria mencionar
isso como um extra porque se você
vai trabalhar com outras pessoas e
quiser compartilhar seu código. Essa será a maneira
mais fácil de fazer isso. Você pode colocar todo o código da
sua biblioteca postal. Novamente em um local compartilhado. Basta ter um script de prateleira que adicione seu
caminho personalizado à sessão do Maya. A propósito, você tem que fazer isso
a cada minuto de sessão. E então você tem um código que está sendo compartilhado com
várias pessoas.