Basic Equation Tokenizer
1. Review


There's no docstring. What does the function do? What does it return?
The result includes the spaces:

&gt;&gt;&gt; tokenize('1 + 2')
['1', ' ', '+', ' ', '2']


but it seems unlikely that the spaces are significant. One of the useful things a tokenizer can do is to discard whitespace.
The tokens are collected into a list and returned. This is inflexible because you have to wait for them all to be collected before you can start processing them. But parsing tends to use one token at a time, so it is often more convenient for the tokenizer to generate the tokens one at a time using the yield instruction.
There's no error-detection:

&gt;&gt;&gt; tokenize('3E$£ω∞あ')
['3', 'E', '$', '£', 'ω', '∞', 'あ']


One of the things a tokenizer ought to do is to detect and report invalid tokens. Surely it's not the case that every string is a valid input to your program?
The tokenizer does not handle floating-point numbers:

&gt;&gt;&gt; tokenize('3.14159')
['3', '.', '14159']


or engineering notation:

&gt;&gt;&gt; tokenize('3e-08')
['3', 'e', '-', '08']


You write in the post that they "can be reconstructed later on" but it would be easier to have the tokenizer do it.
The tokenizer does not return anything other than the tokens themselves. Usually one of the jobs of a tokenizer is to categorize tokens (numbers, names, operators etc.) and to turn string representations of numbers into the number themselves.


2. Revised code

In Python it's often convenient to implement tokenization using a regular expression and the finditer method. In this case we could write:

from enum import Enum
import re

_TOKEN_RE = re.compile(r'''
    \s*(?:              # Optional whitespace, followed by one of:
    ([()^+*/-])         # Punctuation or operator
    |([a-z]+)           # Variable or function name
    |((?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)(?:e[+-]?[0-9]+)?) # Number
    |(\S))              # Anything else is an error
''', re.VERBOSE | re.IGNORECASE)

class Token(Enum):
    """Enumeration of token types."""
    PUNCT = 0           # Punctuation or operator
    NAME = 1            # Variable or function name
    NUMBER = 2          # Number

def tokenize(s):
    """Generate tokens from the string s as pairs (type, token) where type
    is from the Token enumeration and token is a float (if type is NUMBER)
    or a string (otherwise).

    """
    for match in _TOKEN_RE.finditer(s):
        punct, name, number, error = match.groups()
        if punct:
            yield Token.PUNCT, punct
        elif name:
            yield Token.NAME, name
        elif number:
            yield Token.NUMBER, float(number)
        else:
            raise SyntaxError("Expected a token but found {!r}".format(error))


This deals with all my points in §1 above:


There's a docstring.
Spaces are discarded.
Tokens are generated one at a time.
Errors are detected and reported:

&gt;&gt;&gt; list(tokenize('3E$£ω∞あ'))
Traceback (most recent call last):
  File "&lt;stdin&gt;", line 1, in &lt;module&gt;
  File "cr186024.py", line 49, in tokenize
    raise SyntaxError("Expected a token but found {!r}".format(error))
SyntaxError: Expected a token but found '$'

The tokenizer handles floating-point numbers and engineering notation:

&gt;&gt;&gt; list(tokenize('1.2 3e8 .2e-7'))
[(&lt;Token.NUMBER: 2&gt;, 1.2), (&lt;Token.NUMBER: 2&gt;, 300000000.0), (&lt;Token.NUMBER: 2&gt;, 2e-08)]

The tokenizer categorizes the token and converts numbers to floats.