3. El Zen de Python
Tim 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!
4. 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).
5. • 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
6. 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]
7. 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 #entero
x=123L #entero largo
x=3.14 #doble
x=‘hola’ #cadena
x=[0,1,2] #lista
x=(0,1,2) #tupla
x=open(‘archivo.py’,’r’) #archivo
9. 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
10. 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.
11. 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”””
12. 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.
13. • 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}
14. 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
15. 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}
16. 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)])
17. 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}
18. 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}
19. 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}
21. 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.
22. 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]
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']
24. 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]
25. 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]
26. 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']
27. 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")
0
insert(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]
28. 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]
29. 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
30. 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]
31. 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])
>>> cola
deque([1, 2, 3])
>>> cola.append(4)
>>> cola.append(5)
>>> cola
deque([1, 2, 3, 4, 5])
>>> cola.popleft()
1
>>> cola.popleft()
2
>>> cola
deque([3, 4, 5])
>>>
33. 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.
34. 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
>>>
35. 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
37. 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.
38.
39. 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.
40. 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.
41.
42. 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
43.
44. 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.
45.
46. 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.
47.
48. 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
49. 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.
50.
51. 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
53. • $ python fibo.py 50
• Si el módulo se importa, ese código no se ejecuta:
• >>> import fibo
• >>>
54. 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.
55. 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.
