Chapter-4.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Chapter-4.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "### **Less fast food, please!**\n",
        "Monday again! You will start working on a new project - analyzing the evolution of obesity through the years. You have a dataset called obesity with the percentage of obesity in different countries and years. The data is also disaggregated by biological sex.\n",
        "\n",
        "Your main goals are to get the mean percentage of obesity by year and sex, and by country and sex. Also, you want to get the difference between years.\n",
        "\n",
        "You notice that the dataset has multiple indices, so you know you will have to unstack levels to accomplish your goal.\n",
        "\n",
        "The obesity DataFrame is available in your session."
      ],
      "metadata": {
        "id": "lszBSAJo1HFb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "i. Reshape the obesity DataFrame by unstacking the first level, then get the mean value of the columns."
      ],
      "metadata": {
        "id": "C6vQDvYv1MDF"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NMx7KAoF07cs"
      },
      "outputs": [],
      "source": [
        "# Unstack the first level and calculate the mean of the columns\n",
        "print(obesity)\n",
        "obesity_general = obesity.unstack(level=0).mean(axis=1)\n",
        "\n",
        "# Print obesity_general\n",
        "print(obesity_general)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "ii. Define an obesity_mean DataFrame by unstacking the second level of obesity and getting the mean value for the columns."
      ],
      "metadata": {
        "id": "bbSEc1vB1PgV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Unstack the second level and calculate the mean of the columns\n",
        "obesity_mean = obesity.unstack(level=1).mean(axis=1)\n",
        "\n",
        "# Print obesity_mean\n",
        "print(obesity_mean)"
      ],
      "metadata": {
        "id": "feTem__H1SZt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "iii. Lastly, unstack the third level of the obesity DataFrame, then get the difference between the columns using .diff()."
      ],
      "metadata": {
        "id": "8N0aDyA_1ZeK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Unstack the third level and calculate the difference between columns\n",
        "obesity_variation = obesity.unstack(level=2).diff(axis=1)\n",
        "\n",
        "# Print obesity_variation\n",
        "print(obesity_variation)"
      ],
      "metadata": {
        "id": "5y8K3BAv1aK3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Only going up**\n",
        "After your last analysis, you are excited to keep working with the obesity dataset. You have added an extra column, the variation column, which indicates the range in which the percentage varies through regions in the same country. You are not sure if the mean is the best metric to summarize obesity levels.\n",
        "\n",
        "So you decide to explore the median percentage and variation of obesity by year and biological sex. Also, you want to get the maximum percentage observed by country, year, and biological sex.\n",
        "\n",
        "The DataFrame obesity is available in your session. Make sure to examine it in the console!"
      ],
      "metadata": {
        "id": "KNUqNPy91cPU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "i. Stack the obesity DataFrame, get the median value of the columns, and finally, unstack it again."
      ],
      "metadata": {
        "id": "wMyTqViT1lAZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Stack obesity, get median of columns and unstack again\n",
        "print(obesity)\n",
        "median_obesity = obesity.stack().median(axis=1).unstack()\n",
        "\n",
        "# Print median_obesity\n",
        "print(median_obesity)"
      ],
      "metadata": {
        "id": "RHlNJvDx1ifj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "ii. Stack obesity by the first level, get the sum of the columns, and finally, unstack the DataFrame by the second level."
      ],
      "metadata": {
        "id": "YFEuWx5F1nrq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Stack the first level, get sum, and unstack the second level\n",
        "obesity_sum = obesity.stack(level=0).sum(axis=1).unstack(level=1)\n",
        "\n",
        "# Print obesity_max\n",
        "print(obesity_sum)"
      ],
      "metadata": {
        "id": "kf0mg5uT1qgq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **A group analysis**\n",
        "You are almost done working for the day, but there is an extra analysis you want to do. You want to know if the mean and median percentage of obesity by country are different.\n",
        "\n",
        "You analyze the DataFrame obesity. You realize that country is part of the column labels, so you need to reshape the DataFrame so country is part of the index.\n",
        "\n",
        "You want to take a different approach. You will perform the desired calculations, combining the stacking process and .groupby() function.\n",
        "\n",
        "The obesity DataFrame is available in your session. Make sure to examine it in the console!"
      ],
      "metadata": {
        "id": "im69bUsb1tU9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "i. Stack the country level of obesity, group it by country, and take the mean of all the columns."
      ],
      "metadata": {
        "id": "hKDJ-_G71_sf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Stack country level, group by country and get the mean\n",
        "print(obesity)\n",
        "obesity_mean = obesity.stack(level='country').groupby(level='country').mean()\n",
        "\n",
        "# Print obesity_mean\n",
        "print(obesity_mean)"
      ],
      "metadata": {
        "id": "JO-SKjRL18i3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "ii. Stack the country level of obesity, group by country, and take the median of all the columns."
      ],
      "metadata": {
        "id": "MaGxXxuy2Cbj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Stack country level, group by country and get the median \n",
        "obesity_median = obesity.stack(level='country').groupby(level='country').median()\n",
        "\n",
        "# Print obesity_median\n",
        "print(obesity_median)"
      ],
      "metadata": {
        "id": "AClZsvWc2E5e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Merge it all**\n",
        "Time to keep working with the obesity project! You will analyze the mean obesity percentage in different countries, but this time, the obesity DataFrame has a new column named bounds. It contains the minimum and maximum values you can find in different parts of the same country.\n",
        "\n",
        "You notice that these values are given in a list, so you decide that you need to transform that column. You would like to have each element in a new row.\n",
        "\n",
        "The DataFrame obesity is available in your session. Make sure to examine it in the console!\n",
        "\n"
      ],
      "metadata": {
        "id": "OVZnRkbnELnR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "i. Explode the values of the list-like column bounds of the obesity DataFrame to a separate row."
      ],
      "metadata": {
        "id": "DfWm-titEQp5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Explode the values of bounds to a separate row\n",
        "print(obesity)\n",
        "obesity_bounds = obesity['bounds'].explode()\n",
        "\n",
        "# Print obesity_bounds\n",
        "print(obesity_bounds)"
      ],
      "metadata": {
        "id": "bFP2vcEDEOGj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "ii. Merge the resulting Series with the country and perc_obesity columns from the original obesity DataFrame. Use the indexes to perform the operation."
      ],
      "metadata": {
        "id": "2Iq19JBXETRB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Explode the values of bounds to a separate row\n",
        "obesity_bounds = obesity['bounds'].explode()\n",
        "\n",
        "# Merge obesity_bounds with country and perc_obesity columns of obesity using the indexes\n",
        "obesity_final = obesity[['country', 'perc_obesity']].merge(obesity_bounds,right_index=True, left_index=True)\n",
        "\n",
        "# Print obesity_final\n",
        "print(obesity_final)"
      ],
      "metadata": {
        "id": "zYYjmO4IEV_w"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Explode the bounds**\n",
        "You were able to transform the list-like column successfully, but you are not satisfied with the steps you had to take. You want to find an easier way to get the same reshaped DataFrame.\n",
        "\n",
        "You remembered what you learned about exploding list-like columns, and you will apply a new strategy.\n",
        "\n",
        "The same DataFrame obesity is available in your session. It contains the country, perc_obesity, and the column bounds with the minimum and maximum values you can find in different parts of the same country."
      ],
      "metadata": {
        "id": "fEY4SsmfEYS9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "*   Transform the list-like column bounds in the DataFrame obesity to get its elements in different rows.\n",
        "*   Modify the resulting DataFrame by resetting the index, dropping the old one.\n",
        "\n"
      ],
      "metadata": {
        "id": "20jCqZHOEed2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Transform the list-like column named bounds  \n",
        "print(obesity)\n",
        "obesity_explode = obesity.explode('bounds')\n",
        "print(obesity_explode)\n",
        "# Modify obesity_explode by resetting the index \n",
        "obesity_explode.reset_index(drop=True, inplace=True)\n",
        "\n",
        "# Print obesity_explode\n",
        "print(obesity_explode)"
      ],
      "metadata": {
        "id": "h1DzbKsJEd9p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **The good old split**\n",
        "You have to do one last task for the obesity project. Your colleague gave you a new dataset to analyze with which you will perform the same analysis as before.\n",
        "\n",
        "After inspecting the dataset obesity, you realize that you have the same columns as before, but the bounds column is not a list. This time, the column contains two values separated with a hyphen in the form of string.\n",
        "\n",
        "You will process the string and then transform the column.\n",
        "\n",
        "The DataFrame obesity is available in your session."
      ],
      "metadata": {
        "id": "tHYQVXZuEmBS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "i. Split the strings contained in the column bounds, using a hyphen as the delimiter."
      ],
      "metadata": {
        "id": "CrGnUFJ-Eu5B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Split the columns bounds using a hyphen as delimiter\n",
        "print(obesity)\n",
        "obesity_split = obesity['bounds'].str.split('-')\n",
        "\n",
        "# Print obesity_split\n",
        "print(obesity_split)"
      ],
      "metadata": {
        "id": "R6c4ykP4Esg5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "ii. Now, assign the result of splitting the bounds column to the bounds column of obesity ."
      ],
      "metadata": {
        "id": "7ESFR82IExb0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Assign the result of the split to the bounds column\n",
        "obesity_split = obesity.assign(bounds=obesity['bounds'].str.split('-'))\n",
        "\n",
        "# Print obesity\n",
        "print(obesity_split)"
      ],
      "metadata": {
        "id": "rfLjUbAYEzy0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "iii. Transform the list-like column bounds in the resulting DataFrame to get its elements in different rows."
      ],
      "metadata": {
        "id": "oTGOgePDE1cP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Transform the column bounds in the obesity DataFrame\n",
        "obesity_split = obesity.assign(bounds=obesity['bounds'].str.split('-')).explode('bounds')\n",
        "\n",
        "# Print obesity_split\n",
        "print(obesity_split)"
      ],
      "metadata": {
        "id": "5KJsO3_EE4Rp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Nested movies**\n",
        "You are curious about a movies dataset you've had on your computer for some time now that contains data about different movies. You would like to analyze that data, but you realize it's in a nested JSON format.\n",
        "\n",
        "To read it into a DataFrame, you will need to use the function you have just learned. After that, you will reshape the resulting DataFrame to make it easier to work with.\n",
        "\n",
        "The semi-structured JSON named movies is available for you. Make sure to examine it in the console!"
      ],
      "metadata": {
        "id": "aHYPnWmrE9aE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "*   Import the json_normalize() function from pandas.\n",
        "*   Normalize the JSON contained in movies. Separate the names generated from nested records with an underscore.\n",
        "*   Reshape the resulting movies_norm DataFrame from wide to long format, \n",
        "using the director and producer columns as unique indexes. Name the new variable created from the columns movies, starting with features, separated by an underscore with a suffix containing words."
      ],
      "metadata": {
        "id": "OIdEbB0dFFnd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import the json_normalize function\n",
        "from pandas import json_normalize\n",
        "\n",
        "# Normalize movies and separate the new columns with an underscore \n",
        "movies_norm = json_normalize(movies, sep='_')\n",
        "\n",
        "# Reshape using director and producer as index, create movies from column starting from features\n",
        "movies_long = pd.wide_to_long(movies_norm, stubnames='features',i=['director','producer'], j='movies',sep='_', suffix='\\w+')\n",
        "\n",
        "# Print movies_long\n",
        "print(movies_long)"
      ],
      "metadata": {
        "id": "qZ_Z6t5lFClP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **A complex film**\n",
        "You are surprised by your findings from analyzing the movies data, so you find more data to continue the analysis. You explore the data and realize it's in a nested JSON format again.\n",
        "\n",
        "But this time, it's more complex. You would like to read it into a DataFrame. You will take several steps to achieve that.\n",
        "\n",
        "The semi-structured JSON named movies is available for you. Make sure to examine it in the console!\n",
        "\n",
        "The required function for this exercise has been pre-loaded."
      ],
      "metadata": {
        "id": "UDx6V6NNFgmZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "i. Normalize the semi-structured JSON contained in the variable movies."
      ],
      "metadata": {
        "id": "nBNgC26cFpgP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Normalize the JSON contained in movies\n",
        "normalize_movies = json_normalize(movies)\n",
        "\n",
        "# Print normalize_movies\n",
        "print(normalize_movies)"
      ],
      "metadata": {
        "id": "rrL0ubGZFnJy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "ii. Specify that the column called features is the place where the list of records is held."
      ],
      "metadata": {
        "id": "zXDxW6m3FvOg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Specify the features column as the list of records \n",
        "normalize_movies = json_normalize(movies, \n",
        "                                  record_path='features')\n",
        "\n",
        "# Print normalize_movies\n",
        "print(normalize_movies)"
      ],
      "metadata": {
        "id": "kGjVBISCFzRy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "iii. Specify that director and producer columns should be used as metadata for each record in the resulting DataFrame."
      ],
      "metadata": {
        "id": "MR-Rz1nwF2rz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Specify director and producer to use as metadata for each record \n",
        "normalize_movies = json_normalize(movies, \n",
        "                                  record_path='features', \n",
        "                                  meta=['director', 'producer'])\n",
        "\n",
        "# Print normalize_movies\n",
        "print(normalize_movies)"
      ],
      "metadata": {
        "id": "EN96Me5EF5UA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Un-nesting birds**\n",
        "Finally, your job for the day is done, but your colleague asked you a last minute favor. A client has provided data about birds he wants to classify.\n",
        "\n",
        "You examine the data and realize that it's in a bad format - the list of birds is in one file, and the characteristics of the birds are in another.\n",
        "\n",
        "You manage to read the bird names into a list called names. You read the bird facts into another list called bird_facts, but this list contains dictionaries in string format.\n",
        "\n",
        "To have a usable DataFrame, you will need to perform several operations.\n",
        "\n",
        "Both the names and bird_facts lists are available in your session. Make sure to examine it in the console! The json module is pre-loaded."
      ],
      "metadata": {
        "id": "oAyudOtYGCw7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "i. Convert the names and bird_facts lists into columns of a new DataFrame called birds, using the same names."
      ],
      "metadata": {
        "id": "ljXN5E3EGKHz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define birds reading names and bird_facts lists into names and bird_facts columns \n",
        "birds = pd.DataFrame(dict(names=names, bird_facts=bird_facts))\n",
        "\n",
        "# Print birds\n",
        "print(birds)"
      ],
      "metadata": {
        "id": "nLEi8342GE6x"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "ii. Flatten out the dictionary contained in bird_facts column by applying the loads method from json module to the column."
      ],
      "metadata": {
        "id": "rUBS_stAGNRK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define birds reading names and bird_facts lists into names and bird_facts columns\n",
        "birds = pd.DataFrame(dict(names=names, bird_facts=bird_facts))\n",
        "print(birds)\n",
        "# Apply the function json.loads function to the bird_facts column\n",
        "data_split = birds['bird_facts'].apply(json.loads).apply(pd.Series)\n",
        "\n",
        "# Print birds\n",
        "print(data_split)"
      ],
      "metadata": {
        "id": "4jS4bR3lGQao"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "iii. Remove the bird_facts column from the birds DataFrame."
      ],
      "metadata": {
        "id": "JSX_L4suGS-t"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define birds reading names and bird_facts lists into names and bird_facts columns \n",
        "birds = pd.DataFrame(dict(names=names, bird_facts=bird_facts))\n",
        "\n",
        "# Apply to bird_facts column the function loads from json module\n",
        "data_split = birds['bird_facts'].apply(json.loads).apply(pd.Series)\n",
        "\n",
        "# Remove the bird_facts column from birds\n",
        "birds = birds.drop(columns='bird_facts')\n",
        "\n",
        "# Print birds\n",
        "print(birds)"
      ],
      "metadata": {
        "id": "iaiDtfffGVdh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "iv. Concatenate the columns of the birds and data_split DataFrames."
      ],
      "metadata": {
        "id": "i2JrnfN3GaGO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define birds reading names and bird_facts lists into names and bird_facts columns\n",
        "birds = pd.DataFrame(dict(names=names, bird_facts=bird_facts))\n",
        "\n",
        "# Apply to bird_facts column the function loads from json module\n",
        "data_split = birds['bird_facts'].apply(json.loads).apply(pd.Series)\n",
        "\n",
        "# Remove the bird_facts column from birds\n",
        "birds = birds.drop(columns='bird_facts')\n",
        "\n",
        "# Concatenate the columns of birds and data_split\n",
        "birds = pd.concat([birds,data_split], axis=1)\n",
        "\n",
        "# Print birds\n",
        "print(birds)"
      ],
      "metadata": {
        "id": "Fa8EMwixGckm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Don't dump the bird**\n",
        "You want to read the birds data into a DataFrame like you did in the previous exercise, but this time, you would like to try a different approach.\n",
        "\n",
        "You would like to have a code that you can reuse in this situations, so you want to establish the fastest strategy to convert it into a usable DataFrame. You think that working with the json format could speed up the process.\n",
        "\n",
        "The birds DataFrame is available for you."
      ],
      "metadata": {
        "id": "umsmxMO8Gfy8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "i. Flatten out the content of the bird_facts column by applying the loads method from the json module to the column. Transform the result into a list."
      ],
      "metadata": {
        "id": "dXH4ncdUGqLj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Apply json.loads to the bird_facts column and transform it to a list\n",
        "birds_facts = birds['bird_facts'].apply(json.loads).to_list()\n",
        "\n",
        "# Print birds_facts\n",
        "print(birds_facts)"
      ],
      "metadata": {
        "id": "0q3ZciYbGn-o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "ii. Convert the list contained in birds_facts into a JSON format. Assign it to the birds_dump variable."
      ],
      "metadata": {
        "id": "kThYwmeMGtDo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Apply json.loads to the bird_facts column and transform it to a list\n",
        "birds_facts = birds['bird_facts'].apply(json.loads).to_list()\n",
        "\n",
        "# Convert birds_facts into a JSON \n",
        "birds_dump = json.dumps(birds_facts)\n",
        "\n",
        "# Print birds_dump\n",
        "print(birds_dump)"
      ],
      "metadata": {
        "id": "pEutXxL9GvuW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "iii. Now, read the JSON contained in birds_dump into a DataFrame."
      ],
      "metadata": {
        "id": "S1Q_3i6XGyP5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Apply json.loads to the bird_facts column and transform it to a list \n",
        "birds_facts = birds['bird_facts'].apply(json.loads).to_list()\n",
        "\n",
        "# Convert birds_facts into a JSON \n",
        "birds_dump = json.dumps(birds_facts)\n",
        "\n",
        "# Read the JSON birds_dump into a DataFrame \n",
        "birds_df = pd.read_json(birds_dump)\n",
        "\n",
        "# Print birds_df\n",
        "print(birds_df)"
      ],
      "metadata": {
        "id": "CberFDHrG1Dh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "iv. Concatenate the names column of the birds DataFrame with all columns in birds_df."
      ],
      "metadata": {
        "id": "7lE9nuZOG4vb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Apply json.loads to the bird_facts column and transform it to a list \n",
        "birds_facts = birds['bird_facts'].apply(json.loads).to_list()\n",
        "\n",
        "# Convert birds_fact into a JSON \n",
        "birds_dump = json.dumps(birds_facts)\n",
        "\n",
        "# Read the JSON birds_dump into a DataFrame\n",
        "birds_df = pd.read_json(birds_dump)\n",
        "\n",
        "# Concatenate the 'names' column of birds with birds_df\n",
        "birds_final = pd.concat([birds['names'], birds_df], axis=1)\n",
        "\n",
        "# Print birds_final\n",
        "print(birds_final)"
      ],
      "metadata": {
        "id": "aoWKyqZMG-6g"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}