In [1]:

```
# Set up packages for lecture. Don't worry about understanding this code, but
# make sure to run it if you're following along.
import numpy as np
import babypandas as bpd
import pandas as pd
from matplotlib_inline.backend_inline import set_matplotlib_formats
import matplotlib.pyplot as plt
set_matplotlib_formats("svg")
plt.style.use('ggplot')
plt.rcParams['figure.figsize'] = (10, 5)
np.set_printoptions(threshold=20, precision=2, suppress=True)
pd.set_option("display.max_rows", 7)
pd.set_option("display.max_columns", 8)
pd.set_option("display.precision", 2)
from IPython.display import display, IFrame
def show_def():
src = "https://docs.google.com/presentation/d/e/2PACX-1vRKMMwGtrQOeLefj31fCtmbNOaJuKY32eBz1VwHi_5ui0AGYV3MoCjPUtQ_4SB1f9x4Iu6gbH0vFvmB/embed?start=false&loop=false&delayms=60000&rm=minimal"
width = 960
height = 569
display(IFrame(src, width, height))
```

- Functions.
- Applying functions to DataFrames.
- Example: Student names.

** Reminder:** Use the DSC 10 Reference Sheet.

- We've learned how to do quite a bit in Python:
- Manipulate arrays, Series, and DataFrames.
- Perform operations on strings.
- Create visualizations.

- But so far, we've been restricted to using existing functions (e.g.
`max`

,`np.sqrt`

,`len`

) and methods (e.g.`.groupby`

,`.assign`

,`.plot`

).

Suppose you drive to a restaurant 🥘 in LA, located exactly 100 miles away.

- For the first 50 miles, you drive at 80 miles per hour.
- For the last 50 miles, you drive at 60 miles per hour.

**Question**: What is your**average speed**throughout the journey?

$$\text{average speed} = \frac{\text{total distance}}{\text{total time}} = \frac{50 + 50}{\text{time}_1 + \text{time}_2} \text{ miles per hour}$$

In segment 1, when you drove 50 miles at 80 miles per hour, you drove for $\frac{50}{80}$ hours:

$$\text{speed}_1 = \frac{\text{distance}_1}{\text{time}_1}$$
$$80 \text{ miles per hour} = \frac{50 \text{ miles}}{\text{time}_1} \implies \text{time}_1 = \frac{50}{80} \text{ hours}$$

Then,

$$\text{average speed} = \frac{50 + 50}{\frac{50}{80} + \frac{50}{60}} \text{ miles per hour} $$
$$\begin{align*}\text{average speed} &= \frac{50}{50} \cdot \frac{1 + 1}{\frac{1}{80} + \frac{1}{60}} \text{ miles per hour} \\ &= \frac{2}{\frac{1}{80} + \frac{1}{60}} \text{ miles per hour} \end{align*}$$

The **harmonic mean** ($\text{HM}$) of two positive numbers, $a$ and $b$, is defined as

It is often used to find the average of multiple **rates**.

Finding the harmonic mean of 80 and 60 is not hard:

In [2]:

```
2 / (1 / 80 + 1 / 60)
```

Out[2]:

68.57142857142857

**This would require a lot of copy-pasting, which is prone to error.**

**define** our own "harmonic mean" **function** just once, and re-use it multiple times.

In [3]:

```
def harmonic_mean(a, b):
return 2 / (1 / a + 1 / b)
```

In [4]:

```
harmonic_mean(80, 60)
```

Out[4]:

68.57142857142857

In [5]:

```
harmonic_mean(20, 40)
```

Out[5]:

26.666666666666664

Note that we only had to specify how to calculate the harmonic mean once!

Functions are a way to divide our code into small subparts to prevent us from writing repetitive code. Each time we **define** our own function in Python, we will use the following pattern.

In [6]:

```
show_def()
```

- Functions take in inputs, known as
**arguments**, do something, and produce some outputs. - The beauty of functions is that
**you don't need to know how they are implemented in order to use them!**- For instance, you've been using the function
`bpd.read_csv`

without knowing how it works. - This is the premise of the idea of
**abstraction**in computer science – you'll hear a lot about this if you take DSC 20.

- For instance, you've been using the function

In [7]:

```
harmonic_mean(20, 40)
```

Out[7]:

26.666666666666664

In [8]:

```
harmonic_mean(79, 894)
```

Out[8]:

145.17163412127442

In [9]:

```
harmonic_mean(-2, 4)
```

Out[9]:

-8.0

`triple`

has one **parameter**, `x`

.

In [10]:

```
def triple(x):
return x * 3
```

When we call `triple`

with the **argument** 5, within the body of `triple`

, `x`

means 5.

In [11]:

```
triple(5)
```

Out[11]:

15

We can change the argument we call `triple`

with – we can even call it with strings!

In [12]:

```
triple(7 + 8)
```

Out[12]:

45

In [13]:

```
triple('triton')
```

Out[13]:

'tritontritontriton'

The names you choose for a function’s parameters are only known to that function (known as **local scope**). The rest of your notebook is unaffected by parameter names.

In [14]:

```
def triple(x):
return x * 3
```

In [15]:

```
triple(7)
```

Out[15]:

21

`x`

*outside* of the body of `triple`

, our notebook doesn't know what `x`

means.

In [16]:

```
x
```

We can define an `x`

outside of the body of `triple`

, but that doesn't change how `triple`

works.

In [ ]:

```
x = 15
```

In [ ]:

```
# When triple(12) is called, you can pretend
# there's an invisible line inside the body of x
# that says x = 12.
# The x = 15 above is ignored.
triple(12)
```

Functions can have any number of arguments. So far, we've created a function that takes two arguments, `harmonic_mean`

, and a function that takes one argument, `triple`

.

`greeting`

takes no arguments!

In [17]:

```
def greeting():
return 'Hi! 👋'
```

In [18]:

```
greeting()
```

Out[18]:

'Hi! 👋'

The body of a function is not run until you use (**call**) the function.

Here, we can define `where_is_the_error`

without seeing an error message.

In [19]:

```
def where_is_the_error(something):
'''You can describe your function within triple quotes. For example, this function
illustrates that errors don't occur until functions are executed (called).'''
return (1 / 0) + something
```

It is only when we **call** `where_is_the_error`

that Python gives us an error message.

In [20]:

```
where_is_the_error(5)
```

`first_name`

¶Let's create a function called `first_name`

that takes in someone's full name and returns their first name. Example behavior is shown below.

```
>>> first_name('Pradeep Khosla')
'Pradeep'
```

*Hint*: Use the string method `.split`

.

General strategy for writing functions:

- First, try and get the behavior to work on a single example.
- Then, encapsulate that behavior inside a function.

In [21]:

```
'Pradeep Khosla'.split(' ')[0]
```

Out[21]:

'Pradeep'

In [22]:

```
def first_name(full_name):
'''Returns the first name given a full name.'''
return full_name.split(' ')[0]
```

In [23]:

```
first_name('Pradeep Khosla')
```

Out[23]:

'Pradeep'

In [24]:

```
# What if there are three names?
first_name('Chancellor Pradeep Khosla')
```

Out[24]:

'Chancellor'

- The
`return`

keyword specifies what the output of your function should be, i.e. what a call to your function will evaluate to. - Most functions we write will use
`return`

, but using`return`

is not strictly required.**If you want to be able to save the output of your function to a variable, you must use**`return`

!

- Be careful:
`print`

and`return`

work differently!

In [25]:

```
def pythagorean(a, b):
'''Computes the hypotenuse length of a triangle with legs a and b.'''
c = (a ** 2 + b ** 2) ** 0.5
print(c)
```

In [26]:

```
x = pythagorean(3, 4)
```

5.0

In [27]:

```
# No output – why?
x
```

In [28]:

```
# Errors – why?
x + 10
```

In [29]:

```
def better_pythagorean(a, b):
'''Computes the hypotenuse length of a triangle with legs a and b,
and actually returns the result.
'''
c = (a ** 2 + b ** 2) ** 0.5
return c
```

In [30]:

```
x = better_pythagorean(3, 4)
x
```

Out[30]:

5.0

In [31]:

```
x + 10
```

Out[31]:

15.0

Once a function executes a `return`

statement, it stops running.

In [32]:

```
def motivational(quote):
return 0
print("Here's a motivational quote:", quote)
```

In [33]:

```
motivational('Fall seven times and stand up eight.')
```

Out[33]:

0

The DataFrame `roster`

