La data science et la data analysis sont deux domaines qui ont des objectifs similaires, mais qui peuvent être considérés comme des domaines distincts. La data analysis est le processus de collecte, de nettoyage et de manipulation de données pour en extraire des insights et des informations utiles. Cela peut inclure des techniques statistiques simples, telles que la création de graphiques et de tableaux de données, ainsi que l'utilisation de logiciels de visualisation de données.
La data science, en revanche, est une discipline plus large qui utilise des techniques de data analysis avancées, ainsi que des outils de machine learning et de statistiques pour extraire des connaissances et des insights à partir de données. La data science implique souvent la résolution de problèmes complexes et la prédiction de résultats futurs en utilisant des algorithmes d'apprentissage automatique et des modèles statistiques. En tant que data scientist, vous devrez souvent travailler sur de grandes quantités de données et utiliser des outils de traitement de données en masse, tels que Hadoop ou Spark.
En résumé, la data analysis est une partie importante de la data science, mais la data science est une discipline plus large qui inclut également des techniques avancées d'apprentissage automatique et de statistiques.
Merci et bonne lecture!
Cet article est dédié au web scraping (partie technique),
Lors de mon article précédent, j'avais expliqué c'est quoi un web scraping et quels sont les conditions d'utilisation.
Pour faire du web scraping on peut utiliser plusieurs langages comme python, php, Node.js, Ruby, C++, R, ….
Dans notre cas, nous utilisons le langage python car il fait partie de la sainte trinité des langages les plus tendances ces dernières années. Il est simple et facile à utiliser avec ses performances optimales et ses innombrables modules. Python est tout simplement le langage le plus utilisé pour le web scraping.
Outils utilisés :
Back end : python et ses librairies
Front end : HTML, CSS, java script
Tout d’abord vous devez installer:
un éditeur de code (dans notre cas, nous utilisons visual studio code),
le langage python (last version)
les modules comme:
Flask: un micro framework open-source de développement web en Python
pandas: une bibliothèque écrite pour le langage de programmation Python permettant la manipulation et l'analyse des données.
urllib: il est le module de gestion d'URL pour Python. Il est utilisé pour récupérer des URL (Uniform Resource Locators). Il utilise la fonction urlopen et est capable de récupérer des URL en utilisant une variété de protocoles différents.
Beautifulsoup4: une bibliothèque Python d'analyse syntaxique des données HTML et XML
Si toute fois vous rencontrez des difficultés sur l’installation d’un de ces outils ou vous souhaitez que je fasse un article complet sur les installations merci de me le faire savoir via mon mail mamadoutive4@gmail.com
Etape1 :
La première étape du web scraping est de bien maîtriser la structure du code HTML du site dont vous souhaitez scraper. Ahh oui, chaque site a en général sa propre structure HTML, donc il faut bien l’étudier avant toute chose.
Mais comment étudier la structure du code HTML d’un site ?
Ne vous en faites pas, c’est très simple.
Sur votre clavier taper directement «ctrl» + «shift» + «c».
Une nouvelle fenêtre s’ouvre et vous pouvez commencer à étudier la syntaxe de la page.
C’est simple non ?
Etape2 :
Dans votre bureau créez un dossier appelé « webScraping ».
Dans ce dossier, créer :
Deux dossiers ayant obligatoirement et respectivement comme noms « templates » et « static »
Un fichier python sous le nom « scraping.py » ou choisissez le nom qui vous convient mais avec l’extension «.py»
Puis ouvrez le dossier via l’éditeur de code que vous avez installé.
NB: Vous pouvez créer le fichier d'extension «.py» à partir de l’éditeur de code.
Etape3 :
Importer les modules nécessaires au web scraping avec les points suivants :
Importer le module Beautifulsoup en copiant ce code suivant
from bs4 import Beautifulsoup
Importer le module urllib en copiant ce code suivant
from urllib.request import Request, urlopen
Importer le module pandas en copiant ce code suivant
import pandas as pd
Importer le framework flask en copiant ce code suivant
from flask import Flask, request, render_template, url_for
Créer votre application avec le code suivant
app = Flask (_name_,)
Etape4:
Maintenant, nous pouvons copier l'URL du site à scraper et le mettre dans le code suivant :
req = Request(
url = 'https://www.site.com'
headers = {'User-Agent':'Mozilla/5.0'}
)
Vous vous rappelez du module «urllib» installé?, C’est effectivement ce qu’on a utilisé ici pour récupérer toutes les informations du site à scraper à travers son URL.
Après la récupération des données, nous pouvons commencer à les lire en utilisant la fonction « urlopen » comme le décrit le code suivant :
webpage = urlopen(req).read()
Bravo ! Vous y êtes presque.
Maintenant nous pouvons utiliser la fonction « Beautifulsoup » pour parser le fichier Html du site autrement dit cette fonction nous permet de parcourir le contenu du fichier Html du site pour vérifier sa syntaxe ou extraire les informations qui nous intéressent.
Soup = Beautifulsoup(webpage, 'html.parse')
Sur la page ou le site dont vous scrapez, il est certains que vous avez pas besoin de récupérer tout le contenu en intégral. Alors repérez le bloc ou la balise « div » qui contient les informations dont vous avez besoin puis et récupérer la valeur de la classe de la balise.
bloc = soup.find_all("div", class_='valeur_de_la_class_de_la_balise_div_à_mettre_ici ')
Ensuite avec un simple « print(bloc) », vous verrez tout le contenu du bloc, c’est génial non ?
Tout ce qui vous reste à faire c’est de piocher en fonction des sous balises pour récupérer l’information précise.
Vous pouvez utiliser la fonction « find » pour indexer la valeur de l’information à récupérer avec une boucle « for » via le code suivant :
for info in bloc:
try:
valeur = info.find("div", class ₌'valeur_de_la_class_de_la_balise_div_à_mettre_ici' )
except Exception:
continue
Si vous êtes arrivé jusqu’ici, c’est parce que vous êtes vraiment brave et vous avez les capacités nécessaires pour scraper n’importe quel site si ce dernier n’a pas mis des obstacles à contourner.
Tout ce qui vous reste à faire est de mettre les valeurs récupérer dans une liste ou dans un dataframe pour commencer vos analyses statistiques ou les stocker dans une base de données ou un fichier csv.
La prochaine étape de l’article est de vous expliquer:
comment faire de la statistique et de la visualisation à partir des données scraper ?
Comment également assurer une bonne communication entre python et HTML ?
Voici le code intégral à copier et personnaliser selon votre besoin :
#Importation des modules
from flask import Flask, render_template, redirect, url_for
from flask_cors import CORS
from bs4 import BeautifulSoup
from urllib.request import Request, urlopen
import pandas as pd
import re
import numpy as np
from datetime import datetime, timedelta
import calendar
# Création d'application
app = Flask(__name__, static_url_path='',
static_folder='webScraping/static',
template_folder='webScraping/templates')
CORS(app)
# Créer une liste vide où stocker les données récupérées
listeContenus = []
# Récupérer le contenu du site ou de la page
req = Request(
url='url_du_site',
headers={'User-Agent': 'Mozilla/5.0'} )
webpage = urlopen(req).read()
# Parser la page
soup = BeautifulSoup(webpage, 'html.parser')
# Trouver le contenu de la balise qui vous intéresse
bloc = soup.find_all(
"div", class_='valeur_de_la_class_de_la_balise_div_à_mettre_ici')
# Boucler pour récupérer chaque élément du bloc
if bloc:
for info in bloc:
try:
nom = info.find("div", class_='valeur_de_la_class_de_la_balise_div_à_mettre_ici')
adresse = info.find("div", class_='valeur_de_la_class_de_la_balise_div_à_mettre_ici')
telephone = info.find("div", class_='valeur_de_la_class_de_la_balise_div_à_mettre_ici')
# Créer un dictionnaire d'information
contenus = {"nom":nom, "adresse":adresse, "telephone":telephone}
# Ajouter le dictionnaire dans la liste vide qui a été créée au début
listeContenus.append(contenus)
except Exception:
continue
# Créer un dataframe à partir du contenu de la liste
dfListContenus = pd.DataFrame(listeContenus)
dffListContenus = dfListContenus.drop_duplicates() # enlever les duplications de lignes
# Afficher le contenu du dataframe
print(dffVehicule)
# Récupérer la date actuelle
date = datetime.today().strftime('%Y-%m-%d')
# Sauvegarder les données scrapées dans un fichier csv
fil = 'DataScraping_'+str(date)
dffListContenus.to_csv("/{}.csv".format(fil), header=True)
Félicitation, vous avez réussi le web scraping, maintenant vous êtes un expert. N’hésitez pas de me suivre sur ma page linkedIn pour ne pas rater les prochains articles
Si vous avez des questions ou des suggestions merci de me contacter via mon mail mamadoutive4@gmail.com
Les faux comptes sur les réseaux sociaux peuvent causer des problèmes d'image pour vous ou votre entreprise. Pour éviter cela, il est important de mettre en place des mesures de sécurité, comme l'utilisation de QR codes pour permettre à vos abonnés de distinguer les comptes officiels des faux comptes.
Ce code Python utilise la bibliothèque qrcode pour générer un QR code à partir de plusieurs URLs de profils sociaux. Voici une explication étape par étape :
Importation de la bibliothèque qrcode :
import qrcode
Cette ligne importe la bibliothèque qrcode qui permet de générer des codes QR.
Définition de la fonction generate_combined_qr_code :
def generate_combined_qr_code(profile_urls):
Cette fonction prend en paramètre une liste d'URLs de profils sociaux.
Concaténation des URLs :
combined_url = '\n'.join(profile_urls)
Les URLs sont concaténées en une seule chaîne en utilisant un saut de ligne (\n) comme séparateur.
Création de l'objet QR code :
qr = qrcode.QRCode(
version=1,
error_correction=qrcode.constants.ERROR_CORRECT_L,
box_size=10,
border=4,
)
Un objet QRCode est créé avec des paramètres spécifiés, tels que la version, le niveau de correction d'erreur, la taille de la boîte, et la bordure.
Ajout de la chaîne combinée dans le QR code :
qr.add_data(combined_url)
qr.make(fit=True)
La chaîne combinée est ajoutée à l'objet QRCode, et la méthode make est appelée avec l'option fit=True pour ajuster automatiquement la taille du QR code.
Création de l'image QR code :
img = qr.make_image(fill_color="black", back_color="white")
Une image du QR code est créée, avec la couleur de remplissage en noir et la couleur d'arrière-plan en blanc.
Enregistrement de l'image (optionnel) :
img.save("combined_qr_code.png")
L'image du QR code peut être enregistrée sous un fichier, ici nommé "combined_qr_code.png".
Affichage de l'image (optionnel) :
img.show()
L'image du QR code peut être affichée à l'écran.
Exemple d'utilisation avec plusieurs profils :
social_media_profiles = [
"https://twitter.com/orange_sn",
"https://www.linkedin.com/company/orange/",
"https://www.facebook.com/orange.sn/",
]
generate_combined_qr_code(social_media_profiles)
On utilise la fonction avec une liste d'URLs de profils sociaux comme exemple.
Ce script générera un QR code unique qui contient toutes les URLs de profils sociaux spécifiées. Cela peut être utile pour partager plusieurs liens en une seule fois.
Résumé du code
import qrcode
def generate_combined_qr_code(profile_urls):
# Concaténer toutes les URLs en une seule chaîne
combined_url = '\n'.join(profile_urls)
# Création de l'objet QR code
qr = qrcode.QRCode(
version=1,
error_correction=qrcode.constants.ERROR_CORRECT_L,
box_size=10,
border=4,
)
# Ajout de la chaîne combinée dans le QR code
qr.add_data(combined_url)
qr.make(fit=True)
# Création de l'image QR code
img = qr.make_image(fill_color="black", back_color="white")
# Enregistrement de l'image (optionnel)
img.save("combined_qr_code.png")
# Affichage de l'image (optionnel)
img.show()
# Exemple d'utilisation avec plusieurs profils
social_media_profiles = [
"https://twitter.com/orange_sn",
"https://www.linkedin.com/company/orange/",
"https://www.facebook.com/orange.sn/",
]
generate_combined_qr_code(social_media_profiles)
Dans cet article, nous allons explorer comment créer un gestionnaire de tâches simple en utilisant le framework Flask pour Python. Le gestionnaire de tâches permettra d'ajouter, de marquer comme complètes et de supprimer des tâches, avec une interface utilisateur conviviale.
Assurez-vous d'avoir Python et Flask installés sur votre système. Vous pouvez installer Flask en utilisant la commande pip install flask. Créez également deux dossiers dans le répertoire de votre application : "templates" pour les fichiers HTML et "static" pour les fichiers statiques tels que les feuilles de style CSS.
Notre application Flask sera composée de deux parties principales : le code Python qui gère le serveur web et les routes, et les fichiers HTML qui définissent la structure de la page.
from flask import Flask, render_template, request, redirect, url_for
app = Flask(__name__)
class GestionnaireTaches:
def __init__(self):
self.taches = []
def ajouter_tache(self, description):
self.taches.append({"description": description, "complete": False})
def marquer_complet(self, index):
if 1 <= index <= len(self.taches):
self.taches[index - 1]["complete"] = True
def supprimer_tache(self, index):
if 1 <= index <= len(self.taches):
del self.taches[index - 1]
gestionnaire = GestionnaireTaches()
# Ajouter la fonction enumerate au contexte de rendu
@app.context_processor
def utility_processor():
def custom_enumerate(seq, start=1):
return enumerate(seq, start)
return dict(enumerate=custom_enumerate)
@app.route('/', methods=['GET', 'POST'])
def index():
if request.method == 'POST':
description = request.form['description']
gestionnaire.ajouter_tache(description)
return render_template('index.html', taches=gestionnaire.taches)
@app.route('/complete/<int:index>')
def complete(index):
gestionnaire.marquer_complet(index)
return redirect(url_for('index'))
@app.route('/delete/<int:index>')
def delete(index):
gestionnaire.supprimer_tache(index)
return redirect(url_for('index'))
if __name__ == '__main__':
app.run(debug=True)
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/sweetalert2@10">
<title>Gestionnaire de Tâches</title>
<style>
/* ... (voir le code complet ci-dessus) */
</style>
</head>
<body>
<div class="container">
<h1>Gestionnaire de Tâches</h1>
<form method="post" action="/">
<input type="text" name="description" placeholder="Nouvelle tâche" required>
<button type="submit">Ajouter</button>
</form>
<ul>
{% for index, tache in enumerate(taches, start=1) %}
<!-- Ajouter la classe 'incomplete' pour colorer en rouge les tâches incomplètes -->
<li class="{% if not tache['complete'] %}incomplete{% endif %}">
<span>{{ tache['description'] }} - {{ 'Complète' if tache['complete'] else 'Non Complète' }}</span>
<span>
<a href="{{ url_for('complete', index=index) }}">Marquer comme complète</a>
|
<a href="{{ url_for('delete', index=index) }}">Supprimer</a>
</span>
</li>
{% endfor %}
</ul>
</div>
<script src="https://cdn.jsdelivr.net/npm/sweetalert2@10"></script>
<script>
// Ajouter une vérification pour afficher un message SweetAlert si toutes les tâches sont complètes
document.addEventListener('DOMContentLoaded', function () {
var form = document.querySelector('form');
form.addEventListener('submit', function () {
var incompleteTasks = document.querySelectorAll('.incomplete').length;
if (incompleteTasks === 0) {
Swal.fire({
title: 'Félicitations !',
text: 'Toutes les tâches sont complètes.',
icon: 'success',
confirmButtonText: 'OK'
});
}
});
});
</script>
</body>
</html>
Notre application Flask utilise la classe GestionnaireTaches pour gérer les tâches. Les routes définies dans le code Python (app.py) permettent d'ajouter, de marquer comme complètes et de supprimer des tâches. La page HTML (templates/index.html) utilise Jinja2 pour afficher la liste des tâches et ajoute des styles pour améliorer l'esthétique.
Avec ce gestionnaire de tâches simple, vous avez une base solide pour comprendre les concepts de base de Flask, la création de routes, et l'utilisation de modèles HTML pour rendre l'interface utilisateur conviviale. N'hésitez pas à personnaliser davantage le code en ajoutant des fonctionnalités selon vos besoins.
N'oubliez pas de toujours suivre les meilleures pratiques de développement, d'ajouter des commentaires pour faciliter la compréhension, et d'explorer davantage les fonctionnalités de Flask pour construire des applications web plus complexes. Happy coding!
Introduction
La création d'une liste de tâches est l'un des exercices classiques lors de l'apprentissage du développement web. Dans ce tutoriel, nous allons explorer comment construire une application web simple de gestion de tâches en utilisant le framework Flask en Python.
Prérequis
Avant de commencer, assurez-vous d'avoir Python installé sur votre machine. Vous pouvez également utiliser un environnement virtuel pour isoler votre projet. Installez Flask en utilisant la commande suivante dans votre terminal :
pip install Flask
Étape 1 : Mise en place du projet
Commencez par créer un fichier Python (par exemple, app.py) pour notre application Flask. Importez Flask et initialisez votre application.
from flask import Flask, render_template, request, redirect, url_for
app = Flask(__name__)
Étape 2 : Création du gestionnaire de tâches
Définissez une classe GestionnaireTaches qui aura des méthodes pour ajouter, marquer comme complet et supprimer des tâches.
class GestionnaireTaches:
def __init__(self):
self.taches = []
def ajouter_tache(self, description):
self.taches.append({"description": description, "complete": False})
def marquer_complet(self, index):
if 1 <= index <= len(self.taches):
self.taches[index - 1]["complete"] = True
def supprimer_tache(self, index):
if 1 <= index <= len(self.taches):
del self.taches[index - 1]
gestionnaire = GestionnaireTaches()
Étape 3 : Ajout de la fonction enumerate au contexte de rendu
Ajoutez la fonction enumerate au contexte de rendu pour simplifier l'affichage des tâches numérotées dans la vue.
@app.context_processor
def utility_processor():
def custom_enumerate(seq, start=1):
return enumerate(seq, start)
return dict(enumerate=custom_enumerate)
Étape 4 : Création des routes
Définissez les routes pour l'index, la complétion et la suppression des tâches dans l'application Flask.
@app.route('/', methods=['GET', 'POST'])
def index():
if request.method == 'POST':
description = request.form['description']
gestionnaire.ajouter_tache(description)
return render_template('index.html', taches=gestionnaire.taches)
@app.route('/complete/<int:index>')
def complete(index):
gestionnaire.marquer_complet(index)
return redirect(url_for('index'))
@app.route('/delete/<int:index>')
def delete(index):
gestionnaire.supprimer_tache(index)
return redirect(url_for('index'))
Étape 5 : Création de la vue
Créez un fichier HTML (templates/index.html) pour afficher la liste de tâches et fournir un formulaire pour en ajouter de nouvelles.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Liste de tâches</title>
</head>
<body>
<h1>Liste de tâches</h1>
<form method="POST">
<label for="description">Nouvelle tâche :</label>
<input type="text" id="description" name="description" required>
<button type="submit">Ajouter</button>
</form>
<ul>
{% for index, tache in enumerate(taches) %}
<li>
{% if tache["complete"] %}
<del>{{ tache["description"] }}</del>
{% else %}
{{ tache["description"] }}
{% endif %}
[<a href="{{ url_for('complete', index=index+1) }}">Complet</a>]
[<a href="{{ url_for('delete', index=index+1) }}">Supprimer</a>]
</li>
{% endfor %}
</ul>
</body>
</html>
Conclusion
Félicitations, vous avez créé une application web de gestion de tâches simple avec Flask et Python ! N'hésitez pas à personnaliser davantage l'application en ajoutant des fonctionnalités telles que la persistence des données, la gestion des utilisateurs, ou un style CSS pour améliorer l'aspect visuel. Bon codage !