Elisp Cheatsheet for Python Programmers

Elisp list specific translations.

Elisp vector specific translations.

These translations work on either Elisp list or vector types.

Elisp analogs to the Python list methods to handle insertion, appending, and updating are left to the developer to implement. Arguably, the omission of these functions is reluctance on the part of Emacs Core to make the trade-off design decisions required to implement them.

The following Elisp translations will mutate the original input s.

These translations work on either Elisp list or vector types.

An association list (alist) is a list with structure ((key1 . value1) (key2 . value2) …).

Conventional Elisp wisdom arguing for alist usage over a hash-table boils down to convenient serialization and the notion that in practice, alist sizes are small enough to not merit the overhead of using hash-tables (described below).

d: dictionary/alist
k: key
v: value

A property list (plist) is a list with structure (key1 value1 key2 value2 …). Most all the map- commands used to operate on an alist also apply to a plist with the exception of initialization. Whereas an alist can be initialized to be empty (nil), a plist must be initialized with a key, value pair.

A common convention is to name plist keys with a ‘:’ prefix character (e.g. :name). Note the key type is an Elisp symbol, not a string.

d: dictionary/plist
k: key
v: value

The Elisp hash-table is the most straightforward analog to a Python dictionary. That said, there are gotchas, particularly around hash-table creation. If the keys are of type string, then the key comparison should be set to the function equal via the :test slot. If :test is omitted the default function eql is used which compares numbers.

d: dictionary/hash-table
k: key
v: value
cmp: comparison function

Basic Python for loop running the function f(i) for every element in range(n). No results are returned.

for i in range(n):
    f(i)

Elisp equivalent using mapc which does not accumulate results.

(mapc #'f (number-sequence 0 (1- n))) ; f is a function with a single argument

Python map function on an iterable.

map(f range(n)) # f is a function with a single argument

Elisp equivalent using mapcar.

(mapcar #'f (number-sequence 0 (1- n)))

Python filter example of odd numbers only from 0 to 9 inclusive.

filter(lambda x: x % 2, range(10))

Elisp seq-filter equivalent. Note that in Elisp, a 0 value does not coerce to a false value when compared like in Python.

(seq-filter (lambda (x)
              (if (eq 0 (mod x 2))
                  nil
                t))
            (number-sequence 0 9))

Python reduce example.

from functools import reduce
reduce(lambda x,y: x+y, range(10))

Elisp seq-reduce equivalent.

(seq-reduce (lambda (x y)
              (+ x y))
            (number-sequence 0 9) 0)

Python iteration through dictionary d using for loop.

for k,v in d.items():
    f(k,v)

Elisp equivalent using map-do. No results are accumulated.

(map-do #'f d)

Python dictionary iteration example, saving results in a list.

results = []
for k,v in d.items():
    results.append(f(k, v))

Elisp equivalent, where the returned result is a list of each result of f applied to a key, value pair of d.

(map-apply #'f d)

Python and Elisp use different styles of regular expressions (regexps). This document offers no translation of Python regexp style to Elisp. However what is offered is mention of regexp-related calls by both.

p: pattern
r: replacement
s: string