Depending on your few on my approach this is either a question about using np.unique() on awkward1 arrays or a call for a better approach:
Let a and b be two awkward1 arrays of the same outer length (number of events) but different inner lengths. For example:
a = [[1, 2], [3] , [] , [4, 5, 6]]
b = [[7] , [3, 5], [6], [8, 9]]
Let f: (x, y) -> z be a function that acts on two numbers x and y and results in the number z. For example:
f(x, y):= y - x
The idea is to compare every element in a with every element in b via f for each event and filter out the matches of a and b pairs that survive some cut applied to f. For example:
f(x, y) < 4
My approach for this is:
a = ak.from_iter(a)
b = ak.from_iter(b)
c = ak.cartesian({'x':a, 'y':b})
#c= [[{'x': 1, 'y': 7}, {'x': 2, 'y': 7}], [{'x': 3, 'y': 3}, {'x': 3, 'y': 5}], [], [{'x': 4, 'y': 8}, {'x': 4, 'y': 9}, {'x': 5, 'y': 8}, {'x': 5, 'y': 9}, {'x': 6, 'y': 8}, {'x': 6, 'y': 9}]]
i = ak.argcartesian({'x':a, 'y':b})
#i= [[{'x': 0, 'y': 0}, {'x': 1, 'y': 0}], [{'x': 0, 'y': 0}, {'x': 0, 'y': 1}], [], [{'x': 0, 'y': 0}, {'x': 0, 'y': 1}, {'x': 1, 'y': 0}, {'x': 1, 'y': 1}, {'x': 2, 'y': 0}, {'x': 2, 'y': 1}]]
diff = c['y'] - c['x']
#diff= [[6, 5], [0, 2], [], [4, 5, 3, 4, 2, 3]]
cut = diff < 4
#cut= [[False, False], [True, True], [], [False, False, True, False, True, True]]
new = c[cut]
#new= [[], [{'x': 3, 'y': 3}, {'x': 3, 'y': 5}], [], [{'x': 5, 'y': 8}, {'x': 6, 'y': 8}, {'x': 6, 'y': 9}]]
new_i = i[cut]
#new_i= [[], [{'x': 0, 'y': 0}, {'x': 0, 'y': 1}], [], [{'x': 1, 'y': 0}, {'x': 2, 'y': 0}, {'x': 2, 'y': 1}]]
It is possible that pairs with the same element from a but different elements from b survive the cut. (e.g. {'x': 3, 'y': 3} and {'x': 3, 'y': 5})
My goal is to group those pairs with the same element from a together and therefore reshape the new array into:
new = [[], [{'x': 3, 'y': [3, 5]}], [], [{'x': 5, 'y': 8}, {'x': 6, 'y': [8, 9]}]]
My only idea how to achieve this is to create a list of the indexes from a that are still present after the cut by using new_i:
i = new_i['x']
#i= [[], [0, 0], [], [1, 2, 2]]
However, I need a unique version of this list to make every index appear only once. This could be achieved with np.unique() in NumPy. But doesn't work in awkward1:
np.unique(i)
<__array_function__ internals> in unique(*args, **kwargs)
TypeError: no implementation found for 'numpy.unique' on types that implement __array_function__: [<class 'awkward1.highlevel.Array'>]
My question:
Is their a np.unique() equivalent in awkward1 and/or would you recommend a different approach to my problem?
Okay, I still don't know how to use np.unique() on my arrays, but I found a solution for my own problem:
In my previous approach I used the following code to pair up booth arrays.
c = ak.cartesian({'x':a, 'y':b})
#c= [[{'x': 1, 'y': 7}, {'x': 2, 'y': 7}], [{'x': 3, 'y': 3}, {'x': 3, 'y': 5}], [], [{'x': 4, 'y': 8}, {'x': 4, 'y': 9}, {'x': 5, 'y': 8}, {'x': 5, 'y': 9}, {'x': 6, 'y': 8}, {'x': 6, 'y': 9}]]
However, with the nested = True parameter from ak.cartesian() I get a list grouped by the elements of a:
c = ak.cartesian({'x':a, 'y':b}, axis = 1, nested = True)
#c= [[[{'x': 1, 'y': 7}], [{'x': 2, 'y': 7}]], [[{'x': 3, 'y': 3}, {'x': 3, 'y': 5}]], [], [[{'x': 4, 'y': 8}, {'x': 4, 'y': 9}], [{'x': 5, 'y': 8}, {'x': 5, 'y': 9}], [{'x': 6, 'y': 8}, {'x': 6, 'y': 9}]]]
After the cut I end up with:
new = c[cut]
#new= [[[], []], [[{'x': 3, 'y': 3}, {'x': 3, 'y': 5}]], [], [[], [{'x': 5, 'y': 8}], [{'x': 6, 'y': 8}, {'x': 6, 'y': 9}]]]
I extract the y values and reduce the most inner layer of the nested lists of new to only one element:
y = new['y']
#y= [[[], []], [[3, 5]], [], [[], [8], [8, 9]]]
new = ak.firsts(new, axis = 2)
#new= [[None, None], [{'x': 3, 'y': 3}], [], [None, {'x': 5, 'y': 8}, {'x': 6, 'y': 8}]]
(I tried to use ak.firsts() with axis = -1 but it seems to be not implemented yet.)
Now every most inner entry in new belongs to exactly one element from a. By replacing the current y of new with the previously extracted y I end up with my desired result:
new['y'] = y
#new= [[None, None], [{'x': 3, 'y': [3, 5]}], [], [None, {'x': 5, 'y': [8]}, {'x': 6, 'y': [8, 9]}]]
Anyway, should you know a better solution, I'd be pleased to hear it.
Related
I need to fill an array with elements which are dictionaries. For example:
a = np.empty(2,2)
and I need to fill it in this way (which is not allowed)
for i in range(2):
for j in range(2):
a[i,j] = {'x': b[i], 'y': c[j]}
where band c are other lists/arrays or columns of a dataframe.
import numpy as np
a = np.zeros((2, 2))
b = np.ones(a.shape[0])
c = np.ones(a.shape[1]) * [2]
list_a = a.tolist()
for i in range(2):
for j in range(2):
list_a[i][j] = {'x': b[i], 'y': c[j]}
a = np.array(list_a)
print(a)
Output:
array([[{'x': 1.0, 'y': 2.0}, {'x': 1.0, 'y': 2.0}],
[{'x': 1.0, 'y': 2.0}, {'x': 1.0, 'y': 2.0}]], dtype=object)
If you create an object dtype array, you can put anything in the slots:
In [9]: a = np.empty((2,2), object)
In [10]: a
Out[10]:
array([[None, None], # empty() fills with None
[None, None]], dtype=object)
In [11]: for i in range(2):
...: for j in range(2):
...: a[i,j] = {'x':b[i], 'y':c[j]}
...:
In [12]: a
Out[12]:
array([[{'x': 1, 'y': 4}, {'x': 1, 'y': 3}],
[{'x': 3, 'y': 4}, {'x': 3, 'y': 3}]], dtype=object)
But a list comprehension works just as well
In [13]: [[{'x':b[i],'y':c[j]} for j in range(2)] for i in range(2)]
Out[13]: [[{'x': 1, 'y': 4}, {'x': 1, 'y': 3}], [{'x': 3, 'y': 4}, {'x': 3, 'y': 3}]]
In [14]: np.array(_)
Out[14]:
array([[{'x': 1, 'y': 4}, {'x': 1, 'y': 3}],
[{'x': 3, 'y': 4}, {'x': 3, 'y': 3}]], dtype=object)
Or you could start with a flat list, and reshape the array:
In [15]: [{'x':b[i],'y':c[j]} for j in range(2) for i in range(2)]
Out[15]: [{'x': 1, 'y': 4}, {'x': 3, 'y': 4}, {'x': 1, 'y': 3}, {'x': 3, 'y': 3}]
In [16]: np.array(_)
Out[16]:
array([{'x': 1, 'y': 4}, {'x': 3, 'y': 4}, {'x': 1, 'y': 3},
{'x': 3, 'y': 3}], dtype=object)
In [18]: _.reshape(2,2)
Out[18]:
array([[{'x': 1, 'y': 4}, {'x': 3, 'y': 4}],
[{'x': 1, 'y': 3}, {'x': 3, 'y': 3}]], dtype=object)
This array of dictionaries won't be any easier or faster to use than the list(s).
Alternatively we could create a structured array with 2 named fields. Start with a list of tuples:
In [19]: [(b[i],c[j]) for j in range(2) for i in range(2)]
Out[19]: [(1, 4), (3, 4), (1, 3), (3, 3)]
In [20]: np.array(_, dtype=[('x',int),('y',int)])
Out[20]: array([(1, 4), (3, 4), (1, 3), (3, 3)], dtype=[('x', '<i8'), ('y', '<i8')])
In [21]: _.reshape(2,2)
Out[21]:
array([[(1, 4), (3, 4)],
[(1, 3), (3, 3)]], dtype=[('x', '<i8'), ('y', '<i8')])
In [22]: _['x']
Out[22]:
array([[1, 3],
[1, 3]])
In contrast to get all the x values from the 2d object array:
In [24]: [i['x'] for i in a.flat]
Out[24]: [1, 1, 3, 3]
Using python I have to get all the permutations of given subset using python.
I used itertools.permutation but result is a bit different.
Think of a machine and it has a maximum capacity, and we have products can be produced together, and we have to fill the capacity of machine.
Output format is not important, I used a dictionary to describe it. I will make a calculation after getting this combinations.
For example :
products = {'x','y','z','a'}
machine_capcacity = 8
#required output as follows:
{'x':5,'y':1,'z':1,'a':1}
{'x':4,'y':2,'z':1,'a':1}
{'x':4,'y':1,'z':2,'a':1}
{'x':4,'y':1,'z':1,'a':2}
{'x':3,'y':3,'z':1,'a':1}
{'x':3,'y':1,'z':3,'a':1}
{'x':3,'y':1,'z':1,'a':3}
{'x':3,'y':2,'z':2,'a':1}
{'x':3,'y':2,'z':1,'a':2}
{'x':3,'y':1,'z':2,'a':2}
{'x':2,'y':4,'z':1,'a':1}
# ...
{'x':6,'y':1,'z':1} # This can't be in results,since need at least 1 element of product
{'x':4,'y':1,'z':1,'a':1} # This can't be in results,since we need to fill the capacity
And we dont want repeating elements:
{'x':5,'y':1,'z':1,'a':1}
and
{'a':1,'y':1,'z':1,'x':5}
is same thing for us.
Here is a solution not relying on itertools since it's getting contrived with all the constraints (a product yielding unique results and a minimum of 1 appearance per product):
products = {'x','y','z','a'}
machine_capacity=8
def genCap(capacity = machine_capacity,used = 0):
if used == len(products)-1: yield capacity,None
else:
for i in range(1,2+capacity-len(products)+used):
yield i,genCap(capacity-i,used+1)
def printCaps(caps,current = []):
if caps is None:
print(dict(zip(products,current)))
return
for i in caps:
printCaps(i[1],current+[i[0]])
printCaps(genCap())
might be optimize-able with tail recursion and the like. Looks almost like groupby, but I can't see an easy way to use that.
For posterity I leave my old solution - product repeats counts, so filtering it becomes a problem of it's own:
You confused product with permutation. Here is a quick solution using itertools product, and the Counter collection to create the output you want:
from collections import Counter
from itertools import product
products = {'x','y','z','a'}
machine_capacity=8
for x in filter(lambda x: len(x) == len(products),
map(Counter,product(products,repeat=machine_capacity))):
print(dict(x))
Note both product and map are lazy, so they won't be evaluated until you need them. Counter provides the output you want, and converting to dict cleans it up. Note no order is guaranteed anywhere. The filter is used to make sure all your products appear at least once (length of counter equals that of products) - and it is also lazy, so only evaluated when you need it.
You can use a recursive function to find all possible combinations of the values in range(machine_capacity) that both sum to 8 and are unique. Then, the elements in products can be mapped to each element in the sublists of the combinations found:
products = ['x','y','z','a']
machine_capacity = 8
def combinations(d, current = []):
if len(current) == len(products):
yield current
else:
for i in range(machine_capacity):
if sum(current+[i]) <= machine_capacity:
yield from combinations(d, current+[i])
data = [dict(zip(products, i)) for i in filter(lambda x:sum(x) == 8 and len(x) == len(set(x)), combinations(machine_capacity))]
Output:
[{'a': 5, 'x': 0, 'z': 2, 'y': 1}, {'a': 4, 'x': 0, 'z': 3, 'y': 1}, {'a': 3, 'x': 0, 'z': 4, 'y': 1}, {'a': 2, 'x': 0, 'z': 5, 'y': 1}, {'a': 5, 'x': 0, 'z': 1, 'y': 2}, {'a': 1, 'x': 0, 'z': 5, 'y': 2}, {'a': 4, 'x': 0, 'z': 1, 'y': 3}, {'a': 1, 'x': 0, 'z': 4, 'y': 3}, {'a': 3, 'x': 0, 'z': 1, 'y': 4}, {'a': 1, 'x': 0, 'z': 3, 'y': 4}, {'a': 2, 'x': 0, 'z': 1, 'y': 5}, {'a': 1, 'x': 0, 'z': 2, 'y': 5}, {'a': 5, 'x': 1, 'z': 2, 'y': 0}, {'a': 4, 'x': 1, 'z': 3, 'y': 0}, {'a': 3, 'x': 1, 'z': 4, 'y': 0}, {'a': 2, 'x': 1, 'z': 5, 'y': 0}, {'a': 5, 'x': 1, 'z': 0, 'y': 2}, {'a': 0, 'x': 1, 'z': 5, 'y': 2}, {'a': 4, 'x': 1, 'z': 0, 'y': 3}, {'a': 0, 'x': 1, 'z': 4, 'y': 3}, {'a': 3, 'x': 1, 'z': 0, 'y': 4}, {'a': 0, 'x': 1, 'z': 3, 'y': 4}, {'a': 2, 'x': 1, 'z': 0, 'y': 5}, {'a': 0, 'x': 1, 'z': 2, 'y': 5}, {'a': 5, 'x': 2, 'z': 1, 'y': 0}, {'a': 1, 'x': 2, 'z': 5, 'y': 0}, {'a': 5, 'x': 2, 'z': 0, 'y': 1}, {'a': 0, 'x': 2, 'z': 5, 'y': 1}, {'a': 1, 'x': 2, 'z': 0, 'y': 5}, {'a': 0, 'x': 2, 'z': 1, 'y': 5}, {'a': 4, 'x': 3, 'z': 1, 'y': 0}, {'a': 1, 'x': 3, 'z': 4, 'y': 0}, {'a': 4, 'x': 3, 'z': 0, 'y': 1}, {'a': 0, 'x': 3, 'z': 4, 'y': 1}, {'a': 1, 'x': 3, 'z': 0, 'y': 4}, {'a': 0, 'x': 3, 'z': 1, 'y': 4}, {'a': 3, 'x': 4, 'z': 1, 'y': 0}, {'a': 1, 'x': 4, 'z': 3, 'y': 0}, {'a': 3, 'x': 4, 'z': 0, 'y': 1}, {'a': 0, 'x': 4, 'z': 3, 'y': 1}, {'a': 1, 'x': 4, 'z': 0, 'y': 3}, {'a': 0, 'x': 4, 'z': 1, 'y': 3}, {'a': 2, 'x': 5, 'z': 1, 'y': 0}, {'a': 1, 'x': 5, 'z': 2, 'y': 0}, {'a': 2, 'x': 5, 'z': 0, 'y': 1}, {'a': 0, 'x': 5, 'z': 2, 'y': 1}, {'a': 1, 'x': 5, 'z': 0, 'y': 2}, {'a': 0, 'x': 5, 'z': 1, 'y': 2}]
I have a list of dictionary items
[{'x': 0, 'y': 0}, {'x': 1, 'y': 0}, {'x': 2, 'y': 2}]
I want to have an array of "array of dictionaries" with all the maximum permutation order of the list for example for the above array it would be (3 factorial ways)
[[{'x': 0, 'y': 0}, {'x': 1, 'y': 0}, {'x': 2, 'y': 2}],
[{'x': 0, 'y': 0}, {'x': 2, 'y': 2}, {'x': 1, 'y': 0}],
[{'x': 1, 'y': 0}, {'x': 0, 'y': 0}, {'x': 2, 'y': 2}],
[{'x': 1, 'y': 0}, {'x': 2, 'y': 2}, {'x': 0, 'y': 0}],
[{'x': 2, 'y': 2}, {'x': 1, 'y': 0}, {'x': 0, 'y': 0}],
[{'x': 2, 'y': 2}, {'x': 0, 'y': 0}, {'x': 1, 'y': 0}]]
itertools can do permutations
#!python2
import itertools
yourlist = [{'x': 0, 'y': 0}, {'x': 1, 'y': 0}, {'x': 2, 'y': 2}]
for seq in itertools.permutations(yourlist):
print seq
'''
({'y': 0, 'x': 0}, {'y': 0, 'x': 1}, {'y': 2, 'x': 2})
({'y': 0, 'x': 0}, {'y': 2, 'x': 2}, {'y': 0, 'x': 1})
({'y': 0, 'x': 1}, {'y': 0, 'x': 0}, {'y': 2, 'x': 2})
({'y': 0, 'x': 1}, {'y': 2, 'x': 2}, {'y': 0, 'x': 0})
({'y': 2, 'x': 2}, {'y': 0, 'x': 0}, {'y': 0, 'x': 1})
({'y': 2, 'x': 2}, {'y': 0, 'x': 1}, {'y': 0, 'x': 0})
'''
Despite the comments, if you are still messed with how to solve your issue, consider the following.
Strategy: Make use of permutations from itertoolswhich returns a list of tuples in this case. Then, iterating through to convert list of tuples to list of lists to match with your required output.
Here is how you could do:
>>> import itertools
>>> lst = [{'x': 0, 'y': 0}, {'x': 1, 'y': 0}, {'x': 2, 'y': 2}]
>>> [list(elem) for elem in list(itertools.permutations(lst))]
[[{'x': 0, 'y': 0}, {'x': 1, 'y': 0}, {'x': 2, 'y': 2}],
[{'x': 0, 'y': 0}, {'x': 2, 'y': 2}, {'x': 1, 'y': 0}],
[{'x': 1, 'y': 0}, {'x': 0, 'y': 0}, {'x': 2, 'y': 2}],
[{'x': 1, 'y': 0}, {'x': 2, 'y': 2}, {'x': 0, 'y': 0}],
[{'x': 2, 'y': 2}, {'x': 0, 'y': 0}, {'x': 1, 'y': 0}],
[{'x': 2, 'y': 2}, {'x': 1, 'y': 0}, {'x': 0, 'y': 0}]]
Given a string such as "xyz", I would like to generate all dictionaries of the form:
{"x": vx, "y": vy, "z": vz}
where vx, vy, vz are integers between 1 and 5.
So in the above case, there are 125 such dictionaries. But the string can have variable length.
What is a Pythonic way to do this?
I'm positive this is a duplicate but I can't find a good one right now, so I'll answer and make it community wiki. Using itertools.product:
>>> from itertools import product
>>> s = "xyz"
>>> [dict(zip(s,v)) for v in product(range(1,6),repeat=len(s))]
[{'y': 1, 'x': 1, 'z': 1}, {'y': 1, 'x': 1, 'z': 2}, {'y': 1, 'x': 1, 'z': 3}, {'y': 1, 'x': 1, 'z': 4}, {'y': 1, 'x': 1, 'z': 5}, {'y': 2, 'x': 1, 'z': 1}, {'y': 2, 'x': 1, 'z': 2}, {'y': 2, 'x': 1, 'z': 3}, {'y': 2, 'x': 1, 'z': 4}, {'y': 2, 'x': 1, 'z': 5}, {'y': 3, 'x': 1, 'z': 1}, {'y': 3, 'x': 1, 'z': 2}, {'y': 3, 'x': 1, 'z': 3}, {'y': 3, 'x': 1, 'z': 4}, {'y': 3, 'x': 1, 'z': 5}, {'y': 4, 'x': 1, 'z': 1}, {'y': 4, 'x': 1, 'z': 2}, {'y': 4, 'x': 1, 'z': 3}, {'y': 4, 'x': 1, 'z': 4}, {'y': 4, 'x': 1, 'z': 5}, {'y': 5, 'x': 1, 'z': 1}, {'y': 5, 'x': 1, 'z': 2}, {'y': 5, 'x': 1, 'z': 3}, {'y': 5, 'x': 1, 'z': 4}, {'y': 5, 'x': 1, 'z': 5}, {'y': 1, 'x': 2, 'z': 1}, {'y': 1, 'x': 2, 'z': 2}, {'y': 1, 'x': 2, 'z': 3}, {'y': 1, 'x': 2, 'z': 4}, {'y': 1, 'x': 2, 'z': 5}, {'y': 2, 'x': 2, 'z': 1}, {'y': 2, 'x': 2, 'z': 2}, {'y': 2, 'x': 2, 'z': 3}, {'y': 2, 'x': 2, 'z': 4}, {'y': 2, 'x': 2, 'z': 5}, {'y': 3, 'x': 2, 'z': 1}, {'y': 3, 'x': 2, 'z': 2}, {'y': 3, 'x': 2, 'z': 3}, {'y': 3, 'x': 2, 'z': 4}, {'y': 3, 'x': 2, 'z': 5}, {'y': 4, 'x': 2, 'z': 1}, {'y': 4, 'x': 2, 'z': 2}, {'y': 4, 'x': 2, 'z': 3}, {'y': 4, 'x': 2, 'z': 4}, {'y': 4, 'x': 2, 'z': 5}, {'y': 5, 'x': 2, 'z': 1}, {'y': 5, 'x': 2, 'z': 2}, {'y': 5, 'x': 2, 'z': 3}, {'y': 5, 'x': 2, 'z': 4}, {'y': 5, 'x': 2, 'z': 5}, {'y': 1, 'x': 3, 'z': 1}, {'y': 1, 'x': 3, 'z': 2}, {'y': 1, 'x': 3, 'z': 3}, {'y': 1, 'x': 3, 'z': 4}, {'y': 1, 'x': 3, 'z': 5}, {'y': 2, 'x': 3, 'z': 1}, {'y': 2, 'x': 3, 'z': 2}, {'y': 2, 'x': 3, 'z': 3}, {'y': 2, 'x': 3, 'z': 4}, {'y': 2, 'x': 3, 'z': 5}, {'y': 3, 'x': 3, 'z': 1}, {'y': 3, 'x': 3, 'z': 2}, {'y': 3, 'x': 3, 'z': 3}, {'y': 3, 'x': 3, 'z': 4}, {'y': 3, 'x': 3, 'z': 5}, {'y': 4, 'x': 3, 'z': 1}, {'y': 4, 'x': 3, 'z': 2}, {'y': 4, 'x': 3, 'z': 3}, {'y': 4, 'x': 3, 'z': 4}, {'y': 4, 'x': 3, 'z': 5}, {'y': 5, 'x': 3, 'z': 1}, {'y': 5, 'x': 3, 'z': 2}, {'y': 5, 'x': 3, 'z': 3}, {'y': 5, 'x': 3, 'z': 4}, {'y': 5, 'x': 3, 'z': 5}, {'y': 1, 'x': 4, 'z': 1}, {'y': 1, 'x': 4, 'z': 2}, {'y': 1, 'x': 4, 'z': 3}, {'y': 1, 'x': 4, 'z': 4}, {'y': 1, 'x': 4, 'z': 5}, {'y': 2, 'x': 4, 'z': 1}, {'y': 2, 'x': 4, 'z': 2}, {'y': 2, 'x': 4, 'z': 3}, {'y': 2, 'x': 4, 'z': 4}, {'y': 2, 'x': 4, 'z': 5}, {'y': 3, 'x': 4, 'z': 1}, {'y': 3, 'x': 4, 'z': 2}, {'y': 3, 'x': 4, 'z': 3}, {'y': 3, 'x': 4, 'z': 4}, {'y': 3, 'x': 4, 'z': 5}, {'y': 4, 'x': 4, 'z': 1}, {'y': 4, 'x': 4, 'z': 2}, {'y': 4, 'x': 4, 'z': 3}, {'y': 4, 'x': 4, 'z': 4}, {'y': 4, 'x': 4, 'z': 5}, {'y': 5, 'x': 4, 'z': 1}, {'y': 5, 'x': 4, 'z': 2}, {'y': 5, 'x': 4, 'z': 3}, {'y': 5, 'x': 4, 'z': 4}, {'y': 5, 'x': 4, 'z': 5}, {'y': 1, 'x': 5, 'z': 1}, {'y': 1, 'x': 5, 'z': 2}, {'y': 1, 'x': 5, 'z': 3}, {'y': 1, 'x': 5, 'z': 4}, {'y': 1, 'x': 5, 'z': 5}, {'y': 2, 'x': 5, 'z': 1}, {'y': 2, 'x': 5, 'z': 2}, {'y': 2, 'x': 5, 'z': 3}, {'y': 2, 'x': 5, 'z': 4}, {'y': 2, 'x': 5, 'z': 5}, {'y': 3, 'x': 5, 'z': 1}, {'y': 3, 'x': 5, 'z': 2}, {'y': 3, 'x': 5, 'z': 3}, {'y': 3, 'x': 5, 'z': 4}, {'y': 3, 'x': 5, 'z': 5}, {'y': 4, 'x': 5, 'z': 1}, {'y': 4, 'x': 5, 'z': 2}, {'y': 4, 'x': 5, 'z': 3}, {'y': 4, 'x': 5, 'z': 4}, {'y': 4, 'x': 5, 'z': 5}, {'y': 5, 'x': 5, 'z': 1}, {'y': 5, 'x': 5, 'z': 2}, {'y': 5, 'x': 5, 'z': 3}, {'y': 5, 'x': 5, 'z': 4}, {'y': 5, 'x': 5, 'z': 5}]
>>> len(_)
125
Note that we haven't hardcoded the length of the string.
In a list of list of dicts:
A = [
[{'x': 1, 'y': 0}, {'x': 2, 'y': 3}, {'x': 3, 'y': 4}, {'x': 4, 'y': 7}],
[{'x': 1, 'y': 0}, {'x': 2, 'y': 2}, {'x': 3, 'y': 13}, {'x': 4, 'y': 0}],
[{'x': 1, 'y': 20}, {'x': 2, 'y': 4}, {'x': 3, 'y': 0}, {'x': 4, 'y': 8}]
]
I need to retrieve the highest 'y' values from each of the list of dicts...so the resulting list would contain:
Z = [(4, 7), (3,13), (1,20)]
In A, the 'x' is the key of each dict while 'y' is the value of each dict.
Any ideas? Thank you.
max accept optional key parameter.
A = [
[{'x': 1, 'y': 0}, {'x': 2, 'y': 3}, {'x': 3, 'y': 4}, {'x': 4, 'y': 7}],
[{'x': 1, 'y': 0}, {'x': 2, 'y': 2}, {'x': 3, 'y': 13}, {'x': 4, 'y': 0}],
[{'x': 1, 'y': 20}, {'x': 2, 'y': 4}, {'x': 3, 'y': 0}, {'x': 4, 'y': 8}]
]
Z = []
for a in A:
d = max(a, key=lambda d: d['y'])
Z.append((d['x'], d['y']))
print Z
UPDATE
suggested by – J.F. Sebastian:
from operator import itemgetter
Z = [itemgetter(*'xy')(max(lst, key=itemgetter('y'))) for lst in A]
I'd use itemgetter and max's key argument:
from operator import itemgetter
pair_getter = itemgetter('x', 'y')
[pair_getter(max(d, key=itemgetter('y'))) for d in A]
[max(((d['x'], d['y']) for d in l), key=lambda t: t[1]) for l in A]
The solution to your stated problem has been given, but I suggest changing your underlying data structure. Tuples are much faster for small elements such as a point. You may retain the clarity of a dictionary by using namedtuple if you so desire.
>>> from collections import namedtuple
>>> A = [
[{'x': 1, 'y': 0}, {'x': 2, 'y': 3}, {'x': 3, 'y': 4}, {'x': 4, 'y': 7}],
[{'x': 1, 'y': 0}, {'x': 2, 'y': 2}, {'x': 3, 'y': 13}, {'x': 4, 'y': 0}],
[{'x': 1, 'y': 20}, {'x': 2, 'y': 4}, {'x': 3, 'y': 0}, {'x': 4, 'y': 8}]
]
Making a Point namedtuple is simple
>>> Point = namedtuple('Point', 'x y')
This is what an instance looks like
>>> Point(x=1, y=0) # Point(1, 0) also works
Point(x=1, y=0)
A would then look like this
>>> A = [[Point(**y) for y in x] for x in A]
>>> A
[[Point(x=1, y=0), Point(x=2, y=3), Point(x=3, y=4), Point(x=4, y=7)],
[Point(x=1, y=0), Point(x=2, y=2), Point(x=3, y=13), Point(x=4, y=0)],
[Point(x=1, y=20), Point(x=2, y=4), Point(x=3, y=0), Point(x=4, y=8)]]
Now working like this is much easier:
>>> from operator import attrgetter
>>> [max(row, key=attrgetter('y')) for row in A]
[Point(x=4, y=7), Point(x=3, y=13), Point(x=1, y=20)]
To retain the speed advantages of tuples it's better to access by index:
>>> from operator import itemgetter
>>> [max(row, key=itemgetter(2)) for row in A]
[Point(x=4, y=7), Point(x=3, y=13), Point(x=1, y=20)]
result=[]
for item in a:
new = sorted(item, key=lambda k: k['y'],reverse=True)
result.append((new[0]['x'],new[0]['y']))
print(result)
Note-The is not the efficient way to do this but this is one of the ways to get the required result.