Python: Condicional

#!/usr/bin/python

# condicional

cadena = "arenita"

if cadena == "arenita":
	print("es una ardilla")	# es una ardilla
elif cadena == "bob":
	print("es una esponja")
else:
	print("mmmm no se que es :p")

# A if C else B
# se evalua C y devuelve 
# A si es correcto
# B si no es correcto
numero = 10
par = True if (numero %2 == 0) else False

print(numero)		# True

Python: Diccionarios

#!/usr/bin/python

# Diccionarios
# O tambien matrices asociativas, contienen pares de la forma {key:value}

d = {"bob":"esponja","patricio":"estrella","calamardo":"tentaculos"}
print(d)		# {'bob':'esponja','patricio':'estrella','calamardo':'tentaculos'}

# Donde key es cualquier valor inmutable, como numeros, cadenas, boleanos, tuplas
# pero no listas o diccionarios, los cuales son mutables.
#
# NOTA PERSONAL: Las tuplas no son mutables porque una vez definidas no se pueden modificar 
# sus elementos. Las listas y diccionarios son mutables porque se pueden modificar sus elementos
# aun despues de ser definidos. Vease mutables.py
#
# Esto es asi porque los diccionarios se implementan como tablas hash
# y cuando se inserta un nuevo par key:value se calcula el hash de key para
# despues encontrarlo rapidamente.
# Si se cambiara el valor de key, tambien cambiaria el hash, por lo que no se podria
# encontrar el par

# para acceder a los elementos no se usa un indice (porque no estan ordenados)
# sino que se usa el valor de key dentro del operador []
print(d["bob"])		# esponja

# al igual que las listas, (pero no las tuplas, pag 26)
# se pueden editar con el operador []
d["bob"] = False
print(d["bob"])		# False

# pero no se puede usar slicing, entre otras cosas, debido a que
# los diccionarios no son secuencias, sino mappings (mapeados o asociaciones)



# Recorrido de un diccionario
# Se puede usar el ciclo for in de varias formas, dependiendo de lo que se
# se desee usar, la llave o el valor 
dic = {"key_1":1,"key_2":2,"key_3":3}

# Mostrar solo llaves
# Se recorre de manera normal
print "Mostrar solo llaves"
for item in dic:
	print item		# key_1

# Mostrar el par de llave y valor
# Para recuperar el valor, se usa el metodo items(), propio 
# de los diccionarios, el cual devuelve una tupla por cada par 
print "Mostra llaves y valores"
for item in dic.items():
	print item		# ('key_1',1)
	print type(item)	# <type 'tuple'>
	print "key:" + item[0] + ",value:" + str(item[1])

Python: Tuplas

#!/usr/bin/python

# tuplas
# algunas de las operaciones de las listas se pueden aplicar a las tuplas

# las tuplas se construyen dentro de parantesis, separando los elementos
# por comas
tupla = (1,2,3)
print(tupla)		# (1,2,3)

# aunque en realidad, el constructor es la coma
tupla = 1,2,3
print(tupla)		# (1,2,3)

# ademas, se debe agregar una coma al final del elemento
# en el caso de una tupla con un solo elemento
# para diferenciar de un elemento entre parentesis
tupla = (1,)
print(tupla)		# (1,)
print type(tupla)	# <type 'tuple'>

no_tupla = (1)
print(no_tupla)		# 1
print type(no_tupla)	# <type 'int'>

# al igual que las listas, se puede usar el operador []
# para acceder a los elementos de la tupla
# debido a que ambos son de un tipo de objetos llamado secuencias
# al igual que las cadenas de texto
tupla = (1,2,3,4,5)
print(tupla[2])		# 3

# tambien podemos usar slicing
tupla = (0,1,2,3,(4,5,6))
print(tupla)		# (0,1,2,3,(4,5,6))
print(tupla[::2])	# (0:2:(4,5,6))

# ademas, son inmutables, es decir, sus valores no se pueden
# modificar una vez creada y tienen tamano fijo
tupla[0] = False
print(tupla)		# TypeError: 'tuple' object does not support item assigment

Python: Listas

#!/usr/bin/python

# listas
# es una coleccion ordenada similar al array
# puede contener numeros, cadenas, boleanos, listas...

