diff --git a/1_Descriptive_Statistics_Museum.ipynb b/1_Descriptive_Statistics_Museum.ipynb index 859c41b..0247d9a 100644 --- a/1_Descriptive_Statistics_Museum.ipynb +++ b/1_Descriptive_Statistics_Museum.ipynb @@ -93,21 +93,22 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "id": "09daec01-9927-45c7-a6d4-9b9d0340ee02", "metadata": {}, "outputs": [], "source": [ "companies = {'musee' : ['1', '2', '3', '4'], # , '101'\n", - " 'sport': ['5', '6', '7', '8', '9'],\n", " 'musique' : ['10', '11', '12', '13', '14']}" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "d9ccb033-3c7a-4647-ae1a-3a439dec2ea1", - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stdout", @@ -136,6 +137,209 @@ "text": [ ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_1/products_purchased_reduced.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_1/target_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + ":27: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_2/customerplus_cleaned.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_2/campaigns_information.csv\n", + "File path : projet-bdc2324-team1/0_Input/Company_2/products_purchased_reduced.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_2/target_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + ":13: DtypeWarning: Columns (3) have mixed types. Specify dtype option on import or set low_memory=False.\n", + ":27: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_3/customerplus_cleaned.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_3/campaigns_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_3/products_purchased_reduced.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_3/target_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + ":13: DtypeWarning: Columns (3) have mixed types. Specify dtype option on import or set low_memory=False.\n", + ":27: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_4/customerplus_cleaned.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_4/campaigns_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_4/products_purchased_reduced.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + ":13: DtypeWarning: Columns (12) have mixed types. Specify dtype option on import or set low_memory=False.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File path : projet-bdc2324-team1/0_Input/Company_4/target_information.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":13: FutureWarning: The argument 'date_parser' is deprecated and will be removed in a future version. Please use 'date_format' instead, or read your data in as 'object' dtype and then call 'to_datetime'.\n", + ":27: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n" + ] } ], "source": [ @@ -144,11 +348,11 @@ "# liste des compagnies de spectacle\n", "nb_compagnie= companies['musee']\n", "\n", - "customer_sport = pd.DataFrame()\n", - "campaigns_sport_brut = pd.DataFrame()\n", - "campaigns_sport_kpi = pd.DataFrame()\n", - "products_sport = pd.DataFrame()\n", - "tickets_sport = pd.DataFrame()\n", + "customer_musee = pd.DataFrame()\n", + "campaigns_musee_brut = pd.DataFrame()\n", + "campaigns_musee_kpi = pd.DataFrame()\n", + "products_musee = pd.DataFrame()\n", + "tickets_musee = pd.DataFrame()\n", "\n", "# début de la boucle permettant de générer des datasets agrégés pour les 5 compagnies de spectacle\n", "for directory_path in nb_compagnie:\n", @@ -177,21 +381,153 @@ " df_products_purchased_reduced[\"customer_id\"]= directory_path + '_' + df_products_purchased_reduced['customer_id'].astype('str') \n", "\n", "# Concaténation\n", - " customer_sport = pd.concat([customer_sport, df_customerplus_clean], ignore_index=True)\n", - " campaigns_sport_kpi = pd.concat([campaigns_sport_kpi, df_campaigns_kpi], ignore_index=True)\n", - " campaigns_sport_brut = pd.concat([campaigns_sport_brut, df_campaigns_brut], ignore_index=True) \n", - " tickets_sport = pd.concat([tickets_sport, df_tickets_kpi], ignore_index=True)\n", - " products_sport = pd.concat([products_sport, df_products_purchased_reduced], ignore_index=True)\n", + " customer_musee = pd.concat([customer_musee, df_customerplus_clean], ignore_index=True)\n", + " campaigns_musee_kpi = pd.concat([campaigns_musee_kpi, df_campaigns_kpi], ignore_index=True)\n", + " campaigns_musee_brut = pd.concat([campaigns_musee_brut, df_campaigns_brut], ignore_index=True) \n", + " tickets_musee = pd.concat([tickets_musee, df_tickets_kpi], ignore_index=True)\n", + " products_musee = pd.concat([products_musee, df_products_purchased_reduced], ignore_index=True)\n", " " ] }, { "cell_type": "code", - "execution_count": null, - "id": "105862bd-5d66-45ed-be71-ec6e1e103963", - "metadata": {}, + "execution_count": 25, + "id": "e6324fb6-7432-4925-beb0-a831a13be7d5", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 1005251 entries, 0 to 1005250\n", + "Data columns (total 28 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 customer_id 1005251 non-null object \n", + " 1 street_id 1005251 non-null int64 \n", + " 2 structure_id 92386 non-null float64\n", + " 3 mcp_contact_id 453246 non-null float64\n", + " 4 fidelity 1005251 non-null int64 \n", + " 5 tenant_id 1005251 non-null int64 \n", + " 6 is_partner 1005251 non-null bool \n", + " 7 deleted_at 0 non-null float64\n", + " 8 gender 1005251 non-null int64 \n", + " 9 is_email_true 1005251 non-null bool \n", + " 10 opt_in 1005251 non-null bool \n", + " 11 last_buying_date 625674 non-null object \n", + " 12 max_price 625674 non-null float64\n", + " 13 ticket_sum 1005251 non-null int64 \n", + " 14 average_price 790528 non-null float64\n", + " 15 average_purchase_delay 625674 non-null float64\n", + " 16 average_price_basket 625674 non-null float64\n", + " 17 average_ticket_basket 625674 non-null float64\n", + " 18 total_price 840397 non-null float64\n", + " 19 purchase_count 1005251 non-null int64 \n", + " 20 first_buying_date 625674 non-null object \n", + " 21 country 593083 non-null object \n", + " 22 gender_label 1005251 non-null object \n", + " 23 gender_female 1005251 non-null int64 \n", + " 24 gender_male 1005251 non-null int64 \n", + " 25 gender_other 1005251 non-null int64 \n", + " 26 country_fr 593083 non-null float64\n", + " 27 number_company 1005251 non-null int64 \n", + "dtypes: bool(3), float64(10), int64(10), object(5)\n", + "memory usage: 194.6+ MB\n" + ] + } + ], + "source": [ + "customer_musee.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "e7fa2e45-cb48-4c79-994f-9f836d566c21", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [], - "source": [] + "source": [ + "anonymous_customer = {'1' : '1_1', '2' : '2_12184', '3' : '3_1', '4' : '4_2', '101' : '101_1',\n", + " '5' : '5_191835', '6' : '6_591412', '7' : '7_49632', '8' : '8_1942', '9' : '9_19683',\n", + " '10' : '10_19521', '11' : '11_36', '12' : '12_1706757', '13' : '13_8422', '14' : '14_6354'}" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "51d02f4f-980c-4ab9-b295-f9632af9c2f0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['1_1',\n", + " '2_12184',\n", + " '3_1',\n", + " '4_2',\n", + " '101_1',\n", + " '5_191835',\n", + " '6_591412',\n", + " '7_49632',\n", + " '8_1942',\n", + " '9_19683',\n", + " '10_19521',\n", + " '11_36',\n", + " '12_1706757',\n", + " '13_8422',\n", + " '14_6354']" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(anonymous_customer.values())" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "70b6e961-c303-465e-93f4-609721d38454", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# On filtre les outliers\n", + "\n", + "def remove_elements(lst, elements_to_remove):\n", + " return ''.join([x for x in lst if x not in elements_to_remove])\n", + " \n", + "databases = [customer_musee, campaigns_musee_kpi, tickets_musee, products_musee]\n", + "\n", + "outlier_list = list(anonymous_customer.values())\n", + "\n", + "\n", + "customer_musee = customer_musee[~customer_musee['customer_id'].isin(outlier_list)]\n", + "campaigns_musee_kpi = campaigns_musee_kpi[~campaigns_musee_kpi['customer_id'].isin(outlier_list)]\n", + "tickets_musee = tickets_musee[~tickets_musee['customer_id'].isin(outlier_list)]\n", + "products_musee = products_musee[~products_musee['customer_id'].isin(outlier_list)]" + ] }, { "cell_type": "markdown", @@ -1332,7 +1668,9 @@ { "cell_type": "markdown", "id": "45d5261f-4d46-49cb-8582-dd2121122b05", - "metadata": {}, + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, "source": [ "# 1 - Comportement d'achat" ] @@ -3767,7 +4105,9 @@ { "cell_type": "markdown", "id": "d679204b-f3e8-4502-8de9-3bf4180da3bd", - "metadata": {}, + "metadata": { + "jp-MarkdownHeadingCollapsed": true + }, "source": [ "# 2 - Autres informations sur client " ] @@ -3981,6 +4321,464 @@ "source": [ "tags_comparaison" ] + }, + { + "cell_type": "markdown", + "id": "507c1db3-1d6c-4106-a9a2-0187055e0480", + "metadata": {}, + "source": [ + "# 3 - Graphiques communs" + ] + }, + { + "cell_type": "markdown", + "id": "aac367ed-9d5e-482a-a376-bfc7d1a5767e", + "metadata": {}, + "source": [ + "## Nombre de clients" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "94254c32-dc81-42f2-9d27-372ff38c70ed", + "metadata": {}, + "outputs": [], + "source": [ + "def compute_nb_clients(customer_musee):\n", + " company_nb_clients = customer_musee[customer_musee[\"purchase_count\"]>0].groupby(\"number_company\")[\"customer_id\"].count().reset_index()\n", + " plt.bar(company_nb_clients[\"number_company\"], company_nb_clients[\"customer_id\"]/1000)\n", + "\n", + " # Ajout de titres et d'étiquettes\n", + " plt.xlabel('Company')\n", + " plt.ylabel(\"Nombre de clients (milliers)\")\n", + " plt.title(\"Nombre de clients de chaque compagnie de musee\")\n", + " \n", + " # Affichage du barplot\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "aed68c8c-1912-4d8d-a974-11ad371f6ee8", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "compute_nb_clients(customer_musee)" + ] + }, + { + "cell_type": "markdown", + "id": "5eb3efcc-c7a9-4a0e-aab1-29a36032cb31", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "## Part de consentement à la reception de mails" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "848963c9-6129-4106-80b5-76bf814b70d1", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_449/1336968363.py:1: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " customer_musee[\"already_purchased\"] = customer_musee[\"purchase_count\"] > 0\n" + ] + } + ], + "source": [ + "customer_musee[\"already_purchased\"] = customer_musee[\"purchase_count\"] > 0\n", + "\n", + "def mailing_consent(customer_musee):\n", + " df_graph = customer_musee.groupby([\"number_company\", \"already_purchased\"])[\"opt_in\"].mean().reset_index()\n", + " # Création du barplot groupé\n", + " fig, ax = plt.subplots(figsize=(10, 6))\n", + " \n", + " categories = df_graph[\"number_company\"].unique()\n", + " bar_width = 0.35\n", + " bar_positions = np.arange(len(categories))\n", + " \n", + " # Grouper les données par label et créer les barres groupées\n", + " for label in df_graph[\"already_purchased\"].unique():\n", + " label_data = df_graph[df_graph['already_purchased'] == label]\n", + " values = [label_data[label_data['number_company'] == category]['opt_in'].values[0]*100 for category in categories]\n", + " \n", + " label_printed = \"purchased\" if label else \"no purchase\"\n", + " ax.bar(bar_positions, values, bar_width, label=label_printed)\n", + " \n", + " # Mise à jour des positions des barres pour le prochain groupe\n", + " bar_positions = [pos + bar_width for pos in bar_positions]\n", + " \n", + " # Ajout des étiquettes, de la légende, etc.\n", + " ax.set_xlabel('Numero de compagnie')\n", + " ax.set_ylabel('Part de consentement (%)')\n", + " ax.set_title('Part de consentement au mailing selon les compagnies')\n", + " ax.set_xticks([pos + bar_width / 2 for pos in np.arange(len(categories))])\n", + " ax.set_xticklabels(categories)\n", + " ax.legend()\n", + " \n", + " # Affichage du plot\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "c7239078-5c1a-4522-8d72-848efe7df28f", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mailing_consent(customer_musee)" + ] + }, + { + "cell_type": "markdown", + "id": "a6c94f0f-4ef4-432f-b2c9-11f51627b7e9", + "metadata": {}, + "source": [ + "## Part homme / femme client" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "321feb43-242e-4147-a5c8-ad1b41fc1246", + "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", + "
customer_idstreet_idstructure_idmcp_contact_idfidelitytenant_idis_partnerdeleted_atgenderis_email_trueopt_inlast_buying_datemax_priceticket_sumaverage_priceaverage_purchase_delayaverage_price_basketaverage_ticket_baskettotal_pricepurchase_countfirst_buying_datecountrygender_labelgender_femalegender_malegender_othercountry_frnumber_companyalready_purchased
\n", + "
" + ], + "text/plain": [ + "Empty DataFrame\n", + "Columns: [customer_id, street_id, structure_id, mcp_contact_id, fidelity, tenant_id, is_partner, deleted_at, gender, is_email_true, opt_in, last_buying_date, max_price, ticket_sum, average_price, average_purchase_delay, average_price_basket, average_ticket_basket, total_price, purchase_count, first_buying_date, country, gender_label, gender_female, gender_male, gender_other, country_fr, number_company, already_purchased]\n", + "Index: []" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "customer_musee[customer_musee['gender_male'] + customer_musee['gender_female'] + customer_musee['gender_other'] == 0]" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "3bb5dc1e-05dc-41da-83bb-cb6b8d43fa73", + "metadata": {}, + "outputs": [], + "source": [ + "def gender_bar(customer_musee):\n", + " company_genders = customer_musee.groupby(\"number_company\")[[\"gender_male\", \"gender_female\", \"gender_other\"]].mean().reset_index()\n", + " \n", + " # Création du barplot\n", + " plt.bar(company_genders[\"number_company\"], company_genders[\"gender_male\"], label = \"Homme\")\n", + " plt.bar(company_genders[\"number_company\"], company_genders[\"gender_female\"], \n", + " bottom = company_genders[\"gender_male\"], label = \"Femme\")\n", + " plt.bar(company_genders[\"number_company\"], company_genders[\"gender_other\"], \n", + " bottom = company_genders[\"gender_male\"] + company_genders[\"gender_female\"], label = \"Inconnu\")\n", + " \n", + " # Ajout de titres et d'étiquettes\n", + " plt.xlabel('Company')\n", + " plt.ylabel(\"Part de clients de chaque sexe\")\n", + " plt.title(\"Sexe des clients de chaque compagnie de musee\")\n", + " plt.legend()\n", + "\n", + " # Définir les étiquettes de l'axe x\n", + " plt.xticks(company_genders[\"number_company\"], [\"{}\".format(i) for i in company_genders[\"number_company\"]])\n", + " \n", + " \n", + " # Affichage du barplot\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "c61c4b41-ba31-44f4-9515-25922798b86a", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gender_bar(customer_musee)" + ] + }, + { + "cell_type": "markdown", + "id": "b02a2668-5cea-44db-b2b5-168f7738a949", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "## Part de clients français" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "4b3bb641-814b-4679-9a67-4eca87a920a6", + "metadata": {}, + "outputs": [], + "source": [ + "def country_bar(customer_sport):\n", + " company_country_fr = customer_sport.groupby(\"number_company\")[\"country_fr\"].mean().reset_index()\n", + " # Création du barplot\n", + " plt.bar(company_country_fr[\"number_company\"], company_country_fr[\"country_fr\"])\n", + " \n", + " # Ajout de titres et d'étiquettes\n", + " plt.xlabel('Company')\n", + " plt.ylabel(\"Part de clients français\")\n", + " plt.title(\"Nationalité des clients de chaque compagnie de musée\")\n", + "\n", + " # Définir les étiquettes de l'axe x\n", + " plt.xticks(company_country_fr[\"number_company\"], [\"{}\".format(i) for i in company_country_fr[\"number_company\"]])\n", + "\n", + " \n", + " # Affichage du barplot\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "01258674-6b98-49e4-93f4-f4185964999f", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "country_bar(customer_musee)" + ] + }, + { + "cell_type": "markdown", + "id": "6c9e8051-06d1-44ed-aa17-eb8ddd9fb5ed", + "metadata": {}, + "source": [ + "## Ouverture mails" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "e346fdc0-617f-463b-af29-caa0d9f88485", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def campaigns_effectiveness(customer_sport, Train=False):\n", + " if not Train:\n", + " customer_sport[\"already_purchased\"] = customer_sport[\"purchase_count\"]>0\n", + "\n", + " nb_customers_purchasing = customer_sport[customer_sport[\"already_purchased\"]].groupby([\"number_company\",\"already_purchased\"])[\"customer_id\"].count().reset_index()\n", + " nb_customers_no_purchase = customer_sport[~customer_sport[\"already_purchased\"]].groupby([\"number_company\",\"already_purchased\"])[\"customer_id\"].count().reset_index()\n", + "\n", + " plt.bar(nb_customers_purchasing[\"number_company\"], nb_customers_purchasing[\"customer_id\"]/1000, label = \"has purchased\")\n", + " plt.bar(nb_customers_no_purchase[\"number_company\"], nb_customers_no_purchase[\"customer_id\"]/1000, \n", + " bottom = nb_customers_purchasing[\"customer_id\"]/1000, label = \"has not purchased\")\n", + " \n", + " \n", + " # Ajout de titres et d'étiquettes\n", + " plt.xlabel('Company')\n", + " plt.ylabel(\"Nombre de clients (en milliers)\")\n", + " plt.title(\"Nombre de clients ayant acheté ou été ciblés par des mails pour les compagnies de musée\")\n", + " plt.legend()\n", + "\n", + " \n", + " \n", + " # Affichage du barplot\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "928dab1d-96ff-4fc2-91ea-2ff119620f31", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_449/3480143790.py:3: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " customer_sport[\"already_purchased\"] = customer_sport[\"purchase_count\"]>0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "campaigns_effectiveness(customer_musee)" + ] } ], "metadata": {