Sistema Operativo UNIX

1
Sistema Operativo UNIX

• Lección 10 Programación en Perl Parte II
• Prof. Antonio F. Huertas

2
Listas y arreglos
3
Listas y arreglos

• Una lista es un conjunto de valores. Por
  ejemplo
• ("Jose", "Mara", "Teresa", "Rosa")
• ("Jose", 15)
• En Perl las listas pueden ser homgéneas (todos
  los valores del mismo tipo) o heterogéneas
  (valores de distintos tipos).
• Las listas pueden ser asignadas a arreglos. Estos
  arreglos se clasifican como arreglos de escalares
  (arrays of scalars) o como arreglos asociativos
  (associative arrays, hashes).
• En Perl los arreglos son estructuras dinámicas
  (pueden aumentar o disminuir de tamaño según se
  necesite).

4
Arreglos de escalares

• Los arreglos de escalares corresponden a los
  arreglos tradicionales en los cuales el índice
  indica la posición de un elemento relativo al
  inicio del arreglo.
• El primer índice es 0.
• Los arreglos de escalares tienen nombres que
  comienzan con _at_. Por ejemplo
• _at_names ("Jose", "Mara", "Teresa", "Rosa")
• _at_values (10..15)
• Los índices del 0 al 3 del arreglo _at_names
  contienen los valores Jose, Mara, Teresa y
  Rosa , respectivamente.
• Los índice 0 al 5 del arreglo _at_values contienen
  los valores 10 al 15, respectivamente.

5
Arreglos de escalares (cont.)

• Se pueden asignar valores a varios índices a la
  vez como se muestra en el siguiente ejemplo
• _at_names4, 5 ("Pepito", "Sutano")
• Se asignan los valores Pepito y Sutano a los
  índices 4 y 5 del arreglo _at_names. El arreglo
  creció automáticamente.
• El ejemplo anterior se puede escribir así
• _at_names4, 5 qw("Pepito" "Sutano")
• Usé la función quote words para crear la lista.
• Para acceder a un elemento del arreglo se usa la
  notación arregloíndice. Por ejemplo
• print("names1\n")

6
Arreglos de escalares (cont.)

• Para recorrer un arreglo, se puede usar la
  estructura de control foreach que tiene el
  siguiente formato
• foreach variable (lista)
• enunciado(s)
• El siguiente es un ejemplo de un ciclo que
  recorre un arreglo
• index 0
• foreach theName (_at_names)
• print("El valor en el indice index es theName
  \n")
• index

7
Arreglos de escalares (cont.)

• El enunciado foreach puede ser usado para
  recorrer inclusive una lista generada por un
  comando del sistema operativo. Por ejemplo
• foreach file (ls)
• print("file\n")
• Los elementos de un arreglo pueden ser mostrados
  de forma horizontal si se invoca print() de la
  siguiente forma
• print("La lista de nombres es _at_names\n")
• Es posible mostrar elementos específicos de un
  arreglo
• print("La lista es _at_names0, 1, 3\n")

8
Arreglos de escalares (cont.)

• Si el nombre del arreglo se le asigna a una
  variable simple, lo que se almacena en la
  variable es la longitud del arreglo (cantidad de
  elementos). Por ejemplo
• length _at_names
• print("Hay length valores en la lista\n")
• Para obtener el índice del último elemento en el
  arreglo se puede usar la notación arreglo
• last_index names
• print("El ultimo indice es last_index\n")
• Si se aumenta arreglo, el tamaño del arreglo
  crece, si se disminuye arreglo, el tamaño del
  arreglo se achica.

9
Funciones push y pop

• La función push es usada para añadir elementos al
  final de un arreglo.
• La función pop es usada para remover elementos
  del final del arreglo.
• Ejemplo
• _at_names ("Jose", "Mara", "Teresa", "Rosa")
• push(_at_names, "Pepito")
• print("Push Ahora la lista es _at_names\n")
• Push Ahora la lista es Jose Mara Teresa
  Rosa Pepito
• element pop(_at_names)
• print("Pop Ahora la lista es _at_names\n")
• Push Ahora la lista es Jose Mara Teresa Rosa

10
Funciones unshift y shift

• La función unshift es usada para añadir elementos
  al principio de un arreglo.
• La función shift es usada para remover elementos
  del principio del arreglo. Causa que los
  elementos se muevan al índice anterior.
• Ejemplo
• _at_names ("Jose", "Mara", "Teresa", "Rosa")
• unshift(_at_names, "Pepito")
• print("Unshift Ahora la lista es _at_names\n")
• Unshift Ahora la lista es Pepito Jose Mara
  Teresa Rosa
• element shift(_at_names)
• print("Shift Ahora la lista es _at_names\n")
• Push Ahora la lista es Jose Mara Teresa Rosa

11
Funciones reverse y sort

• La función reverse recibe una lista y devuelve la
  lista con los elementos colocados al revés.
• La función sort recibe una lista y devuelve la
  lista con los elementos colocados en orden
  ascendente, según código ASCII.
• _at_names ("Jose", "Mara", "Teresa", "Rosa")
• print("\n")
• _at_rev_list reverse(_at_names)
• print("La lista al reves es _at_rev_list\n")
• La lista al reves es Rosa Teresa Mara Jose
• print("\n")
• _at_sort_list sort(_at_names)
• print("La lista ordenada es _at_sort_list\n")
• La lista ordenada es Jose Mara Rosa Teresa

12
El arreglo _at_ARGV

• Un arreglo importante es _at_ARGV. Este arreglo
  contiene la lista de argumentos en un programa
  cuando se invoca desde la línea de comandos.
• Ejemplo
• print("The list of arguments is _at_ARGV\n")
• length _at_ARGV
• print("There were length arguments")
• print("The first argument is ARGV0\n")
• print("\nThe list again\n")
• foreach arg (_at_ARGV)
• print("arg\n")

13
Arreglos asociativos

• Los arreglos asociativos son arreglos cuyos
  índices son valores alfanuméricos.
• Los arreglos asociativos tienen nombres que
  comienzan con . Por ejemplo
• marcas ("MI" , "Mitsubishi", "TO" , "Toyota",
• "FO" , "Ford", "CH" , "Chrysler")
• marcas ("MI" gt "Mitsubishi", "TO" gt
  "Toyota",
• "FO" gt "Ford", "CH" gt "Chrysler")
• En ambos casos los índices son MI, TO, FO y CH y
  los elementos correspondientes son Mitsubishi,
  Toyota, Ford y Chrysler.
• Para acceder a un elemento del arreglo se usa la
  notación arregloíndice. Por ejemplo
• print (marca"TO") Toyota

14
Arreglos asociativos (cont.)

• Los arreglos asociativos se conocen como hashes
  ya que internamente los datos están almacenados
  en un hash table.
• Un hash table es una estructura de datos que
  permite una búsqueda eficiente de un valor dado
  una clave (key). El índice en un arreglo
  asociativo es el key.
• El mecanismo de búsqueda en un hash table es, en
  general, más rápido que el de la búsqueda binaria
  pero los datos no se almacenan ordenados por el
  key.

15
Funciones keys y values

• Las funciones keys y values pueden ser usadas
  para obtener la lista de claves y la lista de
  valores en un arreglo asociativo.
• marcas ("MI" gt "Mitsubishi", "TO" gt
  "Toyota",
• "FO" gt "Ford", "CH" gt "Chrysler")
• _at_key_list keys(marcas)
• print ("Las claves son _at_key_list\n")
• Las claves son FO MI CH TO
• _at_value_list values(marcas)
• print ("Los valores son _at_value_list\n")
• Los valores son Ford Mitsubishi Chrysler
  Toyota
• Como se ve, los valores no salen ordenados.
  Utilice la función sort para ordenar.

16
Funciones exists y delete

• La función exists es usada para determinar si un
  valor existe en el arreglo asociativo.
• print("Indique el codigo de la marca deseada ")
• chomp(codigo ltSTDINgt)
• if (exists (marcascodigo))
• print("La marca existe y el nombre es " .
• marcascodigo."\n")
• La siguiente instrucción añade o modifica un
  valor
• marcascodigo valor
• Si el valor existe, la función delete lo elimina
• delete (marcascodigo)

17
Recorriendo arreglos asociativos

• Para recorrer un arreglo asociativo existen dos
  opciones
• Usar la función keys para obtener una lista de
  las claves y usar el enunciado foreach para
  recorrer la lista.
• Usar la función each y recorrer mientras haya
  datos en el hash.
• Ejemplos
• foreach codigo (keys(marcas))
• print("El valor correspondiente a codigo es "
  .
• marcascodigo . "\n")
• while ((codigo, nombre) each(marcas))
• print("El valor correspondiente a codigo es "
  .
• nombre . "\n")

18
Archivos
19
Manejo de archivos

• La función open es usada para abrir archivos.
• El primer argumento es el nombre lógico del
  archivo (o filehandle) y el segundo argumento
  especifica el nombre físico del archivo y el tipo
  de acceso.
• Por ejemplo, para abrir un archivo para lectura
  (read), se puede usar uno de los siguientes
• open(INFILE, "ltdata.txt")
• open(INFILE, "data.txt")
• Para abrir un archivo para escritura (write) o
  para añadirle (append), se puede usar
• open(OUTFILE, "gtdata.txt")
• open(OUTFILE, "gtgtdata.txt")

20
Manejo de archivos (cont.)

• Para cerrar archivos se usa la función close.
  Por ejemplo
• close(INFILE)
• close(OUTFILE)
• Normalmente, cuando se abre o se cierra un
  archivo se debe revisar que no hayan errores. Si
  hay errores, se debe terminar el programa usando
  la función die
• open(INFILE, "ltdata.txt") die("Error.\n")
• close(INFILE) die("Error.\n")
• El operador se utiliza para que la función die
  sólo se ejecute si la función anterior no trabaja.

21
Filehandles

• Un filehandle es el nombre de una conexión de I/O
  entre el programa y el mundo exterior.
• Como hemos visto, los filehandles sirven de
  nombres lógicos para los archivos. La
  recomendación es escribirlos usando sólo LETRAS
  MAYUSCULAS.
• Además de los filehandles creados por el
  programador, Perl reconoce los siguientes
  standard filehandles
• STDIN para el standard input, normalmente el
  teclado
• STDOUT para el standard output, normalmente la
  pantalla
• STDERR para el standard error, normalmente la
  pantalla

22
Leyendo y escribiendo archivos

• Para leer una línea de un archivo se usa un
  enunciado de asignación
• line ltINFILEgt
• Para escribir una línea al archivo se usa la
  función print o la función printf
• print(OUTFILE "Line line\n")
• Para procesar todo el archivo se puede usar un
  ciclo
• while (line ltINFILEgt) Se asigna y revisa
  si ok
• procesar line

23
Funciones split y join

• Cuando se lee una línea de un archivo, es común
  que se desee romperla en campos. Esto se hace
  con la función split.
• La función split devuelve una lista que
  corresponde a los campos. Por ejemplo
• line "1111John Doe252800"
• (id, name, age, salary) split(//, line)
• _at_fields split(//, line)
• En el segundo uso de split, los valores se
  asignaron a los elementos fields0, fields1,
  fields2 y fields3, respectivamente.
• El delimitador se escribe entre diagonales ya que
  es una expresión regular.

24
Funciones split y join (cont.)

• La función join combina todos los elementos de un
  arreglo en un string.
• Es muy útil para cuando se desea hacer cambios a
  una porción del string.
• Por ejemplo, para cambiar el nombre en el string
  conenido en line de "John Doe" a "Mary Doe", se
  pueden usar split y join
• line "1111John Doe252800"
• _at_fields split(//, line)
• fields1 "Mary Doe"
• line join("", _at_fields)

25
Here documents

• Perl permite el uso de here documents, como
  muestran los siguientes ejemplos
• print ltltEOT
• Saludos, name.
• Que tengas un buen día.
• EOT
• mensaje ltltEOM
• Saludos, name.
• Que tengas un buen día.
• EOM
• print(mensaje)

26
La variable _ y el arreglo _at__

• Muchos programas de Perl hacen uso de las
  variables especiales _ y _at__.
• Perl presume la variable _ cuando se necesita
  una variable escalar y ésta no está mencionada.
• Perl presume el arreglo _at__ cuando se necesita una
  arreglo de escalares y éste no está mencionado.
• El próximo ejemplo muestra el uso de _ y _at__
  cuando se manejan archivos.

27
La variable _ y el arreglo _at__ (cont.)

• El siguiente fragmento
• while (line ltINFILEgt)
• print("La linea leida es line")
• chomp(line)
• _at_fields split(//, line)
• print("El primer campo es fields0\n")
• Se podría escribir así
• while (ltINFILEgt) Asigna a _ y revisa si ok
• print("La linea leida es _")
• chomp
• split(//) Rompe _ y asigna campos a _at__
• print("El primer campo es _0\n")
• Nota _0 es el primer elemento del arreglo _at__.
  El elemento _0 NO tiene nada que ver con la
  variable _.

28
ltgt

• Para acortar más, algunos programadores se
  aprovechan del hecho de que ltgt simboliza el
  archivo que se le envía al programa si se invoca
  desde la línea de comandos.
• De esta forma se programan los filtros.
• El siguiente ejemplo muestra el contenido de un
  archivo
• !/usr/bin/perl
• lines 0
• while (ltgt)
• print(_)
• lines
• print("\n\nlines lines were read.\n\n")
• El programa se podría invocar así
• ./my_cat.pl in.txt
• ls l ./my_cat.pl

29
Para más información

• Consulte los siguientes capítulos de Learning
  Perl, 2da edición
• Chapter 3 Arrays and List Data
• Chapter 5 Hashes
• Chapter 6 Basic I/O
• Chapter 7 Regular Expressions
• Sec. 7.6 The split and join functions
• Chapter 10 Filehandles and File Tests
• Secs. 10.1-10.4