- Try Free Course
###### Already a student? Login

In this lesson, we'll get some more practice with partial derivatives.

In our explanation of derivatives, we discussed how taking the derivative of multivariable functions is similar to taking the derivatives of single variable functions like $f(x)$. In the first section we'll work up to taking the partial derivative of the multilinear function $ f(x,y) = 3xy $. Here's what the function looks like in a 3d graph.

Before we get there, let's first just first break this function down into it's equivalent of different slices, like we have done previously. We'll do this by taking different slices of the function, stepping through various values of $y$. So instead of considering the entire function, $f(x, y) = 3xy $ we can think about the function $f(x, y)$ evaluated at various points, where $y = 1$, $y = 3$, $y = 6$, and $y = 9$.

Write out Python functions that return the values $f(x, y)$ for $f(x, 1)$, $f(x, 3)$, $f(x, 6)$, and $f(x, 9)$ for the function $f(x, y) = 3xy $.

```
def three_x_y_at_one(x):
pass
def three_x_y_at_three(x):
pass
def three_x_y_at_six(x):
pass
def three_x_y_at_nine(x):
pass
```

```
three_x_y_at_one(3) # 9
three_x_y_at_three(3)# 27
three_x_y_at_six(1) # 18
three_x_y_at_six(2) # 36
```

Now that we have our functions written, we can write functions that provided an argument of `x_values`

, return the associated `y_values`

that our four functions return.

```
zero_to_ten = list(range(0, 11))
zero_to_four = list(range(0, 5))
def y_values_for_at_one(x_values):
pass
def y_values_for_at_three(x_values):
pass
def y_values_for_at_six(x_values):
pass
def y_values_for_at_nine(x_values):
pass
```

```
y_values_for_at_one(zero_to_four) # [0, 3, 6, 9, 12]
y_values_for_at_one(zero_to_ten) # [0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30]
y_values_for_at_three(zero_to_four) # [0, 9, 18, 27, 36]
y_values_for_at_three(zero_to_ten) # [0, 9, 18, 27, 36, 45, 54, 63, 72, 81, 90]
y_values_for_at_six(zero_to_four) # [0, 18, 36, 54, 72]
y_values_for_at_six(zero_to_ten) # [0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180]
y_values_for_at_nine(zero_to_four) # [0, 27, 54, 81, 108]
y_values_for_at_nine(zero_to_ten) #[0, 27, 54, 81, 108, 135, 162, 189, 216, 243, 270]
```

Now we are ready to plot the function $f(x) = x $, $f(x) = 3x $, $f(x) = 6x $ and $f(x) = 9x $

```
from graph import trace_values
y_at_one_trace = trace_values(zero_to_ten, y_values_for_at_one(zero_to_ten), mode = 'lines', name = 'f(x, y) at y=1') or {}
y_at_three_trace = trace_values(zero_to_ten, y_values_for_at_three(zero_to_ten), mode = 'lines', name = 'f(x, y) at y=3') or {}
y_at_six_trace = trace_values(zero_to_ten, y_values_for_at_six(zero_to_ten), mode = 'lines', name = 'f(x, y) at y=6') or {}
y_at_nine_trace = trace_values(zero_to_ten, y_values_for_at_nine(zero_to_ten), mode = 'lines', name = 'f(x, y) at y=9') or {}
```

```
import plotly
from plotly.graph_objs import Scatter, Layout
from plotly.offline import init_notebook_mode, iplot
from IPython.display import display, HTML
init_notebook_mode(connected=True)
fig_constants_lin_functions = {
"data": [y_at_one_trace, y_at_three_trace, y_at_six_trace, y_at_nine_trace],
"layout": Layout(title="constants with linear functions")
}
plotly.offline.iplot(fig_constants_lin_functions)
```

So as you can see, plotting our multivariable $f(x, y)$ at different values of $y$ above lines up conceptually to having one plot step through these values of $y$.

So in the above section, we saw how we can think of representing our multivariable functions as a function evaluated at different value of $y$.

```
plotly.offline.iplot(fig_constants_lin_functions)
```

Now let's think of how to take the derivative of our $ \frac{\partial f}{\partial x} f(x, y)$ at values of $y$. Knowing how to think about partial derivatives of multivariable functions, what is $ \frac{\partial f}{\partial x} $ at the following values of $y$.

```
def df_dx_when_y_equals_one():
pass
```

```
def df_dx_when_y_equals_three():
pass
```

```
def df_dx_when_y_equals_six():
pass
```

```
def df_dx_when_y_equals_nine():
pass
```

So notice that there is a pattern here, in taking $ \frac{\partial f}{\partial x}$ for our function $f(x, y) = 3xy$. Now write a function that calculates $ \frac{\partial f}{\partial x}$ for our function $f(x,y)$ at any provided $x$ and $y$ value.

```
def df_dx_3xy(x_value, y_value):
pass
```

```
df_dx_3xy(2, 1) # 3
```

```
df_dx_3xy(2, 2) # 6
```

```
df_dx_3xy(5, 2) # 6
```

So as you can see, our $y$ value influences the function, and from there it's a calculation of how $f$ changes with $x$, which, in this case, is constant.

Now let's consider the function $ f(x, y) = 4x^2y + 3x + y$. Now soon we will want to take the derivative of this function with respect to $x$. We know that in doing something like that, we will need to translate this function into code, and that when we do so, we will need to capture the exponent of any terms as well as.

Remember that the way we expressed a single variable function, $f(x)$ in Python was to represent the constant, and $x$ exponent for each term. For example, the function $f(x) = 3x^2 + 2x$ can be represented as the following:

```
three_x_squared_plus_two_x = [(3, 2), (2, 1)]
```

Now let's talk about representing our multivariable function $ f(x, y) =4x^2y + 3x + y$ in Python. Instead of using a tuple with two elements, we'll use a tuple with three elements and with that third element the exponent related to the $y$ variable. So our function $ f(x, y) = 4x^2y + 3x + y$ looks like the following:

```
four_x_squared_y_plus_three_x_plus_y = [(4, 2, 1), (3, 1, 0), (1, 0, 1)]
```

Let's get started by writing a function `multivariable_output_at`

that takes in a multivariable function and returns the value $f(x, y)$ evaluated at a specific value of $x$ and $y$ for the function.

```
def multivariable_output_at(list_of_terms, x_value, y_value):
pass
```

```
multivariable_output_at(four_x_squared_y_plus_three_x_plus_y, 1, 1) # 8
```

```
multivariable_output_at(four_x_squared_y_plus_three_x_plus_y, 2, 2) # 40
```

Let's also try this with another function $g(x, y) = 2x^3y + 3yx + x $.

```
two_x_cubed_y_plus_three_y_x_plus_x = [(2, 3, 1), (3, 1, 1), (1, 1, 0)]
```

```
multivariable_output_at(two_x_cubed_y_plus_three_y_x_plus_x, 1, 1) # 6
```

```
multivariable_output_at(two_x_cubed_y_plus_three_y_x_plus_x, 2, 2) # 46
```

So now we want to write a Python function that calculates $\frac{\partial f}{\partial x}$ of a multivariable function. Let's start by writing a function that just calculates $\frac{\partial f}{\partial x}$ of a single term.

```
def term_df_dx(term):
pass
```

```
four_x_squared_y = (4, 2, 1)
term_df_dx(four_x_squared_y) # (8, 1, 1)
```

This solution represents $8xy$

```
y = (1, 0, 1)
term_df_dx(y) # (0, -1, 1)
```

This solution represents $0$, as the first element indicates we are multiplying the term by zero.

Now write a function that finds the derivative of all terms, $\frac{\partial f}{\partial x}$ of a function $f(x, y)$.

```
def df_dx(list_of_terms):
pass
```

```
df_dx(four_x_squared_y_plus_three_x_plus_y) # [(8, 1, 1), (3, 0, 0)]
```

Now that we have done this for $\frac{\partial f}{\partial x}$, lets work on taking the derivative $\frac{\partial f}{\partial y}$. Once again, we can use as an example our function $ f(x, y) = 4x^2y + 3x + y$. Let's start with writing the function `term_df_dy`

, which takes the partial derivative $\frac{\partial f}{\partial y}$ of a single term.

```
def term_df_dy(term):
pass
```

```
four_x_squared_y # (4, 2, 1)
```

```
term_df_dy(four_x_squared_y) # (4, 2, 0)
```

This represents that $\frac{\partial f}{\partial y}4x^2y = 4x^2$

```
term_df_dy(y) # (1, 0, 0)
```

This represents that $\frac{\partial f}{\partial y}y = 1$

```
three_x = four_x_squared_y_plus_three_x_plus_y[1]
term_df_dy(three_x) # (0, 1, -1)
```

This represents that $\frac{\partial f}{\partial y}3x = 0$

Now let's write a function `df_dy`

that takes multiple terms and returns an list of tuples that represent the derivative of our multivariable function. So here is our function: $ f(x, y) = 4x^2y + 3x + y$.

```
four_x_squared_y_plus_three_x_plus_y
```

```
def df_dy(list_of_terms):
pass
```

```
df_dy(four_x_squared_y_plus_three_x_plus_y) # [(4, 2, 0), (1, 0, 0)]
```

```
two_x_cubed_y_plus_three_y_x_plus_x = [(2, 3, 1), (3, 1, 1), (1, 1, 0)]
df_dy(two_x_cubed_y_plus_three_y_x_plus_x) # [(2, 3, 0), (3, 1, 0)]
```

Great job! Hopefully, now you understand a little more about multivariable functions and derivatives!

Unlock your future in tech

Learn to code.