quarta-feira, 25 de fevereiro de 2015

Aula 9–Revisão do Autocad

 

Como essa aula seria muito difícil de ser escrita e explica aqui em formato texto no blog fiz apenas a vídeo aula. Abaixo segue o link.

https://www.youtube.com/watch?v=PfhbMDH-6Tw&feature=youtu.be

Espero que tenham gostado

Sérgio Fernandes

Manual de Cad

segunda-feira, 23 de fevereiro de 2015

Aula 10 – Criando Comandos-Parte 1

 

Olá pessoal, chegou a hora que todos vocês esperavam, vamos criar comandos em Autolisp, mas antes precisamos definir o que será necessário para que vocês consigam criar comandos que realmente ajudem vocês no dia a dia.

1) É necessário ter fortes conhecimentos em Autocad e seus comandos, se você aprendeu com Autocad em português ou usando ícones ou menu estará em grande desvantagem, o ideal é utilizar o Autocad usando a linha de comando e conhecer os comandos pelo seu nome inteiro e não pelo atalho.

2) Imaginação, sim para criar comandos da forma que eu vou ensinar precisa de muita imaginação.

3) Treino

4) Treino de novo.

O que vou ensinar aqui é apenas uma pequena parte do que é possível fazer em Autolisp, na verdade muito pequena mesmo, porem quando eu estava iniciando meu aprendizado em Autolisp não existia muita literatura, youtube ou blogs e isso que vou ensinar agora foi a primeira coisa que eu aprendi em Autolisp e apos muito tempo percebi que não podia ser somente isso e ai corri para aprender tudo o que precisava. O que posso dizer é que a matéria de hoje facilitou muito meu aprendizado acredito que treina-la com exaustão me tornou o ótimo programador que sou hoje e principalmente um usuário avançado do Autocad.

O que vou pedir para vocês agora é apenas decorar o que eu vou escrever, mais a frente no curso vamos conversar mais sobre esse assunto.

Criando o primeiro comando

Para criar um comando precisamos definir o nome do comando para fazer isso usamos o comando DEFUN, abaixo segue a sintaxe desse comando:

(defun c: <nome do comando> ()

Vamos falar um pouco dessa sintaxe:

DEFUN = Definir função

c: = Quer dizer que o a função será um comando usado no Autocad

() = Lista de argumentos

No momento basta decorar isso, no futuro quando começarmos a criar funções precisaremos falar um pouco mais detalhadamente sobre essa linha de programação.

Ótimo, já sabemos como começar o nosso programa, agora precisamos saber como criar o comando em si, para isso vamos sempre fazer o uso de um papel e uma caneta, principalmente se você não tem um domínio tão grande dos comandos do Autocad.

Com papel e caneta nas mãos vamos começar.

Nosso primeiro programa vai ser um programa bem simples, vamos clicar em um ponto qualquer na tela, fazer um circulo com raio de 10 e pinta-lo com a cor vermelha.

A) Precisamos saber como o comando circulo funciona passo a passo, por isso precisamos de papel e caneta para anotar todos os passos, se você abrir o Autocad e for fazer um circulo com raio de 10 certamente seguira os seguintes passos:

1) Digitar o comando circle.

2) Clicar em um ponto qualquer da tela.

3) Digitar o raio.

B) Precisamos agora saber os passos necessários para pintar o circulo de vermelho, muitos podem pensar que é só clicar nele e depois mudar a cor na barra de propriedade do Autocad, porem não é assim, precisamos de um comando em linha de comando que faça essa tarefa, temos varias formas de fazer isso, mas no momento faremos uso do comando CHPROP, se você não conhece esse comando tente aprender mais sobre ele (seu uso já foi ensinado na aula 9), pois usaremos muito durante o curso. Os passos baixo são necessários para mudar a cor de um objeto:

1) Digitar o comando chprop

2) Selecionar o objeto.

3) Pressionar ENTER para informar ao Autocad que não vamos mais selecionar nenhum objeto.

4) Digitamos a opção C (de color)

5) Digitamos o numero da cor, no Autocad a cor vermelha é o numero 1 (no final do blog colocarei uma tabela com as 9 primeiras cores do Autocad).

6) Pressionamos ENTER para informar ao comando chprop que não vamos mais mudar nenhuma propriedade do objeto e que o mesmo pode ser encerrado.

