R Programming

  1. Data Manipulation with Tidyverse
    1. Tidyverse Philosophy
      1. Tidy Data Principles
        1. Each Variable in a Column
          1. Each Observation in a Row
            1. Each Value in a Cell
            2. Functional Programming Approach
              1. Consistent API Design
                1. Core Tidyverse Packages
                2. Data Transformation with dplyr
                  1. Core Verbs
                    1. `filter()` for Row Filtering
                      1. Logical Conditions
                        1. Multiple Conditions
                          1. Missing Value Handling
                          2. `select()` for Column Selection
                            1. Column Names
                              1. Column Ranges
                                1. Helper Functions
                                2. `arrange()` for Sorting
                                  1. Single Column Sorting
                                    1. Multiple Column Sorting
                                      1. Descending Order
                                      2. `mutate()` for Column Creation
                                        1. New Column Creation
                                          1. Column Modification
                                            1. Multiple Columns
                                            2. `summarise()` for Aggregation
                                              1. Summary Statistics
                                                1. Custom Functions
                                                  1. Multiple Summaries
                                                2. Grouping Operations
                                                  1. `group_by()` Function
                                                    1. Grouped Summaries
                                                      1. Grouped Mutations
                                                        1. `ungroup()` Function
                                                        2. The Pipe Operator
                                                          1. Magrittr Pipe (`%>%`)
                                                            1. Native Pipe (`|>`)
                                                              1. Pipe Benefits
                                                                1. Chaining Operations
                                                                  1. Pipe Alternatives
                                                                  2. Advanced dplyr Functions
                                                                    1. `distinct()` for Unique Rows
                                                                      1. `count()` for Counting
                                                                        1. `top_n()` for Top Values
                                                                          1. `sample_n()` and `sample_frac()` for Sampling
                                                                          2. Joining Data
                                                                            1. `inner_join()` for Inner Joins
                                                                              1. `left_join()` for Left Joins
                                                                                1. `right_join()` for Right Joins
                                                                                  1. `full_join()` for Full Joins
                                                                                    1. `semi_join()` and `anti_join()`
                                                                                      1. Join Key Specification
                                                                                        1. Handling Duplicate Keys
                                                                                      2. Data Tidying with tidyr
                                                                                        1. Reshaping Data
                                                                                          1. `pivot_longer()` for Wide to Long
                                                                                            1. Column Selection
                                                                                              1. Names and Values
                                                                                                1. Multiple Value Columns
                                                                                                2. `pivot_wider()` for Long to Wide
                                                                                                  1. Names and Values From
                                                                                                    1. Handling Missing Values
                                                                                                  2. Handling Missing Values
                                                                                                    1. `drop_na()` for Removing Missing
                                                                                                      1. `replace_na()` for Replacing Missing
                                                                                                        1. `fill()` for Forward/Backward Fill
                                                                                                        2. Column Operations
                                                                                                          1. `separate()` for Column Splitting
                                                                                                            1. `unite()` for Column Combining
                                                                                                              1. `extract()` for Pattern Extraction
                                                                                                              2. Nested Data
                                                                                                                1. `nest()` for Creating Nested Data
                                                                                                                  1. `unnest()` for Expanding Nested Data
                                                                                                                    1. Working with List Columns
                                                                                                                  2. String Manipulation with stringr
                                                                                                                    1. String Detection
                                                                                                                      1. `str_detect()` Function
                                                                                                                        1. Pattern Matching
                                                                                                                        2. String Extraction
                                                                                                                          1. `str_extract()` and `str_extract_all()`
                                                                                                                            1. `str_match()` Function
                                                                                                                            2. String Replacement
                                                                                                                              1. `str_replace()` and `str_replace_all()`
                                                                                                                                1. Pattern-based Replacement
                                                                                                                                2. String Splitting
                                                                                                                                  1. `str_split()` Function
                                                                                                                                    1. Fixed vs. Regex Patterns
                                                                                                                                    2. String Length and Trimming
                                                                                                                                      1. `str_length()` Function
                                                                                                                                        1. `str_trim()` and `str_squish()`
                                                                                                                                        2. Case Conversion
                                                                                                                                          1. `str_to_upper()`, `str_to_lower()`, `str_to_title()`
                                                                                                                                        3. Functional Programming with purrr
                                                                                                                                          1. Map Functions
                                                                                                                                            1. `map()` for Lists
                                                                                                                                              1. `map_dbl()`, `map_chr()`, `map_lgl()` for Vectors
                                                                                                                                                1. `map_dfr()` and `map_dfc()` for Data Frames
                                                                                                                                                2. Iteration Patterns
                                                                                                                                                  1. `map2()` for Two Inputs
                                                                                                                                                    1. `pmap()` for Multiple Inputs
                                                                                                                                                      1. `imap()` for Index Mapping
                                                                                                                                                      2. Predicate Functions
                                                                                                                                                        1. `keep()` and `discard()`
                                                                                                                                                          1. `some()` and `every()`
                                                                                                                                                          2. List Manipulation
                                                                                                                                                            1. `pluck()` for Element Extraction
                                                                                                                                                              1. `flatten()` for List Flattening

                                                                                                                                                          Previous

                                                                                                                                                          7. Data Manipulation with Base R

                                                                                                                                                          Go to top

                                                                                                                                                          Next

                                                                                                                                                          9. Programming Constructs in R