diff --git a/French/02_variables_builtin_functions_fr.md b/French/02_variables_builtin_functions_fr.md new file mode 100644 index 000000000..4d681a254 --- /dev/null +++ b/French/02_variables_builtin_functions_fr.md @@ -0,0 +1,304 @@ +
+

30 Jours de Python : Jour 2 - Variables, Fonctions intégrées

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + + +
+ +[<< Jour 1](./README_fr.md) | [Jour 3 >>](./03_operators_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 2](#-jour-2) + - [Fonctions intégrées](#fonctions-intégrées) + - [Variables](#variables) + - [Déclaration de plusieurs variables sur une ligne](#déclaration-de-plusieurs-variables-sur-une-ligne) + - [Types de données](#types-de-données) + - [Vérification des types de données et conversion](#vérification-des-types-de-données-et-conversion) + - [Nombres](#nombres) + - [💻 Exercices - Jour 2](#-exercices---jour-2) + - [Exercices : Niveau 1](#exercices--niveau-1) + - [Exercices : Niveau 2](#exercices--niveau-2) + +# 📘 Jour 2 + +## Fonctions intégrées + +Python dispose de nombreuses fonctions intégrées (built-in functions). Les fonctions intégrées sont disponibles globalement, ce qui signifie que vous pouvez les utiliser sans avoir à importer ou configurer quoi que ce soit. Voici quelques-unes des fonctions intégrées les plus couramment utilisées en Python : _print()_, _len()_, _type()_, _int()_, _float()_, _str()_, _input()_, _list()_, _dict()_, _min()_, _max()_, _sum()_, _sorted()_, _open()_, _file()_, _help()_ et _dir()_. Dans le tableau suivant, vous trouverez une liste exhaustive des fonctions intégrées de Python tirée de la [documentation Python](https://docs.python.org/3/library/functions.html). + +![Fonctions intégrées](../images/builtin-functions.png) + +Ouvrons le shell Python et commençons à utiliser certaines des fonctions intégrées les plus courantes. + +![Fonctions intégrées](../images/builtin-functions_practice.png) + +Pratiquons davantage en utilisant différentes fonctions intégrées. + +![Fonctions Help et Dir](../images/help_and_dir_builtin.png) + +Comme vous pouvez le voir dans le terminal ci-dessus, Python possède des mots réservés. Nous n'utilisons pas les mots réservés pour déclarer des variables ou des fonctions. Nous aborderons les variables dans la section suivante. + +Je pense que vous êtes désormais familiarisé avec les fonctions intégrées. Pratiquons encore une fois avant de passer à la section suivante. + +![Min Max Sum](../images/builtin-functional-final.png) + +## Variables + +Les variables stockent des données dans la mémoire de l'ordinateur. Il est recommandé d'utiliser des variables mnémoniques dans de nombreux langages de programmation. Une variable mnémonique est un nom de variable facile à retenir et à associer. Une variable fait référence à une adresse mémoire dans laquelle les données sont stockées. +Un chiffre au début, un caractère spécial ou un trait d'union ne sont pas autorisés lors du nommage d'une variable. Une variable peut avoir un nom court (comme x, y, z), mais un nom plus descriptif (prénom, nom, âge, pays) est fortement recommandé. + +Règles de nommage des variables en Python + +- Un nom de variable doit commencer par une lettre ou le caractère de soulignement +- Un nom de variable ne peut pas commencer par un chiffre +- Un nom de variable ne peut contenir que des caractères alphanumériques et des traits de soulignement (A-z, 0-9 et \_ ) +- Les noms de variables sont sensibles à la casse (firstname, Firstname, FirstName et FIRSTNAME sont des variables différentes) + +Voici quelques exemples de noms de variables valides : + +```shell +firstname +lastname +age +country +city +first_name +last_name +capital_city +_if # si on veut utiliser un mot réservé comme variable +year_2021 +year2021 +current_year_2021 +birth_year +num1 +num2 +``` + +Noms de variables invalides + +```shell +first-name +first@name +first$name +num-1 +1num +``` + +Nous utiliserons la convention de nommage standard de Python adoptée par de nombreux développeurs Python. Les développeurs Python utilisent la convention de nommage snake_case. Nous utilisons un trait de soulignement après chaque mot pour une variable contenant plus d'un mot (ex. first_name, last_name, engine_rotation_speed). L'exemple ci-dessous illustre le nommage standard des variables ; le trait de soulignement est nécessaire lorsque le nom de la variable comporte plus d'un mot. + +Lorsque nous assignons un certain type de données à une variable, cela s'appelle une déclaration de variable. Par exemple, dans l'exemple ci-dessous, mon prénom est affecté à la variable first_name. Le signe égal est un opérateur d'affectation. Affecter signifie stocker des données dans la variable. Le signe égal en Python n'est pas une égalité mathématique. + +_Exemple :_ + +```py +# Variables en Python +first_name = 'Asabeneh' +last_name = 'Yetayeh' +country = 'Finland' +city = 'Helsinki' +age = 250 +is_married = True +skills = ['HTML', 'CSS', 'JS', 'React', 'Python'] +person_info = { + 'firstname':'Asabeneh', + 'lastname':'Yetayeh', + 'country':'Finland', + 'city':'Helsinki' + } +``` + +Utilisons les fonctions intégrées _print()_ et _len()_. La fonction print accepte un nombre illimité d'arguments. Un argument est une valeur que l'on peut passer ou placer entre les parenthèses de la fonction, comme dans l'exemple ci-dessous. + +**Exemple :** + +```py +print('Hello, World!') # Le texte Hello, World! est un argument +print('Hello',',', 'World','!') # elle peut prendre plusieurs arguments, quatre arguments ont été passés +print(len('Hello, World!')) # elle ne prend qu'un seul argument +``` + +Affichons et trouvons aussi la longueur des variables déclarées plus haut : + +**Exemple :** + +```py +# Affichage des valeurs stockées dans les variables + +print('Prénom :', first_name) +print('Longueur du prénom :', len(first_name)) +print('Nom : ', last_name) +print('Longueur du nom : ', len(last_name)) +print('Pays : ', country) +print('Ville : ', city) +print('Âge : ', age) +print('Marié : ', is_married) +print('Compétences : ', skills) +print('Infos personne : ', person_info) +``` + +### Déclaration de plusieurs variables sur une ligne + +Plusieurs variables peuvent également être déclarées sur une seule ligne : + +**Exemple :** + +```py +first_name, last_name, country, age, is_married = 'Asabeneh', 'Yetayeh', 'Helsinki', 250, True + +print(first_name, last_name, country, age, is_married) +print('Prénom :', first_name) +print('Nom : ', last_name) +print('Pays : ', country) +print('Âge : ', age) +print('Marié : ', is_married) +``` + +Obtenir une entrée utilisateur à l'aide de la fonction intégrée _input()_. Assignons les données obtenues d'un utilisateur aux variables first_name et age. +**Exemple :** + +```py +first_name = input('Quel est votre nom : ') +age = input('Quel âge avez-vous ? ') + +print(first_name) +print(age) +``` + +## Types de données + +Il existe plusieurs types de données en Python. Pour identifier le type de données, nous utilisons la fonction intégrée _type_. Je voudrais vous demander de vous concentrer pour bien comprendre les différents types de données. En programmation, tout tourne autour des types de données. J'ai présenté les types de données au tout début et ils reviennent ici, car chaque sujet est lié aux types de données. Nous couvrirons les types de données plus en détail dans leurs sections respectives. + +## Vérification des types de données et conversion + +- Vérifier les types de données : Pour vérifier le type de données d'une certaine donnée/variable, nous utilisons _type_ + **Exemples :** + +```py +# Différents types de données Python +# Déclarons des variables avec différents types de données + +first_name = 'Asabeneh' # str (chaîne de caractères) +last_name = 'Yetayeh' # str +country = 'Finland' # str +city = 'Helsinki' # str +age = 250 # int (entier), ce n'est pas mon vrai âge, ne vous inquiétez pas + +# Affichage des types +print(type('Asabeneh')) # str +print(type(first_name)) # str +print(type(10)) # int +print(type(3.14)) # float +print(type(1 + 1j)) # complex (nombre complexe) +print(type(True)) # bool (booléen) +print(type([1, 2, 3, 4])) # list (liste) +print(type({'name':'Asabeneh'})) # dict (dictionnaire) +print(type((1,2))) # tuple (tuple) +print(type(zip([1,2],[3,4]))) # zip +``` + +- Conversion (casting) : Convertir un type de données en un autre type de données. Nous utilisons _int()_, _float()_, _str()_, _list_, _set_ + Lorsque nous effectuons des opérations arithmétiques, les nombres sous forme de chaînes doivent d'abord être convertis en int ou float, sinon une erreur sera renvoyée. Si nous concaténons un nombre avec une chaîne, le nombre doit d'abord être converti en chaîne. Nous parlerons de la concaténation dans la section sur les chaînes de caractères. + + **Exemples :** + +```py +# int (entier) vers float (décimal) +num_int = 10 +print('num_int',num_int) # 10 +num_float = float(num_int) +print('num_float:', num_float) # 10.0 + +# float vers int +gravity = 9.81 +print(int(gravity)) # 9 + +# int vers str (chaîne) +num_int = 10 +print(num_int) # 10 +num_str = str(num_int) +print(num_str) # '10' + +# str vers int ou float +num_str = '10.6' +num_float = float(num_str) # Convertit d'abord la chaîne en float +num_int = int(num_float) # Ensuite convertit le float en int +print('num_int', num_int) # 10 +print('num_float', float(num_str)) # 10.6 +num_int = int(num_float) +print('num_int', int(num_int)) # 10 + +# str vers list (liste) +first_name = 'Asabeneh' +print(first_name) # 'Asabeneh' +first_name_to_list = list(first_name) +print(first_name_to_list) # ['A', 's', 'a', 'b', 'e', 'n', 'e', 'h'] +``` + +## Nombres + +Types de données numériques en Python : + +1. Entiers : nombres (négatifs, zéro et positifs) + Exemple : + ... -3, -2, -1, 0, 1, 2, 3 ... + +2. Nombres à virgule flottante (décimaux) + Exemple : + ... -3.5, -2.25, -1.0, 0.0, 1.1, 2.2, 3.5 ... + +3. Nombres complexes + Exemple : + 1 + j, 2 + 4j, 1 - 1j + +🌕 Vous êtes formidable. Vous venez de terminer les défis du jour 2 et vous avez deux pas d'avance sur la voie de la réussite. Maintenant, faites quelques exercices pour votre cerveau et vos muscles. + +## 💻 Exercices - Jour 2 + +### Exercices : Niveau 1 + +1. Dans 30DaysOfPython, créez un dossier appelé day_2. Dans ce dossier, créez un fichier nommé variables.py +2. Écrivez un commentaire Python disant 'Day 2: 30 Days of python programming' +3. Déclarez une variable de prénom et assignez-lui une valeur +4. Déclarez une variable de nom de famille et assignez-lui une valeur +5. Déclarez une variable de nom complet et assignez-lui une valeur +6. Déclarez une variable de pays et assignez-lui une valeur +7. Déclarez une variable de ville et assignez-lui une valeur +8. Déclarez une variable d'âge et assignez-lui une valeur +9. Déclarez une variable d'année et assignez-lui une valeur +10. Déclarez une variable is_married et assignez-lui une valeur +11. Déclarez une variable is_true et assignez-lui une valeur +12. Déclarez une variable is_light_on et assignez-lui une valeur +13. Déclarez plusieurs variables sur une seule ligne + +### Exercices : Niveau 2 + +1. Vérifiez le type de données de toutes vos variables à l'aide de la fonction intégrée type() +2. Utilisez la fonction intégrée _len()_ pour trouver la longueur de votre prénom +3. Comparez la longueur de votre prénom et de votre nom de famille +4. Déclarez 5 comme num_one et 4 comme num_two +5. Additionnez num_one et num_two et assignez le résultat à une variable total +6. Soustrayez num_two de num_one et assignez le résultat à une variable diff +7. Multipliez num_two et num_one et assignez le résultat à une variable product +8. Divisez num_one par num_two et assignez le résultat à une variable division +9. Utilisez le modulo pour diviser num_two par num_one et assignez le résultat à une variable remainder +10. Calculez num_one à la puissance num_two et assignez le résultat à une variable exp +11. Trouvez la division entière (floor division) de num_one par num_two et assignez le résultat à une variable floor_division +12. Le rayon d'un cercle est de 30 mètres. + 1. Calculez l'aire du cercle et assignez la valeur à une variable nommée _area_of_circle_ + 2. Calculez la circonférence du cercle et assignez la valeur à une variable nommée _circum_of_circle_ + 3. Prenez le rayon comme entrée utilisateur et calculez l'aire. +13. Utilisez la fonction intégrée input() pour obtenir le prénom, le nom, le pays et l'âge d'un utilisateur et stockez les valeurs dans les noms de variables correspondants +14. Exécutez help('keywords') dans le shell Python ou dans votre fichier pour vérifier les mots réservés ou mots-clés de Python + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 1](./README_fr.md) | [Jour 3 >>](./03_operators_fr.md) diff --git a/French/03_operators_fr.md b/French/03_operators_fr.md new file mode 100644 index 000000000..98fbde6fc --- /dev/null +++ b/French/03_operators_fr.md @@ -0,0 +1,316 @@ +
+

30 Jours de Python : Jour 3 - Opérateurs

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + +
+ +[<< Jour 2](./02_variables_builtin_functions_fr.md) | [Jour 4 >>](./04_strings_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 3](#-jour-3) + - [Booléen](#booléen) + - [Opérateurs](#opérateurs) + - [Opérateurs d'affectation](#opérateurs-daffectation) + - [Opérateurs arithmétiques](#opérateurs-arithmétiques) + - [Opérateurs de comparaison](#opérateurs-de-comparaison) + - [Opérateurs logiques](#opérateurs-logiques) + - [💻 Exercices - Jour 3](#-exercices---jour-3) + +# 📘 Jour 3 + +## Booléen + +Un booléen est un type de données qui ne peut prendre que deux valeurs : _True_ (Vrai) ou _False_ (Faux). Leur utilité deviendra évidente quand nous commencerons à utiliser les opérateurs de comparaison. La première lettre **T** pour True et **F** pour False doit être en majuscule, contrairement à JavaScript. +**Exemple : Valeurs booléennes** + +```py +print(True) +print(False) +``` + +## Opérateurs + +Python propose plusieurs types d'opérateurs. Dans cette section, nous allons nous concentrer sur les principaux. + +### Opérateurs d'affectation + +Les opérateurs d'affectation servent à assigner des valeurs aux variables. Prenons le signe `=` comme exemple. En mathématiques, il indique une égalité entre deux valeurs, mais en Python, il signifie que l'on stocke une valeur dans une variable — on appelle cela une affectation. Le tableau ci-dessous présente les différents opérateurs d'affectation Python, tiré de [w3schools](https://www.w3schools.com/python/python_operators.asp). + +![Opérateurs d'affectation](../images/assignment_operators.png) + +### Opérateurs arithmétiques + +- Addition(+) : a + b +- Soustraction(-) : a - b +- Multiplication(*) : a * b +- Division(/) : a / b +- Modulo(%) : a % b +- Division entière(//) : a // b +- Exponentiation(**) : a ** b + +![Opérateurs arithmétiques](../images/arithmetic_operators.png) + +**Exemple : Entiers** + +```py +# Opérations arithmétiques en Python +# Entiers + +print('Addition : ', 1 + 2) # 3 +print('Soustraction : ', 2 - 1) # 1 +print('Multiplication : ', 2 * 3) # 6 +print ('Division : ', 4 / 2) # 2.0 La division en Python donne un nombre flottant +print('Division : ', 6 / 2) # 3.0 +print('Division : ', 7 / 2) # 3.5 +print('Division sans le reste : ', 7 // 2) # 3, donne sans la partie décimale +print ('Division sans le reste : ',7 // 3) # 2 +print('Modulo : ', 3 % 2) # 1, donne le reste +print('Exponentiation : ', 2 ** 3) # 8 signifie 2 * 2 * 2 +``` + +**Exemple : Flottants** + +```py +# Nombres flottants +print('Nombre flottant, PI', 3.14) +print('Nombre flottant, gravité', 9.81) +``` + +**Exemple : Nombres complexes** + +```py +# Nombres complexes +print('Nombre complexe : ', 1 + 1j) +print('Multiplication de nombres complexes : ',(1 + 1j) * (1 - 1j)) +``` + +Déclarons une variable et assignons-lui un type de données numérique. Je vais utiliser des noms de variables à un seul caractère, mais rappelez-vous de ne pas prendre l'habitude de déclarer ce genre de variables. Les noms de variables doivent toujours être explicites. + +**Exemple :** + +```python +# Déclaration des variables en premier + +a = 3 # a est un nom de variable et 3 est un entier +b = 2 # b est un nom de variable et 2 est un entier + +# Opérations arithmétiques et affectation du résultat à une variable +total = a + b +diff = a - b +product = a * b +division = a / b +remainder = a % b +floor_division = a // b +exponential = a ** b + +# J'aurais dû utiliser sum au lieu de total, mais sum est une fonction intégrée - essayez d'éviter de masquer les fonctions intégrées +print(total) # si vous n'étiquetez pas votre print avec une chaîne, vous ne savez jamais d'où vient le résultat +print('a + b = ', total) +print('a - b = ', diff) +print('a * b = ', product) +print('a / b = ', division) +print('a % b = ', remainder) +print('a // b = ', floor_division) +print('a ** b = ', exponential) +``` + +**Exemple :** + +```py +print('== Addition, Soustraction, Multiplication, Division, Modulo ==') + +# Déclaration des valeurs et organisation +num_one = 3 +num_two = 4 + +# Opérations arithmétiques +total = num_one + num_two +diff = num_two - num_one +product = num_one * num_two +div = num_two / num_one +remainder = num_two % num_one + +# Affichage des résultats avec étiquettes +print('total : ', total) +print('différence : ', diff) +print('produit : ', product) +print('division : ', div) +print('reste : ', remainder) +``` + +Commençons à faire le lien et à utiliser ce que nous savons déjà pour calculer (aire, volume, densité, poids, périmètre, distance, force). + +**Exemple :** + +```py +# Calcul de l'aire d'un cercle +radius = 10 # rayon d'un cercle +area_of_circle = 3.14 * radius ** 2 # deux * signifie exposant ou puissance +print('Aire du cercle :', area_of_circle) + +# Calcul de l'aire d'un rectangle +length = 10 +width = 20 +area_of_rectangle = length * width +print('Aire du rectangle :', area_of_rectangle) + +# Calcul du poids d'un objet +mass = 75 +gravity = 9.81 +weight = mass * gravity +print(weight, 'N') # Ajout de l'unité au poids + +# Calcul de la densité d'un liquide +mass = 75 # en Kg +volume = 0.075 # en mètres cubes +density = mass / volume # 1000 Kg/m^3 +print(density, 'Kg/m^3') # Ajout de l'unité à la densité +``` + +### Opérateurs de comparaison + +En programmation, nous comparons des valeurs à l'aide d'opérateurs de comparaison. Nous vérifions si une valeur est supérieure, inférieure ou égale à une autre. Le tableau suivant présente les opérateurs de comparaison Python, tiré de [w3schools](https://www.w3schools.com/python/python_operators.asp). + +![Opérateurs de comparaison](../images/comparison_operators.png) +**Exemple : Opérateurs de comparaison** + +```py +print(3 > 2) # True, car 3 est supérieur à 2 +print(3 >= 2) # True, car 3 est supérieur à 2 +print(3 < 2) # False, car 3 est supérieur à 2 +print(2 < 3) # True, car 2 est inférieur à 3 +print(2 <= 3) # True, car 2 est inférieur à 3 +print(3 == 2) # False, car 3 n'est pas égal à 2 +print(3 != 2) # True, car 3 n'est pas égal à 2 +print(len('mango') == len('avocado')) # False +print(len('mango') != len('avocado')) # True +print(len('mango') < len('avocado')) # True +print(len('milk') != len('meat')) # False +print(len('milk') == len('meat')) # True +print(len('tomato') == len('potato')) # True +print(len('python') > len('dragon')) # False + + +# Comparer quelque chose donne soit True, soit False + +print('True == True : ', True == True) +print('True == False : ', True == False) +print('False == False :', False == False) +``` + +En plus des opérateurs de comparaison ci-dessus, Python utilise : + +- _is_ : Renvoie True si les deux variables sont le même objet (x is y) +- _is not_ : Renvoie True si les deux variables ne sont pas le même objet (x is not y) +- _in_ : Renvoie True si la liste interrogée contient un certain élément (x in y) +- _not in_ : Renvoie True si la liste interrogée ne contient pas un certain élément (x not in y) + +```py +print('1 is 1', 1 is 1) # True - car les valeurs de données sont identiques +print('1 is not 2', 1 is not 2) # True - car 1 n'est pas 2 +print('A in Asabeneh', 'A' in 'Asabeneh') # True - A trouvé dans la chaîne +print('B in Asabeneh', 'B' in 'Asabeneh') # False - il n'y a pas de B majuscule +print('coding' in 'coding for all') # True - car coding for all contient le mot coding +print('a in an:', 'a' in 'an') # True +print('4 is 2 ** 2:', 4 is 2 ** 2) # True +``` + +### Opérateurs logiques + +Contrairement à d'autres langages de programmation, Python utilise les mots-clés _and_, _or_ et _not_ pour les opérateurs logiques. Les opérateurs logiques sont utilisés pour combiner des instructions conditionnelles : + +![Opérateurs logiques](../images/logical_operators.png) + +```py +print(3 > 2 and 4 > 3) # True - car les deux instructions sont vraies +print(3 > 2 and 4 < 3) # False - car la deuxième instruction est fausse +print(3 < 2 and 4 < 3) # False - car les deux instructions sont fausses +print('True and True: ', True and True) +print(3 > 2 or 4 > 3) # True - car les deux instructions sont vraies +print(3 > 2 or 4 < 3) # True - car l'une des instructions est vraie +print(3 < 2 or 4 < 3) # False - car les deux instructions sont fausses +print('True or False:', True or False) +print(not 3 > 2) # False - car 3 > 2 est vrai, donc not True donne False +print(not True) # False - Négation, l'opérateur not transforme true en false +print(not False) # True +print(not not True) # True +print(not not False) # False +``` + +🌕 Vous avez une énergie débordante. Vous venez de terminer le défi du Jour 3 et vous êtes trois pas de plus sur la voie de la grandeur. Faites maintenant quelques exercices pour votre cerveau et vos muscles. + +## 💻 Exercices - Jour 3 + +1. Déclarez votre âge comme une variable de type entier. +2. Déclarez votre taille comme une variable de type flottant. +3. Déclarez une variable qui stocke un nombre complexe. +4. Écrivez un script qui demande à l'utilisateur d'entrer la base et la hauteur d'un triangle et calcule l'aire de ce triangle (aire = 0,5 x b x h). + +```py + Entrez la base : 20 + Entrez la hauteur : 10 + L'aire du triangle est 100 +``` + +5. Écrivez un script qui demande à l'utilisateur d'entrer le côté a, le côté b et le côté c d'un triangle. Calculez le périmètre du triangle (périmètre = a + b + c). + +```py +Entrez le côté a : 5 +Entrez le côté b : 4 +Entrez le côté c : 3 +Le périmètre du triangle est 12 +``` + +6. Obtenez la longueur et la largeur d'un rectangle à l'aide de la fonction input. Calculez son aire (aire = longueur x largeur) et son périmètre (périmètre = 2 x (longueur + largeur)). +7. Obtenez le rayon d'un cercle à l'aide de la fonction input. Calculez l'aire (aire = pi x r x r) et la circonférence (c = 2 x pi x r) où pi = 3,14. +8. Calculez la pente, l'ordonnée à l'origine et l'abscisse à l'origine de y = 2x - 2. +9. La pente est (m = y2-y1/x2-x1). Trouvez la pente et la [distance euclidienne](https://en.wikipedia.org/wiki/Euclidean_distance#:~:text=In%20mathematics%2C%20the%20Euclidean%20distance,being%20called%20the%20Pythagorean%20distance.) entre le point (2, 2) et le point (6, 10). +10. Comparez les pentes des tâches 8 et 9. +11. Calculez la valeur de y (y = x^2 + 6x + 9). Essayez différentes valeurs de x et déterminez à quelle valeur de x, y est égal à 0. +12. Trouvez la longueur de 'python' et 'dragon' et faites une déclaration de comparaison fausse. +13. Utilisez l'opérateur _and_ pour vérifier si 'on' se trouve à la fois dans 'python' et 'dragon'. +14. _I hope this course is not full of jargon_. Utilisez l'opérateur _in_ pour vérifier si _jargon_ est dans la phrase. +15. Il n'y a pas de 'on' dans dragon et python. +16. Trouvez la longueur du texte _python_ et convertissez la valeur en flottant, puis convertissez-la en chaîne de caractères. +17. Les nombres pairs sont divisibles par 2 et le reste est zéro. Comment vérifier si un nombre est pair ou non en Python ? +18. Vérifiez si la division entière de 7 par 3 est égale à la valeur convertie en entier de 2,7. +19. Vérifiez si le type de '10' est égal au type de 10. +20. Vérifiez si int('9.8') est égal à 10. +21. Écrivez un script qui demande à l'utilisateur d'entrer le nombre d'heures et le taux horaire. Calculez le salaire de la personne. + +```py +Entrez les heures : 40 +Entrez le taux horaire : 28 +Votre salaire hebdomadaire est 1120 +``` + +22. Écrivez un script qui demande à l'utilisateur d'entrer le nombre d'années vécues. Calculez le nombre de secondes qu'une personne peut vivre. Supposons qu'une personne peut vivre cent ans. + +```py +Entrez le nombre d'années que vous avez vécues : 100 +Vous avez vécu 3153600000 secondes. +``` + +23. Écrivez un script Python qui affiche le tableau suivant : + +```py +1 1 1 1 1 +2 1 2 4 8 +3 1 3 9 27 +4 1 4 16 64 +5 1 5 25 125 +``` + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 2](./02_variables_builtin_functions_fr.md) | [Jour 4 >>](./04_strings_fr.md) diff --git a/French/04_strings_fr.md b/French/04_strings_fr.md new file mode 100644 index 000000000..e2db19c22 --- /dev/null +++ b/French/04_strings_fr.md @@ -0,0 +1,603 @@ +
+

30 Jours de Python : Jour 4 - Chaînes de caractères

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + + +
+ +[<< Jour 3](./03_operators_fr.md) | [Jour 5 >>](./05_lists_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 4](#-jour-4) + - [Chaînes de caractères](#chaînes-de-caractères) + - [Créer une chaîne](#créer-une-chaîne) + - [Concaténation de chaînes](#concaténation-de-chaînes) + - [Séquences d'échappement](#séquences-déchappement) + - [Formatage de chaînes](#formatage-de-chaînes) + - [Formatage à l'ancienne (opérateur %)](#formatage-à-lancienne-opérateur-) + - [Formatage moderne (str.format)](#formatage-moderne-strformat) + - [Interpolation / f-Strings (Python 3.6+)](#interpolation--f-strings-python-36) + - [Les chaînes Python comme séquences de caractères](#les-chaînes-python-comme-séquences-de-caractères) + - [Dépaquetage de caractères](#dépaquetage-de-caractères) + - [Accéder aux caractères par indice](#accéder-aux-caractères-par-indice) + - [Découpage (slicing) des chaînes](#découpage-slicing-des-chaînes) + - [Inverser une chaîne](#inverser-une-chaîne) + - [Sauter des caractères lors du découpage](#sauter-des-caractères-lors-du-découpage) + - [Méthodes de chaînes](#méthodes-de-chaînes) + - [💻 Exercices - Jour 4](#-exercices---jour-4) + +# 📘 Jour 4 + +## Chaînes de caractères + +Le texte est un type de données de type chaîne (string). Toute donnée écrite sous forme de texte est une chaîne. Les données entourées de guillemets simples, doubles ou triples sont des chaînes. Il existe différentes méthodes et fonctions intégrées pour manipuler les chaînes. Pour connaître la longueur d'une chaîne, on utilise la méthode `len()`. + +### Créer une chaîne + +```py +letter = 'P' # Une chaîne peut être un seul caractère ou un texte +print(letter) # P +print(len(letter)) # 1 +greeting = 'Hello, World!' # Une chaîne peut être créée avec des guillemets simples ou doubles +print(greeting) # Hello, World! +print(len(greeting)) # 13 +sentence = "I hope you are enjoying 30 days of Python Challenge" +print(sentence) +``` + +Une chaîne multiligne se crée avec trois guillemets simples (''') ou trois guillemets doubles ("""). Voir l'exemple ci-dessous. + +```py +multiline_string = '''I am a teacher and enjoy teaching. +I didn't find anything as rewarding as empowering people. +That is why I created 30 days of python.''' +print(multiline_string) + +# Autre façon de faire la même chose +multiline_string = """I am a teacher and enjoy teaching. +I didn't find anything as rewarding as empowering people. +That is why I created 30 days of python.""" +print(multiline_string) +``` + +### Concaténation de chaînes + +On peut connecter des chaînes entre elles. Fusionner ou connecter des chaînes s'appelle la concaténation. Voir l'exemple ci-dessous : + +```py +first_name = 'Asabeneh' +last_name = 'Yetayeh' +space = ' ' +full_name = first_name + space + last_name +print(full_name) # Asabeneh Yetayeh +# Vérification de la longueur d'une chaîne avec len() +print(len(first_name)) # 8 +print(len(last_name)) # 7 +print(len(first_name) > len(last_name)) # True +print(len(full_name)) # 16 +``` + +### Séquences d'échappement + +En Python et dans d'autres langages, `\` suivi d'un caractère forme une séquence d'échappement. Voici les caractères d'échappement les plus courants : + +- \n : nouvelle ligne +- \t : tabulation (8 espaces) +- \\\\ : antislash +- \\' : guillemet simple (') +- \\" : guillemet double (") + +Voyons maintenant leur utilisation avec des exemples. + +```py +print('J\'espère que tout le monde apprécie le Python Challenge.\nEt vous ?') # saut de ligne +print('Jours\tSujets\tExercices') # tabulation ou 4 espaces +print('Jour 1\t5\t5') +print('Jour 2\t6\t20') +print('Jour 3\t5\t23') +print('Jour 4\t1\t35') +print('Ceci est un symbole antislash (\\)') # Pour écrire un antislash +print('Dans tous les langages de programmation, on commence par \"Hello, World!\"') # guillemet double dans une chaîne simple + +# affichage +J'espère que tout le monde apprécie le Python Challenge. +Et vous ? +Days Topics Exercises +Day 1 5 5 +Day 2 6 20 +Day 3 5 23 +Day 4 1 35 +This is a backslash symbol (\) +In every programming language it starts with "Hello, World!" +``` + +### Formatage de chaînes + +#### Formatage à l'ancienne (opérateur %) + +Il existe plusieurs façons de formater les chaînes en Python. Nous allons en voir quelques-unes. +L'opérateur `%` permet de formater un ensemble de variables regroupées dans un tuple, associé à une chaîne de format contenant du texte normal et des « spécificateurs d'argument » comme `%s`, `%d`, `%f`, `%.nombre de chiffresf`. + +- %s : Chaîne (ou tout objet ayant une représentation textuelle) +- %d : Entiers +- %f : Nombres flottants +- "%.nombre de chiffresf" : Flottants avec une précision fixe + +```py +# Chaînes uniquement +first_name = 'Asabeneh' +last_name = 'Yetayeh' +language = 'Python' +formated_string = 'I am %s %s. I teach %s' %(first_name, last_name, language) +print(formated_string) + +# Chaînes et nombres +radius = 10 +pi = 3.14 +area = pi * radius ** 2 +formated_string = 'The area of circle with a radius %d is %.2f.' %(radius, area) # 2 chiffres après la virgule + +python_libraries = ['Django', 'Flask', 'NumPy', 'Matplotlib','Pandas'] +formated_string = 'The following are python libraries:%s' % (python_libraries) +print(formated_string) # "The following are python libraries:['Django', 'Flask', 'NumPy', 'Matplotlib','Pandas']" +``` + +#### Formatage moderne (str.format) + +Ce format a été introduit dans Python 3. + +```py + +first_name = 'Asabeneh' +last_name = 'Yetayeh' +language = 'Python' +formated_string = 'Je suis {} {}. J\'enseigne {}'.format(first_name, last_name, language) +print(formated_string) +a = 4 +b = 3 + +print('{} + {} = {}'.format(a, b, a + b)) +print('{} - {} = {}'.format(a, b, a - b)) +print('{} * {} = {}'.format(a, b, a * b)) +print('{} / {} = {:.2f}'.format(a, b, a / b)) # limite à deux décimales +print('{} % {} = {}'.format(a, b, a % b)) +print('{} // {} = {}'.format(a, b, a // b)) +print('{} ** {} = {}'.format(a, b, a ** b)) + +# affichage +4 + 3 = 7 +4 - 3 = 1 +4 * 3 = 12 +4 / 3 = 1.33 +4 % 3 = 1 +4 // 3 = 1 +4 ** 3 = 64 + +# Chaînes et nombres +radius = 10 +pi = 3.14 +area = pi * radius ** 2 +formated_string = 'L\'aire d\'un cercle de rayon {} est {:.2f}.'.format(radius, area) # 2 décimales +print(formated_string) + +``` + +#### Interpolation / f-Strings (Python 3.6+) + +Un autre formatage moderne est l'interpolation de chaînes, les f-strings. Les chaînes commencent par `f` et on peut y injecter les données directement aux positions correspondantes. + +```py +a = 4 +b = 3 +print(f'{a} + {b} = {a +b}') +print(f'{a} - {b} = {a - b}') +print(f'{a} * {b} = {a * b}') +print(f'{a} / {b} = {a / b:.2f}') +print(f'{a} % {b} = {a % b}') +print(f'{a} // {b} = {a // b}') +print(f'{a} ** {b} = {a ** b}') +``` + +### Les chaînes Python comme séquences de caractères + +Les chaînes Python sont des séquences de caractères et partagent leurs méthodes d'accès de base avec les autres séquences ordonnées de Python — listes et tuples. La façon la plus simple d'extraire des caractères individuels d'une chaîne (et des éléments d'une séquence) est de les dépaqueter (unpack) dans des variables correspondantes. + +#### Dépaquetage de caractères + +``` +language = 'Python' +a,b,c,d,e,f = language # dépaquetage des caractères dans des variables +print(a) # P +print(b) # y +print(c) # t +print(d) # h +print(e) # o +print(f) # n +``` + +#### Accéder aux caractères par indice + +En programmation, le comptage commence à zéro. Par conséquent, la première lettre d'une chaîne est à l'indice zéro et la dernière lettre est à l'indice (longueur de la chaîne moins un). + +![Indice d'une chaîne](../images/string_index.png) + +```py +language = 'Python' +first_letter = language[0] +print(first_letter) # P +second_letter = language[1] +print(second_letter) # y +last_index = len(language) - 1 +last_letter = language[last_index] +print(last_letter) # n +``` + +Si l'on veut commencer par la droite, on peut utiliser des indices négatifs. -1 est le dernier indice. + +```py +language = 'Python' +last_letter = language[-1] +print(last_letter) # n +second_last = language[-2] +print(second_last) # o +``` + +#### Découpage (slicing) des chaînes + +En Python, on peut découper les chaînes en sous-chaînes. + +```py +language = 'Python' +first_three = language[0:3] # commence à l'indice 0 et va jusqu'à 3 (non inclus) +print(first_three) #Pyt +last_three = language[3:6] +print(last_three) # hon +# Autre façon +last_three = language[-3:] +print(last_three) # hon +last_three = language[3:] +print(last_three) # hon +``` + +#### Inverser une chaîne + +On peut facilement inverser une chaîne en Python. + +```py +greeting = 'Hello, World!' +print(greeting[::-1]) # !dlroW ,olleH +``` + +#### Sauter des caractères lors du découpage + +Il est possible de sauter des caractères lors du découpage en passant un argument de pas à la méthode de slice. + +```py +language = 'Python' +pto = language[0:6:2] # +print(pto) # Pto +``` + +### Méthodes de chaînes + +Il existe de nombreuses méthodes de chaînes qui permettent de les formater. En voici quelques-unes : + +- capitalize() : Convertit le premier caractère de la chaîne en majuscule. + +```py +challenge = 'thirty days of python' +print(challenge.capitalize()) # 'Thirty days of python' +``` + +- count() : Renvoie le nombre d'occurrences d'une sous-chaîne, count(sous-chaîne, début=.., fin=..). Le début est l'indice de départ et la fin l'indice d'arrêt. + +```py +challenge = 'thirty days of python' +print(challenge.count('y')) # 3 +print(challenge.count('y', 7, 14)) # 1, +print(challenge.count('th')) # 2` +``` + +- endswith() : Vérifie si une chaîne se termine par une fin spécifiée. + +```py +challenge = 'thirty days of python' +print(challenge.endswith('on')) # True +print(challenge.endswith('tion')) # False +``` + +- expandtabs() : Remplace les tabulations par des espaces, taille par défaut 8. Accepte un argument de taille. + +```py +challenge = 'thirty\tdays\tof\tpython' +print(challenge.expandtabs()) # 'thirty days of python' +print(challenge.expandtabs(10)) # 'thirty days of python' +``` + +- find() : Renvoie l'indice de la première occurrence d'une sous-chaîne, ou -1 si introuvable. + +```py +challenge = 'thirty days of python' +print(challenge.find('y')) # 5 +print(challenge.find('th')) # 0 +``` + +- rfind() : Renvoie l'indice de la dernière occurrence d'une sous-chaîne, ou -1 si introuvable. + +```py +challenge = 'thirty days of python' +print(challenge.rfind('y')) # 16 +print(challenge.rfind('th')) # 17 +``` + +- format() : Formate une chaîne pour un affichage plus lisible. + Plus d'informations sur le formatage des chaînes sur ce [lien](https://www.programiz.com/python-programming/methods/string/format) + +```py +first_name = 'Asabeneh' +last_name = 'Yetayeh' +age = 250 +job = 'teacher' +country = 'Finland' +sentence = 'Je suis {} {}. Je suis {}. J\'ai {} ans. J\'habite à {}.'.format(first_name, last_name, job, age, country) +print(sentence) # Je suis Asabeneh Yetayeh. J'ai 250 ans. Je suis enseignant. J'habite en Finlande. + +radius = 10 +pi = 3.14 +area = pi * radius ** 2 +result = 'L\'aire d\'un cercle de rayon {} est {}'.format(str(radius), str(area)) +print(result) # L'aire d'un cercle de rayon 10 est 314 +``` + +- index() : Renvoie le plus petit indice d'une sous-chaîne ; des arguments supplémentaires indiquent les indices de début et de fin (par défaut 0 et longueur - 1). Lève une ValueError si la sous-chaîne n'est pas trouvée. + +```py +challenge = 'thirty days of python' +sub_string = 'da' +print(challenge.index(sub_string)) # 7 +print(challenge.index(sub_string, 9)) # error +``` + +- rindex() : Renvoie le plus grand indice d'une sous-chaîne ; des arguments supplémentaires indiquent les indices de début et de fin. + +```py +challenge = 'thirty days of python' +sub_string = 'da' +print(challenge.rindex(sub_string)) # 7 +print(challenge.rindex(sub_string, 9)) # error +print(challenge.rindex('on', 8)) # 19 +``` + +- isalnum() : Vérifie si la chaîne est alphanumérique. + +```py +challenge = 'ThirtyDaysPython' +print(challenge.isalnum()) # True + +challenge = '30DaysPython' +print(challenge.isalnum()) # True + +challenge = 'thirty days of python' +print(challenge.isalnum()) # False, l'espace n'est pas un caractère alphanumérique + +challenge = 'thirty days of python 2019' +print(challenge.isalnum()) # False +``` + +- isalpha() : Vérifie si tous les caractères sont alphabétiques (a-z et A-Z). + +```py +challenge = 'thirty days of python' +print(challenge.isalpha()) # False, l'espace est exclu +challenge = 'ThirtyDaysPython' +print(challenge.isalpha()) # True +num = '123' +print(num.isalpha()) # False +``` + +- isdecimal() : Vérifie si tous les caractères sont décimaux (0-9). + +```py +challenge = 'thirty days of python' +print(challenge.isdecimal()) # False +challenge = '123' +print(challenge.isdecimal()) # True +challenge = '\u00B2' +print(challenge.isdigit()) # True +challenge = '12 3' +print(challenge.isdecimal()) # False, espace non autorisé +``` + +- isdigit() : Vérifie si tous les caractères sont des chiffres (0-9 et certains caractères unicode numériques). + +```py +challenge = 'Thirty' +print(challenge.isdigit()) # False +challenge = '30' +print(challenge.isdigit()) # True +challenge = '\u00B2' +print(challenge.isdigit()) # True +``` + +- isnumeric() : Vérifie si tous les caractères sont des nombres ou liés à des nombres (comme isdigit(), mais accepte plus de symboles, comme ½). + +```py +num = '10' +print(num.isnumeric()) # True +num = '\u00BD' # ½ +print(num.isnumeric()) # True +num = '10.5' +print(num.isnumeric()) # False +``` + +- isidentifier() : Vérifie si la chaîne est un identifiant valide (nom de variable valide). + +```py +challenge = '30DaysOfPython' +print(challenge.isidentifier()) # False, car commence par un chiffre +challenge = 'thirty_days_of_python' +print(challenge.isidentifier()) # True +``` + +- islower() : Vérifie si tous les caractères alphabétiques sont en minuscules. + +```py +challenge = 'thirty days of python' +print(challenge.islower()) # True +challenge = 'Thirty days of python' +print(challenge.islower()) # False +``` + +- isupper() : Vérifie si tous les caractères alphabétiques sont en majuscules. + +```py +challenge = 'thirty days of python' +print(challenge.isupper()) # False +challenge = 'THIRTY DAYS OF PYTHON' +print(challenge.isupper()) # True +``` + +- join() : Renvoie une chaîne concaténée. + +```py +web_tech = ['HTML', 'CSS', 'JavaScript', 'React'] +result = ' '.join(web_tech) +print(result) # 'HTML CSS JavaScript React' +``` + +```py +web_tech = ['HTML', 'CSS', 'JavaScript', 'React'] +result = '# '.join(web_tech) +print(result) # 'HTML# CSS# JavaScript# React' +``` + +- strip() : Supprime tous les caractères donnés depuis le début et la fin de la chaîne. + +```py +challenge = 'thirty days of pythoonnn' +print(challenge.strip('noth')) # 'irty days of py' +``` + +- replace() : Remplace une sous-chaîne par une autre. + +```py +challenge = 'thirty days of python' +print(challenge.replace('python', 'coding')) # 'thirty days of coding' +``` + +- split() : Découpe la chaîne en utilisant la chaîne donnée ou l'espace comme séparateur. + +```py +challenge = 'thirty days of python' +print(challenge.split()) # ['thirty', 'days', 'of', 'python'] +challenge = 'thirty, days, of, python' +print(challenge.split(', ')) # ['thirty', 'days', 'of', 'python'] +``` + +- title() : Renvoie une chaîne en format titre (première lettre de chaque mot en majuscule). + +```py +challenge = 'thirty days of python' +print(challenge.title()) # Thirty Days Of Python +``` + +- swapcase() : Convertit les majuscules en minuscules et vice-versa. + +```py +challenge = 'thirty days of python' +print(challenge.swapcase()) # THIRTY DAYS OF PYTHON +challenge = 'Thirty Days Of Python' +print(challenge.swapcase()) # tHIRTY dAYS oF pYTHON +``` + +- startswith() : Vérifie si la chaîne commence par une chaîne spécifiée. + +```py +challenge = 'thirty days of python' +print(challenge.startswith('thirty')) # True + +challenge = '30 days of python' +print(challenge.startswith('thirty')) # False +``` + +🌕 Vous êtes une personne extraordinaire avec un potentiel remarquable. Vous venez de terminer le défi du Jour 4 et vous êtes quatre pas de plus sur la voie de la grandeur. Faites maintenant quelques exercices pour votre cerveau et vos muscles. + +## 💻 Exercices - Jour 4 + +1. Concaténez les chaînes 'Thirty', 'Days', 'Of', 'Python' en une seule chaîne, 'Thirty Days Of Python'. +2. Concaténez les chaînes 'Coding', 'For', 'All' en une seule chaîne, 'Coding For All'. +3. Déclarez une variable nommée `company` et assignez-lui la valeur initiale `"Coding For All"`. +4. Affichez la variable `company` en utilisant `print()`. +5. Affichez la longueur de la chaîne `company` avec `len()` et `print()`. +6. Convertissez tous les caractères en majuscules avec `upper()`. +7. Convertissez tous les caractères en minuscules avec `lower()`. +8. Utilisez les méthodes `capitalize()`, `title()`, `swapcase()` pour formater la valeur de la chaîne `Coding For All`. +9. Découpez (slicez) le premier mot de la chaîne `Coding For All`. +10. Vérifiez si la chaîne `Coding For All` contient le mot `Coding` en utilisant `index()`, `find()` ou d'autres méthodes. +11. Remplacez le mot `coding` dans la chaîne `'Coding For All'` par `Python`. +12. Changez `"Python for Everyone"` en `"Python for All"` avec la méthode `replace()` ou une autre méthode. +13. Découpez la chaîne `'Coding For All'` en utilisant l'espace comme séparateur (`split()`). +14. Découpez la chaîne `"Facebook, Google, Microsoft, Apple, IBM, Oracle, Amazon"` au niveau de la virgule. +15. Quel est le caractère à l'indice 0 dans la chaîne `Coding For All` ? +16. Quel est le dernier indice de la chaîne `Coding For All` ? +17. Quel caractère se trouve à l'indice 10 dans la chaîne `"Coding For All"` ? +18. Créez un acronyme ou une abréviation pour le nom `'Python For Everyone'`. +19. Créez un acronyme ou une abréviation pour le nom `'Coding For All'`. +20. Utilisez `index()` pour déterminer la position de la première occurrence de `C` dans `Coding For All`. +21. Utilisez `index()` pour déterminer la position de la première occurrence de `F` dans `Coding For All`. +22. Utilisez `rfind()` pour déterminer la position de la dernière occurrence de `l` dans `Coding For All People`. +23. Utilisez `index()` ou `find()` pour trouver la position de la première occurrence du mot `'because'` dans la phrase : `'You cannot end a sentence with because because because is a conjunction'`. +24. Utilisez `rindex()` pour trouver la position de la dernière occurrence du mot `because` dans la phrase : `'You cannot end a sentence with because because because is a conjunction'`. +25. Extrayez (slicez) l'expression `'because because because'` de la phrase : `'You cannot end a sentence with because because because is a conjunction'`. +26. Trouvez la position de la première occurrence du mot `'because'` dans la phrase : `'You cannot end a sentence with because because because is a conjunction'`. +27. Extrayez (slicez) l'expression `'because because because'` de la phrase : `'You cannot end a sentence with because because because is a conjunction'`. +28. Est-ce que `'Coding For All'` commence par la sous-chaîne `Coding` ? +29. Est-ce que `'Coding For All'` se termine par la sous-chaîne `coding` ? +30. `'   Coding For All      '`, supprimez les espaces de début et de fin dans la chaîne donnée. +31. Parmi les variables suivantes, lesquelles renvoient `True` avec la méthode `isidentifier()` ? + - 30DaysOfPython + - thirty_days_of_python +32. La liste suivante contient les noms de certaines bibliothèques Python : `['Django', 'Flask', 'Bottle', 'Pyramid', 'Falcon']`. Joignez la liste avec un dièse suivi d'un espace. +33. Utilisez la séquence d'échappement de nouvelle ligne pour séparer les phrases suivantes : + ```py + I am enjoying this challenge. + I just wonder what is next. + ``` +34. Utilisez la séquence d'échappement de tabulation pour écrire les lignes suivantes : + ```py + Name Age Country City + Asabeneh 250 Finland Helsinki + ``` +35. Utilisez la méthode de formatage de chaînes pour afficher ce qui suit : + +```sh +radius = 10 +area = 3.14 * radius ** 2 +The area of a circle with radius 10 is 314 meters square. +``` + +36. Réalisez ce qui suit en utilisant les méthodes de formatage de chaînes : + +```sh +8 + 6 = 14 +8 - 6 = 2 +8 * 6 = 48 +8 / 6 = 1.33 +8 % 6 = 2 +8 // 6 = 1 +8 ** 6 = 262144 +``` + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 3](./03_operators_fr.md) | [Jour 5 >>](./05_lists_fr.md) diff --git a/French/05_lists_fr.md b/French/05_lists_fr.md new file mode 100644 index 000000000..1e7eabdcc --- /dev/null +++ b/French/05_lists_fr.md @@ -0,0 +1,589 @@ +
+

30 Jours de Python : Jour 5 - Listes

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + + +
+ +[<< Jour 4](./04_strings_fr.md) | [Jour 6 >>](./06_tuples_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 5](#-jour-5) + - [Listes](#listes) + - [Comment créer une liste](#comment-créer-une-liste) + - [Accéder aux éléments d'une liste par indice positif](#accéder-aux-éléments-dune-liste-par-indice-positif) + - [Accéder aux éléments d'une liste par indice négatif](#accéder-aux-éléments-dune-liste-par-indice-négatif) + - [Dépaquetage d'éléments d'une liste](#dépaquetage-déléments-dune-liste) + - [Découper des éléments d'une liste](#découper-des-éléments-dune-liste) + - [Modifier une liste](#modifier-une-liste) + - [Vérifier la présence d'un élément](#vérifier-la-présence-dun-élément) + - [Ajouter des éléments à une liste](#ajouter-des-éléments-à-une-liste) + - [Insérer des éléments dans une liste](#insérer-des-éléments-dans-une-liste) + - [Supprimer des éléments d'une liste](#supprimer-des-éléments-dune-liste) + - [Supprimer avec Pop](#supprimer-avec-pop) + - [Supprimer avec Del](#supprimer-avec-del) + - [Vider une liste](#vider-une-liste) + - [Copier une liste](#copier-une-liste) + - [Concaténer des listes](#concaténer-des-listes) + - [Compter les occurrences](#compter-les-occurrences) + - [Trouver l'indice d'un élément](#trouver-lindice-dun-élément) + - [Inverser une liste](#inverser-une-liste) + - [Trier une liste](#trier-une-liste) + - [💻 Exercices : Jour 5](#-exercices--jour-5) + - [Exercices : Niveau 1](#exercices--niveau-1) + - [Exercices : Niveau 2](#exercices--niveau-2) + +# 📘 Jour 5 + +## Listes + +Il existe quatre types de données de collection en Python : + +- **Liste** : une collection ordonnée et modifiable. Accepte les doublons. +- **Tuple** : une collection ordonnée et non modifiable (immuable). Accepte les doublons. +- **Ensemble (Set)** : une collection non ordonnée, non indexée et non modifiable, mais on peut y ajouter de nouveaux éléments. Les doublons ne sont pas autorisés. +- **Dictionnaire (Dictionary)** : une collection non ordonnée, modifiable et indexée. Pas de doublons. + +Une liste est une collection de différents types de données, ordonnée et modifiable (mutable). Une liste peut être vide ou contenir des éléments de différents types. + +### Comment créer une liste + +En Python, on peut créer une liste de deux façons : + +- En utilisant la fonction intégrée `list()` + +```py +# syntaxe +lst = list() +``` + +```py +empty_list = list() # une liste vide, sans élément +print(len(empty_list)) # 0 +``` + +- En utilisant les crochets, [] + +```py +# syntaxe +lst = [] +``` + +```py +empty_list = [] # une liste vide, sans élément +print(len(empty_list)) # 0 +``` + +Listes avec valeurs initiales. On utilise _len()_ pour connaître la longueur d'une liste. + +```py +fruits = ['banana', 'orange', 'mango', 'lemon'] # liste de fruits +vegetables = ['Tomato', 'Potato', 'Cabbage','Onion', 'Carrot'] # liste de légumes +animal_products = ['milk', 'meat', 'butter', 'yoghurt'] # liste de produits animaux +web_techs = ['HTML', 'CSS', 'JS', 'React','Redux', 'Node', 'MongDB'] # liste de technologies web +countries = ['Finland', 'Estonia', 'Denmark', 'Sweden', 'Norway'] + +# Affichage des listes et de leur longueur +print('Fruits:', fruits) +print('Nombre de fruits:', len(fruits)) +print('Légumes:', vegetables) +print('Nombre de légumes:', len(vegetables)) +print('Produits animaux:',animal_products) +print('Nombre de produits animaux:', len(animal_products)) +print('Technologies web:', web_techs) +print('Nombre de technologies web:', len(web_techs)) +print('Pays:', countries) +print('Nombre de pays:', len(countries)) +``` + +```sh +sortie +Fruits: ['banana', 'orange', 'mango', 'lemon'] +Nombre de fruits: 4 +Légumes: ['Tomato', 'Potato', 'Cabbage', 'Onion', 'Carrot'] +Nombre de légumes: 5 +Produits animaux: ['milk', 'meat', 'butter', 'yoghurt'] +Nombre de produits animaux: 4 +Technologies web: ['HTML', 'CSS', 'JS', 'React', 'Redux', 'Node', 'MongDB'] +Nombre de technologies web: 7 +Pays: ['Finland', 'Estonia', 'Denmark', 'Sweden', 'Norway'] +Nombre de pays: 5 +``` + +- Les listes peuvent contenir des éléments de différents types + +```py + lst = ['Asabeneh', 250, True, {'country':'Finland', 'city':'Helsinki'}] # liste contenant différents types de données +``` + +### Accéder aux éléments d'une liste par indice positif + +On accède à chaque élément d'une liste par son indice. L'indice d'une liste commence à 0. L'image ci-dessous montre clairement où l'indice commence. + +![Indice de liste](../images/list_index.png) + +```py +fruits = ['banana', 'orange', 'mango', 'lemon'] +first_fruit = fruits[0] # on accède au premier élément via son indice +print(first_fruit) # banana +second_fruit = fruits[1] +print(second_fruit) # orange +last_fruit = fruits[3] +print(last_fruit) # lemon +# Dernier indice +last_index = len(fruits) - 1 +last_fruit = fruits[last_index] +``` + +### Accéder aux éléments d'une liste par indice négatif + +L'indice négatif signifie que l'on commence par la fin : -1 correspond au dernier élément, -2 à l'avant-dernier, etc. + +![Indice négatif de liste](../images/list_negative_indexing.png) + +```py +fruits = ['banana', 'orange', 'mango', 'lemon'] +first_fruit = fruits[-4] +last_fruit = fruits[-1] +second_last = fruits[-2] +print(first_fruit) # banana +print(last_fruit) # lemon +print(second_last) # mango +``` + +### Dépaquetage d'éléments d'une liste + +```py +lst = ['item1','item2','item3', 'item4', 'item5'] +first_item, second_item, third_item, *rest = lst +print(first_item) # item1 +print(second_item) # item2 +print(third_item) # item3 +print(rest) # ['item4', 'item5'] + +``` + +```py +# Premier exemple +fruits = ['banana', 'orange', 'mango', 'lemon','lime','apple'] +first_fruit, second_fruit, third_fruit, *rest = fruits +print(first_fruit) # banana +print(second_fruit) # orange +print(third_fruit) # mango +print(rest) # ['lemon','lime','apple'] +# Deuxième exemple de dépaquetage +first, second, third,*rest, tenth = [1,2,3,4,5,6,7,8,9,10] +print(first) # 1 +print(second) # 2 +print(third) # 3 +print(rest) # [4,5,6,7,8,9] +print(tenth) # 10 +# Troisième exemple de dépaquetage +countries = ['Germany', 'France','Belgium','Sweden','Denmark','Finland','Norway','Iceland','Estonia'] +gr, fr, bg, sw, *scandic, es = countries +print(gr) +print(fr) +print(bg) +print(sw) +print(scandic) +print(es) +``` + +### Découper des éléments d'une liste + +- **Indice positif** : on peut spécifier une plage d'indices positifs en indiquant le début, la fin et le pas. La valeur renvoyée est une nouvelle liste (valeurs par défaut : début = 0, fin = len(lst) - 1, pas = 1). + +```py +fruits = ['banana', 'orange', 'mango', 'lemon'] +all_fruits = fruits[0:4] # renvoie tous les fruits +# donne aussi le même résultat +all_fruits = fruits[0:] # si on ne fixe pas de fin, on prend tout le reste +orange_and_mango = fruits[1:3] # n'inclut pas le premier indice +orange_mango_lemon = fruits[1:] +orange_and_lemon = fruits[::2] # on utilise un 3e argument, le pas. Prend un élément sur deux - ['banana', 'mango'] +``` + +- **Indice négatif** : on peut spécifier une plage d'indices négatifs. + +```py +fruits = ['banana', 'orange', 'mango', 'lemon'] +all_fruits = fruits[-4:] # renvoie tous les fruits +orange_and_mango = fruits[-3:-1] # n'inclut pas le dernier indice, ['orange', 'mango'] +orange_mango_lemon = fruits[-3:] # de -3 jusqu'à la fin, ['orange', 'mango', 'lemon'] +reverse_fruits = fruits[::-1] # un pas négatif prend la liste en ordre inverse, ['lemon', 'mango', 'orange', 'banana'] +``` + +### Modifier une liste + +Une liste est une collection ordonnée d'éléments modifiable (mutable). Modifions la liste de fruits. + +```py +fruits = ['banana', 'orange', 'mango', 'lemon'] +fruits[0] = 'avocado' +print(fruits) # ['avocado', 'orange', 'mango', 'lemon'] +fruits[1] = 'apple' +print(fruits) # ['avocado', 'apple', 'mango', 'lemon'] +last_index = len(fruits) - 1 +fruits[last_index] = 'lime' +print(fruits) # ['avocado', 'apple', 'mango', 'lime'] +``` + +### Vérifier la présence d'un élément + +On vérifie si un élément est membre d'une liste avec l'opérateur *in*. + +```py +fruits = ['banana', 'orange', 'mango', 'lemon'] +does_exist = 'banana' in fruits +print(does_exist) # True +does_exist = 'lime' in fruits +print(does_exist) # False +``` + +### Ajouter des éléments à une liste + +Pour ajouter un élément à la fin d'une liste existante, on utilise la méthode *append()*. + +```py +# syntaxe +lst = list() +lst.append(item) +``` + +```py +fruits = ['banana', 'orange', 'mango', 'lemon'] +fruits.append('apple') +print(fruits) # ['banana', 'orange', 'mango', 'lemon', 'apple'] +fruits.append('lime') # ['banana', 'orange', 'mango', 'lemon', 'apple', 'lime'] +print(fruits) +``` + +### Insérer des éléments dans une liste + +On peut utiliser la méthode *insert()* pour insérer un élément à un indice précis dans une liste. Les autres éléments sont décalés vers la droite. La méthode *insert()* prend deux arguments : l'indice et l'élément à insérer. + +```py +# syntaxe +lst = ['item1', 'item2'] +lst.insert(index, item) +``` + +```py +fruits = ['banana', 'orange', 'mango', 'lemon'] +fruits.insert(2, 'apple') # insère apple entre orange et mango +print(fruits) # ['banana', 'orange', 'apple', 'mango', 'lemon'] +fruits.insert(3, 'lime') # ['banana', 'orange', 'apple', 'lime', 'mango', 'lemon'] +print(fruits) +``` + +### Supprimer des éléments d'une liste + +La méthode `remove()` supprime un élément spécifié de la liste. + +```py +# syntaxe +lst = ['item1', 'item2'] +lst.remove(item) +``` + +```py +fruits = ['banana', 'orange', 'mango', 'lemon', 'banana'] +fruits.remove('banana') +print(fruits) # ['orange', 'mango', 'lemon', 'banana'] - supprime la première occurrence +fruits.remove('lemon') +print(fruits) # ['orange', 'mango', 'banana'] +``` + +### Supprimer avec Pop + +La méthode *pop()* supprime l'élément à l'indice spécifié (ou le dernier élément si aucun indice n'est donné). + +```py +# syntaxe +lst = ['item1', 'item2'] +lst.pop() # dernier élément +lst.pop(index) +``` + +```py +fruits = ['banana', 'orange', 'mango', 'lemon'] +fruits.pop() +print(fruits) # ['banana', 'orange', 'mango'] + +fruits.pop(0) +print(fruits) # ['orange', 'mango'] +``` + +### Supprimer avec Del + +Le mot-clé *del* supprime l'élément à l'indice spécifié et peut aussi supprimer une plage d'éléments. Il peut aussi supprimer complètement la liste. + +```py +# syntaxe +lst = ['item1', 'item2'] +del lst[index] # un seul élément +del lst # supprime complètement la liste +``` + +```py +fruits = ['banana', 'orange', 'mango', 'lemon', 'kiwi', 'lime'] +del fruits[0] +print(fruits) # ['orange', 'mango', 'lemon', 'kiwi', 'lime'] +del fruits[1] +print(fruits) # ['orange', 'lemon', 'kiwi', 'lime'] +del fruits[1:3] # supprime les éléments entre les indices donnés (sans inclure l'indice 3) +print(fruits) # ['orange', 'lime'] +del fruits +print(fruits) # NameError: name 'fruits' is not defined +``` + +### Vider une liste + +La méthode *clear()* vide la liste. + +```py +# syntaxe +lst = ['item1', 'item2'] +lst.clear() +``` + +```py +fruits = ['banana', 'orange', 'mango', 'lemon'] +fruits.clear() +print(fruits) # [] +``` + +### Copier une liste + +On peut copier une liste en la réaffectant à une nouvelle variable : `list2 = list1`. Mais `list2` est alors une référence de `list1` : toute modification dans `list2` modifie aussi `list1` d'origine. Pour éviter cela, on utilise _copy()_. + +```py +# syntaxe +lst = ['item1', 'item2'] +lst_copy = lst.copy() +``` + +```py +fruits = ['banana', 'orange', 'mango', 'lemon'] +fruits_copy = fruits.copy() +print(fruits_copy) # ['banana', 'orange', 'mango', 'lemon'] +``` + +### Concaténer des listes + +Il y a plusieurs façons de joindre (concaténer) deux listes ou plus en Python. + +- **Opérateur +** + +```py +# syntaxe +list3 = list1 + list2 +``` + +```py +positive_numbers = [1, 2, 3, 4, 5] +zero = [0] +negative_numbers = [-5,-4,-3,-2,-1] +integers = negative_numbers + zero + positive_numbers +print(integers) # [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5] +fruits = ['banana', 'orange', 'mango', 'lemon'] +vegetables = ['Tomato', 'Potato', 'Cabbage', 'Onion', 'Carrot'] +fruits_and_vegetables = fruits + vegetables +print(fruits_and_vegetables ) # ['banana', 'orange', 'mango', 'lemon', 'Tomato', 'Potato', 'Cabbage', 'Onion', 'Carrot'] +``` + +- **Concaténation avec `extend()`** + La méthode *extend()* permet d'ajouter une liste à une autre. + +```py +# syntaxe +list1 = ['item1', 'item2'] +list2 = ['item3', 'item4', 'item5'] +list1.extend(list2) # ['item1', 'item2', 'item3', 'item4', 'item5'] +``` + +```py +num1 = [0, 1, 2, 3] +num2= [4, 5, 6] +num1.extend(num2) +print('Nombres:', num1) # Nombres: [0, 1, 2, 3, 4, 5, 6] +negative_numbers = [-5,-4,-3,-2,-1] +positive_numbers = [1, 2, 3,4,5] +zero = [0] + +negative_numbers.extend(zero) +negative_numbers.extend(positive_numbers) +print('Entiers:', negative_numbers) # Entiers: [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5] +fruits = ['banana', 'orange', 'mango', 'lemon'] +vegetables = ['Tomato', 'Potato', 'Cabbage', 'Onion', 'Carrot'] +fruits.extend(vegetables) +print('Fruits et légumes:', fruits ) # Fruits et légumes: ['banana', 'orange', 'mango', 'lemon', 'Tomato', 'Potato', 'Cabbage', 'Onion', 'Carrot'] +``` + +### Compter les occurrences + +La méthode *count()* renvoie le nombre de fois qu'un élément apparaît dans une liste. + +```py +# syntaxe +lst = ['item1', 'item2'] +lst.count(item) +``` + +```py +fruits = ['banana', 'orange', 'mango', 'lemon'] +print(fruits.count('orange')) # 1 +ages = [22, 19, 24, 25, 26, 24, 25, 24] +print(ages.count(24)) # 3 +``` + +### Trouver l'indice d'un élément + +La méthode *index()* renvoie l'indice d'un élément dans la liste. + +```py +# syntaxe +lst = ['item1', 'item2'] +lst.index(item) +``` + +```py +fruits = ['banana', 'orange', 'mango', 'lemon'] +print(fruits.index('orange')) # 1 +ages = [22, 19, 24, 25, 26, 24, 25, 24] +print(ages.index(24)) # 2, la première occurrence +``` + +### Inverser une liste + +La méthode *reverse()* inverse l'ordre d'une liste. + +```py +# syntaxe +lst = ['item1', 'item2'] +lst.reverse() + +``` + +```py +fruits = ['banana', 'orange', 'mango', 'lemon'] +fruits.reverse() +print(fruits) # ['lemon', 'mango', 'orange', 'banana'] +ages = [22, 19, 24, 25, 26, 24, 25, 24] +ages.reverse() +print(ages) # [24, 25, 24, 26, 25, 24, 19, 22] +``` + +### Trier une liste + +Pour trier une liste, on peut utiliser la méthode _sort()_ ou la fonction intégrée _sorted()_. La méthode _sort()_ réordonne les éléments de la liste dans l'ordre croissant et modifie la liste d'origine. Si l'argument reverse de _sort()_ est true, la liste est triée dans l'ordre décroissant. + +- `sort()` : modifie la liste d'origine + + ```py + # syntaxe + lst = ['item1', 'item2'] + lst.sort() # croissant + lst.sort(reverse=True) # décroissant + ``` + + **Exemple :** + + ```py + fruits = ['banana', 'orange', 'mango', 'lemon'] + fruits.sort() + print(fruits) # tri alphabétique, ['banana', 'lemon', 'mango', 'orange'] + fruits.sort(reverse=True) + print(fruits) # ['orange', 'mango', 'lemon', 'banana'] + ages = [22, 19, 24, 25, 26, 24, 25, 24] + ages.sort() + print(ages) # [19, 22, 24, 24, 24, 25, 25, 26] + + ages.sort(reverse=True) + print(ages) # [26, 25, 25, 24, 24, 24, 22, 19] + ``` + + `sorted()` : renvoie la liste triée sans modifier la liste d'origine. + **Exemple :** + + ```py + fruits = ['banana', 'orange', 'mango', 'lemon'] + print(sorted(fruits)) # ['banana', 'lemon', 'mango', 'orange'] + # Ordre inverse + fruits = ['banana', 'orange', 'mango', 'lemon'] + fruits = sorted(fruits,reverse=True) + print(fruits) # ['orange', 'mango', 'lemon', 'banana'] + ``` + +🌕 Vous êtes appliqué et vous avez déjà accompli beaucoup de choses. Vous venez de terminer le défi du Jour 5 et vous êtes cinq pas de plus sur la voie de la grandeur. Faites maintenant quelques exercices pour votre cerveau et vos muscles. + +## 💻 Exercices : Jour 5 + +### Exercices : Niveau 1 + +1. Déclarez une liste vide. +2. Déclarez une liste avec plus de 5 éléments. +3. Trouvez la longueur de votre liste. +4. Obtenez le premier élément, l'élément du milieu et le dernier élément de la liste. +5. Déclarez une liste appelée `mixed_data_types` contenant (votre nom, âge, taille, situation matrimoniale, adresse). +6. Déclarez une variable liste nommée `it_companies` et assignez-lui les valeurs initiales Facebook, Google, Microsoft, Apple, IBM, Oracle et Amazon. +7. Affichez la liste en utilisant _print()_. +8. Affichez le nombre d'entreprises dans la liste. +9. Affichez la première, celle du milieu et la dernière entreprise. +10. Affichez la liste après avoir modifié l'une des entreprises. +11. Ajoutez une entreprise IT à `it_companies`. +12. Insérez une entreprise IT au milieu de la liste. +13. Changez l'un des noms de `it_companies` en majuscules (IBM exclu !). +14. Joignez les `it_companies` avec une chaîne `'#;  '`. +15. Vérifiez si une certaine entreprise existe dans la liste `it_companies`. +16. Triez la liste avec la méthode `sort()`. +17. Inversez la liste dans l'ordre décroissant avec la méthode `reverse()`. +18. Découpez les 3 premières entreprises de la liste. +19. Découpez les 3 dernières entreprises de la liste. +20. Découpez l'entreprise du milieu (ou les entreprises du milieu) de la liste. +21. Supprimez la première entreprise IT de la liste. +22. Supprimez l'entreprise du milieu (ou les entreprises du milieu) de la liste. +23. Supprimez la dernière entreprise IT de la liste. +24. Supprimez toutes les entreprises IT de la liste. +25. Détruisez la liste des entreprises IT. +26. Joignez les listes suivantes : + + ```py + front_end = ['HTML', 'CSS', 'JS', 'React', 'Redux'] + back_end = ['Node','Express', 'MongoDB'] + ``` + +27. Après avoir joint les listes à la question 26, copiez la liste jointe et assignez-la à une variable `full_stack`, puis insérez Python et SQL après Redux. + +### Exercices : Niveau 2 + +1. Voici une liste de 10 âges d'étudiants : + +```sh +ages = [19, 22, 19, 24, 20, 25, 26, 24, 25, 24] +``` + +- Triez la liste et trouvez l'âge minimum et maximum. +- Ajoutez à nouveau l'âge minimum et l'âge maximum à la liste. +- Trouvez l'âge médian (un élément du milieu ou deux éléments du milieu divisés par deux). +- Trouvez l'âge moyen (somme de tous les éléments divisée par leur nombre). +- Trouvez l'étendue des âges (max moins min). +- Comparez la valeur de (min - moyenne) et (max - moyenne), en utilisant _abs()_. + +2. Trouvez le(s) pays du milieu dans la [liste des pays](https://github.com/Asabeneh/30-Days-Of-Python/tree/master/data/countries.py). +3. Divisez la liste des pays en deux listes égales ; si le nombre est impair, un pays de plus pour la première moitié. +4. `['China', 'Russia', 'USA', 'Finland', 'Sweden', 'Norway', 'Denmark']`. Dépaquetez les trois premiers pays et le reste comme pays scandinaves. + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 4](./04_strings_fr.md) | [Jour 6 >>](./06_tuples_fr.md) diff --git a/French/06_tuples_fr.md b/French/06_tuples_fr.md new file mode 100644 index 000000000..359435488 --- /dev/null +++ b/French/06_tuples_fr.md @@ -0,0 +1,253 @@ +
+

30 Jours de Python : Jour 6 - Tuples

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + + +
+ +[<< Jour 5](./05_lists_fr.md) | [Jour 7 >>](./07_sets_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 6](#-jour-6) + - [Tuples](#tuples) + - [Créer un tuple](#créer-un-tuple) + - [Longueur d'un tuple](#longueur-dun-tuple) + - [Accéder aux éléments d'un tuple](#accéder-aux-éléments-dun-tuple) + - [Découper un tuple](#découper-un-tuple) + - [Convertir un tuple en liste](#convertir-un-tuple-en-liste) + - [Vérifier la présence d'un élément dans un tuple](#vérifier-la-présence-dun-élément-dans-un-tuple) + - [Joindre des tuples](#joindre-des-tuples) + - [Supprimer des tuples](#supprimer-des-tuples) + - [💻 Exercices : Jour 6](#-exercices--jour-6) + - [Exercices : Niveau 1](#exercices--niveau-1) + - [Exercices : Niveau 2](#exercices--niveau-2) + +# 📘 Jour 6 + +## Tuples + +Un tuple est une collection ordonnée et non modifiable (immuable) de différents types de données. Les tuples s'écrivent entre parenthèses, (). Une fois qu'un tuple est créé, on ne peut pas modifier ses valeurs. On ne peut pas utiliser les méthodes add, insert, remove sur un tuple car il n'est pas modifiable (mutable). Contrairement à la liste, le tuple a peu de méthodes. Méthodes liées aux tuples : + +- tuple() : créer un tuple vide +- count() : compter le nombre d'occurrences d'un élément dans un tuple +- index() : trouver l'indice d'un élément dans un tuple +- `+` : concaténer deux tuples ou plus pour en créer un nouveau + +### Créer un tuple + +- Tuple vide : création d'un tuple vide + + ```py + # syntaxe + empty_tuple = () + # ou en utilisant le constructeur tuple + empty_tuple = tuple() + ``` + +- Tuple avec valeurs initiales + + ```py + # syntaxe + tpl = ('item1', 'item2','item3') + ``` + + ```py + fruits = ('banana', 'orange', 'mango', 'lemon') + ``` + +### Longueur d'un tuple + +On utilise la méthode _len()_ pour obtenir la longueur d'un tuple. + +```py +# syntaxe +tpl = ('item1', 'item2', 'item3') +len(tpl) +``` + +### Accéder aux éléments d'un tuple + +- Indexation positive + Comme pour le type liste, on utilise l'indexation positive ou négative pour accéder aux éléments d'un tuple. + ![Accéder aux éléments d'un tuple](../images/tuples_index.png) + + ```py + # Syntaxe + tpl = ('item1', 'item2', 'item3') + first_item = tpl[0] + second_item = tpl[1] + ``` + + ```py + fruits = ('banana', 'orange', 'mango', 'lemon') + first_fruit = fruits[0] + second_fruit = fruits[1] + last_index = len(fruits) - 1 + last_fruit = fruits[last_index] + ``` + +- Indexation négative + L'indexation négative signifie que l'on commence par la fin : -1 correspond au dernier élément, -2 à l'avant-dernier, et la valeur négative de la longueur du tuple/de la liste correspond au premier élément. + ![Indexation négative d'un tuple](../images/tuple_negative_indexing.png) + + ```py + # Syntaxe + tpl = ('item1', 'item2', 'item3','item4') + first_item = tpl[-4] + second_item = tpl[-3] + ``` + + ```py + fruits = ('banana', 'orange', 'mango', 'lemon') + first_fruit = fruits[-4] + second_fruit = fruits[-3] + last_fruit = fruits[-1] + ``` + +### Découper un tuple + +On peut extraire un sous-tuple en spécifiant une plage d'indices de début et de fin dans le tuple ; la valeur renvoyée sera un nouveau tuple contenant les éléments spécifiés. + +- Plage d'indices positifs + + ```py + # Syntaxe + tpl = ('item1', 'item2', 'item3','item4') + all_items = tpl[0:4] # tous les éléments + all_items = tpl[0:] # tous les éléments + middle_two_items = tpl[1:3] # n'inclut pas l'élément à l'indice 3 + ``` + + ```py + fruits = ('banana', 'orange', 'mango', 'lemon') + all_fruits = fruits[0:4] # tous les éléments + all_fruits = fruits[0:] # tous les éléments + orange_mango = fruits[1:3] # n'inclut pas l'élément à l'indice 3 + orange_to_the_rest = fruits[1:] + ``` + +- Plage d'indices négatifs + + ```py + # Syntaxe + tpl = ('item1', 'item2', 'item3','item4') + all_items = tpl[-4:] # tous les éléments + middle_two_items = tpl[-3:-1] # n'inclut pas l'élément à l'indice 3 (-1) + ``` + + ```py + fruits = ('banana', 'orange', 'mango', 'lemon') + all_fruits = fruits[-4:] # tous les éléments + orange_mango = fruits[-3:-1] # n'inclut pas l'élément à l'indice 3 + orange_to_the_rest = fruits[-3:] + ``` + +### Convertir un tuple en liste + +On peut convertir des tuples en listes et des listes en tuples. Un tuple est immuable ; si on veut modifier un tuple, on doit le convertir en liste. + +```py +# Syntaxe +tpl = ('item1', 'item2', 'item3','item4') +lst = list(tpl) +``` + +```py +fruits = ('banana', 'orange', 'mango', 'lemon') +fruits = list(fruits) +fruits[0] = 'apple' +print(fruits) # ['apple', 'orange', 'mango', 'lemon'] +fruits = tuple(fruits) +print(fruits) # ('apple', 'orange', 'mango', 'lemon') +``` + +### Vérifier la présence d'un élément dans un tuple + +On peut vérifier si un élément existe ou non dans un tuple avec _in_, qui renvoie un booléen. + +```py +# Syntaxe +tpl = ('item1', 'item2', 'item3','item4') +'item2' in tpl # True +``` + +```py +fruits = ('banana', 'orange', 'mango', 'lemon') +print('orange' in fruits) # True +print('apple' in fruits) # False +fruits[0] = 'apple' # TypeError: 'tuple' object does not support item assignment +``` + +### Joindre des tuples + +On peut joindre deux tuples ou plus avec l'opérateur +. + +```py +# syntaxe +tpl1 = ('item1', 'item2', 'item3') +tpl2 = ('item4', 'item5','item6') +tpl3 = tpl1 + tpl2 +``` + +```py +fruits = ('banana', 'orange', 'mango', 'lemon') +vegetables = ('Tomato', 'Potato', 'Cabbage','Onion', 'Carrot') +fruits_and_vegetables = fruits + vegetables +``` + +### Supprimer des tuples + +Il n'est pas possible de supprimer un seul élément d'un tuple, mais il est possible de supprimer le tuple lui-même avec _del_. + +```py +# syntaxe +tpl1 = ('item1', 'item2', 'item3') +del tpl1 + +``` + +```py +fruits = ('banana', 'orange', 'mango', 'lemon') +del fruits +``` + +🌕 Vous êtes si courageux, vous êtes arrivé jusqu'ici. Vous venez de terminer les défis du jour 6 et vous êtes à six pas de plus sur la voie de la grandeur. Faites maintenant quelques exercices pour votre cerveau et vos muscles. + +## 💻 Exercices : Jour 6 + +### Exercices : Niveau 1 + +1. Créez un tuple vide. +2. Créez un tuple contenant les prénoms de vos sœurs et de vos frères (les frères et sœurs imaginaires sont acceptés). +3. Joignez les tuples frères et sœurs et assignez-les à siblings. +4. Combien de frères et sœurs avez-vous ? +5. Modifiez le tuple siblings en ajoutant le prénom de votre père et de votre mère, puis assignez-le à family_members. + +### Exercices : Niveau 2 + +1. Dépaquetez siblings et parents à partir de family_members. +2. Créez des tuples fruits, légumes et produits animaux. Joignez les trois tuples et assignez-les à une variable appelée food_stuff_tp. +3. Convertissez le tuple food_stuff_tp en une liste food_stuff_lt. +4. Découpez l'élément ou les éléments du milieu du tuple food_stuff_tp ou de la liste food_stuff_lt. +5. Découpez les trois premiers et les trois derniers éléments de la liste food_stuff_lt. +6. Supprimez complètement le tuple food_stuff_tp. +7. Vérifiez si un élément existe dans le tuple : + + - Vérifiez si 'Estonia' est un pays nordique. + - Vérifiez si 'Iceland' est un pays nordique. + + ```py + nordic_countries = ('Denmark', 'Finland','Iceland', 'Norway', 'Sweden') + ``` + +[<< Jour 5](./05_lists_fr.md) | [Jour 7 >>](./07_sets_fr.md) diff --git a/French/07_sets_fr.md b/French/07_sets_fr.md new file mode 100644 index 000000000..eb59bc844 --- /dev/null +++ b/French/07_sets_fr.md @@ -0,0 +1,435 @@ +
+

30 Jours de Python : Jour 7 - Ensembles

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + + +
+ +[<< Jour 6](./06_tuples_fr.md) | [Jour 8 >>](./08_dictionaries_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 7](#-jour-7) + - [Ensembles](#ensembles) + - [Créer un ensemble](#créer-un-ensemble) + - [Obtenir la longueur d'un ensemble](#obtenir-la-longueur-dun-ensemble) + - [Accéder aux éléments d'un ensemble](#accéder-aux-éléments-dun-ensemble) + - [Vérifier un élément](#vérifier-un-élément) + - [Ajouter des éléments à un ensemble](#ajouter-des-éléments-à-un-ensemble) + - [Supprimer des éléments d'un ensemble](#supprimer-des-éléments-dun-ensemble) + - [Vider un ensemble](#vider-un-ensemble) + - [Supprimer un ensemble](#supprimer-un-ensemble) + - [Convertir une liste en ensemble](#convertir-une-liste-en-ensemble) + - [Joindre des ensembles](#joindre-des-ensembles) + - [Trouver les éléments d'intersection](#trouver-les-éléments-dintersection) + - [Vérifier les sous-ensembles et sur-ensembles](#vérifier-les-sous-ensembles-et-sur-ensembles) + - [Vérifier la différence entre deux ensembles](#vérifier-la-différence-entre-deux-ensembles) + - [Trouver la différence symétrique entre deux ensembles](#trouver-la-différence-symétrique-entre-deux-ensembles) + - [Joindre des ensembles](#joindre-des-ensembles-1) + - [💻 Exercices : Jour 7](#-exercices--jour-7) + - [Exercices : Niveau 1](#exercices--niveau-1) + - [Exercices : Niveau 2](#exercices--niveau-2) + - [Exercices : Niveau 3](#exercices--niveau-3) + +# 📘 Jour 7 + +## Ensembles + +Un ensemble est une collection d'éléments. Revenons à vos cours de mathématiques à l'école primaire ou secondaire. La définition mathématique d'un ensemble peut également s'appliquer en Python. Un ensemble est une collection d'éléments distincts, non ordonnés et non indexés. En Python, un ensemble est utilisé pour stocker des éléments uniques, et il est possible de trouver l'_union_, l'_intersection_, la _différence_, la _différence symétrique_, le _sous-ensemble_, le _sur-ensemble_ ainsi que les _ensembles non disjoints_ et _disjoints_. + +### Créer un ensemble + +Pour créer un ensemble vide, nous utilisons la fonction set(). Des accolades vides {} créeront un dictionnaire. + +- Créer un ensemble vide + +```py +# syntax +st = set() +``` + +- Créer un ensemble avec des éléments initiaux + +```py +# syntax +st = {'item1', 'item2', 'item3', 'item4'} +``` + +**Exemple :** + +```py +# syntax +fruits = {'banane', 'orange', 'mangue', 'citron'} +``` + +### Obtenir la longueur d'un ensemble + +Nous utilisons la méthode **len()** pour connaître la taille d'un ensemble. + +```py +# syntax +st = {'item1', 'item2', 'item3', 'item4'} +len(st) +``` + +**Exemple :** + +```py +fruits = {'banane', 'orange', 'mangue', 'citron'} +len(fruits) +``` + +### Accéder aux éléments d'un ensemble + +Nous utilisons des boucles pour accéder aux éléments. Nous verrons cela dans la section sur les boucles. + +### Vérifier un élément + +Pour vérifier si un élément existe dans un ensemble, nous utilisons l'opérateur d'appartenance _in_. + +```py +# syntax +st = {'item1', 'item2', 'item3', 'item4'} +print("Est-ce que l'ensemble st contient item3 ? ", 'item3' in st) # Est-ce que l'ensemble st contient item3 ? True +``` + +**Exemple :** + +```py +fruits = {'banane', 'orange', 'mangue', 'citron'} +print('mangue' in fruits ) # True +``` + +### Ajouter des éléments à un ensemble + +Une fois qu'un ensemble est créé, nous ne pouvons pas modifier ses éléments, mais nous pouvons en ajouter de nouveaux. + +- Ajouter un élément avec _add()_ + +```py +# syntax +st = {'item1', 'item2', 'item3', 'item4'} +st.add('item5') +``` + +**Exemple :** + +```py +fruits = {'banane', 'orange', 'mangue', 'citron'} +fruits.add('lime') +``` + +- Ajouter plusieurs éléments avec _update()_ + La méthode _update()_ permet d'ajouter plusieurs éléments à un ensemble. _update()_ prend une liste en argument. + +```py +# syntax +st = {'item1', 'item2', 'item3', 'item4'} +st.update(['item5','item6','item7']) +``` + +**Exemple :** + +```py +fruits = {'banane', 'orange', 'mangue', 'citron'} +legumes = ('tomate', 'pomme de terre', 'chou', 'oignon', 'carotte') +fruits.update(legumes) +``` + +### Supprimer des éléments d'un ensemble + +Nous pouvons supprimer un élément d'un ensemble en utilisant la méthode _remove()_. Si l'élément n'est pas trouvé, la méthode _remove()_ générera une erreur, il est donc préférable de vérifier si l'élément existe dans l'ensemble. Cependant, la méthode _discard()_ ne génère aucune erreur. + +```py +# syntax +st = {'item1', 'item2', 'item3', 'item4'} +st.remove('item2') +``` + +La méthode pop() retire un élément aléatoire d'un ensemble et retourne l'élément retiré. + +**Exemple :** + +```py +fruits = {'banane', 'orange', 'mangue', 'citron'} +fruits.pop() # retire un élément aléatoire de l'ensemble + +``` + +Si nous souhaitons récupérer l'élément retiré. + +```py +fruits = {'banane', 'orange', 'mangue', 'citron'} +element_retire = fruits.pop() +``` + +### Vider un ensemble + +Si nous voulons vider un ensemble, nous utilisons la méthode _clear_. + +```py +# syntax +st = {'item1', 'item2', 'item3', 'item4'} +st.clear() +``` + +**Exemple :** + +```py +fruits = {'banane', 'orange', 'mangue', 'citron'} +fruits.clear() +print(fruits) # set() +``` + +### Supprimer un ensemble + +Si nous voulons supprimer l'ensemble lui-même, nous utilisons l'opérateur _del_. + +```py +# syntax +st = {'item1', 'item2', 'item3', 'item4'} +del st +``` + +**Exemple :** + +```py +fruits = {'banane', 'orange', 'mangue', 'citron'} +del fruits +``` + +### Convertir une liste en ensemble + +Nous pouvons convertir une liste en ensemble et un ensemble en liste. Convertir une liste en ensemble supprime les doublons et seuls les éléments uniques sont conservés. + +```py +# syntax +lst = ['item1', 'item2', 'item3', 'item4', 'item1'] +st = set(lst) # {'item2', 'item4', 'item1', 'item3'} - l'ordre est aléatoire, car les ensembles ne sont pas ordonnés par nature +``` + +**Exemple :** + +```py +fruits = ['banane', 'orange', 'mangue', 'citron', 'orange', 'banane'] +fruits = set(fruits) # {'mangue', 'citron', 'banane', 'orange'} +``` + +### Joindre des ensembles + +Nous pouvons joindre deux ensembles en utilisant la méthode _union()_, _update()_ ou le symbole _|_. + +- Union + Cette méthode retourne un nouvel ensemble + +```py +# syntax +st1 = {'item1', 'item2', 'item3', 'item4'} +st2 = {'item5', 'item6', 'item7', 'item8'} +st3 = st1.union(st2) #st3 = st1 | st2 +``` + +**Exemple :** + +```py +fruits = {'banane', 'orange', 'mangue', 'citron'} +legumes = {'tomate', 'pomme de terre', 'chou', 'oignon', 'carotte'} +print(fruits.union(legumes)) # {'citron', 'carotte', 'tomate', 'banane', 'mangue', 'orange', 'chou', 'pomme de terre', 'oignon'} +# ou en utilisant : print(fruits | legumes) +``` + +- Mise à jour + Cette méthode insère un ensemble dans un autre ensemble + +```py +# syntax +st1 = {'item1', 'item2', 'item3', 'item4'} +st2 = {'item5', 'item6', 'item7', 'item8'} +st1.update(st2) # le contenu de st2 est ajouté à st1 +``` + +**Exemple :** + +```py +fruits = {'banane', 'orange', 'mangue', 'citron'} +legumes = {'tomate', 'pomme de terre', 'chou', 'oignon', 'carotte'} +fruits.update(legumes) +print(fruits) # {'citron', 'carotte', 'tomate', 'banane', 'mangue', 'orange', 'chou', 'pomme de terre', 'oignon'} +``` + +### Trouver les éléments d'intersection + +L'intersection retourne un ensemble d'éléments qui sont présents dans les deux ensembles, ou en utilisant le symbole _&_. Voir l'exemple + +```py +# syntax +st1 = {'item1', 'item2', 'item3', 'item4'} +st2 = {'item3', 'item2'} +st1.intersection(st2) # {'item3', 'item2'} +# ou en utilisant : st1 & st2 +``` + +**Exemple :** + +```py +nombres_entiers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10} +nombres_pairs = {0, 2, 4, 6, 8, 10} +nombres_entiers.intersection(nombres_pairs) # {0, 2, 4, 6, 8, 10} + +python = {'p', 'y', 't', 'h', 'o','n'} +dragon = {'d', 'r', 'a', 'g', 'o','n'} +python.intersection(dragon) # {'o', 'n'} +# python & dragon +``` + +### Vérifier les sous-ensembles et sur-ensembles + +Un ensemble peut être un sous-ensemble ou un sur-ensemble d'autres ensembles : + +- Sous-ensemble : _issubset()_ +- Sur-ensemble : _issuperset()_ + +```py +# syntax +st1 = {'item1', 'item2', 'item3', 'item4'} +st2 = {'item2', 'item3'} +st2.issubset(st1) # True +st1.issuperset(st2) # True +``` + +**Exemple :** + +```py +nombres_entiers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10} +nombres_pairs = {0, 2, 4, 6, 8, 10} +nombres_entiers.issubset(nombres_pairs) # False, car c'est un sur-ensemble +nombres_entiers.issuperset(nombres_pairs) # True + +python = {'p', 'y', 't', 'h', 'o','n'} +dragon = {'d', 'r', 'a', 'g', 'o','n'} +python.issubset(dragon) # False +``` + +### Vérifier la différence entre deux ensembles + +Elle retourne la différence entre deux ensembles, ou en utilisant le symbole _-_ . + +```py +# syntax +st1 = {'item1', 'item2', 'item3', 'item4'} +st2 = {'item2', 'item3'} +st2.difference(st1) # set() : st2 - st1 +st1.difference(st2) # {'item1', 'item4'} => st1\st2 : st2 - st1 +``` + +**Exemple :** + +```py +nombres_entiers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10} +nombres_pairs = {0, 2, 4, 6, 8, 10} +nombres_entiers.difference(nombres_pairs) # {1, 3, 5, 7, 9} + +python = {'p', 'y', 't', 'o','n'} +dragon = {'d', 'r', 'a', 'g', 'o','n'} +python.difference(dragon) # {'p', 'y', 't'} - le résultat n'est pas ordonné (caractéristique des ensembles) +# python - dragon +dragon.difference(python) # {'d', 'r', 'a', 'g'} +# dragon - python +``` + +### Trouver la différence symétrique entre deux ensembles + +Elle retourne la différence symétrique entre deux ensembles. Cela signifie qu'elle retourne un ensemble contenant tous les éléments des deux ensembles, à l'exception des éléments communs aux deux ensembles, mathématiquement : (A\B) ∪ (B\A) + +```py +# syntax +st1 = {'item1', 'item2', 'item3', 'item4'} +st2 = {'item2', 'item3'} +# cela signifie (A\B)∪(B\A) +st2.symmetric_difference(st1) # {'item1', 'item4'} : st2 ^ st1 +``` + +**Exemple :** + +```py +nombres_entiers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10} +certains_nombres = {1, 2, 3, 4, 5} +nombres_entiers.symmetric_difference(certains_nombres) # {0, 6, 7, 8, 9, 10} + +python = {'p', 'y', 't', 'h', 'o','n'} +dragon = {'d', 'r', 'a', 'g', 'o','n'} +python.symmetric_difference(dragon) # {'r', 't', 'p', 'y', 'g', 'a', 'd', 'h'} +# python ^ dragon +``` + +### Joindre des ensembles + +Si deux ensembles n'ont aucun élément commun, on les appelle des ensembles disjoints. Nous pouvons vérifier si deux ensembles sont non disjoints ou disjoints en utilisant la méthode _isdisjoint()_. + +```py +# syntax +st1 = {'item1', 'item2', 'item3', 'item4'} +st2 = {'item2', 'item3'} +st2.isdisjoint(st1) # False +``` + +**Exemple :** + +```py +nombres_pairs = {0, 2, 4, 6, 8} +nombres_impairs = {1, 3, 5, 7, 9} +nombres_pairs.isdisjoint(nombres_impairs) # True, car aucun élément commun + +python = {'p', 'y', 't', 'h', 'o','n'} +dragon = {'d', 'r', 'a', 'g', 'o','n'} +python.isdisjoint(dragon) # False, il y a des éléments communs {'o', 'n'} +``` + +🌕 Vous êtes une étoile montante. Vous venez de terminer les défis du jour 7 et vous êtes 7 étapes plus loin vers l'excellence. Entraînez votre cerveau et vos muscles avec les exercices suivants. + +## 💻 Exercices : Jour 7 + +```py +# sets +it_companies = {'Facebook', 'Google', 'Microsoft', 'Apple', 'IBM', 'Oracle', 'Amazon'} +A = {19, 22, 24, 20, 25, 26} +B = {19, 22, 20, 25, 26, 24, 28, 27} +age = [22, 19, 24, 25, 26, 24, 25, 24] +``` + +### Exercices : Niveau 1 + +1. Trouvez la longueur de l'ensemble it_companies +2. Ajoutez 'Twitter' à it_companies +3. Insérez plusieurs entreprises informatiques à la fois dans l'ensemble it_companies +4. Supprimez l'une des entreprises de l'ensemble it_companies +5. Quelle est la différence entre remove et discard + +### Exercices : Niveau 2 + +1. Joignez A et B +2. Trouvez l'intersection de A et B +3. A est-il un sous-ensemble de B +4. A et B sont-ils des ensembles disjoints +5. Joignez A avec B et B avec A +6. Quelle est la différence symétrique entre A et B +7. Supprimez complètement les ensembles + +### Exercices : Niveau 3 + +1. Convertissez les âges en un ensemble et comparez la longueur de la liste et celle de l'ensemble. Laquelle est plus grande ? +2. Expliquez la différence entre les types de données suivants : chaîne, liste, tuple et ensemble +3. _I am a teacher and I love to inspire and teach people._ Combien de mots uniques ont été utilisés dans cette phrase ? Utilisez les méthodes split et set pour obtenir les mots uniques. + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 6](./06_tuples_fr.md) | [Jour 8 >>](./08_dictionaries_fr.md) diff --git a/French/08_dictionaries_fr.md b/French/08_dictionaries_fr.md new file mode 100644 index 000000000..122d0000d --- /dev/null +++ b/French/08_dictionaries_fr.md @@ -0,0 +1,343 @@ +
+

30 Jours de Python : Jour 8 - Dictionnaires

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + + +
+ +[<< Jour 7](./07_sets_fr.md) | [Jour 9 >>](./09_conditionals_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 8](#-jour-8) + - [Dictionnaires](#dictionnaires) + - [Créer un dictionnaire](#créer-un-dictionnaire) + - [Longueur d'un dictionnaire](#longueur-dun-dictionnaire) + - [Accéder aux éléments d'un dictionnaire](#accéder-aux-éléments-dun-dictionnaire) + - [Ajouter des éléments à un dictionnaire](#ajouter-des-éléments-à-un-dictionnaire) + - [Modifier des éléments dans un dictionnaire](#modifier-des-éléments-dans-un-dictionnaire) + - [Vérifier les clés dans un dictionnaire](#vérifier-les-clés-dans-un-dictionnaire) + - [Supprimer des paires clé-valeur d'un dictionnaire](#supprimer-des-paires-clé-valeur-dun-dictionnaire) + - [Convertir un dictionnaire en une liste d'éléments](#convertir-un-dictionnaire-en-une-liste-déléments) + - [Vider un dictionnaire](#vider-un-dictionnaire) + - [Supprimer un dictionnaire](#supprimer-un-dictionnaire) + - [Copier un dictionnaire](#copier-un-dictionnaire) + - [Obtenir les clés d'un dictionnaire sous forme de liste](#obtenir-les-clés-dun-dictionnaire-sous-forme-de-liste) + - [Obtenir les valeurs d'un dictionnaire sous forme de liste](#obtenir-les-valeurs-dun-dictionnaire-sous-forme-de-liste) + - [💻 Exercices : Jour 8](#-exercices--jour-8) + +# 📘 Jour 8 + +## Dictionnaires + +Un dictionnaire est une collection de données non ordonnées, modifiables (mutable), sous forme de paires (clé : valeur). + +### Créer un dictionnaire + +Pour créer un dictionnaire, nous utilisons des accolades {} ou la fonction intégrée *dict()*. + +```py +# syntax +empty_dict = {} +# Dictionary with data values +dct = {'key1':'value1', 'key2':'value2', 'key3':'value3', 'key4':'value4'} +``` + +**Exemple :** + +```py +person = { + 'first_name':'Asabeneh', + 'last_name':'Yetayeh', + 'age':250, + 'country':'Finland', + 'is_marred':True, + 'skills':['JavaScript', 'React', 'Node', 'MongoDB', 'Python'], + 'address':{ + 'street':'Space street', + 'zipcode':'02210' + } + } +``` + +Le dictionnaire ci-dessus montre qu'une valeur peut être de n'importe quel type de données : chaîne, booléen, liste, tuple, ensemble ou un dictionnaire. + +### Longueur d'un dictionnaire + +Il vérifie le nombre de paires 'clé : valeur' dans le dictionnaire. + +```py +# syntax +dct = {'key1':'value1', 'key2':'value2', 'key3':'value3', 'key4':'value4'} +print(len(dct)) # 4 +``` + +**Exemple :** + +```py +person = { + 'first_name':'Asabeneh', + 'last_name':'Yetayeh', + 'age':250, + 'country':'Finland', + 'is_married':True, + 'skills':['JavaScript', 'React', 'Node', 'MongoDB', 'Python'], + 'address':{ + 'street':'Space street', + 'zipcode':'02210' + } + } +print(len(person)) # 7 + +``` + +### Accéder aux éléments d'un dictionnaire + +Nous pouvons accéder aux éléments d'un dictionnaire par son nom de clé. + +```py +# syntax +dct = {'key1':'value1', 'key2':'value2', 'key3':'value3', 'key4':'value4'} +print(dct['key1']) # value1 +print(dct['key4']) # value4 +``` + +**Exemple :** + +```py +person = { + 'first_name':'Asabeneh', + 'last_name':'Yetayeh', + 'age':250, + 'country':'Finland', + 'is_marred':True, + 'skills':['JavaScript', 'React', 'Node', 'MongoDB', 'Python'], + 'address':{ + 'street':'Space street', + 'zipcode':'02210' + } + } +print(person['first_name']) # Asabeneh +print(person['country']) # Finland +print(person['skills']) # ['JavaScript', 'React', 'Node', 'MongoDB', 'Python'] +print(person['skills'][0]) # JavaScript +print(person['address']['street']) # Space street +print(person['city']) # Error +``` + +Accéder à un élément par son nom de clé génère une erreur si la clé n'existe pas. Pour éviter cette erreur, nous devons d'abord vérifier si une clé existe, ou nous pouvons utiliser la méthode _get_. La méthode get retourne None, qui est un objet de type NoneType, si la clé n'existe pas. + +```py +person = { + 'first_name':'Asabeneh', + 'last_name':'Yetayeh', + 'age':250, + 'country':'Finland', + 'is_marred':True, + 'skills':['JavaScript', 'React', 'Node', 'MongoDB', 'Python'], + 'address':{ + 'street':'Space street', + 'zipcode':'02210' + } + } +print(person.get('first_name')) # Asabeneh +print(person.get('country')) # Finland +print(person.get('skills')) #['JavaScript', 'React', 'Node', 'MongoDB', 'Python'] +print(person.get('city')) # None +``` + +### Ajouter des éléments à un dictionnaire + +Nous pouvons ajouter de nouvelles paires clé-valeur à un dictionnaire. + +```py +# syntax +dct = {'key1':'value1', 'key2':'value2', 'key3':'value3', 'key4':'value4'} +dct['key5'] = 'value5' +``` + +**Exemple :** + +```py +person = { + 'first_name':'Asabeneh', + 'last_name':'Yetayeh', + 'age':250, + 'country':'Finland', + 'is_marred':True, + 'skills':['JavaScript', 'React', 'Node', 'MongoDB', 'Python'], + 'address':{ + 'street':'Space street', + 'zipcode':'02210' + } +} +person['job_title'] = 'Instructor' +person['skills'].append('HTML') +print(person) +``` + +### Modifier des éléments dans un dictionnaire + +Nous pouvons modifier des éléments dans un dictionnaire. + +```py +# syntax +dct = {'key1':'value1', 'key2':'value2', 'key3':'value3', 'key4':'value4'} +dct['key1'] = 'value-one' +``` + +**Exemple :** + +```py +person = { + 'first_name':'Asabeneh', + 'last_name':'Yetayeh', + 'age':250, + 'country':'Finland', + 'is_marred':True, + 'skills':['JavaScript', 'React', 'Node', 'MongoDB', 'Python'], + 'address':{ + 'street':'Space street', + 'zipcode':'02210' + } + } +person['first_name'] = 'Eyob' +person['age'] = 252 +``` + +### Vérifier les clés dans un dictionnaire + +Nous utilisons l'opérateur _in_ pour vérifier si une clé existe dans un dictionnaire. + +```py +# syntax +dct = {'key1':'value1', 'key2':'value2', 'key3':'value3', 'key4':'value4'} +print('key2' in dct) # True +print('key5' in dct) # False +``` + +### Supprimer des paires clé-valeur d'un dictionnaire + +- _pop(key)_ : supprime l'élément avec le nom de clé spécifié. +- _popitem()_ : supprime le dernier élément. +- _del_ : supprime un élément avec le nom de clé spécifié. + +```py +# syntax +dct = {'key1':'value1', 'key2':'value2', 'key3':'value3', 'key4':'value4'} +dct.pop('key1') # supprime l'élément key1 +dct = {'key1':'value1', 'key2':'value2', 'key3':'value3', 'key4':'value4'} +dct.popitem() # supprime le dernier élément +del dct['key2'] # supprime l'élément key2 +``` + +**Exemple :** + +```py +person = { + 'first_name':'Asabeneh', + 'last_name':'Yetayeh', + 'age':250, + 'country':'Finland', + 'is_marred':True, + 'skills':['JavaScript', 'React', 'Node', 'MongoDB', 'Python'], + 'address':{ + 'street':'Space street', + 'zipcode':'02210' + } + } +person.pop('first_name') # Supprime l'élément first_name +person.popitem() # Supprime l'élément address +del person['is_marred'] # Supprime l'élément is_marred +``` + +### Convertir un dictionnaire en une liste d'éléments + +La méthode _items()_ transforme un dictionnaire en une liste de tuples. + +```py +# syntax +dct = {'key1':'value1', 'key2':'value2', 'key3':'value3', 'key4':'value4'} +print(dct.items()) # dict_items([('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3'), ('key4', 'value4')]) +``` + +### Vider un dictionnaire + +Si nous souhaitons vider un dictionnaire, nous pouvons utiliser la méthode _clear()_. + +```py +# syntax +dct = {'key1':'value1', 'key2':'value2', 'key3':'value3', 'key4':'value4'} +print(dct.clear()) # None +``` + +### Supprimer un dictionnaire + +Si nous n'utilisons plus le dictionnaire, nous pouvons le supprimer complètement. + +```py +# syntax +dct = {'key1':'value1', 'key2':'value2', 'key3':'value3', 'key4':'value4'} +del dct +``` + +### Copier un dictionnaire + +Nous pouvons copier un dictionnaire en utilisant la méthode _copy()_. Utiliser copy nous évite de muter le dictionnaire d'origine. + +```py +# syntax +dct = {'key1':'value1', 'key2':'value2', 'key3':'value3', 'key4':'value4'} +dct_copy = dct.copy() # {'key1':'value1', 'key2':'value2', 'key3':'value3', 'key4':'value4'} +``` + +### Obtenir les clés d'un dictionnaire sous forme de liste + +La méthode _keys()_ nous donne toutes les clés d'un dictionnaire sous forme de liste. + +```py +# syntax +dct = {'key1':'value1', 'key2':'value2', 'key3':'value3', 'key4':'value4'} +keys = dct.keys() +print(keys) # dict_keys(['key1', 'key2', 'key3', 'key4']) +``` + +### Obtenir les valeurs d'un dictionnaire sous forme de liste + +La méthode _values()_ nous donne toutes les valeurs d'un dictionnaire sous forme de liste. + +```py +# syntax +dct = {'key1':'value1', 'key2':'value2', 'key3':'value3', 'key4':'value4'} +values = dct.values() +print(values) # dict_values(['value1', 'value2', 'value3', 'value4']) +``` + +🌕 Vous êtes incroyable. Vous voilà paré du pouvoir des dictionnaires. Vous venez de terminer les défis du jour 8 et vous êtes 8 étapes plus loin vers l'excellence. Entraînez votre cerveau et vos muscles avec les exercices suivants. + +## 💻 Exercices : Jour 8 + +1. Créez un dictionnaire vide appelé dog +2. Ajoutez les clés name, color, breed, legs, age au dictionnaire dog +3. Créez un dictionnaire student et ajoutez first_name, last_name, gender, age, marital status, skills, country, city et address comme clés du dictionnaire +4. Obtenez la longueur du dictionnaire student +5. Obtenez la valeur de skills et vérifiez le type de données, il devrait s'agir d'une liste +6. Modifiez les valeurs de skills en ajoutant une ou deux compétences +7. Obtenez les clés du dictionnaire sous forme de liste +8. Obtenez les valeurs du dictionnaire sous forme de liste +9. Convertissez le dictionnaire en une liste de tuples avec la méthode _items()_ +10. Supprimez l'un des éléments du dictionnaire +11. Supprimez l'un des dictionnaires + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 7](./07_sets_fr.md) | [Jour 9 >>](./09_conditionals_fr.md) diff --git a/French/09_conditionals_fr.md b/French/09_conditionals_fr.md new file mode 100644 index 000000000..a2b2babf5 --- /dev/null +++ b/French/09_conditionals_fr.md @@ -0,0 +1,290 @@ +
+

30 Jours de Python : Jour 9 - Conditionnels

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + + +
+ +[<< Jour 8](./08_dictionaries_fr.md) | [Jour 10 >>](./10_loops_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 9](#-jour-9) + - [Conditionnels](#conditionnels) + - [Condition If](#condition-if) + - [If Else](#if-else) + - [If Elif Else](#if-elif-else) + - [Format raccourci](#format-raccourci) + - [Conditions imbriquées](#conditions-imbriquées) + - [Condition If et opérateurs logiques](#condition-if-et-opérateurs-logiques) + - [If et opérateur logique Or](#if-et-opérateur-logique-or) + - [💻 Exercices : Jour 9](#-exercices--jour-9) + - [Exercices : Niveau 1](#exercices--niveau-1) + - [Exercices : Niveau 2](#exercices--niveau-2) + - [Exercices : Niveau 3](#exercices--niveau-3) + +# 📘 Jour 9 + +## Conditionnels + +Par défaut, les instructions dans un script Python sont exécutées séquentiellement de haut en bas. Si la logique du programme l'exige, l'ordre d'exécution peut être modifié de deux manières : + +- **Exécution conditionnelle** : un bloc d'une ou plusieurs instructions s'exécute si une expression est vraie. +- **Exécution répétitive** : un bloc d'une ou plusieurs instructions s'exécute de manière répétitive tant qu'une expression est vraie. + +Dans cette section, nous aborderons les instructions _if_, _else_, _elif_. Les opérateurs de comparaison et logiques que nous avons appris dans les sections précédentes seront utiles ici. + +### Condition If + +En Python et dans d'autres langages de programmation, le mot-clé _if_ est utilisé pour vérifier si une condition est vraie et exécuter le bloc de code. N'oubliez pas l'indentation après les deux-points. + +```py +# syntax +if condition: + this part of code runs for truthy conditions +``` + +**Exemple 1 :** + +```py +a = 3 +if a > 0: + print('A est un nombre positif') +# A est un nombre positif +``` + +Comme vous pouvez le voir dans l'exemple ci-dessus, 3 est plus grand que 0. La condition était vraie et le bloc de code a été exécuté. Cependant, si la condition est fausse, nous ne voyons pas le résultat. Pour voir le résultat quand la condition est fausse, il faut un autre bloc, qui sera _else_. + +### If Else + +Si la condition est vraie, le premier bloc s'exécute ; sinon, c'est le bloc else qui s'exécute. + +```py +# syntax +if condition: + this part of code runs for truthy conditions +else: + this part of code runs for false conditions +``` + +**Exemple :** + +```py +a = 3 +if a < 0: + print('A est un nombre négatif') +else: + print('A est un nombre positif') +``` + +La condition ci-dessus est fausse, donc le bloc else s'exécute. Et si notre condition a plus de deux cas ? Nous pourrions utiliser _elif_. + +### If Elif Else + +Dans notre vie quotidienne, nous prenons des décisions chaque jour. Nous ne prenons pas nos décisions en vérifiant une ou deux conditions, mais bien plusieurs. Comme dans la vie, la programmation est également pleine de conditions. Nous utilisons _elif_ lorsque nous avons plusieurs conditions. + +```py +# syntax +if condition: + code +elif condition: + code +else: + code + +``` + +**Exemple :** + +```py +a = 0 +if a > 0: + print('A est un nombre positif') +elif a < 0: + print('A est un nombre négatif') +else: + print('A est zéro') +``` + +### Format raccourci + +```py +# syntax +code if condition else code +``` + +**Exemple :** + +```py +a = 3 +print('A est positif') if a > 0 else print('A est négatif') # première condition satisfaite, 'A est positif' sera affiché +``` + +### Conditions imbriquées + +Les conditions peuvent être imbriquées. + +```py +# syntax +if condition: + code + if condition: + code +``` + +**Exemple :** + +```py +a = 0 +if a > 0: + if a % 2 == 0: + print('A est un entier positif et pair') + else: + print('A est un nombre positif') +elif a == 0: + print('A est zéro') +else: + print('A est un nombre négatif') + +``` + +Nous pouvons éviter d'écrire des conditions imbriquées en utilisant l'opérateur logique _and_. + +### Condition If et opérateurs logiques + +```py +# syntax +if condition and condition: + code +``` + +**Exemple :** + +```py +a = 0 +if a > 0 and a % 2 == 0: + print('A est un entier pair et positif') +elif a > 0 and a % 2 != 0: + print('A est un entier positif') +elif a == 0: + print('A est zéro') +else: + print('A est négatif') +``` + +### If et opérateur logique Or + +```py +# syntax +if condition or condition: + code +``` + +**Exemple :** + +```py +user = 'James' +access_level = 3 +if user == 'admin' or access_level >= 4: + print('Accès accordé !') +else: + print('Accès refusé !') +``` + +🌕 Vous faites un excellent travail. N'abandonnez jamais, car les grandes choses prennent du temps. Vous venez de terminer les défis du jour 9 et vous êtes 9 étapes plus loin vers l'excellence. Entraînez votre cerveau et vos muscles avec les exercices suivants. + +## 💻 Exercices : Jour 9 + +### Exercices : Niveau 1 + +1. Obtenez une entrée utilisateur avec input("Entrez votre âge : "). Si l'utilisateur a 18 ans ou plus, retournez : Vous êtes assez âgé pour conduire. Si moins de 18 ans, indiquez le nombre d'années restantes. Sortie : + + ```sh + Entrez votre âge : 30 + Vous êtes assez âgé pour apprendre à conduire. + + Entrez votre âge : 15 + Il vous reste 3 ans à attendre pour apprendre à conduire. + ``` + +2. Comparez les valeurs de my_age et your_age en utilisant if … else. Qui est le plus âgé (moi ou vous) ? Utilisez input("Entrez votre âge : ") pour obtenir l'âge. Vous pouvez utiliser une condition imbriquée pour afficher 'an' pour 1 an de différence, 'ans' pour des différences plus grandes, et un texte personnalisé si my_age = your_age. Sortie : + + ```sh + Entrez votre âge : 30 + Vous avez 5 ans de plus que moi. + ``` + +3. Obtenez deux nombres de l'utilisateur via input. Si a est plus grand que b, retournez a est plus grand que b, si a est plus petit que b, retournez a est plus petit que b, sinon a est égal à b. Sortie : + +```sh +Entrez le nombre un : 4 +Entrez le nombre deux : 3 +4 est plus grand que 3 +``` + +### Exercices : Niveau 2 + +1. Écrivez un code qui attribue une note aux élèves selon leurs scores : + + ```sh + 90-100, A + 80-89, B + 70-79, C + 60-69, D + 0-59, F + ``` + +2. Obtenez le mois de l'utilisateur, puis vérifiez si la saison est Automne, Hiver, Printemps ou Été. Si l'utilisateur saisit : + Septembre, Octobre ou Novembre, la saison est l'Automne. + Décembre, Janvier ou Février, la saison est l'Hiver. + Mars, Avril ou Mai, la saison est le Printemps. + Juin, Juillet ou Août, la saison est l'Été. + +3. La liste suivante contient des fruits : + + ```sh + fruits = ['banana', 'orange', 'mango', 'lemon'] + ``` + + Si un fruit n'existe pas dans la liste, ajoutez le fruit à la liste et affichez la liste modifiée. Si le fruit existe, affichez 'Ce fruit existe déjà dans la liste' avec print(). + +### Exercices : Niveau 3 + +1. Voici un dictionnaire person. N'hésitez pas à le modifier ! + +```py + person={ + 'first_name': 'Asabeneh', + 'last_name': 'Yetayeh', + 'age': 250, + 'country': 'Finland', + 'is_married': True, + 'skills': ['JavaScript', 'React', 'Node', 'MongoDB', 'Python'], + 'address': { + 'street': 'Space street', + 'zipcode': '02210' + } + } +``` + + * Vérifiez si le dictionnaire person a une clé skills, si oui, affichez la compétence du milieu dans la liste skills. + * Vérifiez si le dictionnaire person a une clé skills, si oui, vérifiez si la personne a la compétence 'Python' et affichez le résultat. + * Si la personne n'a que JavaScript et React dans ses compétences, affichez 'Il est développeur front-end' avec print(), si la personne a Node, Python, MongoDB, affichez 'Il est développeur back-end' avec print(), si la personne a React, Node et MongoDB, affichez 'Il est développeur full-stack' avec print(), sinon affichez 'unknown title' avec print() - pour des résultats plus précis, vous pouvez imbriquer davantage de conditions ! + * Si la personne est mariée et vit en Finlande, affichez les informations au format suivant : + +```py + Asabeneh Yetayeh vit en Finlande. Il est marié. +``` + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 8](./08_dictionaries_fr.md) | [Jour 10 >>](./10_loops_fr.md) diff --git a/French/10_loops_fr.md b/French/10_loops_fr.md new file mode 100644 index 000000000..268d907f8 --- /dev/null +++ b/French/10_loops_fr.md @@ -0,0 +1,465 @@ +
+

30 Jours de Python : Jour 10 - Boucles

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + + +
+ +[<< Jour 9](./09_conditionals_fr.md) | [Jour 11 >>](./11_functions_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 10](#-jour-10) + - [Boucles](#boucles) + - [Boucle While](#boucle-while) + - [Break et Continue - Partie 1](#break-et-continue---partie-1) + - [Boucle For](#boucle-for) + - [Break et Continue - Partie 2](#break-et-continue---partie-2) + - [La Fonction Range](#la-fonction-range) + - [Boucle For Imbriquée](#boucle-for-imbriquée) + - [For Else](#for-else) + - [Pass](#pass) + - [💻 Exercices : Jour 10](#-exercices--jour-10) + - [Exercices : Niveau 1](#exercices--niveau-1) + - [Exercices : Niveau 2](#exercices--niveau-2) + - [Exercices : Niveau 3](#exercices--niveau-3) + +# 📘 Jour 10 + +## Boucles + +La vie est faite de routines. En programmation, nous effectuons aussi beaucoup de tâches répétitives. Pour gérer ces tâches répétitives, les langages de programmation utilisent des boucles. Python propose également les deux types de boucles suivants : + +1. while +2. for + +### Boucle While + +Nous utilisons le mot réservé _while_ pour créer une boucle while. Elle est utilisée pour exécuter un bloc d'instructions de manière répétée jusqu'à ce que la condition soit vraie. Lorsque la condition devient fausse, les lignes de code après la boucle continuent de s'exécuter. + +```py + # syntax +while condition: + code goes here +``` + +**Exemple :** + +```py +count = 0 +while count < 5: + print(count) + count = count + 1 +# affiche de 0 à 4 +``` + +Dans la boucle while ci-dessus, la condition devient fausse lorsque count vaut 5. C'est à ce moment que la boucle s'arrête. +Si nous souhaitons exécuter un bloc de code une fois la condition devenue fausse, nous pouvons utiliser _else_. + +```py + # syntax +while condition: + code goes here +else: + code goes here +``` + +**Exemple :** + +```py +count = 0 +while count < 5: + print(count) + count = count + 1 +else: + print(count) +``` + +La condition de la boucle ci-dessus devient fausse lorsque count vaut 5 et la boucle s'arrête, puis l'exécution passe à l'instruction else. Par conséquent, 5 sera affiché. + +### Break et Continue - Partie 1 + +- Break : Nous utilisons break lorsque nous voulons sortir de la boucle ou l'arrêter. + +```py +# syntax +while condition: + code goes here + if another_condition: + break +``` + +**Exemple :** + +```py +count = 0 +while count < 5: + print(count) + count = count + 1 + if count == 3: + break +``` + +La boucle while ci-dessus n'affiche que 0, 1, 2, mais lorsqu'elle atteint 3, elle s'arrête. + +- Continue : Avec l'instruction continue, nous pouvons sauter l'itération en cours et continuer avec la suivante : + +```py + # syntax +while condition: + code goes here + if another_condition: + continue +``` + +**Exemple :** + +```py +count = 0 +while count < 5: + if count == 3: + count += 1 + continue + print(count) + count = count + 1 +``` + +La boucle while ci-dessus n'affiche que 0, 1, 2 et 4 (saute 3). + +### Boucle For + +Le mot-clé _for_ est utilisé pour créer une boucle for, similaire à d'autres langages de programmation, mais avec quelques différences de syntaxe. La boucle est utilisée pour itérer sur une séquence (liste, tuple, dictionnaire, ensemble ou chaîne de caractères). + +- Boucle For sur une liste + +```py +# syntax +for iterator in lst: + code goes here +``` + +**Exemple :** + +```py +numbers = [0, 1, 2, 3, 4, 5] +for number in numbers: # number est un nom temporaire pour référer aux éléments de la liste, valable uniquement dans cette boucle + print(number) # les nombres seront affichés ligne par ligne, de 0 à 5 +``` + +- Boucle For sur une chaîne de caractères + +```py +# syntax +for iterator in string: + code goes here +``` + +**Exemple :** + +```py +language = 'Python' +for letter in language: + print(letter) + + +for i in range(len(language)): + print(language[i]) +``` + +- Boucle For sur un tuple + +```py +# syntax +for iterator in tpl: + code goes here +``` + +**Exemple :** + +```py +numbers = (0, 1, 2, 3, 4, 5) +for number in numbers: + print(number) +``` + +- Boucle For avec un dictionnaire + Itérer sur un dictionnaire avec une boucle donne les clés du dictionnaire. + +```py + # syntax +for iterator in dct: + code goes here +``` + +**Exemple :** + +```py +person = { + 'first_name':'Asabeneh', + 'last_name':'Yetayeh', + 'age':250, + 'country':'Finland', + 'is_marred':True, + 'skills':['JavaScript', 'React', 'Node', 'MongoDB', 'Python'], + 'address':{ + 'street':'Space street', + 'zipcode':'02210' + } +} +for key in person: + print(key) + +for key, value in person.items(): + print(key, value) # de cette façon, nous obtenons à la fois les clés et les valeurs +``` + +- Boucle For sur un ensemble + +```py +# syntax +for iterator in st: + code goes here +``` + +**Exemple :** + +```py +it_companies = {'Facebook', 'Google', 'Microsoft', 'Apple', 'IBM', 'Oracle', 'Amazon'} +for company in it_companies: + print(company) +``` + +### Break et Continue - Partie 2 + +Petit rappel : +_Break_ : Nous utilisons break lorsque nous voulons arrêter notre boucle avant qu'elle ne soit terminée. + +```py +# syntax +for iterator in sequence: + code goes here + if condition: + break +``` + +**Exemple :** + +```py +numbers = (0,1,2,3,4,5) +for number in numbers: + print(number) + if number == 3: + break +``` + +Dans l'exemple ci-dessus, la boucle s'arrête lorsqu'elle atteint 3. + +Continue : Nous utilisons continue lorsque nous voulons sauter certaines étapes dans l'itération de la boucle. + +```py + # syntax +for iterator in sequence: + code goes here + if condition: + continue +``` + +**Exemple :** + +```py +numbers = (0,1,2,3,4,5) +for number in numbers: + print(number) + if number == 3: + continue + print('Le nombre suivant devrait être ', number + 1) if number != 5 else print("fin de la boucle") # pour le format raccourci, les instructions if et else sont toutes deux nécessaires +print('en dehors de la boucle') +``` + +Dans l'exemple ci-dessus, si le nombre est égal à 3, l'étape _après_ la condition (mais à l'intérieur de la boucle) est sautée et l'exécution de la boucle continue s'il reste des itérations. + +### La Fonction Range + +La fonction _range()_ est utilisée pour générer une séquence de nombres. _range(start, end, step)_ prend trois paramètres : le début, la fin et l'incrément. Par défaut, elle commence à 0 et l'incrément est de 1. La séquence range nécessite au moins 1 argument (end). +Créer des séquences avec range + +```py +lst = list(range(11)) +print(lst) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] +st = set(range(1, 11)) # 2 arguments indiquent le début et la fin de la séquence, le pas est fixé à 1 par défaut +print(st) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10} + +lst = list(range(0,11,2)) +print(lst) # [0, 2, 4, 6, 8, 10] +st = set(range(0,11,2)) +print(st) # {0, 2, 4, 6, 8, 10} + +# pour un parcours inversé +lst = list(range(11,0,-2)) +print(lst) # [11,9,7,5,3,1] +``` + +```py +# syntax +for iterator in range(start, end, step): +``` + +**Exemple :** + +```py +for number in range(11): + print(number) # affiche de 0 à 10, 11 non inclus +``` + +### Boucle For Imbriquée + +Nous pouvons écrire des boucles à l'intérieur d'une boucle. + +```py +# syntax +for x in y: + for t in x: + print(t) +``` + +**Exemple :** + +```py +person = { + 'first_name': 'Asabeneh', + 'last_name': 'Yetayeh', + 'age': 250, + 'country': 'Finland', + 'is_marred': True, + 'skills': ['JavaScript', 'React', 'Node', 'MongoDB', 'Python'], + 'address': { + 'street': 'Space street', + 'zipcode': '02210' + } +} +for key in person: + if key == 'skills': + for skill in person['skills']: + print(skill) +``` + +### For Else + +Si nous voulons afficher un message lorsque la boucle se termine, nous utilisons else. + +```py +# syntax +for iterator in range(start, end, step): + do something +else: + print('La boucle est terminée') +``` + +**Exemple :** + +```py +for number in range(11): + print(number) # affiche de 0 à 10, 11 non inclus +else: + print('La boucle s\'arrête à', number) +``` + +### Pass + +En Python, lorsqu'une instruction est requise (après les deux-points), mais que nous ne souhaitons pas y exécuter de code, nous pouvons écrire le mot _pass_ pour éviter les erreurs. Nous pouvons aussi l'utiliser comme un espace réservé pour de futures instructions. + +**Exemple :** + +```py +for number in range(6): + pass +``` + +🌕 Vous avez franchi une grande étape, vous êtes imbattable. Continuez ainsi ! Vous venez de terminer les défis du jour 10 et vous êtes 10 étapes plus loin vers l'excellence. Entraînez votre cerveau et vos muscles avec les exercices suivants. + +## 💻 Exercices : Jour 10 + +### Exercices : Niveau 1 + +1. Itérez de 0 à 10 avec une boucle for, puis faites de même avec une boucle while. +2. Itérez de 10 à 0 avec une boucle for, puis faites de même avec une boucle while. +3. Écrivez une boucle qui effectue sept appels à print() pour obtenir le triangle suivant : + + ```py + # + ## + ### + #### + ##### + ###### + ####### + ``` + +4. Utilisez des boucles imbriquées pour créer le motif suivant : + + ```sh + # # # # # # # # + # # # # # # # # + # # # # # # # # + # # # # # # # # + # # # # # # # # + # # # # # # # # + # # # # # # # # + # # # # # # # # + ``` + +5. Affichez le motif suivant : + + ```sh + 0 x 0 = 0 + 1 x 1 = 1 + 2 x 2 = 4 + 3 x 3 = 9 + 4 x 4 = 16 + 5 x 5 = 25 + 6 x 6 = 36 + 7 x 7 = 49 + 8 x 8 = 64 + 9 x 9 = 81 + 10 x 10 = 100 + ``` + +6. Parcourez la liste ['Python', 'Numpy','Pandas','Django', 'Flask'] avec une boucle for et affichez chaque élément. +7. Utilisez une boucle for pour itérer de 0 à 100 et n'affichez que les nombres pairs. +8. Utilisez une boucle for pour itérer de 0 à 100 et n'affichez que les nombres impairs. + +### Exercices : Niveau 2 + +1. Utilisez une boucle for pour itérer de 0 à 100 et affichez la somme de tous les nombres. + +```sh +The sum of all numbers is 5050. +``` + +2. Utilisez une boucle for pour itérer de 0 à 100 et affichez la somme de tous les nombres pairs et la somme de tous les nombres impairs. + + ```sh + The sum of all evens is 2550. And the sum of all odds is 2500. + ``` + +### Exercices : Niveau 3 + +1. Allez dans le dossier data et utilisez le fichier [countries.py](https://github.com/Asabeneh/30-Days-Of-Python/blob/master/data/countries.py). Parcourez les pays et extrayez tous ceux contenant le mot _land_. +2. Voici une liste de fruits, ['banana', 'orange', 'mango', 'lemon']. Inversez l'ordre en utilisant une boucle. +3. Allez dans le dossier data et utilisez le fichier [countries_data.py](https://github.com/Asabeneh/30-Days-Of-Python/blob/master/data/countries-data.py). + 1. Quel est le nombre total de langues dans les données ? + 2. Trouvez les dix langues les plus parlées dans les données. + 3. Trouvez les 10 pays les plus peuplés du monde. + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 9](./09_conditionals_fr.md) | [Jour 11 >>](./11_functions_fr.md) diff --git a/French/11_functions_fr.md b/French/11_functions_fr.md new file mode 100644 index 000000000..e30ad237a --- /dev/null +++ b/French/11_functions_fr.md @@ -0,0 +1,515 @@ +
+

30 Jours de Python : Jour 11 - Fonctions

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + + +
+ +[<< Jour 10](./10_loops_fr.md) | [Jour 12 >>](./12_modules_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 11](#-jour-11) + - [Fonctions](#fonctions) + - [Définir une fonction](#définir-une-fonction) + - [Déclarer et appeler une fonction](#déclarer-et-appeler-une-fonction) + - [Fonction sans paramètres](#fonction-sans-paramètres) + - [Fonction retournant une valeur - Partie 1](#fonction-retournant-une-valeur---partie-1) + - [Fonction avec paramètres](#fonction-avec-paramètres) + - [Passer des arguments avec clé et valeur](#passer-des-arguments-avec-clé-et-valeur) + - [Fonction retournant une valeur - Partie 2](#fonction-retournant-une-valeur---partie-2) + - [Fonction avec paramètres par défaut](#fonction-avec-paramètres-par-défaut) + - [Nombre arbitraire d'arguments](#nombre-arbitraire-darguments) + - [Paramètres par défaut et nombre arbitraire dans les fonctions](#paramètres-par-défaut-et-nombre-arbitraire-dans-les-fonctions) + - [Fonction comme paramètre d'une autre fonction](#fonction-comme-paramètre-dune-autre-fonction) + - [Témoignage](#témoignage) + - [💻 Exercices : Jour 11](#-exercices--jour-11) + - [Exercices : Niveau 1](#exercices--niveau-1) + - [Exercices : Niveau 2](#exercices--niveau-2) + - [Exercices : Niveau 3](#exercices--niveau-3) + +# 📘 Jour 11 + +## Fonctions + +Jusqu'à présent, nous avons vu de nombreuses fonctions intégrées de Python. Dans cette section, nous allons nous concentrer sur les fonctions personnalisées. Qu'est-ce qu'une fonction ? Avant de commencer à créer des fonctions, découvrons ce qu'est une fonction et pourquoi nous en avons besoin. + +### Définir une fonction + +Une fonction est un bloc de code réutilisable conçu pour effectuer une tâche spécifique. Pour définir ou déclarer une fonction, Python fournit le mot-clé _def_. Voici la syntaxe pour définir une fonction. Le bloc de code de la fonction n'est exécuté que si la fonction est appelée ou invoquée. + +### Déclarer et appeler une fonction + +Lorsque nous créons une fonction, on appelle cela déclarer une fonction. Lorsque nous commençons à l'utiliser, on appelle cela _appeler_ ou _invoquer_ une fonction. Les fonctions peuvent être déclarées avec ou sans paramètres. + +```py +# syntax +# Declaring a function +def function_name(): + codes + codes +# Calling a function +function_name() +``` + +### Fonction sans paramètres + +Une fonction peut être déclarée sans paramètres. + +**Exemple :** + +```py +def generate_full_name (): + first_name = 'Asabeneh' + last_name = 'Yetayeh' + space = ' ' + full_name = first_name + space + last_name + print(full_name) +generate_full_name () # appel d'une fonction + +def add_two_numbers (): + num_one = 2 + num_two = 3 + total = num_one + num_two + print(total) +add_two_numbers() +``` + +### Fonction retournant une valeur - Partie 1 + +Les fonctions retournent des valeurs à l'aide de l'instruction _return_. Si une fonction n'a pas d'instruction return, elle retourne None. Réécrivons les fonctions ci-dessus en utilisant return. Désormais, nous obtenons une valeur d'une fonction lorsque nous l'appelons et l'affichons. + +```py +def generate_full_name (): + first_name = 'Asabeneh' + last_name = 'Yetayeh' + space = ' ' + full_name = first_name + space + last_name + return full_name +print(generate_full_name()) + +def add_two_numbers (): + num_one = 2 + num_two = 3 + total = num_one + num_two + return total +print(add_two_numbers()) +``` + +### Fonction avec paramètres + +Dans une fonction, nous pouvons passer différents types de données (nombre, chaîne, booléen, liste, tuple, dictionnaire ou ensemble) comme paramètres. + +- Paramètre unique : si notre fonction prend un paramètre, nous devons l'appeler avec un argument + +```py + # syntax + # Declaring a function + def function_name(parameter): + codes + codes + # Calling function + print(function_name(argument)) +``` + +**Exemple :** + +```py +def greetings (name): + message = name + ', welcome to Python for Everyone!' + return message + +print(greetings('Asabeneh')) + +def add_ten(num): + ten = 10 + return num + ten +print(add_ten(90)) + +def square_number(x): + return x * x +print(square_number(2)) + +def area_of_circle (r): + PI = 3.14 + area = PI * r ** 2 + return area +print(area_of_circle(10)) + +def sum_of_numbers(n): + total = 0 + for i in range(n+1): + total+=i + return total +print(sum_of_numbers(10)) # 55 +print(sum_of_numbers(100)) # 5050 +``` + +- Deux paramètres : une fonction peut avoir ou non un ou plusieurs paramètres. Une fonction peut aussi avoir deux paramètres ou plus. Si notre fonction prend des paramètres, nous devons l'appeler avec des arguments. Regardons une fonction avec deux paramètres : + +```py + # syntax + # Declaring a function + def function_name(para1, para2): + codes + codes + # Calling function + print(function_name(arg1, arg2)) +``` + +**Exemple :** + +```py +def generate_full_name (first_name, last_name): + space = ' ' + full_name = first_name + space + last_name + return full_name +print('Nom complet : ', generate_full_name('Asabeneh','Yetayeh')) + +def sum_two_numbers (num_one, num_two): + sum = num_one + num_two + return sum +print('Somme de deux nombres : ', sum_two_numbers(1, 9)) + +def calculate_age (current_year, birth_year): + age = current_year - birth_year + return age + +print('Âge : ', calculate_age(2021, 1819)) + +def weight_of_object (mass, gravity): + weight = str(mass * gravity)+ ' N' + return weight +print('Poids d\'un objet en Newtons : ', weight_of_object(100, 9.81)) +``` + +### Passer des arguments avec clé et valeur + +Si nous passons les arguments avec clé et valeur, l'ordre des arguments n'a pas d'importance. + +```py +# syntax +# Declaring a function +def function_name(para1, para2): + codes + codes +# Calling function +print(function_name(para1 = 'John', para2 = 'Doe')) # l'ordre des arguments n'a pas d'importance ici +``` + +**Exemple :** + +```py +def print_fullname(firstname, lastname): + space = ' ' + full_name = firstname + space + lastname + print(full_name) +print_fullname(firstname = 'Asabeneh', lastname = 'Yetayeh') + +def add_two_numbers (num1, num2): + total = num1 + num2 + return total +print(add_two_numbers(num2 = 3, num1 = 2)) # l'ordre n'a pas d'importance +``` + +### Fonction retournant une valeur - Partie 2 + +Si nous ne retournons pas de valeur avec une fonction, alors notre fonction retourne _None_ par défaut. Pour retourner une valeur avec une fonction, nous utilisons le mot-clé _return_ suivi de la variable que nous retournons. Nous pouvons retourner n'importe quel type de données depuis une fonction. + +- Retourner une chaîne : +**Exemple :** + +```py +def print_name(firstname): + return firstname +print_name('Asabeneh') # Asabeneh + +def print_full_name(firstname, lastname): + space = ' ' + full_name = firstname + space + lastname + return full_name +print_full_name(firstname='Asabeneh', lastname='Yetayeh') +``` + +- Retourner un nombre : + +**Exemple :** + +```py +def add_two_numbers (num1, num2): + total = num1 + num2 + return total +print(add_two_numbers(2, 3)) + +def calculate_age (current_year, birth_year): + age = current_year - birth_year + return age +print('Âge : ', calculate_age(2019, 1819)) +``` + +- Retourner un booléen : + **Exemple :** + +```py +def is_even (n): + if n % 2 == 0: + return True # return arrête l'exécution de la fonction, similaire à break + return False +print(is_even(10)) # True +print(is_even(7)) # False +``` + +- Retourner une liste : + **Exemple :** + +```py +def find_even_numbers(n): + evens = [] + for i in range(n + 1): + if i % 2 == 0: + evens.append(i) + return evens +print(find_even_numbers(10)) +``` + +### Fonction avec paramètres par défaut + +Parfois, nous passons des valeurs par défaut aux paramètres lorsque nous invoquons la fonction. Si nous ne passons pas d'arguments lors de l'appel de la fonction, leurs valeurs par défaut seront utilisées. + +```py +# syntax +# Declaring a function +def function_name(param = value): + codes + codes +# Calling function +function_name() +function_name(arg) +``` + +**Exemple :** + +```py +def greetings (name = 'Peter'): + message = name + ', bienvenue à Python pour tous !' + return message +print(greetings()) +print(greetings('Asabeneh')) + +def generate_full_name (first_name = 'Asabeneh', last_name = 'Yetayeh'): + space = ' ' + full_name = first_name + space + last_name + return full_name + +print(generate_full_name()) +print(generate_full_name('David','Smith')) + +def calculate_age (birth_year,current_year = 2021): + age = current_year - birth_year + return age +print('Âge : ', calculate_age(1821)) + +def weight_of_object (mass, gravity = 9.81): + weight = str(mass * gravity)+ ' N' # la valeur doit d'abord être convertie en chaîne + return weight +print('Poids d\'un objet en Newtons : ', weight_of_object(100)) # 9.81 - gravité moyenne à la surface de la Terre +print('Poids d\'un objet en Newtons : ', weight_of_object(100, 1.62)) # gravité à la surface de la Lune +``` + +### Nombre arbitraire d'arguments + +Si nous ne connaissons pas le nombre d'arguments que nous passons à notre fonction, nous pouvons créer une fonction qui peut prendre un nombre arbitraire d'arguments en ajoutant \* avant le nom du paramètre. + +```py +# syntax +# Declaring a function +def function_name(*args): + codes + codes +# Calling function +function_name(param1, param2, param3,..) +``` + +**Exemple :** + +```py +def sum_all_nums(*nums): + total = 0 + for num in nums: + total += num # équivaut à total = total + num + return total +print(sum_all_nums(2, 3, 5)) # 10 +``` + +### Paramètres par défaut et nombre arbitraire dans les fonctions + +```py +def generate_groups (team,*args): + print(team) + for i in args: + print(i) +generate_groups('Team-1','Asabeneh','Brook','David','Eyob') +``` + +### Dépaquetage de dictionnaire + +Vous pouvez appeler une fonction qui a des arguments nommés en utilisant un dictionnaire avec des noms de clés correspondants. Pour ce faire, utilisez ``**``. + +```py +# Définissez une fonction qui prend deux arguments : 'name' et 'location' +def greet(name, location): + # Affiche un message de salutation utilisant les arguments fournis + print("Bonjour", name, "quel temps fait-il à", location) + +# Appelez la fonction en utilisant des arguments nommés +greet(name="Alice", location="New York") +# Sortie : Bonjour Alice quel temps fait-il à New York + +# Créez un dictionnaire avec des clés correspondant aux noms des paramètres de la fonction +my_dict = {"name": "Alice", "location": "New York"} + +# Appelez la fonction en utilisant le dépaquetage de dictionnaire +greet(**my_dict) +# L'opérateur ** dépaquette le dictionnaire, passant ses paires clé-valeur +# comme arguments nommés à la fonction. +# Sortie : Bonjour Alice quel temps fait-il à New York +``` + +### Nombre arbitraire d'arguments nommés + +Vous pouvez également définir une fonction pour accepter un nombre arbitraire d'arguments nommés. + +```py +def arbitrary_named_args(**args): + print("J'ai reçu un nombre arbitraire d'arguments, soit", len(args)) + print("Ils sont fournis sous forme de dictionnaire dans ma fonction :", type(args)) + print("Affichons-les :") + for k, v in args.items(): + print(" * clé :", k, "valeur :", v) +``` + +Évitez généralement cela sauf si nécessaire, car cela rend plus difficile la compréhension de ce que la fonction accepte et fait. + +### Fonction comme paramètre d'une autre fonction + +```py +# Vous pouvez passer des fonctions comme paramètres +def square_number (n): + return n ** n +def do_something(f, x): + return f(x) +print(do_something(square_number, 3)) # 27 +``` + +🌕 Vous avez accompli pas mal de choses jusqu'à présent. Continuez ainsi ! Vous venez de terminer les défis du jour 11 et vous êtes 11 étapes plus loin vers l'excellence. Entraînez votre cerveau et vos muscles avec les exercices suivants. + +## Témoignage + +Il est maintenant temps d'exprimer votre opinion sur l'auteur et 30DaysOfPython. Vous pouvez laisser votre témoignage sur ce [lien](https://testimonial-s3sw.onrender.com/). + +## 💻 Exercices : Jour 11 + +### Exercices : Niveau 1 + +1. Déclarez une fonction _add_two_numbers_. Elle prend deux paramètres et retourne une somme. +2. L'aire d'un cercle se calcule ainsi : aire = π x r x r. Écrivez une fonction qui calcule _area_of_circle_. +3. Écrivez une fonction appelée add_all_nums qui prend un nombre arbitraire d'arguments et les additionne. Vérifiez si tous les éléments de la liste sont de type numérique. Sinon, donnez un retour approprié. +4. La température en °C peut être convertie en °F avec cette formule : °F = (°C x 9/5) + 32. Écrivez une fonction qui convertit °C en °F, _convert_celsius_to_fahrenheit_. +5. Écrivez une fonction appelée check_season, elle prend un paramètre month et retourne la saison : Automne, Hiver, Printemps ou Été. +6. Écrivez une fonction appelée calculate_slope qui retourne la pente d'une équation linéaire. +7. L'équation quadratique se calcule ainsi : ax² + bx + c = 0. Écrivez une fonction qui calcule l'ensemble des solutions d'une équation quadratique, _solve_quadratic_eqn_. +8. Déclarez une fonction nommée print_list. Elle prend une liste en paramètre et affiche chaque élément de la liste. +9. Déclarez une fonction nommée reverse_list. Elle prend un tableau en paramètre et retourne le tableau inversé (utilisez des boucles). + +```py +print(reverse_list([1, 2, 3, 4, 5])) +# [5, 4, 3, 2, 1] +print(reverse_list(["A", "B", "C"])) +# ["C", "B", "A"] +``` + +10. Déclarez une fonction nommée capitalize_list_items. Elle prend une liste en paramètre et retourne une liste d'éléments en majuscules. +11. Déclarez une fonction nommée add_item. Elle prend une liste et un élément en paramètres. Elle retourne une liste avec l'élément ajouté à la fin. + +```py +food_stuff = ['Potato', 'Tomato', 'Mango', 'Milk']; +print(add_item(food_stuff, 'Meat')) # ['Potato', 'Tomato', 'Mango', 'Milk','Meat']; +numbers = [2, 3, 7, 9]; +print(add_item(numbers, 5)) # [2, 3, 7, 9, 5] + +``` + +12. Déclarez une fonction nommée remove_item. Elle prend une liste et un élément en paramètres. Elle retourne une liste avec l'élément supprimé. + +```py +food_stuff = ['Potato', 'Tomato', 'Mango', 'Milk'] +print(remove_item(food_stuff, 'Mango')) # ['Potato', 'Tomato', 'Milk']; +numbers = [2, 3, 7, 9] +print(remove_item(numbers, 3)) # [2, 7, 9] +``` + +13. Déclarez une fonction nommée sum_of_numbers. Elle prend un paramètre number et additionne tous les nombres dans cet intervalle. + +```py +print(sum_of_numbers(5)) # 15 +print(sum_of_numbers(10)) # 55 +print(sum_of_numbers(100)) # 5050 +``` + +14. Déclarez une fonction nommée sum_of_odds. Elle prend un paramètre number et additionne tous les nombres impairs dans cet intervalle. +15. Déclarez une fonction nommée sum_of_even. Elle prend un paramètre number et additionne tous les nombres pairs dans cet intervalle. + +### Exercices : Niveau 2 + +1. Déclarez une fonction nommée evens_and_odds. Elle prend un entier positif en paramètre et compte le nombre de pairs et d'impairs dans le nombre. + +```py + print(evens_and_odds(100)) + # The number of odds are 50. + # The number of evens are 51. +``` + +2. Appelez votre fonction factorial, elle prend un nombre entier en paramètre et retourne la factorielle de ce nombre. +3. Appelez votre fonction _is_empty_, elle prend un paramètre et vérifie s'il est vide ou non. +4. Écrivez différentes fonctions qui prennent des listes. Elles doivent calculer calculate_mean, calculate_median, calculate_mode, calculate_range, calculate_variance, calculate_std (écart type). +5. Écrivez une fonction appelée _greet_ qui prend un argument par défaut, _name_. Si aucun argument n'est fourni, elle doit afficher "Hello, Guest!", sinon elle doit saluer la personne par son nom. + +```py + greet() + # "Hello, Guest! + greet("Alice") + # "Hello, Alice!" +``` + +6. Créez une fonction appelée _show_args_ pour prendre un nombre arbitraire d'arguments nommés et afficher leurs noms et valeurs. + + ```py + show_args(name="Alice", age=30, city="New York") + # Received: name: Alice, age: 30, city: New York + show_args(name="Bob", pet="Fluffy, the bunny") + # Received: name: Bob, pet: Fluffy, the bunny + ``` + +### Exercices : Niveau 3 + +1. Écrivez une fonction appelée is_prime qui vérifie si un nombre est premier. +2. Écrivez une fonction qui vérifie si tous les éléments de la liste sont uniques. +3. Écrivez une fonction qui vérifie si tous les éléments de la liste sont du même type de données. +4. Écrivez une fonction qui vérifie si une variable fournie est une variable Python valide. +5. Allez dans le dossier data et accédez au fichier countries-data.py. + + - Créez une fonction appelée most_spoken_languages in the world. Elle doit retourner les 10 ou 20 langues les plus parlées dans le monde par ordre décroissant. + - Créez une fonction appelée most_populated_countries. Elle doit retourner les 10 ou 20 pays les plus peuplés par ordre décroissant. + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 10](./10_loops_fr.md) | [Jour 12 >>](./12_modules_fr.md) diff --git a/French/12_modules_fr.md b/French/12_modules_fr.md new file mode 100644 index 000000000..249c86762 --- /dev/null +++ b/French/12_modules_fr.md @@ -0,0 +1,305 @@ +
+

30 Jours de Python : Jour 12 - Modules

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + + + +
+ +[<< Jour 11](./11_functions_fr.md) | [Jour 13 >>](./13_list_comprehension_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 12](#-jour-12) + - [Modules](#modules) + - [Qu'est-ce qu'un module](#quest-ce-quun-module) + - [Créer un module](#créer-un-module) + - [Importer un module](#importer-un-module) + - [Importer des fonctions depuis un module](#importer-des-fonctions-depuis-un-module) + - [Importer des fonctions depuis un module et les renommer](#importer-des-fonctions-depuis-un-module-et-les-renommer) + - [Importer des modules intégrés](#importer-des-modules-intégrés) + - [Module OS](#module-os) + - [Module Sys](#module-sys) + - [Module Statistics](#module-statistics) + - [Module Math](#module-math) + - [Module String](#module-string) + - [Module Random](#module-random) + - [💻 Exercices : Jour 12](#-exercices--jour-12) + - [Exercices : Niveau 1](#exercices--niveau-1) + - [Exercices : Niveau 2](#exercices--niveau-2) + - [Exercices : Niveau 3](#exercices--niveau-3) + +# 📘 Jour 12 + +## Modules + +### Qu'est-ce qu'un module + +Un module est un fichier contenant un ensemble de code ou de fonctions qui peuvent être inclus dans une application. Un module peut être un fichier contenant une seule variable, une fonction ou une grande base de code. + +### Créer un module + +Pour créer un module, nous écrivons notre code dans un script Python et nous le sauvegardons avec l'extension .py. Créez un fichier nommé mymodule.py dans votre dossier de projet. Écrivons du code dans ce fichier. + +```py +# mymodule.py file +def generate_full_name(firstname, lastname): + return firstname + ' ' + lastname +``` + +Créez un fichier main.py dans votre répertoire de projet et importez le fichier mymodule.py. + +### Importer un module + +Pour importer le fichier, nous utilisons le mot-clé _import_ et uniquement le nom du fichier. + +```py +# main.py file +import mymodule +print(mymodule.generate_full_name('Asabeneh', 'Yetayeh')) # Asabeneh Yetayeh +``` + +### Importer des fonctions depuis un module + +Nous pouvons avoir plusieurs fonctions dans un fichier et nous pouvons les importer de différentes manières. + +```py +# main.py file +from mymodule import generate_full_name, sum_two_nums, person, gravity +print(generate_full_name('Asabneh','Yetayeh')) +print(sum_two_nums(1,9)) +mass = 100 +weight = mass * gravity +print(weight) +print(person['firstname']) +``` + +### Importer des fonctions depuis un module et les renommer + +Lors de l'importation, nous pouvons renommer le module. + +```py +# main.py file +from mymodule import generate_full_name as fullname, sum_two_nums as total, person as p, gravity as g +print(fullname('Asabneh','Yetayeh')) +print(total(1, 9)) +mass = 100 +weight = mass * g +print(weight) +print(p) +print(p['firstname']) +``` + +## Importer des modules intégrés + +Comme dans d'autres langages de programmation, nous pouvons importer des modules en utilisant le mot-clé _import_. Importons les modules courants que nous utiliserons la plupart du temps. Voici quelques modules intégrés courants : _math_, _datetime_, _os_, _sys_, _random_, _statistics_, _collections_, _json_, _re_. + +### Module OS + +En utilisant le module _os_ de Python, il est possible d'effectuer automatiquement de nombreuses tâches du système d'exploitation. Le module OS en Python fournit des fonctions pour créer un répertoire, changer de répertoire de travail, supprimer un répertoire (dossier), récupérer son contenu, et identifier le répertoire courant. + +```py +# import the module +import os +# Creating a directory +os.mkdir('directory_name') +# Changing the current directory +os.chdir('path') +# Getting current working directory +os.getcwd() +# Removing directory +os.rmdir() +``` + +### Module Sys + +Le module sys fournit des fonctions et des variables utilisées pour manipuler différentes parties de l'environnement d'exécution Python. La fonction sys.argv retourne une liste des arguments de ligne de commande passés à un script Python. L'élément à l'indice 0 de cette liste est toujours le nom du script, à l'indice 1 se trouve l'argument passé depuis la ligne de commande. + +Exemple d'un fichier script.py : + +```py +import sys +#print(sys.argv[0], argv[1],sys.argv[2]) # cette ligne afficherait : nom_du_fichier argument1 argument2 +print('Bienvenue {}. Profitez du défi {} !'.format(sys.argv[1], sys.argv[2])) +``` + +Pour vérifier le fonctionnement de ce script, j'ai écrit dans la ligne de commande : + +```sh +python script.py Asabeneh 30DaysOfPython +``` + +Le résultat : + +```sh +Welcome Asabeneh. Enjoy 30DaysOfPython challenge! +``` + +Quelques commandes sys utiles : + +```py +# pour quitter sys +sys.exit() +# Pour connaître le plus grand entier qu'il peut prendre +sys.maxsize +# Pour connaître le chemin d'environnement +sys.path +# Pour connaître la version de Python utilisée +sys.version +``` + +### Module Statistics + +Le module statistics fournit des fonctions pour les statistiques mathématiques de données numériques. Les fonctions statistiques populaires définies dans ce module : _mean_, _median_, _mode_, _stdev_, etc. + +```py +from statistics import * # importe toutes les fonctions du module statistics +ages = [20, 20, 4, 24, 25, 22, 26, 20, 23, 22, 26] +print(mean(ages)) # ~22.9 +print(median(ages)) # 23 +print(mode(ages)) # 20 +print(stdev(ages)) # ~2.3 +``` + +### Module Math + +Module contenant de nombreuses opérations et constantes mathématiques. + +```py +import math +print(math.pi) # 3.141592653589793, constante pi +print(math.sqrt(2)) # 1.4142135623730951, racine carrée +print(math.pow(2, 3)) # 8.0, fonction exponentielle +print(math.floor(9.81)) # 9, arrondi à l'inférieur +print(math.ceil(9.81)) # 10, arrondi au supérieur +print(math.log10(100)) # 2, logarithme en base 10 +``` + +Nous avons maintenant importé le module *math* qui contient de nombreuses fonctions pour effectuer des calculs mathématiques. Pour voir les fonctions disponibles dans le module, nous pouvons utiliser _help(math)_ ou _dir(math)_. Cela affichera les fonctions disponibles dans le module. Si nous voulons importer seulement une fonction spécifique du module, nous l'importons comme suit : + +```py +from math import pi +print(pi) +``` + +Il est également possible d'importer plusieurs fonctions à la fois : + +```py + +from math import pi, sqrt, pow, floor, ceil, log10 +print(pi) # 3.141592653589793 +print(sqrt(2)) # 1.4142135623730951 +print(pow(2, 3)) # 8.0 +print(floor(9.81)) # 9 +print(ceil(9.81)) # 10 +print(log10(100)) # 2 + +``` + +Mais si nous voulons importer toutes les fonctions du module math, nous pouvons utiliser \* . + +```py +from math import * +print(pi) # 3.141592653589793, constante pi +print(sqrt(2)) # 1.4142135623730951, racine carrée +print(pow(2, 3)) # 8.0, exponentielle +print(floor(9.81)) # 9, arrondi à l'inférieur +print(ceil(9.81)) # 10, arrondi au supérieur +print(math.log10(100)) # 2 +``` + +Lors de l'importation, nous pouvons aussi renommer la fonction. + +```py +from math import pi as PI +print(PI) # 3.141592653589793 +``` + +### Module String + +Le module string est un module utile à plusieurs fins. L'exemple ci-dessous montre quelques utilisations du module string. + +```py +import string +print(string.ascii_letters) # abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ +print(string.digits) # 0123456789 +print(string.punctuation) # !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ +``` + +### Module Random + +Vous êtes maintenant familier avec l'importation de modules. Faisons une importation de plus pour bien nous familiariser. Importons le module _random_ qui nous donne un nombre aléatoire entre 0 et 0,9999.... Le module _random_ a de nombreuses fonctions, mais dans cette section, nous n'utiliserons que _random_ et _randint_. + +```py +from random import random, randint +print(random()) # ne prend aucun argument ; retourne une valeur entre 0 et 0,9999 +print(randint(5, 20)) # retourne un entier aléatoire entre [5, 20] inclus +``` + +🌕 Vous allez loin. Continuez ainsi ! Vous venez de terminer les défis du jour 12 et vous êtes 12 étapes plus loin vers l'excellence. Entraînez votre cerveau et vos muscles avec les exercices suivants. + +## 💻 Exercices : Jour 12 + +### Exercices : Niveau 1 + +1. Écrivez une fonction qui génère un random_user_id de six chiffres/caractères. + ```py + print(random_user_id()) + '1ee33d' + ``` +2. Modifiez la tâche précédente. Déclarez une fonction nommée user_id_gen_by_user. Elle ne prend aucun paramètre mais prend deux entrées avec input(). La première entrée est le nombre de caractères et la seconde est le nombre d'ID à générer. + +```py +print(user_id_gen_by_user()) # saisie utilisateur : 5 5 +#sortie : +#kcsy2 +#SMFYb +#bWmeq +#ZXOYh +#2Rgxf + +print(user_id_gen_by_user()) # 16 5 +#1GCSgPLMaBAVQZ26 +#YD7eFwNQKNs7qXaT +#ycArC5yrRupyG00S +#UbGxOFI7UXSWAyKN +#dIV0SSUTgAdKwStr +``` + +3. Écrivez une fonction nommée rgb_color_gen. Elle générera des couleurs rgb (3 valeurs comprises entre 0 et 255 chacune). + +```py +print(rgb_color_gen()) +# rgb(125,244,255) - la sortie doit être sous cette forme +``` + +### Exercices : Niveau 2 + +1. Écrivez une fonction list_of_hexa_colors qui retourne un nombre quelconque de couleurs hexadécimales dans un tableau (six chiffres hexadécimaux écrits après #. Le système de numération hexadécimal est composé de 16 symboles : 0-9 et les 6 premières lettres de l'alphabet, a-f.) +2. Écrivez une fonction list_of_rgb_colors qui retourne un nombre quelconque de couleurs RVB dans un tableau. +3. Écrivez une fonction generate_colors qui peut générer un nombre quelconque de couleurs hexa ou rgb. + +```py + generate_colors('hexa', 3) # ['#a3e12f','#03ed55','#eb3d2b'] + generate_colors('hexa', 1) # ['#b334ef'] + generate_colors('rgb', 3) # ['rgb(5, 55, 175','rgb(50, 105, 100','rgb(15, 26, 80'] + generate_colors('rgb', 1) # ['rgb(33,79, 176)'] + ``` + +### Exercices : Niveau 3 + +1. Appelez votre fonction shuffle_list, elle prend une liste en paramètre et retourne une liste mélangée. +2. Écrivez une fonction qui retourne un tableau de sept nombres aléatoires dans un intervalle de 0 à 9. Tous les nombres doivent être uniques. + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 11](./11_functions_fr.md) | [Jour 13 >>](./13_list_comprehension_fr.md) diff --git a/French/13_list_comprehension_fr.md b/French/13_list_comprehension_fr.md new file mode 100644 index 000000000..890991086 --- /dev/null +++ b/French/13_list_comprehension_fr.md @@ -0,0 +1,209 @@ +
+

30 Jours de Python : Jour 13 - Compréhension de listes

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + + + +
+ +[<< Jour 12](./12_modules_fr.md) | [Jour 14 >>](./14_higher_order_functions_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 13](#-jour-13) + - [Compréhension de listes](#compréhension-de-listes) + - [Fonction Lambda](#fonction-lambda) + - [Créer une fonction Lambda](#créer-une-fonction-lambda) + - [Fonction Lambda dans une autre fonction](#fonction-lambda-dans-une-autre-fonction) + - [💻 Exercices : Jour 13](#-exercices--jour-13) + +# 📘 Jour 13 + +## Compréhension de listes + +La compréhension de listes en Python est une façon compacte de créer une liste à partir d'une séquence. C'est une manière concise de créer une nouvelle liste. La compréhension de listes est considérablement plus rapide que le traitement d'une liste avec une boucle _for_. + +```py +# syntax +[i for i in iterable if condition] +``` + +**Exemple 1 :** + +Par exemple, si vous voulez convertir une chaîne en une liste de caractères. Vous pouvez utiliser plusieurs méthodes. Voyons-en quelques-unes : + +```py +# Une façon +language = 'Python' +lst = list(language) # conversion de la chaîne en liste +print(type(lst)) # list +print(lst) # ['P', 'y', 't', 'h', 'o', 'n'] + +# Deuxième façon : compréhension de listes +lst = [i for i in language] +print(type(lst)) # list +print(lst) # ['P', 'y', 't', 'h', 'o', 'n'] + +``` + +**Exemple 2 :** + +Par exemple, si vous voulez générer une liste de nombres + +```py +# Génération de nombres +numbers = [i for i in range(11)] # pour générer les nombres de 0 à 10 +print(numbers) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + +# Il est possible d'effectuer des opérations mathématiques pendant l'itération +squares = [i * i for i in range(11)] +print(squares) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100] + +# Il est aussi possible de créer une liste de tuples +numbers = [(i, i * i) for i in range(11)] +print(numbers) # [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)] + +``` + +**Exemple 3 :** + +La compréhension de listes peut être combinée avec une expression if + + +```py +# Génération de nombres pairs +even_numbers = [i for i in range(21) if i % 2 == 0] # pour générer une liste de nombres pairs de 0 à 21 +print(even_numbers) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20] + +# Génération de nombres impairs +odd_numbers = [i for i in range(21) if i % 2 != 0] # pour générer les nombres impairs de 0 à 21 +print(odd_numbers) # [1, 3, 5, 7, 9, 11, 13, 15, 17, 19] +# Filtrage de nombres : filtrons les nombres pairs positifs de la liste ci-dessous +numbers = [-8, -7, -3, -1, 0, 1, 3, 4, 5, 7, 6, 8, 10] +positive_even_numbers = [i for i in numbers if i % 2 == 0 and i > 0] +print(positive_even_numbers) # [4, 6, 8, 10] + +# Aplatissement d'un tableau à deux dimensions +list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] +flattened_list = [ number for row in list_of_lists for number in row] +print(flattened_list) # [1, 2, 3, 4, 5, 6, 7, 8, 9] +``` + +## Fonction Lambda + +Une fonction lambda est une petite fonction anonyme sans nom. Elle peut prendre n'importe quel nombre d'arguments, mais ne peut avoir qu'une seule expression. La fonction lambda est similaire aux fonctions anonymes en JavaScript. Nous en avons besoin lorsque nous voulons écrire une fonction anonyme à l'intérieur d'une autre fonction. + +### Créer une fonction Lambda + +Pour créer une fonction lambda, nous utilisons le mot-clé _lambda_ suivi d'un ou plusieurs paramètres, puis d'une expression. Voir la syntaxe et l'exemple ci-dessous. La fonction lambda n'utilise pas return mais retourne explicitement l'expression. + +```py +# syntax +x = lambda param1, param2, param3: param1 + param2 + param3 +print(x(arg1, arg2, arg3)) +``` + +**Exemple :** + +```py +# Fonction nommée +def add_two_nums(a, b): + return a + b + +print(add_two_nums(2, 3)) # 5 +# Transformons la fonction ci-dessus en une fonction lambda +add_two_nums = lambda a, b: a + b +print(add_two_nums(2,3)) # 5 + +# Fonction lambda auto-invoquée +(lambda a, b: a + b)(2,3) # 5 - nécessite d'être encapsulée dans print() pour voir le résultat dans la console + +square = lambda x : x ** 2 +print(square(3)) # 9 +cube = lambda x : x ** 3 +print(cube(3)) # 27 + +# Variables multiples +multiple_variable = lambda a, b, c: a ** 2 - 3 * b + 4 * c +print(multiple_variable(5, 5, 3)) # 22 +``` + +### Fonction Lambda dans une autre fonction + +Utiliser une fonction lambda à l'intérieur d'une autre fonction. + +```py +def power(x): + return lambda n : x ** n + +cube = power(2)(3) # la fonction power a maintenant besoin de 2 arguments pour s'exécuter, dans des parenthèses séparées +print(cube) # 8 +two_power_of_five = power(2)(5) +print(two_power_of_five) # 32 +``` + +🌕 Continuez votre bon travail. Gardez votre élan, le ciel est la limite ! Vous venez de terminer les défis du jour 13 et vous êtes 13 étapes plus loin vers l'excellence. Entraînez votre cerveau et vos muscles avec les exercices suivants. + +## 💻 Exercices : Jour 13 + +1. Filtrez uniquement les nombres négatifs et zéro dans la liste en utilisant la compréhension de listes. + ```py + numbers = [-4, -3, -2, -1, 0, 2, 4, 6] + ``` +2. Aplatissez la liste de listes suivante en une liste unidimensionnelle : + + ```py + list_of_lists =[[1, 2, 3], [4, 5, 6], [7, 8, 9]] + + output + [1, 2, 3, 4, 5, 6, 7, 8, 9] + ``` + +3. En utilisant la compréhension de listes, créez la liste de tuples suivante : + ```py + [(0, 1, 0, 0, 0, 0, 0), + (1, 1, 1, 1, 1, 1, 1), + (2, 1, 2, 4, 8, 16, 32), + (3, 1, 3, 9, 27, 81, 243), + (4, 1, 4, 16, 64, 256, 1024), + (5, 1, 5, 25, 125, 625, 3125), + (6, 1, 6, 36, 216, 1296, 7776), + (7, 1, 7, 49, 343, 2401, 16807), + (8, 1, 8, 64, 512, 4096, 32768), + (9, 1, 9, 81, 729, 6561, 59049), + (10, 1, 10, 100, 1000, 10000, 100000)] + ``` +4. Aplatissez la liste suivante en une nouvelle liste : + ```py + countries = [[('Finland', 'Helsinki')], [('Sweden', 'Stockholm')], [('Norway', 'Oslo')]] + output: + [['FINLAND','FIN', 'HELSINKI'], ['SWEDEN', 'SWE', 'STOCKHOLM'], ['NORWAY', 'NOR', 'OSLO']] + ``` +5. Convertissez la liste suivante en une liste de dictionnaires : + ```py + countries = [[('Finland', 'Helsinki')], [('Sweden', 'Stockholm')], [('Norway', 'Oslo')]] + output: + [{'country': 'FINLAND', 'city': 'HELSINKI'}, + {'country': 'SWEDEN', 'city': 'STOCKHOLM'}, + {'country': 'NORWAY', 'city': 'OSLO'}] + ``` +6. Convertissez la liste de listes suivante en une liste de chaînes concaténées : + ```py + names = [[('Asabeneh', 'Yetayeh')], [('David', 'Smith')], [('Donald', 'Trump')], [('Bill', 'Gates')]] + output + ['Asabeneh Yetayeh', 'David Smith', 'Donald Trump', 'Bill Gates'] + ``` +7. Écrivez une fonction lambda qui peut calculer la pente ou l'ordonnée à l'origine de fonctions linéaires. + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 12](./12_modules_fr.md) | [Jour 14 >>](./14_higher_order_functions_fr.md) diff --git a/French/14_higher_order_functions_fr.md b/French/14_higher_order_functions_fr.md new file mode 100644 index 000000000..946223b2c --- /dev/null +++ b/French/14_higher_order_functions_fr.md @@ -0,0 +1,372 @@ +
+

30 Jours de Python : Jour 14 - Fonctions d'ordre supérieur

+ + + + + Twitter Follow + + + Auteur : + Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + + +
+ +[<< Jour 13](./13_list_comprehension_fr.md) | [Jour 15 >>](./15_python_type_errors_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 14](#-jour-14) + - [Fonctions d'ordre supérieur](#fonctions-dordre-supérieur) + - [Fonction comme paramètre](#fonction-comme-paramètre) + - [Fonction comme valeur de retour](#fonction-comme-valeur-de-retour) + - [Fermetures Python](#fermetures-python) + - [Décorateurs Python](#décorateurs-python) + - [Créer des décorateurs](#créer-des-décorateurs) + - [Appliquer plusieurs décorateurs à une seule fonction](#appliquer-plusieurs-décorateurs-à-une-seule-fonction) + - [Accepter des paramètres dans les fonctions décoratrices](#accepter-des-paramètres-dans-les-fonctions-décoratrices) + - [Fonctions d'ordre supérieur intégrées](#fonctions-dordre-supérieur-intégrées) + - [Python - Fonction Map](#python---fonction-map) + - [Python - Fonction Filter](#python---fonction-filter) + - [Python - Fonction Reduce](#python---fonction-reduce) + - [💻 Exercices : Jour 14](#-exercices--jour-14) + - [Exercices : Niveau 1](#exercices--niveau-1) + - [Exercices : Niveau 2](#exercices--niveau-2) + - [Exercices : Niveau 3](#exercices--niveau-3) + +# 📘 Jour 14 + +## Fonctions d'ordre supérieur + +En Python, les fonctions sont traitées comme des citoyens de première classe, ce qui permet d'effectuer les opérations suivantes sur les fonctions : + +- Une fonction peut prendre une ou plusieurs fonctions comme paramètres +- Une fonction peut être retournée comme résultat d'une autre fonction +- Une fonction peut être modifiée +- Une fonction peut être assignée à une variable + +Dans cette section, nous aborderons : + +1. La manipulation des fonctions comme paramètres +2. Le retour de fonctions comme valeur de retour depuis d'autres fonctions +3. L'utilisation des fermetures et décorateurs Python + +### Fonction comme paramètre + +```py +def sum_numbers(nums): # fonction normale + return sum(nums) # une fonction simple utilisant la fonction intégrée sum + +def higher_order_function(f, lst): # fonction comme paramètre + summation = f(lst) + return summation +result = higher_order_function(sum_numbers, [1, 2, 3, 4, 5]) +print(result) # 15 +``` + +### Fonction comme valeur de retour + +```py +def square(x): # une fonction carré + return x ** 2 + +def cube(x): # une fonction cube + return x ** 3 + +def absolute(x): # une fonction valeur absolue + if x >= 0: + return x + else: + return -(x) + +def higher_order_function(type): # une fonction d'ordre supérieur retournant une fonction + if type == 'square': + return square + elif type == 'cube': + return cube + elif type == 'absolute': + return absolute + +result = higher_order_function('square') +print(result(3)) # 9 +result = higher_order_function('cube') +print(result(3)) # 27 +result = higher_order_function('absolute') +print(result(-3)) # 3 +``` + +Vous pouvez voir dans l'exemple ci-dessus que la fonction d'ordre supérieur retourne différentes fonctions selon le paramètre passé. + +## Fermetures Python + +Python permet à une fonction imbriquée d'accéder à la portée externe de la fonction englobante. C'est ce qu'on appelle une fermeture (closure). Voyons comment les fermetures fonctionnent en Python. En Python, une fermeture est créée en imbriquant une fonction à l'intérieur d'une autre fonction encapsulante, puis en retournant la fonction interne. Voir l'exemple ci-dessous. + +**Exemple :** + +```py +def add_ten(): + ten = 10 + def add(num): + return num + ten + return add + +closure_result = add_ten() +print(closure_result(5)) # 15 +print(closure_result(10)) # 20 +``` + +## Décorateurs Python + +Un décorateur est un patron de conception en Python qui permet d'ajouter de nouvelles fonctionnalités à un objet existant sans modifier sa structure. Les décorateurs sont généralement appelés avant la définition de la fonction que vous souhaitez décorer. + +### Créer des décorateurs + +Pour créer une fonction décoratrice, nous avons besoin d'une fonction externe avec une fonction wrapper interne. + +**Exemple :** + +```py +# Fonction normale +def greeting(): + return 'Bienvenue à Python' +def uppercase_decorator(function): + def wrapper(): + func = function() + make_uppercase = func.upper() + return make_uppercase + return wrapper +g = uppercase_decorator(greeting) +print(g()) # BIENVENUE À PYTHON + +## Implémentons l'exemple ci-dessus avec un décorateur + +'''Cette fonction décoratrice est une fonction d'ordre supérieur +qui prend une fonction comme paramètre''' +def uppercase_decorator(function): + def wrapper(): + func = function() + make_uppercase = func.upper() + return make_uppercase + return wrapper +@uppercase_decorator +def greeting(): + return 'Bienvenue à Python' +print(greeting()) # BIENVENUE À PYTHON + +``` + +### Appliquer plusieurs décorateurs à une seule fonction + +```py + +'''Ces fonctions décoratrices sont des fonctions d'ordre supérieur +qui prennent des fonctions comme paramètres''' + +# Premier décorateur +def uppercase_decorator(function): + def wrapper(): + func = function() + make_uppercase = func.upper() + return make_uppercase + return wrapper + +# Deuxième décorateur +def split_string_decorator(function): + def wrapper(): + func = function() + splitted_string = func.split() + return splitted_string + return wrapper + +# Les décorateurs sont exécutés de bas en haut +@split_string_decorator +@uppercase_decorator # l'ordre des décorateurs est important dans ce cas - .upper() ne fonctionne pas avec les listes +def greeting(): + return 'Bienvenue à Python' +print(greeting()) # ['BIENVENUE', 'À', 'PYTHON'] +``` + +### Accepter des paramètres dans les fonctions décoratrices + +La plupart du temps, nous avons besoin que nos fonctions prennent des paramètres, nous devons donc définir un décorateur qui accepte des paramètres. + +```py +def decorator_with_parameters(function): + def wrapper_accepting_parameters(para1, para2, para3): + function(para1, para2, para3) + print("Je vis à {}".format(para3)) + return wrapper_accepting_parameters + +@decorator_with_parameters +def print_full_name(first_name, last_name, country): + print("Je suis {} {}. J'aime enseigner.".format( + first_name, last_name)) + +print_full_name("Asabeneh", "Yetayeh",'Finland') +``` + +## Fonctions d'ordre supérieur intégrées + +Parmi les fonctions d'ordre supérieur intégrées que nous abordons dans cette partie, on trouve _map()_, _filter_ et _reduce_. +Une fonction lambda peut être passée comme paramètre et le meilleur cas d'utilisation des fonctions lambda est dans des fonctions comme map, filter et reduce. + +### Python - Fonction Map + +La fonction map() est une fonction intégrée qui prend une fonction et un itérable comme paramètres. + +```py + # syntax + map(function, iterable) +``` + +**Exemple 1 :** + +```py +numbers = [1, 2, 3, 4, 5] # itérable +def square(x): + return x ** 2 +numbers_squared = map(square, numbers) +print(list(numbers_squared)) # [1, 4, 9, 16, 25] +# Appliquons-la avec une fonction lambda +numbers_squared = map(lambda x : x ** 2, numbers) +print(list(numbers_squared)) # [1, 4, 9, 16, 25] +``` + +**Exemple 2 :** + +```py +numbers_str = ['1', '2', '3', '4', '5'] # itérable +numbers_int = map(int, numbers_str) +print(list(numbers_int)) # [1, 2, 3, 4, 5] +``` + +**Exemple 3 :** + +```py +names = ['Asabeneh', 'Lidiya', 'Ermias', 'Abraham'] # itérable + +def change_to_upper(name): + return name.upper() + +names_upper_cased = map(change_to_upper, names) +print(list(names_upper_cased)) # ['ASABENEH', 'LIDIYA', 'ERMIAS', 'ABRAHAM'] + +# Appliquons-la avec une fonction lambda +names_upper_cased = map(lambda name: name.upper(), names) +print(list(names_upper_cased)) # ['ASABENEH', 'LIDIYA', 'ERMIAS', 'ABRAHAM'] +``` + +Ce que fait réellement map, c'est itérer sur une liste. Par exemple, elle met les noms en majuscules et retourne une nouvelle liste. + +### Python - Fonction Filter + +La fonction filter() appelle la fonction spécifiée qui retourne un booléen pour chaque élément de l'itérable spécifié (liste). Elle filtre les éléments qui satisfont les critères de filtrage. + +```py + # syntax + filter(function, iterable) +``` + +**Exemple 1 :** + +```py +# Filtrons uniquement les nombres pairs +numbers = [1, 2, 3, 4, 5] # itérable + +def is_even(num): + if num % 2 == 0: + return True + return False + +even_numbers = filter(is_even, numbers) +print(list(even_numbers)) # [2, 4] +``` + +**Exemple 2 :** + +```py +numbers = [1, 2, 3, 4, 5] # itérable + +def is_odd(num): + if num % 2 != 0: + return True + return False + +odd_numbers = filter(is_odd, numbers) +print(list(odd_numbers)) # [1, 3, 5] +``` + +```py +# Filtrer les noms longs +names = ['Asabeneh', 'Lidiya', 'Ermias', 'Abraham'] # itérable +def is_name_long(name): + if len(name) > 7: + return True + return False + +long_names = filter(is_name_long, names) +print(list(long_names)) # ['Asabeneh'] +``` + +### Python - Fonction Reduce + +La fonction _reduce()_ est définie dans le module functools et nous devons l'importer depuis ce module. Comme map et filter, elle prend deux paramètres : une fonction et un itérable. Cependant, elle ne retourne pas un autre itérable, mais une valeur unique. + +**Exemple 1 :** + +```py +numbers_str = ['1', '2', '3', '4', '5'] # itérable +def add_two_nums(x, y): + return int(x) + int(y) + +total = reduce(add_two_nums, numbers_str) +print(total) # 15 +``` + +## 💻 Exercices : Jour 14 + +```py +countries = ['Estonia', 'Finland', 'Sweden', 'Denmark', 'Norway', 'Iceland'] +names = ['Asabeneh', 'Lidiya', 'Ermias', 'Abraham'] +numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] +``` + +### Exercices : Niveau 1 + +1. Expliquez la différence entre map, filter et reduce. +2. Expliquez la différence entre fonction d'ordre supérieur, fermeture et décorateur. +3. Définissez une fonction d'appel avant map, filter ou reduce, voir les exemples. +4. Utilisez une boucle for pour afficher chaque pays dans la liste countries. +5. Utilisez une boucle for pour afficher chaque nom dans la liste names. +6. Utilisez une boucle for pour afficher chaque nombre dans la liste numbers. + +### Exercices : Niveau 2 + +1. Utilisez map pour créer une nouvelle liste en mettant chaque pays en majuscules dans la liste countries. +2. Utilisez map pour créer une nouvelle liste en convertissant chaque nombre en son carré dans la liste numbers. +3. Utilisez map pour mettre chaque nom en majuscules dans la liste names. +4. Utilisez filter pour filtrer les pays contenant 'land'. +5. Utilisez filter pour filtrer les pays ayant exactement six caractères. +6. Utilisez filter pour filtrer les pays contenant six lettres ou plus dans la liste countries. +7. Utilisez filter pour filtrer les pays commençant par 'E'. +8. Enchaînez deux itérateurs de liste ou plus (ex. arr.map(callback).filter(callback).reduce(callback)). +9. Déclarez une fonction appelée get_string_lists qui prend une liste en paramètre et retourne une liste contenant uniquement les éléments de type chaîne. +10. Utilisez reduce pour additionner tous les nombres de la liste numbers. +11. Utilisez reduce pour concaténer tous les pays et produire cette phrase : Estonie, Finlande, Suède, Danemark, Norvège et Islande sont des pays d'Europe du Nord. +12. Déclarez une fonction appelée categorize_countries qui retourne une liste de pays ayant un motif commun (vous pouvez trouver la [liste des pays](https://github.com/Asabeneh/30-Days-Of-Python/blob/master/data/countries.py) dans ce dépôt sous countries.js (ex. 'land', 'ia', 'island', 'stan')). +13. Créez une fonction retournant un dictionnaire, où les clés représentent les lettres de début des pays et les valeurs sont le nombre de noms de pays commençant par cette lettre. +14. Déclarez une fonction get_first_ten_countries - elle retourne une liste des dix premiers pays de la liste countries.js dans le dossier data. +15. Déclarez une fonction get_last_ten_countries qui retourne les dix derniers pays de la liste countries. + +### Exercices : Niveau 3 + +1. Utilisez le fichier countries_data.py (https://github.com/Asabeneh/30-Days-Of-Python/blob/master/data/countries-data.py) et suivez les tâches ci-dessous : + - Triez les pays par nom, par capitale, par population. + - Triez les dix langues les plus parlées par emplacement. + - Triez les dix pays les plus peuplés. + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 13](./13_list_comprehension_fr.md) | [Jour 15 >>](./15_python_type_errors_fr.md) diff --git a/French/15_python_type_errors_fr.md b/French/15_python_type_errors_fr.md new file mode 100644 index 000000000..72018f123 --- /dev/null +++ b/French/15_python_type_errors_fr.md @@ -0,0 +1,361 @@ +
+

30 Jours de Python : Jour 15 - Erreurs de type en Python

+ + + + + Twitter Follow + + + Auteur : + Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + + +
+ +[<< Jour 14](./14_higher_order_functions_fr.md) | [Jour 16 >>](./16_python_datetime_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) +- [📘 Jour 15](#-jour-15) + - [Types d'erreurs Python](#types-derreurs-python) + - [SyntaxError](#syntaxerror) + - [NameError](#nameerror) + - [IndexError](#indexerror) + - [ModuleNotFoundError](#modulenotfounderror) + - [AttributeError](#attributeerror) + - [KeyError](#keyerror) + - [TypeError](#typeerror) + - [ImportError](#importerror) + - [ValueError](#valueerror) + - [ZeroDivisionError](#zerodivisionerror) + - [💻 Exercices : Jour 15](#-exercices--jour-15) + +# 📘 Jour 15 + +## Types d'erreurs Python + +Quand on écrit du code, il est courant de faire une faute de frappe ou une autre erreur fréquente. Si notre code ne s'exécute pas, l'interpréteur Python affiche un message contenant des informations sur l'endroit où le problème se produit et le type d'erreur. Il nous donne aussi parfois des suggestions de correction. Comprendre les différents types d'erreurs dans les langages de programmation nous aide à déboguer notre code rapidement et nous rend meilleurs dans ce que nous faisons. + +Voyons les types d'erreurs les plus courants un par un. Commençons par ouvrir notre terminal interactif Python. Allez dans votre terminal et tapez 'python'. Le terminal interactif Python s'ouvrira. + +### SyntaxError + +**Exemple 1 : SyntaxError** + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> print 'hello world' + File "", line 1 + print 'hello world' + ^ +SyntaxError: Missing parentheses in call to 'print'. Did you mean print('hello world')? +>>> +``` + +Comme vous pouvez le voir, nous avons fait une erreur de syntaxe car nous avons oublié d'entourer la chaîne de parenthèses, et Python nous suggère déjà la solution. Corrigeons-la. + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> print 'hello world' + File "", line 1 + print 'hello world' + ^ +SyntaxError: Missing parentheses in call to 'print'. Did you mean print('hello world')? +>>> print('hello world') +hello world +>>> +``` + +L'erreur était une _SyntaxError_. Après la correction, notre code s'est exécuté sans problème. Voyons d'autres types d'erreurs. + +### NameError + +**Exemple 1 : NameError** + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> print(age) +Traceback (most recent call last): + File "", line 1, in +NameError: name 'age' is not defined +>>> +``` + +Comme vous pouvez le voir dans le message ci-dessus, le nom age n'est pas défini. Oui, c'est vrai, nous n'avons pas défini de variable age mais nous essayions de l'afficher comme si nous l'avions déclarée. Corrigeons cela en la déclarant et en lui assignant une valeur. + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> print(age) +Traceback (most recent call last): + File "", line 1, in +NameError: name 'age' is not defined +>>> age = 25 +>>> print(age) +25 +>>> +``` + +Le type d'erreur était une _NameError_. Nous avons débogué l'erreur en définissant le nom de la variable. + +### IndexError + +**Exemple 1 : IndexError** + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> numbers = [1, 2, 3, 4, 5] +>>> numbers[5] +Traceback (most recent call last): + File "", line 1, in +IndexError: list index out of range +>>> +``` + +Dans l'exemple ci-dessus, Python a levé une _IndexError_, car la liste n'a que des index de 0 à 4, donc il était hors limites. + +### ModuleNotFoundError + +**Exemple 1 : ModuleNotFoundError** + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> import maths +Traceback (most recent call last): + File "", line 1, in +ModuleNotFoundError: No module named 'maths' +>>> +``` + +Dans l'exemple ci-dessus, j'ai délibérément ajouté un s supplémentaire à math et _ModuleNotFoundError_ a été levée. Corrigeons cela en retirant le s supplémentaire de math. + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> import maths +Traceback (most recent call last): + File "", line 1, in +ModuleNotFoundError: No module named 'maths' +>>> import math +>>> +``` + +Nous avons corrigé, utilisons donc quelques fonctions du module math. + +### AttributeError + +**Exemple 1 : AttributeError** + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> import maths +Traceback (most recent call last): + File "", line 1, in +ModuleNotFoundError: No module named 'maths' +>>> import math +>>> math.PI +Traceback (most recent call last): + File "", line 1, in +AttributeError: module 'math' has no attribute 'PI' +>>> +``` + +Comme vous pouvez le voir, j'ai encore fait une erreur ! Au lieu de pi, j'ai essayé d'appeler une constante PI du module math. Cela a levé une AttributeError, ce qui signifie que l'attribut n'existe pas dans le module. Corrigeons en changeant PI en pi. + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> import maths +Traceback (most recent call last): + File "", line 1, in +ModuleNotFoundError: No module named 'maths' +>>> import math +>>> math.PI +Traceback (most recent call last): + File "", line 1, in +AttributeError: module 'math' has no attribute 'PI' +>>> math.pi +3.141592653589793 +>>> +``` + +Maintenant, en appelant pi depuis le module math, nous avons obtenu le résultat. + +### KeyError + +**Exemple 1 : KeyError** + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> users = {'name':'Asab', 'age':250, 'country':'Finland'} +>>> users['name'] +'Asab' +>>> users['county'] +Traceback (most recent call last): + File "", line 1, in +KeyError: 'county' +>>> +``` + +Comme vous pouvez le voir, il y avait une faute de frappe dans la clé utilisée pour obtenir la valeur du dictionnaire. C'est donc une KeyError et la correction est assez simple. Faisons cela ! + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> user = {'name':'Asab', 'age':250, 'country':'Finland'} +>>> user['name'] +'Asab' +>>> user['county'] +Traceback (most recent call last): + File "", line 1, in +KeyError: 'county' +>>> user['country'] +'Finland' +>>> +``` + +Nous avons débogué l'erreur, notre code s'est exécuté et nous avons obtenu la valeur. + +### TypeError + +**Exemple 1 : TypeError** + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> 4 + '3' +Traceback (most recent call last): + File "", line 1, in +TypeError: unsupported operand type(s) for +: 'int' and 'str' +>>> +``` + +Dans l'exemple ci-dessus, une TypeError est levée car nous ne pouvons pas additionner un nombre à une chaîne. La première solution serait de convertir la chaîne en int ou float. Une autre solution serait de convertir le nombre en chaîne (le résultat serait alors '43'). Suivons la première correction. + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> 4 + '3' +Traceback (most recent call last): + File "", line 1, in +TypeError: unsupported operand type(s) for +: 'int' and 'str' +>>> 4 + int('3') +7 +>>> 4 + float('3') +7.0 +>>> +``` + +L'erreur a été supprimée et nous avons obtenu le résultat attendu. + +### ImportError + +**Exemple 1 : ImportError** + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> from math import power +Traceback (most recent call last): + File "", line 1, in +ImportError: cannot import name 'power' from 'math' +>>> +``` + +Il n'y a pas de fonction appelée power dans le module math, elle porte un nom différent : _pow_. Corrigeons cela : + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> from math import power +Traceback (most recent call last): + File "", line 1, in +ImportError: cannot import name 'power' from 'math' +>>> from math import pow +>>> pow(2,3) +8.0 +>>> +``` + +### ValueError + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> int('12a') +Traceback (most recent call last): + File "", line 1, in +ValueError: invalid literal for int() with base 10: '12a' +>>> +``` + +Dans ce cas, nous ne pouvons pas convertir la chaîne donnée en nombre à cause de la lettre 'a' qu'elle contient. + +### ZeroDivisionError + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> 1/0 +Traceback (most recent call last): + File "", line 1, in +ZeroDivisionError: division by zero +>>> +``` + +Nous ne pouvons pas diviser un nombre par zéro. + +Nous avons couvert certains des types d'erreurs Python ; si vous voulez en savoir plus, consultez la documentation Python sur les types d'erreurs. +Si vous êtes capable de lire les types d'erreurs, vous pourrez corriger vos bugs rapidement et vous deviendrez également un meilleur programmeur. + +🌕 Vous excellez. Vous êtes à mi-chemin de la grandeur. Faites maintenant quelques exercices pour votre cerveau et pour vos muscles. + +## 💻 Exercices : Jour 15 + +1. Ouvrez votre terminal interactif Python et essayez tous les exemples abordés dans cette section. + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 14](./14_higher_order_functions_fr.md) | [Jour 16 >>](./16_python_datetime_fr.md) diff --git a/French/16_python_datetime_fr.md b/French/16_python_datetime_fr.md new file mode 100644 index 000000000..141d54ff4 --- /dev/null +++ b/French/16_python_datetime_fr.md @@ -0,0 +1,209 @@ +
+

30 Jours de Python : Jour 16 - Date et heure en Python

+ + + + + Twitter Follow + + + Auteur : + Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + +
+ +[<< Jour 15](./15_python_type_errors_fr.md) | [Jour 17 >>](./17_exception_handling_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) +- [📘 Jour 16](#-jour-16) + - [Datetime en Python](#datetime-en-python) + - [Obtenir des informations sur *datetime*](#obtenir-des-informations-sur-datetime) + - [Formater la sortie de date avec *strftime*](#formater-la-sortie-de-date-avec-strftime) + - [Chaîne en heure avec *strptime*](#chaîne-en-heure-avec-strptime) + - [Utiliser *date* depuis *datetime*](#utiliser-date-depuis-datetime) + - [Objets Time pour représenter l'heure](#objets-time-pour-représenter-lheure) + - [Différence entre deux instants avec](#différence-entre-deux-instants-avec) + - [Différence entre deux instants avec *timedelta*](#différence-entre-deux-instants-avec-timedelta) + - [💻 Exercices : Jour 16](#-exercices--jour-16) + +# 📘 Jour 16 + +## Datetime en Python + +Python dispose du module _datetime_ pour gérer les dates et les heures. + +```py +import datetime +print(dir(datetime)) +['MAXYEAR', 'MINYEAR', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'date', 'datetime', 'datetime_CAPI', 'sys', 'time', 'timedelta', 'timezone', 'tzinfo'] +``` + +Avec les commandes intégrées dir ou help, il est possible de connaître les fonctions disponibles dans un module donné. Comme vous pouvez le voir, le module datetime contient de nombreuses fonctions, mais nous nous concentrerons sur _date_, _datetime_, _time_ et _timedelta_. Voyons-les une par une. + +### Obtenir des informations sur *datetime* + +```py +from datetime import datetime +now = datetime.now() +print(now) # 2021-07-08 07:34:46.549883 +day = now.day # 8 +month = now.month # 7 +year = now.year # 2021 +hour = now.hour # 7 +minute = now.minute # 38 +second = now.second +timestamp = now.timestamp() +print(day, month, year, hour, minute) +print('timestamp', timestamp) +print(f'{day}/{month}/{year}, {hour}:{minute}') # 8/7/2021, 7:38 +``` + +Le timestamp (ou timestamp Unix) est le nombre de secondes écoulées depuis le 1er janvier 1970 UTC. + +### Formater la sortie de date avec *strftime* + +```py +from datetime import datetime +new_year = datetime(2020, 1, 1) +print(new_year) # 2020-01-01 00:00:00 +day = new_year.day +month = new_year.month +year = new_year.year +hour = new_year.hour +minute = new_year.minute +second = new_year.second +print(day, month, year, hour, minute) #1 1 2020 0 0 +print(f'{day}/{month}/{year}, {hour}:{minute}') # 1/1/2020, 0:0 + +``` + +Pour formater la date et l'heure, on utilise la méthode *strftime* ; la documentation se trouve [ici](https://strftime.org/). + +```py +from datetime import datetime +# date et heure actuelles +now = datetime.now() +t = now.strftime("%H:%M:%S") +print("heure :", t) # heure : 18:21:40 +time_one = now.strftime("%m/%d/%Y, %H:%M:%S") +# format mm/dd/YY H:M:S +print("heure une :", time_one) # heure une : 06/28/2022, 18:21:40 +time_two = now.strftime("%d/%m/%Y, %H:%M:%S") +# format dd/mm/YY H:M:S +print("heure deux :", time_two) # heure deux : 28/06/2022, 18:21:40 +``` + +```sh +heure : 01:05:01 +heure une : 12/05/2019, 01:05:01 +heure deux : 05/12/2019, 01:05:01 +``` + +Voici tous les symboles _strftime_ que nous utilisons pour formater l'heure. Un exemple de tous les formats pour ce module. + +![strftime](../images/strftime.png) + +### Convertir une chaîne en objet datetime avec *strptime* +Voici une [documentation](https://www.programiz.com/python-programming/datetime/strptime) qui aide à comprendre le format. + +```py +from datetime import datetime +date_string = "5 December, 2019" +print("chaîne_date =", date_string) # chaîne_date = 5 December, 2019 +date_object = datetime.strptime(date_string, "%d %B, %Y") +print("objet_date =", date_object) # objet_date = 2019-12-05 00:00:00 +``` + +```sh +chaîne_date = 5 December, 2019 +objet_date = 2019-12-05 00:00:00 +``` + +### Utiliser *date* depuis *datetime* + +```py +from datetime import date +d = date(2020, 1, 1) +print(d) # 2020-01-01 +print('Date actuelle :', d.today()) # 2019-12-05 +# objet date pour la date d'aujourd'hui +today = date.today() +print("Année actuelle :", today.year) # 2019 +print("Mois actuel :", today.month) # 12 +print("Jour actuel :", today.day) # 5 +``` + +### Objets Time pour représenter l'heure + +```py +from datetime import time +# time(heure = 0, minute = 0, seconde = 0) +a = time() +print("a =", a) # a = 00:00:00 +# time(heure, minute et seconde) +b = time(10, 30, 50) +print("b =", b) # b = 10:30:50 +# time(heure, minute et seconde) +c = time(hour=10, minute=30, second=50) +print("c =", c) # c = 10:30:50 +# time(heure, minute, seconde, microseconde) +d = time(10, 30, 50, 200555) +print("d =", d) # d = 10:30:50.200555 +``` + +Sortie +a = 00:00:00 +b = 10:30:50 +c = 10:30:50 +d = 10:30:50.200555 + +### Différence entre deux instants avec + +```py +from datetime import date, datetime +today = date(year=2019, month=12, day=5) +new_year = date(year=2020, month=1, day=1) +time_left_for_newyear = new_year - today +# Temps restant avant le nouvel an : 27 days, 0:00:00 +print('Temps restant avant le nouvel an : ', time_left_for_newyear) # Temps restant avant le nouvel an : 27 days, 0:00:00 + +t1 = datetime(year = 2019, month = 12, day = 5, hour = 0, minute = 59, second = 0) +t2 = datetime(year = 2020, month = 1, day = 1, hour = 0, minute = 0, second = 0) +diff = t2 - t1 +print('Temps restant avant le nouvel an :', diff) # Temps restant avant le nouvel an : 26 days, 23: 01: 00 +``` + +### Différence entre deux instants avec *timedelta* + +```py +from datetime import timedelta +t1 = timedelta(weeks=12, days=10, hours=4, seconds=20) +t2 = timedelta(days=7, hours=5, minutes=3, seconds=30) +t3 = t1 - t2 +print("t3 =", t3) +``` + +```sh + date_string = 5 December, 2019 + date_object = 2019-12-05 00:00:00 + t3 = 86 days, 22:56:50 +``` + +🌕 Vous êtes extraordinaire. Vous avez franchi 16 étapes vers la grandeur. Faites maintenant quelques exercices pour votre cerveau et vos muscles. + +## 💻 Exercices : Jour 16 + +1. Obtenez le jour, le mois, l'année, l'heure, la minute et le timestamp actuels depuis le module datetime. +2. Formatez la date actuelle en utilisant ce format : "%m/%d/%Y, %H:%M:%S" +3. Aujourd'hui nous sommes le 5 décembre 2019. Convertissez cette chaîne de date en objet time. +4. Calculez la différence de temps entre maintenant et le nouvel an. +5. Calculez la différence de temps entre le 1er janvier 1970 et maintenant. +6. Réfléchissez : à quoi pouvez-vous utiliser le module datetime ? Exemples : + - Analyse de séries temporelles + - Obtenir un timestamp de toute activité dans une application + - Ajouter des articles sur un blog + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 15](./15_python_type_errors_fr.md) | [Jour 17 >>](./17_exception_handling_fr.md) diff --git a/French/17_exception_handling_fr.md b/French/17_exception_handling_fr.md new file mode 100644 index 000000000..b348c1a29 --- /dev/null +++ b/French/17_exception_handling_fr.md @@ -0,0 +1,307 @@ +
+

30 Jours de Python : Jour 17 - Gestion des exceptions

+ + + + + Twitter Follow + + + Auteur : + Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + +
+ +[<< Jour 16](./16_python_datetime_fr.md) | [Jour 18 >>](./18_regular_expressions_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 17](#-jour-17) + - [Gestion des exceptions](#gestion-des-exceptions) + - [Empaquetage et dépaquetage d'arguments en Python](#empaquetage-et-dépaquetage-darguments-en-python) + - [Dépaquetage](#dépaquetage) + - [Dépaquetage de listes](#dépaquetage-de-listes) + - [Dépaquetage de dictionnaires](#dépaquetage-de-dictionnaires) + - [Empaquetage](#empaquetage) + - [Empaquetage de listes](#empaquetage-de-listes) + - [Empaquetage de dictionnaires](#empaquetage-de-dictionnaires) + - [Décomposition en Python](#décomposition-en-python) + - [Enumerate](#enumerate) + - [Zip](#zip) + - [Exercices : Jour 17](#exercices--jour-17) + +# 📘 Jour 17 + +## Gestion des exceptions + +Python utilise _try_ et _except_ pour gérer les erreurs avec élégance. Une sortie élégante (ou gestion élégante) des erreurs est un idiome de programmation simple : un programme détecte une condition d'erreur grave et « se termine élégamment », de manière contrôlée. Souvent, le programme affiche un message d'erreur descriptif dans un terminal ou un journal dans le cadre de la sortie élégante, ce qui rend notre application plus robuste. La cause d'une exception est souvent externe au programme lui-même. Un exemple d'exception pourrait être une entrée incorrecte, un nom de fichier erroné, l'impossibilité de trouver un fichier, un périphérique d'E/S défectueux. La gestion élégante des erreurs empêche nos applications de planter. + +Nous avons couvert les différents types d'erreurs Python dans la section précédente. Si nous utilisons _try_ et _except_ dans notre programme, il ne lèvera pas d'erreurs dans ces blocs. + +![Try and Except](../images/try_except.png) + +```py +try: + code in this block if things go well +except: + code in this block run if things go wrong +``` + +**Exemple :** + +```py +try: + print(10 + '5') +except: + print('Quelque chose s\'est mal passé') +``` + +Dans l'exemple ci-dessus, le second opérande est une chaîne. Nous pourrions le convertir en float ou int pour l'additionner au nombre et le faire fonctionner. Mais sans aucune modification, le second bloc, _except_, sera exécuté. + +**Exemple :** + +```py +try: + name = input('Entrez votre nom : ') + year_born = input('Année de naissance : ') + age = 2019 - year_born + print(f'Vous êtes {name}. Et vous avez {age} ans.') +except: + print('Quelque chose s\'est mal passé') +``` + +```sh +Quelque chose s'est mal passé +``` + +Dans l'exemple ci-dessus, le bloc d'exception sera exécuté et nous ne savons pas exactement quel est le problème. Pour analyser le problème, nous pouvons utiliser les différents types d'erreurs avec except. + +Dans l'exemple suivant, l'erreur sera gérée et le type d'erreur levé nous sera également indiqué. + +```py +try: + name = input('Entrez votre nom : ') + year_born = input('Année de naissance : ') + age = 2019 - year_born + print(f'Vous êtes {name}. Et vous avez {age} ans.') +except TypeError: + print('Une erreur de type s\'est produite') +except ValueError: + print('Une erreur de valeur s\'est produite') +except ZeroDivisionError: + print('Une erreur de division par zéro s\'est produite') +``` + +```sh +Entrez votre nom : Asabeneh +Année de naissance : 1920 +Une erreur de type s'est produite +``` + +Dans le code ci-dessus, la sortie sera _TypeError_. +Maintenant, ajoutons un bloc supplémentaire : + +```py +try: + name = input('Entrez votre nom : ') + year_born = input('Année de naissance : ') + age = 2019 - int(year_born) + print(f'Vous êtes {name}. Et vous avez {age} ans.') +except TypeError: + print('Une erreur de type s\'est produite') +except ValueError: + print('Une erreur de valeur s\'est produite') +except ZeroDivisionError: + print('Une erreur de division par zéro s\'est produite') +else: + print('Je m\'exécute généralement avec le bloc try') +finally: + print('Je m\'exécute toujours.') +``` + +```sh +Entrez votre nom : Asabeneh +Année de naissance : 1920 +Vous êtes Asabeneh. Et vous avez 99 ans. +Je m'exécute généralement avec le bloc try +Je m'exécute toujours. +``` + +On peut aussi raccourcir le code ci-dessus comme suit : + +```py +try: + name = input('Entrez votre nom : ') + year_born = input('Année de naissance : ') + age = 2019 - int(year_born) + print(f'Vous êtes {name}. Et vous avez {age} ans.') +except Exception as e: + print(e) + +``` + +## Empaquetage et dépaquetage d'arguments en Python + +Nous utilisons deux opérateurs : + +- \* pour les tuples +- \*\* pour les dictionnaires + +Prenons l'exemple ci-dessous. Elle ne prend que des arguments, mais nous avons une liste. Nous pouvons dépaqueter la liste et la transformer en arguments. + +### Dépaquetage + +#### Dépaquetage de listes + +```py +def sum_of_five_nums(a, b, c, d, e): + return a + b + c + d + e + +lst = [1, 2, 3, 4, 5] +print(sum_of_five_nums(lst)) # TypeError: sum_of_five_nums() missing 4 required positional arguments: 'b', 'c', 'd', and 'e' +``` + +Quand nous exécutons ce code, il lève une erreur, car cette fonction prend des nombres (pas une liste) comme arguments. Dépaquetons/déstructurons la liste. + +```py +def sum_of_five_nums(a, b, c, d, e): + return a + b + c + d + e + +lst = [1, 2, 3, 4, 5] +print(sum_of_five_nums(*lst)) # 15 +``` + +On peut aussi utiliser le dépaquetage dans la fonction intégrée range qui attend un début et une fin. + +```py +numbers = range(2, 7) # appel normal avec des arguments séparés +print(list(numbers)) # [2, 3, 4, 5, 6] +args = [2, 7] +numbers = range(*args) # appel avec des arguments dépaquetés depuis une liste +print(numbers) # [2, 3, 4, 5,6] + +``` + +Une liste ou un tuple peut aussi être dépaqueté comme ceci : + +```py +countries = ['Finland', 'Sweden', 'Norway', 'Denmark', 'Iceland'] +fin, sw, nor, *rest = countries +print(fin, sw, nor, rest) # Finland Sweden Norway ['Denmark', 'Iceland'] +numbers = [1, 2, 3, 4, 5, 6, 7] +one, *middle, last = numbers +print(one, middle, last) # 1 [2, 3, 4, 5, 6] 7 +``` + +#### Dépaquetage de dictionnaires + +```py +def unpacking_person_info(name, country, city, age): + return f'{name} vit en {country}, {city}. Il a {age} ans.' +dct = {'name':'Asabeneh', 'country':'Finland', 'city':'Helsinki', 'age':250} +print(unpacking_person_info(**dct)) # Asabeneh vit en Finlande, Helsinki. Il a 250 ans. +``` + +### Empaquetage + +Parfois, on ne sait jamais combien d'arguments doivent être passés à une fonction Python. Nous pouvons utiliser la méthode d'empaquetage pour permettre à notre fonction de prendre un nombre illimité ou arbitraire d'arguments. + +### Empaquetage de listes + +```py +def sum_all(*args): + s = 0 + for i in args: + s += i + return s +print(sum_all(1, 2, 3)) # 6 +print(sum_all(1, 2, 3, 4, 5, 6, 7)) # 28 +``` + +#### Empaquetage de dictionnaires + +```py +def packing_person_info(**kwargs): + # check the type of kwargs and it is a dict type + # print(type(kwargs)) + # Printing dictionary items + for key in kwargs: + print(f"{key} = {kwargs[key]}") + return kwargs + +print(packing_person_info(name="Asabeneh", + country="Finland", city="Helsinki", age=250)) +``` + +```sh +name = Asabeneh +country = Finland +city = Helsinki +age = 250 +{'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250} +``` + +## Décomposition en Python + +Comme en JavaScript, la dispersion (spreading) est possible en Python. Regardons un exemple ci-dessous : + +```py +lst_one = [1, 2, 3] +lst_two = [4, 5, 6, 7] +lst = [0, *lst_one, *lst_two] +print(lst) # [0, 1, 2, 3, 4, 5, 6, 7] +country_lst_one = ['Finland', 'Sweden', 'Norway'] +country_lst_two = ['Denmark', 'Iceland'] +nordic_countries = [*country_lst_one, *country_lst_two] +print(nordic_countries) # ['Finland', 'Sweden', 'Norway', 'Denmark', 'Iceland'] +``` + +## Enumerate + +Si nous voulons connaître l'indice d'une liste, nous utilisons la fonction intégrée _enumerate_ pour obtenir l'indice de chaque élément de la liste. + +```py +for index, item in enumerate([20, 30, 40]): + print(index, item) +``` + +```py +countries = ['Finland', 'Sweden', 'Norway', 'Denmark', 'Iceland'] +for index, i in enumerate(countries): + if i == 'Finland': + print(f'Le pays {i} a été trouvé à l\'index {index}') +``` + +```sh +Le pays Finland a été trouvé à l'index 0. +``` + +## Zip + +Parfois, nous souhaitons combiner des listes en les parcourant. Voir l'exemple ci-dessous : + +```py +fruits = ['banana', 'orange', 'mango', 'lemon', 'lime'] +vegetables = ['Tomato', 'Potato', 'Cabbage','Onion', 'Carrot'] +fruits_and_veges = [] +for f, v in zip(fruits, vegetables): + fruits_and_veges.append({'fruit':f, 'veg':v}) + +print(fruits_and_veges) +``` + +```sh +[{'fruit': 'banana', 'veg': 'Tomato'}, {'fruit': 'orange', 'veg': 'Potato'}, {'fruit': 'mango', 'veg': 'Cabbage'}, {'fruit': 'lemon', 'veg': 'Onion'}, {'fruit': 'lime', 'veg': 'Carrot'}] +``` + +🌕 Vous êtes déterminé. Vous avez franchi 17 étapes vers la grandeur. Faites maintenant quelques exercices pour votre cerveau et vos muscles. + +## Exercices : Jour 17 + +1. names = ['Finland', 'Sweden', 'Norway','Denmark','Iceland', 'Estonia','Russia']. Dépaquetez les cinq premiers pays et stockez-les dans une variable nordic_countries, stockez Estonia et Russia dans es et ru respectivement. + + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 16](./16_python_datetime_fr.md) | [Jour 18 >>](./18_regular_expressions_fr.md) diff --git a/French/18_regular_expressions_fr.md b/French/18_regular_expressions_fr.md new file mode 100644 index 000000000..c98eaf932 --- /dev/null +++ b/French/18_regular_expressions_fr.md @@ -0,0 +1,459 @@ +
+

30 Jours de Python : Jour 18 - Expressions régulières

+ + + + + Twitter Follow + + + Auteur : + Asabeneh Yetayeh
+ Première édition : 22 nov - 22 déc 2019 + +
+ + +[<< Jour 17](./17_exception_handling_fr.md) | [Jour 19 >>](./19_file_handling_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 18](#-jour-18) + - [Expressions régulières](#expressions-régulières) + - [Le module *re*](#le-module-re) + - [Méthodes du module *re*](#méthodes-du-module-re) + - [Match](#match) + - [Search](#search) + - [Rechercher toutes les correspondances avec *findall*](#rechercher-toutes-les-correspondances-avec-findall) + - [Remplacer une sous-chaîne](#remplacer-une-sous-chaîne) + - [Fractionner du texte avec RegEx Split](#fractionner-du-texte-avec-regex-split) + - [Écrire des motifs RegEx](#écrire-des-motifs-regex) + - [Crochets](#crochets) + - [Caractère d'échappement(\\) dans RegEx](#caractère-déchappement-dans-regex) + - [Une ou plusieurs fois(+)](#une-ou-plusieurs-fois) + - [Point(.)](#point) + - [Zéro ou plusieurs fois(*)](#zéro-ou-plusieurs-fois) + - [Zéro ou une fois(?)](#zéro-ou-une-fois) + - [Quantificateur dans RegEx](#quantificateur-dans-regex) + - [Accent circonflexe ^](#accent-circonflexe-) + - [💻 Exercices : Jour 18](#-exercices--jour-18) + - [Exercices : Niveau 1](#exercices--niveau-1) + - [Exercices : Niveau 2](#exercices--niveau-2) + - [Exercices : Niveau 3](#exercices--niveau-3) + +# 📘 Jour 18 + +## Expressions régulières + +Une expression régulière (RegEx) est une chaîne de texte spéciale qui aide à trouver des motifs dans les données. Une RegEx peut être utilisée pour vérifier si un motif existe dans un type de données différent. Pour utiliser RegEx en Python, nous devons d'abord importer le module RegEx appelé *re*. + +### Le module *re* + +Après avoir importé le module, nous pouvons l'utiliser pour détecter ou trouver des motifs. + +```py +import re +``` + +### Méthodes du module *re* + +Pour trouver un motif, nous utilisons différents ensembles de caractères *re* qui permettent de rechercher une correspondance dans une chaîne. + +- *re.match()* : recherche uniquement au début de la première ligne de la chaîne et retourne les objets correspondants s'ils sont trouvés, sinon retourne None. +- *re.search* : retourne un objet match s'il y a une correspondance quelque part dans la chaîne, y compris dans les chaînes multilignes. +- *re.findall* : retourne une liste contenant toutes les correspondances. +- *re.split* : prend une chaîne, la divise aux points de correspondance, retourne une liste. +- *re.sub* : remplace une ou plusieurs correspondances dans une chaîne. + +#### Match + +```py +# syntaxe +re.match(substring, string, re.I) +# substring est une chaîne ou un motif, string est le texte dans lequel on cherche un motif, re.I ignore la casse +``` + +```py +import re + +txt = 'I love to teach python and javaScript' +# Retourne un objet avec span et match +match = re.match('I love to teach', txt, re.I) +print(match) # +# On peut obtenir la position de début et de fin de la correspondance sous forme de tuple avec span +span = match.span() +print(span) # (0, 15) +# Trouvons les positions de début et de fin à partir du span +start, end = span +print(start, end) # 0 15 +substring = txt[start:end] +print(substring) # I love to teach +``` + +Comme vous pouvez le voir dans l'exemple ci-dessus, le motif que nous recherchons (ou la sous-chaîne que nous recherchons) est *I love to teach*. La fonction match retourne un objet **uniquement** si le texte commence par le motif. + +```py +import re + +txt = 'I love to teach python and javaScript' +match = re.match('I like to teach', txt, re.I) +print(match) # None +``` + +La chaîne ne commence pas par *I like to teach*, donc il n'y a pas eu de correspondance et la méthode match a retourné None. + +#### Search + +```py +# syntaxe +re.search(substring, string, re.I) +# substring est un motif, string est le texte dans lequel on cherche un motif, re.I est le drapeau d'ignorance de la casse +``` + +```py +import re + +txt = '''Python is the most beautiful language that a human being has ever created. +I recommend python for a first programming language''' + +# Retourne un objet avec span et match +match = re.search('first', txt, re.I) +print(match) # +# On peut obtenir la position de début et de fin de la correspondance sous forme de tuple avec span +span = match.span() +print(span) # (100, 105) +# Trouvons les positions de début et de fin à partir du span +start, end = span +print(start, end) # 100 105 +substring = txt[start:end] +print(substring) # first +``` + +Comme vous pouvez le voir, search est bien meilleur que match car il peut chercher le motif dans tout le texte. Search retourne un objet match avec la première correspondance trouvée, sinon il retourne *None*. Une fonction *re* bien meilleure est *findall*. Cette fonction vérifie le motif dans toute la chaîne et retourne toutes les correspondances sous forme de liste. + +#### Rechercher toutes les correspondances avec *findall* + +*findall()* retourne toutes les correspondances sous forme de liste. + +```py +txt = '''Python is the most beautiful language that a human being has ever created. +I recommend python for a first programming language''' + +# Retourne une liste +matches = re.findall('language', txt, re.I) +print(matches) # ['language', 'language'] +``` + +Comme vous pouvez le voir, le mot *language* a été trouvé deux fois dans la chaîne. Pratiquons un peu plus. +Maintenant, cherchons à la fois les mots Python et python dans la chaîne : + +```py +txt = '''Python is the most beautiful language that a human being has ever created. +I recommend python for a first programming language''' + +# Retourne une liste +matches = re.findall('python', txt, re.I) +print(matches) # ['Python', 'python'] + +``` + +Puisque nous utilisons *re.I*, les lettres minuscules et majuscules sont incluses. Si nous n'avons pas le drapeau re.I, nous devrons écrire notre motif différemment. Vérifions cela : + +```py +txt = '''Python is the most beautiful language that a human being has ever created. +I recommend python for a first programming language''' + +matches = re.findall('Python|python', txt) +print(matches) # ['Python', 'python'] + +# +matches = re.findall('[Pp]ython', txt) +print(matches) # ['Python', 'python'] + +``` + +#### Remplacer une sous-chaîne + +```py +txt = '''Python is the most beautiful language that a human being has ever created. +I recommend python for a first programming language''' + +match_replaced = re.sub('Python|python', 'JavaScript', txt, re.I) +print(match_replaced) # JavaScript is the most beautiful language that a human being has ever created.I recommend python for a first programming language +# OU +match_replaced = re.sub('[Pp]ython', 'JavaScript', txt, re.I) +print(match_replaced) # JavaScript is the most beautiful language that a human being has ever created.I recommend python for a first programming language +``` + +Ajoutons un exemple supplémentaire. La chaîne suivante est vraiment difficile à lire à moins de supprimer le symbole %. Remplacer % par une chaîne vide nettoiera le texte. + +```py + +txt = '''%I a%m te%%a%%che%r% a%n%d %% I l%o%ve te%ach%ing. +T%he%re i%s n%o%th%ing as r%ewarding a%s e%duc%at%i%ng a%n%d e%m%p%ow%er%ing p%e%o%ple. +I fo%und te%a%ching m%ore i%n%t%er%%es%ting t%h%an any other %jobs. +D%o%es thi%s m%ot%iv%a%te %y%o%u to b%e a t%e%a%cher?''' + +matches = re.sub('%', '', txt) +print(matches) +``` + +```sh +I am teacher and I love teaching. +There is nothing as rewarding as educating and empowering people. +I found teaching more interesting than any other jobs. Does this motivate you to be a teacher? +``` + +## Fractionner du texte avec RegEx Split + +```py +txt = '''I am teacher and I love teaching. +There is nothing as rewarding as educating and empowering people. +I found teaching more interesting than any other jobs. +Does this motivate you to be a teacher?''' +print(re.split('\n', txt)) # split en utilisant \n - symbole de fin de ligne +``` + +```sh +['I am teacher and I love teaching.', 'There is nothing as rewarding as educating and empowering people.', 'I found teaching more interesting than any other jobs.', 'Does this motivate you to be a teacher?'] +``` + +## Écrire des motifs RegEx + +Pour déclarer une variable chaîne, nous utilisons des guillemets simples ou doubles. Pour déclarer une variable RegEx, on utilise *r''*. +Le motif suivant identifie uniquement apple en minuscules ; pour le rendre insensible à la casse, nous devons soit réécrire notre motif, soit ajouter un drapeau. + +```py +import re + +regex_pattern = r'apple' +txt = 'Apple and banana are fruits. An old cliche says an apple a day a doctor way has been replaced by a banana a day keeps the doctor far far away. ' +matches = re.findall(regex_pattern, txt) +print(matches) # ['apple'] + +# Pour rendre insensible à la casse, ajoutons un drapeau +matches = re.findall(regex_pattern, txt, re.I) +print(matches) # ['Apple', 'apple'] +# ou nous pouvons utiliser une méthode d'ensemble de caractères +regex_pattern = r'[Aa]pple' # cela signifie que la première lettre peut être Apple ou apple +matches = re.findall(regex_pattern, txt) +print(matches) # ['Apple', 'apple'] + +``` + +* [] : Un ensemble de caractères + - [a-c] signifie a, b ou c + - [a-z] signifie n'importe quelle lettre de a à z + - [A-Z] signifie n'importe quel caractère de A à Z + - [0-3] signifie 0, 1, 2 ou 3 + - [0-9] signifie n'importe quel nombre de 0 à 9 + - [A-Za-z0-9] n'importe quel caractère unique, c'est-à-dire a à z, A à Z ou 0 à 9 +- \\ : sert à échapper les caractères spéciaux + - \d signifie : correspond là où la chaîne contient des chiffres (nombres de 0 à 9) + - \D signifie : correspond là où la chaîne ne contient pas de chiffres +- . : n'importe quel caractère sauf le caractère de nouvelle ligne (\n) +- ^ : commence par + - r'^substring' ex. r'^love', une phrase qui commence par le mot love + - r'[^abc] signifie pas a, pas b, pas c +- $ : se termine par + - r'substring$' ex. r'love$', une phrase qui se termine par le mot love +- * : zéro ou plusieurs fois + - r'[a]*' signifie que a est facultatif ou peut apparaître plusieurs fois +- + : une ou plusieurs fois + - r'[a]+' signifie au moins une fois (ou plus) +- ? : zéro ou une fois + - r'[a]?' signifie zéro fois ou une fois +- {3} : exactement 3 caractères +- {3,} : au moins 3 caractères +- {3,8} : 3 à 8 caractères +- | : soit l'un soit l'autre + - r'apple|banana' signifie soit apple, soit banana +- () : capture et groupe + +![Aide-mémoire des expressions régulières](../images/regex.png) + +Utilisons des exemples pour clarifier les métacaractères ci-dessus. + +### Crochets + +Utilisons les crochets pour inclure les minuscules et les majuscules. + +```py +regex_pattern = r'[Aa]pple' # ce crochet signifie soit A soit a +txt = 'Apple and banana are fruits. An old cliche says an apple a day a doctor way has been replaced by a banana a day keeps the doctor far far away.' +matches = re.findall(regex_pattern, txt) +print(matches) # ['Apple', 'apple'] +``` + +Si nous voulons chercher banana, nous écrivons le motif comme suit : + +```py +regex_pattern = r'[Aa]pple|[Bb]anana' # ce crochet signifie soit A soit a +txt = 'Apple and banana are fruits. An old cliche says an apple a day a doctor way has been replaced by a banana a day keeps the doctor far far away.' +matches = re.findall(regex_pattern, txt) +print(matches) # ['Apple', 'banana', 'apple', 'banana'] +``` + +En utilisant les crochets et l'opérateur ou, nous avons réussi à extraire Apple, apple, Banana et banana. + +### Caractère d'échappement(\\) dans RegEx + +```py +regex_pattern = r'\d' # d est un caractère spécial qui signifie chiffres +txt = 'This regular expression example was made on December 6, 2019 and revised on July 8, 2021' +matches = re.findall(regex_pattern, txt) +print(matches) # ['6', '2', '0', '1', '9', '8', '2', '0', '2', '1'], ce n'est pas ce que nous voulons +``` + +### Une ou plusieurs fois(+) + +```py +regex_pattern = r'\d+' # d est un caractère spécial qui signifie chiffres, + signifie une ou plusieurs fois +txt = 'This regular expression example was made on December 6, 2019 and revised on July 8, 2021' +matches = re.findall(regex_pattern, txt) +print(matches) # ['6', '2019', '8', '2021'] - c'est mieux ! +``` + +### Point(.) + +```py +regex_pattern = r'[a].' # ce crochet signifie a et . signifie n'importe quel caractère sauf nouvelle ligne +txt = '''Apple and banana are fruits''' +matches = re.findall(regex_pattern, txt) +print(matches) # ['an', 'an', 'an', 'a ', 'ar'] + +regex_pattern = r'[a].+' # . n'importe quel caractère, + n'importe quel caractère une ou plusieurs fois +matches = re.findall(regex_pattern, txt) +print(matches) # ['and banana are fruits'] +``` + +### Zéro ou plusieurs fois(\*) + +Zéro ou plusieurs fois. Le motif peut ne pas apparaître ou peut apparaître plusieurs fois. + +```py +regex_pattern = r'[a].*' # . n'importe quel caractère, * n'importe quel caractère zéro ou plusieurs fois +txt = '''Apple and banana are fruits''' +matches = re.findall(regex_pattern, txt) +print(matches) # ['and banana are fruits'] +``` + +### Zéro ou une fois(?) + +Zéro ou une fois. Le motif peut ne pas apparaître ou peut apparaître une fois. + +```py +txt = '''I am not sure if there is a convention how to write the word e-mail. +Some people write it as email others may write it as Email or E-mail.''' +regex_pattern = r'[Ee]-?mail' # ? signifie ici que '-' est facultatif +matches = re.findall(regex_pattern, txt) +print(matches) # ['e-mail', 'email', 'Email', 'E-mail'] +``` + +### Quantificateur dans RegEx + +Nous pouvons spécifier la longueur de la sous-chaîne que nous recherchons dans un texte, en utilisant des accolades. Imaginons que nous cherchions une sous-chaîne d'une longueur de 4 caractères : + +```py +txt = 'This regular expression example was made on December 6, 2019 and revised on July 8, 2021' +regex_pattern = r'\d{4}' # exactement quatre fois +matches = re.findall(regex_pattern, txt) +print(matches) # ['2019', '2021'] + +txt = 'This regular expression example was made on December 6, 2019 and revised on July 8, 2021' +regex_pattern = r'\d{1,4}' +matches = re.findall(regex_pattern, txt) +print(matches) # ['6', '2019', '8', '2021'] +``` + +### Accent circonflexe ^ + +- Commence par + +```py +txt = 'This regular expression example was made on December 6, 2019 and revised on July 8, 2021' +regex_pattern = r'^This' # ^ signifie commence par +matches = re.findall(regex_pattern, txt) +print(matches) # ['This'] +``` + +- Négation + +```py +txt = 'This regular expression example was made on December 6, 2019 and revised on July 8, 2021' +regex_pattern = r'[^A-Za-z ]+' # ^ dans un ensemble de caractères signifie négation, pas A à Z, pas a à z, pas d'espace +matches = re.findall(regex_pattern, txt) +print(matches) # ['6,', '2019', '8', '2021'] +``` + +## 💻 Exercices : Jour 18 + +### Exercices : Niveau 1 + + 1. Quel est le mot le plus fréquent dans le paragraphe suivant ? + +```py + paragraph = 'I love teaching. If you do not love teaching what else can you love. I love Python if you do not love something which can give you all the capabilities to develop an application what else can you love. +``` + +```sh + [ + (6, 'love'), + (5, 'you'), + (3, 'can'), + (2, 'what'), + (2, 'teaching'), + (2, 'not'), + (2, 'else'), + (2, 'do'), + (2, 'I'), + (1, 'which'), + (1, 'to'), + (1, 'the'), + (1, 'something'), + (1, 'if'), + (1, 'give'), + (1, 'develop'), + (1, 'capabilities'), + (1, 'application'), + (1, 'an'), + (1, 'all'), + (1, 'Python'), + (1, 'If') + ] +``` + +2. La position de certaines particules sur l'axe horizontal x sont -12, -4, -3 et -1 dans la direction négative, 0 à l'origine, 4 et 8 dans la direction positive. Extrayez ces nombres de ce texte complet et trouvez la distance entre les deux particules les plus éloignées. + +```py +points = ['-12', '-4', '-3', '-1', '0', '4', '8'] +sorted_points = [-12, -4, -3, -1, -1, 0, 2, 4, 8] +distance = 8 -(-12) # 20 +``` + +### Exercices : Niveau 2 + +1. Écrivez un motif qui identifie si une chaîne est une variable Python valide. + + ```sh + is_valid_variable('first_name') # True + is_valid_variable('first-name') # False + is_valid_variable('1first_name') # False + is_valid_variable('firstname') # True + ``` + +### Exercices : Niveau 3 + +1. Nettoyez le texte suivant. Après nettoyage, comptez les trois mots les plus fréquents de la chaîne. + + ```py + sentence = '''%I $am@% a %tea@cher%, &and& I lo%#ve %tea@ching%;. There $is nothing; &as& mo@re rewarding as educa@ting &and& @emp%o@wering peo@ple. ;I found tea@ching m%o@re interesting tha@n any other %jo@bs. %Do@es thi%s mo@tivate yo@u to be a tea@cher!?''' + + print(clean_text(sentence)) + I am a teacher and I love teaching There is nothing as more rewarding as educating and empowering people I found teaching more interesting than any other jobs Does this motivate you to be a teacher + print(most_frequent_words(cleaned_text)) # [(3, 'I'), (2, 'teaching'), (2, 'teacher')] + ``` + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 17](./17_exception_handling_fr.md) | [Jour 19 >>](./19_file_handling_fr.md) diff --git a/French/19_file_handling_fr.md b/French/19_file_handling_fr.md new file mode 100644 index 000000000..405dba2fd --- /dev/null +++ b/French/19_file_handling_fr.md @@ -0,0 +1,517 @@ +
+

30 Jours de Python : Jour 19 - Gestion de fichiers

+ + + + + Twitter Follow + +Auteur : +Asabeneh Yetayeh
+Deuxième édition : juillet 2021 + +
+ +[<< Jour 18](./18_regular_expressions_fr.md) | [Jour 20 >>](./20_python_package_manager_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 19](#-jour-19) + - [Gestion de fichiers](#gestion-de-fichiers) + - [Ouverture de fichiers en lecture](#ouverture-de-fichiers-en-lecture) + - [Ouverture de fichiers en écriture et mise à jour](#ouverture-de-fichiers-en-écriture-et-mise-à-jour) + - [Suppression de fichiers](#suppression-de-fichiers) + - [Types de fichiers](#types-de-fichiers) + - [Fichier avec l'extension txt](#fichier-avec-lextension-txt) + - [Fichier avec l'extension json](#fichier-avec-lextension-json) + - [Convertir du JSON en dictionnaire](#convertir-du-json-en-dictionnaire) + - [Convertir un dictionnaire en JSON](#convertir-un-dictionnaire-en-json) + - [Sauvegarder au format JSON](#sauvegarder-au-format-json) + - [Fichier avec l'extension csv](#fichier-avec-lextension-csv) + - [Fichier avec l'extension xlsx](#fichier-avec-lextension-xlsx) + - [Fichier avec l'extension xml](#fichier-avec-lextension-xml) + - [💻 Exercices : Jour 19](#-exercices-jour-19) + - [Exercices : Niveau 1](#exercices-niveau-1) + - [Exercices : Niveau 2](#exercices-niveau-2) + - [Exercices : Niveau 3](#exercices-niveau-3) + +# 📘 Jour 19 + +## Gestion de fichiers + +Jusqu'à présent, nous avons vu différents types de données Python. Nous stockons généralement nos données dans différents formats de fichiers. En plus de la gestion des fichiers, nous verrons également différents formats de fichiers (.txt, .json, .xml, .csv, .tsv, .excel) dans cette section. Commençons par nous familiariser avec la gestion des fichiers au format courant (.txt). + +La gestion des fichiers est une partie importante de la programmation qui nous permet de créer, lire, mettre à jour et supprimer des fichiers. En Python, pour manipuler des données, nous utilisons la fonction intégrée _open()_. + +```py +# Syntaxe +open('fichier', mode) # mode(r, a, w, x, t, b) peut être lecture, écriture, mise à jour +``` + +- "r" - Lecture (Read) - Valeur par défaut. Ouvre un fichier en lecture, retourne une erreur si le fichier n'existe pas +- "a" - Ajout (Append) - Ouvre un fichier pour ajout, crée le fichier s'il n'existe pas +- "w" - Écriture (Write) - Ouvre un fichier en écriture, crée le fichier s'il n'existe pas +- "x" - Création (Create) - Crée le fichier spécifié, retourne une erreur si le fichier existe +- "t" - Texte (Text) - Valeur par défaut. Mode texte +- "b" - Binaire (Binary) - Mode binaire (ex. images) + +### Ouverture de fichiers en lecture + +Le mode par défaut de _open_ est la lecture, donc nous n'avons pas à spécifier 'r' ou 'rt'. J'ai créé et sauvegardé un fichier nommé reading_file_example.txt dans le dossier files. Voyons comment cela se fait : + +```py +f = open('./files/reading_file_example.txt') +print(f) # <_io.TextIOWrapper name='./files/reading_file_example.txt' mode='r' encoding='UTF-8'> +``` + +Comme vous pouvez le voir dans l'exemple ci-dessus, j'ai affiché le fichier ouvert et il a donné quelques informations à son sujet. Un fichier ouvert dispose de différentes méthodes de lecture : _read()_, _readline_, _readlines_. Un fichier ouvert doit être fermé avec la méthode _close()_. + +- _read()_ : lit tout le texte sous forme de chaîne. Si nous voulons limiter le nombre de caractères à lire, nous pouvons le limiter en passant une valeur entière à la méthode *read(nombre)*. + +```py +f = open('./files/reading_file_example.txt') +txt = f.read() +print(type(txt)) +print(txt) +f.close() +``` + +```sh +# sortie + +This is an example to show how to open a file and read. +This is the second line of the text. +``` + +Au lieu d'afficher tout le texte, affichons les 10 premiers caractères du fichier texte. + +```py +f = open('./files/reading_file_example.txt') +txt = f.read(10) +print(type(txt)) +print(txt) +f.close() +``` + +```sh +# sortie + +This is an +``` + +- _readline()_ : lit uniquement la première ligne + +```py +f = open('./files/reading_file_example.txt') +line = f.readline() +print(type(line)) +print(line) +f.close() +``` + +```sh +# sortie + +This is an example to show how to open a file and read. +``` + +- _readlines()_ : lit tout le texte ligne par ligne et retourne une liste de lignes + +```py +f = open('./files/reading_file_example.txt') +lines = f.readlines() +print(type(lines)) +print(lines) +f.close() +``` + +```sh +# sortie + +['This is an example to show how to open a file and read.\n', 'This is the second line of the text.'] +``` + +Une autre façon d'obtenir toutes les lignes sous forme de liste est d'utiliser _splitlines()_ : + +```py +f = open('./files/reading_file_example.txt') +lines = f.read().splitlines() +print(type(lines)) +print(lines) +f.close() +``` + +```sh +# sortie + +['This is an example to show how to open a file and read.', 'This is the second line of the text.'] +``` + +Après avoir ouvert un fichier, nous devrions le fermer. Il y a une forte tendance à oublier de les fermer. Il existe une nouvelle façon d'ouvrir les fichiers en utilisant _with_ - il ferme les fichiers tout seul. Réécrivons l'exemple précédent avec la méthode _with_ : + +```py +with open('./files/reading_file_example.txt') as f: + lines = f.read().splitlines() + print(type(lines)) + print(lines) +``` + +```sh +# sortie + +['This is an example to show how to open a file and read.', 'This is the second line of the text.'] +``` + +### Ouverture de fichiers en écriture et mise à jour + +Pour écrire dans un fichier existant, nous devons ajouter un mode comme paramètre à la fonction _open()_ : + +- "a" - ajout (append) - ajoute à la fin du fichier, si le fichier n'existe pas, il en crée un nouveau. +- "w" - écriture (write) - écrase tout contenu existant, si le fichier n'existe pas, il le crée. + +Ajoutons du texte au fichier que nous lisions : + +```py +with open('./files/reading_file_example.txt','a') as f: + f.write('This text has to be appended at the end') +``` + +La méthode ci-dessous crée un nouveau fichier, si le fichier n'existe pas : + +```py +with open('./files/writing_file_example.txt','w') as f: + f.write('This text will be written in a newly created file') +``` + +### Suppression de fichiers + +Nous avons vu dans la section précédente comment créer et supprimer un répertoire en utilisant le module _os_. Maintenant, si nous voulons supprimer un fichier, nous utilisons le module _os_. + +```py +import os +os.remove('./files/example.txt') + +``` + +Si le fichier n'existe pas, la méthode remove lèvera une erreur, il est donc bon d'utiliser une condition comme celle-ci : + +```py +import os +if os.path.exists('./files/example.txt'): + os.remove('./files/example.txt') +else: + print('Le fichier n\'existe pas') +``` + +## Types de fichiers + +### Fichier avec l'extension txt + +Le fichier avec l'extension _txt_ est une forme de données très courante et nous l'avons couvert dans la section précédente. Passons au fichier JSON. + +### Fichier avec l'extension json + +JSON signifie JavaScript Object Notation. En réalité, c'est un objet JavaScript ou un dictionnaire Python converti en chaîne de caractères. + +_Exemple :_ + +```py +# dictionnaire +personne_dct = { + "name":"Asabeneh", + "country":"Finland", + "city":"Helsinki", + "skills":["JavaScrip", "React","Python"] +} +# JSON : une chaîne représentant un dictionnaire +personne_json = "{'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'skills': ['JavaScrip', 'React', 'Python']}" + +# nous utilisons trois guillemets et plusieurs lignes pour le rendre plus lisible +personne_json = '''{ + "name":"Asabeneh", + "country":"Finland", + "city":"Helsinki", + "skills":["JavaScrip", "React","Python"] +}''' +``` + +### Convertir du JSON en dictionnaire + +Pour convertir du JSON en dictionnaire, nous importons d'abord le module json, puis nous utilisons la méthode _loads_. + +```py +import json +# JSON +personne_json = '''{ + "name": "Asabeneh", + "country": "Finland", + "city": "Helsinki", + "skills": ["JavaScrip", "React", "Python"] +}''' +# convertissons JSON en dictionnaire +personne_dct = json.loads(personne_json) +print(type(personne_dct)) +print(personne_dct) +print(personne_dct['name']) +``` + +```sh +# sortie + +{'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'skills': ['JavaScrip', 'React', 'Python']} +Asabeneh +``` + +### Convertir un dictionnaire en JSON + +Pour convertir un dictionnaire en JSON, nous utilisons la méthode _dumps_ du module json. + +```py +import json +# dictionnaire python +personne = { + "name": "Asabeneh", + "country": "Finland", + "city": "Helsinki", + "skills": ["JavaScrip", "React", "Python"] +} +# convertissons-le en json +personne_json = json.dumps(personne, indent=4) # indent peut être 2, 4, 8. Il embellit le json +print(type(personne_json)) +print(personne_json) +``` + +```sh +# sortie +# quand vous l'affichez, il n'a pas de guillemets, mais en réalité c'est une chaîne +# JSON n'a pas de type, c'est un type chaîne + +{ + "name": "Asabeneh", + "country": "Finland", + "city": "Helsinki", + "skills": [ + "JavaScrip", + "React", + "Python" + ] +} +``` + +### Sauvegarder au format JSON + +Nous pouvons également sauvegarder nos données sous forme de fichier json. Sauvegardons-le en utilisant les étapes suivantes. Pour écrire un fichier json, nous utilisons la méthode json.dump(), elle peut prendre un dictionnaire, un fichier de sortie, ensure_ascii et indent. + +```py +import json +# dictionnaire python +personne = { + "name": "Asabeneh", + "country": "Finland", + "city": "Helsinki", + "skills": ["JavaScrip", "React", "Python"] +} +with open('./files/json_example.json', 'w', encoding='utf-8') as f: + json.dump(personne, f, ensure_ascii=False, indent=4) +``` + +Dans le code ci-dessus, nous utilisons l'encodage et l'indentation. L'indentation rend le fichier json facile à lire. + +### Fichier avec l'extension csv + +CSV signifie Comma Separated Values (valeurs séparées par des virgules). CSV est un format de fichier simple utilisé pour stocker des données tabulaires, comme un tableur ou une base de données. CSV est un format de données très courant en science des données. + +**Exemple :** + +```csv +"name","country","city","skills" +"Asabeneh","Finland","Helsinki","JavaScript" +``` + +**Exemple :** + +```py +import csv +with open('./files/csv_example.csv') as f: + csv_reader = csv.reader(f, delimiter=',') # nous utilisons la méthode reader pour lire le csv + line_count = 0 + for row in csv_reader: + if line_count == 0: + print(f'Noms des colonnes : {", ".join(row)}') + line_count += 1 + else: + print( + f'\t{row[0]} est un enseignant. Il vit à {row[1]}, {row[2]}.') + line_count += 1 + print(f'Nombre de lignes : {line_count}') +``` + +```sh +# sortie : +Noms des colonnes : name, country, city, skills +Nombre de lignes : 1 + Asabeneh est un enseignant. Il vit à Finland, Helsinki. +Nombre de lignes : 2 +``` + +### Fichier avec l'extension xlsx + +Pour lire des fichiers Excel, nous devons installer le paquet _xlrd_. Nous aborderons cela après avoir couvert l'installation de paquets avec pip. + +```py +import xlrd +classeur_excel = xlrd.open_workbook('sample.xls') +print(classeur_excel.nsheets) +print(classeur_excel.sheet_names) +``` + +### Fichier avec l'extension xml + +XML est un autre format de données structurées qui ressemble à HTML. En XML, les balises ne sont pas prédéfinies. La première ligne est une déclaration XML. La balise person est la racine du XML. La personne a un attribut gender. + +**Exemple : XML** + +```xml + + + Asabeneh + Finland + Helsinki + + JavaScrip + React + Python + + +``` + +Pour plus d'informations sur la lecture d'un fichier XML, consultez la [documentation](https://docs.python.org/2/library/xml.etree.elementtree.html). + +```py +import xml.etree.ElementTree as ET +tree = ET.parse('./files/xml_example.xml') +root = tree.getroot() +print('Balise racine :', root.tag) +print('Attribut :', root.attrib) +for child in root: + print('champ : ', child.tag) +``` + +```sh +# sortie +Balise racine : person +Attribut : {'gender': 'male'} +champ : name +champ : country +champ : city +champ : skills +``` + +🌕 Vous faites de grands progrès. Gardez votre élan, continuez votre bon travail. Maintenant, faites quelques exercices pour votre cerveau et vos muscles. + +## 💻 Exercices : Jour 19 + +### Exercices : Niveau 1 + +1. Écrivez une fonction qui compte le nombre de lignes et le nombre de mots dans un texte. Tous les fichiers sont dans le dossier data : + 1) Lisez le fichier obama_speech.txt et comptez le nombre de lignes et de mots + 2) Lisez le fichier michelle_obama_speech.txt et comptez le nombre de lignes et de mots + 3) Lisez le fichier donald_speech.txt et comptez le nombre de lignes et de mots + 4) Lisez le fichier melina_trump_speech.txt et comptez le nombre de lignes et de mots +2. Lisez le fichier de données countries_data.json dans le dossier data, créez une fonction qui trouve les dix langues les plus parlées + + ```py + # Votre sortie devrait ressembler à ceci + print(most_spoken_languages(filename='./data/countries_data.json', 10)) + [(91, 'English'), + (45, 'French'), + (25, 'Arabic'), + (24, 'Spanish'), + (9, 'Russian'), + (9, 'Portuguese'), + (8, 'Dutch'), + (7, 'German'), + (5, 'Chinese'), + (4, 'Swahili'), + (4, 'Serbian')] + + # Votre sortie devrait ressembler à ceci + print(most_spoken_languages(filename='./data/countries_data.json', 3)) + [(91, 'English'), + (45, 'French'), + (25, 'Arabic')] + ``` + +3. Lisez le fichier de données countries_data.json dans le dossier data, créez une fonction qui crée une liste des dix pays les plus peuplés + + ```py + # Votre sortie devrait ressembler à ceci + print(most_populated_countries(filename='./data/countries_data.json', 10)) + + [ + {'country': 'China', 'population': 1377422166}, + {'country': 'India', 'population': 1295210000}, + {'country': 'United States of America', 'population': 323947000}, + {'country': 'Indonesia', 'population': 258705000}, + {'country': 'Brazil', 'population': 206135893}, + {'country': 'Pakistan', 'population': 194125062}, + {'country': 'Nigeria', 'population': 186988000}, + {'country': 'Bangladesh', 'population': 161006790}, + {'country': 'Russian Federation', 'population': 146599183}, + {'country': 'Japan', 'population': 126960000} + ] + + # Votre sortie devrait ressembler à ceci + + print(most_populated_countries(filename='./data/countries_data.json', 3)) + [ + {'country': 'China', 'population': 1377422166}, + {'country': 'India', 'population': 1295210000}, + {'country': 'United States of America', 'population': 323947000} + ] + ``` + +### Exercices : Niveau 2 + +1. Extrayez toutes les adresses e-mail entrantes sous forme de liste à partir du fichier email_exchange_big.txt. +2. Trouvez les mots les plus courants dans la langue anglaise. Appelez votre fonction find_most_common_words, elle prendra deux paramètres - une chaîne ou un fichier et un entier positif, indiquant le nombre de mots. Votre fonction retournera un tableau de tuples en ordre décroissant. Vérifiez la sortie. + +```py + # Votre sortie devrait ressembler à ceci + print(find_most_common_words('sample.txt', 10)) + [(10, 'the'), + (8, 'be'), + (6, 'to'), + (6, 'of'), + (5, 'and'), + (4, 'a'), + (4, 'in'), + (3, 'that'), + (2, 'have'), + (2, 'I')] + + # Votre sortie devrait ressembler à ceci + print(find_most_common_words('sample.txt', 5)) + + [(10, 'the'), + (8, 'be'), + (6, 'to'), + (6, 'of'), + (5, 'and')] +``` + +3. Utilisez la fonction find_most_frequent_words pour trouver : + 1) Les dix mots les plus fréquents utilisés dans le discours d'[Obama](https://github.com/Asabeneh/30-Days-Of-Python/blob/master/data/obama_speech.txt) + 2) Les dix mots les plus fréquents utilisés dans le discours de [Michelle](https://github.com/Asabeneh/30-Days-Of-Python/blob/master/data/michelle_obama_speech.txt) + 3) Les dix mots les plus fréquents utilisés dans le discours de [Trump](https://github.com/Asabeneh/30-Days-Of-Python/blob/master/data/donald_speech.txt) + 4) Les dix mots les plus fréquents utilisés dans le discours de [Melina](https://github.com/Asabeneh/30-Days-Of-Python/blob/master/data/melina_trump_speech.txt) +4. Écrivez une application Python qui vérifie la similarité entre deux textes. Elle prend un fichier ou une chaîne comme paramètre et évaluera la similarité des deux textes. Par exemple, vérifiez la similarité entre les transcriptions du discours de [Michelle](https://github.com/Asabeneh/30-Days-Of-Python/blob/master/data/michelle_obama_speech.txt) et de [Melina](https://github.com/Asabeneh/30-Days-Of-Python/blob/master/data/melina_trump_speech.txt). Vous aurez besoin de quelques fonctions : une fonction pour nettoyer le texte (clean_text), une fonction pour supprimer les mots vides (remove_support_words) et enfin pour vérifier la similarité (check_text_similarity). La liste des [mots vides](https://github.com/Asabeneh/30-Days-Of-Python/blob/master/data/stop_words.py) se trouve dans le dossier data. +5. Trouvez les 10 mots les plus répétés dans le fichier romeo_and_juliet.txt +6. Lisez le fichier [hacker news csv](https://github.com/Asabeneh/30-Days-Of-Python/blob/master/data/hacker_news.csv) et trouvez : + 1) Comptez le nombre de lignes contenant python ou Python + 2) Comptez le nombre de lignes contenant JavaScript, javascript ou Javascript + 3) Comptez le nombre de lignes contenant Java et pas JavaScript + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 18](./18_regular_expressions_fr.md) | [Jour 20 >>](./20_python_package_manager_fr.md) diff --git a/French/20_python_package_manager_fr.md b/French/20_python_package_manager_fr.md new file mode 100644 index 000000000..d0724aeac --- /dev/null +++ b/French/20_python_package_manager_fr.md @@ -0,0 +1,459 @@ +
+

30 Jours de Python : Jour 20 - PIP

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+Deuxième édition : juillet 2021 + +
+ +[<< Jour 19](./19_file_handling_fr.md) | [Jour 21 >>](./21_classes_and_objects_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 20](#-jour-20) + - [Python PIP - Gestionnaire de paquets Python](#python-pip---gestionnaire-de-paquets-python) + - [Qu'est-ce que PIP ?](#quest-ce-que-pip-) + - [Installer PIP](#installer-pip) + - [Installer des paquets avec pip](#installer-des-paquets-avec-pip) + - [Désinstaller des paquets](#désinstaller-des-paquets) + - [Liste des paquets](#liste-des-paquets) + - [Afficher un paquet](#afficher-un-paquet) + - [PIP Freeze](#pip-freeze) + - [Lecture depuis une URL](#lecture-depuis-une-url) + - [Créer un paquet](#créer-un-paquet) + - [Plus d'informations sur les paquets](#plus-dinformations-sur-les-paquets) + - [Exercices : Jour 20](#exercices-jour-20) + +# 📘 Jour 20 + +## Python PIP - Gestionnaire de paquets Python + +### Qu'est-ce que PIP ? + +PIP signifie Preferred Installer Program (Programme d'installation préféré). Nous utilisons _pip_ pour installer différents paquets Python. +Un paquet est un module Python qui peut contenir un ou plusieurs modules ou d'autres paquets. Un module ou des modules que nous pouvons installer dans notre application est un paquet. +En programmation, nous n'avons pas à écrire chaque programme utilitaire, nous installons plutôt des paquets et les importons dans nos applications. + +### Installer PIP + +Si vous n'avez pas installé pip, installons-le maintenant. Allez dans votre terminal ou invite de commande et copiez-collez ceci : + +```sh +asabeneh@Asabeneh:~$ pip install pip +``` + +Vérifiez si pip est installé en tapant : + +```sh +pip --version +``` + +```py +asabeneh@Asabeneh:~$ pip --version +pip 21.1.3 from /usr/local/lib/python3.7/site-packages/pip (python 3.9.6) +``` + +Comme vous pouvez le voir, j'utilise pip version 21.1.3. Si vous voyez un numéro légèrement inférieur ou supérieur, cela signifie que pip est installé. + +Examinons quelques-uns des paquets utilisés dans la communauté Python à différentes fins. Juste pour vous informer qu'il existe de nombreux paquets disponibles pour différentes applications. + +### Installer des paquets avec pip + +Essayons d'installer _numpy_, appelé numeric python. C'est l'un des paquets les plus populaires dans la communauté du machine learning et de la data science. + +- NumPy est le paquet fondamental pour le calcul scientifique avec Python. Il contient entre autres : + - un puissant objet tableau N-dimensionnel + - des fonctions sophistiquées de diffusion (broadcasting) + - des outils pour intégrer du code C/C++ et Fortran + - des fonctionnalités utiles d'algèbre linéaire, de transformée de Fourier et de nombres aléatoires + +```sh +asabeneh@Asabeneh:~$ pip install numpy +``` + +Commençons à utiliser numpy. Ouvrez votre interpréteur Python interactif, tapez python puis importez numpy comme suit : + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> import numpy +>>> numpy.version.version +'1.20.1' +>>> lst = [1, 2, 3,4, 5] +>>> np_arr = numpy.array(lst) +>>> np_arr +array([1, 2, 3, 4, 5]) +>>> len(np_arr) +5 +>>> np_arr * 2 +array([ 2, 4, 6, 8, 10]) +>>> np_arr + 2 +array([3, 4, 5, 6, 7]) +>>> +``` + +Pandas est une bibliothèque open source sous licence BSD qui fournit des structures de données haute performance et faciles à utiliser ainsi que des outils d'analyse de données pour le langage de programmation Python. Installons le grand frère de numpy, _pandas_ : + +```sh +asabeneh@Asabeneh:~$ pip install pandas +``` + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> import pandas +``` + +Cette section ne porte pas sur numpy ni pandas, ici nous essayons d'apprendre comment installer des paquets et comment les importer. Si besoin, nous parlerons de différents paquets dans d'autres sections. + +Importons un module de navigateur web, qui peut nous aider à ouvrir n'importe quel site. Nous n'avons pas besoin d'installer ce module, il est déjà installé par défaut avec Python 3. Par exemple, si vous aimez ouvrir un certain nombre de sites web à n'importe quel moment ou si vous aimez planifier quelque chose, ce module _webbrowser_ peut être utilisé. + +```py +import webbrowser # module navigateur web pour ouvrir des sites + +# liste d'urls : python +url_lists = [ + 'http://www.python.org', + 'https://www.linkedin.com/in/asabeneh/', + 'https://github.com/Asabeneh', + 'https://twitter.com/Asabeneh', +] + +# ouvre la liste de sites ci-dessus dans un onglet différent +for url in url_lists: + webbrowser.open_new_tab(url) +``` + +### Désinstaller des paquets + +Si vous ne souhaitez pas conserver les paquets installés, vous pouvez les supprimer en utilisant la commande suivante. + +```sh +pip uninstall nom_paquet +``` + +### Liste des paquets + +Pour voir les paquets installés sur notre machine, nous pouvons utiliser pip suivi de list. + +```sh +pip list +``` + +### Afficher un paquet + +Pour afficher des informations sur un paquet : + +```sh +pip show nom_paquet +``` + +```sh +asabeneh@Asabeneh:~$ pip show pandas +Name: pandas +Version: 1.2.3 +Summary: Powerful data structures for data analysis, time series, and statistics +Home-page: http://pandas.pydata.org +Author: None +Author-email: None +License: BSD +Location: /usr/local/lib/python3.7/site-packages +Requires: python-dateutil, pytz, numpy +Required-by: +``` + +Si nous voulons encore plus de détails, ajoutez --verbose : + +```sh +asabeneh@Asabeneh:~$ pip show --verbose pandas +Name: pandas +Version: 1.2.3 +Summary: Powerful data structures for data analysis, time series, and statistics +Home-page: http://pandas.pydata.org +Author: None +Author-email: None +License: BSD +Location: /usr/local/lib/python3.7/site-packages +Requires: numpy, pytz, python-dateutil +Required-by: +Metadata-Version: 2.1 +Installer: pip +Classifiers: + Development Status :: 5 - Production/Stable + Environment :: Console + Operating System :: OS Independent + Intended Audience :: Science/Research + Programming Language :: Python + Programming Language :: Python :: 3 + Programming Language :: Python :: 3.5 + Programming Language :: Python :: 3.6 + Programming Language :: Python :: 3.7 + Programming Language :: Python :: 3.8 + Programming Language :: Cython + Topic :: Scientific/Engineering +Entry-points: + [pandas_plotting_backends] + matplotlib = pandas:plotting._matplotlib +``` + +### PIP Freeze + +Génère une liste des paquets Python installés avec leur version, et la sortie convient pour l'utiliser dans un fichier requirements. Un fichier requirements.txt est un fichier qui devrait contenir tous les paquets Python installés dans un projet Python. + +```sh +asabeneh@Asabeneh:~$ pip freeze +docutils==0.11 +Jinja2==2.7.2 +MarkupSafe==0.19 +Pygments==1.6 +Sphinx==1.2.2 +``` + +La commande pip freeze nous a donné les paquets utilisés, installés et leur version. Nous l'utilisons avec le fichier requirements.txt pour le déploiement. + +### Lecture depuis une URL + +Maintenant, vous êtes familier avec la façon de lire ou d'écrire sur un fichier situé sur votre machine locale. Parfois, nous aimerions lire depuis un site web en utilisant une URL ou depuis une API. +API signifie Application Program Interface (Interface de programmation d'application). C'est un moyen d'échanger des données structurées entre serveurs, principalement sous forme de données json. Pour ouvrir une connexion réseau, nous avons besoin d'un paquet appelé _requests_ - il permet d'ouvrir une connexion réseau et d'implémenter les opérations CRUD (create, read, update, delete). Dans cette section, nous ne couvrirons que la partie lecture (ou "get") du CRUD. + +Installons _requests_ : + +```py +asabeneh@Asabeneh:~$ pip install requests +``` + +Nous verrons les méthodes _get_, _status_code_, _headers_, _text_ et _json_ dans le module _requests_ : + - _get()_ : pour ouvrir une connexion réseau et récupérer des données depuis une URL - retourne un objet réponse + - _status_code_ : après avoir récupéré les données, nous pouvons vérifier le statut de l'opération (succès, erreur, etc.) + - _headers_ : pour vérifier les types d'en-têtes + - _text_ : pour extraire le texte de l'objet réponse récupéré + - _json_ : pour extraire des données json +Lisons un fichier txt depuis ce site : https://www.w3.org/TR/PNG/iso_8859-1.txt. + +```py +import requests # importation du module requests + +url = 'https://www.w3.org/TR/PNG/iso_8859-1.txt' # texte depuis un site web + +response = requests.get(url) # ouverture d'une connexion réseau et récupération de données +print(response) +print(response.status_code) # code de statut, succès : 200 +print(response.headers) # informations d'en-tête +print(response.text) # donne tout le texte de la page +``` + +```sh + +200 +{'date': 'Sun, 08 Dec 2019 18:00:31 GMT', 'last-modified': 'Fri, 07 Nov 2003 05:51:11 GMT', 'etag': '"17e9-3cb82080711c0;50c0b26855880-gzip"', 'accept-ranges': 'bytes', 'cache-control': 'max-age=31536000', 'expires': 'Mon, 07 Dec 2020 18:00:31 GMT', 'vary': 'Accept-Encoding', 'content-encoding': 'gzip', 'access-control-allow-origin': '*', 'content-length': '1616', 'content-type': 'text/plain', 'strict-transport-security': 'max-age=15552000; includeSubdomains; preload', 'content-security-policy': 'upgrade-insecure-requests'} +``` + +- Lisons depuis une API. API signifie Application Program Interface. C'est un moyen d'échanger des données structurées entre serveurs, principalement sous forme de données json. Un exemple d'API : https://restcountries.eu/rest/v2/all. Lisons cette API en utilisant le module _requests_. + +```py +import requests +url = 'https://restcountries.eu/rest/v2/all' # api des pays +response = requests.get(url) # ouverture d'une connexion réseau et récupération de données +print(response) # objet réponse +print(response.status_code) # code de statut, succès : 200 +countries = response.json() +print(countries[:1]) # nous n'avons pris que le premier pays, retirez le slicing pour voir tous les pays +``` + +```sh + +200 +[{'alpha2Code': 'AF', + 'alpha3Code': 'AFG', + 'altSpellings': ['AF', 'Afġānistān'], + 'area': 652230.0, + 'borders': ['IRN', 'PAK', 'TKM', 'UZB', 'TJK', 'CHN'], + 'callingCodes': ['93'], + 'capital': 'Kabul', + 'cioc': 'AFG', + 'currencies': [{'code': 'AFN', 'name': 'Afghan afghani', 'symbol': '؋'}], + 'demonym': 'Afghan', + 'flag': 'https://restcountries.eu/data/afg.svg', + 'gini': 27.8, + 'languages': [{'iso639_1': 'ps', + 'iso639_2': 'pus', + 'name': 'Pashto', + 'nativeName': 'پښتو'}, + {'iso639_1': 'uz', + 'iso639_2': 'uzb', + 'name': 'Uzbek', + 'nativeName': 'Oʻzbek'}, + {'iso639_1': 'tk', + 'iso639_2': 'tuk', + 'name': 'Turkmen', + 'nativeName': 'Türkmen'}], + 'latlng': [33.0, 65.0], + 'name': 'Afghanistan', + 'nativeName': 'افغانستان', + 'numericCode': '004', + 'population': 27657145, + 'region': 'Asia', + 'regionalBlocs': [{'acronym': 'SAARC', + 'name': 'South Asian Association for Regional Cooperation', + 'otherAcronyms': [], + 'otherNames': []}], + 'subregion': 'Southern Asia', + 'timezones': ['UTC+04:30'], + 'topLevelDomain': ['.af'], + 'translations': {'br': 'Afeganistão', + 'de': 'Afghanistan', + 'es': 'Afganistán', + 'fa': 'افغانستان', + 'fr': 'Afghanistan', + 'hr': 'Afganistan', + 'it': 'Afghanistan', + 'ja': 'アフガニスタン', + 'nl': 'Afghanistan', + 'pt': 'Afeganistão'}}] +``` + +Nous utilisons la méthode _json()_ de l'objet réponse, si nous récupérons des données JSON. Pour txt, html, xml et autres formats de fichiers, nous pouvons utiliser _text_. + +### Créer un paquet + +Nous organisons un grand nombre de fichiers dans différents dossiers et sous-dossiers selon certains critères, afin de pouvoir les trouver et les gérer facilement. Comme vous le savez, un module peut contenir plusieurs objets, tels que des classes, des fonctions, etc. Un paquet peut contenir un ou plusieurs modules pertinents. Un paquet est en fait un dossier contenant un ou plusieurs fichiers de modules. Créons un paquet nommé mypackage, en suivant les étapes suivantes : + +Créez un nouveau dossier nommé mypackage dans le dossier 30DaysOfPython +Créez un fichier **__init__**.py vide dans le dossier mypackage. +Créez les modules arithmetic.py et greet.py avec le code suivant : + +```py +# mypackage/arithmetics.py +# arithmetics.py +def add_numbers(*args): + total = 0 + for num in args: + total += num + return total + + +def subtract(a, b): + return (a - b) + + +def multiple(a, b): + return a * b + + +def division(a, b): + return a / b + + +def remainder(a, b): + return a % b + + +def power(a, b): + return a ** b +``` + +```py +# mypackage/greet.py +# greet.py +def greet_person(firstname, lastname): + return f'{firstname} {lastname}, bienvenue au défi 30DaysOfPython !' +``` + +La structure de dossiers de votre paquet devrait ressembler à ceci : + +```sh +─ mypackage + ├── __init__.py + ├── arithmetic.py + └── greet.py +``` + +Ouvrons maintenant l'interpréteur Python interactif et essayons le paquet que nous avons créé : + +```sh +asabeneh@Asabeneh:~/Desktop/30DaysOfPython$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> from mypackage import arithmetics +>>> arithmetics.add_numbers(1, 2, 3, 5) +11 +>>> arithmetics.subtract(5, 3) +2 +>>> arithmetics.multiple(5, 3) +15 +>>> arithmetics.division(5, 3) +1.6666666666666667 +>>> arithmetics.remainder(5, 3) +2 +>>> arithmetics.power(5, 3) +125 +>>> from mypackage import greet +>>> greet.greet_person('Asabeneh', 'Yetayeh') +'Asabeneh Yetayeh, bienvenue au défi 30DaysOfPython !' +>>> +``` + +Comme vous pouvez le voir, notre paquet fonctionne parfaitement. Le dossier du paquet contient un fichier spécial appelé **__init__**.py - il stocke le contenu du paquet. Si nous mettons **__init__**.py dans le dossier du paquet, Python le reconnaît comme un paquet. +Le fichier **__init__**.py expose les ressources spécifiées de ses modules pour être importées dans d'autres fichiers Python. Un fichier **__init__**.py vide rend toutes les fonctions disponibles lorsqu'un paquet est importé. Le fichier **__init__**.py est essentiel pour que le dossier soit reconnu par Python comme un paquet. + +### Plus d'informations sur les paquets + +- Base de données + - SQLAlchemy ou SQLObject - Accès orienté objet à plusieurs systèmes de bases de données différents + - _pip install SQLAlchemy_ +- Développement Web + - Django - Framework web haut niveau. + - _pip install django_ + - Flask - Micro-framework Python basé sur Werkzeug, Jinja 2. (Sous licence BSD) + - _pip install flask_ +- Analyse HTML + - [Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/bs4/doc/) - Analyseur HTML/XML conçu pour des projets à évolution rapide comme le scraping, accepte les balises incorrectes. + - _pip install beautifulsoup4_ + - PyQuery - implémente jQuery en Python ; plus rapide que BeautifulSoup, apparemment. + +- Traitement XML + - ElementTree - Le type Element est un conteneur simple mais flexible, conçu pour stocker des structures de données hiérarchiques, comme des ensembles d'informations XML simplifiés, en mémoire. --Note : Python 2.5 et supérieur inclut ElementTree dans la bibliothèque standard. +- GUI + - PyQt - Liaisons pour le framework Qt multiplateforme. + - TkInter - La boîte à outils d'interface utilisateur Python traditionnelle. +- Analyse de données, Data Science et Machine Learning + - Numpy : Numpy (numeric python) est connu comme l'une des bibliothèques de machine learning les plus populaires en Python. + - Pandas : est une bibliothèque d'analyse de données, de data science et de machine learning en Python qui fournit des structures de données haut niveau et une grande variété d'outils d'analyse. + - SciPy : SciPy est une bibliothèque de machine learning pour les développeurs d'applications et les ingénieurs. La bibliothèque SciPy contient des modules pour l'optimisation, l'algèbre linéaire, l'intégration, le traitement d'images et les statistiques. + - Scikit-Learn : est basé sur NumPy et SciPy. Il est considéré comme l'une des meilleures bibliothèques pour travailler avec des données complexes. + - TensorFlow : est une bibliothèque de machine learning construite par Google. + - Keras : est considérée comme l'une des bibliothèques de machine learning les plus cool en Python. Elle fournit un mécanisme plus facile pour exprimer les réseaux de neurones. Keras fournit également certaines des meilleures utilitaires pour compiler des modèles, traiter des ensembles de données, visualiser des graphiques et bien plus encore. +- Réseau : + - requests : est un paquet que nous pouvons utiliser pour envoyer des requêtes à un serveur (GET, POST, DELETE, PUT) + - _pip install requests_ + +🌕 Vous progressez toujours et vous êtes à 20 pas de votre chemin vers la grandeur. Maintenant, faites quelques exercices pour votre cerveau et vos muscles. + +## Exercices : Jour 20 + +1. Lisez cette url et trouvez les 10 mots les plus fréquents. romeo_and_juliet = 'http://www.gutenberg.org/files/1112/1112.txt' +2. Lisez l'API des chats : cats_api = 'https://api.thecatapi.com/v1/breeds' et trouvez : + 1. le min, max, moyenne, médiane, écart type du poids des chats en unités métriques. + 2. le min, max, moyenne, médiane, écart type de l'espérance de vie des chats en années. + 3. Créez un tableau de fréquences des pays et des races de chats. +3. Lisez l'[API des pays](https://restcountries.eu/rest/v2/all) et trouvez : + 1. les 10 plus grands pays + 2. les 10 langues les plus parlées + 3. le nombre total de langues dans l'API des pays +4. UCI est l'un des endroits les plus courants pour obtenir des ensembles de données pour la data science et le machine learning. Lisez le contenu de UCL (https://archive.ics.uci.edu/ml/datasets.php). Sans bibliothèques supplémentaires, ce sera difficile, vous pouvez donc essayer avec BeautifulSoup4. + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 19](./19_file_handling_fr.md) | [Jour 21 >>](./21_classes_and_objects_fr.md) diff --git a/French/21_classes_and_objects_fr.md b/French/21_classes_and_objects_fr.md new file mode 100644 index 000000000..1b809b14e --- /dev/null +++ b/French/21_classes_and_objects_fr.md @@ -0,0 +1,368 @@ +
+

30 Jours de Python : Jour 21 - Classes et Objets

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+Deuxième édition : juillet 2021 + + +
+ +[<< Jour 20](./20_python_package_manager_fr.md) | [Jour 22 >>](./22_web_scraping_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 21](#-jour-21) + - [Classes et Objets](#classes-et-objets) + - [Créer une classe](#créer-une-classe) + - [Créer un objet](#créer-un-objet) + - [Constructeur de classe](#constructeur-de-classe) + - [Méthodes d'objet](#méthodes-dobjet) + - [Méthodes par défaut d'un objet](#méthodes-par-défaut-dun-objet) + - [Méthode pour modifier les valeurs par défaut d'une classe](#méthode-pour-modifier-les-valeurs-par-défaut-dune-classe) + - [Héritage](#héritage) + - [Surcharge de la méthode parente](#surcharge-de-la-méthode-parente) + - [💻 Exercices : Jour 21](#-exercices-jour-21) + - [Exercices : Niveau 1](#exercices-niveau-1) + - [Exercices : Niveau 2](#exercices-niveau-2) + - [Exercices : Niveau 3](#exercices-niveau-3) + +# 📘 Jour 21 + +## Classes et Objets + +Python est un langage de programmation orientée objet. Tout en Python est un objet, avec ses propriétés et ses méthodes. Un nombre, une chaîne, une liste, un dictionnaire, un tuple, un ensemble, etc. utilisés dans un programme sont des objets d'une classe intégrée correspondante. Nous créons une classe pour créer un objet. Une classe est comme un constructeur d'objet, ou un « plan » pour créer des objets. Nous instancions une classe pour créer un objet. La classe définit les attributs et le comportement de l'objet, tandis que l'objet, quant à lui, représente la classe. + +Nous avons travaillé avec des classes et des objets depuis le début de ce défi sans le savoir. Chaque élément d'un programme Python est un objet d'une classe. +Vérifions si tout en Python est une classe : + +```py +asabeneh@Asabeneh:~$ python +Python 3.9.6 (default, Jun 28 2021, 15:26:21) +[Clang 11.0.0 (clang-1100.0.33.8)] on darwin +Type "help", "copyright", "credits" or "license" for more information. +>>> num = 10 +>>> type(num) + +>>> string = 'string' +>>> type(string) + +>>> boolean = True +>>> type(boolean) + +>>> lst = [] +>>> type(lst) + +>>> tpl = () +>>> type(tpl) + +>>> set1 = set() +>>> type(set1) + +>>> dct = {} +>>> type(dct) + +``` + +### Créer une classe + +Pour créer une classe, nous avons besoin du mot-clé **class** suivi du nom et de deux-points. Le nom de la classe doit être en **CamelCase**. + +```sh +# syntaxe +class NomClasse: + le code va ici +``` + +**Exemple :** + +```py +class Person: + pass +print(Person) +``` + +```sh +<__main__.Person object at 0x10804e510> +``` + +### Créer un objet + +Nous pouvons créer un objet en appelant la classe. + +```py +p = Person() +print(p) +``` + +### Constructeur de classe + +Dans les exemples ci-dessus, nous avons créé un objet à partir de la classe Person. Cependant, une classe sans constructeur n'est pas vraiment utile dans les applications réelles. Utilisons une fonction constructeur pour rendre notre classe plus utile. Comme la fonction constructeur en Java ou JavaScript, Python a aussi une fonction constructeur intégrée **__init__**(). La fonction constructeur **__init__** a un paramètre self qui est une référence à l'instance actuelle de la classe. + +**Exemples :** + +```py +class Person: + def __init__ (self, name): + # self permet d'attacher un paramètre à la classe + self.name =name + +p = Person('Asabeneh') +print(p.name) +print(p) +``` + +```sh +# sortie +Asabeneh +<__main__.Person object at 0x2abf46907e80> +``` + +Ajoutons plus de paramètres à la fonction constructeur. + +```py +class Person: + def __init__(self, firstname, lastname, age, country, city): + self.firstname = firstname + self.lastname = lastname + self.age = age + self.country = country + self.city = city + + +p = Person('Asabeneh', 'Yetayeh', 250, 'Finland', 'Helsinki') +print(p.firstname) +print(p.lastname) +print(p.age) +print(p.country) +print(p.city) +``` + +```sh +# sortie +Asabeneh +Yetayeh +250 +Finland +Helsinki +``` + +### Méthodes d'objet + +Les objets peuvent avoir des méthodes. Les méthodes sont des fonctions qui appartiennent à l'objet. + +**Exemple :** + +```py +class Person: + def __init__(self, firstname, lastname, age, country, city): + self.firstname = firstname + self.lastname = lastname + self.age = age + self.country = country + self.city = city + def person_info(self): + return f'{self.firstname} {self.lastname} a {self.age} ans. Il habite à {self.city}, {self.country}' + +p = Person('Asabeneh', 'Yetayeh', 250, 'Finland', 'Helsinki') +print(p.person_info()) +``` + +```sh +# sortie +Asabeneh Yetayeh a 250 ans. Il habite à Helsinki, Finland +``` + +### Méthodes par défaut d'un objet + +Parfois, vous pouvez vouloir avoir des valeurs par défaut pour les méthodes de votre objet. Si nous donnons des valeurs par défaut aux paramètres du constructeur, nous pouvons éviter les erreurs lorsque nous appelons ou instancions notre classe sans paramètres. Voyons à quoi cela ressemble : + +**Exemple :** + +```py +class Person: + def __init__(self, firstname='Asabeneh', lastname='Yetayeh', age=250, country='Finland', city='Helsinki'): + self.firstname = firstname + self.lastname = lastname + self.age = age + self.country = country + self.city = city + + def person_info(self): + return f'{self.firstname} {self.lastname} a {self.age} ans. Il habite à {self.city}, {self.country}.' + +p1 = Person() +print(p1.person_info()) +p2 = Person('John', 'Doe', 30, 'Nomanland', 'Noman city') +print(p2.person_info()) +``` + +```sh +# sortie +Asabeneh Yetayeh a 250 ans. Il habite à Helsinki, Finland. +John Doe a 30 ans. Il habite à Noman city, Nomanland. +``` + +### Méthode pour modifier les valeurs par défaut d'une classe + +Dans l'exemple ci-dessous, la classe Person a toutes les valeurs par défaut pour les paramètres du constructeur. En plus de cela, nous avons un paramètre skills, auquel nous pouvons accéder via une méthode. Créons une méthode add_skill pour ajouter des compétences à la liste skills. + +```py +class Person: + def __init__(self, firstname='Asabeneh', lastname='Yetayeh', age=250, country='Finland', city='Helsinki'): + self.firstname = firstname + self.lastname = lastname + self.age = age + self.country = country + self.city = city + self.skills = [] + + def person_info(self): + return f'{self.firstname} {self.lastname} a {self.age} ans. Il habite à {self.city}, {self.country}.' + def add_skill(self, skill): + self.skills.append(skill) + +p1 = Person() +print(p1.person_info()) +p1.add_skill('HTML') +p1.add_skill('CSS') +p1.add_skill('JavaScript') +p2 = Person('John', 'Doe', 30, 'Nomanland', 'Noman city') +print(p2.person_info()) +print(p1.skills) +print(p2.skills) +``` + +```sh +# sortie +Asabeneh Yetayeh a 250 ans. Il habite à Helsinki, Finland. +John Doe a 30 ans. Il habite à Noman city, Nomanland. +['HTML', 'CSS', 'JavaScript'] +[] +``` + +### Héritage + +Grâce à l'héritage, nous pouvons réutiliser le code de la classe parente. L'héritage nous permet de définir une classe qui hérite de toutes les méthodes et propriétés de la classe parente. La classe parente, superclasse ou classe de base est la classe qui fournit toutes les méthodes et propriétés. La classe enfant est la classe qui hérite d'une autre classe ou d'une classe parente. +Créons une classe Student en héritant de la classe Person. + +```py +class Student(Person): + pass + + +s1 = Student('Eyob', 'Yetayeh', 30, 'Finland', 'Helsinki') +s2 = Student('Lidiya', 'Teklemariam', 28, 'Finland', 'Espoo') +print(s1.person_info()) +s1.add_skill('JavaScript') +s1.add_skill('React') +s1.add_skill('Python') +print(s1.skills) + +print(s2.person_info()) +s2.add_skill('Organizing') +s2.add_skill('Marketing') +s2.add_skill('Digital Marketing') +print(s2.skills) + +``` + +```sh +sortie +Eyob Yetayeh a 30 ans. Il habite à Helsinki, Finland. +['JavaScript', 'React', 'Python'] +Lidiya Teklemariam a 28 ans. Il habite à Espoo, Finland. +['Organizing', 'Marketing', 'Digital Marketing'] +``` + +Nous n'avons pas appelé le constructeur **__init__**() dans la classe enfant. Si nous ne l'appelons pas, nous pouvons toujours accéder à toutes les propriétés du parent. Mais si nous appelons le constructeur, nous pouvons accéder aux propriétés du parent en appelant _super_. +Nous pouvons ajouter une nouvelle méthode à l'enfant ou nous pouvons surcharger les méthodes de la classe parente en créant le même nom de méthode dans la classe enfant. Lorsque nous ajoutons la fonction **__init__**(), la classe enfant n'héritera plus de la fonction **__init__**() du parent. + +### Surcharge de la méthode parente + +```py +class Student(Person): + def __init__ (self, firstname='Asabeneh', lastname='Yetayeh', age=250, country='Finland', city='Helsinki', gender='male'): + self.gender = gender + super().__init__(firstname, lastname, age, country, city) + def person_info(self): + gender = 'Il' if self.gender == 'male' else 'Elle' + return f'{self.firstname} {self.lastname} a {self.age} ans. {gender} habite à {self.city}, {self.country}.' + +s1 = Student('Eyob', 'Yetayeh', 30, 'Finland', 'Helsinki','male') +s2 = Student('Lidiya', 'Teklemariam', 28, 'Finland', 'Espoo', 'female') +print(s1.person_info()) +s1.add_skill('JavaScript') +s1.add_skill('React') +s1.add_skill('Python') +print(s1.skills) + +print(s2.person_info()) +s2.add_skill('Organizing') +s2.add_skill('Marketing') +s2.add_skill('Digital Marketing') +print(s2.skills) +``` + +```sh +Eyob Yetayeh a 30 ans. Il habite à Helsinki, Finland. +['JavaScript', 'React', 'Python'] +Lidiya Teklemariam a 28 ans. Elle habite à Espoo, Finland. +['Organizing', 'Marketing', 'Digital Marketing'] +``` + +Nous pouvons utiliser la fonction intégrée super() ou le nom du parent Person pour hériter automatiquement des méthodes et propriétés de son parent. Dans l'exemple ci-dessus, nous avons surchargé la méthode parente. La méthode enfant a une fonctionnalité différente, elle peut identifier si le genre est masculin ou féminin et assigner le pronom approprié (Il/Elle). + +🌕 Maintenant, vous êtes pleinement chargé d'un super pouvoir de programmation. Faites maintenant quelques exercices pour votre cerveau et vos muscles. + +## 💻 Exercices : Jour 21 + +### Exercices : Niveau 1 + +1. Python a un module appelé _statistics_ et nous pouvons utiliser ce module pour faire tous les calculs statistiques. Cependant, pour apprendre à créer des fonctions et à les réutiliser, essayons de développer un programme qui calcule les mesures de tendance centrale d'un échantillon (moyenne, médiane, mode) et les mesures de variabilité (étendue, variance, écart type). En plus de ces mesures, trouvez le min, max, count, percentile et la distribution de fréquence de l'échantillon. Vous pouvez créer une classe appelée Statistics et créer toutes les fonctions qui effectuent les calculs statistiques en tant que méthodes de la classe Statistics. Vérifiez la sortie ci-dessous. + +```py +ages = [31, 26, 34, 37, 27, 26, 32, 32, 26, 27, 27, 24, 32, 33, 27, 25, 26, 38, 37, 31, 34, 24, 33, 29, 26] + +print('Nombre :', data.count()) # 25 +print('Somme : ', data.sum()) # 744 +print('Min : ', data.min()) # 24 +print('Max : ', data.max()) # 38 +print('Étendue : ', data.range()) # 14 +print('Moyenne : ', data.mean()) # 30 +print('Médiane : ', data.median()) # 29 +print('Mode : ', data.mode()) # {'mode': 26, 'count': 5} +print('Écart type : ', data.std()) # 4.2 +print('Variance : ', data.var()) # 17.5 +print('Distribution de fréquence : ', data.freq_dist()) # [(20.0, 26), (16.0, 27), (12.0, 32), (8.0, 37), (8.0, 34), (8.0, 33), (8.0, 31), (8.0, 24), (4.0, 38), (4.0, 29), (4.0, 25)] +``` + +```sh +# votre sortie devrait ressembler à ceci +print(data.describe()) +Nombre : 25 +Somme : 744 +Min : 24 +Max : 38 +Étendue : 14 +Moyenne : 30 +Médiane : 29 +Mode : (26, 5) +Variance : 17.5 +Écart type : 4.2 +Distribution de fréquence : [(20.0, 26), (16.0, 27), (12.0, 32), (8.0, 37), (8.0, 34), (8.0, 33), (8.0, 31), (8.0, 24), (4.0, 38), (4.0, 29), (4.0, 25)] +``` + +### Exercices : Niveau 2 + +1. Créez une classe appelée PersonAccount. Elle a les propriétés firstname, lastname, incomes, expenses et les méthodes total_income, total_expense, account_info, add_income, add_expense et account_balance. Incomes est un ensemble de revenus et leurs descriptions. Il en va de même pour expenses. + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 20](./20_python_package_manager_fr.md) | [Jour 22 >>](./22_web_scraping_fr.md) diff --git a/French/22_web_scraping_fr.md b/French/22_web_scraping_fr.md new file mode 100644 index 000000000..1fcb6ec96 --- /dev/null +++ b/French/22_web_scraping_fr.md @@ -0,0 +1,108 @@ +
+

30 Jours de Python : Jour 22 - Web Scraping

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+Deuxième édition : juillet 2021 + +
+ +[<< Jour 21](./21_classes_and_objects_fr.md) | [Jour 23 >>](./23_virtual_environment_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 22](#-jour-22) + - [Python Web Scraping](#python-web-scraping) + - [Qu'est-ce que le Web Scraping ?](#quest-ce-que-le-web-scraping-) + - [💻 Exercices : Jour 22](#-exercices-jour-22) + +# 📘 Jour 22 + +## Python Web Scraping + +### Qu'est-ce que le Web Scraping ? + +L'internet contient une énorme quantité de données qui peuvent être utilisées à différentes fins. Pour collecter ces données, nous devons savoir comment extraire des données d'un site web. + +Le web scraping est le processus d'extraction et de collecte de données à partir de sites web, et de leur stockage sur une machine locale ou dans une base de données. + +Dans cette section, nous utiliserons les paquets beautifulsoup et requests pour extraire des données. La version du paquet que nous utilisons est beautifulsoup 4. + +Pour commencer à scraper des sites web, vous avez besoin de _requests_, _beautifulSoup4_ et d'un _site web_. + +```sh +pip install requests +pip install beautifulsoup4 +``` + +Pour extraire des données de sites web, une compréhension de base des balises HTML et des sélecteurs CSS est nécessaire. Nous ciblons le contenu d'un site web en utilisant des balises HTML, des classes ou/et des identifiants. +Importons les modules requests et BeautifulSoup. + +```py +import requests +from bs4 import BeautifulSoup +``` + +Déclarons une variable url pour le site web que nous allons scraper. + +```py + +import requests +from bs4 import BeautifulSoup +url = 'https://archive.ics.uci.edu/ml/datasets.php' + +# Utilisons la méthode get de requests pour récupérer les données depuis l'url + +response = requests.get(url) +# vérifions le statut +status = response.status_code +print(status) # 200 signifie que la récupération a réussi +``` + +```sh +200 +``` + +Utilisation de BeautifulSoup pour analyser le contenu de la page. + +```py +import requests +from bs4 import BeautifulSoup +url = 'https://archive.ics.uci.edu/ml/datasets.php' + +response = requests.get(url) +content = response.content # nous obtenons tout le contenu du site web +soup = BeautifulSoup(content, 'html.parser') # beautiful soup nous permettra de l'analyser +print(soup.title) # UCI Machine Learning Repository: Data Sets +print(soup.title.get_text()) # UCI Machine Learning Repository: Data Sets +print(soup.body) # donne la page entière du site +print(response.status_code) + +tables = soup.find_all('table', {'cellpadding':'3'}) +# Nous ciblons la table avec l'attribut cellpadding ayant la valeur 3 +# Nous pouvons sélectionner en utilisant id, class ou une balise HTML, pour plus d'informations consultez la doc beautifulsoup +table = tables[0] # le résultat est une liste, nous en extrayons les données +for td in table.find('tr').find_all('td'): + print(td.text) +``` + +Si vous exécutez ce code, vous verrez que l'extraction est à moitié faite. Vous pouvez continuer car cela fait partie de l'exercice 1. +Pour référence, consultez la [documentation beautifulsoup](https://www.crummy.com/software/BeautifulSoup/bs4/doc/#quick-start) + +🌕 Vous êtes si spécial, vous progressez chaque jour. Il ne vous reste plus que huit jours avant d'atteindre la grandeur. Faites maintenant quelques exercices pour votre cerveau et vos muscles. + +## 💻 Exercices : Jour 22 + +1. Scrapez le site web suivant et stockez les données sous forme de fichier json (url = 'http://www.bu.edu/president/boston-university-facts-stats/'). +1. Extrayez la table de cette url (https://archive.ics.uci.edu/ml/datasets.php) et convertissez-la en fichier json. +2. Scrapez la table des présidents et stockez les données sous forme de json (https://en.wikipedia.org/wiki/List_of_presidents_of_the_United_States). La table n'est pas très structurée et le scraping peut prendre beaucoup de temps. + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 21](./21_classes_and_objects_fr.md) | [Jour 23 >>](./23_virtual_environment_fr.md) diff --git a/French/23_virtual_environment_fr.md b/French/23_virtual_environment_fr.md new file mode 100644 index 000000000..08ad949dc --- /dev/null +++ b/French/23_virtual_environment_fr.md @@ -0,0 +1,114 @@ +
+

30 Jours de Python : Jour 23 - Environnement Virtuel

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+Deuxième édition : juillet 2021 + +
+ +[<< Jour 22](./22_web_scraping_fr.md) | [Jour 24 >>](./24_statistics_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 23](#-jour-23) + - [Configuration des environnements virtuels](#configuration-des-environnements-virtuels) + - [💻 Exercices : Jour 23](#-exercices-jour-23) + +# 📘 Jour 23 + +## Configuration des environnements virtuels + +Pour commencer un projet, il est préférable d'avoir un environnement virtuel. Un environnement virtuel peut nous aider à créer un environnement isolé ou séparé. Cela nous aidera à éviter les conflits de dépendances entre projets. Si vous tapez pip freeze sur votre terminal, vous verrez tous les paquets installés sur votre ordinateur. Si nous utilisons virtualenv, nous n'accéderons qu'aux paquets spécifiques à ce projet. Ouvrez votre terminal et installez virtualenv. + +```sh +asabeneh@Asabeneh:~$ pip install virtualenv +``` + +Dans le dossier 30DaysOfPython, créez un dossier flask_project. + +Après avoir installé le paquet virtualenv, allez dans votre dossier de projet et créez un environnement virtuel en tapant : + +Pour Mac/Linux : +```sh +asabeneh@Asabeneh:~/Desktop/30DaysOfPython/flask_project$ virtualenv venv + +``` + +Pour Windows : +```sh +C:\Users\User\Documents\30DaysOfPython\flask_project>python -m venv venv +``` + +Je préfère appeler le nouveau projet venv, mais n'hésitez pas à le nommer différemment. Vérifions si le venv a été créé en utilisant la commande ls (ou dir pour l'invite de commande Windows). + +```sh +asabeneh@Asabeneh:~/Desktop/30DaysOfPython/flask_project$ ls +venv/ +``` + +Activons l'environnement virtuel en tapant la commande suivante dans notre dossier de projet. + +Pour Mac/Linux : +```sh +asabeneh@Asabeneh:~/Desktop/30DaysOfPython/flask_project$ source venv/bin/activate +``` +L'activation de l'environnement virtuel sous Windows peut varier entre Windows Power Shell et git bash. + +Pour Windows Power Shell : +```sh +C:\Users\User\Documents\30DaysOfPython\flask_project> venv\Scripts\activate +``` + +Pour Windows Git bash : +```sh +C:\Users\User\Documents\30DaysOfPython\flask_project> venv\Scripts\. activate +``` + +Après avoir écrit la commande d'activation, votre dossier de projet commencera par venv. Voir l'exemple ci-dessous. + +```sh +(venv) asabeneh@Asabeneh:~/Desktop/30DaysOfPython/flask_project$ +``` + +Maintenant, vérifions les paquets disponibles dans ce projet en tapant pip freeze. Vous ne verrez aucun paquet. + +Nous allons réaliser un petit projet flask, alors installons le paquet flask dans ce projet. + +```sh +(venv) asabeneh@Asabeneh:~/Desktop/30DaysOfPython/flask_project$ pip install Flask +``` + +Maintenant, tapons pip freeze pour voir la liste des paquets installés dans le projet : + +```sh +(venv) asabeneh@Asabeneh:~/Desktop/30DaysOfPython/flask_project$ pip freeze +Click==7.0 +Flask==1.1.1 +itsdangerous==1.1.0 +Jinja2==2.10.3 +MarkupSafe==1.1.1 +Werkzeug==0.16.0 +``` + +Quand vous avez terminé, vous devez désactiver l'environnement actif en utilisant _deactivate_. + +```sh +(venv) asabeneh@Asabeneh:~/Desktop/30DaysOfPython$ deactivate +``` + +Les modules nécessaires pour travailler avec flask sont installés. Maintenant, votre dossier de projet est prêt pour un projet flask. Vous devez inclure le dossier venv dans votre fichier .gitignore pour ne pas le pousser sur GitHub. + +## 💻 Exercices : Jour 23 + +1. Créez un dossier de projet avec un environnement virtuel basé sur l'exemple donné ci-dessus. + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 22](./22_web_scraping_fr.md) | [Jour 24 >>](./24_statistics_fr.md) diff --git a/French/24_statistics_fr.md b/French/24_statistics_fr.md new file mode 100644 index 000000000..27bf1f613 --- /dev/null +++ b/French/24_statistics_fr.md @@ -0,0 +1,1240 @@ +
+

30 Jours de Python : Jour 24 - Statistiques

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+Deuxième édition : juillet 2021 + +
+ +[<< Jour 23](./23_virtual_environment_fr.md) | [Jour 25 >>](./25_pandas_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 24](#-jour-24) + - [Python pour l'analyse statistique](#python-pour-lanalyse-statistique) + - [Statistiques](#statistiques) + - [Données](#données) + - [Module Statistics](#module-statistics) +- [NumPy](#numpy) + +# 📘 Jour 24 + +## Python pour l'analyse statistique + +## Statistiques + +Les statistiques sont la discipline qui étudie la _collecte_, l'_organisation_, l'_affichage_, l'_analyse_, l'_interprétation_ et la _présentation_ des données. +Les statistiques sont une branche des mathématiques qui est recommandée comme prérequis pour la science des données et l'apprentissage automatique. Les statistiques sont un domaine très vaste, mais nous nous concentrerons dans cette section uniquement sur la partie la plus pertinente. +Après avoir terminé ce défi, vous pourrez poursuivre la voie du développement web, de l'analyse de données, de l'apprentissage automatique et de la science des données. Quel que soit le chemin que vous suivrez, à un moment donné de votre carrière, vous obtiendrez des données sur lesquelles vous pourrez travailler. Avoir des connaissances statistiques vous aidera à prendre des décisions basées sur les données, _les données parlent d'elles-mêmes comme on dit_. + +## Données + +Qu'est-ce qu'une donnée ? Une donnée est tout ensemble de caractères qui est rassemblé et traduit dans un but précis, généralement l'analyse. Il peut s'agir de n'importe quel caractère, y compris du texte et des nombres, des images, des sons ou des vidéos. Si les données ne sont pas mises en contexte, elles n'ont aucun sens pour un humain ou un ordinateur. Pour donner un sens aux données, nous devons travailler sur les données en utilisant différents outils. + +Le flux de travail de l'analyse de données, de la science des données ou de l'apprentissage automatique commence par les données. Les données peuvent être fournies par une source de données ou être créées. Il existe des données structurées et non structurées. + +Les données peuvent être trouvées dans un petit ou un grand format. La plupart des types de données que nous obtiendrons ont été couverts dans la section sur la gestion des fichiers. + +## Module Statistics + +Le module Python _statistics_ fournit des fonctions pour calculer des statistiques mathématiques sur des données numériques. Le module n'est pas destiné à être un concurrent des bibliothèques tierces comme NumPy, SciPy, ou des progiciels statistiques complets propriétaires destinés aux statisticiens professionnels comme Minitab, SAS et Matlab. Il vise le niveau des calculatrices graphiques et scientifiques. + +# NumPy + +Dans la première section, nous avons défini Python comme un excellent langage de programmation généraliste en soi, mais avec l'aide d'autres bibliothèques populaires (numpy, scipy, matplotlib, pandas, etc.), il devient un environnement puissant pour le calcul scientifique. + +NumPy est la bibliothèque de base pour le calcul scientifique en Python. Elle fournit un objet tableau multidimensionnel haute performance et des outils pour travailler avec des tableaux. + +Jusqu'à présent, nous avons utilisé vscode, mais à partir de maintenant, je recommande d'utiliser Jupyter Notebook. Pour accéder à Jupyter Notebook, installons [anaconda](https://www.anaconda.com/). Si vous utilisez anaconda, la plupart des paquets courants sont inclus et vous n'avez pas besoin d'installer de paquets si vous avez installé anaconda. + +```sh +asabeneh@Asabeneh:~/Desktop/30DaysOfPython$ pip install numpy +``` + +## Importer NumPy + +Jupyter notebook est disponible si vous préférez [jupyter notebook](https://github.com/Asabeneh/data-science-for-everyone/blob/master/numpy/numpy.ipynb) + +```py + # Comment importer numpy + import numpy as np + # Comment vérifier la version du paquet numpy + print('numpy:', np.__version__) + # Vérification des méthodes disponibles + print(dir(np)) +``` + +## Créer un tableau numpy + +### Créer des tableaux numpy d'entiers + +```py + # Création d'une liste Python + python_list = [1,2,3,4,5] + + # Vérification des types de données + print('Type :', type (python_list)) # + # + print(python_list) # [1, 2, 3, 4, 5] + + two_dimensional_list = [[0,1,2], [3,4,5], [6,7,8]] + + print(two_dimensional_list) # [[0, 1, 2], [3, 4, 5], [6, 7, 8]] + + # Création d'un tableau Numpy (Numerical Python) à partir d'une liste Python + + numpy_array_from_list = np.array(python_list) + print(type (numpy_array_from_list)) # + print(numpy_array_from_list) # array([1, 2, 3, 4, 5]) +``` + +### Créer des tableaux numpy flottants + +Création d'un tableau numpy flottant à partir d'une liste avec un paramètre de type de données flottant + +```py + # Liste Python + python_list = [1,2,3,4,5] + + numy_array_from_list2 = np.array(python_list, dtype=float) + print(numy_array_from_list2) # array([1., 2., 3., 4., 5.]) +``` + +### Créer des tableaux numpy booléens + +Création d'un tableau numpy booléen à partir d'une liste + +```py + numpy_bool_array = np.array([0, 1, -1, 0, 0], dtype=bool) + print(numpy_bool_array) # array([False, True, True, False, False]) +``` + +### Créer un tableau multidimensionnel avec numpy + +Un tableau numpy peut avoir une ou plusieurs lignes et colonnes + +```py + two_dimensional_list = [[0,1,2], [3,4,5], [6,7,8]] + numpy_two_dimensional_list = np.array(two_dimensional_list) + print(type (numpy_two_dimensional_list)) + print(numpy_two_dimensional_list) +``` + +```sh + + [[0 1 2] + [3 4 5] + [6 7 8]] +``` + +### Convertir un tableau numpy en liste + +```python +# Nous pouvons toujours reconvertir un tableau en liste Python en utilisant tolist(). +np_to_list = numpy_array_from_list.tolist() +print(type (np_to_list)) +print('tableau unidimensionnel :', np_to_list) +print('tableau bidimensionnel : ', numpy_two_dimensional_list.tolist()) +``` + +```sh + + tableau unidimensionnel : [1, 2, 3, 4, 5] + tableau bidimensionnel : [[0, 1, 2], [3, 4, 5], [6, 7, 8]] +``` + +### Créer un tableau numpy à partir d'un tuple + +```py +# Tableau numpy à partir d'un tuple +# Création d'un tuple en Python +python_tuple = (1,2,3,4,5) +print(type (python_tuple)) # +print('python_tuple: ', python_tuple) # python_tuple: (1, 2, 3, 4, 5) + +numpy_array_from_tuple = np.array(python_tuple) +print(type (numpy_array_from_tuple)) # +print('numpy_array_from_tuple: ', numpy_array_from_tuple) # numpy_array_from_tuple: [1 2 3 4 5] +``` + +### Forme d'un tableau numpy + +La méthode shape fournit la forme du tableau sous forme de tuple. Le premier élément est la ligne et le second la colonne. Si le tableau est unidimensionnel, il retourne la taille du tableau. + +```py + nums = np.array([1, 2, 3, 4, 5]) + print(nums) + print('forme de nums : ', nums.shape) + numpy_two_dimensional_list = np.array([[0,1,2],[3,4,5],[6,7,8]]) + print(numpy_two_dimensional_list) + print('forme de numpy_two_dimensional_list : ', numpy_two_dimensional_list.shape) + three_by_four_array = np.array([[0, 1, 2, 3], + [4,5,6,7], + [8,9,10,11]])) + print(three_by_four_array) + print('forme de three_by_four_array : ', three_by_four_array.shape) + +``` + +```sh + [1 2 3 4 5] + forme de nums : (5,) + [[0 1 2] + [3 4 5] + [6 7 8]] + forme de numpy_two_dimensional_list : (3, 3) + (3, 4) +``` + +### Type de données d'un tableau numpy + +Types de données : str, int, float, complex, bool, list, None + +```py +int_lists = [-3, -2, -1, 0, 1, 2,3] +int_array = np.array(int_lists) +float_array = np.array(int_lists, dtype=float) + +print(int_array) +print(int_array.dtype) +print(float_array) +print(float_array.dtype) +``` + +```sh + [-3 -2 -1 0 1 2 3] + int64 + [-3. -2. -1. 0. 1. 2. 3.] + float64 +``` + +### Taille d'un tableau numpy + +Dans numpy, pour connaître le nombre d'éléments dans un tableau numpy, nous utilisons size + +```py +numpy_array_from_list = np.array([1, 2, 3, 4, 5]) +two_dimensional_list = np.array([[0, 1, 2], + [3, 4, 5], + [6, 7, 8]]) + +print('La taille :', numpy_array_from_list.size) # 5 +print('La taille :', two_dimensional_list.size) # 3 + +``` + +```sh + La taille : 5 + La taille : 9 +``` + +## Opérations mathématiques avec numpy + +Un tableau NumPy n'est pas exactement comme une liste Python. Pour effectuer des opérations mathématiques sur une liste Python, nous devons parcourir les éléments, mais numpy permet d'effectuer n'importe quelle opération mathématique sans boucle. +Opérations mathématiques : + +- Addition (+) +- Soustraction (-) +- Multiplication (\*) +- Division (/) +- Modulo (%) +- Division entière (//) +- Exponentiation (\*\*) + +### Addition + +```py +# Opération mathématique +# Addition +numpy_array_from_list = np.array([1, 2, 3, 4, 5]) +print('tableau original : ', numpy_array_from_list) +ten_plus_original = numpy_array_from_list + 10 +print(ten_plus_original) + +``` + +```sh + tableau original : [1 2 3 4 5] + [11 12 13 14 15] +``` + +### Soustraction + +```python +# Soustraction +numpy_array_from_list = np.array([1, 2, 3, 4, 5]) +print('tableau original : ', numpy_array_from_list) +ten_minus_original = numpy_array_from_list - 10 +print(ten_minus_original) +``` + +```sh + tableau original : [1 2 3 4 5] + [-9 -8 -7 -6 -5] +``` + +### Multiplication + +```python +# Multiplication +numpy_array_from_list = np.array([1, 2, 3, 4, 5]) +print('tableau original : ', numpy_array_from_list) +ten_times_original = numpy_array_from_list * 10 +print(ten_times_original) +``` + +```sh + tableau original : [1 2 3 4 5] + [10 20 30 40 50] +``` + +### Division + +```python +# Division +numpy_array_from_list = np.array([1, 2, 3, 4, 5]) +print('tableau original : ', numpy_array_from_list) +ten_times_original = numpy_array_from_list / 10 +print(ten_times_original) +``` + +```sh + tableau original : [1 2 3 4 5] + [0.1 0.2 0.3 0.4 0.5] +``` + +### Modulo + +```python +# Modulo ; Trouver le reste +numpy_array_from_list = np.array([1, 2, 3, 4, 5]) +print('tableau original : ', numpy_array_from_list) +ten_times_original = numpy_array_from_list % 3 +print(ten_times_original) +``` + +```sh + tableau original : [1 2 3 4 5] + [1 2 0 1 2] +``` + +### Division entière + +```py +# Division entière : le résultat de la division sans le reste +numpy_array_from_list = np.array([1, 2, 3, 4, 5]) +print('tableau original : ', numpy_array_from_list) +ten_times_original = numpy_array_from_list // 10 +print(ten_times_original) +``` + +### Exponentiation + +```py +# L'exponentiation consiste à élever un nombre à la puissance d'un autre : +numpy_array_from_list = np.array([1, 2, 3, 4, 5]) +print('tableau original : ', numpy_array_from_list) +ten_times_original = numpy_array_from_list ** 2 +print(ten_times_original) +``` + +```sh + tableau original : [1 2 3 4 5] + [ 1 4 9 16 25] +``` + +## Vérification des types de données + +```py +# Nombres entiers et flottants +numpy_int_arr = np.array([1,2,3,4]) +numpy_float_arr = np.array([1.1, 2.0,3.2]) +numpy_bool_arr = np.array([-3, -2, 0, 1,2,3], dtype='bool') + +print(numpy_int_arr.dtype) +print(numpy_float_arr.dtype) +print(numpy_bool_arr.dtype) +``` + +```sh + int64 + float64 + bool +``` + +### Conversion de types + +Nous pouvons convertir les types de données d'un tableau numpy + +1. Int en Float + +```py +numpy_int_arr = np.array([1,2,3,4], dtype = 'float') +numpy_int_arr +``` + + array([1., 2., 3., 4.]) + +2. Float en Int + +```py +numpy_int_arr = np.array([1., 2., 3., 4.], dtype = 'int') +numpy_int_arr +``` + +```sh + array([1, 2, 3, 4]) +``` + +3. Int en booléen + +```py +np.array([-3, -2, 0, 1,2,3], dtype='bool') + +``` + +```sh + array([ True, True, False, True, True, True]) +``` + +4. Int en str + +```py +numpy_float_list.astype('int').astype('str') +``` + +```sh + array(['1', '2', '3'], dtype=' + [[1 2 3] + [4 5 6] + [7 8 9]] + Forme : (3, 3) + Taille : 9 + Type de données : int64 +``` + +### Obtenir des éléments d'un tableau numpy + +```py +# Tableau 2 dimensions +two_dimension_array = np.array([[1,2,3],[4,5,6], [7,8,9]]) +first_row = two_dimension_array[0] +second_row = two_dimension_array[1] +third_row = two_dimension_array[2] +print('Première ligne :', first_row) +print('Deuxième ligne :', second_row) +print('Troisième ligne : ', third_row) +``` + +```sh + Première ligne : [1 2 3] + Deuxième ligne : [4 5 6] + Troisième ligne : [7 8 9] +``` + +```py +first_column= two_dimension_array[:,0] +second_column = two_dimension_array[:,1] +third_column = two_dimension_array[:,2] +print('Première colonne :', first_column) +print('Deuxième colonne :', second_column) +print('Troisième colonne : ', third_column) +print(two_dimension_array) + +``` + +```sh + Première colonne : [1 4 7] + Deuxième colonne : [2 5 8] + Troisième colonne : [3 6 9] + [[1 2 3] + [4 5 6] + 7 8 9]] +``` + +## Decouper un tableau numpy + +Le découpage (slicing) dans numpy est similaire au découpage dans une liste Python + +```py +two_dimension_array = np.array([[1,2,3],[4,5,6], [7,8,9]]) +first_two_rows_and_columns = two_dimension_array[0:2, 0:2] +print(first_two_rows_and_columns) +``` + +```sh + [[1 2] + [4 5]] +``` + +### Comment inverser les lignes et le tableau entier ? + +```py +two_dimension_array[::] +``` + +```sh + array([[1, 2, 3], + [4, 5, 6], + [7, 8, 9]]) +``` + +### Inverser les positions des lignes et des colonnes + +```py + two_dimension_array = np.array([[1,2,3],[4,5,6], [7,8,9]]) + two_dimension_array[::-1,::-1] +``` + +```sh + array([[9, 8, 7], + [6, 5, 4], + [3, 2, 1]]) +``` + +## Comment représenter les valeurs manquantes ? + +```python + print(two_dimension_array) + two_dimension_array[1,1] = 55 + two_dimension_array[1,2] =44 + print(two_dimension_array) +``` + +```sh + [[1 2 3] + [4 5 6] + [7 8 9]] + [[ 1 2 3] + [ 4 55 44] + [ 7 8 9]] +``` + +```py + # Numpy Zéros + # numpy.zeros(shape, dtype=float, order='C') + numpy_zeroes = np.zeros((3,3),dtype=int,order='C') + numpy_zeroes +``` + +```sh + array([[0, 0, 0], + [0, 0, 0], + [0, 0, 0]]) +``` + +```py +# Numpy Zéros +numpy_ones = np.ones((3,3),dtype=int,order='C') +print(numpy_ones) +``` + +```sh + [[1 1 1] + [1 1 1] + [1 1 1]] +``` + +```py +twoes = numpy_ones * 2 +``` + +```py +# Remodeler (Reshape) +# numpy.reshape(), numpy.flatten() +first_shape = np.array([(1,2,3), (4,5,6)]) +print(first_shape) +reshaped = first_shape.reshape(3,2) +print(reshaped) + +``` + +```sh + [[1 2 3] + [4 5 6]] + [[1 2] + [3 4] + [5 6]] +``` + +```py +flattened = reshaped.flatten() +flattened +``` + +```sh + array([1, 2, 3, 4, 5, 6]) +``` + +```py + ## Empilement horizontal + np_list_one = np.array([1,2,3]) + np_list_two = np.array([4,5,6]) + + print(np_list_one + np_list_two) + + print('Ajout horizontal :', np.hstack((np_list_one, np_list_two))) +``` + +```sh + [5 7 9] + Ajout horizontal : [1 2 3 4 5 6] +``` + +```py + ## Empilement vertical + print('Ajout vertical :', np.vstack((np_list_one, np_list_two))) +``` + +```sh + Ajout vertical : [[1 2 3] + [4 5 6]] +``` + +#### Générer des nombres aléatoires + +```py + # Générer un nombre flottant aléatoire + random_float = np.random.random() + random_float +``` + +```sh + 0.018929887384753874 +``` + +```py + # Générer des nombres flottants aléatoires + random_floats = np.random.random(5) + random_floats +``` + +```sh + array([0.26392192, 0.35842215, 0.87908478, 0.41902195, 0.78926418]) +``` + +```py + # Générer un entier aléatoire entre 0 et 10 + + random_int = np.random.randint(0, 11) + random_int +``` + +```sh + 4 +``` + +```py + # Générer des entiers aléatoires entre 2 et 11, et créer un tableau d'une ligne + random_int = np.random.randint(2,10, size=4) + random_int +``` + +```sh + array([8, 8, 8, 2]) +``` + +```py + # Générer des entiers aléatoires entre 0 et 10 + random_int = np.random.randint(2,10, size=(3,3)) + random_int +``` + +```sh + array([[3, 5, 3], + [7, 3, 6], + [2, 3, 3]]) +``` + +### Générer des nombres aléatoires + +```py + # np.random.normal(mu, sigma, size) + normal_array = np.random.normal(79, 15, 80) + normal_array + +``` + +```sh + array([ 89.49990595, 82.06056961, 107.21445842, 38.69307086, + 47.85259157, 93.07381061, 76.40724259, 78.55675184, + 72.17358173, 47.9888899 , 65.10370622, 76.29696568, + 95.58234254, 68.14897213, 38.75862686, 122.5587927 , + 67.0762565 , 95.73990864, 81.97454563, 92.54264805, + 59.37035153, 77.76828101, 52.30752166, 64.43109931, + 62.63695351, 90.04616138, 75.70009094, 49.87586877, + 80.22002414, 68.56708848, 76.27791052, 67.24343975, + 81.86363935, 78.22703433, 102.85737041, 65.15700341, + 84.87033426, 76.7569997 , 64.61321853, 67.37244562, + 74.4068773 , 58.65119655, 71.66488727, 53.42458179, + 70.26872028, 60.96588544, 83.56129414, 72.14255326, + 81.00787609, 71.81264853, 72.64168853, 86.56608717, + 94.94667321, 82.32676973, 70.5165446 , 85.43061003, + 72.45526212, 87.34681775, 87.69911217, 103.02831489, + 75.28598596, 67.17806893, 92.41274447, 101.06662611, + 87.70013935, 70.73980645, 46.40368207, 50.17947092, + 61.75618542, 90.26191397, 78.63968639, 70.84550744, + 88.91826581, 103.91474733, 66.3064638 , 79.49726264, + 70.81087439, 83.90130623, 87.58555972, 59.95462521]) +``` + +## Numpy et les statistiques + +```py +import matplotlib.pyplot as plt +import seaborn as sns +sns.set() +plt.hist(normal_array, color="grey", bins=50) +``` + +```sh + (array([2., 0., 0., 0., 1., 2., 2., 0., 2., 0., 0., 1., 2., 2., 1., 4., 3., + 4., 2., 7., 2., 2., 5., 4., 2., 4., 3., 2., 1., 5., 3., 0., 3., 2., + 1., 0., 0., 1., 3., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 1.]), + array([ 38.69307086, 40.37038529, 42.04769973, 43.72501417, + 45.4023286 , 47.07964304, 48.75695748, 50.43427191, + 52.11158635, 53.78890079, 55.46621523, 57.14352966, + 58.8208441 , 60.49815854, 62.17547297, 63.85278741, + 65.53010185, 67.20741628, 68.88473072, 70.56204516, + 72.23935959, 73.91667403, 75.59398847, 77.27130291, + 78.94861734, 80.62593178, 82.30324622, 83.98056065, + 85.65787509, 87.33518953, 89.01250396, 90.6898184 , + 92.36713284, 94.04444727, 95.72176171, 97.39907615, + 99.07639058, 100.75370502, 102.43101946, 104.1083339 , + 105.78564833, 107.46296277, 109.14027721, 110.81759164, + 112.49490608, 114.17222052, 115.84953495, 117.52684939, + 119.20416383, 120.88147826, 122.5587927 ]), + ) +``` + +### Matrice avec numpy + +```py + +four_by_four_matrix = np.matrix(np.ones((4,4), dtype=float)) +``` + +```py +four_by_four_matrix +``` + +```sh +matrix([[1., 1., 1., 1.], + [1., 1., 1., 1.], + [1., 1., 1., 1.], + [1., 1., 1., 1.]]) +``` + +```py +np.asarray(four_by_four_matrix)[2] = 2 +four_by_four_matrix +``` + +```sh + +matrix([[1., 1., 1., 1.], + [1., 1., 1., 1.], + [2., 2., 2., 2.], + [1., 1., 1., 1.]]) +``` + +### Numpy numpy.arange() + +#### Qu'est-ce que Arrange ? + +Parfois, vous voulez créer des valeurs régulièrement espacées dans un intervalle défini. Par exemple, vous voulez créer des valeurs de 1 à 10 ; vous pouvez utiliser la fonction numpy.arange() + +```py +# créer une liste en utilisant range(début, fin, pas) +lst = range(0, 11, 2) +lst +``` + +```python +range(0, 11, 2) +``` + +```python +for l in lst: + print(l) +``` + +```sh 0 + 2 + 4 + 6 + 8 + 10 +``` + +```py +# Similaire à range, arange numpy.arange(start, stop, step) +whole_numbers = np.arange(0, 20, 1) +whole_numbers +``` + +```sh +array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19]) +``` + +```py +natural_numbers = np.arange(1, 20, 1) +natural_numbers +``` + +```py +odd_numbers = np.arange(1, 20, 2) +odd_numbers +``` + +```sh + array([ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19]) +``` + +```py +even_numbers = np.arange(2, 20, 2) +even_numbers +``` + +```sh + array([ 2, 4, 6, 8, 10, 12, 14, 16, 18]) +``` + +### Créer une séquence de nombres avec linspace + +```py +# numpy.linspace() +# numpy.logspace() in Python with Example +# Par exemple, peut être utilisé pour créer 10 valeurs de 1 à 5 régulièrement espacées. +np.linspace(1.0, 5.0, num=10) +``` + +```sh + array([1. , 1.44444444, 1.88888889, 2.33333333, 2.77777778, + 3.22222222, 3.66666667, 4.11111111, 4.55555556, 5. ]) +``` + +```py +# pour ne pas inclure la dernière valeur de l'intervalle +np.linspace(1.0, 5.0, num=5, endpoint=False) +``` + +``` +array([1. , 1.8, 2.6, 3.4, 4.2]) +``` + +```py +# LogSpace +# LogSpace retourne des nombres régulièrement espacés sur une échelle logarithmique. Logspace a les mêmes paramètres que np.linspace. + +# Syntaxe : + +# numpy.logspace(start, stop, num, endpoint) + +np.logspace(2, 4.0, num=4) +``` + +```sh + +array([ 100. , 464.15888336, 2154.43469003, 10000. ]) +``` + +```py +# pour vérifier la taille d'un tableau +x = np.array([1,2,3], dtype=np.complex128) +``` + +```py +x +``` + +```sh + array([1.+0.j, 2.+0.j, 3.+0.j]) +``` + +```py +x.itemsize +``` + +```sh +16 +``` + +```py +# Indexation et découpage de tableaux NumPy en Python +np_list = np.array([(1,2,3), (4,5,6)]) +np_list + +``` + +```sh + array([[1, 2, 3], + [4, 5, 6]]) +``` + +```py +print('Première ligne : ', np_list[0]) +print('Deuxième ligne : ', np_list[1]) + +``` + +```sh + + Première ligne : [1 2 3] + Deuxième ligne : [4 5 6] +``` + +```p +print('Première colonne : ', np_list[:,0]) +print('Deuxième colonne : ', np_list[:,1]) +print('Troisième colonne : ', np_list[:,2]) + +``` + +```sh + Première colonne : [1 4] + Deuxième colonne : [2 5] + Troisième colonne : [3 6] +``` + +### Fonctions statistiques de NumPy avec exemples + +NumPy a des fonctions statistiques très utiles pour trouver le minimum, le maximum, la moyenne, la médiane, le centile, l'écart type et la variance, etc. à partir des éléments donnés dans le tableau. +Les fonctions sont expliquées ci-dessous : +Fonction statistique +Numpy est équipé de fonctions statistiques robustes comme listé ci-dessous + +- Fonctions Numpy + - Min np.min() + - Max np.max() + - Mean np.mean() + - Median np.median() + - Variance + - Percentile + - Écart type np.std() + +```python +np_normal_dis = np.random.normal(5, 0.5, 100) +np_normal_dis +## min, max, mean, median, sd +print('min : ', two_dimension_array.min()) +print('max : ', two_dimension_array.max()) +print('mean : ',two_dimension_array.mean()) +# print('median : ', two_dimension_array.median()) +print('sd : ', two_dimension_array.std()) +``` + + min : 1 + max : 55 + mean : 14.777777777777779 + sd : 18.913709183069525 + +```python +min : 1 +max : 55 +mean : 14.777777777777779 +sd : 18.913709183069525 +``` + +```python +print(two_dimension_array) +print('Colonne avec le minimum : ', np.amin(two_dimension_array,axis=0)) +print('Colonne avec le maximum : ', np.amax(two_dimension_array,axis=0)) +print('=== Ligne ===') +print('Ligne avec le minimum : ', np.amin(two_dimension_array,axis=1)) +print('Ligne avec le maximum : ', np.amax(two_dimension_array,axis=1)) +``` + + [[ 1 2 3] + [ 4 55 44] + [ 7 8 9]] + Colonne avec le minimum : [1 2 3] + Colonne avec le maximum : [ 7 55 44] + === Ligne == + Ligne avec le minimum : [1 4 7] + Ligne avec le maximum : [ 3 55 9] + +### Comment créer des séquences répétitives ? + +```python +a = [1,2,3] + +# Répéter tout 'a' deux fois +print('Répétition : ', np.tile(a, 2)) + +# Répéter chaque élément de 'a' deux fois +print('Répéter : ', np.repeat(a, 2)) + +``` + + Tile : [1 2 3 1 2 3] + Repeat : [1 1 2 2 3 3] + +### Comment générer des nombres aléatoires ? + +```python +# Un nombre aléatoire entre [0,1) +one_random_num = np.random.random() +one_random_in = np.random +print(one_random_num) +``` + + 0.6149403282678213 + +```python +0.4763968133790438 +``` + + 0.4763968133790438 + +```python +# Nombres aléatoires entre [0,1) de forme 2,3 +r = np.random.random(size=[2,3]) +print(r) +``` + + [[0.13031737 0.4429537 0.1129527 ] + [0.76811539 0.88256594 0.6754075 ]] + +```python +print(np.random.choice(['a', 'e', 'i', 'o', 'u'], size=10)) +``` + + ['u' 'o' 'o' 'i' 'e' 'e' 'u' 'o' 'u' 'a'] + +```python +['i' 'u' 'e' 'o' 'a' 'i' 'e' 'u' 'o' 'i'] +``` + + ['iueoaieuoi'] + +```python +## Nombres aléatoires entre [0, 1] de forme 2, 2 +rand = np.random.rand(2,2) +rand +``` + + array([[0.97992598, 0.79642484], + [0.65263629, 0.55763145]]) + +```python +rand2 = np.random.randn(2,2) +rand2 + +``` + + array([[ 1.65593322, -0.52326621], + [ 0.39071179, -2.03649407]]) + +```python +# Entiers aléatoires entre [0, 10) de forme 2,5 +rand_int = np.random.randint(0, 10, size=[5,3]) +rand_int +``` + + array([[0, 7, 5], + [4, 1, 4], + [3, 5, 3], + [4, 3, 8], + [4, 6, 7]]) + +```py +from scipy import stats +np_normal_dis = np.random.normal(5, 0.5, 1000) # moyenne, écart type, nombre d'échantillons +np_normal_dis +## min, max, mean, median, sd +print('min : ', np.min(np_normal_dis)) +print('max : ', np.max(np_normal_dis)) +print('mean : ', np.mean(np_normal_dis)) +print('median : ', np.median(np_normal_dis)) +print('mode : ', stats.mode(np_normal_dis)) +print('sd : ', np.std(np_normal_dis)) +``` + +```sh + + min : 3.557811005458804 + max : 6.876317743643499 + mean : 5.035832048106663 + median : 5.020161980441937 + mode : ModeResult(mode=array([3.55781101]), count=array([1])) + sd : 0.489682424165213 + +``` + +```python +plt.hist(np_normal_dis, color="grey", bins=21) +plt.show() +``` + +![png](../test_files/test_121_0.png) + +```python +# numpy.dot() : Produit scalaire en Python avec Numpy +# Produit scalaire +# Numpy est une bibliothèque puissante pour le calcul matriciel. Par exemple, vous pouvez calculer le produit scalaire avec np.dot + +# Syntaxe + +# numpy.dot(x, y, out=None) +``` + +### Algèbre linéaire + +1. Produit scalaire + +```python +## Algèbre linéaire +### Produit scalaire : produit de deux tableaux +f = np.array([1,2,3]) +g = np.array([4,5,3]) +### 1*4+2*5 + 3*6 +np.dot(f, g) # 23 +``` + +### Multiplication de matrices NumPy avec np.matmul() + +```python +### Matmul : produit matriciel de deux tableaux +h = [[1,2],[3,4]] +i = [[5,6],[7,8]] +### 1*5+2*7 = 19 +np.matmul(h, i) +``` + +```sh + array([[19, 22], + [43, 50]]) + +``` + +```py +## Déterminant d'une matrice 2*2 +### 5*8-7*6np.linalg.det(i) +``` + +```python +np.linalg.det(i) +``` + + -1.999999999999999 + +```python +Z = np.zeros((8,8)) +Z[1::2,::2] = 1 +Z[::2,1::2] = 1 +``` + +```python +Z +``` + + array([[0., 1., 0., 1., 0., 1., 0., 1.], + [1., 0., 1., 0., 1., 0., 1., 0.], + [0., 1., 0., 1., 0., 1., 0., 1.], + [1., 0., 1., 0., 1., 0., 1., 0.], + [0., 1., 0., 1., 0., 1., 0., 1.], + [1., 0., 1., 0., 1., 0., 1., 0.], + [0., 1., 0., 1., 0., 1., 0., 1.], + [1., 0., 1., 0., 1., 0., 1., 0.]]) + +```python +new_list = [ x + 2 for x in range(0, 11)] +``` + +```python +new_list +``` + + [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] + +```python +[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] +``` + + [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] + +```python +np_arr = np.array(range(0, 11)) +np_arr + 2 +``` + +array([ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]) + +Nous utilisons les équations linéaires pour des quantités qui ont une relation linéaire. Voir l'exemple ci-dessous : + +```python +temp = np.array([1,2,3,4,5]) +pressure = temp * 2 + 5 +pressure +``` + +array([ 7, 9, 11, 13, 15]) + +```python +plt.plot(temp,pressure) +plt.xlabel('Température en oC') +plt.ylabel('Pression en atm') +plt.title('Température vs Pression') +plt.xticks(np.arange(0, 6, step=0.5)) +plt.show() +``` + +![png](../test_files/test_141_0.png) + +Pour tracer la distribution normale gaussienne en utilisant numpy. Comme vous pouvez le voir ci-dessous, numpy peut générer des nombres aléatoires. Pour créer un échantillon aléatoire, nous avons besoin de la moyenne (mu), de sigma (écart type) et du nombre de points de données. + +```python +mu = 28 +sigma = 15 +samples = 100000 + +x = np.random.normal(mu, sigma, samples) +ax = sns.distplot(x); +ax.set(xlabel="x", ylabel='y') +plt.show() +``` + +![png](../test_files/test_143_0.png) + +# Résumé + +Pour résumer, les principales différences avec les listes Python sont : + +1. Les tableaux supportent les opérations vectorisées, contrairement aux listes. +1. Une fois qu'un tableau est créé, vous ne pouvez pas changer sa taille. Vous devez créer un nouveau tableau ou écraser l'existant. +1. Chaque tableau a un et un seul dtype. Tous les éléments doivent être de ce dtype. +1. Un tableau numpy équivalent occupe beaucoup moins d'espace qu'une liste Python de listes. +1. Les tableaux numpy supportent l'indexation booléenne. + +## 💻 Exercices : Jour 24 + +1. Répétez tous les exemples + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 23](./23_virtual_environment_fr.md) | [Jour 25 >>](./25_pandas_fr.md) diff --git a/French/25_pandas_fr.md b/French/25_pandas_fr.md new file mode 100644 index 000000000..ae448f305 --- /dev/null +++ b/French/25_pandas_fr.md @@ -0,0 +1,1216 @@ +
+

30 Jours de Python : Jour 25 - Pandas

+ + + + + Twitter Follow + + + Auteur : + Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + + +
+ +[<< Jour 24](./24_statistics_fr.md) | [Jour 26 >>](./26_python_web_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 25](#-jour-25) + - [Pandas](#pandas) + - [Installer Pandas](#installer-pandas) + - [Importer Pandas](#importer-pandas) + - [Créer une série Pandas avec l'index par défaut](#créer-une-série-pandas-avec-lindex-par-défaut) + - [Créer une série Pandas avec un index personnalisé](#créer-une-série-pandas-avec-un-index-personnalisé) + - [Créer une série Pandas à partir d'un dictionnaire](#créer-une-série-pandas-à-partir-dun-dictionnaire) + - [Créer une série Pandas constante](#créer-une-série-pandas-constante) + - [Créer une série Pandas avec Linspace](#créer-une-série-pandas-avec-linspace) + - [DataFrames](#dataframes) + - [Créer des DataFrames à partir d'une liste de listes](#créer-des-dataframes-à-partir-dune-liste-de-listes) + - [Créer un DataFrame avec un dictionnaire](#créer-un-dataframe-avec-un-dictionnaire) + - [Créer des DataFrames à partir d'une liste de dictionnaires](#créer-des-dataframes-à-partir-dune-liste-de-dictionnaires) + - [Lire un fichier CSV avec Pandas](#lire-un-fichier-csv-avec-pandas) + - [Exploration des données](#exploration-des-données) + - [Modifier un DataFrame](#modifier-un-dataframe) + - [Créer un DataFrame](#créer-un-dataframe) + - [Ajouter une nouvelle colonne](#ajouter-une-nouvelle-colonne) + - [Modifier les valeurs d'une colonne](#modifier-les-valeurs-dune-colonne) + - [Formater les colonnes d'un DataFrame](#formater-les-colonnes-dun-dataframe) + - [Vérifier les types de données des colonnes](#vérifier-les-types-de-données-des-colonnes) + - [Indexation booléenne](#indexation-booléenne) + - [Exercices : Jour 25](#exercices-jour-25) + +# 📘 Jour 25 + +## Pandas + +Pandas est une bibliothèque open source, haute performance et facile à utiliser, fournissant des structures de données et des outils d'analyse de données pour le langage de programmation Python. +Pandas ajoute des structures de données et des outils conçus pour travailler avec des données tabulaires, à savoir les *Series* et les *DataFrames*. +Pandas fournit des outils de manipulation de données : + +- remaniement (reshaping) +- fusion (merging) +- tri (sorting) +- découpage (slicing) +- agrégation (aggregation) +- imputation (imputation) +Si vous utilisez anaconda, vous n'avez pas besoin d'installer pandas. + +### Installer Pandas + +Pour Mac : +```py +pip install conda +conda install pandas +``` + +Pour Windows : +```py +pip install conda +pip install pandas +``` + +La structure de données de Pandas est basée sur les *Series* et les *DataFrames*. + +Une *series* est une *colonne* et un DataFrame est une *table multidimensionnelle* composée d'un ensemble de *series*. Pour créer une série pandas, nous devons utiliser numpy pour créer un tableau unidimensionnel ou une liste Python. +Voyons un exemple de série : + +Série Pandas des noms + +![pandas series](../images/pandas-series-1.png) + +Série des pays + +![pandas series](../images/pandas-series-2.png) + +Série des villes + +![pandas series](../images/pandas-series-3.png) + +Comme vous pouvez le voir, une série pandas est juste une colonne de données. Si nous voulons avoir plusieurs colonnes, nous utilisons les data frames. L'exemple ci-dessous montre les DataFrames pandas. + +Voyons un exemple de data frame pandas : + +![Pandas data frame](../images/pandas-dataframe-1.png) + +Un data frame est un ensemble de lignes et de colonnes. Regardez le tableau ci-dessous ; il a beaucoup plus de colonnes que l'exemple ci-dessus : + +![Pandas data frame](../images/pandas-dataframe-2.png) + +Ensuite, nous verrons comment importer pandas et comment créer des Series et des DataFrames avec pandas. + +### Importer Pandas + +```python +import pandas as pd # importation de pandas en tant que pd +import numpy as np # importation de numpy en tant que np +``` + +### Créer une série Pandas avec l'index par défaut + +```python +nums = [1, 2, 3, 4,5] +s = pd.Series(nums) +print(s) +``` + +```sh + 0 1 + 1 2 + 2 3 + 3 4 + 4 5 + dtype: int64 +``` + +### Créer une série Pandas avec un index personnalisé + +```python +nums = [1, 2, 3, 4, 5] +s = pd.Series(nums, index=[1, 2, 3, 4, 5]) +print(s) +``` + +```sh + 1 1 + 2 2 + 3 3 + 4 4 + 5 5 + dtype: int64 +``` + +```python +fruits = ['Orange','Banana','Mango'] +fruits = pd.Series(fruits, index=[1, 2, 3]) +print(fruits) +``` + +```sh + 1 Orange + 2 Banana + 3 Mango + dtype: object +``` + +### Créer une série Pandas à partir d'un dictionnaire + +```python +dct = {'name':'Asabeneh','country':'Finland','city':'Helsinki'} +``` + +```python +s = pd.Series(dct) +print(s) +``` + +```sh + name Asabeneh + country Finland + city Helsinki + dtype: object +``` + +### Créer une série Pandas constante + +```python +s = pd.Series(10, index = [1, 2, 3]) +print(s) +``` + +```sh + 1 10 + 2 10 + 3 10 + dtype: int64 +``` + +### Créer une série Pandas avec Linspace + +```python +s = pd.Series(np.linspace(5, 20, 10)) # linspace(début, fin, éléments) +print(s) +``` + +```sh + 0 5.000000 + 1 6.666667 + 2 8.333333 + 3 10.000000 + 4 11.666667 + 5 13.333333 + 6 15.000000 + 7 16.666667 + 8 18.333333 + 9 20.000000 + dtype: float64 +``` + +## DataFrames + +Les data frames pandas peuvent être créés de différentes manières. + +### Créer des DataFrames à partir d'une liste de listes + +```python +data = [ + ['Asabeneh', 'Finland', 'Helsink'], + ['David', 'UK', 'London'], + ['John', 'Sweden', 'Stockholm'] +] +df = pd.DataFrame(data, columns=['Names','Country','City']) +print(df) +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NamesCountryCity
0AsabenehFinlandHelsink
1DavidUKLondon
2JohnSwedenStockholm
+ +### Créer un DataFrame avec un dictionnaire + +```python +data = {'Name': ['Asabeneh', 'David', 'John'], 'Country':[ + 'Finland', 'UK', 'Sweden'], 'City': ['Helsiki', 'London', 'Stockholm']} +df = pd.DataFrame(data) +print(df) +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameCountryCity
0AsabenehFinlandHelsiki
1DavidUKLondon
2JohnSwedenStockholm
+ +### Créer des DataFrames à partir d'une liste de dictionnaires + +```python +data = [ + {'Name': 'Asabeneh', 'Country': 'Finland', 'City': 'Helsinki'}, + {'Name': 'David', 'Country': 'UK', 'City': 'London'}, + {'Name': 'John', 'Country': 'Sweden', 'City': 'Stockholm'}] +df = pd.DataFrame(data) +print(df) +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameCountryCity
0AsabenehFinlandHelsinki
1DavidUKLondon
2JohnSwedenStockholm
+ +## Lire un fichier CSV avec Pandas + +Pour télécharger le fichier CSV nécessaire dans cet exemple, la console ou la ligne de commande suffit : + +```sh +curl -O https://raw.githubusercontent.com/Asabeneh/30-Days-Of-Python/master/data/weight-height.csv +``` + +Placez le fichier téléchargé dans votre répertoire de travail. + +```python +import pandas as pd + +df = pd.read_csv('weight-height.csv') +print(df) +``` + +### Exploration des données + +Lisons seulement les 5 premières lignes avec head() + +```python +print(df.head()) # donne cinq lignes, on peut augmenter le nombre en passant un argument à head() +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
GenderHeightWeight
0Male73.847017241.893563
1Male68.781904162.310473
2Male74.110105212.740856
3Male71.730978220.042470
4Male69.881796206.349801
+ +Explorons également les derniers enregistrements du dataframe avec la méthode tail(). + +```python +print(df.tail()) # tail donne les cinq dernières lignes, on peut augmenter le nombre en passant un argument à tail() +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
GenderHeightWeight
9995Female66.172652136.777454
9996Female67.067155170.867906
9997Female63.867992128.475319
9998Female69.034243163.852461
9999Female61.944246113.649103
+ +Comme vous pouvez le voir, le fichier csv a trois colonnes : Gender, Height et Weight. Si le DataFrame avait beaucoup de lignes, il serait difficile de connaître toutes les colonnes. Par conséquent, nous devons utiliser une méthode pour connaître les colonnes. Nous ne connaissons pas non plus le nombre de lignes. Utilisons la méthode shape. + +```python +print(df.shape) # comme vous pouvez le voir, 10000 lignes et trois colonnes +``` + + (10000, 3) + +Obtenons toutes les colonnes en utilisant columns. + +```python +print(df.columns) +``` + + Index(['Gender', 'Height', 'Weight'], dtype='object') + +Maintenant, obtenons une colonne spécifique en utilisant la clé de la colonne + +```python +heights = df['Height'] # c'est maintenant une série +``` + +```python +print(heights) +``` + +```sh + 0 73.847017 + 1 68.781904 + 2 74.110105 + 3 71.730978 + 4 69.881796 + ... + 9995 66.172652 + 9996 67.067155 + 9997 63.867992 + 9998 69.034243 + 9999 61.944246 + Name: Height, Length: 10000, dtype: float64 +``` + +```python +weights = df['Weight'] # c'est maintenant une série +``` + +```python +print(weights) +``` + +```sh + 0 241.893563 + 1 162.310473 + 2 212.740856 + 3 220.042470 + 4 206.349801 + ... + 9995 136.777454 + 9996 170.867906 + 9997 128.475319 + 9998 163.852461 + 9999 113.649103 + Name: Weight, Length: 10000, dtype: float64 +``` + +```python +print(len(heights) == len(weights)) +``` + + True + +La méthode describe() fournit des valeurs statistiques descriptives d'un ensemble de données. + +```python +print(heights.describe()) # donne des informations statistiques sur les données de taille +``` + +```sh + count 10000.000000 + mean 66.367560 + std 3.847528 + min 54.263133 + 25% 63.505620 + 50% 66.318070 + 75% 69.174262 + max 78.998742 + Name: Height, dtype: float64 +``` + +```python +print(weights.describe()) +``` + +```sh + count 10000.000000 + mean 161.440357 + std 32.108439 + min 64.700127 + 25% 135.818051 + 50% 161.212928 + 75% 187.169525 + max 269.989699 + Name: Weight, dtype: float64 +``` + +```python +print(df.describe()) # describe peut aussi donner des informations statistiques d'un DataFrame +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
HeightWeight
count10000.00000010000.000000
mean66.367560161.440357
std3.84752832.108439
min54.26313364.700127
25%63.505620135.818051
50%66.318070161.212928
75%69.174262187.169525
max78.998742269.989699
+ +De la même manière que describe(), la méthode info() donne aussi des informations sur l'ensemble de données. + +## Modifier un DataFrame + +Modifier un DataFrame : + * Nous pouvons créer un nouveau DataFrame + * Nous pouvons créer une nouvelle colonne et l'ajouter au DataFrame, + * nous pouvons supprimer une colonne existante d'un DataFrame, + * nous pouvons modifier une colonne existante dans un DataFrame, + * nous pouvons changer le type de données des valeurs d'une colonne dans le DataFrame + +### Créer un DataFrame + +Comme toujours, nous importons d'abord les paquets nécessaires. Importons pandas et numpy, les deux meilleurs amis du monde. + +```python +import pandas as pd +import numpy as np +data = [ + {"Name": "Asabeneh", "Country":"Finland","City":"Helsinki"}, + {"Name": "David", "Country":"UK","City":"London"}, + {"Name": "John", "Country":"Sweden","City":"Stockholm"}] +df = pd.DataFrame(data) +print(df) +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameCountryCity
0AsabenehFinlandHelsinki
1DavidUKLondon
2JohnSwedenStockholm
+ +Ajouter une colonne à un DataFrame est comme ajouter une clé à un dictionnaire. + +Utilisons d'abord l'exemple précédent pour créer un DataFrame. Après avoir créé le DataFrame, nous allons commencer à modifier les colonnes et leurs valeurs. + +### Ajouter une nouvelle colonne + +Ajoutons une colonne weight dans le DataFrame + +```python +weights = [74, 78, 69] +df['Weight'] = weights +df +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameCountryCityWeight
0AsabenehFinlandHelsinki74
1DavidUKLondon78
2JohnSwedenStockholm69
+ +Ajoutons aussi une colonne height dans le DataFrame + +```python +heights = [173, 175, 169] +df['Height'] = heights +print(df) +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameCountryCityWeightHeight
0AsabenehFinlandHelsinki74173
1DavidUKLondon78175
2JohnSwedenStockholm69169
+ +Comme vous pouvez le voir dans le DataFrame ci-dessus, nous avons ajouté de nouvelles colonnes, Weight et Height. Ajoutons une colonne supplémentaire appelée BMI (Body Mass Index) en calculant leur IMC à partir de leur masse et de leur taille. L'IMC est la masse divisée par la taille au carré (en mètres) - Weight/Height * Height. + +Comme vous pouvez le voir, la taille est en centimètres, nous devons donc la convertir en mètres. Modifions la ligne Height. + +### Modifier les valeurs d'une colonne + +```python +df['Height'] = df['Height'] * 0.01 +df +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameCountryCityWeightHeight
0AsabenehFinlandHelsinki741.73
1DavidUKLondon781.75
2JohnSwedenStockholm691.69
+ +```python +# Utiliser des fonctions rend notre code propre, mais vous pouvez calculer l'IMC sans +def calculate_bmi (): + weights = df['Weight'] + heights = df['Height'] + bmi = [] + for w,h in zip(weights, heights): + b = w/(h*h) + bmi.append(b) + return bmi + +bmi = calculate_bmi() + +``` + + +```python +df['BMI'] = bmi +df +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameCountryCityWeightHeightBMI
0AsabenehFinlandHelsinki741.7324.725183
1DavidUKLondon781.7525.469388
2JohnSwedenStockholm691.6924.158818
+ +### Formater les colonnes d'un DataFrame + +Les valeurs de la colonne BMI du DataFrame sont des flottants avec beaucoup de chiffres significatifs après la virgule. Changeons-les pour un seul chiffre significatif après la virgule. + +```python +df['BMI'] = round(df['BMI'], 1) +print(df) +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameCountryCityWeightHeightBMI
0AsabenehFinlandHelsinki741.7324.7
1DavidUKLondon781.7525.5
2JohnSwedenStockholm691.6924.2
+ +Les informations dans le DataFrame semblent encore incomplètes, ajoutons les colonnes birth year et current year. + +```python +birth_year = ['1769', '1985', '1990'] +current_year = pd.Series(2020, index=[0, 1,2]) +df['Birth Year'] = birth_year +df['Current Year'] = current_year +df +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameCountryCityWeightHeightBMIBirth YearCurrent Year
0AsabenehFinlandHelsinki741.7324.717692020
1DavidUKLondon781.7525.519852020
2JohnSwedenStockholm691.6924.219902020
+ +## Vérifier les types de données des colonnes + +```python +print(df.Weight.dtype) +``` + +```sh + dtype('int64') +``` + +```python +df['Birth Year'].dtype # c'est un objet chaîne, nous devons le changer en nombre + +``` + +```python +df['Birth Year'] = df['Birth Year'].astype('int') +print(df['Birth Year'].dtype) # vérifions le type maintenant +``` + +```sh + dtype('int32') +``` + +Faisons de même pour l'année courante : + +```python +df['Current Year'] = df['Current Year'].astype('int') +df['Current Year'].dtype +``` + +```sh + dtype('int32') +``` + +Maintenant, les valeurs des colonnes birth year et current year sont des entiers. Nous pouvons calculer l'âge. + +```python +ages = df['Current Year'] - df['Birth Year'] +ages +``` + + 0 251 + 1 35 + 2 30 + dtype: int32 + +```python +df['Ages'] = ages +print(df) +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameCountryCityWeightHeightBMIBirth YearCurrent YearAges
0AsabenehFinlandHelsinki741.7324.717692019250
1DavidUKLondon781.7525.51985201934
2JohnSwedenStockholm691.6924.21990201929
+ +La personne de la première ligne a vécu 251 ans. Il est peu probable que quelqu'un vive aussi longtemps. Soit c'est une erreur de saisie, soit les données sont falsifiées. Remplaçons donc cette valeur par la moyenne des colonnes sans inclure la valeur aberrante. + +mean = (35 + 30) / 2 + +```python +mean = (35 + 30) / 2 +print('Moyenne : ', mean) # il est bon d'ajouter une description à la sortie, pour savoir de quoi il s'agit +``` + +```sh + Moyenne : 32.5 +``` + +### Indexation booléenne + +```python +print(df[df['Ages'] > 120]) +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameCountryCityWeightHeightBMIBirth YearCurrent YearAges
0AsabenehFinlandHelsinki741.7324.717692020251
+ + +```python +print(df[df['Ages'] < 120]) +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameCountryCityWeightHeightBMIBirth YearCurrent YearAges
1DavidUKLondon781.7525.51985202035
2JohnSwedenStockholm691.6924.21990202030
+ +## Exercices : Jour 25 + +1. Lisez le fichier hacker_news.csv depuis le dossier data +1. Obtenez les cinq premières lignes +1. Obtenez les cinq dernières lignes +1. Obtenez la colonne title sous forme de série pandas +1. Comptez le nombre de lignes et de colonnes + - Filtrez les titres qui contiennent python + - Filtrez les titres qui contiennent JavaScript + - Explorez les données et donnez-leur un sens + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 24](./24_statistics_fr.md) | [Jour 26 >>](./26_python_web_fr.md) diff --git a/French/26_python_web_fr.md b/French/26_python_web_fr.md new file mode 100644 index 000000000..8c2f07aaf --- /dev/null +++ b/French/26_python_web_fr.md @@ -0,0 +1,570 @@ +
+

30 Jours de Python : Jour 26 - Python pour le web

+ + + + + Twitter Follow + + + Auteur : + Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + +
+ +[<< Jour 25](./25_pandas_fr.md) | [Jour 27 >>](./27_python_with_mongodb_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 26](#-jour-26) + - [Python pour le web](#python-pour-le-web) + - [Flask](#flask) + - [Structure des dossiers](#structure-des-dossiers) + - [Configurer votre dossier de projet](#configurer-votre-dossier-de-projet) + - [Créer des routes](#créer-des-routes) + - [Créer des templates](#créer-des-templates) + - [Script Python](#script-python) + - [Navigation](#navigation) + - [Créer une mise en page](#créer-une-mise-en-page) + - [Servir des fichiers statiques](#servir-des-fichiers-statiques) + - [Déploiement](#déploiement) + - [Créer un compte Heroku](#créer-un-compte-heroku) + - [Se connecter à Heroku](#se-connecter-à-heroku) + - [Créer requirements et Procfile](#créer-requirements-et-procfile) + - [Pousser le projet vers heroku](#pousser-le-projet-vers-heroku) + - [Exercices : Jour 26](#exercices-jour-26) + +# 📘 Jour 26 + +## Python pour le web + +Python est un langage de programmation généraliste et peut être utilisé dans de nombreux domaines. Dans cette section, nous verrons comment utiliser Python pour le web. Il existe de nombreux frameworks web Python. Django et Flask sont les plus populaires. Aujourd'hui, nous allons voir comment utiliser Flask pour le développement web. + +### Flask + +Flask est un framework de développement web écrit en Python. Flask utilise le moteur de template Jinja2. Flask peut également être utilisé avec d'autres bibliothèques front modernes telles que React. + +Si vous n'avez pas encore installé le paquet virtualenv, installez-le d'abord. L'environnement virtuel permettra d'isoler les dépendances du projet de celles de la machine locale. + +#### Structure des dossiers + +Après avoir terminé toutes les étapes, la structure de votre projet devrait ressembler à ceci : + +```sh + +├── Procfile +├── app.py +├── env +│   ├── bin +├── requirements.txt +├── static +│   └── css +│   └── main.css +└── templates + ├── about.html + ├── home.html + ├── layout.html + ├── post.html + └── result.html +``` + +### Configurer votre dossier de projet + +Suivez les étapes suivantes pour commencer avec Flask. + +Étape 1 : installez virtualenv en utilisant la commande suivante. + +```sh +pip install virtualenv +``` + +Étape 2 : + +```sh +asabeneh@Asabeneh:~/Desktop$ mkdir python_for_web +asabeneh@Asabeneh:~/Desktop$ cd python_for_web/ +asabeneh@Asabeneh:~/Desktop/python_for_web$ virtualenv venv +asabeneh@Asabeneh:~/Desktop/python_for_web$ source venv/bin/activate +(env) asabeneh@Asabeneh:~/Desktop/python_for_web$ pip freeze +(env) asabeneh@Asabeneh:~/Desktop/python_for_web$ pip install Flask +(env) asabeneh@Asabeneh:~/Desktop/python_for_web$ pip freeze +Click==7.0 +Flask==1.1.1 +itsdangerous==1.1.0 +Jinja2==2.10.3 +MarkupSafe==1.1.1 +Werkzeug==0.16.0 +(env) asabeneh@Asabeneh:~/Desktop/python_for_web$ +``` + +Nous avons créé un dossier de projet nommé python_for_web. Dans le projet, nous avons créé un environnement virtuel *venv* (qui pourrait avoir n'importe quel nom mais je préfère l'appeler _venv_). Ensuite, nous avons activé l'environnement virtuel. Nous avons utilisé pip freeze pour vérifier les paquets installés dans le dossier du projet. Le résultat de pip freeze était vide car aucun paquet n'était encore installé. + +Maintenant, créons le fichier app.py dans le dossier du projet et écrivons le code suivant. Le fichier app.py sera le fichier principal du projet. Le code suivant a le module flask et le module os. + +### Créer des routes + +La route d'accueil. + +```py +# importons flask +from flask import Flask +import os # importation du module système d'exploitation + +app = Flask(__name__) + +@app.route('/') # ce décorateur crée la route d'accueil +def home (): + return '

Bienvenue

' + +if __name__ == '__main__': + # pour le déploiement nous utilisons environ + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +Pour exécuter l'application Flask, tapez python app.py dans le répertoire principal de l'application Flask. + +Après avoir exécuté _python app.py_, vérifiez le localhost 5000. + +Ajoutons une route supplémentaire. +Création de la route about + +```py +# importons flask +from flask import Flask +import os # importation du module système d'exploitation + +app = Flask(__name__) + +@app.route('/') # ce décorateur crée la route d'accueil +def home (): + return '

Bienvenue

' + +@app.route('/about') +def about(): + return '

À propos

' + +if __name__ == '__main__': + # pour le déploiement nous utilisons environ + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +Maintenant, nous avons ajouté la route about dans le code ci-dessus. Et si nous voulions afficher un fichier HTML au lieu d'une chaîne ? Il est possible d'afficher un fichier HTML en utilisant la fonction *render_template*. Créons un dossier appelé templates et créons les fichiers home.html et about.html dans le dossier du projet. Importons également la fonction *render_template* depuis flask. + +### Créer des templates + +Créez les fichiers HTML dans le dossier templates. + +home.html + +```html + + + + + + Accueil + + + +

Bienvenue

+ + +``` + +about.html + +```html + + + + + + À propos + + + +

À propos de nous

+ + +``` + +### Script Python + +app.py + +```py +# importons flask +from flask import Flask, render_template +import os # importation du module système d'exploitation + +app = Flask(__name__) + +@app.route('/') # ce décorateur crée la route d'accueil +def home (): + return render_template('home.html') + +@app.route('/about') +def about(): + return render_template('about.html') + +if __name__ == '__main__': + # pour le déploiement nous utilisons environ + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +Comme vous pouvez le voir, pour accéder à différentes pages ou naviguer, nous avons besoin d'une navigation. Ajoutons un lien vers chaque page ou créons une mise en page que nous utiliserons pour chaque page. + +### Navigation + +```html + +``` + +Maintenant, nous pouvons naviguer entre les pages en utilisant le lien ci-dessus. Créons une page supplémentaire qui gère les données de formulaire. Vous pouvez l'appeler comme vous voulez, j'aime l'appeler post.html. + +Nous pouvons injecter des données dans les fichiers HTML en utilisant le moteur de template Jinja2. + +```py +# importons flask +from flask import Flask, render_template, request, redirect, url_for +import os # importation du module système d'exploitation + +app = Flask(__name__) + +@app.route('/') # ce décorateur crée la route d'accueil +def home (): + techs = ['HTML', 'CSS', 'Flask', 'Python'] + name = '30 Days Of Python Programming' + return render_template('home.html', techs=techs, name = name, title = 'Accueil') + +@app.route('/about') +def about(): + name = '30 Days Of Python Programming' + return render_template('about.html', name = name, title = 'À propos') + +@app.route('/post') +def post(): + name = 'Analyseur de texte' + return render_template('post.html', name = name, title = name) + + +if __name__ == '__main__': + # pour le déploiement + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +Voyons aussi les templates : + +home.html + +```html + + + + + + Accueil + + + + +

Bienvenue sur {{name}}

+
    + {% for tech in techs %} +
  • {{tech}}
    • + {% endfor %} +
+ + +``` + +about.html + +```html + + + + + + À propos + + + + +

À propos de nous

+

{{name}}

+ + +``` + +### Créer une mise en page + +Dans les fichiers templates, il y a beaucoup de code répété, nous pouvons écrire une mise en page et supprimer la répétition. Créons layout.html dans le dossier templates. +Après avoir créé la mise en page, nous l'importerons dans chaque fichier. + +#### Servir des fichiers statiques + +Créez un dossier static dans votre dossier de projet. Dans le dossier static, créez un dossier CSS ou styles et créez une feuille de style CSS. Nous utilisons le module *url_for* pour servir les fichiers statiques. + +layout.html + +```html + + + + + + + + {% if title %} + 30 Days of Python - {{ title}} + {% else %} + 30 Days of Python + {% endif %} + + + +
+
+ + +
+
+
+ {% block content %} {% endblock %} +
+ + +``` + +Maintenant, supprimons tout le code répété dans les autres fichiers templates et importons layout.html. Le href utilise la fonction _url_for_ avec le nom de la fonction de route pour connecter chaque route de navigation. + +home.html + +```html +{% extends 'layout.html' %} {% block content %} +
+

Bienvenue sur {{name}}

+

+ Cette application nettoie les textes et analyse le nombre de mots, de caractères et + les mots les plus fréquents dans le texte. Essayez-la en cliquant sur analyseur de texte dans le + menu. Vous avez besoin des technologies suivantes pour construire cette application web : +

+
    + {% for tech in techs %} +
  • {{tech}}
    • + + {% endfor %} +
+
+ +{% endblock %} +``` + +about.html + +```html +{% extends 'layout.html' %} {% block content %} +
+

À propos {{name}}

+

+ Ceci est un défi de programmation de 30 jours de Python. Si vous avez codé + jusqu'ici, vous êtes génial. Félicitations pour le travail accompli ! +

+
+{% endblock %} +``` + +post.html + +```html +{% extends 'layout.html' %} {% block content %} +
+

Analyseur de texte

+
+
+ +
+
+ +
+
+
+ +{% endblock %} +``` + +Les méthodes de requête, il existe différentes méthodes de requête (GET, POST, PUT, DELETE) qui sont les méthodes de requête courantes permettant d'effectuer des opérations CRUD (Create, Read, Update, Delete). + +Dans la route post, nous utiliserons les méthodes GET et POST de manière alternative selon le type de requête, regardez à quoi cela ressemble dans le code ci-dessous. La méthode request est une fonction pour gérer les méthodes de requête et aussi pour accéder aux données du formulaire. +app.py + +```py +# importons flask +from flask import Flask, render_template, request, redirect, url_for +import os # importation du module système d'exploitation + +app = Flask(__name__) +# pour arrêter la mise en cache des fichiers statiques +app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0 + + + +@app.route('/') # ce décorateur crée la route d'accueil +def home (): + techs = ['HTML', 'CSS', 'Flask', 'Python'] + name = '30 Days Of Python Programming' + return render_template('home.html', techs=techs, name = name, title = 'Accueil') + +@app.route('/about') +def about(): + name = '30 Days Of Python Programming' + return render_template('about.html', name = name, title = 'À propos') + +@app.route('/result') +def result(): + return render_template('result.html') + +@app.route('/post', methods= ['GET','POST']) +def post(): + name = 'Analyseur de texte' + if request.method == 'GET': + return render_template('post.html', name = name, title = name) + if request.method =='POST': + content = request.form['content'] + print(content) + return redirect(url_for('result')) + +if __name__ == '__main__': + # pour le déploiement + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +Jusqu'à présent, nous avons vu comment utiliser un template, comment injecter des données dans un template, et comment créer une mise en page commune. +Maintenant, gérons les fichiers statiques. Créez un dossier appelé static dans le dossier du projet et créez un dossier appelé css. Dans le dossier css, créez main.css. Votre fichier main.css sera lié au layout.html. + +Vous n'avez pas besoin d'écrire le fichier css, copiez-le et utilisez-le. Passons au déploiement. + +### Déploiement + +#### Créer un compte Heroku + +Heroku fournit un service de déploiement gratuit pour les applications front-end et full-stack. Créez un compte sur [heroku](https://www.heroku.com/) et installez le [CLI](https://devcenter.heroku.com/articles/heroku-cli) heroku pour votre machine. +Après avoir installé heroku, tapez la commande suivante : + +#### Se connecter à Heroku + +```sh +asabeneh@Asabeneh:~$ heroku login +heroku: Press any key to open up the browser to login or q to exit: +``` + +Voyons le résultat en cliquant sur n'importe quelle touche du clavier. Lorsque vous appuyez sur n'importe quelle touche, cela ouvrira la page de connexion heroku et cliquez sur le bouton de connexion. Ensuite, votre machine locale sera connectée au serveur distant heroku. Si vous êtes connecté au serveur distant, vous verrez ceci. + +```sh +asabeneh@Asabeneh:~$ heroku login +heroku: Press any key to open up the browser to login or q to exit: +Opening browser to https://cli-auth.heroku.com/auth/browser/be12987c-583a-4458-a2c2-ba2ce7f41610 +Logging in... done +Logged in as asabeneh@gmail.com +asabeneh@Asabeneh:~$ +``` + +#### Créer requirements et Procfile + +Avant de pousser notre code vers le serveur distant, nous avons besoin de : + +- requirements.txt +- Procfile + +```sh +(env) asabeneh@Asabeneh:~/Desktop/python_for_web$ pip freeze +Click==7.0 +Flask==1.1.1 +itsdangerous==1.1.0 +Jinja2==2.10.3 +MarkupSafe==1.1.1 +Werkzeug==0.16.0 +(env) asabeneh@Asabeneh:~/Desktop/python_for_web$ touch requirements.txt +(env) asabeneh@Asabeneh:~/Desktop/python_for_web$ pip freeze > requirements.txt +(env) asabeneh@Asabeneh:~/Desktop/python_for_web$ cat requirements.txt +Click==7.0 +Flask==1.1.1 +itsdangerous==1.1.0 +Jinja2==2.10.3 +MarkupSafe==1.1.1 +Werkzeug==0.16.0 +(env) asabeneh@Asabeneh:~/Desktop/python_for_web$ touch Procfile +(env) asabeneh@Asabeneh:~/Desktop/python_for_web$ ls +Procfile env/ static/ +app.py requirements.txt templates/ +(env) asabeneh@Asabeneh:~/Desktop/python_for_web$ +``` + +Le Procfile contiendra la commande qui exécute l'application sur le serveur web, dans notre cas sur Heroku. + +```sh +web: python app.py +``` + +#### Pousser le projet vers heroku + +Maintenant, il est prêt à être déployé. Étapes pour déployer l'application sur heroku : + +1. git init +2. git add . +3. git commit -m "message du commit" +4. heroku create 'nom de l'application en un mot' +5. git push heroku master +6. heroku open (pour lancer l'application déployée) + +Après cette étape, vous obtiendrez une application comme [celle-ci](http://thirdaysofpython-practice.herokuapp.com/). + +## Exercices : Jour 26 + +1. Vous allez construire [cette application](https://thirtydaysofpython-v1-final.herokuapp.com/). Seule la partie analyseur de texte reste à faire. + + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 25](./25_pandas_fr.md) | [Jour 27 >>](./27_python_with_mongodb_fr.md) diff --git a/French/27_python_with_mongodb_fr.md b/French/27_python_with_mongodb_fr.md new file mode 100644 index 000000000..9321ac7ab --- /dev/null +++ b/French/27_python_with_mongodb_fr.md @@ -0,0 +1,660 @@ +
+

30 Jours de Python : Jour 27 - Python avec MongoDB

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+Deuxième édition : juillet 2021 + + +
+ +[<< Jour 26](./26_python_web_fr.md) | [Jour 28 >>](./28_API_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 27](#-jour-27) +- [Python avec MongoDB](#python-avec-mongodb) + - [MongoDB](#mongodb) + - [SQL versus NoSQL](#sql-versus-nosql) + - [Obtenir la chaîne de connexion (URI MongoDB)](#obtenir-la-chaîne-de-connexion-uri-mongodb) + - [Connecter l'application Flask au cluster MongoDB](#connecter-lapplication-flask-au-cluster-mongodb) + - [Créer une base de données et une collection](#créer-une-base-de-données-et-une-collection) + - [Insérer plusieurs documents dans une collection](#insérer-plusieurs-documents-dans-une-collection) + - [Trouver avec MongoDB (Find)](#trouver-avec-mongodb-find) + - [Recherche avec requête](#recherche-avec-requête) + - [Requête avec modificateur](#requête-avec-modificateur) + - [Limiter les documents](#limiter-les-documents) + - [Recherche avec tri](#recherche-avec-tri) + - [Mise à jour avec requête](#mise-à-jour-avec-requête) + - [Supprimer un document](#supprimer-un-document) + - [Supprimer une collection](#supprimer-une-collection) + - [💻 Exercices : Jour 27](#-exercices-jour-27) + +# 📘 Jour 27 + +# Python avec MongoDB + +Python est une technologie back-end et peut être connecté à différentes applications de base de données. Il peut être connecté à la fois aux bases de données SQL et NoSQL. Dans cette section, nous connectons Python avec la base de données MongoDB qui est une base de données NoSQL. + +## MongoDB + +MongoDB est une base de données NoSQL. MongoDB stocke les données dans un document de type JSON, ce qui rend MongoDB très flexible et scalable. Voyons les différentes terminologies des bases de données SQL et NoSQL. Le tableau suivant montrera la différence entre SQL et NoSQL. + +### SQL versus NoSQL + +![SQL versus NoSQL](../images/mongoDB/sql-vs-nosql.png) + +Dans cette section, nous nous concentrerons sur une base de données NoSQL : MongoDB. Inscrivons-nous sur [mongoDB](https://www.mongodb.com/) en cliquant sur le bouton sign in, puis cliquez sur register sur la page suivante. + +![MongoDB Sign up pages](../images/mongoDB/mongodb-signup-page.png) + +Remplissez les champs et cliquez sur continue. + +![Mongodb register](../images/mongoDB/mongodb-register.png) + +Sélectionnez le plan gratuit. + +![Mongodb free plan](../images/mongoDB/mongodb-free.png) + +Choisissez la région gratuite la plus proche et donnez un nom à votre cluster. + +![Mongodb cluster name](../images/mongoDB/mongodb-cluster-name.png) + +Maintenant, un sandbox gratuit est créé. + +![Mongodb sandbox](../images/mongoDB/mongodb-sandbox.png) + +Accès à tous les hôtes locaux. + +![Mongodb allow ip access](../images/mongoDB/mongodb-allow-ip-access.png) + +Ajoutez un utilisateur et un mot de passe. + +![Mongodb add user](../images/mongoDB/mongodb-add-user.png) + +Créez un lien URI mongoDB. + +![Mongodb create uri](../images/mongoDB/mongodb-create-uri.png) + +Sélectionnez le pilote Python 3.6 ou supérieur. + +![Mongodb python driver](../images/mongoDB/mongodb-python-driver.png) + +### Obtenir la chaîne de connexion (URI MongoDB) + +Copiez le lien de la chaîne de connexion et vous obtiendrez quelque chose comme ceci : + +```sh +mongodb+srv://asabeneh:@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority +``` + +Ne vous inquiétez pas pour l'URL, c'est un moyen de connecter votre application à mongoDB. +Remplaçons le placeholder du mot de passe par le mot de passe que vous avez utilisé pour ajouter un utilisateur. + +**Exemple :** + +```sh +mongodb+srv://asabeneh:123123123@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority +``` + +Maintenant, j'ai tout remplacé et le mot de passe est 123123 et le nom de la base de données est *thirty_days_python*. Ceci est juste un exemple, votre mot de passe doit être plus fort que l'exemple. + +Python a besoin d'un pilote mongoDB pour accéder à la base de données mongoDB. Nous utiliserons _pymongo_ avec _dnspython_ pour connecter notre application à mongoDB. Dans votre dossier de projet, installez pymongo et dnspython. + +```sh +pip install pymongo dnspython +``` + +Le module "dnspython" doit être installé pour utiliser les URI mongodb+srv://. Dnspython est une boîte à outils DNS pour Python. Il supporte presque tous les types d'enregistrements. + +### Connecter l'application Flask au cluster MongoDB + +```py +# importons flask +from flask import Flask, render_template +import os # importation du module système d'exploitation +MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +print(client.list_database_names()) + +app = Flask(__name__) +if __name__ == '__main__': + # pour le déploiement nous utilisons environ + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) + +``` + +Lorsque nous exécutons le code ci-dessus, nous obtenons les bases de données mongoDB par défaut. + +```sh +['admin', 'local'] +``` + +### Créer une base de données et une collection + +Créons une base de données. La base de données et la collection dans mongoDB seront créées si elles n'existent pas. Créons une base de données nommée *thirty_days_of_python* et une collection *students*. + +Pour créer une base de données : + +```sh +db = client.nom_de_la_base # nous pouvons créer une base de données comme ceci ou la deuxième façon +db = client['nom_de_la_base'] +``` + +```py +# importons flask +from flask import Flask, render_template +import os # importation du module système d'exploitation +MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +# Création de la base de données +db = client.thirty_days_of_python +# Création de la collection students et insertion d'un document +db.students.insert_one({'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250}) +print(client.list_database_names()) + +app = Flask(__name__) +if __name__ == '__main__': + # pour le déploiement nous utilisons environ + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +Après avoir créé une base de données, nous avons également créé une collection students et nous avons utilisé la méthode *insert_one()* pour insérer un document. +Maintenant, la base de données *thirty_days_of_python* et la collection *students* ont été créées et le document a été inséré. +Vérifiez votre cluster mongoDB et vous verrez à la fois la base de données et la collection. Dans la collection, il y aura un document. + +```sh +['thirty_days_of_python', 'admin', 'local'] +``` + +Si vous voyez ceci sur le cluster mongoDB, cela signifie que vous avez créé avec succès une base de données et une collection. + +![Creating database and collection](../images/mongoDB/mongodb-creating_database.png) + +Si vous avez vu sur la figure, le document a été créé avec un long identifiant qui sert de clé primaire. Chaque fois que nous créons un document, mongoDB crée un identifiant unique pour celui-ci. + +### Insérer plusieurs documents dans une collection + +La méthode *insert_one()* insère un élément à la fois. Si nous voulons insérer plusieurs documents à la fois, nous utilisons soit la méthode *insert_many()*, soit une boucle for. +Nous pouvons utiliser une boucle for pour insérer plusieurs documents à la fois. + +```py +# importons flask +from flask import Flask, render_template +import os # importation du module système d'exploitation +MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) + +students = [ + {'name':'David','country':'UK','city':'London','age':34}, + {'name':'John','country':'Sweden','city':'Stockholm','age':28}, + {'name':'Sami','country':'Finland','city':'Helsinki','age':25}, + ] +for student in students: + db.students.insert_one(student) + + +app = Flask(__name__) +if __name__ == '__main__': + # pour le déploiement nous utilisons environ + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +### Trouver avec MongoDB (Find) + +Les méthodes *find()* et *findOne()* sont des méthodes courantes pour trouver des données dans une collection de la base de données mongoDB. C'est similaire à l'instruction SELECT dans une base de données MySQL. +Utilisons la méthode _find_one()_ pour obtenir un document dans une collection de la base de données. + +- \*find_one({"\_id": ObjectId("id"}): Obtient la première occurrence si un id n'est pas fourni + +```py +# importons flask +from flask import Flask, render_template +import os # importation du module système d'exploitation +MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données +student = db.students.find_one() +print(student) + + +app = Flask(__name__) +if __name__ == '__main__': + # pour le déploiement nous utilisons environ + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) + +``` + +```sh +{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Helsinki', 'city': 'Helsinki', 'age': 250} +``` + +La requête ci-dessus retourne la première entrée, mais nous pouvons cibler un document spécifique en utilisant un \_id spécifique. Faisons un exemple, utilisons l'id de David pour obtenir l'objet David. +'\_id':ObjectId('5df68a23f106fe2d315bbc8c') + +```py +# importons flask +from flask import Flask, render_template +import os # importation du module système d'exploitation +from bson.objectid import ObjectId # objet id +MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données +student = db.students.find_one({'_id':ObjectId('5df68a23f106fe2d315bbc8c')}) +print(student) + +app = Flask(__name__) +if __name__ == '__main__': + # pour le déploiement nous utilisons environ + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +```sh +{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34} +``` + +Nous avons vu comment utiliser _find_one()_ avec les exemples ci-dessus. Passons à _find()_. + +- _find()_: retourne toutes les occurrences d'une collection si nous ne passons pas d'objet requête. L'objet est un objet curseur pymongo. + +```py +# importons flask +from flask import Flask, render_template +import os # importation du module système d'exploitation + +MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données +students = db.students.find() +for student in students: + print(student) + +app = Flask(__name__) +if __name__ == '__main__': + # pour le déploiement nous utilisons environ + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +```sh +{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250} +{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34} +{'_id': ObjectId('5df68a23f106fe2d315bbc8d'), 'name': 'John', 'country': 'Sweden', 'city': 'Stockholm', 'age': 28} +{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25} +``` + +Nous pouvons spécifier les champs à retourner en passant un second objet dans _find({}, {})_. 0 signifie ne pas inclure et 1 signifie inclure, mais nous ne pouvons pas mélanger 0 et 1, sauf pour \_id. + +```py +# importons flask +from flask import Flask, render_template +import os # importation du module système d'exploitation + +MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données +students = db.students.find({}, {"_id":0, "name": 1, "country":1}) # 0 signifie ne pas inclure et 1 signifie inclure +for student in students: + print(student) + +app = Flask(__name__) +if __name__ == '__main__': + # pour le déploiement nous utilisons environ + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +```sh +{'name': 'Asabeneh', 'country': 'Finland'} +{'name': 'David', 'country': 'UK'} +{'name': 'John', 'country': 'Sweden'} +{'name': 'Sami', 'country': 'Finland'} +``` + +### Recherche avec requête + +Dans mongoDB, find prend un objet requête. Nous pouvons passer un objet requête et filtrer les documents que nous souhaitons. + +```py +# importons flask +from flask import Flask, render_template +import os # importation du module système d'exploitation + +MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données + +query = { + "country":"Finland" +} +students = db.students.find(query) + +for student in students: + print(student) + + +app = Flask(__name__) +if __name__ == '__main__': + # pour le déploiement nous utilisons environ + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +```sh +{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250} +{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25} +``` + +Requête avec modificateurs + +```py +# importons flask +from flask import Flask, render_template +import os # importation du module système d'exploitation +import pymongo + +MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données + +query = { + "city":"Helsinki" +} +students = db.students.find(query) +for student in students: + print(student) + + +app = Flask(__name__) +if __name__ == '__main__': + # pour le déploiement nous utilisons environ + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +```sh +{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250} +{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25} +``` + +### Requête avec modificateur + +```py +# importons flask +from flask import Flask, render_template +import os # importation du module système d'exploitation +import pymongo + +MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données +query = { + "country":"Finland", + "city":"Helsinki" +} +students = db.students.find(query) +for student in students: + print(student) + + +app = Flask(__name__) +if __name__ == '__main__': + # pour le déploiement nous utilisons environ + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +```sh +{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250} +{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25} +``` + +Requête avec modificateurs + +```py +# importons flask +from flask import Flask, render_template +import os # importation du module système d'exploitation +import pymongo + +MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données +query = {"age":{"$gt":30}} +students = db.students.find(query) +for student in students: + print(student) + +app = Flask(__name__) +if __name__ == '__main__': + # pour le déploiement nous utilisons environ + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +```sh +{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250} +{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34} +``` + +```py +# importons flask +from flask import Flask, render_template +import os # importation du module système d'exploitation +import pymongo + +MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données +query = {"age":{"$gt":30}} +students = db.students.find(query) +for student in students: + print(student) +``` + +```sh +{'_id': ObjectId('5df68a23f106fe2d315bbc8d'), 'name': 'John', 'country': 'Sweden', 'city': 'Stockholm', 'age': 28} +{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25} +``` + +### Limiter les documents + +Nous pouvons limiter le nombre de documents retournés en utilisant la méthode _limit()_. + +```py +# importons flask +from flask import Flask, render_template +import os # importation du module système d'exploitation +import pymongo + +MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données +db.students.find().limit(3) +``` + +### Recherche avec tri + +Par défaut, le tri est en ordre croissant. Nous pouvons changer le tri en ordre décroissant en ajoutant le paramètre -1. + +```py +# importons flask +from flask import Flask, render_template +import os # importation du module système d'exploitation +import pymongo + +MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données +students = db.students.find().sort('name') +for student in students: + print(student) + + +students = db.students.find().sort('name',-1) +for student in students: + print(student) + +students = db.students.find().sort('age') +for student in students: + print(student) + +students = db.students.find().sort('age',-1) +for student in students: + print(student) + +app = Flask(__name__) +if __name__ == '__main__': + # pour le déploiement nous utilisons environ + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +Ordre croissant + +```sh +{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250} +{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34} +{'_id': ObjectId('5df68a23f106fe2d315bbc8d'), 'name': 'John', 'country': 'Sweden', 'city': 'Stockholm', 'age': 28} +{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25} +``` + +Ordre décroissant + +```sh +{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25} +{'_id': ObjectId('5df68a23f106fe2d315bbc8d'), 'name': 'John', 'country': 'Sweden', 'city': 'Stockholm', 'age': 28} +{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34} +{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 250} +``` + +### Mise à jour avec requête + +Nous utiliserons la méthode *update_one()* pour mettre à jour un élément. Elle prend deux objets : un pour la requête et le second pour le nouvel objet. +La première personne, Asabeneh, a un âge très peu plausible. Mettons à jour l'âge d'Asabeneh. + +```py +# importons flask +from flask import Flask, render_template +import os # importation du module système d'exploitation +import pymongo + +MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données + +query = {'age':250} +new_value = {'$set':{'age':38}} + +db.students.update_one(query, new_value) +# vérifions le résultat si l'âge a été modifié +for student in db.students.find(): + print(student) + + +app = Flask(__name__) +if __name__ == '__main__': + # pour le déploiement nous utilisons environ + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +```sh +{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 38} +{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34} +{'_id': ObjectId('5df68a23f106fe2d315bbc8d'), 'name': 'John', 'country': 'Sweden', 'city': 'Stockholm', 'age': 28} +{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25} +``` + +Lorsque nous voulons mettre à jour plusieurs documents à la fois, nous utilisons la méthode *update_many()*. + +### Supprimer un document + +La méthode *delete_one()* supprime un document. La méthode *delete_one()* prend un objet requête en paramètre. Elle ne supprime que la première occurrence. +Supprimons John de la collection. + +```py +# importons flask +from flask import Flask, render_template +import os # importation du module système d'exploitation +import pymongo + +MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données + +query = {'name':'John'} +db.students.delete_one(query) + +for student in db.students.find(): + print(student) +# vérifions le résultat si l'âge a été modifié +for student in db.students.find(): + print(student) + + +app = Flask(__name__) +if __name__ == '__main__': + # pour le déploiement nous utilisons environ + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +```sh +{'_id': ObjectId('5df68a21f106fe2d315bbc8b'), 'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'age': 38} +{'_id': ObjectId('5df68a23f106fe2d315bbc8c'), 'name': 'David', 'country': 'UK', 'city': 'London', 'age': 34} +{'_id': ObjectId('5df68a23f106fe2d315bbc8e'), 'name': 'Sami', 'country': 'Finland', 'city': 'Helsinki', 'age': 25} +``` + +Comme vous pouvez le voir, John a été supprimé de la collection. + +Lorsque nous voulons supprimer plusieurs documents, nous utilisons la méthode *delete_many()*, qui prend un objet requête. Si nous passons un objet requête vide à *delete_many({})*, cela supprimera tous les documents de la collection. + +### Supprimer une collection + +En utilisant la méthode _drop()_, nous pouvons supprimer une collection d'une base de données. + +```py +# importons flask +from flask import Flask, render_template +import os # importation du module système d'exploitation +import pymongo + +MONGODB_URI = 'mongodb+srv://asabeneh:your_password_goes_here@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données +db.students.drop() +``` + +Maintenant, nous avons supprimé la collection students de la base de données. + +## 💻 Exercices : Jour 27 + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 26](./26_python_web_fr.md) | [Jour 28 >>](./28_API_fr.md) diff --git a/French/28_API_fr.md b/French/28_API_fr.md new file mode 100644 index 000000000..34dfd412d --- /dev/null +++ b/French/28_API_fr.md @@ -0,0 +1,161 @@ +
+

30 Jours de Python : Jour 28 - API

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+Deuxième édition : juillet 2021 + + +
+ +[<< Jour 27](./27_python_with_mongodb_fr.md) | [Jour 29 >>](./29_building_API_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [📘 Jour 28](#-jour-28) +- [Interface de Programmation d'Application (API)](#interface-de-programmation-dapplication-api) + - [API](#api) + - [Construire une API](#construire-une-api) + - [HTTP (Hypertext Transfer Protocol)](#http-hypertext-transfer-protocol) + - [Structure de HTTP](#structure-de-http) + - [Ligne de requête initiale (ligne de statut)](#ligne-de-requête-initiale-ligne-de-statut) + - [Ligne de réponse initiale (ligne de statut)](#ligne-de-réponse-initiale-ligne-de-statut) + - [Champs d'en-tête](#champs-dentête) + - [Le corps du message](#le-corps-du-message) + - [Méthodes de requête](#méthodes-de-requête) + - [💻 Exercices : Jour 28](#-exercices-jour-28) + +# 📘 Jour 28 + +# Interface de Programmation d'Application (API) + +## API + +API signifie Application Programming Interface (Interface de Programmation d'Application). Le type d'API que nous couvrirons dans cette section sera les API Web. +Les API Web sont les interfaces définies à travers lesquelles les interactions se produisent entre une entreprise et les applications qui utilisent ses ressources, ce qui est également un accord de niveau de service (SLA) pour spécifier le fournisseur fonctionnel et exposer le chemin du service ou l'URL pour ses utilisateurs d'API. + +Dans le contexte du développement web, une API est définie comme un ensemble de spécifications, telles que les messages de requête HTTP (Hypertext Transfer Protocol), ainsi qu'une définition de la structure des messages de réponse, généralement au format XML ou JSON (JavaScript Object Notation). + +Les API Web ont évolué des services web basés sur SOAP (Simple Object Access Protocol) et de l'architecture orientée services (SOA) vers des ressources web de style REST (Representational State Transfer) plus direct. + +Les services de médias sociaux, les API Web ont permis aux communautés web de partager du contenu et des données entre communautés et différentes plateformes. + +En utilisant l'API, le contenu créé à un endroit peut être dynamiquement publié et mis à jour à plusieurs endroits sur le web. + +Par exemple, l'API REST de Twitter permet aux développeurs d'accéder aux données principales de Twitter, et l'API Search fournit des méthodes permettant aux développeurs d'interagir avec les données de recherche et les tendances de Twitter. + +De nombreuses applications fournissent des points d'accès API. Quelques exemples d'API comme l'API des [pays](https://restcountries.eu/rest/v2/all), l'API des [races de chats](https://api.thecatapi.com/v1/breeds). + +Dans cette section, nous couvrirons une API RESTful qui utilise les méthodes de requête HTTP pour GET, PUT, POST et DELETE les données. + +## Construire une API + +Une API RESTful est une interface de programmation d'application qui utilise des requêtes HTTP pour GET, PUT, POST et DELETE les données. Dans les sections précédentes, nous avons appris Python, Flask et MongoDB. Nous utiliserons les connaissances acquises pour développer une API RESTful avec Python Flask et la base de données MongoDB. Chaque application qui a une opération CRUD (Create, Read, Update, Delete) a une API pour créer des données, obtenir des données, mettre à jour des données ou supprimer des données d'une base de données. + +Pour construire une API, il est bon de comprendre le protocole HTTP et le cycle de requête et réponse HTTP. + +## HTTP (Hypertext Transfer Protocol) + +HTTP est un protocole de communication établi entre un client et un serveur. Un client dans ce cas est un navigateur et le serveur est l'endroit où vous accédez aux données. HTTP est un protocole réseau utilisé pour délivrer des ressources qui pourraient être des fichiers sur le World Wide Web, qu'il s'agisse de fichiers HTML, de fichiers image, de résultats de requêtes, de scripts ou d'autres types de fichiers. + +Un navigateur est un client HTTP car il envoie des requêtes à un serveur HTTP (serveur web), qui renvoie ensuite des réponses au client. + +## Structure de HTTP + +HTTP utilise un modèle client-serveur. Un client HTTP ouvre une connexion et envoie un message de requête à un serveur HTTP, et le serveur HTTP renvoie un message de réponse contenant les ressources demandées. Lorsque le cycle requête-réponse se termine, le serveur ferme la connexion. + +![HTTP request response cycle](../images/http_request_response_cycle.png) + +Le format des messages de requête et de réponse est similaire. Les deux types de messages ont : + +- une ligne initiale, +- zéro ou plusieurs lignes d'en-tête, +- une ligne vide (un CRLF seul), et +- un corps de message optionnel (par exemple, un fichier, des données de requête, ou le résultat d'une requête). + +Prenons un exemple de messages de requête et de réponse en naviguant sur ce site : https://thirtydaysofpython-v1-final.herokuapp.com/. Ce site a été déployé sur le dyno gratuit Heroku et dans quelques mois, il pourrait ne plus fonctionner à cause de nombreuses requêtes. Soutenez ce travail pour que le serveur fonctionne en permanence. + +![Request and Response header](../images/request_response_header.png) + +## Ligne de requête initiale (ligne de statut) + +La ligne de requête initiale est différente de la réponse. +Une ligne de requête a trois parties, séparées par des espaces : + +- le nom de la méthode (GET, POST, HEAD) +- le chemin de la ressource demandée, +- la version de HTTP utilisée. ex : GET / HTTP/1.1 + +GET est la méthode HTTP la plus courante qui aide à obtenir ou lire une ressource, et POST est une méthode de requête courante pour créer une ressource. + +### Ligne de réponse initiale (ligne de statut) + +La ligne de réponse initiale, appelée ligne de statut, a également trois parties séparées par des espaces : + +- La version HTTP +- Le code de statut de la réponse qui donne le résultat de la requête, et une raison qui décrit le code de statut. Exemples de lignes de statut : + HTTP/1.0 200 OK + ou + HTTP/1.0 404 Not Found + Notes : + +Les codes de statut les plus courants sont : +200 OK : La requête a réussi, et la ressource résultante (par exemple, un fichier ou le résultat d'un script) est retournée dans le corps du message. +500 Erreur serveur +Une liste complète des codes de statut HTTP peut être trouvée [ici](https://httpstatuses.com/). Elle peut aussi être trouvée [ici](https://httpstatusdogs.com/). + +### Champs d'en-tête + +Comme vous l'avez vu dans la capture d'écran ci-dessus, les lignes d'en-tête fournissent des informations sur la requête ou la réponse, ou sur l'objet envoyé dans le corps du message. + +```sh +GET / HTTP/1.1 +Host: thirtydaysofpython-v1-final.herokuapp.com +Connection: keep-alive +Pragma: no-cache +Cache-Control: no-cache +Upgrade-Insecure-Requests: 1 +User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.79 Safari/537.36 +Sec-Fetch-User: ?1 +Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9 +Sec-Fetch-Site: same-origin +Sec-Fetch-Mode: navigate +Referer: https://thirtydaysofpython-v1-final.herokuapp.com/post +Accept-Encoding: gzip, deflate, br +Accept-Language: en-GB,en;q=0.9,fi-FI;q=0.8,fi;q=0.7,en-CA;q=0.6,en-US;q=0.5,fr;q=0.4 +``` + +### Le corps du message + +Un message HTTP peut avoir un corps de données envoyé après les lignes d'en-tête. Dans une réponse, c'est là que la ressource demandée est retournée au client (l'utilisation la plus courante du corps du message), ou peut-être un texte explicatif s'il y a une erreur. Dans une requête, c'est là que les données saisies par l'utilisateur ou les fichiers téléchargés sont envoyés au serveur. + +Si un message HTTP inclut un corps, il y a généralement des lignes d'en-tête dans le message qui décrivent le corps. En particulier : + +L'en-tête Content-Type: donne le type MIME des données dans le corps (text/html, application/json, text/plain, text/css, image/gif). +L'en-tête Content-Length: donne le nombre d'octets dans le corps. + +### Méthodes de requête + +Les méthodes de requête GET, POST, PUT et DELETE sont les méthodes de requête HTTP que nous allons implémenter pour une API ou une application CRUD. + +1. GET : La méthode GET est utilisée pour récupérer et obtenir des informations depuis un serveur donné en utilisant une URI donnée. Les requêtes utilisant GET ne doivent que récupérer des données et ne doivent avoir aucun autre effet sur les données. + +2. POST : La requête POST est utilisée pour créer des données et envoyer des données au serveur, par exemple, créer un nouveau post, télécharger un fichier, etc. en utilisant des formulaires HTML. + +3. PUT : Remplace toutes les représentations actuelles de la ressource cible par le contenu téléchargé et nous l'utilisons pour modifier ou mettre à jour des données. + +4. DELETE : Supprime des données + +## 💻 Exercices : Jour 28 + +1. Lisez à propos de l'API et de HTTP + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 27](./27_python_with_mongodb_fr.md) | [Jour 29 >>](./29_building_API_fr.md) diff --git a/French/29_building_API_fr.md b/French/29_building_API_fr.md new file mode 100644 index 000000000..79524a281 --- /dev/null +++ b/French/29_building_API_fr.md @@ -0,0 +1,502 @@ +
+

30 Jours de Python : Jour 29 - Construire une API

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+Deuxième édition : juillet 2021 + + +
+ +[<< Jour 28](./28_API_fr.md) | [Jour 30 >>](./30_conclusions_fr.md) + +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [Jour 29](#jour-29) +- [Construire une API](#construire-une-api) + - [Structure d'une API](#structure-dune-api) + - [Récupérer des données avec get](#récupérer-des-données-avec-get) + - [Obtenir un document par son id](#obtenir-un-document-par-son-id) + - [Créer des données avec POST](#créer-des-données-avec-post) + - [Mettre à jour avec PUT](#mettre-à-jour-avec-put) + - [Supprimer un document avec DELETE](#supprimer-un-document-avec-delete) +- [💻 Exercices : Jour 29](#-exercices-jour-29) + +## Jour 29 + +## Construire une API + +Dans cette section, nous couvrirons une API RESTful qui utilise les méthodes de requête HTTP pour GET, PUT, POST et DELETE les données. + +Une API RESTful est une interface de programmation d'application qui utilise des requêtes HTTP pour GET, PUT, POST et DELETE les données. Dans les sections précédentes, nous avons appris Python, Flask et MongoDB. Nous utiliserons les connaissances acquises pour développer une API RESTful avec Python Flask et MongoDB. Chaque application qui a une opération CRUD (Create, Read, Update, Delete) a une API pour créer des données, obtenir des données, mettre à jour des données ou supprimer des données d'une base de données. + +Le navigateur ne peut gérer que les requêtes GET. Par conséquent, nous devons avoir un outil qui peut nous aider à gérer toutes les méthodes de requête (GET, POST, PUT, DELETE). + +Exemples d'API + +- API des pays : https://restcountries.eu/rest/v2/all +- API des races de chats : https://api.thecatapi.com/v1/breeds + +[Postman](https://www.getpostman.com/) est un outil très populaire en matière de développement d'API. Donc, si vous voulez faire cette section, vous devez [télécharger Postman](https://www.getpostman.com/). Une alternative à Postman est [Insomnia](https://insomnia.rest/download). + +![Postman](../images/postman.png) + +### Structure d'une API + +Un point d'accès API (endpoint) est une URL qui peut aider à récupérer, créer, mettre à jour ou supprimer une ressource. La structure ressemble à ceci : +Exemple : +https://api.twitter.com/1.1/lists/members.json +Retourne les membres de la liste spécifiée. Les membres des listes privées ne seront affichés que si l'utilisateur authentifié possède la liste spécifiée. +Le nom de l'entreprise suivi de la version, suivi du but de l'API. +Les méthodes : +Méthodes HTTP et URLs + +L'API utilise les méthodes HTTP suivantes pour la manipulation des objets : + +```sh +GET Utilisé pour la récupération d'objets +POST Utilisé pour la création d'objets et les actions sur les objets +PUT Utilisé pour la mise à jour d'objets +DELETE Utilisé pour la suppression d'objets +``` + +Construisons une API qui collecte des informations sur les étudiants de 30DaysOfPython. Nous allons collecter le nom, le pays, la ville, la date de naissance, les compétences et la biographie. + +Pour implémenter cette API, nous utiliserons : + +- Postman +- Python +- Flask +- MongoDB + +### Récupérer des données avec get + +Dans cette étape, utilisons des données factices et retournons-les au format json. Pour les retourner en json, nous utiliserons le module json et le module Response. + +```py +# importons flask + +from flask import Flask, Response +import json +import os + +app = Flask(__name__) + +@app.route('/api/v1.0/students', methods = ['GET']) +def students (): + student_list = [ + { + 'name':'Asabeneh', + 'country':'Finland', + 'city':'Helsinki', + 'skills':['HTML', 'CSS','JavaScript','Python'] + }, + { + 'name':'David', + 'country':'UK', + 'city':'London', + 'skills':['Python','MongoDB'] + }, + { + 'name':'John', + 'country':'Sweden', + 'city':'Stockholm', + 'skills':['Java','C#'] + } + ] + return Response(json.dumps(student_list), mimetype='application/json') + + +if __name__ == '__main__': + # pour le déploiement + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +Lorsque vous faites une requête à l'url http://localhost:5000/api/v1.0/students dans le navigateur, vous obtiendrez ceci : + +![Get on browser](../images/get_on_browser.png) + +Lorsque vous faites une requête à l'url http://localhost:5000/api/v1.0/students dans le navigateur, vous obtiendrez ceci : + +![Get on postman](../images/get_on_postman.png) + +Au lieu d'afficher des données factices, connectons l'application Flask avec MongoDB et récupérons les données de la base de données MongoDB. + +```py +# importons flask + +from flask import Flask, Response +import json +import pymongo +import os + +app = Flask(__name__) + +# +MONGODB_URI='mongodb+srv://asabeneh:your_password@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données + +@app.route('/api/v1.0/students', methods = ['GET']) +def students (): + + return Response(json.dumps(student), mimetype='application/json') + + +if __name__ == '__main__': + # pour le déploiement + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +En connectant Flask, nous pouvons récupérer les données de la collection students de la base de données thirty_days_of_python. + +```sh +[ + { + "_id": { + "$oid": "5df68a21f106fe2d315bbc8b" + }, + "name": "Asabeneh", + "country": "Finland", + "city": "Helsinki", + "age": 38 + }, + { + "_id": { + "$oid": "5df68a23f106fe2d315bbc8c" + }, + "name": "David", + "country": "UK", + "city": "London", + "age": 34 + }, + { + "_id": { + "$oid": "5df68a23f106fe2d315bbc8e" + }, + "name": "Sami", + "country": "Finland", + "city": "Helsinki", + "age": 25 + } +] +``` + +### Obtenir un document par son id + +Nous pouvons accéder à un seul document en utilisant un id, accédons à Asabeneh en utilisant son id. +http://localhost:5000/api/v1.0/students/5df68a21f106fe2d315bbc8b + +```py +# importons flask + +from flask import Flask, Response +import json +from bson.objectid import ObjectId +import json +from bson.json_util import dumps +import pymongo +import os + +app = Flask(__name__) + +# +MONGODB_URI='mongodb+srv://asabeneh:your_password@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données + +@app.route('/api/v1.0/students', methods = ['GET']) +def students (): + + return Response(json.dumps(student), mimetype='application/json') +@app.route('/api/v1.0/students/', methods = ['GET']) +def single_student (id): + student = db.students.find({'_id':ObjectId(id)}) + return Response(dumps(student), mimetype='application/json') + +if __name__ == '__main__': + # pour le déploiement + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +```sh +[ + { + "_id": { + "$oid": "5df68a21f106fe2d315bbc8b" + }, + "name": "Asabeneh", + "country": "Finland", + "city": "Helsinki", + "age": 38 + } +] +``` + +### Créer des données avec POST + +Nous utilisons la méthode de requête POST pour créer des données. + +```py +# importons flask + +from flask import Flask, Response +import json +from bson.objectid import ObjectId +import json +from bson.json_util import dumps +import pymongo +from datetime import datetime +import os + +app = Flask(__name__) + +# +MONGODB_URI='mongodb+srv://asabeneh:your_password@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données + +@app.route('/api/v1.0/students', methods = ['GET']) +def students (): + + return Response(json.dumps(student), mimetype='application/json') +@app.route('/api/v1.0/students/', methods = ['GET']) +def single_student (id): + student = db.students.find({'_id':ObjectId(id)}) + return Response(dumps(student), mimetype='application/json') +@app.route('/api/v1.0/students', methods = ['POST']) +def create_student (): + name = request.form['name'] + country = request.form['country'] + city = request.form['city'] + skills = request.form['skills'].split(', ') + bio = request.form['bio'] + birthyear = request.form['birthyear'] + created_at = datetime.now() + student = { + 'name': name, + 'country': country, + 'city': city, + 'birthyear': birthyear, + 'skills': skills, + 'bio': bio, + 'created_at': created_at + + } + db.students.insert_one(student) + return ; +def update_student (id): +if __name__ == '__main__': + # pour le déploiement + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +### Mettre à jour avec PUT + +```py +# importons flask + +from flask import Flask, Response +import json +from bson.objectid import ObjectId +import json +from bson.json_util import dumps +import pymongo +from datetime import datetime +import os + +app = Flask(__name__) + +# +MONGODB_URI='mongodb+srv://asabeneh:your_password@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données + +@app.route('/api/v1.0/students', methods = ['GET']) +def students (): + + return Response(json.dumps(student), mimetype='application/json') +@app.route('/api/v1.0/students/', methods = ['GET']) +def single_student (id): + student = db.students.find({'_id':ObjectId(id)}) + return Response(dumps(student), mimetype='application/json') +@app.route('/api/v1.0/students', methods = ['POST']) +def create_student (): + name = request.form['name'] + country = request.form['country'] + city = request.form['city'] + skills = request.form['skills'].split(', ') + bio = request.form['bio'] + birthyear = request.form['birthyear'] + created_at = datetime.now() + student = { + 'name': name, + 'country': country, + 'city': city, + 'birthyear': birthyear, + 'skills': skills, + 'bio': bio, + 'created_at': created_at + + } + db.students.insert_one(student) + return +@app.route('/api/v1.0/students/', methods = ['PUT']) # ce décorateur crée la route d'accueil +def update_student (id): + query = {"_id":ObjectId(id)} + name = request.form['name'] + country = request.form['country'] + city = request.form['city'] + skills = request.form['skills'].split(', ') + bio = request.form['bio'] + birthyear = request.form['birthyear'] + created_at = datetime.now() + student = { + 'name': name, + 'country': country, + 'city': city, + 'birthyear': birthyear, + 'skills': skills, + 'bio': bio, + 'created_at': created_at + + } + db.students.update_one(query, student) + # return Response(dumps({"result":"a new student has been created"}), mimetype='application/json') + return +def update_student (id): +if __name__ == '__main__': + # pour le déploiement + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +### Supprimer un document avec DELETE + +```py +# importons flask + +from flask import Flask, Response +import json +from bson.objectid import ObjectId +import json +from bson.json_util import dumps +import pymongo +from datetime import datetime +import os + +app = Flask(__name__) + +# +MONGODB_URI='mongodb+srv://asabeneh:your_password@30daysofpython-twxkr.mongodb.net/test?retryWrites=true&w=majority' +client = pymongo.MongoClient(MONGODB_URI) +db = client['thirty_days_of_python'] # accès à la base de données + +@app.route('/api/v1.0/students', methods = ['GET']) +def students (): + + return Response(json.dumps(student), mimetype='application/json') +@app.route('/api/v1.0/students/', methods = ['GET']) +def single_student (id): + student = db.students.find({'_id':ObjectId(id)}) + return Response(dumps(student), mimetype='application/json') +@app.route('/api/v1.0/students', methods = ['POST']) +def create_student (): + name = request.form['name'] + country = request.form['country'] + city = request.form['city'] + skills = request.form['skills'].split(', ') + bio = request.form['bio'] + birthyear = request.form['birthyear'] + created_at = datetime.now() + student = { + 'name': name, + 'country': country, + 'city': city, + 'birthyear': birthyear, + 'skills': skills, + 'bio': bio, + 'created_at': created_at + + } + db.students.insert_one(student) + return +@app.route('/api/v1.0/students/', methods = ['PUT']) # ce décorateur crée la route d'accueil +def update_student (id): + query = {"_id":ObjectId(id)} + name = request.form['name'] + country = request.form['country'] + city = request.form['city'] + skills = request.form['skills'].split(', ') + bio = request.form['bio'] + birthyear = request.form['birthyear'] + created_at = datetime.now() + student = { + 'name': name, + 'country': country, + 'city': city, + 'birthyear': birthyear, + 'skills': skills, + 'bio': bio, + 'created_at': created_at + + } + db.students.update_one(query, student) + # return Response(dumps({"result":"a new student has been created"}), mimetype='application/json') + return +@app.route('/api/v1.0/students/', methods = ['PUT']) # ce décorateur crée la route d'accueil +def update_student (id): + query = {"_id":ObjectId(id)} + name = request.form['name'] + country = request.form['country'] + city = request.form['city'] + skills = request.form['skills'].split(', ') + bio = request.form['bio'] + birthyear = request.form['birthyear'] + created_at = datetime.now() + student = { + 'name': name, + 'country': country, + 'city': city, + 'birthyear': birthyear, + 'skills': skills, + 'bio': bio, + 'created_at': created_at + + } + db.students.update_one(query, student) + # return Response(dumps({"result":"a new student has been created"}), mimetype='application/json') + return ; +@app.route('/api/v1.0/students/', methods = ['DELETE']) +def delete_student (id): + db.students.delete_one({"_id":ObjectId(id)}) + return +if __name__ == '__main__': + # pour le déploiement + # pour que ça fonctionne à la fois en production et en développement + port = int(os.environ.get("PORT", 5000)) + app.run(debug=True, host='0.0.0.0', port=port) +``` + +## 💻 Exercices : Jour 29 + +1. Implémentez l'exemple ci-dessus et développez [ceci](https://thirtydayofpython-api.herokuapp.com/) + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 28](./28_API_fr.md) | [Jour 30 >>](./30_conclusions_fr.md) diff --git a/French/30_conclusions_fr.md b/French/30_conclusions_fr.md new file mode 100644 index 000000000..e79480a57 --- /dev/null +++ b/French/30_conclusions_fr.md @@ -0,0 +1,41 @@ +
+ +

30 Jours de Python : Jour 30 - Conclusions

+ + + + + Twitter Follow + + + +Auteur : +Asabeneh Yetayeh
+Deuxième édition : juillet 2021 + + +
+ +[<< Jour 29](./29_building_API_fr.md) +![30DaysOfPython](../images/30DaysOfPython_banner3@2x.png) + +- [Jour 30](#jour-30) + - [Conclusions](#conclusions) + - [Témoignage](#témoignage) + +# Jour 30 + + +## Conclusions + +Dans le processus de préparation de ce matériel, j'ai beaucoup appris et vous m'avez inspiré à faire plus. Félicitations d'être arrivé à ce niveau. Si vous avez fait tous les exercices et les projets, vous êtes maintenant capable de suivre les voies de l'analyse de données, de la science des données, de l'apprentissage automatique ou du développement web. [Soutenez l'auteur pour plus de matériel pédagogique](https://www.paypal.com/paypalme/asabeneh). + +## Témoignage +Il est maintenant temps d'exprimer vos pensées sur l'auteur et 30DaysOfPython. Vous pouvez laisser votre témoignage sur ce [lien](https://www.asabeneh.com/testimonials). + +DONNEZ VOTRE AVIS : +http://thirtydayofpython-api.herokuapp.com/feedback + +🎉 FÉLICITATIONS ! 🎉 + +[<< Jour 29](./29_building_API_fr.md) diff --git a/French/README_fr.md b/French/README_fr.md new file mode 100644 index 000000000..328e40266 --- /dev/null +++ b/French/README_fr.md @@ -0,0 +1,504 @@ +# 🐍 30 Jours de Python + +| # Jour | Sujet | +| :---: | :---: | +| 01 | [Introduction](./README_fr.md) | +| 02 | [Variables et fonctions intégrées](./02_variables_builtin_functions_fr.md) | +| 03 | [Opérateurs](./03_operators_fr.md) | +| 04 | [Chaînes de caractères](./04_strings_fr.md) | +| 05 | [Listes](./05_lists_fr.md) | +| 06 | [Tuples](./06_tuples_fr.md) | +| 07 | [Ensembles](./07_sets_fr.md) | +| 08 | [Dictionnaires](./08_dictionaries_fr.md) | +| 09 | [Conditionnelles](./09_conditionals_fr.md) | +| 10 | [Boucles](./10_loops_fr.md) | +| 11 | [Fonctions](./11_functions_fr.md) | +| 12 | [Modules](./12_modules_fr.md) | +| 13 | [Compréhension de listes](./13_list_comprehension_fr.md) | +| 14 | [Fonctions d'ordre supérieur](./14_higher_order_functions_fr.md) | +| 15 | [Types d'erreurs en Python](./15_python_type_errors_fr.md) | +| 16 | [Dates et heures en Python](./16_python_datetime_fr.md) | +| 17 | [Gestion des exceptions](./17_exception_handling_fr.md) | +| 18 | [Expressions régulières](./18_regular_expressions_fr.md) | +| 19 | [Gestion de fichiers](./19_file_handling_fr.md) | +| 20 | [Gestionnaire de paquets](./20_python_package_manager_fr.md) | +| 21 | [Classes et objets](./21_classes_and_objects_fr.md) | +| 22 | [Web scraping](./22_web_scraping_fr.md) | +| 23 | [Environnements virtuels](./23_virtual_environment_fr.md) | +| 24 | [Statistiques](./24_statistics_fr.md) | +| 25 | [Pandas](./25_pandas_fr.md) | +| 26 | [Python sur le web](./26_python_web_fr.md) | +| 27 | [Python et MongoDB](./27_python_with_mongodb_fr.md) | +| 28 | [API](./28_API_fr.md) | +| 29 | [Construire une API](./29_building_API_fr.md) | +| 30 | [Conclusions](./30_conclusions_fr.md) | + +🧡🧡🧡 BON CODAGE 🧡🧡🧡 + +--- + +
+

💖 Sponsors

+ +

Un immense merci à nos formidables sponsors qui soutiennent mes contributions open source et la série des défis 30 Days of Challenge !

+ +

Sponsors Actuels

+
+ +
+ + +--- + +### 🙌 Devenir Sponsor + +Vous pouvez soutenir ce projet en devenant sponsor sur **[GitHub Sponsors](https://github.com/sponsors/asabeneh)** ou via [PayPal](https://www.paypal.me/asabeneh). + +Chaque contribution, petite ou grande, fait une énorme différence. Merci pour votre soutien ! 🌟 + +--- + +
+

30 Jours de Python : Jour 1 - Introduction

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+Deuxième édition : juillet 2021 + + +
+ +🇧🇷 [Portuguese](./Portuguese/README.md) | 🇨🇳 [中文](./Chinese/README.md) + +[Aller au Jour 2 >>](./02_variables_builtin_functions_fr.md) + +![30DaysOfPython](.././images/30DaysOfPython_banner3@2x.png) + +- [🐍 30 Jours de Python](#-30-jours-de-python) + - [🙌 Devenir Sponsor](#-devenir-sponsor) +- [📘 Jour 1](#-jour-1) + - [Bienvenue !](#bienvenue-) + - [Introduction](#introduction) + - [Pourquoi choisir Python ?](#pourquoi-choisir-python-) + - [Configuration de l'environnement](#configuration-de-lenvironnement) + - [Installer Python](#installer-python) + - [Le Shell Python](#le-shell-python) + - [Installer Visual Studio Code](#installer-visual-studio-code) + - [Comment utiliser Visual Studio Code](#comment-utiliser-visual-studio-code) + - [Bases de Python](#bases-de-python) + - [Syntaxe de Python](#syntaxe-de-python) + - [Indentation en Python](#indentation-en-python) + - [Commentaires](#commentaires) + - [Types de données](#types-de-données) + - [Nombres](#nombres) + - [Chaînes de caractères](#chaînes-de-caractères) + - [Booléens](#booléens) + - [Listes](#listes) + - [Dictionnaires](#dictionnaires) + - [Tuples](#tuples) + - [Ensembles](#ensembles) + - [Vérifier les types de données](#vérifier-les-types-de-données) + - [Fichiers Python](#fichiers-python) + - [💻 Exercices - Jour 1](#-exercices---jour-1) + - [Exercices : Niveau 1](#exercices--niveau-1) + - [Exercices : Niveau 2](#exercices--niveau-2) + - [Exercices : Niveau 3](#exercices--niveau-3) + +# 📘 Jour 1 + +## Bienvenue ! + +**Félicitations** pour avoir décidé de participer au défi de programmation *30 Jours de Python*. Dans ce défi, vous apprendrez tout ce dont vous avez besoin pour devenir un programmeur Python et assimilerez l'ensemble des concepts fondamentaux de la programmation. À la fin du défi, vous recevrez un certificat de réussite *30DaysOfPython*. + +Si vous souhaitez participer activement, rejoignez le groupe Telegram [30DaysOfPython challenge](https://t.me/ThirtyDaysOfPython). + +## Introduction + +Python est un langage de programmation de haut niveau, polyvalent, open source, interprété et orienté objet. Il a été créé par le programmeur néerlandais Guido van Rossum. Le nom du langage provient de l'émission comique britannique *Monty Python's Flying Circus*. La première version a été publiée le 20 février 1991. Ce défi de 30 jours vous aidera à apprendre progressivement la version la plus récente de Python, Python 3. Chaque jour couvre un sujet différent avec des explications claires, des exemples concrets et de nombreux exercices et projets pratiques. + +Le défi convient aussi bien aux grands débutants qu'aux professionnels qui souhaitent acquérir des compétences en Python. Le terminer peut prendre de 30 à 100 jours ; les membres actifs du groupe Telegram ont statistiquement beaucoup plus de chances d'aller jusqu'au bout. + +Ce défi a été initialement rédigé en anglais simple, puis traduit en plusieurs langues. Il est conçu pour être motivant, accessible et exigeant. Il demande un réel engagement pour être mené à bien. Si vous apprenez mieux avec des vidéos, visitez la chaîne Washera sur YouTube : Washera YouTube channel. Vous pouvez commencer par la vidéo [Python for absolute beginners](https://youtu.be/OCCWZheOesI). Abonnez-vous, posez vos questions dans les commentaires et soyez proactif ; l'auteur finit toujours par remarquer les étudiants impliqués. + +L'auteur apprécie grandement vos retours et le partage de son contenu. Vous pouvez laisser votre témoignage ici : [link](https://www.asabeneh.com/testimonials) + +## Pourquoi choisir Python ? + +Python est un langage doté d'une syntaxe très proche du langage humain, ce qui le rend simple à apprendre, à lire et à utiliser. +Il est utilisé dans de nombreuses industries et par les plus grandes entreprises de la tech (y compris Google). Il sert à développer des applications web, des logiciels de bureau, des scripts d'administration système et des bibliothèques d'intelligence artificielle. Python est d'ailleurs le langage roi au sein de la communauté de la science des données (Data Science) et du Machine Learning. Python est en train de conquérir le monde, apprenez à le maîtriser avant de vous laisser dépasser ! + +## Configuration de l'environnement + +### Installer Python + +Pour exécuter des scripts écrits en Python, vous devez installer l'interpréteur. Visitez la page de téléchargement officielle de Python : [https://www.python.org/](https://www.python.org/). + +Si vous utilisez Windows, cliquez sur le bouton encerclé en rouge sur l'image du site. + +[![Installer sur Windows](.././images/installing_on_windows.png)](https://www.python.org/) + +Si vous utilisez macOS, cliquez sur le bouton correspondant. + +[![Installer sur macOS](.././images/installing_on_macOS.png)](https://www.python.org/) + +Pour vérifier si Python est correctement installé, ouvrez votre terminal et exécutez la commande suivante : + +```shell +python3 --version +``` + +![Version de Python](../images/python_versio.png) + +Sur mon terminal, la version affichée est Python 3.7.5. Votre version peut différer, mais elle doit impérativement être 3.6 ou supérieure. Si la version s'affiche, Python est installé avec succès. Vous pouvez passer à la section suivante. + +### Le Shell Python + +Python étant un langage interprété, il n'a pas besoin d'être compilé en amont. Il exécute le code ligne par ligne. Python inclut par défaut un *Shell Python* (interpréteur interactif), également appelé REPL (Read Eval Print Loop). Il permet d'exécuter des commandes Python uniques et d'en voir le résultat instantanément. + +Le Shell Python reste en attente de vos instructions. Lorsque vous écrivez du code, il l'interprète et affiche le résultat à la ligne suivante. +Ouvrez votre terminal ou invite de commande (cmd) et tapez : + +```shell +python3 +``` + +![Python Scripting Shell](../images/opening_python_shell.png) + +L'interpréteur interactif de Python s'ouvre et affiche l'invite `>>>` indiquant qu'il est prêt. Écrivez votre premier script et appuyez sur Entrée. + +![Script Python dans le shell](../images/adding_on_python_shell.png) + +Génial ! Vous avez écrit votre tout premier script Python directement dans le Shell. Comment quitter cette interface ? +Pour fermer le shell interactif, tapez simplement **exit()** juste après le symbole `>>>` et appuyez sur Entrée. + +![Quitter le shell Python](../images/exit_from_shell.png) + +Vous savez désormais comment ouvrir et fermer l'interpréteur interactif. + +Si vous écrivez du code syntaxiquement incorrect, Python lèvera une erreur. Faisons une erreur intentionnelle pour voir ce qui se passe : + +![Erreur de syntaxe invalide](../images/invalid_syntax_error.png) + +L'erreur indique `SyntaxError: invalid syntax`. Utiliser la lettre `x` pour effectuer une multiplication n'est pas valide en Python ; l'opérateur correct est l'astérisque (`*`). L'erreur vous signale exactement ce qui doit être corrigé. + +Le processus de recherche et de correction des erreurs s'appelle le **débogage** (debugging). Corrigeons le bug en remplaçant `x` par `*` : + +![Correction d'erreur de syntaxe](../images/fixing_syntax_error.png) + +L'erreur est corrigée, le code s'exécute et produit le résultat attendu. En tant que développeur, vous ferez face à ce genre d'erreurs quotidiennement. Apprendre à déboguer est une compétence essentielle. Pour devenir efficace, vous devez apprendre à reconnaître les différents types d'erreurs : `SyntaxError`, `IndexError`, `NameError`, `ModuleNotFoundError`, `KeyError`, `ImportError`, `AttributeError`, `TypeError`, `ValueError`, `ZeroDivisionError`, etc. Nous les détaillerons dans les chapitres suivants. + +Pratiquons encore un peu dans le Shell Python. Rouvrez votre terminal et tapez `python3`. + +![Python Scripting Shell](../images/opening_python_shell.png) + +Faisons quelques opérations mathématiques de base : addition, soustraction, multiplication, division, modulo et puissance. + +Avant de coder, posons les calculs : + +- 2 + 3 = 5 +- 3 - 2 = 1 +- 3 \* 2 = 6 +- 3 / 2 = 1.5 +- 3 \*\* 2 = 3 × 3 = 9 + +En Python, nous avons également : + +- 3 % 2 = 1 (Modulo : donne le reste de la division entière) +- 3 // 2 = 1 (Division entière : effectue la division et supprime la partie décimale) + +Traduisons cela en code Python dans le Shell. Commençons par écrire un commentaire. + +Un **commentaire** est une portion de texte complètement ignorée par Python lors de l'exécution. Il sert exclusivement à documenter le code et à améliorer sa lisibilité pour les humains. En Python, un commentaire commence par le symbole dièse (`#`). + +```python +# Les commentaires commencent par un dièse +# Ceci est un commentaire Python car il commence par (#) +``` + +![Opérations dans le shell Python](../images/maths_on_python_shell.png) + +Avant de continuer, pratiquez un peu : fermez le Shell avec `exit()`, rouvrez-le et essayez d'afficher du texte (des chaînes de caractères) comme ceci : + +![Écrire une chaîne dans le shell Python](../images/writing_string_on_shell.png) + +### Installer Visual Studio Code + +Le Shell Python est très pratique pour tester de courts fragments de code, mais il devient inutilisable pour de vrais projets. Dans un cadre professionnel, les développeurs utilisent des éditeurs de code ou des IDE. Dans ce défi, nous utiliserons Visual Studio Code. VS Code est un éditeur de texte open source, gratuit et extrêmement populaire. Je vous recommande vivement de le télécharger, mais si vous préférez un autre outil, vous êtes libre de l'utiliser. + +[![Visual Studio Code](../images/vscode.png)](https://code.visualstudio.com/) + +Si vous avez installé Visual Studio Code, voyons comment l'utiliser. Vous pouvez aussi regarder ce [tutoriel vidéo](https://www.youtube.com/watch?v=bn7Cx4z-vSo) dédié à la configuration de VS Code pour Python. + +#### Comment utiliser Visual Studio Code + +Ouvrez Visual Studio Code en double-cliquant sur son icône. Prenez le temps de vous familiariser avec l'interface et les différentes icônes légendées ci-dessous. + +![Visual Studio Code](../images/vscode_ui.png) + +Créez un dossier nommé `30DaysOfPython` sur votre bureau, puis ouvrez-le dans Visual Studio Code via le menu ou l'écran d'accueil. + +![Ouvrir un projet dans Visual Studio](../images/how_to_open_project_on_vscode.png) + +![Ouvrir un projet](../images/opening_project.png) + +Une fois le dossier ouvert, vous aurez accès aux raccourcis pour créer des fichiers et des dossiers. J'ai créé le premier fichier sous le nom de `helloworld.py`, faites de même de votre côté. + +![Créer un fichier Python](../images/helloworld.png) + +Lorsque vous avez fini de coder pour la journée, vous pouvez fermer votre projet proprement depuis l'éditeur : + +![Fermer un projet ouvert](../images/closing_opened_project.png) + +Félicitations, votre environnement de développement est entièrement prêt. Place au code ! + +## Bases de Python + +### Syntaxe de Python + +Un script Python peut être écrit et testé directement dans le Shell interactif ou rédigé dans un éditeur de texte. Les fichiers contenant du code Python doivent obligatoirement porter l'extension `.py`. + +### Indentation en Python + +L'indentation désigne les espaces blancs insérés en début de ligne de texte. Dans la majorité des langages de programmation, l'indentation sert uniquement à rendre le code plus lisible. **En Python, l'indentation est obligatoire et sert à définir les blocs de code.** Là où d'autres langages utilisent des accolades `{ }`, Python utilise des espaces. Une mauvaise indentation provoquera immédiatement une erreur d'exécution (`IndentationError`). + +![Erreur d'indentation](../images/indentation.png) + +### Commentaires + +Les commentaires sont cruciaux pour documenter vos scripts. Python n'exécute pas le texte écrit à l'intérieur d'un commentaire. + +**Exemple : Commentaire sur une seule ligne** + +```shell +# Ceci est le premier commentaire +# Ceci est le deuxième commentaire +# Python est en train de conquérir le monde +``` + +**Exemple : Commentaire multiligne (Docstring)** + +On peut utiliser des triples guillemets (`"""`) pour insérer des commentaires sur plusieurs lignes, à condition qu'ils ne soient pas assignés à une variable. + +```shell +"""Ceci est un commentaire multiligne. +Il peut s'étendre sur plusieurs lignes. +Python est vraiment un langage formidable. +""" +``` + +### Types de données + +Python gère nativement plusieurs types de données fondamentaux. Voici un rapide survol pour vous familiariser avec eux (nous les étudierons en profondeur très bientôt). + +#### Nombres + +- **Entiers (Int) :** Nombres positifs, négatifs ou nuls, sans virgule. + Exemple : `... -3, -2, -1, 0, 1, 2, 3 ...` +- **Flottants (Float) :** Nombres à virgule (représentée par un point). + Exemple : `... -3.5, -2.25, -1.0, 0.0, 1.1, 2.2, 3.5 ...` +- **Complexes (Complex) :** Nombres contenant une partie imaginaire. + Exemple : `1 + j, 2 + 4j` + +#### Chaînes de caractères (String) + +Une suite de caractères entourée de guillemets simples ou doubles. Pour un texte de plusieurs phrases, on utilise les triples guillemets. + +**Exemples :** + +```py +'Asabeneh' +'Finlande' +'Python' +"J'adore enseigner" +"""J'espère que vous appréciez ce tout premier jour +du défi 30 Jours de Python.""" +``` + +#### Booléens (Boolean) + +Un type de donnée qui ne peut prendre que deux valeurs : `True` (Vrai) ou `False` (Faux). Attention, la première lettre doit toujours être une majuscule. + +**Exemple :** + +```python +True # La lumière est-elle allumée ? Si oui, la valeur est True. +False # La lumière est-elle allumée ? Si non, la valeur est False. +``` + +#### Listes (List) + +Une collection ordonnée d'éléments qui permet de stocker différents types de données. C'est l'équivalent des tableaux (Arrays) en JavaScript. + +**Exemples :** + +```py +[0, 1, 2, 3, 4, 5] # Une liste contenant uniquement des nombres +['Banane', 'Orange', 'Mangue', 'Avocat'] # Une liste uniquement de chaînes +['Banane', 10, False, 9.81] # Une liste mélangeant plusieurs types de données +``` + +#### Dictionnaires (Dictionary) + +Une collection non ordonnée de données stockées sous la forme de paires `clé: valeur`. + +**Exemple :** + +```py +{ +'first_name': 'Asabeneh', +'last_name': 'Yetayeh', +'country': 'Finlande', +'age': 250, +'is_married': True, +'skills': ['JS', 'React', 'Node', 'Python'] +} +``` + +#### Tuples + +Une collection ordonnée d'éléments, similaire à une liste, mais qui présente une différence majeure : **un tuple est immuable**. Il est impossible de le modifier après sa création. + +**Exemples :** + +```py +('Asabeneh', 'Pawel', 'Brook', 'Abraham', 'Lidiya') # Liste de noms figée +('Terre', 'Jupiter', 'Neptune', 'Mars', 'Vénus') # Les planètes +``` + +#### Ensembles (Set) + +Une collection non ordonnée d'éléments. Contrairement aux listes ou aux tuples, un ensemble ne peut stocker que des **éléments uniques** (les doublons sont automatiquement supprimés). L'ordre des éléments n'a aucune importance. + +**Exemples :** + +```py +{2, 4, 3, 5} +{3.14, 9.81, 2.7} +``` + +### Vérifier les types de données + +Pour connaître le type d'une donnée ou d'une variable, on utilise la fonction native **`type()`**. Regardez les exemples d'utilisation directement depuis le terminal : + +![Vérification des types de données](../images/checking_data_types.png) + +### Fichiers Python + +Ouvrez votre dossier de projet `30DaysOfPython`. À l'intérieur, localisez ou créez le fichier `helloworld.py`. Nous allons maintenant reproduire ce que nous avons fait dans le Shell, mais au sein de notre fichier de code. + +*Note importante :* Le Shell interactif affiche directement les résultats sans qu'on ait besoin de lui demander. Dans un fichier de script sur VS Code, vous devez impérativement utiliser la fonction intégrée **`print()`** pour afficher un résultat dans la console. Elle peut prendre un ou plusieurs arguments séparés par des virgules : `print('argument1', 'argument2')`. + +**Exemple dans le fichier `helloworld.py` :** + +```py +# Jour 1 - Défi 30DaysOfPython + +print(2 + 3) # Addition (+) +print(3 - 1) # Soustraction (-) +print(2 * 3) # Multiplication (*) +print(3 / 2) # Division (/) +print(3 ** 2) # Puissance (**) +print(3 % 2) # Modulo (%) +print(3 // 2) # Division entière (//) + +# Vérification des types de données +print(type(10)) # (Entier) +print(type(3.14)) # (Flottant) +print(type(1 + 3j)) # (Nombre complexe) +print(type('Asabeneh')) # (Chaîne de caractères) +print(type([1, 2, 3])) # (Liste) +print(type({'name': 'Asabeneh'})) # (Dictionnaire) +print(type({9.8, 3.14, 2.7})) # (Ensemble) +print(type((9.8, 3.14, 2.7))) # (Tuple) +``` + +Pour exécuter votre code : cliquez sur le bouton de lecture vert en haut à droite de VS Code, ou ouvrez votre terminal dans le bon dossier et tapez `python3 helloworld.py`. + +![Exécution d'un script Python](../images/running_python_script.png) + +Vous êtes incroyable ! Vous venez de terminer le Jour 1. C'est un excellent début sur la voie de la maîtrise de Python. Pratiquez dès maintenant avec ces quelques exercices. + +## 💻 Exercices - Jour 1 + +### Exercices : Niveau 1 + +1. Vérifiez la version de Python que vous utilisez actuellement. +2. Ouvrez le Shell interactif de Python et effectuez les opérations suivantes en utilisant les nombres **3** et **4** comme opérandes : + - Addition (+) + - Soustraction (-) + - Multiplication (\*) + - Modulo (%) + - Division (/) + - Puissance (\*\*) + - Division entière (//) +3. Écrivez les chaînes de caractères suivantes dans le Shell interactif : + - Votre prénom + - Votre nom de famille + - Votre pays de résidence + - La phrase : "J'apprécie les 30 jours de Python" +4. Vérifiez le type des données suivantes à l'aide de la fonction appropriée : + - `10` + - `9.8` + - `3.14` + - `4 - 4j` + - `['Asabeneh', 'Python', 'Finlande']` + - Votre prénom + - Votre nom de famille + - Votre pays de résidence + +### Exercices : Niveau 2 + +1. Créez un sous-dossier nommé `day_1` à l'intérieur de votre dossier `30DaysOfPython`. Dans ce dossier `day_1`, créez un fichier nommé `helloworld.py`. Répétez l'ensemble des questions du Niveau 1 (1, 2, 3 et 4) à l'intérieur de ce fichier. N'oubliez pas d'encadrer vos instructions avec la fonction `print()` pour que les résultats s'affichent. Utilisez votre terminal pour naviguer jusqu'au dossier et exécutez votre script. + +### Exercices : Niveau 3 + +1. Écrivez dans un script un exemple concret pour chacun des types de données Python suivants : Nombres (Entier, Flottant, Complexe), Chaîne de caractères, Booléen, Liste, Tuple, Ensemble et Dictionnaire. +2. Calculez la distance euclidienne entre les points $(2, 3)$ et $(10, 8)$. *Indice : vous pouvez vous référer à la formule mathématique de la [distance euclidienne](https://en.wikipedia.org/wiki/Euclidean_distance).* + +🎉 FÉLICITATIONS ! 🎉 + +[Aller au Jour 2 >>](./02_variables_builtin_functions_fr.md) diff --git a/readme.md b/readme.md index 5fdb51a27..2c890e74d 100644 --- a/readme.md +++ b/readme.md @@ -33,6 +33,7 @@ | 29 | [Building API](./29_Day_Building_API/29_building_API.md)| | 30 | [Conclusions](./30_Day_Conclusions/30_conclusions.md)| + 🧡🧡🧡 HAPPY CODING 🧡🧡🧡 --- @@ -122,7 +123,7 @@ Every contribution, big or small, makes a huge difference. Thank you for your su 🇧🇷 [Portuguese](./Portuguese/README.md) 🇨🇳 [中文](./Chinese/README.md) - +🇫🇷[French](./French/README_fr.md) [Day 2 >>](./02_Day_Variables_builtin_functions/02_variables_builtin_functions.md) ![30DaysOfPython](./images/30DaysOfPython_banner3@2x.png)