Voici un résumé des spécifications du langage Python moins connues (et égoïstes).
La classification débutant / intermédiaire / avancé est appropriée.
J'ajouterai s'il y en a d'autres.
Les opérations de nombres complexes peuvent être effectuées en standard. Les indices utilisent j au lieu de i.
>>> c1 = 1 + 1j
>>> c2 = 1 - 2j
>>> c1 + c2
(2-1j)
>>> c1 * c2
(3-1j)
>>> c1 / c2
(-0.2+0.6j)
Vous pouvez écrire plusieurs for..in dans la notation d'inclusion.
>>> a = range(3)
>>> b = range(4)
>>> [x + y for x in a for y in b]
[0, 1, 2, 3, 1, 2, 3, 4, 2, 3, 4, 5]
Vous pouvez récupérer des éléments tels que des listes tous les n en écrivant comme suit.
>>> a = list(range(20))
>>> a[::2]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
Vous pouvez faire une copie de la liste sans passer un index à la syntaxe de la tranche.
>>> a = range(10)
>>> b = a
>>> b
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b is a #b et a sont le même objet
True
>>> c = a[:]
>>> c
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> c is a #b et a sont des objets séparés
False
Ellipsis
... est traité comme un objet représentant une "abréviation".
Pour plus d'informations, voir ici.
>>> ...
Ellipsis
>>> bool(...)
True
En écrivant *, dans la définition de la fonction, vous pouvez vous assurer que les arguments suivants doivent être appelés comme arguments de mot-clé.
>>> def f(a, *, b):
... pass
...
>>> f(1)
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: f() missing 1 required keyword-only argument: 'b'
>>> f(1,2)
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: f() takes 1 positional argument but 2 were given
>>> f(1,b=2)
>>>
Vous pouvez annoter des arguments de fonction et renvoyer des valeurs. Puisqu'il s'agit d'une annotation à utiliser dans des documents, etc., aucune erreur ne se produira même si un objet d'un type différent est donné.
>>> def f(x : int, y : int) -> int:
... return x + y
...
>>> f(2, 3)
5
>>> f('hoge', 'fuga') #N'entraîne pas d'erreur
'hogefuga'
global
global vous permet de définir des variables globales au moment de l'exécution à partir de n'importe quelle portée.
>>> def f():
... global a
... a = 1
...
>>> a #Ici a est indéfini
Traceback (most recent call last):
File "<input>", line 1, in <module>
NameError: name 'a' is not defined
>>> f() #La variable globale a est définie en appelant f
>>> a
1
nonlocal
nonlocal permet l'affectation à des variables appartenant à la portée externe.
Vous pouvez facilement faire une fermeture.
>>> def make_counter():
... count = 0
...
... def counter():
... nonlocal count
... count += 1
... return count
...
... return counter
...
>>> c = make_counter()
>>> c(), c(), c()
(1, 2, 3)
Vous pouvez créer un décorateur avec des arguments en écrivant "une fonction qui reçoit une fonction et renvoie une fonction".
Le @ route ('/') etc. de Flask semble être implémenté en utilisant ceci.
>>> def greet(before, after):
... def decorator(func):
... def wrapper(*args, **kwargs):
... print(before)
... func(*args, **kwargs)
... print(after)
... return wrapper
... return decorator
...
>>> @greet('Hi.', 'Bye.')
... def introduce(name):
... print('I am ' + name + '.')
...
>>> introduce('yubessy')
Hi.
I am yubessy.
Bye.
Vous pouvez écrire un décorateur qui enveloppe la classe. Voici un exemple d'implémentation d'un singleton simple.
>>> def singleton(cls):
... instances = {}
... def getinstance(*args, **kwargs):
... if cls not in instances:
... instances[cls] = cls(*args, **kwargs)
... return instances[cls]
... return getinstance
...
>>> @singleton
... class C(object):
... pass
...
>>> c1 = C()
>>> c2 = C()
>>> c1 is c2
True
yield from
Vous pouvez créer un générateur qui renvoie les valeurs d'autres itérateurs.
>>> def g():
... yield from range(5)
... yield from range(5, 10)
...
>>> [i for i in g()]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
raise from
Conservez l'exception de l'expéditeur lors du chaînage des exceptions.
>>> try:
... raise Exception('e1') from Exception('e2')
... except Exception as e:
... print(e.__cause__)
...
e2
Recommended Posts