如何合并二进制数据集

Question

I have a set of values vertically

2,4
4,7
5,8
  9

I want to have binary combination of each two values in vertical for example 2 and 4, 2 and 5 etc . the same for the second

2 4
2 5
4 5
4 7
4 8 
 .
 .
 .

Ok it seems very complicated so I try to make it easier I convert my data into horizon

I have 2,4,5 4,7,8,9

I want to have the binary combination of the first row

2 4
2 5
4 5  

and the the binary combination of the second row

4 7
4 8
4 9
7 8
7 9
8 9

Answer 1

I think I understand. Try this code:

test.py

#!/bin/python

# put items side by side
# take first item and put the next item besides it
# if there are any more items after the next, put that item besides the first item
# if there are no more items after the next, switch to the next item in the list
# repeat
def two_items_side_by_side(mylist):
    list_len = len(mylist)
    for i in range(list_len):
        for j in range(i+1, list_len):
            print '{} {}'.format(mylist[i], mylist[j])

# -------------------------------------------------------------------

# these are two lists
list1 = [2, 4, 5]
list2 = [4, 7, 8, 9]

two_items_side_by_side(list1)
two_items_side_by_side(list2)

When you run this, your results will look like so:

Result

python test.py
2 4
2 5
4 5
4 7
4 8
4 9
7 8
7 9
8 9

If your test case is a string with each line containing comma separated text like this, you can use test2.py as an example

2,4
4,7
5,8
 ,9

test2.py

#!/bin/python

# put items side by side
# take first item and put the next item besides it
# if there are any more items after the next, put that item besides the first item
# if there are no more items after the next, switch to the next item in the list
# repeat
def two_items_side_by_side(mylist):
    list_len = len(mylist)
    for i in range(list_len):
        for j in range(i+1, list_len):
            print '{} {}'.format(mylist[i], mylist[j])

# -------------------------------------------------------------------

# process the data and store them into a list
# then do the same work as we did in the first example
def convert_data_into_lists():
    lines = data.split('\n')
    for line in lines:
        # ignore empty lines
        if len(line.strip()) < 1:
            continue

        # split by comma and ignore if we don't get 2 or more values
        items = line.split(',')
        if len(items) < 2:
            continue

        # put first item in list1 and second item in list2
        if len(items[0].strip()) > 0: list1.append(items[0].strip())
        if len(items[1].strip()) > 0: list2.append(items[1].strip())

# -------------------------------------------------------------------

# this is my string
data = """
2,4
4,7
5,8
 ,9
"""

list1 = []
list2 = []

convert_data_into_lists()
two_items_side_by_side(list1)
two_items_side_by_side(list2)

Result

python test2.py
2 4
2 5
4 5
4 7
4 8
4 9
7 8
7 9
8 9

There are more elegant ways to write this code. I have written it in a manner that will help you understand the code and try it out yourself.

Requirement change

Based on the change in requirement, data is in a text file. We will take three test cases (see in results). To accommodate the requirements, I am going to use the same code I used in test2.py . Instead of creating individual lists for each column we have in our text file, I will create one list that will dynamically contain as many lists as you have columns in your text file.

Code

#!/bin/python

# put items side by side
# take first item and put the next item besides it
# if there are any more items after the next, put that item besides the first item
# if there are no more items after the next, switch to the next item in the list
# repeat
def two_items_side_by_side(mylist):
    list_len = len(mylist)
    for i in range(list_len):
    for j in range(i+1, list_len):
        print '{} {}'.format(mylist[i], mylist[j])

# -------------------------------------------------------------------

# process the data and store them into a list
# then do the same work as we did in the first example
def convert_data_into_lists():

    with open(data) as f:
        lines = f.readlines()

    for line in lines:
        # ignore empty lines
        if len(line.strip()) < 1:
            continue

        # split by comma and ignore if we don't get 2 or more values
        items = line.split(',')

        counter = 0
        for item in items:

            if len(mylist) < counter + 1:
                mylist.append([])
            if len(item.strip()) > 0:
                mylist[counter].append(item.strip())
            counter += 1

# -------------------------------------------------------------------

# this is my string
data = 'test.txt'

mylist = []

convert_data_into_lists()
for individual_list in mylist:
    two_items_side_by_side(individual_list)

Result

Case 1

Data:
2,4
4,7
5,8
 ,9

Results:
2 4
2 5
4 5
4 7
4 8
4 9
7 8
7 9
8 9

Case 2

Data:
2,4
4,7
5,8
6,9

Results:
2 4
2 5
2 6
4 5
4 6
5 6
4 7
4 8
4 9
7 8
7 9
8 9

Case 3

Data:
2,4,10
4,7,11
5,8,
 ,9,13

Results:
2 4
2 5
2 6
4 5
4 6
5 6
4 7
4 8
4 9
7 8
7 9
8 9
10 11
10 13
11 13

Answer 2

If you have values stores in two collectables, use list comprehension

from itertools import izip_longest
a = [(1,'a'),(2,'b'),(3,None)]
b,c = izip_longest(*a)
d = [(i, j) for i in b if i  for j in c if j]

Answer 3

EDIT

By modifying the code above to only use a single parameter, we can read the contents of a csv file and (using some form of delimiter) provide combinations across the entire data set. Just call total_zipper() and replace 'filename.txt' with your file name.

def total_zipper():

    def zipper(a):
        lst = []
        for i in range(1,len(a)+1):
            lst+=zip(a,a[i:])
        return sorted(lst)

    f = open('filename.txt','r')
    return [zipper(line) for line in f]

This treats all lines as iterables (Strings). For readline() to work, I believe you need a return statement at the end of each line in the txt. See the input/output page for Python for more.

---

Here's the shortest version I could come up with. You can use the built-in zip() function. This, when combined with list slicing, results in a pythonic way to pair the values in the required order.

def zipper(a,b):
    lst = []
    for i in range(1,len(b)+1):
        lst+=zip(a,b[i:])
    return sorted(lst)

Now simply call zipper on the various rows of data.

>>> a = [2,4,5]
>>> b = [4,7,8,9]
>>> print(zipper(a,a))
[(2, 4), (2, 5), (4, 5)]
>>> print(zipper(b,b))
[(4, 7), (4, 8), (4, 9), (7, 8), (7, 9), (8, 9)]

---

As a side note, I tried to use list comprehension to make the code shorter. For example, the following code does the same thing as zipper(a) :

def zipper(a):
    return list(zip(a,a[i:]) for i in range(1,len(a)+1))

However, with zip() returning generator objects in Python 3, the results aren't as "clean" as the output from the version above. I'd have to use next() on each generator object in the list outputted by zipper in order to get the same output, but this is a tedious process. Anyone have suggestions for making the list comprehension work?