## NumPy – 28 – indicizzazione fancy – 3 Continuo copiando qui.

Modificare valori con l’indirizzamento fancy
Just as fancy indexing can be used to access parts of an array, it can also be used to modify parts of an array. For example, imagine we have an array of indices and we’d like to set the corresponding items in an array to some value: We can use any assignment-type operator for this. For example: Notice, though, that repeated indices with these operations can cause some potentially unexpected results. Consider the following: Where did the 4 go? The result of this operation is to first assign `x = 4`, followed `by x = 6`. The result, of course, is that `x` contains the value 6.

Fair enough, but consider this operation: You might expect that `x` would contain the value 2, and `x` would contain the value 3, as this is how many times each index is repeated. Why is this not the case? Conceptually, this is because `x[i] += 1` is meant as a shorthand of `x[i] = x[i] + 1`. `x[i] + 1` is evaluated, and then the result is assigned to the indices in `x`. With this in mind, it is not the augmentation that happens multiple times, but the assignment, which leads to the rather nonintuitive results.

So what if you want the other behavior where the operation is repeated? For this, you can use the `at()` method of ufuncs (available since NumPy 1.8), and do the following: Esempio: suddividere dati
You can use these ideas to efficiently bin data to create a histogram by hand. For example, imagine we have 1,000 values and would like to quickly find where they fall within an array of bins. We could compute it using `ufunc.at` like this:

``````import numpy as np

np.random.seed(42)
x = np.random.randn(100)

# compute a histogram by hand
bins = np.linspace(-5, 5, 20)
counts = np.zeros_like(bins)

# find the appropriate bin for each x
i = np.searchsorted(bins, x)

# add 1 to each of these bins

# plot the results
import matplotlib.pyplot as plt
plt.plot(bins, counts, linestyle='steps');
plt.show()`````` Of course, it would be silly to have to do this each time you want to plot a histogram. This is why Matplotlib provides the `plt.hist()` routine, which does the same in a single line:

`plt.hist(x, bins, histtype='step')`

This function will create a nearly identical plot to the one seen here. To compute the binning, matplotlib uses the `np.histogram` function, which does a very similar computation to what we did before. Let’s compare the two here: Our own one-line algorithm is several times faster than the optimized algorithm in NumPy! How can this be? If you dig into the `np.histogram` source code (you can do this in IPython by typing `np.histogram??)`, you’ll see that it’s quite a bit more involved than the simple search-and-count that we’ve done; this is because NumPy’s algorithm is more flexible, and particularly is designed for better performance when the number of data points becomes large: What this comparison shows is that algorithmic efficiency is almost never a simple question. An algorithm efficient for large datasets will not always be the best choice for small datasets, and vice versa. But the advantage of coding this algorithm yourself is that with an understanding of these basic methods, you could use these building blocks to extend this to do some very interesting custom behaviors. The key to efficiently using Python in data-intensive applications is knowing about general convenience routines like `np.histogram` and when they’re appropriate, but also knowing how to make use of lower-level functionality when you need more pointed behavior. Posta un commento o usa questo indirizzo per il trackback.