Desde hace tiempo sigo usando Firefox 3.5, pero hoy he decidido actualizar mi versión sin cambiar a otra versión de Ubuntu.
Ejecuta lo siguiente en consola
sudo apt-add-repository ppa:mozillateam/firefox-next sudo apt-get update sudo apt-get upgrade // responde No sudo apt-get install firefox language-pack-en language-pack-en-base
Vía UbuntuGeek
El siguiente programa muestra el valor de una variable entera y su dirección en memoria.
/*
| Programa 1 c
| Muestra el valor de la variable n
| y su direccion
|
| gcc ejemplo_1.cpp -o salida
|
| Salida:
| n = 75
| &n = 0xbfc4250c
|
| Notas:
| En la linea
| printf("&n= %p \n", &n);
| Se utiliza %p para imprimir la direccion del puntero,
| en este caso, la direccion de n
*/
#include <stdio.h>
int main()
{
int n = 75;
printf("n = %d \n", n);
printf("&n= %p \n", &n);
return 0;
}
/*
| Programa 1 c++
| Muestra el valor de la variable n
| y su direccion
|
| g++ ejemplo_1.cpp -o salida
|
| Salida:
| n = 75
| &n = 0xbfd283fc
|
| Notas:
| La forma correcta de incluir la libreria es
| #include <iostream>
| no
| #include <iostream.h>
|
| Recuerda, cout solo se puede usar si incluyes iostream
*/
#include <iostream>
using namespace std;
int main()
{
int n = 75;
cout<<"n = "<<n<<endl;
cout<<"&n = "<<&n<<endl;
return 0;
}
Happy new year to all! This will be my first post for this year. Recently, I was looking for a way to select rows in
a time interval. After looking, I found this blog with a lot of examples and then, I ran to execute them in sqlcmd. Here are my tests, I hope these are useful.
Current time
select current_timestamp go -- output 2012-01-02 00:51:22.660
DATEADD
Returns a specified date with the number interval (signed integer) added to a specified datepart of that date.
DATEADD(datepart, number, date)
Some dateparts are year (yy, yyyy), month (m,mm), day (d,dd), hour (hh), minute (mi,n), second (ss,s), millisecond (ms), etc.
Get years
SELECT DATEADD(YEAR, -1, CURRENT_TIMESTAMP) AS previous_year, DATEADD(YEAR,0,CURRENT_TIMESTAMP) AS present_year DATEADD(YEAR,1,CURRENT_TIMESTAMP) AS next_year GO -- output 2011-01-02 01:10:24.733 -- previous year 2012-01-02 01:10:24.733 -- present year 2013-01-02 01:10:24.733 -- next year
More info:
Zen of SQL
Date and Time functions (Transact-SQL)
Los duendes de las estadísticas de WordPress.com prepararon un reporte para el año 2011 de este blog.
Aqui es un extracto
Un teleférico de San Francisco puede contener 60 personas. Este blog fue visto por 2.100 veces en 2011. Si el blog fue un teleférico, se necesitarían alrededor de 35 viajes para llevar tantas personas.
El libro del dragón
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using Excel = Microsoft.Office.Interop.Excel;
namespace my_excel
{
class Program
{
static void Main(string[] args)
{
// archivo de entrada
string file = "libro.xls";
string dir = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
string xlsFilePath = Path.Combine(dir, file);
read_file(xlsFilePath);
Console.ReadKey();
}
public static void read_file(string xlsFilePath)
{
if (!File.Exists(xlsFilePath))
return;
Excel.Application xlApp;
Excel.Workbook xlWorkBook;
Excel.Worksheet xlWorkSheet;
Excel.Range range;
var misValue = Type.Missing;//System.Reflection.Missing.Value;
// abrir el documento
xlApp = new Excel.ApplicationClass();
xlWorkBook = xlApp.Workbooks.Open(xlsFilePath, misValue, misValue,
misValue, misValue, misValue, misValue, misValue, misValue,
misValue, misValue, misValue, misValue, misValue, misValue);
// seleccion de la hoja de calculo
// get_item() devuelve object y numera las hojas a partir de 1
xlWorkSheet = (Excel.Worksheet)xlWorkBook.Worksheets.get_Item(1);
// seleccion rango activo
range = xlWorkSheet.UsedRange;
// leer las celdas
int rows = range.Rows.Count;
int cols = range.Columns.Count;
for (int row = 1; row <= rows; row++)
{
for (int col = 1; col <= cols; col++)
{
// lectura como cadena
string str_value = (range.Cells[row, col] as Excel.Range).Value2.ToString();
// conversion
int int_value = Convert.ToInt32(str_value, 10);
Console.WriteLine("string:{0}", str_value);
Console.WriteLine("int:{0}", int_value);
}
}
// cerrar
xlWorkBook.Close(false, misValue, misValue);
xlApp.Quit();
// liberar
releaseObject(xlWorkSheet);
releaseObject(xlWorkBook);
releaseObject(xlApp);
}
public static void releaseObject(object obj)
{
try
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(obj);
obj = null;
}
catch (Exception ex)
{
Console.WriteLine("Unable to release the object(object:{0})", obj.ToString());
}
finally
{
obj = null;
GC.Collect();
}
}
}
}
Fuente:
CSharp
DotNetPerls
El cifrado de César es un tipo de cifrado simple que se basa en el uso de un sólo alfabeto, por lo regular, ordenado. Se emplea una llave para realizar la sustitución. Por ejemplo, si la llave vale 1 y el mensaje es ‘A’, entonces, el mensaje cifrado será ‘B’, y así sucesivamente.
A diferencia de otros algoritmos, como el de Vigenére, se emplea una sola llave para cifrar todo el mensaje.
Para saber más sobre el método de César, este es un libro excelente Cryptography Decrypted
Implementación
Vamos a crear cuatro funciones para el algoritmo:
La función get_alphabet() devolverá una lista con todos los elementos del alfabeto y otros, como números lo que se desee agregar.
def get_alphabet():
"""Devuelve una lista con mayusculas, minuscula, numeros y un espacio"""
alphabet = []
# mayusculas:65-90
for i in range(65,91):
alphabet.append(chr(i))
# minusculas:97-122
for i in range(97,123):
alphabet.append(chr(i))
# numeros
for i in range(10):
alphabet.append(str(i))
# espacio
#alphabet.append(" ")
return alphabet
La función get_index() se usa para validar la llave. En nuestro caso el alfabeto consta de 62 elementos (length), por lo que nuestro índice máximo (max_index) dentro de la lista es de 61 y el índice mínimo (min_index) es 0. Para que un índice sea válido, debe estar en este rango.
En teoría, el algoritmo sólo sirve para un cierto valor de llaves. En un alfabeto de 25 elementos, habrá un máximo de 25 llaves distintas, ya que después se repetirán los valores, es decir, si la llave vale 26, producirá el mismo cifrado que la llave con valor de 1.
def get_index(index = 0, length = 0): """Devuelve un indice valido dentro de un rango, evitando desbordamiento""" min_index = 0 # indice minimo max_index = length - 1 # indice maximo = longitud - 1 while True: # index excede el limite superior if index > max_index: index -= length # index es menor al limite inferior elif index < min_index: index += length # index es valido else: break return index
La función crypt() recibe dos parámetros, el mensaje a cifrar y la llave. Inicia con la declaración de variables. Enseguida, recorre cada letra del mensaje. Si la letra se encuentra dentro de alphabet, se devolverá su índice dentro de la lista. Sino es así, letter no existe dentro de alphabet, provocando una excepción y continuando con la siguiente letra.
La sustitución se realiza de esta forma. Se incrementa index el valor de key y se guarda en move. Si move no fuese un índice válido se evaluará con get_index(). Por ejemplo, si move vale 63 excede el valor de max_index, por lo que se devolverá 1.
Por último se agrega el elemento de alphabet en la posición move al crypted.
def crypt(message = "", key = 0): """Cifra un mensaje usando sustitucion""" crypted = "" # mensaje cifrado alphabet = get_alphabet() # alfabeto length = len(alphabet) # longitud del alfabeto index = 0 # indice de la letra en el alfabeto for letter in message: # se obtiene el indice de letter dentro de alphabet, si existe try: index = alphabet.index(letter) # indice dentro del alfabeto except: print "No existe %s en el alfabeto" % (letter,) continue # se obtiene la nueva posicion, evitando desbordamiento move = index + key # nueva posicion move = get_index(move,length) # debug if debug: print "move %d"%(move,) crypted += alphabet[move] # agrega la letra al mensaje cifrado #debug if debug: print "%s = %s" % (alphabet[index],alphabet[move]) return crypted
La función decrypt() es similar a la anterior, pero en lugar de incrementar el valor de key, se decrementa.
def decrypt(message = "", key = 0): """Decifra un mensaje usando sustitucion""" decrypted = "" # mensaje decifrado alphabet = get_alphabet() # alfabeto length = len(alphabet) # longitud del alfabeto index = 0 for letter in message: try: index = alphabet.index(letter) # indice dentro del alfabeto except: print "No existe %s en el alfabeto" % (letter,) continue move = index - key # nueva posicion move = get_index(move,length) # debug if debug: print "move %d"%(move,) decrypted += alphabet[move] # agrega al mensaje decifrado #debug if debug: print "%s = %s" % (alphabet[index],alphabet[move]) return decrypted
Por último, este es todo el código. Al final, se manda llamar la función crypted() y se imprime el mensaje cifrado.
#!/usr/bin/python
debug = False
# Cifrado por sustitucion
def get_alphabet():
"""Devuelve una lista con mayusculas, minuscula, numeros y un espacio"""
alphabet = []
# mayusculas:65-90
for i in range(65,91):
alphabet.append(chr(i))
# minusculas:97-122
for i in range(97,123):
alphabet.append(chr(i))
# numeros
for i in range(10):
alphabet.append(str(i))
# espacio
#alphabet.append(" ")
return alphabet
def get_index(index = 0, length = 0):
"""Devuelve un indice valido dentro de un rango, evitando desbordamiento"""
min_index = 0 # indice minimo
max_index = length - 1 # indice maximo = longitud - 1
while True:
# index excede el limite superior
if index > max_index:
index -= length
# index es menor al limite inferior
elif index < min_index:
index += length
# index es valido
else:
break
return index
def crypt(message = "", key = 0):
"""Cifra un mensaje usando sustitucion"""
crypted = "" # mensaje cifrado
alphabet = get_alphabet() # alfabeto
length = len(alphabet) # longitud del alfabeto
index = 0 # indice de la letra en el alfabeto
for letter in message:
# se obtiene el indice de letter dentro de alphabet, si existe
try:
index = alphabet.index(letter) # indice dentro del alfabeto
except:
print "No existe %s en el alfabeto" % (letter,)
continue
# se obtiene la nueva posicion, evitando desbordamiento
move = index + key # nueva posicion
move = get_index(move,length)
# debug
if debug:
print "move %d"%(move,)
crypted += alphabet[move] # agrega la letra al mensaje cifrado
#debug
if debug:
print "%s = %s" % (alphabet[index],alphabet[move])
return crypted
def decrypt(message = "", key = 0):
"""Decifra un mensaje usando sustitucion"""
decrypted = "" # mensaje decifrado
alphabet = get_alphabet() # alfabeto
length = len(alphabet) # longitud del alfabeto
index = 0
for letter in message:
try:
index = alphabet.index(letter) # indice dentro del alfabeto
except:
print "No existe %s en el alfabeto" % (letter,)
continue
move = index - key # nueva posicion
move = get_index(move,length)
# debug
if debug:
print "move %d"%(move,)
decrypted += alphabet[move] # agrega al mensaje decifrado
#debug
if debug:
print "%s = %s" % (alphabet[index],alphabet[move])
return decrypted
# inicio
print "Cifrado por sustitucion"
print "Mensaje:"
message = raw_input()
print "Llave:"
key = int(raw_input())
# mensaje cifrado
crypted = crypt(message,key)
print crypted
Ejemplos
# key = 1 auraham@machine:~/projects/python$ python -i cifrar_sustitucion.py Cifrado por sustitucion Mensaje: hola Llave: 1 ipmb
# key = 62, tiene el mismo efecto de key = 0, es decir, no cifra auraham@machine:~/projects/python$ python -i cifrar_sustitucion.py Cifrado por sustitucion Mensaje: hola Llave: 62 hola
# key = 63, tiene el mismo efecto que key = 1 auraham@machine:~/projects/python$ python -i cifrar_sustitucion.py Cifrado por sustitucion Mensaje: hola Llave: 63 ipmb
#!/usr/bin/python
# Mutables e inmutables (personal)
# Las listas y los diccionarios son mutables porque es posible modificar sus elementos
# aun despues de haber sido definidos
# definicion
lista = [1,2,3]
print lista
# modificacion
lista[0] = "modificado"
print lista
# definicion
dic = {"uno":1, "dos":2}
print dic
# modificacion
dic["uno"] = "modificado"
print dic
# Las tuplas en cambio, son inmutables, ya que no es posible modificar sus elementos
# despues de hacer sido definidos
# definicion
tupla = (1,2,3)
print tupla
# no se podra modificar y mostrara este error
# TypeError: 'tuple' object does not support item assigment
tupla[0] = "no se puede modificar, mostrando un error"
#!/usr/bin/python
# Funciones
# Una funcion es un fragmento de codigo con un nombre asociado
# que realiza una serie de tareas y devuelve un valor.
#
# Un procedimiento es similar a la funcion, pero no devuelve valor.
#
# En Python no existen los procedimientos, ya que cuando no se especifica
# un valor de retorno, se devuelve None
#
# def function_name(params):
# """docstring"""
# ...
#
# Para mostrar la ayuda de la funcion, el docstring, usa
# help(function_name)
#
# Para salir usa q
#
def mi_funcion(param1, param2):
"""imprime dos valores"""
print param1
print param2
# Mostrar ayuda
help(mi_funcion)
# Llamada a la funcion
# 1
# 2
print "llamada a la funcion"
mi_funcion(1,2)
# Para no cerrar el interprete al terminar el programa, usa
# python -i script.py
#
#
# Valores por defecto
# Cuando se manda llamar una funcion se debe pasar el numero
# de parametros de acuerdo a la declaracion de la funcion, sino se mostrara
# un error. Por ejemplo, al pasar solo un parametro, se mostrara
# TypeError: mi_funcion() takes exactly 2 arguments (1 given)
#
# Se puede evitar eso colocando valores por defecto en los parametros
def otra_funcion(param1 = "param1", param2 = "param2"):
print param1
print param2
# Llama a la funcion con solo un parametro
# un parametro
# param2
print "parametros por defecto"
otra_funcion("un parametro")
# Cambio de orden
# Es posible cambiar el orden de los valores en los parametros
# indicando el nombre del parametro al momento de llamar a la funcion
#
# param 2
# param 1
print "cambio de orden"
otra_funcion(param2 = "param 1", param1 = "param 2")
# Multiples parametros
# Se pueden pasar un numero variable de argumentos antecediendo un *
# al parametro en la definicion
# Se crea una tupla llamada parametros en la funcion indefinidos
def funcion_lista(*parametros):
for item in parametros:
print item
# Llamada a la funcion
# 1
# 2
# 3
# 4
print "lista de parametros"
funcion_lista(1,2,3,4)
# Tambien es posible usar ** antes de la definicion del parametro
# creando un diccionario. Al momento de llamar a la funcion se deben
# pasar los valores en pares, (key, value) para cada elemento del diccionario
#
# Para mostrar los valores (y no las llaves) del diccionario se usa la el metodo items()
def funcion_diccionario(**params):
for item in params.items():
print item
# Llamada a la funcion
print "diccionario de parametros"
funcion_diccionario(param1 = "param 1", param2 = "param 2", param3 = "param 3")
Fuente
Python para todos
#!/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
