C colabora con Bash

Esto es una continuación de la entrada Python colabora con Bash. Se debe a un comentario de un usuario en Taringa. Aquí colocaré el mismo código de ejemplo en C:

#include

int main(void)
 
{
int i;

for(i=0;i<10 b="b" i="i">
{
system("iceweasel http://galegolinux.blogspot.com.es/");
}

printf('''El programa ha terminado''')
return 0;
}

Python colabora con bash

El otro día se me ocurrieron un par de comandos que querría introducir en un programa de optimización para Debian (lo típico, instalar prelink....borrar el cache...etc) y quería un programa con bastantes opciones por lo que preferí no utilizar bash, sino python. Indagué un poco como podría correr comandos del sistema desde python y es muy sencillo. Sólo es necesario importar el módulo os.

Ahora os presento un ejemplo, imaginad que queréis interrumpir el acceso de otros usuarios a este blog y mandáis muchas peticiones de entrada (como si abrieseis en iceweasel -o el navegador que utilicéis- muchas pestañas de Galegolinux simultaneamente. Todo ello podría automatizarse así:

#!usr/bin/env python3
# Nombre: llamadas_web


import os
def naveg():
    i = 1
    for i in range(1, 10):
        os.system('iceweasel http://galegolinux.blogspot.com.es/')

naveg()

print('''El programa ha terminado''')

Primero llamamos al módulo os con import os
Luego definimos la función naveg() y para invocar un comando del sistema empleamos os.system('comando').

Por supuesto no toméis la idea como una invitación a intentar atacar el blog.....en todo caso cambiad la dirección web jajaja. De todas formas google emplea un mecanismo en blogger que anula estos scripts tan sencillos (afortunadamente).

Un saludo!

Scipt comienza al arranque

Para que un script empiece con el arranque del sistema, simplemente lo guardáis o creáis en la ruta:

~/.kde/Autostart/

Programar en Bash, pequeño manual de referencia

1. Cómo ejecutar scripts Bash

Para escribir en Bash puedes hacerlo directamente desde la consola/terminal de GNU/Linux, sin embargo, su mayor potencia radica en poder escribir ‘scripts’ y ejecutar piezas de código para automatizar tareas. Aquí muestro paso a paso un ejemplo.

1.1. Escribe un ‘script’ Bash

Abre tu editor de textos favoritos y escribe el siguiente código.

1. #!/bin/bash  
2. echo "Hola mundo"  

Guárdalo como holamundo.sh (la extensión no importa pero ésta es renococida por muchos editores de texto) .

1.2. Dale permisos

Para lanzar el ‘script’ Bash, dále permisos de ejecución. Para ello escribe en tu terminal/consola de comandos:
chmod u+x holamundo.sh
Recuerda ejecutar este comando y los siguientes en la misma carpeta/directorio donde se encuentra holamundo.sh

1.3. Ejecútalo

Lanza el ‘script’ ejecutando en tu terminal/consola:
./holamundo.sh
Si no ha habido ningún problema se ejecutará el ‘script’ de Bash mostrando la frase “Hola mundo”.

2. Características Bash

Aquí se mostrarán las características de dicho intérprete de comandos o shell de GNU. Recuerda que los comandos son las acciones a ejecutar desde la consola/terminal Linux. En la siguiente sección hay una recopilación de ellos.

2.1. Comentarios

Los comentarios en Bash se hacen línea a línea con el símbolo #.

1. #!/bin/bash  
2.   
3. #  
4. # Hola Mundo comentado  
5. #  
6.   
7. echo "Hola mundo"  

2.2. Variables

Las variables no tienen tipo, es decir, una variable puede contener una cadena, un número, etc. sin necesidad de definirlo.
La sintaxis es:
nombre_variable=valor_variable
Es obligatorio no dejar espacios antes o despues del simbolo ‘=’ ya que sino Bash interpretaría la variable como un comando Linux.
Para acceder a una variable simplemente escribe como prefijo $ en el nombre de la variable.
echo $varname
Un ejemplo sencillo:

1. #!/bin/bash  
2.   
3. # Asignación y salida de variables  
4.   
5. mivariable="Me llamo Nacho"  
6. echo $mivariable  

2.2.1. Paso de variables

Cuando ejecutas desde tu terminal/consola tienes la posibilidad de pasarle más argumentos. Por ejemplo:
./miScript.sh hola 4
Para recoger estos valores escribe $ y a continuación el número de posición del argumento pasado. El primer argumento tiene valor $1, que sería ‘hola’, y el segundo argumento sería $2, en el ejemplo sería el número 4. La variable $0 es el propio nombre del archivo.

1. #!/bin/bash  
2.   
3. #  
4. # Paso de variables  
5. #  
6.   
7. echo "Tu primer argumento es" $1  
8. echo "Tu segundo argumento es" $2  

También hay que destacar que $? guarda el valor de salida del último comando ejecutado. $* almacena todos los argumentos y $# es el número de argumentos pasados.

2.3. Comparaciones y/o expresiones

Los condicionales y bucles se rigen mediante la evaluación de una expresión. Por eso lo primero es saber cómo programar en Bash las evaluaciones de una expresión.
La evaluación de una expresión da como resultado verdadero o falso. Si la comparación o evaluación de la expresión es verdadera se ejecutará el bucle o la condicional, si es falsa la evaluación no se ejecutará.
En Bash, la sintaxis es la siguiente:

test expresión

ó

[ expresión ]

Un ejemplo de expresión sería [ 3 -eq 5 ] que comprueba si el valor 3 es igual a 5. Como es incorrecto, el valor que devuelve es falso. Los símbolos [ y ] tienen que estar obligatoriamente separados por un espacio.

2.3.1. Comparaciones numéricas

numero1 -eq numero2: Devuelve verdadero si 'numero1' es igual a 'numero2'.
numero1 -ge numero2: Devuelve verdadero si 'numero1' es igual o mayor a 'numero2'.
numero1 -gt numero2: Devuelve verdadero si 'numero1' es mayor a 'numero2'.
numero1 -le numero2: Devuelve verdadero si 'numero1' es igual o menor a 'numero2'.
numero1 -lt numero2: Devuelve verdadero si 'numero1' es menor a 'numero2'.
numero1 -ne numero2: Devuelve verdadero si 'numero1' no es igual a 'numero2'.

2.3.2. Comparaciones de cadenas

cadena1 = cadena2: Devuelve verdadero si 'cadena1' es idéntica a 'cadena2'.
cadena1 != cadena2: Devuelve verdadero si 'cadena1' no es idéntica a 'cadena2'.
cadena1: Devuelve verdadero si 'cadena1' es nulo (no significa que su longitud sea cero).
-n cadena1: Devuelve verdadero si la longitud de caracteres de 'cadena1' es mayor que cero.
-z cadena1: Devuelve verdadero si la longitud de caracteres de 'cadena1' es cero.

2.3.3. Comparaciones de ficheros

-d nombrefichero: Devuelve verdadero si el fichero es un directorio.
-f nombrefichero: Devuelve verdadero si el fichero es un archivo.
-r nombrefichero: Devuelve verdadero si el fichero puede ser leído.
-w nombrefichero: Devuelve verdadero si el fichero puede ser escrito.
-x nombrefichero: Devuelve verdadero si el fichero es ejecutable.

2.3.4. Comparaciones de expresiones

!expresión: Devuelve verdadero si la expresión no se cumple.
expresión1 -a expresión2: Devuelve verdadero si la expresión1 y la expresión2 se cumplen (también vale &&).
expresión1 -o expresión2: Devuelve verdadero si la expresión1 o la expresión2 se cumplen (también vale ||).

2.4. Condicionales

En programación, una sentencia condicional es una instrucción que se pueden ejecutar o no en función del valor de una expresión. En Bash, las condicionales más populares son los siguientes:

2.4.1. If – Then

if [ expresión ]
then
comandos
fi

2.4.2. If – Then – Else

if [ expresión ]
then
comandos
else
comandos
fi

2.4.3. If – Then – Else if – Else

if [ expresión1 ]
then
comandos
elif [ expresión2 ]
then
comandos
else
comandos
fi

2.4.4. Case

case cadena in
cadena1)
comandos
;;
cadena2)
comandos
;;
*)
comandos
;;
esac

Se comprueba cadena. Si concuerda con cadena1 se ejecutará los comandos correspondientes hasta llegar a ;;. Lo mismo ocurre con cadena2. Si cadena no coincide con cadena1 o cadena2 entonces se ejecutará *. Se puede añadir tantas cadenas de verificación como uno desee.

2.5. Bucles

Un bucle repite los comandos que uno ha escrito tantas veces hasta que la expresión se verifique.

2.5.1. For

Existen muchas maneras de realizar un bucle for en Bash. Yo sólo uso ésta:

for (( inicializador; condición; incremento ))
do
 comandos
done

Su sintaxis es casi idéntica a C. Aquí un ejemplo:

1. #!/bin/bash  
2. for (( c=1; c<=5; c++ ))  
3. do  
4.     echo "Bienvenido $c veces..."  
5. done  

2.5.2. While

while [ expresión ]
do
comandos
done

2.5.3. Until

until [ expresión ]
do
comandos
done

3. Comandos Linux

Lista de comandos más importantes según la Wikipedia.

3.1. Ayuda

man: muestra manual del comando que le indiquemos.
--help: da una ayuda de los comandos.

3.2. Archivos y directorios

ls: lista los archivos y directorios.
sort: ordena alfabéticamente una lista de archivos.
cd: cambio de directorio.
pwd: muestra la ruta al directorio actual.
tree: muestra la estructura de directorios y archivos en forma gráfica.
mkdir: crea un directorio.
rmdir: borro directorios.
rm -r: borra directorios no vacíos.
cp: copia archivos.
rm: borra archivos.
mv: mueve o renombra archivos y directorios.
cat: ve el contenido de uno o varios archivos.
more: ve el contenido de los archivos.
less: ve el contenido de los archivos.
split: dividir archivos.
find: busca archivos.
locate: localiza archivos según una lista generada.
updatedb: actualiza la lista de los archivos existentes.
whereis: muestra la ubicación de un archivo.
file: muestra el tipo de archivo.
whatis: muestra descripción del archivo.
wc: cuenta líneas palabras o caracteres en un archivo.
grep: busca un texto en archivos.
head: muestra el inicio de un archivo.
tail: muestra el final de un archivo.
tailf: muestra el final de un archivo y lo que se añada en el instante (logs).
tr: reemplaza caracteres en un fichero de texto.
sed: cambia una cadena de caracteres por otra.
join: cruza la información de dos archivos y muestra las partes que se repiten.
paste: toma la primera línea de cada archivo y las combina para formar una línea de salida.
uniq: elimina líneas repetidas adyacentes del archivo entrada cuando copia al archivo salida.
cut: sirve para seleccionar columnas de una tabla o campos de cada línea de archivo.
ln: crea enlaces a archivos o carpetas.
diff: muestra las diferencias entre dos archivos.
fuser: muestra que usuario tiene en uso o bloqueado un archivo o recurso.
tar: empaqueto archivos.
gzip: comprime archivos gz.
gunzip: descomprime archivos gz.
compress: comprime archivos Z.
uncompress: descomprime archivos Z.
chmod: cambio permisos a archivos y directorios.
chown: cambio de propietario.
chgrp: cambio de grupo.
vi: abre el editor de texto vi.
pico: edita un fichero de texto.

3.3. Usuarios

adduser: agregó nuevo usuario.
useradd: agregó nuevo usuario.
userdel: borra un usuario.
passwd: permite cambiar la contraseña.
su: cambio de usuario.
whoami: muestra el nombre de usuario.
logname: muestra el nombre de usuario.
id: muestra datos de identificación del usuario.
finger: da información de usuario.
chfn: cambia la información del finger.
who: muestra los usuarios del sistema.
w: muestra un detalle de los usuarios.
last: información de los últimos usuarios que han usado el sistema.
mail: programa de correo.
pine: lector de correo en modo texto.
write: manda un mensaje a la pantalla de un usuario.
mesg: activo o desactivo recibir mensajes.
wall: mensaje a todos los usuarios.
talk: establecer una charla con otro usuario.
banner: saca letrero en la pantalla.
set: da información sobre el entorno del usuario.
addgroup: agregó nuevo grupo.
groupadd: agregó nuevo grupo.
chown: cambia el propietario de un fichero.

3.4. Procesos

top: muestra los procesos que se están ejecutando y permite matarlos.
ps: muestra la lista de procesos del usuario.
ps aux: muestra la lista de procesos de la máquina.
kill: mata proceso por ID.
killall: mata proceso por nombre.
time: mide el tiempo que tarda un proceso en ejecutarse.
fg: trae a primer plano un proceso parado o en segundo plano.
bg: pone un proceso en segundo plano.
&: colocado al final de la línea de comando ejecuta en segundo plano.
nice: ajusta la prioridad de un proceso de -20 a 19.

3.5. Discos

mount: monta un disco.
umount: desmonta un disco.
df: muestra el espacio libre de los discos.
du: muestra el espacio usado por el disco o un directorio.
mkfs: formateo un disco.
fsck: estado del disco.
fdisk: gestión de particiones.

3.6. Red

netstat: muestra estado de la red.
ifconfig: muestra la configuración del dispositivo de red.
iwconfig: muestra la configuración del dispositivo de red inalámbrico.
nmap: escanea la red y muestra los puertos que se encuentran disponibles.
ping: indica si hay respuesta por parte del servidor.
nslookup: me da la IP de nuestro servidor DNS.
telnet: me conecto a un equipo remotamente.
netconf: configuro la red.
ntop: muestra los procesos de la red.
route -n: muestra la tabla de rutas.

3.7. Sistema

rlogin: se conecta a otra máquina de forma remota (remote login).
rsh: se conecta a otra máquina de forma remota (remote shell).
ftp: se conecta a otra máquina por el protocolo ftp.
reboot: reinicia la máquina.
halt: apaga el sistema.
shutdown: apaga el sistema.
init0: apaga la máquina.
init6: reinicia la máquina.
uptime: muestra el tiempo transcurrido de encendida la máquina.
exit: cierro sesión actual.
logout: salgo del sistema.
nohup: proporciona inmunidad frente a rupturas de comunicación..
dmesg: muestra mensajes del arranque del ordenador.
history: muestra todos los comandos digitados por el usuario.
uname: da información del sistema operativo.
tee: copia la entrada estándar a la salida estándar y a un archivo.
host: muestra la dirección IP del servidor en una red local.
hostname: muestra el nombre del servidor.
umask: muestra y permite cambiar la máscara de usuario.
chroot: cambia la raíz para que root ejecute algo en forma particular.
chsh: cambia el login shell.
free: estado de la memoria.
date: muestra fecha y hora actual.
cal: muestra calendario.
clear: borro la pantalla.
at: ejecuta un comando más tarde.
env: ver variables de entorno.
export: permite el uso de variables por programas en todos los caminos del usuario.
modprobe: cargo modulo.
startx: arranca el servidor X.
xev: muestra los eventos de las teclas y el ratón.
lspci: muestra los periféricos conectados al puente pci.
lsmod: muestra los modulos cargados en el sistema.
echo: escribe un mensaje en la salida estándar.
alias: crear un alias. Un comando largo abreviado en pocas letras.
unalias: borrar un alias.
bc: calculadora.
mc: ejecuta Midnight Commander.
xkill: mata una ventana gráfica.
rpm: instala los paquetes rpm RedHat.
dpkg: instala los paquetes deb Debian.
kernelcfg: manejo los modulos cargados en el kernel.
insmod: inserta modulos en el kernel.
rmmod: elimina modulos del kernel.
updatedb: actualiza la base de datos interna de archivos.
sh: cambia al bash shell.
setxkbmap: por si no funcionan las teclas con AltGr en modo X.

4. Ejemplos

Introducir dos números diferentes e indicar cuál es el mayor

1. #!/bin/bash  
2. echo "Introducir dos números:"  
3. read A  
4. read B  
5. if [ $A -gt $B ]  
6. then  
7.     echo $A "es el mayor"  
8. else  
9.     echo $B "es el mayor"  
10. fi  

Pasar dos números como parámetros e indicar el menor

#!/bin/bash 

1. echo $#  
2. if [ $# -ne 2 ]  
3. then  
4.     echo "Falta algún parámetro"  
5. elif [ $1 -eq $2 ]  
6.     then  
7.         echo "Son iguales"  
8.     elif [ $1 -lt $2 ]  
9.         then  
10.             echo $1 "es menor"  
11.         else  
12.             echo $2 "es menor"  
13. fi  

Ver los procesos que está ejecutando un usuario concreto

1. #!/bin/bash  
2. RES=s  
3. while [ $RES = s ]  
4. do  
5.     echo "Introducir nombre de usuario:"  
6.     read USU  
7.     ps aux|grep $USU  
8.     echo "¿Desea continuar?"  
9.     read RES  
10. done  

Mostrar los usuarios que pasamos como parámetros y saber si están conectados

1. #!/bin/bash  
2. for i in $*  
3. do  
4.     if who|grep -s $i>/dev/null  
5.     then  
6.         echo $i si está conectado  
7.     else  
8.         echo $i no está conectado  
9.     fi  
10. done  

Un poco de python

Vi esto en un sitio abandonado, y, aunque es escueto, me parece que puede resultarle útil a alguien, así que, ahí va:

Como usar python

Desde la linea de comando. Para arrancar el intérprete (Python interactivo) ejecutar:
Escribimos en la consola python

$ python
Python 2.3.3 (#1, Dec 30 2003, 08:29:25)
[GCC 3.3.1 (cygwing special)] on cygwin
Type “help”, “copyright”, “credits” or “license” for more
information.

>>>

>>>  A este simbolo se le llama el prompt de python y sera el encargado de decir donde empieza una linea de código.
Para salir del intérprete Ctrl­D (en Linux)

>>> import sys

>>> sys.exit()

Ejemplo:Un comando simple:

>>> print “Hola Mundo”
Hola Mundo

—————————————————————————————————————————————————————–

Editores de Python

Spe, idle,  Komodo. Pero  se  puede  usar  cualquier  editor  de  texto  plano  conocido  como  el  vim, nano, gedit, kate, quanta entre otros.
—————————————————————————————————————————————————————–

¿Cómo debes guardar los Archivos?

Debemos guardar el archivo con extension .py
Luego se ejecuta colocando en consola

python archivo.py

Es  importante  localizar  la  dirección  donde  se  encuentra  el  interprete  esto  se  hace tecleando en consola.

which  python

El  resultado  de  esto  es  la  primera  linea  que  colocamos  en nuestro script como se verá a continuación:

#!/usr/bin/python

print “Hola mundo!”

—————————————————————————————————————————————————————–

Comentarios en  python

• Comentarios de una sola linea

Se coloca con el carácter #

Ejemplo: # comentarios de una línea se indican con carácter ‘#’

• Comentarios de varias  lineas

Se debe usar tiple comillas al inicio y al final del comentario.

Ejemplo:

“”"
Este es un comentario de varias lineas
Este es un comentario de varias lineas
Este es un comentario de varias lineas
“”"

—————————————————————————————————————————————————————–

Mostrar datos por pantalla

Con print le decimos a python que muestre datos por pantalla. Realmente lo que hace print es llamar a un módulo del espacio de nombre sys: sys.stdout.write(“cadena”).
El cual le pasa como parámetro de entrada lo que pongas a continuación del print

Import sys
sys.stdout.write(“Hola mundo!”)

Equivalente a

print “Hola mundo!”

—————————————————————————————————————————————————————–

Tomar datos desde el teclado

raw_input(“Mensaje por pantalla”)

Es muy parecido a la filosofía usada para el print, ya que en este caso haremos uso del
módulo sys.stdin.read()

Import sys
variabledeSalida=sys.stdin.read(entero)
entero es el largo de la cadena a leer

Equvalente a

variabledeSalida=raw_input(“Mensaje por pantalla”)

—————————————————————————————————————————————————————–

Operadores

• Operadores Relacionales

>      mayor que
<      menor que
>=    mayor o igual que
<=    menor o igual que
!=     distinto
==    igual

• Operadores Arítmeticos

+     suma (usado para números y para concatenar cadenas)
­-      resta
*     multiplicación
/      división
%    modulo o resto

• Operadores Lógicos

and     y lógico
or        o lógico
not      no lógico

—————————————————————————————————————————————————————–

Sentencias y bloques

Las sentencias acaban en nueva línea, NO en ( ; ).
Los bloques son indicados por tabulación que sigue a una sentencia acabada en ‘:’.
E.j. (bloque.py):

#!/usr/bin/python
name = “Luis1″ # asignación de valor a variable
if name == “Luis”:
print “Hola Luis”
else:
print “¿Quién eres?”
print “¡No eres Luis!”
$ python bloque.py

Salida del terminal:

¿Quién eres?
¡No eres Luis!

—————————————————————————————————————————————————————–

Estructuras de decisiones y bucles:

La condición puede ir o no en paréntesis.
Nota: en python no existe el switch

• Sentencia if: (simple)

if condicion:

sentencia1
sentencian
else:
sentencia11
sentencia nn

• Sentencia if: (Doble)

if condicion:

sentencia1
sentencian
else:
sentencia11
sentencia nn

• Sentencia if: (múltiple)

if condicion:

sentencia1
sentencian
elif condicion:

sentencia11
sentencia nn

—————————————————————————————————————————————————————–

Control de Bucles o sentencias iterativas

• for: se utiliza para iterar sobre los miembros de una  secuencia.

Se puede usar sobre cualquier tipo de datos que sea una secuencia (lista, tupla, diccionario). La función range crea una secuencia descrita por ([start,] end [,step]), donde los campos  start y step son opcionales. Start es 0 y step  es 1 por defecto.
Ej. bucle.py

for x in range(1,5):
print x

$ python bucle.py
1 2 3 4

• while: es otra sentencia de repetición. Ejecuta un bloque de  código hasta que una condición es falsa.

while condicion:
sentencia1
sentencian

Por ejemplo:

reply = ‘repite’
>>> while reply == ‘repite’:
print ‘Hola’
reply = raw_input(‘Introduce “repite” para hacerlo de nuevo’)

• break: nos sirve para salir de un bucle, sirve para pasar a la próxima iteracion dejando sin ejecutar lo que se encuentra por debajo de el.

—————————————————————————————————————————————————————–

Identificadores

Sirven para nombrar variables, funciones y módulos . Deben empezar con un carácter no numérico y contener letras seguido de números y ‘_’ .
No se debe usar una  plabara  reservada  del  lenguaje  para  los  identificadores.
En  python  no  hace  falta delcarar  variables.  Simplemente  se  colocan  a  medida  que  se  vayan  usando.
El  solo entiende  de  expresiones  numericas  y  alfanumericas,  (estas  últimas  se  colocan  entre comillas dobles o simples.) Python es case sensitive
Palabras Reservadas:
and    elif    global    or    assert    else    if    pass    break  except    import    print    class    exec    in   raise continue    finally    is    return    def    for    lambda    try del    from    not    while
—————————————————————————————————————————————————————–

Tipos de Datos

Numéricos (integer, long integer, floating­point, and  complex)

• Strings
• Listas
• Tuplas
• Diccionarios

Numéricos (integer, long integer, floating­point, and  complex). Consiste en usar expresiones númericas sin delimitarlos entre comillas dobles o simples.
La función int, long, float lo que me hace es una conversión si es posible al tipo de datos en caso contario me lanzara una excepción.

>>> x = 4
>>> int (x)
4

>>> long(x)
4L

>>> float(x)
4.0

>>> complex (4, .2)
(4+0.2j)

Strings, delimitados por un par de (‘, ” ). Dos string juntos sin delimitador se unen

>>> print “Hi” “there”
Hithere

Algunos de los métodos que se pueden aplicar a un string son:

>>> len(‘La vida es mucho mejor con Python.’)
>>> 34

>>> ‘La vida es mucho mejor con Python.’.upper()

‘LA VIDA ES MUCHO MEJOR CON PYTHON’

>>> “La vida es mucho mejor con Python”.find(“Python”)
27

>>> “La vida es mucho mejor con Python”.find(‘Perl’)
­1

>>> ‘La vida es mucho mejor con Python’.replace(‘Python’, ‘Jython’)
‘La vida es mucho mejor con Jython’

—————————————————————————————————————————————————————–

El módulo string de Python library

Se definen  métodos para manipulación de strings:

>>> import string
>>> s1 = ‘La vida es mejor con Python’
>>> string.find(s1, ‘Python’)
21

‘%’ es el operador de formateo de cadenas:
>>> variable = ‘muchachos’
>>> “Hola  %s  %s” % (variable, “Como estan”)
‘La capital de Araba es Gasteiz’

—————————————————————————————————————————————————————–

Listas

Es un conjunto ordenado de valores, en el cual cada valor va identificado por un índice.
Los valores que constituyen una lista son sus elementos.
Las listas son similares a las  cadenas  de  texto  (strings),  que  son  conjuntos  ordenados  de  caracteres,  excepto  en que  los  elementos  de  una  lista  pueden  ser  de  cualquier  tipo.
Las  listas  y  las cadenas,  y otras cosas que se comportan como conjuntos ordenados, se llaman secuencias.
Para terminar, hay una lista especial que no contiene elementos.
Se la llama lista vacía y se representa [].
La sintaxis para acceder a los elementos de una lista es la misma que para acceder a los caracteres de una cadena: el operador corchetes [].
La expresión dentro de los corchetes especifica el índice. Recuerde que los índices siempre comienzan en cero:
Indexadas por un entero comienzan en 0:
ejemplo:

>>> meses = ["Enero", "Febrero"]
>>> print meses[0]
Enero

—————————————————————————————————————————————————————–

Matrices

Es común usar listas anidadas para representar matrices. Por ejemplo, la matriz:

1 2 3
7 8 9
4 5 6

Puede ser representada como:

>>> matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Matriz es una lista con tres elementos, siendo cada elemento una fila de la matriz.Podemos elegir una fila entera de la matriz de la forma normal:

>>> matriz[1]
[4, 5, 6]

Añadir un elemento a la lista: append añade un elemento al final de la lista

>>>meses=["enero","Febrero"]
>>> meses.append(“Marzo”)
>>> print meses
['Enero', 'Febrero', 'Marzo']

Dos puntos (:) es el operador de rodajas, permite trabajar con una  porción de la lista, el elemento indicado por el segundo parámetro no se incluye:

>>> print meses[1:2]
['Febrero']

Para usar una lista como una pila, se pueden usar append y pop:

>>> items.append(555)
>>> items [­1, 4, 6, 555]
>>> items.pop( )

Nota: Para mayor documentación sobre las metodos que se le pueden aplicar a una lista pydoc list
—————————————————————————————————————————————————————–

Listas pydoc list

L es el nombre de la lista
append(…)

|      L.append(object) ­­ append object to end
|  count(…)
|      L.count(value) ­> integer ­­ return number of occurrences of value
|  extend(…)
|      L.extend(iterable) ­­ extend list by appending elements from the iterable
|  index(…)
|      L.index(value, [start, [stop]]) ­> integer ­­ return first index of value
|  insert(…)
|      L.insert(index, object) ­­ insert object before index
|  pop(…)
|      L.pop([index]) ­> item ­­ remove and return item at index (default last)
|  remove(…)
|      L.remove(value) ­­ remove first occurrence of value
|
|  reverse(…)
|      L.reverse() ­­ reverse *IN PLACE* |

Las listas pueden contener cualquier tipo de objetos Python:

>>> meses=["Enero","Febrero"]
>>> meses1=["Marzo","Abril"]
>>> meses.append(meses1)
>>> print meses
['Enero', 'Febrero', ['Marzo', 'Abril']]
meses.append(1)
>>> print meses
['Enero', 'Febrero', ['Marzo', 'Abril'], 1]

—————————————————————————————————————————————————————–

Para añadir un elemento a una lista en una determinada posición:

>>> items = [4, 6]
>>> items.insert(0, ­1)
>>> print items
[­1, 4, 6]

—————————————————————————————————————————————————————–

Más (+) es el operador de concatenación:

>>> print meses+meses
['Enero', 'Febrero', 'Marzo', 'Enero', 'Febrero',
'Marzo']
lst=[1,”cad”,[1,2],12]

print lst #imprime la lista completa
print lst[1] #imprime cad
print lst[1][2] se imprime la d de cad
print lst[2][1] imprime el segundo componente del segundo componente de la lista es decir el 2

—————————————————————————————————————————————————————–

Acceder a un trozo de la lista sin incluir los extremos

>>>print lst[1:3]#imprime [1,2] no incluye los extremos con respecto al índice
>>>print lst[2:]# imprime la posicion 2 incluyendo el ultimo elemento de la lista
>>>print lst[:2]# imprime desde el primero hasta el de la posición 2­1 no incluye el extremo

—————————————————————————————————————————————————————–

Funcion range

st=range(20)                                      #Esta funcion lo que me crea es una lista que va desde el 0 al 19. no incluye
el 20
>>> lst=range(20)
>>> print lst

sintáxis de la función range
range([start,] stop[, step])                #nota no incluye el extremo final es decir stop

Ayudas en consola pydoc range me da documentacion sobre esta funcion.
Ejemplo:

range(0,20,4)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>>print lst[5:15:2]                           #imprime comenzando en la posición 5 hasta el 15 sin incuirlo con un
paso de 2
[5, 7, 9, 11, 13]
>>>

—————————————————————————————————————————————————————–

Cadenas y listas

Dos de las funciones más útiles del módulo string tienen que ver con listas de cadenas.

• La función split divide una cadena en una lista de palabras.

Por defecto, cualquier número de caracteres de espacio en blanco se considera un límite de palabra:

>>> import string
>>> cancion = “La lluvia en Mérida…”
>>> string.split(cancion)
[’La’, ’lluvia’, ’en’, Mérida...’]

Se puede usar un argumento opcional llamado delimitador para especificar qué caracteres se usarán como límites de palabra. El siguiente ejemplo usa la cadena ll como delimitador:

>>> string.split(cancion, ’ll’)
[’La ’, ’uvia en Mérida’]

Observe que el delimitador no aparece en la lista.

• La función join es la inversa de split. Toma una lista de cadenas y concatena los elementos con un espacio entre cada par:

>>> lista = [’La’, ’lluvia’, ’en’, Mérida...’]
>>> string.join(lista)
La lluvia en Mérida…’

Como split, join acepta un delimitador opcional que se inserta entre los elementos. El delimitador por defecto es el espacio.

>>> string.join(lista, ’_’)
La_lluvia_en_Sevilla…’

—————————————————————————————————————————————————————–

Tuplas

Son  tipo  de  datos  iguales  que  la  listas  pero  con  la  salvedad  que  no  se  pueden  modificar.
Se usan paréntesis para delimitar sus valores.
Hasta ahora, ha visto dos tipos compuestos: cadenas, que están hechas de caracteres, y listas,
que  están  hechas  de  elementos  de  cualquier  tipo.
Una  de  las  diferencias  que  señalamos  es que los elementos de una lista se pueden modificar, pero los caracteres de una cadena no.
En otras palabras, las cadenas son inmutables y las listas son mutables.
En Python hay otro tipo llamado tupla que es similar a una lista salvo en que es inmutable.
Sintácticamente, una tupla es una lista de valores separados por comas:

>>> tupla = ’a’, ’b’, ’c’, ’d’, ’e’

Aunque no es necesario, la convención     dice que  hay  que encerrar las tuplas entre paréntesis:

>>> tupla = (’a’, ’b’, ’c’, ’d’, ’e’)

Para crear una tupla con un solo elemento, debemos incluir una coma final:

>>> t1 = (’a’,)
>>> type(t1)

Sin la coma,    Python   trata (’a’) como  una cadena  entre paréntesis:

>>> t2 = (’a’)
>>> type(t2)

El operador índice selecciona un elemento de la tupla.

>>> tupla=(“a”,”b”,”c”,”d”,”e”)
>>> tupla[0]
‘a’

Y el operador  de porción elementos.

>>> tupla[1:3]
(‘b’, ‘c’)

Asignaciones multiples

i,j=10,20                     #ene ste caso i=10 y j=20

—————————————————————————————————————————————————————–

Diccionarios

Diccionarios {} arrays asociativos o mapas, indexados por una clave, el valor puede ser cualquier objeto Python, la clave normalmente es un objeto inmutables:

>>> mydict = {“altura” : “media”, “habilidad” : “intermedia”, “salario” : 1000 }
>>> print mydict
{altura’: ‘media’, ‘habilidad’: ‘intermedia’, ‘salario’: 1000

Forma de Acceder a un elemento del diccionario se hace a través de las claves

>>> print mydict["habilidad"]

intermedia

Puedes comprobar la existencia de una clave en un diccionario usando has_key:

if mydict.has_key(‘altura’):
print ‘Nodo encontrado’
Lo mismo se podría hacer:
if ‘altura’ in mydict:
print ‘Nodo encontrado’

Las claves deben ser tipos inmutables (Es decir que los valores se pueden modificar), no hay forma de saber como esta ordenado

dc={“lclave”:”valor”,”lista”:[1,2,3,4],”tupla”:([1,2,3],4),4:”entero”}

Algunos metodos aplicados a este tipo de datos (ayuda en consola pydoc dict)

clear(…)
|      D.clear() ­> None.  Remove all items from D.
|  copy(…)
|      D.copy() ­> a shallow copy of D
|  get(…)
|      D.get(k[,d]) ­> D[k] if k in D, else d.  d defaults to None.
|
|  has_key(…)
|      D.has_key(k) ­> True if D has a key k, else False
|
|  items(…)
|      D.items() ­> list of D’s (key, value) pairs, as 2­tuples
iteritems(…)
|      D.iteritems() ­> an iterator over the (key, value) items of D
¡  iterkeys(…)
|      D.iterkeys() ­> an iterator over the keys of D  |

Algunos metodos aplicados a este tipo de datos (ayuda en consola pydoc dict)

itervalues(…)
|      D.itervalues() ­> an iterator over the values of D
|  keys(…)
|      D.keys() ­> list of D’s keys
|  pop(…)
|      D.pop(k[,d]) ­> v, remove specified key and return the corresponding value
|      If key is not found, d is returned if given, otherwise KeyError is raised
|   popitem(…)
|      D.popitem() ­> (k, v), remove and return some (key, value) pair as a
|      2­tuple; but raise KeyError if D is empty
|   setdefault(…)
|      D.setdefault(k[,d]) ­> D.get(k,d), also set D[k]=d if k not in D
|  update(…)
|      D.update(E, **F) ­> None.  Update D from E and F: for k in E: D[k] = E[k]
|      (if E has keys else: for (k, v) in E: D[k] = v) then: for k in F: D[k] = F[k]
|
|  values(…)
|      D.values() ­> list of D’s values

—————————————————————————————————————————————————————–

Funciones en Python

Se usa la palabra reservada  def  seguido del identificador de la funcióny entre paréntesis los parametro; o sin parametros en caso de que no los tenga.(ojo se aplican las mismas
reglas a este identificador como si fuese una variable)def nombre_funcion(par1, par2,.., parn,): cuerpo return valor_retorno # en caso de que la función me retorne o no un parámetro
Forma de invocar a la función

nombre_funcion(arg1, arg2,.., argn,)
def myfunc(a,b):
sum = a + b
return sum
print myfunc (5,6)

En  python  tambien  se  le  pueden  colocar  a  los  parametros  de  la  función  valores  por defectos. En caso de que se llame la función y se le pase el argumento correspondiente en la función el parametro será reemplazado por el argumento.

#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
# funcionvaloresdefecto.py
#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
def myfunc(a=4,b=6):
sum = a + b
return sum
print myfunc()
print myfunc(b=8) # a es 4, sobreescribir b a 8

Pasando  una  tupla  como  parámetro. A  las  funciones  tambien  se  les  puede  pasar  una tupla  como  argumento.  Pero  entonces  el  el  parametro  dentro  de  la  función  debe  ir precedido por un asterisco (*)

#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
#Pasando una tupla a una función en el momento en que se invoca
# funcionvaloresdefecto.py
#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
def var_param(*parametros):#le estamos pasando una tupla
print “parametros es %s” %type(parametros)
for i in parametros:
print i,#la , lo que hace es que se imprima uno al lado del
otro
var_param(2,3,([1,2,3],7))

Pasando una lista como argumento: Se debe preceder los argumentos de la función por un asterisco (aunque no en este caso es opcional) al igual que sus  parametros.

#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
#Pasando una  a una lista a una función en el momento en que se invoca
# funcionvaloresdefecto2.py
#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
def var_param(parametros):#le estamos pasando una tupla
print “parametros es %s” %type(parametros)
for item in parametros:
print item#la , lo que hace es que se imprima uno al lado
del otro
lista=[2,3,([1,2,3],7)]
var_param(lista)
#Nota: La lista se transfoma en una tupla

Pasando una diccionario como argumento: Se debe preceder los argumentos de la función por un asterisco al igual que sus  parametros.

#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
#Pasando una  un diccionario a una función en el momento en que se invoca
#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
def mas_param(**dc):
print “dc es un:%s”%type(dc)
for item in dc.keys():
print “%s : %s : %s “%(item,dc[item],type(dc[item]))
dc={“nombre”:”Richard Garcia”,”correo”:”rgarcia@fundacite­merida.gob.ve”}
mas_param(**{“nombre”:”Richard Garcia”,”correo”:”rgarcia@fundacite­merida.gob.ve”})
mas_param(**dc)
#nota:  Tanto  el  argumento  como  los  parametros  deben  estar  precedidos  por  dos asteriscos

—————————————————————————————————————————————————————–

Módulos en Python

Módulos: es una colección de métodos en un fichero que acaba en .py. El nombre del fichero determina el nombre del  módulo en la mayoría de los casos.
Uso de un módulo: En otro escript aparte invoco al modulo. Donde modulo es el nombre que se le dio al fichero. Invocando a un modulo se puede hacer de dos maneras:

import nombre_modulo
from nombre_modulo import metodo1, metodo2, …, metodo n

E.j. modulo.py:

def one(a):
print “in one”,a

def two (c):

print “in two” ,c

Ejemplo  1                                                 Ejemplo2
import modulo                                          from  modulo import one
modulo.one(2)                                          one(2)

Listando los procedimientos de un modulo en la consola interactiva

>>> import modulo
>>> dir(modulo)
['__builtins__', '__doc__', '__file__', '__name__', 'one', 'two']

Donde los que aparecen sin los guiones de pisos son los procedimientos que tiene ese modulo .
Tambien se pueden saber los modulos que tiene un archivo.(En un script de la siguiente manera)

import modulo
dir(modulo)

Forma de incluir un modulo en la ruta donde python coloca los módulosimport sys

sys.path.insert(0,’ruta absoluta donde se encuentra el módulo’)

sys.path  son los sitios donde python va a buscar donde se encuentran los módulos
nota para saber los procedimientos de un modulo hago un dir(modulo)

—————————————————————————————————————————————————————–

Manejo de ficheros en Python

Abriendo un fichero en modo de lectura

f=open(”nombrefichero”,”r”)

Abriendo un fichero en modo de ecritura .

f=open(”nombrefichero”,”w”)

Abriendo un fichero en modo de escritura conservando el contenido del mismo

f=open(”nombrefichero”,”a”)

Cerrando un fichero

f.close()

—————————————————————————————————————————————————————–

Leer un fichero (leer_fichero.py)

#!/usr/bin/python
fh = open(“archivo.py”) # open crea un objeto de tipo fichero
fh = open(“archivo.py”,”r”)
for line in fh.readlines() : # lee todas las líneas en un fichero lo convierte en una lista
print line,
fh.close() #cerrando en el fichero

#!/usr/bin/python
fh = open(“ejemplo.txt”) # open crea un objeto de tipo fichero
linea=fh.readline(); leo la primera linea como una cadena devuelve false en caso de estar
vacío
while(linea) : # lee todas las líneas en un fichero
print line
linea=fh.readline()
fh.close()
Nota:  OJO CON ESTA MANERA DE LEER FICHEROS CUANDO LA PRIMERA LINEA
ESTA EN BLANCO DEL FICHERO O HAY UNA LINEA INTERCALADA VACIA

—————————————————————————————————————————————————————–

Escribir un fichero (escribirfichero.py)

#si el fichero en el cual deseo escribir no existe automáticamente se crea el fichero,
siempre y cuando tenga permisos de escritura en el directotio donde lo estoy creando
#!/usr/bin/python
fh = open(“out.txt”, “w”)  #abrir un fichero para escritura
fh.write (“estamos escribiendo …\n”)   #Escribiendo en el fichero
fh.close()  #cerrando en el fichero
luego ejecuto en consola el script
$ python escribirfichero.py
$ cat out.txt
estamos escribiendo …

—————————————————————————————————————————————————————–

Encurtidos.

Para poner valores en un archivo, debe      convertirlos en cadenas. Ya ha visto cómo hacerlo con str:

>>> f.write (str(12.3))
>>> f.write (str([1,2,3]))

El problema es que cuando vuelve usted a leer el valor, obtiene una cadena. Ha perdido la
información del tipo de dato original. En realidad, no puede distinguir dónde termina un
valor y comienza el siguiente:

>>> f.readline()
12.3[1, 2, 3]’

La solución es un encurtido, llamado así porque “conserva” estructuras de datos.  El módulo pickle contiene las órdenes necesarias. Para usarlo, importe pickle y luego abra el
archivo de la forma habitual:

>>> import pickle
>>> f = open(“test.pck”,”w”)

Manejo de ficheros en Python. Encurtidos Para almacenar una estructura de datos, use el método dump y luego cierre el archivo de la
forma habitual:

>>> pickle.dump(12.3, f)
>>> pickle.dump([1,2,3], f)
>>> f.close()

Ahora podemos abrir el archivo para     leer  y cargar  las estructuras de datos que volcamos ahí:

>>> f = open(“test.pck”,”r”)
>>> x = pickle.load(f)
>>> x
12.3
>>> type(x)

>>> y = pickle.load(f)
>>> y
[1, 2, 3]
>>> type(y)

Cada vez que invocamos load obtenemos un valor del archivo, completo con su tipo original.
—————————————————————————————————————————————————————–

Excepciones en python

Las excepciones es el método usado por Python para controlar los errores de compilación de nuestros programas y tener control sobre ellos, para que de este modo
podamos evitar que termine la ejecución de un programa de forma fortuita.Para tener este control Python nos proporciona 3 sentencias:
try: Esta palabra le indica al compilador que las siguientes sentencias pueden lanzar excepciones.

#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
exp.py
#­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
a=”Hola”
b=10
a=a+b
$ python exp.py
Traceback (most recent call last):
File “exp.py”, line 3, in ?
a=a+b

TypeError: cannot concatenate ‘str’ and ‘int’ objects
except:   Es  la  palabra  reservada  que  nos  ofrece  python  para  saber  que  a  partir  de  allí sera el tratamiento de errores para las excepciones que encontremos dentro del try
Ejemplo:

try:
a=”Hola”
b=10
a=a+b
except:
print “Error”
finally: Es la encargada de seguir el programa despues de controlar las excepciones
print “Error”
finally: Es la encargada de seguir el programa despues de controlar las excepciones

—————————————————————————————————————————————————————–

Programación orientada a objetos en python

La  programación  orientada  a  objetos  representa  una  gran  ventaja  respecto  al  método tradicional. Ene ste sentido la orientación a objetos puede considerarse como una manera
de ampliar las posibilidades de los tipos de datos de estructuras.

Sintaxis para crear clases:
Clase simple
class nombreClase:

Clase que hereda de otras clases

class nombreClase(ClaseHereda1,ClaseHereda2):
ejemplo:
Class Persona:

Sintáxis general de una clase:
class nombre_clase:
métodos_especiales
otros_métodos
Sintáxis general de una clase sin métodos:
class nombre_clase:
pass
Importar
a)Importar clases

sintaxis:
import nombreClase

b)Importar funciones de un fichero

Sintaxis:
from nombreClase import nombreMétodo1,.., nombreMétodon

Funciones o métodos de las clases
Sintaxis (Métodos especiales):
def __nombreMetodo__ (Parametros de Entrada):
Sintaxis (Otros métodos):
def nombre_metodo((Parametros de Entrada):

Ejemplo:
def __init__ (self):

self:Es la palabra reservada que usa python para referirse al objeto que estemos tratando en otros lenguajes se usa la palabra reservada this

Constructor
Es un tipo especial de método que se encarga de crear un objeto o instancia de un tipo en concreto de la clase.
En python tiene el siguiente formato

Sintaxis:
def__init__(párametrosDE entrada1,..,párametrosDE entradan):
Ejemplo:def__init__(self):
Para llamar ese constructor desde fuera de la clase se utiliza el nombre de la clase que quiere instanciar a un objeto

Sintaxis
nuevoObjeto=nombreClase(parámetrosDe Entrada1,…,Parametros de EntradaN)

Ejemplo:
persona1=Persona(‘Ana’,'Ramirez’,programador)
Class Persona:
def __init__(self):#self es una variable; el primer parametro es la clase misma

—————————————————————————————————————————————————————–

Conexion con base de datos.Sqlite

Para la base de dtos sqlite
En versiones como la 2.4 instalar: python2.4­sqlite
En versiones de 2.5 en adelante el módulo ya viene por defecto import sqlte3  esta incorporadas a partir de python 2.5. Es decir ya la trae incorporadad el lenguaje

Conexion con base de datos.Sqlite

import sqlite3 as bd #en caso de ser otra base de datos debemos importar el modulo
conn=bd.connect(“/home/richard/curso_Francisco_python/prueba36.test”)
cur=conn.cursor()
def crearTabla():
cur.execute(“create table personas(nombre text,”\
“apellidos text);”)
conn.commit()
def insertarDatosEjemplo():
personas=[['Erny','Revilla'],['Lorenzo','Gil'],['Dani','Molina']]
for persona in personas:
cur.execute(“insert into personas (nombre,apellidos) values (‘%s’,'%s’)” %
tuple(persona))
conn.commit()
**********************continua**************************

Conexion con base de datos.Sqlite
def consultarDatos():
cur.execute(“select * from personas”)
for persona in cur:
print “%20s   %20s” %(persona[0],persona[1])
“”"nota no se puede manejar la salida de una consulta dandole formato
debido a que las tuplas se devuelven en las cadenas con un caracter que
precede a las cadenas”"”
crearTabla()
insertarDatosEjemplo()
consultarDatos()
Primero debemos instalar:

• El servidor mysql (mysql­server)
• Instalar el API de la bas de datos (python­mysqldb)

Estableciendo una conexión

import MySQLdb as bd #importamos el API
conn=db.connect(db=”nombre_bd” , user=”nombre_usuario”,passwd=”pasword_user”,
host=”nombre_host”)
ejemplo:
conn=db.connect(db=”mysql” , user=”root”,passwd=”", host=”localhost”)

Conexión con base de datos. Postgrest
Primero debemos instalar:

• El servidor mysql (mysql­server)
• Instalar módulo de python para postgres (python2.5­psycopg2) en este caso si estamos trabajando  con  la  versión  de  python2.5  sino  instalar  la  correspondiente  a  la  versión  de python que estemos utilizando.

Estableciendo una conexión

import psycoppg2 as bd #importamos el modulo
conn = db.connect (database=”nombre_bd” , user=”nombre_usuario”,
password=”password”, host=”localhost”, port=”5432”)
ejemplo:
conn=db.connect(database=”asl” , user=”usuario”, password=”123″, host=”localhost”,
port=”5432″)

asl es una base de datos que ya esxiste y se creo en postgres.
Usuario es un usuario de postgres y password es la contraseña de ese usuario