Categorías
Python

Django y AJAX envíos de formularios – Say ‘adiós’ a la actualización de la página

 

Tabla de Contenidos

  • Valor de retorno y parámetros de np.arange () Argumentos
  • gama de np.arange () Proporcionar Todo Rango Rango ArgumentsProviding Dos ArgumentsProviding un rango ArgumentProviding negativo ArgumentsCounting BackwardsGetting Vacío matrices
  • Proporcionar Argumentos toda la gama
  • proporcionando argumentos Dos rango
  • proporcionar Argumento Una gama
  • proporcionar argumentos negativos
  • contando hacia atrás
  • quedando vacío Tipos de matrices
  • datos de np.arange ()
  • Más allá de rangos simples con np.arange ()
  • Comparación de la gama y np.arange () Parámetros y OutputsCreating SequencesPython para Loops
  • parámetros y salidas
  • crear secuencias
  • Python para Loops
  • Otras rutinas basadas en numérica Ranges Resumen
  • rápida
  • Conclusión
  • Proporcionar Argumentos toda la gama
  • proporcionando dos Los argumentos de rango
  • Proporcionar Argumento Una gama
  • Proporcionar argumentos negativos
  • contando hacia atrás
  • quedando vacío matrices
  • parámetros y salidas
  • crear secuencias
  • Python para Loops

NumPy es la biblioteca fundamental Python para el cálculo numérico. Su tipo más importante es un tipo de matriz llama ndarray. NumPy ofrece una gran cantidad de rutinas de creación de la matriz para diferentes circunstancias. arange () es un tal función basada en numérico rangos . A menudo se refiere como np.arange () porque np es una abreviatura ampliamente utilizado para NumPy .

Creación de matrices NumPy es importante cuando se trabaja con otras bibliotecas de Python que dependen de ellos, como SciPy, pandas, Matplotlib, scikit-learn, y mucho más. NumPy es adecuado para crear y trabajar con matrices, ya que ofrece rutinas útiles, permite incremento en el rendimiento, y le permite escribir código conciso.

Al final de este artículo, usted sabrá:

  • Lo np.arange () es
  • cómo utilizar np.arange ()
  • Cómo np.arange () se compara con el incorporado Python en el rango de clase
  • ¿Qué rutinas son similares a np.arange () Ver np.arange de

Sea () en la acción! Bono

gratuito: Haga clic aquí para obtener acceso a una Guía de Recursos libre NumPy que señala al los mejores tutoriales, videos y libros para mejorar sus habilidades NumPy.

Valor de retorno y parámetros de np.arange ()

NumPy arange () es una de las rutinas de creación de la matriz en base a rangos numéricos. Se crea una instancia de ndarray con valores uniformemente espaciados y devuelve la referencia a la misma.

Se puede definir el intervalo de los valores contenidos en una matriz, el espacio entre ellos, y su tipo con cuatro parámetros de arange ():

numpy.arange([start, ]stop, [step, ], dtype=None) -> numpy.ndarray

El primero tres parámetros determinan el rango de los valores, mientras que el cuarto especifica el tipo de los elementos:

paso no puede ser cero. De lo contrario, obtendrá un ZeroDivisionError. No se puede mover en cualquier lugar lejos de principio si el incremento o decremento es 0.

Si se omite dtype, arange () intentará deducir el tipo de los elementos de la matriz de los tipos de inicio, parada y paso.

Puede encontrar más información sobre los parámetros y el valor retorno de arange () en el documento oficial. Argumentos

gama de np.arange ()

Los argumentos de NumPy arange () que definen los valores contenidos en la matriz corresponden a los parámetros numéricos de iniciar, detener, y paso. Usted tiene que pasar al menos una de ellos.

Los siguientes ejemplos le mostrarán cómo arange () se comporta en función del número de argumentos y sus valores.

Proporcionar Argumentos toda la gama

Cuando se trabaja con rutinas NumPy, que tienen que importar NumPy primera:

>>> import numpy as np

Ahora, usted tiene NumPy importada y ya está listo para aplicar arange (). de

Veamos un primer ejemplo de cómo utilizar NumPy arange ():

