Bummer! This is just a preview. You need to be signed in with a Basic account to view the entire video.

Preview

Start a free Basic trial
to watch this video

Sign up for Treehouse

Vectorization and Broadcasting Review

2:00 with Craig Dennis

Vectorization and Broadcasting are what makes NumPy so fast. Pandas' data structures have similar super powers!

Example Code

Vectorization in NumPy

Arrays provide a vectorized method named add which removes the need for you to loop through each value to add things together.

np.array([1, 2, 3]) + np.array([4, 5, 6])

array([5, 7, 9])
Broadcasting in NumPy

Scalar values can be broadcasted to values, it's as if there was an equal sized array of all 1's.

conference_counts = np.array([4, 5, 10, 8, 15])
# Broadcast a scalar value
conference_counts + 1

array([ 5,  6, 11,  9, 16])

In the next step we'll see how to use vectorization and broadcasting in Pandas.

  • 0:00

    NumPy is fast,

  • 0:01

    much faster than we could ever achieve ourselves using just straight Python.

  • 0:05

    One of the reasons for this is that it relies heavily on vectorization.

  • 0:10

    It might have been a while since you heard that term, so

  • 0:12

    I thought we'd take a moment to recall what that means.

  • 0:15

    Vectorization allows us to avoid looping.

  • 0:18

    It provides the ability to work on an entire set of values all at one.

  • 0:22

    Because that abstraction is in place,

  • 0:24

    optimizations are handled at a very low level.

  • 0:27

    That is, if we remember to use them.

  • 0:29

    Because Panda sits directly on top of NumPy, I wanna make sure that you

  • 0:33

    don't forget about the vectorization superpowers that are available to you.

  • 0:38

    Just like in NumPy, whenever you start to write a loop, you should pause and

  • 0:42

    think about how you might solve the problem in a vectorized manner.

  • 0:45

    A key feature that allow vectorization to happen more easily is broadcasting.

  • 0:50

    Broadcasting enables you to use similar enough values in element to element based

  • 0:55

    operations.

  • 0:56

    You don't have to have the same number of elements,

  • 0:59

    your intention can be figured out in context.

  • 1:01

    For instance, let's assume that we work in the learning and

  • 1:04

    development department of a business.

  • 1:06

    And we wanna keep track of how many conferences our employees are attending.

  • 1:10

    We have a single dimensional NumPy array, where each element represents the count of

  • 1:14

    all conferences attended by specific employees.

  • 1:17

    There's a conference that comes through our town, and so

  • 1:20

    we send every single employee to it.

  • 1:21

    What we really want is to increment each of these values by 1.

  • 1:25

    But before we simply just loop through these, we should step back and

  • 1:30

    lean on vectorization.

  • 1:31

    We currently don't have an array the same size, full of 1s.

  • 1:34

    We could create one, but that'd be some extra work.

  • 1:37

    What we can do is just add 1, and

  • 1:39

    our scalar value will be assumed to be the same size when the vectorization occurs.

  • 1:45

    Is just as if we had an array of all 1s.

  • 1:47

    Our 1 is broadcasted to all entries.

  • 1:50

    The series object supports both vectorization and broadcasting.

  • 1:55

    They are important tools to remember that you have at your disposal.

  • 1:58

    Let's explore how they work.

You need to sign up for Treehouse in order to download course files.

Sign up