hmm, lists, tuples, arrays, sets or dicts for this data structure?

Question

Beginner programmer here. after a bunch of reading about 'variables' which dont exist in python, (still dont get that) Ive come to the opinion that I think I should be using lists in my data structure, but im not entirely sure.

im analysing a string which contains commands and normal words to be printed out, if the word is a command, which in this case is preceded by an '@' i want it to be in a separate list to the actual words. i will then process all this to be printed out afterwards, but i want the list to be ordered, so i can go through each element and test if it has a word in it, and if not do some action on the command.

so what i want really is a list with two indices(thankyou!) (what do you call that ?) like this:

arglist[x][y]

so i can go through arglist and process whether or not it contains a command or a word to be printed out. i want arglist[x] to contain words and arglist[y] to contain commands.

arglist = [] # not sure how to initialise this properly.
doh="my @command string is this bunch of words @blah with some commands contained in it"
for listindex, word in enumerate(doh):
    if word.startswith('@'):
        # its a command 
        arglist[listindex] = None
        arglist[listindex][listindex]=command
    else:
        # its a normal word
        arglist[listindex]=word
        rglist[listindex][listindex]=None

then i want to be able to go down the list and pick out commands, i guess that would be something like this:

# get the number of items in the list and go through them...
for listindex, woo in enumerate(len(arglist)):
    if arglist[listindex] is None:
        # there is no word here, so print command
        print arglist[listindex][listindex]      
        else:
            # just print out word
            print arglist[listindex] 

so: my question is which data type/ structure should I be using and should I / how do I initialise it ? am I barking up the right tree here?

edit: i just found this gem and now im even more unsure - i want it to be the fastest lookup possible on my data but i still want it to be ordered.

dict and set are fundamentally different from lists and tuples`. They store the hash of their keys, allowing you to see if an item is in them very quickly, but requires the key be hashable. You don't get the same membership testing speed with linked lists or arrays.

many thanks as usual for any help.

edit: eg my string from above should look something like this. doh="my @command string is this bunch of words @blah with some commands contained in it"

arglist[1] = 'my'
arglist[1][1] = None

arglist[2] = None
arglist[2][1] = command

arglist[3] = 'string'
arglist[3][1] = None

etc etc

this whole thing has left me a bit baffled i shall try and update this later.

EDIT: if anyone wanted to know what this was all about look here

Answer 1

The problem here is you've misunderstood the concept of multidimensional lists (arrays). To annotate the expected output you appended to your question:

arglist[1] = 'my'
arglist[1][1] # equivalent to 'my'[1], so you get 'y'.
              # and you cannot assign anything to arglist[1][1] 
              # because 'str' is immutable

arglist[2] = None
arglist[2][1] # invalid, because arglist[2] (None) is not subscriptable

---

If you simply want to iterate through the words and perform different operations depending on whether it is a command (starts with @) or a word, then you can do:

for val in doh.split():
    if val.startswith("@"):  # this is a command
        do_commandy_stuff(val)
    else:   # this is a word
        do_wordy_stuff(val)

If what you want is to be able to quickly look up words using and index and determine if it is a command or not, then how about:

>>> lookup = [(w.startswith("@"), w) for w in doh.split()]
>>> lookup
[(False, 'my'), (True, '@command'), (False, 'string'), (False, 'is'), (False, 'this'), (False, 'bunch'), (False, 'of'), (False, 'words'), (True, '@blah'), (False, 'with'), (False, 'some'), (False, 'commands'), (False, 'contained'), (False, 'in'), (False, 'it')]

lookup is now a list of tuples. The first value in the tuple denotes if it is a command or not, the second stores the word.

Looking words up is simple:

is_command, word = lookup[1]   # is_command = True, word = "@command"

While this seems closer to what you're trying to achieve, I don't see an obvious benefit unless you need lots of random access to words.

Answer 2

If I'm guessing what you're trying to do correctly, you just need two lists. Something like:

>>> def separate_commands(sample):
...   cmds, words = [], []
...   for word in sample.split(' '):
...     if word.startswith('@'):
...       cmds.append(word)
...     else:
...       words.append(word)
...   return cmds, words
...
>>> cmds, words = separate_commands("my @command string is this bunch of words @blah with some commands contained in it")
>>> print cmds
['@command', '@blah']
>>> print words
['my', 'string', 'is', 'this', 'bunch', 'of', 'words', 'with', 'some', 'commands', 'contained', 'in', 'it']

---

Update

>>> COMMANDS = dict(
...   green = '^]GREEN;',
...   brown = '^]BROWN;',
...   blink = '^]BLINK;',
...   reset = '^]RESET;',
... )
>>>
>>> def process_string(sample):
...   ret = []
...   for word in sample.split(' '):
...     if word.startswith('@'):
...       ret.append(COMMANDS.get(word[1:],'<UNKNOWN COMMAND>'))
...     else:
...       ret.append(word)
...   return ' '.join(ret)
...
>>> print process_string("my @green string is this bunch of words @reset with some commands contained in it")
my ^]GREEN; string is this bunch of words ^]RESET; with some commands contained in it

Answer 3

If you need to keep it ordered, then I suggest using a list of tupes. The below code is a generator expression, which can be used to generate a list or just process one

import re
from collections import OrderedDict

def parseCommand(in_string):
    pieces = re.split(r'\B@.*?\b', in_string) # split across words beginning with '@'
    if (not in_string.startswith("@")):
        # First pieces element contains no command
    else:
         for piece in pieces:
             command_parts = piece.split(None, 1)
             yield (command_parts[0], command_parts[1].strip())

command_list = list(parseCommand("my @command string is this bunch of words @blah with some commands contained in it"))

The best tool at this point is probably an ordered dict

commands = OrderedDict()
commands.update(command_list)

From which you can fetch individual commands by name:

blahcommand = commands['blah']

Or treat it as a stack or queue with the .popitem() method (whether it's a stack or queue depends on the boolean argument to popitem().