Programación en Python

Introducción

El Zen de PythonTim Peters plasmó de forma concisa los principios de diseño por los que guiarse al escribir en Python según el BDFL (NT: Benevolent Dictator for Life o Dictador Benévolo de por Vida, en este caso Guido van Rossum, el creador de Python)

• Hermoso es mejor que feo.• Explícito es mejor que implícito.• Simple es mejor que complejo.• Complejo es mejor que complicado.• Plano es mejor que anidado.• Disperso es mejor que denso.• La legibilidad cuenta.• Los casos especiales no son suficientemente especiales como para romper las reglas.• Aunque lo pragmático gana a la pureza.• Los errores nunca deberían dejarse pasar silenciosamente.• A menos que se silencien explícitamente.• Cuando te enfrentes a la ambigüedad, rechaza la tentación de adivinar.• Debería haber una — y preferiblemente sólo una — manera obvia de hacerlo.• Aunque puede que no sea obvia a primera vista a menos que seas holandés. (NT: Guido van Rossum es

holandés)• Ahora es mejor que nunca.• Aunque muchas veces nunca es mejor que *ahora mismo*.• Si la implementación es difícil de explicar, es una mala idea.• Si la implementación es sencilla de explicar, puede que sea una buena idea.• Los espacios de nombres son una gran idea — ¡tengamos más de esas!

Python• Es un lenguaje de scripting orientado a objetos, capaz de realizar aplicaciones Windows

o páginas web.

• PEP (Python Enhacement Proposal ) es la guía de estilo de programación en Python. Actualmente la versión 8 es la mas actual.

• Python es un lenguaje de programación que puede ser clasificado como:

• Lenguaje de alto nivel: Expresa los algoritmos de una manera mas cercana a la capacidad cognitiva humana.

• Multiplataforma: GNU/Linux, Windows, Mac OS, Solaris.• Tipado dinámico: Sus variable no requieren se definidas asignando su tipo de datos, si no

que se auto asigna en tiempo de ejecución.• Multi paradigma: Acepta diferentes paradigmas (técnicas de programación).

• Los usuarios de Python dicen que el código es Pythonico cuando es transparente y legible, por el contrario cuando el dificil de entender se dice que es “no Pythonico”, con el fin de poder escribir código la legible y estandarizado existen ciertas reglas definidas en el documento Python Enhancement Proposal Nº 8 (PEP 8).

• Python es un lenguaje interpretado, lo cual puede ahorrarte mucho tiempo durante el desarrollo ya que no es necesario compilar ni enlazar. El intérprete puede usarse interactivamente, lo que facilita experimentar con características del lenguaje, escribir programas descartables, o probar funciones cuando se hace desarrollo de programas de abajo hacia arriba. Es también una calculadora de escritorio práctica.

• Python permite escribir programas compactos y legibles. Los programas en Python son típicamente más cortos que sus programas equivalentes en C, C++ o Java por varios motivos:

• Los tipos de datos de alto nivel permiten expresar operaciones complejas en una sola instrucción la agrupación de instrucciones se hace por sangría en vez de llaves de apertura y cierre

• no es necesario declarar variables ni argumentos.

Python

Modo interactivo• El intérprete de Python estándar incluye un modo interactivo en el

cual se escriben las instrucciones en una especie de intérprete de comandos: las expresiones pueden ser introducidas una a una, pudiendo verse el resultado de su evaluación inmediatamente, lo que da la posibilidad de probar porciones de código en el modo interactivo antes de integrarlo como parte de un programa. Esto resulta útil tanto para las personas que se están familiarizando con el lenguaje como para los programadores más avanzados.

• >>> 1 + 1 • 2 • >>> a = range(10) • >>> print a • [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Variables• Las variables se definen de forma dinámica, lo que significa

que no se tiene que especificar cuál es su tipo de antemano y puede tomar distintos valores en otro momento, incluso de un tipo diferente al que tenía previamente. Se usa el símbolo = para asignar valores.

x=123 #enterox=123L #entero largox=3.14 #doblex=‘hola’ #cadenax=[0,1,2] #listax=(0,1,2) #tuplax=open(‘archivo.py’,’r’) #archivo

Tipos de datos

Operadores aritméticos • + Suma a = 10 + 5 a es 15 • - Resta a = 12 - 7 a es 5 • - Negación a = -5 a es -5 • * Multiplicación a = 7 * 5 a es 35 • ** Exponente a = 2 ** 3 a es 8 • / División a = 12.5 / 2 a es 6.25 • // División entera a = 12.5 / 2 a es 6.0 • % Módulo a = 27 % 4 a es 3

Elementos del lenguaje• Python fue diseñado para ser leído con facilidad. Una de sus

características es el uso de palabras donde otros lenguajes utilizarían símbolos. Por ejemplo, los operadores lógicos !, || y && en Python se escriben not, or y and, respectivamente.

• El contenido de los bloques de código es delimitado mediante espacios o tabuladores, conocidos como indentación, antes de cada línea de órdenes pertenecientes al bloque.

• Debido al significado sintáctico de la indentación, una instrucción debe estar contenida en línea. No obstante, si por legibilidad se quiere dividir la instrucción en varias líneas, añadiendo una barra invertida \ al final de una línea.

Comentarios• Los comentarios se pueden poner de dos formas. La primera y más

apropiada para comentarios largos es utilizando la notación ''' comentario ''', tres apóstrofos de apertura y tres de cierre. La segunda notación utiliza el símbolo #, y se extienden hasta el final de la línea.

• El intérprete no tiene en cuenta los comentarios, lo cual es útil si deseamos poner información adicional en nuestro código como, por ejemplo, una explicación sobre el comportamiento de una sección del programa.

Comentario de una sola línea#Este es un comentario de una sola línea

Comentario de varia líneas“”Este es un comentario de Varias líneas”””

Tipos de datos complejos (Diccionarios)• A diferencia de las listas y tuplas los diccionarios se indexan

con claves (relaciones de uno a uno) la cuales pueden ser cadena o números.

• Las principales operaciones de un diccionario son guardar un valor con una clave y extraer su valor mediante una misma clave.

• Para declarar un diccionario se usan las llaves {}. Contienen elementos separados por comas, donde cada elemento está formado por un par clave:valor (el símbolo : separa la clave de su valor correspondiente).

• Los diccionarios son mutables, es decir, se puede cambiar el contenido de un valor en tiempo de ejecución.

• En cambio, las claves de un diccionario deben ser inmutables. Esto quiere decir, por ejemplo, que no podremos usar ni listas ni diccionarios como claves.

• El valor asociado a una clave puede ser de cualquier tipo de dato, incluso un diccionario.

Declaración>>> diccionario ={'cve1': 10,'cve2':20, 'cve3':30}

Tipos de datos complejos (Diccionarios)Agregando elementos al diccionario

>>> diccionario ={'cve1': 10,'cve2':20, 'cve3':30}>>> diccionario['cve4']=40>>> diccionario{'cve4': 40, 'cve1': 10, 'cve2': 20, 'cve3': 30}

Obteniendo un elemento del diccionario>>> diccionario ={'cve1': 10,'cve2':20, 'cve3':30}>>> diccionario['cve2']20

Tipos de datos complejos (Diccionarios)Eliminar elementos del diccionario>>> diccionario ={'cve1': 10,'cve2':20, 'cve3':30}>>> del diccionario['cve1']>>> diccionario{'cve2': 20, 'cve3': 30}

Cambiar valor de un elemento>>> diccionario ={'cve1': 10,'cve2':20, 'cve3':30}>>> diccionario['cve1']=100>>> diccionario{'cve1': 100, 'cve2': 20, 'cve3': 30}

Tipos de datos complejos (Diccionarios)• clear() Elimina los elementos del diccionario>>> diccionario.clear()>>> diccionario{}• get() Obtiene el valor de una clave especifica>>> diccionario ={'cve1': 10,'cve2':20, 'cve3':30}>>> diccionario.get('cve1')10• ítems() Muestra una la lista de todos los elementos

(clave,valor) que tiene el diccionario>>> diccionario.items()dict_items([('cve1', 10), ('cve2', 20), ('cve3', 30)])

Tipos de datos complejos (Diccionarios)• keys() Devuelve una lista de todas las claves que se

encuentran en el diccionario.>>> diccionario.keys()dict_keys(['cve1', 'cve2', 'cve3'])

• pop() Elimina un elemento del diccionario.>>> diccionario ={'cve1': 10,'cve2':20, 'cve3':30}diccionario.pop('cve1')10>>> diccionario{'cve2': 20, 'cve3': 30}

Tipos de datos complejos (Diccionarios)• values() Devuelve una lista de todos los valores que hay en el

diccionario>>> diccionario.values()dict_values([100, 20, 30])

• dict() Puede generar un diccionario desde una expresión que cumpla con la secuencia valor – par

>>> diccionario =dict([('cve1',10),('cve2',20),('cve3',30)])>>> diccionario{'cve1': 10, 'cve2': 20, 'cve3': 30}

Tipos de datos complejos (Diccionarios)

• También es posible generar un diccionario a partir de llaves calculadas:

>>> diccionario ={x:x**2 for x in (2,4,6)}>>> diccionario{2: 4, 4: 16, 6: 36}

Tipos de datos complejos (Diccionarios)

Listas y Tuplas• Para declarar una lista se usan los corchetes [], en cambio, para

declarar una tupla se usan los paréntesis (). En ambas los elementos se separan por comas, y en el caso de las tuplas es necesario que tengan como mínimo una coma.

• Tanto las listas como las tuplas pueden contener elementos de diferentes tipos. No obstante las listas suelen usarse para elementos del mismo tipo en cantidad variable mientras que las tuplas se reservan para elementos distintos en cantidad fija.

• Para acceder a los elementos de una lista o tupla se utiliza un índice entero (empezando por "0", no por "1"). Se pueden utilizar índices negativos para acceder elementos a partir del final.

• Las listas se caracterizan por ser mutables, es decir, se puede cambiar su contenido en tiempo de ejecución, mientras que las tuplas son inmutables ya que no es posible modificar el contenido una vez creada.

Tipos de datos complejos (Listas)

• Las listas son los tipos de datos más versátiles de los datos compuestos con los que cuenta Python, las listas pueden ser declaradas como un conjunto de datos separados por comas encerrados entre corchetes, los cuales no es necesario que sean del mismo tipo, ejemplo:

• • >>> lista =["volvo","bmw","vw",1,23]• >>> lista• ['volvo', 'bmw', 'vw', 1, 23]

Tipos de datos complejos (Listas)• Las listas a diferencia las tuplas permite modificar los datos

una vez creados.• Los índices de las listas comienzan en 0 , para acceder a un

elemento de la lista se escribe entre paréntesis el índice del elemento a seleccionar.

>>> lista =["volvo","bmw","vw",1,23]>>> lista[1] #devuelve 'bmw‘

• Es posible seleccionar un rango de elementos de la lista>>> lista[1:3] #devuelve ['bmw', 'vw']

Tipos de datos complejos (Listas)• Seleccionar un numero determinado de ítems

>>> lista =["volvo","bmw","vw",1,23]>>> lista[:3] #devuelve ['volvo', 'bmw', 'vw']>>> lista[3:] #devuelve [1, 23]

• Las listas no son inmutables por lo que permiten modificar los datos una vez creados:

• >>> lista[2] ="ferrari"• >>> lista• ['volvo', 'bmw', 'ferrari', 1, 23]

Tipos de datos complejos (Listas)• append(value) Agrega nuevos elementos a la lista>>> lista.append("ford")>>> lista['volvo', 'bmw', 'ferrari', 1, 23, 'ford']

• clear() Limpia los elementos de la lista>>> lista.clear()>>> lista[]• copy() Copia los elementos de una lista a otra• >>> lista =["volvo","bmw","vw",1,23]• lista2=lista.copy()• >>> lista2• ['volvo', 'bmw', 'vw', 1, 23]

Tipos de datos complejos (Listas)• count(value) Cuenta cuantas veces existe un determinado

elemento en la lista>>> lista =["volvo","bmw","vw",1,23]lista.count("volvo")1• extend(lista) Concatena elementos >>> lista1= ["elemento1", "elemento2"]>>> lista2 = ["elemento3", "elemento4"]lista1.extend(lista2)>>> lista1['elemento1', 'elemento2', 'elemento3', 'elemento4']

Tipos de datos complejos (Listas)• index(value) Regresa la posición de un elemento a buscar>>> lista =["volvo","bmw","vw",1,23]>>> lista.index("volvo")0insert(pos,value) Agrega un elemento a la lista en una posición definida.>>> lista =["volvo","bmw","vw",1,23]• >>> lista.insert(0,"Ford")• >>> lista• ['Ford', 'volvo', 'bmw', 'vw', 1, 23]

Tipos de datos complejos (Listas)• pop(posicion) Elimina un elemento de la lista en base a su

índice.lista =["volvo","bmw","vw",1,23]>>> lista.pop(0)'volvo'>>> lista['bmw', 'vw', 1, 23]• remove() Elimina un elemento de la lista en base a su valor.lista =["volvo","bmw","vw",1,23]lista.remove("volvo")>>> lista['bmw', 'vw', 1, 23]

Tipos de datos complejos (Listas)• reverse() Ordena los elementos de la lista de atrás hacia

adelante.lista =["volvo","bmw","vw",1,23]>>> lista.reverse()>>> lista[23, 1, 'vw', 'bmw', 'volvo']

• len(lista) Regresa el número de elementos de la lista.lista =["volvo","bmw","vw",1,23]>>> len(lista)5

Tipos de datos complejos (Listas)

Usando listas como pilas• Usando los métodos append y pop, es posible utilizar las listas como pilas (UEPS):

>>> pila = [3,4,5]>>> pila.append(6)>>> pila.append(7)>>> pila[3, 4, 5, 6, 7] >>> pila.pop()7>>> pila.pop()6>>> pila.pop()5>>> pila[3, 4]

Tipos de datos complejos (Listas)

Usando listas como colas• También es posible utilizar las listas como Queues donde el primer elemento en ser agregado

es el primer elemento en salir (PEPS).

>>> from collections import deque>>> cola =deque([1,2,3])>>> coladeque([1, 2, 3])>>> cola.append(4)>>> cola.append(5)>>> coladeque([1, 2, 3, 4, 5])>>> cola.popleft()1>>> cola.popleft()2>>> coladeque([3, 4, 5])>>>

Listas

Tipos de datos complejos (Tuplas)• Una tupla es una variable que permite almacenar varios datos

de diferentes tipos inmutables (que no permiten ser modificados una vez creados).

• Una tupla se define del mismo modo que una lista, salvo que se encierran los elementos entre paréntesis en lugar de corchetes.

• Los elementos de una tupla tienen un orden definido al igual que los de una lista, iniciando el primer elemento en 0. A diferencia de las listas estas son más rápidas que las listas.

Tipos de datos complejos (Tuplas)• Las tuplas no tienen métodos, pero son útiles y mas veloces

que las listas>>> mi_tupla =("hola a todos",2,4.5,’cadena de texto’)

Para acceder a cada uno de los elementos de la tupla se hace mediante su índice correspondiente.>>> print (mi_tupla[0])hola a todos>>>

Tipos de datos complejos (Tuplas)• Es posible tomar una porción de la tupla, indicando

únicamente el inicio y el fin de la misma.>>> print(mi_tupla[1:3]) #devuelve (2, 4.5)>>> print(mi_tupla[2:]) #devuelve (4.5, 'cadena de texto')>>> print(mi_tupla[:2]) #devuelve ('hola a todos', 2)

• Otra característica de las tuplas es que podemos acceder a los elementos de la misma en forma inversa:

>>> mi_tupla =("hola a todos",2,4.5,’cadena de texto’)>>> print(mi_tupla[-1]) #devuelve cadena de texto>>> print(mi_tupla[-3]) #devuelve 2

Tuplas

Conjuntos• Los conjuntos se construyen mediante set(items) donde items

es cualquier objeto iterable, como listas o tuplas. Los conjuntos no mantienen el orden ni contienen elementos duplicados.

• Se suelen utilizar para eliminar duplicados de una secuencia, o para operaciones matemáticas como intersección, unión, diferencia y diferencia simétrica.

Listas por comprensión• Una lista por comprensión (en inglés: list comprehension) es

una expresión compacta para definir listas. Al igual que lambda, aparece en lenguajes funcionales.

Funciones• Las funciones se definen con la palabra clave def, seguida del

nombre de la función y sus parámetros. Otra forma de escribir funciones, aunque menos utilizada, es con la palabra clave lambda (que aparece en lenguajes funcionales como Lisp).

• El valor devuelto en las funciones con def será el dado con la instrucción return.

Clases• Las clases se definen con la palabra clave class, seguida del nombre de la

clase y, si hereda de otra clase, el nombre de esta.• En Python 2.x es recomendable que una clase herede de "object", en

Python 3.x esto ya no hará falta.• En una clase un "método" equivale a una "función", y una "propiedad"

equivale a una "variable".• "__init__" es un método especial que se ejecuta al instanciar la clase, se

usa generalmente para inicializar propiedades y ejecutar métodos necesarios. Al igual que todos los métodos en Python, debe tener al menos un parámetro, generalmente se utiliza self. El resto de parámetros serán los que se indiquen al instanciar la clase.

• Las propiedades que se desee que sean accesibles desde fuera de la clase se deben declarar usando self. delante del nombre.

• En python no existe el concepto de encapsulación,22 por lo que el programador debe ser responsable de asignar los valores a las propiedades

Condicionales• Una sentencia condicional (if) ejecuta su bloque de código

interno sólo si se cumple cierta condición. Se define usando la palabra clave if seguida de la condición, y el bloque de código. Condiciones adicionales, si las hay, se introducen usando elif seguida de la condición y su bloque de código. Todas las condiciones se evalúan secuencialmente hasta encontrar la primera que sea verdadera, y su bloque de código asociado es el único que se ejecuta. Opcionalmente, puede haber un bloque final (la palabra clave else seguida de un bloque de código) que se ejecuta sólo cuando todas las condiciones fueron falsas.

Bucle for• El bucle for es similar a foreach en otros lenguajes. Recorre un

objeto iterable, como una lista, una tupla o un generador, y por cada elemento del iterable ejecuta el bloque de código interno. Se define con la palabra clave for seguida de un nombre de variable, seguido de in, seguido del iterable, y finalmente el bloque de código interno.

Bucle while• l bucle while evalúa una condición y, si es verdadera, ejecuta el

bloque de código interno. Continúa evaluando y ejecutando mientras la condición sea verdadera. Se define con la palabra clave while seguida de la condición

Módulos• Existen muchas propiedades que se pueden agregar al

lenguaje importando módulos, que son "minicódigos" (la mayoría escritos también en Python) que proveen de ciertas funciones y clases para realizar determinadas tareas. Un ejemplo es el módulo Tkinter, que permite crear interfaces gráficas basadas en la biblioteca Tk. Otro ejemplo es el módulo os, que provee acceso a muchas funciones del sistema operativo. Los módulos se agregan a los códigos escribiendo import seguida del nombre del módulo que queramos usar.

Crearemos un pequeño modulo.• Al salir del intérprete Python y volver a entrar se pierden las

definiciones echas. Por lo tanto debemos crear Script para programas mas largos.

def fib(n): a, b = 0 , 1 while b < n: print(b, end = ‘ ‘) a , b = b, a + b print()

def fib2(n): resultado = [ ] a, b = 0 , 1 while b < n: resultado.append(b) a , b = b, a + b return resultado

• Import fibo

• Fibo.fib( 1000 )• Fibo.fib2(100)• Fibo.__name__

• From fibo import fib, fib2• From fib import *

• $ python fibo.py 50

• Si el módulo se importa, ese código no se ejecuta:• >>> import fibo• >>>

Biblioteca estándar• Python tiene una gran biblioteca estándar, usada para una

diversidad de tareas. Esto viene de la filosofía "pilas incluidas" ("batteries included") en referencia a los módulos de Python. Los módulos de la biblioteca estándar pueden mejorarse por módulos personalizados escritos tanto en C como en Python. Debido a la gran variedad de herramientas incluidas en la biblioteca estándar, combinada con la habilidad de usar lenguajes de bajo nivel como C y C++, los cuales son capaces de interactuar con otras bibliotecas, Python es un lenguaje que combina su clara sintaxis con el inmenso poder de lenguajes menos elegantes.

conclusión• Python demasiado bello, sencillo y potente para ser real, sin

embargo es “REAL”. Una de las cuestiones que beneficia al lenguaje es la necesidad de ser sencillo. Obtiene lo mejor de cada lenguaje y lo combina para su uso cotidiano.

• Aunque por nuestras experiencias laborales se ha aprendido que libre != gratis, analizando Python no solo se ve prometedor, además cuenta con una curva de aprendizaje muy baja y muy documentado.

Referencias• http://es.wikibooks.org/wiki/Introducci%C3%B3n_a_Python• http://docs.python.org.ar/tutorial/pdfs/TutorialPython2.pdf• http://www.cursosdeprogramacionadistancia.com/static/pdf/

material-sin-personalizar-python.pdf• https://docs.python.org/2/tutorial/datastructures.html• http://www.usabilidadweb.com.ar/python.php• http://programacion.net/articulo/guia_de_aprendizaje_de_python_

65/3• http://www3.uji.es/~vjimenez/PL/python-by-vilar.pdf• https://sites.google.com/site/sugaractivities/home/curso-pygame/ti

pos-de-datos-complejos-de-python-colecciones---2a-parte---tuplas-y-diccionarios

• http://es.diveintopython.net/odbchelper_tuple.html