Python interesante y útil

He estado programando en Python durante varios años, sin embargo, recientemente me di cuenta de que pasé por alto muchos trucos útiles y momentos interesantes, tal vez no soy el único, así que decidí enumerarlos aquí, espero que estos trucos sean útiles para alguien en el trabajo o me ayuden a conocernos con este lenguaje más cerca

Como en muchos idiomas en Python, 1 es equivalente a True y 0 es False, es decir.

1 == True. 

Parecería, y ¿qué hay de malo en eso? Sin embargo, esto tiene algunos efectos secundarios asociados con el hecho de que los mismos objetos deben tener los mismos hashes, por lo que no podrá agrupar la clave 1 y True en un solo diccionario.

  >>> a = {1: "one", 0: "zero", True: "true", False: "false"} # -> {1: 'true', 0: 'false'} 

También permite las siguientes operaciones:

  >>> print(2 * False + True) # -> 1 

En este ejemplo, las cadenas se usaron como valores de diccionario, sin embargo, a menudo quiero usarlas como claves de diccionario, siempre me molestó que al crear un diccionario usando llaves, necesita especificar las cadenas entre comillas, me gustaría omitirlas, esto es posible si crea diccionario a través del constructor dict ().

  >>> {"one": 1, "two": 2, "three": 3} == dict(one=1, two=2, three=3) # -> True 

Además, no solo se crean diccionarios, sino también conjuntos (conjuntos) utilizando llaves.

  >>> a = {1, 2, 3} 

Para combinar los dos conjuntos, por alguna razón quiero usar el operador +, probablemente debido a la forma en que se concatenan las cadenas. Sin embargo, python no admite este operador para conjuntos. Pero, por supuesto, esto no significa que siempre tengamos que usar funciones, los creadores abordaron este problema de manera más sistemática y agregaron soporte para operaciones básicas en conjuntos (no solo uniones) al lenguaje y los "colgaron" en operadores lógicos .

 a = {1, 2, 3} b = {0, 2, 4} print(a & b) # -> {2} print(a | b) # -> {0, 1, 2, 3, 4} print(a ^ b) # -> {0, 1, 3, 4} print(a - b) # -> {1, 3},    #     

Continuando con la conversación sobre los diccionarios, comenzando con la versión 3.7, la especificación del idioma garantiza que los diccionarios preserven el orden de inserción de los elementos.

www.python.org/downloads/release/python-370
mail.python.org/pipermail/python-dev/2017-December/151283.html

 d = dict(zero='Cero', one='Uno', two='Dos', three='Tres', four='Cuatro', five='Cinco', six='Seis', seven='Siete', eight='Ocho', night='Nueve') for index, (key, value) in enumerate(d.items()): print(f"{index} is {key} in England and {value} in Spain") 

Preste atención a la línea de salida, comienza con el prefijo f: este es un tipo especial de líneas introducido en Python 3.6 .

Hay tres tipos de cadenas en el lenguaje: regular, indicado por comillas sin prefijos, sin procesar \ sin procesar (sin procesar), en el que los caracteres especiales, como \ n, no se procesan ni se insertan como texto y líneas f.

Fueron creados para simplificar la salida, python admite una gran cantidad de métodos de salida:

 print("result" + str(2)) #   , python   #      #  ,     print("result", 2) # print      , #        , #        , #      print("result %d" % 2) # %-,      C. print("result %d %.2f" % (2, 2)) # https://docs.python.org/3.4/library/string.html#formatspec print("result %(name)s" % {"name": 2}) #      print("{}".format(2)) #      format() #       print("{0} {1} {0}".format(1, 2)) #          #     #     #        ,    print("{} {}".format(2)) # -> IndexError: tuple index out of range print("{0} {0}".format(2, 3)) # -> 2 2       #     from math import pi #         print("{:.2f}".format(pi)) # -> 3.14 from string import Template #      s = Template("result $res") #       print(s.substitute(res = [3, 4])) 

Ahora agregó más y líneas f. Todas las variables del ámbito están disponibles en ellas, puede llamar a funciones, obtener elementos por clave, además, admiten cadenas de formato.

 from math import pi result = 4 name = "user" print(f"{name:84s} pi= {pi:.2f}, result={result}, {name[2]}") # -> user pi= 3.14, result=4, e from datetime import datetime print(f"{datetime.now():%Y:%m-%d}") 

Son más rápidos que todos los demás métodos de salida, por lo que si python3.6 está disponible para usted, se recomienda que los use.

Una de las piezas más geniales de Python: no se empaquetan y desempaquetan objetos y primitivas, sino parámetros y colecciones.

 def func(*argv, **kwargs) 

Sin embargo, hay un defecto arquitectónico en la implementación:

• argv: una tupla, sus valores no se pueden cambiar, los valores no se pueden agregar o eliminar
• kwargs es un diccionario mutable, por lo que no es posible el almacenamiento en caché

El inconveniente, por supuesto, no es grande, pero sigue siendo desagradable que no puede transferir directamente kwargs a un caché basado en diccionario, por otro lado, si agrega una lista a una tupla, entonces dicha tupla tampoco se puede agregar al diccionario.

Los conjuntos también se crean sobre la base de una tabla hash, lo que significa que los valores deben ser hash, además, el conjunto en sí es un tipo mutable y no hash, hay un tipo especial de conjunto congelado: un conjunto inmutable (no me pregunte por qué es necesario).

Discutieron la creación del tipo frozendict, pero aún no lo han agregado (aunque ya tiene al menos una aplicación, como kwargs). Para un diccionario inmutable, namedtuple tiene que ser eliminado . Y también para notas y clases sin pretensiones.

¿Quién en sus años de estudiante / escuela escribió ciclos para mostrar los valores de la matriz y estaba furioso por la coma al final, cada vez que decidió anotar o reescribir para ser hermoso, y solo en el curso 2-3 aprendió sobre el método de combinación? ¿O soy el único?

Una de las características desagradables del método de combinación para cadenas es que funciona solo con elementos de cadena, si la colección tiene al menos una no cadena, debe usar una expresión generadora, que parece una solución demasiado complicada para una tarea tan simple, sin embargo, hay una manera de simplificar la salida de los valores de lista (sin corchetes) .

 a = list(range(5)) print(" ".join(a)) # -> TypeError: sequence item 0: expected str instance, int found print(" ".join(str(i) for i in a)) # -> 0 1 2 3 4 print(*a) # -> 0 1 2 3 4 

Como las cadenas también son colecciones, también se pueden "unir".

 print('-'.join("hello")) # -> hello 

Considere la línea del ejemplo anterior.

 print(" ".join(str(i) for i in a)) # -> 0 1 2 3 4 

La expresión del generador se pasa a la función de unión sin corchetes; se pueden omitir paréntesis para simplificar la lectura del código. Python se encarga de la expresividad.

 print(sum(i**2 for i in range(10))) # -> 285 

Además, se pueden omitir paréntesis al crear tuplas:

 article = "python", 2018, "LinearLeopard" #   theme, year, author = "python", 2018, "LinearLeopard"#   theme, year, _ = "python", 2018, "LinearLeopard" #     #    # ,  , #  -   , #    #  theme, _, _ = "python", 2018, "LinearLeopard" #    theme, *, author = "python", 2018, "LinearLeopard" #    # ,   #  , # ,  #   #   

El asterisco también se puede usar en declaraciones de funciones, por lo que puede crear parámetros que solo se pueden especificar por clave .

 def sortwords(*wordlist, case_sensitive=False): 

Puede pasar tantos parámetros como desee sin temor a que uno de ellos sea percibido como el valor del parámetro case_sensitive.

Es posible y así.

 def func(first, second, *, kwonly): 

Veremos más de cerca cómo simplemente * difiere de * args.

 def func(first, second, *, kwonly=True): print(first, second, kwonly) def func2(first, second, *args, kwonly=True): print(first, second, *args, kwonly) func(1) #-> TypeError: func() missing 1 required positional argument: 'second' func(1, 2) #-> 1 2 True func(1, 2, False) #-> TypeError: func() takes 2 positional arguments but 3 were given #  *    ,  #        #   func(1, 2, kwonly=False) #-> 1 2 False func2(1, 2, False) #-> 1 2 False True # *args      # ,       #    (>2)  #  

Una característica interesante está asociada con los parámetros predeterminados: se calculan en la etapa de compilación del módulo en bytecode, por lo que es mejor no usar tipos mutables allí. Declaramos una función que agrega un elemento al final de la lista, si se omite el segundo argumento, la función devuelve una nueva lista que contiene solo este elemento.

 def add_to(elem, collection=[]): collection.append(elem) return collection a = ["a", "c"] print(add_to("b", a)) # -> ['a', 'c', 'b'] print(add_to("a")) # -> ['a'] print(add_to("b")) # -> ['a', 'b']   'a'? 

Los valores predeterminados se almacenan en el campo __defaults__, puede averiguar qué hay allí en cualquier momento.

 print(add_to.__defaults__) # -> (['a', 'b'],) 

Como el argumento predeterminado (una lista vacía) se creó en el momento en que se inició el programa y no se volvió a crear cada vez, obtuvimos exactamente este comportamiento.

Puede corregir este comportamiento si hace que el valor predeterminado sea un tipo inmutable y cree una lista en el cuerpo de la función:

 def add_to(elem, collection=None): collection = collection or [] collection.append(elem) return collection 

Presta atención al comando

 collection = collection or [] 

Este es un análogo más corto (y menos claro, aunque no para todos)

 collection = collection if collection else [] 

Enlace a la siguiente parte