martes, 26 de enero de 2016

Curso lenguaje Ensamblador / Assembler

Tiempo atrás me tope con este material me resulto de mucha utilidad cuando comencé a aprender ensamblador , estos dias he vuelto a hacer uso de este así que comencé a desempolvar mis materiales para refrescar un poco y lo volví a encontrar así que comparto con ustedes esperando que les sea de utilidad.



Videotutorial 1:
Damos inicio a este curso el cual esta enfocado a la Programación en Lenguaje Ensamblador, y empezamos con una introducción, en la cual se definirán conceptos muy básicos pero muy importantes para aprender a programar en este lenguaje.

Videotutorial 2:
Empezamos a ver mas a fondo la Arquitectura interna del microprocesador, y definimos detalles importantes que se deben saber antes de programar y porque programar determinado procesador.

Videotutorial 3:
Ultimo Vídeo en el cual se trata teoría e introducción. El tema a tratar son los registros del Microprocesador, ya que estos son muy importantes para la programación con el ensamblador. Estos registros son los que por medio del lenguaje ensamblador nos van a permitir manipular (dar ordenes), al microprocesador. Cabe destacar que este curso también lo podrás orientar, a la programación de micro controladores, ya que estos también utilizan registros para ser programados.

Videotutorial 4:

En el que se trataran los siguientes temas: Manejo de memoria en Ensamblador, Modos de direccionamiento, La instrucción MOV, Instalación de los programas (Masm ', 'Videotutorial No. 4 del curso de Programación en Lenguaje Ensamblador, en el que se trataran los siguientes temas: Manejo de memoria en Ensamblador, Modos de direccionamiento, La instrucción MOV, Instalación de los programas (Masm 'Tasm).

Videotutorial 5:
Conoceremos mas a fondo las interrupciones, ya que es indispensable saber para que sirven cada una de ellas, conocer cada uno de sus elementos por los cuales están conformadas y saber como emplearlas en el lenguaje ensamblador. 
Además que haremos unos ejercicios, en los cuales aplicaremos dichas Interrupciones. En este Video repasaremos la maquetacion de un programa en ensamblador y lo explico de una forma mas detallada. 
Crearemos nuestras funciones, para posicionar en un lugar determinado un texto, ya interactuaremos con el usuario. 
A partir de este videotutorial ya podrás emplear tus conocimientos para comprender el ensamblador para la programación de micro controladores. 
(Ojo ) Emplearlo como análisis y comprender la lógica, no para programar a un micro controlador ya que para eso necesitas conocimientos mas avanzados con respecto a conocer mas afondo la arquitectura del mismo. Si Dios me lo permite en este curso se abarcara la programación de Micro controladores Pic.

Videotutorial 6:
Trabajaremos con Etiquetas, veremos el manejo y las reglas de implementación de las mismas. Además conoceremos algunas instrucciones de salto, estos se complementan con lo mencionado anteriormente es decir con las etiquetas, ya que trabajan a la par. Se vera tambien algunas intrucciones de salto condicional, parecidas a las estructuras condicionales del Lenguaje C, como lo son If - Else, leeremos datos introducidos por el usuario atravez del teclado, y realizaremos comparaciones con instrucciones que nos provee este lenguaje. Simularemos un ciclo While con las herramientas mencionadas anteriormente.

Videotutorial 7:
Seguimos trabajando con la implementación de etiquetas, las instrucciones de comparación, instrucciones de salto incondicional y las instrucciones de salto condicional como lo son JA, JB, del ensamblador, y vemos como trabajan al igual que las sentencias de condición del lenguaje C, como las instrucciones if - else. Todo en conjunto nos ayuda a realizar un programa en el cual se le pide al usuario que introduzca 2 valores desde el teclado y este programa nos dirá cual es el valor mayor, menor o si son iguales. Este ejemplo esta realizado en el compilador TASM versión 5, pero pueden también pueden emplearlo en el compilador MASM.







DESCARGA:

https://www.dropbox.com/s/ptukboic1fudw2i/Curso%20ASM%201.wmv?dl=0
https://www.dropbox.com/s/wlrqr6pyuqpp63m/Curso%20ASM%202.wmv?dl=0
https://www.dropbox.com/s/x1ecfbgviz6xp9e/Curso%20ASM%203.wmv?dl=0
https://www.dropbox.com/s/nencskf7inkqzmw/Curso%20ASM%204.swf?dl=0
https://www.dropbox.com/s/lcwzqspvlow4zmn/Curso%20ASM%205.swf?dl=0
https://www.dropbox.com/s/202kpc2tg6zxs02/Curso%20ASM%206.swf?dl=0
https://www.dropbox.com/s/54akmd7v9fusaaw/Curso%20ASM%207.swf?dl=0

CREADOR DEL CURSO: Edgar Ivan Justo Dominguez

miércoles, 20 de enero de 2016

Aprendamos Python desde cero - Instalación



¿QUE ES PYTHON?

Python es un lenguaje de programación multiplataforma e interpretado , esto quiere decir que funciona en casi cualquier sistema operativo y que el código del programa se ejecuta directamente a través de un programa interprete, en vez de pasar por una fase de compilación para convertirlo en un archivo ejecutable.
El principal objetivo que persigue este lenguaje es la facilidad, tanto de lectura, como de diseño.
Es de libre distribución.
Python se usa en grandes plataformas como:


INSTALACIÓN:
A continuación procederé a explicar la explicación en los 3 principales S.O:

WINDOWS:

Para instalar Python en Windows basta con ir a la página oficial de Python es https://www.python.org/ y bajar el instalador.


La última versión de Python 3.5 disponible actualmente (enero de 2016) es Python 3.5.1 (del 7 de diciembre de 2015) cabe recalcar que aun se sigue usando la versión 2.7.11 de este lenguaje por la gran cantidad de librerías que existen para esa versión de ahí que es de su elección usar la que mas se acomode a su necesidad recalcando que entre ambas versiones varia la sintaxis, de aquí en adelante nosotros usaremos la ultima versión de Python.
El proceso de instalación no es muy complejo solo ejecutar el instalador y seguir las instrucciones :


Seleccionar "Add Python 3.5 PATCH"





MAC

Para poder instalar la última versión de Python en el sistema operativo debemos tener previamente instalado Homebrew. Utilizaremos el siguiente comando para iniciar la instalación:
$ brew install python3 --framework

Este paso instalará todos los componentes necesarios y tardará unos minutos, una vez que culmine debemos exportar está ruta alPATH del usuario.
$ export PATH=/usr/local/share/python:$PATH

La bandera --framework le indica a Homebrew que debe compilar Python en estilo Framework. Esto se realiza porque la versión de Python que venía con Snow Leopard se encontraba compilada de esta manera, y se sigue utilizando solo por prevención de errors en instalaciones futuras.

Una vez finalizada la instalación, ya deberíamos tener Python corriendo en nuestro sistema.

LINUX

Usuarios de Debian y Ubuntu:
sudo apt-get install python3.1


Usuarios de Red Hat / RHEL / CentOS:
sudo yum install python

domingo, 17 de enero de 2016

IMPLEMENTACIÓN DE LOS MÉTODOS DE ORDENACIÓN EN PYTHON




Hola amigos tiempo atrás realice un post acerca delos diferentes métodos de ordenación  y su respectivo análisis de complejidad con su implementacion en java, si desean verlo pueden pasarse por la siguiente publicación:

En la presente publicación comparto con ustedes la implementación de estos métodos pero en python, un lenguaje de programación con el cual comencé a trabajar y me vi con la necesidad de implementar estos métodos 

Método de ordenamiento  Burbuja:

def ordenamientoBurbuja(lista,tam):
    for i in range(1,tam):
        for j in range(0,tam-i):
            if(lista[j] > lista[j+1]):
                k = lista[j+1]
                lista[j+1] = lista[j]
                lista[j] = k;
 
def imprimeLista(lista,tam):
    for i in range(0,tam):
        print lista[i]
 
def leeLista():
    lista=[]
    cn=int(raw_input("Cantidad de numeros a ingresar: "))
 
    for i in range(0,cn):
        lista.append(int(raw_input("Ingrese numero %d : " % i)))
    return lista
 
A=leeLista()
ordenamientoBurbuja(A,len(A))
imprimeLista(A,len(A))


Método de ordenamiento  Shell Sort:
def ordenShell(lista,tam):
    inc=1
    for inc in range(1,tam,inc*3+1):
        while inc>0:
            for i in range(inc,tam):
                j=i
                temp=lista[i]
                while j>=inc and lista[j-inc]>temp:
                    lista[j]=lista[j-inc]
                    j=j-inc
                lista[j]=temp
            inc=inc/2
 
def imprimeLista(lista,tam):
    for i in range(0,tam):
        print lista[i]
 
def leeLista():
    lista=[]
    cn=int(raw_input("Cantidad de numeros a ingresar: "))
 
    for i in range(0,cn):
        lista.append(int(raw_input("Ingrese numero %d : " % i)))
    return lista

Método de ordenamiento  QuickSort:
def quicksort(lista,izq,der):
    i=izq
    j=der
    x=lista[(izq + der)/2]
 
    while( i <= j ):
        while lista[i]< x and j< =der:
            i=i+1
        while x< lista[j] and j > izq:
            j=j-1
        if i<=j:
            aux = lista[i]; lista[i] = lista[j]; lista[j] = aux;
            i=i+1;  j=j-1;
 
        if izq < j:
        quicksort( lista, izq, j );
    if i < der:
        quicksort( lista, i, der );
 
def imprimeLista(lista,tam):
    for i in range(0,tam):
        print lista[i]
 
def leeLista():
    lista=[]
    cn=int(raw_input("Cantidad de numeros a ingresar: "))
 
    for i in range(0,cn):
        lista.append(int(raw_input("Ingrese numero %d : " % i)))
    return lista
 
A=leeLista()
quicksort(A,0,len(A)-1)
imprimeLista(A,len(A))

Método de ordenamiento  QuickSort:
def quicksort(lista,izq,der):
    i=izq
    j=der
    x=lista[(izq + der)/2]
 
    while( i <= j ):
        while lista[i]< x and j<=der:
            i=i+1
        while x< lista[j] and j>izq:
            j=j-1
        if i<=j:
            aux = lista[i]; lista[i] = lista[j]; lista[j] = aux;
            i=i+1;  j=j-1;
 
        if izq < j:
        quicksort( lista, izq, j );
    if i < der:
        quicksort( lista, i, der );
 
def imprimeLista(lista,tam):
    for i in range(0,tam):
        print lista[i]
 
def leeLista():
    lista=[]
    cn=int(raw_input("Cantidad de numeros a ingresar: "))
 
    for i in range(0,cn):
        lista.append(int(raw_input("Ingrese numero %d : " % i)))
    return lista
 
A=leeLista()
quicksort(A,0,len(A)-1)
imprimeLista(A,len(A))

Método de ordenamiento  Insercion:
def insercion(lista,tam):
    for i in range(1,tam):
        v=lista[i]
        j=i-1
        while j >= 0 and lista[j] > v:
            lista[j+1] = lista[j]
            j=j-1
        lista[j+1]=v
 
def imprimeLista(lista,tam):
    for i in range(0,tam):
        print lista[i]
 
def leeLista():
    lista=[]
    cn=int(raw_input("Cantidad de numeros a ingresar: "))
 
    for i in range(0,cn):
        lista.append(int(raw_input("Ingrese numero %d : " % i)))
    return lista
 
A=leeLista()
insercion(A,len(A))
imprimeLista(A,len(A))

Método de ordenamiento  HeapSort:
def heapsort(lista,tam):
    for k in range(tam-1,-1,-1):
        for i in range(0,k):
            item=lista[i]
            j=(i+1)/2
            while j>=0 and lista[j]< item:
                lista[i]=lista[j]
                i=j
                j=j/2
            lista[i]=item
        temp=lista[0];
    lista[0]=lista[k];
    lista[k]=temp;
 
def imprimeLista(lista,tam):
    for i in range(0,tam):
        print lista[i]
 
def leeLista():
    lista=[]
    cn=int(raw_input("Cantidad de numeros a ingresar: "))
 
    for i in range(0,cn):
        lista.append(int(raw_input("Ingrese numero %d : " % i)))
    return lista
 
A=leeLista()
heapsort(A,len(A))
imprimeLista(A,len(A))

Método de ordenamiento  MergeSort:
def merge_sort(lista): 
    n = len(lista) 
    if(n == 1): return lista 
    izquierda = merge_sort(lista[:(n/2)]) 
    derecha = merge_sort(lista[(n/2):]) 
    return merge(izquierda, derecha) 
 
def merge(izquierda, derecha): 
    resultado = [] 
    i = 0 
    j = 0 
    len_izquierda = len(izquierda) 
    len_derecha = len(derecha) 
 
    while(i < len_izquierda or j < len_derecha): 
        if(i >= len_izquierda): 
            resultado.append(derecha[j]) 
            j = j + 1 
        elif(j >= len_derecha): 
            resultado.append(izquierda[i]) 
            i = i + 1 
        elif(izquierda[i] < derecha[j]): 
            resultado.append(izquierda[i]) 
            i = i + 1 
        else: 
            resultado.append(derecha[j]) 
            j = j + 1 
    return resultado 

def imprimeLista(lista):
    for i in range(0,len(lista)):
        print (str(lista[i]))
 
def leeLista():
    lista=[]
    cn=int(input("Cantidad de numeros a ingresar: "))
    for i in range(0,cn):
        lista.append(int(input("Ingrese numero %d : " % i)))
    return lista
 
A=leeLista()
merge_sort(A)
imprimeLista(A)