Introducción a Python

Sintaxis Básica

Print



In [4]:

    
print 1
print "hola"
print [1, 2, 4]
nombre = "Santiago"
print nombre
print "mi nombre es %s" %(nombre)









    



1
hola
[1, 2, 4]
Santiago
mi nombre es Santiago

Operaciones matemáticas



In [5]:

    
print 1 + 2
print 1 - 10
print 10 * 100
print 10 / 5
print 10 / 3
print 10 ** 2

La división por 0 arroja una excepción



In [6]:

    
7 / 0









    



---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
<ipython-input-6-0ea40df5391c> in <module>()
----> 1 7 / 0

ZeroDivisionError: integer division or modulo by zero

Tomar la raíz cuadrada de un número negativo también arroja una excepción



In [7]:

    
(-1) ** 0.5









    



---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-7-ff77933db820> in <module>()
----> 1 (-1) ** 0.5

ValueError: negative number cannot be raised to a fractional power

Números



In [8]:

    
print 10.0 / 3
print 0.54 ** 2
print 9.0 ** 0.5









    



3.33333333333
0.2916
3.0



In [9]:

    
print 1 + 2j
print (1+2j) + (2+3j)
print 1j ** 2









    



(1+2j)
(3+5j)
(-1+0j)

Tipos



In [10]:

    
print type(1)
print type(1000000000000000000000000)
print type(2.0)
print type(5+1j)









    



<type 'int'>
<type 'long'>
<type 'float'>
<type 'complex'>

Conversión de tipos



In [11]:

    
print float(1)
print complex(1.0)









    



1.0
(1+0j)



In [12]:

    
int(1.5)









    Out[12]:





1

Convertir a un tipo de menos información puede fallar



In [13]:

    
float(1+1j)









    



---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-13-215f213c112b> in <module>()
----> 1 float(1+1j)

TypeError: can't convert complex to float

Operaciones sobre números

Para hallar el valor absoluto podemos usar la funcion abs()



In [14]:

    
print abs(-1)
print abs(-2.0)
print abs(1+1j)









    



1
2.0
1.41421356237

Podemos buscar minimos y máximos



In [15]:

    
min(1, 2, 3)









    Out[15]:





1



In [16]:

    
min(1+1j, 2+3j)









    



---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-16-5f944ccdd97b> in <module>()
----> 1 min(1+1j, 2+3j)

TypeError: no ordering relation is defined for complex numbers

Para ver mas funciones básicas (built_in functions): https://docs.python.org/2/library/functions.html

Comparaciones



In [17]:

    
1 < 5









    Out[17]:





True



In [18]:

    
1 < 2 < 3  <= 5









    Out[18]:





True



In [19]:

    
1 > 2









    Out[19]:





False



In [20]:

    
type(1 < 2)









    Out[20]:





bool

Variables y tipos

Nombres de símbolos

Los nombres de las variables en Python pueden contener los caracteres a-z, A-Z, 0-9 y algunos caracteres especiales como _. Los nombres de variables normales deben comenzar con una letra.

Por convención, los nombres de las variables comienzan con letra minúscula, mientras que los nombres de las clases comienzan con una letra mayúscula.

Además, existen algunos palabras claves Python que no pueden ser usados como nombres de variables. Éstas son:

and, as, assert, break, class, continue, def, del, elif, else, except, 
exec, finally, for, from, global, if, import, in, is, lambda, not, or,
pass, print, raise, return, try, while, with, yield

Atención con la palabra `lambda`, que podría fácilmente ser un nombre de variable natural en un programa científico. Sin embargo, como es una palabra clave, no puede ser usado como nombre de una variable.

Asignaciones

El operador para asignar valores en Python es =. Python es un lenguage de escritura dinámica, de modo que no necesitamos especificar el tipo de una variable cuando creamos una.

Al asignar un valor a una variable nueva se crea esa variable:



In [21]:

    
x = 1.0
mi_variable = 128
var1, var2 = 5 , 4
print var1
print var2

5
4



In [22]:

    
var1 == var2









    Out[22]:





False

Otros tipos de datos

Secuencias: Tuplas y listas



In [23]:

    
una_tupla = (1, 20.0, "String", (1+1j))
una_lista = [1, 20.0, "String", (1+1j)]
print una_tupla
print una_lista
print una_tupla == una_lista









    



(1, 20.0, 'String', (1+1j))
[1, 20.0, 'String', (1+1j)]
False

