Show Menu
Cheatography

Python numpy Cheat Sheet by

Python numpy cheat sheet

Creación y copia de arrays

np.arr­ay(­[[l­ist1, list2, list3], [list4, list5,­lis6]])
Creación de array 2x3. Podemos forzar el tipo del array devuelto con el parámetro dtype (dtype = "­int­")
a.ndim
número de dimens­iones del array
a.shape
Dimens­iones y elementos en cada dimensión
a.dtype
tipo del array
np.ara­nge­(start, stop, step)
Genera array de un conjunto de números entre un valor de inicio y uno final. Si no especi­ficamos el tercer argumento, se sobree­ntiende que el incremento es de 1. Si solo añadimos un valor como argumento, la función considera todos los valores desde el cero hasta dicho valor (sin inclui­rlo).
np.lin­spa­ce(­start, finish, n)
genera un array NumPy formado por n números equies­pac­iados entre dos dados. el array generado incluye el valor final. podemos especi­ficar el tipo del array usando el parámetro dtype:
np.log­spa­ce(­start, finish, n)
en una escala logarí­tmica, o, dicho con otras palabras, devuelve también el número de valores especi­ficado (como en linspace), pero devolv­iendo el resultando de elevar 10 a dichos valores
np.emp­ty(­shape = (r, c))
crea un array de las dimens­iones indicadas pero sin inicia­lizar sus valores. Si solo indicamos una dimens­ión... el array será unidim­ens­ional. Si se muestra, saldrán números aleato­rios.
np.zer­os(­shape = (r, c))
np.one­s(shape = (r, c))
np.ful­l(shape = (r, c), fill_value = n)
crea un array de las dimens­iones indicadas, rellen­ándolo con el valor que se especi­fique
np.emp­ty_­like(a)
genera un array sin inicia­lizar con las mismas dimens­iones y tipo que otro array dado.
np.zer­os_­like(a)
np.one­s_l­ike(a)
np.ful­l_l­ike(a, fill_value = n)
np.eye(r, c)
genera un array de dos dimens­iones (con el tamaño indicado por los dos primeros argume­ntos) con ceros salvo en la diagonal principal, donde se insertan unos.
np.ide­nti­ty(d)
genera una matriz identidad: matriz cuadrada de ceros salvo en la diagonal principal.
np.rep­eat(a, times, axis = n)
replica los elementos de un array a lo largo del eje indicado:
a.asty­­pe­(­"­­int­­")
hacer un copia de un array aplicá­ndole otro tipo de datos
b = a.copy()
realizar una copia indepe­­nd­iente de un array
b = a.asty­pe(­"­int­")
hacer un copia de un array aplicá­ndole otro tipo de datos

Permut­aciones

np.ran­dom.pe­rmu­tat­ion­(li­st/­array)
devuelve un array con la versión desord­enada de la secuencia cedida como argumento. Si el array indicado tiene más de una dimensión, solo se desordena a lo largo del primer eje.
np.ran­dom.sh­uff­le(­lis­t/a­rray)
modifica una secuencia in-place desord­enando sus elementos

Funciones de conjuntos

np.uni­que(a)
devuelve un array ordenado con los elementos únicos de las estruc­turas de entrada
np.uni­on1d(a, b)
devuelve un array unidim­ens­ional ordenado con los elementos result­antes de unir los arrays indicados
np.int­ers­ect­1d(a, b)
devuelve un array ordenado con los valores únicos de la inters­ección de las estruc­turas de entrada (devuelve los elementos que se repitan en ambos)
np.int­ers­ect­1d(a, b)
devuelve un array ordenado con los valores únicos de la inters­ección de las estruc­turas de entrada (devuelve los elementos que se repitan en ambos)
np.set­dif­f1d(a, b)
Return the unique values in a that are not in b
np.set­dif­f1d(a, b)
Return the unique values in a that are not in b
np.set­xor­1d(a, b)
devuelve un array ordenado con los valores únicos del conjunto de elementos que pertenecen a a o a b, pero no a ambos
np.in1d(a, b)
devuelve un array ordenado unidim­ens­ional booleano con los elementos de a que se encuentran también en b
np.isin(a, b)
devuelve un array de las mismas dimens­iones que el array a en el que se indique con booleanos si el elemento corres­pon­diente está o no incluido en b

Lectura y escritura de ficheros

np.sav­e("m­y_a­rra­y", a)
guardar el contenido de un array en disco. Con esta función los ficheros se graban con extensión ".np­y". Si no indicamos esta extensión, se añadirá automá­tic­amente (si indicamos otra extensión, la extensión .npy se añadirá tras la nuestra)
a = np.loa­d("a­rra­y.n­py")
Cargar fichero
np.sav­ez(­"­arr­ays­", a, b)
guardar varios arrays NumPy en el mismo archivo. El fichero se guarda con la extensión ".np­z" (la función de lectura sigue siendo la misma: numpy.l­oad). Al leer el fichero guardado, se devuelve un objeto con estructura de lista cuyos elementos contienen los arrays indivi­duales.
arrays.files
comprobar la lista de índices de una lista de arrays. Luego se podrá acceder con arrays­["no­mbr­e"]
np.sav­etx­t("a­rra­y.t­xt", a)
Guardar array como archivo txt
a = np.loa­dtx­t("a­rra­y.t­xt")
Cargar array desde archivo txt
np.sav­etx­t("a­rra­y.c­sv", a, delimiter = "­,")
Guardar array como archivo csv
a = np.loa­dtx­t("a­rra­y.c­sv", delimiter = "­,")
Cargar array desde archivo csv

Funciones de álgebra lineal

np.dot(a, b)
devuelve el producto escalar de dos arrays
a.dot(b)
np.lin­alg.det(a)
devuelve el determ­inante de la matriz repres­entada por el array
np.lin­alg.inv(a)
devuelve la inversa de la matriz. Se puede comprobar con np.rou­nd(­a.d­ot(­np.l­in­alg.in­v(a)))

La función where

np.whe­re(c, x, y)
acepta como argumentos de entrada una condición y dos estruc­turas tipo array, x e y, y devuelve valores de x o de y en función de que se cumpla o no la condición: Si se cumple, se devuelve el valor de x. Si no se cumple, el de y. Por ejemplo, en la posición de c escribimos x > 2
 

Redime­nsi­ona­miento

a[(a >= 6) | (a == 2)] = 0
Edición con booleanos
a.shape = (4, 3)
fijar el tamaño del array. También con esta función es posible utilizar el valor -1 para dejar que sea Numpy quien calcule el tamaño adecuado
b = np.res­hape(a, newshape = (4, 3))
devuelve un nuevo array con los datos del array cedido como primer argumento y el nuevo tamaño indicado:
b = a.resh­ape((4, -1))
a.flat­ten()
devuelve una copia del array colapsado a una única dimensión
b = np.tra­nsp­ose(a)
Transp­osición de arrays
c = a.tran­spose()
a.T

Operac­iones con arrays

a // 2
Redondeo al entero más próximo
np.mul­tip­ly(a, b)
a*b
np.add(a, b)
a+b
np.sub­tra­ct(a, b)
a-b
np.div­ide(a, b)
a/2
np.pow­er(a, b)
a**b
np.rint(a)
Redondea sus elementos al entero más próximo. no preserva el dtype del array (float64)
np.sign(a)
Devuelve un array NumPy del mismo tamaño con valores que indican el signo de los elementos del array de entrada (1 si el elemento es positivo, 0 si es cero, y -1 si el elemento es negativo)
np.exp(a)
Calcula la expone­ncial de los elementos de la estructura de entrada. e^x
np.log(a)
Logaritmo neperiano o natural de los elementos de la estructura de entrada:
np.sqrt(a)
Raíz cuadrada de los valores de la estructura de entrada. si se encuentra un valor negativo y se está trabajando en el dominio de los números reales, se devuelve un error. Esto no ocurre en el dominio de los números imagin­arios (dtype­="co­mpl­ex")
np.squ­are(a)
Devuelve el cuadrado de los elementos de la estructura de entrada
np.gcd(a, b)
Devuelve el máximo común divisor de los elementos de las dos estruc­turas de entrada (dos arrays o un array y un número)
np.lcm(a, b)
Mínimo común múltiplo de los elementos de las dos estruc­turas de entrada (dos arrays o un array y un número)
np.sin(a)
Devuelve el seno de los elementos
np.cos(a)
Coseno de los elementos
np.tan(a)
Tangente de los elementos
np.arc­sin(a)
Arcoseno de los elementos
np.arc­cos(a)
Arcocoseno de los elementos
np.arc­tan(a)
Arcota­ngente de los elementos
np.deg­2rad(a)
Convierte ángulos de grados sexage­simales a radianes
np.rad­2deg(a)
Convierte ángulos de radianes a grados sexage­sim­ales:
np.bit­wis­e_a­nd(a, b)
Aplica un "­y-l­ógi­co" a nivel de bit

Funciones para arrays booleanos

(a > 0).mean()
porcentaje de elementos mayores que cero
a.all()
devuelve True cuando todos los valores a lo largo del eje indicado del array son True. Si no se especifica el eje, se aplana el array. En un array numérico los números diferentes a cero se interp­retan como True, y aquellos con valor 0, como False. cuando el array está vacío, el método devuelve el valor lógico True
a.any()
devuelve True cuando algún valor a lo largo del eje indicado del array es True. Si el array está vacío, devuelve 0
Aceptan el parámetro axis

Funciones polinó­micas

p = np.polynomial.polynomial.Polynomial([1, -5, 1, -2])
Repres­entar el polinomio -2x3 +x2 -5x + 1
list(p)
extraer los coefic­ientes como lista
p.coef
extraer los coefic­ientes como array
p.degree()
extraer el grado del polinomio
p(x)
Evaluación de un polinomio (clase Polyno­mial)
np.pol­yno­mia­l.p­oly­nom­ial.po­lyv­al(­list, c)
evaluación para el punto (o los puntos) del polinomio con lista de coefic­ientes.
p.deriv(n)
Derivación de polinomios (clase polino­mial). La n indica el orden de la derivada (primera, segunda, tercer­a...) Si no se especi­fica, se calcula la primera derivada.
np.pol­yno­mia­l.p­oly­nom­ial.po­lyd­er(c, n)
Derivación de polinomios con lista de coefic­ientes. El segundo argumento indica el orden de la derivada (primera, segunda, tercer­a...) Si no se especi­fica, se calcula la primera derivada.
p.integ()
Integr­ación de polino­mios. Se puede cambiar el valor de la constante k incluyendo el parámetro k=valor. Se puede calcular varias veces con el parámetro m=valor. En este caso, si se incluye el valor k este puede ser una lista cuyos elementos se asignaran en orden a cada integral.
np.pol­yno­mia­l.p­oly­nom­ial.po­lyi­nt(c)
Calcular integral con lista de coefic­ientes. También acepta k y m
p.roots()
Raíz de un polinomio
np.pol­yno­mia­l.p­oly­nom­ial.po­lyr­oots(c)
Raíz de un polinomio si estamos trabajando solo con los coefic­ientes del polinomio
f = np.pol­yno­mia­l.p­oly­nom­ial.Po­lyn­omi­al.f­it(x, y, n, domain = (-1, 1))
devuelve un objeto de tipo Polynomial repres­entando el polinomio del grado indicado que minimiza la suma de cuadrados de las difere­ncias en las ordenadas (método de mínimos cuadra­dos). La n es el grado del polinomio
f = np.pol­yno­mia­l.p­oly­nom­ial.po­lyf­it(x, y, n)
nos permite aproximar un conjunto de datos según el proced­imiento de mínimos cuadrados devolv­iendo un array NumPy con los coefic­ientes del polinomio. La n es el grado del polinomio.
p = np.pol­yno­mia­l.p­oly­nom­ial.Po­lyn­omi­al.f­ro­mro­ots­(co­ef_­list)
acepta como argumento una lista de raíces (puede ser una lista Python o una estructura semejante) y devuelve el polinomio corres­pon­diente
c = np.pol­yno­mia­l.p­oly­nom­ial.po­lyf­rom­roo­ts(­coe­f_list)
acepta la misma lista de raíces y devuelve los coefic­ientes del polinomio resultante
polyad­d(c1, c2)
suma dos polinomios
polysu­b(c1, c2)
resta dos polinomios
polymu­l(c1, c2)
resta dos polinomios
polymu­lx(c)
multiplica un polinomio por la variable indepe­ndiente x
polydi­v(c1, c2)
divide un polinomio por el otro
polypow(c, pow)
eleva un polinomio a una potencia
Hay dos formas de trabajar con polino­mios: La primera consiste en repres­entar el polinomio utilizando la clase Polynomial que podemos encontrar en la sublib­rería numpy.p­ol­yno­mia­l.p­oly­nom­ial). Esta clase propor­ciona los métodos estándar +, -, , //, %, divmod, * y (), así como otros métodos y atributos.

La segunda forma de trabajar con polinomios es repres­ent­arlos por medio de un array (o estructura semejante) de coefic­ientes.
 

Ordenación de arrays

np.sort(a)
Podemos ordenar un array mediante la función numpy.s­ort, función que permite especi­ficar el eje (o dimensión) por el que se desea realizar la ordena­ción. Si el parámetro corres­pon­diente se fija al valor None, el array es aplanado antes de ordenarlo. Por defecto, este parámetro toma el valor -1, indicando que la ordenación se va a realizar a lo largo del último eje.
a.sort­(axis)
La ordenación se produce in-place. la opción de axis = None no está permitida

Distri­buc­iones

a = np.ran­dom.no­rma­l(loc = m, scale = sd, size = n)
genera un array del tamaño indicado a partir de una distri­bución normal o gaussiana de una cierta media y desviación estandar.
numpy.r­an­dom.be­ta(a, b, size=None)
random.ch­isq­uar­e(df, size=None)
random.ex­pon­ent­ial­(sc­ale­=1.0, size=None)
random.po­iss­on(­lam­=1.0, size=None)

Números aleatorios

np.ran­dom.se­ed(seed = n)
inicia­lizar el generador de números aleatorios para que de los mismos resultados cada vez que se ejecute el código
a = np.ran­dom.ra­nd(r, c)
genera un array del tamaño indicado conten­iendo números aleatorios extraídos del intervalo [0, 1) a partir de una distri­bución uniforme. Si se solo se indica el primer parámetro, se genera un array plano
a = np.ran­dom.ra­ndo­m(size = (r, c))
genera un array del tamaño indicado conten­iendo números reales aleatorios extraídos de una distri­bución continua uniforme en el intervalo [0.0, 1.0):
a = np.ran­dom.ra­ndi­nt(s, f, size = (r, c))
genera un array del tamaño indicado conten­iendo números enteros aleatorios extraídos de una distri­bución discreta uniforme entre los intervalos dados (desde un valor inferior incluido, hasta un valor superior sin incluir)
a = np.ran­dom.ch­oic­e(a­rray, n)
devuelve un array del tamaño indicado conten­iendo una muestra del array unidim­ens­ional cedido como argumento. El parámetro replace determina si la selección se hace o no con reemplazo (por defecto este parámetro toma el valor True)

Funciones matemá­ticas

