El Mundo de Ubuntu

Python es un lenguaje de script desarrollado por Guido van Rossum.

Podemos codificar empleando programación lineal, estructurada y orientada a objetos (tengamos en cuenta que esta última es la que se ha impuesto en la actualidad).

Se cuenta con intérpretes de Python en múltiples plataformas: Windows, Linux, Mac etc. Se pueden desarrollar aplicaciones de escritorio como aplicaciones web. Empresas como Google, Yahoo, Nasa etc. utilizan este lenguaje para sus desarrollos (actualmente el creador de Python Guido van Rossum trabaja para Google.)

Se puede ejecutar instrucciones de Python desde la línea de comando o creando archivos con extensión *.py. Cuando uno comienza a aprender este lenguaje la línea de comandos nos provee una retroalimentación del resultado en forma inmediata.

El objetivo de este tutorial es presentar en forma progresiva los conceptos fundamentales de este lenguaje y poder analizar los problemas resueltos y codificar los problemas propuestos en este mismo sitio, sin tener que instalar en un principio el Python en su equipo (o luego de instalado poder avanzar con el tutorial en cualquier máquina conectada a internet).
Los diccionarios tratados como objetos.

Habíamos visto la estructura de datos tipo diccionario que utiliza una clave para acceder a un valor. El subíndice puede ser un entero, un string etc. Un diccionario vincula una clave y un valor.
Los diccionarios en Python también son objetos y como tales tienen una serie de métodos que nos permiten administrarlos:

keys()
Retorna una lista con todas las claves del diccionario.

diccionario={'house':'casa','red':'rojo','bed':'cama','window':'ventana'}
lista=diccionario.keys()
print lista  # ['house', 'window', 'bed', 'red']

values()

Retorna una lista con todos los valores almacenados en el diccionario.

diccionario={'house':'casa','red':'rojo','bed':'cama','window':'ventana'}
lista=diccionario.values()
print lista  # ['casa', 'ventana', 'cama', 'rojo']

items()

Retorna una lista que contiene en cada nodo una tupla con la clave y valor del diccionario.

diccionario={'house':'casa','red':'rojo','bed':'cama','window':'ventana'}
lista=diccionario.items()
print lista  # [('house', 'casa'), ('window', 'ventana'), ('bed', 'cama'), ('red', 'rojo')]

pop(clave,[valor])

Extrae el valor de la clave que pasamos como parámetro y borra el elemento del diccionario. Genera un error si no se encuentra dicha clave, salvo que se inicialice un segundo parámetro que será el dato que retornará.
```
diccionario={'house':'casa','red':'rojo','bed':'cama','window':'ventana'}
valor=diccionario.pop('window')
print valor  # ventana 
print diccionario #{'house': 'casa', 'bed': 'cama', 'red': 'rojo'} 
```
Si no encuentra la clave en el diccionario y hemos indicado un segundo parámetro al método pop será dicho valor el que retorne:
```
diccionario={'house':'casa','red':'rojo','bed':'cama','window':'ventana'}
valor=diccionario.pop('love','clave no encontrada')
print valor  # clave no encontrada 
```

has_key(clave)

Retorna True si la clave se encuentra en el diccionario, False en caso contrario.

diccionario={'house':'casa','red':'rojo','bed':'cama','window':'ventana'}
if diccionario.has_key('love'):
    print 'Si tiene la clave buscada'
else:
    print 'No existe la clave buscada'

clear()

Elimina todos los elementos del diccionario.

diccionario={'house':'casa','red':'rojo','bed':'cama','window':'ventana'}
diccionario.clear()
print diccionario   # {}

copy()

Se genera una copia idéntica del diccionario actual en otra parte de memoria.

diccionario1={'house':'casa','red':'rojo','bed':'cama','window':'ventana'}
diccionario2=diccionario1.copy()
print diccionario2 #{'house': 'casa', 'window': 'ventana', 'red': 'rojo', 'bed': 'cama'}
diccionario1['house']='xxxxx'
print diccionario2 #{'house': 'casa', 'window': 'ventana', 'red': 'rojo', 'bed': 'cama'}

Es importante hacer notar que no es lo mismo:

diccionario2=diccionario1

Con la asignación anterior no se esta creando un segundo diccionario sinó se tiene dos variables que referencian al mismo objeto.

popitem()

Retorna un elemento del diccionario y lo elimina. Como no hay un sentido de orden en el diccionario se extrae uno al azar.
```
diccionario={'house':'casa','red':'rojo','bed':'cama','window':'ventana'}
elemento=diccionario.popitem()
print elemento
print diccionario
```
Para saber cual se extrajo se debe ejecutar el algoritmo.
update(diccionario2)

Modifica el diccionario actual agregando los elementos del diccionario2, si una clave está repetida se modifica su valor.

diccionario1={'uno':'1','dos':'2','tres':'3333'} diccionario2={'tres':'3','cuatro':'4','cinco':'5'} diccionario1.update(diccionario2) print diccionario1 #{'cuatro': '4', 'cinco': '5', 'dos': '2', 'tres': '3', 'uno': '1'}

Además seguimos contando con el comando del para borrar elementos del diccionario:

diccionario={'house':'casa','red':'rojo','bed':'cama','window':'ventana'}
del diccionario['house']
print diccionario #{'window': 'ventana', 'bed': 'cama', 'red': 'rojo'}

El cambio o agregado de un valor al diccionario se hace mediante la asignación:

diccionario={'house':'casa','red':'rojo','bed':'cama','window':'ventana'}
diccionario['red']='colorado'
diccionario['blue']='azul'
print diccionario # {'house': 'casa', 'window': 'ventana', 'bed': 'cama', 'red': 'colorado','blue': 'azul'}

La cantidad de elementos mediante la función len:

diccionario={'house':'casa','red':'rojo','bed':'cama','window':'ventana'}
print len(diccionario) # 4

Instalación de Python en su computadora.

Ahora a llegado el momento de instalar Python en su equipo. Debemos descargar el instalador del sitio oficial de Python.

Aquí seguiremos los pasos para instalar la versión para Windows python-2.5.2. Descarguemos la versión para el procesasor x86.

Tenemos en nuestro equipo el archivo para hacer la instalación local de Python python-2.5.2.msi. Lo ejecutamos

El primer diálogo nos pregunta si se instala solo para nosotros o para todos los usuarios del equipo (podemos dejar la opción seleccionada para todos los usuarios) y presionamos 'Next'.

El segundo formulario del wizard nos permite seleccionar la unidad donde se instala el lenguaje. Dejemos por defecto la que nos propone el instalador: c:\Python25\

El tercer paso nos permite seleccionar o suprimir distintos módulos que vienen con Python (extensiones, documentación etc.), dejaremos por defecto que instale todos.

Finalmente ya tenemos instalado el lenguaje Python en nuestro equipo.

Ahora para codificar los programas utilizaremos un editor que se instala junto con el lenguaje Python, desde el menú de opciones podemos acceder al editor llamado: IDLE.

En realidad lo primero que aparece es una ventana llamada Python Shell donde podemos ejecutar instrucciones en forma unitaria:

Por ejemplo escribamos:

print 'Hola Mundo'

Pero nuestro objetivo fundamental es la creación de programas o módulos completos en Python, para esto seleccionamos en esta ventana desde el menú de opciones File -> New Window.

