Upload
wozgeass
View
1.601
Download
1
Embed Size (px)
Citation preview
Introducción: ¿Que es Python?
Lenguaje de Programación creado por GvR en '90Sintaxis clara y limpia => código legibleLenguaje interpretado ("script"), no compilado código nativo, flexibilidad vs velocidad, pseudocódigo intermedio (bytecode)Tipado dinámico: sin declaración previaFuertemente tipado: conversión explícitaMultiplataforma: unix, windows, mac, etc.Multiparadigma: estructurado, funcional, orientado a objetos, orientado a aspectos
Introducción: ¿Por qué Python?
Lenguaje natural, agrupación por identación sin {}Dinámico, al no declarar variables ni argumentosTipos de datos de alto nivelGestión de memoria automáticaGran cantidad de librerias disponibles, extensibilidad
Fácil de aprenderDesarrollo rápido de aplicacionesCódigo fácil de mantener No recomendable: bajo nivel o rendimiento crítico
Introducción: Instalación
Implementacion estándar: CPython (rápida y estable) Alternativas: Jython (java), IronPython (.net)
CPython: preinstalado Linux y MacInstaladores: http://www.python.org/download/ Versiones disponibles:
2.5.4: final - solo bugfix - mayor compatibilidad2.6.2: estable actual - características 3.x3.1: estable, levemente incompatible hacia atras
Introducción: Herramientas básicas
Interprete (línea de comandos) Ejecutar scripts
IPython: interprete mejorado (autocompletado, ?)IDLE: Interprete/IDE gráfica:
AutocompletadoCalltips (parámetros)Edición de código fuente, con identaciónDepuración básica
IDEs: PyDev, SPE, Eric, Boa, Komodo, WingIDE
Introducción: Hola Mundo
Ingresar al interprete, escribir:
>>> print "hola mundo!"hola mundo!
Ingresar al editor, crear un archivo hola.pyEjecutar el archivo:
python hola.py
Introducción: InterpretePython 2.5.4 (r254:67916, Dec 23 2008, 15:10:54) [MSC v.1310 32 bit (Intel)] on win32Type "help", "copyright", "credits" or "license" for more information.>>> a = """... hola... """>>> a'\nhola\n'>>> print a
hola
>>>
Introducción: Estructura básica
Palabras claves: and as assert break class continue def del elif else except exec finally for from global if import in is lambda not or pass print raise return try while with yieldOperadores: + - * ** / // % << >> & | ^ ~ < > <= >= == != <>Separadores: , : . ` = ; += -= *= /= //= %= &= |= ^= >>= <<= **= ( ) [ ] { } @ Built-in: funciones, objetos y clases incorporadas en el lenguaje por defectoIdentación, espaciado y unión de líneas (\)
Introducción: Sentencias Simples
Instrucciones básicas útiles:print: imprimir por pantalla o salida estándarraw_input(mensaje) / input(mensaje): entrada de datos por teclado o entrada estándarhelp(identificador): devuelve ayuda, argumentos, valor de vuelto, etc.dir(identificador): devuelve los atributos del objeto, módulo o nombres accesiblestype(identificador): devuelve el tipoisinstance(indetificador, tipo): devuelve verdadero si es una instancia del tipo dado
Introducción: Programa básico#!/usr/bin/python# -*- coding: latin1 -*-
# sumo dos variablesa = 2 # enterob = 1.5 # punto flotanteprint a+b
# pregunto el nombre, imprimo saludonombre = raw_input("ingrese su nombre")mensaje = "hola" print mensaje, nombre
Introducción: Tipos de datos básicos
Números:Enteros (int/long): 3De coma flotante (float): 15.57Complejos (complex): 7 + 5j
Cadenas de texto:Strings (str): "Hola Mundo"Unicodes (unicode): u"año"
Valores booleanos: (bool): True (verdadero) y False (falso)
Tipos de datos básicos: Enteros
Tipos:int: números enteros de 32 o 64 bitslong: números de cualquier precisión (prefijo L)Conversión automática int a longDivisión devuelve enteros!
>>> e = 31>>> l = 1234567891234567L>>> e * 1000000003100000000L>>> 7/23
Tipos de datos básicos: Punto Flotante
Tipo:float: números reales (coma flotante de 64 bits)IEEE 754: 1 bit para el signo, 11 bits para el exponente, 52 bits para la mantisa ()Notación científica: 0.1e-3 (exponente base 10)Almacenamiento binario (base 2): ocasional impresición al representar valores sin redondeo
>>> f = 0.1e-3>>> f0.0001>>> 0.20.20000000000000001
Tipos de datos básicos: Complejos
Tipo:complex: números reales e imaginariosparte real e imaginaria: float (internamente)Notación: 2.1 + 7.8j
>>> (0+1j)**2(-1+0j)>>> a=3.0+4.0j # complex(3.0, 4.0)>>> a.real3.0>>> a.imag4.0>>> abs(a) # sqrt(a.real**2 + a.imag**2)5.0
Tipos de datos básicos: Operaciones
Operadores aritméticos:Suma: +, resta: -, multiplicación: *, división: /Negación: -1Potenciación: **Módulo (resto): %
Operadores a nivel de bits:Y (and): &O (or): |O exclusivo (xor) ^No (not): ~)Desplazamiento: << y >>
Tipos de datos básicos: Cadenas
Tipos:str: texto ascii puro (bytes)unicode: texto codificado (ej. utf8): u"áéí"
Caracteres "escapados": '\xe1' (código hexadecimal: á), '\n' (salto de linea), '\t' (tabulación), '\\' (barra invertida) , '\'' (comilla)Comillas simples ('), dobles ("). Multilinea (comillas triples: """ o ''')Texto crudo (raw): r'C:\' es "C:\\" (sin escapar)
Tipos de datos básicos: CadenasOperadores:
Concatenación (+), Multiplicación (*)Indexar [pos] y Recortar [pos1:pos2] (rebanada)No pueden ser modificadas: palabra[0] = 'x'
>>> palabra = 'Ayuda' + 'A'>>> palabra'AyudaA'>>> '<' + palabra*5 + '>''<AyudaAAyudaAAyudaAAyudaAAyudaA>'>>> palabra[4]'a'>>> palabra[0:2]'Ay'
Tipos de datos básicos: CadenasMétodos:
strip(caracter): "limpiar" caracteres(espacios)split(caracter): dividir un textofind(substring, inicio, final): encontrar cadenastartswith(prefijo, inicio, final): ¿empieza con?endswith(sufijo, inicio, final): ¿termina con?lower(): convertir en minúsculasupper(): convertir en minúsculasisdigit(): ¿es numérico?isalpha(): ¿es alfanumérico?islower(): ¿está en minúsculas?isupper(): ¿está en mayúsculas?
Tipos de datos básicos: CadenasCodificación (Unicode):
encode(codificación): codifica un unicodedecode(codificación): codifica un string
>>> u=u"äöü">>> u.encode("latin1")'\xe4\xf6\xfc'>>> s = u.encode("utf-8")>>> s'\xc3\xa4\xc3\xb6\xc3\xbc'>>> s.decode("utf8")u'\xe4\xf6\xfc'>>> unicode('\xe4\xf6\xfc','latin1')u'\xe4\xf6\xfc'
Tipos de datos básicos: Booleanos
Tipo:bool: clases True (verdadero), False (falso)Caso especial de tipo int (0: falso, 1: true)Objetos vacios: falso
Operadores lógicos:Y lógico: and O lógico: orNO lógico: not
>>> True and FalseFalse
Tipos de datos básicos: Booleanos
Operadores relacionales:a Igual b: a == ba Distinto b: a != ba Mayor/Menor b: a > b , a < ba Mayor/Menor o igual b: a >= b , a <= b
>>> 1 == 2False>>> not 'ab' > 'ba'True
Tipos de datos compuestosColecciones de datos:
Listas (list): [1, 'a', 3.0, 1]Tuplas (tuple): (1, 'a', 3.0, 1) (no modificables) Conjuntos (set): set(1, 'a', 3.0) (sin repetidos)Diccionarios (dict): {clave: valor}
Tipos de datos compuestos: Listas
list: colección ordenada, modificable. Equivalente a arrays, o vectores en otros lenguajesPueden contener cualquier tipo de dato: números, cadenas, booleanos, … y también listas.Indicar entre corchetes, y separados por comas, los valores a incluir en la lista:
>>> a = ['pan', 'huevos', 100, 1234]>>> a['pan', 'huevos', 100, 1234]
Tipos de datos compuestos: ListasOperaciones:
Acceder por índice: lista[posición]Recortar: lista[inicio:final]
>>> a = ['pan', 'huevos', 100, 1234]>>> a[0]'pan'>>> a[3]1234>>> a[-2]100>>> a[1:-1]['huevos', 100]
Tipos de datos compuestos: ListasOperaciones:
Acceder por índice: lista[posición]Rebanar o Recortar: lista[inicio:final] Comprobar pertenencia de un elemento: in
>>> a[0]'pan'>>> a[-2]100>>> a[1:-1]['huevos', 100]>>> 'huevos' in aTrue
Tipos de datos compuestos: ListasModificaciones:
Por índice: lista[posición] = nuevoPor "rebanada": lista[inicio:final] = nuevoBorrar con del o [] (lista vacia)
>>> a[0:2] = [1, 12] # cambiar elementos>>> a[1, 12, 123, 1234]>>> a[0:2] = [] # Borrar elementos>>> a[123, 1234] # Insertar elementos>>> a[1:1] = ['bruja', 'xyzzy']>>> a[123, 'bruja', 'xyzzy', 1234]
Tipos de datos compuestos: ListasMétodos:
sort(clave): ordenar la lista (en su lugar)reverse(): revertir el órdenpop(posición): extraer un elementoappend(item): agrega un elementoinsert(posición, item): inserta un elementoremove(item): elimina la primer ocurrenciacount(item): cuenta las ocurrenciasindex(item): devuelve la posición del elementoextend(lista): extiende la lista con otra lista
>>> a.pop()
Tipos de datos compuestos: ListasFunciones incorporadas:
sorted(lista): crea una nueva lista ordenadamax(lista) / min(lista) / sum(lista): devuelve el máximo, mínimo o la suma de una lista any(lista) / all(lista): verifica si algún/todos los elementos son verdaderosmap(función, lista): aplica una función a los elementos de la listafilter(función, listra): filtra una listareduce(función, lista): aplica acumulativamente una función a una lista (devuelve un valor)
Tipos de datos compuestos: ListasDefinición por comprensión: crea una nueva lista aplicando una expresión (cálculo) a los elementos de otra lista que cumplan una determinada condición:
[expresión for variables in iterable if condición]
>>> vec = [2, 4, 6]>>> [3*x for x in vec][6, 12, 18]>>> [3*x for x in vec if x > 3][12, 18]>>> [3*x for x in vec if x[]
Tipos de datos compuestos: Tuplastuple: colección ordenada inmutable. Similar a las listas, pero no modificablesPueden accederse por posición y recortarseNo tienen métodos especiales Son más "ligeras" que las listasSeparar elementos por comas, (opcionalmente entre paréntesis). Incluir coma tuplas de un elemento:
>>> 'pan', 'huevos'('pan', 'huevos')>>> 'pan',('pan',)
Tipos de datos compuestos: Conjuntosset: colección no ordenada sin elementos repetidosSimilar a las listas, pero no se pueden acceder por posición (no indizadas)Soportan operaciones matemáticas como la unión (+), intersección (&), diferencia (-), y diferencia simétrica (^).
>>> a = set('abracadabra')>>> b = set('alacazam')>>> aset(['a', 'r', 'b', 'c', 'd'])>>> a & bset(['a', 'c'])
Tipos de datos compuestos: Diccionarios
dict: colección no ordenada asociando valor y clave. Se indexan por las claves únicas. Las claves pueden ser cualquier inmutableForma {clave:valor, clave:valor, ... }Constructor: dict( (clave, valor), (clave, valor) ...)
>>> tel = {'jack': 4098, 'sape': 4139}>>> tel['guido'] = 4127>>> tel{'sape': 4139, 'jack': 4098, 'guido': 4127}
Tipos de datos compuestos: DiccionariosAsignación y Modificación:
Acceso por clave: dic[clave] (error si la clave no existe)Asignación: dic[clave] = valor (sobreescribe si la clave ya existe)Eliminar un elemento: del dic[clave]Consultar si la clave pertenece al diccionario: clave in dic
Tipos de datos compuestos: DiccionariosMétodos:
keys(): devuelve una lista de las clavesvalues(): devuelve una lista de los valoresitems(): devuelve una lista de tuplas (clave, valor)get(clave, valor por defecto): devuelve el valor para la clave, o el valor por defecto si no existepop(clave, valor por defecto): similar a get, pero remueve el elementosetdefault(clave, valor por defecto): similar a get, pero establece el elemento si no existeupdate(dic): actualiza con otro diccionario
Formateo de StringsEj: "%06.2f, %-20s" % (2.2, 'hola')
Caracter '%', marca el inicio del especificadorClave de mapeo (opcional): Ej (somename)Flags (opcional): '#' (alternativo), '0' (rellenar con 0), '-' (ajustar a la izq.), ' ' (espacio para el signo), '+' (signo '+' o '-') Ancho mínimo (opcional). '*' (lee próx. elemento)Precisión (opcional), '.' + cant. decimales. '*' (lee próx. elemento)Ancho (opcional).Tipo de conversión: 'd': decimal, 'f': float, 's': string, 'e': notación científica, '%': %, ...
Control de flujo: condicionales ifif condición1: bloque si se cumple condición1elif condición2: bloque si se cumple condición2else: bloque en caso contrario
if numero < 0: print "Negativo"elif numero > 0: print "Positivo"else: print "Cero"
Control de flujo: condicional if compacta�Similar al operador ? o iifPermite evaluar una condición en una expresión
A if condición else B
>>> a = 10>>> print 'si' if a==10 else 'no''si'
Control de flujo: bucles whilewhile condición: bloque si se cumple condición continue # vuelve al comienzo break # interrumpo el ciclo
else: bloque si no se ha interrumpido
edad = 0while edad < 18: edad = edad + 1 print "Felicidades, tienes " + str(edad)
Control de flujo: iteraciones forfor elemento in secuencia: bloque continue # vuelve al comienzo break # interrumpo el ciclo
else: bloque si no se ha interrumpido
for elemento in ["uno", "dos", "tres"]: print elemento
for i in xrange(0, 100, 2): print i
Funciones:Fragmentos de código (con o sin nombre*)Pueden recibir argumentos y devuelven un valor (o None)
def funcion(argumento1,argumento2=100): "Esta función hace..." bloque return valor
def saludar(nombre, saludo="hola "): print saludo, nombre
saludar("Mariano", saludo="Buenos días ")
Funciones: argumentosLista de argumentos por posición (*)Diccionario de argumentos (**)
def funcion(*args,**kwargs): "Esta función hace..." print "primer argumento", args[0] print "argumento 'xyz'", kwargs['xyz']
def saludar(*arg, **kwargs): print kwargs['saludo'], arg[0]
saludar("Mariano", saludo="Buenos días ")
Funciones: argumentosSegún el tipo de datos:
Inmutables: no se modifican ("por valor")Mutables: se modifican externamente ("por referencia"), por ej. listas y diccionarios
def agregar(a, b): a.append(b)
>>> x = [1, 2]>>> agregar(x, 3)>>> x[1, 2, 3]
Funciones: ámbitos (espacio de nombres)local: dentro de la funciónglobal: fuera de la función
cont = 0def prueba(): "Esta función suma 1 a cont" global cont # variable glbal incremento = 1 # variable local cont = cont + incremento
prueba()
Funciones: generadoresyield: devuelven un valor, manteniendo el estado interno de la función
def fibonacci(limite): a, b = 0, 1 while b < limite: yield b a, b = b, a+b
>>> fibonacci(10)<generator object at 0x00D79558>>>> for i in fibonacci(10):>>> print i
Funciones: GeneradoresDefinición por comprensión: crea un generador que aplica una expresión (cálculo) a los elementos de otro iterable que cumplan una determinada condición:
(expresión for variables in iterable if condición)
>>> vec = [2, 4, 6]>>> g = (3*x for x in vec)>>> g<generator object at 0x00E10378>>>> list(g)[6, 12, 18]
Funciones anonimas: lambdaFunicones "de una línea" anónimasPueden recibir argumentos y devuelven un valor (o None)No pueden tener instrucciones ni bloques (print, if, while, for, etc.)
funcion = lambda argumento: argumento+1
Clases y ObjetosEncapsulan datos y comportamientoSe definen con classSe instancian llamándolosLos métodos reciben la instancia implícita: selfLas clases se ejecutan!
class MiClase: atributo_de_clase = 123 def __init__(self, valor): # constructor self.atributo_de_instancia = valor
mi_objeto = MiClase(567) # creo la instancia
Clases y Objetos: herencia y mixinsPermiten reutilizar datos y comportamiento de as clases basesEs posible heredar de múltiples clases
class ClaseBase: atributo_de_clase = 123
class ClaseMostrar: def mostrar(self): print self.atributo_de_clase
class MiClase(ClaseBase, ClaseMostrar): pass
Clases y Objetos: atributos y métodosLos métodos pueden ser estáticos, de clase o de instanciaLos atributos pueden ser de clase o de instancia
class MiClase: @staticmethod def estatico(): # no recibo clase/inst. print "hola!"
atributo_de_clase = 1234 @classmethod def de_clase(clase): # recibo la clase! print clase.atributo_de_clase
Clases y Objetos: propiedadesPermiten controlar el comportamiento de atributos
class MiClase: def obtener(self): return self.x
def establecer(self, y): self.x = y + 1
propiedad = property(obtener, establecer)
ExcepcionesCondiciones de error, advertencias, etc.Se lanzan con raise
try: bloque a probarexcept tipo de exepcion, instancia: bloque si ocurre la excepciónelse: bloque si no ocurre excepciónfinally: bloque que se ejecuta indistintamente
Excepciones del Usuario:Derivan de Exception o clases hijas
class MiExcepcion(Exception): def __init__(self, mensaje): self.mensaje = mensaje
try: raise MiExcepcion("hola!")except MiExcepcion as e: print e.mensaje
Módulos, paquetes y espacio de nombresAgrupan código y datosMódulos: archivos individualesPaquetes: directoriosSe accede importandolos: import
import os.path
print os.path.join("C:/","Python2.5")
ArchivosSe abren utilizando open(ruta, modo, buffer)Modos: r (lectura), w (escritura), 'a' (agregar), b (binario), 'U' (salto de linea "universal")Buffer: 0 (sin buffer), 1 (una linea), o tamañoUtilizar with para asegurarse cerrar el archivo
with open("prueba.txt", "r") as archivo: for linea in archivo: print linea
Archivos: métodosread(cantidad): leer una cadena del archivowrite(str): escribir la cadena en el archivoflush(): grabar inmediatamente al discoclose(): cerrar el archivo
archivo = open("prueba.bin","wb")archivo.write("hola") # escribe "hola"archivo.flush() archivo.close()
Documentación y Ayuda
Documentación Oficial: http://docs.python.org/Libro Python para todosPython Argentina: Aprendiendo Python