El Mundo de Ubuntu

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:

Mozilla Firefox

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.

Juegos

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