## How numpy comparison works

numpy compare elements of two arrays
numpy compare two arrays element wise
numpy where
numpy compare two arrays return difference
numpy compare array to scalar
numpy compare arrays
numpy any
numpy all

I am new to this field, this script is used to get 80% of data randomly into training list, and the rest 20% in testing list. This script works, but I have a few questions about why it works. If len(data) is 1000, then randn(1000) will generate 1000 random number with normal distribution. What I do not understand are: 1)I test myself such as [1,2,3,4,5,6,7,8,9,10]<5 I got an error,because the left operator is a list.But why check=a<0.8 legal, a should be a list of 1000 elements?

```import pandas as pd
import numpy as np
len(data)
a=np.random.randn(len(data))
check=a<0.8
training=data[check]
testing=data[~check]
```

NumPy arrays overload the comparison operators to perform the operation per-element, not per container.

In other words,

```check=a<0.8
```

will create a new NumPy array `check` of the same length as `a` such that:

```check[i] = a[i] < 0.8
```

Comparisons, Masks, and Boolean Logic, NumPy also implements comparison operators such as < (less than) and > ( greater and NumPy provides a number of straightforward patterns for working with� For example, 1.0 looks like 0x3c00 to C, and if you do an equality comparison between the different signed zeros, you will get -0.0 != 0.0 (0x8000 != 0x0000), which is incorrect. For these reasons, NumPy provides an API to work with npy_half values accessible by including <numpy/halffloat.h> and linking to ‘npymath’.

Well check variable works as a boolean object and in the code the line for that is only an assignation. In other hand, the comparison with two objects have to be the same type. type([1,2,3,4,5,6,7,8,9,10]) --> 'list' object type(5) --> 'int' object

Numpy element wise comparison for a particular value in two arrays , You can use "masking" followed by the comparison and finally a sum operation: NumPy has a nice function that returns the indices where your criteria As pointed out by @n1k31t4 it only works if you have two arrays that� When operating on two arrays, NumPy compares their shapes element-wise. It starts with the trailing dimensions and works its way forward. Two dimensions are compatible when: they are equal, or; one of them is 1; That’s all there is to it.

In contrast with the built-in types such as `list`, `numpy` arrays take advantage of the Python rich comparison system by overriding the comparison operators. This is in order to allow comparison with atomic types, numpy-array-like types, etc. The rich comparison operators return new arrays (rather than just a `True` or `False`).

Anyone can write a class that does custom comparisons like `numpy` arrays.

Helpful tip: if you use `functools.total_ordering`, you only have to provide two methods, such as, `__eq__` and `__lt__`:

```import functools

@functools.total_ordering
class Mine:
def __eq__(self, other):
...
def __lt__(self, other):
...
```

The remaining methods are sort-of automatically intuited when you provide correct behavior for these two. However in practice, to get a class working the way you want, one will often find it is needed to customize the behaviors of the other rich comparison methods: `__ne__`, `__gt__`, `__le__`, and `__ge__`.

numpy.equal — NumPy v1.19 Manual, Output array, element-wise comparison of x1 and x2. Typically of type bool, unless dtype=object is passed. This is a scalar if both x1 and x2 are� numpy.dot(vector_a, vector_b, out = None) returns the dot product of vectors a and b. It can handle 2D arrays but considering them as matrix and will perform matrix multiplication. For N dimensions it is a sum product over the last axis of a and the second-to-last of b :

numpy.allclose — NumPy v1.19 Manual, numpy. allclose. Returns True if two arrays are element-wise equal within a tolerance. Infs are treated as equal if they are in the same place and of the same sign in both arrays. NumPy is the fundamental Python library for numerical computing. Its most important type is an array type called ndarray. NumPy offers a lot of array creation routines for different circumstances. arange() is one such function based on numerical ranges. It’s often referred to as np.arange() because np is a widely used abbreviation for NumPy.

numpy.isclose — NumPy v1.19 Manual, numpy.isclose. Returns a boolean array where two arrays are element-wise equal within a tolerance. The tolerance values are positive, typically very small numbers. The relative difference (rtol * abs(b)) and the absolute difference atol are added together to compare against the absolute difference between a and b. Basis for Comparison Pandas NumPy; Works with: Pandas module works with the tabular data. NumPy module works with numerical data. Powerful Tools: Pandas has powerful tools like Series, DataFrame etc. NumPy has a powerful tool like Arrays. Organizational usage: Pandas is used in popular organizations like Instacart, SendGrid, and Sighten.

String operations — NumPy v1.19 Manual, Comparison�. Unlike the standard numpy comparison operators, the ones in the char module strip trailing whitespace characters before� numpy is a third-party Python library often used for numerical computations. It’s especially suitable to manipulate arrays. It’s especially suitable to manipulate arrays. It offers a number of useful routines to work with arrays, but also allows writing compact and elegant code without loops.