Bases du langage

Variables

Types

• Integer 1234
• Float 3.14
• String 'string' ou "string"
• Boolean True et False

En Python, le type null est None.

Méthodes utiles pour convertir les types

• int() : conversion en Integer
• float() : conversion en Float
• str() : conversion en String

def greet(name: str) -> str:
  return name

Déclaration d’une variable

En Python les variables ont un typage faible et peuvent changer de type à volonté.

ma_variable = "Chaine de caractères"

Inclusion de variable dans une string :

• Concaténation :

variable = "World"
"Hello, " + variable + " !" # str(variable) si besoin de convertir

• Opérateur “%” :

  • %s pour les strings
  • %d pour les nombres

variable1 = "My"
variable2 = "World"
"Hello, %s %s !"%(variable1, variable2)

• Fonction format() :

variable = "World"
"Hello, {} !".format(variable)

• f-string (Python >= 3.6) :

variable = "World"
f"Hello, {variable} !"

Entrées/Sorties

print() affiche une chaîne de caractères à l’écran

input() récupère une entrée utilisateur (ne garde pas de saut de ligne de fin)

nom = input()
print(f"Bonjour {nom} !")

Commentaires

• Commentaires sur une ligne

En Python, un commentaire sur une ligne est défini par le caractère #.

# Ceci est un commentaire

• Commentaires sur plusieurs lignes

Il est possible de définir un bloc de commentaires pouvant tenir sur plusieurs lignes en l’entourant de """.

"""
Ceci est un bloc de commentaires
pouvant tenir sur plusieurs lignes.
"""

• Docstrings

Ces mêmes commentaires, entourés de """, lorsqu’ils sont placés comme première déclaration d’un module, avant une fonction, une classe ou une définition de méthode, sont appelés docstrings et deviennent l’attribut spécial __doc__ de l’objet.

"""
Ceci est une docstring (accessible via `help()` et `__doc__`).
"""
def function():
  return 'Hello'

Plus d’infos ici

Conditions

Bloc if-elif-else

if <condition>:
  instruction
elif <condition>:
  instruction
else:
  instruction

Il est possible de combiner les conditions avec and, or et not.

Ternaire

En Python, les conditions ternaires s’écrivent avec un if et un else sur une ligne :

result = "ok" if a < b else "ko"

Boucles

Boucle while

while test:
  handle_true()
else:
  handle_false() # Run if didn't exit loop with break

Boucle while-else

i = 0
while i < 10:
  print(i)
  if i == 3:
    break
  i += 1
else:
  print("the `while` loop did NOT exited early")

Boucle for

for x in range(5): # range(5) = 0, 1, 2, 3, 4
  print(x)

Boucle for-else

for i in range(5):
  print(i)
  # if i == 3:
  #   break
else:
  print("the `for` loop did NOT exited early")

Opérations sur les boucles

• Ne rien faire

L’opérateur pass ne fait rien. Il permet d’indiquer explicitement au programme qu’il ne doit rien se passer.

for x in range(5):
  if x == 3:
    pass
  else:
    print(x)

• Arrêter la boucle

L’opérateur break permet de sortir d’une boucle.

for x in range(5):
  if x == 3:
    break

• Sauter une itération

L’opérateur continue permet de passer directement à l’itération suivante.

for x in range(5):
  continue if x == 3
  print(x)

Listes et tuples

Listes

• Déclaration d’une liste et accès à un élément

tableau = [1, 2, '3', '4'] # Un tableau peut contenir des éléments de types différents
print(tableau[0]) # 1

tableau = list(1, 2, '3', '4')
print(tableau[0]) # 1

• Ajout d’un élément à un tableau

Pour ajouter un élément à un tableau, trois méthodes sont disponibles : append pour ajouter un élément, insert qui ajoute un élément à un index précis et enfin extend qui permet d’ajouter une liste d’éléments.

tableau.append('5')
tableau.insert(1, '6')
tableau.extend(['7', '8'])

• Retrait d’un élément du tableau

Pour retirer un élément d’un tableau, trois méthodes sont disponibles : remove qui prend l’élément à supprimer, pop qui prend l’index de l’élément à supprimer ou supprime le dernier élément si non fourni et enfin clear qui supprime l’intégralité des éléments de la liste.

num = ['one', 'two', 'three', 'four']
num.remove('one') # ['two', 'three', 'four']
num.pop() # ['two', 'three']
num.clear() # []

• Connaître la taille d’un tableau

La méthode len() permet de connaître le nombre d’éléments présents dans un tableau.

tableau = [1, 2, 3, 4]
print(len(tableau)) # 4

• Trier un tableau

La méthode sort() permet de trier un tableau par ordre croissant.

tableau = [2, 3, 1, 4]
print(tableau.sort()) # [1, 2, 3, 4]

Tuples

Les tuples sont des structures de données similaires aux tableau à la différence qu’ils sont immutables, contrairement aux tableau qui, eux, peuvent être modifiés.

Ils se déclarent entre parenthèses ().

mon_tuple = (1, 2)

Dictionnaires

• Déclaration d’un dictionnaire et accès à un élément

dico = {
  'key': 'value'
}
print(dico['key']) # value
print(dico['inexistingKey']) # => KeyError

Il est aussi possible d’utiliser la fonction dict() :

dico = dict(
  key: 'value'
)
print(dico['key']) # value
print(dico['inexistingKey']) # => KeyError

• Ajout d’un élément dans un dictionnaire

dico['otherKey'] = 'otherValue'

• Suppression d’un élément d’un dictionnaire

Pour supprimer un élément d’un dictionnaire, il suffit d’utiliser le mot-clé del en précisant l’élément à supprimer.

dico = dict(
  key: 'value'
)
del dico['key']

• Vérification de l’existence d’une clé

Il est possible d’utiliser le mot-clé in pour tester l’existance d’une clé dans un dictionnaire.

dico = dict(
  key: 'value'
)
if 'key' in dico:
  print(dico['key'])

Fonctions

• Définir une fonction

def add(a, b):
  return a + b

En l’absence d’instruction return, une fonction renverra toujours None.

Retour multiple

En Python, il est possible de retourner plusieurs valeurs d’une fonction. Il suffit de les séparer par des virgules et le retour est ainsi récupérable sous forme de tuple.

def test_func(num1, num2):
  return num1, num2

a, b = test_func(5, 10)

Paramètres nommés

def test_func(num1, num2):
  return num1, num2

a, b = test_func(num1=5, num2=10)

Paramètres optionnels

Il est possible de rendre un paramètre optionnel en précisant sa valeur par defaut

def test_func(num1, num2=10):
  return num1, num2

a, b = test_func(5)

Liste de paramètres

def nom_fonction(*args)
  print(type(args)) # <class 'tuple'>

Il est toujours possible de passer des paramètres “isolés” en les mettant avant la liste.

Lambda

Python supporte les fonctions anonymes, aussi appelées lambda.

lambda arguments: expression

Fonctions de fonctions (curryfication)

def greeter(greet_word: str):
  def greet(name: str) -> str:
    return f"{greet_word}, {name}!"
  return greet

g = greeter("Salut")
g("Sarah") # 'Salut, Sarah!'
greeter("Bienvenue")("Michel") # 'Bienvenue, Michel!'

Gérer les erreurs et les exceptions

En Python, les exceptions sont gérées à l’aide du bloc try/except.

try:
  x = int(input("Entrez un nombre entier : "))
  break
except ValueError:
  print("Oops ! Ce n'est pas un nombre entier. Essayez encore...")

Lire et écrire des fichiers

Ouverture et fermeture d’un fichier

En Python, il est possible d’ouvrir un fichier en lecture ou en écriture avec la méthode open().

f = open("myfile.csv")

Il peut être utile de préciser le mode dans lequel on souhaite ouvrir le fichier :

f = open("myfile.csv") # This is the same as “rt” mode.
f = open("myfile.csv", "w") # write in text mode
f = open("myimage.png", "r+b") # read and write in binary mode

Voici la liste des options possibles :

Après utilisation, il est nécessaire de fermer le fichier à l’aide de la méthode close().

f = open("myfile.csv")
f.close()

Le mot-clé with permet d’ouvrir un bloc dans lequel un fichier est ouvert au début et automatiquement fermé à la fin.

with open("myfile.csv") as f:
  <instructions>

Lecture d’un fichier

• Lecture complète sous forme de texte

La méthode read() permet de lire l’entièreté d’un fichier sous la forme d’un string.

with open("myfile.csv") as f:
  content = f.read()

• Lecture ligne par ligne

Il est possible de parcourir un fichier ligne par ligne en itérant dessus avec une boucle for

with open("myfile.csv") as f:
  for line in f:
    print(line)

• Récupération du contenu sous forme de liste

La méthode readlines() permet de récupérer l’entièreté des lignes du fichier sous forme de liste.

with open("myfile.csv") as f:
  lines = f.readlines()

Écriture dans un fichier

La méthode write() permet d’écrire une ligne dans un fichier.

with open("myfile.csv") as f:
  f.write("new line")