Introducción a Python

CURSO I: INTRODUCCIÓN A LA PROGRAMACIÓN CON PYTHON



Introducción

Python es un lenguaje de programación interpretativo de alto nivel orientado a objetos. Se considera de alto nivel porque su sintaxis es más próxima al lenguaje natural que al lenguaje de las máquinas. Como lenguaje presenta un propósito general, por tanto, tiene una gran variedad de librerías con múltiples propósitos: científicas como scipy, scikit y numpy, hasta librerías para crear juegos como pygame o pyganim.

Actualmente Python es considerado uno de los lenguajes de programación más importantes a nivel mundial. Su fácil lectura y generación de scripts lo hace una opción viable en el desarrollo investigativo e industrial.



Objetivo General

  • Introducir al estudiante en el lenguaje de programación Python, mediante la exposición y uso de sus elementos básicos.

Objetivos específicos

  • Conocer los elementos básicos de la programación en Python.
  • Usar listas, tuplas y diccionarios como estructuras manipulables de datos.
  • Usar sentencias condicionales como métodos de control de flujo.
  • Diseñar funciones como herramienta de reutilización de código.
  • Crear scripts con aplicaciones sencillas.
  • Escribir código bajo las normas PEP 8 para facilitar la lectura del script.
  • Conocer las librerías básicas de Python.


Contenido

  1. Introducción a la sintaxis de Python
  2. Control de flujo
  3. Estructuras de datos
  4. Funciones
  5. Importación de librerías
  6. Introducción a Numpy
  7. Clases
  8. Iteradores y generadores
  9. Lectura de archivos

Introducción a la sintaxis de Python

Mauricio Villa

Comentarios

Una de las principales características del lenguaje de programación python es la facilidad de lectura. Los comentarios y documentación hacen parte importante de todo código como información a quien use el script. Para caracteres especiales, es decir, los que no pertenecen al alfabeto norteamericano como la tílde y la ñ, se requiere utilizar el formato de codificación de caracteres $UTF-8$. Se acostumbrara entonces a importar este formato en la primera línea del código de Python.

Comentarios en una línea

Toda línea que comience con el símbolo numeral $\#$ Python lo interpretará como un comentario.

In [1]:
# -*- coding: utf-8 -*-

# Estoy aprendiendo a programar con Python.

Comentarios en varias líneas

Para los comentarios que requieren mas de una línea se usan tres comillas al inicio y al final del comentario

In [2]:
""" 
Necesitaba mas de una línea
para escribir todo este carretazo 
en Python
"""
Out[2]:
' \nNecesitaba mas de una l\xc3\xadnea\npara escribir todo este carretazo \nen Python\n'

Imprimir

Se usa print para que Python muestre en pantalla el valor de una variable, texto, etc.

In [3]:
a = 234e-2
print a
2.34
In [4]:
saludo = 'Hola a todos'
print saludo
Hola a todos
In [5]:
print 234253434
234253434
In [6]:
print a, saludo
2.34 Hola a todos

Tipos de datos

Integer

Integer o int es el conjunto de números enteros

In [7]:
num_entero = 234
otro_entero = 1

Float

float es el conjunto de los números reales

In [8]:
num_real = 32.546
otro_num_real = 0.0000432

String

Un string o cadena es todo dato que representa un texto. Este se escribe entre comillas sencillas o dobles y puede contener todo tipo de caracteres en su interior.

In [9]:
# -*- coding: utf-8 -*-

cadena_1 = 'python'
cadena_2 = "python"
cadena_3 = '345'

None

Este tipo de datos representa la inexistencia del valor de una variable. Se usa cuando se requiere crear una variable cuyo valor se desconoce, pero que posteriormente se asignará.

In [10]:
variable_vacia = None

Reconocer el tipo de dato

En python se puede identificar el tipo de dato de una variable con el comando $type$. Se definene primero tres variables con tipos de datos diferentes:

In [11]:
a = 3.3212
b = 'Adios universo'
c = None

Ahora se usa el $type$ para identificar el tipo de dato

In [12]:
type(b)
Out[12]:
str
In [13]:
type(a)
Out[13]:
float
In [14]:
type(c)
Out[14]:
NoneType

Cambiar el tipo de dato de una variable

Los cambios de tipo de dato pueden ser útiles para usar las propiedaes de un dato específico, pero no es posible hacer conversiones entre todos los datos, algunos cambios posibles:

In [15]:
# float a string
a = 3.234
a = str(a)
print a, type(a)

# float a int
b = 3.9345
b = int(b)
print b, type(b)

# int a float
c = 2
c = float(c)
print c, type(c)
3.234 <type 'str'>
3 <type 'int'>
2.0 <type 'float'>

Pero al pasar strings a números hay que tener en cuenta que el string solo debe tener caracteres numéricos, de lo contrario Python arroja un error.

In [16]:
# string a float
a = '235425'
a = float(a)
print a, type(a)
235425.0 <type 'float'>
In [17]:
a = 'ds235425'
a = float(a)
print a, type(a)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-17-96a970e28cc3> in <module>()
      1 a = 'ds235425'
----> 2 a = float(a)
      3 print a, type(a)

ValueError: could not convert string to float: ds235425



Operadores

Mauricio Villa

Operadores y operaciones aritméticas

Suma

In [1]:
2+3
Out[1]:
5

Resta

In [2]:
2-3
Out[2]:
-1

Multiplicación

In [3]:
22*3
Out[3]:
66

Potencia

In [4]:
34**2
Out[4]:
1156

División

In [5]:
6/3
Out[5]:
2

Estas operaciones requieren atención especial por la forma de ejecución de python. Si se realiza una operación, python dará el resultado como el tipo de dato más complejo que esté presente en la operación, es decir, si se realiza una división con números enteros la respuesta será dada en números enteros también, lo que presenta un problema si no se tiene el cuidado necesario, porque el número dado como respuesta no es precisamente un redondeo, sino más bien un truncamiento del número:

In [6]:
2/3
Out[6]:
0
In [7]:
2.0/3
Out[7]:
0.6666666666666666

Orden en las operaciones

Las operaciones aritméticas tienen un orden específico de ejecución y este depende de su prioridad. Cuando estas tengan igual prioridad, la operación se efectuará de izquierda a derecha.

  1. Paréntesis ()
  2. Exponenciación ∗∗
  3. Multiplicación ∗, división /
  4. Suma +, resta –
In [8]:
(32-10)/4 * 2
Out[8]:
10
In [9]:
5.0/2 * 2
Out[9]:
5.0
In [10]:
2 / 4.0 / 10.0**2
Out[10]:
0.005

Operadores booleanos y lógicos

  1. Falso: False
  2. Verdadero: True
  3. Conjunción: and
  4. Disyunción: or
  5. Negación: not

Operadores de comparación

Las comparaciones en Python arrojan como resultado $True$ si son verdaderas o $False$ si son falsas, son muy usadas en estructuras de control de flujo, como los condicionales.

  1. Igualdad: ==
  2. Mayor: >
  3. Menor: <
  4. Mayor igual: >=
  5. Menor igual: <=
  6. Diferente: ! =
In [11]:
3 == 5
Out[11]:
False
In [12]:
num_ojos = 2
num_ojos < 8
Out[12]:
True
In [13]:
'hola' > 'ana'
Out[13]:
True
In [14]:
nombre_usuario = 'Camila'
nombre_asesor = 'Carlos'
nombre_usuario != nombre_asesor
Out[14]:
True

Ejemplos de combinación de operadores de comparación y operadores lógicos:

In [15]:
4 > 5 and 3 < 2
Out[15]:
False
In [16]:
5 > 4 or 3 < 1
Out[16]:
True
In [17]:
not 2 > 100
Out[17]:
True



Entrada y salida de datos

En ocasiones se requiere interacción de Python con el usuario, que ingrese un dato para comenzar un cálculo, aprobación para ejecutar cierta parte del código, etc. Existen varios métodos para intercambiar datos con un algoritmo, y estos pueden ser de dos tipos: de entrada o salida.

Los métodos de entrada son estos que permiten ingresar algún tipo de dato para que el algoritmo interactúe con este y los métodos de salida son los textos informativos que imprime el lenguaje o la generación de archivos. Por el momento se exponen solo el método de salida print

Método print

Al ejecutarse un script en una interfaz de Python, no se puede ver el valor de las variables a menos que le indiquemos al algoritmo que nos lo muestre, a diferencia de ejecutar código en consola, que una vez ingresado este se ejecuta de forma inmediata.

Para indicarle a Python que debe imprimir el valor de una variable o un resultado de una operación se usa print:

In [1]:
a = 12 + 345
print a
357
In [2]:
promedio = 14.5432
print 'El promedio de los datos es:', promedio
El promedio de los datos es: 14.5432

En ocasiones estas sentencias informativas deben contener resultados, generados en el código, en medio de un texto. Una forma sencilla y limpia de hacer esto es usando el método format. Este método nos permite ingresar las variables indicando la posición de estas con un número entero (comenzando desde cero) dentro de llaves:

In [3]:
num_personas = 15
num_hombres = 10
num_mujeres = 5
print 'De las {0} personas {1} son hombres y {2} son mujeres'.format(num_personas, num_hombres, num_mujeres)
De las 15 personas 10 son hombres y 5 son mujeres

Método raw_input

Este método permite ingresar todo tipo de valores al código, pero siempre serán interpretados por Python como string

In [4]:
nombre = raw_input('Ingrese su nombre: ')
print 'Hola', nombre
print type(nombre)
Ingrese su nombre: Mauricio
Hola Mauricio
<type 'str'>
In [5]:
edad = raw_input('Ingrese su edad: ')
print type(edad)
print edad
Ingrese su edad: 27
<type 'str'>
27

Si se requiere realizar operaciones con una variable diferente a un texto esta debe convertirse al valor deseado una vez que ingresa al algoritmo:

In [6]:
edad = raw_input('Ingrese su edad: ')
edad = int(edad)
print type(edad)
print edad
Ingrese su edad: 27
<type 'int'>
27

Método input

Este método permite ingresar todo tipo de variables, pero al ser ingresados pyton intenta convertirlos al tipo de dato mas conveniente, por lo que si se ingresa un texto este debe ingresarse entre comillas, de lo contrario ocasiona un error.

In [7]:
nombre = input('Ingrese su nombre: ')
print 'Hola', nombre
print type(nombre)
Ingrese su nombre: "Mauricio"
Hola Mauricio
<type 'str'>
In [9]:
edad = input('Ingrese su edad: ')
print type(edad)
print edad
Ingrese su edad: 27
<type 'int'>
27

Error al no especificar que se ingresa un string

In [10]:
nombre = input('Ingrese su nombre: ')
print 'Hola', nombre
print type(nombre)
Ingrese su nombre: Mauricio
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-10-e6db1ba0d695> in <module>()
----> 1 nombre = input('Ingrese su nombre: ')
      2 print 'Hola', nombre
      3 print type(nombre)

/usr/local/lib/python2.7/dist-packages/IPython/kernel/zmq/ipkernel.pyc in <lambda>(prompt)
    145             self._sys_eval_input = builtin_mod.input
    146             builtin_mod.raw_input = self.raw_input
--> 147             builtin_mod.input = lambda prompt='': eval(self.raw_input(prompt))
    148         self._save_getpass = getpass.getpass
    149         getpass.getpass = self.getpass

/usr/local/lib/python2.7/dist-packages/IPython/kernel/zmq/ipkernel.pyc in <module>()

NameError: name 'Mauricio' is not defined



PEP 8 ( Guía de estilo para código Python )

La guía de estilo es un conjunto de recomendaciones para escribir en Python de una forma clara y explicita, de acuerdo con la filosofía de este lenguaje.

Algunos de los ejemplos son tomados del documento de dominio público de la documentación de python:
PEP 0008 -- Style Guide for Python Code

Longitud máxima de línea

Cada línea debe contener máximo 79 caracteres

Comentarios

En una línea:

In [14]:
""" Este es un comentario en una linea. """
Out[14]:
' Este es un comentario en una linea. '

En varias líneas

In [15]:
""" Comentario a 
varias líneas.
"""
Out[15]:
' Comentario a \nvarias l\xc3\xadneas.\n'

Nombres de variables

Se nombran con palabras nemotécnicas, que indique el contenido de esta, en minúsculas y si son varias palabras conectadas por guión bajo.

  • lista_edades
  • num_iter

Nombres de constantes

Se usan palabras en mayúscula unidas por guión bajo.

  • NOMBRE_USUARIO
  • CONST_GAS

Espacios

Definición de variables

si:

In [1]:
x = 1
y = 2
long_variable = 3

No:

In [3]:
x             = 1
y             = 2
long_variable = 3

Operaciones matemáticas

Si:

In [9]:
i = 0
contador = 1
x = 4
i = i + 1
contador += 1
x = x*2 - 1
hipot2 = x*x + y*y
c = (2+3) * (2-3)

No:

In [10]:
i=i+1
contador +=1
x = x * 2 - 1
hipot2 = x * x + y * y
c = (2 + 3) * (2 - 3)



Condicionales

Mauricio Villa

Uno de los controladores de flujo en la programación son las sentencias condicionales if, que permiten ejecutar acciones si se cumple o no una condición dada.

if

In [1]:
num_ojos = 2
if num_ojos != 8:
    print 'Esto no es una araña'
Esto no es una araña

En este caso num_ojos != 8 es verdadero, por tanto se ejecuta el código dentro de la sentencia condicional:

In [2]:
if 4 in [3, 5, 4]:
    print 'El número 4 hace parte de la lista'
El número 4 hace parte de la lista

Se utilizan los operadores lógicos para establecer controladores de flujos con mas condiciones:

In [3]:
num_patas = 2
if num_patas > 0 and num_patas != 4:
    print "Con el número de patas {0}, se cumplen las condiciones".format(num_patas)
Con el número de patas 2, se cumplen las condiciones

else

Cuando se requiere realizar una operación en cualquier caso, se cumpla o no la condición se usa el comando else. Este representa la condición contraria a la condición impuesta en el if, por tanto, no es necesario escribir esta de forma explícita. En el siguiente ejemplo la variable num_bin solo puede tomar valores de 1 ó 0, es decir, el algoritmo ejecuta las sentencias contenidas en el else cuando no cumple la condición del if, en este caso, cuando es diferente de 0.

In [4]:
num_bin = 1

if num_bin == 0:
    num_bin += 1
else:
    num_bin -= 1
    
print num_bin
0

elif

En flujos de mayor complejidad donde se requiere filtrar por más que dos condiciones excluyentes, se usa el comando elif para establecer nuevas condiciones. Para usar este comando se debe haber usado previamente if.

Para que se ejecuten las sentencias dentro del else todas las condiciones anteriores deben ser falsas, tanto la condifición del if como las de los elif.

In [5]:
mi_nombre = 'Mauricio'
num_letras = len(mi_nombre)

if num_letras >= 10:
    print 'Su nombre es exageradamente largo'
elif  6 <= num_letras < 10:
    print 'Ni tan largo ni tan corto'
elif 4 <= num_letras < 6:
    print 'Esta como cortico el nombre'
else:
    print '¿Eso es un nombre?'
Ni tan largo ni tan corto

if anidados

Los if anidados no son mas que condicionales dentro de otros condicionales. Se usan generalmente cuando una sola condición no basta para controlar el flujo en el algoritmo. Por ejemplo, se recibe una variable con la que se debe hacer una suma aritmética si esta esta entre 0 y 10, pero esta variable puede ser de dos tipos: un entero (int) o una cadena (str), asi que primero se debe asegurarse que la variable sea un entero y posteriormente que esté en el rango aceptado para realizar la operación.

In [6]:
variable = 13
# Se comprueba que variable es de tipo entero
if isinstance(variable, int):
    if 0 <= variable <= 10:
        print 'la suma es:', variable + 10
    else:
        print "La variable no esta en el rango adecuado"
else:
    print "la variable es una cadena"
La variable no esta en el rango adecuado

Condicionales especiales

No todos los tipos de variables se comparan con los operadores de comparación expuestos, el caso mas corriente es la comparación con los datos tipo None. Para comparar una variable con este tipo de dato en vez de usar == se usa is:

In [7]:
sustancia = None
if sustancia is None:
    print "No se encontró sustancia"
else:
    print "Su sustancia es:", sustancia
No se encontró sustancia

Si se quiere analizar el caso contrario, es decir cuando la sustancia no es None se puede usar el operador not. Que es el equivalente al código que se ejecuta en el else del ejemplo anterior:

In [8]:
sustancia = "Magnesio"
if sustancia is not None:
    print "Su sustancia es:", sustancia
else:
    print "No se encontró sustancia"
Su sustancia es: Magnesio



Contadores y acumuladores

Mauricio Villa

Estas variables son ampliamente usadas en la programación en los bucles, para guardar resultados o llevar la cuenta de cuantas veces se ha repetido un código. Se expone inicialmente su sintaxis y en el módulo de bucles se expone su aplicación.

Contador

Es una variable que aumenta o disminuye en una cantidad constante, este requiere de un valor inicial.

In [1]:
# Valor inicial
cont = 0

# cambio en su valor en 5
cont = cont + 5

Ahora el valor contenido en la variable cont es su valor anterior más 5. Si se requiere una disminución en el valor basta con cambiar la suma por la resta y dar un valor inicial mayor que 0

In [2]:
# Valor inicial
cont = 100

# Cambio en su valor de 2
cont = cont - 5

En python existe otra forma de escribir estos cambios en la variables, un poco mas limpios, puesto que no hay que escribir dos veces la misma variable. Por ejemplo si se tiene una variable llamada tiempo y se quiere aumentar su valor en 4:

In [3]:
# Valor inicial
tiempo = 0

# Expresión larga
tiempo = tiempo + 4

# Expresión corta
tiempo += 4

En caso de ser una disminución en su valor, aplica de igual forma

In [4]:
tiempo -= 4

Acumulador

Es una variable que aumenta o disminuye en una cantidad constante, este requiere de un valor inicial.

In [5]:
# Valor inicial acumulador
acum = 20

# Variable
var = 2

# Acumulador
acum += var

print acum
22

La principal diferencia es que en cualquier momento del código se puede cambiar el valor de var, haciendo asi que acum no aumente de forma constante.

In [6]:
# Valor inicial acumulador
acum = 20

# Variable
var = 2

# Acumulador
acum += var

# Cambio en el valor de la variable
var = 5

acum += var

print acum
27



Bucles

Mauricio Villa

Al escribir algoritmos es muy común encontrarse con sentencias que deben realizar la misma tarea pero con un parámetro diferente cada vez. Para evitar escribir estas sentencias cada vez que se requieran se recurre a los bucles y asi se puede ejecutar el número de veces deseado escribiendo una sola vez la sentencia