lista = [1,2,3,"cadena",False,[10,20]]

# para acceder a los elementos
# usa indices
print(lista[0])		# 1

# para acceder a un elemento de una lista
# dentro de otra lista, usa dos indices
doble = [1,2,[3,4]]
print(doble[2][1])	# 4	
ndice fin - 1

# el operador [] de python tambien permite el uso de
# indices negativos
# contando desde el final de la lista
secuencia = [0,1,2,3,4,5,6,7,8,9]
print(secuencia[-10])	# 0	primer elemento de la lista (-length)
print(secuencia[-9])	# 1	segundo elemento de la lista
print(secuencia[-1])	# 9	ultimo elemento de la lista (-1)



# slicing o particionado
# permite obtener porciones de la lista con el formato
# [inicio:fin:salto]
# donde
# inicio: indice inicial
# fin: indice fin - 1
# salto: indica cada cuantas posiciones tomar un elemento
print("slicing")		# slicing
print(secuencia[0:3])		# [0,1,2]
print(secuencia[1:3])		# [1,2]
print(secuencia[0:10])		# [0,1,2,3,4,5,6,7,8,9]
print(secuencia[0:10:1])	# [0,1,2,3,4,5,6,7,8,9]
print(secuencia[0:10:2])	# [0,2,4,6,8]
print(secuencia[0:10:3])	# [0,3,6,9]
print(secuencia[0:10:4])	# [0,4,8]

# se puede omitir el inicio y fin
# tomando el primer y ultimo elemento, respectivamente
print(secuencia[::1])		# [0,1,2,3,4,5,6,7,8,9]

# tambien se puede modificar la lista por slicing
lista = [0,1,"c","d"]		
print(lista)			# [0,1,c,d]

lista[0:2] = ["a","b"]
print(lista)			# [a,b,c,d]

# incluso se puede cambiar el tamano de la lista
lista = [0,1,2,"b","c"]
lista[0:3] = ["a","b"]
print(lista)			# [a,b,b,c]


# note la diferencia entre modificar una lista
# por indice y por slicing
print("indice & slicing")	# indice & slicing

# por slicing agrega la lista ["a"] como si fuera solo "a"
print("por slicing")		# por slicing
lista = [0,1,2,3,4,5]
lista[0:3] = ["a"]
print(lista)			# [a,3,4,5]

# por indice agrega la lista ["a"] y se toma como una lista dentro de otra lista
print("por indice")		# por indice
lista = [0,1,2,3,4,5]
lista[0] = ["a"]
print(lista)			# [[a],1,2,3,4,5]

Python: Tipos

#!/usr/bin/python

# cadena
cadena = "hola"
print type(cadena)	#<type 'str'>

# entero
entero = 23
print type(entero)	#<type 'int'>

# entero largo (long)
largo = 23L
print type(largo)	#<type 'long'>

# octal
octal = 010
print type(octal)	#<type 'int'>

#hexadecimal
hex = 0x17
print type(hex)		#<type 'int'>

#real (float)
real = 0.0001		#<type 'float'>
print type(real)

real = 0.1e-3
print type(real)	#<type 'float'>


# complejo (complex)
complejo = 2.1 + 3.4j
print type(complejo)	#<type 'complex'>


# boleano (bool)	#<type 'bool'>
boleano = True
print type(boleano)

Combos dependientes con jQuery y AJAX

Esta es mi adaptación del ejemplo de combos dependientes de 9Lessons.

index.php

<!--?php      //libreria de funciones de DB     include_once("datalib.php"); ?-->

<script type="text/javascript" language="javascript" src="js/jquery-1.6.1.js"></script><script type="text/javascript" language="javascript" src="js/custom.js"></script>

 <!--?php             $result = getAreas();         ?-->

 <select id="subareas" name="subareas"> </select>

connection.php

<!--?php     $username = "user";     $userpass = "pass";     $server   = "localhost";     $database = "database";          $link = mysql_connect($server, $username, $userpass);          mysql_select_db($database, $link); ?-->

datalib.php

<!--?php include_once("connection.php"); function getAreas() {     $query =    "SELECT * ".                 "FROM areas ";          $result = mysql_query($query);          return $result;     } function getSubareas($id_area) {     $query =    "SELECT * ".                 "FROM subareas ".                 "WHERE id_area = $id_area";     //cuidado aqui! xss!          $result = mysql_query($query);          return $result;      } ?-->

ajax.php

<!--?php <br ?-->
include_once("datalib.php");

if($_POST['id_area'])
{
    $id = $_POST['id_area'];

    $result = getSubareas($id);

    while($row = mysql_fetch_array($result))
    {
        $id   = $row['id_subarea'];
        $data = $row['nombre'];

        echo ''.$data.'';
    }
}
?>

js/custom.js

$(document).ready(function()
{

    //Combo areas
    $("#areas").change(function(){

       //valores del combo
       var id_area = $(this).val();

       //valores por POST
       var postdata = "id_area=" + id_area;

       $.ajax({

           type:"POST",
           url:"ajax.php",
           data:postdata,
           cache:false,
           success: function(html)
           {
               $("#subareas").html(html);

           }
       });

    });

});

Fuente:
9Lessons

Eliminación de nodos con HtmlAgilityPack

HtmlNodeCollection tables = doc.DocumentNode.SelectNodes("//table");

// Validacion de tabla nula
if (tables != null)
	doc.LoadHtml(tables[0].OuterHtml);

// Recorrido de la tabla
foreach (HtmlNode tr in doc.DocumentNode.SelectNodes("//tr"))
{
	// Coleccion de columnas
	HtmlNodeCollection cols = tr.SelectNodes("td");

	
	// Elimina la etiqueta bold y br
	cols[0].RemoveChild(cols[0].SelectNodes("b")[0]);
	cols[0].RemoveChild(cols[0].SelectNodes("br")[0]);

	string valor = cols[0].InnerHtml;
	
}

Códigos QR en Ubuntu

Crear códigos QR, Quick Response, en Ubuntu es sencillo con el paquete qrencode. Basta con instalarlo:

sudo apt-get install qrencode

Para generar un código con el mensaje “chocoamigos”, ejecuta el comando

qrencode -l L -v 1 -o codigo2.png "chocoamigos"

He aquí el código:

Fuente:
Nikesh Jauhari

Validar un número con Regex en C#

//Patron de busqueda
string pattern = "^\\d+$";
Regex regex = new Regex(pattern);

//Lista de posibles numeros
List<string> lista = new List<string>();

lista.Add("6.53569E+11");   //No valido
lista.Add("6.53569E11");    //No valido
lista.Add("653569E11");     //No valido
lista.Add("65356911");      //Valido

//Recorrido de la lista
foreach(string item in lista)
{
	if(regex.IsMatch(item))
		MessageBox.Show(item + " es valido");
	else
		MessageBox.Show(item + " no valido");
}

Herencia en C#

using System;

public class Parent
{
    string parentString;

    public Parent()
    {
        Console.WriteLine("Parent Constructor");
    }

    public Parent(string msg)
    {
        parentString = msg;
        Console.WriteLine(parentString);
    }

    public void print()
    {
        Console.WriteLine("Im a parent class");
    }

}

public class Child : Parent
{

    ///
<summary> /// En este constructor se llama explicitamente al constructor que coincida con la
 /// lista de parametros del padre
 ///
 /// Si no se usara : base("From derived") se llamaria al constructor por defecto en la
 /// clase padre, Parent()
 /// </summary>
    public Child() : base("From derived")
    {
        Console.WriteLine("Child Constructor");
    }

    ///
<summary> /// new puede ser usado como modificador en la declaracion de una funcion
 /// en este caso padre e hijo tienen una misma funcion, print(), pero con new
 /// se usara solo la del hijo, ocultando la del padre
 ///
 /// esto es util especialmente cuando se quiere una implementacion distinta a
 /// una funcion existente en la clase padre
 ///
 /// se puede decir que es un override como en java
 /// </summary>
    public new void print()
    {
        //Llama explicitamente al metodo print() del padre
        base.print();

        Console.WriteLine("Im a child class");
    }

    public static void Main()
    {
        Child child = new Child();

        child.print();

        //Otra forma de llamar explicitamente a los miembros de la clase padre
        //es por medio de un cast
        ((Parent)child).print();
    }

}

Fuente:
C# Station