El futuro de la tecnología y sus consecuencias...


El cómic traducido al español dice algo como lo siguiente:

-"La forma cómo vemos el futuro de la tecnología funcionará"

-"La dura realidad: 
¡Por supuesto, traté de volver a encenderlo! 
¿Por qué crees que estoy llamando?"

Vía | Geeks are Sexy
Fuente | Endless Origami

Google Music Frame: cliente nativo de Google Music en Linux


Hace ya algún tiempo, el gigante Google ha decidido hacerle competencia a servicios de streaming de musica, tales como Spotify, Grooveshark, y el ya conocido por nosotros Ubuntu One Music (aunque este llega a costarnos). Ahora bien, si hay algo que muchos de estos servicios de música en línea no tienen es precisamente un cliente que trabaje en Linux en forma nativa (es decir, sin necesidad de tener aplicaciones como Wine).


Google Music, además de ofrecernos el servicio, también nos permite adaptarlo muy bien al escritorio de Ubuntu, ya que además de ofrecernos una interfaz gráfica desde el escritorio, nos permite controlarlo desde el menú de sonido, así como sucede con Banshee.





Instálalo en Ubuntu


Para instalarlo introducimos en una terminal (consola) los siguientes comandos.

sudo add-apt-repository ppa:janousek.jiri/google-music-frame-releases
sudo apt-get update
sudo apt-get install google-music-frame

Notecard Polaroid, lo que debe tener todo amante de la escritura y la fotografía


Si eres fanático de Polaroid y te encanta estar escribiendo lo que se te ocurra en el primer papel que encuentras, Notecard es lo que buscas. Notecard te da la posibilidad de tomar tus notas con todas las características que tiene la Polaroid en sus 5 sobres y 10 hojas que nos ofrecen con este producto hecho en Japón por sólo US$11.

Vía | Incredible Things

Curso de Python: 5-Estructuras de control

Estructuras de control
Hasta ahora, el flujo de ejecución de los comandos se ha desarrollado secuencialmente (paso a paso). Las situaciones que tendrán que atender nuestros programas serán impredecibles, y la ejecución de los comandos se tendrá que realizar en base a una circunstancia dada, añadiéndole inteligencia lógica. Esto nos permitirá, por ejemplo, atender esa situación, o iterar (repetir) cierto código mientras se dé (o no) esa situación.

Operadores relacionales
Para determinar una situación (o condición), y proceder en consecuencia, se reduce dicha situación a un resultado VERDADERO (TRUE) ó FALSO (FALSE). Este resultado se obtiene mediante una expresión comparativa (o boolean), que compara dos valores mediante un operador relacional, retornando TRUE o FALSE según el resultado de dicha comparación:
>>> 6 == 7 # ¿son iguales?
False
>>> 'Pedro' != 'Felipe' # ¿son distintos?
True
>>> 100 < 101 # ¿100 es menor que 101?
True
>>> 'P' > 'Z' # ¿P es mayor que Z?
False

Operadores relacionales
a == b  ¿a es igual a b?
a != b  ¿a es distinto de b?
a < b   ¿a es menor que b?
a <= b  ¿a es menor ó igual que b?
a > b   ¿a es mayor que b?
a >= b  ¿a es mayor ó igual que b?

Control de flujo condicional
Imaginemos un caso en el que hay que informar al usuario si un valor es par o impar. Para averiguar esto, calculamos el resto de la división de ese valor entre 2. Si retorna el valor cero, es par. Si no, es impar.
>>> valor = 6
>>> if valor%2==0: # si ... entonces
... print valor, 'es par' # bloque indentado
...
6 es par

Ha de reseñarse que los bloques de código correspondientes a una estructura de código, ya sea condicional, iteracciones, etc., han de estar indentados, es decir, con una profundidad mayor utilizando la sangría o tabulación. Aquí, este bloque de código se ejecutará cuando se cumpla la condición.

Este ejemplo es muy sencillo, y sólo contempla el caso de que el valor sea par. Para que contemple también el caso de que sea impar, habrá que indicar una ejecución alternativa mediante la sentencia else (si no...):
>>> valor = 7
>>> if valor%2==0: # si ... entonces
... print valor, 'es par'
... else: # si no
... print valor, 'es impar'
...
7 es impar

Cuando hay más de dos casos o situaciones, se utilizará la ejecución encadenada elif (abreviatura de else if (si no, si...entonces)), aportando más casos o condiciones:
>>> nota = 7.2
>>> if nota<5: # Si menos de 5
... print 'Nota:',nota,' - SUSPENDIDO'
... elif nota>=5 and nota<7: # Si no, si entre 5 y 6.99
... print 'Nota:',nota,' - APROBADO SUFICIENTE'
... elif (nota>=7 and nota<9): # Si no, si entre 7 y 8.99
... print 'Nota:',nota,' - APROBADO NOTABLE'
... else: # Si no (en otros casos)
... print 'Nota:',nota,' - APROBADO SOBRESALIENTE'
...
Nota: 7.2 – APROBADO NOTABLE

Las comparaciones lógicas pueden ir o no entre paréntesis, los cuales aportan claridad y prioridad.

Operadores lógicos
Se pueden evaluar varias condiciones o expresiones comparativas, relacionando todos los resultados mediante operadores lógicos, y obteniendo un único resultado boolean. El siguiente ejemplo evalúa dos condiciones obligatorias para admitir a una candidata: ser mayor de edad Y ser mujer:
>>> edad, sexo = 19, 'M'
>>> if edad>=18 and sexo=='M':
... print 'ADMITIDA'
... else:
... print 'NO ADMITIDA'
...
ADMITIDA

El siguiente ejemplo requiere que el candidato posea un titulo O una experiencia mínima de cinco años (al menos, uno de los dos requisitos), Y, además (obligatorio), una edad mínima de 30 años.
>>> titulo, experiencia, edad = True, 7, 32
>>> if ((titulo==True or experiencia>=5) and edad>=30):
... print 'ADMITIDO/A'
... else:
... print 'NO ADMITIDO/A'
...
ADMITIDO/A

Operadores lógicos
not (exprCondic)             ¿es no...? (negación)
exprCondic1 and exprCondic2  ¿se cumplen ambas?
exprCondic1 or exprCondic2   ¿se cumple alguna?

Bucles for
Un bucle es una iteración o repetición de ejecución de código. En el caso de un bucle for, éste recorre uno a uno los elementos de una secuencia, tomando sus valores y asignándolos a una variable.

El siguiente bucle for repite 3 veces un saludo:
>>> for i in range(3): # para i en secuencia
... print 'Hola, Python'
...
Hola, Python
Hola, Python
Hola, Python

Aunque en cada iteración se asigna el valor de la secuencia a la variable i, éste no se ha utilizado. Un ejemplo sencillo sobre su uso podría ser la tabla de multiplicar:
>>> tabla = 5
>>> for i in range(1,11):
... print i, 'x', tabla, '=', i*tabla
...
1 x 5 = 5
2 x 5 = 10
3 x 5 = 15
4 x 5 = 20
5 x 5 = 25
6 x 5 = 30
7 x 5 = 35
8 x 5 = 40
9 x 5 = 45
10 x 5 = 50

El siguiente ejemplo visualiza las tablas del 1 al 10, mediante dos bucles anidados:
>>> for i in range(1,11):
... for n in range(1,11):
... print n,'x',i,'=',n*i


Bucles while
Los bucles for tienen una iteración calculada o controlada, en base a los elementos de una secuencia. Habrá situaciones en que la iteración sea impredecible, o que los valores no estén en una secuencia. Así pues, la secuencia deja de ser un modelo de iteración válido.

¡Vamos a jugar a adivinar un número!. Ahora el número de veces no está determinado por una secuencia, si no por la habilidad del usuario de acertar el número, que puede darse en más o menos intentos (iteraciones).

Para este caso, lo mejor es un bucle de tipo while, el cual repetirá un bloque de código mientras se cumpla una determinada condición:
>>> numero=50
>>> peticion=0
>>> while (numero!=peticion): # mientras numero!=peticion
... peticion=int(raw_input('Dame un numero entre 0 y 100:'))
... if (peticion<numero):
... print 'El numero a acertar es mas grande'
... elif (peticion>numero):
... print 'El numero a acertar es mas pequeño'

El bucle while se repetirá MIENTRAS el número introducido por teclado (mediante la función raw_input() a la variable peticion), no sea el mismo que el número a acertar. La entrada de datos por teclado se asigna en forma de cadena de texto, por lo que se usa la función int(), para convertir este literal a un número entero y poder compararlo como número. Adicionalmente, se añaden otras condiciones para dar al usuario una pista sobre si el número a acertar es mayor o menor al introducido.

El siguiente ejemplo solicitará un dato que repetirá como un eco hasta que se introduzca el valor 'adios':
>>> while(True): # Bucle infinito
... dato=raw_input('# ')
... print dato*3
... if (dato=='adios'):
... break # Salida del bucle

En este caso, la condición de while significa que se ejecutará siempre. Para salir del bucle, dentro de su código se han de contemplar los casos mediante sentencias if, ejecutando la sentencia break (interrumpir) para salir del bucle. Esto también funciona con los bucles for.

Uniendo bucles y estructuras de control
La secuencia para el bucle for se puede obtener de cualquier estructura de datos (internamente son secuencias), facilitando su tratamiento:

>>> lista = ['Manzana', 'Naranja', 'Platano', 'Melon']
>>> for i in lista:
... print i,'-', len(i)
...
Manzana - 7
Naranja - 7
Platano - 7
Melon - 5

La función enumerate() retorna el índice y el valor de una secuencia:
>>> for indice,valor in enumerate(lista):
... print indice,'-',valor
...
0 - Manzana
1 - Naranja
2 - Platano
3 - Melon

Cuando se trata un diccionario, la secuencia toma el valor de la clave:
>>> notas = {'Alba':8.1, 'Raul':6.5, 'Diana':8.2, 'Sergio':5.7,
'Nerea':8.3, 'Carlos':7.3}
>>> for i in notas:
... print i, '-', notas[i]
...
Alba - 8.1
Raul - 6.5
Diana - 8.7
Sergio - 5.7
Nerea - 8.3
Carlos - 7.3

El ejemplo anterior se puede simplificar gracias a la función iteritems(), la cual toma un iterador sobre el diccionario, obteniendo la clave y el valor correspondientes en cada iteración:
>>> for clave, valor in notas.iteritems():
... print clave, '-', valor


Entregas:

Enlaces de interés:

Arma tu propio Steve Jobs de papel


¿Aburrido por la salida del idolatrado Steve Jobs en Apple?. Ahora puedes estar bien tranquilo porque puedes descargar tu propio armable de Steve Jobs para que te diviertas y te siga inspirando en tu mundo tecnológico.

Vía | Super Punch

Curso de Python: 4-Estructuras de datos

Python, mediante el uso de estructuras de datos, ofrece una gran potencia y flexibilidad en la gestión de la información. Ya pudimos experimentar la utilidad y la flexibilidad de las listas, pero Python ofrece otras estructuras de datos con funcionalidades específicas, interesantes y útiles.

Secuencias
Una secuencia, genéricamente, es una colección de datos separados por comas. La secuencia más sencilla se obtiene con la función range([n],z), que retorna una lista de números enteros desde n hasta z-1:
>>> range(10) # de 0 a 9
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(5,16) # de 5 a 15
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

Las listas son también secuencias, las cuales no tienen por qué ser consecutivas, ni estar ordenadas ni ser homogéneas. Los rangos son listas de enteros secuenciales y consecutivos.

Tuplas
Una tupla es muy similar a una lista, pero se diferencia en que sus valores son estáticos (no modificables). Las tuplas son útiles, por ejemplo, para registros de una base de datos, o para pares de coordenadas x e y.
>>> tupla = 'Alba', 1234, 3.8
>>> tupla
('Alba', 1234, 3.8)
>>> tupla[1]
1234
>>> tupla = tupla, ('Diana', 4321, 7.5) # Anidamiento
>>> tupla
(('Alba', 1234, 3.8), ('Diana', 4321, 7.5))
>>> tupla[1]
('Diana', 4321, 7.5)

Conjuntos
Un conjunto es una colección de datos no ordenados y únicos (no repetidos).
>>> material = ['Tornillo', 'Clavo', 'Tuerca', 'Tornillo', 'Llave', 'Clavo']
>>> catalogo = set(material)
>>> catalogo
set(['Tornillo', 'Tuerca', 'Clavo', 'Llave'])

Los conjuntos nos permiten realizar operaciones muy útiles:
>>> 'Tuerca' in catalogo # Está 'Tuerca' en catalogo?
True
>>> catalogo2 = set(['Tuerca', 'Alcayata', 'Destornillador', 'Llave'])
>>> catalogo-catalogo2 # elementos en catalogo pero no en catalogo2
set(['Tornillo', 'Clavo'])
>>> catalogo2-catalogo # elementos en catalogo2 pero no en catalogo
set(['Alcayata', 'Destornillador'])
>>> catalogo | catalogo2 # elementos en catalogo y catalogo2
set(['Tornillo', 'Alcayata', 'Destornillador', 'Tuerca', 'Llave', 'Clavo'])
>>> catalogo & catalogo2 # elementos comunes
set(['Tuerca', 'Llave'])
>>> catalogo ^ catalogo2 # elementos no comunes
set(['Tornillo', 'Alcayata', 'Clavo', 'Destornillador'])

Diccionarios
Un diccionario es un conjunto de datos no ordenados, referenciados y accedidos por una clave única, en lugar de por un índice. Está compuesto de parejas de clave:valor. La mayor parte de las operaciones realizadas sobre el diccionario se realizan a través de la clave para localizar el valor.
>>> notas = {'Nerea':8.3, 'Alba':7.5, 'Diana':7.9}
>>> notas
{'Alba':7.5, 'Diana':7.9, 'Nerea':8.3}
>>> notas['Alba'] # Retorna valor de 'Alba'
7.5
>>> notas.get('Alba') # Retorna valor de 'Alba'
7.5

Otra forma de construir un diccionario sería mediante la función dict (de Dictionary):
>>> # Construcción simple (la clave es un literal)
... notas=dict(Nerea=8.3, Alba=7.5, Diana=7.9)