contains the names and lecture sections of all students enrolled in DSC 10 this quarter. The first names are real, while the last names have been anonymized for privacy.

In [34]:

```
roster = bpd.read_csv('data/roster-anon.csv')
roster
```

Out[34]:

name | section | |
---|---|---|

0 | Kavya Fquroe | 10AM |

1 | Victoria Yppmzx | 10AM |

2 | An-Chi Tmbqlr | 8AM |

... | ... | ... |

522 | Mehri Osrvjq | 9AM |

523 | Noah Byphhr | 9AM |

524 | Emily Hchqii | 9AM |

525 rows × 2 columns

What is the most common first name among DSC 10 students? (Any guesses?)

In [35]:

```
roster
```

Out[35]:

name | section | |
---|---|---|

0 | Kavya Fquroe | 10AM |

1 | Victoria Yppmzx | 10AM |

2 | An-Chi Tmbqlr | 8AM |

... | ... | ... |

522 | Mehri Osrvjq | 9AM |

523 | Noah Byphhr | 9AM |

524 | Emily Hchqii | 9AM |

525 rows × 2 columns

**Problem**: We can't answer that right now, since we don't have a column with first names. If we did, we could group by it.

**Solution**: Use our function that extracts first names on*every*element of the`'name'`

column.

`first_name`

function¶Somehow, we need to call `first_name`

on every student's `'name'`

.

In [36]:

```
roster
```

Out[36]:

name | section | |
---|---|---|

0 | Kavya Fquroe | 10AM |

1 | Victoria Yppmzx | 10AM |

2 | An-Chi Tmbqlr | 8AM |

... | ... | ... |

522 | Mehri Osrvjq | 9AM |

523 | Noah Byphhr | 9AM |

524 | Emily Hchqii | 9AM |

525 rows × 2 columns

In [37]:

```
roster.get('name').iloc[0]
```

Out[37]:

'Kavya Fquroe'

In [38]:

```
first_name(roster.get('name').iloc[0])
```

Out[38]:

'Kavya'

In [39]:

```
first_name(roster.get('name').iloc[1])
```

Out[39]:

'Victoria'

Ideally, there's a better solution than doing this hundreds of times...

`.apply`

¶- To
**apply**the function`func_name`

to every element of column`'col'`

in DataFrame`df`

, use

`df.get('col').apply(func_name)`

- The
`.apply`

method is a**Series**method.**Important**: We use`.apply`

on Series,**not**DataFrames.- The output of
`.apply`

is also a Series.

- Pass
*just the name*of the function – don't call it!- Good ✅:
`.apply(first_name)`

. - Bad ❌:
`.apply(first_name())`

.

- Good ✅:

In [40]:

```
roster.get('name')
```

Out[40]:

0 Kavya Fquroe 1 Victoria Yppmzx 2 An-Chi Tmbqlr ... 522 Mehri Osrvjq 523 Noah Byphhr 524 Emily Hchqii Name: name, Length: 525, dtype: object

In [41]:

```
roster.get('name').apply(first_name)
```

Out[41]:

0 Kavya 1 Victoria 2 An-Chi ... 522 Mehri 523 Noah 524 Emily Name: name, Length: 525, dtype: object

In [42]:

```
roster = roster.assign(
first=roster.get('name').apply(first_name)
)
roster
```

Out[42]:

name | section | first | |
---|---|---|---|

0 | Kavya Fquroe | 10AM | Kavya |

1 | Victoria Yppmzx | 10AM | Victoria |

2 | An-Chi Tmbqlr | 8AM | An-Chi |

... | ... | ... | ... |

522 | Mehri Osrvjq | 9AM | Mehri |

523 | Noah Byphhr | 9AM | Noah |

524 | Emily Hchqii | 9AM | Emily |

525 rows × 3 columns

Now that we have a column containing first names, we can find the **distribution** of first names.

In [43]:

```
name_counts = (
roster
.groupby('first')
.count()
.sort_values('name', ascending=False)
.get(['name'])
)
name_counts
```

Out[43]:

name | |
---|---|

first | |

Kevin | 7 |

Daniel | 6 |

Ryan | 6 |

... | ... |

Hengyu | 1 |

Heeju | 1 |

Zubin | 1 |

438 rows × 1 columns

Below:

- Create a
**bar chart**showing the number of students with each first name, but only include first names shared by at least two students. - Determine the
**proportion**of students in DSC 10 who have a first name that is shared by at least two students.

*Hint*: Start by defining a DataFrame with only the names in `name_counts`

that appeared at least twice. You can use this DataFrame to answer both questions.

shared_names = name_counts[name_counts.get('name') >= 2] # Bar chart. shared_names.sort_values('name').plot(kind='barh', y='name'); # Proportion = # students with a shared name / total # of students. shared_names.get('name').sum() / roster.shape[0]

In [44]:

```
...
```

Out[44]:

Ellipsis

In [45]:

```
...
```

Out[45]:

Ellipsis

`.apply`

works with built-in functions, too!¶In [46]:

```
name_counts.get('name')
```

Out[46]:

first Kevin 7 Daniel 6 Ryan 6 .. Hengyu 1 Heeju 1 Zubin 1 Name: name, Length: 438, dtype: int64

In [47]:

```
# Not necessarily meaningful, but doable.
name_counts.get('name').apply(np.log)
```

Out[47]:

first Kevin 1.95 Daniel 1.79 Ryan 1.79 ... Hengyu 0.00 Heeju 0.00 Zubin 0.00 Name: name, Length: 438, dtype: float64

In `name_counts`

, first names are stored in the index, which is **not** a Series. This means we can't use `.apply`

on it.

In [48]:

```
name_counts.index
```

Out[48]:

Index(['Kevin', 'Daniel', 'Ryan', 'Matthew', 'Eric', 'Brian', 'Nathan', 'Jennifer', 'Karina', 'Andrew', ... 'Isaac', 'Ifra', 'Hyunbin', 'Huiting', 'Hongyu', 'Hien', 'Henry', 'Hengyu', 'Heeju', 'Zubin'], dtype='object', name='first', length=438)

In [49]:

```
name_counts.index.apply(max)
```

`.reset_index()`

to turn the index of a DataFrame into a column, and to reset the index back to the default of 0, 1, 2, 3, and so on.

In [50]:

```
# What is the max of an individual string?
name_counts.reset_index().get('first').apply(max)
```

Out[50]:

0 v 1 n 2 y .. 435 y 436 u 437 u Name: first, Length: 438, dtype: object

- Suppose you're one of the $\approx$27\% of students in DSC 10 who has a first name that is shared with at least one other student.
- Let's try and determine whether someone
**in your lecture section**shares the same first name as you.- For example, maybe
`'Kavya Fquroe'`

wants to see if there's another`'Kavya'`

in their section.

- For example, maybe

Strategy:

- Which section is
`'Kavya Fquroe'`

in? - How many people in that section have a first name of
`'Kavya'`

?

In [51]:

```
roster
```

Out[51]:

name | section | first | |
---|---|---|---|

0 | Kavya Fquroe | 10AM | Kavya |

1 | Victoria Yppmzx | 10AM | Victoria |

2 | An-Chi Tmbqlr | 8AM | An-Chi |

... | ... | ... | ... |

522 | Mehri Osrvjq | 9AM | Mehri |

523 | Noah Byphhr | 9AM | Noah |

524 | Emily Hchqii | 9AM | Emily |

525 rows × 3 columns

In [52]:

```
which_section = roster[roster.get('name') == 'Kavya Fquroe'].get('section').iloc[0]
which_section
```

Out[52]:

'10AM'

In [53]:

```
first_cond = roster.get('first') == 'Kavya' # A Boolean Series!
section_cond = roster.get('section') == which_section # A Boolean Series!
how_many = roster[first_cond & section_cond].shape[0]
how_many
```

Out[53]:

1

`shared_first_and_section`

¶Let's create a function named `shared_first_and_section`

. It will take in the **full name** of a student and return **the number** of students in their section with the same first name and section (including them).

*Note*: This is the first function we're writing that involves using a DataFrame within the function – this is fine!

In [54]:

```
def shared_first_and_section(name):
# First, find the row corresponding to that full name in roster.
# We're assuming that full names are unique.
row = roster[roster.get('name') == name]
# Then, get that student's first name and section.
first = row.get('first').iloc[0]
section = row.get('section').iloc[0]
# Now, find all the students with the same first name and section.
shared_info = roster[(roster.get('first') == first) & (roster.get('section') == section)]
# Return the number of such students.
return shared_info.shape[0]
```

In [55]:

```
shared_first_and_section('Kavya Fquroe')
```

Out[55]:

1

In [56]:

```
# This means that there are 4 Kevins, including Kevin Pxssmm, in whichever section Kevin Pxssmm is in!
shared_first_and_section('Kevin Pxssmm')
```

Out[56]:

4

Now, let's add a column to `roster`

that contains the values returned by `shared_first_and_section`

.

In [57]:

```
roster = roster.assign(shared=roster.get('name').apply(shared_first_and_section))
roster
```

Out[57]:

name | section | first | shared | |
---|---|---|---|---|

0 | Kavya Fquroe | 10AM | Kavya | 1 |

1 | Victoria Yppmzx | 10AM | Victoria | 1 |

2 | An-Chi Tmbqlr | 8AM | An-Chi | 1 |

... | ... | ... | ... | ... |

522 | Mehri Osrvjq | 9AM | Mehri | 1 |

523 | Noah Byphhr | 9AM | Noah | 1 |

524 | Emily Hchqii | 9AM | Emily | 1 |

525 rows × 4 columns

In [58]:

```
roster[(roster.get('shared') >= 2)].sort_values('shared', ascending=False)
```

Out[58]:

name | section | first | shared | |
---|---|---|---|---|

57 | Kevin Rqqbja | 9AM | Kevin | 4 |

332 | Kevin Wvghxc | 9AM | Kevin | 4 |

106 | Kevin Pxssmm | 9AM | Kevin | 4 |

... | ... | ... | ... | ... |

301 | Andrew Fukocl | 1PM | Andrew | 2 |

303 | Brian Riqekv | 9AM | Brian | 2 |

514 | Nathan Arlyoy | 1PM | Nathan | 2 |

50 rows × 4 columns

We can narrow this down to a particular lecture section if we'd like.

In [59]:

```
one_section_only = (
roster[(roster.get('shared') >= 2) &
(roster.get('section') == '1PM')]
.sort_values('shared', ascending=False)
)
one_section_only
```

Out[59]:

name | section | first | shared | |
---|---|---|---|---|

283 | Ryan Ozjjjx | 1PM | Ryan | 3 |

286 | Ryan Ohuhmg | 1PM | Ryan | 3 |

349 | Ryan Mhwpch | 1PM | Ryan | 3 |

... | ... | ... | ... | ... |

404 | Michael Qxcbll | 1PM | Michael | 2 |

472 | Jeremy Yktcwc | 1PM | Jeremy | 2 |

514 | Nathan Arlyoy | 1PM | Nathan | 2 |

15 rows × 4 columns

In [60]:

```
# All of the names shared by multiple students in the 1PM section.
one_section_only.get('first').unique()
```

Out[60]:

array(['Ryan', 'Pranav', 'Andrew', 'Peter', 'Nathan', 'Jeremy', 'Michael'], dtype=object)

While the DataFrames on the previous slide contain the info we were looking for, they're not organized very conveniently. For instance, there are three rows containing the fact that there are 3 Ryans in the 1PM lecture section.

Wouldn't it be great if we could create a DataFrame like the one below? We'll see how on Wednesday!

section | first | name | shared | |
---|---|---|---|---|

0 | 8AM | Daniel | 3 | 3 |

1 | 1PM | Danielle | 1 | 1 |

2 | 10AM | Eric | 2 | 2 |

3 | 10AM | Ethan | 3 | 3 |

4 | 10AM | Justin | 3 | 3 |

5 | 9AM | Kevin | 4 | 4 |

Find the longest first name in the class that is shared by at least two students in the same section.

*Hint*: You'll have to use both `.assign`

and `.apply`

.

with_len = roster.assign(name_len=roster.get('first').apply(len)) with_len[with_len.get('shared') >= 2].sort_values('name_len', ascending=False).get('first').iloc[0]

In [61]:

```
...
```

Out[61]:

Ellipsis

- Functions are a way to divide our code into small subparts to prevent us from writing repetitive code.
- The
`.apply`

method allows us to call a function on every single element of a Series, which usually comes from`.get`

ting a column of a DataFrame.

More advanced DataFrame manipulations!