<jupyter_start><jupyter_text>--- Analyse des données du sondage Stack Overflow 2019---  Compréhension du sondageAvec près de 90 000 réponses provenant de plus de 170 pays et territoires dépendants, le sondage  Stack Overflow Anual Developer Survey  continue d'être le sondage le plus complet jamais réalisée auprès des développeurs de logiciels. Le sondage couvre des aspects tels que la satisfaction professionnelle et la recherche d'emploi dans les langages de programmation...etcDans ce projet, les résultats du sondage seront utilisés pour répondre aux questions suivantes pour les aspirants scientifiques des données (data scientists):* Quel est le langage de programmation de votre choix?* Quel est le salaire des développeurs?* Quel est le framework de choix numéro un pour les développeurs? --- Resulé des résultatsAprès avoir analysé les données, nous constatons que python est le langage de programmation de choix pour les développeurs qui s'identifient en tant que **Data Scientist** et **Machine Learning Specialist**. Les salaires des **Data Scientists et Machine Learning Specialist** sont les plus élevés des États-Unis. Étonnamment, jQuery est le framework web de choix.Pour plus de détails, référons nous à l'analyse complète ci-dessous.---<jupyter_code># Chargement des librairies requis
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline<jupyter_output><empty_output><jupyter_text>--- Compréhension des données---<jupyter_code>df = pd.read_csv("../model_dev/data/survey_results_public_2019.csv", low_memory = False)
schema = pd.read_csv("../model_dev/data/survey_results_schema.csv")
df.head()
df.shape
schema.head()
schema.shape<jupyter_output><empty_output><jupyter_text>Les données du sondage comprennent 88 883 enregistrements et 85 colonnes.<jupyter_code>df.info()
# Vérification des colonnes sans valeurs manquantes
set(df.isna().sum()[df.isna().sum()==0].keys())
# Vérification des colonnes manquant plus de 50% de valeurs
set(df.columns[100*df.isna().sum()/df.shape[0] > 50])
# Vérification de shema manquants
schema.isnull().sum()<jupyter_output><empty_output><jupyter_text>1. Quel est le language de programmation de votre choix? Il y a tellement, tellement de langages de programmation. Jetons donc un coup d'œil à ce que différents développeurs du monde entier utilisent. Cela devrait nous donner une idée de ce quels laguagues sont importants pour quels domaines.<jupyter_code>count_values = df.LanguageWorkedWith.value_counts() #Pandas series pour chaque LanguageWorkedWith

# Affichage des 10 premiers

(count_values[:10]/df.shape[0]).plot(kind="bar");
plt.title("Languages de Programmation");
# le format des langages de programmation doit être nettoyé, car les développeurs utilisant plusieurs langages,
# ces langues sont concaténées avec;
# Nous divisons LanguageWorkedWith pour avoir une bonne perception
languages = df[df['LanguageWorkedWith'].notnull()]

unique_languages = {}

# division des languages au ;
for language_set in languages['LanguageWorkedWith'].apply(lambda row: str(row).split(';')):
    for language in language_set:
        if language not in unique_languages.keys():
            unique_languages[language] = 1
        else:
            unique_languages[language] += 1
# Fonction qui sera utilisée pour l'affichage d'une graphe à barre horizontale
def plot_dimension_count(unique_dim_dict, plot_title):
    """ Fonction de traçage d'un graphique à barres horizontales pour le dictionnaire de dimension donné
    
    INPUT - unique_dim_dict - dictionnaire
            plot_title - string - plot_title
    
    OUTPUT - graphique à barres montrant le nombre total par dimension d'intérêt
            
    """
    dim_count = pd.DataFrame.from_dict(unique_dim_dict, orient='index', dtype=None)
    dim_count.columns = ['Count']
    dim_count.sort_values('Count',ascending=True,inplace=True)

    dim_count.plot(kind = 'barh', figsize = (12,12), fontsize = 10, title = plot_title);
# Graphes à barres
plot_dimension_count(unique_languages,'Les langages de programmation les plus populaires')<jupyter_output><empty_output><jupyter_text>---Bien qu'il soit satisfaisant de connaître les langues les plus populaires, cela ne permet pas à lui seul de connaître la langue la plus populaire pour les Data Scientists. Donc, nous allons prendre une approche différente.---<jupyter_code># Nous divisons LanguageWorkedWith pour avoir une grande perception

# Les developpeurs uniques
developers = df[df['DevType'].notnull()] # suppression des valeurs nulles
unique_developers = {}

# division des languages au ;
for developer_set in developers['DevType'].apply(lambda row: str(row).split(';')):
    for developer in developer_set:
        if developer not in unique_developers.keys():
            unique_developers[developer] = 1
        else:
            unique_developers[developer] += 1
# Graphe des types de developpeurs
plot_dimension_count(unique_developers,'Type de Développeur')<jupyter_output><empty_output><jupyter_text>Étant donné que nous sommes intéressés par le langage de choix de Data Scientists, nous nous concentrerons sur le `` Data scientist ou spécialiste en Machine Learning Specialist''<jupyter_code># nombre de language de programmation par Data scientist or machine learning specialist' developpeur
languages = languages[languages['DevType'].notnull()]

# DataFrame à partir de notre dictionnaire par index
developer_count = pd.DataFrame.from_dict(unique_developers, orient='index', dtype=None)

# Dictionnaire vide de developeur
developer_dict = {}
for devtype in developer_count.index.tolist():
    developer_dict['{}'.format(devtype)] = {}

# remplissement du dictionnaire
for dev in developer_dict.keys():
    developer_dict[dev] = {key: 0 for key in list(unique_languages.keys())}
    
# Nombre de developpeurs utilisant le langage
for key, val in enumerate(languages['DevType']):
    all_developers = val.split(';')
    all_languages = languages.iloc[key, 43].split(';')
    for dev in all_developers:
        for lang in all_languages:
            developer_dict[dev][lang] += 1

developer_language_count = pd.DataFrame.from_dict(developer_dict, orient='index', dtype=None).T
developer_language_count.head()
# Bien, maintenant nous avons un dataframe des langages par developpeur

# Visualization un distribution qui repondera à notre question
ds_count = pd.DataFrame(developer_language_count['Data scientist or machine learning specialist'])
ds_count.columns = ['Count']
ds_count.sort_values('Count',ascending=True,inplace=True)

ds_count.plot(kind = 'barh', figsize = (12,12), fontsize = 10, title = 'Total Count');<jupyter_output><empty_output><jupyter_text>**Constat**Python est de loin le langage de choix pour les développeurs qui s'identifient en tant que Data scientist ou spécialiste ML. Pour ceux qui souhaitent exceller par la suite dans la science des données ou dansl'apprentissage automatique, l'apprentissage du python est certainement un bon investissement. --- Quel est le salaire des developpeurs (le job le mieux payé, le pays qui paie bien)? ---<jupyter_code>salaries_df = df[['DevType', 'Country','ConvertedComp']]

for column in salaries_df.columns.tolist():
    col_desc = schema[schema['Column']==column]['QuestionText'].iloc[0]
    print(col_desc)
# Vérfication des valeurs manquants
salaries_df.isnull().sum()
# Valeurs manquantes en %
round((salaries_df.isnull().sum()/salaries_df.shape[0])*100,1)<jupyter_output><empty_output><jupyter_text>---__Constat__il semble qu'un grand nombre de développeurs ne révèlent pas leurs salaires, ce qui pourrait être dû à des problèmes de confidentialité.--- Pour évaluer la rémunération des développeurs, nous utiliserons la répartition des salaires par pays.<jupyter_code># Suppression des lignes ne contenant aucun salaire dans notre data frame
clean_salaries_df = salaries_df.dropna().reset_index()
clean_salaries_df.head()
clean_salaries_df.shape
# Nombre de developeurs par pays
clean_salaries_df.Country.value_counts().reset_index()<jupyter_output><empty_output><jupyter_text>Wow, très intéressant!Un grand nombre de pays sont sous-représentés, les États-Unis ont de loin le plus grand nombre de répondants.<jupyter_code># repartition des 10 premiers pays en graphe

fig = plt.figure(figsize=(15,10))

countries = clean_salaries_df['Country'].value_counts().sort_values(ascending=False)[:9].index.tolist()

for i,country in enumerate(countries):
    plt.subplot(3,3,i+1)
    temp_salaries = clean_salaries_df.loc[clean_salaries_df['Country']==country,'ConvertedComp']

    ax = temp_salaries.plot(kind='kde')
    ax.axvline(temp_salaries.mean(), linestyle = '-', color = 'red')
    ax.text((temp_salaries.mean() + 1500), (float(ax.get_ylim()[1])*0.55), 'mean = $ ' + str(round(temp_salaries.mean(),0)), fontsize = 12)
    ax.set_xlabel('Salire Anuel en USD')
    ax.set_xlim(-temp_salaries.mean(),temp_salaries.mean()+2*temp_salaries.std())
    
    ax.set_title('Distribution des salaires annuels {}'.format(country))

plt.tight_layout()
plt.savefig('salaire_developeur_pays.png',bbox_inches = 'tight')
plt.show()<jupyter_output><empty_output><jupyter_text>---Les États-Unis ont de loin les salaires les plus élevés.Bien que l'analyse soit utile, nous aimerions connaître les distributions pour les développeurs liés au Data Science.---<jupyter_code># type de salaires de developpeurs
developer_salary_df = df[['DevType','Country','ConvertedComp']]
# suppression des lignes vides
clean_developer_salary_df = developer_salary_df.dropna()
developer_count = pd.DataFrame.from_dict(unique_developers, orient='index', dtype=None)
# liste des pays
developer_countries = list(clean_salaries_df['Country'].value_counts().index)

# Dictionnaire avec nom du pays comme clé et  initialisé avec 0 pour chaque valeur de clé de pays correspondante
developer_salary_dict = {key: 0 for key in developer_countries}

# pour chaque pays dans le dictionnaire, nous voulons mettre le type de développeur et initialiser dans une liste vide
for developer in developer_salary_dict.keys():
    developer_salary_dict[developer] = {key: [] for key in developer_count.index.tolist()}

# remplissage du dictionnaire des salaires de developpeurs avec salaires par type de développeur par pays
for key, val in enumerate(clean_developer_salary_df['DevType']):
    all_developers = val.split(';')
    country = clean_developer_salary_df.iloc[key, 1]
    salary = clean_developer_salary_df.iloc[key, 2]
    
    for developer in all_developers:
        developer_salary_dict[country][developer].append(salary)
# Maintenant, visualisons les salaires des développeurs liés à la science des données aux États-Unis.
dev_type = 'Data scientist or machine learning specialist'

figsize = (15,10)
df1 = pd.DataFrame({'<NAME> (US$)':developer_salary_dict['United States'][dev_type]})
ax = df1.plot(kind = 'kde')
mean = df1['<NAME> (US$)'].mean()

ax.axvline(mean, linestyle = '-', color = 'red')
ax.text((mean + 1500), (float(ax.get_ylim()[1])*0.75), 'mean = $ ' + str(round(mean,0)), fontsize = 12)
ax.set_xlabel('Salaire Annuel en USD')
ax.set_xlim(-mean,mean+2*temp_salaries.std())
ax.set_title('Distribution du Salaire Annuel {} in {}'.format(dev_type, 'United States'), fontsize = 15, y = 1.05)
plt.savefig('salaries_pour_data_science_usa',bbox_inches = 'tight')
plt.show()<jupyter_output><empty_output><jupyter_text>Les salaires moyens sont beaucoup plus élevés que la moyenne globale aux États-Unis. --- Quel est le framework le mieux choisi des developpeurs?---<jupyter_code>count_values = df.WebFrameWorkedWith.value_counts()# Pandas series pour le compteur de chaque LanguageWorkedWith

# 10 premiers framework

(count_values[:10]/df.shape[0]).plot(kind="bar");
plt.title("Web Framework");
#le format des frameworks web doit être nettoyé, pour les développeurs utilisant plusieurs frameworks,
# les frameworks sont concaténés avec;
# Nous division WebFrameWrokedWith pour une meilleure perception
frameworks = df[df['WebFrameWorkedWith'].notnull()]

unique_frameworks = {}

# On fait un split au ;
for framework_set in frameworks['WebFrameWorkedWith'].apply(lambda row: str(row).split(';')):
    for framework in framework_set:
        if framework not in unique_frameworks.keys():
            unique_frameworks[framework] = 1
        else:
            unique_frameworks[framework] += 1
    
# let make a bar graph
framework_count = pd.DataFrame.from_dict(unique_frameworks, orient='index', dtype=None)
framework_count.columns = ['Count']
framework_count.sort_values('Count',ascending=True,inplace=True)

framework_count.plot(kind = 'barh', figsize = (12,12), fontsize = 10, title = 'Les Frameworks les plus populaires');<jupyter_output><empty_output><jupyter_text>---Bien qu'il soit satisfaisant de connaître les cadres les plus populaires, cela ne permet pas à lui seul de connaître le framework le plus populaire pour la data science. Donc, nous allons prendre une approche légèrement différente.---<jupyter_code># Nous divisons WebFrameWrokedWith pour une meilleure perception

# prennons les developpeurs uniques
developers = df[df['DevType'].notnull()] # suppression des champs nuls

unique_developers = {}

# On fait un split au ;
for developer_set in developers['DevType'].apply(lambda row: str(row).split(';')):
    for developer in developer_set:
        if developer not in unique_developers.keys():
            unique_developers[developer] = 1
        else:
            unique_developers[developer] += 1
# un graphe à barre
developer_count = pd.DataFrame.from_dict(unique_developers, orient='index', dtype=None)
developer_count.columns = ['Count']
developer_count.sort_values('Count',ascending=True,inplace=True)

developer_count.plot(kind = 'barh', figsize = (12,12), fontsize = 10, title = 'Developpeur repondants');<jupyter_output><empty_output><jupyter_text>Puisque nous sommes intéressés par le langage de choix de la science des données, nous nous concentrerons sur 'Data scientist or machine learning specialist'<jupyter_code># Pour chaque 'Data scientist or machine learning specialist' developpeur, comptons les frameworks
frameworks = frameworks[frameworks['DevType'].notnull()]

# dictionnaire vide de developpeurs
developer_dict = {}
for devtype in developer_count.index.tolist():
    developer_dict['{}'.format(devtype)] = {}

# remplissage du dictionnaire avec les frameworks
for dev in developer_dict.keys():
    developer_dict[dev] = {key: 0 for key in list(unique_frameworks.keys())}
    
# Maintenant, nous comptons les nombres de developpeurs utilisant le framework
for key, val in enumerate(frameworks['DevType']):
    all_developers = val.split(';')
    all_frameworks = frameworks.iloc[key, 49].split(';')
    for dev in all_developers:
        for fra in all_frameworks:
            developer_dict[dev][fra] += 1

developer_framework_count = pd.DataFrame.from_dict(developer_dict, orient='index', dtype=None).T
developer_framework_count.head()
# Bien, maintenant nous avons un dataframe de framework par developpeur

# Répondons maitenant à notre question
ds_count = pd.DataFrame(developer_framework_count['Data scientist or machine learning specialist'])
ds_count.columns = ['Count']
ds_count.sort_values('Count',ascending=True,inplace=True)

ds_count.plot(kind = 'barh', figsize = (12,12), fontsize = 10, title = 'Nombre Total');<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.1005659272750927, 'fraction_numerical': 0.009432121251544917, 'mean_word_length': 5.626724137931035, 'pattern_counts': {'":': 0, '<': 55, '<?xml version=': 0, '>': 56, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '13', 'dir': 'jupyter-structured-clean-dedup', 'id': '628508', 'license': 'MIT', 'n_tokens_mistral': 4967, 'n_tokens_neox': 4851, 'n_words': 1404, 'path': 'model_dev/.ipynb_checkpoints/sof-dataviz-checkpoint.ipynb', 'repo_name': 'alfahami/sof-dataviz_ml-flask-app', 'size': '15389'}