Lenguaje Funcional Erlang

Erlang es un lenguaje funcional y concurrente que fue desarrollado por Ericcson para la aplicación de telecomunicaciones.

Aunque Ericcson era originalmente el propietario del lenguaje Erlang, en el año 1998 el lenguaje fue cedido como open source.

Erlang es un de los pocos lenguajes de programación declarativos que es exitoso en el mundo empresarial.
Además pertenece a los lenguajes orientados a mensajes, los cuales proporcionan concurrencia osuando procesos paralelos. La concurrencia, es que varios procesos se lleven a cabo (sean ejecutados) al mismo tiempo.

Hablando de Erlang como un lenguaje orientado a mensajes, la interacción que se da entre los threads (procesos) en dichos lenguajes, se lleva a cabo mediante el envío y la recepción de mensajes.

El equipo de Erlang desarrollo ciertas caracterisitcas en el lenguajes de acuerdo a los requisitos que tienen las aplicaciones de telecomunicaciones, las cuales son: alta disponibilidad, modificación del código sin detener la aplicación, y demás.

Bueno, tomando en cuenta estos requisitos, algunas de las caracteristicas desarrollados por el equipo de Erlang son:

• Concurrencia
• Lenguaje funcional
• Tolerancia a fallos
• Reemplazo de código en caliente
• Comunicación entre los procesos mediante mensajes.

El soporte de concurrencia, se dice que es la mayor fortaleza de Erlang, y como ya lo mencione anteriormente, la concurrencia es cuando se llevan a cabo o se ejecutan varios procesos al mismo tiempo.

Además ,Erlang es un lenguaje funcional, ya que esta estructurado por definición de funciones.
Los programas en Erlang se componen de bloques funcionales, llamados funciones.
Podemos identificar una función en un programa en Erlang, mediante el nombre y la aridad de la función, dicha aridad es el número de datos de entrada, que se permitirán en la función. Es decir, la función volumen/3, permite solo 3 datos de entrada mientras que la función area/2, permite solo 2 datos de entrada.

Algo muy importante que hay que mencionar es que pueden coexisitir sin ningun problema dos funciones con el mismo nombre y diferente aridad, como por ejemplo: multiplicación/2 y multiplicación/3, ya que las dos funciones son diferentes.

La definición de una función es la siguiente:

nombre-función(Argumento1, Argumento2, ...)  ->
instruccion,
instruccion,
Resultado-a-devolver.

Las funciones se agrupan en módulos, los cuales son las unidades mínimas de compilación en Erlang. Cada módulo tiene un nombre, único en el programa y se almacena en un fichero fuente, y dicho fichero tiene el nombre del módulo.
Las primeras líneas del fichero contienen la definición del módulo y las funciones que se exportan; las funciones que no sean exportadas, no podrán ser utilizadas fuera de este mismo módulo.

En Erlang el módulo y su función o funciones se escriben de la manera siguiente:
-module(nombre_modulo).
-export([funcion1/2, funcion2/1, funcion3/4]).

También se pueden poner las funciones por separado, es decir, así:
-module(nombre_modulo).
-export([funcion1/2]).
-export([funcion2/1]).
-export([funcion3/4]).

Hay que poner atención en el . que hay al final del módulo y de las funciones exportadas.

En cuanto a la tolerancia a fallos, se puede mencionar que la idea en Erlang sobre estos errores o fallos que se pueden dar, es encontrar una buena forma de manejar dichos errores y problemas en lugar de prevenirlos.

En el reemplazo de código en caliente, puedo mencionar que la unidad mínima de reemplazo son los módulos.

Pueden estar cargadas en memoria al mismo tiempo dos versiones diferentes de un mismo módulo, pero cuando se realiza la llamada a una función, la versión que se utilizará será la última versión disponible del módulo.

Como lo mencione anteriormente la interacción o comunicación que hay entre los threads (procesos), se realiza mediante mensajes.

Bueno, a continuación les mostraré un sencillo ejemplo de un programa en Erlang, al que llame operaciones.

La extensión de los programas en Erlang es .erl
Además el nombre del módulo del programa deberá ser el mismo nombre del programa, en este caso el nombre del módulo es operaciones.

Código

-module(operaciones).
-export([suma/2]).
-export([resta/2]).
-export([multiplicacion/2]).
-export([division/2]).

suma(A,B) ->
A+B.

resta(C,D) ->
C-D.

multiplicacion(E,F) ->
E*F.

division(G,H) ->
G / H.

En sí, este programa realiza las operaciones básicas, como son la suma, la resta, la multiplicación y la división.

En la parte de:

-module(operaciones).
-export([suma/2]).
-export([resta/2]).
-export([multiplicacion/2]).
-export([division/2]).

estan introducidos el módulo y las diferentes funciones junto con su aridad, dichas funciones no pueden llevar acentos. Cada función tiene una aridad de 2, es decir cada función solo puede recibir 2 datos de entrada.
Al final de cada módulo y de cada función exportada deberá ir un punto .
Y en esta parte:

suma(A,B) ->
A+B.

resta(C,D) ->
C-D.

multiplicacion(E,F) ->
E*F.

division(G,H) ->
G / H.

se encuentra cada función con su instrucción.

Dentro de los () de cada función, van las variables, que serán los datos que el usuario introducirá, es decir, los datos de entrada. Estas variables solo pueden ir en mayúscula, y en todas las funciones se pueden poner las mismas variables, en este caso no lo hicé así.
Al final de cada instrucción, deberá ir también un punto .

Bueno para compilar este programa, iremos a la terminal y escribiremos erl (si ya lo tenemos instalado), y después teclearemos lo siguiente:

c(operaciones).

Es decir, se escribe c(nombre_del_programa)). (con punto al final).
Y si el programa esta totalmente bien, si ningún error, entonces nos aparecerá:

{ok,operaciones}

Y ahora si, ya podemos introducir datos, para que sean realizadas las distintas operaciones.
Por ejemplo, para una suma, se deberá introducir, lo siguiente:

operaciones:suma(A,B).

En donde A,B serán cualesquiera números.
Bueno, primero se pone el nombre del módulo (o nombre del programa, que es el mismo nombre del módulo), después :(dos puntos) y luego el nombre de la función (suma, resta, multiplicacion o division) y seguido dentro de paréntesis, se escriben los valores que queremos que sean sumados, restados, multiplicados o divididos.

En cuanto a la división también aparte del /, se puede escribir div, pero este solo funciona para enteros, es decir, si se quiere obtener la división de 3 entre 6, en vez de que el resultado sea 0.5, será 0, y al dividir 29 entre 2, en vez de que resulte 14.5, se obtiene 14. Así, que si se desean divisiones, en donde el resultado no será un entero, se recomienda utilizar el /.

Bueno, aquí les colocó la imagen de la ejecución de este programa, en donde realice cada una de las operaciones:

*Nota: Para salir de la ejecución del programa se escribe halt().

Bueno, aquí están las referencias en las que me base para realizar esta entrada.
Programación en Erlang
Erlang(1)
Erlang (Concurrencia)
Erlang(2)

Aquí les dejo el código.
operaciones.erl

Saludos.

Cálculo Lambda

El cálculo lambda fue desarrollado por Alonso Church en el año de 1930. En sí fue desarrollado para dar una definición precisa de lo que es una función.
Además el cálculo lambda también puede ser usado para definir en una forma precisa lo que es una función computable. Se dice que este ćalculo es universal ya que puede expresar y evaluar cualequier funcion computable. Por esta razón el cálculo lambda es equivalente a las máquinas de Turing, sin embargo el cálculo λ es una propuesta más cercana al software que al hardware.

El cálculo lambda trabaja con objetos llamados lambda-términos, los cuales son cadenas de símbolos como una de las siguientes forma:

• v
• λv.E₁
• (E₁ E₂)

Donde v es una variable, y donde E₁ y E₂ son lambda-términos. Y los términos de la forma λv.E₁ son abstracciones, de lo cual, les hablaré más adelante.

El cálculo lambda se puede considerar como el lenguaje universal más pequeño. Ha sido empleado también como fundamento conceptual de los lenguajes de programación.

Sintaxis
La sintaxis del Cálculo Lambda es:
<término>::= <variable> |
λ<variable>.<término> |
(<término><término>)

Esta sintaxis solo representa a las funciones con un argumento.
Si se quieren mas argumentos sería de la siguiente forma:
λx1.λ x2. .... λxn. M

Un término o expresión en el cálculo lambda se define recursivamente mediante las reglas siguientes:

• Todas las variables son términos, es decir cada una de las variables es un término.
• Suponiendo que x es una variable y t es un término, entonces (λx.t) es un término llamado abstracción lambda.
• Suponiendo que t y s son términos, entonces (ts) es un término llamado aplicación lambda.
• Ninguna otra cosa más que lo anterior, es un término.
  

Una abstracción lambda o abstracción funcional λx.t representa una función que toma solo a un argumento, además se dice que λ liga la variable x en el término t.

Por otra parte, la aplicación lambda o aplicación funcional ts representa la aplicación de un argumento s a una función t.
La aplicación lambda tiene el formato (M N) y dicha aplicación tendrá un resultado.
Para calcular el resultado de una aplicación lambda o funcional será atraves de la generación de expresiones equivalentes por la aplicación de las reglas del cálculo λ.

La relación de equivalencia entre las expresiones del cálculo λ tendrá las siguientes propiedades:

• Reflexividad M = M
  
• Simetría M = N -> N = M
  
• Transitividad M = N Λ N = P -> M = P

También tendrá las siguientes reglas:
M = N -> (M P) = (N P)
M = N -> (P M) = (P N)
M = N -> λx.N = λx.M

Ocurrencia de los términos
Dado en el siguiente término, se ejemplifica la ocurrencia:

((xy)λx.(xy))

(xy) ocurre dos veces
x ocurre tres veces
y ocurre dos veces

Ahora definiré lo que es ocurrencia ligada.
Una ocurrencia de la variable x en un término P es ligada, solamente si x ocurre en un subtérmino de P de la forma λx.M; esto se puede aplicar en el siguiente término: (λy.(yy)λx.(xy)

En sí, x y y ocurren ligadas en el término anterior, ya que este término contiene a los subtérminos:

λy.(yy) -> donde y ocurre ligada tres veces
λx.(xy) -> donde x ocurre ligada dos veces.

Ahora definiré lo que es ocurrencia libre.
Si x ocurre libre en un término de P por lo menos una vez, entonces x es una variable libre de P.
Esto es:
Bueno, en si esto es lo que trata el Cálculo Lambda.
Aquí les dejaré las referencias que utilice para este tema:

Paradigmas de Programación: Cálculo Lambda.
Cálculo Lambda.
Cálculo λ


Saludos.

Máquinas de Turing

La máquina de Turing es un modelo computacional autómata que de una forma secuencial realiza una lectura/escritura de datos, moviéndose en los dos sentidos, derecha e izquierda.

Kurt Gödel descubrió que ciertos teoremas matemáticos aunque eran ciertos no podían ser probados por personas, entonces aquí entra lo que es el concepto de máquina de Turing, introducido por Alan Mathison Turing, quien quería demostrar que estos teoremas se podían probar de una manera mecánica a través de la máquina de Turing.


La máquina de Turing esta conformada por:

• Una cinta. Una cinta es infinita y esta conformada por celdas o casillas, además sobre ella se realiza la lectura/escritura de los datos. Las celdas en las que en un principio no se ha escrito nada, contienen un carácter especial nulo o vacío que se representa por medio de un 0 o por medio de #. En cada celda se puede escribir un símbolo de un conjunto finito de símbolos llamado alfabeto de la máquina.

• Un cabezal. Hay un dispositivo que se mueve sobre la cinta, el cual contiene un cabezal. El cabezal se puede mover a la derecha y a la izquierda de la posición en que se encuentre de la cinta. Además el cabezal puede leer el contenido de una celda, de una en una, o escribir en la celda cualquier símbolo de su alfabeto .

• Un registro de estado. El registro de estado es el que almacena los estados de la máquina. Lo estados de la máquina son finitos y la máquina no tiene que empezar exactamente con un estado especifico.

• Tabla de acción. Contiene las instrucciones que se realizarán, y al ejecutarse estas instrucciones, se siguen los siguientes pasos:
  

1. Se lee el carácter o símbolo en la posición que se encuentra el cabezal.
2. Se escribe un nuevo símbolo en esa posición (puede ser el mismo que había). El símbolo que se escriba tiene que ser del alfabeto de la máquina y además depende del estado actual y del carácter leído.
3. Se desplaza el cabezal una celda ya sea a la izquierda o a la derecha.
4. Se decidirá cual será el nuevo estado en función del estado actual y del carácter que se acaba de leer. Si la tabla de acción no tiene ya correspondencia con el estado actual y con el símbolo, entonces la máquina ya no realiza su funcionamiento, es decir la máquina detiene su funcionamiento.

Ejemplo de una suma de dos números.
Para realizar la suma de dos números, representaremos a cada número tantos unos como se el tamaño del número, es decir, que si vamos a sumar los números 3 y 5, entonces al número 3 lo representaremos así, 111 (3 veces 1) y al número 5 lo representaremos así 11111 (5 veces 1).

Si tenemos a los dos números que sumaremos, separados por un 0, entonces lo que haríamos para sumarlos, sería cambiar un 1 de cualquier extremo de la cinta a un 0, y después al 0 que esta separando a los dos números lo convertiríamos a un 1. Así, ya tendríamos todos los unos juntos, es decir, ya tendríamos los dos números (3 y 5) juntos, es decir, ya estarían sumados.

Es decir, esto sería así:
Cinta
0000111011111000

Ahora colocaremos un 0 en el primer 1 de la izquierda.
0000011011111000

Ahora, colocaremos un 1 en donde se encuentra el 0 de separación.
0000011111111000

Y ahora que ya tenemos todos los unos juntos, es decir los dos números, 3 y 5, ya tenemos la suma, que es 8 unos, entonces la suma de 3 y 5 es 8.

Veamos esto ahora implementándolo con la máquina de Turing.

Vamos a suponer que la máquina se encuentra del lado izquierdo. Empezamos con el estado A y como el cabezal no se encuentra necesariamente antes del primer número, en este caso en el 111 (3), haremos que el cabezal llegue hasta allí sin alterar los caracteres anteriores a este número. Lo que haremos, será que cuando el cabezal lea un 0 en una celda y este en estado A, entonces se escribirá un cero, es decir no se alterará nada, después se volverá al estado A y se moverá hacia la derecha.

Después al moverse a la derecha se llegará al primer número, es decir al 111 (3), y como nos encontraremos en estado A y llegamos a un 1, entonces se cambiará al 1 por un 0 (este 1 es el único que debemos cambiar a 0 como lo mencione anteriormente, cambiar un 1 de cualquier extremo de la cinta a un 0). Como seguiremos a la derecha para llegar al 0 de separación, nos encontraremos con mas unos, entonces como nos encontramos en estado A, esos unos se convertirían en ceros, pero no queremos esto, ya que queremos juntar los unos, para realizar la suma de los dos números, entonces lo que haremos será añadir un nuevo estado B, que cuando se encuentre un 1 en estado A, se deberá pasar a estado B.

Ya cuando se convirtió en 0 el 1, el estado A se pasa a estado B, entonces se seguirá desplazando el cabezal hacia la derecha hasta llegar al 0 de separación, sin alterar nada y cuando se va desplazando el cabezal por cada celda y se encuentra un 1 en estado B, entonces este 1 se convertirá en un 1 y se pasará el cabezal hacia la derecha y se pasará de nuevo a estado B. Y ya cuando llegue a una celda en donde encuentre el carácter 0, significa que ha llegado al 0 de separación y si esta en estado B, entonces este 0 se convertirá a 1.

Ahora que la suma esta terminada, entonces la máquina deberá de parar y pasar a un estado correspondiente, al cual llamaremos @. Cuando la máquina llega a este estado, ya no leerá ninguna celda mas y tampoco ya no se desplazará, entonces la máquina se detendrá.

El programa de este ejemplo con la máquina Turing es así (donde > es desplazarse hacia la derecha):

           0         1 

  A      0,A,>     0,B,> 

  B      1,@       1,B,> 

Las páginas en las que me base son las siguientes:

Computación: Máquina de Turing
Máquina de Turing
Máquinas de Turing

Videos sobre la máquina de Turing

Máquina de Turing (1)

Máquina de Turing (2)

Saludos.

Mas Scripts

Hola compañeros, a continuación les mostraré mas programas que realice en los lenguajes AWK y PYTHON.

Lenguaje AWK
En este lenguaje cree dos programas más. Como ya lo había mencionado antes, AWK es un lenguaje que es muy eficiente para bases de datos, ya que con tan solo unas líneas de código, es posible acceder a una base de datos y realizar distintas instrucciones.

Uno de los programas que realicé en AWK, lo llame sumarregistros.awk, y es el siguiente:

#!/usr/bin/awk

BEGIN{suma = 0}
{sum = suma + NR}
END{print "El archivo contiene", sum, "registros"}

Lo que este programa realiza, es, sumar el numero de registros que se pueden encontrar en una base de datos, es decir, el numero total de lineas que contiene el archivo o base de datos y después imprime ese número de registros.
Este código comienza con la expresion BEGIN y termina con la expresion END, esto hace que el programa realice acciones antes de ir (procesar) al primer registro; si estas expresiones no se colocaran, entonces el programa me imprimiría el numero de cada registro (linea), es decir, si el archivo contiene 4 lineas o registros, entonces me imprimirá 4 veces, El archivo contiene 1 registros y asi hasta llegar al número 4.

Iniciamos con suma = 0, y después coloque sum = suma + NR, que es aquí donde se obtiene la suma total de registros del archivo o base de datos.

NR (Number of record, Número de registro) es una variable predefinida, que contiene el numero de registros del archivo o base de datos.

Y al final del código coloque {print "El archivo contiene", sum, "registros"}, que esto hace que se impriman en la terminal el número de registros.

A continuación, les muestro el archivo que utilicé para ejecutar este programa, al cual nombre como arch.txt.

arch.txt

Como vemos, este archivo llamado arch.txt, solo contiene 4 registros ó lineas.

Para ejecutar este programa tecleeamos lo siguiente en la terminal:

awk -f sumarregistros.awk arch.txt

Ejecución


Otro programa que realicé en AWK, es uno que procesa o lee cada linea de un archivo o base de datos, e imprime el número total de campos que hay en cada uno de los registros o lineas del archivo. El

El código del programa, al cual nombre como linea.awk, es el siguiente:

#!/usr/bin/awk

{print "Procesando linea"}
{print "La linea", NR, "contiene", NF, "campos"}

Como ya sabemos NR es el número de registros de un archivo, pero ahora utilicé además de esta variable, a la variable NF(Number of fields, Número de campos), que es el número de campos que contiene cada registro que se va leyendo o procesando de un archivo o base de datos.
Este programa, en la parte de {print "La linea", NR, "contiene", NF, "campos"}, me va imprimiendo el número de cada línea del archivo, junto con el número total de campos que contiene esta linea.
Los campos son el total de palabras que contiene cada registro o línea, que son delimitados por el caracter "espacio".

A continuación, les muestro el archivo que utilicé para este programa, el cual nombre como archivo.txt.

archivo.txt


Podemos ver, que la linea 1 contiene 4 campos, la linea 2 contiene 3 campos, la linea 3 contiene 5 campos, la linea 4 contiene 6 campos y la linea 5 contiene 4 campos.

Para ejecutar este programa, tecleamos en la terminal lo siguiente:

awk -f linea.awk archivo.txt

Ejecución


Lenguaje PYTHON
En el lenguaje Python realice varios programas utilizando un módulo o libreria llamada os, la cual contiene comandos para crear carpetas, borrar carpetas, eliminar archivos, cambiar nombre a un archivo, ver si algun archivo existe o no, etc.

Uno de los programas que realicé en Python, lo llame oscrear.py, y es el siguiente:

#!usr/bin/python

import os

b = raw_input("\nNombre de la carpeta que desea crear: ")

os.mkdir(b)

print("Creando carpeta..."), b

Lo que este programa realiza, es crear una carpeta.
Principalmente, se coloca el módulo o librería os, colocandola así import os.
La parte de b = raw_input("\nNombre de la carpeta que desea crear: "), pide al usuario que introduzca el nombre de la carpeta que desea que se cree.
Si en vez de colocar raw_input(""), se colocara int(input("")), al momento de que se te pide el nombre de la carpeta a crear, aparece un error, ya que se esta introduciendo el nombre de una carpeta, es decir, se estan introduciendo letras, y es por eso que se debe colocar raw_input(""), ya que esta función lee la entrada, en este caso, el nombre de la carpeta a crear y la convierte en una cadena.

El comando os.mkdir(b), es el que reliza la creación de la carpeta.
b es la carpeta a crear, y es por eso que se coloca dentro de (), en el comando os.mkdir, para que el comando cree a b, es decir, cree a la carpeta con el nombre que el usuario haya introducido.

A continuación les muestro la imagen en donde aún no se ha creado la carpeta.


Para ejecutar este programa, introducimos en la terminal lo siguiente:

python oscrear.py

Ejecución

En este caso, el nombre de la carpeta que se creó se llama Trabajos, y a continuación les muestro la imagen en donde se muestra que esta carpeta ya ha sido creada.


Otro programa que realice en Python lo llame osborrac.py, y es el siguiente:

#!/usr/bin/python

import os

c = raw_input("\nIntroduzca el nombre de la carpeta que desea eliminar: ")

os.rmdir(c)

print "Borrando...", c

Este programa lo que realiza es eliminar una carpeta que el usuario introduzca, por eso es c = raw_input("\nIntroduzca el nombre de la carpeta que desea eliminar: "), donde c, es la carpeta que se desea que sea eliminada. E igualmente utilice raw_input(), ya que se introduce también el nombre de una carpeta (cadena), pero en este caso para ser eliminada.
os.rmdir(c), es el comando que realiza la acción de eliminar la carpeta.
Algo que es importante, es que este comando solo elimina carpetas vacías. Algo también importante es que al ser eliminada la carpeta, se eliminará totalmente, es decir, no se enviará a la papelera de reciclaje o Trash.

Bueno, les mostraré la imagen de una carpeta llamada Tareas que contiene un archivo.


Y para ejecutar el programa, teclearemos lo siguiente:

python osborrarc.py

Ejecución (Con carpeta Tareas, no vacía)

Como vemos, nos marca un error, diciendonos que el directorio o carpeta no esta vacía.

Aquí les muestro la imagen de la carpeta que en el programa anterior realice, llamada Trabajos.


Ejecución (Eliminar carpeta Trabajos, vacía)

Como vemos, ya no nos mostró ningún error, ya que la carpeta Trabajos esta vacía

Y a continuación les muestro la imagen donde ya la carpeta Trabajos ha sido eliminada.


Bueno, el siguiente programa lo llamé osborrara.py, , que igual que los programas anteriores contiene un comando que en esete caso lo que realiza, es eliminar un archivo.
El código de este programa es el siguiente:

#!/usr/bin/python 

import os 

a = raw_input("\nArchivo que se desea eliminar: ")

os.remove(a)

print "Borrando archivo...", a

En este programa también se tiene que colocar la funciónraw_input(""), ya que este programa lo que realiza es eliminar un archivo, y primeramente se pide al usuario que introduzca el nombre del archivo que desea eliminar, y el nombre del archivo debe convertirse en una cadena; es por eso que se utiliza también en este programa la función raw_input(""), siendo a, el archivo a eliminar.
El comando os.remove(), es el que realiza la función de eliminar el archivo que el usuario ha introducido.
El archivo a, se encuentra dentro de (), en el comando os.remove(), para que sea eliminado.
Algo importante, es que al ser eliminado el archivo, se eliminará totalmente, es deicr, no se enviará a la papelera de reciclaje o Trash.

Si se desea eliminar directamente un archivo sin la necesidad de introducir el nombre de este en la terminal, entonces en el comando se tendrá que colocar el nombre del archivo a eliminar junto con su extensión y entre comillas simples o dobles, es decir, os.remove('nombredearchivo.extension') o os.remove("nombredearchivo.extension").

El archivo que utilice para ejecutar este programa, lo nombre ar.txt, y a continuación les muestro la imagen en donde se muestra que el archivo aún no se ha eliminado.


Para ejecutar el programa, tecleamos en la terminal lo siguiente:

python osborrara.py

Ejecución


Aquí les muestro la imagen donde se muestra que el archivo ar.txt ha sido eliminado.


El siguiente programa que realicé, lo llame oscambiar.py, y es el siguiente:

#!/usr/bin/python

import os

d = raw_input("\nNombre del archivo al que desea cambiar el nombre: ")

e = raw_input("\nNombre nuevo del archivo: ")

os.rename(d,e)

print "\nCambiando nombre del archivo ", d
print "por el nombre de ", e

Lo que este programa realiza es cambiar el nombre de un archivo.
Primeramente mediante la parte del código:
d = raw_input("\nNombre del archivo al que desea cambiar el nombre: ")
e = raw_input("\nNombre nuevo del archivo: ")
se le pide al usuario que introduzca el nombre del archivo al que desea cambiarle el nombre, y después se pide al usuario que introduzca el nombre nuevo del archivo, siendo d y e, el archivo al que se le desea cambiar el nombre, y el nombre nuevo del archivo, respectivamente.

El comando os.rename(d,e), es el que realiza el cambio de nombre del archivo. Dentro de (), se coloca primeramente el archivo al que se desea cambiarle el nombre y después de una coma se coloca el nombre nuevo del archivo, en este caso, os.rename(d,e).
Si directamente se desea cambiar el nombre de un archivo sin la necesidad de introducirlo en la terminal, entonces en el comando os.rename(), se colocará dentro de (), el nombre del archivo al que se desea cambiar el nombre, y el nombre nuevo del archivo, respectivamente, con sus extensiones, dentro de comillas simples o comillas dobles, es decir, os.rename('nombredearchivo.extension','nombrenuevodearchivo.extension') o os.rename("nombredearchivo.extension","nombrenuevodearchivo.extension").

El programa que utilicé para ejecutar este programa se llama HolaMundo.java.
Aquí les muestro la imagen en donde se muestra este archivo con el nombre que aún no ha sido cambiado.


Para ejecutar este programa, tecleamos en la terminal lo siguiente:

python oscambiar.py

Ejecución

Como se muestra en la ejecución, se cambió el nombre de HolaMundo.java por el nombre de HelloWorld.java.

Aquí les muestro la imagen en donde se muestra el archivo HolaMundo.java ahora con el nombre de HelloWorld.java.


El siguiente programa lo nombre osexiste.py y es el siguiente:

#!/usr/bin/python

import os

a = raw_input("\nQue archivo desea saber si existe: ")

os.path.exists(a)

if os.path.exists(a):
 
 print "\nSi existe el archivo ", a 
 print "\nEl archivo es el siguiente: \n"
 f = open(a, "r")
 for i in f:
  print i

else:
 print "\nNo existe el archivo ", a

Lo que este programa realiza, es decir si un archivo existe o no, y si existe, imprime lo que se encuentra en el archivo.
Primero se pide al usuario que introduzca el nombre del archivo que desea saber si existe mediante: a = raw_input("\nQue archivo desea saber si existe: "), donde a, es el archivo que se desea saber si existe. También se utiliza la función raw_input(""), para convertir en cadena el nombre del archivo.

El comando os.path.exists(a), es el que realiza la función de decir si un archivo existe.
if os.path.exists(a):, es una condición que menciona que si a existe, entonces mediante print "\nSi existe el archivo ", a , se imprimirá que el archivo a, existe. Además, ya que el archivo si existe, entonces mediante f = open(a, "r"), el archivo a, será abierto en modo de lectura ("r"), y mediante for i in f:, se irá leyendo el archivo a, y mediante print i, se imprimirá el contenido del archivo a. Y mediante else:
print "\nNo existe el archivo ", a, se dice que si no existe el archivo entonces se imprimirá que el archivo a, no existe.

Hay algo muy importante en la sintaxis del if, del for y del else.
Esto es, que cuando después de cada una de estas sentencias, todo lo que se coloque dentro de ellas, se deberá pasar un espacio hacia la derecha en cada línea, sino se hace esto, al momento de ejecutar el programa, se maracará un error, ya que se estará esperando que se coloque una sangría o espacio en lo que esta dentro de cada una de estas sentencias. Ya que si no se coloca de esta manera lo que este dentro de cada sentencia, entonces el programa estará tomando en cuenta que esa parte no esta dentro de la sentencia.
Además después de cada una de estas sentencias se deberan de color : (dos puntos).

Aquí les muestro la imagen de los archivos existentes.


Para ejecutar este programa, tecleamos en la terminal lo siguiente:

python osexiste.py

Aquí les muestro la ejecución del programa, en donde se introdujo el nombre de un archivo que no existe.

Como vemos el archivo jik.txt no existe, como lo podemos ver en la imagen en donde se encuentran los archivos existentes.

Aquí les muestro la imagen de un archivo que si existe, el cual se llama palabras.py.

Como podemos ver, este archivo si existe, y lo podemos comprobar observando la imagen en donde se encuentran los archivos existentes.
También en esta ejecución se puede ver que se imprimió lo que se encuentra dentro de este archivo palabras.py.

Aquí les muestro lo que en este archivo existe, para que se observe que es la misma información que se imprimió en la terminal.


Bueno aquí les dejo los links para descargar estos programas:
oscrear.py
osborrarc.py
osborrara.py
oscambiar.py
osexiste.py

También les dejo los links de las páginas que utilice para realizar los programas, (son en las que mas me base):
AWK
PYTHON

Bueno espero que hayan entendido cada uno de estos programas.
Gracias por su atención.
Saludos.

Terecera Presentación "Detección de palíndromos"

Bueno, esta es la presemtación del tema "Detección de palíndromos que mi compañera Sandra Cecilia Urbina Coronado y yo escogimos.
Saludos.