Python — Pandas : DataFrame & analyse de données

Les questions du quiz

1. 1. Quelle structure de Pandas représente une colonne indexée ?
   1. DataFrame
   2. Series
   3. Index
   4. ndarray
2. 2. Quelle est la différence entre df.loc[...] et df.iloc[...] ?
   1. Aucune
   2. loc indexe par étiquette (label), iloc par position entière
   3. iloc est obsolète
   4. loc ne fonctionne que sur les lignes
3. 3. Que produit ce code ?

   import pandas as pd
   df = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})
   print(df['a'].sum())

   1. [1, 2, 3]
   2. 6
   3. (1, 2, 3)
   4. Erreur
4. 4. Quelle expression sélectionne les lignes où la colonne age est ≥ 18 ?
   1. df.where(age >= 18)
   2. df[df['age'] >= 18]
   3. df.filter('age >= 18')
   4. df.select('age >= 18')
5. 5. Que renvoie ce code ?

   df = pd.DataFrame({'g': ['a', 'b', 'a'], 'v': [10, 20, 30]})
   print(df.groupby('g')['v'].sum().to_dict())

   1. {'a': 40, 'b': 20}
   2. {'a': 10, 'b': 20}
   3. {'a': 30, 'b': 20}
   4. Erreur
6. 6. Quelle méthode joint deux DataFrame sur une colonne commune ?
   1. append
   2. concat
   3. merge
   4. join par défaut
7. 7. Que fait df.dropna() par défaut ?
   1. Remplit les NaN par 0
   2. Supprime les lignes contenant au moins un NaN
   3. Supprime les colonnes contenant un NaN
   4. Renvoie un booléen
8. 8. Que produit ce code ?

   df = pd.DataFrame({'a': [1, 2], 'b': [3, 4]})
   df['c'] = df['a'] + df['b']
   print(df['c'].tolist())

   1. [4, 6]
   2. [3, 6]
   3. [1, 2, 3, 4]
   4. Erreur
9. 9. Comment changer l'index d'un DataFrame pour utiliser une colonne existante ?
   1. df.set_index('col')
   2. df.reindex('col')
   3. df.index = 'col'
   4. df['col'].as_index()
10. 10. Quelle est la différence entre apply, map et applymap ?
    1. Aucune
    2. Series.map élément par élément ; DataFrame.apply par colonne (ou ligne) ; DataFrame.applymap élément par élément (obsolète, remplacé par map en 2.1+)
    3. apply ne fonctionne que sur l'index
    4. map est plus lent que applymap
11. 11. Que produit ce code ?

    df = pd.DataFrame({'x': [1, 2, 3]})
    s = df['x']
    s.iloc[0] = 99
    print(df['x'].iloc[0])

    1. 1
    2. 99
    3. NaN
    4. Erreur
12. 12. Quelle agrégation multi-fonction est correcte ?
    1. df.groupby('g').agg({'v': ['mean', 'std']})
    2. df.groupby('g').sum_mean()
    3. df.groupby('g').multiagg(['mean', 'std'])
    4. df.groupby('g').describe(['mean', 'std'])
13. 13. Que renvoie ce code ?

    idx = pd.date_range('2024-01-01', periods=3, freq='D')
    s = pd.Series([10, 20, 30], index=idx)
    print(s.resample('2D').sum().tolist())

    1. [30, 30]
    2. [60]
    3. [10, 50]
    4. [30, 50]
14. 14. Comment lit-on un CSV en utilisant la colonne date comme index parsé ?
    1. pd.read_csv(p, index_col='date', parse_dates=['date'])
    2. pd.read_csv(p, dates=True)
    3. pd.read_csv(p).set_dates()
    4. pd.read_csv(p, header='date')
15. 15. Quelle expression remplit les NaN d'une Series par la moyenne ?
    1. s.fillna(s.mean())
    2. s.replace(NaN, mean)
    3. s.dropna().mean()
    4. s.mean().fillna()
16. 16. Que produit ce pivot ?

    df = pd.DataFrame({'d': ['x','x','y'], 'k': ['a','b','a'], 'v': [1,2,3]})
    print(df.pivot(index='d', columns='k', values='v'))

    1. k a b\nd \nx 1.0 2.0\ny 3.0 NaN
    2. k a b\nx 1 2\ny 3 3
    3. Erreur car NaN interdit
    4. Une Series 1D
17. 17. Quelle est la sortie de df.dtypes ?
    1. Le type Python global du DataFrame
    2. Une Series donnant le dtype de chaque colonne
    3. Un set de tous les dtypes
    4. Le dtype de l'index
18. 18. Pourquoi df['col'].str.lower() est-il plus rapide qu'une boucle Python ?
    1. Aucune différence
    2. L'accesseur .str applique l'opération en C sur toute la colonne, sans boucle Python
    3. Il met automatiquement en cache le résultat
    4. Il compile en JIT à la volée
19. 19. Quel est le type recommandé pour une colonne avec un petit nombre de valeurs uniques répétées (ex. statuts) ?
    1. object
    2. str
    3. category
    4. bytes
20. 20. Que renvoie ce code ?

    df = pd.DataFrame({'a': [1, 2, 3, 4]})
    print(df.rolling(window=2).sum()['a'].tolist())

    1. [NaN, 3.0, 5.0, 7.0]
    2. [1.0, 3.0, 5.0, 7.0]
    3. [3.0, 5.0, 7.0]
    4. Erreur