python tamaño - ¿Cómo descomprimir una lista de tuplas en listas individuales?





como recorrer (3)


Si quieres una lista de listas:

>>> [list(t) for t in zip(*l)]
[[1, 3, 8], [2, 4, 9]]

Si una lista de tuplas está bien:

>>> zip(*l)
[(1, 3, 8), (2, 4, 9)]

Posible duplicado:
Una función de transposición / descompresión en Python

Tengo una lista de tuplas, donde quiero descomprimir esta lista en dos listas independientes. Estoy buscando alguna operación estandarizada en Python.

>>> l = [(1,2), (3,4), (8,9)]
>>> f_xxx (l)
[ [1, 3, 8], [2, 4, 9] ] 

Estoy buscando una forma concisa y pitónica para lograr esto.

Básicamente, estoy buscando la operación inversa de la función zip() .




Use zip(*list) :

>>> l = [(1,2), (3,4), (8,9)]
>>> zip(*l)
[(1, 3, 8), (2, 4, 9)]

La función zip() empareja los elementos de todas las entradas, comenzando con los primeros valores, luego el segundo, etc. Al usar *l , aplica todas las tuplas en l como argumentos separados a la función zip() , por lo que los pares zip() hasta 1 con 3 con 8 primero, luego 2 con 4 y 9 . Esos coinciden muy bien con las columnas, o la transposición de l .




¿Cómo verifico si existe un archivo, usando Python, sin usar una declaración de prueba?

Ahora disponible desde Python 3.4, importe y cree una instancia de un objeto de Path con el nombre del archivo, y verifique el método is_file (tenga en cuenta que esto devuelve True para los enlaces simbólicos que también apuntan a archivos normales):

>>> from pathlib import Path
>>> Path('/').is_file()
False
>>> Path('/initrd.img').is_file()
True
>>> Path('/doesnotexist').is_file()
False

Si estás en Python 2, puedes realizar una backport del módulo pathlib desde pypi, pathlib2 o, de lo contrario, verificar isfile desde el módulo os.path :

>>> import os
>>> os.path.isfile('/')
False
>>> os.path.isfile('/initrd.img')
True
>>> os.path.isfile('/doesnotexist')
False

Ahora, lo anterior es probablemente la mejor respuesta directa pragmática aquí, pero existe la posibilidad de una condición de carrera (dependiendo de lo que intenta lograr) y el hecho de que la implementación subyacente usa un try , pero los usos de Python lo try en todas partes. implementación.

Debido a que los usos de Python try todas partes, realmente no hay razón para evitar una implementación que lo use.

Pero el resto de esta respuesta intenta considerar estas advertencias.

Respuesta más larga, mucho más pedante.

Disponible desde Python 3.4, use el nuevo objeto Path en pathlib . Tenga en cuenta que .exists no es del todo correcto, porque los directorios no son archivos (excepto en el sentido de UNIX que todo es un archivo).

>>> from pathlib import Path
>>> root = Path('/')
>>> root.exists()
True

Así que necesitamos usar is_file :

>>> root.is_file()
False

Aquí está la ayuda en is_file :

is_file(self)
    Whether this path is a regular file (also True for symlinks pointing
    to regular files).

Así que vamos a obtener un archivo que sabemos que es un archivo:

>>> import tempfile
>>> file = tempfile.NamedTemporaryFile()
>>> filepathobj = Path(file.name)
>>> filepathobj.is_file()
True
>>> filepathobj.exists()
True

De forma predeterminada, NamedTemporaryFile elimina el archivo cuando está cerrado (y se cerrará automáticamente cuando no haya más referencias a él).

>>> del file
>>> filepathobj.exists()
False
>>> filepathobj.is_file()
False

Sin embargo, si profundiza en la implementación , verá que is_file usa try :

def is_file(self):
    """
    Whether this path is a regular file (also True for symlinks pointing
    to regular files).
    """
    try:
        return S_ISREG(self.stat().st_mode)
    except OSError as e:
        if e.errno not in (ENOENT, ENOTDIR):
            raise
        # Path doesn't exist or is a broken symlink
        # (see https://bitbucket.org/pitrou/pathlib/issue/12/)
        return False

Condiciones de carrera: ¿Por qué nos gusta probar?

Nos gusta try porque evita condiciones de carrera. Con el try , simplemente intenta leer su archivo, esperando que esté allí, y si no, puede detectar la excepción y realizar cualquier comportamiento de recuperación que tenga sentido.

Si desea verificar que un archivo existe antes de intentar leerlo, y puede estar eliminándolo y luego puede estar usando varios subprocesos o procesos, u otro programa conoce ese archivo y podría eliminarlo, corre el riesgo de una condición de carrera si verifica que existe, porque entonces está compitiendo para abrirla antes de que cambie su condición (su existencia).

Las condiciones de la carrera son muy difíciles de depurar porque hay una ventana muy pequeña en la que pueden hacer que tu programa falle.

Pero si esta es su motivación, puede obtener el valor de una declaración de try utilizando el administrador de contexto de suppress .

Evitar las condiciones de carrera sin una declaración de prueba: suppress

Python 3.4 nos proporciona el administrador de contexto de suppress (anteriormente el administrador de contexto de ignore ), que hace exactamente lo mismo en forma semántica en menos líneas, mientras que también (al menos superficialmente) cumple con la solicitud original para evitar una declaración de try :

from contextlib import suppress
from pathlib import Path

Uso:

>>> with suppress(OSError), Path('doesnotexist').open() as f:
...     for line in f:
...         print(line)
... 
>>>
>>> with suppress(OSError):
...     Path('doesnotexist').unlink()
... 
>>> 

Para los Pythons anteriores, puedes rodar tu propia suppress , pero sin un try será más detallado que con. Creo que en realidad esta es la única respuesta que no usa try en ningún nivel de Python que se pueda aplicar antes de Python 3.4 porque usa un administrador de contexto en su lugar:

class suppress(object):
    def __init__(self, *exceptions):
        self.exceptions = exceptions
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_value, traceback):
        if exc_type is not None:
            return issubclass(exc_type, self.exceptions)

Quizás más fácil con un intento:

from contextlib import contextmanager

@contextmanager
def suppress(*exceptions):
    try:
        yield
    except exceptions:
        pass

Otras opciones que no cumplen con la solicitud de "sin intentarlo":

isfile

import os
os.path.isfile(path)

de los docs :

os.path.isfile(path)

Devuelva True si la ruta es un archivo regular existente. Esto sigue a los enlaces simbólicos, por lo que tanto islink() como isfile() pueden ser verdaderos para la misma ruta.

Pero si examinas el source de esta función, verás que realmente usa una declaración de prueba:

# This follows symbolic links, so both islink() and isdir() can be true
# for the same path on systems that support symlinks
def isfile(path):
    """Test whether a path is a regular file"""
    try:
        st = os.stat(path)
    except os.error:
        return False
    return stat.S_ISREG(st.st_mode)
>>> OSError is os.error
True

Todo lo que hace es usar la ruta dada para ver si puede obtener estadísticas, capturar OSError y luego verificar si es un archivo si no produjo la excepción.

Si pretende hacer algo con el archivo, sugeriría intentarlo directamente con un intento, excepto para evitar una condición de carrera:

try:
    with open(path) as f:
        f.read()
except OSError:
    pass

os.access

Disponible para Unix y Windows es os.access , pero para usarlo debe pasar indicadores, y no distingue entre archivos y directorios. Esto se usa más para probar si el usuario que invoca real tiene acceso en un entorno de privilegios elevados:

import os
os.access(path, os.F_OK)

También sufre los mismos problemas de condición de carrera que isfile . De la docs :

Nota: el uso de access () para verificar si un usuario está autorizado para, por ejemplo, abrir un archivo antes de hacerlo, utilizando open () crea un agujero de seguridad, ya que el usuario podría aprovechar el corto intervalo de tiempo entre la verificación y la apertura del archivo para manipularlo. Es preferible utilizar técnicas de EAFP. Por ejemplo:

if os.access("myfile", os.R_OK):
    with open("myfile") as fp:
        return fp.read()
return "some default data"

está mejor escrito como:

try:
    fp = open("myfile")
except IOError as e:
    if e.errno == errno.EACCES:
        return "some default data"
    # Not a permission error.
    raise
else:
    with fp:
        return fp.read()

Evite utilizar os.access . Es una función de bajo nivel que tiene más oportunidades de error de usuario que los objetos y funciones de nivel superior descritos anteriormente.

Crítica de otra respuesta:

Otra respuesta dice esto sobre os.access :

Personalmente, prefiero este porque bajo el capó, llama API nativas (a través de "$ {PYTHON_SRC_DIR} /Modules/posixmodule.c"), pero también abre una puerta para posibles errores de los usuarios, y no es tan Pythonic como otras variantes. :

Esta respuesta dice que prefiere un método no pitónico, propenso a errores, sin justificación. Parece animar a los usuarios a usar API de bajo nivel sin entenderlos.

También crea un administrador de contexto que, al devolver incondicionalmente True , permite que todas las Excepciones (¡incluyendo KeyboardInterrupt y SystemExit !) SystemExit en silencio, lo que es una buena manera de ocultar errores.

Esto parece alentar a los usuarios a adoptar malas prácticas.





python list tuples list-comprehension