diff --git a/French/02_variables_builtin_functions_fr.md b/French/02_variables_builtin_functions_fr.md new file mode 100644 index 000000000..342a15cdc --- /dev/null +++ b/French/02_variables_builtin_functions_fr.md @@ -0,0 +1,305 @@ +[<< Jour 1](./README_fr.md) | [Jour 3 >>](./03_operators_fr.md) +
+

30 Days Of Python: Jour 2 - Variables, Fonctions intégrées

+ + + + + Twitter Follow + + +Auteur : +Asabeneh Yetayeh
+ Deuxième édition : juillet 2021 + + +
+ +[<< Jour 1](../readme.md) | [Jour 3 >>](../03_Day_Operators/03_operators.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 assigné à la variable first_name. Le signe égal est un opérateur d'assignation. Assigner 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('First name:', first_name) +print('First name length:', len(first_name)) +print('Last name: ', last_name) +print('Last name length: ', len(last_name)) +print('Country: ', country) +print('City: ', city) +print('Age: ', age) +print('Married: ', is_married) +print('Skills: ', skills) +print('Person information: ', 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', 'Helsink', 250, True + +print(first_name, last_name, country, age, is_married) +print('First name:', first_name) +print('Last name: ', last_name) +print('Country: ', country) +print('Age: ', age) +print('Married: ', 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('What is your name: ') +age = input('How old are you? ') + +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', int(num_str)) # 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 (Integers) : 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.md) | [Jour 3 >>](../03_Day_Operators/03_operators.md) diff --git a/French/03_operators_fr.md b/French/03_operators_fr.md new file mode 100644 index 000000000..6684c3594 --- /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 surcharger 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 not 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..1ad53f88d --- /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('I hope everyone is enjoying the Python Challenge.\nAre you ?') # saut de ligne +print('Days\tTopics\tExercises') # tabulation ou 4 espaces +print('Day 1\t5\t5') +print('Day 2\t6\t20') +print('Day 3\t5\t23') +print('Day 4\t1\t35') +print('This is a backslash symbol (\\)') # Pour écrire un antislash +print('In every programming language it starts with \"Hello, World!\"') # guillemet double dans une chaîne simple + +# affichage +I hope every one is enjoying the Python Challenge. +Are you ? +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 = 'I am {} {}. I teach {}'.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 = 'The area of a circle with a radius {} is {:.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 = 'I am {} {}. I am a {}. I am {} years old. I live in {}.'.format(first_name, last_name, job, age, country) +print(sentence) # I am Asabeneh Yetayeh. I am 250 years old. I am a teacher. I live in Finland. + +radius = 10 +pi = 3.14 +area = pi * radius ** 2 +result = 'The area of a circle with radius {} is {}'.format(str(radius), str(area)) +print(result) # The area of a circle with radius 10 is 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..ac36ecb9d --- /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 (muable). 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 (muable). 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 en ordre croissant et modifie la liste d'origine. Si l'argument reverse de _sort()_ est true, la liste est triée en 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 en 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..f0a507ac0 --- /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 (muable). 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..2532d5c9a --- /dev/null +++ b/French/07_sets_fr.md @@ -0,0 +1 @@ +[<< 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..f1961c381 --- /dev/null +++ b/French/08_dictionaries_fr.md @@ -0,0 +1 @@ +[<< 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..5de386fac --- /dev/null +++ b/French/09_conditionals_fr.md @@ -0,0 +1 @@ +[<< 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..fc2ee72fc --- /dev/null +++ b/French/10_loops_fr.md @@ -0,0 +1 @@ +[<< 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..4e974a196 --- /dev/null +++ b/French/11_functions_fr.md @@ -0,0 +1 @@ +[<< 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..1716ba134 --- /dev/null +++ b/French/12_modules_fr.md @@ -0,0 +1 @@ +[<< 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..34d3dd199 --- /dev/null +++ b/French/13_list_comprehension_fr.md @@ -0,0 +1 @@ +[<< 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..76b9bedd5 --- /dev/null +++ b/French/14_higher_order_functions_fr.md @@ -0,0 +1 @@ +[<< 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..f34946a15 --- /dev/null +++ b/French/15_python_type_errors_fr.md @@ -0,0 +1 @@ +[<< 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..9ebe08460 --- /dev/null +++ b/French/16_python_datetime_fr.md @@ -0,0 +1 @@ +[<< 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..61e0918f1 --- /dev/null +++ b/French/17_exception_handling_fr.md @@ -0,0 +1 @@ +[<< 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..fd9f8876d --- /dev/null +++ b/French/18_regular_expressions_fr.md @@ -0,0 +1 @@ +[<< 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..411b4aa90 --- /dev/null +++ b/French/19_file_handling_fr.md @@ -0,0 +1 @@ +[<< 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..548ad000d --- /dev/null +++ b/French/20_python_package_manager_fr.md @@ -0,0 +1 @@ +[<< 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..a17859241 --- /dev/null +++ b/French/21_classes_and_objects_fr.md @@ -0,0 +1 @@ +[<< 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..7d8723754 --- /dev/null +++ b/French/22_web_scraping_fr.md @@ -0,0 +1 @@ +[<< 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..b9c72329d --- /dev/null +++ b/French/23_virtual_environment_fr.md @@ -0,0 +1 @@ +[<< 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..3c440b838 --- /dev/null +++ b/French/24_statistics_fr.md @@ -0,0 +1 @@ +[<< 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..d904e8646 --- /dev/null +++ b/French/25_pandas_fr.md @@ -0,0 +1 @@ +[<< 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..4e18c030f --- /dev/null +++ b/French/26_python_web_fr.md @@ -0,0 +1 @@ +[<< 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..f9cf90df9 --- /dev/null +++ b/French/27_python_with_mongodb_fr.md @@ -0,0 +1 @@ +[<< 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..e2c8bdfcd --- /dev/null +++ b/French/28_API_fr.md @@ -0,0 +1 @@ +[<< 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..5bb863f71 --- /dev/null +++ b/French/29_building_API_fr.md @@ -0,0 +1 @@ +[<< 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..b1712016c --- /dev/null +++ b/French/30_conclusions_fr.md @@ -0,0 +1 @@ +[<< 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..a561992f4 --- /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_Day_Variables_builtin_functions/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_Day_Lists/05_lists_fr.md) | +| 06 | [Tuples](./06_Day_Tuples/06_tuples_fr.md) | +| 07 | [Ensembles](./07_Day_Sets/07_sets_fr.md) | +| 08 | [Dictionnaires](./08_Day_Dictionaries/08_dictionaries_fr.md) | +| 09 | [Conditionnelles](./09_Day_Conditionals/09_conditionals_fr.md) | +| 10 | [Boucles](./10_Day_Loops/10_loops_fr.md) | +| 11 | [Fonctions](./11_Day_Functions/11_functions_fr.md) | +| 12 | [Modules](./12_Day_Modules/12_modules_fr.md) | +| 13 | [Compréhension de listes](./13_Day_List_comprehension/13_list_comprehension_fr.md) | +| 14 | [Fonctions d'ordre supérieur](./14_Day_Higher_order_functions/14_higher_order_functions_fr.md) | +| 15 | [Types d'erreurs en Python](./15_Day_Python_type_errors/15_python_type_errors_fr.md) | +| 16 | [Dates et heures en Python](./16_Day_Python_date_time/16_python_datetime_fr.md) | +| 17 | [Gestion des exceptions](./17_Day_Exception_handling/17_exception_handling_fr.md) | +| 18 | [Expressions régulières](./18_Day_Regular_expressions/18_regular_expressions_fr.md) | +| 19 | [Gestion de fichiers](./19_Day_File_handling/19_file_handling_fr.md) | +| 20 | [Gestionnaire de paquets](./20_Day_Python_package_manager/20_python_package_manager_fr.md) | +| 21 | [Classes et objets](./21_Day_Classes_and_objects/21_classes_and_objects_fr.md) | +| 22 | [Web scraping](./22_Day_Web_scraping/22_web_scraping_fr.md) | +| 23 | [Environnements virtuels](./23_Day_Virtual_environment/23_virtual_environment_fr.md) | +| 24 | [Statistiques](./24_Day_Statistics/24_statistics_fr.md) | +| 25 | [Pandas](./25_Day_Pandas/25_pandas_fr.md) | +| 26 | [Python sur le web](./26_Day_Python_web/26_python_web_fr.md) | +| 27 | [Python et MongoDB](./27_Day_Python_with_mongodb/27_python_with_mongodb_fr.md) | +| 28 | [API](./28_Day_API/28_API_fr.md) | +| 29 | [Construire une API](./29_Day_Building_API/29_building_API_fr.md) | +| 30 | [Conclusions](./30_Day_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

+
+
+ + + + Wispr Flow Logo + + + +

+ + Parlez au code, restez dans le Flow. + +

+ +

+ + Flow est conçu pour les développeurs qui vivent dans leurs outils. Parlez, donnez plus de contexte et obtenez de meilleurs résultats. + +

+
+
+
+ + + + Petrosky Logo + + + +

+ + Un hébergement pour l'ensemble de votre parcours ! + +

+ +

+ + Des services d'hébergement VPS abordables pour tous vos besoins. + +

+
+ +--- + +### 🙌 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_Day_Variables_builtin_functions/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 une réelle dévotion pour être accompli. 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 qu'il 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_Day_Variables_builtin_functions/02_variables_builtin_functions_fr.md)