{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Analyzing Kaggle Survey 2020 in a structured way\n", "\n", "Yao-Jen Kuo from [DATAINPOINT](https://datainpoint.substack.com/about)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Prerequisite libraries" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## TL; DR\n", "\n", "In this notebook, we define a class `KaggleSurvey2020` that is able to help us analyze the Kaggle Survey 2020 in a more structured way and shows how to conduct data analysis with OOP besides using the traditional procedural programming way." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Pain point\n", "\n", "The original Kaggle Survey 2020 data contains 354 columns with 47 questions combined with multiple choice and multiple selection questions. It is definitely painful and tedious to explore without the aids of re-usable codes like functions or classes." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The `KaggleSurvey2020` class\n", "\n", "We will define 3 major methods of `KaggleSurvey2020` to analyze both survey responses and questions.\n", "\n", "1. The `generate_unique_questions` method: Returns a dataframe that maps question numbers to their descriptions and questions types.\n", "2. The `summarize_response(question_index)` method: Returns an aggregation summary of a given question. For a multiple choice problem (only a single choice can be selected) this method returns a series of percentages. As for a multiple selection problem (multiple choices can be selected) this method return a series of value counts.\n", "3. The `plot_summary(question_index)` method: Plots a horizontal bar plot that illustrates the aggregation summary of a given question." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "class KaggleSurvey2020:\n", " \"\"\"\n", " This class helps us analyze the Kaggle Survey 2020 with ease.\n", " See https://www.kaggle.com/c/kaggle-survey-2020\n", " Args:\n", " csv_file (str): Specify the file path of kaggle_survey_2020_responses.csv.\n", " \"\"\"\n", " def __init__(self, csv_file):\n", " self._csv_file = csv_file\n", " # import survey responses\n", " survey_response = pd.read_csv(self._csv_file, skiprows=[1])\n", " survey_response = survey_response.drop('Time from Start to Finish (seconds)', axis=1)\n", " # import survey questions\n", " first_2_rows = pd.read_csv(self._csv_file, nrows=1)\n", " question_desc = first_2_rows.values.ravel()[1:]\n", " question_index = first_2_rows.columns[1:]\n", " questions_ser = pd.Series(question_desc, index=question_index)\n", " self._survey_response = survey_response\n", " self._questions_ser = questions_ser\n", " def generate_questions(self):\n", " \"\"\"\n", " This function returns the DataFrame of questions.\n", " \"\"\"\n", " question_indices = [l[0] + l[1] if len(l) > 1 else l[0] for l in self._questions_ser.index.str.split(\"_\")]\n", " question_indices = [s.replace('Part', '') if 'Part' in s else s for s in question_indices]\n", " question_indices = [s.replace('OTHER', '') if 'OTHER' in s else s for s in question_indices]\n", " questions = pd.DataFrame()\n", " questions['question_index'] = question_indices\n", " questions['question_desc'] = self._questions_ser.values\n", " return questions\n", " def generate_unique_questions(self):\n", " \"\"\"\n", " This function returns the DataFrame of unique questions.\n", " \"\"\"\n", " questions = self.generate_questions()\n", " question_indices = questions['question_index'].values\n", " question_descs = [l[0] for l in self._questions_ser.str.split(' - ')]\n", " # Collecting unique questions indices and descriptions\n", " unique_question_indices = []\n", " unique_question_descs = []\n", " for qi, qd in zip(question_indices, question_descs):\n", " if qi not in unique_question_indices:\n", " unique_question_indices.append(qi)\n", " if qd not in unique_question_descs:\n", " unique_question_descs.append(qd)\n", " # Categorizing question type\n", " question_types = ['multiple selection' if 'Select all that apply' in s else 'multiple choice' for s in unique_question_descs]\n", " unique_questions = pd.DataFrame()\n", " unique_questions['question_index'] = unique_question_indices\n", " unique_questions['question_desc'] = unique_question_descs\n", " unique_questions['question_type'] = question_types\n", " return unique_questions\n", " def summarize_response(self, question_index):\n", " \"\"\"\n", " This function returns the summary of a given question.\n", " Args:\n", " question_index (str): Specify the question, e.g. 'Q1' for Question 1, 'Q26A' for Question 26-A.\n", " \"\"\"\n", " questions = self.generate_questions()\n", " column_iloc = questions[questions['question_index'] == question_index].index\n", " ith_question = self._survey_response.iloc[:, column_iloc]\n", " unique_questions = self.generate_unique_questions()\n", " ith_unique_question = unique_questions[unique_questions['question_index'] == question_index]\n", " question_desc = ith_unique_question['question_desc'].values[0]\n", " print(question_desc)\n", " # Use simple value_counts for multiple choice questions\n", " if column_iloc.size == 1:\n", " summary = ith_question[question_index].value_counts(normalize=True).sort_values()\n", " # Use iteration for multiple selection questions\n", " else:\n", " freq_counts = dict()\n", " for col in ith_question.columns:\n", " ser = ith_question[col]\n", " ser_value_counts = ser.value_counts()\n", " k, v = ser_value_counts.index[0], ser_value_counts.values[0]\n", " freq_counts[k] = v\n", " summary = pd.Series(freq_counts).sort_values()\n", " return summary\n", " def plot_summary(self, question_index):\n", " \"\"\"\n", " This function plots the bar plot of a given question.\n", " Args:\n", " question_index (str): Specify the question, e.g. 'Q1' for Question 1, 'Q26A' for Question 26-A.\n", " \"\"\"\n", " fig = plt.figure()\n", " axes = plt.axes()\n", " response_ser = self.summarize_response(question_index)\n", " # Showing only top 10 categories if there are too many.\n", " if response_ser.size > 10:\n", " print(\"Too many categories, only showing the top 10.\")\n", " top_ten = response_ser[-10:]\n", " y = top_ten.index\n", " width = top_ten.values\n", " else:\n", " y = response_ser.index\n", " width = response_ser.values\n", " # Highlight top 3 with red\n", " colors = ['c' for _ in range(y.size)]\n", " colors[-3:] = ['r', 'r', 'r']\n", " axes.barh(y, width, color=colors)\n", " axes.spines['right'].set_visible(False)\n", " axes.spines['top'].set_visible(False)\n", " axes.tick_params(length=0)\n", " unique_questions = self.generate_unique_questions()\n", " ith_unique_question = unique_questions[unique_questions['question_index'] == question_index]\n", " question_desc = ith_unique_question['question_desc'].values[0]\n", " axes.set_title(question_desc)\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Summarizing survey questions\n", "\n", "The Kaggle Survey 2020 contains two types of question: multiple choice questions (only a single choice can be selected) and multiple selection questions (multiple choices can be selected). We can generate an overview of Kaggle Survey 2020 questions with our pre-defined class." ] }, { "cell_type": "code", "execution_count": 3, "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", "
question_indexquestion_descquestion_type
0Q1What is your age (# years)?multiple choice
1Q2What is your gender?multiple choice
2Q3In which country do you currently reside?multiple choice
3Q4What is the highest level of formal education ...multiple choice
4Q5Select the title most similar to your current ...multiple choice
\n", "
" ], "text/plain": [ " question_index question_desc \\\n", "0 Q1 What is your age (# years)? \n", "1 Q2 What is your gender? \n", "2 Q3 In which country do you currently reside? \n", "3 Q4 What is the highest level of formal education ... \n", "4 Q5 Select the title most similar to your current ... \n", "\n", " question_type \n", "0 multiple choice \n", "1 multiple choice \n", "2 multiple choice \n", "3 multiple choice \n", "4 multiple choice " ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "csv_file = 'kaggle_survey_2020_responses.csv'\n", "ks = KaggleSurvey2020(csv_file)\n", "unique_questions = ks.generate_unique_questions()\n", "unique_questions.head()" ] }, { "cell_type": "code", "execution_count": 4, "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", "
question_indexquestion_descquestion_type
42Q29BWhich of the following big data products (rela...multiple selection
43Q31BWhich of the following business intelligence t...multiple selection
44Q33BWhich categories of automated machine learning...multiple selection
45Q34BWhich specific automated machine learning tool...multiple selection
46Q35BIn the next 2 years, do you hope to become mor...multiple selection
\n", "
" ], "text/plain": [ " question_index question_desc \\\n", "42 Q29B Which of the following big data products (rela... \n", "43 Q31B Which of the following business intelligence t... \n", "44 Q33B Which categories of automated machine learning... \n", "45 Q34B Which specific automated machine learning tool... \n", "46 Q35B In the next 2 years, do you hope to become mor... \n", "\n", " question_type \n", "42 multiple selection \n", "43 multiple selection \n", "44 multiple selection \n", "45 multiple selection \n", "46 multiple selection " ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "unique_questions.tail()" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "multiple selection 28\n", "multiple choice 19\n", "Name: question_type, dtype: int64\n" ] } ], "source": [ "n_questions = unique_questions.shape[0]\n", "question_summary = unique_questions['question_type'].value_counts()\n", "n_multiple_choice = question_summary['multiple choice']\n", "n_multiple_selection = question_summary['multiple selection']\n", "print(question_summary)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "There are 19 multiple choices and 28 multiple selections among 47 questions.\n" ] } ], "source": [ "print(\"There are {} multiple choices and {} multiple selections among {} questions.\".format(n_multiple_choice, n_multiple_selection, n_questions))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Summarizing survey responses\n", "\n", "We are able to summarize each question (no matter it is a multiple choice or a multiple selection) with the method `summarize_response(question_index)`. Take 2 multiple choice questions as examples, we can summarize the responses with a series of percentages." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Select the title most similar to your current role (or most recent title if retired):\n" ] }, { "data": { "text/plain": [ "DBA/Database Engineer 0.006484\n", "Statistician 0.015044\n", "Data Engineer 0.022670\n", "Product/Project Manager 0.035898\n", "Business Analyst 0.041396\n", "Machine Learning Engineer 0.056129\n", "Research Scientist 0.060902\n", "Data Analyst 0.076516\n", "Currently not employed 0.085698\n", "Other 0.090107\n", "Software Engineer 0.102091\n", "Data Scientist 0.138818\n", "Student 0.268247\n", "Name: Q5, dtype: float64" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Select the title most similar to your current role (or most recent title if retired):\n", "ks.summarize_response('Q5')" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "What programming language would you recommend an aspiring data scientist to learn first?\n" ] }, { "data": { "text/plain": [ "Swift 0.000954\n", "Bash 0.001459\n", "None 0.004545\n", "Javascript 0.004938\n", "Julia 0.006790\n", "Other 0.008473\n", "Java 0.009371\n", "MATLAB 0.010942\n", "C 0.016890\n", "C++ 0.018237\n", "SQL 0.047640\n", "R 0.070647\n", "Python 0.799113\n", "Name: Q8, dtype: float64" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# What programming language would you recommend an aspiring data scientist to learn first?\n", "ks.summarize_response('Q8')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Take other 2 multiple selection questions as examples, we can summarize the responses with a series of value counts." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "What programming languages do you use on a regular basis? (Select all that apply)\n" ] }, { "data": { "text/plain": [ "Swift 198\n", "None 206\n", "Julia 262\n", "Bash 1776\n", "Other 1945\n", "MATLAB 2217\n", "Javascript 2995\n", "C 3315\n", "Java 3367\n", "C++ 3827\n", "R 4277\n", "SQL 7535\n", "Python 15530\n", "dtype: int64" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# What programming languages do you use on a regular basis? (Select all that apply)\n", "ks.summarize_response('Q7')" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Which of the following integrated development environments (IDE's) do you use on a regular basis? (Select all that apply)\n" ] }, { "data": { "text/plain": [ "None 386\n", "Other 1162\n", " Vim / Emacs 1502\n", " MATLAB 1604\n", "Visual Studio 2445\n", " Sublime Text 2452\n", " Notepad++ 3132\n", " Spyder 3290\n", " RStudio 3826\n", " PyCharm 5099\n", "Visual Studio Code (VSCode) 5873\n", "Jupyter (JupyterLab, Jupyter Notebooks, etc) 11211\n", "dtype: int64" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Which of the following integrated development environments (IDE's) do you use on a regular basis? (Select all that apply)\n", "ks.summarize_response('Q9')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plotting survey responses\n", "\n", "Besides showing a series of percentages/value counts, we can also plot a horizontal bar plot based on the series by calling the `plot_summary(question_index)` method. If there are too many categories, this method only shows the top 10 most categories." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Select any activities that make up an important part of your role at work: (Select all that apply)\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "ks.plot_summary('Q23')" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Which of the following big data products (relational databases, data warehouses, data lakes, or similar) do you use on a regular basis? (Select all that apply)\n", "Too many categories, only showing the top 10.\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "ks.plot_summary('Q29A')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Conclusion\n", "\n", "The notebook users have long been criticized for not writing re-usable codes. In this notebook, we incorporate object-oriented programming. We are able to demonstrate how to conduct reproducible exploratory analysis with summaries of percentage/value counts and plots by instantiating the `KaggleSurvey2020` class. If you also find it convenient, it is time to add some OO flavor into your own notebook!\n", "\n", "The `KaggleSurvey2020` class can be imported from ks2020.py via the following codes." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "ks2020.KaggleSurvey2020" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from ks2020 import KaggleSurvey2020\n", "\n", "csv_file = 'kaggle_survey_2020_responses.csv'\n", "ks = KaggleSurvey2020(csv_file)\n", "type(ks)" ] } ], "metadata": { "kernelspec": { "display_name": "Python Data Analysis", "language": "python", "name": "pyda" }, "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.6.8" } }, "nbformat": 4, "nbformat_minor": 4 }