English Spanish

Python

Contenidos



  • Sintaxis

  • Instrucciones básicas

  • Tipo de datos

  • Orientación a objetos

  • Paquetes esenciales de Python: XML, bases de datos, programación web


Introducción


Python fue creado por Guido van Rossum.
Da este nombre al lenguaje inspirado por el popular grupo cómico británico Monty Python. Guido creó Python durante unas vacaciones de navidad en las que, al parecer, se estaba aburriendo.

Hola Mundo


#!/usr/bin/env python

print "Hola Mundo" # "Hola Mundo"
print "hola", "mundo" # "hola mundo"
print "Hola" + "Mundo" # "HolaMundo"

Características



  • Muy legible y elegante

    • Imposible escribir código ofuscado



  • Simple y poderoso

    • Minimalista: todo aquello innecesario no hay que escribirlo (;, {, }, '\n')‏

    • Muy denso: poco código hace mucho

    • Soporta objetos y estructuras de datos de alto nivel: strings, listas, diccionarios, etc.

    • Múltiples niveles de organizar código: funciones, clases, módulos, y paquetes

      • Python standard library (http://www.python.org/doc/current/lib/lib.html) contiene un sinfín de clases de utilidad



    • Si hay áreas que son lentas se pueden reemplazar por plugins en C o C++, siguiendo la API para extender o empotrar Python en una aplicación, o  a través de herramientas como SWIG, sip o Pyrex.

    • De scripting

      • No tienes que declarar constantes y variables antes de utilizarlas

      • No requiere paso de compilación/linkage



      • La primera vez que se ejecuta un script de Python se compila y genera bytecode que es luego interpretado



    • Alta velocidad de desarrollo y buen rendimiento



  • Código interoperable (como en Java "write once run everywhere")‏

    • Se puede utilizar en múltiples plataforma (más aún que Java)‏

    • Puedes incluso ejecutar Python dentro de una JVM (Jython)‏



  • Open source

    • Razón por la cual la Python Library sigue creciendo



  • De propósito general

    • Puedes hacer en Python todo lo que puedes hacer con C# o Java, o más




Peculiaridades de la Sintaxis


Python usa tabulación (o espaciado) para mostrar estructura de bloques:

  • Tabula una vez para indicar comienzo de bloque

  • Des-tabula para indicar el final del bloque












Código en C/JavaCódigo en Python

         if(x) {
                if(y) {
                      f1();
                }
                f2();
          }


       if x:
            if y:
                 f1()
            f2()


Python vs. Perl


    Los dos están basados en un buen entendimiento de las herramientas necesarias para resolver problemas
  • Perl está basado en awk, sed, and shell scripting y su misión es hacer las tareas de administradores de sistemas más sencillas.



  • Python está basado e inspirando en OOP (Object-oriented programming)‏

    • Guido van Rossum diseñó un lenguaje simple, poderoso, y elegante orientado a la creación de sistemas a partir de componentes.




Python vs. Java



  • Java es un lenguaje de programación muy completo que ofrece:

    • Amplio abanico de tipos de datos

    • Soporte para threads

    • Strong typing

    • Y mucho más ...



  • Python es un lenguaje de scripting:

    • No ofrece strong typing

    • Bueno para prototipos pero malo para grandes sistemas

    • Puede cascar en tiempo de ejecución

    • Todo lo que puedes hacer con Java también lo puedes hacer con Python

    • Incluso puedes acceder a través de Python a las API de Java si usas Jython (http://www.jython.org)‏




Python vs. Jython



  • Python

    • También llamado Cpython

    • Implementación del lenguaje Python en C

    • Python C API permite extender Python con librerías realizadas en C

    • Partes que requieren mayor rendimiento en Python están implementadas en C/C++ y tan sólo contienen una pequeña capa de Python encima



  • Jython

    • Implementación de Python en Java

    • Permite acceder a todas las APIs de Java

    • P.E. Podemos producir Swing GUIs desde Python




¿Cuándo usar Python?



  • Python no es el lenguaje perfecto, no es bueno para:

    • Programación de bajo nivel (system-programming), como programación de drivers y kernels

    • Python es de demasiado alto nivel, no hay control directo sobre memoria y otras tareas de bajo nivel

    • Aplicaciones que requieren alta capacidad de computo

    • No hay nada mejor para este tipo de aplicaciones que el viejo C



  • Python es ideal:

    • Como lenguaje "pegamento" para combinar varios componentes juntos

    • Para llevar a cabo prototipos de sistema

    • Para la elaboración de aplicaciones cliente

    • Para desarrollo web y de sistemas distribuidos

    • Para el desarrollo de tareas científicas, en los que hay que simular y prototipar rápidamente




Usando Python desde la línea de comandos


Para arrancar el intérprete (Python interactivo) ejecutar:

  • En Windows:
    C:\>python
    Python 2.4 (#60, Nov 30 2004, 11:49:19) [MSC v.1310 32 bit (Intel)] on win32
    Type "help", "copyright", "credits" or "license" for more information.
    >>>




  • En linux:
    $ python
    Python 2.5.2 (r252:60911, Oct  5 2008, 19:24:49)
    [GCC 4.3.2] on linux2
    Type "help", "copyright", "credits" or "license" for more information.
    >>>



Un comando simple:
>>> print "Hola Mundo"
Hola Mundo
>>>

Para salir del intérprete Ctrl-D (en Linux) o Ctrl-Z (en Windows) o:
>>> import sys
>>> sys.exit()
$

Ejecutar un programa


Python desde script:
Guardar las siguientes sentencias en un fichero llamado holamundo.py
#!/usr/bin/env python
print “Hola mundo!"

Ejecutar el script desde línea de comandos:
$ python helloworld.py
Hola mundo!
$

o le damos permisos de ejecución al archivo y al ejecutarlo se utilizará el intérprete de python como lo indicamos en esta línea #!/usr/bin/env python:
$ chmod +x helloworld.py
$ ./helloworld.py
Hola mundo!
$

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):


# comentarios de línea se indican con carácter '#'
name = "Matias" # asignación de valor a variable
if name == "Matias":
        print "Hola Matias"
else:
        print "¿Quién eres?"
        print "¡No eres Matias!"

$ python bloque.py
¿Quién eres?
¡No eres Matias!

Identificadores



  • Los identificadores sirven para nombrar variables, funciones y módulos

    • Deben empezar con un carácter no numérico y contener letras, números y '_'

    • Python es case sensitive (sensible a la capitalización)‏



  • 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



  • Variables y funciones delimitadas por __ corresponden a símbolos implícitamente definidos:

    • __name__ nombre de función

    • __doc__ documentación sobre una función

    • __init__() constructor de una clase

    • __dict__, diccionario utilizado para guardar los atributos de un objeto




Tipos de datos



  • Numéricos (integer, long integer, floating-point, and complex)‏
          >>> 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
      Hithere
      >>> print "Hi" "there"


    • Los códigos de escape se expresan a través de '\':
      >>>print '\n'


    • Raw strings
      >>> print r'\n\\' # no se 'escapa' \n


    • Lo mismo ' que ", p.e. "\\[foo\\]" r'\[foo\]'

    • 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 la Python library define 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:
      >>> provincia = 'Araba'
      >>> "La capital de %s es %s"  % (provincia, "Gasteiz")‏
      'La capital de Araba es Gasteiz'
      Los caracteres de formateo son los mismos que en C, p.e. d, f, x


    • Para poder escribir caracteres con acentos es necesario introducir la siguiente línea al comienzo de un programa Python:
      # -*- coding: iso-8859-1 -*-


    • Los strings en formato unicode se declaran precediendo el string de una ‘u’:
      print u'¿Qué tal estás?'




  • Listas []

    • Indexadas por un entero comienzan en 0:
      >>> meses = ["Enero", "Febrero"]
      >>> print meses[0]
      Enero
      >>> 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']


    • Más (+) es el operador de concatenación:
      >>> print meses+meses
      [Enero', 'Febrero', 'Marzo', 'Enero', 'Febrero', 'Marzo']


    • Las listas pueden contener cualquier tipo de objetos Python:
      >>> meses.append (meses)
      >>> print meses
      ['Enero', 'Febrero', 'Marzo', ['Enero', 'Febrero', 'Marzo' ]]
      >>> meses.append(1)‏
      ['Enero', 'Febrero', 'Marzo', ['Enero', 'Febrero', 'Marzo' ], 1]


    • Para añadir un elemento a una lista:
      >>> items = [4, 6]
      >>> items.insert(0, -1)
      >>> items
      [-1, 4, 6]


    • Para usar una lista como una pila, se pueden usar append y pop:
      >>> items.append(555)
      >>> items [-1, 4, 6, 555]
      >>> items.pop()
      555
      >>> items [-1, 4, 6]




  • Tuplas (), lo mismo que listas, pero no se pueden modificar
    D:\>python
    Python 2.4 (#60, Nov 30 2004, 11:49:19) [MSC v.1310 32 bit (Intel)] on win32
    Type "help", "copyright", "credits" or "license" for more information.
    >>> mitupla = ('a', 1, "hola")‏
    >>> mitupla[2]
    'hola'
    >>> dir(mitupla)‏
    ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__str__']


  • Diccionarios {} arrays asociativos o mapas, indexados por una clave, la cual puede ser cualquier objeto Python, aunque normalmente es una tupla:
    >>> mydict = {"altura" : "media", "habilidad" : "intermedia", "salario" : 1000 }
    >>> print mydict
    {altura': 'media', 'habilidad': 'intermedia', 'salario': 1000}
    >>> 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'





Control de Flujo:


Condicionales



  • E.j.  (condicional.py)‏


      q = 4
      h = 5
      if q < h :
            print "primer test pasado"
      elif q == 4:
            print “q tiene valor 4”
      else:
            print "segundo test pasado"

      >>> python condicional.py
      primer test pasado


  • Operadores booleanos: "or," "and," "not"

  • Operadores relacionales: ==, >, <, !=


Bucles


for


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)‏
Ej. bucle.py
for x in range(1,5):
       print x

$ python bucle.py
1 2 3 4

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.

while


while es otra sentencia de repetición. Ejecuta un bloque de código hasta que una condición es falsa. break nos sirve para salir de un bucle
Por ejemplo:
reply = 'repite'
while reply == 'repite':
       print 'Hola'
       reply = raw_input('Introduce "repite" para hacerlo de nuevo: ')

Hola
Introduce "repite" para hacerlo de nuevo: repite
Hola
Introduce "repite" para hacerlo de nuevo: adiós

Funciones



  • Una función se declara usando la palabra clave def
    print myfunc(5,6)
    $ python funcionsimple.py
    11
    # funcionsimple.py
    def myfunc(a,b):
        sum = a + b
        return sum

    $ python funcionsimple.py
    11


  • A una función se le pueden asignar parámetros por defecto:
    # 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

    $ python funcion.py
    10
    12


  • Listas de argumentos y argumentos basados en palabras clave:
    # funcionargumentosvariablesyconclave.py
    def testArgLists_1(*args, **kwargs):
        print 'args:', args
        print 'kwargs:', kwargs
    testArgLists_1('aaa', 'bbb', arg1='ccc', arg2='ddd')
    def testArgLists_2(arg0, *args, **kwargs):
        print 'arg0: "%s"' % arg0
        print 'args:', args
        print 'kwargs:', kwargs
    print '=' * 40
    testArgLists_2('un primer argumento', 'aaa', 'bbb', arg1='ccc', arg2='ddd')‏


  • Visualizaría:
    args: ('aaa', 'bbb')
    kwargs: {'arg1': 'ccc', 'arg2': 'ddd'}
    ========================================
    arg0: "un primer argumento"
    args: ('aaa', 'bbb')
    kwargs: {'arg1': 'ccc', 'arg2': 'ddd'}



Clases



  • Una clase contiene una colección de métodos. Cada método contiene como primer parámetro (self, equivalente a this en C++) que hace referencia a un objeto.

  • Existe un soporte limitado para variables privadass mediante name mangling.

    • Un identificador __spam es reemplazado por _classname__spam.

    • El identificador es todavía accesible por _classname__spam.



  • En Python se soporta la herencia múltiple

  • Ejemplo:
    # clasesherencia.py
    class Basic:
       def __init__(self, name):
          self.name = name
       def show(self):
          print 'Basic -- name: %s' % self.name

    class Special(Basic): # entre paréntesis la clase base
       def __init__(self, name, edible):
          Basic.__init__(self, name) # se usa Basic para referir a
          self.upper = name.upper()  # clase base
          self.edible = edible
       def show(self):
          Basic.show(self)
          print 'Special -- upper name: %s.' % self.upper,
          if self.edible:
             print "It's edible."
          else:
             print "It's not edible."
       def edible(self):
          return self.edible


  • Probamos el ejemplo:
    obj1 = Basic('Manzana')
    obj1.show()
    print '=' * 30
    obj2 = Special('Naranja', True)
    obj2.show()‏

    Visualizaría:
    Basic -- name: Manzana
    ==============================
    Basic -- name: Naranja
    Special -- upper name: NARANJA. It's edible.



Excepciones


Cada vez que un error ocurre se lanza una excepción, visualizándose un extracto de la pila del sistema. E.j. excepcion.py:
#!/usr/bin/python
print a

$ python exception.py
Traceback (innermost last): File "exception.py", line 2, in ? print a NameError: a

Para capturar la excepción se usa except:
try:
      fh=open("new.txt", "r")‏
except IOError, e:
      print e

$ python excepcion.py
[Errno 2] No such file or directory: 'new.txt'

Puedes lanzar tu propia excepción usando el comando raise:
raise MyException
raise SystemExitModules

Excepciones personalizadas


# excepcionpersonalizada.py
class E(RuntimeError):
      def __init__(self, msg):
            self.msg = msg
      def getMsg(self):
            return self.msg
      try:
            raise E('mi mensaje de error')‏
      except E, obj:
            print 'Msg:', obj.getMsg()‏

Visualizaría:
Msg: mi mensaje de error

Módulos


Un módulo 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.

  • E.j. modulo.py:
    def one(a):
          print "in one"
    def two (c):
          print "in two"


  • Uso de un módulo:
    >>> import modulo
    >>> dir(modulo) # lista contenidos módulo
    ['__builtins__', '__doc__', '__file__', '__name__', 'one', 'two']
    >>> modulo.one(2)
    in one


  • import hace que un módulo y su contenido sean disponibles para su uso.

  • Algunas formas de uso son:
    import test # Importa modulo test. Referir a x en test con "test.x".
    from test import x # Importa x de test. Referir a x en test con "x".
    from test import * # Importa todos los objetos de test. Referir a x en test con "x".
    import test as theTest # Importa test; lo hace disponible como theTest. Referir a objecto x como "theTest.x".



Paquetes


Un paquete es una manera de organizar un conjunto de módulos como una unidad. Los paquetes pueden a su vez contener otros paquetes.

  • Para aprender como crear un paquete consideremos el siguiente contenido de un paquete:
    package_example/
    package_example/__init__.py
    package_example/module1.py
    package_example/module2.py

  • Y estos serían los contenidos de los ficheros correspondientes:
    # __init__.py
    # Exponer definiciones de módulos en este paquete.
    from module1 import class1
    from module2 import class2


  • Ejemplos:
    # module1.py
    class class1:
          def __init__(self):
                self.description = 'class #1'
          def show(self):
                print self.description 

    # module2.py
    class class2:
          def __init__(self):
                self.description = 'class #2'
          def show(self):
                print self.description

    # testpackage.py
    import package_example
    c1 = package_example.class1()‏
    c1.show()‏
    c2 = package_example.class2()‏
    c2.show()‏

    Visualizaría:
    class #1
    class #2


  • La localización de los paquetes debe especificarse o bien a través de la variable de entorno PYTHONPATH o en código del script mediante sys.path

  • Como en Java el código de un paquete puede recogerse en un .zip:
    >>> import zipfile
    >>> a=zipfile.PyZipFile('mipackage.zip', 'w', zipfile.ZIP_DEFLATED)‏
    >>> a.writepy('package_example')‏
    >>> a.close()‏
    >>> ^Z


  • Luego lo puedes importar y usar insertando su path en sys.path o alternativamente añadiendo a la variable de entorno PYTHONPATH una referencia al nuevo .zip creado:
    $ mkdir prueba; cp mipackage.zip prueba
    $ export PYTHONPATH=/home/dipina/examples/prueba/mipackage.zip
    >>> import sys # esta y la siguiente no hacen falta si se ha inicializado PYTHONPATH
    >>> sys.path.insert(0, '/home/dipina/examples/prueba/mipackage.zip')
    >>> import package_example
    >>> class1 = package_example.module1.class1()‏
    >>> class1.show()‏
    class #1
    >>> ^Z


No hay comentarios:

Publicar un comentario

Suscribirse a: Entradas (Atom)