Typing

03-typing/03-typing.tex

+\documentclass{beamer}
+\usepackage[utf8]{inputenc}
+\usepackage[czech]{babel}
+\usepackage{palatino}
+\usepackage{verbatim}
+\usetheme{Warsaw}
+\title{Programování 2: Typové anotace}
+\author[Martin Mareš]{Martin Mareš\\\texttt{mj@ucw.cz}}
+\institute{Katedra Aplikované Matematiky\\MFF UK Praha}
+\date{2020}
+\setbeamersize{text margin left=5mm}
+\setbeamersize{text margin right=5mm}
+\begin{document}
+\setbeamertemplate{navigation symbols}{}
+\setbeamertemplate{footline}{}
+\setbeamerfont{title page}{family=\rmfamily}
+\shorthandoff{"}
+
+\begin{frame}
+\titlepage
+\end{frame}
+
+\input ../slidemac.tex
+
+% ----------------------------------------------------------------------
+
+\begin{frame}{Proč a nač?}
+
+Jak se programovací jazyky chovají k~typům dat:
+
+\begin{itemize}
+\item {\bf statické} typování -- typ mají proměnné a funkce
+\item {\bf dynamické} typování -- typ mají hodnoty
+\end{itemize}
+
+~
+
+Obojí má své výhody i nevýhody.
+
+~
+
+K~čemu třeba jsou užitečné statické typy:
+
+\begin{itemize}
+\item Lepší dokumentace\\(např.: funguje {\bf math.exp} na komplexní čísla?)
+\item Kontrola konzistence typů před spuštěním programu
+\item Napovídání v~editorech
+\end{itemize}
+
+~
+
+Dnešní Python umí kombinovat statické a dynamické typy~\dots
+
+\end{frame}
+
+% ----------------------------------------------------------------------
+
+\begin{frame}{Typové anotace}
+
+{\tt\color{blue}
+def f(x: int, y: str) -> int:\\
+~~~~return x + len(y)
+}
+
+\smallskip
+
+Čteme: {\bf f} je funkce, parametr {\bf x} je typu {\bf int}, {\bf y} typu {\bf str},\\
+vrací výsledek typu {\bf int}.
+
+~
+
+{\tt\color{blue}
+a: int = 42
+}
+
+\smallskip
+
+Proměnné {\bf a} jsme deklarovali typ {\bf int}.
+
+~
+
+Python sám typy nekontroluje (to dělají samostatné type checkery),
+ale pamatuje si je:
+
+\smallskip
+
+\py{%
+f.\_\_annotations\_\_
+}{%
+\{'x': int, 'y': str, 'return': int\}
+}
+
+\py{%
+help(f)
+}{%
+Help on function f in module \_\_main\_\_:\\
+f(x: int, y: str) -> int
+}
+
+\end{frame}
+
+% ----------------------------------------------------------------------
+
+\begin{frame}{Složitější typy}
+
+{\tt\color{blue}
+from typing import List\\
+def g(seznam: List[str]) -> None:
+}
+
+\smallskip
+
+Parametrizovaný typ pro seznamy.
+
+~
+
+{\tt\color{blue}
+from typing import Optional\\
+def center(s: str, šíře: Optional[int]=80) -> str:
+}
+
+\smallskip
+
+Buď {\bf int} nebo {\bf None} (též chybí-li parametr při volání).
+
+~
+
+{\tt\color{blue}
+Class Třída:\\
+~~~~def metoda(self, něco: int):
+}
+
+\smallskip
+
+{\bf self} automaticky dostane typ {\bf Třída}.
+
+~
+
+
+{\tt\color{blue}
+from typing import Sequence, TypeVar\\
+T = TypeVar("T")\\
+def choose(s: Sequence[T]) -> T:
+}
+
+\smallskip
+
+Funguje pro jakoukoliv homogenní posloupnost (seznam/tuple/\dots).
+
+\end{frame}
+
+% ----------------------------------------------------------------------
+
+\end{document}

03-typing/Makefile

+SLIDES=03-typing.pdf
+
+include ../Makerules