Découverte du langage Python

Environnement de travail

Ouvrir un terminal et lancer la commande: python.

$ python
Python 3.9.18 (main, Sep  7 2023, 00:00:00) 
[GCC 11.4.1 20230605 (Red Hat 11.4.1-2)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

On quitte l’interpréteur avec quit() ou Ctrl+D.

Si vous travaillez sur votre propre ordinateur, installez une version 3.9 ou supérieure de Python.

Lien vers la documentation de référence de Python 3.

Les bases du langage Python

Les exercices ci-dessous sont réalisés dans l’interpréteur. Tapez les commandes et expliquez les résultats.

Nombres

x = 3
type(x)
y = 0.2
type(y)

3 / 2
3 // 2
5 % 3
5 ** 2

Quel le type de 3 / 2? Et celui de 3 // 2?

Chaînes de caractères

x = "Coucou le monde"
type(x)
y = 'Hello, world'
type(y)

'nde' in x
'nde' in y

len(x)
x[7]
x[-1]
x[-2]
x[7:9]
x[::-1]

Quel est le type de x[7]? Et celui de x[7:9]?

L’opérateur [] retourne un slice. Quels sont les trois paramètres de []?

x.upper()
'mangé'.upper()
x.count('ou')
'aaaa'.count('aa')
x.split(' ')
'   text '.strip()
'Foo'.rjust(10, ' ')
x.replace(' ', '-')

Comment obtenir la chaîne '.......Foo' à partir de la chaîne 'Foo'?

nom = 'Ben'
age = 5
f'Bonjour, {nom}, tu as {age} ans'

def make_filename(nom, age):
    return f'{nom}_{age}.jpg'

make_filename('Alice', '2')

dir(nom)

help(str)   # ou help(nom)

Listes

li = ['vélo', 1, 'fin']
li
len(li)

li[0]
li[-1]
li[::2]
li[1:]
li[::-1]
li[2][1]

Quel est le type de li[0]? Celui de li[1:]?

li[1] = 'volant'
li

Expliquer ce que fait l’instruction li[1] = 'volant'

li.append('test')
li
[1,2,3] + [4,5,6]
[0, 1] * 4
"fin" in li
", ".join(li)

Ensembles

s = {'Bordeaux', 'Marseille', 'Rennes'}
s
'Paris' in s
'Londres' in s

s[0]

Expliquez le résultat affiché par l’interpréteur.

s.add('Toulouse')
s

s.union({'Strasbourg', 'Nancy'})

Quel opérateur permet de calculer l’union de deux ensembles? Et l’intersection?

list(s)
set(li)

Que font les deux instructions ci-dessus?

Tuples

t = ('Bordeaux', 33)
t[0], len(t), t[-1]
t[0] = 'Libourne'

Quel est le type de t[0], len(t), t[-1]?

t.append(2)
t + ('Nouvelle Aquitaine',)

Pourquoi faut-il une virgule après 'Nouvelle Aquitaine'?

tuple(s)

Dictionnaires

bdx = {'ville': 'Bordeaux', 'département': 33}
bdx
'ville' in bdx
bdx['ville']
'Bordeaux' in bdx
bdx['région']
'région' in bdx

bdx.keys()
'Bordeaux' in bdx.keys()
bdx.values()
'Bordeaux' in bdx.values()
bdx_items = bdx.items()
bdx_items
('ville', 'Bordeaux') in bdx_items

Quel est le type de bdx_items? Quel est le type des éléments dans bdx_items?

bdx['région'] = 'Nouvelle Aquitaine'
bdx
bdx_items

Expliquer l’affichage produit par la dernière commande (cf. dict-views)

bdx['pays']
bdx.get('pays')
bdx.get('pays', 'France')

À l’aide de la commande help, expliquez le résultat affiché par dernière commande.

score = {}
score[s] = 100
score[li] = 100
score[bdx] = 100
score[t] = 100
score

Quel est le type de score? Quelle propriété doit avoir le type des clés?

if

li

if 'vélo' not in li:
    li.insert(0, 'vélo')
elif 'moto' not in li:
    li.append('moto')
else:
    li.remove('fin')
    
li

Exécutez le if ci-dessus trois fois en affichant la valeur de li à chaque fois, et expliquez le résultat affiché.

while

v = li[:2]
while len(v) < 4:
    v.append(v[0]+v[-1])
v

Quelle est la valeur de v avant la boucle? Que valent v[0] et v[-1] à chaque itération de la boucle?

for

for x in li:
    print(f'element de li: {x}')

for i, x in enumerate(li):
    print(f'li[{i}] = {x}')

Que fait enumerate? (cf. documentation de enumerate)

c = []
for i in range(10):
    c.append(li[i % len(li)])

c

Définitions en compréhension

li
[len(x) for x in li]
sum([len(x) for x in li])
[x for x in li if x[0] == "v"]
{(x,len(x)) for x in li}
{x: len(x) for x in li}
{x: len(x) for x in li if 'o' in x}

Traduire en français chacune des définitions ci-dessus. Donner le type de chaque objet créé par ces définitions, ainsi que le type des objets qu’il contient.

l = [[0] * 4] * 3

On a vu en cours que la déclaration de l ci-dessus créé une liste qui contient 3 références vers une même liste contenant elle-même 4 références vers une entier de valeur 0:

l->[x,x,x] avec x->[y,y,y,y] avec y->0

Alors, l’affectation l[0][0]=1 modifie la liste x en faisant pointer son premier élément vers un entier contenant 1:

l->[x,x,x] avec x->[z,y,y,y] avec y->0 et z->1

Comment faut-il déclarer l pour que l[0][0]=1 ne modifie que le premier élément de la première sous-liste de l? (en d’autres termes: on veut que chaque entrée de l référence un entier distinct).

Entrées / sorties

Fichiers

open('data.txt')

Expliquez l’erreur observée (cf. help(open)).

f = open('data.txt', mode='w') 
f
f.write('Hello world!')
f.close()
f.closed

À quoi correspond le nombre affiché après la commande write (cf. help(f.write))?

with open('data.txt') as f:
    content = f.readlines()
    print(content)

Quel est le type de content? Que fait l’instruction with ... as ...?

Flux du processus

print('un', 2, 3.0)

import sys
print('Erreur!', file=sys.stderr)

line = sys.stdin.readline()
line

Fonctions

def double(x):
    return x * 2

double(3)
double('a')
double([1,2,3])
double({1,2,3})

Modifier la fonction double afin qu’elle retourne le double de x lorsque x est de type int, et None sinon (cf. isinstance).

def hello(name, greeting='Hello'):
    return f'{greeting}, {name}!'

hello('John')
hello('John', greeting='Bonjour')
hello('John', 'Bonjour')   # à éviter

Donnez deux raisons pour lesquelles la dernière forme est à éviter.

def sum_power(x, y, power_x=2, power_y=2):
    return x**power_x + y**power_y
        
sum_power(3)
sum_power(3, 4)
sum_power(3, 4, power_y=3)