curso python basico

Python Básico.

Modos de uso de Python.

Interactivo: Cuando se le dan las ordenes directamente al interprete, por medio de la linea de comandos. Para iniciar este modo en los diferentes sistemas operativos:
```
# Unix/Linux
$python             

#o también

python%            

# Windows/DOS 

C:>python
```

Script: Se escribe en un archivo plano (con extensión .py), cuales son las instrucciones que python debe de seguir, y estas se ejecutan en el momento en el que el script sea llamado. Ejemplo:
```
# Unix/Linux
$python  script.py          
#tambiién
python% script.py           


# Windows/DOS
C:>python script.py
```

Indentación en python

La indentación en python es obligatoria. El número de espacios es variable, pero debe de conservarse la cantidad en cada bloque de código. Ejemplo: En el primer ejemplo hay dos bloques con diferente indentación, sin embargo no hay error. en el segundo ejemplo si se genera un error.

Ejemplo 1

if True:
    print ("True")
else:
  print ("False")

Ejemplo 2

if True:
    print ("caso 2")
    print ("True")
else:
    print ("caso 2")
  print ("False")

Comentarios en python

Usando un símbolo numeral (#) antes de determinado texto, hace que el interprete ignore dicho texto.

#!/usr/bin/python3
# Comentario
print ("Hola mundo!") # comentario dos

Útil: Esperar por el usuario.

Algunas veces (sobre todo en el modo script) se quiere que el programa no se cierre inmediatamente termine la ejecución, una manera de hacer esto es con la siguiente linea de código:

input("\n\n Presione cualquier tecla para terminar")

Asignación de variables

En python no se necesita declarar explícitamente las variables, la declaración se lleva a cabo en el momento de la asignación.
Ejemplo:

entero = 100              # Asignación de un entero
flotante = 1000.0       # Asignación de un punto flotante
cadena    = "Juan"       # asignación de una cadena de caracteres

print (entero)
print (flotante)
print (cadena)

Tipos básicos de variables

Los tipos de almacenar la información en memoria es muy variada. Comenzaremos con los tipos básicos

Números

Los diferentes tipos de números, se separan por la memoria necesaria para guardar dicho número.

int

Los tipos int almacenan números enteros.

var1 = 1
var2 = 10
var3 = -1

float

Los tipo float o punto flotante, almacenan números reales.

var1=0.1
var2=1.0
var3=32.3e18
var4=70.2E-12

complex

Los tipo complex almacenan números complejos

a=4.53e-7j

Strings

...page...

Funciones

Una función es un bloque de código que se piensa de manera que se pueda reutilizar muchas veces mas. Las funciones son la base de la programación modular

Definir una función en Python 3

Se comienza por la palabra reservada def seguida por el nombre de la funcion y entre parentecis los argumentos (si tiene) separados por comas (si aplica).
La primera parte del bloque se sugiere que sea la ayuda de la función, entre comillas dobles. Esto es una descripción breve de que es lo que hace la función, y de los parámetros que recibe.
No se debe de olvidar la indentación y los dos puntos luego del nombre y los parámetros.
El argumento return sirve para retornar un valor al programa que llama a la función, y es opcional(retur None).
- Ejemplo:
```
def printstr( str ):
   "Imprime la cadena de caracteres que se le pase"
   print (str)
   return
```

Llamando una función en python 3

Cuando se define la función, se le da un nombre, se le asignan los parámetros que va a usar, y se estructura su funcionamiento. En el momento en que se llama dicha función dentro del código es que ésta se ejecuta.

Ejemplo:

# La función se define acá
def Multip( x=0,y=0 ):
   """Se le pasan dos argumentos numéricos, x e y; y la función devuelve su producto y=0 y x=0 por defecto. 
Ejemplo: Multip(1,3)"""
   
   return (x*y)


# En este punto se llama a la función
Multip(3,4)

Paso por referencia

Todas las variables en python se pasan por referencia, luego si una variable se pone como argumento en una función, ésta podrá modificar el valor de dicha variable de manera interna.

Ejemplo:

# Definición de la función
def Duplica( lista ):
   "Función que duplica los valores de una lista dada"
   print ("Valores fuera de la función ", lista)
   for i in range(len(lista))::
     lista[i]=2*lista[i]
   print ("Valores dentro de la función: ", lista)
   return

# Ahora se llama a la función Duplica 
mi_lista = [10,20,30]
Duplica( mi_lista )
print ("Valores fuera de la función: ", mi_lista)

Argumentos de las funciones

Se construir funciones con diferentes tipos de argumentos.

Argumentos obligatorios.
Argumentos keyword.
Argumentos por defecto.
Argumentos de longitud variable.

Argumentos obligatorios

Son los argumentos que deben de ser pasados a la función en número y orden estricto, porque de otro modo saldrá un error de sintaxis.

Ejemplo:

def Cuenta( str ):
    "Cuenta el número de letras que tiene una cadena de caracteres y las imprime en orden"

    print ("Tamaño: ",len(str))
    n=1  
    for i in str:
        print(n,": ",i)
    return
    # ahora se llama la función
    Cuenta('Camilo')
    Cuenta()

Al ejecutar este código se tiene la siguiente salida

Cuenta()
Traceback (most recent call last):

  File "<ipython-input-5-4da5406c0b55>", line 1, in <module>
    Cuenta()

TypeError: Cuenta() missing 1 required positional argument: 'str'

Argumentos llave

Estos argumentos están relacionados con la llamada de la función. Esto permite usar algunos de los argumentos, y ponerlos en orden diferente del de la definición.

Ejemplo:

# Definición de la función
def printinfo( nombre, edad ):
   "Imprime lo que se le pase"
   print ("Nombre: ", nombre)
   print ("Age ", edad)
   return;

# Se llama la función, con el orden de las entradas trocadas, pero bien identificadas con la llave.
printinfo( edad=32, nombre="camilo" )

Argumentos por defecto

Son argumentos que tienen un valor asignado desde la definición de la función

Ejemplo:

# Definición de la función
def printinfo( nombre, edad, *sexo ):
    "Imprime lo que se le pase"
    print ("Nombre: ", nombre)
    print ("Age ", edad)
    return;
# Se llama la función
printinfo( edad=32, nombre="camilo" )

Argumentos de longitud variable

Hay ocasiones donde una función puede necesitar mas argumentos de los que se declaran en la definición.

Ejemplo:

# Definición de la función
def Suma( arg1=0, arg2=0 , *vartuple ):
   "Suma todas los argumentos"
   suma=arg1 + arg2
   
   for var in vartuple:
      suma=suma+var
   return suma

# Aqui se usa la función Suma
Suma( 10, 12 )
Suma( 70, 60, 50 )

La palabra reservada return

Esta palabra se usa para terminar una función, de forma opcional se pude pasar una expresión al programa que hace el llamado (return Expresión)

Alcance (scope) de las variables

No todas las variables pueden utilizar (leer, escribir), desde cualquier punto del programa. El alcance de las variables es desde donde o en donde es accesible por el programa, y depende de en que punto de éste fue declarada.
Dependiendo del alcance se puede clasificar las variables (de python) en dos tipos:

Globales: Son las que se pueden ver en el cuerpo del programa o script.

Locales:Son las variables definidas dentro de una función, y a menos que se especifique lo contrario, no pueden ser vistas (leída o escrita) desde fuera de dicha función.
Ejemplo:

# Definición de la función
def sum( arg1, arg2 ):
   # Suma los argumentos arg1 y arg2, imprime el valor de total(local), y entrega total."
   total = arg1 + arg2
   print ("Total Local : ", total)
   return total

#Llamado de la función
total=4
print('total Global:', total)
sum(3,4)
print('total Global:', total)

Ejercicios:

...page...

Módulos en python

Un modulo es un archivo que contiene variables, funciones, clases, objetos e incluso programas principales, que permiten organizar el código de un programa de una manera más inteligible.

Ejemplo: En un archivo llamado new_func.py, está la siguiente definición de función

def Multi( arg1=0, arg2=0 , *vartuple ):
   "Multiplica todos los argumentos"
   produc=arg1*arg2
 
   for var in vartuple:
      produc=produc*var
   return produc

La palabra reservada import

Se puede usar cualquier código hecho en python como módulo, haciendo un import desde otro código, script o programa en pyton. esto es import modulo.

Cuando el interprete se encuentra la palabra import, importa dicho modulo o módulos desde los directorios de búsqueda por defecto.

Ejemplo: Si se tiene el archivo func.py donde está definida la función Multi, esta se puede importar desde otro script, para ser usada

# Se importa el modulo new_func
import new_func

# Ahora se puede usar el código dentro de ese módulo en el nuevo programa
new_func.Multi(2,3,4,5,6)

La palabra reservada from...import

Esta expresión es usada cuando de determinado módulo solo se necesita algunas de los elementos que contiene.

Ejemplo: En el módulo new_func está la función fibo, dicha función recibe un entero n, y entrega una lista con los números de la serie de Fibonacci menores que n. Se quiere hacer un programa que sume los números Fibonacci menores que el número 100. Ahora new_func.py luce así:

def Multi( arg1=0, arg2=0 , *vartuple ):
    "Multiplica todos los argumentos"
    produc=arg1*arg2

    for var in vartuple:
       produc=produc*var
    
    return produc
    
    
def fib(n):
    "Recibe un entero n, y entrega una lista con los números de fibonacci menores que n"
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result

y el script que resuelve el problema es

from new_func import fib #Se importa la función fib desde el modulo new_func

serie=fib(100)  #La variable serie se llena con la serie de fibonacci hasta antes de 100

sum=0
for i in a:
     sum=sum+i

print('la suma de los números de Fibonacci menores que 100 es:',sum)

Hay que notar que al usar "from...import" no se importa ningún otro item (objeto, variable, función...) desde el módulo new_func, y también hay que tener en cuenta que la función "fibo" se llama directamente y no por medio del operador "."(punto).

La palabra reservada from...import*

Otro uso de "from...import" es el de importar todos los elementos de determinado módulo. Si se usa de esta manera, todos los elementos del módulo se van a cargar al programa y se podrán llamar directamente.

Ejemplo: El archivo new_func.py

def Multi( arg1=0, arg2=0 , *vartuple ):
    "Multiplica todos los argumentos"
    produc=arg1*arg2

    for var in vartuple:
       produc=produc*var
    
    return produc
    
    
def fib(n):
    "Recibe un entero n, y entrega una lista con los números de fibonacci menores que n"
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result
    

def SumLis(list):
    sum=0
    for i in list:
        sum=sum + i
        
    return sum

Y el código que resuelve el problema del ejemplo anterior es:

#Importo el módulo
from new_func import *

a=fib(100)   #Se le asigna a "a" una lista con los números de fibonacci menores que 100.

b=SumLis(a)   #Uso la función SumLis para sumar las componentes de la lista a, y se las asigno a b

print("La suma es:" , b)

Ejecutar módulos como un script

Si un código se ejecuta como un modulo, el nombre de este está disponible en la variable global __name__ . Pero si este se ejecuta directamente entonces ésta variable tendrá el valor __name__ = "__main__" . Así si se quiere que el módulo ejecute algunas acciones al ser llamado como script, entonces se ponen dichas acciones después de un condicional.

Ejemplo: Anexamos algunas lineas a new_func.py para que al ser llamado como programa, ejecute unas acciones mas.

def Multi( arg1=0, arg2=0 , *vartuple ):
    "Multiplica todos los argumentos"
    produc=arg1*arg2

    for var in vartuple:
       produc=produc*var
    
    return produc
    
    
def fib(n):
    "Recibe un entero n, y entrega una lista con los números de fibonacci menores que n"
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result
    

def SumLis(list):
    sum=0
    for i in list:
        sum=sum + i
        
    return sum
    
    
if __name__ == "__main__":
    a=fib(200)
    print('Serie de Fibonacci hasta el termino exactamente menor que 200: ',a)
    b=SumLis(a)
    print('Suma de los términos de esta serie: ',b)

La variable PYTHONPATH

PYTHONPATH variable de ambiente, que consiste de una lista de directorios, que es donde python busca los modulos que se le piden importar.

El PYTHONPATH para Windows:

set PYTHONPATH=c:\python34\lib;

Y PYTHONPATH para UNIX:

set PYTHONPATH=/usr/local/lib/python

...page...

Entrada, Salida y Archivos.

En ésta parte del curso, miraremos en detalle las maneras en que el usuario interaccionar con el programa o script.

Imprimir en pantalla

La manera mas sencilla de obtener una salida desde la pantalla, es por medio del comando print, como ya lo habíamos mencionado anteriormente no nos detendremos mucho en el.

Ejemplo:

#Para python 2.7
print "esto es un ejemplo del uso de print"


#Para python 3
print("esto es un ejemplo del uso de print")

Leer desde el teclado

Una característica muy útil de python, es que puede pedir al usuario que introduzca cierta información por medio del teclado. Python tiene un comando para leer datos desde la entrada estándar (casi siempre teclado). El comando input(), imprime la cadena de caracteres que se ponga dentro de los paréntesis, luego recibe datos desde la entrada estándar, y se los entrega (generalmente se asigna a una variable).

Ejemplo:
```
#Pregunto al usuario su nombre, y lo guardo en la variable Nom.
Nom=input('¿Cual es tu nombre? ')
#Utilizo la variable Nom
print('Gusto en conocerte ',Nom)
```
Nota: Para la función input todo entra como cadenas de caracteres, luego si la entrada se va a usar como otra cosa (i.e. float, ent, etc.) se debe de debe de hacer una conversión o cast.

Abrir y cerrar archivos

Python maneja los archivos como objetos file, dichos objetos cuando son creados, se manipulan utilizando el operador ".".

La función open

Antes de realizar cualquier operación sobre un archivo, lo primero que se debe de hacer abrir dicho archivo. La función open crea un objeto tipo file, que se usa para llamar los métodos asociados a un archivo.

Sintaxis

objecto_file = open(nombre_archivo [, modo_uso][, buffering])

objecto_file: Nombre de la variable que va a guardar el objeto tipo file.
nombre_archivo: Nombre del archivo que se va a abrir.

modo_uso: Cual es el uso que se le va a dar a dicho archivo.

r	Abre el archivo en modo "solo lectura", situá el puntero al inicio del archivo
rb	Abre el archivo en modo "solo lectura binaria", situá el puntero al inicio del archivo
r+	Abre el archivo en modo "lectura y escritura", situá el puntero al inicio del archivo
rb+	Abre el archivo en modo "lectura y escritura binario", situá el puntero al inicio del archivo
w	Abre el archivo en modo "solo escritura", sobre escribe el archivo si existe, y sino crea uno nuevo
wb	Abre el archivo en modo "solo escritura binario", sobre escribe el archivo si existe, y sino crea uno nuevo
w+	Abre el archivo en modo "lectura y escritura", sobre escribe el archivo si existe, y sino crea uno nuevo
wb+	Abre el archivo en modo "lectura y escritura binaria", sobre escribe el archivo si existe, y sino crea uno nuevo
a	Abre el archivo en modo "solo append", situá el puntero al final del archivo, y sino existe crea uno nuevo
ab	Abre el archivo en modo "solo append", situá el puntero al final del archivo, y sino existe crea uno nuevo
a+	Abre el archivo en modo "append Y lectura", situá el puntero al final del archivo, y sino existe crea uno nuevo
ab+	Abre el archivo en modo "append Y lectura binario", situá el puntero al final del archivo, y sino existe crea uno nuevo

buffering: Uso de memoria temporal. Si se fija en 0 (cero) no hay buffering, si se pone en 1 (uno) se guarda de a una linea en la memoria temporal, mientras se accede al archivo. Para un entero mayor a uno, se lleva a cabo ese número de lineas de buffering, y para enteros negativos, el buffering se hace según el sistema (comportamiento por defecto.).

Atributos del objeto file

Una vez se crea un objeto file, se puede usar el operador"." para acceder a sus diferentes propiedades

Ejemplo:

# Abro el archivo resultados.txt, en modo escritura binario, y se lo asigno a la variable archivo1
archivo1 = open("resultados.txt", "wb")
print ("Nombre del archivo: ", archivo1.name)
print ("¿Está cerrado? : ", archivo1.closed)
print ("Modo de apertura : ", archivo1.mode)
archivo1.close()

Método close()

El método close() de un objeto file, bota toda la información que no se ha escrito, y cierra el archivo. Luego de usar close() no se puede leer o escribir el archivo.

Método write()

El método write() escribe cualquier cadena de caracteres en el archivo abierto. Las cadenas de caracteres en python no solo pueden guardar texto, también binarios.

Ejemplo: Modifico un poco el ejemplo anterior

#Pregunto al usuario su nombre, y lo guardo en la variable Nom.
Nom=input('¿Cual es tu nombre? ')
# Abro el archivo resultados.txt, en modo escritura, y se lo asigno a la variable archivo1
archivo1 = open("resultados.txt", "w")
print ("Nombre del archivo: ", archivo1.name)
print ("¿Está cerrado? : ", archivo1.closed)
print ("Modo de apertura : ", archivo1.mode)
archivo1.write("Nombre\n") #Escribe la cadena de caracteres "Nombre", y \n es un salto de linea
archivo1.write(Nom) #Escribe la cadena de caracteres guardada en la variable Nom
archivo1.write("\n") #Escribe un salto de linea
archivo1.close()
print ("¿Está cerrado? : ", archivo1.closed)

Nota: Para obtener el directorio de trabajo, se usa os.getcwd() de la librería os.

Método read()

Lee una cadena de caracteres desde un archivo abierto. Python también lee archivos binarios.

Ejemplo:

# Abro el archivo en modo lectura y escritura y lo asigno a la variable Archivo2 
Archivo2 = open("resultados.txt", "r+")
str = Archivo2.read(10) #leo 10 bytes del archivo
print ("los primeros 10 bytes del archivo:  ", str) 
# Cierro el archivo
Archivo2.close()

Posición dentro del archivo

El método tell()

tell() dice cual es la posición actual dentro del archivo.

posicion = obj_file.tell()

El método seek(offset , ref)

offset: número de posiciones que se moverá el puntero.
ref: Desde que posición de referencia
- 0: Desde el inicio del archivo.
- 1: Desde la posición actual.
- 2: Desde el final del archivo.

Ejemplo:

# Abre el archivo 
arch = open("resultados.txt", "r+")
str = arch.read(6)
print ("Los primeros 6 bytes : ", str)

# Mira la posición actual
pos = arch.tell()
print ("posición actual : ", pos)
str2 =arch.read()
apell= input('Apellido: \n')
arch.write(apell)
# Devuelvo el puntero hasta el inicio
pos = arch.seek(0, 0)
str = arch.read()
print ("Todo el archivo completo desde el inicio : \n", str)
# Cierro
arch.close()

Sistema de archivos desde python

El módulo os tiene todas las utilidades para realizar la administración de archivos desde python.

Renombrado de archivos

os.rename(nombre_actual, nuevo_nombre)

Ejemplo:

# Cambio el nombre de resultados.txt a resultado.txt
os.rename( "resultados.txt", "resultado.txt" )

Borrado de archivos

También se puede usar el módulo os para borrar archivos en el sistema operativo.

os.remove(nombre_archivo)

Directorios (carpetas)

Python por medio del módulo os puede crear directorios, borrarlos y moverse entre ellos.

mkdir(): Crea un directorio con el nombre que se le ponga entre los paréntesis.
```
os.mkdir("nuevodir")
```

chdir(): Cambia de directorio, el argumento es el nombre del directorio destino.
Ejemplo:
```
import os

# cambiando de directorio a "/home/nuevodir"
os.chdir("/home/nuevodir")
```

getcwd(): Informa cual es el directorio actual
```
os.getcwd()
```

rmdir(): Borra el directorio cuyo nombre es puesto como argumento.
```
os.rmdir('nombre_dir')
```

...page...

Excepciones en Python

...page...

Clases y Objetos

Python es un lenguaje orientado a objetos, luego la manera más útil de programar en python, es usar este paradigma.

Terminología

Lo primero se debe de tener claro, es a que nos referimos cuando hablamos de , clase, objeto, herencia ...

Clases: Es el prototipo de un objeto, con la definición sus atributos y métodos.
Atributos: Son el conjunto de variables definidas para una clase de objetos (internos).
Métodos: Son el conjunto de funciones definidas para una clase de objetos (internos)
Miembros de la Clase: Son tanto los métodos como los atributos.
Herencia: La transferencia de características de una clase a otra derivada de ella
Instancia: Se llama instancia un objeto creado a partir de una clase.
Instanciación: La creación de un objeto.
Objeto: Una estructura única que es definida por su clase, un objeto es el conjunto de atributos y métodos.
Operador sobrecargado: Cuando se le asigna a un operador mas de una función.

Creando Clases

Para crear una clase, se utiliza la palabra reservada class, seguida del nombre de la clase y al final dos puntos(como todo en python)

Sintaxis:

class Nombre_Clase:
   'Documentación de la clase, tal cual las funciones'
   Componentes_de_la_clase

Ejemplo:

class Estudiante:
   'Cosas comunes a todo estudiante'
   Numero_Estudiantes = 0

   def __init__(self, nombre, nivel):
      self.nombre = nombre
      self.nivel = nivel
      Estudiante.Numero_Estudiantes += 1
   
   def  display_NE(self):
     print ('Numero de estudiantes:', self.Numero_Estudiantes)

   def display_Estudiante(self):
      print ('Nombre:', self.nombre,  ", Nivel: ", self.nivel)

En ésta clase se pueden ver ejemplos de atributos (Numero_Estudiantes, nombre, nivel), de variables de clase (Numero_Estudiantes) que son compartidas por todas las instancias de la clase, y de atributos de la clase (init, display_NE,display_Estudiante).

NOTAS:

El método __init__ es especial llamado método constructor, y tiene como función la iniciación de los objetos, pertenecientes a la clase.
Todas los métodos deben de ser creados con una variable self como primera entrada, ésta variable no se usa cuando se llaman dichos métodos.

Instanciando un Objeto

Para crear una instancia de una clase

#Creemos el primer objeto estudiante, llamado Camilo en el nivel 10.

estu1=Estudiante("Camilo",10)

#Esto instancia un segundo objeto estudiante, llamado Alfredo en el nivel 1.

estu2=Estudiante("Alfredo",1)

Utilizando Atributos

Se puede acceder a los atributos de los objetos de una clase, a través del operador punto "."

Ejemplo:

class Estudiante:
   'Cosas comunes a todo estudiante'
   Numero_Estudiantes = 0
 
   def __init__(self, nombre, nivel):
      self.nombre = nombre
      self.nivel = nivel
      Estudiante.Numero_Estudiantes += 1
 
   def  display_NE(self):
     print ('Numero de estudiantes:', self.Numero_Estudiantes)
 
   def display_Estudiante(self):
      print ('Nombre:', self.nombre,  ", Nivel: ", self.nivel)


#Creemos el primer objeto estudiante, llamado Camilo en el nivel 10.
estu1=Estudiante("Camilo",10)
#Esto instancia un segundo objeto estudiante, llamado Alfredo en el nivel 1.
estu2=Estudiante("Alfredo",1)

print("Número de estudiantes: ", estu1.Numero_Estudiantes)
print("Número de estudiantes: ", estu2.Numero_Estudiantes)
estu1.display_Estudiante()
estu2.display_Estudiante()
estu1.display_NE()
estu2.display_NE()

Atributos por defecto

Cada clase que se crea en python tiene los siguientes atributos

__name__ : Contiene el nombre de la clase
__module__ : Contiene el nombre del módulo del cual la clase fue cargada, si el valor es text main , es porque se está corriendo desde el modo interactivo.
__doc__ : Documentación.
__bases__ : Una tupla que contiene(si hay) en orden de ocurrencia, las clases de las cuales hereda.
__dict__ : Diccionario, que contiene el espacio de nombres de la clase.

Ejemplo:

print ("Employee.__doc__:", Employee.__doc__)
print ("Estudiante.__name__:", estu1.__name__)
print ("Estudiante.__module__:", estu1.__module__)
print ("Estudiante.__bases__:", estu1.__bases__)
print ("Estudiante.__dict__:", estu1.__dict__ )
print ("Estudiante.__dict__:", estu2.__dict__ )

Destruyendo Objetos

Python tiene un proceso llamado "Grabage Collection", y lo que hace es borrar los objetos automáticamente para liberar memoria. Este colector de basura se ejecuta mientras el programa corre, y es alertado cuando el contador de referencia de un objeto llega a cero.
El contador de referencia de un objeto, incrementa cuando se le asigna un nuevo nombre, o se pone dentro de un contenedor (tupla, lista, diccionario u otro objeto). El contador de referencia disminuye cuando el objeto es borrado, o cuando se reasigna la referencia a otro elemento o sale de alcance.

Ejemplo:

a = 40     # Se crea un objeto <40>
b = a      # Aumenta el contador de referencia <40> 
c = [b]    # Aumenta el contador de referencia <40>  

del a       # Disminuye el contador de referencia <40> 
b = 100     # Disminuye el contador de referencia <40>  
c[0] = -1   # Disminuye el contador de referencia <40>

Es recomendable no dejar al garbage collector la liberación de la memoria de los objetos creados, lo que se suele hacer es adicionar un método __del__() con el fin de que sea el encargado de eliminar el objeto.

Ejemplo:

class Punto:
   def __init( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print (class_name, "destruido")

pt1 = Punto()
pt2 = pt1
pt3 = pt1
print (id(pt1), id(pt2), id(pt3)) # Ésto imprime las referencias
del pt1
del pt2
del pt3

Herencia

Una de las características mas relevantes de la orientación a objetos, es la capacidad de reutilizar código usando la herencia, ésto se hace listando las clases de las que va a heredar en paréntesis luego del nombre y antes de los dos puntos.

Sintaxis:

class Nombre_clase_hija (Clase_madre1[, Clase_madre2, ...]):
   'Documentaciión'
   Cuerpo_Sub_Clase

Ejemplo:

class Padre:        # Clase Padre
    def mi_Metodo(self):
      print ('Llamada al método mi_Metodo del padre')
 
class Hijo(Padre): # Clase hija
    def mi_Metodo(self):
      print ('Llamada al método mi_Metodo del hijo')

p=Padre
h=Hijo
p.mi_Metodo(p)
h.mi_Metodo(h)

Sobrecarga de Operadores y Métodos

Cuando adquirimos la habilidad de crear nuestros propios objetos, bien sea desde cero o con herencia, hay que tener en cuenta que posiblemente muchos de los operadores y métodos que estamos acostumbrados a usar, pueden no funcionar bien sobre nuestros nuevos objetos.

Métodos de base que se pueden sobre cargados.

Los métodos a continuación son métodos que existen en todas las clases de python por defecto, y pueden ser sobrecargados.

__init__ ( self [,args...] ) : Es el método constructor, y es lo primero que se ejecuta al instanciar una clase.
__del__( self ) : El método destructor, y siempre se ejecuta cuando se borra un objeto, o cuando es colectado por el garbage colector.
__cmp__( self ) : El método para comparar dos objetos.

Sobrecarga de Operadores

Cuando se definen nuevos objetos, es normal que uno quiera utilizar los operadores que tienen una interpretación natural.
Algunos de los operadores que podemos sobrecargar son la suma (+), la resta (-), multiplicación (*)

__add__(self, other) : Suma
__sub__(self, other) : Resta
__mul__(self, other) : Multiplicación.
__getitem__(self,index) : operador [].
__eq__(self, other) : operador ==.
__ne__(self, other) : operador !=.
__lt__(self, other) : operador < .
__gt__(self, other) : operador > .

Ejemplo:

class Vector:
    '''Es una clase vector de ejemplo'''
    def __init__(self, x0=0,y0=0,z0=0):
        self.x=x0
        self.y=y0
        self.z=z0
        
    def __add__(self,other):
        return Vector(self.x + other.x, self.y + other.y, self.z + other.z)
           
    def __sub__(self,other):
        return Vector(self.x - other.x, self.y - other.y, self.z - other.z)

...page...

Gratificando con Matplotlib

Generalidades de Matplotlib

Para ésta parte vamos a usar una terminal de Python (no de iPython que es la que generalmente usamos)

Cargando la librería en el entorno.

Cuando se va a usar la librería se debe de cargar en el entorno (como ya se vio anteriormente)

import matplotlib.pyplot as plt

Las dos zonas principales donde se dibujaran o sobre las que se interactuará serán:

figure: Es una instancia de matplotlib.figure.Figure. Y es la ventana donde irá el o los gráficos en sí.
Sintaxis:
```
import matplotlib.pyplot as plt


plt.figure #Se debe de tener en cuenta que ptl en este caso traduce matplotlib
```
axes:: Es una instancia de matplotlib.axes.Axes, que es el gráfico en sí donde se dibujará todo lo que le digamos y está localizada dentro de una figure
Sintaxis:
```
import matplotlib.pyplot as plt


plt.axes #Se debe de tener en cuenta que ptl en este caso traduce matplotlib
```

Ventanas, y configuración de sesión.

Lo primero que se va a necesitar es que la sesión esté en modo interactivo, esto es: que cada que se realice un cambio en ésta, se muestre automáticamente.

plt.isinteractive()

cuando ejecute esta linea la respuesta es false entonces tiene el modo interactivo desactivado. Para cambiar de modo interactivo de a activo se usa plt.ion() y para regresar al modo interactivo apagado se usa plt.ioff().

Ejemplo: Ahora con el modo interactivo encendido, hagamos la primera gráfica.
```
plt.plot([1,7,3,-3,5])
```

Otras funcionalidades interesantes son las que provee, las funciones asociadas plt, hold() y ishold(), la primera permite decidir si queremos que los gráficos se sobrescriban, que en el mismo gráfico tengamos diferentes gráficas representadas, o para que el gráfico se limpie y se dibuje la nueva gráfica cada vez. La segunda permite saber el estado de hold(). Si usamos plt.ishold() nos responderá True o False.

Ejemplo:

plt.plot(np.random.rand(10))
plt.plot(np.random.rand(10))
plt.show()

Para borrar todos los gráficos en el modo interactivo se usa plt.clf(), o plt.close() para cerrar la ventana.

También se pueden usar diferentes ventanas de gráficos al mismo tiempo. Esto se hace nombrando a cada una de las ventanas en las que vamos a trabajar cuando se llama plt.figure('nombre').

Ejemplo:

import matplotlib.pyplot as plt 
import numpy as np

plt.figure('scatter') # Crea una ventana titulada 'scatter'
plt.figure('plot') # Crea una ventana titulada 'plot'
a = np.random.rand(100) # Generamos un vector de valores aleatorios
b = np.random.rand(100) # Generamos otro vector de valores aleatorios
"""Le decimos que la ventana activa en la que vamos a dibujar es la ventana 'scatter'"""
plt.figure('scatter')
plt.scatter(a,b) # Dibujamos un scatterplot en la ventana 'scatter'
plt.figure('plot') # Ahora cambiamos a la ventana 'plot'
plt.plot(a,b)

Si no se quiere dibujar los gráficos en dos ventanas, y mas bien tener varios gráficos en la misma. Es posible hacer eso sin problemas con la ayuda de plt.subplot(). Con plt.subplot() podemos indicar el número de filas y columnas que corresponderán a como dividimos la ventana.

Ejemplo:

import matplotlib.pyplot as plt


plt.ion() # Nos ponemos en modo interactivo
# Dividimos la ventana en una fila y dos
# columnas y dibujamos el primer gráfico
plt.subplot(1,2,1)
plt.plot((1,2,3,4,5))
# Dividimos la ventana en una fila y dos
# columnas y dibujamos el segundo gráfico
plt.subplot(1,2,2)
plt.plot((5,4,3,2,1))

Actividad 1

Modificar características de las gráficas

En el siguiente script se puede ver algunas de las modificaciones que se pueden hacer en las gráficas.

import matplotlib.pyplot as plt

plt.ion() # Nos ponemos en modo interactivo
plt.figure('valores por defecto')# Creamos una ventana donde dibujamos el gráfico con la configuración por defecto
plt.suptitle('Titulo valores por defecto') # Esto sirve para poner título dentro de la ventana
plt.plot((1,2,3,4,5), label = 'por defecto') # Hacemos el plot
plt.legend(loc = 2)# Colocamos la leyenda en la esquina superior izquierda
plt.rc('lines', linewidth = 2)# A partir de aquí todas las líneas que dibujemos irán con ancho doble
plt.rc('font', size = 18)# A partir de aquí las fuentes que aparezcan en cualquier gráfico en la misma sesión tendrán mayor tamaño


plt.figure('valores modificados')
plt.suptitle('Titulo valores modificados')
plt.plot((1,2,3,4,5),
label = u'linea más ancha y letra más grande')
plt.legend(loc = 1)

Otras posibles configuraciones de la gráfica se pueden ver en la ayuda de ipython y online.

Configuración del gráfico

Con plt.axes(), que sirve para llamar y/o configurar a un crea de gráfico. Podemos definir la posición, el tamaño, el color del {rea del fondo. En el siguiente ejemplo se pueden ver algunas configuraciones.

import matplotlib.pyplot as plt
import numpy as np

plt.ion() # Ponemos la sesión como interactiva si no está
plt.axes() # Coloca un área de gráfico con los valores por defecto
# Dibuja una exponencial de 0 a 10
plt.plot(np.exp(np.linspace(0,10,100)))
# Dibuja una nueva área de gráfica colocada y con ancho y largo definido por [0.2,0.55,0.3,0.3] y con gris como color de fondo
plt.axes([0.2,0.55,0.3,0.3], axisbg = 'gray')
plt.plot(np.sin(np.linspace(0,10,100)), 'b-o', linewidth = 2)

Actividad:Modifique los valores del área e identifique que cambia cuando modifica cada número

Es posible usar plt.axes() como sustituto de plt.subplot() si se quiere dibujar gráficos que no tengan que tener una forma ‘regular’ dentro de la ventana. En este caso si se quiere borrar el área del gráfico podemos usar plt.delaxes().
También se puede hacer que no aparezca la ‘caja’ donde se dibuja el gráfico con plt.box() o si no hay ‘caja’ y queremos que aparezca podemos llamar a plt.box() y volver a hacer aparecer la ‘caja’. Otra cosa de utilidad es colocar una rejilla en el gráfico mediante plt.grid().

Nota: Se pueden hacer también axes polares con plt.axes( polar = True), rejillas para polares con plt.rgrid() y plt.thetagrids()

Matplotlib dibuja los ejes tal que se ajusten al gráfico pero si eso no es lo que nos interese en algún momento, entonces se puede hacer uso de plt.axis(). Esta Nos permite definir la longitud de los ejes, si queremos que aparezcan los mismos, si queremos que estos estén escalados,... Si solo nos interesa configurar uno de los ejes y dejar que el otro lo maneje matplotlib podemos usar plt.xlim(), plt.xscale(),plt.ylim() y plt.yscale().
Si queremos dejar el eje x o el eje y con escala logarítmica podemos usar, respectivamente, plt.semilogx() o plt.semilogy(). Podemos dibujar un segundo eje x o un segundo eje y usando plt.twinx() o plt.twiny, respectivamente.
También podemos establecer unos márgenes alrededor de los límites de los ejes usando plt.margins(). Por último, podemos etiquetar nuestros ejes con plt.xlabel() y plt.ylabel()

Ejemplo:

import numpy as np
import matplotlib.pyplot as plt

plt.ion()
plt.plot(np.arange(100), 'b') # Dibujamos una línea recta azul
plt.xlabel('Valores de x') # Ponemos etiqueta al eje x
plt.ylabel(u'Línea azul') # Ponemos etiqueta al eje y
plt.twinx() # Creamos un segundo eje y
# Dibuja una exponencial de 0 a 5 con la y representada en el
# segundo eje y
plt.plot(np.exp(np.linspace(0,5,100)), 'g')
plt.ylabel(u'Línea verde') # Ponemos etiqueta al segundo eje y
# Limitamos los valores del eje x para que vayan desde -10 a 110
plt.xlim(-10,110)

Las funciones plt.axvline() y plt.axhline() dibujan líneas verticales y horizontales en la x o en la y que le digamos mientras que plt.axvspan y plt.axhspan dibujan recuadros entre las coordenadas x o y que queramos, respectivamente.

Ejemplo:

import numpy as np
import matplotlib.pyplot as plt

plt.ion() # Ponemos el modo interactivo
# Dibujamos un scatterplot de valores aleatorios
plt.scatter(np.random.randn(1000),np.random.randn(1000))
# Dibujamos una línea vertical verde centrada en x = -0.5
plt.axvline(-0.5, color = 'g')
# Dibujamos una línea vertical verde centrada en x = 0.5
plt.axvline(0.5, color = 'g')
# Dibujamos una línea horizontal verde centrada en x = -0.5
plt.axhline(-0.5, color = 'g')
# Dibujamos una línea horizontal verde centrada en x = 0.5
plt.axhline(0.5, color = 'g')
# Dibujamos un recuadro azul vertical entre x[-0.5,0.5]
# con transparencia 0.25
plt.axvspan(-0.5,0.5, alpha = 0.25)
# Dibujamos un recuadro azul horizontal entre x[-0.5,0.5]
# con transparencia 0.25
plt.axhspan(-0.5,0.5, alpha = 0.25)

El uso del texto dentro de las gráficas se muestra en el siguiente ejemplo:

Ejemplo:

plt.ion() # Ponemos modo interactivo
import matplotlib.pyplot as plt
import numpy as np
import calendar
# Para generar el lugar del primer días de cada mes en un año
dias = [np.array(calendar.mdays)[0:i].sum()+ 1 for i in
np.arange(12)+1]
# Creamos una lista con los nombres de los meses
meses = calendar.month_name[1:13]
plt.axes([0.1,0.2,0.8,0.65])
# Creamos un plot con 365 valores
plt.plot(np.arange(1,366), np.random.rand(365), label = 'valores al azar')
plt.xlim(-5,370) # Los valores del eje y variarán entre -5 y 370
plt.ylim(0,1.2) # Los valores del eje y variarán entre 0 y 1.2
plt.legend() # Creamos la caja con la leyenda
plt.title(u'Ejemplo de título') # Ponemos un título
# Ponemos un título superior
plt.suptitle(u'Ejemplo de título superior')
# Pedimos que se vean subrrayas de división en los ejes
plt.minorticks_on()
# Colocamos las etiquetas, meses, en las posiciones, días,
# con color azul y rotadas 45o
plt.xticks(dias, meses, size = 'small', color = 'b', rotation = 45)
plt.xlabel(u't (días)')
plt.ylabel('Media diaria')

Otros tipos de gráfico son plt.plot_date(), que es similar a plt.plot() considerando uno o ambos ejes como fechas, y plt.plotfile(), que dibuja directamente desde los datos de un fichero.
Otro tipo de gráfico sería el que podemos obtener con plt.stem(). Dibuja líneas
verticales desde una línea base.

Ejemplo:

plt.ion() # Nos ponemos en modo interactivo
x = np.arange(25) + 1 # Valores de x
y = np.random.rand(25) * 10. # Valores de y
# Valores de y normalizados. Esta nueva serie tiene media 0 y desvicación estándar 1
y_norm = (y - y.mean()) / y.std()
# Colocamos los límites del eje x
plt.xlim(np.min(x) - 1, np.max(x) + 1)
# Colocamos los límites del eje y
plt.ylim(np.min(y_norm)-1, np.max(y_norm)+1)
# Dibujamos los valores por encima de la media
plt.stem(x[y_norm > 0],y_norm[y_norm > 0],linefmt='k-.',markerfmt='go',basefmt='b-') 
# Dibujamos los valores por debajo de la media
plt.stem(x[y_norm < 0],y_norm[y_norm < 0],linefmt='k-.',markerfmt='ro',basefmt='b-') 
# Colocamos el título del gráfico
plt.title(u'Representación de (x, f(x))')
plt.xlabel('valores x') # Colocamos la etiqueta en el eje x
plt.ylabel('valores f(x)') # Colocamos la etiqueta en el eje y

Actividad: Comentar el siguiente código, diciendo en cada paso que es lo que hace.

plt.ion()
x = np.arange(100) 
y = np.random.rand(100) 
plt.plot(x,y, color = 'black', label = '(x, f(x)')
plt.plot(x[y > 0.9], y[y > 0.9],'bo', label = 'f(x) > 0.9')
plt.axhspan(0.9, 1, alpha = 0.1)
plt.ylim(0,1.2)
plt.legend()
plt.title(u'Parejas ordenadas (x, f(x))')
plt.xlabel('X')
plt.ylabel('f(x)')

...page...