Aller au contenu

Tour du langage Python

Nous allons faire un tour du langage Python sans forcément tout couvrir car il est très riche en fonctionnalités.

Warning

Comme le langage Python évolue apporte fréquemment des amélioration et simplifications, il se peut que les exemples de code vues ici soient différents de ce que vous trouvez dans la littérature.

Premiers pas

  • Ouvrir VSCode dans un dossier vierge
  • Créer un fichier hello.py contenant print("Hello")
  • Lancer la commande python hello.py
  • Un peu de code pour avoir une idée du langage
# This is a comment
a = 10
print(a)
a = "hello"
print(a)
print("The value of a is", a)

a = "22"
b = 10
# erreur car python est fortement typé et n'autorise pas l'addition sur deux types différents
# c = a + b
# print("a + b", c)
print(a + str(b), int(a) + b)

if b == 10:
    print(b)
    print(b)
else:
    print("b différent de 10 / b is not 10")


def add(x, y):
    print(f"addition of {x} and {y}")
    return x + y


# A function can be documented with optional type hints and a docstring
def multiply(x: int, y: int) -> int:
    """
    Multiply x and y
    Parameters:
        x: first number
        y: second number
    Returns:
        the result of the multiplication
    """
    return x * y


print(add(-810, b))
f = add
print(f(-810, b))

print("range demo: générateur / generator")
r = range(10)
print(r)
print("Start value", r.start, "pas / step", r.step)

print("range loop")
for item in r:
    print(item)


for item in range(10):
    print(item)

for i in range(10, 21, 3):
    print(i)

message = "I ♥️ Python"
for letter in message:
    print(letter)

for i in range(len(message)):
    print(i, message[i])

Quelques caractéristiques

  • Python est dynamiquement typé: une variable peut changer de type durant son utilisation (contraire de statiquement typé)
  • Python est fortement typé: chaque donnée a un type et ne change pas de façon implicite
  • Python supporte la programmation orienté objet et fonctionnelle
  • Les indentations sont utilisées pour définir les blocs de code (au lieu des {} accolades qu'on trouve usuellement dans d'autres langages)
    • La taille de l'indentation doit être consistance au sein du même block
    • Il est recommandé d'avoir une indentation de 4 espaces
  • Il existe plusieurs conventions de programmation mais qui on beaucoup de points communs. La convention officielle est appelée pep 8. Voici quelques règles et recommandations:
    • Snake case pour les fonctions. Ex. find_student()
    • Utiliser des espaces pour définir l'indentation et éviter d'utiliser la touche tab

Types et opérations de base

  • Nombres entier (int), réel (float) et complexes (complex)
  • Chaines de caractères (String)
  • Valeurs booléennes et opérateurs booléens and, or et not
  • Opérateurs de comparaison >, <, ... qui retournent un booléen
    • is permet de tester l'identité entre deux objets. Son résultat peut être personnalisé.
    • == est parfois équivalent à is
  • Comme python est fortement type, convertir un valeur vers un autre type devra se faire explicitement int(), float(), complex(), str(), ...
# https://www.w3schools.com/python/python_operators.asp

x = 15
print("puissance", x**10, "partie entière de la division", x // 4)

# * a plus de priorité par rapport à +
print(1 + 2 * 3)

print(10 < x and x < 20, "est equivalent à", 10 < x < 20)

c = ((i, j) for i in (True, False) for j in (True, False))

for i, j in c:
    print(i, "and", j, i and j)
    print(i, "or", j, i or j)
    print("not", i, not j)

print(10 in range(50))
print(10 in range(0, 50, 3))
print(10 not in [1, 2, 10, 33])

# && -> and (attention & a un comportement différent)

Exceptions

def f_that_throws(b):
    if b:
        return "Success"
    else:
        raise Exception()


print(f_that_throws(True))
# Crash si on n'attrape pas l'exception
# print(f_that_throws(False))

try:
    print(f_that_throws(True))
    print("Before")
    f_that_throws(False)
    print("After")
except Exception:
    print("Oups")

Collections standards

  • Collection: type (ou structure) de données qui permet de gérer un ensemble de données
  • Python propose plusieurs types intégrés de collections
  • Voici les 4 types les plus usuels: list, dict, set et tuple
# List: éléments ordonnées. Chauqe élément est défini par sont indice
numbers = [3, 4, -3, "hello", True, 390]
numbers.append(10)
numbers.append(100)
numbers.remove(3)
print(numbers)
print(numbers[0], numbers[-1], numbers[-2])

print(numbers[0:3], numbers[:3], numbers[1:5])
print(numbers[-3:-1], numbers[2:])

for number in numbers:
    print(number)

for i in range(len(numbers)):
    print(i, numbers[i])

# Dictionnaires: élements identidifiés par une clé (on parle aussi de couples clé/valeur)
pokemon1 = {"name": "Pikachu", "hp": 10, "type": "Thunder", 5: "une valeur"}
print(
    pokemon1,
    pokemon1["name"],
    pokemon1["type"],
    pokemon1[5],
    "name" in pokemon1,
    "surname" in pokemon1,
)

for key, value in pokemon1.items():
    print(key, value)

# Set (ensemble) : élements non ordonnées et uniques
messages = {"hello", "world", 2023}
print(messages, "hello" in messages, 2024 in messages)
messages.add(2023)
print(messages)

for message in messages:
    print(message)

# Tuple : éléments ordonnées immutable (on ne peut ajouter ou supprimer d'éléments). On peut le considérer comme une liste immutable
n1 = (12, 34, 55, 33)
print(n1, n1[2:])

for item in n1:
    print(item)

for i in range(len(n1)):
    print(i, n1[i])

La compréhension des listes, dictionnaires et ensembles

  • Permet de créer une nouvelle liste, dictionnaire ou ensemble à partir d'une collection existante
  • Permet de remplacer certains traitements qu'on aurait dû faire avec les boucles
  • Pour une liste [f(index) for index in input_seq if condition] (input_seq est une liste, tuple ou toute séquence itérable avec indice)
  • Pour une liste [f(item) for item in input_seq if condition] (input_seq est une liste, tuple ou toute séquence itérable)
  • Pour un dictionnaire {f_key(item):f_value(item) for item in input_seq if condition} (input_seq est une séquence itérable)
  • f, f_key, f_value sont des fonctions quelconques
  • La partie if condition est optionnelle
  • Il est aussi possible de remplacer les boucles imbriquées par une seule compréhension
items = [0, 1, 2, 3, 4]

# Double de chaque élément
double_items_1 = []
for item in items:
    double_items_1.append(item * 2)
print("double_items_1", double_items_1)

# Transformer (to map en Anglais) avec les compréhensions
results = [item * 2 for item in items]
print(results)
print([item * 2 for item in items])
# puissance 4 des entier entre -2 et 9 avec un pas de 2
print([item**4 for item in range(-2, 10, 2)])

# Filtrage
# Garder uniquement les éléments pairs
items = [9, 22, -2, 11, 1232, 2323]
print([item for item in items if item % 2 == 0])

# Equivalent avec un boucle for
results = []
for item in items:
    if item % 2 == 0:
        results.append(item)
print(results)

# Garder uniquement les éléments pairs et les multiplier par 3
print([item * 3 for item in items if item % 2 == 0])

messages = ["Hello", "J'aime", "Python"]
print([len(message) for message in messages])
print([f"{message}." for message in messages])
# Dict (dictionnaire)
print({message: len(message) for message in messages})
# Set ensemble
print({len(message) for message in messages})

# Card game from ranks and symbols
ranks = range(1, 11)
symbols = ["💗", "♠️", "🍀", "🔶"]
# Produit cartésien
print([f"{r}{s}" for r in ranks for s in symbols])

m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print([item for row in m for item in row])
row_count = range(len(m))
print([f"m[{i}, {j}] => {m[i][j]}" for i in row_count for j in range(len(m[i]))])

# Equivalent en for
result = []
for i in row_count:
    for j in range(len(m[i])):
        result.append(f"m[{i}, {j}] => {m[i][j]}")
print("Tranformation matrice vers liste avec for", result)

# Pour faire une compréhension de tuple, il faut utiliser tuple()
print(tuple(x + 6 for x in range(10)))

Utiliser une librairie tierce

  • Même si la libraire standard de Python est riche, on a souvent besoin d'utiliser des librairies tierces pour aller plus vite
  • Le dépôt standard des librairies Python est PyPI (Python Package Index)
  • On peut utiliser son moteur de recherche pour trouver un librairie. Par exemple, cherchons la libraire matplotlib
  • Une fois dans la page de la librairie, on peut trouver la commande qui permet de l'installer localement. Pour matplotlib, la commande sera pip install matplotlib (si pip n'est pas trouvé alors essayer avec python -m pip install matplotlib)
  • Ensuite, on pourra utiliser la librairie en se référant à sa documentation. Par exemple, matplotlib propose des tutoriels qui est un bon point de départ.

Sources et références