I want to multiply only every second number on a list(0-100) but I just can't get it to work.
[x*10 for x in range(100) if x%2==0] # take vale to be multiply instead of 10, use x if you want to multiply with number it self
below code will only multiply even elements and keep other as it is.
def iterate_lis(get_list):
ls = []
for x in get_list:
if x%2==0:
ls.append(x*2)
else:
ls.append(x)
print(ls)
return ls
iterate_count = 5 # list will be iterate 5 times
for i in range(iterate_count):
if i ==0:
get_lis = iterate_lis(range(100))
else:
get_lis = iterate_lis(get_lis)
result for iterate_count=5 will be as follow:
>>>
[0, 1, 4, 3, 8, 5, 12, 7, 16, 9, 20, 11, 24, 13, 28, 15, 32, 17, 36, 19, 40, 21, 44, 23, 48, 25, 52, 27, 56, 29, 60, 31, 64, 33, 68, 35, 72, 37, 76, 39, 80, 41, 84, 43, 88, 45, 92, 47, 96, 49, 100, 51, 104, 53, 108, 55, 112, 57, 116, 59, 120, 61, 124, 63, 128, 65, 132, 67, 136, 69, 140, 71, 144, 73, 148, 75, 152, 77, 156, 79, 160, 81, 164, 83, 168, 85, 172, 87, 176, 89, 180, 91, 184, 93, 188, 95, 192, 97, 196, 99]
[0, 1, 8, 3, 16, 5, 24, 7, 32, 9, 40, 11, 48, 13, 56, 15, 64, 17, 72, 19, 80, 21, 88, 23, 96, 25, 104, 27, 112, 29, 120, 31, 128, 33, 136, 35, 144, 37, 152, 39, 160, 41, 168, 43, 176, 45, 184, 47, 192, 49, 200, 51, 208, 53, 216, 55, 224, 57, 232, 59, 240, 61, 248, 63, 256, 65, 264, 67, 272, 69, 280, 71, 288, 73, 296, 75, 304, 77, 312, 79, 320, 81, 328, 83, 336, 85, 344, 87, 352, 89, 360, 91, 368, 93, 376, 95, 384, 97, 392, 99]
[0, 1, 16, 3, 32, 5, 48, 7, 64, 9, 80, 11, 96, 13, 112, 15, 128, 17, 144, 19, 160, 21, 176, 23, 192, 25, 208, 27, 224, 29, 240, 31, 256, 33, 272, 35, 288, 37, 304, 39, 320, 41, 336, 43, 352, 45, 368, 47, 384, 49, 400, 51, 416, 53, 432, 55, 448, 57, 464, 59, 480, 61, 496, 63, 512, 65, 528, 67, 544, 69, 560, 71, 576, 73, 592, 75, 608, 77, 624, 79, 640, 81, 656, 83, 672, 85, 688, 87, 704, 89, 720, 91, 736, 93, 752, 95, 768, 97, 784, 99]
[0, 1, 32, 3, 64, 5, 96, 7, 128, 9, 160, 11, 192, 13, 224, 15, 256, 17, 288, 19, 320, 21, 352, 23, 384, 25, 416, 27, 448, 29, 480, 31, 512, 33, 544, 35, 576, 37, 608, 39, 640, 41, 672, 43, 704, 45, 736, 47, 768, 49, 800, 51, 832, 53, 864, 55, 896, 57, 928, 59, 960, 61, 992, 63, 1024, 65, 1056, 67, 1088, 69, 1120, 71, 1152, 73, 1184, 75, 1216, 77, 1248, 79, 1280, 81, 1312, 83, 1344, 85, 1376, 87, 1408, 89, 1440, 91, 1472, 93, 1504, 95, 1536, 97, 1568, 99]
[0, 1, 64, 3, 128, 5, 192, 7, 256, 9, 320, 11, 384, 13, 448, 15, 512, 17, 576, 19, 640, 21, 704, 23, 768, 25, 832, 27, 896, 29, 960, 31, 1024, 33, 1088, 35, 1152, 37, 1216, 39, 1280, 41, 1344, 43, 1408, 45, 1472, 47, 1536, 49, 1600, 51, 1664, 53, 1728, 55, 1792, 57, 1856, 59, 1920, 61, 1984, 63, 2048, 65, 2112, 67, 2176, 69, 2240, 71, 2304, 73, 2368, 75, 2432, 77, 2496, 79, 2560, 81, 2624, 83, 2688, 85, 2752, 87, 2816, 89, 2880, 91, 2944, 93, 3008, 95, 3072, 97, 3136, 99]
You can`t multiply with 0 , because the result will be always 0.
result=1
for i in range (1 , 10 ):
if i%2==0:
result*=i
print(result)
import numpy as np
l = range(100)
np.product(l[0::2])
This will give you every second element of your list and multiply all.
I want to change to list so: 1,2,3,4,5,6,7,8 becomes 1,4,3,8,5,16 etc.
Though I don't understand how you multiply 6 to end up with 16, I assume this is what you need:
new_list = []
for x in range(1,100):
if x % 2 == 0: new_list.append(x*2)
else: new_list.append(x)
print(new_list)
If the number is divisible by 2, you multiply it with 2 and append it to a new list. If not, you just append it without multiplying.
Running this program, you get the following output:
[1, 4, 3, 8, 5, 12, 7, 16, 9, 20, 11, 24, 13, 28, 15, 32, 17, 36, 19, 40, 21, 44, 23, 48, 25, 52, 27, 56, 29, 60, 31, 64, 33, 68, 35, 72, 37, 76, 39, 80, 41, 84, 43, 88, 45, 92, 47, 96, 49, 100, 51, 104, 53, 108, 55, 112, 57, 116, 59, 120, 61, 124, 63, 128, 65, 132, 67, 136, 69, 140, 71, 144, 73, 148, 75, 152, 77, 156, 79, 160, 81, 164, 83, 168, 85, 172, 87, 176, 89, 180, 91, 184, 93, 188, 95, 192, 97, 196, 99]
Use range() to generate the indexes of the entries you want to change...
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
for i in range(1, len(numbers), 2):
numbers[i] *= 2
will result in numbers containing the list
[1, 4, 3, 8, 5, 12, 7, 16]
Related
I have two lists and I would like to calculate the permutations between the two. I have been able to successfully do this using itertools, but am having trouble taking it further.
I have two nested lists:
list_1 = [0, 226, 68, 100, 70, 71, 42, 43, 44, 14, 16, 114, 210, 22, 87, 28, 125][10, 216, 67, 120, 70, 717, 42, 43, 445, 14, 87, 289, 125]
list_2 = [10, 9, 2, 1, 0][10, 216, 7, 10, 70, 717, 42, 3, 445, 14, 162, 87, 289, 125]
The first entry of list_1 ([0, 226, 68, 100, 70, 71, 42, 43, 44, 14, 16, 114, 210, 22, 87, 28, 125]) needs to be permutated with the first entry of list_2 ([10, 9, 2, 1, 0]). Then I need to get the permutations of the second entry of list_1 with the second entry of list_2, etc.
The issue is that there will be no set number of entries in each list, so it is not feasible to simply make variables for list_1[0], list_2[0], etc.
What would be the simplest way to do this?
import itertools
list_1 = ([0, 226, 68, 100, 70, 71, 42, 43, 44, 14, 16, 114, 210, 22, 87, 28, 125],
[10, 216, 67, 120, 70, 717, 42, 43, 445, 14, 87, 289, 125])
list_2 = ([10, 9, 2, 1, 0],
[10, 216, 7, 10, 70, 717, 42, 3, 445, 14, 162, 87, 289, 125])
count = 0
for list1_item, list2_item in zip(list_1, list_2):
print(f"{list1_item=} {list2_item=}")
for permutation in itertools.permutations(itertools.chain(list1_item, list2_item)):
if count % 10**8 == 0: # print once in a while
print(permutation)
count += 1
print(count)
print(f"last permutation: {permutation}")
gives
list1_item=[0, 226, 68, 100, 70, 71, 42, 43, 44, 14, 16, 114, 210, 22, 87, 28, 125] list2_item=[10, 9, 2, 1, 0]
(0, 226, 68, 100, 70, 71, 42, 43, 44, 14, 16, 114, 210, 22, 87, 28, 125, 10, 9, 2, 1, 0)
(0, 226, 68, 100, 70, 71, 42, 43, 44, 14, 210, 125, 10, 9, 114, 22, 0, 87, 2, 1, 16, 28)
(0, 226, 68, 100, 70, 71, 42, 43, 44, 14, 28, 16, 210, 22, 125, 9, 1, 2, 87, 10, 114, 0)
...
list1_item=[10, 216, 67, 120, 70, 717, 42, 43, 445, 14, 87, 289, 125] list2_item=[10, 216, 7, 10, 70, 717, 42, 3, 445, 14, 162, 87, 289, 125]
(10, 216, 67, 120, 70, 717, 42, 43, 445, 14, 87, 289, 125, 10, 216, 7, 10, 70, 717, 42, 3, 445, 14, 162, 87, 289, 125)
...
Why my boxplot is not showing the expected output? I can see only circles and instead I'll want to see a traditional boxplot. How can I fix it?
import matplotlib as plt
collection_0 = [826, 58, 305, 161, 341, 25, 50, 1303, 1241, 406, 4318, 14330, 62, 45, 17, 809, 2560, 2901, 1988, 1755, 2584, 1924, 218, 13, 140, 156, 591, 109, 17, 563, 242, 23, 156, 179, 85, 59, 78, 55, 57, 27, 33, 62, 499, 685, 1418, 70, 155, 388, 205, 62, 22, 358, 688, 273, 27, 107, 85, 856, 375, 144, 476, 161, 33, 1748, 315, 106, 347, 85, 43, 157, 770, 616, 220, 13, 170, 156, 200, 165, 1211, 138, 163, 61, 78, 140, 318, 1296, 14, 386, 19, 918, 193, 381, 178, 106, 91, 109, 261, 72, 436, 194, 176, 237, 28, 201, 36, 166, 1928, 358, 611, 58, 82, 59, 37, 269, 223, 836, 45, 425, 166, 26, 63, 387, 270, 180, 331, 342, 629, 610, 46, 67, 151, 57, 188, 70, 96, 41, 92, 79, 26, 56, 188, 466, 214, 45, 39, 161, 70, 134, 370, 70, 401, 85, 113, 224, 60, 508, 58, 71, 49, 56, 400, 1308, 22, 124, 74, 63, 56, 84, 144, 26, 29, 33, 20, 241, 25, 17, 25, 45, 37, 100, 93, 175, 27, 308, 134, 28, 203, 195, 161, 168, 364, 102, 66, 53, 57, 195, 30, 55, 108, 110, 75, 42, 531, 25, 17, 156, 24, 29, 303, 77, 36, 184, 67, 15, 92, 124, 206, 51, 87, 83, 23, 134, 64, 50, 99, 451, 144, 265, 228, 96, 357, 39, 14, 91, 46, 110, 75, 18, 30, 93, 61, 31, 203, 226, 92, 162, 415, 30, 48, 86, 51, 79, 130, 181, 17, 64, 57, 168, 153, 72, 57, 34, 234, 18, 30, 72, 98, 44, 114, 58, 23, 54, 24, 126, 37, 28, 73, 8, 38, 86, 214, 46, 34, 63, 79, 72, 111, 37, 499, 382, 76, 589, 72, 139, 108, 301, 63, 158, 17, 12, 103, 337, 65, 17, 56, 32, 27, 14, 224, 33, 40, 55, 60, 76, 18, 24, 56, 99, 135, 23, 50, 102, 74, 114, 29, 24, 50, 84, 33, 316, 52, 38, 112, 61, 10, 22, 17, 71, 22, 99, 51, 84, 34, 32, 18, 91, 240, 29, 141, 121, 67, 40, 303, 78, 86, 48, 149, 102, 57, 42, 88, 137, 133, 89, 88, 70, 31, 24, 73, 7, 53, 46, 156, 17, 133, 85, 103, 70, 26, 145, 26, 112, 81, 37, 27, 98, 14, 84, 26, 31, 43, 42, 19, 38, 32, 35, 92, 168, 53, 175, 25, 30, 48, 84, 98, 57, 62, 32, 38, 75, 11, 33, 29, 38, 48, 52, 244, 303, 135, 10, 52, 12, 43, 78, 34, 50, 51, 49, 68, 68, 53, 18, 50, 64, 17, 27, 17, 21, 12, 46, 29, 35, 31, 93, 93, 25, 20, 18, 18, 43, 61, 29, 16, 40, 28, 26, 15, 30, 41, 67, 75, 53, 64, 105, 15, 35, 41, 22, 54, 20, 38, 31, 21, 105, 23, 37, 12, 29, 38, 16, 16, 21, 57, 66, 83, 44, 43, 14, 28, 48, 51, 17, 21, 16, 7, 34, 50, 23, 14, 18, 23, 32, 91, 29, 31, 23, 9, 14, 17, 15, 43, 16, 17, 20, 11, 16, 7, 13, 11, 49, 42, 13, 23, 18, 28, 38, 23, 10, 32, 9, 34, 16, 18, 9, 23, 16, 12, 65, 31, 37, 16, 9, 34, 8, 12, 22, 55, 17, 30, 13, 25, 27, 14, 7, 78, 19, 11, 41, 54, 22, 27, 8, 18, 22, 6, 29, 16, 35, 27, 8, 10, 7, 51, 9, 23, 12, 9, 6, 15, 16, 8, 7, 14, 12, 10, 14, 17, 10, 13, 18, 8, 7, 9, 10, 10]
collection_1 = [1353, 25, 2430, 1995, 1209, 1291, 564, 68, 1184, 81, 132, 140, 1463, 258, 143, 338, 63, 38, 144, 534, 130, 2742, 392, 157, 301, 193, 620, 2303, 2269, 84, 1464, 148, 593, 191, 102, 1194, 211, 11, 2498, 359, 808, 552, 96, 334, 238, 46, 1771, 536, 160, 195, 318, 193, 684, 280, 249, 19, 235, 15, 144, 2030, 104, 619, 523, 106, 902, 31, 13, 55, 9, 21, 68, 51, 45, 92, 41, 432, 436, 137, 81, 57, 210, 254, 34, 28, 301, 72, 134, 409, 30, 53, 112, 106, 267, 33, 57, 35, 18, 143, 52, 45, 36, 183, 43, 66, 40, 100, 194, 139, 18, 280, 262, 62, 331, 196, 604, 56, 43, 181, 82, 171, 57, 22, 34, 52, 46, 260, 125, 50, 46, 23, 69, 83, 28, 219, 94, 32, 82, 31, 200, 20, 78, 725, 225, 107, 58, 59, 31, 44, 18, 136, 180, 74, 20, 44, 28, 90, 69, 48, 47, 50, 74, 18, 50, 20, 75, 127, 19, 80, 23, 163, 30, 103, 27, 10, 37, 37, 44, 41, 46, 49, 48, 55, 14, 19, 42, 79, 50, 45, 36, 15, 45, 128, 122, 46, 38, 21, 21, 81, 24, 12, 15, 53, 9, 26, 43, 23, 16, 79, 9, 45, 146, 58, 17, 30, 13, 8, 17, 24, 56, 6, 12, 17, 9, 15, 11, 13, 13, 12, 14, 21, 10, 8, 15, 8, 28, 8, 11, 24, 9, 13, 30, 14, 15, 7, 9, 25, 7, 8, 10, 5, 7, 7, 6, 7, 6, 7, 8, 9]
data_to_plot = [collection_0, collection_1]
box = plt.boxplot(data_to_plot,patch_artist=True, labels=["Contracting", "Expanding"])
colors = ['red', 'green']
for patch, color in zip(box['boxes'], colors):
patch.set_facecolor(color)
plt.ylabel("Unique adopters")
plt.show()
Your data varies over 4 orders of magnitude with a majority of data lying close to less than 1000. The mean of your data is around 170 and so the whole box plot appears compressed due to the huge outlier value of above 14000. You can see this via a histogram
plt.hist(collection_0);
You should try using a log scale for your expected visualization
plt.yscale('log')
I'm interested in plotting the probability distribution of a set of points which are distributed as a power law. Further, I would like to use logarithmic binning to be able to smooth out the large fluctuations, especially those observed in the tail. I made the code:
plt.figure()
plt.grid(True)
plt.loglog(x, y, 'bo')
plt.savefig('distribution.png', dpi=400)
plt.show()
plt.close()
Where x and y are lists with the data. I know I should use numpy.logspace, but I'm not sure how to do it.
I attach the lists and image of the graph:
Graphic: 1
x=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
38, 39, 40, 41, 44, 45, 46, 48, 50, 53, 54, 55, 56, 57, 58, 59, 63, 64,
66, 71, 72, 73, 76, 79, 81, 84, 85, 86, 90, 95, 97, 99, 100, 101, 103,
105, 114, 117, 118, 120, 122, 129, 141, 159, 166, 168, 172, 199, 201,
206, 218, 226, 243, 260, 262, 263, 265, 273, 274, 278, 281, 292, 300,
390, 404, 420, 443, 491, 849, 939, 1036, 1156, 1191, 1389, 1551, 1742,
2082]
y=[0.0, 0.3508771929824561, 0.4259259259259261, 0.4400278940027895,
0.439337474120083, 0.43933333333333335, 0.4165445665445665,
0.4361247947454843, 0.4325877825877826, 0.4820728291316526,
0.42828042328042315, 0.35761299632267374, 0.3491461529923068,
0.4079423222280365, 0.43694194694194693, 0.34069215098626865,
0.3449795896319961, 0.3633688071188071, 0.30852671293847767,
0.4242381075714409, 0.20068791049183207, 0.24466260863319686,
0.12237645395540135, 0.37624875124875123, 0.28918557997841887,
0.25374977395437753, 0.4761346678013344, 0.41219336219336217,
0.19267411510058569, 0.30895915678524377, 0.18104998922645982,
0.2407892107892108, 0.23937740965604742, 0.3727204759813455,
0.23712669683257917, 0.2567023619655199, 0.33474793703626654,
0.3520767731294047, 0.2475947884643537, 0.3738888888888889,
0.5274725274725275, 0.33489003749873314, 0.18518518518518517,
0.15181358496575886, 0.3152953084067635, 0.17919413919413918,
0.20858299108299105, 0.21746880570409982, 0.1915602105707053,
0.2972972972972973, 0.18115942028985507, 0.25, 0.32707722385141735,
0.33894302848575714, 0.21774193548387097, 0.34782608695652173,
0.27608756290137165, 0.17296320127462694, 0.2727272727272727,
0.2879728132387707, 0.06535947712418301, 0.083710407239819,
0.28118393234672306, 0.1951219512195122, 0.09254361251031618,
0.3062211259885678, 0.002663622526636225, 0.27311522048364156,
0.0506558118498417, 0.1044776119402985, 0.06284153005464481,
0.18588399720475193, 0.2129032258064516, 0.14903846153846154,
0.021532091097308487, 0.3089430894308943, 0.301010101010101,
0.3761904761904762, 0.10466269841269842, 0.07138047138047138,
0.21709633649932158, 0.019401589527816735, 0.017575757575757574,
0.15817805383022773, 0.025306629405371837, 0.20850040096230954,
0.0001638001638001638, 0.04357084357084357, 0.09221213569039656,
0.14047410008779632, 0.002560163850486431, 0.0031680440771349864,
0.12334152334152335, 0.6428571428571429, 0.012745098039215686,
0.0058073399287151255, 0.0012413644214162348, 0.013532269257460098,
0.04368752313957793, 0.20265151515151514, 0.0018470281790196543,
0.023099982366425676, 0.03265807243707796, 0.00695970695970696,
0.003737745098039216, 0.009634076615208691, 0.024085079762277136,
0.0062196422224854876, 0.030849549121974372, 0.01636020744931636,
0.003922512815882666, 0.005677708965459911, 0.04833570605382686,
0.014331723027375202]
I have a nested numpy array (dtype=object), it contains 333 arrays that increase consistently from size 52x1 to size 52x333
I would like to effectively extract and concatenate these arrays so that I have a single 52x55611 array
I imagine this may be straightforward but my attempts using numpy.reshape have been unsuccesful
If you want to stack them along the second axis, you can use numpy.hstack.
list_of_arrays = [ array_1, ..., array_n] #all these arrays have same shape[0]
big_array = np.hstack( list_of_arrays)
if I have understood you correctly, you could use numpy.concatenate.
>>> import numpy as np
>>> a = np.array([range(52)])
>>> b = np.array([range(52,104), range(104, 156)])
>>> np.concatenate((a,b))
array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51],
[ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103],
[104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155]])
>>>
I have a 5 dimensional matrix.
I want to be able to extract the indices of the first value in each row of a certain (2d) slice that meets a condition, then use those indices to extract the value of the corresponding indices in another slice.
Here is my example:
In [3]: g = np.arange(48400).reshape(20,11,11,2,10)
the two slices I'm working with are:
In [4]: sliceA = g[0,:,:,0,0]
In [5]: sliceA
Out[5]:
array([[ 0, 20, 40, 60, 80, 100, 120, 140, 160, 180, 200],
[ 220, 240, 260, 280, 300, 320, 340, 360, 380, 400, 420],
[ 440, 460, 480, 500, 520, 540, 560, 580, 600, 620, 640],
[ 660, 680, 700, 720, 740, 760, 780, 800, 820, 840, 860],
[ 880, 900, 920, 940, 960, 980, 1000, 1020, 1040, 1060, 1080],
[1100, 1120, 1140, 1160, 1180, 1200, 1220, 1240, 1260, 1280, 1300],
[1320, 1340, 1360, 1380, 1400, 1420, 1440, 1460, 1480, 1500, 1520],
[1540, 1560, 1580, 1600, 1620, 1640, 1660, 1680, 1700, 1720, 1740],
[1760, 1780, 1800, 1820, 1840, 1860, 1880, 1900, 1920, 1940, 1960],
[1980, 2000, 2020, 2040, 2060, 2080, 2100, 2120, 2140, 2160, 2180],
[2200, 2220, 2240, 2260, 2280, 2300, 2320, 2340, 2360, 2380, 2400]])
and one I made separately, then added in (for illustration purposes):
In [6]: sliceB = np.array([[ 3, 12, 21, 31, 41, 51, 69, 77, 83, 91, 100],
...: [ 6, 12, 23, 33, 43, 51, 69, 77, 83, 91, 100],
...: [ 8, 12, 27, 37, 47, 51, 69, 77, 83, 91, 100],
...: [ 4, 12, 28, 38, 48, 51, 69, 77, 83, 91, 100],
...: [ 7, 12, 29, 39, 49, 51, 69, 77, 83, 91, 100],
...: [ 9, 12, 22, 32, 42, 51, 69, 77, 83, 91, 100],
...: [ 6, 12, 21, 31, 41, 51, 69, 77, 83, 91, 100],
...: [ 8, 12, 25, 35, 45, 51, 69, 77, 83, 91, 100],
...: [ 5, 12, 26, 36, 46, 51, 69, 77, 83, 91, 100],
...: [ 7, 12, 22, 32, 42, 51, 69, 77, 83, 91, 100],
...: [ 3, 12, 24, 34, 44, 51, 69, 77, 83, 91, 100]])
In [11]: g[0,:,:,0,1] = sliceB
In [12]: g[0,:,:,0,1]
Out[12]:
array([[ 3, 12, 21, 31, 41, 51, 69, 77, 83, 91, 100],
[ 6, 12, 23, 33, 43, 51, 69, 77, 83, 91, 100],
[ 8, 12, 27, 37, 47, 51, 69, 77, 83, 91, 100],
[ 4, 12, 28, 38, 48, 51, 69, 77, 83, 91, 100],
[ 7, 12, 29, 39, 49, 51, 69, 77, 83, 91, 100],
[ 9, 12, 22, 32, 42, 51, 69, 77, 83, 91, 100],
[ 6, 12, 21, 31, 41, 51, 69, 77, 83, 91, 100],
[ 8, 12, 25, 35, 45, 51, 69, 77, 83, 91, 100],
[ 5, 12, 26, 36, 46, 51, 69, 77, 83, 91, 100],
[ 7, 12, 22, 32, 42, 51, 69, 77, 83, 91, 100],
[ 3, 12, 24, 34, 44, 51, 69, 77, 83, 91, 100]])
Now, I want to create an array of indices of the first element in each row of sliceB that meets a condition (eg. >=35), ie these values:
array([[ 3, 12, 21, 31, *41*, 51, 69, 77, 83, 91, 100],
[ 6, 12, 23, 33, *43*, 51, 69, 77, 83, 91, 100],
[ 8, 12, 27, *37*, 47, 51, 69, 77, 83, 91, 100],
[ 4, 12, 28, *38*, 48, 51, 69, 77, 83, 91, 100],
[ 7, 12, 29, *39*, 49, 51, 69, 77, 83, 91, 100],
[ 9, 12, 22, 32, *42*, 51, 69, 77, 83, 91, 100],
[ 6, 12, 21, 31, *41*, 51, 69, 77, 83, 91, 100],
[ 8, 12, 25, *35*, 45, 51, 69, 77, 83, 91, 100],
[ 5, 12, 26, *36*, 46, 51, 69, 77, 83, 91, 100],
[ 7, 12, 22, 32, *42*, 51, 69, 77, 83, 91, 100],
[ 3, 12, 24, 34, *44*, 51, 69, 77, 83, 91, 100]])
then use that to create an array of values in sliceA with the corresponding indices, ie:
array([[ 0, 20, 40, 60, *80*, 100, 120, 140, 160, 180, 200],
[ 220, 240, 260, 280, *300*, 320, 340, 360, 380, 400, 420],
[ 440, 460, 480, *500*, 520, 540, 560, 580, 600, 620, 640],
[ 660, 680, 700, *720*, 740, 760, 780, 800, 820, 840, 860],
[ 880, 900, 920, *940*, 960, 980, 1000, 1020, 1040, 1060, 1080],
[1100, 1120, 1140, 1160, *1180*, 1200, 1220, 1240, 1260, 1280, 1300],
[1320, 1340, 1360, 1380, *1400*, 1420, 1440, 1460, 1480, 1500, 1520],
[1540, 1560, 1580, *1600*, 1620, 1640, 1660, 1680, 1700, 1720, 1740],
[1760, 1780, 1800, *1820*, 1840, 1860, 1880, 1900, 1920, 1940, 1960],
[1980, 2000, 2020, 2040, *2060*, 2080, 2100, 2120, 2140, 2160, 2180],
[2200, 2220, 2240, 2260, *2280*, 2300, 2320, 2340, 2360, 2380, 2400]])
I have tried for hours using the following functions:
np.amax, np.argmax, np.where, x[x>34].min()
but can't seem to find the missing link or combination.
I'd like to do this without loops in the interest of speed.
I can't test it right now, but it should be pretty simple:
idx = np.argmax(sliceB >= 35, axis=1) # index of first occurrence of condition
sliceA[np.arange(sliceA.shape[0]), idx]
Something like this should work:
#First sort sliceA
tmp = np.argsort(sliceA,axis=1)
#Mask all indices that you dont want with values larger then any in the array
tmp[ sliceB<=34 ] = tmp.shape[-1]*2
#Find the minimum positions
min_pos = tmp.argmin(axis=1)
#Finally take the slice
print sliceA[np.arange(sliceA.shape[0]),min_pos]
[ 80 300 500 720 940 1180 1400 1600 1820 2060 2280]