\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mxa_high\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mxa_low\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (44,) (57,) "
]
}
],
"source": [
"xa_high + xa_low"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Yikes! The exception tells us that the two arrays we are using the operator on need to have the same shape. This makes sense: if we are going to do element-by-element addition, the arrays better have the same number of elements. To continue with our operators on two arrays, we'll slice the longer NumPy array. The basic slicing syntax is the same as for strings, lists, and tuples."
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# Just take the first elements\n",
"xa_low_slice = xa_low[:len(xa_high)]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ok, let's try adding arrays again."
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([3523, 4151, 3961, 3840, 4303, 4120, 3901, 3946, 4041, 3651, 4172,\n",
" 3760, 3967, 3483, 3920, 3900, 3981, 3911, 3960, 3888, 3784, 4143,\n",
" 3692, 3690, 3831, 3960, 3927, 4053, 3755, 3928, 3602, 3840, 3722,\n",
" 4110, 4013, 3652, 4007, 3432, 3561, 4044, 4142, 4212, 4261, 3889])"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"xa_high + xa_low_slice"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Great! We get element-by-element addition. The same happens for the other operators we've discussed. `np.isclose()` also operates element-by-element."
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([False, False, False, False, False, False, False, False, False,\n",
" False, False, False, False, False, False, False, False, False,\n",
" False, False, False, False, False, False, False, False, False,\n",
" False, False, False, False, False, False, False, False, False,\n",
" False, False, False, False, False, False, False, False])"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.isclose(xa_high, xa_low_slice)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Slicing NumPy arrays\n",
"\n",
"We already saw that we can slice NumPy arrays like lists and tuples. Here are a few examples."
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1828, 2131, 1851, 2030, 1930, 1660, 1721, 1740, 1752, 1863, 2141,\n",
" 1701, 1661, 1712, 1749, 1642, 1882, 1821, 1800, 1692, 1680, 1671,\n",
" 1683, 1833, 1800, 1930, 1910, 1821, 1840, 1787, 1683, 1809, 1951,\n",
" 1892, 1731, 1751, 1802, 1912, 1781, 2091, 1852, 1792, 2061, 1683])"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Reversed array\n",
"xa_high[::-1]"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1852, 1751, 1683, 1930, 1680, 1642, 2141, 1660, 1828])"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Every 5th element, starting at index 3\n",
"xa_high[3::5]"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1892, 1951, 1809, 1683, 1787, 1840, 1821, 1910, 1930, 1800, 1833])"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Entries 10 to 20\n",
"xa_high[10:21]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Fancy indexing\n",
"\n",
"NumPy arrays also allow **fancy indexing**, where we can slice out specific values. For example, say we wanted indices 1, 19, and 6 (in that order) from `xa_high`. We just index with a list of the indices we want."
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([2061, 1800, 1912])"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"xa_high[[1, 19, 6]]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Instead of a list, we could also use a NumPy array."
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([2061, 1800, 1912])"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"xa_high[np.array([1, 19, 6])]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As a very nice feature, we can use Boolean indexing with Numpy arrays, just like with Pandas using `.loc`. Say we only want the egg cross sectional areas that are greater than 2000 µm$^2$."
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([2061, 2091, 2141, 2030, 2131])"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Just slice out the big ones\n",
"xa_high[xa_high > 2000]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If we want to know the indices where the values are high, we can use the `np.where()` function."
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(array([ 1, 4, 33, 40, 42]),)"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.where(xa_high > 2000)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## NumPy arrays are mutable\n",
"\n",
"Yes, NumPy arrays are mutable. Let's look at some consequences."
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 2, 6, 4])"
]
},
"execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Make an array\n",
"my_ar = np.array([1, 2, 3, 4])\n",
"\n",
"# Change an element\n",
"my_ar[2] = 6\n",
"\n",
"# See the result\n",
"my_ar"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now, let's try working attaching another variable to the NumPy array."
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 2, 6, 9])"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Attach a new variable\n",
"my_ar2 = my_ar\n",
"\n",
"# Set an entry using the new variable\n",
"my_ar2[3] = 9\n",
"\n",
"# Does the original change? (yes.)\n",
"my_ar"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's see how messing with NumPy in functions affects things."
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([0.1, 0.2, 0.3, 0.4])"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Re-instantiate my_ar\n",
"my_ar = np.array([1, 2, 3, 4]).astype(float)\n",
"\n",
"# Function to normalize x (note that /= works with mutable objects)\n",
"def normalize(x):\n",
" x /= np.sum(x)\n",
"\n",
"# Pass it through a function\n",
"normalize(my_ar)\n",
"\n",
"# Is it normalized even though we didn't return anything? (Yes.)\n",
"my_ar"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So, be careful when writing functions. What you do to your NumPy array inside the function will happen outside of the function as well."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Slices of NumPy arrays are **views**, not copies\n",
"\n",
"A very important distinction between NumPy arrays and lists is that slices of NumPy arrays are **views** into the original NumPy array, NOT copies."
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1, 2, 3, 4]\n",
"[1 9 3 4]\n"
]
}
],
"source": [
"# Make list and array\n",
"my_list = [1, 2, 3, 4]\n",
"my_ar = np.array(my_list)\n",
"\n",
"# Slice out of each\n",
"my_list_slice = my_list[1:-1]\n",
"my_ar_slice = my_ar[1:-1]\n",
"\n",
"# Mess with the slices\n",
"my_list_slice[0] = 9\n",
"my_ar_slice[0] = 9\n",
"\n",
"# Look at originals\n",
"print(my_list)\n",
"print(my_ar)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Messing with an element of a slice of a NumPy array messes with that element in the original! This is not the case with lists. Let's issue a warning.\n",
"\n",
"\n",
"
Slices of NumPy arrays are **views**, not copies.\n",
"\n",
"\n",
"Fortunately, you can make a copy of an array using the `np.copy()` function."
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Make a copy\n",
"xa_high_copy = np.copy(xa_high)\n",
"\n",
"# Mess with an entry\n",
"xa_high_copy[10] = 2000\n",
"\n",
"# Check equality\n",
"np.allclose(xa_high, xa_high_copy)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So, messing with an entry in the copy did not affect the original."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Indexing 2D NumPy arrays\n",
"\n",
"NumPy arrays need not be one-dimensional. We'll create a two-dimensional NumPy array by reshaping our `xa_high` array from having shape `(44,)` to having shape `(11, 4)`. That is, it will become an array with 11 rows and 4 columns."
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[1683, 2061, 1792, 1852],\n",
" [2091, 1781, 1912, 1802],\n",
" [1751, 1731, 1892, 1951],\n",
" [1809, 1683, 1787, 1840],\n",
" [1821, 1910, 1930, 1800],\n",
" [1833, 1683, 1671, 1680],\n",
" [1692, 1800, 1821, 1882],\n",
" [1642, 1749, 1712, 1661],\n",
" [1701, 2141, 1863, 1752],\n",
" [1740, 1721, 1660, 1930],\n",
" [2030, 1851, 2131, 1828]])"
]
},
"execution_count": 35,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# New 2D array using the reshape() method\n",
"my_ar = xa_high.reshape((11, 4))\n",
"\n",
"# Look at it\n",
"my_ar"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Notice that it is represented as an array made out of a list of lists. If we had a list of lists, we would index it like this:\n",
"\n",
" list_of_lists[i][j]"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 36,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Make list of lists\n",
"list_of_lists = [[1, 2], [3, 4]]\n",
"\n",
"# Pull out value in first row, second column\n",
"list_of_lists[0][1]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Though this will work with NumPy arrays, this is *not* how NumPy arrays are indexed. They are indexed much more conveniently."
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2061"
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"my_ar[0,1]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We essentially have a tuple in the indexing brackets. Now, say we wanted the second row (indexing starting at 0)."
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1751, 1731, 1892, 1951])"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"my_ar[2,:]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can use Boolean indexing as before."
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([2061, 2091, 2141, 2030, 2131])"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"my_ar[my_ar > 2000]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note that this gives a one-dimensional list of the entries greater than 2000. If we wanted indices where this is the case, we can again use `np.where()`."
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(array([ 0, 1, 8, 10, 10]), array([1, 0, 1, 0, 2]))"
]
},
"execution_count": 40,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.where(my_ar > 2000)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This tuple of NumPy arrays is how we would index using fancy indexing to pull those values out using fancy indexing."
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([2061, 2091, 2141, 2030, 2131])"
]
},
"execution_count": 41,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"my_ar[(np.array([ 0, 1, 8, 10, 10]), np.array([1, 0, 1, 0, 2]))]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"NumPy arrays can be of arbitrary integer dimension, and these principles extrapolate to 3D, 4D, etc., arrays."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Concatenating arrays\n",
"\n",
"Let's say we want to study all cross sectional areas and don't care if the mother was well-fed or not. We would want to concatenate our arrays. The `np.concatenate()` function accomplishes this. We simply have to pass it a tuple containing the NumPy arrays we want to concatenate."
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1683, 2061, 1792, 1852, 2091, 1781, 1912, 1802, 1751, 1731, 1892,\n",
" 1951, 1809, 1683, 1787, 1840, 1821, 1910, 1930, 1800, 1833, 1683,\n",
" 1671, 1680, 1692, 1800, 1821, 1882, 1642, 1749, 1712, 1661, 1701,\n",
" 2141, 1863, 1752, 1740, 1721, 1660, 1930, 2030, 1851, 2131, 1828,\n",
" 1840, 2090, 2169, 1988, 2212, 2339, 1989, 2144, 2290, 1920, 2280,\n",
" 1809, 2158, 1800, 2133, 2060, 2160, 2001, 2030, 2088, 1951, 2460,\n",
" 2021, 2010, 2139, 2160, 2106, 2171, 2113, 2179, 1890, 2179, 2021,\n",
" 1969, 2150, 1900, 2267, 1711, 1901, 2114, 2112, 2361, 2130, 2061,\n",
" 2121, 1832, 2210, 2130, 2153, 2009, 2100, 2252, 2143, 2252, 2222,\n",
" 2121, 2409])"
]
},
"execution_count": 42,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"combined = np.concatenate((xa_high, xa_low))\n",
"\n",
"# Look at it\n",
"combined"
]
}
],
"metadata": {
"anaconda-cloud": {},
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.6.5"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
![](\"caltech_rosen.png\")
\n",
"\n",
"*This tutorial was generated from a Jupyter notebook. You can download the notebook [here](l27_numpy_arrays.ipynb).*\n",
"\n",
"