Podemos obviar los paréntesis cuando definimos una tupla



In [24]:

    
1 , 15.4 , "Hola"









    Out[24]:





(1, 15.4, 'Hola')

Tienes operaciones en común



In [25]:

    
print len(una_tupla), len(una_lista)

4 4



In [26]:

    
1 in una_tupla









    Out[26]:





True



In [27]:

    
1 in una_lista









    Out[27]:





True

Podemos indexar las secuencias, utilizando la sintaxis [<inicio>:<final>:<salto>]:



In [28]:

    
print una_lista[0]  # Primer elemento, 1
print una_tupla[1]  # Segundo elemento, 2
print una_lista[0:2]  # Desde el primero hasta el tercero, excluyendo este: 1, 2
print una_tupla[:3]  # Desde el primero hasta el cuarto, excluyendo este: 1, 2, 3.0
print una_lista[-1]   # El último: 4 + 0j
print una_tupla[:]  # Desde el primero hasta el último
print una_lista[::2]  # Desde el primero hasta el último, saltando 2: 1, 3.0









    



1
20.0
[1, 20.0]
(1, 20.0, 'String')
(1+1j)
(1, 20.0, 'String', (1+1j))
[1, 'String']

Nota: ¡En Python la indexación empieza por cero!

Podemos cambiar el valor de una elemento de una lista



In [29]:

    
una_lista[0] = 2
print una_lista









    



[2, 20.0, 'String', (1+1j)]

Pero, no podemos cambiar el valor de un elemento de una tupla



In [30]:

    
una_tupla[0] = 2









    



---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-30-ad776b542125> in <module>()
----> 1 una_tupla[0] = 2

TypeError: 'tuple' object does not support item assignment

Estructuras de Control

Condicionales



In [31]:

    
edad = 20
if edad < 18:
    print "menor de edad"
else:
    print "mayor de edad"









    



mayor de edad

Importante: En Python los bloques se delimitan por sangrado, utilizando siempre cuatro espacios. Cuando ponemos los dos puntos al final de la primera línea del condicional, todo lo que vaya a continuación con *un* nivel de sangrado superior se considera dentro del condicional. En cuanto escribimos la primera línea con un nivel de sangrado inferior, hemos cerrado el condicional. Si no seguimos esto a rajatabla Python nos dará errores; es una forma de forzar a que el código sea legible.

Si queremos añadir condiciones adicionales, podemos usar la sentencia elif (abreviatura de else if). Para la parte final, que debe ejecutarse si ninguna de las condiciones anteriores se ha cumplido, usamos la sentencia else



In [32]:

    
if edad == 0:
    print "recien nacido"
elif 0 < edad < 18:
    print "menor de edad"
elif edad > 18:
    print "mayor de edad"
else:
    print "No nacido"









    



mayor de edad

Ciclos

Hay dos tipos de bucles en Python: while y for.
Como en el caso de los condicionales, el cuerpo del ciclo se determinan con el sangrado



In [33]:

    
ii = 0
while ii < 5:
    print(ii)
    ii += 1

Podemos interrumpir el ciclo con la sentencia break



In [34]:

    
ii = 0
while ii < 5:
    print(ii)
    ii += 1
    if ii == 3:
        break

Podemos determinar si el ciclo terminó, de la siguiente forma



In [35]:

    
ii = 0
while ii < 5:
    print(ii)
    ii += 1
else:
    print "El ciclo terminó"









    



0
1
2
3
4
El ciclo terminó

Las sentencia for se utiliza para recorrer una secuencia de elementos



In [36]:

    
for ii in 1, 2, 4:
    print(ii)



In [37]:

    
for nombre in "Juan", "Luis", "Carlos":
    print(nombre)









    



Juan
Luis
Carlos



In [38]:

    
for ii in range(1250):
    print(ii)



In [39]:

    
for jj in range(2, 5):
    print(jj)



In [40]:

    
for jj in xrange(2, 5):
    print(jj)



In [41]:

    
%%timeit 
a = 1 
for jj in range(2, 5): 
    a = a + jj









    



1000000 loops, best of 3: 461 ns per loop



In [42]:

    
%%timeit 
a = 1 
for jj in xrange(2, 5): 
    a = a + jj









    



1000000 loops, best of 3: 393 ns per loop

Funciones

Para definir nuestra propia función utilizamos la sentencia def seguida del nombre de la misma y entre paréntesis los argumentos de entrada.

La primera línea de la función puede ser una cadena de documentación.

Los valores de retorno de la función se especifican con la sentencia return.



In [43]:

    
def funcion(x, y):
    """Función de prueba."""
    return x + y



In [44]:

    
type(funcion)









    Out[44]:





function



In [45]:

    
funcion?



In [46]:

    
funcion??

Para invocar una función, le paso los parámetros entre paréntesis



In [47]:

    
funcion(1, 5)









    Out[47]:





6

Parámetros por default y parámetros por nombre



In [48]:

    
def multiplica(x, y=2.0):
    """Multiplica dos números, por defecto el primero por 2."""
    return x * y

multiplica(4, 3)









    Out[48]:





12



In [49]:

    
multiplica(4)









    Out[49]:





8.0



In [50]:

    
def eleva(x=1, p=2, debug=False):
    """Eleva un número x a la potencia p"""
    if debug:
        # Esto es un comentario
        print("elevando el numero x = " + str(x) + " usando el exponente p = " + str(p))
    return x**p

eleva(3, 5, True)









    



elevando el numero x = 3 usando el exponente p = 5






    Out[50]:





243



In [51]:

    
eleva(debug=True, p=3, x=2)









    



elevando el numero x = 2 usando el exponente p = 3






    Out[51]:





8



In [52]:

    
eleva()









    Out[52]:





1

Módulos

Uno de los conceptos más importantes en programación es el de reusar código para evitar repeticiones.

La idea es escribir funciones y clases con un proposito y extensión bien definidos, y reusarlas en lugar de repetir código similar en diferentes partes del programa (programación modular). Usualmente el resultado es que se mejora ostensiblemente la facilidad de lectura y de mantención de un programa. En la práctica, esto significa que nuestro programa tendrá menos errores, y serán más fáciles de extender y corregir.

Python permite programación modular en diferentes niveles. Las funciones y las clases son ejemplos de herramientas para programación modular de bajo nivel. Los módulos Python son construcciones de programación modular de más alto nivel, donde podemos colectar variables relacionadas, funciones y clases. Un módulo Python es definido en un archivo Python (con extensión .py), y puede ser accequible a otros módulos Python y a programas usando el comendo import.

Considere el siguiente ejemplo: el archivo mimodulo.py contiene una implementación simple de una variable, una función y una clase:



In [68]:

    
%more mimodulo.py

Para poder utilizar lo que definimos en nuestro módulo tenemos que importarlo



In [54]:

    
import mimodulo



In [55]:

    
mimodulo.mi_function()









    Out[55]:





1



In [56]:

    
help(mimodulo)









    



Help on module mimodulo:

NAME
    mimodulo

FILE
    /home/santiago/desarrollo/capacitaciones/python-para-cientificos/mimodulo.py

DESCRIPTION
    Ejemplo de un módulo Python. Contiene una variable llamada mi_variable,
    una función llamada mi_function, y una clase llamada MiClase.

CLASSES
    MiClase
    
    class MiClase
     |  Clase ejemplo.
     |  
     |  Methods defined here:
     |  
     |  __init__(self)
     |  
     |  get_variable(self)
     |  
     |  set_variable(self, nuevo_valor)
     |      Asigna self.variable a un nuevo valor

FUNCTIONS
    mi_function()
        Función ejemplo

DATA
    mi_variable = 1

Módulos de Python



In [57]:

    
import math



In [58]:

    
help(math)









    



Help on built-in module math:

NAME
    math

FILE
    (built-in)

DESCRIPTION
    This module is always available.  It provides access to the
    mathematical functions defined by the C standard.

FUNCTIONS
    acos(...)
        acos(x)
        
        Return the arc cosine (measured in radians) of x.
    
    acosh(...)
        acosh(x)
        
        Return the hyperbolic arc cosine (measured in radians) of x.
    
    asin(...)
        asin(x)
        
        Return the arc sine (measured in radians) of x.
    
    asinh(...)
        asinh(x)
        
        Return the hyperbolic arc sine (measured in radians) of x.
    
    atan(...)
        atan(x)
        
        Return the arc tangent (measured in radians) of x.
    
    atan2(...)
        atan2(y, x)
        
        Return the arc tangent (measured in radians) of y/x.
        Unlike atan(y/x), the signs of both x and y are considered.
    
    atanh(...)
        atanh(x)
        
        Return the hyperbolic arc tangent (measured in radians) of x.
    
    ceil(...)
        ceil(x)
        
        Return the ceiling of x as a float.
        This is the smallest integral value >= x.
    
    copysign(...)
        copysign(x, y)
        
        Return x with the sign of y.
    
    cos(...)
        cos(x)
        
        Return the cosine of x (measured in radians).
    
    cosh(...)
        cosh(x)
        
        Return the hyperbolic cosine of x.
    
    degrees(...)
        degrees(x)
        
        Convert angle x from radians to degrees.
    
    erf(...)
        erf(x)
        
        Error function at x.
    
    erfc(...)
        erfc(x)
        
        Complementary error function at x.
    
    exp(...)
        exp(x)
        
        Return e raised to the power of x.
    
    expm1(...)
        expm1(x)
        
        Return exp(x)-1.
        This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.
    
    fabs(...)
        fabs(x)
        
        Return the absolute value of the float x.
    
    factorial(...)
        factorial(x) -> Integral
        
        Find x!. Raise a ValueError if x is negative or non-integral.
    
    floor(...)
        floor(x)
        
        Return the floor of x as a float.
        This is the largest integral value <= x.
    
    fmod(...)
        fmod(x, y)
        
        Return fmod(x, y), according to platform C.  x % y may differ.
    
    frexp(...)
        frexp(x)
        
        Return the mantissa and exponent of x, as pair (m, e).
        m is a float and e is an int, such that x = m * 2.**e.
        If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.
    
    fsum(...)
        fsum(iterable)
        
        Return an accurate floating point sum of values in the iterable.
        Assumes IEEE-754 floating point arithmetic.
    
    gamma(...)
        gamma(x)
        
        Gamma function at x.
    
    hypot(...)
        hypot(x, y)
        
        Return the Euclidean distance, sqrt(x*x + y*y).
    
    isinf(...)
        isinf(x) -> bool
        
        Check if float x is infinite (positive or negative).
    
    isnan(...)
        isnan(x) -> bool
        
        Check if float x is not a number (NaN).
    
    ldexp(...)
        ldexp(x, i)
        
        Return x * (2**i).
    
    lgamma(...)
        lgamma(x)
        
        Natural logarithm of absolute value of Gamma function at x.
    
    log(...)
        log(x[, base])
        
        Return the logarithm of x to the given base.
        If the base not specified, returns the natural logarithm (base e) of x.
    
    log10(...)
        log10(x)
        
        Return the base 10 logarithm of x.
    
    log1p(...)
        log1p(x)
        
        Return the natural logarithm of 1+x (base e).
        The result is computed in a way which is accurate for x near zero.
    
    modf(...)
        modf(x)
        
        Return the fractional and integer parts of x.  Both results carry the sign
        of x and are floats.
    
    pow(...)
        pow(x, y)
        
        Return x**y (x to the power of y).
    
    radians(...)
        radians(x)
        
        Convert angle x from degrees to radians.
    
    sin(...)
        sin(x)
        
        Return the sine of x (measured in radians).
    
    sinh(...)
        sinh(x)
        
        Return the hyperbolic sine of x.
    
    sqrt(...)
        sqrt(x)
        
        Return the square root of x.
    
    tan(...)
        tan(x)
        
        Return the tangent of x (measured in radians).
    
    tanh(...)
        tanh(x)
        
        Return the hyperbolic tangent of x.
    
    trunc(...)
        trunc(x:Real) -> Integral
        
        Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic method.

DATA
    e = 2.718281828459045
    pi = 3.141592653589793



In [59]:

    
math?



In [60]:

    
math.e









    Out[60]:





2.718281828459045



In [61]:

    
math.cos(math.pi)









    Out[61]:





-1.0



In [62]:

    
math.factorial(25)









    Out[62]:





15511210043330985984000000L



In [63]:

    
math.log(10)









    Out[63]:





2.302585092994046



In [64]:

    
math.sqrt(9)









    Out[64]:





3.0



In [65]:

    
math.sqrt(-1)









    



---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-65-5234f21f3b4d> in <module>()
----> 1 math.sqrt(-1)

ValueError: math domain error

Links útiles

Tutorial de Python oficial (Traducido por PyAR): http://docs.python.org.ar/tutorial/pdfs/TutorialPython2.pdf
Librería Estándar de Python: https://docs.python.org/2.7/library/
Más módulos: https://pypi.python.org/pypi