Cours 2 Fonctions et séquences

Qu’est-ce qu’un ordinateur ?

Un ordinateur est un système composé de plusieurs éléments

• Processeur,
• Mémoire,
• Stockage,
• périphériques.

Processeur

Processeur

• Central Processing Unit (CPU)
• Exécute des instructions
• Programme = suite d’instructions
• Un programme manipule des données

Mémoire

Mémoire

• Random Access Memory (RAM)
• Contient le programme et les données utilisée par le processeur
• Rapide
• Taille limitée
• Volatile

Stockage

Stockage

• Solid State Drive (SSD) ou Hard Disk Drive (HDD) “disque dur”
• Contient des programmes et des données
• Lent
• Taille importante
• Persistant
• Organisé en fichiers et répertoires

Interpréteur

Le CPU exécute mes programmes Python ?

• Non, pas directement
• Python est un langage interprété.
• L’interpréteur Python (python.exe) exécute les programmes Python.
• python.exe est en langage machine et est exécuté par le CPU.
• L’interpréteur Python est indispensable pour exécuter un programmes Python !

Installation

Interpréteur:

• Version actuelle: 3.X.X
• Télécharger sur python.org
• Cocher la case “Add Python 3.X to PATH”

Éditeur:

• Pour écrire les fichiers contenant le texte de nos programmes
• Zed

Terminal

• pythion.exe n’a pas d’interface graphique. Il faut l’utiliser depuis un terminal.
• Powershell sous Windows, Terminal sous MacOS

> pwd
C:\Users\lur

> ls
Desktop Documents

> cd Documents

> pwd
C:\Users\lur\Documents

> python --version
Python 3.X.X

Python dans le terminal

• Mode interactif

> python
Python 3.X.X ...
Type "help", "copyright", "credits" or "license" for more
information.

>>> 1 + 1
2

>>> exit()

Python dans le terminal

• Mode script

hello.py

print('Hello World')

> python hello.py
Hello World

Fonctions

• Nous avons déjà vu plusieurs fonctions prédéfinies :

  print(), sqrt(), input(), int(), …

• Une fonction est une “boite noire” qui peut recevoir une ou plusieurs valeurs en arguments et peut renvoyer une valeur de sortie.

• Définir ses propres fonctions sert à deux choses :

  • Eviter de répéter plusieurs fois le même code.
  • Structurer les longs programmes en les découpant en petites parties simples.

Fonctions sans argument ni valeur de retour

• Voici la définition d’une fonction qui affiche la table de 7 :

def table7():
    n = 1
    while n <= 10:
        print(n, "x 7 =", n * 7)
        n += 1

• Une fois la fonction définie, on peut l’appeler autant de fois qu’on veut

# affichons 2 fois la table de 7
table7()
table7()

Une fonction n’est exécutée que lorsqu’on l’appelle

Fonctions sans argument ni valeur de retour

• La fonction table7() ne retourne rien :

x = table7() # affiche la table de 7
print(x)     # affiche None

• Comme elle ne prend pas de paramètre, elle fait toujours la même chose.

Fonctions avec arguments

• Les valeur(s) reçue(s) en paramètre(s) sont utilisée(s) lors de l’exécution de la fonction :

# définition de la fonction table().
def table(base):
    n=1
    while n <= 10:
        print(n, "x", base, "=", n * base)
        n += 1

# appels à la fonction table()
table(3)       # affiche la table de 3
table(base=8)  # affiche la table de 8
a = 42
table(a)       # affiche la table de 42

Fonctions avec arguments

• On peut aussi avoir plusieurs arguments :

# définition de la fonction table().
def table(base, start, length):
    n = start
    while n < start + length:
        print(n, "x", base, "=", n * base)
        n += 1

# appels à la fonction table()
table(3, 1, 10)
table(base=8, start=5, length=2)

Fonctions avec arguments

• On peut aussi avoir des valeurs par défaut pour les arguments :

# définition de la fonction table().
def table(base, start=1, length=10):
    n = start
    while n < start + length:
        print(n, "x", base, "=", n * base)
        n += 1

