Dans le monde de la programmation Python, le filtrage booléen est une technique puissante qui permet aux développeurs de traiter et de manipuler sélectivement des données en fonction de conditions logiques. Ce tutoriel explore des stratégies complètes pour implémenter le filtrage booléen, en donnant des informations sur la façon dont les opérateurs logiques et les méthodes de filtrage de Python peuvent améliorer l'efficacité du traitement des données et la clarté du code.
La logique booléenne est un concept fondamental en programmation qui traite des valeurs vraies et fausses. En Python, la logique booléenne constitue le pilier des opérations de prise de décision et de filtrage. Au cœur de la logique booléenne se trouvent des opérations logiques qui retournent soit True, soit False.
Python propose plusieurs opérateurs booléens clés :
| Opérateur | Description | Exemple |
|---|---|---|
and |
ET logique | True and False retourne False |
or |
OU logique | True or False retourne True |
not |
NON logique | not True retourne False |
En Python, les valeurs booléennes sont représentées par True et False. Cependant, de nombreux objets peuvent être évalués dans un contexte booléen :
## Falsy values
print(bool(0)) ## False
print(bool([])) ## False (empty list)
print(bool(None)) ## False
print(bool('')) ## False (empty string)
## Truthy values
print(bool(42)) ## True
print(bool([1, 2, 3]))## True
print(bool('Hello')) ## TrueLes opérateurs de comparaison retournent des valeurs booléennes :
| Opérateur | Signification | Exemple |
|---|---|---|
== |
Égal à | 5 == 5 retourne True |
!= |
Différent de | 5 != 3 retourne True |
> |
Supérieur à | 5 > 3 retourne True |
< |
Inférieur à | 3 < 5 retourne True |
>= |
Supérieur ou égal | 5 >= 5 retourne True |
<= |
Inférieur ou égal | 3 <= 5 retourne True |
def check_eligibility(age, has_license):
"""
Check if a person is eligible to drive
"""
return age >= 18 and has_license
## Usage
print(check_eligibility(20, True)) ## True
print(check_eligibility(16, True)) ## FalseLabEx recommande de pratiquer ces concepts pour maîtriser la logique booléenne en programmation Python.
Les compréhensions de liste offrent un moyen concis de filtrer des listes en fonction de conditions booléennes :
## Basic filtering
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = [num for num in numbers if num % 2 == 0]
print(even_numbers) ## [2, 4, 6, 8, 10]filter()La fonction filter() propose une autre méthode de filtrage puissante :
def is_positive(x):
return x > 0
numbers = [-1, 0, 1, 2, -3, 4]
positive_numbers = list(filter(is_positive, numbers))
print(positive_numbers) ## [1, 2, 4]| Technique | Description | Exemple |
|---|---|---|
| Compréhension de liste | Filtrage en ligne | [x for x in list if condition] |
Fonction filter() |
Filtrage fonctionnel | filter(function, iterable) |
| Expressions conditionnelles | Filtrage de type ternaire | value if condition else alternative |
## Complex filtering
data = [
{'name': 'Alice', 'age': 25, 'active': True},
{'name': 'Bob', 'age': 30, 'active': False},
{'name': 'Charlie', 'age': 35, 'active': True}
]
## Filter active users over 30
filtered_users = [
user for user in data
if user['active'] and user['age'] > 30
]
print(filtered_users)import numpy as np
## NumPy boolean filtering
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
filtered_arr = arr[arr % 2 == 0]
print(filtered_arr) ## [2 4 6 8 10]| Méthode de filtrage | Complexité temporelle | Lisibilité |
|---|---|---|
| Compréhension de liste | O(n) | Élevée |
filter() |
O(n) | Moyenne |
| Indexation booléenne NumPy | O(n) | Élevée |
filter() pour les approches de programmation fonctionnelleLabEx recommande de maîtriser ces techniques pour écrire un code de filtrage efficace et propre en Python.
Le filtrage booléen est crucial dans le prétraitement des données :
def clean_user_data(users):
## Remove invalid or incomplete user records
valid_users = [
user for user in users
if user['email'] and len(user['name']) > 2
]
return valid_users
users = [
{'name': 'A', 'email': 'a@example.com'},
{'name': 'Bob', 'email': ''},
{'name': 'Charlie', 'email': 'charlie@example.com'}
]
cleaned_users = clean_user_data(users)
print(cleaned_users)def identify_profitable_stocks(stocks):
## Filter stocks meeting specific criteria
profitable_stocks = [
stock for stock in stocks
if stock['price_change'] > 0 and stock['volume'] > 1000000
]
return profitable_stocks
stocks = [
{'symbol': 'AAPL', 'price_change': 2.5, 'volume': 1500000},
{'symbol': 'GOOGL', 'price_change': -1.2, 'volume': 800000},
{'symbol': 'MSFT', 'price_change': 1.8, 'volume': 2000000}
]
profitable = identify_profitable_stocks(stocks)
print(profitable)def filter_critical_logs(logs):
## Extract critical error logs
critical_logs = [
log for log in logs
if log['level'] == 'ERROR' and log['timestamp'] > recent_threshold
]
return critical_logs
logs = [
{'level': 'INFO', 'message': 'System started'},
{'level': 'ERROR', 'message': 'Connection failed'},
{'level': 'ERROR', 'message': 'Database timeout'}
]
critical_issues = filter_critical_logs(logs)
print(critical_issues)| Application | Approche de filtrage | Points clés à considérer |
|---|---|---|
| Nettoyage des données | Filtrage basé sur des conditions | Valider l'intégrité des données |
| Analyse financière | Filtrage basé sur les performances | Identifier les investissements optimaux |
| Surveillance du système | Filtrage par niveau de journal et horodatage | Détecter les problèmes critiques |
def prepare_training_data(dataset):
## Filter and prepare machine learning dataset
filtered_data = [
sample for sample in dataset
if sample['features_complete'] and sample['label'] is not None
]
return filtered_data
ml_dataset = [
{'features': [1.2, 3.4], 'features_complete': True, 'label': 1},
{'features': [], 'features_complete': False, 'label': None},
{'features': [2.1, 4.5], 'features_complete': True, 'label': 0}
]
training_data = prepare_training_data(ml_dataset)
print(training_data)LabEx recommande de pratiquer ces applications pratiques pour maîtriser les techniques de filtrage booléen dans des scénarios réels.
En maîtrisant les techniques de filtrage booléen en Python, les développeurs peuvent créer un code plus élégant, concis et performant. Comprendre comment exploiter les opérateurs logiques, les compréhensions de liste et les méthodes de filtrage intégrées permet aux programmeurs de gérer des scénarios de filtrage de données complexes avec plus de précision et de simplicité, améliorant ainsi globalement la productivité de la programmation.