Ahora sí tenemos el editor que suministra Python para codificar nuestros programas.

Escribamos una aplicación muy sencilla:

import random def mostrarnumeros(): for x in range(7): valor=random.randint(1,100) print valor mostrarnumeros()

La grabamos en nuestro disco duro (por ejemplo prueba1.py) y desde el menú de opciones seleccionamos Run -> Run Module, si hemos tipeado correctamente el programa tendremos el resultado en la ventana "Python Shell".

En los conceptos siguientes veremos temas que no pueden ser ejecutados directamente en el sitio PythonYa, por lo que tener el lenguaje Python en forma local en su equipo se hace indispensable para probarlos.

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales

Ahora que hemos introducido los conceptos básicos de objetos veamos más profundo el concepto de cadenas (string) en Python.

En Python todo es un objetos, por lo que cuando definimos una cadena estamos definiendo un objeto.
Como hemos visto toda clase tiene una serie de métodos, veremos los métodos principales que tiene la clase que en Python administra una cadena.
Los métodos:

capitalize()
Retorna otra cadena con el primer caracter en mayúsculas.
```
cadena='ana'
print cadena.capitalize() #Ana
print cadena  #ana
```
Es importante notar que no se modifica el contenido de la variable 'cadena'. El método capitalize() retorna otra cadena con el primero en mayúsculas.
upper()

Retorna otra cadena con todos los caracteres convertidos a mayúscula. cadena1='ana'
```
cadena2=cadena1.upper()
print cadena2               #ANA
```
lower()

Retorna otra cadena con todos los caracteres convertidos a minúsculas.
```
cadena1='Ana'
cadena2=cadena1.lower()
print cadena2               #ana
```

isupper()

Retorna True si todos los caracteres de la cadena están en mayúsculas.

cadena='ANA'
if cadena.isupper():
    print 'La cadena '+cadena+' esta toda en mayusculas'

islower()

Retorna True si todos los caracteres de la cadena están en minúsculas.

cadena1='ana'
if cadena.islower():
    print 'La cadena '+cadena+' esta toda en minusculas'

isdigit()

Retorna verdadero si todos los caracteres de la cadena son dígitos.
```
cadena='120'
if cadena.isdigit():
    print 'Todos los caracteres de la cadena son numeros'
```
Si al menos uno de los caracteres es distinto a un dígito retorna False. Inclusive si tiene el caracter punto.

isalpha()

Retorna True si todos los caracteres son alfabéticos.

cadena='Hola Mundo'
if cadena.isalpha():
    print 'Todos los caracteres de la cadena son del alfabeticos'
else:
    print 'No todos los caracteres de la cadena son del alfabeticos'

En el ejemplo superior ejecuta el bloque del else ya que la cadena contiene un caracter de espacio.

isspace()

Retorna verdadero si todos los caracteres de la cadena son espacios en blanco

cadena='   '
if cadena.isspace():
    print 'Todos los caracteres de la cadena son espacios en blanco'

isalnum()

Retorna True si todos los caracteres de la cadena son números o caracteres alfabéticos.

cadena='cordoba2008'
if cadena.isalnum():
    print 'Todos los caracteres son numeros o alfabeticos'

find('cadena',[inicio],[fin])

Retorna la posición donde se encuentra el valor del primer parámetro en el string. Si no se encuentra retorna -1. Podemos indicar como segundo y tercer parámetro a partir de que posición y hasta que posición de la cadena hacer la búsqueda.
```
cadena='esto es una prueba y es solo eso'
pos=cadena.find('es')
print pos   #0
```
Retorna 0 ya que los dos primeros caracteres son la cadena 'es', es decir retorna la primera aparición del string.
```
cadena='esto es una prueba y es solo eso'
pos=cadena.find('es',5)
print pos   #5
```
En este otro ejemplo comenzamos la búsqueda a partir de la posición 5. Si no indicamos el tercer parámetro la búsqueda la hace hasta el final de la cadena
rfind('cadena',[inicio],[fin])

Igual al método find con la diferencia que la búsqueda comienza desde el final.
```
cadena='esto es una prueba y es solo eso'
pos=cadena.rfind('es')
print pos  #29
```
count('cadena',[inicio],[fin])

Retorna la cantidad de veces que la cadena se repite en el string.
```
cadena='esto es una prueba y es solo eso'
cant=cadena.count('es')
print cant   #4
```
replace('cadena1','cadena2',[maximo])

Retorna un string remplazando todas las ocurrencias de cadena1 por cadena2. Podemos eventuamente indicar la cantidad máxima de remplazos.
```
cadena1='esto es una prueba y es solo eso'
cadena2=cadena1.replace('es','ES')
print cadena2  #ESto ES una prueba y ES solo ESo 
```

split('caracter separador',[maximo])

El método split retorna una lista dividiendo el string por el caracter indicado en el primer parámetro. Podemos pasar un segundo parámetro indicando la cantidad de trozos a general, el último elemento de la lista almacena el resto del string.

cadena='esto es una prueba y es solo eso'
lista=cadena.split(' ')
print lista               #['esto', 'es', 'una', 'prueba', 'y', 'es', 'solo', 'eso']
print len(lista)          #8
lista=cadena.split(' ',2) 
print lista               #['esto', 'es', 'una prueba y es solo eso'] 
print len(lista)          #3

rsplit('caracter separador',[maximo])

Semejante a split pero procesando desde el final del string. En caso de indicar maximo el primer elemento de la lista almacena el trozo restante.

cadena='esto es una prueba y es solo eso'
lista=cadena.rsplit(' ')
print lista               #['esto', 'es', 'una', 'prueba', 'y', 'es', 'solo', 'eso']
print len(lista)          #8
lista=cadena.rsplit(' ',2) 
print lista               #['esto es una prueba y es', 'solo', 'eso'] 
print len(lista)          #3

splitlines()

Retorna una lista dividiendo el string con los retornos de carro contenidos en el mismo.

mensaje="""Primer linea
           Segunda linea
           Tercer linea
           Cuarta linea"""
lista=mensaje.splitlines()
print lista #['Primer linea', ' Segunda linea', ' Tercer linea', ' Cuarta linea']

swapcase()

Retorna un string transformando los caracteres minúsculas a mayúsculas y los mayúsculas a minúsculas.
```
cadena1='Sistema de Facturacion'
cadena2=cadena1.swapcase()
print cadena2        #sISTEMA DE fACTURACION 
```
rjust(ancho,caracter de relleno)

Retorna un string justificado a derecha y rellenando el lado izquierdo con caracteres según el segundo parámetro. La nueva cadena toma un largo indicado según el valor del primer parámetro.
```
cadena='200'
cadena2=cadena.rjust(5,'$')
print cadena2   #$$200
```
ljust(ancho,caracter de relleno)

Similar a rjust con la salvedad que se justifica a derecha el string.
```
cadena='200'
cadena2=cadena.ljust(5,'$')
print cadena2   #200$$
```

center(ancho,caracter de relleno)

El string original se centra.

cadena='200'
cadena2=cadena.center(5,'$')
print cadena2   #$200$

Las listas tratadas como objetos.

Ahora veremos más profundamente el concepto de listas en Python y los métodos que provee su clase.

Los métodos:

append(elemento)

El método append añade un elemento al final de la lista.

lista=['juan','ana','luis']
lista.append('carlos')
print lista  #['juan', 'ana', 'luis', 'carlos']

extend(elementos)

El método extend procesa la secuencia de elementos del parámetro y los añade uno a uno a la lista. La diferencia con el método append es que append siempre añade un único elemento a la lista y extend añade tantos elementos como tenga la secuencia.
```
lista=['juan','ana','luis']
lista.extend(['uno','dos'])
print lista  #['juan', 'ana', 'luis', 'uno', 'dos'] 
```
Ahora la lista tiene 5 elementos, es decir se añadieron 2 nuevas componentes a la lista.

En cambio si utilizamos append el resultado es:
```
lista=['juan','ana','luis']
lista.append(['uno','dos'])
print lista  #['juan', 'ana', 'luis', ['uno', 'dos']]  
Ahora la lista tiene cuatro elementos y el último elemento es una lista también.
```
insert(posición,elemento)

El método insert añade un elemento en la posición que le indicamos en el primer parámetro.
```
lista=['juan','ana','luis']
lista.insert(0,'carlos')
print lista  #['carlos', 'juan', 'ana', 'luis'] 
```
En este ejemplo insertamos la cadena 'carlos' al principio de la lista, ya que pasamos la posición 0, no se borra el elemento que se encuentra en la posición 0 sino se desplaza a la segunda posición.

