IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

La première version bêta de Python 3.11 est disponible et s'accompagne d'une meilleure gestion des erreurs
De la prise en charge de toml et d'améliorations pour la programmation asynchrone

Le , par Stéphane le calme

60PARTAGES

19  0 
Meilleure gestion des erreurs

Python 3.10 nous a donné de meilleurs messages d'erreur à divers égards, mais Python 3.11 vise à les améliorer encore plus. Certaines des choses les plus importantes qui sont ajoutées aux messages d'erreur dans Python 3.11 sont :

Emplacements exacts des erreurs dans les retraçages

Jusqu'à présent, dans un traçage, la seule information que vous obteniez sur l'endroit où une exception a été déclenchée était la ligne. Le problème aurait pu être n'importe où sur la ligne, donc parfois cette information n'était pas suffisante.

Voici un exemple*:

Code Python : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def get_margin(data): 
    margin = data['profits']['monthly'] / 10 + data['profits']['yearly'] / 2 
    return margin 
  
data = { 
    'profits': { 
        'monthly': 0.82, 
        'yearly': None, 
    }, 
    'losses': { 
        'monthly': 0.23, 
        'yearly': 1.38, 
    }, 
} 
print(get_margin(data))

Ce code génère une erreur, car l'un de ces champs dans le dictionnaire est None. Voici ce que nous obtenons*:

Citation Envoyé par Affichage à l'écran
Traceback (most recent call last):
File "/Users/tusharsadhwani/code/marvin-python/mytest.py", line 15, in <module>
print(get_margin(data))
File "/Users/tusharsadhwani/code/marvin-python/mytest.py", line 2, in print_margin
margin = data['profits']['monthly'] / 10 + data['profits']['yearly'] / 2
TypeError: unsupported operand type(s) for /: 'NoneType' and 'int'

Mais il est impossible de dire par le retraçage lui-même, quelle partie du calcul a causé l'erreur.

Sur la version 3.11 cependant :

Citation Envoyé par Affichage à l'écran
Traceback (most recent call last):
File "asd.py", line 15, in <module>
print(get_margin(data))
^^^^^^^^^^^^^^^^
File "asd.py", line 2, in print_margin
margin = data['profits']['monthly'] / 10 + data['profits']['yearly'] / 2
~~~~~~~~~~~~~~~~~~~~~~~~~~^~~
TypeError: unsupported operand type(s) for /: 'NoneType' and 'int'

Il est évident que data['profits']['yearly'] était None.

Pour pouvoir restituer ces informations, les données end_line et end_col ont été ajoutées aux objets de code Python. Vous pouvez également accéder à ces informations directement via la méthode obj.__code__.co_positions().

Les notes pour les exceptions

Pour rendre les traces encore plus riches en contexte, Python 3.11 vous permet d'ajouter des notes aux objets d'exception, qui sont stockées dans les exceptions et affichées lorsque l'exception est déclenchée.

Prenez ce code par exemple, où nous ajoutons des informations importantes sur une logique de conversion de données d'API*:

Code Python : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
def get_seconds(data): 
    try: 
        milliseconds = float(data['milliseconds']) 
    except ValueError as exc: 
        exc.add_note( 
            "The time field should always be a number, this is a critial bug. " 
            "Please report this to the backend team immediately." 
        ) 
        raise  # re-raises the exception, instead of silencing it 
  
    seconds = milliseconds / 1000 
    return seconds 
  
get_seconds({'milliseconds': 'foo'})  # 'foo' is not a number!

Cette note ajoutée est imprimée juste en dessous du message d'exception*:

Citation Envoyé par Affichage à l'écran
Traceback (most recent call last):
File "asd.py", line 14, in <module>
get_seconds({"milliseconds": "foo"})
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "asd.py", line 3, in get_seconds
milliseconds = float(data["milliseconds"])
^^^^^^^^^^^^^^^^^^^^^^^^^^^
ValueError: could not convert string to float: 'foo'
The time field should always be a number, this is a critial bug. Please report this to the backend team immediately.

