Forem: Eric Le Codeur

Python : Modules et Packages

Eric Le Codeur — Mon, 11 Apr 2022 22:24:25 +0000

Le cours accéléré Python est gratuit et sera publié ici sur dev.to. Je publierai un nouvel article tous les deux jours environ. Pour ne rien manquer, vous pouvez me suivre sur twitter : Suivez @EricLeCodeur

Modules et Packages

Créer vos propres modules

Jusqu’à présent, nous avons utilisé plusieurs modules déjà inclut dans Python. Maintenant il est temps de créer nos propres modules.

Lorsque nous créons une application Python, nous n’allons pas placer tous notre code dans un seul et unique fichier. Il est possible pour des questions de lisibilité et de ré-utilisabilité de créer nos propres modules.

Qu’est-ce qu’un module Python ?

Python considère comme un module n’importe quel fichier avec l’extension ".py". Voici une structure de fichier qui serait possible d’avoir pour votre application

main.py
utilities.py

L’application comporte deux modules. Le module principal “main.py” et un autre module “utilities.py”

Voici un exemple de leur contenu :

utilities.py

def display_message(message):
    print("******************")
    print(" " + message)
    print("******************\n")

Le fichier contient la fonction display_message() qui permet d'afficher un message

main.py

import utilities

utilities.display_message("Hello World")

Ici l’instruction “import” permet d’inclure et d’utiliser le code du fichier “utilities.py” dans le fichier en cours.

À noter que pour appeler la fonction display_message() il faut utiliser le nom du module soit : utilities.display_message()

Si on exécute main.py on obtient :

******************
 Hello World
******************

Syntaxe alternative

Il est possible d’utiliser l’instruction “import” d’une autre façon

main.py

from utilities import display_message

display_message("Hello World")

L’instruction “from” permet d’importer seulement une partie du fichier “utilities.py”. Dans ce cas-ci, seulement la fonction display_message() sera importé.

Le résultat sera le même sauf que l’appel de la fonction ne nécessite plus le nom du module.

Import avec un autre nom de module

Lors de l’import, il est possible de modifier le nom du module

import utilities as utils

utils.display_message("Hello World")

L’instruction “as” permet de modifier le nom qui sera utilisé pour l’appel.

Regrouper plusieurs modules ensemble sous un package

Lorsque l’on construit des applications d’une certaine taille, nous aurons beaucoup de modules. Certains de ces modules pourraient être regroupés ensemble (sous un même dossier) afin de rendre l’application plus logique.

Voici un exemple. Supposons que nous avons une application avec ces modules

math_add.py
math_sub.py
message_info.py
message_log.py
message_error.py

Ici notre application comporte 5 modules. 2 sont relatifs au Math et 3 autres messages.

Il serait donc peut-être plus logique de diviser l’application avec cette structure de dossier :

/math
    add.py
    sub.py

/message
    info.py
    log.py
    error.py

Ici la structure est plus logique et par conséquent sera donc plus facile à comprendre, à maintenir et à faire évoluer.

Pour utiliser cette structure en Python. Il faut aviser Python que les dossiers /math et /message sont en faite des packages Python.

Un "package" est en faite un simple dossier qui contient des modules.

Pour indiquer à Python qu’un dossier est un package il faut créer un fichier vide nommé __init__.py

/math
    __init__.py
    add.py
    sub.py

/message
    __init__.py
    info.py
    log.py
    error.py

Si le fichier __init__.py est présent dans le dossier, Python va le considérer comme un package.

Utiliser un package dans votre application

Pour faire l’“import” de ces packages dans le code de votre application, vous devez utiliser la syntaxe suivante.

import math.add

Ici Python va rendre disponible le code du fichier “add.py” inclut dans le package “math”

Utiliser des librairies crée par la communauté

Une des forces de Python est son immense communauté.

Vous avez un problème et vous cherchez à le résoudre à l’aide de Python ?

Pourquoi réinventer la roue ? Il y a de forte chance qu’un membre a déjà rencontrer ce problème et encore mieux qu’il a partagé sa solution avec la communauté.

Les packages créés par la communauté sont répertoriés sur le site https://pypi.org/ et peuvent être installés sur votre ordinateur à l’aide de l’application PIP.

Cette application permet d’installer sur votre machine la ou les librairies que vous aurez choisies.

Vérifier l’installation de PIP

À partir de la console, lancer Python avec le module PIP

python -m pip --version

ou

python3 -m pip --version

# pip 22.0.4 from /Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages/pip (python 3.10)

Ici PIP est bel et bien installé. Si vous avez un problème quelconque, revisitez la procédure d’installation de Python au début de ce cours.

Installé et utiliser votre premier package

python -m pip install emoji

ou

python3 -m pip install emoji

Avec cette commande, le package “emoji” est maintenant installé et utilisable.

À noter que certains package sont dépendants de d’autres packages pour fonctionner. PIP va installer le package demandé mais également les autres dépendances nécessaires.

python3 - m pip list

Package    Version
---------- -------
emoji      1.7.0
pip        22.0.4
setuptools 58.1.0

La commande PIP list permet d'afficher la liste de tous les packages installés sur votre machine.

PIP a installé la dernière version par défaut

python3 -m pip uninstall emoji

python3 -m pip list

Package    Version
---------- -------
pip        22.0.4
setuptools 58.1.0

La commande pip uninstall désinstalle le package “emoji” sur votre machine.

Le package “emoji” permet d’ajouter des emoji au message imprimer dans le terminal.

Voici un exemple d’utilisation du package emoji

import emoji

print(emoji.emojize('Python is :thumbs_up:'))

# Python is 👍

Pour utiliser un package qui vous a installé, il faut faire un import.

À noter que plusieurs packages possèdent une documentation en ligne qui vous informe des fonctions disponibles et comment les utiliser.

À quel endroit sont installés les packages sur votre machine ?

Les packages installés avec PIP sont installés dans un dossier central partagé entre toutes vos applications Python.

Donc une fois qu’un package est installé sur votre machine, il n’est pas nécessaire de le réinstaller si vous en avez besoin pour une autre application.

Problème de version ?

Cette façon de procéder va un jour ou l’autre apporter un problème au niveau des versions. Par exemple votre application 1 va utiliser le packages “emoji” version 1.7 mais votre application 2 a besoin de “emoji” version 1.8

Comment éviter les problèmes de version ?

Pour éviter ce genre de problème, il existe une solution et c’est de créer un “environnement virtuel” pour chacun de vos projets.

Environnement Virtuel

Un environnement virtuel c’est un dossier dans lequel sont placés tous les fichiers nécessaires afin de faire fonctionner votre application.

Par exemple, Python, PIP et les packages de la communauté que vous utilisez dans votre application.

Enfin, cet environnement peut être re-créer sur n’importe quelle machine ou serveur et exécuter votre code avec exactement les bonnes versions de tous !

Qu’est-ce un environnement virtuel ?

Ne vous laissez pas impressionner par ce grand nom. Un environnement virtuel est simplement un dossier qui contient une version x de Python (ex 3.9) et une version x des autres packages nécessaires au bon fonctionnement de votre application.

Chaque application possède son propre environnement virtuel (dossier) afin d’y garder les librairies nécessaires a son bon fonctionnement.

Exemple de création d’un environnement virtuel

Lorsque l'on travaille sur un projet Python, on est amené à travailler avec plusieurs librairies comme FastAPI, Flask ou Django, etc.

Selon la date de création du projet. Il est possible par exemple que la librairie FastAPI ne soit pas exactement au même no de version dans les autres projets.

Comment faire pour permettre à chaque projet d'avoir sa propre version de Python et ses propres versions de librairies ?

Nous allons utiliser les environnements virtuels.

Un environnement virtuel permet d'installer Python et des librairies python dans un dossier/projet sans que cela n'affecte les autres dossiers/projets.

Python met à votre disposition un système qui permet de créer des environnements virtuels.

Une fois l'environnement créé et activé, toutes les librairies installées pourront être utilisées seulement dans l'environnement auquel ils appartiennent.

Comment créer un environnement virtuel

Normalement nous plaçons un environnement virtuel dans le dossier du projet.

Créer et accéder à un dossier pour notre projet

$ mkdir learn-python
$ cd learn-pythob

À partir de ce dossier vous pouvez maintenant créer l'environnement virtuel qui sera attaché au projet

$ python3 -m venv env

Ici on lance python3 avec l'option module venv. env est le nom que l'on donne à notre environnement virtuel.

Une fois l’environnement virtuel créé vous pouvez l'activer :

MacOS / Linux

$ source env/bin/activate

Windows

$ env\\Scripts\\activate.bat

Voilà c'est tout ! Vous avez maintenant un environnement virtuel Python créé pour votre projet. Normalement le terminal vous indiquera que votre environnement est activé en affichant son nom.

À noter que pour désactiver l'environnement virtuel vous devez exécuter

$ deactivate

Conclusion

C'est tout pour aujourd'hui, je publierai un nouvel article tous les deux jours environ. Pour être sûr de ne rien rater vous pouvez me suivre sur twitter : Suivre @EricLeCodeur

Python : Manipulation des dossiers et fichiers

Eric Le Codeur — Tue, 05 Apr 2022 06:14:14 +0000

Manipulation de dossiers et fichiers

Python rend très simple la lecture et écriture de fichiers et dossier. Voici les principales fonctions

Lecture d’un fichier

Voici un fichier test “names.txt”

Mike Taylor
John Desbien
Marc Lacasse
Paul Brown

La fonction “open” permet d’ouvrir un fichier en mode lecture. La fonction readline() permet de lire une ligne dans le fichier. Enfin, la fonction close() permet de fermer le fichier.

filename = 'names.txt'
file = open(filename)
line = file.readline()
file.close()

print(line)
# Mike Taylor

Il est possible de lire toutes les lignes d’un coup avec la fonction readlines(). Cette fonction retournera un tableau avec une entrée pour chaque ligne.

filename = 'names.txt'
file = open(filename)
lines = file.readlines()
file.close()

print(lines)
# ['Mike Taylor\n', 'John Desbien\n', 'Marc Lacasse\n', 'Paul Brown']

Utiliser l’instruction “with”

L’utilisation séparée de la fonction open() et close() n’est pas la façon la plus efficace de travailler avec les fichiers. La raison c’est que si vous oubliez de fermer votre fichier ou que votre application s’arrête brusquement dû à une erreur, le fichier ne serait jamais fermé convenablement.

Il existe une syntaxe qui permettra de gérer la fermeture du fichier automatiquement et cela même en cas d’erreur dans votre application. Pour ce faire il faut utiliser l’instruction “with”.

Voici un exemple :

filename = 'names.txt'
with open(filename) as file:
    lines = file.readlines()

print(lines)

Ici l’instruction “with” permet de créer un bloc de code. Les instructions relativent au fichier seront exécuter dans le bloc de code. Une fois le bloc terminé, l’instruction “with” va automatiquement fermer le fichier et nettoyer les références mémoires.

Écriture d’un fichier

Même principe que la lecture. La différence c’est qu’il faut utiliser un argument qui va spécifier le type d’écriture : “w” pour “overwrite” ou “a” pour “append”

names = [
    "Mike Taylor/n",
    "John Desbien/n",
    "Marc Lacasse/n",
    "Paul Brown/n"
]

filename = 'names.txt'

with open(filename, "w") as file:
    file.writelines(names)

À noter que la fonction writelines() n’inclut pas un caractère “saut de ligne”. Nous l’avons donc ajouté manuellement à la fin de chaque “names”

Créer un dossier

Et si vous désirez placer vos fichiers dans un sous dossier ex: /data ?

La fonction os.mkdir() permet justement de faire cela

import os

os.mkdir("data")

Ici le dossier “data” sera créé dans le dossier en cours. Si le dossier “data” existe déjà une erreur sera retourné.

Pour éviter cette situation il est possible de vérifier si le dossier existe avec la fonction exists()

from genericpath import exists
import os

if not exists("data"):
    os.mkdir("data")

Cette fonction peut vérifier autant l’existence d’un dossier que d’un fichier

Créer un fichier CSV

import csv

products = [
    {'id': 100, 'name': 'iPadPro'},
    {'id': 200, 'name': 'iPhone 12'},
    {'id': 300, 'name': 'Charger'},
]

csv_file = 'export.csv'
csv_columns = products[0].keys() # ['id', 'name']

with open(csv_file, 'w') as csvfile:
    writer = csv.DictWriter(csvfile, fieldnames=csv_columns)
    writer.writeheader()

    for item in products:
        writer.writerow(item)

Examinons ce code ligne par ligne:

Le tableau products est la liste de produit que l’on souhaite exporter en csv
csv_file est le nom du fichier
csv_columns est le nom de chaque colonnes du fichier. Le nom des colonnes est le même que le nom des clés du dictionnaires
writer.writeheaders() va écrire le noms des colonnes sur la première ligne du fichier
writer.writerow() va écrire chaque ligne du tableau dans le fichier

Path relatif vs absolue

La plupart des fonctions de manipulations de fichiers Python permettent d’utiliser un path relatif ou absolue.

Voici un exemple de chacun

Path relatif

relative_path = "/data"

Le path relatif a comme point de depart le dossier en cours d’exécution. Donc en supposant que le script Python s’exécute du dossier en cours “/users/eric/dev/learn_python/” le path relatif “/data” sera égale à un path absolue : “/users/eric/dev/learn_python/data”

Path absolue

abdolute_path_mac = "/users/eric/dev/learn_python/data"
absolute_path_windowns = "c:\users\eric\dev\learn_python\data"

Le path absolue est le chemin complet pour accéder au dossier/fichier

La plus part des fonctions de manipulation de fichiers supportent les deux type de path (relatif et absolue) et vont s’adapter en conséquence.

Ces deux appels de fonction aurons le meme résultat

import os

os.mkdir("data") 
# va créer /users/eric/dev/learn_python/data

os.mkdir("/users/eric/dev/learn_python/data")
# va créer /users/eric/dev/learn_python/data

Conclusion

C'est tout pour aujourd'hui, je publierai un nouvel article tous les deux jours environ. Pour être sûr de ne rien rater vous pouvez me suivre sur twitter : Suivre @EricLeCodeur

Python : Les Fonctions

Eric Le Codeur — Fri, 01 Apr 2022 08:41:23 +0000

Créer vos propres fonctions

Comme vous avez pu le constater jusqu’à présent, Python inclut déjà plusieurs fonctions afin de nous simplifier la vie.

Le même principe va s'appliquer dans votre application, c’est-à-dire qu'il est possible de simplifier votre vie et celle de votre équipe en créant des fonctions réutilisables.

Voici les grandes lignes sur comment créer ses propres fonctions.

Déclaration

Pour créer une fonction vous devez utiliser l’instruction “def” suivit du nom de votre fonction, ajouter les parenthèses () et enfin les deux “:” qui indiquerons le début de votre bloc de code.

def say_hello():
    print("Hello World")

Voilà votre première fonction !

Par contre, ceci n’est que la déclaration, pour la lancer il faut l’appeler de votre code.

say_hello()

# Hello World

L’appel se fait en utilisant le nom de la fonction suivit des parenthèses ()

Arguments

Il est possible de créer une fonction avec un ou des arguments. Les arguments sont un concept très puissant car ils permettent de personnaliser la fonction.

def say_hello(message):
    print(message)

say_hello("Hello all!")

# Hello all!

À noter que le nombre d’argument de déclaration doit être identique au nombre d’argument lors de l’appel. Sinon, Python retournerait une erreur.

Pour éviter cette situation, un argument peut avoir une valeur par défaut. Pour ce faire il faut assigner une valeur à l’argument (argument = valeur par défaut)

def say_hello(message = "Hello World!"):
    print(message)

say_hello()
# Hello World

Ici, l’appel de notre fonction say_hello() n’a pas d’argument. Python va donc utiliser sa valeur par défaut spécifié lors de sa déclaration.

Du coup, avec ce concept il est possible de rendre un argument optionnel.

Multiples arguments

Évidemment il est possible d’avoir plusieurs arguments

def say_hello(message, upper):
    if upper:
        return message.upper()
    else:
        return message

print(say_hello("Hello World", True))

Comme il est également possible d’avoir plusieurs valeurs par défaut

def say_hello(message="Hello", upper=True):
    if upper:
        return message.upper()
    else:
        return message

print(say_hello())

Ici l’appel de la fonction say_hello() est possible sans argument car les deux arguments sont optionnels.

Ordre des arguments quand il y a une valeur par défaut

À noter que les arguments qui ont une valeur par défaut doivent absolument être placés en dernier.

Voici un exemple qui retournera une erreur :

def say_hello(message="Hello", upper):
    if upper:
        return message.upper()
    else:
        return message

print(say_hello(True))
# SyntaxError: non-default argument follows default argument

Le code suivant n’est pas valide et retournera une erreur car certains arguments ont une valeur par défaut mais l’argument “upper” est en dernier et n’a pas de valeur par défaut. Dans cet exemple il serait impossible pour Python de savoir si l’argument True doit être associé à la variable “message” ou “upper”

Nommé un argument

Si une fonction comporte plusieurs arguments elle peut rapidement devenir complexe à lire.

Voici un exemple d’une fonction avec plusieurs arguments:

def create_invoice(sub_total, shipping, taxes):
    print("...code...")

create_invoice(1000, 25, 100)

Lors de l’appel de la fonction il faut spécifier 3 arguments de type nombre. Il devient alors difficile de savoir à quoi servent ces nombres, du coup la lecture du code n’est pas explicite.

Pour éviter cette situation, Python permet de spécifier le nom de l’argument

create_invoice(sub_total=1000, shipping=25, taxes=100)

Comme vous pouvez le constater, cette syntaxe rend la lecture du code beaucoup plus compréhensible.

Cette syntaxe permet également de changer l’ordre des arguments

create_invoice(taxes=100, sub_total=1000, shipping=25)

Une fonction qui retourne une valeur

Une fonction peut être assignée comme valeur à une variable

amount = calc_total(500, 50, 25)

Il est possible pour une fonction de retourner une valeur lors de son exécution. Pour ce faire vous devez utiliser l’instruction “return”

def calc_total(sub_total, taxes, shipping):
    return sub_total + taxes + shipping

Si la fonction n’a pas d’instruction “return” elle va retourner “None”

def say_hello(message):
    print(message)

return_value = say_hello("Hello World!")
print(return_value)

# Hello World
# None

En l’absence de l’instruction “return” la fonction va retourner la valeur “None”

Conclusion

C'est tout pour aujourd'hui, je publierai un nouvel article tous les deux jours environ. Pour être sûr de ne rien rater vous pouvez me suivre sur twitter : Suivre @EricLeCodeur

Python : Manipulation des dictionnaires

Eric Le Codeur — Wed, 30 Mar 2022 08:43:10 +0000

Type de variable : Dictionnaires

Les dictionnaires permettent de stocker plusieurs items dans une seule variable sous le format clé/valeur.

Un dictionnaire est très semblable à une List mais au lieu d'utiliser des index, on utilise des clés.

Par exemple, parfois nous aurions besoin d’une liste d’étudiant avec leur no, leur nom et leur âge. Pour ce faire nous pourrions utiliser une variable de type List que nous venons justement d’apprendre :

student = ["1020", "Mike Taylor", 17]

print(student)
# ["1020", "Mike Taylor", 17]

Quoique cet exemple soit fonctionnel, il serait beaucoup plus simple et efficace si notre No d’étudiant pouvait être la clé d’accès.

Voici un exemple du résultat désirez. C’est-à-dire accéder à l’information à partir d’un nom de clé.

print(student["no"])
# 1020

print(student["name"])
# Mike Taylor

print(student["age"])
# 17

Ce type de liste avec une clé personnalisée existe en Python sous le nom de Dictionary.

Créer un Dictionary

Voici comment déclarer un Dictionary on utilisant les accolades { }

student = {
    "no": 1020,
    "name": "Mike Taylor",
    "age": 17
}

La structure d’un Dictionary est sous forme de clé/valeur. La syntaxe est la suivante : “nom de la clé”: valeur

"no": 1020

Chaque clé/valeur est séparée par une virgule.

student = {
    "no": 1020,
    "name": "Mike Taylor",
    "age": 17
}

Récupération

La récupération peut s’effectuer directement ou avec la fonction get()

Directement :

print(student["no"])

# KeyError: 'num'

Si la clé n’existe pas, la syntaxe directe retourne une erreur “KeyError: 'num’” et du coup arrête l’exécution du code

Fonction get()

print(student.get("num"))

# None

Si la clé n’existe pas, la fonction get() retourne la valeur “None” du coup le code continu son exécution.

Avec la fonction get() il est possible de retourner une valeur par défaut si la clé n’existe pas.

print(student.get("num", "no key"))

# no key

Ajouter une clé/valeur

Pour ajouter une clé/valeur il suffit d’assigner :

student = {
    "no": 1020,
    "name": "Mike Taylor",
    "age": 17
}

student["city"] = "Paris"

print(student)
# {'no': 1020, 'name': 'Mike Taylor', 'age': 17, 'city': 'New York'}

Effacer une clé/valeur

Pour effacer une clé/valeur du dictionnaire. Il suffit d'utiliser le mot-clé "del"

student = {
    "no": 1020,
    "name": "Mike Taylor",
    "age": 17
}

del student["age"]
print(student)
#{'no': 1020, 'name': 'Mike Taylor'}

Boucle dans les items d’un Dictionary

Comme pour une List, il est possible de faire une boucle dans un Dictionary. Le seul truc c’est qu’il faut identifier à l’avance sur quoi nous voulons faire la boucle. Les clés ? Les valeurs ? Les deux ?

Boucle sur les clés. Pour ce faire il faut utiliser la fonction keys(). Cette fonction retourne une liste de toutes les clés du Dictionary

student = {
    "no": 1020,
    "name": "Mike Taylor",
    "age": 17
}

print(student.keys())
# dict_keys(['no', 'name', 'age'])

Il sera donc possible de faire une boucle sur cette liste

student = {
    "no": 1020,
    "name": "Mike Taylor",
    "age": 17
}

for key in student.keys():
    print(key)

# no
# name
# age

Boucle sur les valeurs. Même principe que pour les clés. Sauf cette fois il faut utiliser la fonction .values()

student = {
    "no": 1020,
    "name": "Mike Taylor",
    "age": 17
}

for value in student.values():
    print(value)

# 1020
# Mike Taylor
# 17

Boucle sur clé et valeurs. Il faut utiliser la fonction items() qui fait deux retours soit la clé et la valeur.

student = {
    "no": 1020,
    "name": "Mike Taylor",
    "age": 17
}

for key, value in student.items():
    print(key, value)

# no 1020
# name Mike Taylor
# age 17

List de Dictionary

Un pattern très populaire est de créer une List de Dictionary. Ce pattern ressemble beaucoup à table dans une base de données.

La List représente chaque ligne de la table et le Dictionary représente les colonnes de la table.

products = [
    {'id': 100, 'name': 'iPadPro'},
    {'id': 200, 'name': 'iPhone 12'},
    {'id': 300, 'name': 'Charger'},
]

print(products[0]['name']) # iPadPro

Conclusion

C'est tout pour aujourd'hui, je publierai un nouvel article tous les deux jours environ. Pour être sûr de ne rien rater vous pouvez me suivre sur twitter : Suivre @EricLeCodeur

Python : Manipulation des listes

Eric Le Codeur — Mon, 28 Mar 2022 02:06:50 +0000

Type de variable : List et Tuple

Les listes permettent de stocker plusieurs items dans une seule variable.

En Python le type de cette variable est “List”. Je vais utiliser ce terme tout au long de cette section

Il arrive souvent que vous deviez stocker plusieurs informations de même nature dans plusieurs variables. Voici un exemple :

user1 = "Mike"
user2 = "Paul"
user3 = "John"
user4 = "Peter"

Quoique fonctionnel ce code n’est pas du tout efficace et sera extrêmement difficile à créer, manipuler et maintenir.

C’est pourquoi Python met à notre disposition un type de variable appelé “List”.

Les “List” permettent de stocker les informations de même nature.

Créer une variable List

Pour créer une "List" vide il suffit d’utiliser les crochets []. Python va automatiquement créer une variable de type "List"

users = []

Il est possible d’assigner des valeurs à la "List" lors de sa création :

users = ["Mike", "Paul", "John", "Peter"]

Chaque valeur est séparée par une virgule.

Une "List" peut contenir des variables de différent type.

user_info = ["Mike", 32, True]
            # Str, Int, Bool

Ajouter et supprimer un item

Une fois la variable de type List créé, il est possible d’ajouter un item avec la fonction append()

users.append("Martin")

# ["Mike", "Paul", "John", "Peter", "Martin"]

Il est possible d’enlever un item avec l’instruction “del”

users = ["Mike", "Paul", "John", "Peter"]

del users[1]

print(users)
# ['Mike', 'John', 'Peter']

Nombre d’items dans une List

La fonction “len()” permet de savoir combien d’items il y a dans une List

users = ["Mike", "Paul", "John", "Peter"]

nb_user = len(users)

print(nb_user)
# 4

Récupérer et modifier un item en particulier

Comme pour une variable de type String, un élément de votre variable List peut être accessible via son numéro de position.

users = ["Mike", "Paul", "John", "Peter"]
           0       1       2       3

print(users[2])
# John

Un item de la List peut également être modifié grâce à son numéro de position

users = ["Mike", "Paul", "John", "Peter"]

users[0] = "Sunny"

print(users[0])
# Sunny

Le numéro de position -1 permet de récupérer le dernier item d’une List

print(users[-1])
# Peter

Récupérer seulement une partie d’une List

Voici la syntaxe qui permet de récupérer une partie d’une List

list[debut:fin]

Voici un exemple

users = ["Mike", "Paul", "John", "Peter"]
#          0        1       2       3

some_users = users[1:3]
print(some_users)
# ["Paul", "John"]

Dans cet exemple, la List “users” retournera la position 1 à 3. Pour rappel, la première position est zéro et la position de fin n’est jamais incluse dans le résultat.

Si la position de début n’est pas spécifiée, Python utilisera la position zéro.

Si la position de fin n’est pas spécifié, Python utilisera la dernière position

users = ["Mike", "Paul", "John", "Peter"]
#          0       1       2        3     

first_users = users[:3]
print(first_users)
# ["Mike", "Paul", "John"]

last_users = users[2:]
print(last_users)
# ["John", "Peter"]

Récupérer toute la List

Il est possible de récupérer une List dans son entièreté et du coup effectuer une copie. Voici la syntaxe

users = ["Mike", "Paul", "John", "Peter"]

copy_users = users[:]

print(copy_users)
# ["Mike", "Paul", "John", "Peter"]

Créer une List à partir d’une String

La fonction split() permet de créer une variable List à partir d’une variable String.

colors = "red, green, blue".split()

print(colors)
# ['red', 'green', 'blue']

Par défaut, la fonction split() utilise la virgule “,” comme caractère séparateur

Voici un autre exemple avec un autre séparateur :

colors = "red - green - blue".split(" - ")

print(colors)
# ['red', 'green', 'blue']

Joindre deux variables List

Il est possible d’unir deux List en une seule grande List

colors1 = ['red', 'blue']
colors2 = ['green', 'yellow']
colors3 = colors1 + colors2

print(colors3)
# ['red', 'blue', 'green', 'yellow']

Tuples

Les Tuples sont un type de variable en Python. Ce type de variable est très semblable au type List mais avec quelques différences :

Une fois assigné, un Tuple ne peut être modifié (lecture seulement)
La performance des Tuples est légèrement supérieure au List
Un Tuple utilise les parenthèses () à la place des crochets []

Voici un exemple de List vs Tuple

# List
colors = ["red", "green", "blue"]

# Tuple
colors = ("red", "green", "blue")

Par convention, si votre liste de données est fixe et en lecture seulement alors mieux vaut la placer dans un Tuple. Sinon, une variable de type "List" fera l’affaire.

Faire une boucle dans une List

Il est possible de lire chaque item d’une "List" et d’exécuter du code. Pour ce faire il faut utiliser l’instruction “for”

items = ["iPhone", "iPad", "iWatch"]

for item in items:
    print(item)

# iPhone
# iPad
# iWatch

La syntaxe de la boucle est relativement simple “for item in items:” pourrait se traduire avec : Pour chaque “item” dans ma List “items” exécuter le bloc de code qui suit les “:”

”item” Le nom de cette variable pourrait être n’importe quoi. C’est juste une référence pour rendre la lecture du code plus simple. Voici un exemple avec un autre nom.

for product in items:
    print(product)

Nom différent mais même résultat.

Il est également possible d’obtenir un index qui représente la position de l’item dans la "List". Pour ce faire vous devez utiliser la fonction enumerate()

items = ["iPhone", "iPad", "iWatch"]

for index, item in enumerate(items):
    print(index, item)

# 0 iPhone
# 1 iPad
# 2 iWatch

La fonction enumerate() retourne deux valeurs soit l’index et l’item en tant que tel.

Boucle avec une seule ligne de code

Il existe une syntaxe propre à Python qui permet de faire cela : List Comprehension

Voici un exemple de List Comprehension

items = ["iPhone", "iPad", "iWatch"]

print_items = [print(item) for item in items]

List Comprehension avec une condition

items = ["iPhone", "", "iPad", "iWatch"]

items = ["iPhone", "", "iPad", "iWatch"]

print_items = [print(item) for item in items if item == "iPhone"]

Conclusion

C'est tout pour aujourd'hui, je publierai un nouvel article tous les deux jours environ. Pour être sûr de ne rien rater vous pouvez me suivre sur twitter : Suivre @EricLeCodeur

Python : Exécution conditionnelle et boucles

Eric Le Codeur — Thu, 24 Mar 2022 04:07:36 +0000

Exécution conditionnelle

Dans cette section nous verrons comment exécuter un bloc de code seulement si une expression est vraie.

Pour ce faire vous devez utiliser l’instruction « if » en respectant la syntaxe suivante :

if {expression}:

bloc de code à exécuter si expression est vrai

Voici un exemple

if x == 4:
    print('x est 4')

La première ligne représente la condition.

Les deux petits points ":" à la fin de la première ligne indique le début du bloc de code conditionel.

En python, La vérification de l’égalité entre deux valeurs doit être faite avec deux caractères égaux “==”

La deuxième ligne représente le code à exécuter si la condition est vraie.

À noter que la deuxième ligne commence par 4 espaces blanches. En Python ces espaces sont nécessaires afin d’indiquer que cette ligne fait partie du bloc de code.

Il est donc possible d’inclure plus d’une ligne à exécuter

if x == 4:
    print("x est 4")
    print("fait partie du bloc if")

print("Ne fait pas partie du bloc if")

Seules les lignes avec 4 espaces blancs font partie du bloc du “if”

L’opérateur Not “!”

Parfois il peut être pratique d’exécuter un bloc de code seulement si l’expression n’est pas égale à une certaine valeur.

if x != 4:
    print("x n'est pas 4")

Multiples expressions avec l’opérateur “and” et “or”

Il est possible de faire la vérification de plusieurs expressions

Voici deux exemples :

if x == 2 or x == 4:
   print("x est égale à 2 ou 4")

if x > 2 and x < 10:
   print("x est compris entre 3 et 9")

L’instruction “else”

Vous venez d’apprendre comment exécuter du code si une expression est vraie. Sachez qu’il est également possible d’exécuter du code si l’expression est fausse.

Voici un exemple :

if x == 4:
    print("x est 4")
else:
   print("x pas égale à 4")

Selon le résultat de l’expression, Python va exécuter un des deux blocs de code.

L’instruction “elif”

Il peut arriver que vous ailliez plusieurs expressions à vérifier et que chaque expression doit avoir son propre bloc de code.

if x == 4:
    print("x est 4")
elif x == 6:
    print("x est 4")
else:
   print("x pas égale à 4 ni à 6")

Expression sans opérateurs

Voici un exemple valide:

messsage = ""

if message:
    print(message)
else:
    print("Sorry, no message")

Ici le code “if message:” ne contiens pas d’opérateur de comparaison. L’expression sera donc convertie en valeur True/False (Boolean)

Dans le dernier exemple, étant donné que la variable “message" est vide, sa valeur Boolean sera “False”. Résultat, le code print(”Sorry, no message”) sera exécuté

Voici un autre exemple

shipping_fee = 100

if shipping_fee:
    print(f"Shipping fees: {shipping_fee}")
else:
   print("Free shipping")

Dans cet exemple, shipping_fee sera convertie en “True” car Python convertie tous les nombres qui ne sont pas égaux à 0 en “True”.

Si vous vous demandez quelle sera la valeur en Boolean d’une expression, vous pouvez utiliser la fonction bool(expression)

text_num = "0"

print(bool(text_num))
# True

Dans cet exemple la variable est de type texte et Python convertira en “True” toutes les variables textes qui ne sont pas vides.

Il est possible d’associé directement une valeur Boolean (True/False) à une variable et ensuite de l’utiliser dans notre code.

is_active = True

if is_active:
    print("User active")
else:
    print("User inactive")

Exécution conditionnelle avec syntaxe abrégée

Il existe une syntax abrégée qui permet d’exécuter du code conditionnel avec une seule ligne de code.

price = 100

print("C'est chers") if price > 100 else print("Pas chers")

Le même principe peut s’appliquer pour faire une assignation conditionnelle

active_color = default_color if default_color else "blue"

Itérations : Exécuter un bloc de code à plusieurs reprises

Parfois vous aurez besoin d’écrire plusieurs lignes de code qui peuvent sembler répétitives.

Par exemple écrire une petite application qui affiche les nombres 1 à 10

print(1)
print(2)
print(2)
print(4)
print(5)
print(6)
print(7)
print(8)
print(9)
print(10)

Bien que ce code fonctionne, il est clair que ce n’est pas du tout efficace car pour chaque ligne de code, seulement le nombre change.

Une meilleure solution serait de faire une boucle avec l’instruction “for”

L’instruction “for” permet de faire une boucle sur une séquence. Il est possible de créer une séquence avec la fonction range()

Par exemple, la fonction range(10) va créer la séquence suivante :

0 1 2 3 4 5 6 7 8 9

À noter que les séquences commencent toujours par la position zéro

Une fois la séquence créée, l’instruction “for” permet de faire une boucle et d’exécuter du code pour chaque valeur.

Voici un exemple :

for i in range(10): 
    print(i+1)

Avec ce code on obtient le même résultat que notre premier exemple mais beaucoup plus rapide à écrire et à maintenir.

Voici un autre exemple avec une séquence un peu plus complexe

for i in range(10, 20, 2): 
    print(i)

# 10, 12, 14, 16, 18

La fonction range() permet de spécifier trois paramètres : départ, fin et step. La valeur de départ et le step sont optionnels. Si non spécifiée, la valeur de départ sera 0 et le step sera 1.

Boucle un nombre indéterminé

Il est possible que vous ne savez pas d’avance quel sera le nombre d’itérations à effectuer. C’est pourquoi il existe en Python un autre type de boucle : l’instruction “while”

L’instruction “while” permet d’exécuter du code tant que l’expression est True

Voici un exemple :

key = ""

while key != "5":
    key = input("Enter your selection (5 = Quit): ")

Dans cet exemple, le bloc de code sera exécuté tant et aussi longtemps que la valeur de key ne sera pas “5”.

La fonction “break” et “continue”

Il est possible de terminer une boucle immédiatement et sans que la condition soit respectée en utilisant la fonction “break()”

key = ""

while key != "5":
    key = input("Enter your selection (5 = Quit): ")
    if key == "6":
        print("Secret door")
        break

Dans cet exemple, la fonction “break()” va terminer la boucle “while” sans exécuter aucun autre code quelle contient.

Il est également possible de sauter l’itération en cours avec la fonction “continue()”

x = 0

while x < 5:
    x += 1
    if x == 3:
        continue

    print(x)

# 1, 2, 4, 5

Dans cet exemple, le nombre 3 ne sera jamais imprimé. La fonction “continue()” renvoie l’exécution du code à la prochaine itération sans exécuter le code restant du bloc.

Boucle dans une String

Il est possible de faire une boucle sur tous les caractères d’une String. Voici un exemple :

keycode = "abc123def"

for letter in keycode:
    print(letter)


#a
#b
#c
#1
#2
#3
#d
#e
#f

Conclusion

C'est tout pour aujourd'hui, je publierai un nouvel article tous les deux jours environ. Pour être sûr de ne rien rater vous pouvez me suivre sur twitter : Suivre @EricLeCodeur

Python : Manipulation des nombres

Eric Le Codeur — Wed, 23 Mar 2022 05:21:21 +0000

Manipulation des nombres

Python permet d’exécuter la plupart des opérations mathématiques directement.

Voici quelques exemples :

# Plus et moins
num = 100 + 100 - 20 
# 180

# Division
num = 1000 / 10 
# 100.0

# Multiplication
num = 5 * 5 
# 25

# Exponentiel
num = 2 ** 4
# 16

# Modulus (reste d'une division)
num = 10 % 5
# 0

# Parenthèses (priorisation)
num = (100 + 10) * 2
# 220

Obtenir un nombre aléatoire

from random import random
print(random()) # 0.26230234411558273

La première ligne avec l’import permet d’utiliser la librairie “random” qui contient la fonction “random()”

Obtenir un nombre aléatoire entre deux valeurs spécifiées

from random import randint
print(randint(3, 9)) # 5

Arrondir un nombre

# arrondir
number = 4.6
round(number) # 5

# Arrondir avec un nombre de décimales
number = 4.5163
round(number, 2) # 4.52

Imprimer un nombre avec un format

# Formater la String avec 2 décimales
num = 12.9947
number_string = f"{num:.2f}" 
# '12.99'

Dans cet exemple, "{num:.2f}" “2” représente le nombre de décimale pour arrondir. Et le “f” indique Python que le format d’affichage sera fixe (selon nombre de décimales)

Conversion entre différents types de variable

Lorsque vous créez une variable, Python va automatiquement lui attribuer un type selon le contenu que vous lui avez assigné.

Il est possible que vous désirez changer le type de données afin de la manipuler adéquatement.

Voici quelques fonctions Python qui permettent de faire exactement cela :

# Convert to string
my_text = str(199.99)   # "199.99"

# Convert to number
my_number = int(21.99) # 21
my_number = float('21.99') # 21.99

Il est possible de récupérer le type de variable

my_text = "Hello World"
my_number = 100.0

# Get type
type(my_text) # <class 'str'>
type(my_number) # <class 'float'>

# Check type
isinstance(my_number, int) # True

Conclusion

C'est tout pour aujourd'hui, je publierai un nouvel article tous les deux jours environ. Pour être sûr de ne rien rater vous pouvez me suivre sur twitter : Suivre @EricLeCodeur

Python : Manipulation des Strings

Eric Le Codeur — Mon, 21 Mar 2022 13:39:55 +0000

Manipulation des Strings

Voyons maintenant un peu plus en détail comment créer et manipuler des chaînes de caractères (Strings) avec Python.

Une variable de type String peut être créée avec des guillemets simples ou doubles

name = 'Mike'

# ou

name = "Mike"

Python permet d’insérer des caractères spéciaux dans vos Strings.

message = "Hello \nWorld"
print(message)
# Hello
# World

Le caractère spécial “\n” va être remplacé par un saut de ligne. Python met à votre disposition plusieurs caractères spéciaux. Voici une liste : https://www.w3schools.com/python/gloss_python_escape_characters.asp

Interpolation

L’utilisation du préfixe “f” permet d’afficher le contenu de la variable spécifié entre les crochets {}

name = "Mike"

print(f"Hello {name}")
# Hello Mike

Python peut également exécuter n’importe quelle expression qui se trouve entre les crochets {}, du coup ce concept peut devenir très puissant. Voici en exemple :

name = "Mike"

print(f"Hello {name.upper()}")
# Hello MIKE

Il est également possible de joindre deux Strings avec l'opérateur "+" (plus)

name = "Mike"

print("Hello " + name)
# Hello Mike

Ignorer les caractères spéciaux

L’utilisation du préfixe “r” permet d’afficher le contenu de la String tel quelle. C’est-à-dire sans tenir compte des caractères spéciaux (ex. \n)

message = r"https:\\example.com\index.html"
print(message)
# https:\\example.com\index.html

Ici l’utilisation du préfix “r” permet d’afficher le path correctement. Sinon Python aurait interprété le double backslash "\\" comme un caractère spécial.

String sur plusieurs lignes

Python permet également de créer une String exactement tel que saisie même avec les sauts de lignes. Pour ce faire vous devez utiliser trois guillemets.

message = """This is multiline
String that is easier to
read and assign"""

print(message)
# This is multiline
# String that is easier to
# read and assign

Du coup, la lecture de la String dans le code est très explicite.

Récupération d’une partie de String

Python permet de récupérer seulement une partie de la String.

Une variable String est en effet composé de plusieurs caractères qu’il est possible de lire un à un ou en groupe. Voici quelque exemple

product = "iPhone 12"
# position 012345678

print(product[0]) 
# i

print(product[2]) 
# h

print(product[1:6])
# Phone

Chaques caractères est associé à un numéro de position. La première position est toujours 0. Pour accéder à une position en particulier il faut la spécifier entre crochet []

A noter qu’il n’est pas possible de modifier la String de cette façon. Toute tentative de modification va retourner une erreur.

product = "iPhone 12"
product[0] = "e"

# TypeError: 'str' object does not support item assignment

Il est possible d'accéder aux caractères de la String à partir de la fin.

message = "Hello World";

print(message[-1])
# d

La position -1 représente le dernier caractère, -2 l'avant-dernier, et ainsi de suite.

Lors de la récupération de plusieurs caractères, si une des deux positions est omise, la récupération se fera depuis le début de la String

message = "Hello World";

print(message[:5])
# Hello

print(message[-5:])
# World

Manipulation des Strings

Python a plusieurs fonctions qui vous permettent de transformer le contenu de la String. En voici quelques-unes :

Conversion majuscule et minuscule

name = 'Mike Taylor'

print(name.lower())
# mike taylor

print(name.upper())
# MIKE TAYLOR

Supprimer les espaces blancs avant et après une String

message = "  Hello World        "

print(message.strip())
# "Hello World"

Retourner le nombre de caractères dans la String

name = "Mike Taylor"

nb_char = len(name)

print(nb_char)
# 11

Changer la première lettre d’une String en majuscule

name = "mike"

name_cap = name.capitalize() 

print(name_cap)
# Mike

Changer la première lettre de tous les mots d’une String en majuscule

name = 'mike Taylor'

name_title = name.title() 

print(name_title)
# Mike Taylor

Vérifier si la String commence ou se termine par un ou des caractères en particulier

name = 'Mike'

print(name.startswith('M')) 
# True

print(name.endswith('ke')) 
# True

Remplacer une partie de la String par d’autres caractères

name = "Mike"

new_name = name.replace('M', 'P')

print(new_name)
# Pike

Retourner la position d’un caractère en particulier

name = "Mike"

print(name.find('k'))
# 2

À noter que la première position commence toujours à zéro et si le caractère n’est pas trouvé, la fonction retournera -1

Conclusion

C'est tout pour aujourd'hui, je publierai un nouvel article tous les deux jours environ. Pour être sûr de ne rien rater vous pouvez me suivre sur twitter : Suivre @EricLeCodeur

Python : Cours accéléré

Eric Le Codeur — Thu, 17 Mar 2022 16:49:37 +0000

Qu'est-ce que vous allez apprendre dans ce cours ?

Ce cours vous enseignera les concepts de base en Python. Le tout avec des termes et des exemples simples à comprendre. Avant d'apprendre à courir, il faut savoir marcher. Bien connaître la base c'est essentiel pour maîtriser un langage comme Python.

Le cours accéléré est gratuit et sera publié ici sur dev.to. Je publierai un nouvel article tous les deux jours environ. Pour ne rien manquer, vous pouvez me suivre sur twitter : Suivez @EricLeCodeur

Pourquoi un cours accéléré ?

Ce type de cours permet d’apprendre un maximum de concepts en un minimum de temps.
Un cours accéléré permet à l’étudiant de garder un haut niveau d’intérêt et de motivation.
Le temps épargné permet de mettre en pratique plus rapidement les concepts appris.
À la fin du cours accéléré, l’étudiant connaît suffisamment le sujet pour apprendre par lui-même les concepts qui n’ont pas été couverts.

Installation de Python

Pour commencer à coder avec Python vous devez vous assurer que vous avez une version à jour de Python (version 3.10 ou +)

À partir du terminal, taper cette commande pour connaître la version de Python installé sur votre machine.

$ python --version

ou

$ python3 --version

Si vous n'avez pas Python ou une version antérieur à 3.10, vous pouvez obtenir la dernière version de Python le site officiel : https://www.python.org/downloads/

Si vous désirez commencer à coder immédiatement et installer Python plus tard vous pouvez utiliser une version sur le web (gratuite) de Python.

Voici le lien:

https://replit.com/languages/python3

Editeur de code

Pour suivre ce tutoriel vous devrez utiliser un éditeur de code. Il existe plusieurs choix, si vous n’avez pas encore d’éditeur préféré, je vous recommande vscode de Microsoft.

Voici le lien:

https://code.visualstudio.com/download

Dans ce tutoriel nous n’enseignerons pas comment vscode fonctionne. Si vous désirez apprendre la base de vscode, il existe plusieurs outils gratuits de disponibles.

Une option que je recommande est de configurer vscode afin de permettre de l’exécuter à partir du terminal. Voici un lien sur les instructions à suivre pour ce faire:

Max OSX

https://code.visualstudio.com/docs/setup/mac

Windows

https://code.visualstudio.com/docs/setup/windows

Exécuter du code python

Une fois l’installation de Python complété sur votre machine, il est maintenant temps d’exécuter votre premier code Python.

Dans les prochaines sections nous allons apprendre ensemble les bases de langages python. Je vais donc vous inviter à créer un dossier et un fichier afin d'y placer le code qui sera donné en exemple.

Créer un dossier nommé “demo_python”

~$ mkdir demo_python
~$ cd demo_python

À l’intérieur du dossier crée un fichier nommé “main.py”

~$ code main.py

Votre première ligne de code

Ajouter ce code dans le fichier “main.py”

print("Hello World")

Ici l’instruction “print()” permet d’afficher du texte dans le terminal

Une fois le fichier sauvegardé, à partir du terminal vous pouvez l’exécuter à l’aide de Python.

~$ python3 main.py

ou

~$ python main.py

Python va exécuter toutes les lignes de codes présentes dans le fichier et afficher le résultat dans le terminal.

Hello World

Exécuter du code Python rapidement

Si vous désirez exécuter du code Python rapidement et sans créer de fichier, il est possible d’utiliser le shell. Le shell est une application qui permet de saisir une ligne de code Python, de l’exécuter et d’afficher le résultat immédiatement.

Pour exécuter le shell il suffit de lancer Python sans ajouter d’argument

~$ python3

ou 

~$ python

La commande va lancer le shell à partir du terminal

Python 3.9.9 (main, Nov 21 2021, 03:16:13) 
[Clang 13.0.0 (clang-1300.0.29.3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> _

Une fois l’application lancée, il est possible de saisir une ligne de commande après les caractères suivants >>>

Exemple:

>>> print("Hello World")

Une fois la commande saisie appuyer sur la touche “retour” et le code sera exécuté

>>> print("Hello World")
Hello World
>>> _

Vous aurez compris que le shell est plus utile pour tester une commande Python que pour écrire une vraie application.

Si vous développez une vraie application python l'approche à utiliser est de placer le code dans des fichiers avec l’extension “.py”

Vos premiers pas avec Python

Pour les prochains exemples, je vous invite à utiliser le fichier “main.py” que nous avons créé à l’exemple précédent.

Les variables

Les variables permettent de stocker de l’information qui pourra être utilisée plus tard par votre application.

Pour définir une variable il suffit de lui attribuer un nom et une valeur.

Par exemple, supposons que vous souhaitiez stocker le nom d'utilisateur, vous pouvez utiliser une variable et lui donner le nom : name et définir son contenu égal à “Mike Taylor”

name = "Mike Taylor"
print(name)

Ici la variable se nomme “name” et contient le texte “Mike Taylor”. Les guillemets indiquent à Python que son contenu est du texte.

Types de variables

Une variable peut contenir plusieurs types de données. Dans le dernier exemple il s’agit de texte mais nous aurions pu lui attribuer un nombre entier.

num = 25

Remarquez que pour être reconnu comme un nombre, vous ne devez pas utiliser de guillemets ““

Avec Python, il n’est pas nécessaire de spécifier le type de la variable. Python va détecter le type automatiquement selon le contenu que vous allez lui attribuer.

Selon le type détecté par Python, il sera possible d’effectuer des opérations sur cette variable.

Voici un exemple :

value = "100"

value2 = 100

Ici “value” est une variable de type texte (string) qui contient le texte “100”. Cette variable n'est pas un nombre qui peut être utilisé dans une opération mathématique.

“value2” est une variable de type nombre entier (integer) qui a le nombre 100 comme contenu. Cette variable est un nombre et donc peut être utilisée pour des opérations mathématiques.

result = value + value
# "100100"

result2 = value2 + value2
# 200

L’addition de ces deux variables ne donne pas le même résultat. En Python L’addition de variable texte (string) va jumeler les deux textes ensemble. Tandis que l’addition de variables nombre entier va additionner mathématiquement les deux valeurs.

Voici différents types de variables qu’il est possible de définir avec Python. Nous allons revenir sur chacun d’eux en détail plus tard

name = 'Mike' # string (texte)
age = 42 # integer (nombre entier)
price = 199.99 # float (nombre décimal)
is_active = True # boolean (vrai ou faux)

colors = ['red', 'green', 'blue'] # liste
states = ('inactive', 'active', 'archive') # tuple
products = { 'name': 'iPad Pro', 'price': 199.99 } # dictionnaire

Afin de simplifier le tutoriel, à partir de ce point, les types de variables seront appelés par leur nom anglais. Par exemple je n'utiliserai pas le terme “texte” ou "nombre entier" mais plutôt "string” et “integer”.

Convention de déclaration

Par convention les variables Python sont définies en lettres minuscules et peuvent contenir le caractère _ comme séparateur.

first_name = "Mike"

Commentaires

Il est possible d’insérer un commentaire dans votre code. Pour ce faire il faut utiliser le caractère “#”. Tout ce qui suit ce caractère ne sera pas exécuté par Python

# Ceci est un commentaire
name = "Mike Taylor"

age = 27  # Ceci est un commentaire

Il est également possible de créer des commentaires multilignes avec l’utilisation de trois guillemets “”” commentaires “””

def say_hello():
    """ Cette fonction permet d'afficher un
    messsage de bienvenu sur plusieurs lignes """ 

   print("Hello World")

Conclusion

C'est tout pour aujourd'hui, je publierai un nouvel article tous les deux jours environ. Pour être sûr de ne rien rater vous pouvez me suivre sur twitter : Suivre @EricLeCodeur

Apprendre le PHP : require, include, manipulation fichiers et enumerations

Eric Le Codeur — Fri, 28 Jan 2022 14:28:55 +0000

Aujourd'hui, vous apprendrez les instructions "require" et "include", la manipulation de fichiers et les énumérations.

Ce cours accéléré PHP est gratuit et sera publié ici sur dev.to. Je publierai un nouvel article tous les deux jours environ. Pour ne rien manquer, vous pouvez me suivre sur twitter : Follow @EricLeCodeur

require et include

Jusqu’a présent nous avons créer seulement un fichier PHP pour tous nos tests.

Lors de la création d’une application il en sera presque toujours autrement. Très rapidement nous aurons besoin de diviser/organiser notre code en plusieurs fichiers.

Ici nous verrons deux instructions qui permettent d’exécuter du code qui à été définit dans un autre fichier.

Pour ce faire nous allons créer deux fichiers. Le premier nommé message.php et écrire le code suivant

<?php

function sendMessage(string $message)
{
    echo $message . '<br>';
}

Ici c’est du code simple de chez simple. Une petite fonction qui affiche un message et un saut de ligne.

Ensuite, créer le second fichier nommé index.php et écrire le code suivant

<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <?php
        require 'message.php';
        sendMessage('Hello World');
    ?>
</body>

</html>

Dans cet exemple, on découvre l’instruction require. Elle permet d’inclure le code du fichier message.php. Donc, par conséquent, permet l’utilisation de la fonction sendMessage()

Que se passe t’il si le fichier spécifié comme paramètre n’existe pas ? Dans ce cas, PHP retournera une erreure.

L’instruction include

Permet de faire exactement la même chose que require sauf que PHP ne retournera pas une erreure (seulement un Warning) si le fichier à inclure n’est pas présent.

require_once et include_once

Ces instructions sont identiques à leur instructions sœur (require et include). La différence c’est que PHP va inclure le fichier seulement s'il ne l’a pas déjà fait.

Manipulation de fichiers et dossiers

PHP inclut plusieurs fonctions pour manipuler les dossiers et fichier sur le serveur

Voici quelques fonctions très utiles

Créer un fichier

file_put_contents("test.txt", "Hello World!");

Cette fonction va créer le fichier test.txt (dans le dossier en cours) avec le contenu ‘Hello World’.

Il est possible de spécifier le dossier.

file_put_contents("data/test.txt", "Hello World!");

Si le dossier n’existe pas, PHP retournera un warning

Vous pouvez créer le dossier avec la fonction mkdir

mkdir('data');

file_put_contents("data/test.txt", "Hello World!");

À noter que pour effacer un dossier vous pouvez utiliser la fonction rmdir(). Le dossier doit être vide afin que sa suppression soit possible.

Si vous désirez créer le fichier dans un dossier qui est parent au dossier en cours utilisez les deux points . .

file_put_contents("../test.txt", "Hello World!");

Le fichier sera créé dans le dossier parent

Si le fichier existe déjà, la fonction file_put_contents va remplacer le fichier existant. Si votre objectif est d’ajouter au fichier existant, utiliser l’option FILE_APPEND

file_put_contents("test.txt", "Hello World!", FILE_APPEND);

Lire un fichier

$content = file_get_contents("test.txt");

Si le fichier n’existe pas, PHP va retourner un warning

Pour vérifier si le fichier existe vous pouvez utiliser la fonction file_exists()

if (file_exists('/posts/first.txt')) {
  // do some stuff
}

Lire un fichier ligne par ligne

La fonction précédente permettait de lire un fichier d’un coup. Il existe une fonction pour lire ligne par ligne.

$file = fopen("test.txt", "r");

while(! feof($file)) {
  $line = fgets($file);
  echo $line. "<br>";
}
fclose($file);

ici le fichier est ouvert avec l’option ‘r’ pour read.

Le bloc de code va s’exécuter tant que la fin du fichier n’est pas détectée feof()

Écrire dans un fichier ligne par ligne

$file = fopen('export.csv', 'w');

Ici le fichier est ouvert avec l’option ‘w’ pour créer ou overwrite. Si on aurait voulu faire un ajout on aurait pu utiliser l’option ‘a’ pour append

Une fois le fichier ouvert on peut insérer des lignes

$array = [
    ['name' => 'Mike', 'age' => 45],
    ['name' => 'John', 'age' => 38],
];

//Write key name as csv header
fputcsv($file, array_keys($array[0]));

//Write lines (format as csv)
foreach ($array as $row) {
    fputcsv($file, $row); 
}
fclose($file);

La fonction fputfile() permet d’écrire des lignes. Ici nous avons plustot utiliser sa fonction soeur fputcsv() qui fait sensiblement la même chose mais au format csv.

À noter que nous avons utilisé un fputcsv avant la boucle. Cette ligne sera la première ligne du fichier et devra inclure le nom des colonnes. La fonction array_keys() permet justement de récupérer le nom des clé du tableau (name et age)

Énumérations

Les énumérations, ou "Enums" permettent de définir un “type” personnalisé qui se limitera à l'une des valeurs possibles parmi celle spécifiée. Les Enums sont un type d’objet et peuvent donc être utilisés partout ou un objet peut être utilisé.

Voici un exemple de déclaration

// Définir le nom et les valeurs posssible
enum InvoiceStatus
{
    case Sent;
    case Paid;
    case Cancelled;
}

Cette déclaration crée un type InvoiceStatus qui peut avoir seulement trois valeurs

InvoiceStatus::Sent

InvoiceStatus::Paid

InvoiceStatus::Cancel

Il est possible d’utiliser ce type dans une fonction avec type hint

function printInvoiceStatus(InvoiceStatus $status)
{
    print($status->name);
}

printInvoiceStatus(InvoiceStatus::Sent);
// Sent

La propriété name permet de récupérer le nom du case

Il est possible d’associé une valeur pour chacun des “case”. Pour ce faire il faut absolument spécifier le type du enum lors de sa déclaration : ex. enum InvoiceStatus : int

Il est également possible d’ajouter une méthode à notre enum

enum InvoiceStatus : int
{
    case Sent = 0;
    case Paid = 1;
    case Cancelled = 2;
}

print(InvoiceStatus::Paid->value);

La propriété value permet de récupérer la valeur associée au “case”

Tout comme un objet, il est possible d’ajouter une méthode au Enum

enum InvoiceStatus : int
{
    case Sent = 0;
    case Paid = 1;
    case Cancelled = 2;

    public function text() : string
    {
        return match ($this) {
            self::Sent => 'Sent',
            self::Paid => 'Paid',
            self::Cancelled => 'Cancelled'
        };
    }
}

function getInvoiceStatus(InvoiceStatus $status)
{
    print($status->text());
    print($status->value);
}

getInvoiceStatus(InvoiceStatus::Paid);
// Paid1

Conclusion

C'est tout pour aujourd'hui, je publierai un nouvel article tous les deux jours environ. Pour être sûr de ne rien rater vous pouvez me suivre sur twitter : Suivre @EricLeCodeur

Apprendre le PHP : Conditions, boucles et fonctions

Eric Le Codeur — Sun, 23 Jan 2022 18:02:22 +0000

Aujourd'hui, vous apprendrez les conditions, les boucles et les fonctions

Exécution conditionnelle

En PHP, il est possible d’exécuter une ligne de code seulement si une condition est vraie.

if ($name === 'Mike') {
    echo 'Hello Mike';
}

Le code inclut entre les parenthèses est ce que l’on appel une expression. PHP va exécuter ce code et retourner sa valeur booléenne (vrai ou faux).

Si le résultat est ‘vrai’ alors le code contenu entre les { } sera exécuté.

Si le résultat est faux, rien ne sera exécuté dans ce bloc 'if'

Voici un autre exemple avec l’opérateur plus grand que '>'


if ($amount > 100) {
    echo 'Livraison gratuite';
}

Il est possible d’exécuter du code si la condition est fausse

$amount = 120;

if ($amount > 100) {
    echo 'Livraison gratuite';
} else {
    echo 'Livraison 9.95$';
}

Ici le mot-clé 'else' exécute le code si l’expression est ‘false’

Enfin, il est possible d’avoir plusieurs conditions

$amount = 120;

if ($amount > 100) {
    echo 'Livraison gratuite';
} elseif ($amount > 50) {
    echo 'Livraison 9.95$';
} else {
    echo 'Livraison 19.95$';
}

Le mot-clé 'elseif' permet de tester une autre condition. À noter que cette condition sera testée seulement si la première condition est fausse.

Si la première et la deuxième condition sont fausses, alors le code dans la section 'else' sera exécuté.

Opérateur de comparaison

Voici les différents opérateurs qui peuvent être utilisés dans les expressions.

== equal no type check
=== equal with type check
!= not equal
|| or
&& and
> greater than
< less than

il est possible de tester plusieurs expressions en même temps avec l’opérateur &&

if ($amount > 0 && $amount < 50) {
   echo 'Le prix est entre 1 et 49';
}

Le même principe s’applique pour l’opérateur ou ||

if ($amount === 100 || $amount === 200) {
   echo 'Le prix est 100$ ou 200$';
}

Les expressions sans opérateur de comparaison

$amount = 0;

if ($amount) {
    echo 'Le montant n est pas de zéro';
}

Ici l’expression ($amount) ne contient pas d’opérateur de comparaison, malgré ce fait, ce code est valide. Pourquoi ? En PHP chaque expression est convertie en valeur booléenne. Donc ici 0 est convertie en faux. Toute autre valeur autre que zéro (ou null) serait convertie en vrai.

Convertion en valeur booléenne

Voici la liste des valeurs qui seront converties en false

false

0.0

null

‘0’ (string égale à zéro)

‘ ’ (string vide)

Toutes les autres valeurs seront converties en true

Voici quelques exemples de conversion en valeur booléenne

$messsage = 'Hello World';

if ($message) { // true
   echo $messsage;
}

if ($value) {
    echo 'Variable is set';
} else {
    echo 'Variable is unset';
}

Utiliser les 'if' dans un fichier HTML

<html lang="en">

<body>
    <?php $isAdmin = true; ?>

    <h1>Home page</h1>

    <?php if ($isAdmin) : ?>
        <p>Welcome Administrator</p>
    <?php else : ?>
        <p>Welcome Guest</p>
    <?php endif ?>

</body>

</html>

Chaque bloc de code PHP a une balise d’ouverture et de fermeture. La particularité ici c’est le bloc de code du if et du else . Il n’y a pas { }. Il est possible d’utiliser les : à la place.

Switch

Si nous avons plusieurs conditions, les 'if', 'elseif' etc.. peuvent donner un code difficile à lire. Dans ce cas l’instruction 'switch' permet justement d’aider à simplifier votre code.

switch ($color) {
    case 'red':
        echo 'Danger';
         break;
    case 'yellow':
        echo 'Warning';
        break;
    case 'green':
        echo 'Success';
        break;
    default:
        echo 'The color is unknown';
}

La première ligne représente l’expression que nous désirons évaluer : switch($color)

Ensuite suffit d’inclure les “case” possible.

La fonction “break” empêche l’exécution de continuer

Le “case” default est utilisé s'il y a aucun case qui correspond.

Match

Nouveauté PHP 8, cette instruction permet de retourner une expression selon une correspondance clé ⇒valeur

$type = match($color) {
    'red' => 'danger',
    'yellow', 'orange' => 'warning',
    'green' => 'success',
    default => 'Unknown'
};

La première ligne représente l’expression que nous désirons vérifier la correspondance: match($color)

Sur la deuxième ligne on remarque qu’il est possible de correspondre plus d’une expression à la fois.

Ensuite s’en suit une liste de clé ⇒ valeur. Si aucune clé→valeur n’est trouvé, la clé default sera exécutée.

À noter que la clé peut être une expression et que la valeur peut être également, une expression et même une fonction.

$type = match($color) {
    userID == 100 => openAdmin(),
    userID < 100 && userID > 0 => openUser(),
    default => openOther()
};

Switch ou Match ?

Chacun possède des plus. Match est plus simple visuellement mais Switch permet d’exécuter plus d’une ligne de code pour chaque “case”. Match permet de retourner une valeur ce que Switch ne fait pas. Bref moi j’utilise Match si possible car je trouve l’instruction plus épurée visuellement mais sinon je n'ai pas de problème avec l’instruction switch

Ternary operator ?:

C’est une syntaxe raccourcie pour un if...else.

Voici un exemple avec if...else

if ($isValid) {
    echo 'user valid';
} else {
    echo 'user not valid';
}

Voici le même exemple mais avec l’opérateur Ternary

echo $isValid ? 'user valid' : 'user not valid';

Si l’expression qui précède L’opérateur “?” est vraie alors la valeur suivant “?” sera utilisé, sinon c’est la valeur suivant les “:” qui sera utilisé.

L'opérateur de coalescence Null ??

L'opérateur de coalescence Null renvoie son premier opérande s'il existe et n'est pas NULL ; sinon il renvoie son deuxième opérande

echo $name ?? 'Mike';  //output 'Mike' if $name is null

Assignation avec l'opérateur de coalescence Null ??

$name ??= 'Mike';

Assigne la valeur ‘Mike’ si la variable $name est null

Opérateur Null safe

echo $user?->profile?->activate();

Si une des variables qui précède l’opérateur “?” est null alors la valeur de l’expression sera null

Les boucles

La boucle “while”

Permet d’exécuter un block de code un certain nombre de fois. Le nombre de fois va dépendre de la condition. Tantque la condition est vrai, le block de code va s’exécuter.

$number = 1;
while ($number < 10) {
    echo 'value : ' . $number ;
    $number += 1;
}

Ici le bloc de code sera exécuté 9 fois.

La boucle “do while”

Essentiellement le même principe que la boucle “while” mais dans ce cas-ci, le bloc de code va toujours s’exécuter au moins une fois. La condition étant testé seulement à la fin du bloc de code.

$number = 1;
do {
    echo 'value : ' . $number ;
    $number += 1;
} while ($number < 10);

La boucle “for”

Permet d’exécuter un bloc de code un nombre de fois définit par une condition.

for ($i = 0; $i < 20; $i++) {
    echo "i value = " . i;
}

Le paramètre se divise en trois sections, le première étant la définition du compteur (i = 0). Ensuite la condition à respecter pour exécuter le bloc de code ($i < 20) et enfin le code à exécuter à chaque itération ($i++)

La boucle “foreach”

La fonction foreach permet d’exécuter un bloc de code pour chaque élément d’un tableau.

$names = ['Mike', 'Shawn', 'John'];

foreach($names as $name) { 
   echo 'Hello ' . $name;
}

Le premier paramètre c’est le nom du tableau à parcourir, le second paramètre représente la référence à l’élément en cours.

Break et Continue

Les instructions break et continue permettent de modifier la boucle

for ($i = 0; $i < 20; $i++) {
    if ($i % 2 === 0) {
        continue;
    }
    echo $i . '<br>';
}

Cette boucle va imprimer la valeur de $i, seulement lorsque la valeur sera impaire.

Si la valeur est paire ($i % 2 === 0). Alors on demande à la boucle de faire un continue avec la prochaine valeur.

Il est possible de sortir de la boucle à tout moment avec l’instruction break

$i = 0;

while ($i < 10000) {
    $i++;
    if ($i == 10) {
        break;
    }
    echo $i . '<br>';
}

Ici la boucle va s’arrêter lorsque $i aura 10 comme valeur

Les fonctions

En PHP il existe plusieurs fonctions déjà pré-définit. Il est également possible de créer nos propres fonctions.

Les fonctions permettent d’éviter de répéter notre code plusieurs fois. Elles permettent également de diviser notre application en petit morceau plus facile à maintenir.

La syntaxe pour créer une fonction est assez simple

function hello() {
    echo 'Hello World';
}

Ici nous utilisons le mot-clé “function” suivit du nom de notre fonction.

Une fois notre fonction créée, il est possible de lancer son exécution

hello();

Il est possible d’inclure un ou des paramètres notre fonction

function hello($firstName, $lastName) {
    echo 'Hello' . $firstName . ' ' . $lastName;
}

Le lancement de la fonction devra inclure les paramètres dans l’ordre qu’ils ont été déclarés

hello('Mike', 'Taylor');

Une valeur par défaut peut-être attribué à un paramètre ce qui du coup rendra se paramètre optionnel lors de l’appel de la fonction.

function hello($firstName, $lastName = 'none') {
    echo 'Hello' . $firstName . ' ' . $lastName;
}

hello('Mike');
// Mike none

À noter que les paramètres avec une valeur par défaut doivent absolument être définit en dernier ordre.

Depuis la version 8 de PHP il est possible de lancer une fonction en nommant les paramètres. L’appel est plus clair et l’ordre des paramètres n’a pas à être respecté.

hello(lastName: 'Taylor', firstName: 'Mike');

L’instruction Return

Permet de retourner une valeur lorsque l’on l'appel la fonction.

function fullName($firstName, $lastName) {
    return $firstName . ' ' . $lastName;
}

echo fullName('John', 'Doe');

Ici la fonction retourne une string concaténé avec prénom et nom

La fonction echo va afficher sur la page web la valeur retournée par la fonction fullName()

Fonctions anonymes (closure)

Permet la création de fonctions sans préciser leur nom. Voici un exemple :

$sum = function ($a, $b) (
    return $a + $b;
);

echo $sum(10, 15);

Les fonctions anonymes se terminent par un semi colon ; Et elles ne peuvent pas accéder aux variables du contexte parent.

Il est possible de passer une variable depuis le contexte parent avec l’instruction use

$x = 10;

$sum = function ($a, $b) use $x (
    return $x + $a + $b;
);

echo $sum(10, 15);
// 35

Callback functions

Les fonctions Callback sont des fonctions anonymes passé comme paramètre. Voici un exemple

$products = ['iPhone 12', 'iPhone 13', 'iPad', 'iWatch'];

$filtered_products = array_filter($products, function ($product) {
    return str_contains($product, 'Phone');
});

print_r($filtered_products);
// Array ( [0] => iPhone 12 [1] => iPhone 13 )

Ici la fonction array_filter() possède une fonction anonyme comme deuxième paramètre.

Arrow functions

Permet l’utilisation d’une syntaxe raccourci:

$products = ['iPhone 12', 'iPhone 13', 'iPad', 'iWatch'];

$filtered_products = array_filter($products, fn ($product) => str_contains($product, 'Phone'));

print_r($filtered_products);

À noter que pour le moment, les Arrow fonctions permettent l’exécution de seulement une expression. Les Arrow function sont exécuté dans le contexte en cours donc peuvent utiliser les variables sans à avoir à utiliser l’instruction use.

Fonction Type Hint

À noter que les fonctions peuvent être typé (string, int, etc.). Il est possible de définir un type pour chacun des paramètres et un type pour la valeur de retour de la fonction.

function display(string $first, string $last) : string {
    return "$first $last";
}

Ici les paramètres $first et $last devront être de type string ainsi que le valeur de retour.

Il existe plusieurs autres trucs à savoir sur les fonctions typé, nous y reviendrons un peu plus tard.

Strict Type

Voici un exemple d’une fonction avec type

function add(int $a, int $b): int
{
    return $a + $b;
}

echo add('10', 20);
// 30

Dans cette exemple le paramètre $a est de type integer. Malgré tout PHP ne retourne pas d’erreur. La raison c’est que PHP va tenter de convertir la string ‘10’ en integer. Si la conversion est possible alors aucune erreur n’est rapporté.

Il arrive parfois que vous aimeriez que PHP ne permette pas cette conversion et exécute seulement si le paramètre est vraiment du type spécifié. Pour ce faire il faut ajouter un instruction au début de votre fichier.

declare(strict_types=1);

function add(int $a, int $b): int
{
    return $a + $b;
}

echo add('10', 20);
// TypeError

Ici une erreur est retournée car le type du paramètre n’est pas un integer

Conclusion

C'est tout pour aujourd'hui, je publierai un nouvel article tous les deux jours environ. Pour être sûr de ne rien rater vous pouvez me suivre sur twitter : Suivre @EricLeCodeur

Apprendre le PHP : Manipulation des tableaux

Eric Le Codeur — Mon, 17 Jan 2022 13:45:33 +0000

Aujourd'hui, vous apprendrez la manipulation des tableaux en PHP.

Tout d'abord, voici un scénario très courant dans le développement Web qui vous aidera à comprendre pourquoi nous avons besoin d'Array.
Dans l'exemple suivant, nous devons afficher une liste de produits et leurs prix.

$product1 = "iPad";
$product2 = "iPhone";
$product3 = "iWatch";

$price1 = 599;
$price2 = 899;
$price3 = 699;

echo $product1 . ' : ' . $price1 . '<br>';
echo $product2 . ' : ' . $price2 . '<br>';
echo $product3 . ' : ' . $price3 . '<br>';

Comme vous pouvez l'imaginer, ce code est loin d'être optimal. Imaginez si nous avions 100 produits ou même 10 000 produits.

Il existe un moyen de faire l'exemple précédent de manière beaucoup plus efficace... Les tableaux.

Les tableaux en PHP sont des listes de valeurs. Les valeurs d'un tableau peuvent être de types différents.
Pour définir un tableau, nous utilisons des crochets [ ]

$products = [];

La variable $products est un tableau vide

Il est possible de créer un tableau avec du contenu

$products = ['iPad', 'iPhone', 'iWatch'];

Ce tableau contient trois chaînes : iPad, iPhone, iWatch

Chaque élément du tableau est séparé par une virgule.

Il est possible d'avoir des tableaux avec différents types de variables

$array = ['First entry', 100, true];

Il est même possible de créer un tableau dans un tableau

$array = ['First entry', 100, ['iPad', 'iPhone'], false];

Pour accéder à un élément

echo $array[0];
// First entry

Les éléments d'un tableau sont indexés à partir de 0. Ainsi, le premier élément est à la position 0, le second à la position 1, et ainsi de suite.

$array = ['First entry', 100, ['iPad', 'iPhone'], false];
                 0         1           2            3

Pour accéder à un tableau dans un tableau, vous utilisez la syntaxe suivante

echo $array[2][1];
// iPhone

Ici, nous affichons l'élément 2, c'est-à-dire ['iPad', 'iPhone'] alors que le sous élément 1 est l'iPhone

Si vous tentez d'accéder à un élément inexistant. PHP renverra un avertissement et la valeur null.

$array = ['First entry', 100, true];

echo $array[3];
// null 
// Warning: Undefined array key 3

Nombres d'items dans un tableau

Pour déterminer le nombre d'éléments dans un tableau, vous pouvez utiliser la fonction count()

$array = ['First entry', 100, true];

echo count($array);
// 3

Manipulation de tableaux

Ajouter un élément à la fin du tableau

$array[] = 'Last';

// ['First entry', 100, ['iPad', 'iPhone'], false, 'Last']

Supprimer un élément du tableau

unset($array[0]);

// [100, ['iPad', 'iPhone'], false, 'Last']

Convertir un tableau en chaîne avec la fonction implode

$array = ['One', 'Two', 'Three'];
echo implode(', ', $array);
// "One, Two, Three"

Le premier paramètre est le séparateur.
Transformer une chaîne en tableau avec la fonction éclater

$text = 'Mike, Shawn, John';
echo explode(',', $text); // ['Mike', 'Shawn', 'John'];

Le premier paramètre est le séparateur.

Itérer à travers tous les éléments d'un tableau

La fonction foreach exécute le code pour chaque élément du tableau.

$names = ['Mike', 'Shawn', 'John'];

foreach($names as $name) { 
   echo 'Hello ' . $name;
}

Le premier paramètre est le nom du tableau à parcourir, le deuxième paramètre représente la référence à l'élément courant.

Tableaux associatifs

Jusqu'à présent, nous avons appris comment fonctionnent les tableaux. Ils ont une clé numérique commençant à 0.
Il est possible de créer des tableaux avec une clé personnalisée. C'est ce que PHP appelle des tableaux associatifs.

$person = ['age' => 45, 'genre' => 'men'];

Ici, « l'âge » et le « genre » sont les clés. 45 et 'men' sont les valeurs associées à ces clés. Notez que certains langages de programmation appellent ce type de tableau un dictionnaire.

Les tableaux associatifs sont très pratiques et vous devez bien les comprendre car vous les utiliserez très souvent. Ils sont parfaits pour stocker des informations.

$product = ['id' => 100, 'name' => 'iPad', 'price' => 699];

L'accès à une valeur de tableau se fait avec la clé

echo "Product :" . $product['name'];

L'ajout d'une clé/valeur au tableau est possible en spécifiant une nouvelle clé

$product['qty'] = 5;

Il est possible de vérifier si une clé existe

$product = ['id' => 100, 'name' => 'iPad', 'price' => 699];

echo array_key_exists('id', $product);
// true

Boucle dans un tableau associatif avec des valeurs et des clés

foreach($names as $key => $value) {
   echo $key . ' : ' . $value;
}

Concaténation : Joindre deux tableaux

$names1 = ['Mike', 'Paul', 'Tom'];
$names2 = ['John', 'Sam'];

$allNames = array_merge($names1, $names2);
// ['Mike', 'Paul', 'Tom', 'John', 'Sam'];

Concaténation avec l'opérateur de propagation (...)

$names1 = ['Mike', 'Paul', 'Tom'];
$names2 = ['John', 'Sam'];

$allNames = [...$names1, ...$names2];
// ['Mike', 'Paul', 'Tom', 'John', 'Sam'];

Ici, l'opérateur de propagation avant le nom du tableau (...$names) déconstruit le tableau.

Un tableau de tableaux associatifs

Un modèle que vous utiliserez souvent est un tableau contenant des tableaux associatifs.

$items = [
    ['id' => '100', 'name' => 'product 1'],
    ['id' => '200', 'name' => 'product 2'],
    ['id' => '300', 'name' => 'product 3'],
    ['id' => '400', 'name' => 'product 4'],
];

Ce type de tableau est excellent pour représenter les données.Il est possible de boucler et d'afficher chaque élément

foreach($items as $item) {
    echo $item['name'] . <br>;
}

L'instruction 'as' crée une référence à l'élément de tableau.

Récupère une partie d'un tableau

Il existe plusieurs fonctions qui permettent de récupérer une partie d'un tableau.

Récupérer uniquement les clés ou les valeurs

$person = ['age' => 45, 'genre' => 'men'];

// Return an array with only keys
echo array_keys($person); // ['age', 'genre']

// Return an array with only values
echo array_values($person); // [45, 'men']

Fonctions avec fonction comme paramètre

Dans cette partie du tutoriel nous allons voir trois fonctions qui permettent la manipulation des tableaux. Ces fonctions sont :

array_filter()
array_map()
array_reduce()

Ces fonctions sont particulières car elle ont chacune une fonction callback comme paramètre. Une fonction callback est une fonction anonyme qui s'exécute de la même façon qu'une fonction classique.

Le concept des fonctions callback peut être plus difficile à comprendre. Donc si vous ne saisissez pas tout du premier coup c'est normale.

array_filter()

Permet la récupération des éléments qui correspondent à un critère spécifique

$items = [
    ['id' => 100, 'name' => 'product 1'],
    ['id' => 200, 'name' => 'product 2'],
    ['id' => 300, 'name' => 'product 3'],
    ['id' => 400, 'name' => 'product 4'],
];

$filteredItem = array_filter($items, function ($product) {
    return $product['id'] > 200;
});

print_r($filteredItem);
// $items = [
//    ['id' => '300', 'name' => 'product 3'],
//    ['id' => '400', 'name' => 'product 4'],
// ];

La fonction array_filter() est une fonction avec une fonction de rappel en paramètre. Pour chaque élément du tableau, une expression sera évaluée. Si l'expression est vraie, l'élément courant sera inclus dans le tableau résultant.

Recherche dans un tableau

$items = [
  ['id' => '100', 'name' => 'product 1'],
  ['id' => '200', 'name' => 'product 2'],
  ['id' => '300', 'name' => 'product 3'],
  ['id' => '400', 'name' => 'product 4'],
];

$found_key = array_search('product 3', array_column($items, 'name'));
// 2

La fonction array_search() permet de rechercher une clé spécifique selon un critère de recherche. Dans le dernier exemple nous recherchons la clé du 'produit' dans la colonne 'nom'

Créez un nouveau tableau avec la fonction array_map()

$items = [
    ['id' => 100, 'name' => 'product 1'],
    ['id' => 200, 'name' => 'product 2'],
    ['id' => 300, 'name' => 'product 3'],
    ['id' => 400, 'name' => 'product 4'],
];

$mapItems = array_map(function ($product) {
    return [
        'id' => $product['id'] * 2, 
        'name' => $product['name']
    ];
}, $items);

print_r($mapItems);
//[
    ['id' => 200, 'name' => 'product 1'],
    ['id' => 400, 'name' => 'product 2'],
    ['id' => 600, 'name' => 'product 3'],
    ['id' => 800, 'name' => 'product 4'],
];

La fonction array_map() renvoie un tableau qui contient ce que chaque élément de rappel renverra.
La fonction array_map() doit avoir deux paramètres : une fonction callback et un tableau. ex. array_map (fonction de rappel, tableaux)

La fonction array_map() boucle sur chaque élément du tableau et construit en même temps un nouveau tableau. Chaque élément du nouveau tableau est le résultat (retour) de la fonction callback. Dans le dernier exemple, chaque boucle a renvoyé un élément avec l'identifiant * 2 et le nom du produit.
La table d'origine n'est pas modifiée, une nouvelle table est créée.

La fonction array_reduce()

Cette fonction prend un tableau et le réduit à une seule valeur. Par exemple, a renvoyé le résultat de l'addition de tous les nombres contenus dans un tableau.

$numbers = [2, 4, 6, 100];

$sum = array_reduce($numbers, function ($num, $total) {
    return $total + $num;
}, 0);

print_r($sum);
// 112

La fonction array_reduce() prend deux paramètres : une référence à l'élément réel et une variable totale. A chaque itération, la fonction callback retourne le résultat dans la variable total.

Conclusion

C'est tout pour aujourd'hui, je publierai un nouvel article tous les deux jours environ. Pour être sûr de ne rien rater vous pouvez me suivre sur twitter : Suivre @EricLeCodeur