cours-python/sessions/python-02.tex

\documentclass{beamer}

\usepackage[utf8]{inputenc}
\usepackage{hyperref}
\usepackage{listings}
\lstset{language=Python, showstringspaces=false}

\usetheme{Madrid}

\hypersetup{colorlinks=true}

\title{Introduction à la programmation avec Python \\ (chapitre 2)}
\author{Dimitri Merejkowsky}
\institute{E2L}

\begin{document}

\frame{\titlepage}

\begin{frame}

Note: \\~\\

Les sources sont sur GitHub:

\url{https://github.com/E2L/cours-python/tree/master/sources}. \\~\\


Mais il vaut mieux recopier le code vous-mêmes.

\end{frame}


\begin{frame}

\frametitle{Plan}

\begin{itemize}
  \item Retours sur le chapitre 1
  \item Fonctions
  \item Structures de données
\end{itemize}

\end{frame}


\begin{frame}[fragile]
  \centering
  \begin{beamercolorbox}[sep=8pt,center,shadow=true,rounded=true]{title}
    Retours sur le chapitre 1
  \end{beamercolorbox}
\end{frame}


\begin{frame}[fragile]
  \frametitle{Combiner assignation et opérations}

\begin{lstlisting}
>>> a = 3
>>> a = a + 1
3
\end{lstlisting}

Même résultat que:

\begin{lstlisting}
>>> a = 3
>>> a += 1
\end{lstlisting}

\vfill

Marche aussi avec \texttt{-=}, \texttt{*=} etc.

\end{frame}

\begin{frame}[fragile]
  \frametitle{Retour sur les strings}

\begin{lstlisting}

>>> text = "Je suis un message\nSur deux lignes")
>>> print(text)
Je suis un message
Sur deux lignes
\end{lstlisting}

\end{frame}

\begin{frame}[fragile]
  \frametitle{Concaténation implicite}

\begin{lstlisting}

  >>> text = "Je suis une " "longue" " string"
  >>> text
  'Je suis une longue string'
\end{lstlisting}

\end{frame}


\begin{frame}[fragile]
  \frametitle{Concaténer des strings (2)}
\begin{lstlisting}
message = (
    "ligne 1\n"
    "ligne 2\n"
)
\end{lstlisting}

Les parenthèse permettent d'aller à la ligne dans le code :)

\end{frame}


\begin{frame}[fragile]
  \frametitle{Répéter une string}

\begin{lstlisting}
>>> "argh " * 3
argh argh argh
\end{lstlisting}

\end{frame}


\begin{frame}[fragile]
  \frametitle{Faire une longue string sur plusieurs lignes}

\begin{lstlisting}
poeme = """
Ceci est un poeme

Qui contient "des quotes"
Et parle d'autre choses ...
"""
\end{lstlisting}

\begin{block}{Note}
Marche aussi avec des "triples-simple-quotes", mais c'est moins lisible :P
\end{block}
\end{frame}


\begin{frame}[fragile]
  \frametitle{Opérations sur les strings (1)}

\begin{lstlisting}
>>> text = "  bonjour! \n "
>>> text.strip()
"bonjour!"
\end{lstlisting}
Nouvelle syntaxe: notez le '.' entre la variable et la "fonction".
\end{frame}

\begin{frame}[fragile]
  \frametitle{Opérations sur les strings (2)}

Modification de la casse:

\begin{lstlisting}
>>> text = "Hello"
>>> text.upper()
"HELLO"

>>> text = "Au Revoir"
>>> text.lower()
"au revoir"

>>> text = "ceci est un titre"
>>> text.title()
"Ceci est un titre"
\end{lstlisting}

\end{frame}



\begin{frame}[fragile]
  \frametitle{Retour sur input()}
On peut afficher un message avant de lire l'entrée utilisateur.

\begin{lstlisting}
# A adapter
import random
secret = random.randint()

