Python\u2019s support for static typing gradually improves with each new release of Python. The core features were in place in Python 3.5<\/a>. Since then, there\u2019ve been many tweaks and improvements to the type hinting system<\/strong>. This evolution continues in Python 3.12, which, in particular, simplifies the typing of generics.<\/p>\n In this tutorial, you\u2019ll:<\/strong><\/p>\n This won\u2019t be an introduction to using type hints in Python. If you want to review the background that you\u2019ll need for this tutorial, then have a look at Python Type Checking<\/a>.<\/p>\n You\u2019ll find many other new features, improvements, and optimizations in Python 3.12. The most relevant ones include the following:<\/p>\n Go ahead and check out what\u2019s new<\/a> in the changelog for more details on these and other features.<\/p>\n Free Bonus:<\/strong> Click here to download your sample code<\/a> for a sneak peek at Python 3.12, coming in October 2023.<\/p>\n<\/div>\n Type variables have been a part of Python\u2019s static typing system since its introduction in Python 3.5. PEP 484<\/a> introduced type hints to the language, and type variables and generics play an important role in that document. In this section, you\u2019ll dive into how you\u2019ve used type variables so far. This\u2019ll give you the necessary background to appreciate the new syntax that you\u2019ll learn about later.<\/p>\n A generic type<\/strong> is a type parametrized by another type. Typical examples include a list<\/a> of integers and a tuple consisting of a float, a string, and another float. You use square brackets to parametrize generics in Python. You can write the two examples above as In addition to using built-in generic types, you can define your own generic<\/a> classes. In the following example, you implement a generic queue<\/a> based on This is a first-in, first-out (FIFO<\/a>) queue. It represents the kind of lines that you\u2019ll find yourself in at stores, where the first person into the queue is also the first one to leave the queue. Before looking closer at the code, and in particular at the type hints, play a little with the class:<\/p>\n You can use Normally, using square brackets like you did in To answer that question, you need to look at In your If you look back at the source code of Speaking of static type checkers, how do you actually check the types in your code? Type annotations are mostly ignored during runtime. Instead, you need to install a separate type checker and run it explicitly on your code.<\/p>\n Note:<\/strong> In this tutorial, you\u2019ll use Pyright<\/a> as your type checker. You can install Pyright from PyPI<\/a> using If you\u2019re using Visual Studio Code<\/a>, then you can use Pyright inside the editor through the Pylance<\/a> extension. You may need to activate it by setting the Python \u203a Analysis: Type Checking Mode<\/em> option in your settings.<\/p>\n<\/div>\n If you install Pyright, then you can use it to type check your code:<\/p>\n To see an example of the kinds of errors that Pyright can detect, add the following lines to your generic queue implementation:<\/p>\n<\/div>\n [ Improve Your Python With ? Python Tricks ? \u2013 Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples<\/a> ]<\/em><\/p>\n\n In this tutorial, you’ll preview the new static typing features in Python 3.12. You’ll learn about the new syntax for type variables, making generics simpler to define. You’ll also see how @override lets you model inheritance and how you use typed dictionaries to annotate variable keyword arguments.<\/p>\n<\/div>","protected":false},"author":2055,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"slim_seo":{"title":"Python 3.12 Preview: Static Typing Improvements - ITTeacherITFreelance.hk","description":"In this tutorial, you'll preview the new static typing features in Python 3.12. You'll learn about the new syntax for type variables, making generics simpler to"},"footnotes":""},"categories":[10700],"tags":[],"_links":{"self":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/329486"}],"collection":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/users\/2055"}],"replies":[{"embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/comments?post=329486"}],"version-history":[{"count":1,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/329486\/revisions"}],"predecessor-version":[{"id":329487,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/329486\/revisions\/329487"}],"wp:attachment":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/media?parent=329486"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/categories?post=329486"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/tags?post=329486"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}\n
@override<\/code> decorator<\/strong><\/li>\n**kwargs<\/code> more precisely<\/strong> with typed dictionaries<\/li>\n<\/ul>\n\n
perf<\/code> profiler<\/a><\/li>\nRecap Type Variable Syntax Before Python 3.12<\/a><\/h2>\n
list[int]<\/code> and tuple[float, str, float]<\/code>, respectively.<\/p>\ndeque<\/code><\/a> in the standard library:<\/p>\n<\/span># generic_queue.py<\/span>\n\nfrom<\/span> collections<\/span> import<\/span> deque<\/span>\nfrom<\/span> typing<\/span> import<\/span> Generic<\/span>,<\/span> TypeVar<\/span>\n\nT<\/span> =<\/span> TypeVar<\/span>(<\/span>\"T\"<\/span>)<\/span>\n\nclass<\/span> Queue<\/span>(<\/span>Generic<\/span>[<\/span>T<\/span>]):<\/span>\n def<\/span> __init__<\/span>(<\/span>self<\/span>)<\/span> -><\/span> None<\/span>:<\/span>\n self<\/span>.<\/span>elements<\/span>:<\/span> deque<\/span>[<\/span>T<\/span>]<\/span> =<\/span> deque<\/span>()<\/span>\n\n def<\/span> push<\/span>(<\/span>self<\/span>,<\/span> element<\/span>:<\/span> T<\/span>)<\/span> -><\/span> None<\/span>:<\/span>\n self<\/span>.<\/span>elements<\/span>.<\/span>append<\/span>(<\/span>element<\/span>)<\/span>\n\n def<\/span> pop<\/span>(<\/span>self<\/span>)<\/span> -><\/span> T<\/span>:<\/span>\n return<\/span> self<\/span>.<\/span>elements<\/span>.<\/span>popleft<\/span>()<\/span>\n<\/code><\/pre>\n<\/div>\n<\/span>>>> <\/span>from<\/span> generic_queue<\/span> import<\/span> Queue<\/span>\n\n>>> <\/span>queue<\/span> =<\/span> Queue<\/span>[<\/span>int<\/span>]()<\/span>\n<\/span>\n>>> <\/span>queue<\/span>.<\/span>push<\/span>(<\/span>3<\/span>)<\/span>\n>>> <\/span>queue<\/span>.<\/span>push<\/span>(<\/span>12<\/span>)<\/span>\n>>> <\/span>queue<\/span>.<\/span>elements<\/span>\ndeque([3, 12])<\/span>\n\n>>> <\/span>queue<\/span>.<\/span>pop<\/span>()<\/span>\n3<\/span>\n<\/code><\/pre>\n<\/div>\n.push()<\/code> to add elements to the queue and .pop()<\/code> to remove elements from the queue. Note that when you called the Queue()<\/code> constructor<\/a>, you included [int]<\/code>. This isn\u2019t necessary, but it tells the type checker that you expect the queue to only contain integer elements.<\/p>\nQueue[int]()<\/code> isn\u2019t valid Python syntax. You can use square brackets with Queue<\/code>, however, because you defined Queue<\/code> as a generic class by inheriting from Generic<\/code>. How does the rest of your class use this int<\/code> parameter?<\/p>\nT<\/code>, which is a type variable<\/strong>. A type variable is a special variable that can stand in for any type. However, during type checking, the type of T<\/code> will be fixed.<\/p>\nQueue[int]<\/code> example, T<\/code> will be int<\/code> in all annotations on the class. You could also instantiate Queue[str]<\/code>, where T<\/code> would represent str<\/code> everywhere. This would then be a queue with string elements.<\/p>\nQueue<\/code>, then you\u2019ll see that .pop()<\/code> returns an object of type T<\/code>. In your special integer queue, the static type checker will make sure that .pop()<\/code> returns an integer.<\/p>\npip<\/code><\/a>:<\/p>\n<\/span>$ <\/span>python <\/span>-m <\/span>pip <\/span>install <\/span>pyright\n<\/code><\/pre>\n<\/div>\n<\/span>$ <\/span>pyright <\/span>generic_queue.py\n0 errors, 0 warnings, 0 informations<\/span>\n<\/code><\/pre>\n<\/div>\nRead the full article at https:\/\/realpython.com\/python312-typing\/ \u00bb<\/a><\/h2>\n
\n![\\\"IT\u96fb\u8166\u88dc\u7fd2](\\\"http:\/\/itteacheritfreelance.hk\/test\/wordpress\/wp-content\/uploads\/2016\/05\/logo2-2.png\\\"){kind=logo}
\r\nwww.itsec.hk<\/a>
\r\nwww.itsec.vip<\/a>
\r\nwww.itseceu.uk<\/a>
<\/p>","protected":false},"excerpt":{"rendered":"