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).
Cuando nuestra aplicación genera un error que Python no puede resolver podemos disponer un código que se ejecute para dichas situaciones.

Errores como tratar de abrir un archivo que no existe, acceder a un elemento de una lista que no existe, dividir por cero etc. genera un error que hace que nuestro programa se detenga y no continúe su ejecución. Pero con Python podemos preveer estas situaciones y definir un algoritmo que se ejecutará exepcionalmente cuando ocurra dicho error.
Si ejecutamos el siguiente código el programa se detendrá informándonos que se produjo un error y no puede continuar:

y=0
x=10/y
print 'esta linea nunca se ejecuta'

Utilizando excepciones podemos capturar el error y continuar la ejecución del programa:

y=0
try:
    x=10/y
except ZeroDivisionError:
    print 'No existe la division por cero'
print 'Esta linea si se ejecuta'

La estructura try/except requiere que indiquemos el tipo de excepción a capturar, en este caso cuando se trata de dividir por cero Python genera una excepción llamada ZeroDivisionError. Para capturar dicha excepción debemos disponerla seguido de la palabra clave except.
Si se produce la excepción se ejecutan las instrucciones que dispongamos en las líneas siguientes al except.
Cuando se captura una excepción el programa no se detiene y continua con las intrucciones siguientes al bloque try/except.
Veamos otro ejemplo de intentar acceder a un elemento que no existe en una lista:

lista1=['juan','ana','carlos']
try:
    print lista1[5]
except IndexError:
    print 'Intenta acceder a un elemento no existente a la lista'

lista1 almacena 3 elementos y tratamos de acceder al de la posición 5. Python en este situación genera una excepción de tipo IndexError, como disponemos el acceso dentro de la contrucción try/except y captura el tipo de excepción IndexError el programa no se detiene y ejecuta la instrucción seguida de la línea except IndexError.
Un tema de aplicación muy común donde se utilizan las excepciones es con el tratamiento de archivos, hay muchas situaciones que pueden generar excepciones en estos casos como puede ser que no se pueda abrir un archivo porque no existe, no lo pueda crear porque la unidad de amacenamiento está llena, el archivo se encuentra bloqueado por otro programa etc.
El código para crear, grabar y leer un archivo capturando las excepciones queda de la siguiente manera:

def creartxt():
    try:
        archi=open('datos.txt','w')
        archi.close()
    except IOError:
        print 'No se pudo crear el archivo'

def grabartxt():
    try:
        archi=open('datos.txt','a')
        archi.write('Linea 1\n')
        archi.write('Linea 2\n')
        archi.write('Linea 3\n')
        archi.close()
    except IOError:
        print 'No se pudo abrir el archivo'

def leertxt():
    try:
       archi=open('noexiste.txt','r')
       linea=archi.readline()
       while linea!="":
           print linea
           linea=archi.readline()
       archi.close()
    except IOError:
        print 'El archivo no existe'

creartxt()
grabartxt()
leertxt()

La excepción cumple un doble cometido en estas situaciones, primero mostramos mensajes que nosotros definimos y no los que Python muestra por defecto cuando se genera un error y por otro lado podemos continuar con la ejecución de nuestro algoritmo sin que se detenga.
Podemos disponer varios capturas de excepciones para un bloque try:

lista1=['juan','ana','carlos']
try:
    print lista1[0]
    z=10/0
except IndexError:
    print 'Intenta acceder a un elemento no existente a la lista'
except ZeroDivisionError:
    print 'Division por cero no permitida'

En este bloque try capturamos las excepciones de tipo: IndexError y ZeroDivisionError. Como podemos ver la que se dispara es la de ZeroDivisionError. Pero podemos generar el otro tipo de excepción modificando la línea de impresión del elemento de la lista:

print lista1[5]

Si hacemos este cambio se ejecuta la sección seguida a 'except IndexError:'. Una vez disparada dicha excepción no continua con las instrucciones del bloque del try, es decir no generará la excepción de división por cero, pero si continuará con el flujo del algoritmo.
Si no queremos tratar los errores en forma independiente podemos agrupar excepciones:

lista1=['juan','ana','carlos']
try:
    print lista1[0]
    z=10/0
except (IndexError,ZeroDivisionError):
    print 'Se produjo un error'

Debemos indicar entre paréntesis todas las excepciones a capturar y como se procede con ellas, en este caso solo se muestra un mensaje 'Se produjo un error'.
Otra parte opcional de un bloque try es la del else. Este bloque se ejecuta si no se produce la excepción:

lista1=['juan','ana','carlos']
try:
    print lista1[0]
    z=10/5
except (IndexError,ZeroDivisionError):
    print 'Se produjo un error'
else:
    print z

Este programa muestra el primer elemento de la lista, luego procede a inicializar la variable z con el valor 10/5 y seguidamente ejecuta la sección del else ya que no se a generado excepciones.
Podemos tratar de imprimir una componente que no exista de la lista y veremos que no se ejecuta el bloque del else.
Hemos visto que podemos capturar distintas excepciones en forma independiente:

except IndexError:
    print 'Intenta acceder a un elemento no existente a la lista'
except ZeroDivisionError:
    print 'Division por cero no permitida'

En forma conjunta:

except (IndexError,ZeroDivisionError):
    print 'Se produjo un error'

Inclusive Python nos permite disponer un bloque try except para la captura de cualquier tipo de excepción (si bien esto no es lo más recomendable ya que es difícil emprender una acción para todos los tipos de errores que pueden generarse):

lista1=['juan','ana','carlos']
try:
    print lista1[0]
    z=10/0
except:
    print 'Se produjo un error'

Otra sección que puede tener un bloque try except es finally.
finally permite disponer un bloque de código que se ejecutará siempre, indistintamente se produzca o no la excepción. El objetivo de esta sección es generalmente utilizado para liberar recursos como puede ser cerrar la conexión con una base de datos o cerrar un archivo.

try:
    z=10/0
    print 'Esto no se ejecuta'
except:
    print 'Se produjo un error'
finally:
    print 'Siempre se ejecuta'

Google App Engine utilizando Python.

El servicio de Google App Engine nos permite obtener una cuenta para crear nuestras aplicaciones web utilizando los servidores y tecnología de Google. Y como ventaja después de haber estudiado Python Google App Engine nos facilita crear un sitio utilizando como lenguaje de servidor el Python.
Actualmente nos suministra 500 MB para el almacenamiento de nuestras páginas y base de datos, todo esto en forma gratuita.

• El primer paso es registrarnos en Google para obtener una cuenta y esto lo podemos hacer desde aquí
  
• Si tarda un poco la asignación de la cuenta no es tan importante ya que todo el desarrollo lo hacemos en forma local en nuestro equipo. Finalizado el proyecto lo debemos cargar en los servidores de Google.
  Para trabajar en forma local debemos tener instalado el lenguaje Python en su versión 2.5 o superior.
  También tenemos que tener instalado el kid de desarrollo que nos provee Google y ejecuta nuestra aplicación en forma local, podemos descargar la última actualización del mismo desde aquí.
  

Luego de instalar el Python 2.5 o superior debemos proceder a instalar el kid de desarrollo que nos provee Google. Cuando lo instalamos nos sugiere donde se instala el software (podemos dejar el que nos propone por defecto): c:\Archivo de programa\Google\google_appengine\
Ya tenemos todo para comenzar a experimentar con Python y el framework que nos provee Google para el desarrollo de aplicaciones web.
Si ya dispone la cuenta suministrada por Google desde el panel de administración podemos crear una aplicación presionando el botón "Create an Application".
Debemos seleccionar un nombre para nuestra aplicación que correrá como un subdominio de appspot.com, como podrán comprobar muchos de los nombres más comunes ya han sido tomados por otros usuarios.
Seleccionado un nombre disponible (podemos comprobar disponibilidad presionando el botón "Check Availability") asignamos un título y aceptamos los términos del servicio. Ya estamos en condiciones de subir nuestra aplicación (tengamos en cuenta que todavía no hemos desarrollado ni el 'Hola Mundo').
Hola mundo con Google App Engine.
Primero debemos crear un directorio donde se instaló el Google App Engine, normalmente en: c:\Archivo de programa\Google\google_appengine\
Este nombre debe coincidir con el que obtuvimos desde el panel de control de nuestra cuenta de Google App Engine (yo tomaré como nombre tutorialya)
Para utilizar los servidores de Google deberemos crear un archivo de configuración llamado app.yaml y que deberemos localizar en el directorio que acabamos de crear.
El archivo app.yaml tiene una estructura similar a:

application: tutorialya
version: 1
runtime: python
api_version: 1

handlers:
- url: /.*
  script: tutorialya.py

Del ejemplo anterior deberá modificar la propiedad de application con el nombre de aplicación que gestionó desde su panel de control del Google App Engine. Lo mismo pasa con la propiedad script.
Ahora que tenemos nuestro directorio donde se alojará nuestro sitio en forma local y el archivo de configuración app.yaml debemos crear el archivo Python principal y lo llamaremos igual que el nombre de la carpeta y con extensión *.py y debe coincidir con la propiedad script del archivo app.yaml (en mi caso yo lo llamé tutorialya.py).
Para codificar nuestra aplicación Google creó un framework propio llamado webapp y que se instala automáticamente con nuestra aplicación.
Luego nuestra aplicación mínima utilizando dicho framework es:

import wsgiref.handlers

from google.appengine.ext import webapp

class HolaMundo(webapp.RequestHandler):
  def get(self):
    self.response.out.write('<html><head></head>')
    self.response.out.write('<body>')
    self.response.out.write('<h1>Hola Mundo</h1>')
    self.response.out.write('</body>')

def main():
  application = webapp.WSGIApplication([('/', HolaMundo)],
                                       debug=True)
  wsgiref.handlers.CGIHandler().run(application)

if __name__ == '__main__':
  main()

Después nos detendremos en la forma de codificar utilizando este framework, por ahora solo nos interesa ver aparecer el 'Hola mundo' en el navegador.
Ya tenemos codificado el archivo *.yaml y *.py, ahora queda iniciar nuestro servidor y peticionar la página.
Como servidor web no utilizaremos el Apache, sino un servidor creado con Python que viene incluido con el Google App Engine. Para activar este servidor debemos ir a la línea de comandos de nuestro sistema operativo hasta la carpeta (c:\Archivo de programa\Google\google_appengine\) y desde allí arrancar el servidor indicando el nombre de nuestra aplicación:

c:\Archivo de programa\Google\google_appengine>dev_appserver.py tutorialya/

Tener en cuenta de pasar como parámetro al programa dev_appserver.py el nombre de la carpeta que hemos creado para nuestro proyecto (en mi caso la llamé tutorialya)
Si tenemos correctamente creado el archivo *.yaml deberá mostrar un mensaje que el servidor web está esperando peticiones en el puerto 8080. Luego desde el navegador debemos llamar nuestra aplicación con la siguiente sintaxis:

http://localhost:8080

Si codificamos correctamente la aplicación deberemos tener el mensaje 'Hola Mundo'.

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:

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).

Creación, carga y lectura de archivos de texto.
Python cuenta con una clase llamada file que nos permite crear, escribir y leer datos de un archivo de texto.
Para crear un objeto de la clase file debemos utilizar la función open. Cuando llamamos a dicha función le pasamos como primer parámetro el nombre del archivo de texto y el modo de apertura del mismo:

open(nombre del archivo,modo)

Si el archivo de texto se encuentra en la misma carpeta que nuestro programa no necesitamos indicar el path (camino). Los modos de apertura del archivo de texto pueden ser:

• 'r' Abre el archivo para lectura (debe existir el archivo)
• 'w' Crea el archivo y lo abre para escribir
• 'a' Abre el archivo para escribir. Se crea si el archivo no existe. Solo podemos agregar datos al final

Creación de un archivo de texto.
El siguiente algoritmo crea en disco un archivo de texto llamado 'datos.txt' y no graba datos. Si queremos luego de ejecutar el programa podemos verificar la existencia del archivo en la misma carpeta donde almacenamos nuestro programa.
Cuando lo grabamos el archivo fuente en Python debemos darle un nombre al programa (por ejemplo texto1.py)

def creaciontxt():
    archi=open('datos.txt','w')
    archi.close()

creaciontxt()

Creamos una función llamada creaciontxt donde primero llamamos a la función open pasando como parámetros el nombre del archivo de texto a crear y el modo de apertura ('w')
La función open retorna la referencia del objeto file. Luego llamamos al método close de la clase file. Si luego queremos ver si se a creado el archivo de textos podemos hacerlo desde algun explorador de archivos, en la carpeta donde se encuentra nuestro programa en Python veremos un archivo llamado 'datos.txt' que tiene un tamaño de 0 bytes.
Grabación de líneas en el archivo de texto.

def creartxt():
    archi=open('datos.txt','w')
    archi.close()

def grabartxt():
    archi=open('datos.txt','a')
    archi.write('Linea 1\n')
    archi.write('Linea 2\n')
    archi.write('Linea 3\n')
    archi.close()

creartxt()
grabartxt()

La función creartxt es similar al ejemplo anterior, y la función grabartxt tiene por objetivo abrir el archivo en modo de agregado. Cada vez que grabamos un string en el archivo de texto insertamos un salto de línea '\n'. Finalmente liberamos el archivo llamando al método close.
Para ver el contenido de nuestro archivo de texto debemos utilizar un editor de texto (bloc de notas o el mismo entorno del Idle nos puede servir para ver el contenido de un archivo txt)
Lectura línea a línea de un archivo de texto.
La clase file tiene un método llamado readline() que retorna toda una línea del archivo de texto y deja posicionado el puntero de archivo en la siguiente línea. Cuando llega al final del archivo readline retorna un string vacío.

def creartxt():
    archi=open('datos.txt','w')
    archi.close()

def grabartxt():
    archi=open('datos.txt','a')
    archi.write('Linea 1\n')
    archi.write('Linea 2\n')
    archi.write('Linea 3\n')
    archi.close()

def leertxt():
    archi=open('datos.txt','r')
    linea=archi.readline()
    while linea!="":
        print linea
        linea=archi.readline()
     archi.close()


creartxt()
grabartxt()
leertxt()

Luego de de abrir el archivo para lectura procedemos a leer la primer línea:

archi=open('datos.txt','r')
    linea=archi.readline()

El while se repite mientras el método readline() no retorne un string vacío. Dentro del while procedemos a imprimir la línea que acabamos de leer y leemos la siguiente (el método readline() retorna el contenido de toda la línea inclusive el salto de línea \n):

while linea!="":
        print linea
        linea=archi.readline()

Podemos leer todo el contenido de un archivo de texto y almacenarlo en una lista (esto tiene sentido si el archivo de texto no es muy grande):

def creartxt():
    archi=open('datos.txt','w')
    archi.close()

def grabartxt():
    archi=open('datos.txt','a')
    archi.write('Linea 1\n')
    archi.write('Linea 2\n')
    archi.write('Linea 3\n')
    archi.close()

def leertxtenlista():
    archi=open('datos.txt','r')
    lineas=archi.readlines()
    print lineas
    archi.close()

creartxt()
grabartxt()
leertxtenlista()

Utilizamos el método readlines() en lugar de readline(). El método readlines() retorna una lista con cada línea del archivo de texto.
Recordemos que podemos procesar luego cada elemento de la lista recorriéndola con una estructura repetitiva:

def leertxtenlista():
    archi=open('datos.txt','r')
    lineas=archi.readlines()
    for li in lineas:
        print li
    archi.close()

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:

El comando unix dig (domain information groper), con el permiso de nslookup, es una de las mejores opciones a la hora de hacer troubleshooting o debug de problemas DNS.
Vamos a ver unos cuantos ejemplos de algunas las posibilidades que nos ofrece.
Como siempre podrán encontrar más información en la página man del comando o la ayuda:

$ man dig
$ dig -h

Ejecución sin argumentos.
.Cuando ejecutamos el comando dig sin argumentos se realiza una consulta de los NS (Name Servers) raíz o root servers “.”. Cara al troubleshooting o debug no suele ser de mucha utilidad:

Dominio como argumento.
La forma más común y simple de ejecutar dig. En este caso pasamos como argumento el dominio a consultar. Cuando no se especifica nada se consulta siempre el registro A del dominio.
Al no especificar tampoco los servidores DNS contra los que hacer la consulta se utilizan los especificados en nuestra conexión (/etc/resolv.conf). Debemos prestar especial importancia a la sección ANSWER SECTION, ya que muestra el resultado de nuestra consulta:

Dominio como argumento y usando un name server específico.
El comando anterior usaba el DNS local especificado en /etc/resolv.conf (127.0.0.1) para solicitar el registro A del dominio, en este caso vamos a hacer la consulta contra un NS externo, el de google por ejemplo (8.8.8.8). Se indica con la IP/nombre del servidor precedida de @.
Se puede ver en la sección final como se especifica el servidor que utilizamos para la query (negrita). La respuesta debería ser la misma que los servidores autoritativos del dominio, en caso contrario podría haber envenenamiento DNS, DNS spoofing…:

Especificar el registro (A, NS, MX, CNAME…) a consultar.
Como decía antes, por defecto se consulta el registro A del dominio, pero podemos especificar el tipo de registro que queramos (ANY, NS, A, MX, SIG,SOA…):


Consultar todos los registros de la zona DNS.
En lugar de especificar el tipo de registro a mostrar (A, MX, CNAME, AAAA…) podemos decir directamente que consulte todos los que se sirven en la zona DNS del dominio con el parámetero ANY:

Hacer debug con el parámetro trace.
El parámetro “+trace” es muy útil para hacer debug ante problemas de resolución DNS ya que permite ver la traza y saltos de la petición hasta que llega al servidor autoritativo que ofrece la respuesta del registro:

Para realizar consultas de reverse DNS tenemos el parámetro -x:

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:

XDAM es una alternativa a IDM para los que migran de Windows a Linux.
Este paquete  es un acelerador de descarga escrito en Java.
La descarga es de verdad muy buena, de tal manera que me dejo por unos segundos sin ancho de banda a Mozilla Firefox
.
xdam no trae limitador de velocidad.
Otra cosa buena es que se puede integrar a Firefox.
Este paquete es originalmente para Puppy Night Precise y Puppy-es pero dejé el tar.gz para que lo puedan empaquetar en su distro y subir los link aqui asi los agrego.

xdman-3.01.tar.gz

Download (384.96 KB)

Acá les muestro como integrarlo a Firefox.
Seleccionen browser integration.

Luego les abrirá una ventana, ahí arrastran el icono a la barra de navegación, y denle enter se descargara el adons.

miren ya quedo integrado y sale en el menu,
 
En funcionamiento.

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:

No es la primera vez que hablo aquí de programas curiosos para la consola, como la demo multimedia, el tetris en consola o la reproducción de video en modo texto.

Creo que es una buena forma de desmitificar la consola y una excelente para verla  como una herramienta más a nuestro servicio y no como un verdadero tabù.

Hoy vuelvo al ataque con un paquete de juegos para la consola.
El paquete en cuestión, esta en los repositorios, se llama bsdgames e incluye los siguientes juegos y utilidades:

# adventure – Juego de exploración
# arithmetic – Test matemáticos
# atc – Control de tráfico aereo
# backgammon – El tradicional backgammon
# banner – Para imprimir banners
# battlestar – Juego de aventuras
# boggle – Juego de buscar palabras
# caesar - Desencripta códigos caesar
# canfield – Juego de cartas canfield
# cfscores – Muestra los records de canfield
# cribbage – Juego de cartas cribbage
# fish - Juego Go Fish
# gomoku – Cinco en linea
# hangman – El ahorcado
# hunt – Juego multiusuario
# huntd – Demonio para hunt
# mille - Juego Mille Bornes
# monop – El Monopoly
# morse – Traduce al morse
# number – Convierte números
# phantasia – Un juego de conversacional de fantasía
# pom – Muestra las fases lunares
# primes – Generador de numeros primos
# quiz – Un juego tipo trivial
# rain – Lluvia en tu pantalla (en modo texto)
# robots – Lucha de robots
# rot13 – Codificador rot13
# snake – Juego de la serpiente
# teachgammon – Tutorial de backgammon
# tetris-bsd – El tetris
# trek – Juego para trekies
# wargames – Curioso juego basado en Juegos de guerra.
# worm – El juego del gusano
# worms – Gusanos animados en el terminal

Instalación:
Ya que estamos hablando de la consola, lo instalaremos desde ella.
Nada de complicaciones, solo hay que poner

aptitude install bsdgames

Y ya los tendremos a nuestra disposición. Solo nos queda disfrutar de juegos como el maravilloso tetris.

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:

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).
Las cadenas tratadas como objetos.

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:

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).

Redefinición de los operadores matemáticos con objetos.

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:

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:

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: