'Lightweight persistence for python variables.
Example::
In [1]: l = [\'hello\',10,\'world\']
In [2]: %store l
In [3]: exit
(IPython session is closed and started again...)
ville@badger:~$ ipython
In [1]: l
NameError: name \'l\' is not defined
In [2]: %store -r
In [3]: l
Out[3]: [\'hello\', 10, \'world\']
Usage:
* ``%store``          - Show list of all variables and their current
values
* ``%store spam``     - Store the *current* value of the variable spam
to disk
* ``%store -d spam``  - Remove the variable and its value from storage
* ``%store -z``       - Remove all variables from storage
* ``%store -r``       - Refresh all variables from store (overwrite
current vals)
* ``%store -r spam bar`` - Refresh specified variables from store
(delete current val)
* ``%store foo >a.txt``  - Store value of foo to new file a.txt
* ``%store foo >>a.txt`` - Append value of foo to file a.txt
It should be noted that if you change the value of a variable, you
need to %store it again if you want to persist the new value.
Note also that the variables will need to be pickleable; most basic
python types can be safely %store\'d.
Also aliases can be %store\'d across sessions.'

@line_magic
def store(self, parameter_s=''):

    (opts, argsl) = self.parse_options(parameter_s, 'drz', mode='string')
    args = argsl.split(None, 1)
    ip = self.shell
    db = ip.db
    if ('d' in opts):
        try:
            todel = args[0]
        except IndexError:
            raise UsageError('You    must    provide    the    variable    to    forget')
        else:
            try:
                del db[('autorestore/' + todel)]
            except:
                raise UsageError(("Can't    delete    variable    '%s'" % todel))
    elif ('z' in opts):
        for k in db.keys('autorestore/*'):
            del db[k]
    elif ('r' in opts):
        if args:
            for arg in args:
                try:
                    obj = db[('autorestore/' + arg)]
                except KeyError:
                    print ('no    stored    variable    %s' % arg)
                else:
                    ip.user_ns[arg] = obj
        else:
            restore_data(ip)
    elif (not args):
        vars = db.keys('autorestore/*')
        vars.sort()
        if vars:
            size = max(map(len, vars))
        else:
            size = 0
        print 'Stored    variables    and    their    in-db    values:'
        fmt = (('%-' + str(size)) + 's    ->    %s')
        get = db.get
        for var in vars:
            justkey = os.path.basename(var)
            print (fmt % (justkey, repr(get(var, '<unavailable>'))[:50]))
    else:
        if ((len(args) > 1) and args[1].startswith('>')):
            fnam = os.path.expanduser(args[1].lstrip('>').lstrip())
            if args[1].startswith('>>'):
                fil = open(fnam, 'a')
            else:
                fil = open(fnam, 'w')
            obj = ip.ev(args[0])
            print ("Writing    '%s'    (%s)    to    file    '%s'." % (args[0], obj.__class__.__name__, fnam))
            if (not isinstance(obj, str)):
                from pprint import pprint
                pprint(obj, fil)
            else:
                fil.write(obj)
                if (not obj.endswith('\n')):
                    fil.write('\n')
            fil.close()
            return
        try:
            obj = ip.user_ns[args[0]]
        except KeyError:
            name = args[0]
            try:
                cmd = ip.alias_manager.retrieve_alias(name)
            except ValueError:
                raise UsageError(("Unknown    variable    '%s'" % name))
            staliases = db.get('stored_aliases', {})
            staliases[name] = cmd
            db['stored_aliases'] = staliases
            print ('Alias    stored:    %s    (%s)' % (name, cmd))
            return
        else:
            modname = getattr(inspect.getmodule(obj), '__name__', '')
            if (modname == '__main__'):
                print textwrap.dedent(("                                                                                Warning:%s    is    %s\n                                                                                Proper    storage    of    interactively    declared    classes    (or    instances\n                                                                                of    those    classes)    is    not    possible!    Only    instances\n                                                                                of    classes    in    real    modules    on    file    system    can    be    %%store'd.\n                                                                                " % (args[0], obj)))
                return
            db[('autorestore/' + args[0])] = obj
            print ("Stored    '%s'    (%s)" % (args[0], obj.__class__.__name__))