Agora que anotamos como os comandos funcionam precisamos entender mais uma coisa, quando digitamos o nome do comando no Autocad precisamos em seguida pressionar o ENTER para confirmar o comando, porem, em Autolisp esse ENTER será dado de forma Automática. O mesmo ocorre quando digitamos um dado como o raio do circulo ou clicarmos na tela.

Porem quando um comando permite que selecionemos vários objetos precisamos em um determinado momento informar ao comando que não queremos mais selecionar nenhum objeto e para fazer isso pressionamos o ENTER, nesse caso precisamos anotar, pois será necessário também informar em Autolisp esse ENTER.

A mesma coisa acontece quando o comando somente é encerrado quando você pressiona ENTER para informa-lo que você não fará mais nenhuma modificação no objeto, isso acontece, por exemplo, com o comando chprop que continuara no comando ate que você pressione ENTER ou pressione o ESC (cancelando o comando), no caso do comando circle isso não é necessário porque depois de digitar o raio o comando é encerrado automaticamente não sendo necessário dar um novo ENTER para encerra-lo.

Parece difícil, mas não é quando se entende o procedimento tudo fica mais fácil.

Função COMMAND

Agora com todos os dados em mãos precisamos aprender a utilizar a função command, abaixo segue a sintaxe desse comando:

Sintaxe:

(command <nome do comando em strings> <argumentos do comando em strings>)

Temos ainda alguns argumentos que podemos usar, veja eles abaixo:

pause = pausa o comando esperando uma ação do usuário

“” (duas aspas duplas) = equivale a um ENTER do teclado

Vamos agora dar continuidade no nosso exemplo que é criar um circulo com raio de 10 e altera-lo para a cor vermelha, vamos fazer esse exemplo duas vezes, na segunda vez vamos aprimora-lo fazendo com que o mesmo fique mais funcional e aumente a velocidade do nosso novo comando.

Agora faremos uso de tudo aqui que anotamos e aquilo que aprendermos nessa aula.

Primeiro vamos criar a primeira linha de programação, aquela que eu pedi para vocês decorarem.

(defun c:cv()

Essa linha quer dizer que criaremos um comando que se chamara CV, ou seja bastara digitarmos CV  na linha de comando para utiliza-lo.

O próximo passo é fazer uso das nossas anotações primeiro do comando circle

1) Digitar o comando circle.

2) Clicar em um ponto qualquer da tela.

3) Digitar o raio.

(command “circle” pause “10”)

Nessa linha utilizamos a função command e digitamos o comando que queremos usar no caso o “circle” cercado por aspas duplas pois como visto na sintaxe o ocomando precisa ser fornecido como strings, depois utilizamos o pause (sem aspas, o pause é sempre sem aspas), o pause quer dizer que a função command aguardará que o usuário clique em um ponto na tela e por ultimo entramos com o raio “10” também como strings, com essa função criaremos um circulo com raio de 10 em qualquer ponto fornecido pelo usuário.

Agora só falta pintar ele de vermelho, para fazer isso vamos fazer uso também das anotações e implementa-las usando a função command.

1) Digitar o comando chprop.

2) Selecionar o objeto.

3) Pressionar ENTER para informar ao Autocad que não vamos mais selecionar nenhum objeto.

4) Digitamos a opção C (de color)

5) Digitamos o numero da cor, no Autocad a cor vermelha e a cor 1 (no final do blog colocarei uma tabela com as 9 primeiras cores do Autocad)

6) Pressionamos ENTER para informar ao comando chprop que não vamos mais mudar nenhuma propriedade do objeto.

(command “chprop” pause “”  “c”  “1”  “”)

Vamos entender essa linha, primeiro digitamos o comando “chprop” como string, depois o pause vai aguardar que o usuário selecione um objeto no nosso caso o circulo, para informar que não vamos mais selecionar nenhum objeto usamos as duas aspas duplas “” que é a mesma coisa que um ENTER, depois entramos com a letra “c” que informara ao comando chprop que queremos mudar a cor do objeto, com o numero “1” vamos fazer com que o objeto selecionado fique com a cor vermelha (no final do blog vou colocar a tabela de cores), para terminar daremos um ENTER usando duas aspas duplas para informar ao comando chprop que não vamos mais alterar o objeto e que queremos que o mesmo seja finalizado.

Agora podemos juntar tudo e montar o nosso comando

(defun c:cv()

  (command “circle” pause “10”)

  (command “chprop” pause “”  “c”  “1”  “”)

)

Para finalizar as instruções usaremos sempre um parêntese fechando a nossa função CV, apenas decorem isso, mas a frente no curso vamos falar mais sobre isso.

Pronto criamos o nosso primeiro comando, porem vem uma perguntar, será que ele não pode fica melhor, vamos pensar um pouco:

A primeira coisa que foi feita foi criar o circulo, portanto o circulo foi o ultimo objeto criado pelo Autocad, podemos então ao invés de selecionar o circulo (que é ruim pois o danado o usuário pode selecionar um objeto diferente e fazer mal uso do programa) podemos simplesmente usar a função de seleção last para selecionar o ultimo objeto criado tornando o programa mais rápido.

Fazendo essa modificação nosso programa vai ficar assim:

(defun c:cv()

  (command “circle” pause “10”)

  (command “chprop” “L” “” “c”  “1”  “”)

)

Note que tiramos o pause do comando chprop pois agora não necessitaremos que o usuário selecione mais o circulo ao invés disso colocamos o “L” (de last) para selecionar o ultimo objeto e depois as duas aspas duplas para dizer que não vamos selecionar mais nada.

Duas dicas que podem ajudar vocês quando forem se aventurar criando seus comandos:

1) Para não se confundirem se precisam ou não usar as aspas duplas pensem da seguinte forma:

Quando uso um comando preciso pressionar enter para ativa-lo como ele esta cercado por aspas duplas (strings) as duas aspas duplas corresponderam ao enter automático o enter só precisara ser usado quando em suas anotações você deu enter sem ter anotado nada ai será necessário usar aspas duplas.

2) Anote tudo e faça os seus comando em linha de comando, mesmo que você saiba usar o visual lisp ou que tenha digitado em um bloco de notas e carregado com o comando appload, fazer os comando nessa etapa do curso em linha de comando vai fazer com que vocês errem e refaçam varias vezes mesmo um simples comando forçando que vocês se acostumem com as mensagens de erro e ao mesmo tempo forçando vocês a repetirem tudo de novo varias e varias vezes, tipo karate kid.

Na próxima aula continuaremos falando desse assunto e vamos criar novos comandos explorando cada vez mais esse recurso, a ideia é fazer com que vocês treinem muito antes de passarmos para o próximo assunto.

Abaixo segue o link para assistirem essa vídeo aula em nosso canal do Manual de Cad no youtube:

https://www.youtube.com/watch?v=fxJh_v_Lu1k&feature=youtu.be

Abaixo segue a tabela contendo as oito primeiras cores do Autocad.

 

Tabela de Cores
Vermelho 1
Amarelo 2
Verde 3
Cian 4
Azul 5
Magenta 6
Branco 7
Cinza 8

Espero que tenham gostado

Sergio Fernandes

Manual de Cad.

 

 

 

 

 

terça-feira, 17 de fevereiro de 2015

Aula 8–Manipulando Listas- Parte 2

 

Olá Pessoal, vamos dar continuidade à aula de manipulação de listas, hoje aprenderemos novas funções de manipulação de listas que em conjunto com o CAR e o CDR nos permitem conseguir qualquer valor dentro de uma lista de forma bem fácil.

Função REVERSE

A função reverse inverte uma lista

Sintaxe:

(reverse <lista>)

Exemplo 1:

(setq lista (list 1 2 3 4 5))

Retornara a lista (1 2 3 4 5)

(setq inverso (reverse lista))

Retornará a lista invertida (5 4 3 2 1)

Exemplo 2:

(setq lista (list 1 2 3 (list 4 5 6)))

Retornara a lista (1 2 3 (4 5 6))

(setq inverso (reverse lista))

Retornará ((4 5 6) 3 2 1)

ATENÇÃO: A função reverse inverte os elementos da lista principal não invertendo os dados das sub-listas como no exemplo acima.

 

Função LAST

A função last pega o ultimo elemento de uma lista.

Sintaxe:

(last <lista>)

Exemplo:

(setq lista (list 1 2 3 4 5))

Retornara a lista (1 2 3 4 5)

(setq ultimo (last lista))

Retornará 5 que é o ultimo elemento da lista.

 

Função Length

Retorna o número de elementos de uma lista

Sintaxe:

(length <lista>)

Exemplo:

(setq lista (list 1 2 3 (list 4 5 6)))

Retornara a lista (1 2 3 (4 5 6))

(setq contagem (length lista))

Retornará 4 como sendo o número de itens dessa lista.

ATENÇÃO: Apesar de parecer que essa lista tem 6 elementos ela não tem, ela tem 3 números inteiros e uma lista, a função length não conta elementos dentro das sub-listas.

 

Função NTH

Retorna o elemento da lista que se encontra em determinada posição.

Antes de mostra a sintaxe e o exemplo de como funciona essa função precisamos entender uma coisa, o indexador, tudo em Autolisp quando o assunto é indexador precisamos sempre lembrar que o indexador inicial é sempre o zero, se, por exemplo, tivermos uma lista com cinco elementos o indexador do primeiro elemento será o zero e do ultimo elemento será 4.

Sintaxe:

(nth <indexador> <lista>)

Exemplo 1:

(setq lista (list 1 2 3 (list 4 5 6)))

Retornara a lista (1 2 3 (4 5 6))

(setq valor (nth 2 lista))

Retornara o valor 3 que é o elemento referente ao indexador 2.

Exemplo 2:

(setq valor (nth 3 lista))

Retornará o valor (4 5 6) que é o elemento referente ao indexador 3.

Exemplo 3:

(setq valor (nth 1 (nth 3 lista)))

Retornará o valor 5, vamos entender a linha de programação desse exemplo, primeiro devemos interpretar (nth 3 lista) que retornara (4 5 6), depois falamos para pegar o indexador 1 desse resultado na lista (4 5 6) o indexador 1 é referente ao valor 5.

 

Função APPEND

A função append junta as listas fornecidas.

Sintaxe:

(append <lista1> <lista2> . . .)

Exemplo 1:

(setq lista1 (list 1 2 3 4 5))

Retornará (1 2 3 4 5)

(setq lista2 (list “a” “b” “c”))

Retornará (“a” “b” “c”)

(setq lista_nova (append lista1 lista2))

Retornara (1 2 3 4 5 ”a” “b” “c”)

Exemplo 2:

(setq lista1 (list 1 2 3 4 5))

Retornará (1 2 3 4 5)

(setq lista2 (list “a” “b” “c”))

Retornará (“a” “b” “c”)

(setq lista_nova (append lista2 lista1)); Note que inverti a ordem das listas nesse exemplo

Retornara (”a” “b” “c” 1 2 3 4 5)

Nesse exemplo podemos notar que a ordem das listas na função append pode modificar o layout final da lista.

Voltaremos a falar sobre essa função mais a frente, pois quando estivermos falando sobre loopings precisaremos dar uma revisada nessa função.

 

Função MEMBER

A função member verifica se um determinado elemento esta contido dentro da lista. Caso a função member encontre o item dentro da lista ele retornara o restante da lista a partir do item encontrado, caso ele não encontre o item ele retornara NIL.

Sintaxe:

(member <elemento> <lista>)

Exemplo 1:

(setq lista (list 1 2 3 (list 4 5 6)))

Retornara a lista (1 2 3 (4 5 6))

(setq localiza (member 3 lista))

Retornara (3 (4 5 6)) que é o restante da lista a partir do elemento encontrado

Exemplo 2:

(setq lista (list 1 2 3 (list 4 5 6)))

Retornara a lista (1 2 3 (4 5 6))

(setq localiza (member 4 lista))

Retornará nil, isso mesmo nil, mesmo o elemento 4 existindo na lista. Isso acontece porque a função member realiza a pesquisa apenas na lista principal não estendendo a busca as sub-listas e é exatamente o nosso caso pois o número 4 encontra-se dentro de outra lista.

Exemplo 3:

(setq lista (list 1 2 3 (list 4 5 6)))

Retornara a lista (1 2 3 (4 5 6))

(setq localiza (member (list 4 5 6) lista))

Retornara ((4 5 6)), ele retornou a lista principal com o restante da lista a partir do item encontrado por isso teremos uma lista dentro da outra.

Espero que tenham gostado na próxima aula faremos os nosso primeiros programas criaremos os nosso primeiros comandos.

 

Exercicios

1) Monte a lista abaixo em seguida execute as manipulações conforme solicitado.

( 1 2 3 4 5 (“a” “b” “c”) 5 6 7 8 9 10 (( “mario” “amanda” “carlos”) 20 25 30))

Monte as seguintes linhas de programação, sempre guardando o resultado delas em alguma variável de sua escolha:

a) Informe o número de itens da lista

b) Pegue o quinto elemento da lista

c) Verifique se o elemento 10 existe dentro da lista

