En esta clase haremos una rápida introducción a la sintaxis de Python. Veremos cuáles son los tipos y estructuras básicas de este lenguaje. Seguro que ya has oído hablar mucho sobre las bondades de Python frente a otros lenguajes. Si no es así, échale un vistazo a esto. ¿Estás preparado? ¡Pues Empezamos!
Python dispone de los tipos numéricos y las operaciones más habituales:
In [1]:
2 * 4 - (7 - 1) / 3 + 1.0
Out[1]:
Las divisiones por cero lanzan un error:
In [2]:
1 / 0
In [3]:
1.0 / 0.0
La división entre enteros en Python 3 devuelve un número real, al contrario que en Python 2.
In [4]:
3 / 2
Out[4]:
Se puede forzar que la división sea entera con el operador //:
In [5]:
3 // 2
Out[5]:
Se puede elevar un número a otro con el operador **:
In [6]:
2 ** 16
Out[6]:
Otro tipo que nos resultará muy útil son los complejos:
In [7]:
2 + 3j
Out[7]:
In [8]:
1j
Out[8]:
In [9]:
# Valor absoluto
abs(2 + 3j)
Out[9]:
In [10]:
abs(_13)
Podemos convertir variables a int, float, complex, str...
In [11]:
int(18.6)
Out[11]:
In [12]:
round(18.6)
Out[12]:
In [13]:
float(1)
Out[13]:
In [14]:
complex(2)
Out[14]:
In [15]:
str(256568)
Out[15]:
Podemos comprobar el tipo de una variable:
In [16]:
a = 2.
type(a)
Out[16]:
In [17]:
isinstance(a, float)
Out[17]:
Otras funciones útiles son:
In [18]:
print('hola mundo')
In [19]:
max(1,5,8,7)
Out[19]:
In [20]:
min(-1,1,0)
Out[20]:
¡Acabas de utilizar funciones! Como ves es una manera bastante estándar: los argumentos se encierran entre paréntesis y se separan por comas. Se hace de esta manera en otros lenguajes de programación y no requiere mayor explicación, de momento.
print es la que se usa para imprimir resultados por pantalla. Por si lo ves en algún sitio, en Python 2 era una sentencia y funcionaba de manera distinta, sin paréntesis y sin posibilidad de pasar argumentos adicionales.La asignación se realiza con el operador =. Los nombres de las variables en Python pueden contener caracteres alfanuméricos (empezando con una letra) a-z, A-Z, 0-9 y otros símbolos como la _.
Por cuestiones de estilo, las variables suelen empezar con minúscula, reservando la mayúcula para clases.
Algunos nombres no pueden ser usados porque son usados por python:
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
In [21]:
a = 1 + 2j
En Python la asignación no imprime el resultado por pantalla, al contrario de como sucede en MATLAB y Octave (salvo que se incluya el punto y coma al final). La mejor manera de visualizar la variable que acabamos de asignar es esta:
In [22]:
b = 3.14159
b
Out[22]:
En una celda podemos escribir código que ocupe varias líneas. Si la última de ellas devuelve un resultado, este se imprimirá.
In [23]:
x, y = 1, 2
x, y
Out[23]:
In [24]:
x, y = y, x
x, y
Out[24]:
Los operadores de comparación son:
== igual a!= distinto de < menor que<= menor o igual queDevolverán un booleano: True o False
In [25]:
x == y
Out[25]:
In [26]:
print(x != y)
In [27]:
print(x < y)
print(x <= y)
print(x > y)
print(x >= y)
In [28]:
# incluso:
x = 5.
6. < x < 8.
Out[28]:
Si la ordenación no tiene sentido nos devolverá un error:
In [29]:
1 + 1j < 0 + 1j
In [30]:
# En las cadenas de texto sí existe un orden
'aaab' > 'ba'
Out[30]:
In [31]:
True and False
Out[31]:
In [32]:
not False
Out[32]:
In [33]:
True or False
Out[33]:
In [34]:
# Una curiosidad:
(True + True) * 10
Out[34]:
Otro tipo de datos muy importante que vamos a usar son las secuencias: las tuplas y las listas. Ambos son conjuntos ordenados de elementos: las tuplas se demarcan con paréntesis y las listas con corchetes.
In [35]:
una_lista = [1, 2, 3.0, 4 + 0j, "5"]
una_tupla = (1, 2, 3.0, 4 + 0j, "5")
print(una_lista)
print(una_tupla)
print(una_lista == una_tupla)
Para las tuplas, podemos incluso obviar los paréntesis:
In [36]:
tupla_sin_parentesis = 2,5,6,9,7
type(tupla_sin_parentesis)
Out[36]:
En los dos tipos podemos:
in:
In [37]:
2 in una_lista
Out[37]:
In [38]:
2 in una_tupla
Out[38]:
len:
In [39]:
len(una_lista)
Out[39]:
[<inicio>:<final>:<salto>]:
In [40]:
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
Veremos más cosas acerca de indexación en NumPy, así que de momento no te preocupes. Sólo recuerda una cosa:
Podemos complicarlo un poco más y hacer cosas como una lista de listas:
In [41]:
mis_asignaturas = [
['Álgebra', 'Cálculo', 'Física'],
['Mecánica', 'Termodinámica'],
['Sólidos', 'Electrónica']
]
mis_asignaturas
Out[41]:
Esto nos será de gran ayuda en el futuro para construir arrays.
if <condition>:
<do something>
elif <condition>:
<do other thing>
else:
<do other thing>
In [42]:
print(x,y)
if x > y:
print("x es mayor que y")
print("x sigue siendo mayor que y")
In [43]:
if 1 < 0:
print("1 es menor que 0")
print("1 sigue siendo menor que 0") # <-- ¡Mal!
In [44]:
if 1 < 0:
print("1 es menor que 0")
print("1 sigue siendo menor que 0")
Si queremos añadir ramas adicionales al condicional, podemos emplear 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 [45]:
print(x,y)
if x > y:
print("x es mayor que y")
else:
print("x es menor que y")
In [46]:
print(x, y)
if x < y:
print("x es menor que y")
elif x == y:
print("x es igual a y")
else:
print("x no es ni menor ni igual que y")
En Python existen dos tipos de estructuras de control típicas:
whileforLos bucles while repetiran las sentencias anidadas en él mientras se cumpla una condición:
while <condition>:
<things to do>
Como en el caso de los condicionales, los bloques se separan por indentación sin necesidad de sentencias del tipo end
In [47]:
ii = -2
while ii < 5:
print(ii)
ii += 1
Se puede interrumpir el bucle a la mitad con la sentencia break:
In [48]:
ii = 0
while ii < 5:
print(ii)
ii += 1
if ii == 3:
break
Un bloque else justo después del bucle se ejecuta si este no ha sido interrumpido por nosotros:
In [49]:
ii = 0
while ii < 5:
print(ii)
ii += 1
if ii == 3:
break
else:
print("El bucle ha terminado")
In [50]:
ii = 0
while ii < 5:
print(ii)
ii += 1
#if ii == 3:
#break
else:
print("El bucle ha terminado")
El otro bucle en Python es el bucle for, y funciona de manera un que puede resultar chocante al principio. La idea es recorrer un conjunto de elementos:
for <element> in <iterable_object>:
<do whatever...>
In [51]:
for ii in (1,2,3,4,5):
print(ii)
In [52]:
for nombre in "Juan", "Luis", "Carlos":
print(nombre)
In [53]:
for ii in range(3):
print(ii)
In [54]:
for jj in range(2, 5):
print(jj)
La guía de estilo:
(Traducido de http://docs.python.org/3/tutorial/controlflow.html#intermezzo-coding-style)
Utilizando el módulo pep8
https://pypi.python.org/pypi/pep8
Y la extensión pep8magic
https://gist.github.com/Juanlu001/9082229/
Podemos comprobar si una celda de código cumple con las reglas del PEP8:
Hemos visto como la sintaxis de Python nos facilita escribir código legible así como aprendido algunas buenas prácticas al programar. Características como el tipado dinámico (no hace falta declarar variables) y ser lenguaje interpretado (no hace falta compilarlo) hacen que el tiempo que pasamos escrbiendo código sea menos que en otro tipo de lenguajes.
Se han presentado los tipos de variables, así como las estructuras de control básicas. En la siguiente clase practicaremos con algunos ejercicios para que te familiarices con ellas
Esperamos también que poco a poco te sientas cada vez más a gusto con el Jupyter Notebook y puedas sacarle todo el partido
Referencias