>>> np.arange(start=1, stop=10, step=3)
array([1, 4, 7])

En este ejemplo, el arranque es 1. Por lo tanto, el primer elemento de la matriz obtenida es 1. paso es 3, por lo que su segundo valor es 1 + 3, que es 4, mientras que el tercer valor de la matriz es 4 + 3, que es igual a 7.

Siguiendo este patrón, el siguiente valor sería 10 (7 + 3), pero el recuento debe ser terminado antes de parada se alcanza, por lo que éste no está incluido.

Puede pasar iniciar, detener, y el paso como argumentos posicionales así:

>>> np.arange(1, 10, 3)
array([1, 4, 7])

Este ejemplo de código es equivalente a, pero más concisa que la anterior.

El valor de parada no está incluido en una matriz. Es por eso que se puede obtener resultados idénticos con diferentes valores de parada:

>>> np.arange(1, 8, 3)
array([1, 4, 7])

este ejemplo de código devuelve la matriz con los mismos valores que los dos anteriores. Se puede obtener el mismo resultado con cualquier valor de parada estrictamente mayor que 7 y menor o igual a 10.

Sin embargo, si se hace mayor parada del 10, entonces el conteo va a terminar después de 10 se alcanza:

>>> np.arange(1, 10.1, 3)
array([ 1., 4., 7., 10.])

En este caso, se obtiene la matriz con cuatro elementos que incluye 10.

Tenga en cuenta que este ejemplo se crea una matriz de números de punto flotante, a diferencia de la anterior. Esto se debe a que no hemos definido dtype y arange () dedujeron por usted. Usted aprenderá más sobre esto más adelante en el artículo.

Se puede ver las representaciones gráficas de estos tres ejemplos en la siguiente figura: inicio

se muestra en verde, parada en rojo, mientras paso y los valores contenidos en las matrices son de color azul.

como se puede ver a partir de la figura anterior, los dos primeros ejemplos tienen tres valores (1, 4, y 7) contados. No permiten 10 que deben incluirse. En el tercer ejemplo, parada es mayor que 10, y que está contenida en la matriz resultante.

medio de argumentos Dos Rango

puede omitir paso. En este caso, arange () utiliza su valor por defecto de 1. Los dos sentencias siguientes son equivalentes:

>>> np.arange(start=1, stop=10, step=1)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(start=1, stop=10)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])

La segunda afirmación es más corto. paso, que por defecto es 1, es lo que se espera normalmente de forma intuitiva.

Usando arange () con el incremento de 1 es un caso muy frecuente en la práctica. Una vez más, puede escribir el ejemplo anterior de manera más concisa con empiezan los argumentos posicionales y parada:

>>> np.arange(1, 10)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])

Se trata de una forma intuitiva y concisa para invocar arange (). El uso de los argumentos de palabra clave en este ejemplo en realidad no mejorar la legibilidad.

Nota: Si usted proporciona dos argumentos posicionales, a continuación, la primera es iniciar y el segundo es parada.

Proporcionar Argumento Una gama

usted tiene que proporcionar al menos un argumento arange (). Para ser más precisos, usted tiene que proporcionar inicio.

¿Pero qué sucede si se omite deja? ¿De qué manera arange () sabe cuándo dejar de conteo? En este caso, la matriz comienza en 0 y termina antes de que el valor de inicio se alcanza! Una vez más, el valor por defecto de paso es 1.

En otras palabras, arange () asume que usted ha proporcionado de parada (en lugar de inicio) y que inicio es 0 y 1. paso es

Vamos a ver un ejemplo en el que desea para iniciar una matriz con 0, aumentando los valores de 1, y parar antes de las 10:

>>> np.arange(start=0, stop=10, step=1)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(0, 10, 1)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(start=0, stop=10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(0, 10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Estos ejemplos de código están bien. Trabajan como se muestra en los ejemplos anteriores. Hay una, forma aún más corto y más limpio, pero todavía intuitiva para hacer lo mismo. Puede acaba de proporcionar un solo argumento posicional:

>>> np.arange(10) # Stop is 10, start is 0, and step is 1!
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Esta es la forma más habitual para crear una matriz NumPy que comienza en cero y tiene un incremento de uno.

Nota: Los solo argumento define el lugar donde se detiene el conteo. La matriz de salida comienza en 0 y tiene un incremento de 1.

Si intenta prever explícitamente parada sin salida, entonces obtendrá un TypeError:

>>> np.arange(stop=10)
Traceback (most recent call last):
File "", line 1, in
TypeError: arange() missing required argument 'start' (pos 1)

Tienes el error porque arange () no le permite a explícitamente evitar el primer argumento que corresponde a empezar. Si usted proporciona un único argumento, entonces tiene que ser comienzo, pero arange () lo usará para definir dónde se detiene el conteo.

medio de argumentos negativos

Si proporciona valores negativos para el arranque o ambos de inicio y parada, y tiene un paso positivo, entonces arange () funcionará de la misma manera que con todos los argumentos positivos:

>>> np.arange(-5, -1)
array([-5, -4, -3, -2])
>>> np.arange(-8, -2, 2)
array([-8, -6, -4])
>>> np.arange(-5, 6, 4)
array([-5, -1, 3])

Este comportamiento es totalmente coherente con los ejemplos anteriores. El recuento comienza con el valor de inicio, incrementando repetidamente a paso, y termina antes de llegar a la parada.

contando hacia atrás

veces deseará una matriz con los valores en decremento de izquierda a derecha. En tales casos, puede utilizar arange () por un valor negativos para la etapa, y con un mayor arranque de parada:

>>> np.arange(5, 1, -1)
array([5, 4, 3, 2])
>>> np.arange(7, 0, -3)
array([7, 4, 1])

En este caso, la notificación el siguiente patrón: las aperturas de matriz obtenidos con el valor del primer argumento y decrementos para el paso hacia el valor del segundo argumento.

En la última sentencia, el inicio es de 7, y la matriz resultante comienza con este valor. paso es -3 por lo que el segundo valor es 7 + (- 3), es decir 4. El tercer valor es 4 + (- 3), o 1. Contar detiene aquí desde tope (0) se alcanza antes de que el siguiente valor (- 2).

Se puede ver las representaciones gráficas de este ejemplo en la figura siguiente:

Una vez más, de inicio se muestra en verde, parada en rojo, mientras que el paso y los valores contenidos en la matriz son de color azul.

Esta vez, las flechas indican la dirección de derecha a izquierda. Esto se debe a inicio es mayor que la parada, el paso es negativo, y que está básicamente contando hacia atrás.

El ejemplo anterior produce el mismo resultado que la siguiente:

>>> np.arange(1, 8, 3)[::-1]
array([7, 4, 1])
>>> np.flip(np.arange(1, 8, 3))
array([7, 4, 1])

Sin embargo, la variante con el valor negativo de paso es más elegante y concisa.

quedando vacío matrices

Hay varios casos límite donde se puede obtener matrices NumPy vacíos con arange (). Estos son casos regulares de numpy.ndarray sin ningún tipo de elementos.

Si proporciona valores iguales de inicio y parada, entonces obtendrá una matriz vacía:

>>> np.arange(2, 2)
array([], dtype=int64)

Esto se debe a extremos de conteo antes de que el valor de parada se alcanza. Dado que el valor de inicio es igual a la parada, no se puede llegar y se incluye en la matriz resultante también.

Uno de los casos inusuales es cuando inicio es mayor que la parada y el paso es positivo, o cuando la marcha está a menos de parada y el paso es negativo:

>>> np.arange(8, 2, 1)
array([], dtype=int64)
>>> np.arange(2, 8, -1)
array([], dtype=int64)

Como se puede ver, estos ejemplos resultan con matrices vacías, no con errores. Tipos

de datos de np.arange ()

Los tipos de los elementos de arrays NumPy son un aspecto importante del uso de ellos. Cuando se trabaja con arange (), puede especificar el tipo de elementos con el dtype parámetro.

Nota: Aquí están algunos puntos importantes sobre los tipos de los elementos contenidos en las matrices NumPy:

  • Todos los elementos de una matriz NumPy son del mismo tipo llamado dtype (abreviatura de tipo de datos). dtypes
  • NumPy permiten que haya más posibilidades de que los tipos numéricos incorporadas de Python.
  • En algunos casos, dtypes NumPy tiene alias que corresponden a los nombres de Python tipos incorporados.
  • Por lo general, las rutinas NumPy puede aceptar Python tipos numéricos y viceversa.
  • Algunos dtypes NumPy tiene definiciones dependientes de la plataforma.

Si desea obtener más información sobre las matrices de dtypes NumPy, a continuación, lea la documentación oficial.

Usted es libre de dtype omitir. En este caso, arange () intentará deducir la dtype de la matriz resultante. Depende de los tipos de inicio, parada y paso, como se puede ver en el siguiente ejemplo:

>>> x = np.arange(5)
>>> x
array([0, 1, 2, 3, 4])
>>> x.dtype
dtype('int64')
>>> x.itemsize # In bytes
8

Aquí, hay un argumento (5) que define el rango de valores. Su tipo es int. Es por eso que el dtype de la matriz x serán uno de los tipos de enteros proporcionadas por NumPy. En este caso, NumPy elige el dtype Int64 por defecto. Este es un tipo entero de 64 bits (8 bytes).

la matriz en el ejemplo anterior es equivalente a ésta:

>>> x = np.arange(5, dtype=int)
>>> x
array([0, 1, 2, 3, 4])
>>> x.dtype
dtype('int64')

El argumento dtype = int no se refiere a Python int. Se traduce en NumPy Int64 o simplemente np.int.

NumPy le ofrece varias dtypes enteros de tamaño fijo que se diferencian en la memoria y límites:

  • np.int8: entero de 8 bits (de -128 a 127)
  • np.uint8: 8 bits entero sin signo (de 0 a 255)
  • np.int16: entero con signo de 16 bits (-32,768 hasta 32.767)
  • np.uint16: 16 bits entero sin signo (de 0 a 65535)
  • np.int32: entero con signo de 32 bits (de -2 ** 31 a 2 ** 31-1)
  • np.uint32: 32 bits entero sin signo (de 0 a 2 ** 32-1)
  • np.int64: entero con signo de 64 bits (de -2 ** 63 a 2 ** 63-1)
  • np.uint64: 64 bits entero sin signo (de 0 a 2 ** 64-1)

Si desea que otros tipos de enteros para los elementos de la matriz , a continuación, sólo especificar dtype:

>>> x = np.arange(5, dtype=np.int32)
>>> x
array([0, 1, 2, 3, 4], dtype=int32)
>>> x.dtype
dtype('int32')
>>> x.itemsize # In bytes
4

Ahora la matriz resultante tiene los mismos valores que en el caso anterior, pero los tipos y tamaños de los elementos difieren. El argumento dtype = np.int32 (o dtype = ‘int32’) fuerzas el tamaño de cada elemento de x a ser de 32 bits (4 bytes).

Cuando su argumento es un número decimal en lugar de número entero, el dtype pasará algún NumPy tipo de punto flotante, en este caso float64:

>>> y = np.arange(5.0)
>>> y
array([0., 1., 2., 3., 4.])
>>> y.dtype
dtype('float64')

Los valores de los elementos son los mismos en los últimos cuatro ejemplos, pero los dtypes difieren .

Generalmente, cuando se proporciona al menos un argumento de coma flotante a arange (), la matriz resultante tendrá elementos de punto flotante, incluso cuando otros argumentos son números enteros:

>>> np.arange(1, 5.1)
array([1., 2., 3., 4., 5.])
>>> np.arange(1, 5.1).dtype
dtype('float64')
>>> np.arange(0, 9, 1.5)
array([0. , 1.5, 3. , 4.5, 6. , 7.5])
>>> np.arange(0, 9, 1.5).dtype
dtype('float64')

en los ejemplos anteriores, el inicio es un número entero, pero la dtype es np.float64 debido parada o paso son los números de punto flotante.

Si especifica dtype, entonces arange () va a tratar de producir una matriz con los elementos del tipo de datos siempre que:

>>> y = np.arange(5, dtype=float)
>>> y
array([0., 1., 2., 3., 4.])
>>> y.dtype
dtype('float64')

El argumento dtype = flotar aquí se traduce en NumPy float64, que es np.float. Se no se refiere a Python flotador. alias de tamaño fijo para float64 son np.float64 y np.float_.

cuando se necesita un dtype de coma flotante con precisión y menor tamaño (en bytes), se puede especificar explícitamente que:

>>> z = np.arange(5, dtype=np.float32)
>>> z
array([0., 1., 2., 3., 4.], dtype=float32)
>>> z.dtype
dtype('float32')

Usando dtype = np.float32 (o dtype = ‘float32’) hace que cada elemento de la matriz z 32 bits (4 bytes) grandes. El tamaño de cada elemento de y es de 64 bits (8 bytes):

>>> y.itemsize # In bytes
8
>>> z.itemsize # In bytes
4

La diferencia entre los elementos de Y y Z, y en general entre np.float64 y np.float32, es la memoria utilizada y la precisión: la primera es más grande y más preciso que la segunda.

En muchos casos, no se dará cuenta de esta diferencia. Sin embargo, a veces es importante. Por ejemplo, TensorFlow utiliza float32 y int32. Del mismo modo, cuando se trabaja con imágenes, se utilizan tipos aún más pequeños como uint8.

Cuando paso no es un entero, los resultados podrían ser inconsistentes debido a las limitaciones de aritmética de punto flotante.

Más allá de rangos simples con np.arange ()

Se pueden combinar convenientemente arange () con los operadores (como +, -, *, /, **, etc.) y otras rutinas NumPy (como abs () o sin ()) para producir los rangos de valores de salida:

>>> x = np.arange(5)
>>> x
array([0, 1, 2, 3, 4])
>>> 2**x
array([ 1, 2, 4, 8, 16])
>>> y = np.arange(-1, 1.1, 0.5)
>>> y
array([-1. , -0.5, 0. , 0.5, 1. ])
>>> np.abs(y)
array([1. , 0.5, 0. , 0.5, 1. ])
>>> z = np.arange(10)
>>> np.sin(z)
array([ 0. , 0.84147098, 0.90929743, 0.14112001, -0.7568025 ,
-0.95892427, -0.2794155 , 0.6569866 , 0.98935825, 0.41211849])

Esto es particularmente adecuado cuando se desea crear una trama en la Matplotlib.

Si necesita una matriz multidimensional, entonces se puede combinar arange () con .reshape () o funciones y métodos similares:

>>> a = np.arange(6).reshape((2, 3))
>>> a
array([[0, 1, 2],
[3, 4, 5]])
>>> a.shape
(2, 3)
>>> a.ndim
2

Así es como se puede obtener la instancia ndarray con los elementos [0, 1, 2, 3, 4, 5] y darle forma a una matriz de dos dimensiones.

Comparación de la gama y np.arange ()

Python tiene incorporado un rango de clase, similar a NumPy arange () en cierta medida. alcance y np.arange () tienen importantes distinciones relacionadas con la aplicación y rendimiento. Vas a ver sus diferencias y similitudes.

La principal diferencia entre los dos es que se alcance una clase incorporada Python, mientras arange () es una función que pertenece a una biblioteca de terceros (NumPy).

Además, sus efectos son diferentes! En general, el rango es más adecuado cuando se necesita para iterate utilizando el pitón de bucle. Si desea crear una matriz NumPy, y aplicar bucles rápidos bajo el capó, entonces arange () es una solución mucho mejor.

parámetros y salidas

Tanto gama y arange () tienen los mismos parámetros que definen los intervalos de los números obtenidos: paso

  • inicio
  • parada

De aplicar estos parámetros de manera similar, incluso en los casos en que de inicio y parada son iguales.

Sin embargo, cuando se trabaja con un rango:

  • usted tiene que proporcionar argumentos número entero. De lo contrario, obtendrá un TypeError.
  • No se puede especificar el tipo de los números cedidos. Siempre ha int.

cubre y arange () también difieren en sus tipos de retorno: gama

  • crea una instancia de esta clase que tiene las mismas características que otras secuencias (como lista y tupla), tales como la adhesión, la concatenación, la repetición, rebanado, comparación, verificación de longitud, y más.
  • arange () devuelve una instancia de NumPy ndarray.

crear secuencias

Puede aplicar rango para crear una instancia de lista o tupla con números iguales de tiempo dentro de un rango predefinido. Usted puede encontrar comprensiones especialmente adecuado para este propósito.

Sin embargo, crear y manipular matrices NumPy es a menudo más rápido y más elegante que trabajar con listas o tuplas. de

Let comparar el rendimiento de la creación de una lista mediante la comprensión contra un ndarray NumPy equivalente con arange ():

>>> import timeit
>>> n = 1
>>> timeit.timeit(f'x = [i**2 for i in range({n})]')
>>> timeit.timeit(f'x = np.arange({n})**2', setup='import numpy as np')

La repetición de este código para variar los valores de n arrojó los siguientes resultados en mi máquina:

Estos resultados podrían variar, pero claramente se puede crear una matriz NumPy mucho más rápido que una lista, a excepción de las secuencias de longitudes muy pequeñas. (La aplicación menudo trae beneficios adicionales de rendimiento!)

Esto se debe a NumPy realiza muchas operaciones, incluyendo un bucle, en el nivel C. Además, NumPy está optimizado para trabajar con vectores y evita algunos gastos generales a Python.

Python para Loops

Si necesita los valores para repetir en un bucle for Python, entonces rango suele ser una solución mejor. De acuerdo con la documentación oficial de Python:

La ventaja del tipo rango sobre una lista regular o tupla es que un objeto de rango tomará siempre la misma (pequeña) cantidad de memoria, no importa el tamaño del rango que representa (como lo sólo almacena los valores de inicio, parada y la etapa de cálculo artículos y subintervalos individuales según sea necesario). rango (Fuente)

es a menudo más rápido que arange () cuando se utiliza en Python para bucles, sobre todo cuando hay una posibilidad de salir de un bucle pronto. Esto se debe a rango genera números de la manera perezosa, ya que son necesarios, uno a la vez.

Por el contrario, arange () genera todos los números al principio.

Para obtener más información sobre la gama, se puede comprobar la función Python El rango () (Guía) y la documentación oficial.

otras rutinas Basado en Numerical Ranges

Además de arange (), puede aplicar otras rutinas de creación de la matriz NumPy sobre la base de intervalos numéricos:

  • linspace () es similar a arange () en que devuelve números iguales de tiempo. Sin embargo, puede especificar el número de valores para generar, así como si se debe incluir el punto final y si desea crear varias matrices a la vez.
  • logspace () y geomspace () son similares a linspace (), excepto los números devueltos están espaciadas uniformemente en la escala logarítmica.
  • meshgrid (), ogrid (), y mGrid () rejillas de retorno de puntos representan como matrices.

Todas estas funciones tienen sus características específicas y casos de uso. Se puede elegir el más adecuado de acuerdo a sus necesidades.

Como ya vimos, NumPy contiene más rutinas para crear instancias de ndarray. Resumen

rápida

Para uso NumPy arange (), es necesario importar numpy primera:

>>> import numpy as np

Aquí hay una tabla con algunos ejemplos que resumen cómo utilizar NumPy arange (). Podría ser útil para memorizar varios usos:

no se olvide que también puede influir en la memoria utilizada para las matrices especificando dtypes NumPy con el dtype parámetro.

Conclusión

Ahora ya sabe cómo utilizar NumPy arange (). El np.arange función () es una de las rutinas NumPy fundamentales a menudo utilizados para crear instancias de NumPy ndarray. Tiene cuatro argumentos:

También ha aprendido NumPy arange () se compara con el pitón incorporado en el rango de clase al crear secuencias y generar valores para repetir.

viste que hay otras rutinas de creación de la matriz NumPy basados ​​en rangos numéricos, como linspace (), logspace (), meshgrid (), y así sucesivamente.

Si tiene alguna pregunta o comentario, por favor ponerlos en la sección de comentarios.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *