Scripting Python – Memo Bases

 


 

Le shebang

#!

Permet de signifier à l’OS que le fichier est un script exécutable. La commande file identifie le contenu d’un fichier grâce au shebang, et non par son extension ou les lignes de codes qui le constituent.
Il est possible qu’il s’agisse de la contraction de sharp (#) et bang (!), de celle de hash (#) et bang (!), ou tout simplement de shell et bang (!).
Il peut aussi être appelé shabang, sha-bang, she-bang ou encore hash-bang.
Sur la même ligne se trouve le chemin absolu vers l’interpréteur qui devra être utilisé.

Pour Python 2.X :
#!/usr/bin/python

Equivaut à :
#!/usr/bin/python2
ou, pour une version plus portable entre systèmes UNIX :

#!/usr/bin/env python

Equivaut à :
#!/usr/bin/env python2
Ci-dessus, Python 2.X sera recherché dans chaque répertoire du PATH jusqu’à être trouvé.

Pour Python 3.X :
#!/usr/bin/python3

ou, pour une version plus portable entre systèmes UNIX :

#!/usr/bin/env python3

Ci-dessus, Python 3.X sera recherché dans chaque répertoire du PATH jusqu’à être trouvé.

 


 

Spécifier l’encodage du script

Fichier enregistré en UTF-8 :

# -*- coding: utf-8 -*-

Fichier enregistré en ISO-8859-1 :

# -*- coding: latin-1 -*-

 


 

L’exécution d’un script

Si le script ne possède pas de shebang en en-tête (ce qui ne devrait jamais être le cas, hormis pour les modules Python) ou qu’il ne possède pas les droits d’exécution (u+x) :
Pour Python 2.X :

python filename.py
python2 filename.py

ou
Pour Python 3.X :

python3 filename.py

On spécifie ainsi l’interpréteur à utiliser pour exécuter le script.
Toutefois, un script possède systématiquement l’en-tête cité précédemment, et la procédure pour l’exécuter est la suivante :

chmod u+x filename.py
./filename.py
../adminsys/filename.py
/home/adminsys/filename.py

On rend le script exécutable pour le propriétaire puis on l’exécute à partir du répertoire courant ou en spécifiant un chemin relatif/absolu.
Le script, s’il est dans le répertoire courant s’exécute en le préfixant de ./ car sans cela la commande serait recherchée dans le PATH et ne serait pas reconnue, à moins qu’une commande système porte le même nom, ce qui est une très mauvaise idée pour un nom de script, ou que le répertoire courant soit inclus dans le PATH, ce qui est également une très mauvaise décision en termes de sécurité.

# filename.py
bash: filename.py : commande introuvable

Retourne une erreur car filename.py est recherché dans les répertoires constituant la variable d’environnement PATH.

# echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
# .filename.py
bash: .filename.py : commande introuvable

La même erreur est retournée si on le préfixe d’un point pour la même raison, une commande .filename.py (script caché cette fois-ci) est recherchée dans le PATH mais n’est pas trouvée.
La bonne manière de procéder est donc la suivante :

./filename.py

car filename.py et ./filename.py sont équivalents, à la différence près que la première commande est recherchée dans le PATH alors que la seconde est recherchée dans le répertoire courant.

# ls -l filename.py
-rwxr--r-- 1 root root 15 nov.  22 10:49 filename.py
# ls -l ./filename.py
-rwxr--r-- 1 root root 15 nov.  22 10:49 ./filename.py
# ls -l ./*
-rw-r--r-- 1 root root 0 nov.  22 11:05 ./file1.txt
-rw-r--r-- 1 root root 0 nov.  22 11:05 ./file2.txt
-rw-r--r-- 1 root root 0 nov.  22 11:05 ./file3.txt
-rw-r--r-- 1 root root 0 nov.  22 11:05 ./filename.py
# ls -l *
-rw-r--r-- 1 root root 0 nov.  22 11:05 file1.txt
-rw-r--r-- 1 root root 0 nov.  22 11:05 file2.txt
-rw-r--r-- 1 root root 0 nov.  22 11:05 file3.txt
-rw-r--r-- 1 root root 0 nov.  22 11:05 filename.py

 


 

Afficher la liste et l’aide des modules importables

Afficher la liste des modules disponibles :

help('modules')

Ou alternativement filtrer avec un mot-clé :

help('modules keyword')

Afficher l’aide détaillée d’un module :

help(modulename)

Importer le module en question et afficher ses attributs, méthodes et fonctions :

import modulename
dir(modulename)

Afficher l’aide détaillée d’une fonction d’un module :

help(modulename.function)

ex :

>>> import Tkinter
>>> from pprint import pprint
>>> pprint(dir(Tkinter))
[...]
 'Image',
 'InstanceType',
 'IntType',
 'IntVar',
 'LAST',
 'LEFT',
 'Label',
 'LabelFrame',
 'LambdaType',
 'ListType',
 'Listbox',
 'LongType',
 'MITER',
 'MOVETO',
 'MULTIPLE',
[...]
>>> help(Tkinter.Canvas)
Help on class Canvas in module Tkinter:

class Canvas(Widget, XView, YView)
 |  Canvas widget to display graphical elements like lines or text.
 |
 |  Method resolution order:
 |      Canvas
 |      Widget
 |      BaseWidget
 |      Misc
 |      Pack
 |      Place
 |      Grid
 |      XView
 |      YView

 


 

Import d’un module ou d’un package

Import d’un module complet sans renommage

import modulename
import math
math.cos(90)

Import d’un module complet avec renommage

import modulename as newname
import math as m
m.cos(90)

Importer seulement une fonction d’un module

from modulename import functionname
from math import cos
cos(90)

Importer toutes les fonctions d’un module (mauvaise méthode : conflits)

from modulename import *
from math import *
cos(90)
sin(90)

Importer un module depuis un package en le renommant

import packagename.modulename as newname
import matplotlib.pylab as plt

OU

from packagename import modulename as newname
from matplotlib import pylab as plt

 


 

Les conventions de nommage

1. Les caractères autorisés et les mots-clés réservés

a ➜ z A ➜ Z 0 ➜ 9 _

Les 31 mots-clefs réservés dans la version Python 2.7.9 :

Python 2.7.9 (default, Aug 13 2016, 16:41:35) 
[GCC 4.9.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import keyword
>>> print(keyword.kwlist)
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
and as assert break class
continue def del elif else
except exec finally for from
global if import in is
lambda not or pass print
raise return try while with
yield

Les 33 mots-clefs réservés dans la version Python 3.4.2 :

Python 3.4.2 (default, Oct  8 2014, 13:14:40) 
[GCC 4.9.1] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import keyword
>>> print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
and as assert break class
continue def del elif else
except False finally for from
global if import in is
lambda None nonlocal not or
pass raise return True try
while with yield

2. Les variables classiques

Une variable est une adresse mémoire où est stockée une valeur.
Les noms de variables classiques commencent par une minuscule et les parties sont accolées avec une majuscule.
Le corps d’une variable peut contenir un tiret bas ou underscore (_).
Une variable ne commence jamais par un chiffre.

spam
spamAndEggs
spam_And_Eggs
spamAndEggs123

3. Les variables privées d’une classe

Une variable privée débute, par convention, par un tiret bas ou underscore (_).
Ceci n’empêche toutefois pas d’y accéder de l’extérieur d’une classe, c’est une simple convention de nommage.

_spam
_spamAndEggs
_spam_And_Eggs
_spamAndEggs123

4. Les variables superprivées d’une classe

Une variable superprivée débute, par convention, par au moins deux tirets bas ou underscores (__).
Ceci empêche d’y accéder de l’extérieur d’une classe.

__spam
__spamAndEggs
__spam_And_Eggs
__spamAndEggs123

5. Les constantes

Les noms de constantes sont écrits en majuscules, avec un tiret bas ou underscore (_) comme séparateur.

SPAM
SPAM_AND_EGGS

6. Les classes

Les noms de classes commencent par une majuscule et les parties sont accolées avec une majuscule.

class Spam:
class SpamAndEggs(Spam):

7. Les méthodes de classe

Les noms de méthodes sont en minuscules et les parties sont séparées par un tiret bas ou underscore (_).

def spam_and_eggs(self):

8. Les méthodes privées de classe

Les méthodes privées sont précédées de deux tirets bas ou underscores (__).
Ceci empêche d’y accéder de l’extérieur d’une classe.

def __spam_and_eggs(self):

9. Les méthodes spéciales de classe

Les méthodes spéciales sont précédées et suivies de deux tirets bas ou underscores (__).

def __init__(self):
def __getattr__(self, name):
def __setattr__(self, name, value):
def __repr__(self):

 

10. Majuscules ou minuscules?

Packages (ex : utilities) :

    nom court
    tout en minuscules
    De préférence sans caractère underscore

Modules (ex : db_utils, dbutils) :

    nom court
    tout en minuscules
    Peut contenir le caractère underscore

Classes (ex : BankAccount) :

    CapWords (camel case)

Fonctions (ex : open_account) :

    tout en minuscules
    mots séparés par le caractère underscore

Variables (ex : account_id) :

    tout en minuscules
    mots séparés par le caractère underscore

Constantes (ex : MIN_APR) :

    tout en majuscules
    mots séparés par le caractère underscore

 


 

Indentation : tabulations ou espaces

Python Enhancement Proposal 8 (PEP8) recommande d’utiliser des espaces au lieu des tabulations pour marquer l’indentation du code Python.

def printme( str ):
....print str
....return;

Plutôt que :

def printme( str ):
print str
return;

 


 

Paramètres et arguments

def fonction(parametre):
    return 2 * parametre


Ci-dessus fonction unaire, c’est-à-dire d’arité un, en d’autres termes n’acceptant qu’un seul argument lorsqu’elle est appelée.

>>> print(fonction('argument'))
argumentargument

 


 

Les variables

1. Les nombres entiers

integerNumber = 10

2. Les nombres rationnels

floatingNumber = 10.7

3. Les chaînes de caractères

stringName = 'spam'
stringName = 'Exemple d\'affectation'
stringName = "Exemple d'affectation"
stringName = "10.7"

 


 

Les modules par défaut

Au lancement de Python, certains modules sont chargés par défaut :

>>> dir()
['__builtins__', '__doc__', '__name__', '__package__']

Modules auxquels s’ajoute le pseudo-module __main__

  • __main__
  • __builtins__
  • __doc__
  • __name__
  • __package__

On peut afficher les fonctions, méthodes, variables, etc. importées avec un module particulier :

>>> dir("__builtins__")
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BufferError', 'BytesWarning', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError', 'RuntimeWarning', 'StandardError', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'ZeroDivisionError', '_', '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs', 'all', 'any', 'apply', 'basestring', 'bin', 'bool', 'buffer', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'cmp', 'coerce', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'execfile', 'exit', 'file', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'intern', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'long', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']
>>> dir("__main__")
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

On peut retrouver les fonctions natives sur le site officiel : pour Python 2 et Python 3.

 


 

Les opérateurs

Les opérateurs de comparaison

Ils renvoient l’un des booléens True ou False.

< strictement inférieur
> strictement supérieur
<= inférieur ou égal
>= supérieur ou égal
== égal
!= différent
is objets identiques
is not objets non identiques

Rmq :
Les opérateurs == et is sont totalement différents.
Le premier teste l’égalité numérique des objets en appelant la méthode spéciale __eq__.
Le second teste si les objets sont identiques et font référence à la même adresse mémoire
Il existe une confusion venant du fait que leur comportement est semblable pour des objets de valeurs comprises entre -5 et 256.
En effet, ces 262 valeurs sont stockées par défaut en mémoire et tous les objets ayant l’une de ces valeurs seront identiques numériquement mais aussi en termes d’adresses mémoire.

>>> var1 = 10
>>> var2 = 10
>>> id(10)
163948612
>>> id(var1)
163948612
>>> id(var2)
163948612
>>> var1 is var2
True
>>> var1 is 10
True
>>> var1 == var2
True
>>> var1 == 10
True
>>> var1 = 257
>>> var2 = 257
>>> id(257)
164030960
>>> id(var1)
164031032
>>> id(var2)
164030972
>>> var1 is var2
False
>>> var1 is 257
False
>>> var1 == var2
True
>>> var1 == 257
True

 


 

Break – Continue – Pass

Break :

Sort d’une itération en cours, complètement, l’itération n’étant plus poursuivie, sort de la boucle. Seule l’instruction suivante en dehors de la boucle est lue.

Continue :

Sort de l’itération en cours, mais reste dans la boucle en reprenant à la valeur suivante de l’itération. L’instruction suivante de la boucle n’est pas lue.

Pass :

Ne fait rien pour l’instruction en cours, l’instruction suivante de la boucle est lue.
 
Rmq : Si l’instruction finally est utilisée (dans un bloc try – except – finally) alors cette dernière sera toujours executée, même si elle est précédée de l’instruction break, continue ou pass.

def test(x) :
    for y in [x, x+1] :
      if y == 2 :
        x *= 10
      if y == 4 :
        pass
      if y == 6 :
        break
      if y == 8 :
        continue
      x += 1
    x *= 10
    return x

 


 

Le formatage des chaînes et des nombres

Ancien formatage ‘%s %s’ % (‘one’, ‘two’) ‘%d %d’ % (1, 2)
Nouveau formatage ‘{} {}’.format(‘one’, ‘two’) ‘{} {}’.format(1, 2) ‘{1} {0}’.format(‘one’, ‘two’)
Retour one two 1 2 two one
{[argument_index_or_keyword]:[width][.precision][type]}

Les valeurs possibles correspondant au type sont les suivantes :

d Nombre entier
f Nombre rationnel
b Nombre binaire
o Nombre octal
x Nombre hexadécimal
e Nombre rationnel au format exponentiel
s Nombre chaîne de caractères
>>> "Floating point {:.2f}".format(345.7916732)
'Floating point 345.79'
>>> "Floating point {0:.2f}".format(345.7916732)
'Floating point 345.79'
>>> import math
>>> "Floating point {0:10.3f}".format(math.pi)
'Floating point      3.142'
>>> "Floating point {0:20.3f}".format(math.pi)
'Floating point                3.142'
>>> "Floating point pi = {0:.3f}, with {1:d} digit precision".format(math.pi, 3)
'Floating point pi = 3.142, with 3 digit precision'
>>> 'Sam has {1:d} red balls and {0:d} yellow balls'.format(12, 31)
'Sam has 31 red balls and 12 yellow balls'
>>> "In binary 4 is {0:b}".format(4)
'In binary 4 is 100'
>>> "A = {0}, B = {1}, C = {2}".format(*[34, 66, 12])
'A = 34, B = 66, C = 12'
>>> array = [34, 66, 12]
>>> "A = {0}, B = {1}, C = {2}".format(*array)
'A = 34, B = 66, C = 12'
>>> d = {'hats' : 122, 'mats' : 42}
>>> "Sam had {hats} hats and {mats} mats".format(**d)
'Sam had 122 hats and 42 mats'
>>> 'Sam has {red} red balls and {green} yellow balls'.format(red = 12, green = 31)
'Sam has 12 red balls and 31 yellow balls'

 


 

Vérifier la syntaxe d’un script (PEP8)

Installer le module de vérification PEP8 :

pip install pycodestyle

(Normalement il est déjà installé avec Python)
Vérification d’un script :

pycodestyle --first scriptname.py

Vérification de la syntaxe d’un script nommé ici main.py :

pycodestyle --first main.py
main.py:4:19: E203 whitespace before ':'
main.py:8:1: E305 expected 2 blank lines after class or function definition, found 1
main.py:10:1: W391 blank line at end of file

Ceci est équivalent à activer Code analysis sur Eclipse avec PyDev :

 


 

Convertir un script de Python 2 vers Python 3

Le script 2to3.py est installé automatiquement avec Python dans Tools/Scripts depuis le répertoire d’installation.
Afficher seulement le différentiel :

python 2to3.py scripttoconvert.py

Modifier le fichier source en le sauvegardant (.bak) :

python 2to3.py -w scripttoconvert.py

Pour plus d’informations, voir la page officielle.

 


 

Création d’un environnement virtuel sous Linux

Exemple en considérant que nous utilisons Python 3 :

# apt-get install python3-pip
# pip3 install virtualenv
Collecting virtualenv
  Downloading virtualenv-15.1.0-py2.py3-none-any.whl (1.8MB)
    100% |████████████████████████████████| 1.8MB 526kB/s 
Installing collected packages: virtualenv
Successfully installed virtualenv-15.1.0

OU

# apt-get install python3-virtualenv

Exemple en considérant que nous utilisons Python 2 :

# apt-get install python-pip
# pip install virtualenv
Collecting virtualenv
  Downloading virtualenv-15.1.0-py2.py3-none-any.whl (1.8MB)
    100% |████████████████████████████████| 1.8MB 526kB/s 
Installing collected packages: virtualenv
Successfully installed virtualenv-15.1.0

OU

# apt-get install python-virtualenv

Création de l’environnement virtuel proprement dit :

# mkdir -p /home/adminsys/Workspace/Python-3.6-Env1/
# cd /home/adminsys/Workspace/Python-3.6-Env1/
# virtualenv -p /usr/bin/python3 .venv
Running virtualenv with interpreter /usr/bin/python3
Using base prefix '/usr'
New python executable in /home/adminsys/Workspace/Python-3.6-Env1/.venv/bin/python3
Also creating executable in /home/adminsys/Workspace/Python-3.6-Env1/.venv/bin/python
Installing setuptools, pip, wheel...done.
# source .venv/bin/activate
(.venv) # which python
/home/adminsys/Workspace/Python-3.6-Env1/.venv/bin/python
(.venv) # python
Python 3.5.3 (default, Jan 19 2017, 14:11:04) 
[GCC 6.3.0 20170118] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> exit()
(.venv) # deactivate
#

Sauvegarde de la liste des librairies installées en vue de restauration :

# pip freeze > requirements.txt

Restauration de librairies installées :

# pip install -r requirements.txt

 


 

Création d’un environnement virtuel sous Windows

Exemple en considérant que nous utilisons Python 3 :

>pip3 install virtualenv
Collecting virtualenv
  Downloading virtualenv-15.1.0-py2.py3-none-any.whl (1.8MB)
    100% |████████████████████████████████| 1.8MB 691kB/s
Installing collected packages: virtualenv
Successfully installed virtualenv-15.1.0

Exemple en considérant que nous utilisons Python 2 :

>pip install virtualenv
Collecting virtualenv
  Downloading virtualenv-15.1.0-py2.py3-none-any.whl (1.8MB)
    100% |████████████████████████████████| 1.8MB 691kB/s
Installing collected packages: virtualenv
Successfully installed virtualenv-15.1.0

Création de l’environnement virtuel proprement dit :

C:\>mkdir -p C:\Workspace\Python-3.6-Env1\
C:\>cd C:\Workspace\Python-3.6-Env1\
C:\Workspace\Python-3.6-Env1>virtualenv -p C:\Python36\python.exe .venv
Running virtualenv with interpreter C:\Python36\python.exe
Using base prefix 'C:\\Python36'
New python executable in C:\Workspace\Python-3.6-Env1\.venv\Scripts\python.exe
Installing setuptools, pip, wheel...done.

C:\Workspace\Python-3.6-Env1>.venv\Scripts\activate

(.venv) C:\Workspace\Python-3.6-Env1>where python
C:\Workspace\Python-3.6-Env1\.venv\Scripts\python.exe
C:\Python36\python.exe

(.venv) C:\Workspace\Python-3.6-Env1>python
Python 3.6.4 (v3.6.4:d48eceb, Dec 19 2017, 06:54:40) [MSC v.1900 64 bit (AMD64)]
 on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> exit()

(.venv) C:\Workspace\Python-3.6-Env1>deactivate
C:\Workspace\Python-3.6-Env1>

 


 

Ajouter un Build System sous Sublime Text 3

Tools > Build System > New Build System…

Sous Windows : Python 2.7

{
    "cmd": ["c:/Python27/python.exe", "-u", "$file"],
    "file_regex": "^[ ]*File \"(...*?)\", line ([0-9]*)",
    "selector": "source.python",
    "env": {"PYTHONIOENCODING": "utf8"}
}

Sous Windows : Python 3.6

{
    "cmd": ["c:/Python36/python.exe", "-u", "$file"],
    "file_regex": "^[ ]*File \"(...*?)\", line ([0-9]*)",
    "selector": "source.python",
    "env": {"PYTHONIOENCODING": "utf8"}
}

Sous Windows : Environnement virtuel Python 2.7

{
    "cmd": ["c:/Workspace/Python-2.7-Env1/.venv/Scripts/python.exe", "-u", "$file"],
    "file_regex": "^[ ]*File \"(...*?)\", line ([0-9]*)",
    "selector": "source.python",
    "env": {"PYTHONIOENCODING": "utf8"}
}

Sous Windows : Environnement virtuel Python 3.6

{
    "cmd": ["c:/Workspace/Python-3.6-Env1/.venv/Scripts/python.exe", "-u", "$file"],
    "file_regex": "^[ ]*File \"(...*?)\", line ([0-9]*)",
    "selector": "source.python",
    "env": {"PYTHONIOENCODING": "utf8"}
}

Sous Linux : Python 2.7

{
    'cmd': ['/usr/bin/python', '-u', '$file'],
    'file_regex': '^[ ]*File "(…*?)", line ([0-9]*)',
    'selector': 'source.python',
    "env": {"PYTHONIOENCODING": "utf8"}
}

Sous Linux : Python 3.6

{
    'cmd': ['/usr/bin/python3', '-u', '$file'],
    'file_regex': '^[ ]*File "(…*?)", line ([0-9]*)',
    'selector': 'source.python',
    "env": {"PYTHONIOENCODING": "utf8"}
}

Sous Linux : Environnement virtuel Python 2.7

{
    'cmd': ['/home/adminsys/Workspace/Python-2.7-Env1/.venv/bin/python', '-u', '$file'],
    'file_regex': '^[ ]*File "(…*?)", line ([0-9]*)',
    'selector': 'source.python',
    "env": {"PYTHONIOENCODING": "utf8"}
}

Sous Linux : Environnement virtuel Python 3.6

{
    'cmd': ['/home/adminsys/Workspace/Python-3.6-Env1/.venv/bin/python3', '-u', '$file'],
    'file_regex': '^[ ]*File "(…*?)", line ([0-9]*)',
    'selector': 'source.python',
    "env": {"PYTHONIOENCODING": "utf8"}
}

Mettre à jour pip

# python -m pip install --upgrade pip

Mettre à jour les modules installés

# pip install pip-review
# pip-review --local --interactive

Afficher l’aide ou la documentation d’un module

python -m pydoc module[.method]
python -c "import module; help(module[.method])"
# python -m pydoc input
# python -m pydoc random
# python -m pydoc random.sample
# python -c "import random; help(random)"
# python -c "import random; help(random.sample)"

Simuler la saisie d’un utilisateur (input)

Avec Sublime Text 3 :
Installer le module Sublime Input

'''input
answer1
answer2
...
'''

Avec un module custom :

"""
How to use autoreply in your code :
import autoreply
input, input = autoreply.call(['answer1', 'answer2', ...])
"""

def call(answers):

    def input(prompt=None):
        answer = answers.pop(0)
        if prompt: print(prompt, end=' ')
        print(answer)
        return answer

    return input, input

Références