En python existen dos tipos de bluces: while y for, en el primero la sentencia se repite hasta que el incumplimiento de una condición y en el segundo se sabe por anticipado cuantos bucles se deben realizar.

while

En este bucle requiere de una condición para ser ejecutado. Se detiene cuando se incumpla la condición. Normalmente se usa un contador dentro de este.

In [1]:
contador = 0
lista = []
while contador <= 10:
    lista.append(contador)
    print lista
    contador += 1
[0]
[0, 1]
[0, 1, 2]
[0, 1, 2, 3]
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 5]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7, 8]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Uno de los errores mas comunes al escribir los bucles es crear bucles infinitos, es decir que la condición siempre se cumple, pro tanto el bucle no se detiene. Si en el anterior bucle se elimina la línea en la que se aumenta el valor de contador, este siempre tendrá un valor de 0 y siempre será menor que 10 y el bucle nunca se dentendrá.

while anidado

Es posible realizar bucles dentro de otros bucles, el externo se ejecutará cada que los internos hayan terminado todas sus repeticiones. Un ejemplo recurrente es el recorrer todos los elementos de una lista de listas.

In [2]:
listas = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Contadores de listas
index_listas = 0

# Con este bucle se recorre cada una de las listas 
while index_listas < len(listas):
    lista = listas[index_listas]
    
    # Contador de elementos
    index_elementos = 0
    
    # Con este bucle se recorre cada uno de los elementos de las listas
    while index_elementos < len(lista):
        
        # Se imprime cada uno de los elementos
        print lista[index_elementos]
        index_elementos += 1
    index_listas +=1
1
2
3
4
5
6
7
8
9

for

Se utiliza este bucle cuando se conoce de antemano el número de veces que se quiere repetir el código.

In [3]:
# Se crea una lista vacía
lista = []

# Bucle desde 0 hasta 4. se realiza esta operación 5 veces
# i toma cada uno de los valores de la lista generada por range(5)
for i in range(5):
    lista.append(i)
    print lista
[0]
[0, 1]
[0, 1, 2]
[0, 1, 2, 3]
[0, 1, 2, 3, 4]

for anidados

Se repetirá el ejemplo realizado con los while anidados, para ver el cambio en el código y que bucle conviene mas en este caso

In [4]:
listas = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Con este bucle se recorre cada una de las listas 
for lista in listas:
    # Con este bucle se recorre cada uno de los elementos de las listas
    for elemento in lista: 
        # Se imprime cada uno de los elementos
        print elemento
1
2
3
4
5
6
7
8
9

Como se ve en el anteriro código la complejidad se disminuye notablemente y la diferencia radica en que con el for no es necesario manejar contadores y que los iteradores (lista y elemento, en este caso) llevan los valores de las variables, mientras que en el while se requiere acceder a las listas con los iteradores para poder tomar estos valores.

Bucles sobre listas

Las iteraciones comunes sobre listas son tomando los valores de los elementos de las listas o por el índice de estos elementos, pero es posible realizar un bucle tomando ambos valores con la sentencia enumerate:

In [5]:
for indice, valor in enumerate(['e', 'a', 't']):
    print 'posición en la lista:', indice
    print 'valor:', valor
    print '\n' # Genera un espacio entre los valores impresos
posición en la lista: 0
valor: e


posición en la lista: 1
valor: a


posición en la lista: 2
valor: t


Continue

Sentencia para ejecutar el bucle con el siguiente valor. Por ejemplo: Se desea realizar una operación solo con los números pares e ignorar el resto.

In [6]:
for i in range(1, 10):
    if i%2 != 0:
        continue
    else:
        print i**2+1
5
17
37
65

Break

Sentencia para detener el bucle. Por ejemplo: se desea buscar un valor en una lista, y luego de encontrar este ya no es necesario continuar ejecutando el código.

In [7]:
buscar = [4, 2, 7, 1, 8, 23]

# Se quiere buscar la posición del número 7

for idx, num in enumerate(buscar):
    if num == 7:
        print 'la posición del número 7 es:', idx
        break
la posición del número 7 es: 2

Listas por extensión

Es una forma de crear listas con poco código y evitando usar funciones como map o filter. Generalmente se crean a partir del bucle for y se pueden añadir condicionales.

In [8]:
# Se crea una lista con el cuadrado de los números del 0 al 5
[x**2 for x in range(5)]
Out[8]:
[0, 1, 4, 9, 16]

Crear listas como resultado de operaciones con otra lista

In [9]:
list_str = ['python', 'math', 'Colombia']

['mi variable-'+x for x in list_str]
Out[9]:
['mi variable-python', 'mi variable-math', 'mi variable-Colombia']



Listas

Mauricio Villa

Una lista es una estructura para almacenar todo tipo de datos. Se escriben separados por comas entre corchetes:

In [1]:
lista = [ 1, 'hola', 3.1243, 3.0/6]

También puede ser creada una lista vacía con la función list()

In [2]:
lista = list()

Los elementos dentro de una lista estan ordenados y es posible referirse a estos por medio de un índice, siendo 0 el primer elemento:

In [3]:
b = ['python', 342, 2.5]
b[0]
Out[3]:
'python'
In [4]:
b[1]
Out[4]:
342

Desde el último elemento hacia el primero con números negativos:

In [5]:
b[-2]
Out[5]:
342
In [6]:
b[-1]
Out[6]:
2.5

Parar referirse a varios elementos se escribe entre los corchetes los índices, separados por dos puntos, del elemento inicial hasta el índice posterior al elemento deseado.

In [7]:
lista = [22, 43, 64, 895, 56, 347, 58]
lista[3:5]
Out[7]:
[895, 56]

Si no se escribe el índice inicial se toma desde el 0

In [8]:
lista[:2]
Out[8]:
[22, 43]
Función range

Otra forma de crear listas en python es con la función range. Se dan los valores inicial y final de la lista y de forma opcional el paso, si este no se especifica el valor por defecto es 1. si solo se indica un valor se toma este como el valor final y 0 como el valor inicial. Debe tenerse encuenta que el valor final no pertenecerá a la lista creada.

In [9]:
# se crea una lista de 0 a 4
range(5)
Out[9]:
[0, 1, 2, 3, 4]
In [10]:
# Se crea una lista desde 3 hasta 20 con paso 2
range(3, 20, 2)
Out[10]:
[3, 5, 7, 9, 11, 13, 15, 17, 19]
In [11]:
# una lista desde -12 hasta 5 con paso 1 
range(-12, 5)
Out[11]:
[-12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4]

Métodos de las listas

Append

Para agregar nuevos elementos a una lista en la última posición

In [12]:
a = [2, 4, 'eso veo']
a.append('hola')
print a
[2, 4, 'eso veo', 'hola']

Es posible agregar una lista como elemento de otra lista

In [13]:
b = [ 4, 'tarea', 456]
b.append([2, 3])
print b
[4, 'tarea', 456, [2, 3]]

Insert

Se agrega un elemento en la lista indicado primero la posición de la lista en que se quiere agregar y luego el elemento. En este ejemplo se agrega el número 3 en la posición 1 de la lista.

In [14]:
a.insert(1, 3)
print a
[2, 3, 4, 'eso veo', 'hola']

Extend

Si se requiere agregar los valores de una lista dentro de otra el método append no servirá, puesto que este agregará la lista como un elemento mas, con el método extend, los elementos de una lista se agregarán al final de la otra:

In [15]:
lista_1 = [4, 2, 3]
lista_2 = [1, 2, 3]
lista_1.extend(lista_2)
print lista_1
[4, 2, 3, 1, 2, 3]

Otra forma de hacer esto es con una suma:

In [16]:
lista_1 = [4, 2, 3]
lista_2 = [1, 2, 3]
lista_1 + lista_2
Out[16]:
[4, 2, 3, 1, 2, 3]

Index

Devuelve la posición en la lista de uno de sus componentes, si este valor no está en la lista, devuelve error.

In [17]:
a = [ 4, 'monty', 'python']
a.index('monty')
Out[17]:
1
In [18]:
a.index(5)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-18-1e3117811f1f> in <module>()
----> 1 a.index(5)

ValueError: 5 is not in list

Sort

El ordenamiento de estos arreglos es muy usado en la elaboración de scripts con aplicaciones en la ciencia. Hay que establecer una diferencia en las prioridades de python respecto a los números y los caracteres del alfabeto:

  1. Números
  2. Letras en mayúscula
  3. Letras en minúscula
In [19]:
lista_num = [ 2, 543, 234, 1 , 54, 4]
lista_num.sort()
print lista_num
[1, 2, 4, 54, 234, 543]
In [20]:
lista_letras = ['monty', 'Python', 'codigo']
lista_letras.sort()
print lista_letras
['Python', 'codigo', 'monty']
In [21]:
lista_alfa_num = [ 32, 'math', 43.21, 'Axear']
lista_alfa_num.sort()
print lista_alfa_num
[32, 43.21, 'Axear', 'math']



Strings

Mauricio Villa

lower

Cambia todas las letras del string en minúscula

In [1]:
texto = '... viejEcita Sin nadita qUE comer Sino carnes, frutas, dulces'
texto.lower()
Out[1]:
'... viejecita sin nadita que comer sino carnes, frutas, dulces'

upper

Cambia todas las letras del string en mayúscula

In [2]:
texto = '... viejEcita Sin nadita qUE comer Sino carnes, frutas, dulces'
texto.upper()
Out[2]:
'... VIEJECITA SIN NADITA QUE COMER SINO CARNES, FRUTAS, DULCES'

