Download - Intro Common Lisp 2012
![Page 1: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/1.jpg)
Introducción aCommon Lisp
Elaborado por:
Dr. Sergio Luis Castillo Valerio
Este presentación puede reproducirse libremente conservando estos derechos de autor.
![Page 2: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/2.jpg)
Descripción General Lisp = List Processing. Inventado por John McCarthy a finales de los 50’s. Adecuado para IA por su habilidad para el
procesamiento eficiente de información simbólica. Lenguaje con sintaxis simple, casi nulo manejo de
tipos y administración dinámica de memoria.
![Page 3: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/3.jpg)
Common Lisp Existen varios dialectos de Lisp: Franzlisp, Interlisp,
Maclisp, Qlisp, Scheme, etc. Common Lisp es un intento por estandarizar el
lenguaje y hacerlo más portable y fácil de mantener. Por tanto, Common Lisp es el lenguaje a aprender. En adelante, al referirnos a Lisp, nos estaremos
refiriendo a Common Lisp.
![Page 4: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/4.jpg)
Bloques básicos (1) Los bloques de construcción básicos de Lisp son:
– El átomo.– La lista.– La cadena de caracteres (string).
Estos 3 son los únicos objetos válidos en Lisp. Son llamados expresiones simbólicas o expresiones-
s.
![Page 5: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/5.jpg)
Bloques básicos (2) Átomo
– Todo número o secuencia de caracteres es un átomo. Lista
– Es una secuencia de átomos y/o otras listas encerradas entre paréntesis y separadas por uno o más espacios.
Cadena de caracteres:– Grupo de caracteres encerrados entre dobles
comillas (“ “).
![Page 6: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/6.jpg)
Ejemplos de bloques básicos Algunos átomos válidos:
– esto-es-un-atomo - 345– bloque#1 - *var*
Algunas listas válidas:– (1 2 3) - (a (a b) c d)– (hijo Luis (José Susana)) - ()
Algunas cadenas de caracteres válidas:– “Hoy es lunes” - “a b c d e”– “1 2 3 4” - “teclea la fecha:”
![Page 7: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/7.jpg)
Expresiones-s Toda expresión-s es potencialmente un programa
válido en Lisp.
Los programas pueden ser interpretados o compilados.
En un intérprete de Lisp, el programa fuente se examina en un lazo repetitivo llamado lazo lee-evalúa-imprime (read-evaluate-print loop).
![Page 8: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/8.jpg)
Notación prefija (1) Lisp utiliza notación prefija. Por ejemplo:
– >(+ 5 6 7)– >18– >
El prompt “>” indica que el intérprete está listo para leer.
El símbolo + es una función y 5, 6 y 7 son sus argumentos.
![Page 9: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/9.jpg)
Notación prefija (2) El nombre de la función y sus argumentos se
encierran entre paréntesis para indicar al intérprete que debe evaluarla.
El lazo lee-evalúa-imprime del intérprete, lee la función con sus argumentos, la evalúa e imprime el valor que la función regresa (18, en el ejemplo anterior).
Después, imprime otra vez el prompt para indicar que está listo para la siguiente lectura.
![Page 10: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/10.jpg)
Funciones numéricas Las funciones numéricas básicas son:
– +, -, * y / (suma, resta, multiplicación y división)
Los argumentos pueden ser enteros o números reales (de punto flotante).
– + y * toman 0 o más argumentos.– - y / toman al menos 1 argumento.
Ejemplos:– (+ 3 5 8 4)- (- 10 12)– (* 2 3 4) - (/ 25 2)
![Page 11: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/11.jpg)
Constantes importantes Lisp trata de avaluar todo, incluyendo los argumentos
de una función.
Existen 3 tipos de elementos que son especiales porque siempre regresan su propio valor:
– Los números.– La letra t (para verdadero).– Nil (para falso). (Nil: palabra sueca para 0 o nada)
• Nil es el único objeto de Lisp que es a la vez un átomo y una lista (la lista vacía).
![Page 12: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/12.jpg)
Evaluación de funciones (1) Cada función se evalúa en el orden en que ocurre
dentro de los paréntesis de izquierda a derecha. Por ejemplo.
● > (+ (* (/ 9 5) 50) 32) → 122
La función a evaluar primero es la suma, pero su primer argumento es una multiplicación.
Por tanto, se debe evaluar primero la multiplicación.
![Page 13: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/13.jpg)
Evaluación de funciones (2) Pero a su vez, el primer argumento de la
multiplicación es una división, por tanto, es necesario evaluar primero esta división.
La división regresa el valor 1.8 a la multiplicación, para dar (* 1.8 50).
La multiplicación regresa el valor 90 a la suma para dar (+ 90 32), que al ser evaluada regresa el
valor 122.
![Page 14: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/14.jpg)
Funciones lógicas (1) Las funciones lógicas básicas son NOT, AND y OR.• NOT es la más simple, toma un solo argumento y
regresa T si el argumento se evalúa como nil y NIL si el argumento es diferente de nil.
• (not (= 0 5)) → T• (not (< 4 5)) → NIL
![Page 15: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/15.jpg)
Función lógica AND La función AND toma cualquier número de
argumentos que se evalúan de izquierda a derecha. Si todos los argumentos evalúan diferente de nil, AND regresa el valor del último argumento, de otra manera regresa NIL.
• (and (< 4 5) 1) → 1• (and 5 3 (= 3 2)) → NIL
![Page 16: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/16.jpg)
Función lógica OR Los argumentos del OR se evalúan de izquierda a
derecha hasta que uno de ellos evalúa diferente de nil, en cuyo caso regresa ese valor; de otra manera regresa NIL.
• (or (< 4 3) (> 4 3)) → T• (or (< 3 4) 7 5) → 7
![Page 17: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/17.jpg)
Marca de Acotación (quotation mark) Algunas veces se quiere que un átomo o una lista
sea considerada como un dato y no como una función que debe evaluarse.
Para esto, se utiliza la marca de acotación (quotation mark).
Por ejemplo:– '(a b c d) - '(+ 3 4 5)– En el primer caso se considera a la lista como el
conjunto de datos a, b c y d, y no como la función a con argumentos b, c y d.
Nota: El apóstrofe ' equivale a la forma quote
![Page 18: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/18.jpg)
Asignación de valores a variables Variable: Un átomo no numérico, esto es, un átomo
simbólico, al que pueden asignarse o ligarse valores cambiantes.
Función setq– Asigna o liga una variable con un valor.– Toma 2 argumentos:
● (setq variable valor)– Por ejemplo:
● (setq x 10) ; x = 10● (setq lst1 ‘(a b c)) ;lst1=(a b c)
![Page 19: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/19.jpg)
Asignación con setf
• setf nos permite asignar valores a varias variables. Sintáxis:• (setf var1 val1 var2 val2 ... varn valn)
Ejemplo:• (setf a 10 b 15 c 12) ;a=10,b=15,c=12
![Page 20: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/20.jpg)
Manipulación de listas (1) Algunas funciones básicas para el manejo de listas son:
● (first lista) o (car lista): Regresa el primer átomo de lista● (rest lista) o (cdr lista): Regresa el resto de lista
Por ejemplo:– (setq lst1 ‘(a b c d)) → (a b c d) ; crea lista– (first lst1) → a ; primer elemento– (car lst1) → a– (rest lst1) → (b c d) ; resto de la lista– (cdr lst1) → (b c d)
![Page 21: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/21.jpg)
Manipulación de listas (2) Otras funciones para el manejo de listas son:
● first, second, third, fourth, fifth, sixth, seventh, eighth, ninth y tenth.
Por ejemplo:– (setq lst1 ‘(a b c d)) → (a b c d) ; crea lista– (first lst1) → a ; primer elemento– (second lst1) → b ; segundo elemento– (fourth lst1) → d ; cuarto elemento
![Page 22: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/22.jpg)
Manipulación de listas (2) Otras funciones para el manejo de listas son:
● (nth indice lista)
Por ejemplo:– (setq lst1 ‘(a b c d)) → (a b c d) ; crea lista– (nth 0 lst1) → a ; elemento cero– (nth 1 lst1) → b ; elemento uno– (nth 3 lst1) → d ; elemento tres
![Page 23: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/23.jpg)
Construcción de listas(1) Otra función para el manejo de listas:
– (cons elemento lista) cons utiliza 2 argumentos. Construye una nueva lista haciendo a elemento el
primer miembro de lista. Por ejemplo:
– (cons ‘a ‘(b c)) → (a b c)– (cons (* 2 3) ‘(1 2 3)) → (6 1 2 3)
![Page 24: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/24.jpg)
Construcción de listas(2) Otra función para el manejo de listas:
– (list átomo1 átomo2 ... átomo_n) Construye una lista con miembros átomo1,
átomo2, ..., átomo_n Toma cualquier número de argumentos.
– (list ‘a ‘b ‘c ‘d) → (a b c d)– (list ‘a ‘(b c d)) → (a (b c d))– (list (+ 2 3) ‘a ‘b) → (5 a b)
![Page 25: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/25.jpg)
Funciones en general La sintaxis para llamar a una función es:
– (nombre_función arg1 arg2 ...) Al llamarse a un función los argumentos se evalúan
de izquierda a derecha (a menos que haya un marca de acotación).
Entonces la función se ejecuta usando los valores evaluados de sus argumentos.
Ejemplo:– (cons (car ‘(a 2 )) (cdr ‘(2 b c ))) → (a b
c)
![Page 26: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/26.jpg)
Más funciones para listas (1) append: Unión de 2 o más listas en una:
– (append ‘(a) ‘(b c)) → (a b c) last: Regresa una lista con el último elemento:
– (last ‘(a b c d)) → (d)– (last ‘(a b c d) 2) → (c d)
butlast: Regresa la lista sin el último elemento– (butlast '(a b c d e)) → (a b c d)– (butlast '(a b c d e) 2) → (a b c)
![Page 27: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/27.jpg)
Más funciones para listas (2) reverse: Regresa la lista en orden inverso:
– (reverse ‘(a (b c) d e)) → (e d (b c) a) sort: Ordenamiento de listas:
– (sort ‘(2 4 1 5 3) #’<) → (1 2 3 4 5)– (sort ‘(2 4 1 5 3) #’>) → (5 4 3 2 1)– (sort '(b c a) 'string-lessp) → (a b c)– (sort '(b c a) 'string-greaterp)→(c b a)
position: Posición dentro de lista– (position ‘d ‘(a b c d e f))→ 3
![Page 28: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/28.jpg)
Más funciones para listas (3) member: Regresa el resto de la lista a partir de
primer argumento:– (member ‘b ‘(a b c d)) → (b c d)
set-difference: Regresa los elementos que resultan de “restar” dos listas.
– (set-difference '(a b c d) '(a c)) → (b d)
length: Regresa el número de elementos de nivel superior que hay en una lista.
– (length '(a b (c d))) → 3
![Page 29: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/29.jpg)
Más funciones para listas (4) remove: Elimina un elemento de una lista: (remove 100 '(1 2 100 3)) → (1 2 3) union: Toma 2 listas como conjuntos y regresa la
unión de esos 2 conjuntos:– (union '(a b c d) '(a c e)) → (b d a c e)
intersection: Regresa la intersección de 2 listas consideradas como conjuntos:
– (intersection '(a b c) '(b c d))→(b c)
![Page 30: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/30.jpg)
Funciones matemáticas de Lisp mod: Función Módulo:
– (mod 26 3) → 2– (mod -25 4) → 3
rem: Función Residuo (remainder):– (rem 26 3) → 2– (rem -25 4) → -1
abs: Valor absoluto:– (abs -3.5) → 3.5
![Page 31: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/31.jpg)
Otras funciones matemáticas (2) sqrt: Raíz cuadrada (square root):
– (sqrt 25) → 5 max y min: Máximo y mínimo:
– (max 3 5 9 3 1) → 9 – (min 3 5 9 3 1) → 1
expt: Exponenciación– (expt 2 3) → 8 (23)
exp: en– (exp 1) → 2.7182817 (e1)
![Page 32: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/32.jpg)
Más funciones matemáticas (3) log: Logaritmo
– (log 5) → 1.609438 (log10 5)– (log 8 2) → 3 (log2 8)
sin y cos: Funciones trigonométricas (en radianes):
– (sin 1) → 0.84147096– (cos 1) → 0.5403023
![Page 33: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/33.jpg)
Más funciones matemáticas (4) 1+ : Incrementa en uno.
– (1+ 5) → 6 1- : Decrementa en uno.
– (1- 5) → 4 gcd: Máximo común divisor.
– (gcd 15 10) → 5
![Page 34: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/34.jpg)
Predicados Son procedimientos que regresan t o nil. atom: ¿es un átomo? numberp: ¿es un número? listp: ¿es una lista? symbolp: ¿es un símbolo? zerop: ¿es el número 0? plusp: ¿es un número positivo? Otros: minusp, evenp, oddp, null.
![Page 35: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/35.jpg)
Definición de funciones defun nos permite definir nuestras propias funciones:
– (defun nombre (arg1 arg2 arg3 ...) cuerpo) Por ejemplo:
– (defun inc5 (n) (+ 5 n))– Define la función llamada inc5 que incrementa en 5
su único argumento llamado n.– (inc5 3) → 8
![Page 36: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/36.jpg)
Parámetros opcionales (1)
En Lisp, las funciones pueden definirse con parámetros opcionales.
Por ejemplo, sea la función raiz que regresa la raíz cuadrada si es invocada con un solo parámetro y la raíz n si es invocada con 2 parámetros.
![Page 37: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/37.jpg)
Parámetros opcionales (2)((defun raiz (x &optional n)
(if n (expt x (/ n))
(sqrt x)) )
Si al invocar raiz lo hacemos con un sólo parámetro, este se asigna a x y n se vuelve nil.
(raiz 25) → 5 {X=5, n=nil}
Si lo hacemos con dos parámetros, x toma el primer valor y n toma el segundo
(raiz 64 4) → 4 {x=64, n=4}
![Page 38: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/38.jpg)
Parámetros opcionales (3) También podemos definir el valor por omisión para el
parámetro opcional:
En este caso, si raiz es llamado con un solo parámetro, n toma el valor de 2.
• (raiz 25) → 5 {X=5, n=2}
(defun raiz (x &optional (n 2))
(expt x (/ n)) )
![Page 39: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/39.jpg)
Entrada y salida Las funciones de Entrada/Salida más comunes son: Entrada:
– read Salidas básicas:
– print - prin1– princ - terpri
Salida con formato:– format
![Page 40: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/40.jpg)
Ejemplo de read• read causa que el programa se detenga en espera
de una entrada desde el teclado:
Cuando el intérprete encuentra el read, espera por una entrada desde el teclado y la entrega a la función +.
(+ 10 (read))
![Page 41: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/41.jpg)
print• print toma una cadena o un átomo como
argumento, la despliega y regresa el argumento.• print antecede su argumento con un retorno de
carro y un avance de línea y la sigue con un espacio• (print “Hola Mundo!”)
– “Hola Mundo!” ; valor desplegado– “Hola Mundo!” ; valor que regresa
![Page 42: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/42.jpg)
prin1• prin1 funciona igual que print, pero no agrega ni
el retorno de carro ni el avance de línea al inicio ni el espacio al final.
• (prin1 “hola”)– “hola” ; valor desplegado– “hola” ; valor que regresa
![Page 43: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/43.jpg)
princ y terpri
• princ es igual a prin1 sólo que no imprime las comillas de la cadena de caracteres.
• (princ “Hola Mundo!”)– Hola Mundo! ; valor desplegado– “Hola Mundo!” ; valor que regresa
• terpri no toma argumentos, sólo introduce un retorno de carro y un avance de línea y regresa nil.
![Page 44: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/44.jpg)
Un ejemplo con E/S básicas(defun area-circulo ()
(terpri)
(princ “Por favor, teclea el radio:”)
(setq radio (read))
(princ “El area del circulo es: ”)
(princ (* pi radio radio))
(terpri)
)
![Page 45: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/45.jpg)
format (1) La función format nos permite generar salidas mejor
formadas que las operaciones de salida básica. Su sintáxis es:
– (format <destino> <cadena> arg1 arg2... argn)
Para nuestros propósitos <destino> será t, que es la salida por omisión, la pantalla de video.
![Page 46: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/46.jpg)
format (2) En la <cadena> se introduce la cadena de
caracteres de salida que se desee desplegar junto con algunas directivas de formato que especifican como deben representarse los argumentos arg1 ... argn.
Las directivas de formato deben aparecer en el mismo orden que los argumentos a desplegar.
![Page 47: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/47.jpg)
Directivas de formato (3) Las directivas de formato son precedidas por la tilde (~)
para identificarlas como tales. Algunas directivas de formato son:
– ~A: El argumento se despliega como con princ– ~S: El argumento se despliega como con prin1– ~D: El argumento debe ser entero y se despliega en
decimal.– ~F: El argumento debe ser un número y se despliega en
decimal con punto flotante.– ~%: Se despliega una nueva línea
![Page 48: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/48.jpg)
Ejemplo de format
;;; area-circulo2;;; Ilustra el uso de format(defun area-circulo2 () (terpri) (princ "Por favor, teclea el radio: ") (setq radio (read)) (format t "El area del circulo con radio ~4F es: ~7F~%” radio (* pi radio radio)))
![Page 49: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/49.jpg)
Capturando la sesión Lisp nos provee un medio para capturar los resultados de
una sesión interactiva:– (dribble “archivo_salida.txt”)
Esto indica a Lisp que envie una copia de todo lo que aparece en pantalla al archivo “archivo_salida.txt”
Para detener la captura:– (dribble)
Que indica a Lisp que detenga la captura.
![Page 50: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/50.jpg)
Editando programas Para editar un programa de Common Lisp se puede
utilizar cualquier editor de texto que maneje texto plano.
En Windows, podemos usar notepad En Linux, podemos usar vi o emacs. Por convención, los archivos con código de Common
Lisp usan la extensión .lsp En Windows, desde una ventana de DOS, tecleamos notepad nombrearch.lsp
![Page 51: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/51.jpg)
Cargando archivos Para cargar un archivo con código Lisp, desde el
prompt de Common Lisp tecleamos: (load “nombrearch.lsp”)
En nuestro caso, tecleamos:
(load “z:/nombrearch.lsp”). Esto supone que el archivo está almacenado en la
raíz de la unidad Z de Windows.
![Page 52: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/52.jpg)
Estructuras de control (1) Decisiones condicionales
– (if condición acción-verdadero acción-falso)
Por ejemplo:– (defun mayor (a b) (if (> a b) a b))
– (mayor 5 3) → 5– (mayor 4 6) → 6
![Page 53: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/53.jpg)
Estructuras de control (2)• cond (conditional) es similar a if..then..else. Sintaxis:
Cada prueba se evalúa hasta que una de ellas resulta diferente de nil, en cuyo caso se ejecutan las acciones asociadas y termina el cond.
(cond (prueba1 accion11 accion12 ... accion1n)
(prueba2 accion21 accion22 ... accion2m)
: : : :
(pruebak accionk1 accionk2 ... accionkl))
![Page 54: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/54.jpg)
Ejemplo de cond(defun compara (a b) (cond((= a b) (princ “A igual a B”))
((< a b) (princ “A es menor que B”)) (t (princ “A es mayor que B”)))
)
(compara 4 5) → “A es menor que B”(compara 4 4) → “A es igual a B”(compara 5 4) → “A es mayor que B”
![Page 55: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/55.jpg)
Estructuras de control (3) case es otra forma condicional Sintaxis:
(case clave
(valor1 accion11 accion12 ... accion1n)
(valor2 accion21 accion22 ... accion2m)
: : : :
(clavek accionk1 accionk2 ... accionkl)
(otherwise acciond1 acciond2 ...acciondn))
![Page 56: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/56.jpg)
Ejemplo de case(defun figura (forma r) (case forma (circulo (* pi r r)) (esfera (* 4 pi r r)) (otherwise (princ “figura no conocida”)) ))
> (figura 'circulo 1) → 3.141592...> (figura 'esfera 1) → 12.5336....> (figura 'cuadrado 2) → “figura no conocida”
![Page 57: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/57.jpg)
Funciones recursivas Una función recursiva es aquella que puede usarse a
sí misma. Por ejemplo:• factorial(n) puede definirse recursivamente
como:– 1 para n=0– n*factorial(n-1) para n>1
![Page 58: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/58.jpg)
Factorial(n) en Lisp
;;; Factorial de n como una;;; función recursiva(defun fact (x) (if (= x 0) 1 (* x (fact (1- x))) ) )
Esta es una función recursiva simple porque en su definición se llama a sí misma una sola vez.
![Page 59: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/59.jpg)
Más funciones recursivas simples• Mn se puede definir recursivamente como:
– 1 para n=0– M*Mn-1 para n>0
En Lisp:
(defun potencia (m n)
(if (zerop n) 1
(* m (potencia m (1- n)))
)
)
![Page 60: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/60.jpg)
Longitud de una lista
;;; Obtiene la longitud de la lista
(defun longitud (lista)
(if (endp lista) 0
(1+ (longitud (rest lista)))
)
)
Otro ejemplo de recursión simple:
![Page 61: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/61.jpg)
Funciones recursivas dobles La función de Fibonacci(n) se define como:
– 1 para n=0– 1 para n=1– Fibonacci(n-1) + Fibonacci(n-2) para n > 1
Esta función se llama dos veces a sí misma, por lo que se dice que tiene recursión doble.
![Page 62: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/62.jpg)
Fibonacci en Lisp
;;; Obtiene la función de Fibonacci
;;; con recursión doble.
(defun fibonacci (n)
(if (or (zerop n) (= n 1)) 1
(+ (fibonacci (1- n)) (fibonacci (- n 2)) )
)
)
![Page 63: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/63.jpg)
Mapcar y Funcall• Mapcar es una instrucción que se utiliza para transformar
listas. Sintáxis:
– (mapcar #’procedimiento lista) Mapcar genera una nueva lista con los elementos de lista afectados por procedimiento.
Nota: #’ es una abreviatura de function, que define el átomo siguiente como una función.
![Page 64: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/64.jpg)
Ejemplos de mapcar
(mapcar #’1+ ‘(1 2 3)) → (2 3 4)
(mapcar #’oddp ‘(3 4 5)) → (T NIL T)
• Suponiendo que inc5 está definida como:
(defun inc5 (n) (+ n 5))
Entonces:
(mapcar #’inc5 ‘(3 4 5)) → (8 9 10)
![Page 65: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/65.jpg)
Funcall
• Funcall aplica el argumento inicial al valor de los otros argumentos.
Sintáxis:– (funcall #’arg0 arg1 arg2 ... argn)
Esta instrucción produce átomos o listas dependiendo del valor de arg0.
![Page 66: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/66.jpg)
Ejemplos de funcall
(funcall #’1+ 1 2 3) → 6
(funcall #’append ‘(a b) ‘(c d))
→ (a b c d)
(funcall #’member ‘c ‘(a b c d))
→ (c d)
(funcall #’position ‘d ‘(a b c d e f))
→ 3
![Page 67: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/67.jpg)
Lazos e iteraciones Existen varias maneras de implementar lazos (loops)
e iteraciones en Common Lisp. Algunas de ellas son:
– dolist– dotimes– do– loop
![Page 68: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/68.jpg)
Dolist• Dolist asigna a una variable los valores de los
elementos de una lista en orden hasta que encuentra el fin de la lista.
Sintáxis:– (dolist (var lista) cuerpo)
Ejemplo:
(dolist (x ‘(5 6 7 8))
(print (* x x))
)
Nota: Dolist siempre retorna nil
![Page 69: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/69.jpg)
Dotimes• Dotimes ejecuta las sentencias de su cuerpo n veces
utilizando una variable como contador. Sintáxis:
– (dotimes (var_conta limite) cuerpo) Ejemplo:
(dotimes (i 10)
(print i)
)Note que este ejemplo despliega 0,1,2, ..., 9 dado que el valor inicial de la variable es cero y se incrementa en uno cada iteración. Dotimes siempre retorna nil.
![Page 70: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/70.jpg)
Do (1) Esta es la forma de iteración más complicada ya que
consta de 3 partes:– En la primera se definen las variables a utilizar, sus
valores iniciales y como deben actualizarse en cada iteración.
– En la segunda se especifican la condición de terminación y el valor a regresar.
– La última parte es el cuerpo. Mientras la condición de terminación es falsa, do itera su
cuerpo y actualiza sus variables.
![Page 71: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/71.jpg)
Do (2)
Sintáxis:– (do ( (var1 val_ini_1 actualiza_1) (var2 val_ini_2 actualiza_2)... (varn val_ini_n actualiza_n) ) (cond_termina valor_a_retornar)
cuerpo ) Ejemplo:
(do ((x 0 (1+ x))) ((> x 9) x) (print x)
)
![Page 72: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/72.jpg)
Loop• Loop realiza iteraciones sobre su cuerpo mientras no
encuentre una instrucción (return). Sintáxis:
– (loop cuerpo) Ejemplo:
(setq a 0)
(loop (setq a (1+ a))
(print a)
(when (> a 9) (return a)) )
![Page 73: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/73.jpg)
Funciones lambda Lambda se utiliza cuando se desea crear una función
temporal que no tendrá un nombre. Patrick H. Winston sugirió sustituir, en nuestra
imaginación, la frase “defun-anónimo” por “lambda”. Sintáxis:
– (lambda (arg1 arg2 ... argn) cuerpo )
![Page 74: Intro Common Lisp 2012](https://reader034.vdocuments.site/reader034/viewer/2022052304/55721396497959fc0b929c56/html5/thumbnails/74.jpg)
Ejemplo de lambda El siguiente ejemplo muestra el uso de lambda:
Se define una función anónima que incrementa en 2 y se aplica a una lista por medio de mapcar.
(mapcar #’(lambda (x) (+ x 2))
‘(1 3 5 7)
)