Vamos a experimentar algunas operaciones con diccionarios:
>>> notas['Carlos']=7.3 # Añade nueva clave (no existe)
>>> notas
{'Alba':7.5, 'Diana':7.9, 'Nerea':8.3, 'Carlos':7.3}
>>> notas['Alba']=8.1 # Cambia valor a 'Alba' (existe)
>>> notas
{'Alba':8.1, 'Diana':7.9, 'Nerea':8.3, 'Carlos':7.3}
>>> 'Nerea' in notas # Está 'Nerea' en el diccionario?
True
>>> del notas['Nerea'] # Borrar 'Nerea' del diccionario
>>> notas.has_key('Nerea') # Está 'Nerea' en el diccionario?
False
>>> notas
{'Alba':8.1, 'Diana':7.9, 'Carlos':7.3}
>>> notas.keys() # Claves en el diccionario
['Alba', 'Diana', 'Carlos']
>>> notas.values() # Valores en el diccionario
[8.1, 7.9, 7.3]
>>> notas['Nerea']=8.3 # Añade 'Nerea' al diccionario
>>> notas
{'Diana':7.9, 'Alba':8.1, 'Nerea':8.3, 'Carlos':7.3}
>>> len(notas) # Tamaño del diccionario
4
>>> notas2=notas.items() # Copia del diccionario como lista
>>> notas2 # es una lista de tuplas, no un diccionario
[('Diana',7.9), ('Alba',8.1), ('Nerea',8.3), ('Carlos', 7.3)]
>>> notas2=notas.copy() # Copia el diccionario a notas2
>>> notas2
{'Diana':7.9, 'Alba':8.1, 'Nerea':8.3, 'Carlos':7.3}
>>> notas2.pop('Alba') # Quita a Alba del diccionario notas2
8.1
>>> notas2
{'Diana':7.9, 'Nerea':8.3, 'Carlos':7.3}
>>> notas3={'Diana':8.2, 'Sergio':5.7, 'Raul':6.5} # nuevo diccionario
>>> notas
{'Diana':7.9, 'Alba':8.1, 'Nerea':8.3, 'Carlos':7.3}
>>> notas.update(notas3) # Actualiza notas con notas3
>>> notas
{'Alba':8.1, 'Raul'_6.5, 'Diana':8.2, 'Sergio':5.7, 'Nerea':8.3,
'Carlos':7.3}



Entregas:

Enlaces de interés:

JSFiddle: Un entorno de desarrollo Web online

Las aplicaciones web empiezan a suplantar las funcionalidades de las aplicaciones de desarrollo. Los navegadores y los lenguajes de programación evolucionan de forma imparable. Ya es posible prescindir de clientes de correo, e incluso de aplicaciones de oficina, por poner algún ejemplo conocido.

JSFiddle es una aplicación que contiene un entorno de desarrollo, en el que un programador puede desarrollar aplicaciones en HTML, CSS y JavaScript, ejecutarlas online y ver los resultados. Al igual que un IDE, permite el coloreado de sintaxis, autocompletado de etiquetas, validar el código JavaScript... Además, permite incluir algunos frameworks de JavaScript, como MooTools, JQuery, Prototype, YUI, Dojo, ExtJS, etc. Por si fuera poco todo ésto, incluye ejemplos prácticos en cada librería JavaScript, como el que se adjunta en el pantallazo siguiente, generado con JQuery, y en el que con muy pocos cambios se puede realizar una lectura de una cuenta Twitter.


Vía | Página oficial de JSFiddle

Mandriva 2011 liberada

Ya está disponible la última versión de esta veterana distribución de Linux, llamada Mandriva 2011 "Hydrogen". Tras la crisis sufrida por la recapitalización de la compañía, por la marcha de los principales desarrolladores hacia Mageia, y tras las dudas surgidas sobre si la compañía se centraría sólo en la parte de negocio, Mandriva resurge de sus cenizas, demostrando con esta release que sigue presente en la comunidad.
 
Entre sus principales características cabe destacar las siguientes:
  • Kernel 2.6.38.7
  • Gestor de paquetes RPM5
  • Gestor de servicios Systemd (en lugar de Sysvinit)
  • Escritorio KDE 4.6.5
  • LibreOffice 3.4.2
  • Firefox 5.0.1
  • Reproductor multimedia Clementine (en lugar de Amarok)
  • Editor de vídeo Pitivi
  • Gestor de fotografías Shotwell (en lugar de DigiKam)
  • Gestión de comunicaciones KNetworkmanager
  • Cliente de microblogging Choqok


Anuncio | Anuncio de Mandriva
Notas | Notas de la release
Tour | 2011.0 Tour 
Descarga | Repositorio de descarga

Curso de Python: 3-Listas

Listas

Python gestiona colecciones de valores llamadas listas o arrays dinámicos. A diferencia de los arrays o matrices en otros lenguajes de programación, las listas poseen características más avanzadas y potentes, como la posibilidad de trabajar con diferentes tipos de datos, ordenar o invertir los datos, etc.

Una lista se crea definiendo entre corchetes todos sus valores separados por comas. Los valores de una lista pueden ser homogéneos (del mismo tipo) o heterogéneos (distinto tipo):
>>> semestre = ['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio']
>>> notas = [5.4, 6.2, 3.3, 4.0, 8.3]
>>> lista = ['Nerea', 7.8, 'Carlos', 7.5]

Si deseamos añadir más elementos al final de una lista, utilizaremos la función append() (añadir): 
>>> lista.append('Cristina')
>>> lista.append(7.3)
>>> lista
['Nerea', 7.8, 'Carlos', 7.5, 'Cristina', 7.3]

