Mechasoft: Blog de Matías J. Magni

…dedicado al Open Source y al delirio del Autor…

  • Matías J. Magni

  • RSS Ubuntu

    • Security Team Weekly Summary: August 17, 2017 17/08/2017
      The Security Team weekly reports are intended to be very short summaries of the Security Team’s weekly activities. If you would like to reach the Security Team, you can find us at the #ubuntu-hardened channel on FreeNode. Alternatively, you can mail the Ubuntu Hardened mailing list at: ubuntu-hardened@lists.ubuntu.com During the last week, the Ubuntu Securit […]
    • How to set up Kubernetes on any cloud and monitor your apps with Weave 17/08/2017
      On August 2, Luke Marsden (Weaveworks) and Marco Ceppi (Canonical) presented a webinar on how to Speed up your software development lifecycle with Kubernetes. In the session they described how you can use conjure-up and Weave Cloud to set up, manage and monitor an app in Kubernetes. In this tutorial we’re going to show you […]
    • Ubuntu Foundations Development Summary – August 16, 2017 16/08/2017
      This newsletter is to provide a status update from the Ubuntu Foundations Team. There will also be highlights provided for any interesting subjects the team may be working on. If you would like to reach the Foundations team, you can find us at the #ubuntu-devel channel on freenode. Highlights Updated cloud images have been released […]
    • Kernel Team Summary- August 16, 2017 16/08/2017
      Development (Artful / 17.10) We intend to target a 4.13 kernel for the Ubuntu 17.10 release. The artful kernel is now based on Linux 4.11. The Ubuntu 17.10 Kernel Freeze is Thurs Oct 5, 2017. The kernel in the artful-proposed pocket of the Ubuntu archive has been updated to v4.12.7 The kernel in the Artful […]
    • Ubuntu Server Development Summary – 15 Aug 2017 15/08/2017
      Hello Ubuntu Server! The purpose of this communication is to provide a status update and highlights for any interesting subjects from the Ubuntu Server Team. If you would like to reach the server team, you can find us at the #ubuntu-server channel on Freenode. Alternatively, you can sign up and use the Ubuntu Server Team […]
  • RSS LUGMen

    • Se ha producido un error; es probable que la fuente esté fuera de servicio. Vuelve a intentarlo más tarde.
  • Archivos

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
    • 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/Java Có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

Una respuesta to “Python”

  1. chromeaa said

    hola gente http://javaencrypt.com/javascript-obfuscator/index.php?lang=es suerte.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

 
A %d blogueros les gusta esto: