`np.arange(b)`

- gives an array with
`b`

elements, starting from zero

`np.arange(a,b)`

- starts the array at
`a`

and ends at`b`

- 1

`np.arange(a,b,c)`

- starts at
`a`

, increases in increments of`c`

, stops at`b - c`

.

`np.linspace(a,b,c)`

- gives an array starting at
`a`

and ending at`b`

with`c`

elements`c`

defaults to 50

`np.zeros( (a,b) )`

- gives an array in the shape of
`(a,b)`

filled with zeros

`np.ones( (a,b) )`

- gives an array in the shape of
`(a,b)`

filled with ones

`np.full( (a,b),c)`

- gives an array in the shape of
`(a,b)`

filled with`c`

`np.zeros_like(A)`

- gives an array in the same shape as
`A`

but filled with zeros

`np.ones_like(A)`

- gives an array in the same shape as
`A`

but filled with ones

`np.full_like(A,b)`

- gives an array in the same shape as
`A`

but filled with`b`

`np.copy()`

- creates a new array that isn't linked back to the old one.
- example:
`b = a`

will make it so that changes to`b`

propagate back to`a`

`b = a.copy()`

will make`b`

not pass any changes backwards.

For 1d arrays:

`A[1:]`

will give all but the first element of`A`

`A[:-1]`

will give all but the last element of`A`

`A[::2]]`

will give every other element of`A`

`X = (A[1:] + A[:-1]) / 2`

will create a new array`X`

that interpolates between the values of`A`

- This works by adding the offset arrays together as follows:
`A[1] + A[0]`

,`A[2] + A[1]`

, … ,`A[-1] + A[-2]`

and then halving the results.

for 2d arrays:

`B[0][0]`

will give the element in the first row & column of`B`

`B[0,0]]`

does the same

`B[1:]`

will give all but the first row of`B`

`B[:][1:]`

will do the same

`B[:-1]`

will give all but the last row of`B`

`B[:,1:]`

will give all but the first column of`B`

`B[a:b:c]`

will give rows`a`

through`b`

in steps of`c`

`B[::-1]]`

will reverse the order of rows in the array

`B[::,a,b,c]]`

will give columns`a`

through`b`

in steps of`c`

`B[::,::-1]]`

will reverse the order of columns in the array`B[::-1,::-1]`

will reverse both the order of rows and columns in the array simultaneously (mirroring on the off-diagonal)

`B = A>5`

will create an array`B`

the same size as`A`

. Elements of`B`

will be`True`

where the matching element of`A`

is greater than 5, and`False`

otherwise`A[A>5]`

will return only the elements of`A`

which are larger than 5.- This does not preserve the shape of the array, so be careful in 2d!
`B = A>5`

followed by`A[B]`

does the same thing as`A[A>5]`

`A[A>5 & A<8]`

does not work and gives an error`ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()`

- This error is because Numpy can't tell if we want to know if we want to know if any elements in
`A`

meet the conditions or if we want to know if all of the elements in`A`

meet the conditions. In practice, we want neither. `B = A>5`

then`C=A<8`

followed by`A[B & C]`

behaves as intended, returning elements of`A`

that are greater than 5 but less than 8.`A[(A>5) & (A<8)]`

works as it evaluates each clause separately and then combines them.- One final method is to use Python's
`map`

function, which lets you apply an operation to each element in an array. It returns an iterable object, so you need to convert it to a Python`list`

`def filter(value): return value > 5 & value < 8`

`A[list(map(filter,A))]`

Suppose you want to show a subset of data in a plot, where `X`

values are between 100 and 200.

`lims = (X >100) & (X < 200)`

`ax.plot(X[lims],Y[lims])`

`np.loadtxt(a.txt)`

will try to load data from`a.txt`

, using whitespace as a separator`delimiter = “,”`

will indicate that a`,`

separates data entries`skiprows = n`

will skip the first`n`

rows in the file`usecols = (a,b,c,…)`

will keep only data from the columns in the list`(a,b,c,…)`

- Either a Python list or Numpy array will work here.

`np.genfromtxt(a.txt)`

will also load data from`a.txt`

using whitespace as a separator, but handles missing values more gracefully`skip_header = n`

is used instead of`skiprows`

`C = np.append(A,B)`

will create`C`

, which extends`A`

by adding`B`

data to the end of it.- If you are working with 1d arrays, this will result in a single longer array
`C = np.hstack(A,B)`

will do the same

`C = np.vstack(A,B)`

will create a 2D array`C`

by making rows of`A`

and`B`

- This can also just add new rows onto an existing 2D array
- This only works if the
`A`

and`B`

are the same length

`np.squeeze(A)`

will remove singleton dimensions of array`A`

`np.squeeze([A])[0]`

will give you the 0th element of`A`

`[A][0]`

will just give you the array`A`

- Mostly this is useful if you've got an extra dimension of array crammed into your data randomly