Comment utiliser IPython

Je vais vous montrer comment l'utiliser pour commémorer la sortie d'IPython 2.0.

Qu'est-ce qu'IPython?

IPython est une extension puissante (vraiment puissante) de l'interpréteur interactif de Python. Cependant, ce n'est pas seulement une extension, il a les fonctions suivantes.

• Shell interactif étendu --Modèle de communication inter-processus séparé --Mécanisme de calcul parallèle

Mais d'abord, encore une fois, je vais décrire brièvement comment utiliser le puissant shell interactif d'IPython.

Installons-le d'abord.

$ pip install ipython

Commençons-le une fois qu'il est installé.

$ ipython

Vous n'êtes pas bon parce que vous comptez simplement sur le complément

Par rapport au shell interactif standard de Python, la puissance d'IPython est d'abord remarquée par ses riches compléments. Essayez de taper ʻimport odans le shell IPython lancé et d'appuyer sur la touche`.

In [1]: import o
octavemagic  opcode      operator    optparse    os

Vous avez un candidat complémentaire merveilleux et astucieux! Les complétions de shell interactives standard n'ont pas été très pratiques, mais les complétions IPython sont tout à fait utilisables.

Essayons un peu plus. Entrez ʻos.pacomme ʻimport os`` <TAB>

In [1]: import os
In [2]: os.pa
os.pardir          os.path            os.pathconf        os.pathconf_names  os.pathsep

Même les modules importés sont candidats à l'achèvement.

Bien entendu, vous pouvez également compléter les variables que vous avez déclarées.

In [3]: spam = 'Hello!'
In [4]: sp

Si vous appuyez sur <TAB> ici, spam sera terminé.

De plus, non seulement les objets et mots-clés Python, mais également les noms de fichiers et de répertoires sont ciblés pour être complétés.

In [5]: .bash
.bash_history  .bash_profile  .bashrc

Cette complétion à elle seule est plus que suffisante pour vous motiver à utiliser IPython.

Je ne sais pas ce que signifie être une introspection.

IPython facilite l'inspection des objets. Si vous l'exécutez en ajoutant ? Au nom de l'objet, tel que ʻobject_name? `, Les informations de cet objet seront affichées.

Par exemple, cela ressemble à ce qui suit.

In [6]: spam?
Type:        str
String form: Hello
Length:      5
Docstring:
str(object='') -> str
str(bytes_or_buffer[, encoding[, errors]]) -> str

Create a new string object from the given object. If encoding or
errors is specified, then the object must expose a data buffer
that will be decoded using the given encoding and error handler.
Otherwise, returns the result of object.__str__() (if defined)
or repr(object).
encoding defaults to sys.getdefaultencoding().
errors defaults to 'strict'.

Les modules intégrés et, bien sûr, vos propres classes sont OK. Ce qui est affiché est l'ensemble docstring, la ligne de définition de fonction / méthode, et dans le cas d'une classe, les informations du constructeur (?).

In [7]: os.path.join?
Type:        function
String form: <function join at 0x10c6592f0>
File:        /Users/mubae/.virtualenvs/py3/lib/python3.4/posixpath.py
Definition:  os.path.join(a, *p)
Docstring:
Join two or more pathname components, inserting '/' as needed.
If any component is an absolute path, all previous path components
will be discarded.  An empty last part will result in a path that
ends with a separator.

Vous pouvez également afficher des informations plus détaillées en utilisant «??» au lieu de «?».

In [8]: os.path.join??
Type:        function
String form: <function join at 0x10c6592f0>
File:        /Users/mubae/.virtualenvs/py3/lib/python3.4/posixpath.py
Definition:  os.path.join(a, *p)
Source:
def join(a, *p):
   """Join two or more pathname components, inserting '/' as needed.
   If any component is an absolute path, all previous path components
   will be discarded.  An empty last part will result in a path that
   ends with a separator."""
   sep = _get_sep(a)
   path = a
   try:
       for b in p:
           if b.startswith(sep):
               path = b
           elif not path or path.endswith(sep):
               path += b
           else:
               path += sep + b
   except TypeError:
       valid_types = all(isinstance(s, (str, bytes, bytearray))
                         for s in (a, ) + p)
       if valid_types:
           # Must have a mixture of text and binary data
           raise TypeError("Can't mix strings and bytes in path "
                           "components.") from None
       raise
   return path

De plus, il est possible d'afficher uniquement les informations spécifiées en utilisant des ** commandes magiques ** telles que «% pdoc», «% pdef», «% psource» et «% pfile».

La commande magique sera expliquée plus tard.

In [9]: %pdoc os.path.join
Class docstring:
   Join two or more pathname components, inserting '/' as needed.
   If any component is an absolute path, all previous path components
   will be discarded.  An empty last part will result in a path that
   ends with a separator.
Call docstring:
   Call self as a function.

In [10]: %psource os.path.join
def join(a, *p):
   """Join two or more pathname components, inserting '/' as needed.
   If any component is an absolute path, all previous path components
   will be discarded.  An empty last part will result in a path that
   ends with a separator."""
   sep = _get_sep(a)
   path = a
   try:
       for b in p:
           if b.startswith(sep):
               path = b
           elif not path or path.endswith(sep):
               path += b
           else:
               path += sep + b
   except TypeError:
       valid_types = all(isinstance(s, (str, bytes, bytearray))
                         for s in (a, ) + p)
       if valid_types:
           # Must have a mixture of text and binary data
           raise TypeError("Can't mix strings and bytes in path "
                           "components.") from None
       raise
   return path

Commande magique, oh commande magique. Cela rendra-t-il votre vie meilleure?

Même avec le contenu jusqu'à présent, j'espère que vous avez réalisé la commodité d'IPython. Cependant, vous pouvez l'utiliser encore plus commodément en connaissant les commandes magiques que nous allons introduire.

Les commandes Magic sont des commandes qui peuvent être utilisées dans le shell IPython et sont grossièrement classées dans les deux types suivants.

• Orienté ligne ** Line Magic ** Une commande avec un «%» au début, passant le contenu de cette ligne à la commande en tant qu'argument.
• Orienté cellule ** Cell Magic ** Une commande avec «%%» au début vous permet de passer plusieurs lignes, pas seulement cette ligne.

Par exemple, la commande % timeit peut mesurer le temps d'exécution.

In [1]: %timeit range(1000)
1000000 loops, best of 3: 804 ns per loop

Il s'agit d'un motif multiligne.

In [1]: %%timeit x = range(10000)
   ...: max(x)
   ...:
1000 loops, best of 3: 963 µs per loop

De plus, les commandes intégrées suivantes sont disponibles.

• Lié au code %run, %edit, %save, %macro, %recall
• En relation avec la coque %colors, %xmode, %autoindent, %automagic --Autre %reset, %timeit, %%file, %load, or %paste

Vous pouvez vérifier la commande magique avec % quickref, alors voyons ce que signifie la commande et quelles autres commandes sont disponibles.

Exécuter et déboguer

Regardons un peu plus la commande magique.

Utilisez la commande magique % run pour exécuter votre script Python préféré et charger les données directement dans l'espace de noms du shell interactif. Contrairement à ʻimport`, celui-ci est rechargé à chaque fois qu'il est exécuté, donc toute modification du script sera immédiatement reflétée.

La commande % run a quelques options spéciales, l'option -t peut être utilisée pour chronométrer l'exécution du script, et l'option -d peut être utilisée pour le lancer dans le débogueur pdb.

De plus, si une exception se produit pendant l'exécution du script, vous pouvez immédiatement démarrer pdb et le déboguer en exécutant la commande % debug. Si vous voulez démarrer pdb automatiquement lorsqu'une exception se produit, vous pouvez basculer le comportement du démarrage automatique de pdb avec la commande % pdb.

Peu importe l'histoire que j'ai tracée, je ne t'ai jamais vu briller. Bien sûr, à partir de maintenant.

IPython enregistre un historique des entrées et des sorties. Ceci est également très pratique.

Le moyen le plus simple de retracer l'historique est d'utiliser les touches fléchées ↑ ↓ `, mais il existe d'autres moyens plus sophistiqués d'accéder à l'historique.

L'historique des entrées / sorties est sauvegardé dans les variables ʻIn et ʻOut avec le numéro d'invite comme clé, donc vous pouvez vous y référer plus tard.

In [1]: pig = 'boo'

In [2]: pig.capitalize()
Out[2]: 'Boo'

In [3]: pig.upper()
Out[3]: 'BOO'

In [4]: In[3]
Out[4]: 'pig.upper()'

In [5]: Out[3]
Out[5]: 'BOO'

De plus, les trois dernières sorties sont stockées sous les noms «», «», «», donc elles sont plus faciles d'accès.

Vous pouvez également vous référer à l'historique avec la commande % history.

C'est pratique de pouvoir utiliser les commandes du shell système d'IPython, cette merde.

Les commandes du shell système sont faciles à utiliser, il suffit de les préfixer avec ! Et de les exécuter.

In [1]: !ping 2ch.net
PING 2ch.net (206.223.154.230): 56 data bytes
64 bytes from 206.223.154.230: icmp_seq=0 ttl=50 time=118.838 ms
64 bytes from 206.223.154.230: icmp_seq=1 ttl=50 time=118.843 ms
64 bytes from 206.223.154.230: icmp_seq=2 ttl=50 time=118.642 ms
64 bytes from 206.223.154.230: icmp_seq=3 ttl=50 time=118.378 ms

De plus, vous pouvez capturer le résultat de sortie tel qu'il est dans la liste comme suit.

In [16]: files = !ls

référence

Je pense que le dernier était presque comme une traduction du tutoriel. http://ipython.org/ipython-doc/stable/interactive/tutorial.html