COMANDOS PYTHON

• Estructura de programa:
1. Comentarios con el tipo de codificación, objeto del programa, nombre del
programador y fecha de la última modificación
2. Sentencias que importan los módulos pertinentes Automático en Windows

3. Definición de las funciones y procedimientos que vayamos a utilizar

4. Grueso del algoritmo o programa principal
5. Órdenes de salida o de escritura de la solución

• A tener en cuenta:
- Incluir comentarios que describan el efecto de cada algoritmo para comprenderlo
al leerlo a posteriori
- No olvidar el sangrado cuando sea pertinente
- Nombrar las variables de manera reconocible (a no ser que se haya especificado
su significado en los comentarios)
- Líneas de código preferiblemente no demasiado largas
- Si se tiene una línea demasiado larga, puede cortarse con una barra invertida (\)
y continuar en la siguiente línea
- En paréntesis, corchetes o llaves, no dejar espacios inmediatamente dentro de
ellas
- Justo después de coma, punto y coma o punto, separar con un espacio para mayor
claridad, pero no antes de los mismos
• Directorio archivo ― pwd Consultas sobre las func iones:
help(funcion) o funcion?
• Cambiar directorio ― cd

• Crear archivo con lo trabajado ― %logstart -o nombre_archivo.txt/.py

• Salir o reentrar al archivo ― %logoff/%logon

• Cargar los comandos “mágicos” de iPython ― %magic

• Consultar el tipo de elemento ― type(#)

- String o cadena de texto ― str: ‘cadena de texto random’, “28” (‘’ o “”)
- Entero ― int: 10, 69, 1 Las operaciones entre enteros solo
- Decimal ― float: 10.0, 69.5, 1. pueden dar como resultado otro
entero (se trunca el resultado)
• Redondear ― round(#)
- Redondear eligiendo el número de decimales (x) ― round(#, x)
- Al alza ― ceil(#)
- A la baja ― floor(#) Debe haberse importado previamente el
módulo matemático: from math import *
• Operaciones básicas:
- Suma ― + Para renombrar los contenidos de un
módulo, p.e. from math import sin
- Resta ― - as sen
- Multiplicación ― *
- División ― /
- Exponenciación ― **
Prioridad de ejecución: **, *, /, %, +, -
- Residuo o resto de la división ― %
• Logaritmos:
- Neperiano ― log(x)
- Decimal ― log10(x)
- Otra base (p.e. 3) ― log(x, 3)
F or F = F

F or T = T
• Operadores lógicos:
- Igual a (comparación) ― == T or T = T

- Distinto de ― != o <> F and F = F

- Menor que ― < T and F = F
- Mayor que ― >
T and T = T El índice empieza siempre en
- Y, o ― and, or 0, por lo que el primer
- Verdadero, falso ― True, False elemento es frase[0] y no
frase[1]. Al escribir frase[10]
estamos tomando el elemento
• Número de caracteres ― len(#) 11, no el 10

• Índices: Espacios incluidos. Empieza en 0

- Caracteres contando x desde el principio ― frase[x]

- Caracteres contando x desde el final ― frase[-x]
- Caracteres en el intervalo ― frase[x:y] Sin incluir y  [x, y)
- Caracteres a la izquierda de x ― frase[:x]
- Caracteres a la derecha de x ― frase[x:] Omitiendo x en ambos
casos
• Strings en Unicode ― frase = u‘Física’, u‘España’

Los caracteres en Python son de tipo ascii (7 bits), si queremos que no haya problemas con los
acentos o con la letra ñ tienen q ue ser definidos como de tipo unicode de 8 bits

• Transformar string a minúsculas ― frase_minusculas = frase.lower()

• Transformar string a mayúsculas ― frase_mayusculas = frase.upper()

• Sustituir termino_1 por termino_2 ― frase.replace("termino_1",

“termino_2")

• Concatenar strings ― “Esto es” + “una frase” = “Esto es una frase”

Únicamente pueden concatenarse strings. Para concatenar letras o números hay que convertirlos en
strings: print(str(10) + “al cuadrado es” + str(100))

• Imprimir con formato predefinido ― print(“El %s de %d es %f”) % (‘cubo’,

10, 10.**3) = “El cubo de 10 es 1000.”
Para los floats puede utilizarse el %s - símbolo string
formato: %x.yf, siendo x el número %d - símbolo número entero
de caracteres e y, el de decimales %f - símbolo float
%e - símbolo notación científica

• Listas ― [12, 56, 84], [‘Newton’, ‘Curie’, ‘Galileo’], [23,

‘Tesla’, [‘Nietzsche’, ‘Hobbes’, ‘Schopenhauer’], 55, 90]
• Número de elementos de una lista ― len(lista)

• Convertir string en lista (frase = “Yo estudio fisica.”):

- Separando por espacios ― lista_frase = frase.split()
 type(lista_frase) = list
- Separando por ‘no’ ― lista_frase = frase.split(no)
 print(lista_frase) = [‘Yo’, ‘fisica.’]
Nótese que el elemento por el que se
separa desaparece (espacios y ‘no’)
• Funcionalidades de las listas:
- Insertar elementos en una lista ― lista.append(‘elemento’)
- Insertar en posición concreta (índice x+1) ― lista.insert(x, ‘elemento’)
- Conocer posición de un elemento ― lista.index(‘elemento’)
- Ordenar elementos por orden alfabético ― lista.sort()
- Extraer y eliminar un elemento de la lista (x = índice) ― lista.pop(x)
- Eliminar un elemento de la lista ― lista.remove(‘elemento’)
- Invertir orden de una lista ― lista_invertida =
lista.sort(reverse=True) o lista[::1]

• Hacer anotaciones ― #Anotación que no Los elementos en las listas

influye en el programa tienen las mismas
funcionalidades que los
caracteres en los strings
• Listas numéricas:
- Lista de números enteros (rango [0, x) ) ― print(range(x))
- Lista de números enteros con rango acotado (hasta x-1), con intervalo entre
consecutivos ― print(range(100, 200, 10)) = [100, 110,…, 190]

• Tuplas, igual que las listas pero inalterables ― (‘Newton’, ‘Curie’, ‘Galileo’)

• Diccionarios ― datos = {‘Nombre’: ‘Simone’, ‘Apellido’: ‘de

Beauvoir’, ‘Nacionalidad’: ‘francesa’, ‘Edad’: ‘78’} 
print(datos[‘Nombre’]): ‘Simone’
- Parámetros ― datos.keys()
- Datos ― datos.values()

• Ejecutar programa ― execfile(‘nombre_programa.py’) o run

nombre_programa.py
Podemos definir
ahora una
• Definir variables: variable para
- def instancia_funcion(variable_1, variable_2): cada dato ―
funcion = formula (incluyendo variables) esfera(x) =
l,s,v, incluso
return (funcion) sustituyendo x
por un valor
- def esfera(r): pi_x_r se
denomina variable interna
pi_x_r = pi * r o local porque solo se usa
longitud = 2. * pi_x_r dentro de la función (no
superficie = 4. * pi_x_r * r se devuelve mediante el
return)
volumen = superficie * r /3.
return [longitud, superficie, volumen]
• Pedir datos por pantalla ― dato = raw_input(‘Dame el dato: ’)
- Especificar el tipo de dato (p.e. float) ― dato = float(raw_input(‘Dame
el decimal: ’))
- Dato genérico (permite varios tipos) ― dato = eval(raw_input(‘Dame el
dato: ’))

• Crear módulos personales:

- Crear fichero de texto con todos los módulos (funciones definidas una tras otra)
- Nombrarlo como funciones.py (nombre arbitrario, lo importante es la extensión)
- Invocarlo desde otro programa ― from funciones import funcion / from
funciones import *

• Bucles:
- For ― realiza una misma acción varias veces, como sumatorios o recorrer con
una variable cada uno de los elementos de una lista:
cientificos = [‘Nikola Tesla’, ‘Ernest Rutherford’,
‘Jocelyn Bell Burnell’]
for cientifico in cientificos:
print(‘%s hizo grandes aportes a la Ciencia’
%cientifico)
Resultado: ‘cientifico’ es una
Nikola Tesla hizo grandes aportes a la Ciencia variable muda que
Ernest Rutherford hizo grandes aportes a la Ciencia va tomando el valor
de cada uno de los
Jocelyn Bell Burnell hizo grandes aportes a la Ciencia elementos de la
lista hasta que no
queden más (fin del
bucle)
En bucles, enumerate () devuelve dos cosas: elemento e índice
de una lista. Definiendo dos variables, podemos usarlo de la siguiente manera:

for i, cientifico in enumerate(ci entificos):

print(‘%d - %s hizo grandes aportes a la Ciencia’ % (i+1,
cientifico))
Además de la función range(),
Resultado:
Python tiene xrange(), muy
1- Nikola Tesla hizo grandes aportes a la Ciencia
similar, salvo porque us ada en
2- Ernest Rutherford hizo grandes aportes a la Ciencia un bucle for, va creando los
elementos a medida que los va
3- Jocelyn Bell Burnell hizo grandes aportes a la Ciencia necesitando, en lugar de
crearlos todos de una vez y
¡Ojo! Python reconoce que guardarlos en memoria ( es
el bucle termina cuando el decir, no genera una lista, por
sangrado cambia lo que es mucho más rápido y
eficiente)
- While / while not ― para cuando no
conocemos el número de veces que hay que ejecutar las operaciones. Se
ejecutan operaciones mientras se cumpla cierta condición:
En este bucle tenemos que incrementar
cuentas = 0 explícitamente el valor de la variable, o
while cuentas < 4: bien nunca cambiaría y tendríamos un bucle
infinito. SI esto ocurre podemos pararlo con
print(cuentas) las teclas ctrl + C o pulsando el
cuentas = cuentas + 1 cuadradito rojo en la consola de iPython
 Resultado:
0
1 Debido a la precisión finita de los ordenadores
2 es posible que determinada igualdad nunca se
3 cumpla y no se detenga el bucle. Es preferible,
por tanto, no comparar floats exactamente.
- If/else ― condicionales: Solución: usar intervalos de precisión

c = int(raw_input(‘Introduzca un entero: ’))

if c > 0:
print(‘La variable c es positiva’)
Si tras un condicional
elif c < 0: hay una única sentencia,
print(‘La variable c es negativa’) esta se puede escribir en
else: la misma línea sin
necesidad de sangrar:
print(‘La variable c vale cero’)
if a > b: print(‘a
- Break ― interrumpir el bloque más cercano es mayor que b’)
en un bucle while o for. Se usa, por ejemplo, else: print(’a es
menor o igual que
para evitar que un bucle siga corriendo b’)
cuando ya se ha cumplido la condición.
- Continue ― indica continuar con el siguiente Un else puede usarse dentro
elemento del bucle más interior, de un bucle for para imprimir
un aviso si el for agota la
interrumpiendo el actual.
lista, terminando el bucle
• Indicar que hay un error cuando ya adelantamos
que este puede producirse ― try-except

a, b = eval(raw_input(‘Introduzca dos valores: ’))

try:
a/b
except:
print(‘Hay un error en los valores de entrada’)

a, b, c = 23, 0, ‘A’
try:
a/b
except ZeroDivisionError:
print(‘Error, division entre cero’)
try:
a/c
except TypeError:
print(‘Error en el tipo de dato’)

• Arrays ― orientado al cálculo numérico (más práctico que las listas en ese
sentido). Pueden considerarse como vectores o matrices. Se importan mediante el
módulo numpy, que contiene las mismas funcionalidades que math y añade otras
tantas.
- Crear array ― x = ([2., 7.6, 3.1, 9.8])
- Convertir lista (p.e. la llamada ‘datos’) en array ― datos = array(datos)
 - Rango en array ― arange(x)
- Array de x ceros ― zeros(x)
- Array de x unos ― ones(x)
- Array n valores desde x hasta y (incluidos), con el mismo intervalo entre valor y
valor ― linspace(x, y, n)

• Índices de arrays:
- Intervalo concreto: [x, z) ― print(nombre_array[x:y])
- Elementos desde el primero hasta x-1: [0, x) ― print(nombre_array[:x])
- Elementos desde y hasta el final ― print(nombre_array[y:])
- Elemento x contando desde el final ― print(nombre_array[-x])
- Elementos de x hasta y, de dos en dos ― print(nombre_array[x:y:2])

z.funcionalidad() == funcionalidad(z)
• Funcionalidades de un array:
- Número de elementos de un array ― print(len(nombre_array))
- “Forma” de un array ― print(nombre_array.shape)
- Conocer tipo de dato x dentro de un array ― type(nombre_array[x])
- Concatenar arrays ― m = concatenate((array1, array2))
- Concatenar array y valores x e y ― n = concatenate((array1, [x, y]))
- Añadir un elemento x a un array z ― z = append(z, x)
- Añadir un elemento x a un array z en la posición 3 ― z = insert(z, 2, x)
- Imprimir valor máximo de los elementos del array ― z.max()
- Imprimir valor mínimo de los elementos del array ― z.min()
- Imprimir valor medio de los elementos del array ― z.mean()
- Imprimir deviación típica de los elementos del array ― z.std() Se trate o no de
- Imprimir suma de todos los elementos del array ― z.sum() arrays booleanos
- Imprimir mediana de los elementos del array ― z.median()
- Array como índice de otro array ― print(array1[array_indice])
- Crear arrays usando operadores booleanos ― array_mayores_50 = array2 >
50  imprime un array booleano con elementos True o False en función de si el
dato cumple o no la desigualdad
from scipy import
random
• Array de x números aleatorios alrededor de cero y con varianza = 1― numeros =
random.randn(x)
from numpy.random import
*
• Array de n números aleatorios entre x e y-1: [x, y) ― randint(x, y, n)

• Operaciones con arrays:

- Suma ― array1 + array2 Las operaciones con arrays se
En la división de hacen elemento a elemento, así
- Resta ― array1 – array2 que es importante que tengan
arrays: inf =
- División ― array1/array2 división entre 0 la misma forma

• Arrays con datos booleanos:

Teniendo:
A = array([True, False, True])
B = array([False, False, True])
C = array([1, 2, 3])
 El “dominante” es False, que hace cero los datos “estándar”, mientras que a
otro booleano lo reemplaza por sí mismo:
- A*B = array([False, False, True])
- A*C = ([1, 0, 3])

• Arrays multidimensionales:
- Array de tres filas y tres columnas — array0 = array([[a,b,c],
[x, y, z], [j, k, l]])
- Array de ceros de 2x3 ― array1 = zeros((2, 3))
- Array de unos de 4x2 ― array2 = ones((4, 2))
- Array de rango 9 ( [0, 9) ) y de forma 3x3 ― array3 =
arange(9).reshape(3,3)
- Primer elemento de la primera fila y la primera columna (índice[0x0]) ―
array4[0,0]
- Primera columna ― array5[:,0]
- Primera fila ― array6[0,:]
- Segunda fila ― array7[1,:]

El primer elemento del corchete equivale a la De la misma forma podemos asignarle valores
fila, y el segundo, a la columna. Podemos jugar a los arrays. Simplemente escogemos la
introduciendo un valor fijo en uno de los lugares posición o posiciones que queremos manipular
(0, 1 o 2 en el caso de que haya 3 y los igualamos a los valores buscados. P.e.
filas/columnas) y modificando el otro con ‘:x’, nombre_array[1:, 2 ] nos daría el segundo
siendo x la posición del último elemento que y tercer elemento de la tercera columna de
queremos que dé. P.e. nombre_array[1,:2] un array 3x3. Si pusiéramos
nos devolvería un array con los dos primeros nombre_array[1:, 2] = [x, y] , estos
elementos de la segunda fila de un array 3x3. dos elementos se sustituirían por x e y

Otro ejemplo: poniendo nombre_array[ -1,

:] = nombre_array[-1, :]*10, Python nos
devolvería un array cuya últi ma fila está
íntegramente multiplicada por 10
Incluido en el módulo
stats de scipy
• Media aritmética — mean(#)

• Media geométrica (incertidumbre que actúa de forma multiplicativa p.e. porcentajes) ― gmean(#)

• Mediana (valor que separa la mitad de los valores mayores que la otra mitad) ― median(#)

• Varianza (cuadrado de la desviación estándar) ― var(#)

• Desviación estándar ― std(#)

• Media ponderada ― average(#) Funciones estadísticas incluidas en

numpy salvo especificaciones

• Manipular fichero ― instancia = open(‘mi_fichero.txt’, ‘x’)

- Abrir para leer (debe existir previamente) ― x = r
- Abrir para escribir (si no existe lo crea y si existe lo sobreescribe) ― x = w
 - Abrir para añadir texto (si no existe lo crea y si existe continúa escribiendo al
final del fichero) ― x = a
- Abrir el fichero para leer y escribir ― x = rw

Primer paso para manipular un fichero: crear una instancia, una llamada o referencia (en este
caso a un fichero) a la que se le asigna un nombre. P.e. vamos a definir la instancia fs y a
manipular un hipotético fichero invocándola:

fs = open(‘fichero.txt’, ‘w’)
fs.write(‘Texto del fichero’ )

• Cerrar un fichero ― instancia.close() Importantísimo porque aquí es

cuando realmente se escribe el
• Dejar línea en blanco ― ‘\n’ fichero

• Leer un fichero línea a línea ― líneas = instancia.readlines()

Los datos (números, letras, caracteres) se escriben y lee n como strings. Si queremos operar con
ellos debemos transformarlos en los tipos de variables apropiadas (int, float, list, array…)

• Convertir listas en arrays (p.e.) ― x_datos, y_datos = array(x_datos),

array(y_datos)

• Separar una línea en columnas ― x, y = línea.split() (linea previamente

definida) Separa, por defecto, datos en el texto separados por espacios. S i queremos
otra cosa hay que especificarla, p.e. split(‘,’)

• Crear y guardar un fichero de dos columnas con los datos de los arrays x_datos e
y_datos ― savetxt(‘nombre_archivo.txt’, (x_datos, y_datos))

• Leer un archivo del tipo correspondiente al punto anterior y almacenar los arrays
en las variables x e y ― x, y = loadtxt(‘nombre_archivo.txt’)

savetxt() guarda cada array en una fila, salvo que queramos guardar un
array unidimensional, en cuyo caso se escribe en una columna

• Distribuir datos de un único array d (6x3):

- Definimos una instancia ― d = loadtxt(‘nombre_fichero.txt’)
- Columna 1 (tiempo) ― t = d[0, :]
- Columna 2 (x1) ― x1 = d[1, :]
- Columna 3 (x2) ― x2 = d[2, :]

• Leer datos de un fichero desde la línea x ― x = loadtxt("datos.txt",

skiprows=x) Módulo numpy

• Separar columnas por comas (u otro) en lugar de espacios ― x, y =

loadtxt("datos.txt", delimiter=‘,’)

• Conocer “forma” de los datos de un fichero ― instancia.shape

• Dibujar gráficas:
- Importar módulo pylab
- Definir x (mediante un arange(), por ejemplo)
 - Generar el gráfico de la función ― plot(x)
- Mostrar el gráfico por pantalla ― show() En Windows no es necesario

• Activar modo interactivo para que cada cabio en la gráfica se muestre

inmediatamente ― ion() Solo disponible en iPython

• Crear una instancia para poder “apelar” a la gráfica más tarde ―

mi_dibujo, = plot(x)
Ojo con la coma después de la instancia: indica que
• Variaciones del plot(#): mi_dibujo debe tomar el valor del primer (y en este
caso el único) elemento de la lista, no la lista en sí
- Colores:
▪ Azul ― ‘b’
▪ Verde ― ‘g’
▪ Rojo ― ‘r’
▪ Cian ― ‘c’
▪ Magenta ― ‘m’
▪ Amarillo ― ‘y’
▪ Negro ― ‘k’
▪ Blanco ― ‘w’
- Marcas y líneas:
▪ Línea continua ― ‘-’
▪ Línea a trazos ― ‘―’
▪ Línea a puntos y rayas ― ‘-.’
▪ Línea punteada ― ‘:’
▪ Símbolo pixel ― ‘,’
▪ Símbolo círculo relleno ― ‘o’
▪ Símbolo triángulo hacia arriba ― ‘v’
▪ Símbolo triángulo hacia abajo ‘^’
▪ Símbolo triángulo hacia la izquierda ― ‘<’
▪ Símbolo triángulo hacia la derecha ― ‘>’
▪ Símbolo cuadrado ― ‘s’
▪ Símbolo pentágono ― ‘p’
▪ Símbolo estrella ― ‘*’
▪ Símbolo cruz ― ‘+’
▪ Símbolo X ― ‘x’
▪ Símbolo diamante ― ‘D’
▪ Símbolo diamante alargado ― ‘d’
- Parámetros:
▪ Grado de transparencia ― alpha Float: 0.0 = transparente a 1.0 = opaco

▪ Color de matplotlib ― color o c

String
▪ Etiqueta con cadena de texto ― label
▪ Color del borde del símbolo ― markeredgecolor o mec
▪ Ancho del borde del símbolo ― markeredgewidth o mew (*)
▪ Color del símbolo ― markerefacecolor o mfc
▪ Tamaño del símbolo ― markersize o ms (*) Tipo de línea: ‘-’ ‘–
▪ Tipo de línea ― linestyle o ls ’ ‘-.’‘:’ ‘None’

▪ Ancho de línea ― linewidth o lw (*)

 ▪ Tipo de símbolo ― marker Tipo de símbolo: ‘+’ ‘*’ ‘,’, ‘.’ ‘1’ ‘2’ ‘3’
‘4’ ‘<’ ‘>’ ‘D’ ‘H’ ‘^’ ‘_’ ‘d’ ‘h’ ‘o’ ‘p’
‘s’ ‘v’ ‘x’ ‘|’ TICKUP TICKDOWN TICKLEFT
(*) Float (en número de puntos) TICKRIGHT

- Ejemplos de plot(#):
▪ mi dibujo_2, = plot(x(t), y(t), ‘bx-’)
▪ mi dibujo_3, = plot(x, lw=5,c ='y', marker='o', ms=10,
mfc='red')

• Crear un nuevo gráfico cada vez que hacemos plot(#) ―

mi_dibujo_4, = plot(x, ‘o’, hold=False)

• Borrar figura completa ― clf()

• Borrar dibujo dentro de los ejes, no ejes en sí ― cla()

• Cambiar intervalos mostrados en los ejes ― xlim(x,y) y ylim(x,y)

• Cambiar el símbolo de la gráfica (una vez pintada) ―

nombre_grafica.set_marker(‘o’) Otra forma de incluir texto
en gráficas es usar el
código LaTeX, un sistema
• Cambiar el color de la gráfica (una vez pintada) ― de escritura muy popular.
nombre_grafica.set_color(‘y’) Introducción a LaTeX:
http://www.ctan.org/tex -
archive/info/lshort/spanish
• Hacer los cambios ― draw()

• Añadir anotación en coordenadas x, y ― text(x, y, ‘texto’)

• Etiquetar los ejes ― xlabel(‘etiqueta_x’), ylabel(‘etiqueta_y’)

• Titular la gráfica ― title(‘titulo_de_grafica’) Asigna las funciones a los

elementos de la leyenda
según el orden en el que
• Añadir una malla ― grid() los hemos puesto

• Añadir una leyenda ― legend((‘Funcion 1’, ‘Función 2’, ‘Funcion 3’),

prop = {‘size’: x}, loc = ‘upper right’) Upper, lower, left, right

• Histograma ― hist(nombre_array) Incluido en el módulo pylab

• Modificar número de bins (barras) del histograma (por defecto son 10) ―
hist(nombre_array, bins=x)
Desde que se escribe figure(n) (antes de
hacer plot(#)) todos los parámetros que Cada bin representa el número de
introduzcamos se aplicaran a esa figura. La valores que “caen” en ese intervalo
primera función es por defecto figure(1)

• Diferenciar figuras independientes (donde n es el número de la figura) ― figure(n)

Cada hist(#) devuelve un array con el número de elementos de cada intervalo, un array con el
punto del eje OX donde empieza cada intervalo y una lista con referencias a cada una de las
barras para modificar sus propiedades
a = nº de filas en los que se dividirá la figura
Escribimos subplot(a, b, c) antes de cada
b = nº de columnas
plot(#), variando, como mínimo, el valor c
c = gráfico con el que estamos trabajando

• Mostrar varios gráficos en una misma figura/ventana ― subplot(a, b, c)

• Cargar datos desde un fichero:

- Leer fichero
- Comprobar su “forma”
- Hacer un plot por cada “grupo” de datos (filas, columnas…) ― p1, =
plot(instancia[:, 0], ‘b.’) (p.e. primera columna, puntos azules)

• Trazar línea horizontal de color c en coordenada y=a ― axhline(a, color=‘c’)

• Trazar línea vertical de color c en coordenada x=b ― axvline(b, color=‘c’)

• Trazar banda horizontal de color c de y=a a y=b con un 30% de transparencia ―

axhspan(a, b, alpha=0.3, color=‘c’)

• Trazar banda vertical de color k de x=a a x=b con un 30% de transparencia ―

axvspan(a, b, alpha=0.3, color=‘k’)

• Barras de error:
- Definimos arrays con los valores de x, y
- Si el error es común a todos los puntos:
▪ Definimos errores fijos ― err_x = a & err_y = b
▪ Pintamos la gráfica, donde m son los parámetros de color y forma de los
puntos de la gráfica ― errorbar(x, y, err_x, err_y, ‘m’)
- Si existen diferentes errores en cada punto:
▪ Definimos un array de errores ― err_x = array([a, b, c]) & err_y =
array([d, e, f])
▪ Pintamos la gráfica, donde m son los parámetros de color y forma de los
puntos de la gráfica ― errorbar(x, y, err_x, err_y, ‘m’)

• Poner ejes en escala logarítmica (m son los parámetros de color y forma de los puntos
de la gráfica):
- Eje x ― p1, = semilogx(x, y, ‘m’)
- Eje y ― p2, = semilogy(x, y ‘m’) Por defecto paleta
- Ambos ejes ― p3, = loglog(x, y, ‘m’) de colores jet()

• Representar array bidimensional: escala de colores ― imshow(nombre_array)

• Añadir paleta para indicar la equivalencia entre los colores y la función ―

colorbar()

• Cambio de la paleta de colores a tonos grises ― gray() Siempre comprobar que se

está en el directorio
• Abrir foto desde directorio ― instancia = correcto (pwd) y si no,
imread(‘nombre_archivo.extensión’) cambiar (cd)
• Tomar un canal RGB ― foto1 = foto[:, :, 0] Todas las
imágenes en
• Variar paleta de colores ― imshow(foto1, cmap=paleta()) color tienen tres
canales RGB

• Ejemplos de paletas ― jet(), gray(), hot(), spectral()

• Guardar una figura ― savefig(‘nombre_del_archivo.extensión’)

Con un solo canal

Extensiones disponibles en Python: png, pdf, ps, eps y svg RGB podemos
variar la paleta de
• Ajuste lineal: pylab para pintar las gráficas
colores
- Introducir arrays de datos
Módulo numpy
- p = polyfit(x, y, n), donde n es el grado del polinomio
- Valores de y calculados del ajuste ― y_ajuste = p[0] * x + p[1]
- Dibujo de los datos experimentales, donde m son los parámetros de color y
forma de los puntos de la gráfica ― p_datos, = plot(x, y, ‘m’)
- Dibujo de la recta de ajuste, donde m son los parámetros de color y forma de
recta ― p_ajuste, = plot(x, y_ajuste, ‘m’)

• Ajuste con información completa (tupla con el array de parámetros, el residuo, el

rango, los valores singulares y la condición relativa) ― resultado = polyfit(x, y,
n, full=True)

• Evaluar polinomio en un x=a (p sigue siendo el ajuste) ― print polyval(p, a)

• Crear una función polinómica de parámetros p ― mi_recta = poly1d(p)

• Evaluar la recta en x=a ― print mi_recta(a)

from scipy.optimize
import leastsq
• Ajuste no lineal:
- Introducir arrays de datos
- Defino una función para calcular los residuos:
def residuos(p, x, y):
pylab para pintar las gráficas
error = y ― (p[0]*x + p[1])
return error
- Parámetros iniciales estimados (datos conocidos) ― p0 = [u, v]
- Ajuste ― leastsq(residuos, p0, args=(datos_y, datos_x))
- El resultado es una lista cuyo primer
elemento es otra lista con los parámetros
del ajuste ― print ajuste[0]

scipy tiene también el módulo Tupla con los argumentos de

curve_fit(#) que funciona la función de residuos (en
este caso, los arrays de datos )
como leastsq(#) para curvas