Prise en charge toml intégrée

La bibliothèque standard a maintenant un support intégré pour lire les fichiers TOML, en utilisant le module tomllib*:

Code Python : Sélectionner tout
1
2
3
4
import tomllib 
  
with open('.deepsource.toml', 'rb') as file: 
    data = tomllib.load(file)

tomllib est en fait basé sur une bibliothèque d'analyse TOML open source appelée tomli. Et actuellement, seule la lecture des fichiers TOML est prise en charge. Si vous devez plutôt écrire des données dans un fichier TOML, envisagez d'utiliser le package tomli-w.

Groupes de travail asynchrones

Lorsque vous faites de la programmation asynchrone, vous rencontrez souvent des situations où vous devez déclencher de nombreuses tâches à exécuter simultanément, puis prendre des mesures lorsqu'elles sont terminées. Par exemple, télécharger un tas d'images en parallèle, puis les regrouper dans un fichier zip à la fin.

Pour ce faire, vous devez collecter des tâches et les transmettre à asyncio.gather. Voici un exemple simple de tâches exécutées en parallèle avec la fonction de gather*:

Code Python : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import asyncio 
  
async def simulate_flight(city, departure_time, duration): 
    await asyncio.sleep(departure_time) 
    print(f"Flight for {city} departing at {departure_time}PM") 
  
    await asyncio.sleep(duration) 
    print(f"Flight for {city} arrived.") 
  
  
flight_schedule = { 
    'boston': [3, 2], 
    'detroit': [7, 4], 
    'new york': [1, 9], 
} 
  
async def main(): 
    tasks = [] 
    for city, (departure_time, duration) in flight_schedule.items(): 
        tasks.append(simulate_flight(city, departure_time, duration)) 
  
    await asyncio.gather(*tasks) 
    print("Simulations done.") 
  
asyncio.run(main())

Mais devoir maintenir une liste des tâches soi-même pour pouvoir les attendre est un peu maladroit. Aussi, une nouvelle API est ajoutée à asyncio appelée Groupes de tâches*:

Code Python : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import asyncio 
  
async def simulate_flight(city, departure_time, duration): 
    await asyncio.sleep(departure_time) 
    print(f"Flight for {city} departing at {departure_time}PM") 
  
    await asyncio.sleep(duration) 
    print(f"Flight for {city} arrived.") 
  
  
flight_schedule = { 
    'boston': [3, 2], 
    'detroit': [7, 4], 
    'new york': [1, 9], 
} 
  
async def main(): 
    async with asyncio.TaskGroup() as tg: 
        for city, (departure_time, duration) in flight_schedule.items(): 
            tg.create_task(simulate_flight(city, departure_time, duration)) 
  
    print("Simulations done.") 
  
asyncio.run(main())

Lorsque le gestionnaire de contexte asyncio.TaskGroup() se ferme, il s'assure que toutes les tâches créées à l'intérieur ont fini de s'exécuter.


Groupes d'exceptions

Une fonctionnalité similaire a également été ajoutée pour la gestion des exceptions dans les tâches asynchrones, appelées groupes d'exceptions.

Supposons que de nombreuses tâches asynchrones s'exécutent ensemble et que certaines d'entre elles génèrent des erreurs. Actuellement, le système de gestion des exceptions de Python ne fonctionne pas bien dans ce scénario.

Voici une courte démo de ce à quoi cela ressemble avec 3 tâches simultanées qui ont planté*:

Code Python : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
import asyncio 
  
def bad_task(): 
    raise ValueError("oops") 
  
async def main(): 
    tasks = [] 
    for _ in range(3): 
        tasks.append(asyncio.create_task(bad_task())) 
  
    await asyncio.gather(*tasks) 
  
asyncio.run(main())

Lorsque vous exécutez ce code*:

Citation Envoyé par Affichage à l'écran
$ python asd.py
Traceback (most recent call last):
File "asd.py", line 13, in <module>
asyncio.run(main())
File "/usr/bin/python3.8/lib/asyncio/runners.py", line 44, in run
return loop.run_until_complete(main)
File "/usr/bin/python3.8/lib/asyncio/base_events.py", line 616, in run_until_complete
return future.result()
File "asd.py", line 9, in main
tasks.append(asyncio.create_task(bad_task()))
File "asd.py", line 4, in bad_task
raise ValueError("oops")
ValueError: oops

Rien n'indique que 3 de ces tâches s'exécutaient ensemble. Dès que la première échoue, elle fait planter tout le programme.

Mais en Python 3.11, le comportement est un peu meilleur*:

Code Python : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
import asyncio 
  
async def bad_task(): 
    raise ValueError("oops") 
  
async def main(): 
    async with asyncio.TaskGroup() as tg: 
        for _ in range(3): 
            tg.create_task(bad_task()) 
  
asyncio.run(main())
Citation Envoyé par Affichage à l'écran
$ python asd.py
+ Exception Group Traceback (most recent call last):
| File "<stdin>", line 1, in <module>
| File "/usr/local/lib/python3.11/asyncio/runners.py", line 181, in run
| return runner.run(main)
| ^^^^^^^^^^^^^^^^
| File "/usr/local/lib/python3.11/asyncio/runners.py", line 115, in run
| return self._loop.run_until_complete(task)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| File "/usr/local/lib/python3.11/asyncio/base_events.py", line 650, in run_until_complete
| return future.result()
| ^^^^^^^^^^^^^^^
| File "<stdin>", line 2, in main
| File "/usr/local/lib/python3.11/asyncio/taskgroups.py", line 139, in __aexit__
| raise me from None
| ^^^^^^^^^^^^^^^^^^
| ExceptionGroup: unhandled errors in a TaskGroup (3 sub-exceptions)
+-+---------------- 1 ----------------
| Traceback (most recent call last):
| File "<stdin>", line 2, in bad_task
| ValueError: oops
+---------------- 2 ----------------
| Traceback (most recent call last):
| File "<stdin>", line 2, in bad_task
| ValueError: oops
+---------------- 3 ----------------
| Traceback (most recent call last):
| File "<stdin>", line 2, in bad_task
| ValueError: oops
+------------------------------------

L'exception nous indique maintenant que trois erreurs ont été générées, dans une structure appelée ExceptionGroup.

La gestion des exceptions avec ces groupes d'exceptions est également intéressante, vous pouvez soit faire except ExceptionGroup pour intercepter toutes les exceptions en une seule fois :

Code Python : Sélectionner tout
1
2
3
4
try: 
    asyncio.run(main()) 
except ExceptionGroup as eg: 
    print(f"Caught exceptions: {eg}")
Citation Envoyé par Affichage à l'écran
$ python asd.py
Caught exceptions: unhandled errors in a TaskGroup (3 sub-exceptions)

Ou vous pouvez les intercepter en fonction du type d'exception, en utilisant la nouvelle syntaxe except**:

Code Python : Sélectionner tout
1
2
3
4
try: 
    asyncio.run(main()) 
except* ValueError as eg: 
    print(f"Caught ValueErrors: {eg}")
Citation Envoyé par Affichage à l'écran
$ python asd.py
Caught ValueErrors: unhandled errors in a TaskGroup (3 sub-exceptions)

Améliorations apportées au module typing

Le module typing a vu beaucoup de mises à jour intéressantes dans cette version. Voici quelques-uns des plus intéressantes :

Génériques variadiques

La prise en charge des génériques variadiques a été ajoutée au module typing dans Python 3.11.

Cela signifie que vous pouvez désormais définir des types génériques pouvant contenir un nombre arbitraire de types. Il est utile pour définir des méthodes génériques pour les données multidimensionnelles.

Par exemple:

Code Python : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
from typing import Generic 
from typing_extensions import TypeVarTuple, Unpack 
  
Shape = TypeVarTuple('Shape') 
  
class Array(Generic[Unpack[Shape]]): 
    ... 
  
# holds 1 dimensional data, like a regular list 
items: Array[int] = Array() 
  
# holds 3 dimensional data, for example, X axis, Y axis and value 
market_prices: Array[int, int, float] = Array() 
  
# This function takes in an `Array` of any shape, and returns the same shape 
def double(array: Array[Unpack[Shape]]) -> Array[Unpack[Shape]]: 
    ... 
  
# This function takes an N+2 dimensional array and reduces it to an N dimensional one 
def get_values(array: Array[int, int, *Shape]) -> Array[*Shape]: 
    ... 
  
# For example: 
vector_space: Array[int, int, complex] = Array() 
reveal_type(get_values(vector_space))  # revealed type is Array[complex]

Les génériques variadiques peuvent être très utiles pour définir des fonctions qui mappent sur des données à N dimensions. Cette fonctionnalité peut être très utile pour la vérification de type des bases de code qui s'appuient sur des bibliothèques de science des données telles que numpy ou tensorflow.

L'équipe responsable du développement de Python explique que : « La nouvelle syntaxe Generic[*Shape] n'est prise en charge que dans Python 3.11. Pour utiliser cette fonctionnalité dans Python 3.10 et versions antérieures, vous pouvez utiliser la fonction intégrée typing.Unpack à la place de Generic[Unpack[Shape]] ».

singledispatch prend désormais en charge les unions

functools.singledispatch est un moyen pratique de surcharger les fonctions en Python, basé sur des indications de type. Cela fonctionne en définissant une fonction générique et en se servant de @singledispatch. Ensuite, vous pouvez définir des variantes spécialisées de cette fonction, en fonction du type des arguments de la fonction*:

Code Python : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from functools import singledispatch 
  
  
@singledispatch 
def half(x): 
    """Returns the half of a number""" 
    return x / 2 
  
@half.register 
def _(x: int): 
    """For integers, return an integer""" 
    return x // 2 
  
@half.register 
def _(x: list): 
    """For a list of items, get the first half of it.""" 
    list_length = len(x) 
    return x[: list_length // 2] 
  
                            # Outputs: 
print(half(3.6))            # 1.8 
print(half(15))             # 7 
print(half([1, 2, 3, 4]))   # [1, 2]

En...
La fin de cet article est réservée aux abonnés. Soutenez le Club Developpez.com en prenant un abonnement pour que nous puissions continuer à vous proposer des publications.

Une erreur dans cette actualité ? Signalez-nous-la !

Avatar de archqt
Membre émérite https://www.developpez.com
Le 29/10/2022 à 15:01
Le C++ a une syntaxe moche ? autant les templates à la création cela peut être effectivement compliqué, mais cela est réservé pour les cas complexes aux experts, autant pour le reste je ne trouve pas cela moche
4  0 
Avatar de
https://www.developpez.com
Le 31/10/2022 à 0:15
Citation Envoyé par archqt Voir le message
Le C++ a une syntaxe moche ? autant les templates à la création cela peut être effectivement compliqué, mais cela est réservé pour les cas complexes aux experts, autant pour le reste je ne trouve pas cela moche
De toute façon, dire qu'un langage est moche, quel qu'il soit c'est un peu débile ...
Le langage est secondaire dans tout les cas.

Il n'est là que pour permettre d'atteindre un but précis : donner vie à une idée.
Celui qui se masturbe sur le langage est clairement à des années lumières d'avoir compris le boulot de développeur.

Même si il est évident que certains sont plus adapté à des contextes et que donc, la règle numéro une dans ce métier c'est "ça dépend", même là, s'attacher à ça n'est pas se concentrer sur les bonnes choses.

Les seuls à être convaincu de l'inverse de ce que je viens d'écrire, ce sont les mecs formés à l'arrache en six mois, ultra spécialisé qui ne connaissent rien au code et qui se rendrons compte dans 5 ans qu'ils étaient sur la mauvaise route depuis le départ.
4  1 
Avatar de electroremy
Membre expérimenté https://www.developpez.com
Le 21/11/2022 à 14:38
La performance des langages n'est pas seulement accessoire

Un bon langage qui permet de faire plus facilement du code compact et rapide permet :
- d'économiser de l'énergie
- d'utiliser un système avec moins de RAM, moins de ROM et un CPU plus lent ce qui éviter de remplacer son matériel

Un langage à la fois lent et populaire est une catastrophe pour la planète et nos portemonnaies.

Bien sûr, il y a le rôle du programmeur qui doit optimiser son code.

Exemple : sur Arduino, j'ai optimisé deux bibliothèques pour faire "rentrer" le code de mon projet dans les 32ko de rom (client TCP IP + écran LCD graphique + dalle tactile + capteurs). Non seulement ça marche mais en plus mes fonctions sont à la fois plus complète et sont 8 à 13 fois plus rapide que le code d'origine.
Mais ça demandé pas mal de travail...
...et surtout mon code n'est plus "portables" sur les autres cartes à microcontrôleur
...normal, on ne peut pas tout avoir

Quand on voit ce que demande en RAM et en CPU les versions actuelles de Word et Excel, alors qu'on ne fait pas grand chose de plus avec que les versions de 1997...

Mon premier ordinateur était un Amiga 1200, CPU 68020 à 14Mhz, 2Mo de RAM, j'étais impressionné par ce qu'arrivait à en tirer les programmeurs de l'époque, notamment sur des jeux dignes de bornes d'arcade, des applications graphiques et musicales.

S'agissant de la syntaxe et du confort, ça ne dépend pas que du langage mais aussi de l'IDE.
Un langage "facile" peut être performant : si par exemple les premières versions de Visual Basic étaient lentes, la version VB.NET permet de faire du code aussi rapide qu'en C#
2  0 
Avatar de leopard78
Candidat au Club https://www.developpez.com
Le 07/11/2022 à 14:15
Si tu code moche en C++ c’est ton problème 😬 pas les autres !
1  0 
Avatar de fred1599
Expert éminent https://www.developpez.com
Le 16/11/2022 à 8:04
Bonjour,

Dire qu'un langage est moche est très souvent subjectif et un avis de ce type ne concerne que soit. On lui demande le sien, il le donne... ce n'est pas pour ça que le contredire lui fera changer d'avis sur le C++ ou tout ceux qui sont d'accord avec lui.

La version 3.11 est sans doute améliorée, ce n'est pas pour autant que j'ai choisi ce langage, et ce n'est pas non plus pour cela que des développeurs se mettront à apprendre ce langage.

Même si c'est plus rapide, ça ne le sera pas suffisamment face à des langages compilés et autant dire que c'est souvent à cette comparaison (langages interprétés - compilés) que l'on fait référence.

Par contre cette amélioration peut être intéressante et faire la différence sur des langages comme ruby, R et surtout celui qui commence à faire de l'ombre... julia.

julia étant connu pour être bien plus performant et spécialisé pour des travaux scientifiques, on peut être amené à choisir l'un ou l'autre, et cette version 3.11 équilibre les forces côté performances.
1  0 
Avatar de shenron666
Expert confirmé https://www.developpez.com
Le 07/11/2022 à 20:51
Le binaire compilé en C++ s'exécute en seulement 1,8 fois moins de temps que le code javascript.
Mon premier avis est que je doute que le code C++ soit correctement écrit.
En plus, comparer des temps d'exécution de cet ordre (moins d'une seconde) manque de précision.

Dire que C++ a une syntaxe moche est plus que ridicule vu que la beauté c'est subjectif, et la beauté d'un code c'est... encore plus subjectif.
Perso je préfère le C# mais jamais je n'irai dire que c'est plus beau ou moins moche qu'un autre langage.
0  0 
Avatar de byrautor
Membre éclairé https://www.developpez.com
Le 08/11/2022 à 13:36
3 fois plus rapide !
Mazette, il faut y croire, ma conviction est que ...
0  0 
Avatar de vivid
Membre habitué https://www.developpez.com
Le 16/11/2022 à 7:35
X3 fois plus rapide, c'est reconnaitre que la version précédente a été conçue avec les pieds ! ils font la promotion de leur incompétence ?!!
0  0