let and let* create new variable bindings and execute a series of forms that use these bindings. 
let performs the bindings in parallel and let* does them sequentially.

The form

 (let ((var1 init-form-1)
       (var2 init-form-2)
       ...
       (varm init-form-m))
   declaration1
   declaration2
   ...
   declarationp
   form1
   form2
   ...
   formn)

first evaluates the expressions init-form-1, init-form-2, and so on, in that order, saving the resulting values. 
Then all of the variables varj are bound to the corresponding values; 
each binding is lexical unless there is a special declaration to the contrary. 
The expressions formk are then evaluated in order; the values of all but the last are discarded 
   (that is, the body of a let is an implicit progn).
let* is similar to let, but the bindings of variables are performed sequentially rather than in parallel. 
The expression for the init-form of a var can refer to vars previously bound in the let*.

The form

 (let* ((var1 init-form-1)
        (var2 init-form-2)
        ...
        (varm init-form-m))
   declaration1
   declaration2
   ...
   declarationp
   form1
   form2
   ...
   formn)
first evaluates the expression init-form-1, then binds the variable var1 to that value;
 then it evaluates init-form-2 and binds var2, and so on. 
The expressions formj are then evaluated in order; 
the values of all but the last are discarded (that is, the body of let* is an implicit progn).

For both let and let*, if there is not an init-form associated with a var, var is initialized to nil.

The special form let has the property that the scope of the name binding does not include any initial value form. 
For let*, a variable's scope also includes the remaining initial value forms for subsequent variable bindings.


Examples:

 (setq a 'top) =>  TOP
 (defun dummy-function () a) =>  DUMMY-FUNCTION
 (let ((a 'inside) (b a))
    (format nil "~S ~S ~S" a b (dummy-function))) =>  "INSIDE TOP TOP" 
 (let* ((a 'inside) (b a))
    (format nil "~S ~S ~S" a b (dummy-function))) =>  "INSIDE INSIDE TOP" 
 (let ((a 'inside) (b a))
    (declare (special a))
    (format nil "~S ~S ~S" a b (dummy-function))) =>  "INSIDE TOP INSIDE"

Simple LOOP loops forever...

? (loop
    (print "Look, I'm looping!"))
"Look, I'm looping!" 
"Look, I'm looping!" 
"Look, I'm looping!" 
"Look, I'm looping!" 
"Look, I'm looping!" 
"Look, I'm looping!" 
"Look, I'm looping!" 
"Look, I'm looping!" 
... and so on, until you interrupt execution... 
Aborted
? 

? (let ((n 0))
    (loop
      (when (> n 10) (return))
      (print n) (prin1 (* n n))
      (incf n)))
0 0
1 1
2 4
3 9
4 16
5 25
6 36
7 49
8 64
9 81
10 100
NIL
?

? (dotimes (n 11)
    (print n) (prin1 (* n n)))
0 0
1 1
2 4
3 9
4 16
5 25
6 36
7 49
8 64
9 81
10 100
NIL
?

? (dolist (item '(1 2 4 5 9 17 25))
    (format t "~&~D is~:[n't~;~] a perfect square.~%" item (integerp (sqrt item))))
1 is a perfect square.
2 isn't a perfect square.
4 is a perfect square.
5 isn't a perfect square.
9 is a perfect square.
17 isn't a perfect square.
25 is a perfect square.
NIL

? (dolist (item `(1 foo "Hello" 79.3 2/3 ,#'abs))
    (format t "~&~S is a ~A~%" item (type-of item)))
1 is a FIXNUM
FOO is a SYMBOL
"Hello" is a (SIMPLE-BASE-STRING 5)
79.3 is a DOUBLE-FLOAT
2/3 is a RATIO
#<Compiled-function ABS #x1E9CC3E> is a FUNCTION
NIL
? 

? (do ((which 1 (1+ which))
       (list '(foo bar baz qux) (rest list)))
      ((null list) 'done)
    (format t "~&Item ~D is ~S.~%" which (first list)))
Item 1 is FOO.
Item 2 is BAR.
Item 3 is BAZ.
Item 4 is QUX.
DONE
? 

     (var2 init2 step2)
     ...)
    (end-test result)
  statement1
  ...)

var1       = which
init1      = 1
step1      = (1+ which)
var2       = list
init2      = '(foo bar baz qux)
step2      = (rest list)
end-test   = (null list)
result     = 'done
statement1 = (format t "~&Item ~D is ~S.~%" which (first list))

find item sequence &key from-end test test-not start end key => element

find-if predicate sequence &key from-end start end key => element

find-if-not predicate sequence &key from-end start end key => element

Examples:
(find #\d "here are some letters that can be looked at" :test #'char>)
=> #\Space
(find-if #'oddp '(1 2 3 4 5) :end 3 :from-end t) => 3
(find-if-not #'complexp '#(3.5 2 #C(1.0 0.0) #C(0.0 1.0)) :start 2) => NIL

mapc function &rest lists+ => list-1

mapcar function &rest lists+ => result-list

mapcan function &rest lists+ => concatenated-results

mapl function &rest lists+ => list-1

maplist function &rest lists+ => result-list

mapcon function &rest lists+ => concatenated-results

(mapcar #'car '((1 a) (2 b) (3 c))) =>  (1 2 3)   
(mapcar #'abs '(3 -4 2 -5 -6)) =>  (3 4 2 5 6)  
(mapcar #'cons '(a b c) '(1 2 3)) =>  ((A . 1) (B . 2) (C . 3)) 

(maplist #'append '(1 2 3 4) '(1 2) '(1 2 3))  =>  ((1 2 3 4 1 2 1 2 3) (2 3 4 2 2 3)) 
(maplist #'(lambda (x) (cons 'foo x)) '(a b c d)) =>  ((FOO A B C D) (FOO B C D) (FOO C D) (FOO D))  
(maplist #'(lambda (x) (if (member (car x) (cdr x)) 0 1)) '(a b a c d b c)) =>  (0 0 1 0 1 1 1)

(setq dummy nil) =>  NIL   
(mapc #'(lambda (&rest x) (setq dummy (append dummy x)))
         '(1 2 3 4)
         '(a b c d e)
         '(x y z)) =>  (1 2 3 4)
dummy =>  (1 A X 2 B Y 3 C Z)

(setq dummy nil) =>  NIL   
(mapl #'(lambda (x) (push x dummy)) '(1 2 3 4)) =>  (1 2 3 4)   
dummy =>  ((4) (3 4) (2 3 4) (1 2 3 4))   

(mapcan #'(lambda (x y) (if (null x) nil (list x y)))   
        '(nil nil nil d e)  
        '(1 2 3 4 5 6)) =>  (D 4 E 5)   
(mapcan #'(lambda (x) (and (numberp x) (list x)))  
        '(a 1 b c 3 4 d 5)) =>  (1 3 4 5) 

(mapcon #'list '(1 2 3 4)) =>  ((1 2 3 4) (2 3 4) (3 4) (4))