From c0117afa2acabfc2038552e58094d5f2241e01bf Mon Sep 17 00:00:00 2001 From: Rebecca Barter Date: Tue, 30 Jan 2024 11:46:41 -0700 Subject: [PATCH] Add incomplete files and visualization lesson --- .Rhistory | 0 content/complete/01_variables.ipynb | 8 + content/complete/02_types.ipynb | 2 + content/complete/03_type_conversions.ipynb | 6 + content/complete/04_boolean_operations.ipynb | 15 + content/complete/05_numpy.ipynb | 14 +- content/complete/06_pandas_dataframes.ipynb | 8 + content/complete/07_index.ipynb | 2 + content/complete/08_series.ipynb | 12 +- content/complete/09_subsetting.ipynb | 15 +- content/complete/10_filtering_logical.ipynb | 11 +- content/complete/11_filtering_query.ipynb | 6 + content/complete/12_iloc.ipynb | 241 +-------- .../complete/13_modifying_dataframes.ipynb | 20 +- .../complete/14_summarizing_dataframes.ipynb | 24 +- .../complete/15_grouped_computations.ipynb | 4 + content/complete/16_visualization.ipynb | 263 ++++++++++ content/complete/17_list_comprehension.ipynb | 12 + content/incomplete/01_variables.ipynb | 223 ++++++++ content/incomplete/02_types.ipynb | 481 ++++++++++++++++++ content/incomplete/03_type_conversions.ipynb | 258 ++++++++++ .../incomplete/04_boolean_operations.ipynb | 240 +++++++++ content/incomplete/05_numpy.ipynb | 194 +++++++ content/incomplete/06_pandas_dataframes.ipynb | 304 +++++++++++ content/incomplete/07_index.ipynb | 255 ++++++++++ content/incomplete/08_series.ipynb | 307 +++++++++++ content/incomplete/09_subsetting.ipynb | 227 +++++++++ content/incomplete/10_filtering_logical.ipynb | 158 ++++++ content/incomplete/11_filtering_query.ipynb | 155 ++++++ content/incomplete/12_iloc.ipynb | 180 +++++++ .../incomplete/13_modifying_dataframes.ipynb | 345 +++++++++++++ .../14_summarizing_dataframes.ipynb | 298 +++++++++++ .../incomplete/15_grouped_computations.ipynb | 93 ++++ content/incomplete/16_visualization.ipynb | 146 ++++++ 34 files changed, 4271 insertions(+), 256 deletions(-) create mode 100644 .Rhistory create mode 100644 content/incomplete/01_variables.ipynb create mode 100644 content/incomplete/02_types.ipynb create mode 100644 content/incomplete/03_type_conversions.ipynb create mode 100644 content/incomplete/04_boolean_operations.ipynb create mode 100644 content/incomplete/05_numpy.ipynb create mode 100644 content/incomplete/06_pandas_dataframes.ipynb create mode 100644 content/incomplete/07_index.ipynb create mode 100644 content/incomplete/08_series.ipynb create mode 100644 content/incomplete/09_subsetting.ipynb create mode 100644 content/incomplete/10_filtering_logical.ipynb create mode 100644 content/incomplete/11_filtering_query.ipynb create mode 100644 content/incomplete/12_iloc.ipynb create mode 100644 content/incomplete/13_modifying_dataframes.ipynb create mode 100644 content/incomplete/14_summarizing_dataframes.ipynb create mode 100644 content/incomplete/15_grouped_computations.ipynb create mode 100644 content/incomplete/16_visualization.ipynb diff --git a/.Rhistory b/.Rhistory new file mode 100644 index 0000000..e69de29 diff --git a/content/complete/01_variables.ipynb b/content/complete/01_variables.ipynb index 2669d86..9bcd718 100644 --- a/content/complete/01_variables.ipynb +++ b/content/complete/01_variables.ipynb @@ -13,6 +13,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Simple computations\n", + "\n", "We can use Python to do simple computations, like this:" ] }, @@ -41,6 +43,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Defining variables/objects\n", + "\n", "If I want to use the \"output\" of this code, we need to assign it to a variable/object." ] }, @@ -166,6 +170,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Overwriting variables\n", + "\n", "You can overwrite variables, by re-assinging them:" ] }, @@ -204,6 +210,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### The `+=` shortcut\n", + "\n", "There is a shortcut that will let you add a number to a variable *and* update its value: `+=`" ] }, diff --git a/content/complete/02_types.ipynb b/content/complete/02_types.ipynb index e527da0..153bbea 100644 --- a/content/complete/02_types.ipynb +++ b/content/complete/02_types.ipynb @@ -65,6 +65,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### The `type()` function\n", + "\n", "We can check the type of `y` using the `type()` funciton" ] }, diff --git a/content/complete/03_type_conversions.ipynb b/content/complete/03_type_conversions.ipynb index e8110f7..5044bc1 100644 --- a/content/complete/03_type_conversions.ipynb +++ b/content/complete/03_type_conversions.ipynb @@ -62,6 +62,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Converting to a string using `str()`\n", + "\n", "The `str()` function will convert whatever value it is given to a string (whose shorthand is `str`). \n", "\n", "Below, we convert the integer `4` to a string, assign it to a variable called `a` and then we check the type of `a` (which is `str`):" @@ -130,6 +132,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Converting to an integer using `int()`\n", + "\n", "Converting the float `3.0` to an integer removes the decimal point:" ] }, @@ -215,6 +219,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Converting to a boolean using `bool()`\n", + "\n", "When you convert a number to a boolean using `bool()`, it is always converted to `True`, unless the number is equal to `0` (this is the only number that is converted to `False`):" ] }, diff --git a/content/complete/04_boolean_operations.ipynb b/content/complete/04_boolean_operations.ipynb index faf6483..4ead0d5 100644 --- a/content/complete/04_boolean_operations.ipynb +++ b/content/complete/04_boolean_operations.ipynb @@ -30,6 +30,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Asking if two things are equal with `==`\n", + "\n", "To ask a question of equality, we use two equal signs `==`" ] }, @@ -86,6 +88,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Asking if two things are not equal with `!=`\n", + "\n", "The \"not equal to\" operator is written `!=`. The following question asks if the `age` variable is \"not equal\" to 10:" ] }, @@ -114,6 +118,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Less than or greater than with `<` and `>`\n", + "\n", "Next, to ask questions of greater than or less than, we use the `<` and `>` operators:" ] }, @@ -219,6 +225,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Less than or greater than for strings\n", + "\n", "Strings are treated alphabetically, so `'apple'` is \"less\" than `'bannana'` because the first letter of apple \"a\" comes before the first letter of banana \"b\" in the alphabet:" ] }, @@ -264,6 +272,13 @@ "'carrot' < 'banana'" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "metadata": {}, diff --git a/content/complete/05_numpy.ipynb b/content/complete/05_numpy.ipynb index d1d9ec6..9f37149 100644 --- a/content/complete/05_numpy.ipynb +++ b/content/complete/05_numpy.ipynb @@ -20,6 +20,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Installing numpy\n", + "\n", "Just like an application on your computer, where you need to first download and install the application before you can use it on your computer, before you can use Python libraries, you need to first download and install them. \n", "\n", "The way that you will install Python libraries depends on your Python installation. \n", @@ -66,7 +68,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "You *don't* need to include this `pip install numpy` code in your notebook.\n", + "You *don't* need to include this `pip install numpy` code in your notebook.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Importing numpy\n", "\n", "Once you've successfully installed the numpy library once, you can import the library (make its functions available) using the `import as ` command below. \n", "\n", @@ -87,6 +97,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Using numpy functions\n", + "\n", "Let's take a look at some of the functions that the numpy library provides.\n", "\n", "First, let's define a variable `x` that contains the value `2`:" diff --git a/content/complete/06_pandas_dataframes.ipynb b/content/complete/06_pandas_dataframes.ipynb index 2ba5326..8f83a54 100644 --- a/content/complete/06_pandas_dataframes.ipynb +++ b/content/complete/06_pandas_dataframes.ipynb @@ -41,6 +41,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Loading a data file into a pandas DataFrame\n", + "\n", "To load a .csv data file into our space, we need to use the `read_csv()` function from the pandas library. Make sure that you have saved the `gapminder.csv` file in a `data` subfolder that lives in the same place where this notebook is saved.\n", "\n", "Let's load the gapminder dataset:" @@ -618,6 +620,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### The shape attribute\n", + "\n", "To extract an attribute from an object in Python, we use the `object.attribute` syntax. So if we want to extract the `shape` attribute from the `gapminder` DataFrame object, we can do so as follows:" ] }, @@ -653,6 +657,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### The head() method\n", + "\n", "The `head()` function typically prints out the first few rows of a DataFrame. However, `head()` is not a regular function. If `head()` were a regular function, we would be able to apply it like this:" ] }, @@ -794,6 +800,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Arguments\n", + "\n", "You can provide additional arguments to the `head()` inside the parentheses. For example, if you want to print 10 rows instead of 5, you can do so as follows:" ] }, diff --git a/content/complete/07_index.ipynb b/content/complete/07_index.ipynb index ce11f5c..52fa733 100644 --- a/content/complete/07_index.ipynb +++ b/content/complete/07_index.ipynb @@ -150,6 +150,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Changing the index\n", + "\n", "You can change the index using the `set_index()` method and providing, for example, a column name as a string." ] }, diff --git a/content/complete/08_series.ipynb b/content/complete/08_series.ipynb index a6a5c85..8d4353a 100644 --- a/content/complete/08_series.ipynb +++ b/content/complete/08_series.ipynb @@ -227,7 +227,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "There are several ways to extract a column from a DataFrame. The first, involves writing the name of the DataFrame object followed by square parentheses inside which you provide the name of the column you want to extract as a string:" + "There are several ways to extract a column from a DataFrame. \n", + "\n", + "### Method 1: Using square brackets\n", + "\n", + "The first, involves writing the name of the DataFrame object followed by square parentheses inside which you provide the name of the column you want to extract as a string:" ] }, { @@ -266,6 +270,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Method 2: Using the column attribute with `.`\n", + "\n", "Another way to do the same thing is to use the `.` syntax to extract the named column attribute from the DataFrame object, such as:" ] }, @@ -428,6 +434,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### The Series index\n", + "\n", "They do however have an `index` (row name) attribute, which is inherited from the DataFrame from which the Series came:" ] }, @@ -456,6 +464,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### The vectorized nature of Series objects\n", + "\n", "The nice thing about Pandas Series objects is that they are **vectorized**. \n", "\n", "This means that when you apply simple mathematical operations to them, the operation will be applied to *every* entry in the Series. For example, if we add `5` to the `year` Series object, `5` will be added to *every* value in the `year` Series object:" diff --git a/content/complete/09_subsetting.ipynb b/content/complete/09_subsetting.ipynb index f4e017a..95d931e 100644 --- a/content/complete/09_subsetting.ipynb +++ b/content/complete/09_subsetting.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Working with DataFrames\n", + "# Extracting subsets of data frames\n", "\n", "In this notebook, we will learn how to manipulate pandas DataFrame objects, starting with extracting subsets." ] @@ -120,13 +120,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Extracting subsets of data frames" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ + "### Extracting multiple columns\n", + "\n", "Suppose that you want to extract multiple columns at once from your DataFrame object. You might imagine that you can do this by providing two column names inside the square parentheses that follow the object name, as follows:" ] }, @@ -362,6 +357,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Using `:` with `.loc` to select all rows/columns\n", + "\n", "If you want to extract all rows (or columns), you can replace the corresponding index entry with `:`. So the following code will extract all rows for the `gdpPercap` column:" ] }, @@ -702,6 +699,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Using `.loc` with non-numeric indexes\n", + "\n", "Note that the fact that we can index the rows using `.loc` with integers is solely a result of the fact that the row index corresponds to integers. If, instead the row index corresponded to the `country` values, such as in `gapminder_country`, we would not be able to use integers to subset the rows, and we would instead need to use the country names. \n", "\n", "Let's create `gapminder_country`, whose row index corresponds to the country variable:" diff --git a/content/complete/10_filtering_logical.ipynb b/content/complete/10_filtering_logical.ipynb index e7cb120..ded3f36 100644 --- a/content/complete/10_filtering_logical.ipynb +++ b/content/complete/10_filtering_logical.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Filtering using logical operations and `.loc`" + "# Filtering using logical operations and `.loc`" ] }, { @@ -114,6 +114,13 @@ "gapminder.head()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Filtering with `.loc` using a boolean series\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -159,6 +166,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "\n", + "\n", "We can use this boolean series to subset/filter the rows of our DataFrame by providing it in the row indexing position of the `.loc` indexer. The following will filter the `gapminder` DataFrame just to the rows where the `country` value equals `'Australia'`:" ] }, diff --git a/content/complete/11_filtering_query.ipynb b/content/complete/11_filtering_query.ipynb index f125b9d..3aeb565 100644 --- a/content/complete/11_filtering_query.ipynb +++ b/content/complete/11_filtering_query.ipynb @@ -473,6 +473,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Filtering using `.query()`\n", + "\n", "The `.query()` method does the same thing, but the syntax is a bit different. Since `query` is a method, it is followed by round parentheses `()` rather than square parentheses `[]`, and unlike in the above examples where we need to explicitly create a boolean Series object from the `country` column, e.g., `gapminder['country'] == \"Australia\"`, we instead provide a string (text) argument in which we just write the name of the column that we are using to filter, `country`, followed by the condiiton `== \"Australia\"`." ] }, @@ -653,6 +655,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### External variables in the `.query()` method\n", + "\n", "Note that if you want to use an \"external\" variable in your filtering query, you need to access it within the argument using `@variable_name`. For example, if we have defined an external variable, `selected_country` that contains the name of the country that we want to use to filter to in our query, to access this `selected_country` variable inside our query argument, we need to write `@selected_country` with the `@` symbol, which will impute the value stored in `selected_country` when the query is executed." ] }, @@ -835,6 +839,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Combining `.query()` with `.loc`\n", + "\n", "Note that since `gapminder.query()` outputs a DataFrame itself, you can follow a query method call with further subsetting which will then apply to the outputted DataFrame. The code below filters to just the country rows equal to \"Brazil\", and then uses the `.loc` indexer to subset just the \"year\" and \"lifeExp\" columns for the eventual output:" ] }, diff --git a/content/complete/12_iloc.ipynb b/content/complete/12_iloc.ipynb index a9dd46d..3700909 100644 --- a/content/complete/12_iloc.ipynb +++ b/content/complete/12_iloc.ipynb @@ -360,6 +360,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Positional indexing with `.iloc`\n", + "\n", "Now let's try and extract the rows 1, 4, and 5 and the columns `'year'`, `'lifeExp'`, and `'pop'` from this country-indexed version of gapminder:" ] }, @@ -398,239 +400,8 @@ "source": [ "We get an error, because there are no longer any rows with row index names 1, 4, 5.\n", "\n", - "To subset rows using `iloc`, we need to provide string values that match the row index values we're interested in:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
yearlifeExppop
country
Australia195269.1208691212
Australia195770.3309712569
Australia196270.93010794968
Australia196771.10011872264
Australia197271.93013177000
Australia197773.49014074100
Australia198274.74015184200
Australia198776.32016257249
Australia199277.56017481977
Australia199778.83018565243
Australia200280.37019546792
Australia200781.23520434176
Canada195268.75014785584
Canada195769.96017010154
Canada196271.30018985849
Canada196772.13020819767
Canada197272.88022284500
Canada197774.21023796400
Canada198275.76025201900
Canada198776.86026549700
Canada199277.95028523502
Canada199778.61030305843
Canada200279.77031902268
Canada200780.65333390141
\n", - "
" - ], - "text/plain": [ - " year lifeExp pop\n", - "country \n", - "Australia 1952 69.120 8691212\n", - "Australia 1957 70.330 9712569\n", - "Australia 1962 70.930 10794968\n", - "Australia 1967 71.100 11872264\n", - "Australia 1972 71.930 13177000\n", - "Australia 1977 73.490 14074100\n", - "Australia 1982 74.740 15184200\n", - "Australia 1987 76.320 16257249\n", - "Australia 1992 77.560 17481977\n", - "Australia 1997 78.830 18565243\n", - "Australia 2002 80.370 19546792\n", - "Australia 2007 81.235 20434176\n", - "Canada 1952 68.750 14785584\n", - "Canada 1957 69.960 17010154\n", - "Canada 1962 71.300 18985849\n", - "Canada 1967 72.130 20819767\n", - "Canada 1972 72.880 22284500\n", - "Canada 1977 74.210 23796400\n", - "Canada 1982 75.760 25201900\n", - "Canada 1987 76.860 26549700\n", - "Canada 1992 77.950 28523502\n", - "Canada 1997 78.610 30305843\n", - "Canada 2002 79.770 31902268\n", - "Canada 2007 80.653 33390141" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Use .loc[,] to subset row with index 'Australia', 'Canada' and columns `year', 'lifeExp', 'pop' from gapminder_country\n", - "gapminder_country.loc[['Australia', 'Canada'],['year', 'lifeExp', 'pop']]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If you do want to do positional indexing, this is where the `.iloc` indexer comes in.\n", + "\n", + "If you want to do positional indexing, this is where the `.iloc` indexer comes in.\n", "\n", "The following code will subset the country-indexed gapminder dataset to just the 2nd positional row and the 2nd positional column (remember that Python is 0-indexed, so this is actually the third row and column). Recall also that the country column is now the index rather than a column." ] @@ -740,6 +511,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Using `:` to mean all rows/columns\n", + "\n", "We can also use the `:` placeholder for \"all rows\" or \"all columns\". The code below will select the 0th, 3rd, and 5th columns and *all* rows:" ] }, @@ -877,6 +650,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### More general sequencing with `start:stop:step`\n", + "\n", "And finally, you can extract more general sequences of rows/columns using the `start:stop` sequencing syntax. `0:20` will correspond to a list of integers from 0 up to 20 (not inclusive -- so it will actually go up to 19). \n", "\n", "`start:stop:step`, e.g., `0:20:2`, will similarly correspond to a list of integers from 0 up to 20 (non-inclusive) with a step size of 2, so 0, 2, 4, 6, ..., 18. \n", diff --git a/content/complete/13_modifying_dataframes.ipynb b/content/complete/13_modifying_dataframes.ipynb index 429ea36..d1249a8 100644 --- a/content/complete/13_modifying_dataframes.ipynb +++ b/content/complete/13_modifying_dataframes.ipynb @@ -125,14 +125,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Creating a new column in a DataFrame" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's add a new column `gdp` which is the product of the `pop` and `gdpPercap` columns:" + "### Creating a new column in a DataFrame" ] }, { @@ -167,6 +160,13 @@ "gapminder['pop'] * gapminder['gdpPercap']" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's add a new column `gdp` which is the product of the `pop` and `gdpPercap` columns:" + ] + }, { "cell_type": "code", "execution_count": 24, @@ -366,7 +366,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Removing a column from a DataFrame" + "### Removing a column from a DataFrame using `.drop()`" ] }, { @@ -924,7 +924,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Creating a copy of a DataFrame object" + "### Creating a copy of a DataFrame object" ] }, { diff --git a/content/complete/14_summarizing_dataframes.ipynb b/content/complete/14_summarizing_dataframes.ipynb index 35df4cb..b682008 100644 --- a/content/complete/14_summarizing_dataframes.ipynb +++ b/content/complete/14_summarizing_dataframes.ipynb @@ -23,7 +23,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "To apply a statistical summary such as the mean to a single column from a DataFrame, you first need to extract the column of interest, e.g., using the `df['col']` syntax, and then apply the relevant method (e.g., `.mean()`) to the resulting Series object.\n", + "To apply a statistical summary such as the mean to a single column from a DataFrame, you first need to extract the column of interest, e.g., using the `df['col']` syntax, and then apply the relevant method (e.g., `.mean()`) to the resulting Series object.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Calculating the mean\n", "\n", "For example, the code below applies the `.mean()` method to the `lifeExp` column from gapminder:" ] @@ -353,6 +361,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Extracting columns of a particular type\n", + "\n", "Fortunately, you can extract all of the numeric columns of gapminder using the `.select_dtypes()` method, and then apply the `.mean()` method to the resulting DataFrame:" ] }, @@ -386,7 +396,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Note that `.mean()` is just one of many statistical summaries that you can compute on Pandas DataFrame and Series objects. \n", + "Note that `.mean()` is just one of many statistical summaries that you can compute on Pandas DataFrame and Series objects. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Other statistical summaries: sum, median, std\n", "\n", "Others include the sum:" ] @@ -484,6 +502,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Counting the number of unique categorical values with the `value_counts()` method\n", + "\n", "While the above methods can only be used for numeric (float or integer) columns, there are some summaries that you can use for categorical columns too. For example, the `.value_counts()` method will compute the number of times each unique value appears in a column.\n", "\n", "The following code counts the number of times each unique country appears in the `country` column:" diff --git a/content/complete/15_grouped_computations.ipynb b/content/complete/15_grouped_computations.ipynb index 9c14833..b7d3b91 100644 --- a/content/complete/15_grouped_computations.ipynb +++ b/content/complete/15_grouped_computations.ipynb @@ -23,6 +23,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### The `.groupby()` method\n", + "\n", "So far we have seen how to compute statistical summaries across an entire column, but sometimes we want to compute a summary separately for different groups (where the groups might be defined by the unique values in a column).\n", "\n", "The code below uses the `.groupby()` method to compute the mean of each column separately for each `year` value:" @@ -173,6 +175,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### Grouping by multiple columns\n", + "\n", "We can group by multiple columns at once by providing a *list* of the column names that we want to group by as the argument of the `.groupby()` method, and we can then extract a single column (if we choose) and compute the mean of it separately within each grouped combination. For example, the code below computes the mean `lifeExp` value for each year-continent combination:" ] }, diff --git a/content/complete/16_visualization.ipynb b/content/complete/16_visualization.ipynb index 5267dda..90225d8 100644 --- a/content/complete/16_visualization.ipynb +++ b/content/complete/16_visualization.ipynb @@ -19,6 +19,269 @@ "\n", "gapminder = pd.read_csv('data/gapminder.csv')" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Pandas visualization methods\n", + "\n", + "Pandas has a few methods that allow you to quickly create visualizations from your DataFrame. We will use the `plot` method to create a few plots.\n", + "\n", + "The general syntax is `df.plot(kind=)`" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Use `df.plot` to create a scatterplot of gdpPercap vs lifeExp\n", + "gapminder.plot(kind='scatter', x='gdpPercap', y='lifeExp')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Use `df.plot` to create a barplot of the number of countries in each continent\n", + "# Hint: use value_counts() first to get the counts\n", + "gapminder['continent'].value_counts().plot(kind='bar')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# create a histogram of the life expectancy\n", + "# Hint: extract the lifeExp column first\n", + "gapminder['lifeExp'].plot(kind='hist')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The Seaborn library\n", + "\n", + "The inbuilt Pandas plotting functionalities are somewhat limited in what they can do.\n", + "\n", + "If you want to create more sophisticated visualizations, you'll want to use another library. One of the most popular libraries for data visualization is [Seaborn](https://seaborn.pydata.org/)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Import seaborn\n", + "import seaborn as sns\n", + "\n", + "# Use seaborn to create a scatterplot of gdpPercap vs lifeExp\n", + "sns.scatterplot(data=gapminder, x='gdpPercap', y='lifeExp')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# create a version of the above scatterplot for just the year 2007, \n", + "# where the color is based on continent \n", + "# and the size is based on population\n", + "# and the size range is from 20 to 500\n", + "# and the transparency is 0.7\n", + "sns.scatterplot(data=gapminder.query('year == 2007'), \n", + " x='gdpPercap', \n", + " y='lifeExp', \n", + " hue='continent', \n", + " size='pop', \n", + " sizes=(20, 500), \n", + " alpha=0.7)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Creating bar charts and histograms with seaborn is also fairly straightforward" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# create a bar chart of the number of countries in each continent using sns.countplot()\n", + "sns.countplot(data=gapminder,\n", + " y='continent')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# create a histogram of lifeExp using sns.histplot()\n", + "sns.histplot(data=gapminder,\n", + " x='lifeExp')" + ] } ], "metadata": { diff --git a/content/complete/17_list_comprehension.ipynb b/content/complete/17_list_comprehension.ipynb index b4a46ba..f18f8c5 100644 --- a/content/complete/17_list_comprehension.ipynb +++ b/content/complete/17_list_comprehension.ipynb @@ -19,6 +19,18 @@ "\n", "gapminder = pd.read_csv('data/gapminder.csv')" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We've seen lists a few times throughout this workshop, but we haven't really talked much about them." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] } ], "metadata": { diff --git a/content/incomplete/01_variables.ipynb b/content/incomplete/01_variables.ipynb new file mode 100644 index 0000000..9ba3a5c --- /dev/null +++ b/content/incomplete/01_variables.ipynb @@ -0,0 +1,223 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Variables and objects in Python\n", + "\n", + "In this document, we will define some objects/variables and learn how to interact with them. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simple computations\n", + "\n", + "We can use Python to do simple computations, like this:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# compute 1 + 1\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining variables/objects\n", + "\n", + "If I want to use the \"output\" of this code, we need to assign it to a variable/object." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# assign the output of 1 + 1 to a variable y\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To access the results of the `1 + 1` computation, we need to type the name of the variable:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# print out the results of the above computation using y\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can do mathematical operations with variables:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# multiply y by 6\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# compute y squared\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# compute y**2 + y/2 and assign it to z\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# see what z contains\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Overwriting variables\n", + "\n", + "You can overwrite variables, by re-assinging them:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# overwrite/reassign y with 10\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# check the value of z -- has it changed?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The `+=` shortcut\n", + "\n", + "There is a shortcut that will let you add a number to a variable *and* update its value: `+=`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# print the value of z + 2 (do not reassign it)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# has the value of z changed?\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# update z to be z + 2 using the += shorthand\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# print z again. Has it changed now?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise\n", + "\n", + "Without running the code below, can you guess what the output of the following code cell will be?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "value = 1\n", + "computed_result = (value * 10) + (3 ** 2)\n", + "value += 2\n", + "computed_result * 2" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/content/incomplete/02_types.ipynb b/content/incomplete/02_types.ipynb new file mode 100644 index 0000000..6292aa7 --- /dev/null +++ b/content/incomplete/02_types.ipynb @@ -0,0 +1,481 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Types\n", + "\n", + "The main types in python are:\n", + "\n", + "- Float (decimal point): 1.2, 3.0, 5.123\n", + "\n", + "- Integers: 1, 7, 11\n", + "\n", + "- String (text): 'banana', 'Utah', 'Rebecca' etc\n", + "\n", + "- Boolean (True/False): True or False" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Numeric types" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's define a variable $y = 2 \\times 3.2 + 1$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# define y\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# look at y. What do you think its type is?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The `type()` function\n", + "\n", + "We can check the type of `y` using the `type()` funciton" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# apply the type function to the variable y\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's also create a variable $z = 1 + 5$ and check its type:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# define z\n", + "\n", + "# look at z--what type do you think z has?\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# check the type of z using type()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can do mathematical operations with float and integer type objects" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# compute y squared\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# divide z by 2\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### String types" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"String\" in Python just means \"text\", so string type objects contain text, and can be identified because they are surrounded by quotes:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# define w to contain the string 'John Doe'\n", + "\n", + "# look at the value of w\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What do you think will happen when you try to **multiply** a string by an *integer*?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Multiply w by 7\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What about **adding** a string and an *integer*?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Add w and 7\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What about **adding** a string to another *string*?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# add w and the string 'Smith'\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's overwrite `w` with a new string value: 'banana'. Notice that we need 'banana' to be surrounded by quotes. The quotes around the string values are very important since they distinguish string *values* from variable *names*:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# redefine w to contain 'banana'\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# look at w\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# check the type of w\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that you can also use the type function on *values* directly (rather than on variables):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# check the type of the string value 'a' ('a' is not assigned to a variable)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Boolean type" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The boolean type corresponds to binary True/False values:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Write the boolean True value\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that `True` above, is a special value, it's not a variable name. You can't just write any text and expect it to be printed out." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's check the type of `True`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# check the type of True\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice that this is different from the type of `'True'`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# check the type of 'True' (with quotes)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The converse to `True` is `False`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# write the boolean False value\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# check the type of False\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can assign boolean values to variables, just as with integers/floats and strings:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# assign True to the variable a\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# print out the value of a\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can do mathematical operations with boolean values:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# add a and 3\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# add False and 4\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that you *cannot* add Boolean values and string values together:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# try to add True and 'True'\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise\n", + "\n", + "Without running the following code cells, answer the following questions:\n", + "\n", + "1. Will the computation work? \n", + "\n", + "1. If so, what will the output be? \n", + "\n", + "1. What type will the output have?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "'True' * 4" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "'banana' + 'apple'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "False + 5" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "True * 'True'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "5 + '5.2'" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/content/incomplete/03_type_conversions.ipynb b/content/incomplete/03_type_conversions.ipynb new file mode 100644 index 0000000..cc2bd92 --- /dev/null +++ b/content/incomplete/03_type_conversions.ipynb @@ -0,0 +1,258 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Type conversion\n", + "\n", + "Objects of one type can be converted to another type using a collection of functions whose names match the type shorthand you want to convert to." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As a reminder, the `type()` function tells us the type of a value::" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# check the type of '4' (with quotes)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# check the type of 4:\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Converting to a string using `str()`\n", + "\n", + "The `str()` function will convert whatever value it is given to a string (whose shorthand is `str`). \n", + "\n", + "Below, we convert the integer `4` to a string, assign it to a variable called `a` and then we check the type of `a` (which is `str`):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# convert the integer 4 to a string and assign it to a variable a:\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# check the type of a\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Rather than assigning `str(4)` to a, and then checking the type of `a` directly, we can use nested functions:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# in one line, convert the integer 4 to a string and check its type\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Converting to an integer using `int()`\n", + "\n", + "Converting the float `3.0` to an integer removes the decimal point:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# convert the float 3.0 to an integer\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When you do the same thing for a float point number with a non-zero decimal, it also just removes the decimal point:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# convert the float 4.2 to an integer\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What happens when you try to convert a string to an integer?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Convert the string 'two' to an integer\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Converting to a boolean using `bool()`\n", + "\n", + "When you convert a number to a boolean using `bool()`, it is always converted to `True`, unless the number is equal to `0` (this is the only number that is converted to `False`):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# convert the integer 3 to a boolean\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# convert the integer 1 to a boolean\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# convert the integer 0 to a boolean\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# convert the float 1.1 to a boolean\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Do you think a negative number will be converted to `True` or `False`?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# convert the float -3.4 to a boolean\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What will a string be converted to?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# convert the string 'hello' to a boolean\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# check the type of the boolean version of 'hello' from the previous cell\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise\n", + "\n", + "1. Create a string variable called `my_string` containing the value `'two'`. \n", + "\n", + "1. Convert `my_string` to a boolean and assign the result to a variable called `my_bool`. \n", + "\n", + "1. Print the value of `my_bool` and check its type. \n", + "\n", + "1. Convert `my_bool` to an integer and assign the result to a variable called `my_int`.\n", + "\n", + "Try to convert the original `my_string` variable to an integer directly. What happens?" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/content/incomplete/04_boolean_operations.ipynb b/content/incomplete/04_boolean_operations.ipynb new file mode 100644 index 0000000..dfcb224 --- /dev/null +++ b/content/incomplete/04_boolean_operations.ipynb @@ -0,0 +1,240 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Asking questions with boolean operations\n", + "\n", + "There are several helpful operations (`==`, `<=`, `<` `!=`) that allow us to ask logical questions of our data whose answers are True or False" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's define a variable `age` and give it the value `20`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# assign age to 20\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Asking if two things are equal with `==`\n", + "\n", + "To ask a question of equality, we use two equal signs `==`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ask is age equal to 18?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This questions doesn't have to involve a variable and a value, it can instead be asked directly of two values, for instance:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ask is 1 equal to 1?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Asking if two things are not equal with `!=`\n", + "\n", + "The \"not equal to\" operator is written `!=`. The following question asks if the `age` variable is \"not equal\" to 10:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ask is age \"not equal\" to 18?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Less than or greater than with `<` and `>`\n", + "\n", + "Next, to ask questions of greater than or less than, we use the `<` and `>` operators:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ask is age greater than 18?\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ask is the value 20 greater than the value 18?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"Greater or equal to\" is the \"greater than\" symbol (`>`) followed by the equals symbol (`=`):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# is age greater than or equal to 18?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "and similarly for less than or equal to:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# is age less than or equal to 18?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Less than or greater than for strings\n", + "\n", + "Strings are treated alphabetically, so `'apple'` is \"less\" than `'bannana'` because the first letter of apple \"a\" comes before the first letter of banana \"b\" in the alphabet:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ask is 'apple' less than 'banana'\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ask is 'carrot' less than 'banana'\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also use these operators to compare the values contained within two variables:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# assign age_john the value 18\n", + "\n", + "# assign age_beth the value 22\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ask is age_john less than age_beth?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Create two variables, `age1` and `age2` and assign them integer values `12` and `15`, respectively.\n", + "\n", + "1. Write a boolean condition to test if `age1` is equal to `age2`.\n", + "\n", + "1. Write a boolean condition to test if `age1` is greater than `age2`.\n", + "\n", + "1. Write a boolean condition to test if `age1` is less than or equal to `age2`.\n", + "\n", + "1. Write a boolean condition to test if `age1` is not equal to `age2`.\n", + "\n", + "1. Write a boolean condition to test if the absolute difference between `age1` and `age2` is greater than 5 using the `abs()` function." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/content/incomplete/05_numpy.ipynb b/content/incomplete/05_numpy.ipynb new file mode 100644 index 0000000..7127bd6 --- /dev/null +++ b/content/incomplete/05_numpy.ipynb @@ -0,0 +1,194 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The numpy library" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Some functions that exist \"natively\" in the Python programming language (like `type()`, `bool()`, `int()`, etc), byt Python lacks native versions of many important functions, such as the logarithm, exponential, and square root functions. \n", + "\n", + "Libraries can be installed that provide access to many functions. \n", + "\n", + "The **Numpy** library (pronounced \"Num Pie\") is an add-on library that gives us access to many mathematical functions such as the `log()`, `exp()`, and `sqrt()` functions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Installing numpy\n", + "\n", + "Just like an application on your computer, where you need to *first download and install* the application before you can use it on your computer, before you can use Python libraries, you need to first download and install them. \n", + "\n", + "\n", + "**Downloading libraries requires internet access.**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that just like **you only ever have to download and install an application to your computer _once_**, you similarly only need to install each Python library *once*. Thus it is not encouraged to repeatedly run a `pip install ` command every time you work on your notebook. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# install numpy and then comment out the installation line\n", + "# !pip install numpy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Importing numpy\n", + "\n", + "Unlike the `pip install` command, you **do** need to include this `import` line of code in every new `.ipynb` notebook file." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# import numpy and rename it to np\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using numpy functions\n", + "\n", + "Define a variable `x` that contains the value `2`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# define a variable x and assign it a value of 2\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# take a look at x\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If we wanted to compute the logarithm of `x`, you might imagine that we would write:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# try to compute the log of x using the log() function\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But, notice that we get an error that essentially says that Python doesn't know what `log()` is. \n", + "\n", + "In Python, to access functions that come from imported libraries, you need to extract the function from the library shorthand/nickname using the `library.function()` syntax, e.g., `np.log()` instead of just `log()`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# try to compute the log of x using the np.log() function\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is also true of the `sqrt()` function that is imported from the `numpy` library:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# compute the square root of x\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And the `exp()` function:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# compute the exponential of 2\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise\n", + "\n", + "Compute the sum of the log of 7 and the square root of 8 and exponentiate the result, i.e., $e^{\\log(7) + \\sqrt{8}}$." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/content/incomplete/06_pandas_dataframes.ipynb b/content/incomplete/06_pandas_dataframes.ipynb new file mode 100644 index 0000000..52ce93d --- /dev/null +++ b/content/incomplete/06_pandas_dataframes.ipynb @@ -0,0 +1,304 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Pandas data frames\n", + "\n", + "In this notebook, we will start learning about Pandas data frames. \n", + "\n", + "To import the pandas library to our notebook, if you haven't done so already you will first need to download and install the pandas library (`pip install pandas`).\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then you can import the pandas library into this notebook as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# import the pandas library and alias as pd\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Loading a data file into a pandas DataFrame\n", + "\n", + "To load a .csv data file into our space, we need to use the `read_csv()` function from the pandas library. Make sure that you have saved the `gapminder.csv` file in a `data` subfolder that lives in the same place where this notebook is saved.\n", + "\n", + "Let's load the gapminder dataset:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# read the csv file living in data/gapminder.csv into a pandas dataframe \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This just prints out the gapminder dataset, but it doesn't save it. \n", + "\n", + "To save the dataset so that we can use it in our notebook, we can to assign the results of the `pd.read_csv()` function to a variable called `gapminder`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Save the above dataframe as a variable called gapminder\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To view the dataset we have just loaded, we can type the name of the variable that we saved it in:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# look at the gapminder dataframe object\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can then use the same `type()` function that we used in the previous notebook to ask what kind of object the `gapminder` variable is (the answer is a pandas DataFrame):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# check the type of the dataframe object\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extracting information/attributes from DataFrames\n", + "\n", + "In this section, we will learn how to extract attributes from DataFrame objects and how to apply DataFrame-specific \"methods\" to DataFrames, both using the `.` syntax." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As a reminder, let's print out the `gapminder` DataFrame that we're working with:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# look at gapminder again\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The shape attribute\n", + "\n", + "To extract an attribute from an object in Python, we use the `object.attribute` syntax. So if we want to extract the `shape` attribute from the `gapminder` DataFrame object, we can do so as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# extract the shape attribute from gapminder\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This `shape` attribute tells us the number of rows (1704) and the number of columns (6) and is helpful for learning about the size of our data objects" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The head() method\n", + "\n", + "The `head()` function typically prints out the first few rows of a DataFrame. However, `head()` is not a regular function. If `head()` were a regular function, we would be able to apply it like this:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# try to look at the first 5 rows of the gapminder dataset using the head() function\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But this results in an error. This is because `head()` is not a function that can be applied in the regular way. \n", + "\n", + "Instead, `head()` is a **method**, which is applied using the `object.method()` syntax rather than the `method(object)` syntax above. \n", + "\n", + "We can apply the `head()` method to the `gapminder` dataset as follows, which will print out the first 5 rows of the DataFrame:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# apply the the head() method to gapminder\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Arguments\n", + "\n", + "You can provide additional arguments to the `head()` inside the parentheses. For example, if you want to print 10 rows instead of 5, you can do so as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# apply the head() method to gapminder with an argument of 10\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This argument has a name `n`, which you can explicitly specify:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# apply the head method to gapminder with a *named* argument of n=10\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But you don't need to specify the `n=` part of the argument because the `head()` method knows that the first argument is the number of rows to print." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise\n", + "\n", + "1. The pandas DataFrame has an attribute called `dtypes` that will print out the *type* of each column. Extract the `dtypes` attribute from the `gapminder` DataFrame:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# extract the dtypes attribute from gapminder\n", + "gapminder.dtypes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the \"string\" type is called `object` in pandas." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. The pandas DataFrame has a \"method\" called `select_dtypes()` that will extract just the columns of a certain type from the DataFrame. Use the `select_dtypes()` function to extract the numeric (float and integer) columns of gapminder by providing an argument `include='number'` inside the parentheses of `select_dtypes()`. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# use the select_dtypes() method to select only the columns of type number\n", + "gapminder.select_dtypes(include='number')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# to instead extract the string/object-type columns:\n", + "gapminder.select_dtypes(include='object')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/content/incomplete/07_index.ipynb b/content/incomplete/07_index.ipynb new file mode 100644 index 0000000..d298c7f --- /dev/null +++ b/content/incomplete/07_index.ipynb @@ -0,0 +1,255 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## DataFrame indexing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this section we will learn about the column and row indexes of the DataFrame. These are essentially the column and row names of the DataFrame.\n", + "\n", + "We will keep working with the gapminder DataFrame." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's start by importing the libraries that we need:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# import the pandas library\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's load the gapminder dataset:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# read the data from the downloaded CSV file and save it as a pandas DataFrame called gapminder\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To view the dataset we have just loaded, we can type the name of the variable that we saved it in:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# look at the gapminder object\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The column index\n", + "\n", + "To extract the column index, which corresponds to the column names of the DataFrame, we need to extract the `columns` attribute of the Dataframe object." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# extract the column index (the column names) from the gapminder DataFrame\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice that the output of the cell above is an \"Index\" object. \n", + "\n", + "We can use the `list()` function to convert the index object to a simpler type of object called a \"list\" (which is just a collection of values):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# use the list() function to create a \"list\" of the column names\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The row index\n", + "\n", + "The row index can be extracted using the `index` attribute (there is no `rows` attribute):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# extract the row index from gapminder\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This time, the output is a `RangeIndex` object." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To extract the actual integer values we can use the `list()` function:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# use the list() function to create a \"list\" of the row index entries\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Changing the index\n", + "\n", + "You can change the index using the `set_index()` method." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's set the `country` column to be the row index:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# use the set_index() method to set the 'country' column as the index of gapminder\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "However, notice also that this did not actually modify the `gapminder` object itself." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# show that the gapminder DataFrame still has its original index\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below, we create a *new* DataFrame corresponding to the version of `gapminder` with the `'country'` column as the row index:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# create a new DataFrame called gapminder_country where the index is the 'country' column\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice that the original gapminder dataset is unchanged:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# print gapminder to show that gapminder DataFrame still has its original index\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But that the `gapminder_country` DataFrame has the `country` column as its index. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# print gapminder_country to show that it has the 'country' column as the index \n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/content/incomplete/08_series.ipynb b/content/incomplete/08_series.ipynb new file mode 100644 index 0000000..443ef69 --- /dev/null +++ b/content/incomplete/08_series.ipynb @@ -0,0 +1,307 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Extracting columns from a DataFrame as a Pandas Series object\n", + "\n", + "In the video I was working in the old file, but I thought it was actually getting a bit long, so here is a shorter one. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's start by importing the libraries that we need:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# import the pandas library\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's load the gapminder dataset:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# read the gapminder data and save it as a DataFrame object called 'gapminder'\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To view the dataset we have just loaded, we can type the name of the variable that we saved it in:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# take a look at gapminder\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extracting columns from a DataFrame" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are several ways to extract a column from a DataFrame. \n", + "\n", + "### Method 1: Using square brackets\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# use the `df['colname']` syntax to extract the 'year' column\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Method 2: Using the column attribute with `.`\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# use the df.colname syntax to extract the 'year' column\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The Pandas Series object" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Save the `year` column from gapminder as a variable called `year`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# define a variable called year and assign to it the 'year' column of gapminder\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# take a look at the year variable\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What is the type of `year`? \n", + "\n", + "The answer is a **Pandas Series** object:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# check the type of year using type()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Series objects are like 1-column Dataframe objects, but they don't have a `columns` attribute like a DataFrame does:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# try to extract the columns attribute from the year object\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The Series index\n", + "\n", + "They do however have an `index` (row name) attribute, which is inherited from the DataFrame from which the Series came:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# extract the index attribute from the year object\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The vectorized nature of Series objects\n", + "\n", + "The nice thing about Pandas Series objects is that they are **vectorized**. \n", + "\n", + "This means that when you apply simple mathematical operations to them, the operation will be applied to *every* entry in the Series. For example, if we add `5` to the `year` Series object, `5` will be added to *every* value in the `year` Series object:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Try to add 5 to year\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Similarly, if we raise `lifeExp` to the power of 2, this computation will be applied to every single value in the Series object:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Try to raise the lifeExp column of gapminder to the power of 2\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also apply the numpy mathematical functions in a vectorized way to Series objects:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Try to compute the logarithm of the gdpPercap column of gapminder\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is important to note that this behaviour, while it seeems natural, is not exhibited in other Python object types, such as lists (more on lists in a future video)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also ask boolean/logical questions of each value in a Series object simultaneously. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ask which entries in the year column of gapminder equal 2007\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ask which entries in the lifeExp column are greater or equal to 60\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise\n", + "\n", + "1. Extract the `country` and `continent` columns from gapminder and create a Series object that contains the country and continent values separated by a comma, e.g., the first few entries should be \"Afghanistan, Asia\"." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Extract the `pop` and `gdpPercap` columns from gapminder and create a Series object that contains the total GDP for each country. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/content/incomplete/09_subsetting.ipynb b/content/incomplete/09_subsetting.ipynb new file mode 100644 index 0000000..41ac65c --- /dev/null +++ b/content/incomplete/09_subsetting.ipynb @@ -0,0 +1,227 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Extracting subsets of data frames\n", + "\n", + "In this notebook, we will learn how to manipulate pandas DataFrame objects, starting with extracting subsets." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# import pandas\n", + "\n", + "# load the gapminder dataset and save as `gapminder`\n", + "\n", + "# take a look at the head of gapminder\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Extracting multiple columns\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# try to extract two columns: country and gdpPercap from gapminder using the `df[]` notation with two column names\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `df[]` syntax expects only one value (or object) inside the square parentheses. \n", + "\n", + "Fortunately, you can provide multiple column names as a single **list** object." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# create a list containing the names of the columns we want to extract: 'country' and 'gdpPercap' \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can extract both the country and gdpPercap columns by providing this *list* in the indexing square parentheses" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# provide the list of names inside the `df[]` notation to extract the two columns from gapminder\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The `.loc` indexer\n", + "\n", + "An alternative (and ultimately more flexible) approach to subsetting a Pandas DataFrame is to use the `.loc` indexer. \n", + "\n", + "With `.loc`, the square brackets expect *two* values: one for the *row* index and one for the *column* index. \n", + "\n", + "The general syntax is `df.loc[rows, cols]`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Use `df.loc[,]` to extract the entry with row index 3 from the 'gdpPercap' column\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using `:` with `.loc` to select all rows/columns\n", + "\n", + "If you want to extract all rows (or columns), you can replace the corresponding index entry with `:`. So the following code will extract all rows for the `gdpPercap` column:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Use `df.loc[,]` to extract all rows from the 'gdpPercap' column\n", + "\n", + "# what are two other ways that you could do this same thing?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you want to extract multiple columns (or rows), you still need to provide all of the index values that you want to extract in a list." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# use `df.loc[,]` to extract all rows for the 'country' and 'gdpPercap' columns\n", + "\n", + "# what is another way to do the same thing?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# extract the rows with index 4, 5, 6, 7, and 8 for the country and gdpPercap columns\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If your index corresponds to a sequence of integers, you can instead provide a \"range\" object:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# use the `range()` function to simplify the code in the previous cell\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using `.loc` with non-numeric indexes\n", + "\n", + "Let's create `gapminder_country`, whose row index corresponds to the country variable:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# define gapminder_country as a new dataframe with the country column as the row index\n", + "\n", + "# look at gapminder_country\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# use the `df.loc[,]` notation to extract the rows for Germany for the gdpPercap column\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise\n", + "\n", + "1. Extract the population and year columns for Australia using `gapminder_country`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2. Extract the 'country' and 'lifeExp' columns for the first, second, and third rows of `gapminder_country`." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/content/incomplete/10_filtering_logical.ipynb b/content/incomplete/10_filtering_logical.ipynb new file mode 100644 index 0000000..9974f19 --- /dev/null +++ b/content/incomplete/10_filtering_logical.ipynb @@ -0,0 +1,158 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Filtering using logical operations and `.loc`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# import pandas\n", + "\n", + "# load the gapminder dataset\n", + "\n", + "# take a look at the head of gapminder\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Filtering with `.loc` using a boolean series\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Recall that you can create a **boolean series** based on a **logical condition** on a column from a DataFrame. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# use a boolean operation to identify which rows have the value 'Australia' in the 'country' column \n", + "# save the result as australia_index\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "We can use this boolean series to subset/filter the rows of our DataFrame by providing it in the row indexing position of the `.loc` indexer. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# use .loc and australia_index to select only the rows corresponding to Australia\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The simpler `df[]` syntax can be used to filter *either* the columns or the rows, but not both at the same time. \n", + "\n", + "If you provide a list of column names, Pandas will know that you are trying to subset to those *columns*, whereas if you provide a boolean series whose length equals the number of rows, Pandas will know that you are trying to subset the *rows*. \n", + "\n", + "But just looking at the code, if you don't know what the data looks like, it is very hard to tell if the syntax below is subsetting the rows or the columns." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# using the single-bracket `df[]` syntax:\n", + "gapminder[australia_index]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This it is recommended that you use the `.loc` indexing syntax, which has an explicit position for the row subsetting and the column subsetting: `df.loc[row_index,column_index]`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Rather than defining a separate indexing series object for filtering the rows (like `australia_index`), it is common to just put the logical filtering condition directly in the indexing syntax:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# directly use logical conditioning inside .loc to select only the rows corresponding to Australia\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Multiple conditions\n", + "\n", + "You can provide multiple row filtering conditions by separating them with an `&`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# provide multiple logical conditions in `.loc` to filter the rows so that only rows corresponding to Australia after 1990 are selected\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise\n", + "\n", + "Extract the subset of the data corresponding to Asian countries for which the life expectancy is at least 75." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/content/incomplete/11_filtering_query.ipynb b/content/incomplete/11_filtering_query.ipynb new file mode 100644 index 0000000..b3b2329 --- /dev/null +++ b/content/incomplete/11_filtering_query.ipynb @@ -0,0 +1,155 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Filtering the rows using the `.query` method\n", + "\n", + "In this section, we will introduce another row filtering approach using the `.query()` method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# import pandas\n", + "\n", + "# load the gapminder dataset\n", + "\n", + "# take a look at the head of gapminder\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As a reminder, so far we have learned:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# filter to Australia using a logical condition inside `gapminder[]`\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# filter to Australia using a logical condition inside `gapminder.loc[,]`\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Filtering using `.query()`\n", + "\n", + "The `.query()` method does the same thing, but the syntax is a bit different. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# filter to Australia using a logical string expression inside query\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### External variables in the `.query()` method\n", + "\n", + "Note that if you want to use an \"external\" variable in your filtering query, you need to access it within the argument using `@variable_name`. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# define a variable, selected_country, and assign it the string 'Brazil'\n", + "\n", + "# use query with @ to filter gapminder to selected_country\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Combining `.query()` with `.loc`\n", + "\n", + "Note that since `gapminder.query()` outputs a DataFrame itself, you can follow a query method call with further subsetting, e.g., using `.loc[]`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Use .query() to filter to the selected country and then use df.loc[,] to select the year and lifeExp columns\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note, however, that you cannot reverse the order of the `.loc` indexer and the `query()` method in this case." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Try to use .loc[,] to select the year and lifeExp columns and then use .query() to filter to the selected country\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise\n", + "\n", + "Use the query method to filter to the gapminder data to the year 2007, and return just the `country` and `lifeExp` columns.\n", + "\n", + "Then do the same thing using only the `.loc` indexer." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/content/incomplete/12_iloc.ipynb b/content/incomplete/12_iloc.ipynb new file mode 100644 index 0000000..9227a49 --- /dev/null +++ b/content/incomplete/12_iloc.ipynb @@ -0,0 +1,180 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Subsetting with the `.iloc` indexer\n", + "\n", + "The `.iloc` indexer allows you to do positional indexing, whereas `.loc` required that you do named indexing. The fact that we could provide integer positions to the `.loc` indexer previously was a result of the fact that the row index values of the `gapminder` DataFrame were themselves integer values.\n", + "\n", + "Let's take a quick look at the gapminder dataset (notice that the row index consists of integers):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# import pandas\n", + "\n", + "# load the gapminder dataset\n", + "\n", + "# take a look at the head of gapminder\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A `.loc[,]` reminder:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# use .loc[,] to subset row with index 1, 4, 5 and columns `year', 'lifeExp', 'pop' from gapminder\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define the `gapminder_country` DataFrame that has the `country` column as the row index:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# create gapminder_country dataframe with country as index\n", + "\n", + "# look at the head of gapminder_country\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Positional indexing with `.iloc`\n", + "\n", + "Now let's try and extract the rows 1, 4, and 5 and the columns `'year'`, `'lifeExp'`, and `'pop'` from this country-indexed version of gapminder:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Try to use .loc[,] to subset row with index 1, 4, 5 and columns `year', 'lifeExp', 'pop' from gapminder_country\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We get an error, because there are no longer any rows with row index names 1, 4, 5.\n", + "\n", + "If you want to do positional indexing, use `.iloc`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Use .iloc to extract the 3rd row and 3rd column (i.e., index position of 2) of gapminder_country using positional indexing\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can subset to multiple rows and column by providing a list of row/column positions to the corresponding entry of the `.iloc` indexer. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Use .iloc to extract rows in position 2, 5, 7, and the columns in position 1 and 3\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Using `:` to mean all rows/columns\n", + "\n", + "We can also use the `:` placeholder for \"all rows\" or \"all columns\". " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Use .iloc to extract all rows for columns 0, 3, 5\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### More general sequences with `start:stop:step`\n", + "\n", + "`start:stop:step`, e.g., `0:20:2`, will similarly correspond to a list of integers from 0 up to 20 (non-inclusive) with a step size of 2, so 0, 2, 4, 6, ..., 18. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Use .iloc to extract rows 0, 2, 4, 6, ..., 18 (inclusive) for columns 0 to 3 (inclusive)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise\n", + "\n", + "Use `iloc` to extract every third row starting at index position 2 up to position 100, and the first two columns. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/content/incomplete/13_modifying_dataframes.ipynb b/content/incomplete/13_modifying_dataframes.ipynb new file mode 100644 index 0000000..3f037be --- /dev/null +++ b/content/incomplete/13_modifying_dataframes.ipynb @@ -0,0 +1,345 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Adding and dropping columns from DataFrames" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This document will demonstrate how to add and remove columns from a DataFrame" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# import pandas\n", + "\n", + "# load the gapminder dataset\n", + "\n", + "# take a look at the head of gapminder\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Creating a new column in a DataFrame" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# compute the product of the pop and gdpPercap columns\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's add a new column `gdp` which is the product of the `pop` and `gdpPercap` columns:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# add a new column to gapminder corresponding to the product of the values in the 'pop' and 'gdpPercap' columns\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Has the original gapminder object changed?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Removing a column from a DataFrame using `.drop()`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To remove a column from a DataFrame, you can use the pandas `.drop` method. \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# try to remove gdp from gapminder using the df.drop(columns=) method\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# did the original gapminder data object change?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "To update the `gapminder` DataFrame to be the version without the `gdp` column, you need to overwrite the `gapminder` object by assigning it to be the version without `gdp` as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# overwrite gapminder with the output of the df.drop(columns=) method\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# now look at the gapminder data object - has it changed?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Creating a copy of a DataFrame object" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Suppose that you want to keep an unmodified copy of the original `gapminder` DataFrame object in your environment, and create a different version, called `gapminder_new`, that you can modify as much as you like. \n", + "\n", + "You might try to create a new variable `gapminder_new` that contains the original `gapminder` DataFrame as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# define gapminder_new and set it equal to gapminder\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Indeed, `gapminder_new` contains the same DataFrame object as `gapminder`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# take a look at gapminder_new\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's add a `GDP` column to this new `gapminder_new` DataFrame object:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Define a new column in gapminder_new called 'GDP' that is equal to the product of the 'pop' and 'gdpPercap' columns\n", + "\n", + "# take a look at gapminder_new\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# take a look at the original gapminder object -- has it changed?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What's going on here?\n", + "\n", + "Let's revert the `gapminder` DataFrame object to the original dataset by re-loading the csv file:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# read in gapminder again to revert to the original dataset\n", + "gapminder = pd.read_csv('data/gapminder.csv')\n", + "gapminder" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The `.copy()`` method\n", + "\n", + "The problem, is that when you write `gapminder_new = gapminder`, this is creating a new \"pointer\" to the `gapminder` DataFrame: `gapminder_new` acts as an \"alias\" for the original `gapminder` DataFrame. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The way to create an independent copy of a DataFrame, use the Pandas `.copy()` method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# define gapminder_new this time as a copy of gapminder\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's add a new column to `gapminder_new` called `gdp_new`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# add a column, gdp_new, to gapminder_new that is equal to the product of the 'pop' and 'gdpPercap' columns\n", + "\n", + "# take a look at gapminder_new\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# check whether the original gapminder object has changed\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise \n", + "\n", + "Create a version of gapminder called `gapminder_gdp` that contains three columns: country, year, and gdp (the GDP for each country-year in millions). Make sure that the original `gapminder` DataFrame is not modified." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Modifying existing columns of a DataFrame" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `df['col'] = ...` syntax can be used not only to add new columns, but also to modify existing columns." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Round the lifeExp column values to the nearest integer:\n", + "# -------------\n", + "# import numpy\n", + "\n", + "# apply np.round() to the 'lifeExp' column of gapminder\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Update the existing `lifeExp` column with this rounded version as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# update the lifeExp column of gapminder with the rounded version\n", + "\n", + "# look at gapminder\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/content/incomplete/14_summarizing_dataframes.ipynb b/content/incomplete/14_summarizing_dataframes.ipynb new file mode 100644 index 0000000..c2d05a1 --- /dev/null +++ b/content/incomplete/14_summarizing_dataframes.ipynb @@ -0,0 +1,298 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Summarizing DataFrames\n", + "\n", + "This notebook will demonstrate how to apply simple statistical methods, such as the mean, sum, median, standard deviation (for numeric columns), and counts (for categorical columns) to columns in a pandas DataFrame." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "gapminder = pd.read_csv('data/gapminder.csv')\n", + "gapminder" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To apply a statistical summary such as the mean to a single column from a DataFrame, you first need to extract the column of interest, e.g., using the `df['col']` syntax, and then apply the relevant method (e.g., `.mean()`) to the resulting Series object.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Calculating the mean\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Use the .mean() method to compute the mean of the lifeExp column\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that `.mean()` is a *method*, rather than a function" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Try to use mean() as a function to compute the mean of lifeExp\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can apply `.mean()` to multiple columns at once by extracting the relevant columns (e.g., using `df[[]]` or `df.loc[,]`), and then applying `.mean()` to the resulting DataFrame:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# use the .mean() method to compute the mean of both the lifeExp and gdpPercap columns simultaneously\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What is the type of the object returned by `.mean()`?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Check the type of the result above\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since `.mean()` can be applied to multiple columns at once, why is it that applying `.mean()` directly to `gapminder` doesn't work? " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# what happens when you try to apply the .mean() method to the entire gapminder DataFrame?\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# show gapminder to try to figure out why the above command failed\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Extracting columns of a particular type\n", + "\n", + "You can extract all of the numeric columns of gapminder using the `.select_dtypes()` method, and then apply the `.mean()` method to the resulting DataFrame:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# apply the .mean() method to the gapminder DataFrame\n", + "# but only to the columns of type 'number' extracted using .select_dtypes()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### Other statistical summaries: sum, median, std\n", + "\n", + "The sum:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# apply the .sum() method to the gapminder DataFrame, but only to the columns of type 'number'\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The median:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# apply the .median() method to the gapminder DataFrame, but only to the columns of type 'number'\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The standard deviation:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# apply the .std() method to the gapminder DataFrame, but only to the columns of type 'number'\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Counting the number of unique categorical values with the `value_counts()` method\n", + "\n", + "While the above methods can only be used for numeric (float or integer) columns, there are some summaries that you can use for categorical columns too. \n", + "\n", + "The `.value_counts()` method will compute the number of times each unique value appears in a column." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# apply the .value_counts() method to the country column of the gapminder DataFrame\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And the `continent` column:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# apply the .value_counts() method to the continent column of the gapminder DataFrame\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise\n", + "\n", + "Compute the average life expectancy for all countries in Asia in the year 1992." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Standardizing a DataFrame" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's create a version of gapminder that just contains the numeric columns:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# create gapminder_numeric, a subset of gapminder that contains only the columns of type 'number'\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that Pandas' will perform mathematical operations column-wise, so standardization can be done by subtracting the mean and dividing by the standard deviation:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# create gapminder_std, which contains the standardized values of gapminder_numeric\n", + "\n", + "# look at gapminder_std" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/content/incomplete/15_grouped_computations.ipynb b/content/incomplete/15_grouped_computations.ipynb new file mode 100644 index 0000000..50b4ecd --- /dev/null +++ b/content/incomplete/15_grouped_computations.ipynb @@ -0,0 +1,93 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Grouped Computations for DataFrames" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "gapminder = pd.read_csv('data/gapminder.csv')\n", + "# create a version of gapminder with only the numeric columns called `gapminder_numeric`\n", + "gapminder_numeric = gapminder.select_dtypes(include='number').copy()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The `.groupby()` method\n", + "\n", + "Sometimes we want to compute a summary separately for different groups (where the groups might be defined by the unique values in a column).\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Apply the .mean() method to gapminder_numeric\n", + "\n", + "# Apply the .mean() method to gapminder_numeric, but group by the 'year' column.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Grouping by multiple columns\n", + "\n", + "We can group by multiple columns at once by providing a *list* of the column names to the `.groupby()` method." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# group by the year and continent columns and compute the mean of the lifeExp column\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise\n", + "\n", + "1. Compute the maximum population for each country\n", + "\n", + "2. Compute the mean gdpPercap for each continent averaged across all years after 1990" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/content/incomplete/16_visualization.ipynb b/content/incomplete/16_visualization.ipynb new file mode 100644 index 0000000..4cd6cab --- /dev/null +++ b/content/incomplete/16_visualization.ipynb @@ -0,0 +1,146 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Visualizing DataFrames\n", + "\n", + "In this notebook, we will use the pandas visualization methods to visualize our DataFrames. We will also touch on other visualization libraries that allow you to create more advanced and customized figures." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "gapminder = pd.read_csv('data/gapminder.csv')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Pandas visualization methods\n", + "\n", + "Pandas has a few methods that allow you to quickly create visualizations from your DataFrame. We will use the `plot` method to create a few plots.\n", + "\n", + "The general syntax is `df.plot(kind=)`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Use `df.plot` to create a scatterplot of gdpPercap vs lifeExp\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Use `df.plot` to create a barplot of the number of countries in each continent\n", + "# Hint: use value_counts() first to get the counts\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# create a histogram of the life expectancy\n", + "# Hint: extract the lifeExp column first\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### The Seaborn library\n", + "\n", + "The inbuilt Pandas plotting functionalities are somewhat limited in what they can do.\n", + "\n", + "If you want to create more sophisticated visualizations, you'll want to use another library. One of the most popular libraries for data visualization is [Seaborn](https://seaborn.pydata.org/)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Import seaborn\n", + "\n", + "\n", + "# Use seaborn to create a scatterplot of gdpPercap vs lifeExp\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# create a version of the above scatterplot for just the year 2007, \n", + "# where the color is based on continent \n", + "# and the size is based on population\n", + "# and the size range is from 20 to 500\n", + "# and the transparency is 0.7\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Creating bar charts and histograms with seaborn is also fairly straightforward" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# create a bar chart of the number of countries in each continent using sns.countplot()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# create a histogram of lifeExp using sns.histplot()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}