count

Cantidad de repeticiones en un string. Como argumento se da el string que se quiere buscar.

In [3]:
texto = 'Nadie, nadie la cuidaba Sino Andrés y Juan y Gil'
texto.count('y')
Out[3]:
2
In [4]:
texto.count('a')
Out[4]:
6

split

Separa en un caracter definido, si este no se especifica se toma por defecto el espacio. EL caracter con el que se separa la palabra será omitido del resultado. Arroja como resultado una lista.

In [5]:
texto = "separar este segmento de texto"
In [6]:
texto.split()
Out[6]:
['separar', 'este', 'segmento', 'de', 'texto']
In [7]:
texto.split('e')
Out[7]:
['s', 'parar ', 'st', ' s', 'gm', 'nto d', ' t', 'xto']
In [8]:
texto.split('este')
Out[8]:
['separar ', ' segmento de texto']

find

Devuelve el índice en donde comienza el string que se quiere encontrar comenzando de izquierda a derecha. Si no encuentra el string devuelve -1.

In [9]:
texto = "El hijo de ruana rin rin renacuajo"
In [10]:
texto.find('hijo')
Out[10]:
3
In [11]:
texto.find('rin')
Out[11]:
17
In [12]:
texto.find('viejecita')
Out[12]:
-1

rfind

Devuelve el índice en donde comienza el string que se quiere encontrar comenzando de derecha a izquierda. Si no encuentra el string devuelve -1.

In [13]:
texto = "El hijo de ruana rin rin renacuajo"
texto.rfind('hijo')
Out[13]:
3
In [14]:
texto.rfind('rin')
Out[14]:
21

index

Devuelve el índice en donde comienza el string que se quiere encontrar comenzando de izquierda a derecha. Si no encuentra el string devuelve error.

In [15]:
texto = "Apetito nunca tuvo Acabando de comer"
texto.index('a')
Out[15]:
12
In [16]:
texto.index('nunca')
Out[16]:
8
In [17]:
texto.index('mantener')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-17-8c9fbe746826> in <module>()
----> 1 texto.index('mantener')

ValueError: substring not found

rindex

Devuelve el índice en donde comienza el string que se quiere encontrar comenzando de derecha a izquierda. Si no encuentra el string devuelve error.

In [18]:
texto = "Y esta pobre viejecita Al morir no dejó más"
texto.rindex('r')
Out[18]:
30
In [19]:
texto.rindex('caimán')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-19-cca83f3df151> in <module>()
----> 1 texto.rindex('caimán')

ValueError: substring not found

replace

Permite reemplazar cualquier string por otro, si este no se encunetra devuelve el string original.

In [20]:
texto = 'Duerma en paz, y Dios permita Que logremos disfrutar'
texto.replace('e', 'a')
Out[20]:
'Duarma an paz, y Dios parmita Qua logramos disfrutar'
In [21]:
texto.replace('Dormir', 'Hola')
Out[21]:
'Duerma en paz, y Dios permita Que logremos disfrutar'

Nótese que el texto no se modifica realmente al aplicar esta función, para esto abría que asignarlo nuevamente a la variable

In [22]:
texto
Out[22]:
'Duerma en paz, y Dios permita Que logremos disfrutar'
In [23]:
texto = texto.replace('e', 'a')
In [24]:
print texto
Duarma an paz, y Dios parmita Qua logramos disfrutar



Tuplas

Las tuplas, al igual que las listas, son arreglos de cualquier tipo de elementos con una posición definida. Estas se escriben entre paréntesis o solo los elementos entre comas:

In [1]:
mi_tupla = (12, 'asdads', [2,3,4])
print type(mi_tupla)
<type 'tuple'>
In [2]:
mi_tupla = 12, 'asdads', [2,3,4]
print type(mi_tupla)
<type 'tuple'>

Se puede crear una tupla vacía solo con los paréntesis o con la sentencia tuple

In [3]:
tupla_vacia = ()
tupla_vacia = tuple()

Una tupla con un solo elemento puede ser creada con el elemento y una coma al final

In [4]:
singleton = 6,
print singleton
(6,)

A diferencia de las listas las tuplas son inmutables, por lo que no tienen los mismos métodos que alteran su contenido. Se puede acceder al contenido de una tupla, pero no cambiarlo.

In [5]:
tupla = (1,3,4,5,6,7)
In [6]:
tupla[1]
Out[6]:
3
In [7]:
tupla[2:]
Out[7]:
(4, 5, 6, 7)
In [8]:
tupla[1] = 12
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-8-9743ea29dc97> in <module>()
----> 1 tupla[1] = 12

TypeError: 'tuple' object does not support item assignment

Convertir una lista a tupla

In [9]:
lista = [4, 3, 5, 4, 3]
tuple(lista)
Out[9]:
(4, 3, 5, 4, 3)

Longitud de una tupla

In [10]:
tupla = (3, 4, 5, 6, 7)
In [11]:
len(tupla)
Out[11]:
5

Concatenar tuplas

In [12]:
tupla + tupla
Out[12]:
(3, 4, 5, 6, 7, 3, 4, 5, 6, 7)
In [13]:
tupla * 4
Out[13]:
(3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7)

Elementos en tuplas

In [14]:
12 in tupla
Out[14]:
False
In [15]:
3 in tupla
Out[15]:
True

Iteraciones sobre tuplas

Se usa la misma sintaxis vista en el módulo de listas

In [16]:
for x in tupla:
    print x
3
4
5
6
7



Diccionarios

Un diccionario es una estructura en la que sus elementos no tienen un orden definido. Cada elemento tiene dos partes: clave y valor. El diccionario se crea entre el símbolo de agrupación llaves {}.

In [1]:
mi_dict = {'nombre': 'Mauricio', 'edad': 27, 'lenguaje': 'Python', 0:'acepto'}

Para acceder a cada uno de los elementos se usan los corchetes [ ] y dentro se escribe la clave (elemento antes de los dos puntos) y el diccionario devuelve el valor (elemento posterior a los dos puntos).

In [2]:
mi_dict['lenguaje']
Out[2]:
'Python'
In [3]:
mi_dict['nombre']
Out[3]:
'Mauricio'

Si se especifica una clave que no está en el diccionario este devuelve el error KeyError

In [4]:
mi_dict['gato']
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-4-4144516b0474> in <module>()
----> 1 mi_dict['gato']

KeyError: 'gato'

Un diccionario vacío se puede crear solo con el símbolo llaves o con la sentencia dict

In [5]:
dict_vacio = {}
dict_vacio = dict()

También se pueden crear con la sentencia dict agregando cada clave y valor como argumento. la clave debe ser una variable, esta será convertida a string en el diccionario.

In [6]:
otro_dict = dict(sape=4139, guido='4127', jack=4098)
print otro_dict
{'sape': 4139, 'jack': 4098, 'guido': '4127'}

Diccionarios a partir de tuplas

Se debe crear una tupla que contenga tuplas con la clave y el valor deseado en el diccionario:

In [7]:
mi_tupla = (('nombre', 'Mauricio'), ('edad', 27), ('lenguaje', 'Python'), (0, 'acepto'))
mi_dict = dict(mi_tupla)
print mi_dict
{'edad': 27, 'nombre': 'Mauricio', 'lenguaje': 'Python', 0: 'acepto'}

La misma operación se puede realizar si es una lista de tuplas

In [8]:
mi_tupla = [('nombre', 'Mauricio'), ('edad', 27), ('lenguaje', 'Python'), (0, 'acepto')]
mi_dict = dict(mi_tupla)
print mi_dict
{'edad': 27, 'nombre': 'Mauricio', 'lenguaje': 'Python', 0: 'acepto'}

Diccionarios por comprension

In [9]:
{x: x+2 for x in range(4)}
Out[9]:
{0: 2, 1: 3, 2: 4, 3: 5}

Claves de los diccionarios

In [10]:
mi_dict = {'nombre': 'Mauricio', 'edad': 27, 'lenguaje': 'Python', 0:'acepto'}
mi_dict.keys()
Out[10]:
['edad', 'nombre', 'lenguaje', 0]

Valores de los diccionarios

In [11]:
mi_dict = {'nombre': 'Mauricio', 'edad': 27, 'lenguaje': 'Python', 0:'acepto'}
mi_dict.values()
Out[11]:
[27, 'Mauricio', 'Python', 'acepto']

Iteración sobre diccionarios

In [12]:
mi_dict = {'nombre': 'Mauricio', 'edad': 27, 'lenguaje': 'Python', 0:'acepto'}

Iteración sobre las claves

In [13]:
for key in mi_dict:
    print key
edad
nombre
lenguaje
0

Iteración sobre los valores

In [14]:
for key in mi_dict.values():
    print key
27
Mauricio
Python
acepto

Iteración sobre claves y valores

In [15]:
for key, value in mi_dict.iteritems():
    print key, value
edad 27
nombre Mauricio
lenguaje Python
0 acepto



Funciones

Mauricio Villa

Las funciones son recursos usados en todos los lenguajes de programación, estas contienen algoritmos que solo se ejecutan cuando la función es invocada. Al igual que los ciclos es útil para evitar la repetición de código.

Sintaxis

En Python las funciones se escriben con el comando def, el nombre de la función y se finaliza con dos puntos:

In [1]:
def mi_funcion():
    # Código que se ejecuta al invocar la función
    pass

La sentencia pass le indica a Python que al ejecutar el código continue su flujo normalmente. En la anterior función fue útil, puesto que al no contener ninguna instrucción esto generaría un error de sintaxis.

Para invocar la función basta con escribir su nombre:

In [2]:
mi_funcion()

Existen dos tipos de funciones en cuanto a su ejecución: La primera realiza cierto procedimiento y muestra su resultado al terminar y la segunda devuelve un valor, que debe ser asignado a otra variable.

Caso I

Función que solo muestra el resultado en pantalla

In [3]:
def saludo_print():
    print 'Hola'
In [4]:
saludo_print()
Hola

Caso II

Función que devuelve el resultado

In [5]:
def saludo_return():
    return 'Hola'
In [6]:
resultado = saludo_return()
resultado
Out[6]:
'Hola'

Parámetros de las funciones

Parámetros obligatorios

Son las variables que recibe una función para realizar un operación determinada. No todas las funciones requieren parámetros, pero si al crear la función se especifica que necesita una variable para ejecutarse es obligatorio ingresar un valor para ésta. Los parámetros se indican entre los paréntesis al crear la función:

In [7]:
def saludo(nombre):
    print '¡Hola {0}!'.format(nombre)
In [8]:
saludo('Mauricio')
¡Hola Mauricio!
In [9]:
def nombre(nombre, apellido):
    print 'Su nombre es:', nombre, apellido
In [10]:
nombre('Mauricio', 'Villa')
Su nombre es: Mauricio Villa

Parámetros opcionales

Las funciones pueden recibir cuantos parámetros se necesiten y algunos se les puede definir un valor por defecto, a éstos se les llaman parámetros opcionales y siempre se definen después de los parámetros obligatorios.

In [11]:
def nombre(nombre, apellido='Villa'):
    print 'Su nombre es:', nombre, apellido

Si no se especifica un valor para el parámetro opcional, la función asigna el valor por defecto al parámetro, que en este caso para apellido es Villa

In [12]:
nombre('Carlos')
Su nombre es: Carlos Villa

Si el valor por defecto no es el requerido se puede especificar el nuevo valor al parámetro

In [13]:
nombre('Carlos', apellido='Calle')
Su nombre es: Carlos Calle

Es posible no decir esplicitamente el nombre del parámetro al que se le esta cambiando el valor, pero para esto se deben escribir los nuevos valores en el mismo orden en que fueron definidos al crear la función. No se recomienda usar de esta forma, pues es fácil cambiar el orden y generar errores.

In [14]:
nombre('Carlos', 'Calle')
Su nombre es: Carlos Calle

Funciones lambda

Son funciones que no requieren mucho código, se escriben en una sola línea y no necesitan un nombre. Éstas se escriben con la sentencia lambda, seguida de los parámetros de la función y luego la operación que realiza. Las funciones lambda retornan siempre el resultado de dicha operación.

In [15]:
lambda y: y**2
Out[15]:
<function __main__.<lambda>>

Estas pueden ser usadas como argumento de otras funciones e incluso asignadas a una variable

Elevar un número al cuadrado:

In [16]:
exp_dos = lambda x: x**2
exp_dos(9)
Out[16]:
81

Por ejemplo, se usa una función lambda para filtrar los valores de una lista que no son multiplos de 2. Para esto se usa también la sentencia filter:

In [17]:
lista = [23, 245, 12, 45, 123, 456, 234, 547]
print filter(lambda x: x % 2 == 0, lista)
[12, 456, 234]

Funciones recursivas

Son funciones que se llaman asi mismas, porque su resultado depende de evaluaciones de la misma función. Los ejemplos típicos son generar la serie fibonacci y la operación factorial.

In [18]:
def fib(num):
    if num < 2:
        return num
    return fib(num-2) + fib(num-1)
In [19]:
fib(2)
Out[19]:
1
In [20]:
for i in range(10):
    print fib(i)
0
1
1
2
3
5
8
13
21
34
In [21]:
def factorial(num):
    if num < 2:
        return 1
    return num * factorial(num-1)
In [22]:
factorial(18)
Out[22]:
6402373705728000



Uso de *args y **kwargs

La principal diferencia entre *args y **kwargs es que la primera representa una tupla con los elementos en el orden de entrada establecido por la función y **kwargs es un diccionario en dónde las claves tienen igual nombre a los argumentos de la función.

Los nombres args y kwargs son solo convención, estos se pueden renombrar como se desee.

Como entrada de argumentos a una función preestablecida

Se define una función sencilla cuyo objetivo es restar dos números. La función resta toma como argumentos de entrada la variable a y la variable b y devuelve el valor de a-b

In [1]:
def resta(a, b):
    return a-b

resta(2, 3)
Out[1]:
-1

Se puede definir ahora los argumentos de entrada como una tupla o una lista, teniendo en cuenta que importa el orden de estos. El primer valor de args corresponde al valor del primer argumento de la función. Con éste método no importa que nombre tengan los argumentos de la función.

In [2]:
# Tupla como argumento de entrada a la función resta
args = 2, 3
resta(*args)
Out[2]:
-1
In [3]:
# Cambiando los valores de los argumentos
args = 3, 2 
resta(*args)
Out[3]:
1
In [4]:
# Lista como argumento de entrada a la función resta
args = [3, 2] 
resta(*args)
Out[4]:
1

Ahora se definen los argumentos de entrada de la función como un diccionario, en este caso no importa el orden en que se ingresen a este, pero las claves de éste deben tener el mismo nombre que los argumentos de la función.

In [5]:
kwargs = {'b':3, 'a':2}
resta(**kwargs)

# Esto es equivalente a ejecutar resta(2, 3)
Out[5]:
-1

Para definir los argumentos de una función

Una función definida solo con el argumento *args puede tener cualquier número de argumentos de entrada, incluso ninguno. Dentro de la función se reciben los argumentos como componentes de una tupla.

In [6]:
def pack_area(*args):
    print args

pack_area(2,3)
pack_area()
(2, 3)
()

Por ejemplo, se crea una función que suma todos los argumentos, independiente de su valor y de la cantidad de estos

In [7]:
def suma(*args):
    # Se convierte la tupla en lista
    data = list(args)
    return sum(data)
In [8]:
suma(1,14,5,6)
Out[8]:
26
In [9]:
suma()
Out[9]:
0

Una función con solo el argumento **kwargs puede recibir cualquier cantidad de argumentos de entrada, la diferencia con args es que este requiere un nombre para cada argumento que se ingrese a la función. Dentro de la función se reciben todos los argumentos como elementos de un diccionario.

In [10]:
def pack_area(**kwargs):
    print kwargs

pack_area(r=2, t=4)
pack_area()
{'r': 2, 't': 4}
{}

Se crea una función que muestra datos personales

In [11]:
def datos_personales(**kwargs):
    for nombre, valor in kwargs.iteritems():
        print '{0}: {1}'.format(nombre, valor)
In [12]:
datos_personales(nombre='Andrés', edad=27)
edad: 27
nombre: Andrés

En caso de que se requieran muchos argumentos de entrada se recomienta crear un diccionario

In [13]:
kwargs = {'Nombre': 'Andrés', 'Edad':27, 'Estado civil': 'Soltero'}
datos_personales(**kwargs)
Edad: 27
Nombre: Andrés
Estado civil: Soltero

Es posible usar tanto *args como **kwargs en una misma función:

In [14]:
def pack_area(*args, **kwargs):
    print args
    print kwargs

pack_area(2, 4, 5, c=3, d=4)
(2, 4, 5)
{'c': 3, 'd': 4}



Librerías en Python

Existen infinidad de librerías para Python y cada vez hay mayor oferta, porque muchos de los usuarios crean sus propios módulos y publica sus trabajos. Estos son fácilmente accesibles desde repositorios como GitHub o usando el gestor de paquetes pip.

Entre las librerías destacables en python se encuentran: math, numpy, matplotlib, scipy, logging, os, etc. Algunas de estas están incluídas en el paquete base de Python y otras hay que descargarlas de forma independiente. Para profundizar en el tema de instalacion de libererías se puede acceder a la documentación de *pip*

Importación de librerías en Python

Existen varias formas de comunicarse con librerías y todo depende de si se quiere acceder a toda la librería o a módulos especificos de esta.

Toda la librería

In [5]:
import numpy
In [6]:
from numpy import *

Solo un módulo de la librería

In [7]:
from numpy import exp
In [9]:
exp(1)
Out[9]:
2.7182818284590451
In [10]:
from datetime import datetime
In [11]:
import matplotlib.pyplot

Algunos nombres de las librerías son muy largos, lo que hace que al momento de usarlas se ofusque un poco el código, como al importar el módulo pyplot de la librería matplotlib, para esto se pueden crear nombres para su uso dentro del script

In [13]:
import matplotlib.pyplot as plt

Ahora al usar la el módulo no se requiere escribir matplotlib.pyplot sino plt. Otros ejemplos:

In [14]:
import numpy as np
import logging as lg
import matplotlib as mpl

Librería math

Incluído desde la instalación de Python, es una librería que provee las funciones matemáticas estándar, tales como el valor absoluto, funciones trigonométricas, raices, redondeo, exponencial, logaritmos, etc. Documentación de math: https://docs.python.org/2/library/math.html

Importación de math

In [15]:
import math

Algunas funciones

Logarítmo natural

In [16]:
math.log(3)
Out[16]:
1.0986122886681098

Logarítmo en base 10

In [17]:
math.log10(3)
Out[17]:
0.47712125471966244

Raíz cuadrada

In [18]:
math.sqrt(3)
Out[18]:
1.7320508075688772

Constantes

In [19]:
math.e
Out[19]:
2.718281828459045
In [20]:
math.pi
Out[20]:
3.141592653589793

Librería Random

Permite generar número aleatorios en diferentes distribuciones como uniforme, normal, lognormal, gamma, etc.

In [21]:
import random

Número entero aleatorio en una distribución uniforme entre dos valores dados:

In [23]:
random.randint(20, 50)
Out[23]:
33

Aplicando bucles y la formación de listas por compresión, es posible crear una lista de 10 números enteros aleatorios entre 20 y 50

In [25]:
[random.randint(20, 50) for i in range(10)]
Out[25]:
[25, 20, 33, 36, 24, 39, 41, 40, 46, 39]

Números aleatorios entre 0 y 1 con una distribución uniforme

In [26]:
[random.random() for i in range(10)]
Out[26]:
[0.49335198767574384,
 0.7293734723995742,
 0.7627677417643117,
 0.5506454691133145,
 0.8809840188332397,
 0.5452858510209823,
 0.9883915355581456,
 0.6049860750297263,
 0.674576151073103,
 0.21446218481426815]

Números aleatorios con una distribución normal, dada la media y la desviación

In [27]:
media = 0
desv = 1
[random.gauss(media, desv) for i in range(10)]
Out[27]:
[-0.5095035078240844,
 -1.754948428814209,
 -0.44077207459960144,
 -1.0681015582799502,
 -0.24813046168867875,
 0.4176189341232568,
 -0.3427972698563807,
 0.5540192185504451,
 0.7128032430478768,
 -0.23319731161966856]



Numpy

Paquete de computación científica para python escrito en lenguaje de programación C/C++ y fortran. Puede ser usado como un contenedor multidimensional de datos y para esto crea otras posibilidades de tipo de datos como los objetos numpy array. Generalmente se usa una reducción en el nombre de la librería en la importación:

In [1]:
import numpy as np

Numpy también realiza operaciones con exponenciales, radicación y tienen los valores de algunas constantes matemáticas:

Algunas constantes

In [2]:
np.exp(1)
Out[2]:
2.7182818284590451
In [3]:
np.pi
Out[3]:
3.141592653589793

Logaritmo natural

In [4]:
np.log(2)
Out[4]:
0.69314718055994529

Logaritmo en base 10

In [5]:
np.log10(2)
Out[5]:
0.3010299956639812

Raiz cuadrada

In [6]:
np.sqrt(4.32)
Out[6]:
2.078460969082653

Numpy array

Es una colección de elementos del mismo tipo

Array de una dimensión

In [7]:
mi_array = np.array([2, 3, 4, 5])
mi_array
Out[7]:
array([2, 3, 4, 5])

También se puede construir un array en un rango de números con una cantidad determinada:

In [8]:
x = np.linspace(0,10,11)
x
Out[8]:
array([  0.,   1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.])

Linspace crea un array con la siguiente sintaxis:
linspace(num incial, num final, num componentes del array).

Obtener datos de un array

Al igual que las listas o las tuplas se usan los corchetes [ ] y la posición en su interior para obtener un elemento del array

In [35]:
mi_array = np.array([2, 3, 4, 5])
mi_array[2]
Out[35]:
4

Array de dos dimensiones

Estos array estan compuestos por otros array de cualquier dimensión

In [36]:
mi_array = np.array([[1, 2], [2, 3]])
mi_array
Out[36]:
array([[1, 2],
       [2, 3]])

Se puede generar un array de dos dimensiones con números aleatorios a partir de una distribución uniforme:
Se indica como argumento deel método random.rand() la cantidad de elementos del array principal (exterior) y el segundo número indica el número de elementos que contendrán los array interiores

In [33]:
# Se genera un array con 5 arrays en su interior cada uno con 3 elementos
np.random.rand(5, 3)
Out[33]:
array([[ 0.36371268,  0.16911992,  0.21269402],
       [ 0.38154437,  0.93675278,  0.53834116],
       [ 0.06430003,  0.01977875,  0.60671112],
       [ 0.66269208,  0.63796042,  0.50528926],
       [ 0.79394094,  0.64100999,  0.09660829]])

Obtener datos de un array de dos dimensiones

La sintaxis es igual, pero ahora se deben especificar dos índices: la posición de la lista en el interior del array y la posición del dato en la lista interior

In [38]:
mi_array = np.array([[1, 2], [12, 3]])

Si se quiere obtener el número 12 se debe indicar la segunda lista interna, es decir, el índice 1. Luego, la posición de 12 en esta es 0, porque es el primer dato del array

In [41]:
# Se obtiene el primer dato (0) de la segunda lista (1)
mi_array[1][0]
Out[41]:
12

O una sintaxis resumida:

In [40]:
mi_array[1, 0]
Out[40]:
12

Operaciones con numpy array

In [10]:
a = np.array([2, 3, 4, 5])
b = np.array([[1, 2], [5, 3]])

Suma

In [12]:
a+2
Out[12]:
array([4, 5, 6, 7])
In [13]:
a+a
Out[13]:
array([ 4,  6,  8, 10])

Resta

In [14]:
a-2
Out[14]:
array([0, 1, 2, 3])
In [15]:
a-a
Out[15]:
array([0, 0, 0, 0])

Multiplicación

In [16]:
7*a
Out[16]:
array([14, 21, 28, 35])
In [48]:
a * (a*2)
Out[48]:
array([ 8, 18, 32, 50])
In [42]:
b*b
Out[42]:
matrix([[11,  8],
        [20, 19]])

División

In [19]:
a/2.0
Out[19]:
array([ 1. ,  1.5,  2. ,  2.5])
In [20]:
a/(5.0*a)
Out[20]:
array([ 0.2,  0.2,  0.2,  0.2])

Operaciones de matrices con numpy arrays

In [21]:
a = np.array([2, 3, 4, 5])
b = np.array([[1, 2], [5, 3]])

Multiplicación matricial

In [22]:
np.dot(b, b)
Out[22]:
array([[11,  8],
       [20, 19]])

Traspuesta

In [23]:
b.transpose()
Out[23]:
array([[1, 5],
       [2, 3]])

Inversa

In [57]:
np.linalg.inv(b)
Out[57]:
matrix([[-0.42857143,  0.28571429],
        [ 0.71428571, -0.14285714]])

Métodos de numpy array

Las operaciones de matrices con numpy array hechas en el ítem anterior son algunos de los métodos de los numpy array, se muestran algunos de relevancia y el resto puede ser consultado en la documentación oficial de numpy: numpy methods

In [69]:
my_array = np.random.rand(1,10)
my_array
Out[69]:
array([[ 0.56604311,  0.55585422,  0.71337118,  0.11939723,  0.60129414,
         0.41650893,  0.92686655,  0.15911952,  0.08943104,  0.34126916]])
In [70]:
# Máximo
my_array.max()
Out[70]:
0.92686655295751907
In [71]:
# Mínimo
my_array.min()
Out[71]:
0.089431035991810903
In [72]:
# Media
my_array.mean()
Out[72]:
0.44891550803024882
In [76]:
# desviación
my_array.std()
Out[76]:
0.2609940682795075
In [79]:
# Índices de los elementos diferentes de cero
otro_array = np.array([0, 2, 0, 34, 23, 0, 2])
otro_array.nonzero()
Out[79]:
(array([1, 3, 4, 6], dtype=int64),)
In [84]:
# Se cambia la distribución de los datos en el array
otro_array = np.array([[0, 2, 4], [0, 34, 23], [1, 23, 0]])
otro_array.reshape(1, 9)
Out[84]:
array([[ 0,  2,  4,  0, 34, 23,  1, 23,  0]])
In [85]:
otro_array.reshape(9, 1)
Out[85]:
array([[ 0],
       [ 2],
       [ 4],
       [ 0],
       [34],
       [23],
       [ 1],
       [23],
       [ 0]])
In [75]:
# Ordenamiento del array
my_array.sort()
my_array
Out[75]:
array([[ 0.08943104,  0.11939723,  0.15911952,  0.34126916,  0.41650893,
         0.55585422,  0.56604311,  0.60129414,  0.71337118,  0.92686655]])

Numpy matrix

Numpy matrix es un tipo de dato diferente a los numpy arrays, este obedece a la definición de una matriz, por tanto las operaciones son las definidas para este arreglo

Operaciones de matrices con numpy matrix

In [55]:
b = np.matrix([[1, 2], [5, 3]])
c = np.matrix([[1], [2]])
print b, '\n'
print c
[[1 2]
 [5 3]] 

[[1]
 [2]]

Multiplicación

In [49]:
b*b
Out[49]:
matrix([[11,  8],
        [20, 19]])
In [51]:
b*c
Out[51]:
matrix([[ 5],
        [11]])

Traspuesta

In [27]:
b.T
Out[27]:
matrix([[1, 5],
        [2, 3]])

Inversa

In [28]:
b.I
Out[28]:
matrix([[-0.42857143,  0.28571429],
        [ 0.71428571, -0.14285714]])

Solución de sistema de ecuaciones lineales con matrices

Solucionar el sistema de ecuaciones:

$x+2y=1$
$5x+3y=2$

In [29]:
import numpy as np
from numpy import linalg

b = np.matrix([[1, 2], [5, 3]])
c = np.matrix([[1], [2]])

np.linalg.solve(b, c)
Out[29]:
matrix([[ 0.14285714],
        [ 0.42857143]])

