Ask the delta to say 100 and removed each point for which there is another point with a lower value within +-delta.

You're out of the area for the Arctic. [-pi/2, pi/2]:In [83]: arr = np.arange(0.7, 2.2, 0.3) In [84]: arr Out[84]: array([ 0.7, 1. , 1.3, 1.6, 1.9, 2.2]) In [85]: x = 1.9 In [86]: math.acos(x * 0.48 * x) ValueError Traceback (most recent call last) <ipython-input-86-116284452697> in <module>() ----> 1 math.acos(x * 0.48 * x) ValueError: math domain error Verification:In [90]: x * 0.48 * x Out[90]: 1.7327999999999997 In [91]: x * 0.48 * x <= math.pi/2 Out[91]: False In fact, since you're already using NumPy, I'd advise you to use ventilated functions instead of cycles:In [99]: def func_vect(x): ...: if not isinstance(x, (np.ndarray, np.generic)): ...: a = np.array(x) ...: else: ...: a = x ...: return (0.48 ** 3 + np.sin(1.2 * a) / (np.arccos(a * 0.48 * a) + np.exp(-a / 2))) ...: In [100]: func_vect(arr) C:\Anaconda3\Scripts\ipython-script.py:6: RuntimeWarning: invalid value encountered in arccos Out[100]: array([ 0.47596058, 0.66647826, 0.98265387, nan, nan, nan]) In [101]: func_vect(zad2) Out[101]: array([ 0.23254206, 0.28922696, 0.39676013, 0.62461928, 0.94825303]) nan - symbol Not a NumberComparison of productivity for a set of 1,000 elements:In [107]: arr = np.random.rand(10**3) In [108]: l = arr.tolist() In [109]: len(arr) Out[109]: 1000 In [110]: len(l) Out[110]: 1000 In [111]: %%timeit ...: for n in l: ...: func(n) ...: 1000 loops, best of 3: 933 µs per loop In [112]: %timeit func_vect(arr) 10000 loops, best of 3: 54 µs per loop and now for a mass of 1,000.000 elements:In [113]: arr = np.random.rand(10**6) In [114]: l = arr.tolist() In [115]: len(arr) Out[115]: 1000000 In [116]: len(l) Out[116]: 1000000 In [117]: %%timeit ...: for n in l: ...: func(n) ...: 1 loop, best of 3: 949 ms per loop In [118]: %timeit func_vect(arr) 10 loops, best of 3: 59.4 ms per loop

To get speeds comparable to numpy.cumsum() for large masses, http://cython.readthedocs.io/en/latest/src/quickstart/overview.html :cpdef void clipped_cumsum(int[:] a) nogil: cdef Py_ssize_t i, n = a.shape[0] for i in range(n-1): a[i+1] += a[i] if a[i+1] > 0: a[i+1] = 0 For example, this code can be retained. clipped_cumsum.pyx file and file pip install cythonto try:#!/usr/bin/env python import numpy as np import pyximport # $ pip install cython pyximport.install() # compile on-the-fly from clipped_cumsum import clipped_cumsum a = np.array([0, 1, -2, -3, 4, 5, -6], dtype=np.intc) clipped_cumsum(a) print(a) # -> [ 0 0 -2 -5 -1 0 -6] pyximport module cython The package allows the overflight to clipped_cumsum.pyx file, which makes the expansion module accessible clipped_cumsum♪For tiny volumes as in your example, such changes in the code are unlikely to be useful.For a.repeat(1000_000) mass, Cython version with a clear typeint[:]*100 times faster than the version that works with Pitton int In my car. It can be further accelerated if the checks are switched off in indexing (boundscheck=False♪ wraparound=Falsebut the likely increase already exists is sufficient and the checks may be left for future code modifications.

If you have one. numpy mass a:a = numpy.array([-1,0,0,0,0,1,1,1,1,-1,-1,1,-1]) It's enough to find a cumulative amount. https://docs.scipy.org/doc/numpy/reference/generated/numpy.cumsum.html :>>> a.cumsum() array([-1, -1, -1, -1, -1, 0, 1, 2, 3, 2, 1, 2, 1]) Simple comparison shows the difference - 70 times compared to the code on my car.ipython In [0]: import numpy In [1]: a = numpy.repeat(1, 1000000) In [2]: %timeit a.copy() 1000 loops, best of 3: 937 µs per loop In [3]: %timeit a.cumsum() 100 loops, best of 3: 2.39 ms per loop In [4]: %timeit a.copy().cumsum() 100 loops, best of 3: 6.31 ms per loop In [5]: def cumsum_mihail(a): # код из вопроса for i in range(a.shape[0] - 1): a[i + 1] = a[i + 1] + a[i] In [6]: %timeit cumsum_mihail(a.copy()) 1 loop, best of 3: 477 ms per loop

Got it, the problem is I called the second file a time.

Useable https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.nbytes.html :In [5]: a = np.random.rand(10**6) In [6]: a.nbytes Out[6]: 8000000 In [7]: a.dtype Out[7]: dtype('float64') It also works for multi-dimensional matrices:In [11]: a = np.random.randint(0, 10, (103, 103, 10**3), dtype=np.int8) In [12]: a.shape Out[12]: (1000, 1000, 1000) In [13]: a.nbytes Out[13]: 1000000000 In [14]: a.dtype Out[14]: dtype('int8') A standard function can also be used: https://docs.python.org/3/library/sys.html#sys.getsizeof In [33]: a = np.random.rand(10**6) In [34]: sys.getsizeof(a) Out[34]: 8000096 That's what's going on. sizeof for the object:In [35]: a.sizeof() Out[35]: 8000096 From documentation:getsizeof() calls the object’s __ sizeof __ method and adds an additional garbage collector overhead if the object is managed by the garbage collector.

This may be done as follows:In [122]: A Out[122]: 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]]]) In [123]: pd.DataFrame(A.reshape(-1,).reshape(A.shape[2], A.shape[0] * A.shape[1]).T) Out[123]: 0 1 2 0 0 9 18 1 1 10 19 2 2 11 20 3 3 12 21 4 4 13 22 5 5 14 23 6 6 15 24 7 7 16 25 8 8 17 26 Horse:In [118]: A.reshape(-1,) Out[118]: 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]) In [119]: A.reshape(-1,).reshape(A.shape[2], A.shape[0] * A.shape[1]) Out[119]: 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]]) In [120]: A.reshape(-1,).reshape(A.shape[2], A.shape[0] * A.shape[1]).T Out[120]: array([[ 0, 9, 18], [ 1, 10, 19], [ 2, 11, 20], [ 3, 12, 21], [ 4, 13, 22], [ 5, 14, 23], [ 6, 15, 24], [ 7, 16, 25], [ 8, 17, 26]])

Looks like you have a column. syear or indeed negative numbers or, most likely, large positive (more than 32767) which, when type of data np.int16 They turn into negative. ♪ ♪Demo:max() and min() for type np.int16:In [67]: np.iinfo(np.int16) Out[67]: iinfo(min=-32768, max=32767, dtype=int16) as a large positive whole (32880) is negative (32656) when using the type np.int16:In [72]: df = pd.DataFrame({'a':[32880]}, dtype=np.int16) In [73]: df Out[73]: a 0 -32656 Incorrect.In [88]: df1.query('syear <= 1980 or syear > 2016').syear Out[88]: 248737 -9076 248738 -26593 248739 1725 248740 -25171 248741 7963 248742 27137 248743 19854 248744 26738 248745 6716 248746 9885 248747 19361 248748 -19726 248749 -24605 248750 24074 248751 -8070 248752 -16027 248753 -23424 248754 3848 248755 1471 248756 30634 248757 -8162 248758 -18937 248759 16733 248760 -21923 248761 16817 248762 3834 248763 -13556 248764 -16229 248765 24272 248766 25642 ... 252510 -1 252511 -1 252512 -1 252513 -1 252514 -1 252515 -1 252516 -1 252517 -1 Name: syear, dtype: int16 Interesting surveillance - all bad data go on a continuous block (with indices: 248737 - 252517)

The use of fluxes accelerates the code for calculations, as there is a python https://ru.wikipedia.org/wiki/Global_Interpreter_Lock ♪ Use the code to speed up. Process from module multiprocessing or ProcessPoolExecutor from module concurrent♪

If I understood the condition correctly, I'd write it down:array = numpy.array([]) if condition1: array = numpy.concatenate((array, newarray1)) ... if conditionN: array = numpy.concatenate((array, newarrayN))

The deposit of the mass into numpy is carried out as follows:import numpy as np a = np.array([[0, 1, 2], [4, 5, 6]]) a = a.transpose() print(a) Result:[[0 4] [1 5] [2 6]]

We need help. numpy? Or would another library be okay?For example, scipy♪import numpy as np from scipy.signal import convolve2d def compute_neighbours_scipy(Z): return convolve2d(Z, np.ones((3,3), dtype=int), 'same') - Z This function shall be calculated correctly for the elements on the boundaries of the matrix.UPDATENet options numpy♪def compute_neighbours_numpy2(Z): mask = np.asarray([[1,1,1], [1,0,1], [1,1,1]]) s = mask.shape + tuple(np.subtract(Z.shape, mask.shape) + 1) sub = np.lib.stride_tricks.as_strided(Z, shape = s, strides = Z.strides * 2) return np.pad(np.einsum('ij,ijkl->kl', mask, sub), [(1, 1), (1, 1)], mode='constant') Option from @CrazyElf with reference calculation for the boundaries of the matrix.def compute_neighbours_numpy_CrazyElf(Z): ZZ = np.pad(Z, [(1, 1), (1, 1)], mode='constant') N = ZZ[:-2, :-2] + ZZ[1:-1, :-2] + ZZ[2:, :-2] + ZZ[:-2, 1:-1] + ZZ[2:, 1:-1] + ZZ[:-2, 2: ] + ZZ[1:-1, 2: ] + ZZ[2:, 2: ] return N Performance measures:import numpy as np from scipy.signal import convolve2d import numba import timeit def compute_neighbours(Z): shape = Z.shape N = [[0 for i in range(shape[1])] for i in range(shape[0])] for x in range(1, shape[0]-1): for y in range(1, shape[1]-1): N[x][y] = Z[x - 1][y - 1] + Z[x][y - 1] + Z[x + 1][y - 1] \ + Z[x - 1][y ] + Z[x + 1][y ] \ + Z[x - 1][y + 1] + Z[x][y + 1] + Z[x + 1][y + 1] return N @numba.njit def compute_neighbours_numba(Z): shape = Z.shape N = [[0 for i in range(shape[1])] for i in range(shape[0])] for x in range(1, shape[0]-1): for y in range(1, shape[1]-1): N[x][y] = Z[x - 1][y - 1] + Z[x][y - 1] + Z[x + 1][y - 1] \ + Z[x - 1][y ] + Z[x + 1][y ] \ + Z[x - 1][y + 1] + Z[x][y + 1] + Z[x + 1][y + 1] return N def compute_neighbours_numpy(Z): return np.asarray([[np.sum(Z[x-1:x+2, y-1:y+2])-Z[x, y] for y in range(0, Z.shape[1])] for x in range(0, Z.shape[0])]) @numba.njit def compute_neighbours_numpy_numba(Z): return np.asarray([[np.sum(Z[x-1:x+2, y-1:y+2])-Z[x, y] for y in range(0, Z.shape[1])] for x in range(0, Z.shape[0])]) def compute_neighbours_numpy2(Z): mask = np.asarray([[1,1,1], [1,0,1], [1,1,1]]) s = mask.shape + tuple(np.subtract(Z.shape, mask.shape) + 1) sub = np.lib.stride_tricks.as_strided(Z, shape = s, strides = Z.strides * 2) return np.pad(np.einsum('ij,ijkl->kl', mask, sub), [(1, 1), (1, 1)], mode='constant') def compute_neighbours_numpy_CrazyElf(Z): ZZ = np.pad(Z, [(1, 1), (1, 1)], mode='constant') N = ZZ[:-2, :-2] + ZZ[1:-1, :-2] + ZZ[2:, :-2] + ZZ[:-2, 1:-1] + ZZ[2:, 1:-1] + ZZ[:-2, 2: ] + ZZ[1:-1, 2: ] + ZZ[2:, 2: ] return N def compute_neighbours_scipy(Z): return convolve2d(Z, np.ones((3,3), dtype=int),'same') - Z matrix = np.random.randint(2, size=(2000,2000)) print("list :", timeit.timeit("compute_neighbours(matrix)" , globals=globals(), number=2)) print("list + numba :", timeit.timeit("compute_neighbours_numba(matrix)" , globals=globals(), number=2)) print("numpy :", timeit.timeit("compute_neighbours_numpy(matrix)" , globals=globals(), number=2)) print("numpy + numba :", timeit.timeit("compute_neighbours_numpy_numba(matrix)" , globals=globals(), number=2)) print("numpy2 :", timeit.timeit("compute_neighbours_numpy2(matrix)" , globals=globals(), number=2)) print("numpy CrazyElf:", timeit.timeit("compute_neighbours_numpy_CrazyElf(matrix)", globals=globals(), number=2)) print("scipy :", timeit.timeit("compute_neighbours_scipy(matrix)" , globals=globals(), number=2)) matrix = np.random.randint(2, size=(10,10)) print(matrix) print(*compute_neighbours(matrix), sep="\n") print(compute_neighbours_numpy2(matrix)) print(compute_neighbours_numpy_CrazyElf(matrix)) print(compute_neighbours_numpy(matrix)) print(compute_neighbours_scipy(matrix)) Measurement results:list : 19.943651329 list + numba : 0.7527782960000025 numpy : 62.82599582 numpy + numba : 0.8693800110000041 numpy2 : 0.2166252049999997 numpy CrazyElf: 0.1425725370000066 scipy : 0.3862877149999946

I can only assume that you've forgotten one unit to display (in Item 7). Well, then...import numpy as np a=np.zeros((9,1), dtype=np.int) b=np.array([1,3,7,9]) a[b-1] = 1 print(a.tolist()) Conclusion:[[1], [0], [1], [0], [0], [0], [1], [0], [1]] Transformation tolist It's only necessary for the beauty of the withdrawal so that one line can be printed like you.Why would it be necessary? map I don't know, you're just talking to the index numbers and everything. Just take into account that indexing comes from scratch.Well, actually, map You can use it if you want, of course:print(list(map(lambda x: [int(x[0] in b)], enumerate(a, 1)))) Conclusion:[[1], [0], [1], [0], [0], [0], [1], [0], [1]] Or so, but without the lists, then:print(list(map(int, map(b.contains, range(1, len(a)+1))))) Conclusion:[1, 0, 1, 0, 0, 0, 1, 0, 1]

It's pretty simple. I just need to guess with the axle number on the summation. I usually just try first. sum() No arguments, then in line with axis=0 and axis=1♪ This is the case. axis=1:P = A / A.sum(axis=1)

Preparation of artificial data:import numpy as np count = 1_000_000 swift = 4 ArrayOfByte = np.random.randint(255, size=count*2) Let's see how long a normal python will work and how much he reads:%%time i = 0 j = 1 newArray = [] for m in range(count): x = ArrayOfByte[i] + (ArrayOfByte[j] * 256) i += 2 j += 2 newArray.append((x >> swift) & 255) print(sum(newArray)) Conclusion:118611957 CPU times: user 1.76 s, sys: 0 ns, total: 1.76 s Wall time: 1.76 s Now. vectorized code numpy:%%time newArray = ((ArrayOfByte[::2] + (ArrayOfByte[1::2] * 256)) >> swift) & 255 print(newArray.sum()) Conclusion:118611957 CPU times: user 11 ms, sys: 0 ns, total: 11 ms Wall time: 14.6 ms The numbers are the same, i.e. the code performs the same calculations. However, vectorized code implemented 100 One more time.P.S. More "small" data types like np.uint8 the difference between the python and numpy 1,000 times more. Numpy They work faster, and they work faster. Python slower. The default type is used np.int64♪

Adding elements to the mass is as follows:arrayXY = np.append(arrayXY, [[x, y]], axis = 0) a To create:arrayXY = np.ndarray(shape=(0,2), dtype=int)

What can be done:b = np.apply_along_axis(lambda x: np.bincount(x, minlength=a.shape[0]), axis=0, arr=a) https://stackoverflow.com/a/19202117/8324991 in English SO.A simpler version unfortunately doesn't work for your data:b = np.apply_along_axis(np.bincount, 0, m) The problem is, bincount may return different bulbs for different columns, so this option does not always work.

(c[i,j]+=1) ^ SyntaxError: invalid syntax You've got a piton error, numpy There's nothing to do with this. You can't make an assignment inside the brackets. That's how it works. c[i,j] += 1

I suspect it's a problem with the exact presentation of the chips with a floating point. And that you have numbers right at the intervals. How beautiful/right to cure, I don't know, but if you add some epilon to the right edge. pd.interval_range, the last value will interval:end = df['linear'].max() + 1e-12 Conclusion:... 0 AG21 430 [426.66666666666737, 503.3333333333342) 503.333333 5 11 AG55 580 [503.3333333333342, 580.000000000001) 580.000000 6

In df: data x1 x2 x3 A str1 76 41 33 B str2 18 82 28 C str3 62 33 48 . . . X str24 57 66 1 Y str25 10 86 24 Z str26 50 74 58 Use the method idxmax by reference axis:df["Result"] = df[["x1", "x2", "x3"]].idxmax(axis=1) The result will be: data x1 x2 x3 Result A str1 76 41 33 x1 B str2 18 82 28 x2 C str3 62 33 48 x1 . . . X str24 57 66 1 x2 Y str25 10 86 24 x2 Z str26 50 74 58 x2 Supplement:If you need to find the peaks in the numerical columns and their numbers don't know or change, there's a more universal way:import numpy as np df["Result"] = df.select_dtypes(np.number).idxmax(axis=1) The result will be the same.