a = [ 'abc=lalalla', 'appa=kdkdkdkd', 'kkakaka=oeoeoeo']
d = dict(s.split('=') for s in a)
print d


Output:
{'kkakaka': 'oeoeoeo', 'abc': 'lalalla', 'appa': 'kdkdkdkd'}

http://codepad.org/bZ8lGuHE

You can work with .split():

data = {
    'name': self.name,
    'type': self.type,
    # …
    'keywords': [{'name': n} for n in self.keywords.split(',')],
}

It might however be better to work with a custom field. You can define such field with:

from django.db import models


class ListAsCharField(models.Field):
    def __init__(self, separator=',', *args, **kwargs):
        self.separator = separator
        super().__init__(*args, **kwargs)

    def get_db_prep_value(self, value, connection, prepared=False):
        if isinstance(value, (str, type(None))):
            value = self.separator.join(str(x) for x in value)
        return super().get_db_prep_value(value, connection, prepared)

    def from_db_value(self, value, expression, connection):
        if isinstance(value, str):
            return value.split(self.separator)

    def to_python(self, value):
        if isinstance(value, str):
            value = value.split(self.separator)
        return value

then you can use this in the model to automatically do the wrapping/unwrapping from a list:

class MyClass1(models.Model):
    keywords = ListAsCharField(
        max_length=256, verbose_name=_('Keywords'), null=True, blank=True
    )

Then you can process this with:

data = {
    'name': self.name,
    'type': self.type,
    # …
    'keywords': [{'name': n} for n in self.keywords],
}

Your string looks very similar to the YAML syntax. Indeed it is almost valid syntax for an associative list, there are only spaces missing after the :. So, why not use a YAML parser?

import yaml

data = """
41:n
43:n
44:n
46:n
47:n
49:n
50:n
51:n
52:n
53:n
54:n
55:cm
56:n
57:n
58:n"""

print(yaml.load(data.replace(":", ": ")))
# {41: 'n',
#  43: 'n',
#  44: 'n',
#  46: 'n',
#  47: 'n',
#  49: 'n',
#  50: 'n',
#  51: 'n',
#  52: 'n',
#  53: 'n',
#  54: 'n',
#  55: 'cm',
#  56: 'n',
#  57: 'n',
#  58: 'n'}

You might have to install it first, which you can do via pip install yaml.

Using a simple iteration.

Ex:

result = []
with open(filename) as infile:
    for line in infile:                   #Iterate each line
        key, val = line.split(":")        #Get key-value
        for i in val.strip().split():
            result.append((key, i))

with open(filename, "w") as outfile:      #Write Output
    for line in result:
        outfile.write(": ".join(line) + "\n")  

Output:

1: 200
3: 300
3: 400
3: abc
4: xyz
4: 300

You can combine both cases by concatenating your b.name value with an empty array:

b.options = [].concat(b.name).map(function(v,i) { 
    return [v, b.value[i]]; 
});

in that way, you will get an array from b.name when is a string and also when it is an array already. You may need to handle the case when b or b.name is undefined though. Or you can use more general zip function:

var zip = function(arr1, arr2) {
  var a = [].concat(arr1);
  var b = [].concat(arr2);
  var len = Math.min(a.length, b.length)

  return a.slice(0, len).map(function(item, i){
      return [a[i], b[i]];
  });
}

b.options = zip(b.name, b.value);

Mind in that case that the returned array will have the length of the shortest array.

First off, you should standardize your names, Key and value don't follow the same naming rules, or if they do, they're not apparent to me. And so I'd recommend that you name your things in lower_snake_case, to adhere to PEP8.

After this I'd use str.strip rather than str.split. And use a list comprehension to change both the key and value without having to duplicate the code, which can remove the key and value variables altogether. This can leave you with:

item = [i.strip() for i in line.split('=')]
CQ_options[item[0]] = item[1]

If you want to stick with using key and value however, you need to make sure that line.split('=') will only return two items. You can make sure it'll return a max of two items with the optional parameter, and since we'd already error if there's not at least a single =, then you can use:

key, value = [i.strip() for i in line.split('=', 1)]
CQ_options[key] = value

You can use the $ at the start of a line to identify this is a new key, append it to the keys list and append a new blank string to the values list. Then every time you have a line which doesnt start with a $ you concat that value on to the last element of values as this line must be related to the current key. only when you read a new key do you create a new blank values element.

data = "$key\nsome value\n$another_key\nanother longer\nvalue\n"
keys = []
values = []
for line in data.split('\n'):
    if line.startswith('$'):
        keys.append(line)
        values.append("")
    else:
        values[-1] += line
print(keys, values)

Output

['$key', '$another_key'] ['some value', 'another longervalue']

Use re.findall():

dict(re.findall(r'(\w+)="([^"]+)"', twikiattribs))

re.findall(), when presented with a pattern with multiple capturing groups, returns a list of tuples, each nested tuple containing the captured groups. dict() happily takes that output and interprets each nested tuple as a key-value pair.

Demo:

>>> import re
>>> twikiattribs = 'author="PersonsName" date="1183050420" format="1.1" version="1.2"'
>>> re.findall(r'(\w+)="([^"]+)"', twikiattribs)
[('author', 'PersonsName'), ('date', '1183050420'), ('format', '1.1'), ('version', '1.2')]
>>> dict(re.findall(r'(\w+)="([^"]+)"', twikiattribs))
{'date': '1183050420', 'format': '1.1', 'version': '1.2', 'author': 'PersonsName'}

re.split() also behaves differently based on capturing groups; the text on which you split is included in the output if grouped. Compare the output with and without the capturing group:

>>> re.split('(=?" ?)', twikiattribs)
['author', '="', 'PersonsName', '" ', 'date', '="', '1183050420', '" ', 'format', '="', '1.1', '" ', 'version', '="', '1.2', '"', '']
>>> re.split('=?" ?', twikiattribs)
['author', 'PersonsName', 'date', '1183050420', 'format', '1.1', 'version', '1.2', '']

The re.findall() output is far easier to convert to a dictionary however.

You can just use eval or ast.literal_eval appending opening and closing curly braces at the beginning and the end of your string representation.

>>> import ast
>>> ast.literal_eval('{'+test_str+'}')
{1: 20, 3: 4, 5: 30}