Fonctionnalités cachées de Python [fermé]

Quelles sont les fonctionnalités moins connues mais utiles du langage de programmation Python?

• Essayez de limiter les réponses au noyau Python.
• Une fonctionnalité par réponse.
• Donnez un exemple et une brève description de la fonction, pas seulement un lien vers la documentation.
• Étiquetez l'entité en utilisant un titre comme première ligne.

Liens rapides vers les réponses:

• Déballage des arguments
• Un appareil dentaire
• Chaînage des opérateurs de comparaison
• Décorateurs
• Arguments par défaut Gotchas / Dangers of Mutable Arguments par défaut
• Descripteurs
• .getValeur par défaut du dictionnaire
• Tests de docstring
• Ellipsis Slicing Syntax
• Énumération
• Pour / sinon
• Fonction comme argument iter ()
• Expressions de générateur
• import this
• Échange de valeur sur place
• Liste pas à pas
• __missing__ articles
• Regex multiligne
• Formatage des chaînes nommées
• Liste imbriquée / compréhension de générateur
• Nouveaux types à l'exécution
• .pth des dossiers
• Encodage ROT13
• Débogage Regex
• Envoi aux générateurs
• Compléter la tabulation dans l'interpréteur interactif
• Expression ternaire
• try/except/else
• Déballage + print()fonction
• with déclaration

Chaînage des opérateurs de comparaison:

>>> x = 5
>>> 1 < x < 10
True
>>> 10 < x < 20 
False
>>> x < 10 < x*10 < 100
True
>>> 10 > x <= 9
True
>>> 5 == x > 4
True

Dans le cas où vous pensez que c'est en train de faire 1 < x, qui apparaît comme True, puis en comparant True < 10, ce qui est aussi True, alors non, ce n'est vraiment pas ce qui se passe (voir le dernier exemple.) Il se traduit vraiment en 1 < x and x < 10, et x < 10 and 10 < x * 10 and x*10 < 100, mais avec moins de frappe et chaque terme n'est évalué qu'une seule fois.

Obtenez l'arbre d'analyse des expressions rationnelles python pour déboguer votre expression régulière.

Les expressions régulières sont une grande fonctionnalité de python, mais leur débogage peut être pénible, et il est trop facile de se tromper en termes d'expression régulière.

Heureusement, python peut imprimer l'arbre d'analyse rationnelle, en passant le drapeau caché, expérimental et non documenté re.DEBUG(en fait, 128) à re.compile.

>>> re.compile("^\[font(?:=(?P<size>[-+][0-9]{1,2}))?\](.*?)[/font]",
    re.DEBUG)
at at_beginning
literal 91
literal 102
literal 111
literal 110
literal 116
max_repeat 0 1
  subpattern None
    literal 61
    subpattern 1
      in
        literal 45
        literal 43
      max_repeat 1 2
        in
          range (48, 57)
literal 93
subpattern 2
  min_repeat 0 65535
    any None
in
  literal 47
  literal 102
  literal 111
  literal 110
  literal 116

Une fois que vous avez compris la syntaxe, vous pouvez repérer vos erreurs. Là , nous pouvons voir que j'ai oublié d'échapper à la []dans[/font] .

Bien sûr, vous pouvez le combiner avec les indicateurs que vous souhaitez, comme les expressions rationnelles commentées:

>>> re.compile("""
 ^              # start of a line
 \[font         # the font tag
 (?:=(?P<size>  # optional [font=+size]
 [-+][0-9]{1,2} # size specification
 ))?
 \]             # end of tag
 (.*?)          # text between the tags
 \[/font\]      # end of the tag
 """, re.DEBUG|re.VERBOSE|re.DOTALL)

énumérer

Enveloppez un itérable avec énumérer et il donnera l'élément avec son index.

Par exemple:

>>> a = ['a', 'b', 'c', 'd', 'e']
>>> for index, item in enumerate(a): print index, item
...
0 a
1 b
2 c
3 d
4 e
>>>

Références:

• Tutoriel Python - Techniques de bouclage
• Documents Python — fonctions intégrées—enumerate
• PEP 279

Création d'objets générateurs

Si vous écrivez

x=(n for n in foo if bar(n))

vous pouvez sortir le générateur et l'affecter à x. Maintenant, cela signifie que vous pouvez faire

for n in x:

L'avantage de ceci est que vous n'avez pas besoin de stockage intermédiaire, dont vous auriez besoin si vous le faisiez

x = [n for n in foo if bar(n)]

Dans certains cas, cela peut entraîner une accélération importante.

Vous pouvez ajouter de nombreuses instructions if à la fin du générateur, en répliquant essentiellement les boucles imbriquées:

>>> n = ((a,b) for a in range(0,2) for b in range(4,6))
>>> for i in n:
...   print i 

(0, 4)
(0, 5)
(1, 4)
(1, 5)

iter () peut prendre un argument appelable

Par exemple:

def seek_next_line(f):
    for c in iter(lambda: f.read(1),'\n'):
        pass

La iter(callable, until_value)fonction appelle callableet produit son résultat à plusieurs reprises jusqu'à ce qu'elle until_valuesoit renvoyée.

Soyez prudent avec les arguments par défaut modifiables

>>> def foo(x=[]):
...     x.append(1)
...     print x
... 
>>> foo()
[1]
>>> foo()
[1, 1]
>>> foo()
[1, 1, 1]

Au lieu de cela, vous devez utiliser une valeur sentinelle indiquant "non fourni" et remplacer par le mutable que vous souhaitez par défaut:

>>> def foo(x=None):
...     if x is None:
...         x = []
...     x.append(1)
...     print x
>>> foo()
[1]
>>> foo()
[1]

Envoi de valeurs dans les fonctions du générateur . Par exemple, avoir cette fonction:

def mygen():
    """Yield 5 until something else is passed back via send()"""
    a = 5
    while True:
        f = (yield a) #yield a and possibly get f in return
        if f is not None: 
            a = f  #store the new value

Vous pouvez:

>>> g = mygen()
>>> g.next()
5
>>> g.next()
5
>>> g.send(7)  #we send this back to the generator
7
>>> g.next() #now it will yield 7 until we send something else
7

Si vous n'aimez pas utiliser les espaces pour désigner les étendues, vous pouvez utiliser le style C {} en émettant:

from __future__ import braces

L'argument step dans les opérateurs de tranche. Par exemple:

a = [1,2,3,4,5]
>>> a[::2]  # iterate over the whole list in 2-increments
[1,3,5]

Le cas spécial x[::-1]est un idiome utile pour «x inversé».

>>> a[::-1]
[5,4,3,2,1]

Décorateurs

Décorateurs permettent d'encapsuler une fonction ou une méthode dans une autre fonction qui peut ajouter des fonctionnalités, modifier des arguments ou des résultats, etc. Vous écrivez des décorateurs une ligne au-dessus de la définition de la fonction, en commençant par un signe "at" (@).

L'exemple montre un print_argsdécorateur qui affiche les arguments de la fonction décorée avant de l'appeler:

>>> def print_args(function):
>>>     def wrapper(*args, **kwargs):
>>>         print 'Arguments:', args, kwargs
>>>         return function(*args, **kwargs)
>>>     return wrapper

>>> @print_args
>>> def write(text):
>>>     print text

>>> write('foo')
Arguments: ('foo',) {}
foo

La syntaxe for ... else (voir http://docs.python.org/ref/for.html )

for i in foo:
    if i == 0:
        break
else:
    print("i was never 0")

Le bloc "else" sera normalement exécuté à la fin de la boucle for, sauf si le break est appelé.

Le code ci-dessus pourrait être émulé comme suit:

found = False
for i in foo:
    if i == 0:
        found = True
        break
if not found: 
    print("i was never 0")

À partir de la version 2.5, les pronostics ont une méthode spéciale __missing__qui est appelée pour les éléments manquants:

>>> class MyDict(dict):
...  def __missing__(self, key):
...   self[key] = rv = []
...   return rv
... 
>>> m = MyDict()
>>> m["foo"].append(1)
>>> m["foo"].append(2)
>>> dict(m)
{'foo': [1, 2]}

Il existe également une sous-classe dict dans collectionscalled defaultdictqui fait à peu près la même chose mais appelle une fonction sans arguments pour les éléments non existants:

>>> from collections import defaultdict
>>> m = defaultdict(list)
>>> m["foo"].append(1)
>>> m["foo"].append(2)
>>> dict(m)
{'foo': [1, 2]}

Je recommande de convertir de tels dict en dicts réguliers avant de les passer à des fonctions qui n'attendent pas de telles sous-classes. Beaucoup de code utilise d[a_key]et attrape KeyErrors pour vérifier si un élément existe qui ajouterait un nouvel élément au dict.

Échange de valeur sur place

>>> a = 10
>>> b = 5
>>> a, b
(10, 5)

>>> a, b = b, a
>>> a, b
(5, 10)

Le côté droit de l'affectation est une expression qui crée un nouveau tuple. Le côté gauche de l'affectation décompresse immédiatement ce tuple (non référencé) aux noms aetb .

Après l'affectation, le nouveau tuple n'est pas référencé et marqué pour la récupération de place, et les valeurs liées à aetb ont été échangées.

Comme indiqué dans la section du didacticiel Python sur les structures de données ,

Notez que l'affectation multiple n'est en réalité qu'une combinaison de tuple et de décompression de séquence.

Expressions régulières lisibles

En Python, vous pouvez fractionner une expression régulière sur plusieurs lignes, nommer vos correspondances et insérer des commentaires.

Exemple de syntaxe verbeuse (de Dive into Python ):

>>> pattern = """
... ^                   # beginning of string
... M{0,4}              # thousands - 0 to 4 M's
... (CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
...                     #            or 500-800 (D, followed by 0 to 3 C's)
... (XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
...                     #        or 50-80 (L, followed by 0 to 3 X's)
... (IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
...                     #        or 5-8 (V, followed by 0 to 3 I's)
... $                   # end of string
... """
>>> re.search(pattern, 'M', re.VERBOSE)

Exemples de correspondances de nommage (tirées du HOWTO sur les expressions rationnelles )

>>> p = re.compile(r'(?P<word>\b\w+\b)')
>>> m = p.search( '(((( Lots of punctuation )))' )
>>> m.group('word')
'Lots'

Vous pouvez également écrire verbalement une expression régulière sans utiliser re.VERBOSEgrâce à la concaténation littérale de chaîne.

>>> pattern = (
...     "^"                 # beginning of string
...     "M{0,4}"            # thousands - 0 to 4 M's
...     "(CM|CD|D?C{0,3})"  # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
...                         #            or 500-800 (D, followed by 0 to 3 C's)
...     "(XC|XL|L?X{0,3})"  # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
...                         #        or 50-80 (L, followed by 0 to 3 X's)
...     "(IX|IV|V?I{0,3})"  # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
...                         #        or 5-8 (V, followed by 0 to 3 I's)
...     "$"                 # end of string
... )
>>> print pattern
"^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$"

Déballage des arguments de fonction

Vous pouvez décompresser une liste ou un dictionnaire comme arguments de fonction en utilisant *et **.

Par exemple:

def draw_point(x, y):
    # do some magic

point_foo = (3, 4)
point_bar = {'y': 3, 'x': 2}

draw_point(*point_foo)
draw_point(**point_bar)

Raccourci très utile car les listes, tuples et dict sont largement utilisés comme conteneurs.

ROT13 est un codage valide pour le code source, lorsque vous utilisez la bonne déclaration de codage en haut du fichier de code:

#!/usr/bin/env python
# -*- coding: rot13 -*-

cevag "Uryyb fgnpxbiresybj!".rapbqr("rot13")

Créer de nouveaux types de manière entièrement dynamique

>>> NewType = type("NewType", (object,), {"x": "hello"})
>>> n = NewType()
>>> n.x
"hello"

qui est exactement le même que

>>> class NewType(object):
>>>     x = "hello"
>>> n = NewType()
>>> n.x
"hello"

Probablement pas la chose la plus utile, mais agréable à savoir.

Edit : le nom fixe du nouveau type devrait être NewTypeexactement la même chose qu'avec l' classinstruction.

Modifier : Ajustement du titre pour décrire plus précisément la fonction.

Gestionnaires de contexte et withdéclaration " "

Introduit dans PEP 343 , un gestionnaire de contexte est un objet qui agit comme un contexte d'exécution pour une suite d'instructions.

Comme la fonctionnalité utilise de nouveaux mots clés, elle est introduite progressivement: elle est disponible en Python 2.5 via la __future__directive. Python 2.6 et supérieur (y compris Python 3) le propose par défaut.

J'ai beaucoup utilisé la déclaration "with" car je pense que c'est une construction très utile, voici une démo rapide:

from __future__ import with_statement

with open('foo.txt', 'w') as f:
    f.write('hello!')

Ce qui se passe ici dans les coulisses, c'est que l' instruction "with" appelle les méthodes spéciales __enter__et __exit__sur l'objet fichier. Les détails des exceptions sont également transmis à __exit__si une exception a été déclenchée à partir du corps de l'instruction with, permettant ainsi la gestion des exceptions.

Dans ce cas particulier, cela a pour effet de garantir la fermeture du fichier lorsque l'exécution sort du cadre de la withsuite, que cela se produise normalement ou qu'une exception soit levée. Il s'agit essentiellement d'un moyen d'abstraire le code de gestion des exceptions commun.

D'autres cas d'utilisation courants pour cela incluent le verrouillage avec des threads et des transactions de base de données.

Les dictionnaires ont une méthode get ()

Les dictionnaires ont une méthode 'get ()'. Si vous faites d ['clé'] et que la clé n'est pas là, vous obtenez une exception. Si vous faites d.get ('clé'), vous récupérez Aucun si 'clé' n'est pas là. Vous pouvez ajouter un deuxième argument pour récupérer cet élément au lieu de Aucun, par exemple: d.get ('key', 0).

C'est génial pour des choses comme l'addition de nombres:

sum[value] = sum.get(value, 0) + 1

Descripteurs

Ils sont la magie derrière tout un tas de fonctionnalités principales de Python.

Lorsque vous utilisez l'accès en pointillé pour rechercher un membre (par exemple, xy), Python recherche d'abord le membre dans le dictionnaire d'instances. S'il n'est pas trouvé, il le recherche dans le dictionnaire de classe. S'il le trouve dans le dictionnaire de classe et que l'objet implémente le protocole de descripteur, au lieu de simplement le renvoyer, Python l'exécute. Un descripteur est une classe qui implémente les __get__, __set__ou les __delete__méthodes.

Voici comment implémenter votre propre version (en lecture seule) de la propriété à l'aide de descripteurs:

class Property(object):
    def __init__(self, fget):
        self.fget = fget

    def __get__(self, obj, type):
        if obj is None:
            return self
        return self.fget(obj)

et vous l'utiliseriez comme la propriété intégrée ():

class MyClass(object):
    @Property
    def foo(self):
        return "Foo!"

Les descripteurs sont utilisés en Python pour implémenter des propriétés, des méthodes liées, des méthodes statiques, des méthodes de classe et des emplacements, entre autres. Les comprendre permet de comprendre facilement pourquoi beaucoup de choses qui ressemblaient auparavant à des «bizarreries» de Python sont ce qu'elles sont.

Raymond Hettinger a un excellent tutoriel qui fait un bien meilleur travail de description que moi.

Affectation conditionnelle

x = 3 if (y == 1) else 2

Il fait exactement ce que cela ressemble: "attribuez 3 à x si y est 1, sinon affectez 2 à x". Notez que les parens ne sont pas nécessaires, mais je les aime pour la lisibilité. Vous pouvez également l'enchaîner si vous avez quelque chose de plus compliqué:

x = 3 if (y == 1) else 2 if (y == -1) else 1

Mais à un certain point, ça va un peu trop loin.

Notez que vous pouvez utiliser if ... else dans n'importe quelle expression. Par exemple:

(func1 if y == 1 else func2)(arg1, arg2) 

Ici func1 sera appelé si y est 1 et func2, sinon. Dans les deux cas, la fonction correspondante sera appelée avec les arguments arg1 et arg2.

De façon analogue, ce qui suit est également valable:

x = (class1 if y == 1 else class2)(arg1, arg2)

où class1 et class2 sont deux classes.

Doctest : documentation et tests unitaires à la fois.

Exemple extrait de la documentation Python:

def factorial(n):
    """Return the factorial of n, an exact integer >= 0.

    If the result is small enough to fit in an int, return an int.
    Else return a long.

    >>> [factorial(n) for n in range(6)]
    [1, 1, 2, 6, 24, 120]
    >>> factorial(-1)
    Traceback (most recent call last):
        ...
    ValueError: n must be >= 0

    Factorials of floats are OK, but the float must be an exact integer:
    """

    import math
    if not n >= 0:
        raise ValueError("n must be >= 0")
    if math.floor(n) != n:
        raise ValueError("n must be exact integer")
    if n+1 == n:  # catch a value like 1e300
        raise OverflowError("n too large")
    result = 1
    factor = 2
    while factor <= n:
        result *= factor
        factor += 1
    return result

def _test():
    import doctest
    doctest.testmod()    

if __name__ == "__main__":
    _test()

Formatage nommé

Le formatage% prend un dictionnaire (applique également la validation% i /% s etc.).

>>> print "The %(foo)s is %(bar)i." % {'foo': 'answer', 'bar':42}
The answer is 42.

>>> foo, bar = 'question', 123

>>> print "The %(foo)s is %(bar)i." % locals()
The question is 123.

Et comme locals () est également un dictionnaire, vous pouvez simplement le passer comme dict et avoir des sous-positions% à partir de vos variables locales. Je pense que cela est mal vu, mais simplifie les choses ..

Mise en forme d'un nouveau style

>>> print("The {foo} is {bar}".format(foo='answer', bar=42))

Pour ajouter plus de modules python (en particulier ceux de tiers), la plupart des gens semblent utiliser des variables d'environnement PYTHONPATH ou ils ajoutent des liens symboliques ou des répertoires dans leurs répertoires de packages de sites. Une autre façon consiste à utiliser des fichiers * .pth. Voici l'explication officielle du doc ​​python:

"Le moyen le plus pratique [pour modifier le chemin de recherche de python] consiste à ajouter un fichier de configuration de chemin à un répertoire qui se trouve déjà sur le chemin de Python, généralement dans le répertoire ... / site-packages /. Les fichiers de configuration de chemin ont une extension de .pth et chaque ligne doit contenir un seul chemin d'accès qui sera ajouté à sys.path. (Étant donné que les nouveaux chemins d'accès sont ajoutés à sys.path, les modules des répertoires ajoutés ne remplaceront pas les modules standard. Cela signifie que vous ne pouvez pas utiliser ce mécanisme pour l'installation de versions fixes de modules standard.) "

Clause d' exception sinon :

try:
  put_4000000000_volts_through_it(parrot)
except Voom:
  print "'E's pining!"
else:
  print "This parrot is no more!"
finally:
  end_sketch()

L'utilisation de la clause else est préférable à l'ajout de code supplémentaire à la clause try, car elle évite d'attraper accidentellement une exception qui n'a pas été déclenchée par le code protégé par l'instruction try ... except.

Voir http://docs.python.org/tut/node10.html

Relancer les exceptions :

# Python 2 syntax
try:
    some_operation()
except SomeError, e:
    if is_fatal(e):
        raise
    handle_nonfatal(e)

# Python 3 syntax
try:
    some_operation()
except SomeError as e:
    if is_fatal(e):
        raise
    handle_nonfatal(e)

L'instruction 'raise' sans argument dans un gestionnaire d'erreur indique à Python de relancer l'exception avec le retraçage d'origine intact , vous permettant de dire "oh, désolé, désolé, je ne voulais pas attraper cela, désolé, désolé. "

Si vous souhaitez imprimer, stocker ou jouer avec le traçage d'origine, vous pouvez l'obtenir avec sys.exc_info (), et l'imprimer comme le ferait Python se fait avec le module 'traçage'.

Messages principaux :)

import this
# btw look at this module's source :)

Décrypté :

Le Zen de Python, par Tim Peters

Beau, c'est mieux que laid.
Explicite vaut mieux qu'implicite.
Simple, c'est mieux que complexe.
Complexe vaut mieux que compliqué.
L'appartement est meilleur que l'emboîtement.
Clairsemé vaut mieux que dense.
La lisibilité compte.
Les cas spéciaux ne sont pas assez spéciaux pour enfreindre les règles.
Bien que la praticité l'emporte sur la pureté.
Les erreurs ne doivent jamais passer silencieusement.
Sauf silence explicite. Si la mise en œuvre est facile à expliquer, ce peut être une bonne idée. Les espaces de noms sont une excellente idée de klaxon - faisons-en plus!
Face à l'ambiguïté, refusez la tentation de deviner. Il devrait y avoir une - et de préférence une seule - manière évidente de le faire.
Bien que cette façon ne soit pas évidente au début, sauf si vous êtes néerlandais.
C'est mieux que jamais.
Bien que jamais ne soit souvent meilleur quedroit maintenant.
Si l'implémentation est difficile à expliquer, c'est une mauvaise idée.

Achèvement de l'onglet d'interpréteur interactif

try:
    import readline
except ImportError:
    print "Unable to load readline module."
else:
    import rlcompleter
    readline.parse_and_bind("tab: complete")


>>> class myclass:
...    def function(self):
...       print "my function"
... 
>>> class_instance = myclass()
>>> class_instance.<TAB>
class_instance.__class__   class_instance.__module__
class_instance.__doc__     class_instance.function
>>> class_instance.f<TAB>unction()

Vous devrez également définir une variable d'environnement PYTHONSTARTUP.

Compréhensions de listes imbriquées et expressions de générateur:

[(i,j) for i in range(3) for j in range(i) ]    
((i,j) for i in range(4) for j in range(i) )

Ceux-ci peuvent remplacer d'énormes morceaux de code en boucle imbriquée.

Surcharge d'opérateur pour le setbuiltin:

>>> a = set([1,2,3,4])
>>> b = set([3,4,5,6])
>>> a | b # Union
{1, 2, 3, 4, 5, 6}
>>> a & b # Intersection
{3, 4}
>>> a < b # Subset
False
>>> a - b # Difference
{1, 2}
>>> a ^ b # Symmetric Difference
{1, 2, 5, 6}

Plus de détails dans la référence de bibliothèque standard: Définir les types