— Special Form: setq [symbol form]...

This special form is the most common method of changing a variable's value. Each symbol is given a new value, which is the result of evaluating the corresponding form. The most-local existing binding of the symbol is changed.

setq does not evaluate symbol; it sets the symbol that you write. We say that this argument is automatically quoted. The `q' in setq stands for “quoted.”

The value of the setq form is the value of the last form.

          (setq x (1+ 2))
               => 3
          x                   ; x now has a global value.
               => 3
          (let ((x 5))
            (setq x 6)        ; The local binding of x is set.
            x)
               => 6
          x                   ; The global value is unchanged.
               => 3
     

Note that the first form is evaluated, then the first symbol is set, then the second form is evaluated, then the second symbol is set, and so on:

          (setq x 10          ; Notice that x is set before
                y (1+ x))     ;   the value of y is computed.
               => 11
     

— Function: set symbol value

This function sets symbol's value to value, then returns value. Since set is a function, the expression written for symbol is evaluated to obtain the symbol to set.

The most-local existing binding of the variable is the binding that is set; shadowed bindings are not affected.

          (set one 1)
          error--> Symbol's value as variable is void: one
          (set 'one 1)
               => 1
          (set 'two 'one)
               => one
          (set two 2)         ; two evaluates to symbol one.
               => 2
          one                 ; So it is one that was set.
               => 2
          (let ((one 1))      ; This binding of one is set,
            (set 'one 3)      ;   not the global value.
            one)
               => 3
          one
               => 2
     

If symbol is not actually a symbol, a wrong-type-argument error is signaled.

          (set '(x y) 'z)
          error--> Wrong type argument: symbolp, (x y)
     

Logically speaking, set is a more fundamental primitive than setq. Any use of setq can be trivially rewritten to use set; setq could even be defined as a macro, given the availability of set. However, set itself is rarely used; beginners hardly need to know about it. It is useful only for choosing at run time which variable to set. For example, the command set-variable, which reads a variable name from the user and then sets the variable, needs to use set.

Common Lisp note: In Common Lisp, set always changes the symbol's “special” or dynamic value, ignoring any lexical bindings. In Emacs Lisp, all variables and all bindings are dynamic, so set always affects the most local existing binding.