El Mundo de Ubuntu: Programación

Mostrando las entradas con la etiqueta Programación. Mostrar todas las entradas

Python es un lenguaje de script desarrollado por Guido van Rossum.

Podemos codificar empleando programación lineal, estructurada y orientada a objetos (tengamos en cuenta que esta última es la que se ha impuesto en la actualidad).

Se cuenta con intérpretes de Python en múltiples plataformas: Windows, Linux, Mac etc. Se pueden desarrollar aplicaciones de escritorio como aplicaciones web. Empresas como Google, Yahoo, Nasa etc. utilizan este lenguaje para sus desarrollos (actualmente el creador de Python Guido van Rossum trabaja para Google.)

Se puede ejecutar instrucciones de Python desde la línea de comando o creando archivos con extensión *.py. Cuando uno comienza a aprender este lenguaje la línea de comandos nos provee una retroalimentación del resultado en forma inmediata.

El objetivo de este tutorial es presentar en forma progresiva los conceptos fundamentales de este lenguaje y poder analizar los problemas resueltos y codificar los problemas propuestos en este mismo sitio, sin tener que instalar en un principio el Python en su equipo (o luego de instalado poder avanzar con el tutorial en cualquier máquina conectada a internet).

Redefinición de los operadores matemáticos con objetos.

Python nos permite redefinir los operadores matemáticos cuando planteamos una clase.
Los métodos especiales que debemos implementar son los siguientes:
Para el operador +:

__add__(self,objeto2)

Para el operador -:

__sub__(self,objeto2)

Para el operador *:

__mul__(self,objeto2)

Para el operador /:

__div__(self,objeto2)

Veamos con un ejemplo la sintaxis para redefinir el operador +. Crearemos una clase Cliente de un banco y redefiniremos el operador + para que nos retorne la suma de los depósitos de los dos clientes que estamos sumando.

class Cliente:
    def __init__(self,nom,mon):
        self.nombre=nom
        self.monto=mon
    def __add__(self,objeto2):
        s=self.monto+objeto2.monto
        return s
cli1=Cliente('Ana',1200)
cli2=Cliente('Luis',1500)
print 'El total depositado es '
print cli1+cli2

Es muy importante tener en cuenta que debemos redefinir un operador matemático siempre y cuando haga nuestro programa más legible.

Debemos redefinir los operadores +,-,*,/ etc. solo para las clases que con solo leer su nombre el programador intuya que operación implementaría dicho operador.

Redefinición de los operadores relacionales con objetos.

Python también nos permite redefinir los operadores relacionales cuando planteamos una clase.

Los métodos especiales que podemos implementar son los siguientes:

Para el operador ==:

__eq__(self,objeto2)

Para el operador !=:

__ne__(self,objeto2)

Para el operador >:

__gt__(self,objeto2)

Para el operador >=:

__ge__(self,objeto2)

Para el operador <:

__lt__(self,objeto2)

Para el operador <=:

__le__(self,objeto2)

Es importante recordar que una redefinición de un operador tiene sentido si ayuda y hace más claro nuestro algoritmo.

Veamos con un ejemplo la sintaxis para redefinir todos estos operadores relacionales. Crearemos una clase Persona que tiene como atributo el nombre y la edad. El operador == retornará verdadero si las dos personas tienen la misma edad, el operador > retornará True si la edad del objeto de la izquierda tiene una edad mayor a la edad del objeto de la derecha del operador >, y así sucesivamente

class Persona:
    def __init__(self,nom,ed):
        self.nombre=nom
        self.edad=ed
    def __eq__(self,objeto2):
        if self.edad==objeto2.edad:
            return True
        else:
            return False
    def __ne__(self,objeto2):
        if self.edad!=objeto2.edad:
            return True
        else:
            return False
    def __gt__(self,objeto2):
        if self.edad>objeto2.edad:
            return True
        else:
            return False
    def __ge__(self,objeto2):
        if self.edad>=objeto2.edad:
            return True
        else:
            return False
    def __lt__(self,objeto2):
        if self.edad<objeto2.edad:
            return True
        else:
            return False
    def __le__(self,objeto2):
        if self.edad<=objeto2.edad:
            return True
        else:
            return False
per1=Persona('juan',22)
per2=Persona('ana',22)
if per1==per2:
    print 'Las dos personas tienen la misma edad.'
else:
    print 'No tienen la misma edad.'

Como pedemos observar planteamos un método por cada operdor relacional:

def __eq__(self,objeto2):
        if self.edad==objeto2.edad:
            return True
        else:
            return False

El método recibe como referencia (self) la dirección del objeto ubicado a la izquierda del operador relacionar y como parámetro (objeto2) la referencia del objeto ubicado a la derecha del operador. Solo nos queda analizar el atributo edad de cada objeto y retornar True si los dos almacenan el mismo valor, en caso contrario retornar False.

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales

Otra característica que tiene que tener un lenguaje para considerarse orientado a objetos es la HERENCIA.
La herencia significa que se pueden crear nuevas clases partiendo de clases existentes, que tendrá todas los atributos y los métodos de su 'superclase' o 'clase padre' y además se le podrán añadir otros atributos y métodos propios.
En Python, a diferencia de otros lenguajes orientados a objetos (Java, C#), una clase puede derivar de varias clases, es decir, Python permite la herencia múltiple.

Superclase o clase padre.
Clase de la que desciende o deriva una clase. Las clases hijas (descendientes) heredan (incorporan) automáticamente los atributos y métodos de la la clase padre.

Subclase.
Clase desciendiente de otra. Hereda automáticamente los atributos y métodos de su superclase. Es una especialización de otra clase. Admiten la definición de nuevos atributos y métodos para aumentar la especialización de la clase.
Veamos algunos ejemplos teóricos de herencia:
1) Imaginemos la clase Vehículo. Qué clases podrían derivar de ella

Vehiculo

   Colectivo                Moto                    Auto

                                             FordK        Renault 9

Siempre hacia abajo en la jerarquía hay una especialización (las subclases añaden nuevos atributos y métodos)
2) Imaginemos la clase Software. Qué clases podrían derivar de ella?

Software

             DeAplicacion                                        DeBase

ProcesadorTexto       PlanillaDeCalculo                          SistemaOperativo

Word   WordPerfect    Excel     Lotus123                         Linux    Windows

Si vemos que dos clase responden a la pregunta ClaseA "..es un.." ClaseB es posible que haya una relación de herencia.
Por ejemplo:
Auto "es un" Vehiculo
Circulo "es una" Figura
Mouse "es un" DispositivoEntrada
Suma "es una" Operacion
Ahora plantearemos el primer problema utilizando herencia en Python. Supongamos que necesitamos implementar dos clases que llamaremos Suma y Resta. Cada clase tiene como atributo valor1, valor2 y resultado. Los métodos a definir son cargar1 (que inicializa el atributo valor1), carga2 (que inicializa el atributo valor2), operar (que en el caso de la clase "Suma" suma los dos atributos y en el caso de la clase "Resta" hace la diferencia entre valor1 y valor2, y otro método mostrarresultado.
Si analizamos ambas clases encontramos que muchos atributos y métodos son idénticos. En estos casos es bueno definir una clase padre que agrupe dichos atributos y responsabilidades comunes.
La relación de herencia que podemos disponer para este problema es:

Operacion

Suma Resta

Solamente el método operar es distinto para las clases Suma y Resta (esto hace que no lo podamos disponer en la clase Operacion), luego los métodos cargar1, cargar2 y mostrarresultado son idénticos a las dos clases, esto hace que podamos disponerlos en la clase Operacion. Lo mismo los atributos valor1, valor2 y resultado se definirán en la clase padre Operacion.
En Pyton la codificación de estas tres clases es la siguiente:

class Operacion:
    def cargar1(self,v1):
        self.valor1=v1
    def cargar2(self,v2):
        self.valor2=v2
    def imprimir(self):
        print self.resultado
        print '<br>'

class Suma(Operacion):
    def operar(self):
        self.resultado=self.valor1+self.valor2

class Resta(Operacion):
    def operar(self):
        self.resultado=self.valor1-self.valor2

s=Suma()
s.cargar1(10)
s.cargar2(20)
s.operar()
print 'La suma es:'
s.imprimir()
r=Resta()
r.cargar1(10)
r.cargar2(2)
r.operar()
print 'La resta es:'
r.imprimir()

Veamos como es la sintaxis para indicar que una clase hereda de otra:

class Suma(Operacion):

Indicamos entre paréntesis el nombre de la clase padre (con esto estamos indicando que todos los métodos y atributos de la clase Operación son también métodos de la clase Suma.
Luego la característica que añade la clase Suma es el siguiente método:

def operar(self):
self.resultado=self.valor1+self.valor2

El método operar puede acceder a los atributos heredados.
Ahora podemos decir que la clase Suma tiene cuatro métodos (tres heredados y uno propio) y 3 atributos
Si creamos un objeto de la clase Suma tenemos:

s=Suma()
s.cargar1(10)
s.cargar2(20)
s.operar()
print 'La suma es:'
s.imprimir()

Podemos llamar tanto al método propio de la clase Suma "operar()" como a los métodos heredados. Quien utilice la clase Suma solo debe conocer que métodos tiene (independientemente que pertenezcan a la clase Suma o a una clase superior)
La lógica es similar para declarar la clase Resta:

class Resta(Operacion):
def operar(self):
self.resultado=self.valor1-self.valor2

y la definición de un objeto de dicha clase:

r=Resta()
r.cargar1(10)
r.cargar2(2)
r.operar()
print 'La resta es:'
r.imprimir()

La clase Operación agrupa en este caso un conjunto de atributos y métodos comunes a un conjunto de subclases (Suma, Resta). No tiene sentido definir objetos de la clase Operacion.
El planteo de jerarquías de clases es una tarea compleja que requiere un perfecto entendimiento de todas las clases que intervienen en un problema, cuales son sus atributos y responsabilidades.
Método especial __str__

Podemos hacer que se ejecute un método definido por nosotros cuando pasamos un objeto a la función print o cuando llamamos a la función str.
Que sucede cuando llamamos a la función print y le pasamos como parámetro un objeto?

class Persona:
    def __init__(self,nom,ape):
        self.nombre=nom
        self.apellido=ape

per=Persona('Jose','Rodriguez')
print per

Nos muestra algo parecido a esto:

<__main__.Persona instance at 0xf9e0a60ec5872050>

Python nos permite redefinir el método que se debe ejecutar. Esto se hace definiendo en la clase el método especial __str__
En el ejemplo anterior si queremos que se muestre el nombre y apellido separados por coma cuando llamemos a la función print el código que debemos implementar es el siguiente:

class Persona:
    def __init__(self,nom,ape):
        self.nombre=nom
        self.apellido=ape
    def __str__(self):
        cadena=self.nombre+','+self.apellido
        return cadena

per=Persona('Jose','Rodriguez')
print per

Como vemos debemos implementar el método __str__ y retornar un string, este luego será el que imprime la función print:

def __str__(self):
cadena=self.nombre+','+self.apellido
return cadena

Esta característica definida en Python nos permite crear programas muy legibles y flexibles.
El método __str__ también se ejecuta si llamamos a la función str y pasamos como parámetro un objeto que tiene definido dicho método:

class Persona:
    def __init__(self,nom,ape):
        self.nombre=nom
        self.apellido=ape
    def __str__(self):
        cadena=self.nombre+','+self.apellido
        return cadena

per1=Persona('Jose','Rodriguez')
per2=Persona('Ana','Martinez')
print str(per1)+'-'+str(per2) # Jose,Rodriguez-Ana,Martinez

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales

Python es un lenguaje de script desarrollado por Guido van Rossum.

Podemos codificar empleando programación lineal, estructurada y orientada a objetos (tengamos en cuenta que esta última es la que se ha impuesto en la actualidad)

Se cuenta con intérpretes de Python en múltiples plataformas: Windows, Linux, Mac etc. Se pueden desarrollar aplicaciones de escritorio como aplicaciones web. Empresas como Google, Yahoo, Nasa etc. utilizan este lenguaje para sus desarrollos (actualmente el creador de Python Guido van Rossum trabaja para Google.)

Se puede ejecutar instrucciones de Python desde la línea de comando o creando archivos con extensión *.py. Cuando uno comienza a aprender este lenguaje la línea de comandos nos provee una retroalimentación del resultado en forma inmediata.

El objetivo de este tutorial es presentar en forma progresiva los conceptos fundamentales de este lenguaje y poder analizar los problemas resueltos y codificar los problemas propuestos en este mismo sitio, sin tener que instalar en un principio el Python en su equipo (o luego de instalado poder avanzar con el tutorial en cualquier máquina conectada a internet).

Métodos de una clase.

Los métodos son como las funciones en los lenguajes estructurados, pero están definidos dentro de una clase y operan sobre los atributos de dicha clase.
Los métodos también son llamados las responsabilidades de la clase. Para encontrar las responsabilidades de una clase hay que preguntarse qué puede hacer la clase.
El objetivo de un método es ejecutar las actividades que tiene encomendada la clase a la cual pertenece.
Los atributos de un objeto se modifican mediante llamadas a sus métodos.
Confeccionaremos un nuevo problema para concentrarnos en la definición y llamada a métodos.
Problema:Confeccionar una clase CabeceraPagina que permita mostrar un título, indicarle si queremos que aparezca centrado, a derecha o izquierda.
Definiremos dos atributos, uno donde almacenar el título y otro donde almacenar la ubicación.
Ahora pensemos que métodos o responsabilidades debe tener esta clase para poder mostrar la cabecera de la página. Seguramente deberá tener un método que pueda inicializar los atributos y otro método que muestre la cabecera dentro de la página.
Veamos el código de la clase CabeceraPagina

class CabeceraPagina:
    def inicializar(self,tit,ubi):
      self.titulo=tit
      self.ubicacion=ubi

    def graficar(self):
        print '<div style="font-size:40px;text-align:'+self.ubicacion+'">'
        print self.titulo
        print '</div>'

cabecera=CabeceraPagina()
cabecera.inicializar('El blog del programador','center')
cabecera.graficar()

La clase CabeceraPagina tiene dos atributos donde almacenamos el texto que debe mostrar y la ubicación del mismo ('center', 'left' o 'right'), nos valemos de CSS para ubicar el texto en la página.
No es obligatorio en Python definir previo a los métodos todos los atributos. Como vemos se definen e inicializan al llamar al método inicializar.
Ahora analicemos lo que más nos importa en el concepto que estamos concentrados (métodos de una clase):

def inicializar(self,tit,ubi):
self.titulo=tit
self.ubicacion=ubi

Un método tiene un nombre, conviene utilizar verbos para la definición de métodos (mostrar, inicializar, graficar etc.) y sustantivos para la definición de atributos (color, enlace, titulo etc.)

Un método debe tener como primer parámetro el identificador self, el mismo nos permite acceder a los atributos de la clase, además puede tener otros parámetros que inicializan atributos del objeto:

self.titulo=tit
self.ubicacion=ubi

Luego para llamar a los métodos debemos crear un objeto de dicha clase:

cabecera=CabeceraPagina()
cabecera.inicializar('El blog del programador','center')
cabecera.graficar()

Es importante notar que siempre que llamamos a un método le antecedemos el nombre del objeto. El orden de llamada a los métodos es importante, no va a funcionar si primero llamamos a graficar y luego llamamos al método inicializar.

Método constructor de una clase.

El constructor es un método especial de una clase. El objetivo fundamental del constructor es inicializar los atributos del objeto que creamos.
Básicamente el constructor remplaza al método inicializar que habíamos hecho en el concepto anterior.
Las ventajas de implementar un constructor en lugar del método inicializar son:

El constructor es el primer método que se ejecuta cuando se crea un objeto.
El constructor se llama automáticamente. Es decir es imposible de olvidarse de llamarlo ya que se llamará automáticamente.
Quien utiliza POO (Programación Orientada a Objetos) conoce el objetivo de este método.

Otras características de los constructores son:

El constructor se ejecuta inmediatamente luego de crear un objeto y no puede ser llamado nuevamente.
Un constructor no puede retornar dato.
Un constructor puede recibir parámetros que se utilizan normalmente para inicializar atributos.
El constructor es un método opcional, de todos modos es muy común definirlo.

Veamos la sintaxis del constructor:

def __init__([parámetros]):
[algoritmo]

Debemos definir un método llamado __init__ (es decir utilizamos dos caracteres de subrayado, la palabra init y seguidamente otros dos caracteres de subrayado).
Confeccionaremos el mismo problema del concepto anterior para ver el cambio que debemos hacer de ahora en más.
Problema:Confeccionar una clase CabeceraPagina que permita mostrar un título, indicarle si queremos que aparezca centrado, a derecha o izquierda.

class CabeceraPagina:
    def __init__(self,tit,ubi):
        self.titulo=tit
        self.ubicacion=ubi

    def graficar(self):
        print '<div style="font-size:40px;text-align:'+self.ubicacion+'">'
        print self.titulo
        print '</div>'

cabecera=CabeceraPagina('El blog del programador','center')
cabecera.graficar()

Ahora podemos ver como cambió la sintaxis para la definición del constructor:

def __init__(self,tit,ubi):
self.titulo=tit
self.ubicacion=ubi

Veamos como se modifica la llamada al constructor cuando se crea un objeto:

cabecera=CabeceraPagina('El blog del programador','center')
cabecera.graficar()

Es decir el constructor se llama en la misma línea donde creamos el objeto, por eso disponemos después del nombre de la clase los parámetros:

cabecera=CabeceraPagina('El blog del programador','center')

Generalmente todo aquello que es de vital importancia para el funcionamiento inicial del objeto se lo pasamos mediante el constructor.

Llamada de métodos dentro de la clase.
Hasta ahora todos los problemas planteados hemos llamado a los métodos desde donde definimos un objeto de dicha clase, por ejemplo:

cabecera=CabeceraPagina('El blog del programador','center')
cabecera.graficar()

Utilizamos la sintaxis:

[nombre del objeto].[nombre del método]

Es decir antecedemos al nombre del método el nombre del objeto y el operador punto
Ahora bien que pasa si queremos llamar dentro de la clase a otro método que pertenece a la misma clase, la sintaxis es la siguiente:

self.[nombre del método]

Es importante tener en cuenta que esto solo se puede hacer cuando estamos dentro de la misma clase.
Confeccionaremos un problema que haga llamadas entre métodos de la misma clase.
Problema:Confeccionar una clase Tabla que permita indicarle en el constructor la cantidad de filas y columnas. Definir otra responsabilidad que podamos cargar un dato en una determinada fila y columna. Finalmente debe mostrar los datos en una tabla HTML.

class Tabla:
    mat=[]
    cantfilas=0
    cantcolumnas=0

    def __init__(self,fi,co):
        self.cantfilas=fi
        self.cantcolumnas=co
        for f in range(0,fi):
            self.mat.append([])
            for c in range(0,co):
                self.mat[f].append('')

    def cargar(self,fi,col,valor):
        self.mat[fi][col]=valor

    def iniciotabla(self):
        print '<table border="1">'

    def iniciofila(self):
        print '<tr>'

    def mostrar(self,fi,co):
        print '<td>'
        print self.mat[fi][co]
        print '</td>'

    def finfila(self):
        print '</tr>'

    def fintabla(self):
        print '</table>'

    def graficar(self):
        self.iniciotabla()
        for f in range(0,self.cantfilas):
            self.iniciofila()
            for c in range(0,self.cantcolumnas):
                self.mostrar(f,c)
            self.finfila()
        self.fintabla()

tabla1=Tabla(3,4)
tabla1.cargar(0,0,1)
tabla1.cargar(0,1,2)
tabla1.cargar(0,2,3)
tabla1.cargar(0,3,4)
tabla1.cargar(1,0,5)
tabla1.cargar(1,1,6)
tabla1.cargar(1,2,7)
tabla1.cargar(1,3,8)
tabla1.cargar(2,0,9)
tabla1.cargar(2,1,10)
tabla1.cargar(2,2,11)
tabla1.cargar(2,3,12)
tabla1.graficar()

Vamos por parte, primero veamos los tres atributos definidos,el primero se trata de una lista donde almacenaremos todos los valores que contendrá la tabla HTML y otros dos atributos que indican la dimensión de la tabla HTML (cantidad de filas y columnas):

mat=[]
cantfilas=0
cantcolumnas=0

El constructor recibe como parámetros la cantidad de filas y columnas que tendrá la tabla, además creamos la lista con tantas filas como indica el parámetro fi e insertamos una lista en cada componente (es decir que cada componente de la lista es una lista que representa los elementos de la fila respectiva) Dentro de un for interno agregamos string vacíos a cada elemento de la lista interna:

self.cantfilas=fi
      self.cantcolumnas=co
      for f in range(0,fi):
          self.mat.append([])
          for c in range(0,co):
              self.mat[f].append('')

Otro método de vital importancia es el de cargar datos. Llegan como parámetro la fila, columna y dato a almacenar:

def cargar(self,fi,col,valor):
self.mat[fi][col]=valor

Otro método muy importante es el graficar:

def graficar(self):
        self.iniciotabla()
        for f in range(0,self.cantfilas):
            self.iniciofila()
            for c in range(0,self.cantcolumnas):
                self.mostrar(f,c)
            self.finfila()
        self.fintabla()

El método graficar debe hacer las salidas de datos dentro de una tabla HTML. Para simplificar el algoritmo definimos otros cinco métodos que tienen por objetivo hacer la generación del código HTML propiamente dicho. Así tenemos el método iniciotabla que hace la salida de la marca table e inicialización del atributo border:

def iniciotabla(self):
print '<table border="1">'

De forma similar los otros métodos son:

def iniciofila(self):
        print '<tr>'

    def mostrar(self,fi,co):
        print '<td>'
        print self.mat[fi][co]
        print '</td>'

    def finfila(self):
        print '</tr>'

    def fintabla(self):
        print '</table>'

Si bien podíamos hacer todo esto en el método graficar y no hacer estos cinco métodos, la simplicidad del código aumenta a medida que subdividimos los algoritmos. Esto es de fundamental importancia con algoritmos más complejos./p>
Lo que nos importa ahora ver es como llamamos a métodos que pertenecen a la misma clase:

def graficar(self):
        self.iniciotabla()
        for f in range(0,self.cantfilas):
            self.iniciofila()
            for c in range(0,self.cantcolumnas):
                 self.mostrar(f,c)
            self.finfila()
        self.fintabla()

Es decir le antecedemos la palabra self al nombre del método a llamar. De forma similar a como accedemos a los atributos de la clase.
Por último debemos definir un objeto de la clase Tabla y llamar a los métodos respectivos:

tabla1=Tabla(3,4)
tabla1.cargar(0,0,1)
tabla1.cargar(0,1,2)
tabla1.cargar(0,2,3)
tabla1.cargar(0,3,4)
tabla1.cargar(1,0,5)
tabla1.cargar(1,1,6)
tabla1.cargar(1,2,7)
tabla1.cargar(1,3,8)
tabla1.cargar(2,0,9)
tabla1.cargar(2,1,10)
tabla1.cargar(2,2,11)
tabla1.cargar(2,3,12)
tabla1.graficar()

Es importante notar que donde definimos un objeto de la clase Tabla no llamamos a los métodos iniciotabla(), iniciofila(), etc.

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales

Python es un lenguaje de script desarrollado por Guido van Rossum.

Podemos codificar empleando programación lineal, estructurada y orientada a objetos (tengamos en cuenta que esta última es la que se ha impuesto en la actualidad)

Se cuenta con intérpretes de Python en múltiples plataformas: Windows, Linux, Mac etc. Se pueden desarrollar aplicaciones de escritorio como aplicaciones web. Empresas como Google, Yahoo, Nasa etc. utilizan este lenguaje para sus desarrollos (actualmente el creador de Python Guido van Rossum trabaja para Google.)

Se puede ejecutar instrucciones de Python desde la línea de comando o creando archivos con extensión *.py. Cuando uno comienza a aprender este lenguaje la línea de comandos nos provee una retroalimentación del resultado en forma inmediata.

El objetivo de este tutorial es presentar en forma progresiva los conceptos fundamentales de este lenguaje y poder analizar los problemas resueltos y codificar los problemas propuestos en este mismo sitio, sin tener que instalar en un principio el Python en su equipo (o luego de instalado poder avanzar con el tutorial en cualquier máquina conectada a internet).

Conceptos de programación orientada a objetos.

Habíamos dicho que Python nos permite combinar las metodologías de programación Lineal, Estructurada y Orientada a Objetos. A partir de este concepto mostraremos en forma sencilla la metodología de Programación Orientada a Objetos.
Se irán introduciendo conceptos de objeto, clase, atributo, método etc. y de todos estos temas se irán planteando problemas resueltos.
Prácticamente todos los lenguajes desarrollados en los últimos 15 años implementan la posibilidad de trabajar con POO (Programación Orientada a Objetos)
El lenguaje Python tiene la característica de permitir programar con las siguientes metodologías:

Programación Lineal: Es cuando desarrollamos todo el código sin emplear funciones.
Programación Estructurada: Es cuando planteamos funciones que agrupan actividades a desarrollar y luego dentro del programa llamamos a dichas funciones que pueden estar dentro del mismo archivo o en una librería separada.
Programación Orientada a Objetos: Es cuando planteamos clases y definimos objetos de las mismas (Este es el objetivo de los próximos conceptos, aprender la metodología de programación orientada a objetos y la sintaxis particular de Python para la POO)

Conceptos básicos de Objetos.

Un objeto es una entidad independiente con sus propios datos y programación. Las ventanas, menúes, carpetas de archivos pueden ser identificados como objetos; el motor de un auto también es considerado un objeto, en este caso, sus datos (atributos) describen sus características físicas y su programación (métodos) describen el funcionamiento interno y su interrelación con otras partes del automóvil (también objetos).
El concepto renovador de la tecnología Orientación a Objetos es la suma de funciones a elementos de datos, a esta unión se le llama encapsulamiento. Por ejemplo, un objeto página contiene las dimensiones físicas de la página (ancho, alto), el color, el estilo del borde, etc, llamados atributos. Encapsulados con estos datos se encuentran los métodos para modificar el tamaño de la página, cambiar el color, mostrar texto, etc. La responsabilidad de un objeto pagina consiste en realizar las acciones apropiadas y mantener actualizados sus datos internos. Cuando otra parte del programa (otros objetos) necesitan que la pagina realice alguna de estas tareas (por ejemplo, cambiar de color) le envía un mensaje. A estos objetos que envían mensajes no les interesa la manera en que el objeto página lleva a cabo sus tareas ni las estructuras de datos que maneja, por ello, están ocultos. Entonces, un objeto contiene información pública, lo que necesitan los otros objetos para interactuar con él e información privada, interna, lo que necesita el objeto para operar y que es irrelevante para los otros objetos de la aplicación.

Declaración de una clase y creación de objetos.
La programación orientada a objetos se basa en la programación de clases; a diferencia de la programación estructurada, que está centrada en las funciones.
Una clase es un molde del que luego se pueden crear múltiples objetos, con similares características.
Un poco más abajo se define una clase Persona y luego se crean dos objetos de dicha clase.
Una clase es una plantilla (molde), que define atributos (lo que conocemos como variables) y métodos (lo que conocemos como funciones).
La clase define los atributos y métodos comunes a los objetos de ese tipo, pero luego, cada objeto tendrá sus propios valores y compartirán las mismas funciones.
Debemos crear una clase antes de poder crear objetos (instancias) de esa clase. Al crear un objeto de una clase, se dice que se crea una instancia de la clase o un objeto propiamente dicho.
Confeccionaremos nuestra primer clase para conocer la sintaxis en el lenguaje Python, luego definiremos dos objetos de dicha clase.
Implementaremos una clase llamada Persona que tendrá como atributo (variable) su nombre y dos métodos (funciones), uno de dichos métodos inicializará el atributo nombre y el siguiente método mostrará en la página el contenido del mismo.

class Persona:
    def inicializar(self,nom):
        self.nombre=nom

    def imprimir(self):
        print 'Nombre:'
        print self.nombre
        print '<br>'

persona1=Persona()
persona1.inicializar('Juan')
persona1.imprimir()

persona2=Persona()
persona2.inicializar('Ana')
persona2.imprimir()

Siempre conviene buscar un nombre de clase lo más próximo a lo que representa. La palabra clave para declarar la clase es class, seguidamente el nombre de la clase y luego dos puntos.
Los métodos de una clase se definen utilizando la misma sintaxis que para la definición de funciones.
Como veremos todo método tiene como primer parámetro el identificador self que tiene la referencia del objeto que llamó al método.
Luego dentro del método diferenciamos los atributos del objeto antecediendo el identificador self:

self.nombre=nom

Con la asignación previa almacenamos en el atributo nombre el parámetro nom, los atributos siguen existiendo cuando finaliza la ejecución del método. Por ello cuando se ejecuta el método imprimir podemos mostrar el nombre que cargamos en el primer método.
Decíamos que una clase es un molde que nos permite definir objetos. Ahora veamos cual es la sintaxis para la definición de objetos de la clase Persona:

persona1=Persona()
persona1.inicializar('Juan')
persona1.imprimir()

Definimos un objeto llamado persona1 y lo creamos asignándole el nombre de la clase.
Luego para llamar a los métodos debemos anteceder el nombre del objeto el operador . y por último el nombre del método.
En el caso que tenga parámetros se los enviamos (salvo el primer parámetro (self) que el mismo Python se encarga de enviar la referencia del objeto que se creó):

persona1.inicializar('Juan')

También podemos definir tantos objetos de la clase Persona como sean necesarios para nuestro algoritmo:

persona2=Persona()
persona2.inicializar('Ana')
persona2.imprimir()

Esto nos da una idea que si en una página WEB tenemos 2 menúes, seguramente definiremos una clase Menu y luego crearemos dos objetos de dicha clase.
Esto es una de las ventajas fundamentales de la Programación Orientada a Objetos (POO), es decir reutilización de código (gracias a que está encapsulada en clases) es muy sencilla.
Atributos de una clase.
Ahora trataremos de concentrarnos en los atributos de una clase. Los atributos son las características, cualidades, propiedades distintivas de cada clase. Contienen información sobre el objeto. Determinan la apariencia, estado y demás particularidades de la clase. Varios objetos de una misma clase tendrán los mismos atributos pero con valores diferentes.
Cuando creamos un objeto de una clase determinada, los atributos declarados por la clase son localizadas en memoria y pueden ser modificados mediante los métodos.
Plantearemos un nuevo problema para analizar detenidamente la definición, sintaxis y acceso a los atributos.
Problema: Implementar una clase que muestre una lista de hipervínculos en forma horizontal (básicamente un menú de opciones)
Lo primero que debemos pensar es que valores almacenará la clase, en este caso debemos cargar una lista de direcciones web y los títulos de los enlaces. Podemos definir dos listas paralelas que almacenen las direcciones y los títulos respectivamente.
Definiremos dos métodos: cargaropcion y mostrar.

class Menu:
    enlaces=[]
    titulos=[]
    def cargaropcion(self,en,tit):
        self.enlaces.append(en)
        self.titulos.append(tit)

    def mostrar(self):
        for indice in range(0,len(self.enlaces)):
            print '<a href="'+self.enlaces[indice]+'">'+self.titulos[indice]+'</a>'

menu1=Menu()
menu1.cargaropcion('http://www.google.com.ar','Google')
menu1.cargaropcion('http://www.yahoo.com.ar','Yahoo')
menu1.cargaropcion('http://www.live.com.ar','Msn')
menu1.mostrar()

En este caso los atributos son de tipo listas y estamos obligados a definirlos dentro de la clase y previo a la declaración de los métodos:

enlaces=[]
titulos=[]

Estamos definiendo dos listas vacías.
El método cargaropcion recibe el enlace y el título y los almacena al final de cada lista empleando el método append de la lista (tengamos en cuenta que Python administra las listas como objetos)

self.enlaces.append(en)
self.titulos.append(tit)

El método que imprime todos los enlaces utiliza un for para recorrer las listas y acceder a cada elemento de las listas y mostrarlos dentro de la página:

for indice in range(0,len(self.enlaces)):
print '<a href="'+self.enlaces[indice]+'">'+self.titulos[indice]+'</a>'

Luego creamos un objeto de la clase Menu y llamamos tantas veces al método cargaropcion como opciones tenga nuestro menú

menu1=Menu()
menu1.cargaropcion('http://www.google.com.ar','Google')
menu1.cargaropcion('http://www.yahoo.com.ar','Yahoo')
menu1.cargaropcion('http://www.live.com.ar','Msn')

Finalmente llamamos al método mostrar que imprime cada hipervínculo en la página:

menu1.mostrar()

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales

Python es un lenguaje de script desarrollado por Guido van Rossum.

Podemos codificar empleando programación lineal, estructurada y orientada a objetos (tengamos en cuenta que esta última es la que se ha impuesto en la actualidad)

Se cuenta con intérpretes de Python en múltiples plataformas: Windows, Linux, Mac etc. Se pueden desarrollar aplicaciones de escritorio como aplicaciones web. Empresas como Google, Yahoo, Nasa etc. utilizan este lenguaje para sus desarrollos (actualmente el creador de Python Guido van Rossum trabaja para Google.)

Se puede ejecutar instrucciones de Python desde la línea de comando o creando archivos con extensión *.py. Cuando uno comienza a aprender este lenguaje la línea de comandos nos provee una retroalimentación del resultado en forma inmediata.

El objetivo de este tutorial es presentar en forma progresiva los conceptos fundamentales de este lenguaje y poder analizar los problemas resueltos y codificar los problemas propuestos en este mismo sitio, sin tener que instalar en un principio el Python en su equipo (o luego de instalado poder avanzar con el tutorial en cualquier máquina conectada a internet).

Asignaciones múltiples.
Python permite asignaciones múltiples:

x1,x2,x3=1,2,3
print x1 # 1
print x2 # 2
print x3 # 3

Para entenderlo mejor podemos también utilizar esta sintaxis:

x1,x2,x3=(1,2,3)
print x1 # 1
print x2 # 2
print x3 # 3

Es decir lo que estamos haciendo inicializar cada una de las variables de la izquierda con las componentes homólogas (de la misma posición) de la tupla.
Esta característica es útil si tenemos que recuperar por ejemplo de una lista que contiene tuplas de dos elementos que representan puntos en el plano (x,y):

puntos=[(10,2),(4,2),(9,3)]
for x,y in puntos:
print 'Coordenada x:%d y:%d' % (x,y)
print '<br>'

Cada vuelta del for se almacena en x e y los valores de la tupla a procesar.
Otra aplicación muy útil es si queremos intercambiar el valor de dos variables la forma más simple es:

x=10
y=20
print x # 10
print y # 20
x,y = y,x
print x # 20
print y # 10

En una asignación pueden intervenir valores de distinto tipo (enteros, reales, string etc.):

nombre,edad,sueldo=('juan',32,1500.30)
print 'Nombre:%s Edad:%d Sueldo%10.2f' % (nombre,edad,sueldo)
# Nombre:juan Edad:32 Sueldo 1500.30

Podemos con esto hacer que una función retorne más de un dato (por lo menos en apariencia), esto lo logramos retornando una tupla:

def sumadiferencia(x1,x2):
    suma=x1+x2
    diferencia=x1-x2
    return (suma,diferencia)

su,di=sumadiferencia(10,4)
print su # 14
print di # 6

Como vemos llamamos a una función y le asignamos el valor devuelto a dos variables.
Si queremos inicializar tres variables con el mismo valor la sintaxis que podemos utilizar es:

x1=x2=x3=10
print x1 # 10
print x2 # 10
print x3 # 10

Funciones con parámetros por defecto.

Como habíamos visto una función es una estructura de programación que agrupa un conjunto de instrucciones y resuelve un problema particular. Una función puede tener parámetros, los mismos almacenan los valores que se le pasan cuando la llamamos.
En algunos casos si queremos que la función sea mas flexible podemos definir parámetros con valores por defecto. Esto nos permite llamar a la función pudiendo o no pasar datos a dichos parámetros.
Veamos con un ejemplo este concepto, vamos a desarrollar una función que reciba un dato a imprimir, con la posibilidad de indicarle el color de fuente y el color de fondo, en caso de no indicarle dichos valores la función muestra el dato con color negro y fondo blanco.

def mostrartitulo(dato,colorletra='#000',colorfondo='#fff'):
print '<h1 style="color:'+colorletra+';background-color:'+colorfondo+'">'+dato+'</h1>'

mostrartitulo('Primer titulo')
mostrartitulo('Segundo titulo','#f00')
mostrartitulo('Tercer titulo','#f00','#000')

Como podemos ver para indicar a Python que un parámetro es por defecto debemos utilizar el operador de asignación en la declaración de la cabecera de la función junto al valor que tomará dicho parámetro en caso de no pasarlo desde donde la llamamos:

def mostrartitulo(dato,colorletra='#000',colorfondo='#fff'):

Cuando llamamos la función mostrartitulo podemos hacerlo de diferentes maneras:

mostrartitulo('Primer titulo')
mostrartitulo('Segundo titulo','#f00')
mostrartitulo('Tercer titulo','#f00','#000')

La primer llamada es pasando un único dato, es decir solo el título que debe mostrar, en este caso el segundo y tercer parámetro toman como valor el indicado en el declaración:

colorletra='#000',colorfondo='#fff'

Podemos llamar a la función mostrartitulo pasando el primer parámetro y el segundo, lo que hace que el tercer parámetro se inicialice con el indicado en la declaración de la función:

mostrartitulo('Segundo titulo','#f00')

En el ejemplo la tercer llamada a la función se hace pasando tres parámetros:

mostrartitulo('Tercer titulo','#f00','#000')

Como podemos ver los parámetros por defecto nos permiten implementar funciones más generales, con esto podemos hacer que las funciones sean útiles para mayor cantidad de situaciones.
Que pasa si queremos llamar la función indicando el primer y último parámetro, esto solo se puede hacer si al llamar la función indicamos que dato se le pasa a cada parámetro:

Si bien se hace más engorroso la llamada a la función al tener que indicar el nombre de cada parámetro junto al valor, nos trae como beneficio que sea aún más flexible.
Funciones con una cantidad variable de parámetros.

python Funciones con parámetros por defecto1

Otra posibilidad en la declaración de una función en Python es la definición de una cantidad variable de parámetros.
Para definir una cantidad variante de parámetros debemos antecederle el caracter asterísco (*) al último parámetro de la función.
Supongamos que necesitemos implementar una función que le enviemos una serie de enteros y nos retorne la suma de todos ellos (como mínimo le enviamos 2 y no hay un máximo de valores):

def sumar(x1,x2,*xn):
    s=x1+x2
    for valor in xn:
        s=s+valor
    return s

print sumar(1,2)
print '<br>'
print sumar(1,2,3,4)
print '<br>'
print sumar(1,2,3,4,5,6,7,8,9,10)

Lo que en realidad el lenguaje Python hace es una tupla con todos los valores de los parámetros a partir del tercero.
Luego nuestro algoritmo debe recorrer la tupla para procesar los elementos propiamente dichos, en nuestro caso con un for in y los sumamos junto al primer y segundo parámetro.
Luego cuando hacemos la llamada a la función:

print sumar(1,2)

Si pasamos solo dos parámetros la tupla se inicializa vacía, por lo que el for in no ejecuta el bloque contenido.
Si llamamos la función con 10 parámetros:

print sumar(1,2,3,4,5,6,7,8,9,10)

Luego la tupla se crea con 7 elementos.

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales

Python es un lenguaje de script desarrollado por Guido van Rossum.
Podemos codificar empleando programación lineal, estructurada y orientada a objetos (tengamos en cuenta que esta última es la que se ha impuesto en la actualidad)
Se cuenta con intérpretes de Python en múltiples plataformas: Windows, Linux, Mac etc. Se pueden desarrollar aplicaciones de escritorio como aplicaciones web. Empresas como Google, Yahoo, Nasa etc. utilizan este lenguaje para sus desarrollos (actualmente el creador de Python Guido van Rossum trabaja para Google.)
Se puede ejecutar instrucciones de Python desde la línea de comando o creando archivos con extensión *.py. Cuando uno comienza a aprender este lenguaje la línea de comandos nos provee una retroalimentación del resultado en forma inmediata.
El objetivo de este tutorial es presentar en forma progresiva los conceptos fundamentales de este lenguaje y poder analizar los problemas resueltos y codificar los problemas propuestos en este mismo sitio, sin tener que instalar en un principio el Python en su equipo (o luego de instalado poder avanzar con el tutorial en cualquier máquina conectada a internet).
Indices negativos en tuplas, listas y string.

python Indices negativos en tuplas, listas y string

Hemos visto que en Python accedemos a los elementos de una lista, tupla y string mediante un subíndice que comienza a numerarse a partir de cero:

tupla=(2,4,6,8,10)
print tupla[0]   # 2
lista=[2,4,6,8,10]
print lista[0]   # 2
cadena='hola'
print cadena[0]   # h

Si queremos acceder a la última componente podemos hacerlo:

tupla=(2,4,6,8,10)
print tupla[len(tupla)-1] # 10

Pero Pyton tiene integrado en el lenguaje el acceso de los elementos de la secuencia mediante índices negativos, por ejemplo si queremos acceder a la última componente luego podemos hacerlo con la siguiente sintaxis:

tupla=(2,4,6,8,10)
print tupla[-1]   # 10
lista=[2,4,6,8,10]
print lista[-1]   # 10
cadena='hola'
print cadena[-1]   # a

Es mucho más cómodo utilizar esta segunda forma para acceder a los elementos de una lista, tupla o cadena de caracteres.
Si queremos imprimir los elementos de una tupla en forma inversa (es decir desde el último elemento hasta el primero) podemos hacerlo con el siguiente algoritmo:

tupla=(2,4,6,8,10)
indice=-1
for x in range(0,len(tupla)):
print tupla[indice] # 10 8 6 4 2
indice=indice-1

Estructura de datos tipo diccionario.

Las estructuras de datos vistas hasta ahora (tuplas y listas) utilizan un entero como subíndice. La estructura de datos tipo diccionario utiliza una clave para acceder a un valor. El subíndice puede ser un entero, un string etc.
Un diccionario vincula una clave y un valor.
Si queremos almacenar la cantidad de productos que tenemos en stock podemos implementar un diccionario donde utilizamos como clave el nombre del producto y como valor la cantidad de productos disponibles.
Podemos definir un diccionario con la siguiente sintaxis:
productos={'manzanas':23,'peras':50,'papas':120}
Luego si queremos acceder a la cantidad de productos en stock utilizamos como subíndice el nombre del producto:

print productos['manzanas']

La línea anterior produce como resultado el valor 23.
Mediante un diccionario asociamos para toda clave un valor.
Podemos borrar cualquier entrada dentro del diccionario empleando la siguiente sintaxis:

del(productos['manzana'])

Luego si imprimimos el diccionario en forma completa tenemos como resultado que ya no contiene la entrada 'manzana':

print propductos

{'peras': 50, 'papas': 120}

Podemos modificar el valor asociado a una clave mediante una simple asignación:

productos['papas']=5

Luego si imprimimos el diccionario obtenemos como resultado:

{'peras': 50, 'papas': 5}

Podemos conocer en cualquier momento la cantidad de pares clave-valor que contiene nuestro diccionario mediante la función len:

print len(productos)

Con nuestro problema tenemos como resultado que nuestro diccionario tiene 2 elementos.
Formato de cadenas de caracteres (string).

python Formato de cadenas de caracteres (string)

Cuando tenemos que combinar cadenas de caracteres e incorporarle valores almacenados en otras variables el lenguaje Python nos suministra una técnica para incrustar valores dentro de la cadena.
Veamos mediante ejemplos cual es la sintaxis para plantear estos formatos de cadenas:

x1=10
x2=5
x3=20
print 'El contenido de la primer variable es %d, de la segunda %d y la tercera %d' % (x1,x2,x3)

Si bien podemos utilizar el operador + para ir concatenando cadenas y variables esta técnica hace que nuestro programa sea más legible sobre todo cuando tenemos que sustituir varias variables dentro de una cadena.
Primero indicamos entre comillas la cadena y utilizamos el símbolo % para indicar el lugar donde se sustituirá el valor, debemos indicar luego del caracter % el tipo de dato (en nuestro ejemplo un valor decimal (d))
Luego de la cadena debemos indicar una tupla con los valores o variables de donde se obtendrán los datos. Entre la cadena de formato y la tupla debemos disponer el caracter % (aquí el caracter porcentaje tiene un objetivo distinto que dentro de la cadena de formato)
Se especifican distintos caracteres para cada tipo de dato a sustituir:

x=10
g=10.2
cadena='juan'
print 'El valor entero %d el valor real %f y la cadena %s' % (x,g,cadena)

En el ejemplo propuesto vemos que podemos utilizar los caracteres de formato d (decimal), f (float) y s (string).
Es importante el orden de los valores de la tupla ya que el lenguaje procesa los datos en forma secuencia, es decir cada vez que debe sustituir un valor en la cadena extrae de la tupla el siguiente valor.
Cuando damos formato a una variable real (con coma) podemos disponer dos valores previos al caracter f:

g=20.5498
print 'El valor real es %10.2f' % (g)

El primer valor indica el largo total a reservar y el segundo la cantidad de decimales.
Podemos convertir el valor decimal a tipo octal o hexadecimal:

x=255
print 'Decimal %d en hexadecimal es %x y en octal %o' % (x,x,x)
#Decimal 255 en hexadecimal es ff y en octal 377

No es obligatorio que el formato de cadena se utilice siempre en un print, podemos almacenar el resultado del formato en otra variable string (que podemos eventualmente almacenarla en una base de datos por ejemplo).

vx=10
vy=90
resultado='(%d,%d)' % (vx,vy)
print resultado # (10,90)

También podemos indicar un valor entero en el formato para los tipos de datos enteros y string:

x1=100
x2=1500
x3=5
print '<pre>'
print '%5d' % (x1)
print '%5d' % (x2)
print '%5d' % (x3)
print '</pre>'

El resultado por pantalla es:

100
1500
5

Es decir reserva en este caso 5 espacios para el entero y hace la alineación a derecha.
Si indicamos un valor negativo los datos se alínean a izquierda:

animales=['perro','elefante','pez']
print '<pre>'
for elemento in animales:
print '%20s' % elemento
for elemento in animales:
print '%-20s' % elemento
print '</pre>'

El resultado de ejecutar el programa es:

perro
elefante
pez
perro
elefante
pez

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales

Python es un lenguaje de script desarrollado por Guido van Rossum.
Podemos codificar empleando programación lineal, estructurada y orientada a objetos (tengamos en cuenta que esta última es la que se ha impuesto en la actualidad)
Se cuenta con intérpretes de Python en múltiples plataformas: Windows, Linux, Mac etc. Se pueden desarrollar aplicaciones de escritorio como aplicaciones web. Empresas como Google, Yahoo, Nasa etc. utilizan este lenguaje para sus desarrollos (actualmente el creador de Python Guido van Rossum trabaja para Google.)
Se puede ejecutar instrucciones de Python desde la línea de comando o creando archivos con extensión *.py. Cuando uno comienza a aprender este lenguaje la línea de comandos nos provee una retroalimentación del resultado en forma inmediata.
El objetivo de este tutorial es presentar en forma progresiva los conceptos fundamentales de este lenguaje y poder analizar los problemas resueltos y codificar los problemas propuestos en este mismo sitio, sin tener que instalar en un principio el Python en su equipo (o luego de instalado poder avanzar con el tutorial en cualquier máquina conectada a internet).
Porciones de tuplas.

El lenguaje Python nos permite rescatar una "porción" de una tupla, es decir un trozo de la misma.
Si tenemos la siguiente tupla:

tupla1=(1,7,20,40,51,3)

tupla2=tupla1[0:4]
print tupla2

El resultado es una tupla con cuatro valores:

(1,7,20,40)

Es decir indicamos como subíndice un rango de valores, en este caso desde la posición 0 hasta la posición 4 sin incluirla.
Podemos no indicar alguno de los dos rangos:

tupla1=(1,7,20,40,51,3)

tupla2=tupla1[3:]
print tupla2

El resultado es una tupla con tres valores, desde la posición 3 hasta el final de la tupla:

(40, 51, 3)

En caso de no indicar el primer rango:

tupla1=(1,7,20,40,51,3)
tupla2=tupla1[:2]
print tupla2

El resultado es una tupla con dos valores, desde el principio de la tupla hasta la posición 2 sin incluirla:

(1, 7)

Estructura de datos tipo cadena de caracteres (string).

Una cadena de caracteres permite almacenar un conjunto de caracteres. Su funcionamiento es similar a una tupla.
Para inicializar un string utilizamos el operador de asignación.

nombre='Juan Pablo'

Podemos utilizar las comillas simples o dobles para su inicialización:

mail='jose@gmail.com'

mail="jose@gmail.com"

Para conocer el largo de un string podemos utilizar la función len:

print len(mail)

Para acceder a un caracter particular del string lo hacemos indicando un subíndice entre corchetes:

print mail[0] #Imprimimos el primer caracter

El lenguaje Python nos permite rescatar una "porción" de un string con la misma sintaxis que trabajamos las tuplas:

nombre='Jose Maria'
print nombre[1:4] #ose
print nombre[:4] #Jose
print nombre[5:] #Maria

Los string son inmutables, es decir que no podemos modificar su contenido luego de ser inicializados:

titulo='Administracion'
titulo[0]='X' # Esto produce un error

Esto no significa que no podemos utilizar la variable para que referencie a otro string:

nombre='Jose'
print nombre
nombre='Ana'
print nombre

Para concatenar string Python permite utilizar el operador +.
Si tenemos tres string y queremos almacenar sus contenidos en un cuarto string podemos codificarlo de la siguiente manera:

cadena1='uno'
cadena2='dos'
cadena3='tres'
total=cadena1+cadena2+cadena3
print total #unodostres

También Python define el operador * para los string. El resultado de multiplicar un string por un entero es otro string que repite el string original tantas veces como indica el número.

#si queremos un string con 80 caracteres de subrayado, la forma más sencilla es utilizar la siguiente expresión:
separador='_'*80
print separador

Los operadores relacionales definidos para los string son:

> Mayor
>= Mayor o igual
< Menor
<= Menor o igual
== Igual
!= Distinto

Si queremos saber si un string es mayor alfabéticamente que otro utilizamos el operador >

nombre1='CARLOS'
nombre2='ANABEL'
if nombre1>nombre2:
print nombre1+' es mayor alfabéticamente que '+nombre2

si queremos saber si dos variables tienes en mismo contenido:

nombre1='CARLOS'
nombre2='CARLOS'
if nombre1==nombre2:
print 'Las dos variables tienen el mismo contenido:'+nombre1

Estructura de datos tipo lista.

Una lista es una colección de datos no necesariamente del mismo tipo que se los accede por medio de subíndices. La diferencia fundamental de una lista con una tupla es que podemos modificar la estructura luego de haberla creado.
Hay varias formas de crear una lista, la primera y más sencilla es enumerar sus elementos entre corchetes y separados por coma:

lista1=['juan','ana','luis']

Para acceder a sus elementos lo hacemos indicando un subíndice subíndice:

print lista1[0]

Como decíamos la diferencia con una tupla (son inmutables) es que podemos modificar la lista luego de creada:

lista1=[10,15,20]
print lista1
print '<br>'
lista1[0]=700 # modificamos el valor almacenado en la primer componente de la lista.
print lista1

De forma similar a las tuplas y string la función len nos informa de la cantidad de elementos que contiene la lista:

lista1=[10,15,20]
print len(lista1) # imprime un 3

Es muy común emplear la estructura for in para recorrer y rescatar cada elemento de la lista, la variable elemento almacena en cada ciclo del for un elemento de la lista1, comenzando por el primer valor:

lista1=['juan',23,1.92]
for elemento in lista1:
print elemento
print '<br>'

Si queremos saber si un valor se encuentra en una lista existe un operador llamado in:

lista1=[12,45,1,2,5,4,3,55]
if 1 in lista1:
print 'El valor 1 está contenido en la lista '
else:
print 'El valor 1 no está contenido en la lista '
print lista1

Python define los operadores + y * para listas, el primero genera otra lista con la suma de elementos de la primer y segunda lista. El operador * genera una lista que repite tantas veces los elementos de la lista como indica el valor entero seguido al operador *.

lista1=[2,4,6,8]
lista2=[10,12,14,16]
listatotal=lista1+lista2
print listatotal

Luego empleando el operador *:

lista1=['juan','carlos']
producto=lista1*3
print producto

El resultado de este algoritmo es:

['juan', 'carlos', 'juan', 'carlos', 'juan', 'carlos']

También con listas podemos utilizar el concepto de porciones que nos brinda el lenguaje Python:

lista=[2,4,6,8,10]
print lista[2,4]   #[6, 8]
print lista[:3]    #[2, 4, 6]
print lista[3:]    #[8, 10]

Como vimos podemos modificar el contenido de elementos de la lista asignándole otro valor:

lista=[2,4,6]
lista[1]=10
print lista #[2, 10, 6]

Podemos borrar elementos de la lista utilizando la función del:

lista=[2,4,6]
del(lista[1])
print lista #[2, 6]

Además podemos utilizar porciones para borrar un conjunto de elementos de la lista:

lista=[2,4,6]
del(lista[1:])
print lista #[2]

También podemos añadir elementos a una lista:

lista=[5,10,11,12]
lista[1:1]=[6,7,8,9]
print lista #[5,6,7,8,9,10,11,12]

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales