> ## Content Index
> Fetch the complete content index at: https://www.bambooweekly.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Bamboo Weekly #41: Wine production (solutions)
- URL: https://www.bambooweekly.com/bw-41-wine-production-solution/
- Published: 2023-11-23T16:01:14.000Z
- Updated: 2026-08-23T09:37:01.000Z
- Description: Get better at: Excel files, regular expressions, filtering, grouping, plotting, pivot tables, cleaning
- Author: Reuven M. Lerner
- Tags: excel, regular-expressions, filtering, grouping, plotting, pivot-table, cleaning

### Black Friday

Remember, my Black Friday sale, with 25% off annual memberships to my community (just Python, or Python+Data), and 40% off my courses, continues. Learn more [https://lernerpython.com/bfcm-2023/](https://lernerpython.com/bfcm-2023/?ref=bambooweekly.com). But don’t delay, because these deals only last through Monday.

And now, back to our regularly scheduled solutions about wine.

![](https://storage.ghost.io/c/06/ba/06ba0cc0-be6f-4de7-af2f-5c20165279b9/content/images/image/fetch/f_auto,q_auto:good,fl_progressive:steep/https-3a-2f-2fsubstack-post-media.s3.amazonaws.com-2fpublic-2fimages-2f189ed769-4a5d-4ba6-8c24-eb4d6e2c1470_1024x1024.png)

Last summer, I heard a great [story on Marketplace](https://www.marketplace.org/2022/07/08/sour-grapes-an-english-countys-wine-wins-a-special-status-but-a-neighboring-county-complains/?ref=bambooweekly.com) about how England was now producing more and more wine. Now, England is many wonderful things — but the climate never struck me as appropriate for growing grapes, let alone wine-quality grapes. It turns out that as climate change raises temperatures around the world, the UK is increasingly suitable for vineyards.

Of course, this means that places which were previously suitable for growing grapes are finding it increasingly difficult to do so. That’s part of what the OIV, the French initials for the International Organization of Vine and Wine, reported recently about wine production around the world. Climate change is having a big effect on grapes, so much so that wine production in 2023 has been going down — and will likely be the lowest in 60 years. As they wrote, “Harvests have plummeted in the Southern Hemisphere and in some major countries due to the extreme climatic conditions.” You can read the full outlook for wine in 2023 here: [/content/files/sites/default/files/documents/oiv\_world\_wine\_production\_outlook\_2023.pdf](https://www.bambooweekly.com/content/files/sites/default/files/documents/oiv%5Fworld%5Fwine%5Fproduction%5Foutlook%5F2023.pdf)

Fortunately, the OIV’s data is available for download. And while we’re not going to look at all of their conclusions — especially since most data comes from before 2023 — we can definitely draw some interesting conclusions about the state of winemaking. Along the way, we’ll explore some of the most common and useful Pandas functionality having to do with grouping, joins, and pivot tables.

### Data and seven questions

As I mentioned, this week's questions comes from OIV, specifically, their full database. You can view it here:

[https://www.oiv.int/what-we-do/data-discovery-report?oiv](https://www.oiv.int/what-we-do/data-discovery-report?oiv&ref=bambooweekly.com)

I exported the data to Excel by clicking on the three dots in their viewer and choosing to export it to a file. With that in hand, I was able to start doing some analysis.

Here are the seven questions and tasks I gave you for this week. A link to download and view my Jupyter notebook follows the final solution, below.

### Download the English-language version of the report as an Excel file. Turn it into a data frame, keeping only the named columns and rows with actual data.

The first thing that I had to do was start up Pandas:

```
import pandas as pd
```

With that in place, I wanted to take the file (data.xlsx) and turn it into a data frame. On the one hand, this should be pretty straightforward, using the “[read\_excel](https://www.bambooweekly.com/pandas-read-excel/)” function that comes with Pandas:

```
filename = 'data.xlsx'

df = (
    pd
    .read_excel(filename)
)
```

However, there are some problems with this:

1. I got warnings when I tried to read the file with read\_excel. The import still worked, but it gave me weird warnings about formatting in the file. I investigated this a bit, and it seems that the Excel file had invisible formatting that Pandas wanted to warn me about. I found that making an invisible modification to the file, and then saving it, solved this issue. If you got the warning and are OK with seeing it, you can just ignore it, though.
2. I end up with a bunch of columns that I don’t want or need.
3. The final row of the file contains information about the export, and thus corrupts the data.

Let’s first remove the columns that we don’t need: I decided to use the “[filter](https://www.bambooweekly.com/pandas-filter/)” method, which lets me choose rows or columns based on the index or column names. I decided to use a [regular expression](https://regexpcrashcourse.com/?ref=bambooweekly.com), indicating that I want only those columns whose names contain alphanumeric characters and slashes, from the start to the end:

```
filename = 'data.xlsx'

df = (
    pd
    .read_excel(filename)
    .filter(regex='^[\w/]+$', axis='columns')
)
```

This gave me the columns I wanted, but I also wanted to remove the final two rows. (The final row has the export info, and the second-to-last row contains only NaN values.) I decided to use the “[iloc](https://www.bambooweekly.com/pandas-iloc/)” accessor, giving it a slice of \[:-2\], meaning that I want all of the rows in the data frame except for the final two.

The final query to load our data thus looks like this:

```
filename = 'data.xlsx'

df = (
    pd
    .read_excel(filename)
    .filter(regex='^[\w/]+$', axis='columns')
    .iloc[:-2]
)
```

The final data frame contains 52,795 rows and 7 columns.

### In how many ways is grape production measured? Which unit is used for wine?

What columns does our data frame contain? Let’s take a look:

- Continent
- Region/Country
- Product
- Variable
- Year
- Unit
- Quantity

When I saw this, I was a bit surprised to see that we’re using different units to measure things. At first, I thought that the different units were being used by different countries, sort of like the English system vs. the metric system. But it turns out that no, different products are measured in different ways.

We can get a complete list of the units, and how frequently they’re used, with “[value\_counts](https://www.bambooweekly.com/pandas-value-counts/)”. This is one of my favorite methods, which given a series (or a column) returns a new series whose index contains the unique values from the original series, and whose values contains integers, the number of times each of those values occurred.

To find out how often each of these measures is used, we can run value\_counts on the “Units” column:

```
df['Unit'].value_counts()
```

This is what we get back:

```
Unit
tonnes     32674
1000 hl    17531
ha          2590
Name: count, dtype: int64
```

The three measures are:

- tonnes (i.e., 1,000 kg), a measure of weight
- hectoliters, a unit of volume — and “hecto” always means 100 in the metric system, so this represents 100 liters
- ha, or hectares, where one hectare is 10,000 square meters — a unit of land.

It’s easy to see why these three different measures are used in this report. If you want to know how many grapes are being planted, you would measure it in hectares. If you want to know how many grapes were harvested, you would use tonnes. And if you want to know how much wine was produced, you would use hectoliters — or in our case, 1,000-hectoliter units.

By the way, most bottles of wine that I’ve seen have about 750 ml, aka 0.75 liters. So every 1,000 hectoliters would make about 133,000 bottles of wine.

Do we indeed see that wine is measured in hectoliters? Let’s ask our data frame: We’ll find all of the rows in which the product being measured is wine, and then we’ll run value\_counts on all of those rows. If they’re using different measurement units, then we’ll find out how often each is used. But if they’re all using 1,000-hl units, then we’ll see just one row:

```
df.loc[
    df['Product'] == 'Wine', 
    'Unit'
].value_counts()
```

Here, I’m using “[loc](https://www.bambooweekly.com/pandas-loc/)” in its two-argument form:

- The first argument is the row selector. Here, we’re providing a boolean series, the result of running a comparison between the “Product” column and the string “Wine”. Wherever this comparison returns True, we’ll get a row back from df.
- The second argument is the column selector. Here, we just want one column, “Unit”.

In other words, we want the “Unit” column from all rows in which the product is wine. We then run value\_counts on that column:

```
Unit
1000 hl    17531
Name: count, dtype: int64
```

Since the resulting series has a single item whose index is “1000 hl”, it would appear that wine is indeed always measured in 1,000 hl units. We can also see it as a percentage:

```
df.loc[df['Product'] == 'Wine', 'Unit'].value_counts(normalize=True)
```

The result, expressed as a percentage:

```
Unit
1000 hl    1.0
Name: proportion, dtype: float64
```

By the way, assuming that only a single unit of measure is used for each product, we can find out what that unit is by running it on a “[groupby](https://www.bambooweekly.com/pandas-groupby/)” query:

```
df.groupby('Product')['Unit'].value_counts()
```

The result:

```
Product       Unit   
Dried Grapes  tonnes     15249
Fresh Grapes  tonnes     11513
Table Grapes  tonnes      5912
Vineyard      ha          2590
Wine          1000 hl    17531
Name: count, dtype: int64
```

## Create a line graph showing total global wine production each year. Is 2023 really slated to be the lowest on record?

We don’t have all of the data that the OIV has at its disposal, so we can’t really decide if 2023 is going to be the worst. But let’s see what we can do with the current data, starting by selecting global wine production. In order to do that, we’ll need three boolean series (one for “Global”, another for “Wine”, and a third for “Production”), joined together with & (for “and”), and passed as a combined row selector to loc:

```
(
    df.loc[(df['Region/Country'] == 'Global') &
           (df['Variable'] == 'Production') &
           (df['Product'] == 'Wine')
    ]
)
```

We’ll now have only those rows having to do with global wine production. We want to create a data frame in which the rows are the years, so we’ll use “[set\_index](https://www.bambooweekly.com/pandas-set-index/)” to select the “Year” column:

```
(
    df.loc[(df['Region/Country'] == 'Global') &
           (df['Variable'] == 'Production') &
           (df['Product'] == 'Wine')
    ]
    .set_index('Year')
)
```

We’re only interested in the “Quantity” column, so we’ll use square brackets for that:

```
(
    df.loc[(df['Region/Country'] == 'Global') &
           (df['Variable'] == 'Production') &
           (df['Product'] == 'Wine')
    ]
    .set_index('Year')
    ['Quantity']
)
```

Finally, we’ll turn it into a line graph:

```
(
    df.loc[(df['Region/Country'] == 'Global') &
           (df['Variable'] == 'Production') &
           (df['Product'] == 'Wine')
    ]
    .set_index('Year')
    ['Quantity']
    .plot.line()
)
```

The result:

![](https://storage.ghost.io/c/06/ba/06ba0cc0-be6f-4de7-af2f-5c20165279b9/content/images/image/fetch/f_auto,q_auto:good,fl_progressive:steep/https-3a-2f-2fsubstack-post-media.s3.amazonaws.com-2fpublic-2fimages-2fa00cfc09-8b79-4620-a8ba-a931f670b549_578x432.jpg)

It’s probably a bit much to say that this will be the worst year on record, given what we saw in both 1995 and 2017\. And given that they said it would be the worst in several decades, it’s quite possible that I’m measuring the wrong thing. But we can see that after a small rise in 2020, things went down in 2021 and 2022 — and saying that things will be bad in 2023 might not be an exaggeration. Certainly, we’re nowhere close to the amount of production that we’ve seen multiple times in the last few decades.

## What 10 countries produced the greatest amount of wine in 2022?

Once again, we’re going to select for wine production in 2022\. But this time, we’re interested in each individual country’s production numbers, which means that we need to exclude the “Global” value in the “Country/Region” column.

Here’s how I started, using loc on df with four different parts to our row selector:

```
(
    df
    .loc[
        (df['Year'] == 2022) & 
        (df['Product'] == 'Wine') & 
        (df['Variable'] == 'Production') &
        (df['Region/Country'] != 'Global')
    ]
)
```

Remember that each of these comparisons produces a boolean series. When we use &, we tell Pandas to return a new series based on its two inputs, one in which we get False unless both of the inputs are True. Combining four series in this way, our resulting boolean series contains True whenever all four are True, and False otherwise.

We can apply it to df using loc, and thus get only those rows for non-global wine production in 2022.

Let’s then add a column selector to loc, to get only two columns: Region/Country and Quantity:

```
greatest_producers = (
    df
    .loc[
        (df['Year'] == 2022) & 
        (df['Product'] == 'Wine') & 
        (df['Variable'] == 'Production') &
        (df['Region/Country'] != 'Global'),
        ['Region/Country', 'Quantity']
    ]
)
```

Because we’re going to want to sort based on the country, we’ll use “[sort\_values](https://www.bambooweekly.com/pandas-sort-values/)” to get back a data frame with the same content as before, but with the values sorted from highest to lowest:

```
greatest_producers = (
    df
    .loc[
        (df['Year'] == 2022) & 
        (df['Product'] == 'Wine') & 
        (df['Variable'] == 'Production') &
        (df['Region/Country'] != 'Global'),
        ['Region/Country', 'Quantity']
    ]
    .set_index('Region/Country')
    .sort_values('Quantity', ascending=False)
)
```

Finally, I use “head” to get only the top 10 countries. I also stick the result into a variable, because we’ll be using these top-10 countries again in a little bit:

```
greatest_producers = (
    df
    .loc[
        (df['Year'] == 2022) & 
        (df['Product'] == 'Wine') & 
        (df['Variable'] == 'Production') &
        (df['Region/Country'] != 'Global'),
        ['Region/Country', 'Quantity']
    ]
    .set_index('Region/Country')
    .sort_values('Quantity', ascending=False)
    .head(10)
)

greatest_producers
```

The result:

```
Region/Country
Italy                       49843.0
France                      45616.0
Spain                       35703.0
United States of America    22385.0
Australia                   13070.0
Chile                       12443.0
Argentina                   11451.0
South Africa                10337.0
Germany                      8940.0
Portugal                     6848.0
Name: Quantity, dtype: float64
```

On the one hand, I’m not hugely surprised. On the other hand, Israel has tons of wineries, and we consume quite a bit of local wine. I didn’t expect Israel to be in the top 10… but where are we?

A bit of checking, and I found that Israel is at 31 in terms of world wine production. Which is … not that impressive, I guess, when you see that we produce less than half as much as Ukraine, and less than one-third as much as Moldova. I’m not trying to say anything about those countries and their wines, but I kinda, somehow thought that we were higher in rank. It’s so easy to be blind to the reality when you live in a small country. (And of course, you could make all sorts of arguments about quality, but those are definitely not mine to make…)

## Create a line plot showing the amount of wine produced in each country over the years; the years should be the X axis, the quantity should be the Y axis, and each country should be a different color. Only show the top 10 wine-producing countries that we previously found. Do we see a trend?

In order to produce such a line plot, I’ll need to have a data frame in which the rows represents countries, and the row index contains country names. The columns will need to contain years. Ignoring the requirement that we only look at top-10 wine-producing countries, how can we create such a data frame?

Let’s start by using loc to grab only those rows from df that talk about non-global wine production:

```
(
    df
    .loc[
        (df['Product'] == 'Wine') & 
        (df['Variable'] == 'Production') &
        (df['Region/Country'] != 'Global'),
    ]    
)
```

Next, we’ll use set\_index to take the “Region/Country” column and make it the index of our data frame:

```
(
    df
    .loc[
        (df['Product'] == 'Wine') & 
        (df['Variable'] == 'Production') &
        (df['Region/Country'] != 'Global'),
    ]    
    .set_index('Region/Country')
)
```

We’re now pretty close! We could now create a pivot table:

- index would be the unique values in the “Year” column
- columns would be the unique values in the “Region/Country” table
- values would be the “Quantity” for each year-country combination

Then we can plot it:

```
(
    df
    .loc[
        (df['Product'] == 'Wine') & 
        (df['Variable'] == 'Production') &
        (df['Region/Country'] != 'Global'),
    ]    
    .set_index('Region/Country')
    .pivot_table(index='Year', columns='Region/Country', values='Quantity')
    .plot.line()
)
```

The problem? We’ll get a line for every single country in the data set, which might be a bit crowded and hard to read:

![](https://storage.ghost.io/c/06/ba/06ba0cc0-be6f-4de7-af2f-5c20165279b9/content/images/image/fetch/f_auto,q_auto:good,fl_progressive:steep/https-3a-2f-2fsubstack-post-media.s3.amazonaws.com-2fpublic-2fimages-2f29ba5624-0b77-4366-8f7f-302058631317_569x1748.jpg)

Yeah, um, I think we should pare this down just a bit. But how?

One way would be to select only those countries that are in the index of our “greatest\_producers” data frame, thanks to the use of “[isin](https://www.bambooweekly.com/pandas-isin/)”:

```
(
    df
    .loc[
        (df['Product'] == 'Wine') & 
        (df['Variable'] == 'Production') &
        (df['Region/Country'].isin(greatest_producers.index))
    ]
    .set_index('Region/Country')
    .pivot_table(index='Year', columns='Region/Country', values='Quantity')
    .plot.line()
)
```

Here’s the plot created by this query:

![](https://storage.ghost.io/c/06/ba/06ba0cc0-be6f-4de7-af2f-5c20165279b9/content/images/image/fetch/f_auto,q_auto:good,fl_progressive:steep/https-3a-2f-2fsubstack-post-media.s3.amazonaws.com-2fpublic-2fimages-2fcea14fa6-c1ea-4168-8010-4c7d29a6d15a_569x432.jpg)

Another way to do this is by using “[join](https://www.bambooweekly.com/pandas-join/)”. Normally, we use join in order to combine values from two different data frames. And there’s nothing wrong with that! The two data frames are joined along their indexes — which means that if a name exists in one index but not the other, Pandas needs to make a choice.

Normally, the choice is to keep the name if it’s on the left, but not if it’s on the right. However, we can change that by specifying we want a “right” join, where the right-side (i.e., the data frame passed as an argument to “join”) determines what names are kept. If we do this, then only those countries named in “greatest\_producers” will be in the result:

```
(
    df
    .loc[ 
       (df['Product'] == 'Wine') & 
        (df['Variable'] == 'Production') &
        (df['Region/Country'] != 'Global'),
    ]    
    .set_index('Region/Country')
    .join(greatest_producers, how='right', rsuffix='_r')
    .pivot_table(index='Year', columns='Region/Country', values='Quantity')
    .plot.line()
)
```

If you’re wondering what the “rsuffix” keyword argument is, it’s because column names in Pandas must be unique. And when we join two data frames with identical column names, Pandas gives us an error. We can specify “lsuffix”, “rsuffix”, or both to tell Pandas what suffix (a string) should be added to columns that would otherwise clash. If there will be no clash, then you don’t have to pass either “lsuffix” or “rsuffix”.

The result of this query is identical to the previous one:

![](https://storage.ghost.io/c/06/ba/06ba0cc0-be6f-4de7-af2f-5c20165279b9/content/images/image/fetch/f_auto,q_auto:good,fl_progressive:steep/https-3a-2f-2fsubstack-post-media.s3.amazonaws.com-2fpublic-2fimages-2fb0fe51d6-85cd-4b34-8c05-e35e3142359a_569x432.jpg)

We can see that Italy, France, and Spain continue to produce (a lot) more wine than other countries. France seems to be heading up, at least from this data.

But we can also see that some southern-hemisphere countries, such as Argentina, Australia, and South Africa, have had a downturn in the last few years, as the OIV report said. The 2023 numbers might indeed point to an even steeper problem.

## Now create a line plot showing the mean amount of wine produced on each continent over the years. The years should be the X axis, the quantity should be the Y axis, and each continent should be a different color.

What if we look not at countries, but at continents? After we grab non-global wine production rows with loc, we can then create a pivot table:

- Index contains the unique values in the Year column
- Columns contain the unique values in the Continent column
- Values contains the mean of the values for every year-continent combination

How do we know that the pivot table will calculate the mean? Because that’s the default aggregation method used when creating a pivot table:

```
(
    df
    .loc[
        (df['Product'] == 'Wine') & 
        (df['Variable'] == 'Production') &
        (df['Region/Country'] != 'Global'),
    ]    
    .pivot_table(index='Year', columns='Continent', values='Quantity')
    .plot.line()
)
```

Here’s the line plot we get:

![](https://storage.ghost.io/c/06/ba/06ba0cc0-be6f-4de7-af2f-5c20165279b9/content/images/image/fetch/f_auto,q_auto:good,fl_progressive:steep/https-3a-2f-2fsubstack-post-media.s3.amazonaws.com-2fpublic-2fimages-2f44f462b8-3e1d-49b9-8c87-054719603be6_569x432.jpg)

This graph tells me three things:

1. Wow, African wine production has absolutely skyrocketed in the last few years. It’s now higher than anywhere else!
2. Oceania, aka Australia and New Zealand, have had quite a downturn, likely thanks in no small part to the climate issues we’ve been talking about.
3. If we want to look at South America as opposed to other continents, we can’t, because the data lumps North, Central, and South America into a single “America” continent. I’m not going to quibble with the geographic categories, but if we’re going to talk about the southern hemisphere, then we should probably have a way to break out that data, no?

## What countries import, on average, more wine than they export? What country is the greatest net importer of wine?

Finally, we have data on not just the production of wine, but also its import and export. I wanted to know which countries import more wine than they export.

To do this, we’ll need to create a data frame in which the rows are countries, and the columns are the mean amounts that each country imports and exports. We can do this with … a pivot table!

First, let’s grab only those rows where the product is wine and the “Variable” column is either “Imports” or “Exports”:

```
(
    df
    .loc[
        (df['Product'] == 'Wine') &
        (df['Variable'].isin(['Imports', 'Exports']))
    ]
)
```

Now we can create our pivot table:

- Index will be the Region/Country
- Columns will be the values in “Variable”
- Values will be the mean of “Quantity” for imports/exports in that country

```
(
    df
    .loc[
        (df['Product'] == 'Wine') &
        (df['Variable'].isin(['Imports', 'Exports']))
    ]
    .pivot_table(index='Region/Country', columns='Variable', values='Quantity')
)
```

I now have the data that I need! However, there are a lot of NaN values, thanks to 50 countries that don’t export wine at all. Let’s replace those NaN values with 0, thanks to “[fillna](https://www.bambooweekly.com/pandas-fillna/)”:

```
(
    df
    .loc[
        (df['Product'] == 'Wine') &
        (df['Variable'].isin(['Imports', 'Exports']))
    ]
    .pivot_table(index='Region/Country', columns='Variable', values='Quantity')
    .fillna(0)
)
```

Next, I can compute the difference between the columns using “[diff](https://www.bambooweekly.com/pandas-diff/)”, specifying that I want to use it across the columns:

```
(
    df
    .loc[
        (df['Product'] == 'Wine') &
        (df['Variable'].isin(['Imports', 'Exports']))
    ]
    .pivot_table(index='Region/Country', columns='Variable', values='Quantity')
    .fillna(0)
    .diff(axis='columns')
)
```

The “Imports” column now contains a positive number for net importers of wine, and a negative number for net exporters of wine. We want to find net importers, which means finding all of those rows in which “Imports” is positive. We’ll use “loc” with a lambda to find all such rows:

```
(
    df
    .loc[
        (df['Product'] == 'Wine') &
        (df['Variable'].isin(['Imports', 'Exports']))
    ]
    .pivot_table(index='Region/Country', columns='Variable', values='Quantity')
    .fillna(0)
    .diff(axis='columns')
    .loc[lambda df_: df_['Imports'] > 0]
)
```

Finally, we’ll sort the rows by the “Imports” column, then just grab that column to end up with a series:

```
(
    df
    .loc[
        (df['Product'] == 'Wine') &
        (df['Variable'].isin(['Imports', 'Exports']))
    ]
    .pivot_table(index='Region/Country', columns='Variable', values='Quantity')
    .fillna(0)
    .diff(axis='columns')
    .loc[lambda df_: df_['Imports'] > 0]
    .sort_values('Imports', ascending=False)
    ['Imports']
)
```

The result:

```
Region/Country
United Kingdom              11112.071429
Germany                     10157.142857
United States of America     5144.642857
Russia                       4075.250000
Netherlands                  3247.642857
Canada                       2735.642857
China                        2534.285714
Japan                        2096.142857
Belgium                      1993.207792
Switzerland                  1825.928571
Sweden                       1695.500000
Denmark                      1564.571429
Czech Republic               1155.535714
Poland                        841.214286
Norway                        709.750000
Angola                        671.464286
Brazil                        627.821429
Ireland                       618.821429
Finland                       517.750000
Mexico                        388.964286
Name: Imports, dtype: float64
```

As we can see, the UK and Germany import a lot more wine than they export, with the US and Russia coming in third and fourth places there — albeit still a far cry from those first values.

Which, to bring us back to how I started today’s solutions, points to a real economic opportunity for the UK if they start to produce their own wine. Maybe, in a few years’ time, we’ll see them as net exporters, rather than net importers?

Comments or questions? Share them here!

Meanwhile, you can check out my Jupyter notebook for this week: [https://drive.google.com/file/d/1V932ORL\_6kow6iSwFyu31JemE7lX1bSw/view?usp=sharing](https://drive.google.com/file/d/1V932ORL%5F6kow6iSwFyu31JemE7lX1bSw/view?usp=sharing&ref=bambooweekly.com)

I’ll be back next Wednesday with more Pandas challenges based on current events.

Reuven