Extracting information from the dataset

1. Extracting information from the dataset

Let's now see how we manipulate functions to clean our list.

2. Function manipulation

In this course, we have seen several functions that output another function. A function that behaves as such is called an high-order function. partial() and compose() from purrr have this behavior: they return another function. We have seen them in the previous chapters, and we will be using them again in the following exercises.

3. partial()

Remember partial()? partial() is a purrr function used to prefill a function. It takes a function as input and a list of parameters with values. These parameters will be passed to the newly created function, which can be used inside an iteration (or anywhere else).

4. compose()

With compose(), you're creating a new function from two or more functions. We've seen this function in the previous chapters. The idea with compose() is to make your code clearer: if you need to call a combination of functions several times, you can write a composed function at the beginning of your script, and call this newly created function every time you need it.

5. Cleaner lists

The purrr package also has functions that can be used to clean lists. In the exercises, you will be using compact(), which you have already seen in the previous chapters, and flatten(), a function we haven't seen yet, which is designed to remove one level from a nested list.

6. compact()

In Chapter 2 of this course, we've seen compact(). This function removes all the NULL elements from a list. It allows you to have a cleaner version of your results, as you might not need the NULL elements.

7. flatten()

flatten() is a function that can be useful when you have a list that is nested and want to remove a level of hierarchy to make it easier to manipulate. For example, if you have a list of lists, you can map over this list to extract an element, and then pass the result to flatten(), so that you only have a list with one level of depth. It's what we are going to do in the exercises.

8. Let's practice!

Let's try these functions in the exercises.

Create Your Free Account

or

By continuing, you accept our Terms of Use, our Privacy Policy and that your data is stored in the USA.

This exercise is part of the course

Intermediate Functional Programming with purrr

IntermediateSkill Level

4.9+

Start Course for Free

Do lambda functions, mappers, and predicates sound scary to you? Fear no more! After refreshing your purrr memory, we will dive into functional programming 101, discover anonymous functions and predicates, and see how we can use them to clean and explore data.

Exercise 1: purrr basics - a refresher Exercise 2: Refreshing your purrr memory Exercise 3: Another purrr refresher Exercise 4: Introduction to mappers Exercise 5: Creating lambda functions Exercise 6: Lambda functions Exercise 7: Using mappers to clean up your data Exercise 8: Clean up your data with keep Exercise 9: Split up with keep() and discard()Exercise 10: Predicates Exercise 11: What is a predicate?Exercise 12: Exploring data with predicates

Ready to go deeper with functional programming and purrr? In this chapter, we'll discover the concept of functional programming, explore error handling using including safely() and possibly(), and introduce the function compact() for cleaning your code.

Exercise 1: Functional programming in R Exercise 2: Everything that happens is a function call Exercise 3: Identifying pure functions Exercise 4: Tools for functional programming in purrr Exercise 5: Safe iterations Exercise 6: Create a function Exercise 7: Using possibly()Exercise 8: A possibly() version of read_lines()Exercise 9: Everything in one call Exercise 10: Handling adverb results Exercise 11: Purrrfecting our function Exercise 12: Extracting status codes with GET()

In this chapter, we'll use purrr to write code that is clearer, cleaner, and easier to maintain. We'll learn how to write clean functions with compose() and negate(). We'll also use partial() to compose functions by "prefilling" arguments from existing functions. Lastly, we'll introduce list-columns, which are a convenient data structure that helps us write clean code using the Tidyverse.

Exercise 1: Why cleaner code?Exercise 2: How to write compose()Exercise 3: Back to the office Exercise 4: Building functions with compose() and negate()Exercise 5: Build a function Exercise 6: Count the NA Exercise 7: Prefilling functions Exercise 8: A content extractor Exercise 9: Another extractor Exercise 10: List columns Exercise 11: About list-columns Exercise 12: Create a list-column data.frame

We'll wrap up everything we know about purrr in a case study. Here, we'll use purrr to analyze data that has been scraped from Twitter. We'll use clean code to organize the data and then we'll identify Twitter influencers from the 2018 RStudio conference.

Exercise 1: Discovering the dataset Exercise 2: Playing with tweets, round 1 Exercise 3: Identify profiles Exercise 4: Extracting information from the dataset

Current Exercise

Exercise 5: Counting favorites Exercise 6: Extracting mentions Exercise 7: Manipulating URLs Exercise 8: Analyzing URLs Exercise 9: Playing with URLs Exercise 10: Identifying influencers Exercise 11: Splitting the dataset Exercise 12: We have a winner!Exercise 13: Congratulations!