El acceso a los elementos de la lista es similar al de los caracteres en un literal:

>>> lista[2] # Acceso al segundo elemento 'Carlos'
>>> lista[:2] # Elementos hasta la posicion 2
['Nerea', 7.8]
>>> lista[2:] # Elementos desde la posicion 2
['Carlos', 7.5, 'Cristina', 7.3]
>>> lista[2:4] # Elementos en el rango 2 a 4
['Carlos', 7.5]
>>> lista[-2] # Penultimo elemento
'Cristina'

Para conocer el tamaño de la lista, se utiliza la función len():

>>> print "Tamaño de lista:", len(lista), "elementos"
Tamaño de lista: 6 elementos

A diferencia de un literal, una lista permite cambiar el valor de sus elementos. En el siguiente ejemplo, se suma medio punto a la nota de Cristina:
>>> lista[5] = lista[5]+0.5
>>> lista
['Nerea', 7.8, 'Carlos', 7.5, 'Cristina', 7.8]

Para saber cuántas veces aparece un valor dentro de una lista, se utiliza la función count() (contar): 
>>> lista.count(7.8)
2

Para conocer la posición de la primera ocurrencia de un determinado valor, usar la función index() (índice):

>>> lista.index('Carlos')
2

En el siguiente ejemplo, se sustituye a Carlos por Javier, así como también su nota:

>>> lista[2:4]=['Javier',6.7] # rango 2 a 4
>>> lista
['Nerea', 7.8, 'Javier', 6.7, 'Cristina', 7.8]

Para eliminar elementos, la función remove() (quitar) localiza en la lista el primer elemento encontrado, y lo quita de la lista:
>>> lista.remove('Cristina') # Quita el elemento 'Cristina'
>>> lista
['Nerea', 7.8, 'Javier', 6.7, 7.8]
>>> lista.insert(4,'Cristina') # Inserta 'Cristina' en pos. 4
>>> lista
['Nerea', 7.8, 'Javier', 6.7, 'Cristina', 7.8]

Se puede eliminar más elementos, indicando un rango de la lista y asignándole una lista vacía:
>>> lista[4:6]=[]
>>> lista
['Nerea', 7.8, 'Javier', 6.7]

Otra forma de eliminar elementos es mediante la función pop() (reventar), que muestra el valor del elemento eliminado. Si no se especifica parámetro, elimina el valor de la última posición de la lista:
>>> lista.pop() # último elemento
6.7
>>> lista
['Nerea', 7.8, 'Javier']
>>> lista.pop(1) # elemento nº 1
7.8
>>> lista
['Nerea', 'Javier']

Para insertar un elemento, se utiliza la función insert(), indicando la posición y el elemento a insertar:
>>> lista=['Nerea', 7.8, 'Javier', 6.7]
>>> lista.insert(2, 'Antonio')
>>> lista.insert(3, 6.7)
>>> lista.insert(4, 'Carmen')
>>> lista.insert(5, 7.2)
>>> lista
['Nerea', 7.8, 'Antonio', 6.7, 'Carmen', 7.2, 'Javier', 6.7]

También se pueden insertar elementos de forma similar a reemplazar, pero indicando en el rango la misma posición de inicio que de fin. El siguiente ejemplo hace en una línea lo mismo que el ejemplo anterior:
>>> lista=['Nerea', 7.8, 'Javier', 6.7]
>>> lista[2:2]=['Antonio', 6.7, 'Carmen', 7.2]

Para añadir una lista a otra lista utilizaremos la función extend() (extender), o sumaremos ambas listas:
>>> listab = ['Juan', 5.4, 'Luis', 6.8]
>>> lista
['Nerea', 7.8, 'Antonio', 6.7, 'Carmen', 7.2, 'Javier', 6.7]
>>> lista.extend(listab) # O también lista=lista+listab
>>> lista
['Nerea', 7.8, 'Antonio', 6.7, 'Carmen', 7.2, 'Javier', 6.7, 'Juan', 5.4, 'Luis', 6.8]

Lo siguiente vacía por completo la lista (sin valores de inicio ni fin en el rango, se asume toda la lista):
>>> lista[:]=[] # Vacía la lista
>>> lista
[]

Gracias a la función sort() (ordenar), los valores de una lista se ordenan alfabéticamente, o de menor a mayor, siempre y cuando ésta es homogénea (datos del mismo tipo).
>>> semestre.sort()
>>> semestre
['Abril', 'Enero', 'Febrero', 'Junio', 'Marzo', 'Mayo']

También es posible invertir los elementos de la lista, gracias a la función reverse() (invertir).
>>> semestre.reverse()
>>> semestre
['Mayo', 'Marzo', 'Junio', 'Febrero', 'Enero', 'Abril']

Los valores de una lista pueden ser también objetos e incluso otras listas (anidamiento):
>>> lista1 = ['Arroyomolinos', 'Mostoles', 'Alcorcon']
>>> lista2 = ['Navacerrada', lista1, 'Villalba']
>>> lista2
['Navacerrada', ['Arroyomolinos', 'Mostoles', 'Alcorcon'], 'Villalba']

La lista anidada es una referencia, por lo que un cambio en la lista original afectará también a la referencia:
>>> lista1[1]="Fuenlabrada" # Mostoles por Fuenlabrada
>>> lista1
['Arroyomolinos', 'Fuenlabrada', 'Alcorcón']
>>> lista2
['Navacerrada', ['Arroyomolinos', 'Fuenlabrada', 'Alcorcón'], 'Villalba']

Para acceder a los elementos de la lista anidada, se especifica primero el elemento en la lista posicionado en
la anidada, y a continuación la posición dentro de la lista anidada:
>>> lista2[1] # Posición en lista anidada
['Arroyomolinos', 'Fuenlabrada', 'Alcorcon']
>>> lista2[1][1] # Posición en elemento de lista anidada 'Fuenlabrada'

Si se modifica la referencia, el cambio afectará a la lista original:
>>> lista2[1][1]='Mostoles' # Fuenlabrada por Mostoles
>>> lista2 # Cambio en la referencia
['Navacerrada', ['Arroyomolinos', 'Mostoles', 'Alcorcon'], 'Villalba']
>>> lista1 # Cambio en la lista original
['Arroyomolinos', 'Mostoles', 'Alcorcon']


Operadores básicos
Operador +: Suma números, concatena cadenas y extiende listas
Operador -: Resta números
Operador *: Multiplica números, repite textos y repite listas
Operador /: Divide números
Operador %: Resto de división
Operador **: Exponenciación

Cadenas como colecciones
Las cadenas de texto, en sí mismas, son colecciones de caracteres, por lo que se puede acceder a éstos indicando su/s posición/es entre corchetes, sabiendo que comienza desde la posición cero hasta longitud-1:
>>> pueblo = "Arroyomolinos"
>>> pueblo[4] # carácter en posición 4
'y'
>>> pueblo[:6] # caracteres HASTA posición 6
'Arroyo'
>>> pueblo[6:] # caracteres DESDE la posición 6
'molinos'
>>> pueblo[6:10] # caracteres entre las posiciones 6 y 10
'moli'
>>> pueblo[-1] # último carácter
's'
>>> pueblo[-3] # antepenúltimo carácter
'n'
>>> pueblo[-5:] # últimos 5 caracteres
'linos'
>>> pueblo[:-5] # todo menos 5 últimos caracteres
'Arroyomo'

Si se desea conocer el tamaño de un literal, la función len() (de length o longitud), retorna el número de caracteres que lo conforma.
>>> len(pueblo)
13


Entregas:

Enlaces de interés:

Google+ actualiza su aplicación para Android


Nueva actualización para la aplicación de Google+ en los dispositivos con sistema Android, con la que todos sus usuarios estarán bastante felices y disfrutarán de nuevas características incorporadas, que entre ellas, la más importante es la de poder compartir el contenido de los círculos. También hay otras mejoras como el soporte para 38 idiomas, mayor fiabilidad del sistema de notificación, opciones más claras para el desplazamiento, corrección de errores, de rendimiento y ajustes a la interfaz de usuario. 

Esta nueva versión se puede descargar entonces desde el Android Market. Mientras tanto, 
los usuarios de iOS mantengan la calma que de seguro debe haber alguna actualización en camino.



Vía | Ubergizmo

Las gráficas lo dicen todo, Apple bajo la dirección de Steve Jobs


Una imagen vale más que mil palabras, o en este caso, un gráfico vale mucho más para apreciar los excelentes resultados que tuvo la compañía de Apple desde que Steve Jobs retornó nuevamente en el año de 1997 desempeñándose en el cargo de CEO hasta este pasado 24 de agosto de 2011.

Entonces desde aquí el mismo tiempo será quien nos dirá más adelante si Apple logrará mantenerse en la cima sin Steve Jobs a su lado como el gran director ejecutivo que muchos veneran en el mundo de la tecnología.

Vía | Geekosystem

Curso de Python: 2-Conceptos básicos

Modo interactivo
Python incluye una consola que nos permitirá evaluar y ejecutar sentencias de forma individual, en modo interactivo, sin necesidad de escribir código en un fichero, lo que nos permitirá probar pequeñas partes de código antes de incluirlas definitivamente en un programa. Python suele venir ya instalado en muchas distribuciones Linux, como en Ubuntu, normalmente instalado en el directorio /usr/bin, y referenciado por la variable de entorno PATH, con el fin de poder ejecutar directamente la consola y el intérprete desde un terminal Linux (para más información sobre la instalación y configuración de Python, consultar la URL: http://docs.python.org/using/index.html). 

Para acceder a la consola/intérprete, ejecutar desde un terminal:

$ python 
Python 2.6.5 (r265:79063, Apr 16 2010, 13:57:41)
[GCC 4.4.3] on linux2
Type “help”, “copyright”, “credits” or “license” for more information.
>>>

El prompt está representado por >>>, indicando que acepta comandos por parte del usuario para su
ejecución. Una vez introducido ha de pulsarse la tecla Enter (ó Intro) para su ejecución. Para comenzar,
vamos a evaluar directamente valores, ya sean números o literales de texto:
>>> 2+2
4
>>> (2+2)*5
20
>>> "3 elevado a 3 son: ", 3**3
('3 elevado a 3 son: ', 27)

La consola visualiza el resultado debajo de cada prompt. Lo último evalúa dos expresiones, separadas por una coma: un literal (entre comillas dobles) , y un número (resultado de un cálculo). Para los literales, da igual especificar comillas simples que dobles, con tal de que las comillas iniciales y las finales sean iguales.

Vamos a probar la última operación utilizando la sentencia print (imprimir):

>>> print '3 elevado a 3 son: ', 3**3
3 elevado a 3 son: 27

Ahora la consola está ejecutando una sentencia que visualiza el resultado de las dos expresiones como una única salida en pantalla.



Variables y números
Los valores pueden ser almacenados en variables, las cuales son nombres simbólicos que facilitan al humano recordarlos mejor que su valor. Básicamente, en la ejecución del código se sustituye el nombre por su valor.  

A diferencia de otros lenguajes de programación, Python no necesita declarar el tipo del valor a almacenar en una variable. Esto es lo que se denomina tipado fuerte o dinámico:

>>> valor1 = 34
>>> valor2 = 3.67
>>> resultado = valor1*valor2
>>> print "Resultado = ",resultado
Resultado = 124.78
>>> resultado = "Hola, Python"
>>> print "Resultado = ", resultado
Resultado = Hola, Python

Se pueden reasignar diferentes tipos de valor a una misma variable, teniendo presente siempre el último.

El siguiente ejemplo muestra el uso de varias funciones específicas para números:

>>> float(valor1) # valor en coma flotante (decimal)
34.0
>>> valor1.real # valor real (de un entero)
34
>>> valor2.real # valor real (de un decimal)
3.67
>>> int(valor2) # valor entero (sin decimal)
3
>>> abs(valor2) # valor absoluto
3.67
>>> round(valor2,1) # redondeo a un digito decimal
3.7

Tras cada sentencia aparece un literal precedido del carácter '#', que indica que a partir de ahí es un comentario y no se ejecutará. Los comentarios añaden claridad al código, pero no hacen nada.

Python permite definir y asignar varias variables con varios valores en la misma línea:

>>> a = b = c = 5 # Asigna el mismo valor
>>> print ("a=",a," - b=",b," - c=",c)
a= 5 - b= 5 - c= 5
>>> a,b,c=1,'Pedro',3.5 # Asigna distintos valores
>>> print "a=",a," - b=",b," - c=",c
a= 1 - b= Pedro - c= 3.5

Literales de texto
Los literales o cadenas de texto poseen unas características especiales que son convenientes conocer. Por ejemplo, si el propio literal contiene comillas, para que el intérprete entienda que éstas son caracteres y no la apertura o cierre de un literal, ha de iniciarse con unas determinadas comillas, y utilizar dentro el otro tipo de comillas (por ejemplo, iniciar con comillas dobles y dentro utilizar comillas simples, o viceversa).

>>> print 'Dije: "Sí"', " - y él dijo: 'No'"
Dije: "Sí" - y él dijo: 'No'

En el caso de iniciar un literal y necesitar el carácter de las comillas en su interior, se pueden utilizar las secuencias de caracteres \" y \' para comillas dobles y comillas simples respectivamente.

>>> print 'Don\'t cry.', "Dije: \"Oh, baby\""
Don't cry. Dije: "Oh, baby"

Los literales son caracteres que se visualizan secuencialmente, pero a veces será necesario cambiar de línea o agregar una sangría, lo que se consigue con las secuencias de escape \n y \t, respectivamente.

>>> print "linea\t1\n\tlinea 2"
linea 1
linea 2

Si es necesario un texto largo con varias líneas, sangrías, espaciados, etc., no es necesario escribir secuencias especiales, si no escribir el texto tal cual visualizar encerrado entre comillas triples:

>>> texto = """El teniente se acercó al sargento:
... - "Déme las novedades" - ordenó en tono amenazante.
... El sargento titubeó, y respondió:
... - "No hay novedades. Lo siento, mi teniente" """
>>> print texto
El teniente se acercó al sargento:
- "Déme las novedades" - ordenó en tono amenazante.
El sargento titubeó, y respondió:
– "No hay novedades. Lo siento, mi teniente"

Cuando el comando aún no ha terminado, la consola de Python muestra unos puntos suspensivos en el prompt, indicando que sigamos escribiendo hasta que finalice. En el ejemplo se inició el literal de una variable con comillas triples, y no terminrá hasta que se cierre con sus respectivas comillas triples.

Una operación muy común con literales es la concatenación, la cual permite unir dos cadenas o literales, bien mediante la definición de dos literales separados por un espacio, o bien sumando ambos literales.

>>> print "Arroyo","molinos" # 2 literales
Arroyo molinos
>>> print "Arroyo" "molinos" # Concatenación
Arroyomolinos
>>> print "Arroyo"+"molinos" # Concatenación
Arroyomolinos

Una concatenación especial se consigue con el operador asterisco (“*”), el cual repite n veces un literal o una lista (ésta se verá más adelante).

>>> print "ja"*10
jajajajajajajajajaja


Entregas:

Enlaces de interés:

Tempestad bajo la vía láctea


Como todos los time-lapse que se ha mostrado en el blog, este con el nombre de "Tempest Milky Way" del fotógrafo Randy Halverson también es sencillamente espectacular, donde podemos apreciar una tormenta bajo una hermosa vía láctea, que fueron capturados con la ayuda de una Canon 5D Mark II, Canon 60D, y otra Canon T2i en el sur de Dakota entre el mes de junio y agosto del presente año.

"Uno de los retos en la toma de este video, era tratar de conseguir una buena tormenta y la explosión de estrellas. La oportunidad no viene muy a menudo, la tormenta que se mueve a la velocidad correcta y el rayo puede sobreexponer las exposiciones largas. Tuve varias oportunidades den este verano para conseguir la tormenta y las estrellas fugaces. En una ocasión, dentro de un minuto de agarrar la cámara y el dolly, vinieron vientos de un solo golpe a más de 70mph. Una tormenta perfecta, que llegó directamente hacia la instalación, y luego murió justo antes de acercarse a ella."



Vía | PetaPixel

Google Docs para Android ahora con portapapeles web


Desde hace poco, Google Docs para Android ofrece una nueva y excelente opción para todos sus usuarios con un portapapeles web, con el que hacen así mucho más fácil la inserción de imágenes en un documento de este servicio en la nube.

En el blog oficial de Google Docs puedes ver el paso a paso si quieres aprender a utilizar el portapapeles web de Android y comenzar a sacarle todo el provecho.

Vía | Ubergizmo

Curso de Python: 1-Introducción

Python es uno de los lenguajes de programación más populares y utilizados del momento. Gran parte de su éxito se debe a su sencillez, versatilidad, productividad y potencia, lo que lo hace idóneo para multitud de propósitos y escenarios. El presente curso pretende asentar de forma didáctica y práctica las bases para adentrarse firmemente en el apasionante mundo de la programación con Python.

Introducción
El software (programa) que se ejecuta en nuestros ordenadores es, básicamente, un código o secuencia de datos interpretados para hacer algo (operaciones matemáticas, guardar datos, activar un evento, etc). Para crear ese software, previamente un programador ha creado una secuencia organizada de instrucciones en un lenguaje de programación comprensible para el ser humano.

Desde el primer transistor, los lenguajes de programación han evolucionado junto a la tecnología y a las necesidades del momento, según alguna filosofía, paradigma, tendencia, funcionalidad, etc. Python goza de una gran aceptación y preferencia por parte de los programadores, lo que lo ha encumbrado entre los diez lenguajes de programación más utilizados del momento.

Un poco de historia
El origen de Python se remonta a finales de los años ochenta, en los Países Bajos, de la mano de Guido van Rossum, como una alternativa al lenguaje ABC. Su nombre se debe al grupo humorístico británico Monty Python, del que Guido era un gran entusiasta. Durante más de veinte años, Python ha evolucionado adoptando características avanzadas de otros lenguajes de programación, de los cuales está influenciado, como ABC, Haskell, Lisp, Modula-3, Perl, Smalltalk ó Java. Asimismo, Python ha inspirado, a su vez, a otros lenguajes de programación, tales como D, Ruby, Groovy ó JavaScript.

Características de Python
Las características principales de Python son:
Lenguaje de alto nivel de código abierto.
Lenguaje multiparadigma: programación imperativa, funcional y orientada a objetos.
Sintaxis limpia que favorece un código legible, corto y compacto.
   • Los tipos de datos de alto nivel expresan operaciones complejas en una simple sentencia.
   • Uso de arrays dinámicos (o listas) y diccionarios.
   • La agrupación de código se realiza mediante indentación (sangría mediante tabulación), en lugar de crear bloques comenzando y terminando con brackets (como { y }, ó begin y end).
   • Tipado dinámico: no requiere declaraciones de tipos en variables o en argumentos.
Lenguaje interpretado, basado en scripts. No requiere de compilación ni enlazado, por lo que el tiempo de desarrollo es más ágil y rápido.
Multiplataforma. Puede utilizarse en diferentes sistemas: Windows, Linux, y MacOS
Extensible. Se pueden añadir nuevos módulos o extensiones al intérprete (en C ó C++).

¿Dónde se usa Python?
Python es un lenguaje de propósito general que abarca un amplio espectro de escenarios posibles: operaciones con el sistema operativo, matemáticas, internet, correo electrónico, multihilo, red, aplicaciones web, HTML, XML, Web Services, bases de datos, aplicaciones de escritorio (GUIs), juegos, dispositivos móviles, etc. Además existen frameworks (marcos de trabajo) para extender las posibilidades de Python, como Django, que permite crear fácil y rápidamente sitios web, de forma semejante a Ruby on Rails.

Enlaces de interés:
© commandcat
Maira Gall