d) Pegue o ultimo elemento da lista

e) Inverta lista

f) Crie a seguinte lista (“pato” “macaco” 12) e adicione-a a lista

g) Usando apenas duas funções de manipulação e sem usar a função last pegue o ultimo elemento da lista

h) Usando apenas dois comandos de manipulação de listas pegue o valor “b” da lista, não pode utilizar nem CAR nem CDR nem nenhuma fusão deles.

i) Usando apenas duas funções de manipulação e sem usar a função last e sem usar as funções que usou no exercício G pegue o ultimo elemento da lista

j) Usando no máximo 3 comandos de manipulação diferentes extraia o valor “mario” da lista, não pode utilizar nem CAR nem CDR nem nenhuma fusão deles.

Espero que tenham gostado.

Assista também a essa aula em nosso canal Manual de Cad no Youtube.

https://www.youtube.com/watch?v=WItCIiHg7rI&feature=youtu.be

Sérgio Fernandes

Manual de Cad

sábado, 14 de fevereiro de 2015

Aula 7–Manipulando Listas- Parte 1

 

Olá pessoal, hoje vamos aprender a manipular os dados de uma lista, existem diversas ferramentas em Autolisp para a manipulação de listas, vamos dar inicio aprendendo as duas funções mais básicas do Autolisp o CAR e o CDR.

Funções CAR e CDR

A função CAR retorna o primeiro item da lista.

A função CDR retorna a lista sem o primeiro item, preste atenção  no que eu vou escrever e mais a frente entenderemos melhor, “o resto de uma lista ainda é uma lista”, grave bem isso.

Vamos ver alguns exemplos e vamos discutir cada um deles, primeiro vou montar uma lista que usaremos em alguns exemplos.

(setq lista (list “A” “B” “C” (list 1 2 3 4 5)))

O resultado dessa lista será (“A” “B” “C” (1 2 3 4 5))

1) Exemplo

Nesse primeiro exemplo vamos pegar o primeiro elemento dessa lista, ou seja, “A”, para fazer isso devemos fazer uso da função CAR, para facilitar toda vez que fizermos algum exemplo daqui pra frente vamos sempre armazenar o valor dele em uma variável.

(setq primeiro (car lista))

A função car pega apenas o primeiro elemento da lista.

2) Exemplo

Nesse exemplo precisamos pegar o segundo elemento da lista, se você pensou que agora basta usar a função CDR errou, a função CDR retornará o restante da lista sem o primeiro item, e o restante de uma lista sempre será uma lista, então teremos que usar uma combinação de CAR e CDR para pegar o segundo elemento, primeiro faremos isso de forma separada e depois faremos isso de forma combinada.

(setq resto_lista (cdr lista))

A função CDR vai retornar a lista sem o primeiro item (“B” “C” (1 2 3 4 5)), agora temos uma lista chamada resto_lista contendo a lista sem o seu primeiro item, agora podemos usar a função CAR para pegar o primeiro item dessa lista que acabamos de criar e assim pegarmos o valor “B” que é o segundo elemento da lista original.

(setq segundo (car resto_lista))

Como o primeiro elemento da lista resto_lista é o “B” chegamos ao nosso objetivo.

Mas não precisamos na verdade criar uma nova variável para executar essa operação, podemos fazer tudo em uma única linha de programação.

(setq segundo (car (cdr lista)))

Pronto, o Autolisp vai interpretar isso da seguinte forma, primeiro pegaremos o CDR da lista, ou seja, o resto dela sem o primeiro item e depois pegaremos o CAR desse resultado que nos retornará como valor o “B”.

ATENÇÃO: Se você tiver uma lista com apenas dois elementos, não adianta usar a função CDR achando que já que ele vai remover o primeiro item da lista o que sobrar será o que você necessita, lembre-se o resto de uma lista ainda é uma lista, CDR sempre vai devolver o valor como uma lista, se tiver uma lista (1 2) e usar a função CDR terá como resultado (2) que ainda é uma lista e para ter o valor 2 como número inteiro terá que usar a função CAR para remover esse valor de dentro da lista.

3) Exemplo

Usando ainda a lista que criamos acima a nossa meta agora será pegar o valor 2 da lista, esse será bem mais complicado, pois o valor 2 esta dentro de outra lista, para isso faremos uso de diversas funções CAR e CDR, vamos fazer isso passo a passo, depois faremos isso em uma única linha de programação, não vou guarda-las em variáveis, pois vou formular a logica para que depois possamos desenvolver isso em uma única linha.

(cdr lista)

Retornará (“B” “C” (1 2 3 4 5))

(cdr (cdr lista))

Retornará (“C” (1 2 3 4 5))

(cdr (cdr (cdr lista)))

Retornará ((1 2 3 4 5))

(car (cdr (cdr (cdr lista))))

Retornará (1 2 3 4 5) ATENÇÃO, É DIFERENTE DO RESULTADO ACIMA.

(cdr (car (cdr (cdr (cdr lista)))))

Retornará (2 3 4 5))

(car (cdr (car (cdr (cdr (cdr lista))))))

Retornará 2

Resultado final

(setq valor (car (cdr (car (cdr (cdr (cdr lista)))))))

Bem trabalhoso né, existe uma forma de fazer isso que particularmente não gosto, mas que pode deixar a linha de programação um pouco mais legível.

Formando novas funções com CAR e CDR

Isso que vou ensinar agora não é utilizado pela minha pessoa, eu particularmente acredito que o programador perde mais tempo tentando criar novas funções com CAR e CDR do que utilizando da forma que fizemos acima.

Vamos criar uma lista simples

(setq lista (list 1 2 3 4 5))

Retornará (1 2 3 4 5), uma lista contendo 5 itens.

Agora vamos supor que queremos extrair o valor 4 da lista, uma forma de pegar esse valor seria fazer assim (car (cdr (cdr (cdr lista))), mas o que faremos é combina-los e formar uma nova função.

Para fazer isso precisamos pegar as duas primeiras letras da primeira função que no exemplo acima é o CAR, nesse caso as duas primeiras letras seriam CA e das demais funções pegaremos somente a letra do meio, no exemplo acima são CDR, CDR e CDR, pegando somente a letra do meio teremos D D D, agora basta adicionar um R no final.

Então escrever (car (cdr (cdr (cdr lista))) é a mesma coisa de escrever (cadddr lista), ambos retornarão o valor 4.

Vamos criar uma lista um pouco mais complexa

(setq lista (list (list 1 2 3) (list 4 5 6)))

Retornará ( (1 2 3) (4 5 6) ), ou seja, uma lista que tem dois elementos e esses dois elementos são duas outras listas.

Vamos agora pegar o valor 3 dessa lista, se fizemos passo a passo como foi feito no inicio seria assim:

(car lista)

Retornará (1 2 3)

(cdr(car lista))

Retornará (2 3)

(cdr(cdr(car lista))

Retornará (3), note que o 3 ainda é uma lista, então precisamos tira-lo da lista usando o CAR.

(car (cdr (cdr (Car lista))))

Retornará 2

Guardando em uma variável:

(setq valor (car(cdr(cdr(Car lista)))))

Agora criando uma nova função ficaria assim

(setq valor (caddar lista))

Pegamos as duas letras da primeira função CAR e assim fica CA e depois a letra do meio das demais funções D D A e por fim acrescentamos o R.

Não sei informar qual o limite para isso, mas sei que tem, então tente não utilizar esse método com muitas funções.

Eu não sou muito fã disso, mas esta ai para que quiser usar,

Na próxima aulas aprenderemos mais funções de manipulação de listas.

Abaixo seguem os exercícios.

Crie a seguinte lista

( ( 1 2 3) (“a” “b” “c”) ( ( 10 20 30) ”X” “Y” “Z”) ) )

1) Extraia os valores solicitados abaixo usando as funções CAR e CDR sem criar novas funções.

a) Pegue o valor ( 1 2 3)

c) Pegue o valor (“a” “b” “b”)

b) Pegue o valor (10 20 30)

d) Pegue o valor “X”

e) Pegue o valor “Z”

f) Pegue o valor “Y”

g) Pegue o valor “a”

h) Pegue o valor “c”

i) Pegue o valor “b”

j) Pegue o valor “2”

2) Extraia os valores do exercício acima criando novas funções usando o CAR e CDR.

Assista tambem a video aula em meu canal Manual de Cad no Youtube.

https://www.youtube.com/watch?v=PO1E9GptZXo

Espero que tenham gostado

Sergio Fernandes

Manual de Cad

quinta-feira, 12 de fevereiro de 2015

Aula 6 – Listas – Parte 2

 

Olá pessoal, vamos dar continuidade no aprendizado das listas, acredito que devemos falar um pouco mais sobre o layout de uma lista, ver mais alguns exemplos de listas complexas e explicar melhor o porquê escolhi determinado layout para a lista.

Vamos criar um exemplo um pouco mais complicado do que o exemplo da aula passada.

Exemplo:

Criarei uma lista que deve armazenar os seguintes dados.

1) O nome do bloco.

2) Seu ponto de Inserção.

3) Nome do layer, cor e tipo de linha.

4) Rotação do Bloco.

5) Escala X Y e Z.

Dependendo da quantidade de blocos de um desenho essa lista pode ser pequena ou enorme, para não dificultar muito vou criar um layout de lista contendo apenas 2 elementos, e ai vou explicar o motivo da escolha desse layout.

( ( “Cota” ( 10 20 0) (“Cota_Arvore” 7 “Continuos”) 63 ( 1 1 1) ) ( “Ponto” ( 100 205 0) (“Ponto_Cotado” 1 “Continuos”) 0 ( 1 1 1) ) )

Ficou difícil de entender não é, para facilitar a visualização vou mostrar como essa lista é visualizada no Visual Lisp que é o editor de programas lisp do Autocad.

clip_image001

Essa é a janele Inspect do Visual lisp, aprenderemos a usar ela mais a frente no curso, agora não entrarei em maiores detalhes, o que nos interessa agora é entender o layout dessa lista.

Na parte de cima temos a lista completa, logo abaixo dela temos duas linhas uma começando com (0)  e a outra com (1) , isso apenas indica o numero do elemento da lista, ou seja o primeiro item da lista é o item zero o segundo é o item 1, em Autolisp o identificador de item inicial é sempre o zero, então em uma lista com dois elementos teremos dois itens, o item zero e o item 1.

Em cada um desses itens temos outra lista, ou seja, temos uma lista principal e dentro dela temos duas outras listas contendo diversos tipos de dados ( números, strings e outras listas).

Mas porque eu organizei os dados desse jeito, a ideia é agrupar informações relevantes que facilite não só a manipulação desses dados como também o acesso a eles. Criei uma lista principal e para organizar os dados dentro dela eu criei uma lista contendo os dados do bloco (nome, ponto de inserção, os dados do layer, rotação e escalas do bloco), depois precisei pensar em como organizar esses dados, pensei então em criar uma lista contendo esses dados porem não poderia simplesmente criar uma lista simples com todos os dados jogados lá dentro de qualquer maneira, então resolvi organiza-los da seguinte forma, primeiro item dessa sub lista dentro da lista principal seria o nome do bloco em formato string (texto), as coordenadas X Y e Z foram organizadas dentro de outra lista, os dados do layer também foram organizados como uma lista contendo os dados do nome do layer em string, cor do layer como um numero inteiro e o tipo de linha como string, em seguida inseri a rotação como um numero inteiro e as escalas eu organizei em uma lista contendo os números inteiros das escalas em X Y e Z.

A ideia principal é deixar os dados organizados, quando formos manipular os dados dessa lista poderemos usar funções que aprenderemos que facilitarão quando precisarmos acessar os dados ou criar loopings com eles.

Criando listas

Para criar uma lista podemos fazer uso de duas técnicas, o comando list e o quote (‘) sinal de apostrofo.

Primeiro Método – LIST

Esse é o método que eu utilizo abaixo segue a sintaxe desse comando:

Sintaxe:

(list <item 1> <item 2> …)

Exemplos:

(setq lista (list 1 2 3 4 5))

Retornará o valor (1 2 3 4 5), uma lista contendo esses cinco elementos.

(setq lista (list "cota" (list 10 20 0)))

Retornara o valor (“Cota” (10 20 0)), uma lista contendo dois item , uma string e uma lista.

Veja como seria criar a lista do inicio desse post com o comando list:

(setq lista (list (list "Cota" (list 10 20 0) (list "Cota_Arvore" 7 "Continuos") 63 (list 1 1 1) ) (list "Ponto" (list  100 205 0) (list "Ponto_Cotado" 1 "Continuos") 0 (list  1 1 1))))

Complicado né, mas posso garantir que isso é treino, assista a vídeo aula que ficara mais claro como utilizar esse comando.

Segundo Método – ‘ (quote)

O segundo método é mais simples e faremos uso do sinal de apostrofo (‘) chamado de quote, quando utilizamos o quote montamos a lista da forma que quisermos da mesma forma como queremos que ela seja armazenada.

Exemplos:

