Python 3 : Division, Unpacking et Fonctions Essentielles

Introduction

La migration de Python 2 vers Python 3 a introduit des changements fondamentaux qui peuvent surprendre meme les developpeurs experimentes. Parmi ces changements, la division numerique, l’unpacking d’iterables et la transformation de print en fonction sont particulierement importants a maitriser.

Dans cet article, vous apprendrez :

• Comment fonctionne la division en Python 3 et comment eviter les pieges courants
• Les techniques avancees d’unpacking avec les operateurs * et **
• L’utilisation complete de la fonction print() et ses options

L’Operation Division en Python 3

Difference entre Python 2 et Python 3

L’une des principales differences entre Python 2 et Python 3 est la maniere dont les operations de division sont gerees.

Operateur	Python 2	Python 3
/	Division entiere si operandes entiers	Toujours division decimale
//	Division entiere	Division entiere

# Python 3
print(5 / 2)   # Resultat: 2.5 (division decimale)
print(5 // 2)  # Resultat: 2 (division entiere)
print(-5 // 2) # Resultat: -3 (arrondi vers le bas)

Cas Pratiques et Solutions

Un code qui fonctionnait correctement en Python 2 peut produire des resultats inattendus en Python 3 :

# Calcul de moyenne - Attention aux types!
items = [10, 20, 30, 40]

# Python 3 - Fonctionne correctement
average = sum(items) / len(items)
print(f"Moyenne: {average}")  # 25.0

# Si vous avez besoin d'un entier
average_int = sum(items) // len(items)
print(f"Moyenne entiere: {average_int}")  # 25

Division avec le module decimal pour la precision

Pour les calculs financiers ou scientifiques necessitant une precision elevee :

from decimal import Decimal, ROUND_HALF_UP

# Calcul precis avec Decimal
prix = Decimal('19.99')
quantite = Decimal('3')
total = prix * quantite
print(f"Total: {total}")  # 59.97

# Arrondi precis
resultat = Decimal('10') / Decimal('3')
arrondi = resultat.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
print(f"Arrondi: {arrondi}")  # 3.33

Unpacking d’Iterables avec * et **

Unpacking Basique

L’unpacking permet d’extraire les elements d’un iterable dans des variables distinctes :

# Unpacking simple
coordonnees = (10, 20, 30)
x, y, z = coordonnees
print(f"x={x}, y={y}, z={z}")  # x=10, y=20, z=30

# Unpacking avec l'operateur *
first, second, *tail, last = [1, 2, 3, 4, 5, 6, 7]
print(f"Premier: {first}")    # 1
print(f"Second: {second}")    # 2
print(f"Queue: {tail}")       # [3, 4, 5, 6]
print(f"Dernier: {last}")     # 7

Unpacking Avance avec *

L’operateur * est extremement flexible :

# Ignorer des elements du milieu
debut, *_, fin = range(10)
print(f"Debut: {debut}, Fin: {fin}")  # Debut: 0, Fin: 9

# Combiner des listes
liste1 = [1, 2, 3]
liste2 = [4, 5, 6]
combinee = [*liste1, *liste2]
print(combinee)  # [1, 2, 3, 4, 5, 6]

# Unpacking dans les appels de fonction
def afficher_infos(nom, age, ville):
    print(f"{nom}, {age} ans, habite a {ville}")

donnees = ["Alice", 30, "Paris"]
afficher_infos(*donnees)  # Alice, 30 ans, habite a Paris

Fusion de Dictionnaires avec **

La syntaxe ** permet de travailler avec les dictionnaires :

# Fusion de dictionnaires
config_defaut = {'theme': 'clair', 'langue': 'fr', 'notifications': True}
config_user = {'theme': 'sombre', 'taille_police': 14}

# Fusion avec priorite a config_user
config_finale = {**config_defaut, **config_user}
print(config_finale)
# {'theme': 'sombre', 'langue': 'fr', 'notifications': True, 'taille_police': 14}

# Ajout de nouvelles cles
enrichi = {**config_finale, 'version': '2.0', 'debug': False}

Unpacking dans les Comprehensions

# Aplatir une liste de listes
matrice = [[1, 2], [3, 4], [5, 6]]
aplatie = [element for ligne in matrice for element in ligne]
print(aplatie)  # [1, 2, 3, 4, 5, 6]

# Avec unpacking
paires = [(1, 'a'), (2, 'b'), (3, 'c')]
nombres, lettres = zip(*paires)
print(list(nombres))  # [1, 2, 3]
print(list(lettres))  # ['a', 'b', 'c']

La Fonction print() en Python 3

Syntaxe Complete

En Python 3, print est une fonction avec plusieurs parametres utiles :

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

Options de Formatage

# Separateur personnalise
print("Python", "Java", "JavaScript", sep=" | ")
# Python | Java | JavaScript

# Fin de ligne personnalisee
for i in range(5):
    print(i, end=" -> ")
print("Fin")
# 0 -> 1 -> 2 -> 3 -> 4 -> Fin

# Combinaison
valeurs = [10, 20, 30]
print(*valeurs, sep=", ", end=".\n")
# 10, 20, 30.

Ecriture dans un Fichier

# Ecrire dans un fichier avec print
with open('log.txt', 'w') as f:
    print("Debut du traitement", file=f)
    print("Etape 1 terminee", file=f)
    print("Fin du traitement", file=f)

# Forcer l'ecriture immediate avec flush
import time
for i in range(5):
    print(f"Progression: {i+1}/5", flush=True)
    time.sleep(1)

Redirection vers stderr

import sys

def log_erreur(message):
    print(f"[ERREUR] {message}", file=sys.stderr)

def log_info(message):
    print(f"[INFO] {message}")

log_info("Application demarree")
log_erreur("Connexion impossible")

Bonnes Pratiques

1. Utilisez toujours / pour la division decimale et // pour la division entiere explicite

2. Preferez les f-strings pour le formatage :

# Recommande
nom = "Alice"
age = 30
print(f"{nom} a {age} ans")

# Moins lisible
print("{} a {} ans".format(nom, age))

3. Utilisez l’unpacking pour echanger des variables :

a, b = b, a  # Echange sans variable temporaire

4. Evitez l’unpacking trop complexe - si plus de 3 elements, utilisez l’indexation

5. Utilisez flush=True pour les logs en temps reel dans les scripts longs

Pieges Courants

Division par zero

# Toujours verifier avant la division
def division_sure(a, b):
    if b == 0:
        return None
    return a / b

Unpacking avec mauvais nombre d’elements

# Ceci leve une ValueError
try:
    a, b, c = [1, 2]  # Pas assez d'elements
except ValueError as e:
    print(f"Erreur: {e}")

# Solution avec valeurs par defaut
from itertools import zip_longest
valeurs = [1, 2]
a, b, c = list(zip_longest(valeurs, [None]*3, fillvalue=0))[0][:3]

Modification pendant l’iteration

# A eviter
liste = [1, 2, 3, 4, 5]
# for item in liste:
#     if item % 2 == 0:
#         liste.remove(item)  # Comportement imprevisible!

# Solution correcte
liste = [item for item in liste if item % 2 != 0]

Conclusion

La maitrise de la division Python 3, de l’unpacking d’iterables et de la fonction print() sont des competences essentielles pour tout developpeur Python. Ces fonctionnalites permettent d’ecrire du code plus concis, plus lisible et plus Pythonique.

Points cles a retenir :

• / pour division decimale, // pour division entiere
• * pour unpacking de listes/tuples, ** pour dictionnaires
• print() est une fonction avec des parametres sep, end, file et flush

Pour Aller Plus Loin

• Explorez le module operator pour des operations plus avancees
• Decouvrez les walrus operator := introduit en Python 3.8
• Apprenez les pattern matching avec match/case en Python 3.10+