print("Devine le nombre auquel je pense")
while True:
    reponse = input("Ta reponse: ")
    response = int(response)
    ...
\end{lstlisting}


\end{frame}

\begin{frame}[fragile]
  \frametitle{Retour sur print()}

On peut spécifier le caractère de fin. \textbackslash n par défaut.

\begin{lstlisting}
# Dans hello.py
print("Bonjour", end=" ")
print("monde", end="!\n")
\end{lstlisting}

\begin{lstlisting}
$ python hello.py
Bonjour monde!
\end{lstlisting}

\end{frame}


\begin{frame}[fragile]
  \begin{beamercolorbox}[sep=8pt,center,shadow=true,rounded=true]{title}
    Fonctions
  \end{beamercolorbox}
\end{frame}


\begin{frame}[fragile]
  \frametitle{Sans arguments}

\begin{lstlisting}
def say_hello():
    print("Hello")

say_hello()
\end{lstlisting}

\vfill

Notez l'utilisation des parenthèses pour \emph{appeler} la fonction

\end{frame}


\begin{frame}[fragile]
  \frametitle{Définition simple}

\begin{lstlisting}
def add(a, b):
    return a + b

a = 1
b = 2
c = add(a, b)
print(c)
\end{lstlisting}

\end{frame}

\begin{frame}[fragile]
  \frametitle{Paramètres nommés}
\begin{lstlisting}
def greet(name, shout=False):
    result = "Hello, "
    result += name
    if shout:
        result += "!"
    return result

>>> greet("John")
'Hello, John'

>>> greet("Jane", shout=True)
'Hello, Jane!'
\end{lstlisting}


\end{frame}

\begin{frame}[fragile]
  \frametitle{Note}
\texttt{print()} est une fonction :)
\end{frame}


\begin{frame}[fragile]
  \begin{beamercolorbox}[sep=8pt,center,shadow=true,rounded=true]{title}
    Structures de données
  \end{beamercolorbox}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Créer une liste}
\begin{lstlisting}

>>> ma_liste = list()  # liste vide
>>> ma_liste = []  # aussi une liste vide
>>> ma_liste = [1, 2, 3] # trois entiers

\end{lstlisting}

\vfill

\begin{alertblock}{Note}
  \texttt{list()} est \textbf{aussi} une fonction :)
\end{alertblock}

\end{frame}

\begin{frame}[fragile]
  \frametitle{Listes hétérogènes}

On peut mettre des types différents dans une même liste:

\begin{lstlisting}
>>> pommes_et_carottes = [True, 2, "three"]
\end{lstlisting}

\vfill
Et même des listes dans des listes:

\begin{lstlisting}
>>> liste_de_liste = [[1, 2], ["one", "two"]]
\end{lstlisting}


\end{frame}


\begin{frame}[fragile]
  \frametitle{Connaître la taille d'une liste}
Avec la fonction \texttt{len()}:

\vfill

\begin{lstlisting}
>>> liste_vide = []
>>> len(liste_vide)
0
>>> autre_liste = [1, 2, 3]
>>> len(autre_liste)
3
\end{lstlisting}

\end{frame}



\begin{frame}[fragile]
  \frametitle{Indexer une liste}

\begin{lstlisting}

>>> liste = [1, 2, 3]
>>> liste[0]   # ca commence a zero
1
>>> liste[4]
IndexError
\end{lstlisting}

\vfill

Astuce: l'index maximal est \texttt{len(list) -1} ;)

\end{frame}

\begin{frame}[fragile]
  \frametitle{Modifer une liste}
\begin{lstlisting}
>>> liste = [1, 2, 3]
>>> liste[1] = 4
>>> liste
[1, 4, 3]
\end{lstlisting}

\end{frame}

\begin{frame}[fragile]
  \frametitle{Itérer sur les éléments d'une liste}
\begin{lstlisting}
names = ["Alice", "Bob", "Charlie"]
for name in names:
    print("Bonjour", name)

Bonjour Alice
Bonjour Bob
Bonjour Charlie
\end{lstlisting}

\end{frame}

\begin{frame}[fragile]
  \frametitle{Test de présence}

Avec le mot-clé \texttt{in}:

\vfill

\begin{lstlisting}
>>> fruits = ["pomme", "banane"]
>>> "pomme" in fruits
True
>>> "orange" in fruits
False
\end{lstlisting}

\end{frame}

\begin{frame}[fragile]
  \frametitle{Ajout d'un élément}
Avec \texttt{append()}

\begin{lstlisting}
>>> fruits.append("poire")
>>> fruits
['pomme', 'banane', 'poire']
\end{lstlisting}

\vfill

Notez le point entre `fruits` et `append`
\end{frame}


\begin{frame}[fragile]
  \frametitle{Autres opérations}

\begin{lstlisting}
>>> fruits = ["pomme", "poire"]

>>> fruits.insert(1, "abricot")
# ['pomme', 'abricot', 'poire']

>>> fruits.remove("pomme")
# ['abricot', 'poire']
>>> fruits.remove("pas un fruit")
Erreur!
\end{lstlisting}

\end{frame}



\begin{frame}[fragile]
  \frametitle{Dictionnaires}

Des clés et des valeurs:

\begin{lstlisting}
>>> mon_dico = dict() # dictionaire vide
>>> mon_dico = {} # aussi un dictionnaire vide

# deux cles et deux valeurs:
>>> scores = {"john": 24, "jane": 23}
>>> scores.keys()
["john", "jane"

>>> mon_dico.values()
[24, 23]
\end{lstlisting}

\end{frame}

\begin{frame}[fragile]
  \frametitle{Insertion}
\begin{lstlisting}
>>> scores = {"john": 10 }
>>> scores["john"] = 12  # John marque deux points
>>> scores["bob"] = 3  # Bob entre dans la partie
>>> scores["personne"]
KeyError
\end{lstlisting}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Fusion de dictionnaires}

\begin{lstlisting}
>>> s1 = {"john": 12, "bob": 2}
>>> s2 = {"bob": 3, "charlie": 4}
>>> s1.update(s2)
>>> s1
{"john": 12, "bob": 3, "charlie": 4}
\end{lstlisting}
\end{frame}


\begin{frame}[fragile]
  \frametitle{Destruction}

\begin{lstlisting}
>>> scores = {"john": 12, "bob": 23}
>>> scores.pop("john")
# {"bob': 23}
>>> scores.pop("personne")
KeyError
\end{lstlisting}

\end{frame}

\begin{frame}[fragile]
  \frametitle{Ensembles}
Des objets sans ordre ni doublons.

Création avec la fonction \texttt{set()}:

\begin{lstlisting}
>>> sac = set()
>>> sac = {}  # oups, c'est un dictionnaire vide!

>>> sac = {"one", "two"} # un set avec deux strings
>>> len(sac)  # len() fonctionne aussi avec les ensembles
>>> 2
\end{lstlisting}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Ajout d'un élement dans un ensemble}
\begin{lstlisting}
>>> sac = {"one", "two"}
>>> sac.add("three"}
# {"one", "two", "three"}
>>> sac.add("one")
# {"one", "two", "three"}  # pas de changement
\end{lstlisting}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Autres opérations}
\begin{lstlisting}
>>> s1 = {"one", "two"}
>>> s2 = {"one", "three"}
# {"two"}
\end{lstlisting}

Aussi:

\begin{itemize}
  \item \texttt{update()}
  \item \texttt{union()}
  \item \texttt{intersection()}
\end{itemize}
\end{frame}

\begin{frame}[fragile]

  \begin{beamercolorbox}[sep=8pt,center,shadow=true,rounded=true]{title}
    Jeu du pendu
  \end{beamercolorbox}

\end{frame}






\end{document}