Filtros sobre arrays

A veces se requiere efectuar operaciones sobre algunos de los datos contenidos en un array o simplemente seleccionar los que cumplan determinadas condiciones. Es posible ejecutar comparaciones con cada uno de los valores contenidos en un array de la siguiente forma:

In [1]:
import numpy as np
In [8]:
my_array = np.random.randint(1, 6, 20)
my_array
Out[8]:
array([5, 2, 4, 4, 2, 1, 3, 1, 5, 3, 2, 5, 4, 4, 1, 2, 1, 3, 4, 5])

Se seleccionan los datos menores que 3

In [9]:
my_array[my_array < 3]
Out[9]:
array([2, 2, 1, 1, 2, 1, 2, 1])

La comparación devuelve un array de booleanos, con True si cumple la condición y False en caso contrario

In [23]:
my_array < 3
Out[23]:
array([False,  True, False, False,  True,  True, False,  True, False,
       False,  True, False, False, False,  True,  True,  True, False,
       False, False], dtype=bool)

El resto de la expresión my_array[ ] toma los valores solo de las posiciones donde el array de booleanos sea True.

Se puede efectuar todo tipo de comparaciones: igualdad, diferente, mayor, mayor igual, menor, menor igual.

In [13]:
# Valores iguales a 3
my_array[my_array == 3]
Out[13]:
array([3, 3, 3])
In [14]:
# Valores diferentes de 3
my_array[my_array != 3]
Out[14]:
array([5, 2, 4, 4, 2, 1, 1, 5, 2, 5, 4, 4, 1, 2, 1, 4, 5])
In [19]:
# Valoers mayores iguales a 3
my_array[my_array >= 3]
Out[19]:
array([5, 4, 4, 3, 5, 3, 5, 4, 4, 3, 4, 5])

Para filtrar el array con varias condiciones se debe especificar cada condición dentro de paréntesis e indicarse un operador lógico: y ( & ), o ( | )

In [18]:
# Los números deben ser menores iguales a 2 o mayores que 3
my_array[(my_array <= 2) | (my_array > 3)]
Out[18]:
array([5, 2, 4, 4, 2, 1, 1, 5, 2, 5, 4, 4, 1, 2, 1, 4, 5])
In [22]:
# Los números deben ser mayores iguales a 2 y menores que 4
my_array[(my_array >= 2) & (my_array < 4)]
Out[22]:
array([2, 2, 3, 3, 2, 2, 3])

Posición de los datos

Los filtros anteriores devuelven los datos en un nuevo array solo con los datos que cumplen la condición, por lo que su posición dentro de este es diferente a la posición original. Si se quiere obtener la posición de estos elementos en el array original, se debe usar la función np.argwhere()

In [29]:
my_array = np.random.randint(10, 25, 50)
my_array
Out[29]:
array([16, 24, 10, 20, 14, 12, 12, 22, 22, 23, 11, 17, 14, 21, 14, 12, 15,
       20, 15, 18, 24, 10, 16, 22, 12, 18, 16, 14, 11, 11, 23, 20, 14, 24,
       14, 20, 22, 22, 18, 22, 23, 10, 24, 15, 11, 16, 19, 15, 14, 19])

Condición: Se requiere la posición de los datos que entre 16 y 22.

In [30]:
# Datos que cumplen la condición
my_array[(my_array >= 16) & (my_array<=22)]
Out[30]:
array([16, 20, 22, 22, 17, 21, 20, 18, 16, 22, 18, 16, 20, 20, 22, 22, 18,
       22, 16, 19, 19])
In [31]:
# Posición de los datos en el array original
np.argwhere((my_array >= 16) & (my_array<=22))
Out[31]:
array([[ 0],
       [ 3],
       [ 7],
       [ 8],
       [11],
       [13],
       [17],
       [19],
       [22],
       [23],
       [25],
       [26],
       [31],
       [35],
       [36],
       [37],
       [38],
       [39],
       [45],
       [46],
       [49]], dtype=int64)

Se ejecuta la misma condición sobre un array de dos dimensiones

In [37]:
my_array = np.random.randint(10, 25, 50).reshape(10, 5)
my_array
Out[37]:
array([[10, 22, 20, 12, 17],
       [16, 11, 16, 13, 13],
       [12, 22, 11, 14, 22],
       [24, 16, 14, 17, 11],
       [24, 17, 11, 19, 17],
       [24, 14, 24, 19, 18],
       [20, 16, 22, 20, 15],
       [10, 24, 18, 12, 10],
       [22, 20, 12, 21, 19],
       [13, 19, 10, 12, 24]])
In [40]:
# Datos que cumplen la condición
my_array[(my_array >= 16) & (my_array<=22)]
Out[40]:
array([22, 20, 17, 16, 16, 22, 22, 16, 17, 17, 19, 17, 19, 18, 20, 16, 22,
       20, 18, 22, 20, 21, 19, 19])

Nótese que el resultado de la función argwhere ahora requiere dos índices para dar la posición del número en el array original, mientras que el filtro anterior siempre devuelve un array de una dimensión.

In [39]:
# Posición de los datos en el array original
np.argwhere((my_array >= 16) & (my_array<=22))
Out[39]:
array([[0, 1],
       [0, 2],
       [0, 4],
       [1, 0],
       [1, 2],
       [2, 1],
       [2, 4],
       [3, 1],
       [3, 3],
       [4, 1],
       [4, 3],
       [4, 4],
       [5, 3],
       [5, 4],
       [6, 0],
       [6, 1],
       [6, 2],
       [6, 3],
       [7, 2],
       [8, 0],
       [8, 1],
       [8, 3],
       [8, 4],
       [9, 1]], dtype=int64)

Filtrar datos np.nan

np.nan es la versión del None de Python en numpy. Este tipo de dato a diferencia del None tiene definidas las operaciones aritméticas por lo que no interfiere en operaciones que se realicen con los array, pero estos cuentan como un dato dentro de los array. Para excluir o detectar su posición en el array es necesario usar una comparación, pero este tipo de dato al igual que el None se compara con is:

In [49]:
3 is None
Out[49]:
False
In [50]:
np.nan is None
Out[50]:
False
In [64]:
np.nan is np.nan
Out[64]:
True

Pero esta comparación dentro de un filtro no devuelve lo esperado

In [62]:
my_array = np.array([np.nan, 3, 2 ,6 ,4, np.nan, np.nan, 5, 3, 2])
my_array
Out[62]:
array([ nan,   3.,   2.,   6.,   4.,  nan,  nan,   5.,   3.,   2.])
In [65]:
my_array[my_array is np.nan]
Out[65]:
nan

Para detectar entonces este tipo de datos se usa la función np.isnan

In [66]:
my_array[np.isnan(my_array)]
Out[66]:
array([ nan,  nan,  nan])

Se usa la negación ( ~ ) para encontrar los valores diferentes de np.nan

In [67]:
my_array[~np.isnan(my_array)]
Out[67]:
array([ 3.,  2.,  6.,  4.,  5.,  3.,  2.])
In [71]:
# Posición de los nan en el array original
np.argwhere(np.isnan(my_array))
Out[71]:
array([[0],
       [5],
       [6]], dtype=int64)

Operaciones sobre valores específicos de un array

Usando los métodos para filtrar array anteriores es posible aplicar todo tipo de operaciones sobre datos específicos del array y dejar el resto de los datos intactos

In [82]:
my_array = np.array([2,4,1,5,3,4,2,5,4,3])

Se multiplica por 3 solo a los datos menores e iguales que 2

In [83]:
my_array[my_array <= 2] *= 5
my_array
Out[83]:
array([10,  4,  5,  5,  3,  4, 10,  5,  4,  3])

La operación $x*=y$ es equivalente a la operación $x = x\times y$ y se aplica igual lógica para cualquier operación de ese tipo: -=, **=, +=, etc.




Clases

Es una representación abstracta de un objeto. Esta puede estar formada por atributos y métodos.

Inicialmente se crea una clase solo con atributos para crear una idea general sobre las clases. Se crea entonces una representación abstracta de un carro solo con atributos. Para crear una clase se usa la sentencia class y se nombra con mayúscula inicial.

In [9]:
class Carro():
    color = 'Negro'
    marca = 'Renoult'

Instancia de una clase

Al igual que las funciones una clase solo se ejecuta cuando es instanciada. Esta se asigna a una variable y esta variable se convierte en un objeto con los atributos de la clase.

In [10]:
mi_carro = Carro()
print type(mi_carro)
<type 'instance'>

Atributos de la clase

Para acceder a los atributos del objeto se escribe variable.atributo

In [4]:
mi_carro.color
Out[4]:
'Negro'
In [20]:
mi_carro.marca
Out[20]:
'Renoult'

Modificar atributos de la clase

El valor de los atributos se puede cambiar en un objeto ya creado, pero cada que se cree una nueva instancia tendrá los valores que se asignaron al definir la clase:

In [6]:
# Cambio del valor del atributo color
mi_carro.color = 'azul'
In [7]:
mi_carro.color
Out[7]:
'azul'
In [11]:
# Al crear una nueva instancia se mantiene el valor del atributo que se asigno en la clase
otro_carro = Carro()
otro_carro.color
Out[11]:
'Negro'

Métodos de la clase

Los métodos crean la funcionalidad de las clases. Estos no son mas que funciones definidas al interior de la clase y pueden modificar los valores de los atributos. Ahora los atributos de la clase se crean dentro de una función llamada _init_, que se ejecuta una vez la clase es instanciada.

In [12]:
class Carro():
    
    def __init__(self):
        self.color = 'negro'
        self.marca = 'renoult'
        self.encendido = False
    
    def encender(self):
        self.encendido = True
        
    def apagar(self):
        self.encendido = False

Ahora la clase contiene tres atributos: Color, marca y encendido y dos métodos: encender y apagar.

Se instancia la clase creando el objeto en la variable carro

In [13]:
carro = Carro()

Se impriment los valores de los atributos

In [14]:
print carro.color
print carro.marca
print carro.encendido
negro
renoult
False

Uso de los métodos

De igual forma que se accede a los atributos de la clase se puede acceder a los métodos, con la diferencia de que estos terminan en ( )

In [15]:
# Encender el carro
carro.encender()
In [16]:
carro.encendido
Out[16]:
True
In [18]:
# Apagar el carro
carro.apagar()
In [19]:
carro.encendido
Out[19]:
False

Atributos como argumentos de entrada al crear la clase

Es posible crear la clase definiendo que argumentos tiene el objeto pero no los valores y estos pueden ser dados al momento de instanciar la clase, de igual forma que se agregan los argumentos a las funciones, incluso se puede usar el formato *args y **kwargs.

In [21]:
class Carro():
    
    def __init__(self, color, marca, encendido=False):
        self.color = color
        self.marca = marca
        self.encendido = encendido
    
    def encender(self):
        self.encendido = True
        
    def apagar(self):
        self.encendido = False
In [23]:
carro = Carro('azul', 'Mazda')
In [24]:
print carro.color
print carro.marca
print carro.encendido
azul
Mazda
False



Iteradores

Los iteradores son objetos que contienen el método next. Este método devuelve el valor siguiente de una secuencia y en caso de que la secuencia haya terminado devuelve el error StopIteration

Los iteradores pueden ser creados a partir de listas, strings y cualquier objeto iterable, es decir, que se pueda mover a través de sus elementos

In [1]:
iterador = iter([4,5,6])
In [2]:
iterador.next()
Out[2]:
4
In [3]:
iterador.next()
Out[3]:
5
In [4]:
iterador.next()
Out[4]:
6
In [5]:
iterador.next()
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-5-b07df6ddd969> in <module>()
----> 1 iterador.next()

StopIteration: 
In [6]:
text_iter = iter('hi')
text_iter.next()
Out[6]:
'h'
In [7]:
text_iter.next()
Out[7]:
'i'
In [8]:
text_iter.next()
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-8-e8660103256d> in <module>()
----> 1 text_iter.next()

StopIteration: 

Generadores

Son iteradores escritos en forma de función, pero en vez de la sentencia return se usa yield. Al ser un iterador este tiene el método next y arroja los valores de una secuencia

In [9]:
def gen():
    yield 4
    yield 5
    yield 6
In [10]:
generador = gen()
In [11]:
generador.next()
Out[11]:
4
In [12]:
generador.next()
Out[12]:
5
In [13]:
generador.next()
Out[13]:
6
In [14]:
generador.next()
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-14-4f893dc60854> in <module>()
----> 1 generador.next()

StopIteration: 

Es posible crear generadores sin límite, a estos se les puede pedir el número de siguiente de la secuencia infinitas veces. Por ejemplo este generardor para la serie de números de Fibonacci.

In [15]:
def fib():
    a, b = 0, 1
    while 1:
        yield a
        a, b = b, a + b
In [16]:
num = fib()
In [17]:
print [num.next() for x in range(20)]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181]



Lectura de archivos

Archivos .txt

Para la lectura de archivos de extensión .txt se usa la sentencia de open

In [1]:
texto = open('ejemplo.txt')
print type(texto)
print texto
<type 'file'>
<open file 'ejemplo.txt', mode 'r' at 0x7f6face35810>

El resultado de la lectura es un objeto con el contenido del archivo pero este no puede ser visto tan solo imprimiendo la variable a la que fue asignado, para esto se usa el método read( )

In [2]:
print texto.read()
No one was to blame for what happened, but that does not make it any less difficult 
to accept. It was all a matter of missed connections, bad timing, blundering in the dark. 
We were always in the right place at the wrong time, the wrong place at the right time, 
always just missing each other, always just a few inches from figuring the whole thing out. 
That's what the story boils down to, I think. A series of lost chances. All the pieces 
were there from the beginning, but no one knew how to put them together. 
In [3]:
print type(texto)
print texto
<type 'file'>
<open file 'ejemplo.txt', mode 'r' at 0x7f6face35810>

También es posible iterar sobre el objeto tipo file creado y recorrer el texto línea a línea.

In [4]:
texto = open('ejemplo.txt')
for line in texto:
    print line
No one was to blame for what happened, but that does not make it any less difficult 

to accept. It was all a matter of missed connections, bad timing, blundering in the dark. 

We were always in the right place at the wrong time, the wrong place at the right time, 

always just missing each other, always just a few inches from figuring the whole thing out. 

That's what the story boils down to, I think. A series of lost chances. All the pieces 

were there from the beginning, but no one knew how to put them together. 

Creación de archivos

La sentencia open también tiene modalidad de escritura. El segndo argumento de esta función es el modo. Si no se indica se toma r (lectura) por defecto. Para crear un nuevo archivo se especifica el nombre y el modo w (escritura) en la función open

In [5]:
# Crea un arhivo .txt de nombre *nuevo_archivo*
file = open("nuevo_archivo.txt", "w")

# Se escribe al interior del archivo
file.write("Este es el primer texto del archivo\n")
file.write("¡Ah! Y esta es la segunda.\n")

# Se guarda el archivo
file.close()

Archivos .json

La información en los archivos .json es interpretada en Python como un diccionario. Para la lectura se requiere de la librería json.

In [6]:
import json

Al igual que con los archivos .txt se usa la sentencia open, pero para interpretar la información se usa json.load( )

In [7]:
data_json = open('ejemplo.json')
data = json.load(data_json)
print type(data)
print data
<type 'dict'>
{u'edad': 27, u'nombre': u'Mauricio', u'apellido': u'Villa'}

Luego de cargada la información los datos son de tipo diccionario y los cambios que se realicen sobre la variable en la que fueron cargados no afecta la información del archivo original.

In [8]:
print data['edad']
27
In [9]:
with open("ejemplo.json") as json_file:
    json_data = json.load(json_file)
    print(json_data)
{u'edad': 27, u'nombre': u'Mauricio', u'apellido': u'Villa'}

Lectura de csv y .xls, .xlsx con pandas

Pandas es una librería con herramientas para el manejo de datos. Usa como base un objeto llamado dataframe.

Leve introducción a los dataframes

Un dataframe es una "tabla" con ciertas funciones predefinidas para organizar, filtrar y obtener datos de esta.

In [10]:
import pandas as pd
In [11]:
dataframe = pd.DataFrame([[1,2,3], [2,3,4], [4,5,6]])
dataframe
Out[11]:
0 1 2
0 1 2 3
1 2 3 4
2 4 5 6

3 rows × 3 columns

Pandas permite leer y crear de archivos .csv (texto plano separado por comas) y archivos del software Excel. Para la lectura se usan los métodos read_csv o read_excel dependiendo del tipo de archivo que se requiera leer.

In [12]:
data = pd.read_csv('SacramentocrimeJanuary2006.csv')
print data.head()
     cdatetime              address  district        beat  grid  \
0  1/1/06 0:00   3108 OCCIDENTAL DR         3  3C          1115   
1  1/1/06 0:00  2082 EXPEDITION WAY         5  5A          1512   
2  1/1/06 0:00           4 PALEN CT         2  2A           212   
3  1/1/06 0:00       22 BECKFORD CT         6  6C          1443   
4  1/1/06 0:00     3421 AUBURN BLVD         2  2A           508   

                      crimedescr  ucr_ncic_code   latitude   longitude  
0  10851(A)VC TAKE VEH W/O OWNER           2404  38.550420 -121.391416  
1     459 PC  BURGLARY RESIDENCE           2204  38.473501 -121.490186  
2  10851(A)VC TAKE VEH W/O OWNER           2404  38.657846 -121.462101  
3   476 PC PASS FICTICIOUS CHECK           2501  38.506774 -121.426951  
4   459 PC  BURGLARY-UNSPECIFIED           2299  38.637448 -121.384613  

[5 rows x 9 columns]

Para crear arhivos se usan los métodos to_csv y to_excel para guardar en formato .csv o .xls respectivamente.

In [13]:
# Se toman las primeras 3 columnas y las 10 primeras filas 
data_filtro = data.iloc[range(10), range(3)]
print data_filtro
     cdatetime              address  district
0  1/1/06 0:00   3108 OCCIDENTAL DR         3
1  1/1/06 0:00  2082 EXPEDITION WAY         5
2  1/1/06 0:00           4 PALEN CT         2
3  1/1/06 0:00       22 BECKFORD CT         6
4  1/1/06 0:00     3421 AUBURN BLVD         2
5  1/1/06 0:00   5301 BONNIEMAE WAY         6
6  1/1/06 0:00        2217 16TH AVE         4
7  1/1/06 0:00            3547 P ST         3
8  1/1/06 0:00     3421 AUBURN BLVD         2
9  1/1/06 0:00    1326 HELMSMAN WAY         1

[10 rows x 3 columns]
In [14]:
# Se guardan los datos filtrados en excel
data_filtro.to_excel('filtro.xls', index=False)



Apoyado por: