Aide-mémoire du langage Python

Python est un langage de programmation informatique multiplateforme. C’est un langage orienté objet à typage dynamique, conçu à l’origine pour l’écriture de scripts d’automatisation (shell). Avec la mise à jour continue des versions et l’ajout de nouvelles fonctionnalités, il est de plus en plus utilisé pour le développement de projets indépendants de grande envergure.

Général

• Python est sensible à la casse
• L’indexation Python commence à 0
• Python utilise des espaces blancs (tabulations ou espaces) pour l’indentation du code au lieu d’utiliser des accolades.

Aide (Help)

Modules (Bibliothèques)

L’instruction import crée un nouvel espace de noms et exécute toutes les instructions du fichier .py associé au sein de cet espace de noms. Si vous souhaitez charger le contenu du module dans l’espace de noms actuel, utilisez “from module1 import *”

Types scalaires

Vérifier le type de données : type(variable)

Entiers (Integers)

int/long - Les grands entiers sont automatiquement convertis en entiers longs (en Python 3, seul int existe et gère toutes les tailles).

Flottants (Floats)

float - 64 bits, il n’y a pas de type “double”.

Booléens (Booleans)

bool - Vrai (True) ou Faux (False).

Chaînes de caractères (Strings)

str - Python 2.x par défaut est en ASCII ; Python 3 est en Unicode.

• Les chaînes peuvent être entre guillemets simples/doubles/triples.
• Une chaîne est une séquence de caractères, elle peut donc être traitée comme n’importe quelle autre séquence.
• Les caractères spéciaux peuvent être représentés en les précédant de \ ou r (chaînes brutes / raw strings).

  str1 = r'ceci\f?ff'
• Le formatage des chaînes peut être réalisé de plusieurs manières.

  template = '%.2f %s haha $%d'
  str1 = template % (4.88, 'hola', 2)

str(), bool(), int() et float() sont également des fonctions de conversion de type explicites.

Valeur nulle (Null)

NoneType(None) - Valeur ’null’ de Python (il n’existe qu’une seule instance de l’objet None).

• None n’est pas un mot-clé réservé, mais l’unique instance de “NoneType”.
• None est une valeur par défaut courante pour les paramètres de fonction optionnels :

  def func1(a, b, c = None)
• Utilisation courante de None :

  if variable is None :

Date et heure (Datetime)

datetime - Le module intégré “datetime” de Python fournit les types “datetime”, “date”, “time”, etc.

• “datetime” combine les informations stockées dans “date” et “time”.

  Créer datetime à partir d’une chaîne	dt1 = datetime.strptime(‘20091031’, ‘%Y%m%d’)
  Obtenir l’objet “date”	dt1.date()
  Obtenir l’objet “time”	dt1.time()
  Formater datetime en chaîne	dt1.strftime(’%m/%d/%Y %H:%M’)
  Modifier la valeur d’un champ	dt2 = dt1.replace(minute = 0, second=30)
  Obtenir la différence	diff = dt1 - dt2 # diff est un objet ‘datetime.timedelta’

Structures de données

Tuples

Un tuple est une séquence de longueur fixe et immuable.

Listes (Lists)

Une liste est une séquence de longueur variable et modifiable.

Note :

• L’index de début (start) est inclus, mais l’index de fin (stop) est exclu.
• start/stop peuvent être omis, par défaut c’est le début/la fin.

Découpage (Slicing)

Les types de séquence incluent ‘str’, ‘array’, ’tuple’, ’list’, etc.

list1[start:stop]
list1[start:stop:step]
list1[::2]
str1[::-1]

Dictionnaires (Hash)

Ensembles (Sets)

Un ensemble est une collection non ordonnée d’éléments uniques.

Fonctions

• Forme de base :

  def func1(posArg1, keywordArg1 = 1, ..):

• Utilisation courante de “Les fonctions sont des objets” :

  def func1(ops = [str.strip, user_define_func, ..], ..):
      for function in ops:
          value = function(value)

• Valeurs de retour :

  • S’il n’y a pas d’instruction return, ne renvoie aucune valeur (None).
  • Renvoyer plusieurs valeurs via un tuple.

  return (value1, value2)
  
  value1, value2 = func1(..)

• Fonctions anonymes (Lambda) :

  lambda x : x * 2
  # def func1(x) : return x * 2

Fonctions courantes

1. Enumerate : renvoie une séquence de tuples (index, valeur), où l’index est la position actuelle.

   for key, val in enumerate(collection):

2. Sorted : trie n’importe quel objet itérable.

   sorted([2, 1, 3]) => [1, 2, 3]

3. Zip : regroupe les éléments correspondants des objets en tuples et renvoie une liste de ces tuples.

   zip(seq1, seq2) => [('seq1_1', 'seq2_1'), (..), ..]

4. Reversed : renvoie un itérateur inversé.

   list(reversed(range(10)))

Contrôle de flux

1. Opérateurs de condition “if else” :

   Vérifier si deux variables sont le même objet	var1 is var2
   Vérifier si deux variables sont des objets différents	var1 is not var2
   Vérifier si deux variables ont la même valeur	var1 == var2

2. Utilisation courante de l’opérateur for :

   for element in iterator :

3. ‘pass’ : ne fait rien, généralement utilisé comme espace réservé.

4. Expression ternaire :

   value = true-expr if condition else false-expr

5. Pas d’instruction switch/case ; utilisez if/elif.

Orientation objet (OOP)

1. ‘object’ est la base de tous les types Python.

2. Tout (nombres, chaînes, fonctions, classes, modules, etc.) est un objet, et chaque objet a un ’type’. Les variables d’objet sont des pointeurs vers leur emplacement en mémoire.

3. Forme de base d’un objet :

   class MyObject(object):
       # 'self' équivaut à 'this' en Java/C++
       def __init__(self, name):
           self.name = name
   
       def memberFunc1(self, arg1):
           ..
   
       @staticmethod
       def classFunc2(arg1):
           ..
   
   obj1 = MyObject('name1') 
   obj1.memberFunc1('a') 
   MyObject.classFunc2('b')

4. Outils interactifs :

   dir(variable1) # Lister toutes les méthodes disponibles sur l'objet

Opérations sur les chaînes de caractères

Joindre une liste/tuple avec un séparateur :

', '.join([ 'v1', 'v2', 'v3']) => 'v1, v2, v3'

Formater une chaîne :

string1 = 'My name is {0} {name}'
newString1 = string1.format('Sean', name = 'Chen')

Diviser une chaîne :

sep = '-'
stringList1 = string1.split(sep)

Trancher une chaîne :

start = 1
string1[start:8]

Remplir une chaîne avec des zéros :

month = '5'
month.zfill(2) => '05' 
month = '12'
month.zfill(2) => '12'

Gestion des exceptions

1. Forme de base :

try:
    ..
except ValueError as e:
    print(e)
except (TypeError, AnotherError):
    ..
except:
    ..
finally:
    ..

2. Lever une exception manuellement :

raise AssertionError # Échec de l'assertion
raise SystemExit # Demander l'arrêt du programme
raise RuntimeError('Message d\'erreur :..')

Compréhension de listes, d’ensembles et de dictionnaires

Sucre syntaxique pour rendre le code plus facile à lire et à écrire.

1. Compréhension de liste :

   Un moyen concis de former une nouvelle liste en filtrant les éléments d’une collection et en transformant ceux qui passent le filtre.

   Forme de base :

   [expr for val in collection if condition]

   Équivalent à :

   result = []
   for val in collection:
       if condition:
           result.append(expr)

2. Compréhension de dictionnaire :

   {key-expr : value-expr for value in collection if condition}

3. Compréhension d’ensemble : Identique à la compréhension de liste, mais en utilisant {} au lieu de [].

4. Compréhension de liste imbriquée :

   Forme de base :

   [expr for val in collection for innerVal in val if condition]