slides-06-01.qmd

---
title: "lists (slides)"
format: revealjs
slide-number: true
df-print: kable
---

# CSc 110 - Lists

## Sequences

We've worked with `strings`, which are sequences in Python. Sequences can be indexed with `[ ]`:

```{python}
#| eval: true
#| echo: true
word = "uncopyrightable"
word[0] # returns first character in string
```

```{python}
#| eval: true
#| echo: true
word[1] # returns second character in string
```

We also have `lists` in Python, which are also sequences and can indexed with `[ ]`:

```{python}
#| eval: true
#| echo: true
numbers = [4, 2, 5, 7]
numbers[0] # returns first item in list
```

## Data Structures

-   Data structures is a way to organize data when coding
-   Data structures allow for easy access and **modification** of values
-   You can see data structures as a collection of data values
-   In Python `lists` are a data structure that is:
    -   mutable (you can change the values in it)
    -   unordered -- you can have repeated elements in a list

## Creating lists

```{python}
#| eval: true
#| echo: true
# empty list
no_numbers = []

# list of integers
numbers = [1, 5, 2, 10, 7]

# list of strings
names = ['ron', 'joe', 'kyle']

# mixed types list
values = [1, 1.15, 7, 1.75, 'those']
```

## Evaluate the expressions

```{python}
#| eval: false
#| echo: true
numbers = [2, 3, 2, 4, 5]
numbers[1] + numbers[4]

numbers = [2.0, 3, 1.3, 4]
numbers[0] * numbers[2]

words = ['the', 'bear', 'in', 'the', 'tree']
words[3] + words[4] + words[1]

floats = [1.2, 3.4, 0.3, 1.0, 3.2]
len(floats)
```

## Evaluate the expressions

```{python}
#| eval: true
#| echo: true
numbers = [2, 3, 2, 4, 5]
numbers[1] + numbers[4]
```

```{python}
#| eval: true
#| echo: true
numbers = [2.0, 3, 1.3, 4]
numbers[0] * numbers[2]
```

```{python}
#| eval: true
#| echo: true
words = ['the', 'bear', 'in', 'the', 'tree']
words[3] + words[4] + words[1]
```

```{python}
#| eval: true
#| echo: true
floats = [1.2, 3.4, 0.3, 1.0, 3.2]
len(floats)
```

## Write a function

Its name is `sum_all` that takes a list of `values` as an argument.
It runs a loop that iterates through the number in `values` summing all numbers.
It returns the sum of all numbers in `values`.
HINT: a) create a variable that accumulate the sum and b) use `while`.

Name your file `sum_list.py` and submit to Gradescope.

```{python}
#| eval: false
#| echo: true
assert sum_all([2, 2, 2]) == 6
assert sum_all([1, 2, 1, 1]) == 5
assert sum_all([]) == 0
```


## Write a function -- solution

Add test cases to the solution below:

```{python}
#| eval: true
#| echo: true
def sum_all(values):
  total = 0
  index = 0
  while index < len(values):
    total += values[index]
    index += 1
  return total

def main():
  assert sum_all([2, 2, 2]) == 6
  assert sum_all([1, 2, 1, 1]) == 5
  assert sum_all([]) == 0
    
main()
```

## Loop Table

We start with `index = 0` and `total = 0`:
```{python}
#| eval: false
#| echo: true
sum_all([2, 1, 5, 2, 3])
```

```{r}
#| eval: true
#| echo: false
#| warning: false
#| message: false
library(knitr)
library(tidyverse)
data.frame(index = c(0:5),
           condition = c("True", "True", "True", "True",
                                               "True", "False"),
           `item` = c("2", "1", "5", "2", "3", "-"),
           total = c("0 + 2 = 2", "2 + 1 = 3", "3 + 5 = 8",
                     "8 + 2 = 10", "10 + 3 = 13", "13")
                    ) %>% 
  kable(col.names = c("index", "index < len(values)", "values[index]", "total"))
```

## Loop Table

Start with `index = 0` and `total = 0`:
```{python}
#| eval: false
#| echo: true
sum_all([2, 1, 3, 4])
```

```{r}
#| eval: true
#| echo: false
#| warning: false
#| message: false
data.frame(index = c("|", "| ", "| ", "| ",
                                               "| ", "| "),
           condition = c(" ", " ", " ", " ",
                                               " ", " "),
           `item` = c(" ", " ", " ", " ", " ", " "),
           total = c(" ", " ", " ",
                     " ", " ", " ")
                    ) %>% 
  kable(col.names = c("index", "index < len(values)", "values[index]", "total"))
```

## Loop Table -- solution

```{python}
#| eval: false
#| echo: true
sum_all([2, 1, 3, 4])
```

```{r}
#| eval: true
#| echo: false
#| warning: false
#| message: false
data.frame(index = c(0:4),
           condition = c("True", "True", "True", "True",
                                               "False"),
           `item` = c("2", "1", "3", "4", "-"),
           total = c("2", "3", "6",
                     "10", "10")
                    ) %>% 
  kable(col.names = c("index", "index < len(numbers)", "numbers[index]", "total"))
```

# Python Tutor

You can also visualize code in python on [Python Tutor](https://pythontutor.com/visualize.html#mode=edit)

## Using a control variable

Remember how to get the max of three numbers?

```{python}
#| eval: true
#| echo: true
def max3(x, y, z):
  max = x # assume max is first number
  if y > max:
    max = y # assumption is incorrect, assume y is max
  if z > max:
    max = z # assumption is incorrect, z is max
  return max

def main():
  print( max3(1, 2, 2) ) # 2
  
main()
```

Adapt this function (`max_list`) to take a list of numbers (for example `[1, 2, 2, 1, 3, 1, 1]`) instead of three numbers (use `while`). 

## Max of list -- solution

```{python}
#| eval: true
#| echo: true
def max_list(numbers):
  '''
  Given a list of number, this function returns the highest number.
  Args:
    List of numeric values
  Returns:
    Max (float or integer, whatever value type is the highest)
  '''
  max = numbers[0]
  index = 1
  while index < len(numbers):
    if numbers[index] > max:
      max = numbers[index]
    index += 1
  return max

def main():
  print( max_list([1, 2, 2, 1, 3, 1, 1]) ) # 3
  print( max_list([3, 2, 2, 1, 0, 1, 1]) ) # 3
  
main()
```

## Loop table

We start with `index = 1` and `max = 2`:
```{python}
#| eval: false
#| echo: true
max_list([2, 1, 3, 1])
```

```{r}
#| eval: true
#| echo: false
#| warning: false
#| message: false
data.frame(index = c("|", "| ", "| ", "| ",
                                               "| ", "| "),
           condition = c(" ", " ", " ", " ",
                                               " ", " "),
           `item` = c(" ", " ", " ", " ", " ", " "),
           total = c(" ", " ", " ",
                     " ", " ", " ")
                    ) %>% 
  kable(col.names = c("index", "index < len(numbers)", "numbers[index]", "max"))
```

## Loop table -- solution

We start with `index = 1` and `max = 2`:
```{python}
#| eval: false
#| echo: true
max_list([2, 1, 3, 1])
```

```{r}
#| eval: true
#| echo: false
#| warning: false
#| message: false
data.frame(index = c(1:4),
           condition = c("True", "True", "True", "False"),
           `item` = c("1", "3", "1", "-"),
            max = c("2", "3", "3", "3")) %>% 
  kable(col.names = c("index", "index < len(numbers)", "numbers[index]", "max"))
```

## Max solution

-   What about empty lists?
-   How to get the min instead?

```{python}
#| eval: false
#| echo: true
assert max_list([]) == None
assert max_list([2, 1, 3, 1]) == 3
```

## Max solution - empty lists

```{python}
#| eval: true
#| echo: true
def max_list(numbers):
  max = None
  index = 0
  while index < len(numbers):
    if max == None or numbers[index] > max:
      max = numbers[index]
    index += 1
  return max

def main():
  print( max_list([2, 1, 3, 1]) ) # 3
  print( max_list([]) ) # None

main()
```


## Write a function

Its name is `double` that takes a list of numeric variables as argument.
It iterates over the list (use `while`) doubling (multiplying by two) each value in the list.
It returns the modified list.

Name your file `double.py` and submit it to gradescope.


```{python}
#| eval: false
#| echo: true
assert double([0, 1, 2, 3]) == [0, 2, 4, 6]
```

## Write a function -- solution

```{python}
#| eval: false
#| echo: true
def double(numbers):
  index = 0
  while index < len(numbers):
    numbers[index] *= 2
    index += 1
  return numbers

def main():
  original_list = [0, 1, 2, 3]
  new_list = double(original_list)
  assert original_list == new_list
  assert original_list == [0, 2, 4, 6]
  
  print("Passed all tests")
  
main()
```


## Slicing lists

* Range -- `list[2:4]`
* Whole list -- `list[:]`
* Everything but last character -- `list[:-1]`

The same slicing can be done with strings