basics.qmd

---
title: "Core Concepts"
---

## Overview

This section covers some of the most fundamental operations of both languages. These include [variable]{.py}/[object]{.r} assignment, data [type]{.py}/[class]{.r}, arithmetic, etc. External data are _not_ included in this page.

Note that any line in a code chunk preceded by a hashtag (`#`) is a "comment" and is not evaluated in either language. Including comments is generally good practice because it allows humans to read and understand code that may otherwise be unclear to them.

## Assignment

At its most basic, we want to store data in code in such a way that we can use / manipulate it via our scripts. This requires **assigning** data to a [variable]{.py}/[object]{.r} with the **assignment operator**.

:::panel-tabset
## [{{< fa brands r-project >}} R]{.r}

In [{{< fa brands r-project >}} R]{.r}, the assignment operator is `<-`. To use it, the name of the new object-to-be is on the left of the arrow and the information to assign is on the right.

```{r r-assign}
# Make a simple object
a <- 2

# Check it out
a
```

## [{{< fa brands python >}} Python]{.py}

In [{{< fa brands python >}} Python]{.py}, the assignment operator is `=`. To use it, the name of the new object-to-be is on the left of the equal sign and the information to assign is on the right.

```{python py-assign}
# Make a simple object
a = 2

# Check it out
a
```
:::

Once we've created a [variable]{.py}/[object]{.r} we can then use the information stored inside of it in downstream operations! For example, we could perform basic arithmetic on our [variable]{.py}/[object]{.r} and assign the result to a new [variable]{.py}/[object]{.r}.

:::panel-tabset
## [{{< fa brands r-project >}} R]{.r}

Addition, subtraction, multiplication, and division share operators across both languages (`+`, `-`, `*`, and `/` respectively). However, in [{{< fa brands r-project >}} R]{.r} exponents use `^`.

```{r r-math}
# Raise to an exponent
b <- a^3

# Check out the result
b
```

## [{{< fa brands python >}} Python]{.py}

Addition, subtraction, multiplication, and division share operators across both languages (`+`, `-`, `*`, and `/` respectively). However, in [{{< fa brands python >}} Python]{.py} exponents use `**`

```{python py-math}
# Raise to an exponent
b = a**3

# Check out the result
b
```
:::

## [Type]{.py} & [Class]{.r}

Some operations are only possible on some categories of information. For instance, we can only perform arithmetic on numbers. In [{{< fa brands python >}} Python]{.py} this is known as the [variable]{.py}'s [type]{.py} & while in [{{< fa brands r-project >}} R]{.r} this is the [object]{.r}'s [class]{.r}. In either case, it's important to know--and be able to check--this information about the [variables]{.py}/[objects]{.r} with which we are working.

:::panel-tabset
## [{{< fa brands r-project >}} R]{.r}

In [{{< fa brands r-project >}} R]{.r} we use the `class` function to get this information. Note that the names of [{{< fa brands r-project >}} R]{.r} classes sometimes differ from their equivalents in [{{< fa brands python >}} Python]{.py}.

```{r r-class1}
# Check class of an integer
class(37)
```

```{r r-class2}
# Check class of a decimal
class(3.14159)
```

```{r r-class3}
# Check class of text
class("my hands are typing words")
```

## [{{< fa brands python >}} Python]{.py}

In [{{< fa brands python >}} Python]{.py}, the `type` function returns the type of the data object. Note that the names of [{{< fa brands python >}} Python]{.py} types sometimes differ from their equivalents in [{{< fa brands r-project >}} R]{.r}.

```{python py-type1}
# Check type of an integer
type(37)
```

```{python py-type2}
# Check type of a decimal
type(3.14159)
```

```{python py-type3}
# Check type of text
type("my hands are typing words")
```
:::

## Indexing

When our [variables]{.py}/[objects]{.r} have more than one [item]{.py}/[element]{.r} we may want to examine the piece of information at a specific position. This position is the "index position" and can be accessed in either language fairly easily.

In order to explore this more fully, let's make some example multi-component [variables]{.py}/[objects]{.r}.

:::panel-tabset
## [{{< fa brands r-project >}} R]{.r}

In [{{< fa brands r-project >}} R]{.r}, one of the fundamental data structures is a "vector". Vectors are assembled with the concatenation function (`c`) where each item is separated by commas (`,`) and the set of them is wrapped in parentheses (`(...)`).

Note that the class of the object comes from the vector's _contents_ rather than the fact that it is a vector. All elements in a vector therefore must share a class.

```{r r-index-prep}
# Make a multi-item variable
x <- c(1, 2, 3, 4, 5)

# Check it out
class(x)
```

## [{{< fa brands python >}} Python]{.py}

In [{{< fa brands python >}} Python]{.py} the fundamental data structure is a "list". Lists are assembled either by wrapping the items to include in square brackets (`[...]`) or by using the `list` function. In either case, each item is separated from the others by commas (`,`).

Note that the type of the variable comes from the _list itself_ rather than its contents. Lists therefore support items of multiple different types.

```{python py-index-prep}
# Make a multi-item variable
x = [1, 2, 3, 4, 5]

# Check it out
type(x)
```
:::

One crucial difference between [{{< fa brands r-project >}} R]{.r} and [{{< fa brands python >}} Python]{.py} is that [{{< fa brands python >}} Python]{.py} is "0-based" meaning that the first [item]{.py} is at index position `0` while in [{{< fa brands r-project >}} R]{.r} the position of the equivalent [element]{.r} is `1`.

Fortunately, in either language the syntax for indexing is the same.

:::panel-tabset
## [{{< fa brands r-project >}} R]{.r}

To index a multi-element object, simply append square brackets to the end of the object name and specify the number of the index position in which you are interested.

```{r r-index}
# Access the first element of the vector
x[1]
```

## [{{< fa brands python >}} Python]{.py}

To index a multi-item variable, simply append square brackets to the end of the variable name and specify the number of the index position in which you are interested.

```{python py-index}
# Access the first item of the list
x[0]
```
:::

## Slicing

When we index more than one position, this is known as "slicing". We can still use square brackets in either language to slice multiple [items]{.py}/[elements]{.r} and the syntax inside of those brackets _seems_ shared but yields different results due to inherent syntactical differences.

:::panel-tabset
## [{{< fa brands r-project >}} R]{.r}

In [{{< fa brands r-project >}} R]{.r}, when we write two numbers separated by a colon (`:`), that indicates that we want those two numbers and all integers between them.

```{r r-slice-cont1}
# Demonstrate that the colon is shorthand for 'all numbers between'
1:10
```

We can use this to slice out multiple _continuous_ index positions from an object.

```{r r-slice-cont2}
# Slice items in the `x` object
x[2:4]
```

## [{{< fa brands python >}} Python]{.py}

In order to slice in [{{< fa brands python >}} Python]{.py}, we include the start and stop _bounds_ of the items that we want to slice separated by a colon (`:`) inside of square brackets. The first bound (i.e., bound position 0) is actually the starting bracket of the list! This means that we can treat the first number in the slice in the same way we would in single indexing but the second number is actually the bound before the item with that index value.

Another way of thinking about this is that it is similar to a mathematical set. The starting bound is _inclusive_ while the ending bound is _exclusive_.

```{python py-slice-cont}
# Strip out several items of the Python list
x[2:4]
```

Notice that we only get the items at third and fourth index position despite `4` being after the colon (which in an index would return the fifth index position)? That is because the fourth bound is after the fourth item but _before_ the fifth item.
:::