np.mean(a)
Devuelve la media aritmética de los valores del array a lo largo de los ejes especi­fic­ados. Si no se especi­fica, se calcula la media con todos los valores. También se pueden especi­ficar capas (axis=(0, 2))
np.med­ian(a)
Devuelve la mediana de los valores de un array a lo largo de los ejes especi­fic­ados. Mismas opciones que mean
np.std(a)
Devuelve la desviación estándar de los valores un array a lo largo de los ejes especi­ficados
np.var(a)
Devuelve la varianza de los valores de un array a lo largo de los ejes especi­ficados
np.sum(a)
devuelve la suma de los valores de un array a lo largo de los ejes especi­ficados
np.cum­sum(a)
devuelve la suma acumulada de los valores de un array a lo largo de los ejes especi­ficados
np.cor­rco­ef(a)
devuelve el coefic­iente de correl­ación de Pearson entre las filas de un array bidime­nsional o entre dos arrays unidim­ens­ionales np.cor­rco­ef(a, b)
np.ave­rage(a, weights = w)
Devuelve la media aritmética ponderada de los valores de un array a lo largo de los ejes especi­fic­ados. Los pesos a utilizar se indican con el parámetro weights en forma de lista. Si no se especi­fican los pesos, la función asume que todos los valores sobre los que se va a aplicar el cálculo tienen idéntico peso:
np.arg­max(a)
devuelve los índices de los mayores valores del array a lo largo del eje indicado. Si no se especifica el eje, se aplana el array.
np.arg­min(a)
devuelve los índices de los menores valores del array a lo largo del eje indicado. Si no se especifica el eje, se aplana el array.
Funcionan lo largo de los ejes especi­ficados (axis=0). Si no se especi­fica, se calcula la función con todos los valores. También se pueden especi­ficar capas (axis=(0, 2))

Funciones univer­sales flotantes

np.isnan(a)
evalúa si los elementos de la estructura de entrada son NaN
np.flo­or(a)
devuelve el mayor entero menor o igual que los elementos
np.ceil(a)
devuelve el menor entero mayor o igual que los elementos
np.tru­nc(a)
devuelve los elementos de la estructura de entrada truncados. El valor truncado de un número es el entero más próximo al mismo que está más cerca del cero que el propio elemento
np.round(a, 2)
devuelve un array equiva­lente al cedido como argumento tras sustituir cada elemento por la versión redondeada a un cierto número de decimales. El número de decimales se indica como segundo argumento.
numpy.a­round
a_function = np.vec­tor­ize­(fu­nction)
Permite crear una función vector­izada a partir de una que no lo es, lo que nos permite aplicar esta última a un array.

Funciones univer­sales de compar­ación

np.gre­ater(a, b)
valor verdadero de la compar­ación x1 > x2, comparando elemento a elemento
np.gre­ate­r_e­qual(a, b)
valor verdadero de la compar­ación x1 ≥ x2
np.less(a, b)
valor verdadero de la compar­ación x1 < x2
np.les­s_e­qual(a, b)
valor verdadero de la compar­ación x1 ≤ x2
np.not­_eq­ual(a, b)
valor verdadero de la compar­ación x1 ≠ x2
np.equ­al(a, b)
valor verdadero de la compar­ación x1 == x2
np.log­ica­l_a­nd(a, b)
valor verdadero de x1 AND x2 (con arrays con valores booleanos o arrays con valores -1, 0, y 1))
np.log­ica­l_or(a, b)
evalúa el valor verdadero de x1 OR x2
np.log­ica­l_x­or(a, b)
evalúa el valor verdadero de x1 XOR x2
np.log­ica­l_n­ot(a)
aplica el operador lógico NOT a los elementos
np.max­imum(a, b)
evalúa el valor máximo de las estruc­turas de entrada comparando elemento a elemento
np.min­imum(a, b)
evalúa el valor mínimo de las estruc­turas de entrada

Unión de arrays

np.con­cat­ena­te((a, b), axis = 1)
Unión de arrays. Eje por defecto es 0.
np.hst­ack((a, b))
concatena arrays horizo­nta­lmente (uno al lado del otro)
np.vst­ack((a, b))
realiza la concat­enación vertical (uno encima del otro)
   
 

Comments

No comments yet. Add yours below!

Add a Comment

Your Comment

Please enter your name.

    Please enter your email address

      Please enter your Comment.

          Related Cheat Sheets

            Python 3 Cheat Sheet by Finxter

          More Cheat Sheets by julenx

          Python pandas Cheat Sheet
          R Cheat Sheet
          Pandas datetime Cheat Sheet