Guia Python: implementación de módulos y funciones de uso común.

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

Implementación de módulos.

Cuando uno codifica un programa en Python lo almacena en un archivo con extensión *.py

Una vez instalado el Python en forma local podemos llamar un programa desde la línea de comando del sistema operativo.

Si tenemos un programa mínimo llamado: programa1.py

def holamundo():
   print('Hola Mundo')

holamundo();

Luego desde la carpeta donde hemos instalado el Python debemos ejecutarlo con la siguiente sintaxis:

c:\Python25>python c:\pruebaspython\programa1.py

Luego de esto veremos en pantalla el mensaje 'Hola Mundo'

Este archivo en Python se lo llama módulo.

Un programa pequeño puede estar formado por un único módulo, pero programas de mayor tamaño deben dividirse en distintos módulos para facilitar su mantenimiento. Cada módulo normalmente almacena un conjunto de funciones relacionadas.

La sintaxis para llamar a una función que se encuentra en otro módulo es la siguiente:

modulo1.py

def funcion1():
   print 'Función 1'  

modulo2.py

import modulo1

def funcion2():
   modulo1.funcion1()
   print 'Función 2'

funcion2()  

Luego desde la línea de comandos ejecutamos el modulo2.py:

c:\Python25>python c:\pruebaspython\modulo2.py

Y como resultado tenemos en pantalla

Función 1
Función 2

Veremos más adelante que Python nos provee de una gran biblioteca de módulos. Recordemos que ya hemos estado utilizando la función randint que se encuentra en el módulo random:

import random

x=random.randint(1,1000)
print x

Funciones de uso común (range - type - str - dir).

Como hemos visto en el punto anterior Python agrupa las funciones en módulos que serán importados en el caso que nuestro programa los necesite. Pero hay un pequeño grupo de funciones que Python las importa de forma automática, esto quiere decir que podemos hacer uso sin tener que hacer un import.

Funciones incorporadas en Python

• range([inicio],fin,[paso])
  La función range devuelve una lista de valores enteros, comienza con el valor pasado al parámetro [inicio], en caso de omitir este parámetro comienza en cero y finaliza con el valor indicado en el parámetro 'fin' sin incluirlo. En caso de indicar el parámetro [paso] la lista de valores crece según dicho número, sino se incrementa de a uno.

lista1=range(5,10)
print lista1  # [5, 6, 7, 8, 9]
lista2=range(10)
print lista2  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
lista3=range(-5,5)
print lista3  # [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
lista4=range(1,10,3)
print lista4  # [1, 4, 7]
Es muy común utilizar esta función para generar un contador con la estructura for in, por ejemplo si queremos mostrar los números del 1 al 10:

for x in range(1,11):
   print x
   print '-'

• str(variable)
  Convierte el contenido del parámetro a cadena y lo retorna. Funciona para cualquier tipo de dato como puede ser un entero, real, tupla, lista etc.
  Muy útil cuando tenemos que generar un string a partir de un conjunto de variables heterogeneas.

x=10
y=2.5
fin=False
edades=(40,50)
print str(x) + str(y) + str(fin) + str(edades)
En el ejemplo concatenamos el contenido de cuatro variables de distinto tipo, para ello debemos llevarlas a todas a tipo string.

• type(variable)
  Retorna el tipo de una variable.

x=10
print type(x) # <type 'int'>
y=2.5
print type(y)  # <type 'float'>
fin=False
print type(fin) # <type 'bool'>
edades=(40,50)
print type(edades) # <type 'tuple'>

• dir(variable)
  Si pasamos como parámetro a la función dir un objeto luego nos devuelve todos los métodos que tiene definidos la clase de dicho objeto (veremos más adelante en profundidad cada uno de los métodos de la clase lista y diccionario):

lista1=[2,4,6]
print dir(lista1) #['__add__', '__class__', '__contains__', '__delattr__',
   # '__delitem__', '__delslice__', '__doc__', '__eq__', '__ge__',
   # '__getattribute__', '__getitem__', '__getslice__', '__gt__',
   # '__hash__', '__iadd__', '__imul__', '__init__', '__iter__',
   # '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__',
   # '__reduce__', '__reduce_ex__', '__repr__', '__reversed__',
   # '__rmul__', '__setattr__', '__setitem__', '__setslice__',
   # '__str__', 'append', 'count', 'extend', 'index', 'insert',
   # 'pop', 'remove', 'reverse', 'sort']
  
dic1={'juan':44,'ana':3}
print dir(dic1)   # ['__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__',
   # '__doc__', '__eq__', '__ge__', '__getattribute__', '__getitem__', '__gt__',
   # '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__',
   # '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__',
   # '__str__', 'clear', 'copy', 'fromkeys', 'get', 'has_key', 'items', 'iteritems',
   # 'iterkeys', 'itervalues', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

Si le pasamos como parámetro el nombre de un módulo la función dir nos retorna todas las funciones definidas entre otros datos (recordemos que hemos estado utilizando la función randint para generar un valor aleatorio y como podemos ver se encuentra listado al llamar a la función dir):

import random

print dir(random) # ['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST',
   # 'SystemRandom', 'TWOPI', 'WichmannHill', '_BuiltinMethodType', '_MethodType',
   # '__all__', '__builtins__', '__doc__', '__file__', '__name__', '_acos', '_ceil',
   # '_cos', '_e', '_exp', '_hexlify', '_inst', '_log', '_pi', '_random', '_sin',
   # '_sqrt', '_test', '_test_generator', '_urandom', '_warn', 'betavariate',
   # 'choice', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate',
   # 'jumpahead', 'lognormvariate', 'normalvariate', 'paretovariate', 'randint',
   # 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'uniform',
   # 'vonmisesvariate', 'weibullvariate']

Función de uso común (help).

La función help tiene por objetivo ayudar al programador dando información de documentación definidas en módulos, funciones, clases etc.

Veamos que nos devuelve la función help si le pasamos como parámetro la función randint:

import random

help(random.randint) # Help on method randint in module random: randint(self, a, b)
   # method of random.Random instance Return random integer in
   # range [a, b], including both end points.

Podemos observar que nos informa el módulo donde se almacena, sus parámetros y el objetivo de la misma.

Nosotros podemos crear cadenas de documentación para nuestras funciones con la siguiente sintaxis:

def sumar(v1,v2):
   """El objetivo de esta funcion es realizar la
   suma de los dos valores que recibe como
   parametro y retornarlo."""
   su=v1+v2
   return su

help(sumar) # Help on function sumar in module __main__: sumar(v1, v2)
   # El objetivo de esta funcion es realizar la suma de los
   # dos valores que recibe como parametro y retornarlo.

El string que definamos inmediatamente después de la cabecera se tomará como cadena de documentación de la función. Como en este caso nuestra cadena de documentación ocupa varias líneas en Python podemos encerrarla entre triples comillas y no deberemos indicar el caracter de continuación de línea (Si la cadena de documentación es una sola línea podemos emplear una sola comillas al principio y al final)

Si utilizamos una sola comillas debemos indicar al final de cada línea que continúa:

def sumar(v1,v2):
   "El objetivo de esta funcion es realizar la \
   suma de los dos valores que recibe como \
   parametro y retornarlo."
   su=v1+v2
   return su

Podemos crear cadenas de documentación para definir objetivos del mismo.

Si tenemos un módulo mínimo llamado: modulo1.py, podemos definir las siguientes cadenas de documentación

"cadena de documentacion del modulo"

def holamundo():
   "cadena de documentacion de funcion"
   print('Hola Mundo')

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: