Modifying Subsets of Vectors

The subsetting logic from the previous reading isn’t just for extracting subsets of vectors to analyze – it’s also useful for modifying vectors. The idea is that instead of keeping elements that meet a logical condition or occur at a specific index, we can change them!

For example, let’s consider the vector with the salaries of everyone in my company. Suppose we wanted to give a raise to one of our workers – the person earning $80,000 – how would we correct that mistake without re-creating the full vector?

The answer is that we can fix it using indexing, or a logical statement.

import numpy as np

# Create a vector with salaries of employees
salaries = np.array([105_000, 50_000, 55_000, 80_000])
salaries

array([105000,  50000,  55000,  80000])

salaries[salaries == 80_000] = 90_000  # using a logical statement
salaries

array([105000,  50000,  55000,  90000])

salaries[3] = 90_000  # using indexing
salaries

array([105000,  50000,  55000,  90000])

Note that we can also make modifications to subsets of rows by using subsets on BOTH sides of the assignment operator.

For example, we wanted to give a raise to everyone enter company who made less than $75,000.

If we were getting a raise to everyone, we could just to:

salaries = salaries + 10_000

But then we’d be giving a raise to some of the folks who make more than 75,000 dollars. So we have to (a) pull out the salaries that are less than 75,000 dollars, (b) increment them up by 10,000 dollars, and (c) re-insert them, replacing the old salaries:

salaries = np.array([105_000, 50_000, 55_000, 80_000])

# Get lower salaries
lower_salaries = salaries[salaries < 75_000]
lower_salaries

array([50000, 55000])

# Increase them all by ten thousand
new_salaries = lower_salaries + 10_000
new_salaries

array([60000, 65000])

# Re-insert
salaries[salaries < 75_000] = new_salaries
salaries

array([105000,  60000,  65000,  80000])

Note that this last operation worked because the vector on the left side of the assignment operator had a length of two, and the new vector on the right-hand side was also of length two, so numpy could match the entries being subset on the left to entries on the right one-to-one.

But while we can do this is all these separate steps, we can also collapse this:

# Re-create her original salary vector
salaries = np.array([105_000, 50_000, 55_000, 80_000])

salaries[salaries < 75_000] = salaries[salaries < 75_000] + 10_000
salaries

array([105000,  60000,  65000,  80000])

Again, note this only worked because we were careful to ensure that the vector on the right of the assignment operator “fit” into the space being subset on the left! This is a trick we use a lot in data science, so make sure you’re comfortable with it before proceeding.

Modifying Vectors and Data Types

You may not have noticed, but up till now we’ve only being doing “like-for-like” substitutions. For example, when we changed an entry in age, we were always replacing one int with another.

This is important, because as we discussed in our last reading, vectors are homogeneously typed, meaning that unlike lists, you can’t put different types of data in an array.

Now when we’re creating a vector, numpy will use type promotion to pick a type that accommodates everything you’re putting into an array. For example, if I pass both bools and integers to np.array(), it will just type promote everything to be integers:

np.array([True, False, 7])

array([1, 0, 7])

But once a vector has been created, numpy stops being so considerate: if you try and cram data of a different type into a vector of a given type, it will try to coerce the data into the established type of the array.

For example, if we try and cram 7 into an array that’s already of type bool, numpy will coerce 7 into type bool (e.g. run Boolean(7)), which will turn 7 into True even though this is causing information to be lost:

bool_vector = np.array([True, False])
bool_vector

array([ True, False])

bool_vector[1] = 7
bool_vector

array([ True,  True])

Similarly, if you try and put a floating point number into an integer vector, that float will be type coerced into an integer, which is accomplished by just truncating any information after the decimal:

int_vector = np.array([1, 2, 3])
int_vector

array([1, 2, 3])

int_vector[0] = 42.989723798729874
int_vector

array([42,  2,  3])

This is why, as we mentioned in the last reading, you might not always want to let numpy pick your datatypes for you. Suppose in the example above, for example, you know you might later need to put a floating point number into int_vector – you could instead tell numpy to make it a floating point number vector at creation:

no_longer_an_int_vector = np.array([1, 2, 3], dtype="float")
no_longer_an_int_vector[0] = 42.989723798729874
no_longer_an_int_vector

array([42.9897238,  2.       ,  3.       ])

I know this can be a little confusing, so here’s a recap:

• When creating a vector, numpy will do everything it can to ensure that you don’t lose any information by type promoting your data to the lowest type that preserves all the information in your data.

• Once a vector has been created, numpy’s hands are tied, so it will use type coercion to force the data you’re trying to put into your existing vector into the established type, even if that causes information loss.

Exercises

1. Create the following vector of salaries: 50_000, 105_250, 55_000, 89_000. What is the total payroll (sum of all salaries for the company)?

2. Now suppose our evil CEO has decided to give herself a raise. Take your salary vector and modify it so that the CEO – the person making 105,000 dollars – gets a raise of 15%.

3. 115% of 105,250 dollars is 121,037.50 dollars. Is that the value in your array? If not, can you tell why not?

4. Recreate your vector, do something with the dtype argument so that when you give the CEO a raise of 15%, she ends up with a salary of 121,037.50 dollars.

5. Now suppose this has so annoyed the lowest paid employee (the woman earning 50,000 dollars) that she demands a raise as well. Increase her salary by 20%.

6. This has so irritated the other two employees you must now give them 10% raises. Increase their salaries by 10%.

7. Now calculate the total payroll for the company. In the end, what did the CEO’s ~16,000 raise end up costing the company?