MemoryError en Python

python error

Todas las excepciones de Python heredan de la clase BaseException o se extienden desde una clase heredada en la misma. La jerarquía de excepciones completa de este error es:

*BaseException

*Excepción.

*MemoryError

En la mayoría de las situaciones, un MemoryError en Python indica una falla importante en la aplicación actual.

Por ejemplo, una aplicación que acepta archivos o entrada de datos de usuario podría ejecutar MemoryErrors si la aplicación no tiene suficientes controles que validen y saneen las entradas.

Hay toneladas de escenarios en los que los límites de memoria pueden ser problemáticos, pero para nuestra ilustración de código nos quedaremos con una asignación simple en la memoria local usando cadenas y arreglos.

El factor más importante para determinar si es probable una aplicacion experimente MemoryErrors es en realidad la arquitectura de la computadora en la que se ejecuta el sistema.

O, incluso más específicamente, la arquitectura que usa su versión de Python.

Versión Python y MemoryError

Si está utilizando Python de 32 bits, la asignación de memoria máxima otorgada al proceso de Python,  es excepcionalmente baja.

El límite máximo específico de asignación de memoria varía y depende de su sistema, pero por lo general es de alrededor de 2 GB y  no más de 4 GB.

Por otro lado, las versiones de Python de 64 bits, están más o menos limitadas solo por la memoria disponible del sistema.

En términos prácticos, es poco probable que un intérprete de Python de 64 bits experimente problemas de memoria, o si lo hace, es porque hay  un problema mucho mayor que está afectando a todo el  resto del sistema.

Puedes ver más información sobre este error, en Stackoverflow

En definitiva debido a que existe una gran diferencia entre las versiones de Python de 32 y 64 bits, la solución a tu problema de memoria podría ser  cambiar a Python de 64 bits y ejecutar el mismo código.

Si después de unas pocas iteraciones no se ha lanzado MemoryError se debe a la versión de Python que estas utilizando.

Puedes cortar las rosas una a una, ……. pero la primavera seguirá en el jardín

J.A. Buesa

Como recorrer directorios en Python con scandir

logo python

En este post aprenderás como recorrer  directorios en Python con scandir.

La documentación actualizada de Python recomienda recorrer directorios en Python con scandir como método.

Scandir es un método del DirEntry que pertenece a la libreria Os, dicho de otro modo  os.scandir, se usa para crear un iterador de los objetos del  método os.DirEntry correspondientes a los  elementos que existan en el argumento path.

Su sintaxis es:

 scandir(‘path’)

El objeto que crea scandir() expone la ruta y otros atributos del archivo en el directorio.

Este método proporciona toda la información posible sobre el directorio de una sola vez, lo que evita llamadas adicionales l sistema información como sea posible sin realizar llamadas al sistema adicionales.

Las instancias de os.DirEntry, entre las que se encuentra scandir no almacena sus resultados en estructuras de datos de larga duración; por tanto es recomendable llamar al método de scandir stat, con la sintaxis  os.stat(entry.path), si se necesita actualizar la información y este resultado se almacena en caché al igual que si se llama a lstat()

Este método genera excepciones del tipo OSError, que puede ser manejado como cualquier otro método en Python.

Otros artículos sobre Python

Veamos varios ejemplos de uso scandir().

# importmos os 
import os

 
# Directorio que nos interesa recorrer 
path = '/home/soluciones'
 
# Scaneamos el  directorio y creamos un iterador de  los objetos de tipo os.DirEntry 

directorio = os.scandir(path)
 
# Listamos todos los archivos y directorios dentro de esa ruta 
print("Archivos y  Directorios in '% s':" % path)
for cosas  in directorio :
    if cosas.is_dir() or cosas.is_file():
        print(entry.name)
 
 
# cosas.is_file() chequea si los elementos existentes son archivos o no
# cosas.is_dir() chequea si los elementos existentes son directorios o no
 
# para cerrar el iterador podemos llamar scandir.close(), no obstante este método
# es llamado de modo automatico cuando el iterador excede su capacidad o cuando
#ocurre un error al iterar
directorio.close()
 

En el siguiente ejemplo además de determinar si existe el objeto, definiremos con qué comienza o termina el nombre.

import os
dir = "/Users/blackmaster/Downloads/"
textos=[]
directorios_p=[]
with os.scandir(dir) as contenido:
    for cosas in contenido:
        #si cosas es archivo y termina en .csv lo añadimos a la varible textos
        if cosas.is_file and cosas.name.endswith('.csv'):
            textos.append(entry.name)
        #si cosas es directorio y comienza con p lo añadimos a la varible directorios p    
        if cosas.is_dir and cosas.name.startswith('p'):
            directorios_p.append(cosas.name)
            
print(textos)
print(directorios_p)

Y hasta aquí, espero modestamente, que este post ayude a alguien.

Tres cosas necesitan las ovejas para andar en manadas, el miedo al perro, la voz de amo y que la de atrás empuje por miedo a quedarse sola.

Y.

Manejar el AssertionError en Python

python error

En este artículo, exploraremos el AssertionError, comenzando por el lugar donde reside en la jerarquía general de clases de excepción de Python.

Un AssertionError, solo puede ocurrir cuando falla una declaración de aserción (afirmación), por lo tanto, un AssertionError nunca debe ser una sorpresa o aparecer en una sección del código de su aplicación que sea inesperado.

Cada vez que escribas una declaración de aserción, también debes proporcionar un código de manejo de excepciones apropiado, para hacer frente a un error de aserción inevitable.

También hara una prueba con código funcional, que ilustra cómo se pueden usar las declaraciones assert y cómo la falla de dicha declaración generará un AssertionError que debe detectarse y manejarse, como cualquier otro error

Herencia

Todas las excepciones de Python heredan de la clase BaseException, o bien  extienden desde una clase heredada en la misma. La jerarquía de excepciones completa de este error es:

• BaseException

o Excepción

 AssertionError

Código

A continuación, se muestra el ejemplo de código completo que usaremos en este artículo. Se puede copiar y pegar si desea jugar con el código usted mismo y ver cómo funciona todo.

import datetime

from gw_utility.book import Book
from gw_utility.logging import Logging


def main():
    Logging.line_separator("BOTH INCLUDE PUBLICATION DATES", 50, '+')
    # Creamos dos Books con argumentos identicos.
    the_stand = Book("The Stand", "Stephen King", 1153, datetime.date(1978, 1, 1))
    the_stand_2 = Book("The Stand", "Stephen King", 1153, datetime.date(1978, 1, 1))

    # Afirma la equivalencia de los Books.
    check_equality(the_stand, the_stand_2)

    Logging.line_separator("ONE MISSING PUBLICATION DATE", 50, '+')
    # Create two Books, one without publication_date argument specified.
    the_hobbit = Book("The Hobbit", "J.R.R. Tolkien", 366, datetime.date(1937, 9, 15))
    the_hobbit_2 = Book("The Hobbit", "J.R.R. Tolkien", 366)

    # Afirma la equivalencia de los Books.
    check_equality(the_hobbit, the_hobbit_2)


def check_equality(a, b):
    """Afirmacion de equivalencia de dos objetos pasados..

    :param a: First object.
    :param b: Second object.
    :return: Indicates if assertion was successful.
    """
    try:
        Logging.line_separator("ASSERTING EQUIVALENCE OF...")
        # Output objects using __str__ method.
        Logging.log(a)
        Logging.log(b)
        # Afirmacion de la  equivalencia de los objetos indicando que la inigualdad ha fallado..
        assert a == b, "The objects ARE NOT equal."
        # Indica que la   assertion ha sucedido.
        Logging.log("The objects are equal.")
        return True
    except AssertionError as error:
        # Salida  esperada de un AssertionErrors.
        Logging.log_exception(error)
    except Exception as exception:
        # Salida de una excepcion inesperada.
        Logging.log_exception(exception, False)


if __name__ == "__main__":
    main()

import datetime


class Book:
    author: str
    page_count: int
    publication_date: datetime.date
    title: str

    def __eq__(self, other):
        """Determina si los objetos pasados son equivalentes a un objeto actual. """
        return self.__dict__ == other.__dict__

    def __init__(self, title: str = None, author: str = None, page_count: int = None,
                 publication_date: datetime.date = None):
        """Inicializa una instancia de Book.

        :param title: Title of Book.
        :param author: Author of Book.
        :param page_count: Page Count of Book.
        :param publication_date: Publication Date of Book.
        """
        self.author = author
        self.page_count = page_count
        self.publication_date = publication_date
        self.title = title

    def __len__(self):
        """Devuelve el length del titulo."""
        return len(self.title)

    def __str__(self):
        """Devuelve un string formateado como represntacion de   Book."""
        date = '' if self.publication_date is None else f', published on {self.publication_date.__format__("%B %d, %Y")}'
        return f'\'{self.title}\' by {self.author} at {self.page_count} pages{date}.'

Como funciona un assert (afirmación)

Para ilustrar cómo funcionan las afirmaciones, realizaremos algunas pruebas de equivalencia básicas para determinar si un objeto es igual a un segundo objeto.

Para hacer las cosas un poco más interesantes, hemos creado una clase Book personalizada simple, que almacena información básica sobre cada instancia de Book.

class Book:
    author: str
    page_count: int
    publication_date: datetime.date
    title: str

    def __eq__(self, other):
        """Determines if passed object is equivalent to current object."""
        return self.__dict__ == other.__dict__

    def __init__(self, title: str = None, author: str = None, page_count: int = None,
                 publication_date: datetime.date = None):
        """Inicializando instancia de Book.

        :param title: Title of Book.
        :param author: Author of Book.
        :param page_count: Page Count of Book.
        :param publication_date: Publication Date of Book.
        """
        self.author = author
        self.page_count = page_count
        self.publication_date = publication_date
        self.title = title

    def __len__(self):
        """Returns the length of title."""
        return len(self.title)

    def __str__(self):
        """Returns a formatted string representation of Book."""
        date = '' if self.publication_date is None else f', published on {self.publication_date.__format__("%B %d, %Y")}'
        return f'\'{self.title}\' by {self.author} at {self.page_count} pages{date}.'

Una vez realizada la  asignación de propiedad de instancia en el método __init __ (self, title: str = None, author: str = None, page_count: int = None, publishing_date: datetime.date = None).

Podemos iniciar el proceso de comparación.

Vemos que tenemos un método __eq __ (self, other), al que se llamará cuando se intente verificar la equivalencia entre una instancia de Book y otro objeto.

Para manejar esto, usamos la propiedad incorporada __dict__ como una forma de comparación (aunque podríamos optar también por __str __ (self)).

El código que usaremos para probar algunas instancias de objetos comienza con el método check_equality (a, b)

def check_equality(a, b):
    """Afirmando la equivalencia de dos objetos 

    :param a: First object.
    :param b: Second object.
    :return: Indica que el assertion fue exitoso.
    """
    try:
        Logging.line_separator("ASSERTING EQUIVALENCE OF...")
        # Salida de objetos usando __str__ method.
        Logging.log(a)
        Logging.log(b)
        # Assert de equivalencia de objetos, indicando que la desigualdad ha fallado 
        assert a == b, "The objects ARE NOT equal."
        # Indica que la afirmación se realizó correctamente.

        Logging.log("The objects are equal.")
        return True
    except AssertionError as error:
        # Esperando salida de un AssertionError.
        Logging.log_exception(error)
    except Exception as exception:
        # Salida de una excepción inesperada
        Logging.log_exception(exception, False)

La mayor parte del código  que tenemos, maneja la salida de información al registro (log) sobre la prueba de igualdad.

La línea crítica es assert a == b, "Los objetos NO SON iguales", que realiza una afirmación de que ambos objetos pasados ​​son equivalentes entre sí.

El segundo argumento de una declaración de aserción es el mensaje de fallo que se usa como argumento si ocurre una falla.

En términos prácticos, este argumento de mensaje de falla se agrega a la propiedad .args de la instancia AssertionError, dándonos un mensaje de error real cuando detectamos la excepción en otra parte de nuestro código.

Dado que una declaración de aserción fallida siempre genera un AssertionError, si la ejecución continúa más allá de esa declaración, podemos asumir que los objetos son iguales y la salida al registro.

Con todo configurado, podemos probar nuestro método de aserción creando un par de instancias de Book, the_stand y the_stand_2:

def main():
    Logging.line_separator("BOTH INCLUDE PUBLICATION DATES", 50, '+')
    # Creando dos  Books con argumentos identicos.
    the_stand = Book("The Stand", "Stephen King", 1153, datetime.date(1978, 1, 1))
    the_stand_2 = Book("The Stand", "Stephen King", 1153, datetime.date(1978, 1, 1))

    # Comparando equivalencia de los libros
    check_equality(the_stand, the_stand_2)

    # ...

Pasar ambas instancias de Book a check_equality (a, b) produce el siguiente resultado:

+++++++++ BOTH INCLUDE PUBLICATION DATES +++++++++
----- ASSERTING EQUIVALENCE OF... ------
'The Stand' by Stephen King at 1153 pages, published on January 01, 1978.
'The Stand' by Stephen King at 1153 pages, published on January 01, 1978.
The objects are equal

Como podemos suponer lógicamente, dado que todos los argumentos pasados ​​a ambos inicializadores de Libro eran idénticos, nuestra declaración assert  tuvo éxito y vemos la salida de confirmación en el registro. 

Sin embargo, veamos qué sucede si intentamos una segunda prueba con dos objetos Book ligeramente diferentes, donde una instancia no pasó un argumento publication_date durante la inicialización:

Logging.line_separator("ONE MISSING PUBLICATION DATE", 50, '+')
# Creando dos Books, uno de ello sin el argumento publication_date 
the_hobbit = Book("The Hobbit", "J.R.R. Tolkien", 366, datetime.date(1937, 9, 15))
the_hobbit_2 = Book("The Hobbit", "J.R.R. Tolkien", 366)

# Comparando equivalencia de los libros
check_equality(the_hobbit, the_hobbit_2)

 

Como probablemente pueda adivinar, estos dos objetos Book no se consideran iguales, ya que sus propiedades __dict__ subyacentes son diferentes entre sí.

En consecuencia, nuestra declaración de aserción falla y genera un AssertionError en la salida:

++++++++++ ONE WITHOUT PUBLICATION DATE ++++++++++
----- ASSERTING EQUIVALENCE OF... ------
'The Hobbit' by J.R.R. Tolkien at 366 pages, published on September 15, 1937.
'The Hobbit' by J.R.R. Tolkien at 366 pages.
[EXPECTED] AssertionError: The objects ARE NOT equal.

Espero que lo hayas entendido. Gracias

…. hay que levantarse cada mañana con una esperanza y dormirse cada noche con una meta….

Y

Ejecutar comandos Shell en Python con os.system

logo python

Si en alguna ocasión, ante alguna necesidad de programación, has necesitado ejecutar comandos Shell en Python con os.system, tienes una opción interesante que te mostraré si sigues leyendo.

Python nos permite ejecutar un comando de shell que se almacena en una cadena usando os.system()

import os
#muestra el mensaje en la consola
os.system("echo mostrar mensaje en la consola")
output
mostrar mensaje en la consola

Al igual que os.system() en el ejemplo anterior, donde imprimimos con echo el mensaje en consola, podemos no usar echo y obtener una salida estándar (stdout) que no se muestra en consola.

Cuando damos una orden con os.system, el resultado positivo será igual a 0, o diferente de 0, en caso de que no se cumpla.

En este ejemplo, intentamos mover el directorio actual a un directorio que no existe, por tanto recibimos un error diferente de 0.

directorio_erroneo = os.system("cd directoriofalso")
print("cd directoriofalso da un codigo de error %d" % directorio_erroneo)
Output
sh: line 0: cd: directoriofalso: No such file or directory
cd directoriofalso da un codigo de error 256

Podemos emplear otros métodos más potentes para escribir comandos Shell en Python como subprocess().

Y hasta aquí, espero ayudar a alguien con este post.

Hacer preguntas es prueba de qué se piensa.

R. Tagore

Contar las apariciones de un carácter en una cadena de Python.

logo python

En muchas ocasiones nos hemos o veremos necesitados de contar las  apariciones de un carácter en una cadena de Python, para lo cual tenemos diferente opciones.

En dependencia de nuestra necesidad, o el módulo con el que nos encontremos trabajando, podremos hacerlo por una vía u otra

for

Podemos recorrer la cadena, crear un contador e incrementarlo en uno cada vez que encuentre en carácter que buscamos.

cadena = 'Quien va en busca de montañas, no puede detenerse a recoger las piedras del camino.'
    
contador = 0 
for i in cadena:
    if i == "a":
        contador = contador + 1
print(contador)
salida
8

count

La función count(), devuelve de un modo sencillo, cúantos caracteres  iguales al que e le pasa como parámetro, existen en la cadena.

Sintaxis

array.count('x')

Aquí, dos modos de implementarla:

a = 'Quien va en busca de montañas, no puede detenerse a recoger las piedras del camino.'.count('n')
print(a)
print('Quien va en busca de montañas, no puede detenerse a recoger las piedras del camino.'.count('a'))
salida
6
8

Una función lambda

Una lambda en Python, es la mínima función que se puede expresar dentro de una expresión.

Por tanto para contar caracteres con una función lambda, podemos plantearlo con la función map() que aplicará sobre cada integrante de la lista una acción que en nuestro caso será dar valor 1 y luego lo sumaremos con la función sum().

cadena = 'Quien va en busca de montañas, no puede detenerse a recoger las piedras del camino.'
# utilizamos las funciones map y sum, un bucle if  - else la funcion map y sum, 
# lammbda parametro . accion, donde se ejecuta
print(sum(map(lambda x : 1 if 'a' in x else 0, cadena)))
salida
8

defaultdict

defaultdict(), pertenece al modulo collections. Permite contar los elementos dados dentro de una cadena y devuelve un valor 0 si el carácter no existe.

from collections import defaultdict
cita = 'Quien va en busca de montañas, no puede detenerse a recoger las piedras del camino.'
chars = defaultdict(int) #creamos el objeto con el parámetro int

for char in cita:  #empleamos un for para recorrer la cadena 
    chars[char] += 1
    
print(chars['a'])
print(chars['e'])
print(chars['i'])
print(chars['o'])
print(chars['u'])
print(chars['l'])
print(chars['m'])
print(chars['n'])
print(chars['u'])
print(chars['z']) #caracter que no existe
print(chars['h']) #caracter que no existe
print(chars['v'])

salida
8
13
3
4
3
2
2
6
3
0
0
1

collections.counter

counter() es una subclase de dictado para contar objetos hash, o sea datos estructurados de forma que asocian llaves o claves con valores.

En esta colección, los elementos se almacenan como claves de diccionario y sus recuentos se almacenan como valores de diccionario. El conteo puede arrojar cualquier cualquier valor entero, incluido el cero, o valores negativos. Counter devuelve cero para elementos inexistentes.

cadena = 'Quien va en busca de montañas, no puede detenerse a recoger las piedras del camino.'
from collections import Counter
cadena = 'Quien va en busca de montañas, no puede detenerse a recoger las piedras del camino.'
counter = Counter(cadena)
print(counter['a'])
print(counter['x'])
salida
8
0

Otros artículos sobre Python

pandas.df.value_count

La librería Pandas por supuesto, también ofrece  una funcion simple para contar caracteres en una cadena.

Debemos primero convertir la cadena a un dataframe o serie  pandas y luego aplicarle  la función value.count(), como se ve en el ejemplo:

import pandas as pd
cadena = 'Quien va en busca de montañas, no puede detenerse a recoger las piedras del camino.'
print(pd.Series(list(cadena)).value_counts())
salida
14
e    13
a     8
n     6
s     5
d     5
o     4
r     4
u     3
c     3
i     3
l     2
m     2
p     2
t     2
,     1
v     1
ñ     1
Q     1
g     1
b     1
.     1
dtype: int64

re  y findall trabajando con expresiones regulares

El modulo re y la función findall(), nos permiten trabajar con expresiones regulares. Digamos que una expresión regular, es una sintaxis dada que está contenida en un patrón. Si hacemos coincidir es patrón con nuestro parámetro de búsqueda, obtendremos los elementos que se repiten.

import re
cadena = 'Quien va en busca de montañas, no puede detenerse a recoger las piedras del camino.'
print(len(re.findall("a", cadena))) 

Y hasta aquí, espero sinceramente que esto sirva de ayuda a alguien.

Por mucho tiempo que este un tronco en el agua, nunca llegará a ser cocodrilo.

D.

Assertion Error en Python

python error

El manual indica que Assertion Error en Python se lanza cuando la declaración assert falla. Acá te explico porque.

El lenguaje incluye esta declaración assert (afirmación) incorporada que le permite crear salidas de mensajes de depuración simples basadas en afirmaciones lógicas simples.

Cuando una declaración afirmativa (assertion) de este tipo falla (es decir, devuelve un valor False), se genera un AssertionError.

El Assertion Error, se basa en el concepto de que al escribir un código, se  declara que una condición es verdadera mediante una declaración de afirmación antes de ejecutar el módulo.

Si la condición es Verdadera, el control simplemente se mueve a la siguiente línea de código.

En caso de que sea False, el programa deja de ejecutarse y devuelve AssertionError Exception. 

Un error común es una condición en la cual se retorna un None, lo cual es visto como un fallo por el interprete.

Así que si tienes este error debes comenzar a revisar por ahí.

En otro artículo te diré como capturar esta excepción y manejarla.

El amor construye, con las mismas razones que el odio destruye. Emplean la misma energía, copan al cerebro con la misma fuerza, arrastran pasiones con el mismo fervor; no es raro entonces que pasemos de uno a otro con tanta impunidad social.

Y

Copiar un fichero en Python con shutil

logo python

Veamos hoy como copiar un fichero en Python con shutil, que es un modulo que Python ofrece para este tipo de acciones

Tenemos varias opciones, a continuación, te las muestro:

copy

Este es un modulo de Python, que pertenece a shutil().

copy() copia el contenido del fichero y sus permisos, pero sin embargo, no copia los metadatos del fichero.

copy() acepta como parámetros, los siguientes:

  • src: Ruta completa del fichero origen, en formato cadenav(string), o un objeto(PathLike)
  • dst: Ruta del fichero  de destino. En este caso  hay que considerar que si la ruta es un directorio, se copiará el fichero origen en el directorio y tomará como nombre el del fichero original.
  • follow_symlinks (default =True): Cuando follow_symlinks es falso y src es un enlace simbólico, dst se creará como un enlace simbólico. Si follow_symlinks es verdadero y src es un enlace simbólico, dst será una copia del archivo al que se refiere src.
import shutil
shutil.copy('origen.txt', 'destino.txt')
shutil.copy('/ruta/origen.txt', '/ruta/destino/copia.txt')
shutil.copy('/ruta/origen.txt', '/ruta/destino')

Otros artículos sobre Python

copy2

La función copy2(), permite copiar los metadatos del archivo y funciona exactamente igual que copy().

import shutil
shutil.copy2('origen.txt', 'destino.txt')
shutil.copy2('/ruta/origen.txt', '/ruta/destino/copia.txt')
shutil.copy2('/ruta/origen.txt', '/ruta/destino')

Copyfile

copyfile() permite  copiar  solo el contenido de un fichero.

Su sintaxis es:

copyfile(src, dst, follow_symlinks=True). 

Esta función hace una copia del fichero original src() en el fichero destino dst(). Tanto src(), como dst(), son cadenas de texto que ofrecen rutas.

Considera, que si el fichero destino ya existe, este será reemplazado.

La función lanzara un OSError, si no se puede  escribir en el destino.

import shutil
shutil.copyfile('origen.txt', 'destino.txt')
shutil.copyfile('/ruta/origen.txt', '/ruta/destino/copia.txt')

Copyfileobj

Esta función funciona como  copyfile(), con la diferencia  de que src() y dst() deben ser objetos de tipo fichero (no  un string con las rutas).

import shutil
file_src = 'source.txt' 
f_src = open(file_src, 'rb')
file_dest = 'destination.txt' 
f_dest = open(file_dest, 'wb')
shutil.copyfileobj(f_src, f_dest)

Y hasta aquí, esto es todo.

Espero que sirva de ayuda a alguien

Para ser parte del 1%, hay que hacer lo que el 99% no hace.

D.

Cambiar el tamaño de la imagen en Python con opencv

logo python

En este pequeño post enseñaré como cambiar el tamaño de una imagen en Python con opencv. Python es un lenguaje que resulta útil, para llevar a cabo muchas tareas necesarias, incluido el tratamiento de imágenes, que pueden exigir diferentes niveles de complejidad.

Consideremos primero que una  imagen es un array, que puede ser tratado como un objeto numpy.

El método resize() de Python no es efectivo en este caso, ya que no tiene en cuenta el eje, y debido a esto no es capaz de extrapolar y/o interpolar.

El módulo opencv se usa en Python para  la visión por computadora  y el procesamiento de imágenes.

El procedimiento en esencia es leer primero la imagen empleando la función imread(), y luego cambiar su dimensión empleando función resize().

La sintaxis seria así:

dst = cv2.resize(src, dsize[, fx[, fy[, interpolation]]]])

Donde fx y fy son factores de escala a lo largo de los ejes x e y, dsize() se refiere al tamaño de la imagen de salida y el indicador de interpolación se refiere al método que vamos a usar.

Ya sea que se especifique (fx, fy) o dsize, OpenCV calcula el otro automáticamente.

Lo primero es disponer de opencv en el ordenador, para ello deberás descargarla y tenerla ya instalada. Puedes seguir las instrucciones acá .

import cv2
import numpy as np
img = cv2.imread('archivo.jpeg')
res = cv2.resize(img, dsize=(54,140),interpolation=cv2.INTER_CUBIC)

Podemos emplear como interpolación las siguientes:

Nearest Neighbor:

near_img = cv2.resize(img,None, fx = 10, fy = 10, interpolation = cv2.INTER_NEAREST)

la bilineal,

bilinear_img = cv2.resize(img,None, fx = 10, fy = 10, interpolation = cv2.INTER_LINEAR)

o la bicúbica que teníamos en el ejemplo inicial

bicubic_img = cv2.resize(img,None, fx = 10, fy = 10, interpolation = cv2.INTER_CUBIC)

Todas emplean algoritmos diferentes, y su efectividad varía de un caso a otro.

Y hasta aquí, esto es todo.

Espero que esto sirva de ayuda a alguien.

La ignorancia, es la muerte de los vivos

FloatingPointError en Python

python error

El  FloatingPointError en Python, indica que algo salió mal, al efectuar  un cálculo de punto flotante.

Las causas del error por tanto pueden ser varias, y su manejo dependerá de tus objetivos.

Si necesitamos evitarlo, el empleo de decimal(), puede ayudarnos,  ya que  contienen varias funciones integradas para operaciones matemáticas simples (por ejemplo, sqrt); sin embargo es posible que los resultados de estas funciones no siempre coincidan con la función correspondiente en matemáticas u otros módulos con mayor precisión.

Justo por esto es más recomendable emplear math(), por su mayor exactitud.

Lo importante que debes saber, es que la causa de este  error  muchas veces está, en las características de los números con base N.

Como declarar un array en Python

logo python

En Python trabajamos constantemente con matrices de diferentes dimensiones. En este articulo vamos a ver como declarar un array en Python, usando dos formas.

Lo primero a considerar, es que en Python el primer elemento de una matriz, ocupa la posición 0, el segundo la posición 1 y así sucesivamente.

Declaración simple:

La forma mas sencilla de declarar que una variable recibe como datos un array es escribiendo el nombre de la variable el signo igual y corchetes:

mi_array = []

Esto indica al interprete de Python que mi_array es un array que de  momento esta vacío.

En este caso estamos accediendo al modulo list()

Se puede acceder a los elementos de la lista simplemente pasando el índice requerido. Dicho entonces, se entiende que mi lista[2] accederá al tercer elemento.

Para añadir un elemento usamos el módulo append() con el elemento que se agregará, teniendo en cuenta que append() lo colocará al final.

Si deseamos colocarlo en una posición especifica, se usa la función insert(x, y)  donde el índice es  x, e  y el valor y.

Si el índice tiene un valor negativo es porque estamos accediendo a las posiciones contando de atrás hacia adelante, o sea en orden inverso.  

mi_matriz = [1,2,3,"s",5]
print(mi_matriz [-2])
mi_matriz.insert(4,6)
print(mi_matriz [-2])
mi_matriz.append('f')
print(mi_matriz)
 output
s
12
[1, 3, 5, 7, 9, 's', 12, 'f', 'g']

La clase array

El modulo array permite inicializar un array que incluirá  solo elementos homogéneos.

Para usarlo debe importarlo como cualquier otro modulo, y viene de la librería array.

Este se define con paréntesis y acepta dos argumentos,  el type code que define el tipo de los elementos que lo integran; el segundo parámetro es la lista de estos elementos entre corchetes.

Para acceder a un elemento del array, se emplea la función index(x) donde x es el índice del array.

Para insertar un nuevo elemento en el array, se llama a la función insert(i,x), donde es el índice y x es el valor a insertar.

Translate »