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
- Introducción a la sintaxis de Python
- Comentarios
- Tipos de datos: int, float, bool, str y None
- Operadores y operaciones aritméticas
- Operadores booleanos
- Entrada y salida de datos: raw_input, input y print
- PEP 8 generalidades
- Control de flujo
- Sentencias condicionales: if
- Bifurcaciones: if, else
- Sentencias condicionales: if, elif, else
- Condicionales anidados
- Contadores y acumuladores
- Bucle while
- Bucles while anidados
- Bucle for
- Bucles for anidados
- Bucles sobre listas
- Sentencias break, continue
- Estructuras de datos
- Sintaxis listas
- Métodos de las listas
- Métodos de las cadenas (strings)
- Tuplas
- Operaciones y lectura en tuplas
- Diccionarios
- Creación de diccionarios a partir de listas o tuplas
- Operaciones con diccionarios: get, items, values, keys, merge, popitem
- Bucles sobre diccionarios
- PEP 8 listas, tuplas y diccionarios
- Funciones
- Sintaxis de funciones
- Funciones con argumentos opcionales
- Funciones anónimas: lambda
- Funciones recursivas
- Uso de *args y **kwargs
- PEP 8 funciones
- Importación de librerías
- Introducción a Numpy
- Clases
- Iteradores y generadores
- 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.
# -*- 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
"""
Necesitaba mas de una línea
para escribir todo este carretazo
en Python
"""
Imprimir¶
Se usa print para que Python muestre en pantalla el valor de una variable, texto, etc.
a = 234e-2
print a
saludo = 'Hola a todos'
print saludo
print 234253434
print a, saludo
Tipos de datos¶
Integer¶
Integer o int es el conjunto de números enteros
num_entero = 234
otro_entero = 1
Float¶
float es el conjunto de los números reales
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.
# -*- 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á.
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:
a = 3.3212
b = 'Adios universo'
c = None
Ahora se usa el $type$ para identificar el tipo de dato
type(b)
type(a)
type(c)
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:
# 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)
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.
# string a float
a = '235425'
a = float(a)
print a, type(a)
a = 'ds235425'
a = float(a)
print a, type(a)
Operadores¶
Mauricio Villa
Operadores y operaciones aritméticas¶
Suma¶
2+3
Resta¶
2-3
Multiplicación¶
22*3
Potencia¶
34**2
División¶
6/3
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:
2/3
2.0/3
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.
- Paréntesis ()
- Exponenciación ∗∗
- Multiplicación ∗, división /
- Suma +, resta –
(32-10)/4 * 2
5.0/2 * 2
2 / 4.0 / 10.0**2
Operadores booleanos y lógicos¶
- Falso: False
- Verdadero: True
- Conjunción: and
- Disyunción: or
- 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.
- Igualdad: ==
- Mayor: >
- Menor: <
- Mayor igual: >=
- Menor igual: <=
- Diferente: ! =
3 == 5
num_ojos = 2
num_ojos < 8
'hola' > 'ana'
nombre_usuario = 'Camila'
nombre_asesor = 'Carlos'
nombre_usuario != nombre_asesor
Ejemplos de combinación de operadores de comparación y operadores lógicos:
4 > 5 and 3 < 2
5 > 4 or 3 < 1
not 2 > 100
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:
a = 12 + 345
print a
promedio = 14.5432
print 'El promedio de los datos es:', promedio
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:
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)
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
nombre = raw_input('Ingrese su nombre: ')
print 'Hola', nombre
print type(nombre)
edad = raw_input('Ingrese su edad: ')
print type(edad)
print edad
Si se requiere realizar operaciones con una variable diferente a un texto esta debe convertirse al valor deseado una vez que ingresa al algoritmo:
edad = raw_input('Ingrese su edad: ')
edad = int(edad)
print type(edad)
print edad
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.
nombre = input('Ingrese su nombre: ')
print 'Hola', nombre
print type(nombre)
edad = input('Ingrese su edad: ')
print type(edad)
print edad
Error al no especificar que se ingresa un string
nombre = input('Ingrese su nombre: ')
print 'Hola', nombre
print type(nombre)
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:
""" Este es un comentario en una linea. """
En varias líneas
""" Comentario a
varias líneas.
"""
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:
x = 1
y = 2
long_variable = 3
No:
x = 1
y = 2
long_variable = 3
Operaciones matemáticas¶
Si:
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:
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¶
num_ojos = 2
if num_ojos != 8:
print '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:
if 4 in [3, 5, 4]:
print 'El número 4 hace parte de la lista'
Se utilizan los operadores lógicos para establecer controladores de flujos con mas condiciones:
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)
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.
num_bin = 1
if num_bin == 0:
num_bin += 1
else:
num_bin -= 1
print num_bin
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.
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?'
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.
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"
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:
sustancia = None
if sustancia is None:
print "No se encontró sustancia"
else:
print "Su sustancia es:", 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:
sustancia = "Magnesio"
if sustancia is not None:
print "Su sustancia es:", sustancia
else:
print "No se encontró sustancia"
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.
# 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
# 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:
# 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
tiempo -= 4
Acumulador¶
Es una variable que aumenta o disminuye en una cantidad constante, este requiere de un valor inicial.
# Valor inicial acumulador
acum = 20
# Variable
var = 2
# Acumulador
acum += var
print acum
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.
# Valor inicial acumulador
acum = 20
# Variable
var = 2
# Acumulador
acum += var
# Cambio en el valor de la variable
var = 5
acum += var
print acum
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.
contador = 0
lista = []
while contador <= 10:
lista.append(contador)
print lista
contador += 1
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.
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
for¶
Se utiliza este bucle cuando se conoce de antemano el número de veces que se quiere repetir el código.
# 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
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
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
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:
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
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.
for i in range(1, 10):
if i%2 != 0:
continue
else:
print i**2+1
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.
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
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.
# Se crea una lista con el cuadrado de los números del 0 al 5
[x**2 for x in range(5)]
Crear listas como resultado de operaciones con otra lista
list_str = ['python', 'math', 'Colombia']
['mi variable-'+x for x in list_str]
Listas¶
Mauricio Villa
Una lista es una estructura para almacenar todo tipo de datos. Se escriben separados por comas entre corchetes:
lista = [ 1, 'hola', 3.1243, 3.0/6]
También puede ser creada una lista vacía con la función list()
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:
b = ['python', 342, 2.5]
b[0]
b[1]
Desde el último elemento hacia el primero con números negativos:
b[-2]
b[-1]
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.
lista = [22, 43, 64, 895, 56, 347, 58]
lista[3:5]
Si no se escribe el índice inicial se toma desde el 0
lista[:2]
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.
# se crea una lista de 0 a 4
range(5)
# Se crea una lista desde 3 hasta 20 con paso 2
range(3, 20, 2)
# una lista desde -12 hasta 5 con paso 1
range(-12, 5)
Métodos de las listas¶
Append¶
Para agregar nuevos elementos a una lista en la última posición
a = [2, 4, 'eso veo']
a.append('hola')
print a
Es posible agregar una lista como elemento de otra lista
b = [ 4, 'tarea', 456]
b.append([2, 3])
print b
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.
a.insert(1, 3)
print a
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:
lista_1 = [4, 2, 3]
lista_2 = [1, 2, 3]
lista_1.extend(lista_2)
print lista_1
Otra forma de hacer esto es con una suma:
lista_1 = [4, 2, 3]
lista_2 = [1, 2, 3]
lista_1 + lista_2
Index¶
Devuelve la posición en la lista de uno de sus componentes, si este valor no está en la lista, devuelve error.
a = [ 4, 'monty', 'python']
a.index('monty')
a.index(5)
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:
- Números
- Letras en mayúscula
- Letras en minúscula
lista_num = [ 2, 543, 234, 1 , 54, 4]
lista_num.sort()
print lista_num
lista_letras = ['monty', 'Python', 'codigo']
lista_letras.sort()
print lista_letras
lista_alfa_num = [ 32, 'math', 43.21, 'Axear']
lista_alfa_num.sort()
print lista_alfa_num
Strings¶
Mauricio Villa
lower¶
Cambia todas las letras del string en minúscula
texto = '... viejEcita Sin nadita qUE comer Sino carnes, frutas, dulces'
texto.lower()
upper¶
Cambia todas las letras del string en mayúscula
texto = '... viejEcita Sin nadita qUE comer Sino carnes, frutas, dulces'
texto.upper()
count¶
Cantidad de repeticiones en un string. Como argumento se da el string que se quiere buscar.
texto = 'Nadie, nadie la cuidaba Sino Andrés y Juan y Gil'
texto.count('y')
texto.count('a')
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.
texto = "separar este segmento de texto"
texto.split()
texto.split('e')
texto.split('este')
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.
texto = "El hijo de ruana rin rin renacuajo"
texto.find('hijo')
texto.find('rin')
texto.find('viejecita')
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.
texto = "El hijo de ruana rin rin renacuajo"
texto.rfind('hijo')
texto.rfind('rin')
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.
texto = "Apetito nunca tuvo Acabando de comer"
texto.index('a')
texto.index('nunca')
texto.index('mantener')
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.
texto = "Y esta pobre viejecita Al morir no dejó más"
texto.rindex('r')
texto.rindex('caimán')
replace¶
Permite reemplazar cualquier string por otro, si este no se encunetra devuelve el string original.
texto = 'Duerma en paz, y Dios permita Que logremos disfrutar'
texto.replace('e', 'a')
texto.replace('Dormir', 'Hola')
Nótese que el texto no se modifica realmente al aplicar esta función, para esto abría que asignarlo nuevamente a la variable
texto
texto = texto.replace('e', 'a')
print texto
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:
mi_tupla = (12, 'asdads', [2,3,4])
print type(mi_tupla)
mi_tupla = 12, 'asdads', [2,3,4]
print type(mi_tupla)
Se puede crear una tupla vacía solo con los paréntesis o con la sentencia tuple
tupla_vacia = ()
tupla_vacia = tuple()
Una tupla con un solo elemento puede ser creada con el elemento y una coma al final
singleton = 6,
print singleton
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.
tupla = (1,3,4,5,6,7)
tupla[1]
tupla[2:]
tupla[1] = 12
Convertir una lista a tupla¶
lista = [4, 3, 5, 4, 3]
tuple(lista)
Longitud de una tupla¶
tupla = (3, 4, 5, 6, 7)
len(tupla)
Concatenar tuplas¶
tupla + tupla
tupla * 4
Elementos en tuplas¶
12 in tupla
3 in tupla
Iteraciones sobre tuplas¶
Se usa la misma sintaxis vista en el módulo de listas
for x in tupla:
print x
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 {}.
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).
mi_dict['lenguaje']
mi_dict['nombre']
Si se especifica una clave que no está en el diccionario este devuelve el error KeyError
mi_dict['gato']
Un diccionario vacío se puede crear solo con el símbolo llaves o con la sentencia dict
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.
otro_dict = dict(sape=4139, guido='4127', jack=4098)
print otro_dict
Diccionarios a partir de tuplas¶
Se debe crear una tupla que contenga tuplas con la clave y el valor deseado en el diccionario:
mi_tupla = (('nombre', 'Mauricio'), ('edad', 27), ('lenguaje', 'Python'), (0, 'acepto'))
mi_dict = dict(mi_tupla)
print mi_dict
La misma operación se puede realizar si es una lista de tuplas
mi_tupla = [('nombre', 'Mauricio'), ('edad', 27), ('lenguaje', 'Python'), (0, 'acepto')]
mi_dict = dict(mi_tupla)
print mi_dict
Diccionarios por comprension¶
{x: x+2 for x in range(4)}
Claves de los diccionarios¶
mi_dict = {'nombre': 'Mauricio', 'edad': 27, 'lenguaje': 'Python', 0:'acepto'}
mi_dict.keys()
Valores de los diccionarios¶
mi_dict = {'nombre': 'Mauricio', 'edad': 27, 'lenguaje': 'Python', 0:'acepto'}
mi_dict.values()
Iteración sobre diccionarios¶
mi_dict = {'nombre': 'Mauricio', 'edad': 27, 'lenguaje': 'Python', 0:'acepto'}
Iteración sobre las claves
for key in mi_dict:
print key
Iteración sobre los valores
for key in mi_dict.values():
print key
Iteración sobre claves y valores
for key, value in mi_dict.iteritems():
print key, value
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:
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:
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
def saludo_print():
print 'Hola'
saludo_print()
Caso II¶
Función que devuelve el resultado
def saludo_return():
return 'Hola'
resultado = saludo_return()
resultado
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:
def saludo(nombre):
print '¡Hola {0}!'.format(nombre)
saludo('Mauricio')
def nombre(nombre, apellido):
print 'Su nombre es:', nombre, apellido
nombre('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.
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
nombre('Carlos')
Si el valor por defecto no es el requerido se puede especificar el nuevo valor al parámetro
nombre('Carlos', apellido='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.
nombre('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.
lambda y: y**2
Estas pueden ser usadas como argumento de otras funciones e incluso asignadas a una variable
Elevar un número al cuadrado:
exp_dos = lambda x: x**2
exp_dos(9)
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:
lista = [23, 245, 12, 45, 123, 456, 234, 547]
print filter(lambda x: x % 2 == 0, lista)
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.
def fib(num):
if num < 2:
return num
return fib(num-2) + fib(num-1)
fib(2)
for i in range(10):
print fib(i)
def factorial(num):
if num < 2:
return 1
return num * factorial(num-1)
factorial(18)
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
def resta(a, b):
return a-b
resta(2, 3)
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.
# Tupla como argumento de entrada a la función resta
args = 2, 3
resta(*args)
# Cambiando los valores de los argumentos
args = 3, 2
resta(*args)
# Lista como argumento de entrada a la función resta
args = [3, 2]
resta(*args)
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.
kwargs = {'b':3, 'a':2}
resta(**kwargs)
# Esto es equivalente a ejecutar resta(2, 3)
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.
def pack_area(*args):
print args
pack_area(2,3)
pack_area()
Por ejemplo, se crea una función que suma todos los argumentos, independiente de su valor y de la cantidad de estos
def suma(*args):
# Se convierte la tupla en lista
data = list(args)
return sum(data)
suma(1,14,5,6)
suma()
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.
def pack_area(**kwargs):
print kwargs
pack_area(r=2, t=4)
pack_area()
Se crea una función que muestra datos personales
def datos_personales(**kwargs):
for nombre, valor in kwargs.iteritems():
print '{0}: {1}'.format(nombre, valor)
datos_personales(nombre='Andrés', edad=27)
En caso de que se requieran muchos argumentos de entrada se recomienta crear un diccionario
kwargs = {'Nombre': 'Andrés', 'Edad':27, 'Estado civil': 'Soltero'}
datos_personales(**kwargs)
Es posible usar tanto *args como **kwargs en una misma función:
def pack_area(*args, **kwargs):
print args
print kwargs
pack_area(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
import numpy
from numpy import *
Solo un módulo de la librería
from numpy import exp
exp(1)
from datetime import datetime
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
import matplotlib.pyplot as plt
Ahora al usar la el módulo no se requiere escribir matplotlib.pyplot sino plt. Otros ejemplos:
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¶
import math
Algunas funciones¶
Logarítmo natural
math.log(3)
Logarítmo en base 10
math.log10(3)
Raíz cuadrada
math.sqrt(3)
Constantes¶
math.e
math.pi
Librería Random¶
Permite generar número aleatorios en diferentes distribuciones como uniforme, normal, lognormal, gamma, etc.
import random
Número entero aleatorio en una distribución uniforme entre dos valores dados:
random.randint(20, 50)
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
[random.randint(20, 50) for i in range(10)]
Números aleatorios entre 0 y 1 con una distribución uniforme
[random.random() for i in range(10)]
Números aleatorios con una distribución normal, dada la media y la desviación
media = 0
desv = 1
[random.gauss(media, desv) for i in range(10)]
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:
import numpy as np
Numpy también realiza operaciones con exponenciales, radicación y tienen los valores de algunas constantes matemáticas:
Algunas constantes
np.exp(1)
np.pi
Logaritmo natural
np.log(2)
Logaritmo en base 10
np.log10(2)
Raiz cuadrada
np.sqrt(4.32)
Numpy array¶
Es una colección de elementos del mismo tipo
Array de una dimensión¶
mi_array = np.array([2, 3, 4, 5])
mi_array
También se puede construir un array en un rango de números con una cantidad determinada:
x = np.linspace(0,10,11)
x
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
mi_array = np.array([2, 3, 4, 5])
mi_array[2]
Array de dos dimensiones¶
Estos array estan compuestos por otros array de cualquier dimensión
mi_array = np.array([[1, 2], [2, 3]])
mi_array
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
# Se genera un array con 5 arrays en su interior cada uno con 3 elementos
np.random.rand(5, 3)
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
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
# Se obtiene el primer dato (0) de la segunda lista (1)
mi_array[1][0]
O una sintaxis resumida:
mi_array[1, 0]
Operaciones con numpy array¶
a = np.array([2, 3, 4, 5])
b = np.array([[1, 2], [5, 3]])
Suma¶
a+2
a+a
Resta¶
a-2
a-a
Multiplicación¶
7*a
a * (a*2)
b*b
División¶
a/2.0
a/(5.0*a)
Operaciones de matrices con numpy arrays¶
a = np.array([2, 3, 4, 5])
b = np.array([[1, 2], [5, 3]])
Multiplicación matricial¶
np.dot(b, b)
Traspuesta¶
b.transpose()
Inversa¶
np.linalg.inv(b)
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
my_array = np.random.rand(1,10)
my_array
# Máximo
my_array.max()
# Mínimo
my_array.min()
# Media
my_array.mean()
# desviación
my_array.std()
# Índices de los elementos diferentes de cero
otro_array = np.array([0, 2, 0, 34, 23, 0, 2])
otro_array.nonzero()
# 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)
otro_array.reshape(9, 1)
# Ordenamiento del array
my_array.sort()
my_array
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¶
b = np.matrix([[1, 2], [5, 3]])
c = np.matrix([[1], [2]])
print b, '\n'
print c
Multiplicación¶
b*b
b*c
Traspuesta¶
b.T
Inversa¶
b.I
Solución de sistema de ecuaciones lineales con matrices¶
Solucionar el sistema de ecuaciones:
$x+2y=1$
$5x+3y=2$
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)
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:
import numpy as np
my_array = np.random.randint(1, 6, 20)
my_array
Se seleccionan los datos menores que 3
my_array[my_array < 3]
La comparación devuelve un array de booleanos, con True si cumple la condición y False en caso contrario
my_array < 3
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.
# Valores iguales a 3
my_array[my_array == 3]
# Valores diferentes de 3
my_array[my_array != 3]
# Valoers mayores iguales a 3
my_array[my_array >= 3]
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 ( | )
# Los números deben ser menores iguales a 2 o mayores que 3
my_array[(my_array <= 2) | (my_array > 3)]
# Los números deben ser mayores iguales a 2 y menores que 4
my_array[(my_array >= 2) & (my_array < 4)]
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()
my_array = np.random.randint(10, 25, 50)
my_array
Condición: Se requiere la posición de los datos que entre 16 y 22.
# Datos que cumplen la condición
my_array[(my_array >= 16) & (my_array<=22)]
# Posición de los datos en el array original
np.argwhere((my_array >= 16) & (my_array<=22))
Se ejecuta la misma condición sobre un array de dos dimensiones
my_array = np.random.randint(10, 25, 50).reshape(10, 5)
my_array
# Datos que cumplen la condición
my_array[(my_array >= 16) & (my_array<=22)]
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.
# Posición de los datos en el array original
np.argwhere((my_array >= 16) & (my_array<=22))
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:
3 is None
np.nan is None
np.nan is np.nan
Pero esta comparación dentro de un filtro no devuelve lo esperado
my_array = np.array([np.nan, 3, 2 ,6 ,4, np.nan, np.nan, 5, 3, 2])
my_array
my_array[my_array is np.nan]
Para detectar entonces este tipo de datos se usa la función np.isnan
my_array[np.isnan(my_array)]
Se usa la negación ( ~ ) para encontrar los valores diferentes de np.nan
my_array[~np.isnan(my_array)]
# Posición de los nan en el array original
np.argwhere(np.isnan(my_array))
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
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
my_array[my_array <= 2] *= 5
my_array
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.
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.
mi_carro = Carro()
print type(mi_carro)
Atributos de la clase¶
Para acceder a los atributos del objeto se escribe variable.atributo
mi_carro.color
mi_carro.marca
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:
# Cambio del valor del atributo color
mi_carro.color = 'azul'
mi_carro.color
# Al crear una nueva instancia se mantiene el valor del atributo que se asigno en la clase
otro_carro = Carro()
otro_carro.color
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.
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
carro = Carro()
Se impriment los valores de los atributos
print carro.color
print carro.marca
print carro.encendido
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 ( )
# Encender el carro
carro.encender()
carro.encendido
# Apagar el carro
carro.apagar()
carro.encendido
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.
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
carro = Carro('azul', 'Mazda')
print carro.color
print carro.marca
print carro.encendido
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
iterador = iter([4,5,6])
iterador.next()
iterador.next()
iterador.next()
iterador.next()
text_iter = iter('hi')
text_iter.next()
text_iter.next()
text_iter.next()
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
def gen():
yield 4
yield 5
yield 6
generador = gen()
generador.next()
generador.next()
generador.next()
generador.next()
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.
def fib():
a, b = 0, 1
while 1:
yield a
a, b = b, a + b
num = fib()
print [num.next() for x in range(20)]
Lectura de archivos¶
Archivos .txt¶
Para la lectura de archivos de extensión .txt se usa la sentencia de open
texto = open('ejemplo.txt')
print type(texto)
print texto
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( )
print texto.read()
print type(texto)
print texto
También es posible iterar sobre el objeto tipo file creado y recorrer el texto línea a línea.
texto = open('ejemplo.txt')
for line in texto:
print line
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
# 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.
import json
Al igual que con los archivos .txt se usa la sentencia open, pero para interpretar la información se usa json.load( )
data_json = open('ejemplo.json')
data = json.load(data_json)
print type(data)
print data
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.
print data['edad']
with open("ejemplo.json") as json_file:
json_data = json.load(json_file)
print(json_data)
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.
import pandas as pd
dataframe = pd.DataFrame([[1,2,3], [2,3,4], [4,5,6]])
dataframe
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.
data = pd.read_csv('SacramentocrimeJanuary2006.csv')
print data.head()
Para crear arhivos se usan los métodos to_csv y to_excel para guardar en formato .csv o .xls respectivamente.
# Se toman las primeras 3 columnas y las 10 primeras filas
data_filtro = data.iloc[range(10), range(3)]
print data_filtro
# Se guardan los datos filtrados en excel
data_filtro.to_excel('filtro.xls', index=False)