Interactivity

Loading...

Из курса от партнера University of Michigan

Applied Plotting, Charting & Data Representation in Python

1707 оценки

University of Michigan

Applied Plotting, Charting & Data Representation in Python

1707 оценки

Курс 2 из 5 — Specialization Applied Data Science with Python

This course will introduce the learner to information visualization basics, with a focus on reporting and charting using the matplotlib library. The course will start with a design and information literacy perspective, touching on what makes a good and bad visualization, and what statistical measures translate into in terms of visualizations. The second week will focus on the technology used to make visualizations in python, matplotlib, and introduce users to best practices when creating basic charts and how to realize design decisions in the framework. The third week will be a tutorial of functionality available in matplotlib, and demonstrate a variety of basic statistical charts helping learners to identify when a particular method is good for a particular problem. The course will end with a discussion of other forms of structuring and visualizing data. This course should be taken after Introduction to Data Science in Python and before the remainder of the Applied Data Science with Python courses: Applied Machine Learning in Python, Applied Text Mining in Python, and Applied Social Network Analysis in Python.

Из урока

Module 3: Charting Fundamentals

In this module you will explore charting fundamentals. For this week’s assignment you will work to implement a new visualization technique based on academic research. This assignment is flexible and you can address it using a variety of difficulties - from an easy static image to an interactive chart where users can set ranges of values to be used.

Interactivity5:27

Познакомьтесь с преподавателями

Christopher Brooks

Interactivity and animation are very similar in Matplotlib.

For interactivity though, we have to head down to the artist layer a bit more.

In particular, we have to reference the canvas object of the current figure.

The canvas object handles all of the drawing events and

it's tightly connected with a given back end.

If event listening is something you're not familiar with,

it can be a bit of a tough concept to grasp.

For decades, computers have had abstract methods for

doing multiple things at once and now with multiprocessing and multi-core machines,

there's actually physical ways Is to do many thing at once.

But even before that,

the abstraction news was largely focused on the notion of events.

Moving a mouse pointer for instance would create an event, clicking will create

an event, pressing on keys on the keyboard would create an event.

And this didn't only happen at the hardware level such as IRQ interrupts but

at the software level as well.

In fact, event driven programming has infiltrated most of the ways computer

programmers regularly engage with software.

From HTML and JavaScript, down to lower level C code.

You can think of an event as a piece of data which is associated with

a function call.

And when the event happens, the software environment, in our case this is

Matplotlibs backend, will call the function with the relevant data.

Let's look at a trivial example.

We'll create a new figure and plot some random data to it.

Then we'll create a new function called onclick.

And this takes one parameter, which is the event object.

So what's in an event object?

Well, that depends on the type of the event.

Here we're going to deal with mouse events.

And they have both an x and

a y value as far as the location of the mouse in pixels on the canvas.

As well as an x and

a y values first location of the mouse relative to our data and axis.

So for our onclick we'll clear the current axis then plot our data

then set the title of the plot to be variance location of the mouse.

Finally, we have to connect this events to an event listener and

this process is usually called wiring it up.

In this case very easy, get the current figure and

its canvas subject then call the mpl_connect function.

Passing in the string for button_press_event as well as

reference to the function onclick, which will be call when the event is detected.

Now when we click on our plot we see the most information printed to the title.

The Matplotlib documentation describes the kinds of events you can listen from.

But whether they work or not, depends on the backend you're using, and

some backends are not interactive.

Button presses, key presses, scroll events and figuring axis enter and

leave events are almost common.

But the most important event for us is the pick event.

The pick event allows you to respond when the user is

actually clicked on a visual element in the figure.

Let's look at an example.

For this, I want to create a list of countries in randomized order.

We can do this with the shuffle function from the random module.

Then I'll create a new DataFrame with random values for height and weight, and

another column for origin.

Great, now we have some C data to play with.

Now we can create a scatterplot with the x and y values as the height and

weight respectively, pulling from the data frame.

Note that we've added a new argument here called picker and set it to 5.

This informs the Matplotlib backend that the mouse doesn't have to click directly

on a rendered object that can be up to 5 pixels away and

it should find the closest object.

What works for you depends on how you're rendering your charts.

With axis labeled, let's go render this.

Okay, nothing special with this chart yet but let's wired it up.

We'll create a function called onpick, which takes on an event.

This event is a pick event which has different data than the most event.

In particular,

it's got an index value which happens to correspond to our index and the dataframe.

Now Matplotlib isn't aware of the data frame but

it renders the data in the same order.

So we can use the data frame iloc indexer to pull out the origin information.

Now you can see that when you click on an item,

it renders the origin as we would expect.

And there we have it, a fairly straight forward example of

adding interactivity to your graphs and plots.

Now I'll be honest, this looks like very little code to write and

this lecture was pretty short but there is a lot of hunting through documentation and

forms that you have to do it in order to understand the details of the events which

are being passed around.

Pythons lack of static typing has an unfortunate side effect and

it matches the documentation for features like events is buried or missing.

Ознакомьтесь с нашим каталогом

Присоединяйтесь бесплатно и получайте персонализированные рекомендации, обновления и предложения.

Coursera делает лучшее в мире образование доступным каждому, предлагая онлайн-курсы от ведущих университетов и организаций.

© Coursera Inc., 2018 Все права защищены.

Загрузить из App Store

Загрузить в Google Play