(setq lista ‘(1 2 3 4 5))

Retornará o valor (1 2 3 4 5), uma lista contendo esses cinco elementos.

(setq lista ‘("cota" (list 10 20 0))

Retornará o valor (“Cota” (10 20 0)), uma lista contendo dois item , uma string e uma lista. Note que o valor retornado é idêntico ao que foi escrito acima.

Veja como seria criar a lista do inicio desse post com o quote:

(setq a '(("Cota" ( 10 20 0) ("Cota_Arvore" 7 "Continuos") 63 ( 1 1 1) ) ("Ponto" ( 100 205 0) ("Ponto_Cotado" 1 "Continuos") 0 ( 1 1 1))))

Facilita bastante pois o quote retornara uma lista idêntica ao que foi feito, no caso do list o resultado é o mesmo porem um pouco mais complicado. Mas nem sempre poderemos usar o quote para a criação de listas, por esse motivo eu sempre utilizo o comando list.

Vamos ver mais alguns exemplo usando os dois métodos, agora vamos criar algumas variáveis antes e usa-las para criar as listas e ai você entenderá porque o quote nem sempre é a melhor opção.

Variáveis

(setq nome “Carlos”)

(setq num1 10)

(setq num2 20)

(setq num3 30)

(setq lista1 (list 1 2 3 4 5))

Exemplo 1 :

Com list

(setq lista (list num1 num2))

Retornará (10 20)

Com quote

(setq lista ‘(num1 num2))

Retornará (num1 num2)

Veja o exemplo acima, você pensou que o quote retornaria o mesmo valor que o list, porem não podemos utilizar o quote quando precisamos criar uma lista usando o valor de uma variável, quando utilizamos o quote ele apenas retorna o nome da variável sem o seu valor.

Exemplo 2 :

Com list

(setq lista (list (list num1 num2) lista1))

Retornará ( (10 20) (1 2 3 4 5) )

Com Quote

(setq lista ‘(( num1 num2) lista1))

Retornará ((num1 num2)(lista))

Exemplo 3:

Com list

(setq lista (List (list num1 num2 (list num3)) (list lista1)))

Retornará ( ( 10 20 (30) ) ( ( 1 2 3 4 5 ) ) )

Com quote

(setq lista ‘((num1 num2 (num3)) (lista1)))

Retornará ((num1 num2 (num3)) (lista1)))

O quote pareceu muito pratico na criação de listas mas não serve quando o assunto é variável, como em Autolisp tudo gira em torno de variável fica muito difícil utiliza o quote, isso não quer dizer que não o utilizaremos no futuro, mas aconselho nesse inicio do curso aprender a criar listas usando somente o comando list.

Aprendemos a criar listas, na próxima aula aprenderemos como manipular os dados de uma lista.

Exercícios:

1) Usando apenas o comando list crie as listas abaixo e armazene o seu resultado em uma variável qualquer.

a) ( ( 1 2 3 4 5) (“a” “b” “c” “d” “e”) )

B) ( ( ( 1 2 3) (4 5 6) ) ( ( “a” “b” “c”) (“d” “e” “f”) ) )

C) (“a” (“b”) “c” 1 (2) 3 (4))

d) ( ( “casa” (“armário” “mesa” “cadeira) ) (“escritório” (“computador” “servidor”) ) )

2) Usando o quote cria as listas abaixo

a) ( ( 1 2 3 4 5) (“a” “b” “c” “d” “e”) )

B) ( ( ( 1 2 3) (4 5 6) ) ( ( “a” “b” “c”) (“d” “e” “f”) ) )

C) (“a” (“b”) “c” 1 (2) 3 (4))

d) ( ( “casa” (“armário” “mesa” “cadeira) ) (“escritório” (“computador” “servidor”) ) )

3) Crie as variáveis abaixo em seguida crie as listas da forma que foi solicitada, execute esse exercício usando o comando list.

Variáveis

(setq a 1)

(setq b 10)

(setq c 100)

(setq nome “Carlos”)

(setq casa “Cadeira”)

(setq quarto “Cama”)

a) ( ( 1 100) ( 10 “Cadeira”))

B) ( (1) (10) (100) ( ( “Cadeira”) ) )

C) ( ( (“Cadeira” 100 (10) ) (“Carlos” 1 (100) ) ) “Cama” )

Assista também a essa aula em nosso canal Manual de Cad no Youtube.

Sérgio Fernandes

Manual de Cad