Tutorial |

Plotting climate data using pandas

Sat, 20 Mar 2021 00:00:00 +0000

Table of Contents

Introduction

The data for this comes from a subset of The National Centers for Environmental Information (NCEI) Daily Global Historical Climatology Network (GHCN-Daily). The GHCN-Daily is comprised of daily climate records from thousands of land surface stations across the globe.

The data (stored in a ) is comprised of daily climate records over the period 2005-2015, from land surface stations near Ann Arbor, Michigan, United States. Each row in the datafile corresponds to a single observation.

The provided variables are :

id : station identification code
date : date in YYYY-MM-DD format
element : indicator of element type
- TMAX : Maximum temperature (tenths of degrees C)
- TMIN : Minimum temperature (tenths of degrees C)
value : data value for element (in tenths of degrees C)

For the purpose of this notebook, we are going to plot a line chart of the record high and record low temperatures by day of the year over the period 2005-2014. Then, we overlay a scatter of the 2015 data for any points (highs and lows) for which the ten-year record (2005-2014) was broken in 2015.

Importing libraries and reading data

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import seaborn as sns
from matplotlib.dates import MonthLocator, DateFormatter

df = pd.read_csv('data.csv')

Data processing and time series manipulation

Since the temparture values are in the tenths of degree Celsius, we need to convert them to °C.

df['Data_Value'] = df['Data_Value']/10 #convert temperatures to °C

Next, we would ensure that the Date values are interpreted as date type, and sort the entire DataFrame by date.

df['Date'] = pd.to_datetime(df['Date'], infer_datetime_format=True) #convert to date type
df = df.sort_values('Date') #sort DataFrame by date

We use the head() function to get the first n rows (5 by default), and the shape attribute for a tuple representing the dimensionality of the resulting DataFrame:

print (df.head(), "\n The size of the DataFrame is", df.shape)

 ID Date Element Data_Value
60995 USW00004848 2005-01-01 TMIN 0.0
17153 USC00207320 2005-01-01 TMAX 15.0
17155 USC00207320 2005-01-01 TMIN -1.1
10079 USW00014833 2005-01-01 TMIN -4.4
10073 USW00014833 2005-01-01 TMAX 3.3
 The size of the DataFrame is (165085, 4)

For clarity and ease, we are going to create two distinct DataFrames to hold TMAX and TMIN values.

dftmax = df[df['Element']=='TMAX'] #get dataframe of only TMAX values
dftmin = df[df['Element']=='TMIN'] #get dataframe of only TMIN values

To have a better overview of the entire data, I decided to keep all values including those of leap years. In this cell, we use numpy.arange() to get all possible dates in such a year (2008).

observation_dates = np.arange('2008-01-01', '2009-01-01', dtype='datetime64[D]')

Now, we would get the maximum temperatures for each day in the period from 2005 to 2014. We should remember that there are several registered values for any given day for that period. The resulting DataFrame dftmax14 has a length of 3652 (maximum values for each day in a 10-year span).

Then, we’ll create a pandas series comprised of all TMAX values in a one-year span (tmax1y). For any single day value (1 June for example), we would get the maximum TMAX for that day for the period 2005-2014.

#extract of TMAX of each day from 2005 to 2014
dftmax14 = dftmax[dftmax['Date']<'2015-01-01'].groupby('Date')['Data_Value'].max()

#set index to month-day format instead of year-m-d
dftmax14.index = dftmax14.index.strftime('%m-%d')

#TMAX in a one year span resume for data from 2005 to 2014
tmax1y = dftmax14.groupby(dftmax14.index).max()

We repeat the same steps to get minimum temperatures for each day in the period from 2005 to 2014.

#extract of TMIN of each day from 2005 to 2014
dftmin14 = dftmin[dftmin['Date']<'2015-01-01'].groupby('Date')['Data_Value'].min()

#set index to month-day format instead of year-m-d
dftmin14.index = dftmin14.index.strftime('%m-%d')

#TMIN in a one year span resume for data from 2005 to 2014
tmin1y = dftmin14.groupby(dftmin14.index).min()

Similarly, we create a DataFrame for TMAX values in 2015 (dftmax15). Then, we extract the dates for which TMAX values in 2015 were higher than the values of TMAX over the period 2005-2014 (observation_dates_tmax15). Finally, we update dftmax15 to have a DataFrame of those record breaking TMAX values.

#extract of TMAX of each day in 2015
dftmax15 = dftmax[dftmax['Date'] >= '2015-01-01'].groupby('Date')['Data_Value'].max()
#set index to month-day format instead of year-m-d
dftmax15.index = dftmax15.index.strftime('%m-%d')

dftmax15.loc['02-29'] = tmax1y['02-29']
dftmax15.sort_index(inplace=True)

observation_dates_tmax15 = observation_dates[dftmax15.values > tmax1y.values]

dftmax15 = dftmax15[dftmax15.values > tmax1y.values]

We can check the size of dftmax15, and infer that there are 37 days in 2015 that broke all TMAX values registered from 2005 to 2014.

dftmax15.size

The same previous steps to get a DataFrame dftmin15 of those record breaking TMIN values.

#extract of TMIN of each day in 2015
dftmin15 = dftmin[dftmin['Date'] >= '2015-01-01'].groupby('Date')['Data_Value'].min()
#set index to month-day format instead of year-m-d
dftmin15.index = dftmin15.index.strftime('%m-%d')

dftmin15.loc['02-29'] = tmin1y['02-29']
dftmin15.sort_index(inplace=True)

observation_dates_tmin15 = observation_dates[dftmin15.values < tmin1y.values]

dftmin15 = dftmin15[dftmin15.values < tmin1y.values]

By checking the size of dftmin15, we infer that there are 32 days in 2015 that broke all TMIN values registered from 2005 to 2014.

dftmin15.size

Plotting and styling using matplotlib and seaborn

In this cell, we use matplotlib and seaborn to create a figure, and plot line charts of the record high and record low temperatures by day of the year over the period 2005-2014, and a scatter of the 2015 data for any points (highs and lows) for which the ten-year record (2005-2014) was broken in 2015. I made sure the visual was nice, with appropriate legends and labels, and reduced chart junk.

months = MonthLocator(range(1, 13), bymonthday=1, interval=1)
monthsFmt = DateFormatter("%b")

%matplotlib inline
sns.set_style("white") # Set the aesthetic style of the plot

fig = plt.figure(figsize=(10,5)) # Create a new figure with determined figsize parameter
ax = plt.gca() # Get the current Axes instance on the current figure

# Plots and Scatter plots of y vs. x with determined parameters
ax.scatter(observation_dates_tmax15 , dftmax15.values, s=35,
 c=sns.dark_palette("purple", n_colors=37), alpha=0.5, label='2005-2014 record high broken' )
ax.scatter(observation_dates_tmin15 , dftmin15.values, s=25,
 c=sns.dark_palette((260, 75, 60), input="husl", n_colors=32), alpha=0.9, label='2005-2014 record low broken' )

ax.plot(observation_dates, tmax1y.values, '-', color= sns.color_palette("Reds")[-2], label='High', alpha=0.7, linewidth=1)
ax.plot(observation_dates, tmin1y.values, '-', color= sns.color_palette("Blues")[-2], label='Low', alpha=0.7, linewidth=1)

ax.set_xlabel('Months')
ax.set_ylabel('Degrees (C)')

ax.set_title('Highest and lowest temperatures by day of the year over the period 2005-2014 \n and records broken in 2015 for Ann Arbor, Michigan, United States')

ax.xaxis.set_major_locator(months)
ax.xaxis.set_major_formatter(monthsFmt)

plt.xticks(alpha=0.5)
plt.yticks(alpha=0.5)
sns.despine()
ax.legend()

maxv=tmax1y.values
minv=tmin1y.values
#To shade the area between the record high and record low temperatures for each day
ax.fill_between(observation_dates,maxv, minv, facecolor=sns.light_palette("lightgrey")[4], alpha=0.2)

#fig.savefig("temp.png", dpi=1200) #comment out to save the figure in png format (reduce dpi to get smaller files)

This is not the only way to represent the data as you may opt to tweak the different parameters, and experience more with the plotting libraries. You can also treat other questions, and have fun with the data and figures.

Furthermore, there are several ways to handle the data and the various DataFrames. I tried to be more explicit and went for simplicity, all whilst incorporating the .

If you want to learn more about data science through the python programming language, I highly recommend on Coursera.

Analysing Olympic Games medal table

Thu, 18 Mar 2021 00:00:00 +0000

Table of Contents

Introduction

The following uses the , which was derived from the Wikipedia entry on , as of the 2016 Summer Olympics and 2018 Winter Olympics. All changes in medal standings due to doping cases and medal redistributions up to and including 25 November 2020 are taken into account. Data queried on March 18th, 2021.

Using the power of pandas, read the csv file containing the dataset (the result is a DataFrame). Then perform data cleaning and preprocessing operations to get a more readable and practical format of the DataFrame, to be used later.

import pandas as pd
df = pd.read_csv("olympic_games_medal_table.csv",index_col=0,skiprows=1, encoding='latin_1')

for col in df.columns: # clean the lables of the raw data
 if col[:2]=="01":
 df.rename(columns={col:"Gold"+col[4:]}, inplace=True)
 if col[:2]=="02":
 df.rename(columns={col:"Silver"+col[4:]}, inplace=True)
 if col[:2]=="03":
 df.rename(columns={col:"Bronze"+col[4:]}, inplace=True)
 if col[:1]=="№":
 df.rename(columns={col:"#"+col[1:]}, inplace=True)

names_ids = df.index.str.split('\s\(') # split the index by '('

df.index = names_ids.str[0] # the [0] element is the country name (will be the new index)

df['ID'] = names_ids.str[1].str[:3] # the [1] element is the abbreviation or ID (take first 3 characters)

spare_df = df.copy()
df = df.drop('Totals') # remove the row with label 'Totals'

Get the top ten countries that have the most medals in the summer and winter games.

most_medals = df['Combined total'].nlargest(10).index

Stacked bar chart

In this cell, we use to visualize stacked bar charts representing the top ten countries in terms of total number of medals in the winter and summer games.

import matplotlib.pyplot as plt

%matplotlib inline

# get necessary pandas series
summer_medals = df.loc[most_medals, ['Total']]['Total']
winter_medals = df.loc[most_medals, ['Total.1']]['Total.1']

fig = plt.figure(figsize=(20, 10)) # create a figure object

# context manager for temporary styling
with plt.style.context(('seaborn-poster', {'xtick.labelsize' : 14, 'axes.labelpad':20 , 'axes.titlepad' : 20,
 'axes.spines.top' : False, 'axes.spines.right' : False, 'axes.spines.left' : False} )):
 # create the bar plots
 bar_list = [plt.bar(range(len(most_medals)), summer_medals, width = 0.5 ,color='#d69728',
 tick_label = most_medals, label = 'Summer'),
 plt.bar(range(len(most_medals)), winter_medals, width = 0.5 , bottom = summer_medals ,
 tick_label = most_medals, label = 'winter')]
 ax = plt.gca()
 ax.set_ylabel('Number of Medals')
 ax.set_xlabel('Countries')
 ax.set_title('Number of total medals for the top ten countries')
 ax.tick_params(bottom=False, left=False, labelleft=False)

 # attach text label for each bar displaying its value
 for i in bar_list:
 for bar in i:
 height = bar.get_height()
 bottom = bar.get_y()
 if height < 50:
 y = 0.5*height+bottom*1.20
 else:
 y = 0.5*height+bottom
 plt.gca().text(bar.get_x() + bar.get_width()/2, y, str(int(height)),
 ha='center', color='black', fontsize=20)
 plt.legend()

# save the plot as a png file. you can change the file format to pdf or any supported extension (comment out to use)
#fig.savefig("totalmedals.png", dpi=150)

Bubble chart

This chart is an example of a visualization that can be created to help understand the data. This is a bubble chart showing the value of adjusted gold medals (#total gold/ #total games) Vs. the rank with reference to the number of total medals won.

The size of the bubble corresponds to an adjusted value of total medals (#total medals/ #total games) won, and the color corresponds to the geolocation (European or non-European) or current status (red: no longer exists).

top_medals = spare_df['Combined total'].nlargest(11).index
bubble_df = spare_df.loc[top_medals].drop('ID', axis=1) # dataframe for top 11 winners

# to eliminate overlapping medals' count
sum_topcoun = bubble_df[1:][bubble_df.columns[~bubble_df.columns.str.contains('#')]].sum()
for col in bubble_df.columns:
 if col in sum_topcoun.index:
 bubble_df.loc['Totals'][col] -= sum_topcoun[col]

bubble_df = bubble_df.rename(index={'Totals':'Rest of the World'})

# create 2 new columns with their respective data
bubble_df['adjusted_cgold'] = (bubble_df['Gold.2'].div(bubble_df['# Combined Games'])).apply(lambda x: float('%.1f'%x))
bubble_df['Rank'] = range(1,len(bubble_df.index)+1)

# chart creation and styling
with plt.style.context(('seaborn-poster', {'xtick.labelsize' :12, 'ytick.labelsize':12,'axes.labelpad':20 ,
 'axes.titlepad' : 20,'axes.labelsize':15} )):
 ax2 = bubble_df.plot(x='Rank', y='adjusted_cgold', kind='scatter',
 c=['#e4aa1a','#377eb8','#e41a1c','#4daf4a','#4daf4a','#4daf4a','#4daf4a','#4daf4a',
 '#377eb8','#4daf4a','#4daf4a'], linewidths=2 ,
 xticks=range(1,len(bubble_df.index)+1),
 s=(bubble_df['Combined total'].div(bubble_df['# Combined Games']))*100, alpha=.55, figsize=[15,7])
 ax2.set_ylim(0,65)
 ax2.set_title('Adjusted total gold medals by total medals won')
 ax2.set_ylabel('Adjusted gold medals')
 for i, txt in enumerate(bubble_df.index): # add labels inside each bubble
 ax2.annotate(txt, [bubble_df['Rank'][i], bubble_df['adjusted_cgold'][i]], ha='center',fontsize=11)

#plt.savefig("cgold.png", dpi=150)

This chart shows that the United States has the most number of total medals in summer and winter games as indicated by the x-axis (Rank). Norway has the least number of combined medals among the top ten.

Based on the values of adjusted gold medals represented by the y-axis, the Soviet Union won the most gold medals relative to the number of olympic games in which they participated, followed by the US and Russia respectively.

The sizes of bubbles suggest that the top 3 countries that won most medals relative to the number of games they were part of, are respectively, the Soviet Union, the US and Russia.

To put it in perspective by comparing France and China, the latter won less total medals overall (position on x-axis). But taking into account the number of olympic games played, China did win more gold medals (position on y-axis) and total medals (bubble-size).

Les bases de Python

Sun, 12 Aug 2018 00:00:00 +0000

Table of Contents

Utiliser Python comme une calculatrice

Après avoir , vous pouvez ouvrir une console ou l’invite de commande, tapez python et un intepréteur Python s’ouvre. Pour l’instant, nous utilisons ce . Essayons quelques commandes Python simples

2+3 # Un commentaire

20 + 11 * 3

(20 - 11) / 4

Les nombres entiers (comme 2, 3 et 11) sont de type int, alors que les décimaux (comme 10.0 et 3.14) sont de type float.

19 / 3 # La division (/) donne toujours un nombre de type 'float'

19 // 3 # L'opérateur (//) effectue des divisions entières

19 % 3 # L'opérateur (%) donne le reste de la division entière.

Il est possible de calculer des puissances (x**y) avec l’opérateur **

3 ** 2
# 11 ** 12. # les opérations avec des types d'opérandes mélangés donnent un résultat en virgule flottante

Le signe égal ( = ) permet d’affecter une valeur à une variable

hauteur = 7
base = 9
aire_du_triangle = (hauteur * base) / 2
aire_du_triangl # parlons des erreurs dans l'affichage des résultats

Les chaînes de caractères

Les chaînes de caractères peuvent être exprimés de différentes manières :

'Bonjour' # guillemets simples
"Hello" # guillemets doubles

'de l\'art' # utiliser \' pour protéger les guillemets
# "de l'art" # ou utiliser les guillemets doubles

'"Le petit chat est mort. ", dit Agnès'
# "\"Le petit chat est mort. \", dit Agnès"

La fonction print() affiche les chaînes de caractères de manière plus lisible.

'"L\'art !" dit Michel.'
# print ('"L\'art !" dit Michel.')
# p = 'Première ligne.\nDeuxième ligne.' # \n signifie nouvelle ligne
# p
# print (p)

Utilisez les chaînes brutes (raw strings) en préfixant la chaîne d’un r, pour éviter que les caractères précédés d’un antislash ne soient interprétés comme étant spéciaux.

print('C:\Documents\nom')
# print(r'C:\Documents\nom') # les guillemets précédés par (r)

Utilisez des triples guillemets : '''abc''' ou """xyz""" pour écrire des chaînes de caractères qui s’étalent sur plusieurs lignes.

Empêcher le retour à la ligne en ajoutant \

print("""\
Définitions:
 -dictionnaire Une structure de donnée associant des clefs et des valeurs
 -fonction Une suite d'instructions qui renvoient une valeur à celui qui l'appelle
""")

L’opérateur + permet de coller (concaténer) plusieurs chaînes. L’opérateur * permet de répéter les chaînes.

'OUI ' * 3 + 'Hurrah!'
# prefix = 'Hello Wo'
# prefix + 'rld!'

Les caractères peuvent être accédés par leur position. Pour l’indexation des chaînes de caractères, le premier caractère est à la position 0.

phrase = "Je m'appelle Brian"
phrase[0]
# phrase[15]

Pour effectuer un décompte en partant de la droite, nous utilisons des indices négatifs (commencent par -1).

phrase[-1]
# phrase[-3]
# phrase[-18]

Pour obtenir une sous-chaîne :

phrase[0:2] # caractères de la position 0 (inclut) à 2 (exclu)
# phrase[13:18]
# phrase[:12]
# phrase[12:] # s[:i] + s[i:] = s
# phrase[-5:]
# phrase[20] # indice trop grand (hors bornes)
# phrase[5:20] # gérés silencieusement si utilisés dans des tranches

Les chaînes de caractères sont immutable : elles ne peuvent pas être modifiées.

phrase = "Je m'appelle Brian"
phrase[1] = 'j'
# phrase[13:] = 'Stewie'
# phrase[:13] + 'Stewie !'

La fonction len() donne la longueur d’une chaîne :

p = 'I have a dream'
len(p)

Les listes

Une suite d’éléments séparés par des virgules, placés entre crochets. Les éléments d’une liste ne sont pas obligatoirement du même type.

premiers = [2, 3, 5, 7, 11]
premiers

Les listes peuvent être indicées et découpées :

premiers[0]
# premiers[-1]
# premiers[2:10]

Les opérations de découpage (en tranches) renvoient une nouvelle liste contenant les éléments spécifiés.

premiers[:] # une copie de la liste

Les listes supportent des opérations comme pour les chaînes de caratcères.

premiers + [13, 17, 19]
# premiers * 2

Il est possible de changer le contenu des listes : elles sont mutables

nbres = [1, 2, 'c', 4]
# nbres[2] = 3
nbres

nbres.append(5) # méthode pour ajouter des éléments à la fin
nbres

nbres[2:4] = [10, 100] # affectation par tranches
# nbres[:] = [] # supprimer toutes les valeurs
nbres

Il est possible de créer des listes contenant d’autres listes :

a = [1, 2, 3]
b = ['f', 'r', 'a']
res = [a, b]
# res
# res[1]
# res[0][2]

La compréhension des listes (list comprehension) permet de construire des nouvelles listes où chaque élément est le résultat d’une opération appliquée à chaque élément d’une autre séquence; ou de créer une sous-séquence d’éléments satisfaisants une certaine condition. Elle consiste en deux crochets contenants une expression suivie par une clause for, puis par une ou plusieurs clauses for ou if.

[x for x in range(6) if x % 2 == 0]

[(x, y) for x in [1,2,3] for y in [3,1] if x != y]

Contrôle du flux

L’instruction `if` :

x = 11
if x % 2 == 0:
 print ('foo')
 s = 'nombre pair'
else:
 print ('bar') # x % 2 != 0

x = 20
if x % 5 == 0 and x % 2 == 0:
 print ('foobar')
elif x % 5 == 0:
 print ('foo')
else:
 print ('bar')

L’instruction `for` :

Elle permet d’itérer sur les éléments d’une séquence (une liste, une chaîne de caractères, etc.) par ordre.

pays = ['France', 'Canada', 'Belgique', 'Suisse']
for p in pays:
 print (p, len(p))

mot = '1 chat'
for c in mot:
 print (c)

for i in range(1, 4):
 print (i ** 2)

L’instruction `while` :

x = 1
while x <= 5:
 print (x, end=' ') # Le paramètre (end) sert à enlever le retour à la ligne, ou terminer par un autre caractère
 x += 2 # x = x + 2

Les fonctions :

Le mot-clé def définit la fonction. Il est suivi du nom de la fonction, et de ses paramètres entre parenthèses.

def add(n): # calculer la somme des chiffres de 1 à n
 somme = 0 # une variable locale
 for i in range(1, n+1):
 somme += i
 return somme
add(3)
# add(10)

# somme # n'est pas défini 'globalement'
# somme = 100 # variable globale
# somme

def fib(a, b, n):
 """ print une suite de fibnoacci à partir des termes a et b, jusqu'à n """
 while a < n:
 print(a, end=' ')
 a, b = b, a+b
fib(5, 8, 2000) '''{même les fonctions sans instruction
 return renvoient une valeur, quoique ennuyeuse. Cette valeur est appelée None }'''

Structures de données

Tuples

Une séquence d’éléments séparés par des virgules (et encadrés par des parenthèses si nécessaire)

t = 'python', 3.5, 101
t
# t[2]

# n = t, 'Guido', ('2.7', 2010), [0, 90] # tuples imbriqués
# n

n[1] = 'Guido van Rossum' # ils sont immutables
# n[3][1] = 100
n

vide = () # initier un tuple vide
# un = 'python',

Les ensembles (`sets`)

Une collection non ordonnée, sans élément dupliqué.

notes = {18, 15, 14, 11 ,18, 14}
notes
# fruits = {'orange', 'raisin', 'pomme' ,'kiwi' , 'orange', 'pomme'}
# fruits

a = set('abccba')
a
# a & set('atta') # supportent d'autres opérations (unions, intersections, différences, etc.)

Dictionnaires

Des ensembles non ordonnés de pairs clé : valeur (key : value pairs). Ils sont indexés par des clés (keys), qui peuvent être de n’importe quel type immuable : chaînes de caractères, nombres et tuples (s’ils ne contiennent que des immutables). Les clés doivent être uniques au sein d’un dictionnaire.

d = {} # créer un dictionnaire vide

# d = {'Marie':15, 'Jean':2, 'Victor':9}
# d['Marie']
# del d['Victor']
# d['Charles'] = 33
d

p = dict([('Anthony', 'a'), ('Guido', [0, 'g']), ('Marie', 'm')])
# p.keys()
# p.values()
# 'guido' in p
# 'Guido' in p

Création des dictionnaires par compréhension (dict comprehensions).

{x: x**3 for x in range(1, 6)}

Modules

Un module est un fichier contenant des définitions et des instructions. Le nom du fichier est celui du module, suffixé de .py.

import <module> # importer le module dans la table des symboles

<module>.<fonction> # accéder aux fonctions (ou constantes)

Pour importer les noms d’un <module_1> directement dans la table des symboles du module qui l’importe (<module_2>). De ce fait, le nom du <module_1> n’est pas défini à l’intérieur du <module_2>

from <module> import <fonction_1>, <fonction_2>, <fonction_n>

Ou bien

from <module> import * # importer tous les noms du module (déconseillé)

Exercice pratique de synthèse

Définir une fonction somme_impairs qui prend une liste de nombres comme argument, et renvoie la somme de tous les entiers impairs. Par exemple :

somme_impairs([5, -13, 3]) = -5
somme_impairs([2, 1, 1.01) = 1

Écrire un programme qui prend une valeur entrée par l’utilisateur (1 <= N <= 100), et affiche un message comme suit :

 - "Votre valeur X est plus grande. Essayer de nouveau !" # si la valeur entrée est plus grande à celle du programme
 - "Votre valeur X est plus petite. Essayer de nouveau !" # si la valeur entrée est plus petite à celle du programme
 - "Bravo ! C'était bien X" # si la valeur entrée est correcte

Avec X est la valeur entrée par l’utilisateur. Penser à utiliser la fonction randint du module random pour générer un entier aléatoirement.

from random import randint
n = randint(1, 100)

Pour plus de détails sur n’importe quel objet, fonction ou module, utiliser : help(<nom>)

Tutorial |

Plotting climate data using pandas

Introduction

Data processing and time series manipulation

Plotting and styling using matplotlib and seaborn

Analysing Olympic Games medal table

Introduction

Stacked bar chart

Bubble chart

Les bases de Python

Utiliser Python comme une calculatrice

Les chaînes de caractères

Les listes

Contrôle du flux

L’instruction if :

L’instruction for :

L’instruction while :

Les fonctions :

Structures de données

Tuples

Les ensembles (sets)

Dictionnaires

Modules

Exercice pratique de synthèse

L’instruction `if` :

L’instruction `for` :

L’instruction `while` :

Les ensembles (`sets`)