Consejos y trucos de mi canal de Telegram @pythonetc, febrero de 2019

Es una nueva selección de consejos y trucos sobre Python y la programación de mi canal de Telegram @pythonetc.

Publicaciones anteriores

Comparación de estructuras

En ocasiones, desea comparar estructuras complejas en pruebas que ignoran algunos valores. Por lo general, se puede hacer comparando valores particulares con la estructura:

>>> d = dict(a=1, b=2, c=3) >>> assert d['a'] == 1 >>> assert d['c'] == 3 

Sin embargo, puede crear un valor especial que informa que es igual a cualquier otro valor:

 >>> assert d == dict(a=1, b=ANY, c=3) 

Eso se puede hacer fácilmente definiendo el método __eq__ :

 >>> class AnyClass: ... def __eq__(self, another): ... return True ... >>> ANY = AnyClass() 

sys.stdout es un contenedor que le permite escribir cadenas en lugar de bytes sin formato. La cadena se codifica automáticamente mediante sys.stdout.encoding :

 >>> _ = sys.stdout.write('Straße\n') Straße >>> sys.stdout.encoding 'UTF-8' 

sys.stdout.encoding es de solo lectura y es igual a la codificación predeterminada de Python, que se puede cambiar configurando la variable de entorno PYTHONIOENCODING :

 $ PYTHONIOENCODING=cp1251 python3 Python 3.6.6 (default, Aug 13 2018, 18:24:23) [GCC 4.8.5 20150623 (Red Hat 4.8.5-28)] on linux Type "help", "copyright", "credits" or "license" for more information. >>> import sys >>> sys.stdout.encoding 'cp1251' 

Si desea escribir bytes en stdout , puede omitir la codificación automática accediendo al búfer envuelto con sys.stdout.buffer :

 >>> sys.stdout <_io.TextIOWrapper name='<stdout>' mode='w' encoding='cp1251'> >>> sys.stdout.buffer <_io.BufferedWriter name='<stdout>'> >>> _ = sys.stdout.buffer.write(b'Stra\xc3\x9fe\n') Straße 

sys.stdout.buffer también es un contenedor que almacena en búfer por usted. Se puede sys.stdout.buffer.raw accediendo al controlador de archivos sin sys.stdout.buffer.raw con sys.stdout.buffer.raw :

 >>> _ = sys.stdout.buffer.raw.write(b'Stra\xc3\x9fe') Straße 

Elipsis constante

Python tiene una lista muy corta de constantes integradas. Uno de ellos es Ellipsis que también se puede escribir como ... Esta constante no tiene un significado especial para el intérprete, pero se usa en lugares donde dicha sintaxis parece apropiada.

numpy support Ellipsis como argumento __getitem__ , por ejemplo, x[...] devuelve todos los elementos de x .

PEP 484 define un significado adicional: Callable[..., type] es una forma de definir un tipo de invocables sin tipos de argumentos especificados.

Finalmente, puede usar ... para indicar que la función aún no está implementada. Este es un código Python completamente válido:

 def x(): ... 

Sin embargo, en Python 2 Los Ellipsis no se pueden escribir como ... La única excepción es a[...] que significa a[Ellpsis] .

Todas las siguientes sintaxis son válidas para Python 3, pero solo la primera línea es válida para Python 2:

 a[...] a[...:2:...] [..., ...] {...:...} a = ... ... is ... def a(x=...): ... 

Reimportación de módulos

Los módulos ya importados no se volverán a cargar. import foo simplemente no hace nada. Sin embargo, resultó útil volver a importar módulos mientras se trabaja en un entorno interactivo. La forma correcta de hacer esto en Python 3.4+ es usar importlib :

 In [1]: import importlib In [2]: with open('foo.py', 'w') as f: ...: f.write('a = 1') ...: In [3]: import foo In [4]: foo.a Out[4]: 1 In [5]: with open('foo.py', 'w') as f: ...: f.write('a = 2') ...: In [6]: foo.a Out[6]: 1 In [7]: import foo In [8]: foo.a Out[8]: 1 In [9]: importlib.reload(foo) Out[9]: <module 'foo' from '/home/v.pushtaev/foo.py'> In [10]: foo.a Out[10]: 2 

ipython también tiene la extensión de autoreload que automáticamente autoreload importar módulos si es necesario:

 In [1]: %load_ext autoreload In [2]: %autoreload 2 In [3]: with open('foo.py', 'w') as f: ...: f.write('print("LOADED"); a=1') ...: In [4]: import foo LOADED In [5]: foo.a Out[5]: 1 In [6]: with open('foo.py', 'w') as f: ...: f.write('print("LOADED"); a=2') ...: In [7]: import foo LOADED In [8]: foo.a Out[8]: 2 In [9]: with open('foo.py', 'w') as f: ...: f.write('print("LOADED"); a=3') ...: In [10]: foo.a LOADED Out[10]: 3 

\ G

En algunos idiomas, puede usar la aserción \G Coincide en la posición donde finaliza el partido anterior. Eso permite escribir autómatas finitos que recorren la cadena palabra por palabra (donde la palabra está definida por la expresión regular).

Sin embargo, no hay tal cosa en Python. La solución adecuada es rastrear manualmente la posición y pasar la subcadena a las funciones regex:

 import re import json text = '<a><b>foo</b><c>bar</c></a><z>bar</z>' regex = '^(?:<([az]+)>|</([az]+)>|([az]+))' stack = [] tree = [] pos = 0 while len(text) > pos: error = f'Error at {text[pos:]}' found = re.search(regex, text[pos:]) assert found, error pos += len(found[0]) start, stop, data = found.groups() if start: tree.append(dict( tag=start, children=[], )) stack.append(tree) tree = tree[-1]['children'] elif stop: tree = stack.pop() assert tree[-1]['tag'] == stop, error if not tree[-1]['children']: tree[-1].pop('children') elif data: stack[-1][-1]['data'] = data print(json.dumps(tree, indent=4)) 

En el ejemplo anterior, podemos ahorrar algo de tiempo evitando cortar la cadena una y otra vez, pero pidiéndole al módulo re que busque desde una posición diferente.

Eso requiere algunos cambios. Primero, re.search no admite la búsqueda desde una posición personalizada, por lo que tenemos que compilar la expresión regular manualmente. En segundo lugar, ^ significa el comienzo real de la cadena, no la posición donde comenzó la búsqueda, por lo que debemos verificar manualmente que la coincidencia ocurrió en la misma posición.

 import re import json text = '<a><b>foo</b><c>bar</c></a><z>bar</z>' * 10 def print_tree(tree): print(json.dumps(tree, indent=4)) def xml_to_tree_slow(text): regex = '^(?:<([az]+)>|</([az]+)>|([az]+))' stack = [] tree = [] pos = 0 while len(text) > pos: error = f'Error at {text[pos:]}' found = re.search(regex, text[pos:]) assert found, error pos += len(found[0]) start, stop, data = found.groups() if start: tree.append(dict( tag=start, children=[], )) stack.append(tree) tree = tree[-1]['children'] elif stop: tree = stack.pop() assert tree[-1]['tag'] == stop, error if not tree[-1]['children']: tree[-1].pop('children') elif data: stack[-1][-1]['data'] = data def xml_to_tree_slow(text): regex = '^(?:<([az]+)>|</([az]+)>|([az]+))' stack = [] tree = [] pos = 0 while len(text) > pos: error = f'Error at {text[pos:]}' found = re.search(regex, text[pos:]) assert found, error pos += len(found[0]) start, stop, data = found.groups() if start: tree.append(dict( tag=start, children=[], )) stack.append(tree) tree = tree[-1]['children'] elif stop: tree = stack.pop() assert tree[-1]['tag'] == stop, error if not tree[-1]['children']: tree[-1].pop('children') elif data: stack[-1][-1]['data'] = data return tree _regex = re.compile('(?:<([az]+)>|</([az]+)>|([az]+))') def _error_message(text, pos): return text[pos:] def xml_to_tree_fast(text): stack = [] tree = [] pos = 0 while len(text) > pos: error = f'Error at {text[pos:]}' found = _regex.search(text, pos=pos) begin, end = found.span(0) assert begin == pos, _error_message(text, pos) assert found, _error_message(text, pos) pos += len(found[0]) start, stop, data = found.groups() if start: tree.append(dict( tag=start, children=[], )) stack.append(tree) tree = tree[-1]['children'] elif stop: tree = stack.pop() assert tree[-1]['tag'] == stop, _error_message(text, pos) if not tree[-1]['children']: tree[-1].pop('children') elif data: stack[-1][-1]['data'] = data return tree print_tree(xml_to_tree_fast(text)) 

Resultado:

 In [1]: from example import * In [2]: %timeit xml_to_tree_slow(text) 356 µs ± 16.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) In [3]: %timeit xml_to_tree_fast(text) 294 µs ± 6.15 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each) 

Función redonda

La publicación de hoy está escrita por orsinium , el autor de @itgram_channel.

La función redondear redondea un número a una precisión dada en dígitos decimales.

 >>> round(1.2) 1 >>> round(1.8) 2 >>> round(1.228, 1) 1.2 

También puede configurar una precisión negativa:

 >>> round(413.77, -1) 410.0 >>> round(413.77, -2) 400.0 

round devuelve el valor del tipo de número de entrada:

 >>> type(round(2, 1)) <class 'int'> >>> type(round(2.0, 1)) <class 'float'> >>> type(round(Decimal(2), 1)) <class 'decimal.Decimal'> >>> type(round(Fraction(2), 1)) <class 'fractions.Fraction'> 

Para sus propias clases, puede definir el procesamiento redondo con el método __round__ :

 >>> class Number(int): ... def __round__(self, p=-1000): ... return p ... >>> round(Number(2)) -1000 >>> round(Number(2), -2) -2 

Los valores se redondean al múltiplo más cercano de 10 ** (-precision) . Por ejemplo, para precision=1 valor se redondeará a múltiplo de 0.1: round(0.63, 1) devuelve 0.6 . Si dos múltiplos están igualmente cerca, el redondeo se realiza hacia la opción par:

 >>> round(0.5) 0 >>> round(1.5) 2 

A veces el redondeo de carrozas puede ser un poco sorprendente:

 >>> round(2.85, 1) 2.9 

Esto se debe a que la mayoría de las fracciones decimales no se pueden representar exactamente como un flotante (https://docs.python.org/3.7/tutorial/floatingpoint.html):

 >>> format(2.85, '.64f') '2.8500000000000000888178419700125232338905334472656250000000000000' 

Si desea redondear a la mitad, puede usar decimal.Decimal .

 >>> from decimal import Decimal, ROUND_HALF_UP >>> Decimal(1.5).quantize(0, ROUND_HALF_UP) Decimal('2') >>> Decimal(2.85).quantize(Decimal('1.0'), ROUND_HALF_UP) Decimal('2.9') >>> Decimal(2.84).quantize(Decimal('1.0'), ROUND_HALF_UP) Decimal('2.8')