Utilización de scripts wsadmin con Jython
Jython es una implementación alternativa de Python, escrita totalmente en Java™.
La herramienta wsadmin utiliza Jython V2.7. La siguiente información es un resumen básico de la sintaxis de Jython. En todos los códigos de ejemplo, la notación => al principio de una línea representa la salida de mandatos o funciones.
Para obtener información adicional específica de Jython V2.7, consulte Cambios en el comportamiento de la versión 2.7 de Jython
Si se requiere Jython V2.1, debe configurarlo explicitamente mediante uno de los métodos siguientes:
- Especifique Jython V2.1 mediante el mandato wsadmin:
wsadmin -conntype soap -usejython21 true -f test.py
- Especifique Jython V2.1 utilizando la propiedad personalizada del archivo wsadmin.properties:
com.ibm.ws.scripting.usejython21=true
El valor predeterminado es false.
Función básica
La función es el nombre de una función incorporada o una función Jython. Por ejemplo, las funciones siguientes devuelven "¡Hola a todos!" como salida:
print "¡Hola a todos!"
=>¡Hola a todos!
import sys
sys.stdout.write("¡Hola a todos!\n")
=>¡Hola a todos!
En el ejemplo, print identifica la corriente de salida estándar. Puede utilizar el módulo incorporado ejecutando sentencias import como en el ejemplo anterior. La sentencia import ejecuta el código de un módulo como parte de la importación y devuelve el objeto del módulo. sys es un módulo incorporado del lenguaje Python. En el lenguaje Python, los módulos son espacios de nombres que son lugares donde se crean los nombres. Los nombres que residen en módulos se llaman atributos. Los módulos corresponden a archivos y el lenguaje Python crea un objeto de módulo para contener todos los nombres definidos en el archivo. En otras palabras, los módulos son espacios de nombres.


Variable
Para asignar objetos a nombres, el destino de una asignación debe estar en el primer lado del signo igual (=) y el objeto que se está asignando debe estar en el otro lado. El destino en el primer lado puede ser un componente de nombre u objeto, y el objeto en el otro lado puede ser una expresión arbitraria que calcula un objeto. Existen las siguientes reglas para asignar objetos a nombres:
- Las asignaciones crean referencias de objeto.
- Los nombres se crean cuando se asignan.
- Debe asignar un nombre antes de hacer referencia a éste.
Las normas de nombres de variables son como las normas para el lenguaje C; por ejemplo, los nombres de variables puede tener un carácter de subrayado (_) o una letra más cualquier número de letras, números o subrayados.
- y
- assert
- break
- class
- continue
- def
- del
- elif
- else
- except
- exec
- finally
- for
- from
- global
- if
- import
- in
- is
- lambda
- not
- or
- pass
- raise
- return
- try
- while
Por ejemplo:
a = 5
print a
=> 5
b = a
print b
=> 5
texto1, texto2, texto3, texto4 = 'bueno', 'malo', 'bonito', 'feo'
print texto3
=> bonito
El segundo ejemplo asigna el valor de la variable "a" a la variable "b".
Tipos y operadores
La lista siguiente contiene ejemplos de los tipos de objeto incorporados:
- Números. Por ejemplo:
8, 3,133, 999L, 3+4j num1 = int(10) print num1 => 10
- Series. Por ejemplo:
'nombre', "de nombre", '' print str(12345) => '12345'
- Listas. Por ejemplo:
x = [1, [2, 'libre'], 5] y = [0, 1, 2, 3] y.append(5) print y => [0, 1, 2, 3, 5] y.reverse() print y => [5, 3, 2, 1, 0] y.sort() print y => [0, 1, 2, 3, 5] print list("manzana") => ['a', 'p', 'p', 'l', 'e'] print list((1,2,3,4,5)) => [1, 2, 3, 4, 5] prueba = "Esto es una prueba" test.index("prueba") => 10 test.index('s') => 3
La lista siguiente contiene ejemplos de los operadores:
- x or y
y se evalúa sólo si x es false. Por ejemplo:
print 0 or 1 => 1
- x and y
y se evalúa sólo si x es true. Por ejemplo:
print 0 and 1 => 0
- x +y , x - y
Suma y concatenación, sustracción. Por ejemplo:
print 6 + 7 => 13 texto1 = 'Algo' texto2 = ' más' print texto1 + texto2 => Algo más lista1 = [0, 1, 2, 3] lista2 = [4, 5, 6, 7] print lista1 + lista2 => [0, 1, 2, 3, 4, 5, 6, 7] print 10 - 5 => 5
- x * y, x / y, x % y
Multiplicación y repetición, división, resto y formato. Por ejemplo:
print 5 * 6 => 30 print 'prueba' * 3 => prueba prueba prueba print 30 / 6 => 5 print 32 % 6 => 2
- x[i], x[i:j], x(...)
Indexación, división en intervalos, llamadas a función. Por ejemplo:
prueba = "Esto es una prueba" print prueba[3] => s print prueba[3:10] => o es u print prueba[5:] => es una prueba print test[:-4] => Esto es una p print len(prueba) => 14
- <, <=, >, >=, ==, <>, !=, es no es
Operadores de comparación, identifican pruebas. Por ejemplo:
L1 = [1, ('a', 3)] L2 = [1, ('a', 2)] L1 < L2, L1 == L2, L1 > L2, L1 <> L2, L1 != L2, L1 is L2, L1 no es L2 => (0, 0, 1, 1, 1, 0, 1)
Sustitución de la barra inclinada invertida
Si la sentencia tiene que ocupar varias líneas, también puede añadir una barra inclinada invertida (\) al final de la línea anterior para indicar que continúa en la línea siguiente. No utilice caracteres de espacio en blanco, específicamente tabulaciones o espacios, a continuación del carácter de barra inclinada invertida.Por ejemplo:
text = "Esto es una prueba de líneas largas" \
" aquí continúan las líneas."
print texto
=> Esto es una prueba de líneas largas aquí continúan las líneas.
Funciones y ámbito
- def, return
La sentencia def crea una función object y la asigna a un nombre. La sentencia return devuelve un objeto de resultado al proceso que efectúa la llamada. Esto es opcional y si no está presente, una función sale de modo que el flujo de control cae al final del cuerpo de función.
- global
La sentencia global declara variables a nivel de módulo que se van a asignar. De forma predeterminada, todos los nombres asignados en una función son locales a esa función y existen sólo durante la ejecución de la función. Para asignar un nombre en el módulo que lo encierra, enumere funciones en una sentencia global.
A continuación figura la sintaxis básica para definir una función:
def nombre (arg1, arg2, ... ArgN)
statements
return value
donde nombre es el nombre de la función que se va a definir. Va seguida de los signos: abrir paréntesis, cerrar paréntesis y dos puntos. Los argumentos dentro de los paréntesis incluyen una lista de parámetros para los procedimientos. La línea siguiente a continuación de los dos puntos es el cuerpo de función. Un grupo de mandatos que forma el cuerpo de la función. Una vez que define una función Jython, se utiliza exactamente igual que cualquiera de las funciones integradas. Por ejemplo:
def intersect(seq1, seq2):
res = []
try:
for x in seq1:
if x in seq2:
res.append(x)
except:
pass
return res
Para llamar a la función anterior, utilice el mandato siguiente:
s1 = "SPAM"
s2 = "SCAM"
intersect(s1, s2)
=> [S, A, M]
intersect([1,2,3], (1.4))
=> [1]
Comentarios
Haga comentarios en el lenguaje Jython con el carácter de almohadilla (#).
Argumentos de línea de mandatos
Los shell de Jython pasan los argumentos de línea de mandatos al script con el valor de sys.argv. En wsadmin Jython, el nombre del programa o script, no es parte de sys.argv. A diferencia de wsadmin Jython, Jython autónomo utiliza el archivo de script como argumento inicial del script. Dado que sys.argv es una matriz, utilice el mandato index para extraer elementos de la lista de argumentos. Por ejemplo, test.py toma tres argumentos a, b y c.
wsadmin -f test.py a b c
Contenido de test.py:
import sys
first = sys.argv[0]
second = sys.argv[1]
third = sys.argv[2]
arglen = len(sys.argv)
Sentencias básicas
Hay dos sentencias de bucle: while y for. La sentencia condicional es if. La sentencia de manejo de errores es try. Finalmente, hay algunas sentencias para ajustar el flujo de control: break, continue y pass.
- if
La sentencia if selecciona acciones que se van a realizar. La sentencia if puede contener otras sentencias, incluidas otras sentencias if. La sentencia if puede ir seguida de una o más sentencias elif opcionales y finaliza con un bloque else opcional.
El formato general de una sentencia if se parece al siguiente:
if test1 statements1 elif test2 statements2 else statements3
Por ejemplo:
tiempo = 'soleado' if tiempo == 'soleado': print "Buen tiempo" elif tiempo == 'lluvioso': print "Mal tiempo" else: print "Inestable, no se tiene previsto nada"
- while
La sentencia while consta de una línea de cabecera con una expresión de prueba, un cuerpo de una o más sentencias con sangrado y una sentencia else opcional que se ejecuta si el control sale del bucle sin ejecutarse en una sentencia break. La sentencia while ejecuta repetidamente un bloque de sentencias con sangrado siempre que la prueba de la línea de cabecera siga evaluándose con el valor true. A continuación se muestra un ejemplo de while:
while test1 setencias1 else sentencias2
Por ejemplo:
a = 0; b = 10 while a < b: print a a = a + 1
- for
La sentencia for comienza por una línea de cabecera que especifica un destino o destinos de asignación, junto con un objeto por el que desea pasar. La cabecera va seguida de un bloqueo de sentencias con sangrado que desea repetir.
A continuación se muestra un ejemplo de una sentencia for:
for destino in objeto: sentencias else: sentencias
Asigna elementos del objeto de secuencia al destino, de uno en uno, y ejecuta el cuerpo del bucle para cada uno. El cuerpo del bucle suele utilizar el destino de la asignación para hacer referencia al elemento actual de la secuencia como si fuera un cursor que pasara por la secuencia. Por ejemplo:
suma = 0 for x in [1, 2, 3, 4]: suma = suma + x
- break, continue y pass
Puede controlar los bucles con las sentencias break, continue y pass. La sentencia break sale del bucle más cercano que lo encierra (pasa toda la sentencia del bucle). La sentencia continue salta al principio del bucle más cercano que lo encierra (a la línea de cabecera del bucle) y la sentencia pass es un representante de sentencia vacía.
- try
La sentencia emitirá un error si se llama con un número incorrecto de argumentos o si detecta alguna condición de error en particular a su implementación. Cuando hay un error no detectado se termina anormalmente la ejecución del script. La sentencia try se utiliza para interrumpir tales errores. Las sentencias try de Python vienen de dos modos, uno que maneja excepciones y otro que ejecuta el código de finalización ocurran o no excepciones. Las sentencias: try, except y else comienzan con una línea de cabecera try seguida de un bloque de sentencias con sangrado, a continuación una o más cláusulas except opcionales que nombran las excepciones que se van a capturar y una cláusula else opcional al final. Las sentencias: try y finally comienzan por una línea de cabecera try seguida de un bloque de sentencias con sangrado, luego la cláusula finally que siempre se ejecuta a la salida tanto si la excepción se produce cuando el bloque try estaba en ejecución o no.
A continuación se muestra un ejemplo de las funciones try, except, else:
try: sentencias except nombre: sentencias except nombre, datos: sentencias else sentencias
Por ejemplo:
try: myfunction() except: import sys print 'uncaught exception', sys.exc_info() try: myfilereader() except EOFError: break else: procesar aquí la línea siguiente
El formato general de una sentencia try y finally se parece al siguiente:
try sentencias finally sentencias
Por ejemplo:
def divide(x, y): return x / y def tester(y): try: print divide(8, y) finally: print 'a la salida...'
- Las sentencias se ejecutan secuencialmente de manera predeterminada. Las sentencias suelen terminar al final de la línea en la que aparecen. Cuando las sentencias son demasiado largas para caber en una sola línea también se puede añadir una barra inclinada invertida (\) al final de la línea anterior para indicar que sigue en la línea siguiente.
- Los límites de bloque y sentencia se detectan automáticamente. No hay llaves ni delimitadores begin y end alrededor de los bloques de código. En su lugar, el lenguaje Python utiliza el sangrado de sentencias bajo una cabecera para agruparlas en un bloque anidado. Los límites de bloque se detectan mediante el sangrado de línea. Todas las sentencias que tienen la misma distancia de sangrado pertenecen al mismo bloque de código hasta que el bloque termina por una línea con menos distancia de sangrado.
- Sentencias compuestas = cabecera; ':', sentencias con sangrado. Todas las sentencias compuestas del lenguaje Python siguen el mismo patrón: una línea de cabecera terminada por dos puntos, seguida de una o más sentencias anidadas sangradas bajo la cabecera. Las sentencias con sangrado se denominan bloque.
- Normalmente, se ignoran espacios y comentarios. Los espacios dentro de las sentencias y de las expresiones casi siempre se ignoran (excepto en constantes de tipo serie y el sangrado), por lo tanto son comentarios.
Invocación de scripts utilizando otro script
Utilice el mandato execfile para llamar a un script Jython desde otro script Jython. Por ejemplo:
Cree un script denominado test1.py que contenga lo siguiente:
![[AIX Solaris HP-UX Linux Windows]](../images/dist.gif)
execfile('c:/temp/script/testFunctions.py')
print printName('Cathy', 'Smith')
![[z/OS]](../images/ngzos.gif)
execfile('/temp/script/testFunctions.py')
print printName('Cathy', 'Smith')
Cree un script denominado testFunctions.py que contenga lo siguiente:
def printName(first, last):
name = first + ' ' + last
return name
A continuación, pase la siguiente vía de acceso como argumento de script:
![[AIX Solaris HP-UX Linux Windows]](../images/dist.gif)
wsadmin -lang jython -f 'c:/temp/script/test1.py'
![[z/OS]](../images/ngzos.gif)
wsadmin -lang jython -f '/temp/script/test1.py'
Debe utilizar barras inclinadas (/) como separador de la vía de acceso. Las barras inclinadas invertidas (\) no funcionarán.
Ejecución de scripts Jython que utilizan paquetes
Si ejecuta scripts que utilizan paquetes, debe proporcionar la herramienta wsadmin con la vía de acceso de búsqueda de los scripts Jython que utilizan paquetes.
Para proporcionar esta información a la herramienta wsadmin, incluya la opción siguiente cuando inicie la herramienta:
-Dwsadmin.script.libraries.packages=path1;path2;...
donde dir1 y dir2 representa las vías de acceso de búsqueda de directorios de las bibliotecas que contienen paquetes Jython.
![[Windows]](../images/windows.gif)
Uso de Jython con directorios de Microsoft Windows
Jython trata la lista siguiente de caracteres o condiciones como especiales. No utilice los caracteres, si es posible, al utilizar Jython.
- \a
- \b
- \f
- \n
- \N
- \r
- \t
- \u
- \U
- \v
- \x
- una barra inclinada invertida seguida de una secuencia de números entre 0 y 7
Cuando se especifiquen vías de acceso a archivos de Microsoft Windows en Jython, se deben tener en cuenta estas condiciones especiales. Cuando deba utilizar cualquiera de estas series de caracteres, puede contrarrestar la interpretación de Jython de estas series de caracteres especiales utilizando "dos barras invertidas" en lugar de una barra inclinada o sustituyendo una barra inclinada por una barra invertida. Los ejemplos siguientes ilustran cómo realizar estos ajustes.
Vía de acceso errónea | Vía de acceso de dos barras invertidas corregida | Vía de acceso de barra inclinada corregida |
---|---|---|
c:\aadirectory\myfile.txt | c:\\aadirectory\\myfile.txt | c:/aadirectory/myfile.txt |
c:\myfiles\number1.txt | c:\\myfiles\\number1.txt | c:/myfiles/number1.txt |
c:\zebra7\stripe.txt | c:\zebra7\\stripe.txt | c:/zebra7/stripe.txt |
c:\5mod\Net33\residue.log | c:\\fivemod\\Net33\\residue.log | c:/fivemod/Net33/residue.log |
