4  Basic Data Types

4.1 Values and Types

Let’s start this section with some basic vocabulary.

• a value is a basic unit of stuff that a program works with, like 1, 2, "Hello, World", and so on.
• values have types - 2 is an integer, "Hello, World" is a string (it contains a “string” of letters). Strings are in quotation marks to let us know that they are not variable names.

In both R and python, there are some very basic data types:

• logical or boolean - FALSE/TRUE or 0/1 values. Sometimes, boolean is shortened to bool

• integer - whole numbers (positive or negative)

• double or float or numeric- decimal numbers.

  • float is short for floating-point value.
  • double is a floating-point value with more precision (“double precision”).¹
  • R uses the name numeric to indicate a decimal value, regardless of precision.

• character or string - holds text, usually enclosed in quotes.

If you don’t know what type a value is, both R and python have functions to help you with that.

class(FALSE)
class(2L) # by default, R treats all numbers as numeric/decimal values. 
          # The L indicates that we're talking about an integer. 
class(2)
class("Hello, programmer!")

[1] "logical"
[1] "integer"
[1] "numeric"
[1] "character"

type(False)
type(2)
type(3.1415)
type("This is python code")

<class 'bool'>
<class 'int'>
<class 'float'>
<class 'str'>

4.2 Variables

Programming languages use variables - names that refer to values. Think of a variable as a container that holds something - instead of referring to the value, you can refer to the container and you will get whatever is stored inside.

We assign variables values using the syntax object_name <- value (R) or object_name = value (python). You can read this as “object name gets value” in your head.

message <- "So long and thanks for all the fish"
year <- 2025
the_answer <- 42L
earth_demolished <- FALSE

message = "So long and thanks for all the fish"
year = 2025
the_answer = 42
earth_demolished = False

We can then use the variables - do numerical computations, evaluate whether a proposition is true or false, and even manipulate the content of strings, all by referencing the variable by name.

1st_thing <- "check your variable names!"

Error: <text>:1:2: unexpected symbol
1: 1st_thing
     ^

1st_thing <- "check your variable names!"

second.thing <- "this isn't valid"

Error in py_call_impl(callable, dots$args, dots$keywords): NameError: name 'second' is not defined

Detailed traceback:
  File "<string>", line 1, in <module>

4.3 Type Conversions

We talked about values and types above, but skipped over a few details because we didn’t know enough about variables. It’s now time to come back to those details.

What happens when we have an integer and a numeric type and we add them together? Hopefully, you don’t have to think too hard about what the result of 2 + 3.5 is, but this is a bit more complicated for a computer for two reasons: storage, and arithmetic.

In days of yore, programmers had to deal with memory allocation - when declaring a variable, the programmer had to explicitly define what type the variable was. This tended to look something like the code chunk below:

int a = 1
double b = 3.14159

Typically, an integer would take up 32 bits of memory, and a double would take up 64 bits, so doubles used 2x the memory that integers did. Both R and python are dynamically typed, which means you don’t have to deal with any of the trouble of declaring what your variables will hold - the computer automatically figures out how much memory to use when you run the code. So we can avoid the discussion of memory allocation and types because we’re using higher-level languages that handle that stuff for us².

But the discussion of types isn’t something we can completely avoid, because we still have to figure out what to do when we do operations on things of two different types - even if memory isn’t a concern, we still have to figure out the arithmetic question.

So let’s see what happens with a couple of examples, just to get a feel for type conversion (aka type casting or type coercion), which is the process of changing an expression from one data type to another.

mode(2L + 3.14159) # add 2 and pi

[1] "numeric"

mode(2L + TRUE) # add integer 2 and TRUE

[1] "numeric"

mode(TRUE + FALSE) # add TRUE and FALSE

[1] "numeric"

type(2 + 3.14159)

<class 'float'>

type(2 + True)

<class 'int'>

type(True + False)

<class 'int'>

You may be asking yourself at this point why this matters, and that’s a decent question. We will eventually be reading in data from spreadsheets and other similar tabular data, and types become very important at that point, because we’ll have to know how R and python both handle type conversions.

Above, we looked at automatic type conversions, but in many cases, we also may want to convert variables manually, specifying exactly what type we’d like them to be. A common application for this in data analysis is when there are “*” or “.” or other indicators in an otherwise numeric column of a spreadsheet that indicate missing data: when this data is read in, the whole column is usually read in as character data. So we need to know how to tell R and python that we want our string to be treated as a number, or vice-versa.

x <- 3
y <- "3.14159"

x + y

Error in x + y: non-numeric argument to binary operator

x + as.numeric(y)

[1] 6.14159

x = 3
y = "3.14159"

x + y

Error in py_call_impl(callable, dots$args, dots$keywords): TypeError: unsupported operand type(s) for +: 'int' and 'str'

Detailed traceback:
  File "<string>", line 1, in <module>

x + float(y)

6.14159

4.4 Operators and Functions

In addition to variables, functions are extremely important in programming.

Let’s first start with a special class of functions called operators. You’re probably familiar with operators as in arithmetic expressions: +, -, /, *, and so on.

Here are a few of the most important ones:

Note that integer division is the whole number answer to A/B, and modular division is the fractional remainder when A/B.

14 %/% 3

[1] 4

14 %% 3

[1] 2

14 // 3

4

14 % 3

2

Note that these operands are all intended for scalar operations (operations on a single number) - vectorized versions, such as matrix multiplication, are somewhat more complicated (and different between R and python).

(1+1)^(5-2) # 2 ^ 3 = 8

[1] 8

1 + 2^3 * 4 # 1 + (8 * 4)

[1] 33

3*1^3 # 3 * 1

[1] 3

(1+1)**(5-2)

8

1 + 2**3*4

33

3*1**3

3

"first " + "second"

'first second'

"hello " * 3

'hello hello hello '

paste("first", "second", sep = " ")

[1] "first second"

paste("first", "second", collapse = " ")

[1] "first second"

paste(c("first", "second"), sep = " ") # sep only works on separate parameters

[1] "first"  "second"

paste(c("first", "second"), collapse = " ") # collapse works on vectors

[1] "first second"

paste(c("a", "b", "c", "d"), 
      c("first", "second", "third", "fourth"), 
      sep = "-", collapse = " ")

[1] "a-first b-second c-third d-fourth"

# sep is used to collapse parameters, then collapse is used to collapse vectors

paste0(c("a", "b", "c"))

[1] "a" "b" "c"

paste0("a", "b", "c") # equivalent to paste(..., sep = "")

[1] "abc"