Si indicamos una posición que no existe porque supera a la posición del último elemento se inserta al final de la lista.
pop([posicion]

El método pop si lo llamamos sin parámetro nos retorna y borra la información del último nodo de la lista. Si en cambio pasamos un entero este indica la posición del cual se debe extraer.
```
lista=['juan','ana','luis','marcos']
elemento=lista.pop()
print elemento       #marcos 
print lista          #['juan', 'ana', 'luis'] 
print lista.pop(1)   #ana
print lista          #['juan', 'luis']
```

remove(elemento)

Borra el primer nodo que coincide con la información que le pasamos como parámetro.

lista=['juan','ana','luis','marcos','ana']
lista.remove('ana')
print lista            #['juan', 'luis', 'marcos', 'ana']

count(elemento)

Retorna la cantidad de veces que se repite la información que le pasamos como parámetro.
```
lista=['juan','ana','luis','marcos','ana']
print lista.count('ana')  #2
```
index(elemento,[inicio],[fin])

Retorna la primera posición donde se encuentra el primer parámetro en la lista. Podemos eventualmente indicarle a partir de que posición empezar a buscar y en que posición terminar la búsqueda.

Si no lo encuentra en la lista genera un error: ValueError: list.index(x): x not in list
```
lista=['juan','ana','luis','marcos','ana']
print lista.index('ana') #1
```

sort()

Ordena la lista de menor a mayor.

lista=['juan','ana','luis','marcos','ana']
lista.sort()
print lista   #['ana', 'ana', 'juan', 'luis', 'marcos']

reverse()

Invierte el orden de los elementos de la lista.

lista=['juan','ana','luis','marcos','ana']
lista.reverse()
print lista    #['ana', 'marcos', 'luis', 'ana', 'juan']

Si necesitamos borrar un nodo de la lista debemos utilizar el comando del que provee Python:

lista=['juan','ana','luis','marcos']
del lista[2]
print lista #['juan', 'ana', 'marcos']

Podemos utilizar el concepto de porciones para borrar un conjunto de elementos de la lista:

Si queremos borrar los elementos de la posición 2 hasta la 3:

lista=['juan','ana','carlos','maria','pedro']
del lista[2:4]
print lista # ['juan', 'ana', 'pedro']

Si queremos borrar desde la 2 hasta el final:

lista=['juan','ana','carlos','maria','pedro']
del lista[2:]
print lista # ['juan', 'ana']

Si queremos borrar todos desde el principio hasta la posición 3 sin incluirla:

lista=['juan','ana','carlos','maria','pedro']
del lista[:3]
print lista # ['maria', 'pedro']

Si queremos ir borrando de a uno de por medio:

lista=['juan','ana','carlos','maria','pedro']
del lista[::2]
print lista # ['ana', 'maria']

Si necesitamos modificar el contenido de un nodo de la lista debemos utilizar el operador de asignación:

lista=['juan','ana','luis','marcos']
lista[2]='xxxxx'
print lista #['juan', 'ana', 'xxxxx', 'marcos']

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales

Python nos permite redefinir los operadores matemáticos cuando planteamos una clase.
Los métodos especiales que debemos implementar son los siguientes:
Para el operador +:

__add__(self,objeto2)

Para el operador -:

__sub__(self,objeto2)

Para el operador *:

__mul__(self,objeto2)

Para el operador /:

__div__(self,objeto2)

Veamos con un ejemplo la sintaxis para redefinir el operador +. Crearemos una clase Cliente de un banco y redefiniremos el operador + para que nos retorne la suma de los depósitos de los dos clientes que estamos sumando.

class Cliente:
    def __init__(self,nom,mon):
        self.nombre=nom
        self.monto=mon
    def __add__(self,objeto2):
        s=self.monto+objeto2.monto
        return s
cli1=Cliente('Ana',1200)
cli2=Cliente('Luis',1500)
print 'El total depositado es '
print cli1+cli2

Es muy importante tener en cuenta que debemos redefinir un operador matemático siempre y cuando haga nuestro programa más legible.

Debemos redefinir los operadores +,-,*,/ etc. solo para las clases que con solo leer su nombre el programador intuya que operación implementaría dicho operador.

Redefinición de los operadores relacionales con objetos.

Python también nos permite redefinir los operadores relacionales cuando planteamos una clase.

Los métodos especiales que podemos implementar son los siguientes:

Para el operador ==:

__eq__(self,objeto2)

Para el operador !=:

__ne__(self,objeto2)

Para el operador >:

__gt__(self,objeto2)

Para el operador >=:

__ge__(self,objeto2)

Para el operador <:

__lt__(self,objeto2)

Para el operador <=:

__le__(self,objeto2)

Es importante recordar que una redefinición de un operador tiene sentido si ayuda y hace más claro nuestro algoritmo.

Veamos con un ejemplo la sintaxis para redefinir todos estos operadores relacionales. Crearemos una clase Persona que tiene como atributo el nombre y la edad. El operador == retornará verdadero si las dos personas tienen la misma edad, el operador > retornará True si la edad del objeto de la izquierda tiene una edad mayor a la edad del objeto de la derecha del operador >, y así sucesivamente

class Persona:
    def __init__(self,nom,ed):
        self.nombre=nom
        self.edad=ed
    def __eq__(self,objeto2):
        if self.edad==objeto2.edad:
            return True
        else:
            return False
    def __ne__(self,objeto2):
        if self.edad!=objeto2.edad:
            return True
        else:
            return False
    def __gt__(self,objeto2):
        if self.edad>objeto2.edad:
            return True
        else:
            return False
    def __ge__(self,objeto2):
        if self.edad>=objeto2.edad:
            return True
        else:
            return False
    def __lt__(self,objeto2):
        if self.edad<objeto2.edad:
            return True
        else:
            return False
    def __le__(self,objeto2):
        if self.edad<=objeto2.edad:
            return True
        else:
            return False
per1=Persona('juan',22)
per2=Persona('ana',22)
if per1==per2:
    print 'Las dos personas tienen la misma edad.'
else:
    print 'No tienen la misma edad.'

Como pedemos observar planteamos un método por cada operdor relacional:

def __eq__(self,objeto2):
        if self.edad==objeto2.edad:
            return True
        else:
            return False

El método recibe como referencia (self) la dirección del objeto ubicado a la izquierda del operador relacionar y como parámetro (objeto2) la referencia del objeto ubicado a la derecha del operador. Solo nos queda analizar el atributo edad de cada objeto y retornar True si los dos almacenan el mismo valor, en caso contrario retornar False.

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales

Top es una herramienta que nos proporciona información de los procesos que se estan corriendo en ese momento en tiempo real con valors de uso de CPU, memoria, swap y la posibilidad de manupular procesos. Presenta una interfaz simple que cuenta con varias partes.

Para ejecutar este comando solo tenemos que colocar en la consola:

# top

Y nos vamos a encontrar con algo como esto:

Se divide en dos la interfáz entre la cabecera y la lista de procesos corriendo en ese momento. La cabecera además se divide en 5 lineas:

Primera linea: Muestra una serie de datos referidos al sistema.
- “02:51:37″: Es la hora actual de este caso
- “up 59 min”: Es el tiempo en minutos que el sistema esta corriendo en este caso
- “2 users”: Cantidad de usuarios conectados en ese momento
- “Load average”: Los numeros indican el estado de uso del CPU. Si los numeros son menores a “1″ esto quiere decir que el CPU no tiene que esperar para poder ejecutar una instruccion. Si esta por encima de “1″ quiere decir que es necesario que el CPU necesite esperar para ejecutar una instruccion. Los tres numeros muestran el average cada 5, 10 y 15 minutos respectivamente.
Segunda linea: Muestra el total de procesos corriendo y los divide por estados, “Running”, “Slepping”, “Stopped”, “Zombie”.
Tercera linea: Muestra el uso de CPU en ese momento.
- “%us”: muestra el uso de cpu del usuario
- “%sy”: muestra el uso de cpu del sistema.
- “%id”: muestra el uso de cpu disponible para utilizar.
- “%wa”: muestra en porcentaje el tiempo en espera del cpu para manejo de I/O.
Cuarta linea: Muestra valores referentes a la memoria fisica del equipo (los valores pueden ser algo enañosos).
- Tota: Es el valor total de la memoria fisica
- Used: Es el valor de la memoria utilizada
- Free: Es el valor de la memoria libre
- Buffered: Es el valor de memoria fisica que esta en el buffer de memoria.
Quinta linea: Muestra valores referentes al uso de la memoria SWAP. Es similar a la cuarta linea en cuanto a los datos que proporciona salvo por un solo cambio que al final de la linea muestra la memoria que esta cacheada.

Ahora bien, como puedo calcular la memoria libre que tengo en el sistema?. Para eso lo que tenemos que hacer es sumar una serie de valores que nos presenta el comando top. La memoria disponible es la suma del valor “buffered” en la cuarta linea y el valor cached” de la quinta linea:
Memoria RAM disponible = Cached(12964k) + Buffered(153762k)
Para averiguar cuanta memoria estan utilizando los programas:
Memoria RAM utilizada por programas = Used (1942256) – (Cached(12964k) + Buffered(153762k))
Luego, en la parte inferior de la pantalla se encuentra la lista de procesos corriendo en el sistema en orden descendente. Cada linea cuenta con los siguientes datos:

PID: Process ID del proceso
USER: Usuario que esta corriendo dicha aplicacion
PR: Prioridad del proceso
NI: Valor por el cual se establece una prioridad para el proceso
VIRT: Total de la memoria virtual usada
RES: Resident task size
SHR: Estado del proceso. S (sleeping), D (uninterruptible sleep), R (running), Z(zombies), or T (stopped or traced)
%CPU, %MEM: Porcentajes de memoria y cpu utilizados en ese momento
Time: El tiempo de uso del procesador para ese proceso
Command: El comando que esta siendo ejecutado por el Daemon

Dentro del programa podemos interactuar con el con varias opciones:

k -> Si se quiere matar el proceso, luego debemos ingresar el numero de su PID.
r -> Cambia la prioridad del proceso
O (upercase) -> Muestra las posibles columnas que podemos agregar a la lista de procesos
1 -> Muestra la información de todos los cores
z o b -> Agregan colores a la interfaz
c -> Muestra el path absoluto del binario que se esta ejecutando.
n -> nos permite reducir la lista a “n” procesos.
N (upercase) -> Ordena los procesos por PID
A (upercase) -> Ordena los procesos por aparicion, primero se encuentran los mas nuevos
P (upercase) -> Ordena los procesos por uso de CPU, esta opcion es la default
M (upercase) -> Ordena los procesos por memoria residente
T (upercase) -> Ordena los procesos por tiempo.
W (upercase) -> Guarda la configuracion que hicimos
q -> Salir de Top

Además top cuenta con una serie de switches además de las opciones anteriores:

top -u usuario -> Muestra los procesos que estan corriendo con ese usuario y sus valores
top -p PID -> muestra el proceso seleccionado y sus valores
top -n numero -> Numero es la cantidad de iteraciones que va a tener el comando y luego se cerrara
top -d numero -> “Numero” es el tiempop en segundos que va a esperar el comando para refrescar la lista.
top -b -> Batch mode, ideal para mandar resultados desde top a otros programas

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Sistema

Ps ("process status", estado de procesos en idioma inglés) es un comando asociado en el sistema operativo UNIX (estandarizado en POSIX y otros) que permite visualizar el estado de un Proceso (informática).

El comando ps muestra por pantalla un listado de los procesos que se están ejecutando en el sistema.

Si no añadimos ningún parámetro, ps mostrará los procesos del usuario con el que estamos logueados.
Generalmente en cualquier distribución de GNU/Linux se incluye la versión de ps que acepta diferentes tipos de opciones: las opciones UNIX que son precedidas por un guión (dash), las opciones BSD que no utilizan guión, y las opciones GNU largas que se preceden por dos guiones.

Estas opciones se pueden mezclar, pero a veces ocasionan conflictos o existen opciones sinónimas que producen los mismos resultados. Por ejemplo "ps -aux" muestra todos los procesos pertenecientes al usuario llamado "x", ya que no suele existir un usuario llamado "x" ps lo interpreta como el comando "ps aux" e imprime una advertencia :D

Por defecto ps sólo muestra los procesos con el mismo user id efectivo (EUID) que el del usuario que lo ejecuta. Cuando utilizamos ps con las opciones "aux" el resultado es:

a: eliminar la restricción BSD "only yourself" para agregar procesos de otros usuarios
u: utilizar el formato orientado al usuario
x: eliminar la restricción BSD "must have a tty" para agregar procesos que no tengan una tty asociada

De esta forma seleccionamos todos los procesos en el sistema y los mostramos en el formato orientado al usuario.

Captura de pantalla salida ps.
Comando
    ps [modificadores] [condición]
Donde modificadores es opcional, y puede tomar los siguientes valores:

Los siguientes modificadores no toman el parámetro condición:
    -A: Muestra todos los procesos (de todos los usuarios en el sistema).
    -a: Muestra todos los procesos de una [tty] determinada.
    -d: Muestra todo excepto los líderes de la sesión.
    -e: Muestra todos los procesos (equivalente a -A).
    T: Muestra todos los procesos de la terminal actual.
    a: Muestra todos los procesos de la terminal actual incluyendo los de otros usuarios.
    g: Muestra todos los procesos incluyendo grupos líderes (obsoleta excepto en sunOs).
    r: Muestra solamente los procesos corriendo.
    x: Muestra los procesos en un estilo BSD (sin controlar la [TTY]).

Los siguientes modificadores toman el parámetro condición:
    -N: Muestra todos los procesos excepto los que encajan con la condición (equivalente a --deselect).
    -C: Muestra los procesos que tienen como nombre la condición.
    -G: Muestra los procesos que tienen como grupo (nombre de grupo o id) la condición.
    -P: Muestra los procesos que tienen como [Identificador de proceso] la condición.
    -S: Muestra los procesos que tienen como sesión la condición.
    -U: Muestra los procesos que tienen como usuario (nombre de grupo o id) la condición.
Existen distintos modificadores admitidos según la versión del comando ps que se esté usando en el sistema (BSD, POSIX, GNU, etc.)
Entre muchas opciones que tiene ps, es posible ordenar la salida de acuerdo a una columna, para esto se debe utilizar la opción gnu larga "--sort", por ejemplo para ordenar por tiempo de CPU (si deseamos determinar qué proceso ha utilizado más CPU) seleccionamos el código "cputime", correspondiente a la columna TIME:

ps aux --sort cputime

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Sistema

Vmstat es un comando que nos permite obtener un detalle general de los procesos, E/S, uso de memoria/swap, estado del sistema y actividad del CPU. Es esencial para entender que esta pasando en tu sistema, detectar cuellos de botella, etc..

Para usarlo, podemos correrlo sin parámetros, y obtendremos algo similar a esto:
La primera línea es simple, se divide en seis categorías: procesos, memoria, swap, E/S, sistema y CPU.
La segunda un detalle abierto de cada categoria superior.

Los campos mostrados en relación a los a procesos son:
r: El número de procesos ejecutables esperando para acceder al CPU.
b: El número de procesos en un estado dormido contínuo.
Los campos relacionados a la memoria son:
swpd: La cantidad de memoria utilizada.
free: La cantidad de memoria libre.
buff: La cantidad de memoria utilizada por las memorias intermedias.
cache: La cantidad de memoria utilizada como caché de páginas.
Los campos relacionados a swap son:

si: La cantidad de memoria intercambiada desde el disco.
so: La cantidad de memoria intercambiada hacia el disco.
Los campos relacionados con E/S son:
bi: Los bloques enviados a un dispositivo de bloques.
bo: Los bloques recibidos desde un dispositivo de bloques.
Los campos relacionados al sistema son:
in: El número de interrupciones por segundo.
cs: El número de cambios de contexto por segundo.
Los campos relacionados al CPU son:
us: El porcentaje de tiempo que el CPU ejecutó código de nivel del usuario.
sy: El porcentaje de tiempo que el CPU ejecutó código de nivel del sistema.
id: El porcentaje de tiempo que el CPU estaba desocupado.
wa: Esperas de E/S.
Si se ejecuta el comando “vmstat” sin opciones, nos muestra una unica línea, que contiene promedios calculados desde la última vez que se arrancó el sistema.
Si ejecutamos “vmstat 1″ muestra una nueva línea de utilización de datos cada segundo, mientras que el comando “vmstat 1 10″, muestra una nueva línea por segundo, pero sólo por los próximos 10 segundos.

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Sistema

Otra característica que tiene que tener un lenguaje para considerarse orientado a objetos es la HERENCIA.
La herencia significa que se pueden crear nuevas clases partiendo de clases existentes, que tendrá todas los atributos y los métodos de su 'superclase' o 'clase padre' y además se le podrán añadir otros atributos y métodos propios.
En Python, a diferencia de otros lenguajes orientados a objetos (Java, C#), una clase puede derivar de varias clases, es decir, Python permite la herencia múltiple.

Superclase o clase padre.
Clase de la que desciende o deriva una clase. Las clases hijas (descendientes) heredan (incorporan) automáticamente los atributos y métodos de la la clase padre.

Subclase.
Clase desciendiente de otra. Hereda automáticamente los atributos y métodos de su superclase. Es una especialización de otra clase. Admiten la definición de nuevos atributos y métodos para aumentar la especialización de la clase.
Veamos algunos ejemplos teóricos de herencia:
1) Imaginemos la clase Vehículo. Qué clases podrían derivar de ella

Vehiculo

   Colectivo                Moto                    Auto

                                             FordK        Renault 9

Siempre hacia abajo en la jerarquía hay una especialización (las subclases añaden nuevos atributos y métodos)
2) Imaginemos la clase Software. Qué clases podrían derivar de ella?

Software

             DeAplicacion                                        DeBase

ProcesadorTexto       PlanillaDeCalculo                          SistemaOperativo

Word   WordPerfect    Excel     Lotus123                         Linux    Windows

Si vemos que dos clase responden a la pregunta ClaseA "..es un.." ClaseB es posible que haya una relación de herencia.
Por ejemplo:
Auto "es un" Vehiculo
Circulo "es una" Figura
Mouse "es un" DispositivoEntrada
Suma "es una" Operacion
Ahora plantearemos el primer problema utilizando herencia en Python. Supongamos que necesitamos implementar dos clases que llamaremos Suma y Resta. Cada clase tiene como atributo valor1, valor2 y resultado. Los métodos a definir son cargar1 (que inicializa el atributo valor1), carga2 (que inicializa el atributo valor2), operar (que en el caso de la clase "Suma" suma los dos atributos y en el caso de la clase "Resta" hace la diferencia entre valor1 y valor2, y otro método mostrarresultado.
Si analizamos ambas clases encontramos que muchos atributos y métodos son idénticos. En estos casos es bueno definir una clase padre que agrupe dichos atributos y responsabilidades comunes.
La relación de herencia que podemos disponer para este problema es:

Operacion

Suma Resta

Solamente el método operar es distinto para las clases Suma y Resta (esto hace que no lo podamos disponer en la clase Operacion), luego los métodos cargar1, cargar2 y mostrarresultado son idénticos a las dos clases, esto hace que podamos disponerlos en la clase Operacion. Lo mismo los atributos valor1, valor2 y resultado se definirán en la clase padre Operacion.
En Pyton la codificación de estas tres clases es la siguiente:

class Operacion:
    def cargar1(self,v1):
        self.valor1=v1
    def cargar2(self,v2):
        self.valor2=v2
    def imprimir(self):
        print self.resultado
        print '<br>'

class Suma(Operacion):
    def operar(self):
        self.resultado=self.valor1+self.valor2

class Resta(Operacion):
    def operar(self):
        self.resultado=self.valor1-self.valor2

s=Suma()
s.cargar1(10)
s.cargar2(20)
s.operar()
print 'La suma es:'
s.imprimir()
r=Resta()
r.cargar1(10)
r.cargar2(2)
r.operar()
print 'La resta es:'
r.imprimir()

Veamos como es la sintaxis para indicar que una clase hereda de otra:

class Suma(Operacion):

Indicamos entre paréntesis el nombre de la clase padre (con esto estamos indicando que todos los métodos y atributos de la clase Operación son también métodos de la clase Suma.
Luego la característica que añade la clase Suma es el siguiente método:

def operar(self):
self.resultado=self.valor1+self.valor2

El método operar puede acceder a los atributos heredados.
Ahora podemos decir que la clase Suma tiene cuatro métodos (tres heredados y uno propio) y 3 atributos
Si creamos un objeto de la clase Suma tenemos:

s=Suma()
s.cargar1(10)
s.cargar2(20)
s.operar()
print 'La suma es:'
s.imprimir()

Podemos llamar tanto al método propio de la clase Suma "operar()" como a los métodos heredados. Quien utilice la clase Suma solo debe conocer que métodos tiene (independientemente que pertenezcan a la clase Suma o a una clase superior)
La lógica es similar para declarar la clase Resta:

class Resta(Operacion):
def operar(self):
self.resultado=self.valor1-self.valor2

y la definición de un objeto de dicha clase:

r=Resta()
r.cargar1(10)
r.cargar2(2)
r.operar()
print 'La resta es:'
r.imprimir()

La clase Operación agrupa en este caso un conjunto de atributos y métodos comunes a un conjunto de subclases (Suma, Resta). No tiene sentido definir objetos de la clase Operacion.
El planteo de jerarquías de clases es una tarea compleja que requiere un perfecto entendimiento de todas las clases que intervienen en un problema, cuales son sus atributos y responsabilidades.
Método especial __str__

Podemos hacer que se ejecute un método definido por nosotros cuando pasamos un objeto a la función print o cuando llamamos a la función str.
Que sucede cuando llamamos a la función print y le pasamos como parámetro un objeto?

class Persona:
    def __init__(self,nom,ape):
        self.nombre=nom
        self.apellido=ape

per=Persona('Jose','Rodriguez')
print per

Nos muestra algo parecido a esto:

<__main__.Persona instance at 0xf9e0a60ec5872050>

Python nos permite redefinir el método que se debe ejecutar. Esto se hace definiendo en la clase el método especial __str__
En el ejemplo anterior si queremos que se muestre el nombre y apellido separados por coma cuando llamemos a la función print el código que debemos implementar es el siguiente:

class Persona:
    def __init__(self,nom,ape):
        self.nombre=nom
        self.apellido=ape
    def __str__(self):
        cadena=self.nombre+','+self.apellido
        return cadena

per=Persona('Jose','Rodriguez')
print per

Como vemos debemos implementar el método __str__ y retornar un string, este luego será el que imprime la función print:

def __str__(self):
cadena=self.nombre+','+self.apellido
return cadena

Esta característica definida en Python nos permite crear programas muy legibles y flexibles.
El método __str__ también se ejecuta si llamamos a la función str y pasamos como parámetro un objeto que tiene definido dicho método:

class Persona:
    def __init__(self,nom,ape):
        self.nombre=nom
        self.apellido=ape
    def __str__(self):
        cadena=self.nombre+','+self.apellido
        return cadena

per1=Persona('Jose','Rodriguez')
per2=Persona('Ana','Martinez')
print str(per1)+'-'+str(per2) # Jose,Rodriguez-Ana,Martinez

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales

1.- Medusa, la mejor alternativa a AutoCAD en Linux.

De sobra nos es conocido que el rey indiscutible del CAD es AutoCad, ningún programa ha sido capaz de hacerle sombra, aunque los precios del software son, por ser amables, abusivos.
La única distribución que, desde mi punto de vista, permite trabajar de forma cómoda al estilo de AutoCad es ZWCAD que se puede adquirir por un precio inferior.

2.- Ubuntu 13.04 disponible para descarga (Información de pantalla, video, tutorial).

Canonical oficialmente ha publicado hoy su version 13.04 nombre en codigo “Raring Ringtail”Se están notando las ventajas de optimizar el sistema operativo para dispositivos móviles con pocos recursos.
El sistema consume menos Ram y se agiliza su utilización.
Los cambios más destacados, respecto al consumo son:

Se ha reducido el uso de memoria que hacían algunos paquetes, cargando datos e imágenes CSS de GTK3, sólo cuando se necesitan.
Se arreglaron problemas de memoria en los paquetes libdbusmenu, update-notifier, upower, whoopsie y otros más.

3.- FreetuxTV excelente aplicación para ver la TV o escuchar la radio en Ubuntu.

Si buscas una aplicación que te permita ver la televisión en directo o escuchar la radio de cualquier parte del mundo en GNU/Linux puede que FreeTuxTV te sea de gran utilidad ya que nos permite hacer esto mismo de forma sencilla.
La interfaz de FreetuxTV es muy sencilla y cuando lo iniciamos ya podremos agregar los canales en español, también podremos grabar lo que estamos viendo muy útil si quieres mantenerlo en tu equipo para verlo cuando quieras.

4.- 7 aplicaciones multimedia presentes en los repositorios oficiales de Ubuntu.

Ubuntu ofrece una amplia gama de aplicaciones multimedia desde sus repositorios Main, Universe y Multiverse.
Para ayudarte a escoger al reproductor de música o el editor de vídeo más conveniente, es útil distinguir entre los reproductores de medios de comunicación ellos mismos (o 'front-ends) y los motores de reproducción (playback)(' back-ends') que utilizan. Los front ends son las aplicaciones con las que interactuas con tu escritorio.
Algunos están integrados fuertemente con los entorno de escritorio, el GNOME y KDE; otros son independientes de plataforma.

5.- DJL es un instalador de juegos que proporciona una interfaz sencilla y muchas utilidades.

DJL es es un administrador de juegos escrito en Python, que nos permitirá instalar una gran cantidad de títulos (ver el detalle al final del post) en Linux.
Es un gestor de juegos, que nos sirve tanto para lanzar los juegos que hemos instalado con él, como para instalar juegos desde la red
He mirado los juegos disponibles en el repositorio y no me puedo quejar, están tanto los más famosos como los no tan conocidos.
Para usarlo debemos descargar la última versión, descomprimirla e instalarla.

6.- La campaña de financiación colectiva (crowdfunding) de Ubuntu Edge paso a paso.

La campaña de financiación colectiva que Canonical puso en marcha hace una semana comenzó con gran fuerza, pero en las últimas horas el empuje de esas inversiones se ha ralentizado de forma notable.
¿Conseguirán recaudar los 32 millones de dólares que persiguen para desarrollar y fabricar sus Ubuntu Edge?
El problema reside en que la avalancha de peticiones iniciales se ha debido a los importantes descuentos que Canonical ofreció. El Ubuntu Edge se podía conseguir por 600 dólares (más 30 de gastos de envío) frente a los 830 dólares que supondrían el coste final. Esa oferta se ha visto continuada con algunas más, pero éstas son cada vez menos atractivas.

7.- Cómo instalar un emulador de Android en Ubuntu.

Este emulador lo pueden encontrar en la página oficial de Android para desarrolladores.
Pensado para desarrolladores, incluye:
Herramientas.
Ejemplos de código.
Documentación.
Permite seleccionar cuales de los anteriores desea instalarse.
Posibilidad de descargar cualquier versión del Sistema Operativo (1.6,3.0,4,etc).
Todo para apoyar el desarrollo de aplicaciones para esta plataforma. Además permite:
Navegar por internet, utilizando la conexión de tu ordenador.
Navegar por la interfaz y algunas configuraciones del dispositivo virtual.

8.- 10 Artículos Recomendados sobre Seguridad en Ubuntu.

La mayor amenaza de seguridad informática no son los programas en sì mismos, es el hombre, el usuario.
Siempre hablamos de los virus y de la seguridad informática, de cómo es muy difícil penetrar en un sistema Gnu/Linux y muy fácil entrar en Windows.
Pero difícil no significa imposible y cada vez más y más amenazas se crean para Gnu/Linux y en especial para Ubuntu, al ser uno de los sistemas más usados dentro de la familia Gnu/Linux. Los rootkits son un buen ejemplo de amenaza que se ha llegado a Ubuntu, aunque al igual que hay una forma de que llegue, siempre hay una forma de sacarlo de nuestro sistema.

9.- Instalar Angry Birds en Ubuntu 12.04 “Precise Pangolin”.

Angry_Birds_Plushies

Angry Birds es un videojuego creado en 2009 por la empresa finlandesa Rovio Mobile. Desde entonces, el juego ha sido adaptado a dispositivos de pantalla táctil, como los basados en Maemo, iOS, Symbian, Java y Android.
Con más de un billón de descargas en 2012, esta aplicación quizá sea la más popular del año en la App Store de Apple. Además es también el juego más vendido de la historia en soportes móviles.
Actualmente la compañía trabaja en desarrollar versiones para PC, Xbox360, PS3, HTML5 y otras plataformas. Sin embargo, Angry Birds no es sólo un fenómeno digital: los personajes son tan populares que la empresa está empezando a comercializar juguetes físicos de los pájaros y hacia el futuro pretenden comercializar disfraces, dibujos animados y todo tipo de merchandising.

10.- Introducción a Inkscape programa de diseño vectorial.

Inkscape es un programa de diseño vectorial. Esto significa que los gráficos así creados se podrán escalar a cualquier tamaño sin que pierdan calidad, o reformar una vez hechos sin tener que borrar cada línea.
También tiene la capacidad de exportar lo que dibujemos a un formato de mapa de bits para utilizarlo en cualquier aplicación, como fondo de pantalla, en una página web, etc.
Inkscape se encuentra desarrollado principalmente para el sistema operativo GNU/Linux, pero es una herramienta multiplataforma.
Es una aplicación disponible en muchas lenguas, incluyendo sistemas de escritura complejos (como sistemas de escritura de derecha a izquierda como árabe, hebreo...).

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Android

Python es un lenguaje de script desarrollado por Guido van Rossum.

Podemos codificar empleando programación lineal, estructurada y orientada a objetos (tengamos en cuenta que esta última es la que se ha impuesto en la actualidad)

Se cuenta con intérpretes de Python en múltiples plataformas: Windows, Linux, Mac etc. Se pueden desarrollar aplicaciones de escritorio como aplicaciones web. Empresas como Google, Yahoo, Nasa etc. utilizan este lenguaje para sus desarrollos (actualmente el creador de Python Guido van Rossum trabaja para Google.)

Se puede ejecutar instrucciones de Python desde la línea de comando o creando archivos con extensión *.py. Cuando uno comienza a aprender este lenguaje la línea de comandos nos provee una retroalimentación del resultado en forma inmediata.

El objetivo de este tutorial es presentar en forma progresiva los conceptos fundamentales de este lenguaje y poder analizar los problemas resueltos y codificar los problemas propuestos en este mismo sitio, sin tener que instalar en un principio el Python en su equipo (o luego de instalado poder avanzar con el tutorial en cualquier máquina conectada a internet).

Métodos de una clase.

Los métodos son como las funciones en los lenguajes estructurados, pero están definidos dentro de una clase y operan sobre los atributos de dicha clase.
Los métodos también son llamados las responsabilidades de la clase. Para encontrar las responsabilidades de una clase hay que preguntarse qué puede hacer la clase.
El objetivo de un método es ejecutar las actividades que tiene encomendada la clase a la cual pertenece.
Los atributos de un objeto se modifican mediante llamadas a sus métodos.
Confeccionaremos un nuevo problema para concentrarnos en la definición y llamada a métodos.
Problema:Confeccionar una clase CabeceraPagina que permita mostrar un título, indicarle si queremos que aparezca centrado, a derecha o izquierda.
Definiremos dos atributos, uno donde almacenar el título y otro donde almacenar la ubicación.
Ahora pensemos que métodos o responsabilidades debe tener esta clase para poder mostrar la cabecera de la página. Seguramente deberá tener un método que pueda inicializar los atributos y otro método que muestre la cabecera dentro de la página.
Veamos el código de la clase CabeceraPagina

class CabeceraPagina:
    def inicializar(self,tit,ubi):
      self.titulo=tit
      self.ubicacion=ubi

    def graficar(self):
        print '<div style="font-size:40px;text-align:'+self.ubicacion+'">'
        print self.titulo
        print '</div>'

cabecera=CabeceraPagina()
cabecera.inicializar('El blog del programador','center')
cabecera.graficar()

La clase CabeceraPagina tiene dos atributos donde almacenamos el texto que debe mostrar y la ubicación del mismo ('center', 'left' o 'right'), nos valemos de CSS para ubicar el texto en la página.
No es obligatorio en Python definir previo a los métodos todos los atributos. Como vemos se definen e inicializan al llamar al método inicializar.
Ahora analicemos lo que más nos importa en el concepto que estamos concentrados (métodos de una clase):

def inicializar(self,tit,ubi):
self.titulo=tit
self.ubicacion=ubi

Un método tiene un nombre, conviene utilizar verbos para la definición de métodos (mostrar, inicializar, graficar etc.) y sustantivos para la definición de atributos (color, enlace, titulo etc.)

Un método debe tener como primer parámetro el identificador self, el mismo nos permite acceder a los atributos de la clase, además puede tener otros parámetros que inicializan atributos del objeto:

self.titulo=tit
self.ubicacion=ubi

Luego para llamar a los métodos debemos crear un objeto de dicha clase:

cabecera=CabeceraPagina()
cabecera.inicializar('El blog del programador','center')
cabecera.graficar()

Es importante notar que siempre que llamamos a un método le antecedemos el nombre del objeto. El orden de llamada a los métodos es importante, no va a funcionar si primero llamamos a graficar y luego llamamos al método inicializar.

Método constructor de una clase.

El constructor es un método especial de una clase. El objetivo fundamental del constructor es inicializar los atributos del objeto que creamos.
Básicamente el constructor remplaza al método inicializar que habíamos hecho en el concepto anterior.
Las ventajas de implementar un constructor en lugar del método inicializar son:

El constructor es el primer método que se ejecuta cuando se crea un objeto.
El constructor se llama automáticamente. Es decir es imposible de olvidarse de llamarlo ya que se llamará automáticamente.
Quien utiliza POO (Programación Orientada a Objetos) conoce el objetivo de este método.

Otras características de los constructores son:

El constructor se ejecuta inmediatamente luego de crear un objeto y no puede ser llamado nuevamente.
Un constructor no puede retornar dato.
Un constructor puede recibir parámetros que se utilizan normalmente para inicializar atributos.
El constructor es un método opcional, de todos modos es muy común definirlo.

Veamos la sintaxis del constructor:

def __init__([parámetros]):
[algoritmo]

Debemos definir un método llamado __init__ (es decir utilizamos dos caracteres de subrayado, la palabra init y seguidamente otros dos caracteres de subrayado).
Confeccionaremos el mismo problema del concepto anterior para ver el cambio que debemos hacer de ahora en más.
Problema:Confeccionar una clase CabeceraPagina que permita mostrar un título, indicarle si queremos que aparezca centrado, a derecha o izquierda.

class CabeceraPagina:
    def __init__(self,tit,ubi):
        self.titulo=tit
        self.ubicacion=ubi

    def graficar(self):
        print '<div style="font-size:40px;text-align:'+self.ubicacion+'">'
        print self.titulo
        print '</div>'

cabecera=CabeceraPagina('El blog del programador','center')
cabecera.graficar()

Ahora podemos ver como cambió la sintaxis para la definición del constructor:

def __init__(self,tit,ubi):
self.titulo=tit
self.ubicacion=ubi

Veamos como se modifica la llamada al constructor cuando se crea un objeto:

cabecera=CabeceraPagina('El blog del programador','center')
cabecera.graficar()

Es decir el constructor se llama en la misma línea donde creamos el objeto, por eso disponemos después del nombre de la clase los parámetros:

cabecera=CabeceraPagina('El blog del programador','center')

Generalmente todo aquello que es de vital importancia para el funcionamiento inicial del objeto se lo pasamos mediante el constructor.

Llamada de métodos dentro de la clase.
Hasta ahora todos los problemas planteados hemos llamado a los métodos desde donde definimos un objeto de dicha clase, por ejemplo:

cabecera=CabeceraPagina('El blog del programador','center')
cabecera.graficar()

Utilizamos la sintaxis:

[nombre del objeto].[nombre del método]

Es decir antecedemos al nombre del método el nombre del objeto y el operador punto
Ahora bien que pasa si queremos llamar dentro de la clase a otro método que pertenece a la misma clase, la sintaxis es la siguiente:

self.[nombre del método]

Es importante tener en cuenta que esto solo se puede hacer cuando estamos dentro de la misma clase.
Confeccionaremos un problema que haga llamadas entre métodos de la misma clase.
Problema:Confeccionar una clase Tabla que permita indicarle en el constructor la cantidad de filas y columnas. Definir otra responsabilidad que podamos cargar un dato en una determinada fila y columna. Finalmente debe mostrar los datos en una tabla HTML.

class Tabla:
    mat=[]
    cantfilas=0
    cantcolumnas=0

    def __init__(self,fi,co):
        self.cantfilas=fi
        self.cantcolumnas=co
        for f in range(0,fi):
            self.mat.append([])
            for c in range(0,co):
                self.mat[f].append('')

    def cargar(self,fi,col,valor):
        self.mat[fi][col]=valor

    def iniciotabla(self):
        print '<table border="1">'

    def iniciofila(self):
        print '<tr>'

    def mostrar(self,fi,co):
        print '<td>'
        print self.mat[fi][co]
        print '</td>'

    def finfila(self):
        print '</tr>'

    def fintabla(self):
        print '</table>'

    def graficar(self):
        self.iniciotabla()
        for f in range(0,self.cantfilas):
            self.iniciofila()
            for c in range(0,self.cantcolumnas):
                self.mostrar(f,c)
            self.finfila()
        self.fintabla()

tabla1=Tabla(3,4)
tabla1.cargar(0,0,1)
tabla1.cargar(0,1,2)
tabla1.cargar(0,2,3)
tabla1.cargar(0,3,4)
tabla1.cargar(1,0,5)
tabla1.cargar(1,1,6)
tabla1.cargar(1,2,7)
tabla1.cargar(1,3,8)
tabla1.cargar(2,0,9)
tabla1.cargar(2,1,10)
tabla1.cargar(2,2,11)
tabla1.cargar(2,3,12)
tabla1.graficar()

Vamos por parte, primero veamos los tres atributos definidos,el primero se trata de una lista donde almacenaremos todos los valores que contendrá la tabla HTML y otros dos atributos que indican la dimensión de la tabla HTML (cantidad de filas y columnas):

mat=[]
cantfilas=0
cantcolumnas=0

El constructor recibe como parámetros la cantidad de filas y columnas que tendrá la tabla, además creamos la lista con tantas filas como indica el parámetro fi e insertamos una lista en cada componente (es decir que cada componente de la lista es una lista que representa los elementos de la fila respectiva) Dentro de un for interno agregamos string vacíos a cada elemento de la lista interna:

self.cantfilas=fi
      self.cantcolumnas=co
      for f in range(0,fi):
          self.mat.append([])
          for c in range(0,co):
              self.mat[f].append('')

Otro método de vital importancia es el de cargar datos. Llegan como parámetro la fila, columna y dato a almacenar:

def cargar(self,fi,col,valor):
self.mat[fi][col]=valor

Otro método muy importante es el graficar:

def graficar(self):
        self.iniciotabla()
        for f in range(0,self.cantfilas):
            self.iniciofila()
            for c in range(0,self.cantcolumnas):
                self.mostrar(f,c)
            self.finfila()
        self.fintabla()

El método graficar debe hacer las salidas de datos dentro de una tabla HTML. Para simplificar el algoritmo definimos otros cinco métodos que tienen por objetivo hacer la generación del código HTML propiamente dicho. Así tenemos el método iniciotabla que hace la salida de la marca table e inicialización del atributo border:

def iniciotabla(self):
print '<table border="1">'

De forma similar los otros métodos son:

def iniciofila(self):
        print '<tr>'

    def mostrar(self,fi,co):
        print '<td>'
        print self.mat[fi][co]
        print '</td>'

    def finfila(self):
        print '</tr>'

    def fintabla(self):
        print '</table>'

Si bien podíamos hacer todo esto en el método graficar y no hacer estos cinco métodos, la simplicidad del código aumenta a medida que subdividimos los algoritmos. Esto es de fundamental importancia con algoritmos más complejos./p>
Lo que nos importa ahora ver es como llamamos a métodos que pertenecen a la misma clase:

def graficar(self):
        self.iniciotabla()
        for f in range(0,self.cantfilas):
            self.iniciofila()
            for c in range(0,self.cantcolumnas):
                 self.mostrar(f,c)
            self.finfila()
        self.fintabla()

Es decir le antecedemos la palabra self al nombre del método a llamar. De forma similar a como accedemos a los atributos de la clase.
Por último debemos definir un objeto de la clase Tabla y llamar a los métodos respectivos:

tabla1=Tabla(3,4)
tabla1.cargar(0,0,1)
tabla1.cargar(0,1,2)
tabla1.cargar(0,2,3)
tabla1.cargar(0,3,4)
tabla1.cargar(1,0,5)
tabla1.cargar(1,1,6)
tabla1.cargar(1,2,7)
tabla1.cargar(1,3,8)
tabla1.cargar(2,0,9)
tabla1.cargar(2,1,10)
tabla1.cargar(2,2,11)
tabla1.cargar(2,3,12)
tabla1.graficar()

Es importante notar que donde definimos un objeto de la clase Tabla no llamamos a los métodos iniciotabla(), iniciofila(), etc.

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales