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

Implementación de módulos.
Cuando uno codifica un programa en Python lo almacena en un archivo con extensión *.py
Una vez instalado el Python en forma local podemos llamar un programa desde la línea de comando del sistema operativo.
Si tenemos un programa mínimo llamado: programa1.py

def holamundo():
    print('Hola Mundo')

holamundo();

Luego desde la carpeta donde hemos instalado el Python debemos ejecutarlo con la siguiente sintaxis:

c:\Python25>python c:\pruebaspython\programa1.py

Luego de esto veremos en pantalla el mensaje 'Hola Mundo'
Este archivo en Python se lo llama módulo.
Un programa pequeño puede estar formado por un único módulo, pero programas de mayor tamaño deben dividirse en distintos módulos para facilitar su mantenimiento. Cada módulo normalmente almacena un conjunto de funciones relacionadas.
La sintaxis para llamar a una función que se encuentra en otro módulo es la siguiente:

modulo1.py

def funcion1():
    print 'Función 1'   

modulo2.py

import modulo1

def funcion2():
    modulo1.funcion1()
    print 'Función 2'

funcion2()      

Luego desde la línea de comandos ejecutamos el modulo2.py:

c:\Python25>python c:\pruebaspython\modulo2.py

Y como resultado tenemos en pantalla

Función 1
Función 2

Veremos más adelante que Python nos provee de una gran biblioteca de módulos. Recordemos que ya hemos estado utilizando la función randint que se encuentra en el módulo random:

import random

x=random.randint(1,1000)
print x

Funciones de uso común (range - type - str - dir).

Como hemos visto en el punto anterior Python agrupa las funciones en módulos que serán importados en el caso que nuestro programa los necesite. Pero hay un pequeño grupo de funciones que Python las importa de forma automática, esto quiere decir que podemos hacer uso sin tener que hacer un import.

Funciones incorporadas en Python

• range([inicio],fin,[paso])
  La función range devuelve una lista de valores enteros, comienza con el valor pasado al parámetro [inicio], en caso de omitir este parámetro comienza en cero y finaliza con el valor indicado en el parámetro 'fin' sin incluirlo. En caso de indicar el parámetro [paso] la lista de valores crece según dicho número, sino se incrementa de a uno.

lista1=range(5,10)
print lista1  # [5, 6, 7, 8, 9]
lista2=range(10)
print lista2  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
lista3=range(-5,5)
print lista3  # [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
lista4=range(1,10,3)
print lista4  # [1, 4, 7]
Es muy común utilizar esta función para generar un contador con la estructura for in, por ejemplo si queremos mostrar los números del 1 al 10:

for x in range(1,11):
    print x
    print '-'

• str(variable)
  Convierte el contenido del parámetro a cadena y lo retorna. Funciona para cualquier tipo de dato como puede ser un entero, real, tupla, lista etc.
  Muy útil cuando tenemos que generar un string a partir de un conjunto de variables heterogeneas.

x=10
y=2.5
fin=False
edades=(40,50)
print str(x) + str(y) + str(fin) + str(edades)
En el ejemplo concatenamos el contenido de cuatro variables de distinto tipo, para ello debemos llevarlas a todas a tipo string.

• type(variable)
  Retorna el tipo de una variable.

x=10
print type(x) # <type 'int'>
y=2.5
print type(y)  # <type 'float'>
fin=False
print type(fin) # <type 'bool'>
edades=(40,50)
print type(edades) # <type 'tuple'>

• dir(variable)
  Si pasamos como parámetro a la función dir un objeto luego nos devuelve todos los métodos que tiene definidos la clase de dicho objeto (veremos más adelante en profundidad cada uno de los métodos de la clase lista y diccionario):

lista1=[2,4,6]
print dir(lista1) #['__add__', '__class__', '__contains__', '__delattr__',
                  # '__delitem__', '__delslice__', '__doc__', '__eq__', '__ge__',
                  # '__getattribute__', '__getitem__', '__getslice__', '__gt__',
                  # '__hash__', '__iadd__', '__imul__', '__init__', '__iter__',
                  # '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__',
                  # '__reduce__', '__reduce_ex__', '__repr__', '__reversed__',
                  # '__rmul__', '__setattr__', '__setitem__', '__setslice__',
                  # '__str__', 'append', 'count', 'extend', 'index', 'insert',
                  # 'pop', 'remove', 'reverse', 'sort']
                 
dic1={'juan':44,'ana':3}
print dir(dic1)   # ['__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__',
                  # '__doc__', '__eq__', '__ge__', '__getattribute__', '__getitem__', '__gt__',
                  # '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__',
                  # '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__',
                  # '__str__', 'clear', 'copy', 'fromkeys', 'get', 'has_key', 'items', 'iteritems',
                  # 'iterkeys', 'itervalues', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

Si le pasamos como parámetro el nombre de un módulo la función dir nos retorna todas las funciones definidas entre otros datos (recordemos que hemos estado utilizando la función randint para generar un valor aleatorio y como podemos ver se encuentra listado al llamar a la función dir):

import random

print dir(random) # ['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST',
                  # 'SystemRandom', 'TWOPI', 'WichmannHill', '_BuiltinMethodType', '_MethodType',
                  # '__all__', '__builtins__', '__doc__', '__file__', '__name__', '_acos', '_ceil',
                  # '_cos', '_e', '_exp', '_hexlify', '_inst', '_log', '_pi', '_random', '_sin',
                  # '_sqrt', '_test', '_test_generator', '_urandom', '_warn', 'betavariate',
                  # 'choice', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate',
                  # 'jumpahead', 'lognormvariate', 'normalvariate', 'paretovariate', 'randint',
                  # 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'uniform',
                  # 'vonmisesvariate', 'weibullvariate']

Función de uso común (help).

La función help tiene por objetivo ayudar al programador dando información de documentación definidas en módulos, funciones, clases etc.
Veamos que nos devuelve la función help si le pasamos como parámetro la función randint:

import random

help(random.randint) # Help on method randint in module random: randint(self, a, b)
                     # method of random.Random instance Return random integer in
                     # range [a, b], including both end points.

Podemos observar que nos informa el módulo donde se almacena, sus parámetros y el objetivo de la misma.
Nosotros podemos crear cadenas de documentación para nuestras funciones con la siguiente sintaxis:

def sumar(v1,v2):
    """El objetivo de esta funcion es realizar la
       suma de los dos valores que recibe como
       parametro y retornarlo."""
    su=v1+v2
    return su

help(sumar) # Help on function sumar in module __main__: sumar(v1, v2)
            # El objetivo de esta funcion es realizar la suma de los
            # dos valores que recibe como parametro y retornarlo.

El string que definamos inmediatamente después de la cabecera se tomará como cadena de documentación de la función. Como en este caso nuestra cadena de documentación ocupa varias líneas en Python podemos encerrarla entre triples comillas y no deberemos indicar el caracter de continuación de línea (Si la cadena de documentación es una sola línea podemos emplear una sola comillas al principio y al final)
Si utilizamos una sola comillas debemos indicar al final de cada línea que continúa:

def sumar(v1,v2):
    "El objetivo de esta funcion es realizar la \
    suma de los dos valores que recibe como \
    parametro y retornarlo."
    su=v1+v2
    return su

Podemos crear cadenas de documentación para definir objetivos del mismo.
Si tenemos un módulo mínimo llamado: modulo1.py, podemos definir las siguientes cadenas de documentación

"cadena de documentacion del modulo"

def holamundo():
    "cadena de documentacion de funcion"
    print('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).

Asignaciones múltiples.
Python permite asignaciones múltiples:

x1,x2,x3=1,2,3
print x1 # 1
print x2 # 2
print x3 # 3

Para entenderlo mejor podemos también utilizar esta sintaxis:

x1,x2,x3=(1,2,3)
print x1 # 1
print x2 # 2
print x3 # 3

Es decir lo que estamos haciendo inicializar cada una de las variables de la izquierda con las componentes homólogas (de la misma posición) de la tupla.
Esta característica es útil si tenemos que recuperar por ejemplo de una lista que contiene tuplas de dos elementos que representan puntos en el plano (x,y):

puntos=[(10,2),(4,2),(9,3)]
for x,y in puntos:
    print 'Coordenada x:%d y:%d' % (x,y)
    print '<br>'

Cada vuelta del for se almacena en x e y los valores de la tupla a procesar.
Otra aplicación muy útil es si queremos intercambiar el valor de dos variables la forma más simple es:

x=10
y=20
print x # 10
print y # 20
x,y = y,x
print x # 20
print y # 10

En una asignación pueden intervenir valores de distinto tipo (enteros, reales, string etc.):

nombre,edad,sueldo=('juan',32,1500.30)
print 'Nombre:%s Edad:%d Sueldo%10.2f' % (nombre,edad,sueldo)
      # Nombre:juan Edad:32 Sueldo 1500.30

Podemos con esto hacer que una función retorne más de un dato (por lo menos en apariencia), esto lo logramos retornando una tupla:

def sumadiferencia(x1,x2):
    suma=x1+x2
    diferencia=x1-x2
    return (suma,diferencia)

su,di=sumadiferencia(10,4)
print su # 14
print di # 6

Como vemos llamamos a una función y le asignamos el valor devuelto a dos variables.
Si queremos inicializar tres variables con el mismo valor la sintaxis que podemos utilizar es:

x1=x2=x3=10
print x1 # 10
print x2 # 10
print x3 # 10

Funciones con parámetros por defecto.

Como habíamos visto una función es una estructura de programación que agrupa un conjunto de instrucciones y resuelve un problema particular. Una función puede tener parámetros, los mismos almacenan los valores que se le pasan cuando la llamamos.
En algunos casos si queremos que la función sea mas flexible podemos definir parámetros con valores por defecto. Esto nos permite llamar a la función pudiendo o no pasar datos a dichos parámetros.
Veamos con un ejemplo este concepto, vamos a desarrollar una función que reciba un dato a imprimir, con la posibilidad de indicarle el color de fuente y el color de fondo, en caso de no indicarle dichos valores la función muestra el dato con color negro y fondo blanco.

def mostrartitulo(dato,colorletra='#000',colorfondo='#fff'):
    print '<h1 style="color:'+colorletra+';background-color:'+colorfondo+'">'+dato+'</h1>'

mostrartitulo('Primer titulo')
mostrartitulo('Segundo titulo','#f00')
mostrartitulo('Tercer titulo','#f00','#000')

Como podemos ver para indicar a Python que un parámetro es por defecto debemos utilizar el operador de asignación en la declaración de la cabecera de la función junto al valor que tomará dicho parámetro en caso de no pasarlo desde donde la llamamos:

def mostrartitulo(dato,colorletra='#000',colorfondo='#fff'):

Cuando llamamos la función mostrartitulo podemos hacerlo de diferentes maneras:

mostrartitulo('Primer titulo')
mostrartitulo('Segundo titulo','#f00')
mostrartitulo('Tercer titulo','#f00','#000')

La primer llamada es pasando un único dato, es decir solo el título que debe mostrar, en este caso el segundo y tercer parámetro toman como valor el indicado en el declaración:

colorletra='#000',colorfondo='#fff'

Podemos llamar a la función mostrartitulo pasando el primer parámetro y el segundo, lo que hace que el tercer parámetro se inicialice con el indicado en la declaración de la función:

mostrartitulo('Segundo titulo','#f00')

En el ejemplo la tercer llamada a la función se hace pasando tres parámetros:

mostrartitulo('Tercer titulo','#f00','#000')

Como podemos ver los parámetros por defecto nos permiten implementar funciones más generales, con esto podemos hacer que las funciones sean útiles para mayor cantidad de situaciones.
Que pasa si queremos llamar la función indicando el primer y último parámetro, esto solo se puede hacer si al llamar la función indicamos que dato se le pasa a cada parámetro:

def mostrartitulo(dato,colorletra='#000',colorfondo='#fff'):
    print '<h1 style="color:'+colorletra+';background-color:'+colorfondo+'">'+dato+'</h1>'

mostrartitulo(dato='Primer titulo',colorfondo='#00f')

Si bien se hace más engorroso la llamada a la función al tener que indicar el nombre de cada parámetro junto al valor, nos trae como beneficio que sea aún más flexible.
Funciones con una cantidad variable de parámetros.

Otra posibilidad en la declaración de una función en Python es la definición de una cantidad variable de parámetros.
Para definir una cantidad variante de parámetros debemos antecederle el caracter asterísco (*) al último parámetro de la función.
Supongamos que necesitemos implementar una función que le enviemos una serie de enteros y nos retorne la suma de todos ellos (como mínimo le enviamos 2 y no hay un máximo de valores):

def sumar(x1,x2,*xn):
    s=x1+x2
    for valor in xn:
        s=s+valor
    return s

print sumar(1,2)
print '<br>'
print sumar(1,2,3,4)
print '<br>'
print sumar(1,2,3,4,5,6,7,8,9,10)

Lo que en realidad el lenguaje Python hace es una tupla con todos los valores de los parámetros a partir del tercero.
Luego nuestro algoritmo debe recorrer la tupla para procesar los elementos propiamente dichos, en nuestro caso con un for in y los sumamos junto al primer y segundo parámetro.
Luego cuando hacemos la llamada a la función:

print sumar(1,2)

Si pasamos solo dos parámetros la tupla se inicializa vacía, por lo que el for in no ejecuta el bloque contenido.
Si llamamos la función con 10 parámetros:

print sumar(1,2,3,4,5,6,7,8,9,10)

Luego la tupla se crea con 7 elementos.

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:

Hydrogen es un avanzado sintetizador de batería que te permite programar sencillos patrones de ritmo con resultados verdaderamente profesionales.

Hydrogen cuenta con una interfaz totalmente gráfica y relativamente fácil de usar, con soporte para simples, un secuenciador basado en patrones, múltiples capas disponibles para los diversos instrumentos y hasta 32 pistas de composición.

Pros

• Interfaz muy visual y fácil de utilizar
• Hasta 32 pistas

Contras

• Algunos problema
• Faltan algunos sonidos de batería

7.- El Editor de instrumentos.
En cada patrón pueden aparecer hasta 32 instrumentos. Y cada instrumento puede ser un único sonido basado en una muestra de audio o bién una combinación de hasta 16 capas de muestras.
Los instrumentos con múltiples capas permiten crear sonidos más ricos y sobretodo más realistas. Tienes más información sobre este efecto en una caja amarilla.

La siguiente figura muestra una caja (snare) con 5 capas de muestras.

 
 
8.- Transformando una caja en un bombo.
Hydrogen, como buen instrumento basado en muestras (o directamente "sampler" que es, permite ajustar parámetros de la reproducción de las muestras, para diseñar el sonido a tu gusto:
Estas opciones se encuentran en la ventana Instrument editor
Vamos a ver un ejemplo práctico del uso de estos controles. El objetivo de este ejemplo es crear un sonido de bombo a partir de una muestra de caja. Para empezar, asegúrate que Hydrogen está en pattern mode, sino ponlo en este modo usando el botón mode de la barra de transporte.
Pon una pista de caja (snare) en modo solo. Tienes dos formas de hacer esto: Desde el Pattern editor haciendo clic con el botón derecho sobre la pista de caja, o bien, desde el Mixer activando el botón del canal correspondiente.

Rellena unos cuantos golpes de caja en el patrón actual para oír constantemente el sonido que vamos a manipular. Si no lo está, selecciona el instrumento de caja en el Pattern editor.

Ahora ya estamos listos para ajustar parámetros de la ventana Instrument. Primero de todo, vamos a bajar el tono o afinación del instrumento. Para ello gira al máximo a la izquierda el botón pitch que se encuentra en la pestaña Layers. Si se tratara de un instrumento multi capa, debes repetir la operación para todas las capas.

El sonido es más grave pero aún es demasiado largo y ruidoso.
Sitúate en la pestaña Instrument y modifica el envolvente ADSR (attack, decay, sustain, release) de la siguiente forma: Gira el sustain el máximo a la izquierda, situa el decay alrededor de un 25% y asegúrate que el tiempo de ataque, botón attack está al mínimo. Con esto conseguimos que solamente suene un ataque corto de la caja.

Por último, atenua los agudos fijando un cutoff bastante bajo, y sube la resonance para realzar el efecto de filtro, tal como mostramos en la captura de pantalla.
 
9. Reciclando un loop de batería 
Selecciona un canal vacío en el Pattern Editor, abre el Instrument Editor, ve a la pestaña Layer y carga el archivo WAV correspondiente mediante el botón Load.

Repite la operación con el resto de sonidos que quieras cargar.

Utiliza tus conocimientos musicales y experimenta con los sonidos que cortaste, seguro que saldrá algo original. Debes tener en cuenta que dependiendo de si los sonidos que utilices contienen más de un golpe de percusión, estos irán al tempo original del loop y por lo tanto tendrás que ajustar el tempo de Hydrogen con el del loop original.

Finalmente, usa la opción File-Export para exportar toda tu canción en un archivo WAV.

10.- Crea tus propios drumkits .
El Drumkit Manager es, como su propio nombre indica en inglés, el gestor de los drumkits que usamos en Hydrogen. Permite exportar los kits de percusión que hayas creado con el editor de instrumentos, o importar conjuntos de instrumentos creados por otros usuarios.

Para exportar los drumkits que estes utilizando en el programa, primero debes guardarlos en la lista de drumkits. Cuando tengas tu kit listo para guardar, abre el Drumkit Manager por el panel de Save y escribe un nombre para tu kit, añade si quieres el nombre del autor (tu mismo!) y una breve descripción y guárdalo. Vuelve al panel Load y aparecerá listado junto a los kits por defecto de Hydrogen. Ahora ya puedes exportar cualquiera de los kits que aparezcan en esta lista.

Selecciona el kit a exportar, dale un nombre y haz clic en el botón Export. El archivo resultante tendrá la extensión *.h2drumkit y contendrá los ajustes de todas tus muestras así como los propios sonidos que has utilizado. Para importar sonidos que hayas descargado de internet o que tengas archivados pero no cargados en el programa, deberás importarlos primero mediante el panel Import. Localiza el archivo a importar y haz clic en Open. Ahora el archivo estará disponible en tu lista de kits para ser cargado en Hydrogen desde el panel Load.

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:

LibreOffice es una suite ofimática libre y gratuita multiplataforma que cuenta con un procesador de texto (Writer), un editor de hojas de cálculo (Calc), un gestor de presentaciones (Impress), un gestor de bases de datos (Base), un editor de gráficos vectoriales (Draw), y un editor de fórmulas matemáticas (Math).

LibreOffice fue creada por la fundación The Document Foundation como una bifurcación (fork) de la suite OpenOffice.org en octubre de 2010. Está disponible bajo la licencia GNU Lesser General Public License.

La compra de Sun Microsystems (líder del desarrollo de OpenOffice.org) por Oracle fue el desencadenante de esta bifurcación debido a la orientación dada por Oracle.

LibreOffice 3.3 ha sido descargado más de 1,3 millones de veces. Es la suite ofimática predeterminada en Debian (versión testing), Ubuntu, openSUSE, Fedora y Mageia

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:

Wammu es un programa para manejar los datos en el teléfono celular como los contactos, calendario y mensajes.

Está creado sobre la biblioteca Gammu, que provee una capa de abstracción para trabajar con diferentes teléfonos celulares de diferentes proveedores (incluyendo Nokia, Sony-Ericsson, Motorola, Samsung, Siemens, Huawei y otros).

Con Wammu, podremos sincronizar teléfonos móviles Symbian sin ningún problema, además de incluir soporte para otros terminales con sistema operativo propiedad de la marca como pueden ser Nokia, Samsung, Alcatel, Siemens, Motorola o Sharp entre otros modelos.

Para revisar el soporte de un modelo de teléfono la mejor fuente es la Base de datos de teléfonos Gammu que contiene la experiencia de los usuarios con Gammu y diferentes modelos de teléfono.

Familia Gammu.

Gammu ya no es solo un único programa sino que también hay muchas herramientas útiles que comparten la misma biblioteca.

Wammu.

Programa con Interfaz gráfica para manejar contactos, tareas, calendario y mensajes en tu teléfono.

Gammu.

Utilidad de línea de comandos que permite usar todas las funciones de libGammu.

libGammu.

Biblioteca que exporta una API C para comunicarse con teléfonos celulares.

Gammu SMSD.

Servicio de demonio SMS para recibir y mandar mensajes automaticamente.

Python-Gammu.

Vinculaciones Python para libGammu para poder utilizala desde scripts Python.

Kalkun.

Manejador web de SMS («Short Message Service») de código abierto de terceras partes que utiliza Gammu SMSD.

Descargas:

Ultima versión estable: 1.33.0

Gammu.

• Código fuente
• Paquetes para Debian
• Paquetes para Ubuntu
• Paquetes para Ubuntu en repositorio personal (PPA, última versión estable)
• Paquetes para Ubuntu en repositorio personal (PPA, última versión de pruebas)
• Acceso o copias del repositorio git

Wammu.

• Código fuente
• Paquetes para Debian
• Paquetes para Ubuntu
• Paquetes para Ubuntu en repositorio personal (PPA, última versión estable)
• Paquetes para Ubuntu en repositorio personal (PPA, última versión de pruebas) .
• Acceso o copias del repositorio git

 

Capturas de pantallas.

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:

 

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

 

2.- 11 excusas para no usar Ubuntu.

Estos son algunos de los argumentos que los usuarios de Windows utilizan para no usar Ubuntu ( incluye a Linux en general). Los escucho a diario cuando dicen ,,,,"como podés usar eso y no tener Windows". Los tengo , tanto XP y Seven ( originales) y los he usado por mucho tiempo, solo que los quité de mis ordenadores de uso privado. Algunos cuestionamientos que se hacen por desconocimiento.

 

3.- 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.
• LightDM PPS cayó de un uso de 25.7M a 0.6M
• Algunos procesos fueron modificados para que terminen si no se usan y se reinicien cuando se demandan, por ejemplo signond, signon-ui.

 

4.- Guía HTML: introducción y estructura interna de una página.

En una reciente limpieza a mi disco duro he encontrado esta guia que tenia guardada por ahi y creo que esta muy buena para empezar y conocer las nociones basicas del HTML.
Introducción.
HTML es el lenguaje que se emplea para el desarrollo de páginas de internet.
Este lenguaje está constituido de elementos que el navegador interpreta y las despliega en la pantalla de acuerdo a su objetivo. Veremos que hay elementos para disponer imágenes sobre una página, hipervínculos que nos permiten dirigirnos a otra página, listas, tablas para tabular datos, etc.

 

5.- Guia Python: funciones, estructuras y formatos (2a parte).

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

 

6.- Diseño Gráfico en Linux: completo videotutorial de Gimp (28 vídeos).

GIMP (GNU Image Manipulation Program) es un programa de edición de imágenes digitales en forma de mapa de bits, tanto dibujos como fotografías. Es un programa libre y gratuito. Forma parte del proyecto GNU y está disponible bajo la Licencia pública general de GNU. Es el programa de manipulación de gráficos disponible en más sistemas operativos (Unix, GNU/Linux, FreeBSD, Solaris, Microsoft Windows y Mac OS X, entre otros).

 

7.- Guia Python: operadores y estructuras (2a parte).

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

 

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

 

9.- Guia Python: funciones, estructuras y formatos (3a parte).

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

 

10.- Workarround para usar PulseAudio y Jack de forma sencilla.

Para los que están metidos en el mundo de grabación y producción musical en GNU/Linux de seguro están más que familiarizados con JACK (una herramienta excelente), y seguramente tengan más de una placa de audio (alguna interfaz profesional, la placa de sonido onboard, el micrófono incorporado en las cámaras web, etc) y la forma más fácil de tener todas las placas en orden es a través de PulseAudio.

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).
Indices negativos en tuplas, listas y string.

Hemos visto que en Python accedemos a los elementos de una lista, tupla y string mediante un subíndice que comienza a numerarse a partir de cero:

tupla=(2,4,6,8,10)
print tupla[0]   # 2
lista=[2,4,6,8,10]
print lista[0]   # 2
cadena='hola'
print cadena[0]   # h

Si queremos acceder a la última componente podemos hacerlo:

tupla=(2,4,6,8,10)
print tupla[len(tupla)-1] # 10

Pero Pyton tiene integrado en el lenguaje el acceso de los elementos de la secuencia mediante índices negativos, por ejemplo si queremos acceder a la última componente luego podemos hacerlo con la siguiente sintaxis:

tupla=(2,4,6,8,10)
print tupla[-1]   # 10
lista=[2,4,6,8,10]
print lista[-1]   # 10
cadena='hola'
print cadena[-1]   # a

Es mucho más cómodo utilizar esta segunda forma para acceder a los elementos de una lista, tupla o cadena de caracteres.
Si queremos imprimir los elementos de una tupla en forma inversa (es decir desde el último elemento hasta el primero) podemos hacerlo con el siguiente algoritmo:

tupla=(2,4,6,8,10)
indice=-1
for x in range(0,len(tupla)):
    print tupla[indice] # 10 8 6 4 2
    indice=indice-1

Estructura de datos tipo diccionario.

Las estructuras de datos vistas hasta ahora (tuplas y listas) utilizan un entero como subíndice. La estructura de datos tipo diccionario 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.
Si queremos almacenar la cantidad de productos que tenemos en stock podemos implementar un diccionario donde utilizamos como clave el nombre del producto y como valor la cantidad de productos disponibles.
Podemos definir un diccionario con la siguiente sintaxis:
productos={'manzanas':23,'peras':50,'papas':120}
Luego si queremos acceder a la cantidad de productos en stock utilizamos como subíndice el nombre del producto:

print productos['manzanas']

La línea anterior produce como resultado el valor 23.
Mediante un diccionario asociamos para toda clave un valor.
Podemos borrar cualquier entrada dentro del diccionario empleando la siguiente sintaxis:

del(productos['manzana'])

Luego si imprimimos el diccionario en forma completa tenemos como resultado que ya no contiene la entrada 'manzana':

print propductos

{'peras': 50, 'papas': 120}

Podemos modificar el valor asociado a una clave mediante una simple asignación:

productos['papas']=5

Luego si imprimimos el diccionario obtenemos como resultado:

{'peras': 50, 'papas': 5}

Podemos conocer en cualquier momento la cantidad de pares clave-valor que contiene nuestro diccionario mediante la función len:

print len(productos)

Con nuestro problema tenemos como resultado que nuestro diccionario tiene 2 elementos.
Formato de cadenas de caracteres (string).

Cuando tenemos que combinar cadenas de caracteres e incorporarle valores almacenados en otras variables el lenguaje Python nos suministra una técnica para incrustar valores dentro de la cadena.
Veamos mediante ejemplos cual es la sintaxis para plantear estos formatos de cadenas:

x1=10
x2=5
x3=20
print 'El contenido de la primer variable es %d, de la segunda %d y la tercera %d' % (x1,x2,x3)

Si bien podemos utilizar el operador + para ir concatenando cadenas y variables esta técnica hace que nuestro programa sea más legible sobre todo cuando tenemos que sustituir varias variables dentro de una cadena.
Primero indicamos entre comillas la cadena y utilizamos el símbolo % para indicar el lugar donde se sustituirá el valor, debemos indicar luego del caracter % el tipo de dato (en nuestro ejemplo un valor decimal (d))
Luego de la cadena debemos indicar una tupla con los valores o variables de donde se obtendrán los datos. Entre la cadena de formato y la tupla debemos disponer el caracter % (aquí el caracter porcentaje tiene un objetivo distinto que dentro de la cadena de formato)
Se especifican distintos caracteres para cada tipo de dato a sustituir:

x=10
g=10.2
cadena='juan'
print 'El valor entero %d el valor real %f y la cadena %s' % (x,g,cadena)

En el ejemplo propuesto vemos que podemos utilizar los caracteres de formato d (decimal), f (float) y s (string).
Es importante el orden de los valores de la tupla ya que el lenguaje procesa los datos en forma secuencia, es decir cada vez que debe sustituir un valor en la cadena extrae de la tupla el siguiente valor.
Cuando damos formato a una variable real (con coma) podemos disponer dos valores previos al caracter f:

g=20.5498
print 'El valor real es %10.2f' % (g)

El primer valor indica el largo total a reservar y el segundo la cantidad de decimales.
Podemos convertir el valor decimal a tipo octal o hexadecimal:

x=255
print 'Decimal %d en hexadecimal es %x y en octal %o' % (x,x,x)
      #Decimal 255 en hexadecimal es ff y en octal 377 

No es obligatorio que el formato de cadena se utilice siempre en un print, podemos almacenar el resultado del formato en otra variable string (que podemos eventualmente almacenarla en una base de datos por ejemplo).

vx=10
vy=90
resultado='(%d,%d)' % (vx,vy)
print resultado # (10,90)

También podemos indicar un valor entero en el formato para los tipos de datos enteros y string:

x1=100
x2=1500
x3=5
print '<pre>'
print '%5d' % (x1)
print '%5d' % (x2)
print '%5d' % (x3)
print '</pre>'

El resultado por pantalla es:

100
1500
    5

Es decir reserva en este caso 5 espacios para el entero y hace la alineación a derecha.
Si indicamos un valor negativo los datos se alínean a izquierda:

animales=['perro','elefante','pez']
print '<pre>'
for elemento in animales:
    print '%20s' % elemento
for elemento in animales:
    print '%-20s' % elemento
print '</pre>'

El resultado de ejecutar el programa es:

perro
  elefante
  pez
perro              
elefante           
pez                

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).
Porciones de tuplas.

El lenguaje Python nos permite rescatar una "porción" de una tupla, es decir un trozo de la misma.
Si tenemos la siguiente tupla:

tupla1=(1,7,20,40,51,3)

tupla2=tupla1[0:4]
print tupla2

El resultado es una tupla con cuatro valores:

(1,7,20,40)

Es decir indicamos como subíndice un rango de valores, en este caso desde la posición 0 hasta la posición 4 sin incluirla.
Podemos no indicar alguno de los dos rangos:

tupla1=(1,7,20,40,51,3)

tupla2=tupla1[3:]
print tupla2

El resultado es una tupla con tres valores, desde la posición 3 hasta el final de la tupla:

(40, 51, 3)

En caso de no indicar el primer rango:

tupla1=(1,7,20,40,51,3)
tupla2=tupla1[:2]
print tupla2

El resultado es una tupla con dos valores, desde el principio de la tupla hasta la posición 2 sin incluirla:

(1, 7)

Estructura de datos tipo cadena de caracteres (string).

Una cadena de caracteres permite almacenar un conjunto de caracteres. Su funcionamiento es similar a una tupla.
Para inicializar un string utilizamos el operador de asignación.

nombre='Juan Pablo'

Podemos utilizar las comillas simples o dobles para su inicialización:

mail='jose@gmail.com'

o

mail="jose@gmail.com"

Para conocer el largo de un string podemos utilizar la función len:

print len(mail)

Para acceder a un caracter particular del string lo hacemos indicando un subíndice entre corchetes:

print mail[0]  #Imprimimos el primer caracter

El lenguaje Python nos permite rescatar una "porción" de un string con la misma sintaxis que trabajamos las tuplas:

nombre='Jose Maria'
print nombre[1:4]  #ose
print nombre[:4] #Jose
print nombre[5:] #Maria

Los string son inmutables, es decir que no podemos modificar su contenido luego de ser inicializados:

titulo='Administracion'
titulo[0]='X' # Esto produce un error

Esto no significa que no podemos utilizar la variable para que referencie a otro string:

nombre='Jose'
print nombre
nombre='Ana'
print nombre

Para concatenar string Python permite utilizar el operador +.
Si tenemos tres string y queremos almacenar sus contenidos en un cuarto string podemos codificarlo de la siguiente manera:

cadena1='uno'
cadena2='dos'
cadena3='tres'
total=cadena1+cadena2+cadena3
print total #unodostres

También Python define el operador * para los string. El resultado de multiplicar un string por un entero es otro string que repite el string original tantas veces como indica el número.

#si queremos un string con 80 caracteres de subrayado, la forma más sencilla es utilizar la siguiente expresión:
separador='_'*80
print separador

Los operadores relacionales definidos para los string son:

> Mayor
>= Mayor o igual
< Menor
<= Menor o igual
== Igual
!= Distinto

Si queremos saber si un string es mayor alfabéticamente que otro utilizamos el operador >

nombre1='CARLOS'
nombre2='ANABEL'
if nombre1>nombre2:
    print nombre1+' es mayor alfabéticamente que '+nombre2

si queremos saber si dos variables tienes en mismo contenido:

nombre1='CARLOS'
nombre2='CARLOS'
if nombre1==nombre2:
   print 'Las dos variables tienen el mismo contenido:'+nombre1

Estructura de datos tipo lista.

Una lista es una colección de datos no necesariamente del mismo tipo que se los accede por medio de subíndices. La diferencia fundamental de una lista con una tupla es que podemos modificar la estructura luego de haberla creado.
Hay varias formas de crear una lista, la primera y más sencilla es enumerar sus elementos entre corchetes y separados por coma:

lista1=['juan','ana','luis']

Para acceder a sus elementos lo hacemos indicando un subíndice subíndice:

print lista1[0]

Como decíamos la diferencia con una tupla (son inmutables) es que podemos modificar la lista luego de creada:

lista1=[10,15,20]
print lista1
print '<br>'
lista1[0]=700 # modificamos el valor almacenado en la primer componente de la lista.
print lista1

De forma similar a las tuplas y string la función len nos informa de la cantidad de elementos que contiene la lista:

lista1=[10,15,20]
print len(lista1) # imprime un 3

Es muy común emplear la estructura for in para recorrer y rescatar cada elemento de la lista, la variable elemento almacena en cada ciclo del for un elemento de la lista1, comenzando por el primer valor:

lista1=['juan',23,1.92]
for elemento in lista1:
    print elemento
    print '<br>'

Si queremos saber si un valor se encuentra en una lista existe un operador llamado in:

lista1=[12,45,1,2,5,4,3,55]
if 1 in lista1:
    print 'El valor 1 está contenido en la lista '
else:
    print 'El valor 1 no está contenido en la lista '
print lista1

Python define los operadores + y * para listas, el primero genera otra lista con la suma de elementos de la primer y segunda lista. El operador * genera una lista que repite tantas veces los elementos de la lista como indica el valor entero seguido al operador *.

lista1=[2,4,6,8]
lista2=[10,12,14,16]
listatotal=lista1+lista2
print listatotal

Luego empleando el operador *:

lista1=['juan','carlos']
producto=lista1*3
print producto

El resultado de este algoritmo es:

['juan', 'carlos', 'juan', 'carlos', 'juan', 'carlos']

También con listas podemos utilizar el concepto de porciones que nos brinda el lenguaje Python:

lista=[2,4,6,8,10]
print lista[2,4]   #[6, 8]
print lista[:3]    #[2, 4, 6]
print lista[3:]    #[8, 10]

Como vimos podemos modificar el contenido de elementos de la lista asignándole otro valor:

lista=[2,4,6]
lista[1]=10
print lista  #[2, 10, 6]

Podemos borrar elementos de la lista utilizando la función del:

lista=[2,4,6]
del(lista[1])
print lista  #[2, 6]

Además podemos utilizar porciones para borrar un conjunto de elementos de la lista:

lista=[2,4,6]
del(lista[1:])
print lista  #[2]

También podemos añadir elementos a una lista:

lista=[5,10,11,12]
lista[1:1]=[6,7,8,9]
print lista #[5,6,7,8,9,10,11,12]

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: