Introduction à Python

PG121 - Introduction à Python

Frédéric Herbreteau, Bordeaux INP/LaBRI (frederic.herbreteau@bordeaux-inp.fr)

Le langage Python

  • créé en 1991 par Guido van Rossum (Python 3.0 en 2008)
  • principales caractéristiques:
    • interprété, multiparadigme et multiplateforme
    • programmation impérative structurée, fonctionnelle et orientée objet
    • typage dynamique fort, gestion automatique de la mémoire, exceptions
    • permet de prototyper très rapidement
  • très nombreuses applications grâce à une vaste bibliothèque de modules: IA, calcul quantique, DevOps, calcul scientifique, analyse de données, etc

Langage de script

Avantages

  • syntaxe simple: typage implicite, abstraction des détails techniques
  • pas de compilation
  • portable sur d’autres systèmes: il suffit d’avoir l’interpréteur

Inconvénients

  • découverte des erreurs à l’exécution
  • exécution lente (pas adapté à tous les contextes)

REPL (Read-Eval-Print-Loop)

  • on travaille avec Python 3.9.X
  • la version 3.9.18 est installée sur les ordinateurs de l’école
$ 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.
>>> print("hello world")
hello world
>>> quit()

Types, valeurs et variables

Types et valeurs

  • Types: bool, int, float, str, list, tuple, set, dict, NoneType,…
  • Toutes les valeurs sont des objets
>>> type(3)
<class 'int'>
>>> type(3.930)
<class 'float'>
>>> type({1,2,3})
<class 'set'>
>>> type({1: 'ab', 2: 'cde'})
<class 'dict'>
>>> type([1,2,3])
<class 'list'>
>>> type((1,2,3))
<class 'tuple'>
>>> type(None)
<class 'NoneType'>

Expressions

  • opérateurs arithmétiques: +, -, *, /, //, %, **
  • comparateurs: <, >, <=, >=, ==, !=
  • opérateurs booléens: and, or, not
>>> 2 / 3
0.6666666666666666
>>> 2 // 3
0
>>> 2 % 3
2
>>> (2 < 3) and not(2 // 3)
True
>>> True + 1
2

Conversion de type

  • conversion par construction d’un nouvel objet du type souhaité
>>> float(3)
3.0
>>> bool(3)
True
>>> bool(0)
False
>>> l = [1,2,3]
>>> set(l)
{1, 2, 3}
>>> dict(l)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot convert dictionary update sequence element #0 to a sequence

Variables

  • une variable conserve une référence sur une valeur
  • les variables ne sont pas typées
>>> x=3
>>> print(x)
3
>> type(x)
<class 'int'>
>>> x="abc"
>>> print(x)
abc
>>> type(x)
<class 'str'>

Convention: noms en minuscules, informatifs, et snake case (_)

Références et partage d’objets

  • plusieurs variables peuvent référencer le même objet
>>> a = []
>>> b = a
>>> a.append(1)
>>> b
[1]

>>> t = [[0] * 4] * 3
>>> t
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
>>> t[0] is t[1] # t[0] et t[1] sont-ils des alias?
True
>>> t[0][0] is t[0][1] # t[0][0] et t[0][1] sont-ils des alias?
True
>>> t[0][0] = 1
>>> t
[[1, 0, 0, 0], [1, 0, 0, 0], [1, 0, 0, 0]]

Opérateurs et méthodes

  • les opérateurs appellent les méthodes correspondantes des objets
>>> 3 + 2
5
>>> int(3).__add__(2)
5
>>> l = [1, 2, 3]
>>> l + 4
[1,2,3,4]
>>> l.__add__([4])
[1,2,3,4]
>>> 'abc' + 'de'
'abcde'
>>> 'abc'.__add__('de')
'abcde'

Manipulation des objets

  • lister les méthodes d’un objet avec dir
>>> x = 'abc'
>>> dir(x)
>>> x.upper()
'ABC'
>>> x = 3
>>> dir(x)
>>> x.bit_count()
2
  • documentation avec help
help(x)
help(x.bit_count)

Chaînes de caractères

  • séquences de caractères délimitées par " " ou par ' '
  • chaînes multi lignes:
>>> """ Ceci
...    est
... une longue ligne"""
' Ceci\n   est\nune longue ligne'
  • chaînes formatées: f" " ou f' '
>>> f'{x} est représentée sur {x.bit_count()} bit(s)'
'3 est représentée sur 2 bit(s)'

Instructions de base

Entrées/sorties élémentaires

  • affichage sur la sortie standard
>>> print('abc')
abc
  • lecture depuis l’entrée standard
>>> name = input('Entrez votre nom: ')
Entrez votre nom: John
>>> print('Bonjour', name, '!')
Bonjour John !
>>> print(f'Bonjour {name}!')
Bonjour John!

Branchement conditionnel

  • instruction if ... elif ... else ...
if s.isupper():
    print('Mot écrit en majuscules')
    print(f'Le mot {s} en minuscules: {s.lower()}')
elif s.islower():
    print('Mot écrit en minuscules')
    print(f'Le mot {s} en majuscules: {s.upper()}')
else:
    print('Mot mélangeant majuscules et minuscules')

ATTENTION: l’indentation est significative. Elle marque qu’un bloc d’instructions se situe à l’intérieur d’une autre instruction

Boucles

  • while répétition conditionnelle
i = 0
while i < 5:
    print(i)
    i += 1
  • for parcours des éléments d’une liste, d’un ensemble, … (d’un itérable)
for i in [0,1,2,3,4]:
    print(i)

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

for c in 'hello':
    print(c)

Fonctions

  • Définition:
def sum(a, b):
    return a + b

def factorial(n):
    return 1 if n == 0 else n * factorial(n - 1)
  • Utilisation:
>>> sum(4, 5)
9
>>> sum('ab', 'cde')
'abcde'
>>> sum('ab', 3)
TypeError: can only concatenate str (not "int") to str
>>> factorial(5)
120

Portée et visibilité des variables

>>> x = 0
>>> def f():
...     x = 1
...     print(x)
... 
>>> f()
1
>>> x
0
  • utiliser global pour référencer une variable globale
>>> def g():
...     global x
...     x = 1
>>> g()
>>> x
1