我需要将python列表拆分为几个python列表，但是新列表需要在某些字符串之间包含字段

Question

I have a fairly large Python 2.7 list containing strings like this:

biglist = ['A','B1','C00','D','A','1','2000','A','X','3','1','C','D','A','B','C']

I need to cut this up in several seperate lists cutted each time it finds a 'A' string in the list and then that new list contains everything until the next 'A'. So the result is this:

list1 = ['A','B1','C00','D']    
list2 = ['A','1','2000']
list3 = ['A','X','3','1','C','D']
list4 = ['A','B','C']
listx = ...

The amount of newly created list is also varying.

I'm completely stuck on this and it's completely over my head, I research all day can't find anything. Thank you for helping me out. I use python2.7

EDITED: MY STRINGS IN THE BIGLIST ARE NOT ALL 1 CHAR, THEY ARE DIFFERENT IN SIZE, THANK YOU FOR THE HELP.

Answer 1

it's can be done fairly simply with a generator

def split(biglist):
    last = None
    for x in biglist:
        if x == "A":
            if last:
                yield last
            last = [x]
        else:
            if last is None: # in case the list didn't start with 'A'
                last = []
            last.append(x)

for x in split(biglist):
    print x

['A', 'B', 'C', 'D']
['A', '1', '2']
['A', 'X', '3', '1', 'C', 'D']

Answer 2

This might not be elegant, but should do the trick:

biglist = ['A','B','C','D','A','1','2','A','X','3','1','C','D','A','B','C']

Make the list into a string first:

bigstring=" ".join(biglist)

Split on "A", sneakily insert A again

finallist=["A"+l for l in bigstring.split("A") if l]

Output:

['ABCD ', 'A 1 2 ', 'AX 3 1 CD ', 'AB C']

To access those strings, just do finallist[index] , eg finallist[0] gives you 'ABCD ' . You can also put them all into variables like so:

var1, var2, var3, var4 = finallist

To turn strings into lists, just do [l.split() for l in finallist]

Answer 3

Aside from the other excellent suggestions, you could write a generator which will give you things you can enumerate over late. This could be tidier, but...

def group(stuff):
  item = []
  for thing in stuff:
    if thing != 'A':
      item.append(thing)
      continue
    if len(item) > 0:
      yield item
    item = ['A']
  yield item

if __name__ == '__main__':
  biglist = ['A','B','C','D','A','1','2','A','X','3','1','C','D','A','B','C']
  for i in group(biglist):
    print i

Answer 4

I'd probably use itertools.groupby :

from itertools import groupby

def group_stuff(iterable, partition='A'):
    out = []
    for k, v in groupby(iterable, key=lambda x: x != partition):
        if not k:
            out = list(v)
        else:
            out.extend(v)
            yield out
            out = []
    if out:
        yield out



# Test cases
biglist = ['A','B','C','D','A','1','2','A','X','3','1','C','D','A','B','C']

for item in group_stuff(biglist):
    print(item)

print('*' * 80)
biglist.append('A')
for item in group_stuff(biglist):
    print(item)

print('*' * 80)
biglist.pop(0)
for item in group_stuff(biglist):
    print(item)

Basically, we notice that in your list we have 2 separate groups... The first group is "It's an A!", the second group is "It isn't an A". groupby will partition your iterable into those two groups trivially. All that remains is a little logic to merge the groups appropriately (adding a "It's an A!" group -- if it exists -- to the start of an "It's not an A" group).

If you have consecutive 'A' in your list, this will give you a list that has more than one 'A' at the beginning. If that's a problem, we can modify the logic in the if not k: block slightly to yield all but the last value as a list...

if not k:
    values = list(v)
    for item in values[:-1]:
        yield [item]
    out = [values[-1]]

As for setting that output as names in the local namespace, there are LOTS of questions around here which point out that this is generally a bad idea. Here's an external post which talks about it. The gist of it is that you'll do much better if you just use a to hold the data. Instead of

list0 = ...
list1 = ...

do:

lst[0] = ...
lst[1] = ...

etc. Your code will end up being much easier to work with.

Answer 5

First take your big-list and join it together as a string.

new_list = ''.join(biglist)

then you have new_list = 'ABCDA12AX31CDABC'

split up new_list on 'A'

split_list = new_list.split('A')

then you have split_list = ['', 'BCD', '12', 'X31CD', 'BC']

then add the 'A's back in there

final_list = ['A'+x for x in split_list if x]

alltoghether:

new_list = ''.join(biglist)
split_list = new_list.split('A')
final_list = ['A'+x for x in split_list if x]

>>> final_list
['ABCD', 'A12', 'AX31CD', 'ABC']

or in neato one line format:

final_list = ['A'+x for x in ''.join(biglist).split('A') if x]

slap it into a dictionary:

dict_lists = {}
for i,v in enumerate(final_list):
    dict_lists['list{}'.format(i)] = v

and access them like

>>> dict_lists['list0']
'ABCD'

Answer 6

You could put the results in a dictionary with 'list1' , 'list2' , ... as keys. The defaultdict creates a new key with an empty list every time an A is encountered in the list. The items followinng 'A' are added to this list until another 'A' is encountered.

from collections import defaultdict
from itertools import count

biglist = ['A','B','C','D','A','1','2','A','X','3','1','C','D','A','B','C']

c = count(1)
d = defaultdict(list)

for i in biglist:
    if i == 'A':
        j = str(next(c))
    d['list'+ j].append(i)

print(d)
# defaultdict(<class 'list'>, {'list2': ['A', '1', '2'], 'list3': ['A', 'X', '3', '1', 'C', 'D'], 'list1': ['A', 'B', 'C', 'D'], 'list4': ['A', 'B', 'C']})

The first list can be accessed via d['list1'] and generally d['listn'] where n is the number of lists in the dictionary values.

Answer 7

You can convert the list of characters in a string and use the split() function to divide the string at each occurrence of 'A'.

biglist = ['A','B','C','D','A','1','2','A','X','3','1','C','D','A','B','C']
lists = [list('A'+x) for x in ''.join(s).split("A") if x]

will give you a list of characters as required.

>>> lists
 [['A', 'B', 'C', 'D'], ['A', '1', '2'], ['A', 'X', '3', '1', 'C', 'D'], ['A', 'B', 'C']]

Answer 8

One option to use groupby from itertools:

# create a group variable by looping through the list
from itertools import groupby
acc, grp = 0, []
for e in biglist:
    acc += (e == 'A')
    grp.append(acc)

# split the original list by the group variable
[[i[0] for i in g] for _, g in groupby(zip(biglist, grp), lambda x: x[1])]

# [['A', 'B', 'C', 'D'],
#  ['A', '1', '2'],
#  ['A', 'X', '3', '1', 'C', 'D'],
#  ['A', 'B', 'C']]

We can also use pandas :

import pandas as pd
s = pd.Series(biglist)
[list(g) for _, g in s.groupby((s == 'A').cumsum())]

# [['A', 'B', 'C', 'D'],
#  ['A', '1', '2'],
#  ['A', 'X', '3', '1', 'C', 'D'],
#  ['A', 'B', 'C']]

Answer 9

This will create module level variables list1, .. listn.

If it possible to use list of lists or dict of lists you should prefer other answers.

This answer base on python function globals that return dict of current global namespace. It modifying this dict to create variables on fly. There is also same function for getting local variables, but there is "note" in documentation with warning that is bad idea to change this dict. However there is no such warning for globals so, i hope, the code is safe.

 biglist = ['A','B','C','D','A','1','2','A','X','3','1','C','D','A','B','C']

    last_arr_index = 1;
    tmp_list = []
    for idx, letter in enumerate( biglist ):
        if letter == 'A' and idx > 0:
            globals()[ 'list' + str(last_arr_index) ] = tmp_list
            last_arr_index+=1
            tmp_list = ['A']
        else:
            tmp_list.append( letter )

    print( list1 )
    print( list2 )
    print( list3 )