How to start using types in Python with mypy
0 likes86 views
This document provides an overview of using type annotations in Python to enable static type checking. It demonstrates how to annotate basic types like integers, strings, and lists. It also shows how to define type aliases, use optionals, create generic functions, use union types, and annotate callables. The goal is to add type safety to Python code and catch errors earlier using the static type checker Mypy.
![Let’s prepare some 🍔
def make_hamburger(meat, number_of_meats):
return ["bread"] + [meat] * number_of_meats + ["bread"]
print(make_hamburger("BEEF", 2))
# ['bread', 'BEEF', 'BEEF', 'bread']](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-12-320.jpg)
![class MyTest(unittest.TestCase):
def test_make_hamburger_returns_list(self):
self.assertTrue(isinstance(make_hamburger("beef", 2), list))
def test_empty_make_hamburger_returns_breads(self):
self.assertEqual(make_hamburger(None, 0), ['bread', 'bread'])
def test_invalid_make_hamburger_raises(self):
with self.assertRaises(TypeError):
make_hamburger()
Unit testing?](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-13-320.jpg)
![from typing import List
def make_hamburger(meat: str, number_of_meats: int) -> List[str]:
return ["bread"] + [meat] * number_of_meats + ["bread"]
The `typing`module](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-14-320.jpg)
![from typing import List
Hamburger = List[str]
def make_hamburger(meat: str, number_of_meats: int) -> Hamburger:
return ["bread"] + [meat] * number_of_meats + ["bread"]
Type Alias](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-15-320.jpg)
![from typing import List, Optional
Hamburger = List[str]
Extras = Optional[List[str]]
def make_hamburger(meat: str, number_of_meats: int, extras: Extras) -> Hamburger:
if extras:
return ["bread"] + extras + [meat] * number_of_meats + ["bread"]
else:
return ["bread"] + [meat] * number_of_meats + ["bread"]
print(make_hamburger("Beef", 2, ['tomatoes', 'pickles']))
# ['bread', 'tomatoes', 'pickles', 'Beef', 'Beef', 'bread']
Optionals 🍅](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-16-320.jpg)
![from typing import TypeVar, List
T = TypeVar("T", int, List[str])
def generic_add(x: T, y: T) -> T:
return x + y
Generics ](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-17-320.jpg)
![x1: int = 5
y1: int = 2
print(generic_add(x1, y1)) # 7
x2: List[str] = ["Hello"]
y2: List[str] = ["World"]
print(generic_add(x2, y2)) # ['Hello', 'World']
x3: str = "foo"
y3: str = "bar"
print(generic_add(x3, y3)) # mypy error: Value of type variable "T" of
"generic_add" cannot be "str"
Generics ](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-18-320.jpg)
![from typing import Union
Number = Union[float, int]
def union_add(x: Number, y: Number) -> Number:
return x + y
Union Types](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-19-320.jpg)
![x1: int = 5
y1: float = 2.5
print(union_add(x1, y1))
# 7
x2: int = 2
y2: str = "1"
print(union_add(x2, y2))
# error: Argument 1 to "union_add" has incompatible type "str";
expected "Union[float, int]"
# error: Argument 2 to "union_add" has incompatible type "str";
expected "Union[float, int]"
Union Types](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-20-320.jpg)
![from typing import Callable
def sum_and_process(a: int, b: int, callback: Callable[[int], bool]) -> bool:
total = a + b
return callback(total)
def is_positive(val: int) -> bool:
return val > 0
output = sum_and_process(5, 2, is_positive)
print(output)
# True
Callables](https://image.slidesharecdn.com/typeannotationsinpython-pyconchina2020-210620172507/85/How-to-start-using-types-in-Python-with-mypy-21-320.jpg)
More Related Content
Similar to How to start using types in Python with mypy (20)
How to start using types in Python with mypy
- 1. How to start using types in Python with Mypy
- 2. Carlos Villavicencio Ecuadorian Software Developer at Stack Builders Community leader Amateur photographer cvillavicencio [email protected] @po5i po5i Quilotoa Lake, Ecuador 2020. 大家好!
- 4. Data Structures Primitive Non-primitive Integer Float String Boolean Array List Tuple Dictionary Set File Linear Non-linear Stacks Queues Graphs Trees
- 7. Types are known in compilation time Variables bind to types Very verbose Bytecode is well optimized in memory Types are known in runtime Variables bind to objects 🦆 Less verbose Bugs in run-time are very common Dynamic vs. Static Languages
- 8. Weakly vs. Strongly Type System Implicit coercion between non-related types Flexibles Unpredictables Explicit type conversion (casting) Strict rules on the static analysis. Type Safety
- 9. Static type checking in Python But you can also use
- 10. Type Annotations
- 11. meat: str = "Beef" weight_pounds: float = "0.5" # mypy # error: Incompatible types in assignment # (expression has type "str", variable has type "float") Primitive types 🦕
- 12. Let’s prepare some 🍔 def make_hamburger(meat, number_of_meats): return ["bread"] + [meat] * number_of_meats + ["bread"] print(make_hamburger("BEEF", 2)) # ['bread', 'BEEF', 'BEEF', 'bread']
- 13. class MyTest(unittest.TestCase): def test_make_hamburger_returns_list(self): self.assertTrue(isinstance(make_hamburger("beef", 2), list)) def test_empty_make_hamburger_returns_breads(self): self.assertEqual(make_hamburger(None, 0), ['bread', 'bread']) def test_invalid_make_hamburger_raises(self): with self.assertRaises(TypeError): make_hamburger() Unit testing?
- 14. from typing import List def make_hamburger(meat: str, number_of_meats: int) -> List[str]: return ["bread"] + [meat] * number_of_meats + ["bread"] The `typing`module
- 15. from typing import List Hamburger = List[str] def make_hamburger(meat: str, number_of_meats: int) -> Hamburger: return ["bread"] + [meat] * number_of_meats + ["bread"] Type Alias
- 16. from typing import List, Optional Hamburger = List[str] Extras = Optional[List[str]] def make_hamburger(meat: str, number_of_meats: int, extras: Extras) -> Hamburger: if extras: return ["bread"] + extras + [meat] * number_of_meats + ["bread"] else: return ["bread"] + [meat] * number_of_meats + ["bread"] print(make_hamburger("Beef", 2, ['tomatoes', 'pickles'])) # ['bread', 'tomatoes', 'pickles', 'Beef', 'Beef', 'bread'] Optionals 🍅
- 17. from typing import TypeVar, List T = TypeVar("T", int, List[str]) def generic_add(x: T, y: T) -> T: return x + y Generics
- 18. x1: int = 5 y1: int = 2 print(generic_add(x1, y1)) # 7 x2: List[str] = ["Hello"] y2: List[str] = ["World"] print(generic_add(x2, y2)) # ['Hello', 'World'] x3: str = "foo" y3: str = "bar" print(generic_add(x3, y3)) # mypy error: Value of type variable "T" of "generic_add" cannot be "str" Generics
- 19. from typing import Union Number = Union[float, int] def union_add(x: Number, y: Number) -> Number: return x + y Union Types
- 20. x1: int = 5 y1: float = 2.5 print(union_add(x1, y1)) # 7 x2: int = 2 y2: str = "1" print(union_add(x2, y2)) # error: Argument 1 to "union_add" has incompatible type "str"; expected "Union[float, int]" # error: Argument 2 to "union_add" has incompatible type "str"; expected "Union[float, int]" Union Types
- 21. from typing import Callable def sum_and_process(a: int, b: int, callback: Callable[[int], bool]) -> bool: total = a + b return callback(total) def is_positive(val: int) -> bool: return val > 0 output = sum_and_process(5, 2, is_positive) print(output) # True Callables
- 23. 谢谢! ευχαριστώ Obrigado! ¡Gracias! Thank You! Check out my tutorial