2 Types de données

Il existe quelques types de données intégrés dans Python. Nous allons dans cette partie évoquer les chaînes de caractères, les valeurs numériques, les bouléens (TRUE/FALSE), la valeur null et les dates et temps.

2.1 Chaînes de caractères

Une chaîne de caractères, ou string en anglais, est une collection de caractères comme des lettres, des nombres, des espaces, des signes de ponctuation, etc.

Les chaînes de caractères sont repérées à l’aide de guillemets simples, doubles, ou triples.

Voici un exemple :

x = "Hello World"

Pour afficher dans la console le contenu de notre variable x contenant la chaîne de caractères, on fait appel à la fonction print() :

print(x)
## Hello World

Comme indiqué juste avant, des guillemets simples peuvent être utilisés pour créer une chaîne de caractères :

y = 'How are you?'
print(y)
## How are you?

Pour faire figurer des apostrophes dans une chaîne de caractères créée à l’aide de guillemets simples, il est nécessaire d’utiliser un caracrère d’échappement : une barre oblique inversée (\) :

z = 'I\'m fine'
print(z)
## I'm fine

On peut noter que si la chaîne de caractères est créée à l’aide de guillemets doubles, il n’est pas nécessaire d’avoir recours au caractère d’échappement :

z = "I'm \"fine\""
print(z)
## I'm "fine"

Pour indiquer un retour à la ligne, on utilise la chaîne \n :

x = "Hello, \nWorld"
print(x)
## Hello, 
## World

Dans le cas de chaînes de caractères sur plusieurs lignes, le fait d’utiliser des guillemets simples ou doubles renverra une erreur (EOL while scanning trial literal, i.e., détection d’une erreur de syntaxe, Python s’attendait à quelque chose d’autre à la fin de la ligne). Pour écrire une chaîne de caractères sur plusieurs lignes, Python propose d’utiliser trois fois des guillemets (simples ou doubles) en début et fin de chaîne :

x = """Hello,
World"""
print(x)
## Hello,
## World

Le caractère \ (barre oblique inversée, ou backslash) est le caractère d’échappement. Il permet d’afficher certains caractères, comme les guillemets dans une chaîne elle-même définie à l’aide de guillemets, ou bien les caractères de contrôle, comme la tabulation, le saut de ligne, etc. Voici quelques exemples courants :

Code Description Code Description
\n Nouvelle ligne \r Retour à la ligne
\t Tabulation \b Retour arrière
\\ Barre oblique inversée \' Apostrophe
\" Apostrophe double \` Accent grave

Pour récupérer la longueur d’une chaîne de caractères, Python propose la fonction len() :

x = "Hello World !"
print(len(x))
## 13
print(x, len(x))
## Hello World ! 13

2.1.1 Concaténation de chaînes

Pour concaténer des chaînes de caractères, c’est-à-dire les mettre bout à bout, Python propose d’utiliser l’opérateur + :

print("Hello" + " World")
## Hello World

L’opérateur * permet quant à lui de répéter plusieurs fois une chaîne :

print( 3 * "Go Habs Go! " + "Woo Hoo!")
## Go Habs Go! Go Habs Go! Go Habs Go! Woo Hoo!

Lorsque deux littéraux de chaînes sont côte à côte, Python les concatène :

x = ('You shall ' 'not ' "pass!")
print(x)
## You shall not pass!

Il est également possible d’ajouter à une chaîne de caractères le contenu d’une variable, à l’aide de crochets ({}) et de la méthode format()

x = "J'aime coder en {}"
langage_1 = "R"
langage_2 = "Python"
preference_1 = x.format(langage_1)
print(preference_1)
## J'aime coder en R
preference_2 = x.format(langage_2)
print(preference_2)
## J'aime coder en Python

Il est tout à fait possible d’ajouter plus d’un contenu de variable dans une chaîne de caractères, toujours avec les crochets et la méthode format() :

x = "J'aime coder en {} et en {}"
preference_3 = x.format(langage_1, langage_2)
print(preference_3)
## J'aime coder en R et en Python

2.1.2 Indexation et extraction

Les chaînes de caractères peuvent être indexées. Attention, l’indice du premier caractère commence à 0.

Pour obtenir le ie caractère d’une chaîne, on utilise des crochets. La syntaxe est la suivante :

x[i-1]

Par exemple, pour afficher le premier caractère, puis le cinquième de la chaîne Hello :

x = "Hello"
print(x[0])
## H
print(x[4])
## o

L’extraction peut s’effectuer en partant par la fin de la chaîne, en faisant précéder la veleur de l’indice par le signe moins (-).

Par exemple, pour afficher l’avant-dernier caractère de notre chaîne x :

print(x[-2])
## l

L’extraction d’une sous-chaîne en précisant sa position de début et de fin (implicitement ou non) s’effectue avec les crochets également. Il suffit de préciser les deux valeurs d’indices : [debut:fin].

x = "You shall not pass!"

# Du quatrième caractère (non inclus) au neuvième (inclus)
print(x[4:9])
## shall

Lorsque l’on ne précise pas la première valeur, le début de la chaîne est pris par défaut ; lorsque le second n’est pas précisé, la fin de la chaîne est prise par défaut.

# Du 4e caractère (non inclus) à la fin de la chaîne
print(x[4:])
# Du début de la chaîne à l'avant dernier caractère (inclus)
print(x[:-1])
# Du 3e caractère avant la fin (inclus) jusqu'à la fin
print(x[-5:])
## shall not pass!
## You shall not pass
## pass!

Il est possible de rajouter un troisième indice dans les crochets : le pas.

# Du 4e caractère (non inclus), jusqu'à la fin de la chaîne,
# par pas de 3.
print(x[4::3])
## sln s

Pour obtenir la chaîne en dans le sens opposé :

print(x[::-1])
## !ssap ton llahs uoY

2.1.3 Méthodes disponibles avec les chaînes de caractères

De nombreuses méthodes sont disponibles pour les chaînes de caractères. En ajoutant un point (.) après le nom d’un objet désignant une chaîne de caractères puis en appuyant sur la touche de tabulation, les méthodes disponibles s’affichent dans un menu déroulant.

Par exemple, la méthode count() permet de compter le nombre d’occurrences d’un motif dans la chaîne. Pour compter le nombre d’occurrence de in dans la chaîne suivante :

x = "le train de tes injures roule sur le rail de mon indifférence"
print(x.count("in"))
## 3
Une fois l’appel à méthode écrit, en plaçant le curseur à la fin de la ligne et en appuyant sur les touches Shift et Tabulation, on peut afficher des explications.

2.1.3.1 Conversion en majuscules ou en minuscules

Les méthodes lower() et upper() permettent de passer une chaîne de caractères en caractères minuscules et majuscules, respectivement.

x = "le train de tes injures roule sur le rail de mon indifférence"
print(x.lower())
print(x.upper())
## le train de tes injures roule sur le rail de mon indifférence
## LE TRAIN DE TES INJURES ROULE SUR LE RAIL DE MON INDIFFÉRENCE

2.1.3.2 Recherche de chaînes de caractères

Quand on souhaite retrouver un motif dans une chaîne de caractères, on peut utiliser la méthode find(). On fournit en paramètres un motif à rechercher. La méthode find() retourne le plus petit indice dans la chaîne où le motif est trouvé. Si le motif n’est pas retrouvé, la valeur retournée est -1.

print(x.find("in"))
print(x.find("bonjour"))
## 6
## -1

Il est possible d’ajouter en option une indication permettant de limiter la recherche sur une sous-chaîne, en précisant l’indice de début et de fin :

print(x.find("in", 7, 20))
## 16

Note : on peut omettre l’indice de fin ; en ce cas, la fin de la chaîne est utilisée :

print(x.find("in", 20))
## 49
Si on ne désire pas connaître la position de la sous-chaîne, mais uniquement sa présence ou son absence, on peut utiliser l’opérateur in : print("train" in x)

Pour effectuer une recherche sans prêter attention à la casse, on peut utiliser la méthode capitalize() :

x = "Mademoiselle Deray, il est interdit de manger de la choucroute ici."
print(x.find("deray"))
## -1
print(x.capitalize().find("deray"))
## 13

2.1.3.3 Découpage en sous-chaînes

Pour découper une chaîne de caractères en sous-chaînes, en fonction d’un motif servant à la délimitation des sous-chaînes (par exemple une virgule, ou une espace), on utilise la méthode split() :

print(x.split(" "))
## ['Mademoiselle', 'Deray,', 'il', 'est', 'interdit', 'de', 'manger', 'de', 'la', 'choucroute', 'ici.']

En indiquant en paramètres une valeur numérique, on peut limiter le nombre de sous-chaînes retournées :

# Le nombre de sous-chaînes maximum sera de 3
print(x.split(" ", 3))
## ['Mademoiselle', 'Deray,', 'il', 'est interdit de manger de la choucroute ici.']

La méthode splitlines() permet également de séparer une chaîne de caractères en fonction d’un motif, ce motif étant un caractère de fin de ligne, comme un saut de ligne ou un retour chariot par exemple.

x = '''"Luke, je suis ton pere !
- Non... ce n'est pas vrai ! C'est impossible !
- Lis dans ton coeur, tu sauras que c'est vrai.
- Noooooooon ! Noooon !"'''
print(x.splitlines())
## ['"Luke, je suis ton pere !', "- Non... ce n'est pas vrai ! C'est impossible !", "- Lis dans ton coeur, tu sauras que c'est vrai.", '- Noooooooon ! Noooon !"']

2.1.3.4 Nettoyage, complétion

Pour retirer des caractères blancs (e.g., des espaces, sauts de ligne, quadratins, etc.) présents en début et fin de chaîne, on peut utiliser la méthode strip(), ce qui est parfois très utile pour nettoyer des chaînes.

x = "\n\n    Pardon, du sucre ?     \n  \n"
print(x.strip())
## Pardon, du sucre ?

On peut préciser en paramètre quels caractères retirer en début et fin de chaîne :

x = "www.egallic.fr"
print(x.strip("wrf."))
## egallic

Parfois, il est nécessaire de s’assurer d’obtenir une chaîne d’une longueur donnée (lorsque l’on doit fournir un fichier avec des largeurs fixes pour chaque colonne par exemple). La méthode rjust() est alors d’un grand secours. En lui renseignant une longueur de chaîne et un caractère de remplissage, elle retourne la chaîne de caractères avec une complétion éventuelle (si la longueur de la chaîne retournée n’est pas assez longue au regard de la valeur demandée), en répétant le caractère de remplissage autant de fois que nécessaire.

Par exemple, pour avoir une coordonnée de longitude, stockée dans une chaîne de caractères de longueur 7, en rajoutant des espaces si nécessaire :

longitude = "48.11"
print(x.rjust(7," "))
## www.egallic.fr

2.1.3.5 Remplacements

La méthode replace() permet d’effectuer des remplacements de motifs dans une chaîne de caractères.

x = "Criquette ! Vous, ici ? Dans votre propre salle de bain ? Quelle surprise !"
print(x.replace("Criquette", "Ridge"))
## Ridge ! Vous, ici ? Dans votre propre salle de bain ? Quelle surprise !

Cette méthode est très pratique pour retirer des espaces par exemple :

print(x.replace(" ", ""))
## Criquette!Vous,ici?Dansvotrepropresalledebain?Quellesurprise!

Voici un tableau répertoriant quelques méthodes disponibles (liste exhaustive dans la documentation) :

Méthode Description
capitalize() Mise en majuscule du premier caractère et en minuscile du reste
casefold() retire les distinctions de casse (utile pour la comparaison de chaînes sans faire attention à la casse)
count() Compte le nombre d’occurrence (sans chevauchement) d’un motif
encode() Encode une chaîne de caractères dans un encodage spécifique
find() Retourne le plus petit indice où une sous-chaîne est trouvée
lower() Retourne la chaîne en ayant passé chaque caractère alphabétique en minuscules
replace() Remplace un motif par un autre
split() Sépare la chaîne en sous-chaînes en fonction d’un motif
title() Retourne la chaîne en ayant passé chaque première lettre de mot par une majuscule
upper() Retourne la chaîne en ayant passé chaque caractère alphabétique en majuscules

2.1.4 Conversion en chaînes de caractères

Lorsque l’on veut concaténer une chaîne de caractères avec un nombre, Python retourne une erreur.

nb_followers = 0
message = "He has " + nb_followers + "followers."
## TypeError: must be str, not int
## 
## Detailed traceback: 
##   File "<string>", line 1, in <module>
print(message)
## NameError: name 'message' is not defined
## 
## Detailed traceback: 
##   File "<string>", line 1, in <module>

Il est alors nécessaire de convertir au préalable l’objet n’étant pas une chaîne en une chaîne de caractères. Pour ce faire, Python propose la fonction str() :

message = "He has " + str(nb_followers) + " followers."
print(message)
## He has 0 followers.

2.1.5 Exercice

  1. Créer deux variables nommées a et b afin qu’elles contiennent respectivement les chaînes de caractères suivantes : 23 à 0 et C'est la piquette, Jack!.
  2. Afficher le nombre de caractères de a, puis de b.
  3. Concaténer a et b dans une seule chaîne de caractères, en ajoutant une virgule comme caractère de séparation.
  4. Même question en choisissant une séparation permettant un retour à la ligne entre les deux phrases.
  5. À l’aide de la méthode appropriée, mettre en majuscules a et b.
  6. À l’aide de la méthode appropriée, mettre en minuscules a et b.
  7. Extraire le mot la et Jack de la chaîne b, en utilisant les indices.
  8. Rechercher si la sous-chaîne piqu est présente dans b, puis faire de même avec la sous-chaîne mauvais.
  9. Retourner la position (indice) du premier caractère a retrouvé dans la chaîne b, puis essayer avec le caractère w.
  10. Remplacer les occurrences du motif a par le motif Z dans la sous-chaîne b.
  11. Séparer la chaîne b en utilisant la virgule comme séparateur de sous-chaînes.
  12. (Bonus) Retirer tous les caractères de ponctuation de la chaîne b, puis utiliser une méthode appropriée pour retirer les caractères blancs en début et fin de chaîne. (Utiliser la librairie regex).

2.2 Valeurs numériques

Il existe quatre catégories de nombres en Python : les entiers, les nombres à virgule flottante et les complèxes.

2.2.1 Entiers

Les entiers (ints), en Python, sont des nombres entiers signés.

On accède au type d’un objet à l’aide de la fonction type() en Python. 
x = 2
y = -2
print(type(x))
## <class 'int'>
print(type(y))
## <class 'int'>

2.2.2 Nombre à virgule flottante

Les nombres à virgule flottante (floats) représentent les nombres réels. Ils sont écrits à l’aide d’un point permettant de distinguer la partie entière de la partie décimale du nombre.

x = 2.0
y = 48.15162342
print(type(x))
## <class 'float'>
print(type(y))
## <class 'float'>

Il est également possible d’avoir recours aux notations scientifiques, en utilisant E ou e pour indiquer une puissance de 10. Par exemple, pour écrire \(3,2^{12}\), on procèdera comme suit :

x = 3.2E12
y = 3.2e12
print(x)
## 3200000000000.0
print(y)
## 3200000000000.0

Par ailleurs, lorsque le nombre est égal à une fraction de 0, on peut s’affranchir d’écrire le zéro :

print(0.35)
## 0.35
print(.35)
## 0.35

2.2.3 Nombres complèxes

Python permet nativement de manipuler des nombres complèxes, de la forme \(z=a+ib\), où \(a\) et \(b\) sont des nombres à virgule flottante, et tel que \(i^2=(-i)^2=1\). La partie réelle du nombre, \(\mathfrak{R}(z)\), est \(a\) tandis que sa partie imaginaire, \(\mathfrak{I}(z)\), est \(b\).

En python, l’unité imaginaire \(i\) est dénotée par la lettre j.

z = 1+3j
print(z)
## (1+3j)
print(type(z))
## <class 'complex'>

Il est également possible d’utiliser la fonction complex(), qui demande deux paramètres (la partie réelle et la partie imaginaire) :

z = complex(1, 3)
print(z)
## (1+3j)
print(type(z))
## <class 'complex'>

Plusieurs méthodes sont disponibles avec les nombres complèxes. Par exemple, pour accéder au conjugué, Python fournit la méthode conjugate() :

print(z.conjugate())
## (1-3j)

L’accès à la partie réelle d’un complèxe ou à sa partie imaginaire s’effectue à l’aide des méthodes real() et imag(), respectivement.

z = complex(1, 3)
print(z.real())
## TypeError: 'float' object is not callable
## 
## Detailed traceback: 
##   File "<string>", line 1, in <module>
print(z.imag())
## TypeError: 'float' object is not callable
## 
## Detailed traceback: 
##   File "<string>", line 1, in <module>

2.2.4 Conversions

Pour convertir un nombre dans un autre format numérique, Python dispose de quelques fonctions.

2.2.4.1 Conversion en entier

La conversion d’un nombre ou d’une chaîne de caractères en entier s’effectue à l’aide de la fonction int() :

x = "3"
x_int = int(x)
print(type(x_int))
## <class 'int'>
print(type(x))
## <class 'str'>

On note que la conversion d’un nombre à virgule flottante tronque le nombre pour ne garder que la partie entière :

x = 3.6
x_int = int(x)
print(x_int)
## 3

2.2.4.2 Conversion en nombre à virgule flottante

Pour convertir un nombre ou une chaîne de caractères en nombre à virgule flottante (si possible), Python propose d’utiliser la fonction float().

x = "3.6"
x_float = float(x)
print(type(x_float))
## <class 'float'>

Avec un entier à l’origine :

x = 3
x_float = float(x)
print(x_float)
## 3.0

2.2.4.3 Conversion en complèxe

La conversion d’un nombre ou d’une chaîne de caractères en nombre complèxe s’effectue avec la fonction complex() :

x = "2"
x_complex = complex(x)
print(x_complex)
## (2+0j)

Avec un float :

x = 2.4
x_complex = complex(x)
print(x_complex)
## (2.4+0j)

2.3 Booléens

Les données de type logique peuvent prendre deux valeurs : True ou False. Elles répondent à une condition logique. Il faut faire attention à bien respecter la casse.

x = True
y = False
print(x, y)
## True False

True peut être converti automatiquement en 1 ; False en 0. Cela peut s’avérer très pratique, pour faire des comptages de valeurs vraies ou fausses dans les colonnes d’un tableau de données, par exemple.

res = True + True + False + True*True
print(res)
## 3

2.4 Objet vide

L’objet vide, communément appelé null, possède un équivalent en Python : None. Pour l’assigner à une variable, il faut faire attention à la casse :

x = None
print(x)
## None
print(type(x))
## <class 'NoneType'>

L’objet None est une variable neutre, au comportement “null”.

Pour tester si un objet est l’objet None, on procède comme suit (le résultat est un booléen) :

x = 1
y = None
print(x is None)
## False
print(y is None)
## True

2.5 Dates et temps

Il existe plusieurs moduels pour gérer les dates et le temps en Python. Nous allons explorer une partie du module datetime.

2.5.1 Module datetime

Python possède un module appelé datetime qui offre la possibilité de manipuler des dates et des durées (dates et times).

Il existe plusieurs types d’objets désignant des dates :

  • date : une date suivant le calendrier grégorien, renseignant l’année, le mois et le jour ;
  • time : un temp donné, sans prise en compte d’un jour particulier, renseignant l’heure, la minute, la seconde (possiblement la microseconde et le fuseau horaire également).
  • datetime : une date combinant date et time ;
  • timedelta : une durée entre deux objets de type dates, time ou datetime ;
  • tzinfo : un type de base abstraite, renseignant au sujet des fuseaux horaires ;
  • timezone : un type utilisant le type tzinfo comme un décalage fixe par rapport à l’UTC.

2.5.1.1 Date

Les objets de type date désignent des dates du calendrier grégorien, pour lesquelles sont mentionnées les caractéristiques suivantes : l’année, le mois et le jour.

Pour créer un objet date, la syntaxe est la suivante :

date(year, month, day)

Par exemple, pour créer la date renseignant le 23 avril 2013 :

from datetime import date
debut = date(year = 2013, month = 4, day = 23)
print(debut)
## 2013-04-23
print(type(debut))
## <class 'datetime.date'>
Il n’est pas obligatoire de préciser le nom des paramètres dans l’appel à la fonction date. L’ordre à respecter devra toutefois être le suivant : année, mois, jour.

On peut ensuite accéder aux attributs de la date créée (ce sont des entiers) :

print(debut.year) # Extraire l'année
## 2013
print(debut.month) # Extraire le mois
## 4
print(debut.day) # Extraire le jour
## 23

Les objets du type date possèdent quelques méthodes. Nous allons passer en revue quelques-unes d’entre-elles.

2.5.1.1.1 ctime()

La méthode ctime() retourne la date sous forme d’une chaîne de caractères.

print(debut.ctime())
## Tue Apr 23 00:00:00 2013
2.5.1.1.2 weekday()

La méthode weekday() retourne la position du jour de la semaine (lundi valant 0, dimanche 6)

print(debut.weekday())
## 1
Cette méthode peut être très pratique lors d’une analyse des données, pour explorer les aspects de saisonnalité hebdomadaire.
2.5.1.1.3 isoweekday()

Dans la même veine que weekday(), la méthode isoweekday() retourne la position du jour de la semaine, en attribuant cette fois la valeur 1 au lundi et 7 au dimanche.

print(debut.isoweekday())
## 2
2.5.1.1.4 toordinal()

La méthode toordinal() retourne le numéro du jour, en prenant comme référence la valeur 1 pour le premier jour de l’an 1.

print(debut.toordinal())
## 734981
2.5.1.1.5 isoformat()

La méthode isoformat() retourne la date en numérotation ISO, sous forme d’une chaîne de caractères.

print(debut.isoformat())
## 2013-04-23
2.5.1.1.6 isocalendar()

La méthode isocalendar() retourne un nuplet (c.f. Section 3.2) comprenant trois éléments : l’année, le numéro de la semaine et le jour de la semaine (les trois en numérotation ISO).

print(debut.isocalendar())
## (2013, 17, 2)
2.5.1.1.7 replace()

La méthode replace() retourne la date après avoir effectué une modification

x = debut.replace(year=2014)
y = debut.replace(month=5)
z = debut.replace(day=24)
print(x, y, z)
## 2014-04-23 2013-05-23 2013-04-24

Cela n’a pas d’incidence sur l’objet d’origine :

print(debut)
## 2013-04-23

Il est possible de modifier plusieurs éléments en même temps :

x = debut.replace(day=24, month=5)
print(x)
## 2013-05-24
2.5.1.1.8 strftime()

La méthode strftime() retourne, sous la forme d’une chaîne de caractères, une représentation de la date, selon un masque utilisé.

Par exemple, pour que la date soit représentée sous la forme DD-MM-YYYY (jour sur deux chiffres, mois sur deux chiffres et année sur 4) :

print(debut.strftime("%d-%m-%Y"))
## 23-04-2013

Dans l’exemple précédent, on note deux choses : la présence de directives de formatage (qui commencent par le symbole de pourcentage) et des caractères autres (ici, les tirets). On peut noter que les caractères peuvent être remplacés par d’autres, il s’agit ici d’un choix pour représenter la date en séparant ses éléments par ddes tirets. Il est tout à fait possible d’adopter une autre écriture, par exemple avec des barres obliques, ou même d’autres chaînes de caractères :

print(debut.strftime("%d/%m/%Y"))
## 23/04/2013
print(debut.strftime("Jour : %d, Mois : %m, Annee : %Y"))
## Jour : 23, Mois : 04, Annee : 2013

Concernant les directives de formatage, elles correspondent aux codes requis par le standard C (c.f. la documentation de Python). En voici quelques-uns :

Table 2.1: Codes de formatages
Code Description Exemple
%a Abréviation du jour de la semaine (dépend du lieu) Tue
%A Jour de la semaine complet (dépend du lieu) Tuesday
%b Abréviation du mois (dépend du lieu) Apr
%B Nom du mois complet (dépend du lieu) octobre April
%c Date et heure (dépend du lieu) au format %a %e %b %H:%M:%S:%Y Tue Apr 23 00:00:00 2013
%C Siècle (00-99) -1 (partie entière de la division de l’année par 100) 20
%d Jour du mois (01–31) 23
%D Date au format %m/%d/%y 04/23/13
%e Jour du mois en nombre décimal (1–31) 23
%F Date au format %Y-%m-%d 2013-04-23
%h Même chose que %b Apr
%H Heure (00–24) 00
%I Heure (01–12) 12
%j Jour de l’année (001–366) 113
%m Mois (01–12) 04
%M Minute (00-59) 00
%n Retour à la ligne en output, caractère blanc en input \n
%p AM/PM PM AM
%r Heure au format 12 AM/PM 12:00:00 AM
%R Même chose que %H:%M 00:00
%S Seconde (00-61) 00
%t Tabulation en output, caractère blanc en input \t
%T Même chose que %H:%M:%S 00:00:00
%u Jour de la semaine (1–7), commence le lundi 2
%U Semaine de l’anné (00–53), dimanche comme début de semaine, et le premier dimanche de l’année définit la semaine 16
%V Semaine de l’année (00-53). Si la semaine (qui commence un lundi) qui contient le 1 er janvier a quatre jours ou plus dans la nouvelle année, alors elle est considérée comme la semaine 1. Sinon, elle est considérée comme la dernière de l’année précédente, et la semaine suivante est considérée comme semaine 1 (norme ISO 8601) 17
%w Jour de la semaine (0–6), dimanche étant 0 2
%W Semaine de l’année (00–53), le lundi étant le premier jour de la semaine, et typiquement, le premier lundi de l’année définit la semaine 1 (conviention G.B.) 16
%x Date (dépend du lieu) 04/23/13
%X Heure (dépend du lieu) 00:00:00'
%y Année sans le “siècle”" (00–99) 13
%Y Année (en input, uniquement de 0 à 9999) 2013
%z offset en heures et minutes par rapport au temps UTC
%Z Abréviation du fuseau horaire (en output seulement) CEST

2.5.1.2 Time

Les objets de type time désignent des temps précis sans prise en compte d’un jour particulier. Ils renseignant l’heure, la minute, la seconde (possiblement la microseconde et le fuseau horaire également).

Pour créer un objet time, la syntaxe est la suivante :

time(hour, minute, second)

Par exemple, pour créer le moment 23:04:59 (vingt-trois heures, quatre minutes et cinquante-neuf secondes) :

from datetime import time
moment = time(hour = 23, minute = 4, second = 59)
print(moment)
## 23:04:59
print(type(moment))
## <class 'datetime.time'>

On peut rajouter des informations sur la microseconde. Sa valeur doit être comprise entre zéro et un million.

moment = time(hour = 23, minute = 4, second = 59, microsecond = 230)
print(moment)
## 23:04:59.000230
print(type(moment))
## <class 'datetime.time'>

On peut ensuite accéder aux attributs de la date créée (ce sont des entiers), parmi lesquels :

print(moment.hour) # Extraire l'heure
## 23
print(moment.minute) # Extraire la minute
## 4
print(moment.second) # Extraire la seconde
## 59
print(moment.microsecond) # Extraire la microseconde
## 230

Les objets du type time possèdent quelques méthodes, dont l’utilisation est similaire aux objets de classe date (se référer à la Section 2.5.1.1).

2.5.1.3 Datetime

Les objets de type datetime combinent les éléments des objets de type date et time. Ils renseignant le jour dans le calendrier grégorien ainsi que l’heure, la minute, la seconde (possiblement la microseconde et le fuseau horaire).

Pour créer un objet datetime, la syntaxe est la suivante :

datetime(year, month, day, hour, minute, second, microsecond)

Par exemple, pour créer la date 23-04-2013 à 17:10:00 :

from datetime import datetime
x = datetime(year = 2013, month = 4, day = 23,
  hour = 23, minute = 4, second = 59)
print(x)
## 2013-04-23 23:04:59
print(type(x))
## <class 'datetime.datetime'>

Les objets de type datetime disposent des attributs des objets de type date (c.f. Section 2.5.1.1) et de type time (c.f. Section 2.5.1.2).

Pour ce qui est des méthodes, davantage sont disponibles. Nous allons en commenter certaines.

2.5.1.3.1 today() et now()

Les méthodes today() et now() retournent le datetime courant, celui au moment où est évaluée l’instruction :

print(x.today())
## 2018-10-19 16:06:56.835013
print(datetime.today())
## 2018-10-19 16:06:56.836414

La distinction entre les deux réside dans le fuseau horaire. Avec today(), l’attribut tzinfo est mis à None, tandis qu’avec now(), l’attribut tzinfo, s’il est indiqué, est pris en compte.

2.5.1.3.2 timestamp()

La méthode timestamp() retourne, sous forme d’un nombre à virgule flottante, le timestamp POSIX correspondant à l’objet de type datetime. Le timestamp POSIX correspond à l’heure Posix, équivalent au nombre de secondes écoulées depuis le premier janvier 1970, à 00:00:00 UTC.

print(x.timestamp())
## 1366751099.0
2.5.1.3.3 date()

La méthode date() retourne un objet de type date dont les attributs d’année, de mois et de jour sont identiques à ceux de l’objet :

x_date = x.date()
print(x_date)
## 2013-04-23
print(type(x_date))
## <class 'datetime.date'>
2.5.1.3.4 time()

La méthode time() retourne un objet de type time dont les attributs d’heure, minute, seconde, microseconde sont identiques à ceux de l’objet :

x_time = x.time()
print(x_time)
## 23:04:59
print(type(x_time))
## <class 'datetime.time'>

2.5.1.4 Timedelta

Les objets de type timedelta représentent des durées séparant deux dates ou heures.

Pour créer un objet de type timedelta, la syntaxe est la suivante :

timedelta(days, hours, minutes, seconds, microseconds)

Il n’est pas obligatoire de fournir une valeur à chaque paramètre. Lorsque qu’un paramètre ne reçoit pas de valeur, celle qui lui est attribuée par défaut est 0.

Par exemple, pour créer un objet indiquant une durée de 1 jour et 30 secondes :

from datetime import timedelta
duree = timedelta(days = 1, seconds = 30)
duree
datetime.timedelta(1, 30)

On peut accéder ensuite aux attributs (ayant été définis). Par exemple, pour accéder au nombre de jours que représente la durée :

duree.days
1

La méthode total_seconds() permet d’obtenir la durée exprimée en secondes :

duree = timedelta(days = 1, seconds = 30, hours = 20)
duree.total_seconds()
158430.0
2.5.1.4.1 Durée séparant deux objets date ou datetime

Lorsqu’on soustrait deux objets de type date, on obtient le nombre de jours séparant ces deux dates, sous la forme d’un objet de type timedelta :

from datetime import timedelta
debut = date(2018, 1, 1)
fin = date(2018, 1, 2)
nb_jours = fin-debut
print(type(nb_jours))
## <class 'datetime.timedelta'>
print(nb_jours)
## 1 day, 0:00:00

Lorsqu’on soustrait deux objets de type datetime, on obtient le nombre de jours, secondes (et microsecondes, si renseignées) séparant ces deux dates, sous la forme d’un objet de type timedelta :

debut = datetime(2018, 1, 1, 12, 26, 30, 230)
fin = datetime(2018, 1, 2, 11, 14, 31)
duree = fin-debut
print(type(duree))
## <class 'datetime.timedelta'>
print(duree)
## 22:48:00.999770

On peut noter que les durée données prennent en compte les années bissextiles. Regardons d’abord pour une année non-bissextile, le nombre de jours séparant le 28 février du premier mars :

debut = date(2021, 2,28)
fin = date(2021, 3, 1)
duree = fin - debut
duree
datetime.timedelta(1)

Regardons à présent la même chose, mais dans le cas d’une année bissextile :

debut_biss = date(2020, 2,28)
fin_biss = date(2020, 3, 1)
duree_biss = fin_biss - debut_biss
duree_biss
datetime.timedelta(2)

Il est également possible d’ajouter des durées à une date :

debut = datetime(2018, 12, 31, 23, 59, 59)
print(debut + timedelta(seconds = 1))
## 2019-01-01 00:00:00

2.5.2 Module pytz

Si la gestion des dates revêt une importance particulière, une librairie propose d’aller un peu plus loins, notamment en ce qui concerne la gestion des fuseaux horaires. Cette librarie s’appelle pytz. De nombreux exemples sont proposés sur la page web du projet.

2.5.3 Exercices

  1. En utilisant la fonction appropriée, stocker la date du 29 août 2019 dans un objet que l’on appellera d puis afficher le type de l’objet.
  2. À l’aide de la fonction appropriée, afficher la date du jour.
  3. Stocker la date suivante dans un objet nommé d2 : “2019-08-29 20:30:56”. Puis, afficher dans la console avec la fonction print() les attributs d’année, de minute et de seconde de d2.
  4. Ajouter 2 jours, 3 heures et 4 minutes à d2, et stocker le résultat dans un objet appelé d3.
  5. Afficher la différence en secondes entre d3 et d2.
  6. À partir de l’objet d2, afficher sous forme de chaîne de caractères la date de d2 de manière à ce qu’elle respecte la syntaxe suivante : “Mois Jour, Année”, avec “Mois” le nom du mois (August), “Jour” le numéro du jour sur deux chiffres (29) et “Année” l’année de la date (2019).