# appels à la fonction table()
table(8, 5, 2)
table(8)
table(8, 5)
table(8, length=2)

Fonctions avec valeur de retour

• Le mot-clé return permet de définir la valeur de retour :

# définition de la fonction multiply()
def multiply(a, b):
    return a * b

res = multiply(7, 9)   # appel à la fonction. N'affiche rien.
print(res)             # affiche 63
print(multiply(6, 7))  # affiche 42

Fonctions avec valeur de retour

• On peut utiliser une fonction dans le corps d’une autre :

# définition de multiply()
def multiply(a, b):
    return a * b

# définition de table()
def table(base, start=1, length=10):
    n = start
    while n < start + length:
        # utilisation de multiply()
        print(n, "x", base, "=", multiply(n, base))
        n += 1

# appel à la fonction table()
table(5, length=3)

Fonctions avec valeur de retour

• Lorsque le mot-clé return est rencontré, la fonction s’arrête et le programme se poursuit après l’appel. Cela permet quelques simplifications

def abs(x):
    if x < 0:
        return -x
    else:
        return x

# version simplifiée
def abs(x):
    if x < 0:
        return -x
    return x

Variables locales et globales

• Dès que l’on a des fonctions, il faut comprendre la différence entre variables locales et globales.
• Une variable globale est définie en dehors de toute fonction. Elle est accessible dans l’ensemble du programme.
• Une variable locale est définie dans une fonction. Elle est accessible uniquement dans cette fonction.

def tvac(amount):
    n = 1 + interest / 100
    return amount * n

interest = 21
n = 25
r = tvac(n)
print(r)

Variables locales et globales

def tvac(amount):
    n = 1 + interest / 100
    return amount * n

interest = 21
n = 25
r = tvac(n)
print(r)

Variables locales et globales

def tvac(amount):
    n = 1 + interest / 100
    return amount * n

interest = 21
n = 25
r = tvac(n)
print(r)

Variables locales et globales

def tvac(amount):
    n = 1 + interest / 100
    return amount * n

interest = 21
n = 25
r = tvac(n)
print(r)

Variables locales et globales

def tvac(amount):
    n = 1 + interest / 100
    return amount * n

interest = 21
n = 25
r = tvac(n)
print(r)

Variables locales et globales

def tvac(amount):
    n = 1 + interest / 100
    return amount * n

interest = 21
n = 25
r = tvac(n)
print(r)

Variables locales et globales

def tvac(amount):
    n = 1 + interest / 100
    return amount * n

interest = 21
n = 25
r = tvac(n)
print(r)

Variables locales et globales

def tvac(amount):
    n = 1 + interest / 100
    return amount * n

interest = 21
n = 25
r = tvac(n)
print(r)

Variables locales et globales

def tvac(amount):
    n = 1 + interest / 100
    return amount * n

interest = 21
n = 25
r = tvac(n)
print(r)

Variables locales et globales

def tvac(amount):
    n = 1 + interest / 100
    return amount * n

interest = 21
n = 25
r = tvac(n)
print(r)

Que va-t-il s’afficher ?

def fun():
    a = 12

fun()

print(a)

Que va-t-il s'afficher ?

def fun():
    a = 12

fun()

print(a)

Que va-t-il s'afficher ?

def fun():
    a = 12

fun()

print(a)

Que va-t-il s'afficher ?

def fun():
    a = 12

fun()

print(a)

Que va-t-il s'afficher ?

def fun():
    a = 12

fun()

print(a)

Que va-t-il s'afficher ?

def fun():
    a = 12

fun()

print(a)

Que va-t-il s'afficher ?

def fun():
    a = 12

fun()

print(a)

Variables locales et globales

• Une variable locale est inaccessible hors de la fonction où elle est définie

def fun():
    a = 12 # variable locale à fun

fun()

print(a) # inaccessible ici

Que va-t-il s’afficher ?

def fun():
    print(a)

a = 12
fun()

Que va-t-il s'afficher ?

def fun():
    print(a)

a = 12
fun()

Que va-t-il s'afficher ?

def fun():
    print(a)

a = 12
fun()

Que va-t-il s'afficher ?

def fun():
    print(a)

a = 12
fun()

Que va-t-il s'afficher ?

def fun():
    print(a)

a = 12
fun()

Que va-t-il s'afficher ?

def fun():
    print(a)

a = 12
fun()

Que va-t-il s'afficher ?

def fun():
    print(a)

a = 12
fun()

Variables locales et globales

• Une variable globale est accessible partout :

def fun():
    print(a) # accès à la variable 'a' globale

a = 12
fun()

Que va-t-il s’afficher ?

def fun():
    a = 42
    print("dans fun :", a)

a = 12
fun()

print("en dehors de fun :", a)

Que va-t-il s'afficher ?

def fun():
    a = 42
    print("dans fun :", a)

a = 12
fun()

print("en dehors de fun :", a)

Que va-t-il s'afficher ?

def fun():
    a = 42
    print("dans fun :", a)

a = 12
fun()

print("en dehors de fun :", a)

Que va-t-il s'afficher ?

def fun():
    a = 42
    print("dans fun :", a)

a = 12
fun()

print("en dehors de fun :", a)

Que va-t-il s'afficher ?

def fun():
    a = 42
    print("dans fun :", a)

a = 12
fun()

print("en dehors de fun :", a)

Que va-t-il s'afficher ?

def fun():
    a = 42
    print("dans fun :", a)

a = 12
fun()

print("en dehors de fun :", a)

Que va-t-il s'afficher ?

def fun():
    a = 42
    print("dans fun :", a)

a = 12
fun()

print("en dehors de fun :", a)

Que va-t-il s'afficher ?

def fun():
    a = 42
    print("dans fun :", a)

a = 12
fun()

print("en dehors de fun :", a)

Que va-t-il s'afficher ?

def fun():
    a = 42
    print("dans fun :", a)

a = 12
fun()

print("en dehors de fun :", a)

Variables locales et globales

• Lorsqu’une variable locale porte le même nom qu’une globale, priorité à la locale

def fun():
    a = 42
    print("dans fun :", a)     # 'a' locale masque 'a' globale

a = 12
fun()
print("en dehors de fun :", a) # seule 'a' globale accessible ici

Que va-t-il s’afficher ?

def fun():
    print("globale? :", a)
    a = 42

a = 12
fun()

Que va-t-il s'afficher ?

def fun():
    print("globale? :", a)
    a = 42

a = 12
fun()

Que va-t-il s'afficher ?

def fun():
    print("globale? :", a)
    a = 42

a = 12
fun()

Que va-t-il s'afficher ?

def fun():
    print("globale? :", a)
    a = 42

a = 12
fun()

Que va-t-il s'afficher ?

def fun():
    print("globale? :", a)
    a = 42

a = 12
fun()

Que va-t-il s'afficher ?

def fun():
    print("globale? :", a)
    a = 42

a = 12
fun()

Variables locales et globales

• Priorité à la locale même avant sa définition dans la fonction

def fun():
    # ici 'a' local existe déjà mais n'a pas encore de valeur

    print("globale? :", a)  # erreur: accès à 'a' local sans valeur
    a = 42

a = 12
fun()

Les séquences

• Les séquences sont des types de valeur :

  • Les chainés de caractères (str)

    a = "hello"      # littéral
    b = 2 * a + "!!" # expression
    c = '6' + '7'    # '67'
    

  • Les listes (list)

    a = [1, 2, 3, 4]    # littéral
    a = [1, 2] + [3, 4] # expression
    

Les séquences

• Les chaînes de caractères et les listes sont des séquences représente une suite ordonnée de valeurs
• Une séquence stocke zéro, une ou plusieurs valeurs
• Les valeurs d’une séquence possèdent un numéro d’ordre dans la séquence l’indice de l’élément

l = [2, 42, 3.1416, 34]       # 'l' est une séquence de valeurs
s = "Le Python, c'est bon !"  # 's' est une séquence de caractères

Opérations sur les séquences

• L’opérateur + entre deux séquences permet de créer une nouvelle séquence contenant les deux opérandes bout-à-bout On appelle cette opération la concaténation

• L’opérateur * entre un entier n et une séquence permet de créer une nouvelle séquence contenant n fois la séquence de départ.

f = [1, 2] + [3, 4]  # [1, 2, 3, 4]
g = 3 * "hello"      # "hellohellohello"

Test d’appartenance

• L’opérateur in permet de vérifier si une valeur se trouve dans une séquence. Ou si une sous-chaine est dans une chaine de caractères

L = [1, 2, 42, 3]
if 42 in L:
    print("OK")

S = 'Python'
if 'hon' not in S:
    print("KO")

Accès aux éléments

• Il est possible d’accéder aux éléments individuels Pour cela, on utilise les crochets []
• Chaque éléments est repéré par son numéro d’ordre Le numéro d’ordre est appelé indice
• Les indices commencent à zéro Les indices négatifs permettent d’indiquer un élément en partant de la fin de la séquence

Le slicing

• Il est possible de référencer une sous-séquence c-à-d une “tranche” de la séquence. On sépare les deux indices délimitant la tranche par un “:”
• La tranche [m:n] référence la sous-séquence qui va du mième élément (compris) au nième élément (non-compris).
• Si on omet le premier indice, la tranche démarre au début de la séquence Idem avec le deuxième indice et la fin de la séquence

s = "Le Python, c'est bon !"
print(s[3:9])   # affiche 'Python'
print(s[17:-2]) # affiche 'bon'
print(s[17:])   # affiche 'bon !'
print(s[:9])    # affiche 'Le Python'

• Un slice produit une nouvelle séquence

La longueur d’une séquence

• Il est possible de connaitre le nombre d’éléments contenus dans une séquence grâce à la fonction len()

s = "Le Python, c'est bon !"
print(len(s)) # affiche 22

Un str est immuable

• On peut modifier un élément d’une liste

s = [1, 2, 42, 4, 5]
s[2] = 3
print(s)   # affiche [1, 2, 3, 4, 5]

• Une fois créée, une chaine de caractères ne peut plus être modifiée

s = "Le Python, c'est bon !"
s[17] = "c"     # provoque une erreur !

Liste

• Une liste est une séquence permettant de stocker tous types de valeurs

numbers = [1, 2, 3, 4, 5]
words = ["I", "love", "Python"]
mixed = [1, "duck-billed platypus", True]
nested = [[1, 2], [3, 4]]

• On peut supprimer un élément d’une liste.

numbers = [1, 2, 2, 3, 4, 5]
del(numbers[1])
print(numbers) # affiche [1, 2, 3, 4, 5]

Ajout d’éléments

• On peut ajouter un élément à la fin d’une liste.

numbers = [1, 2, 3, 4, 5]
numbers.append(6)
print(numbers)  # affiche [1, 2, 3, 4, 5, 6]

• On peut insérer un élément à un indice précis.

numbers = [1, 2, 4, 5]
numbers.insert(2, 3)  # insère 3 à l'indice 2
print(numbers)        # affiche [1, 2, 3, 4, 5]

Attention aux copies

• Que va-t-il s’afficher ?

words = ['I', 'like', 'Python']
mots = words
mots[1] = 'love'
print(words)
print(mots)

Que va-t-il s'afficher ?

words = ['I', 'like', 'Python']
mots = words
mots[1] = 'love'
print(words)
print(mots)

Que va-t-il s'afficher ?

words = ['I', 'like', 'Python']
mots = words
mots[1] = 'love'
print(words)
print(mots)

Que va-t-il s'afficher ?

words = ['I', 'like', 'Python']
mots = words
mots[1] = 'love'
print(words)
print(mots)

Que va-t-il s'afficher ?

words = ['I', 'like', 'Python']
mots = words
mots[1] = 'love'
print(words)
print(mots)

Que va-t-il s'afficher ?

words = ['I', 'like', 'Python']
mots = words
mots[1] = 'love'
print(words)
print(mots)

Que va-t-il s'afficher ?

words = ['I', 'like', 'Python']
mots = words
mots[1] = 'love'
print(words)
print(mots)

Attention aux copies

• Les listes sont manipulées via des références

words = ['I', 'like', 'Python']
mots = words     # ici on ne copie que la référence
mots[1] = 'love'
print(words)
print(mots)

Attention aux copies

• Il explicitement créer une nouvelle liste

words = ['I', 'like', 'Python']
mots = list(words)
mots[1] = 'love'
print(words)
print(mots)

Que va-t-il s'afficher ?

words = ['I', 'like', 'Python']
mots = list(words)
mots[1] = 'love'
print(words)
print(mots)

Que va-t-il s'afficher ?

words = ['I', 'like', 'Python']
mots = list(words)
mots[1] = 'love'
print(words)
print(mots)

Que va-t-il s'afficher ?

words = ['I', 'like', 'Python']
mots = list(words)
mots[1] = 'love'
print(words)
print(mots)

Que va-t-il s'afficher ?

words = ['I', 'like', 'Python']
mots = list(words)
mots[1] = 'love'
print(words)
print(mots)

Que va-t-il s'afficher ?

words = ['I', 'like', 'Python']
mots = list(words)
mots[1] = 'love'
print(words)
print(mots)

Que va-t-il s'afficher ?

words = ['I', 'like', 'Python']
mots = list(words)
mots[1] = 'love'
print(words)
print(mots)

Que va-t-il s'afficher ?

words = ['I', 'like', 'Python']
mots = list(words)
mots[1] = 'love'
print(words)
print(mots)

Créer une copie d’une liste

• On peut imaginer plusieurs moyen de créer explicitement une nouvelle liste

numbers = [1, 2, 3, 4, 5]
copy1 = list(numbers)  # la fonction 'list()' crée une liste
copy2 = numbers * 1    # le '*' crée une liste
copy3 = numbers + []   # le '+' crée une liste
copy4 = numbers[:]     # le slice crée une liste

Passage par référence

• Le même phénomène se produit lors du passage d’une liste à une fonction

def more_love(l):
  l[1] = "love"

words = ['I', 'like', 'Python']
fun(words)

print(words)

Passage par référence

def more_love(l):
  l[1] = "love"

words = ['I', 'like', 'Python']
fun(words)

print(words)

Passage par référence

def more_love(l):
  l[1] = "love"

words = ['I', 'like', 'Python']
fun(words)

print(words)

Passage par référence

def more_love(l):
  l[1] = "love"

words = ['I', 'like', 'Python']
fun(words)

print(words)

Passage par référence

def more_love(l):
  l[1] = "love"

words = ['I', 'like', 'Python']
fun(words)

print(words)

Passage par référence

def more_love(l):
  l[1] = "love"

words = ['I', 'like', 'Python']
fun(words)

print(words)

Passage par référence

def more_love(l):
  l[1] = "love"

words = ['I', 'like', 'Python']
fun(words)

print(words)

Passage par référence

def more_love(l):
  l[1] = "love"

words = ['I', 'like', 'Python']
fun(words)

print(words)

Boucler dans une séquence

• Pour parcourir les éléments d’une séquence, on peut utiliser une boucle while.

numbers = [2, 5, 7, 2, 1]
i = 0
while i < len(numbers):
    print(numbers[i])
    i += 1     # raccourci pour i = i + 1

• On peut aussi utiliser la boucle for ... in Où n prendra successivement chaque valeur de numbers

numbers = [2, 5, 7, 2, 1]
for n in numbers:
    print(n)

• Cela marche aussi avec les chaines de caractères.

Intervalles

• Un intervalle est une séquence numérique logique.

• Créé avec la fonction range()

range(5)         # [0, 1, 2, 3, 4]
range(1, 5)      # [1, 2, 3, 4]
range(1, 8, 2)   # [1, 3, 5, 7]
range(5, 0, -1)  # ???

• Souvent utilisé dans les boucles for

for i in range(5):
    print(i)

• Un intervalle n’est pas une liste Mais on peut créer une liste à partir d’un intervalle avec la fonction list()

Example

• squares() est une fonction qui retourne une liste contenant les n premiers nombres naturels au carré.

def squares(n):
    res = []
    for i in range(n):
        res.append((i+1)**2)
    return res