En esta clase haremos una rápida introducción a la sintaxis de Python. Veremos cuáles son los tipos numéricos básicos, cómo se comportan al operar con ellos, cómo almacenarlos en variables, y tendremos nuestro primer contacto con contenedores de datos como son las listas y las tuplas.
Objetivos:
Python dispone de los tipos numéricos y las operaciones más habituales:
2 * 4 - (7 - 1) / 3 + 1.0
7.0
Las divisiones por cero lanzan un error:
1 / 0
--------------------------------------------------------------------------- ZeroDivisionError Traceback (most recent call last) <ipython-input-2-b971f1464605> in <module>() ----> 1 1 / 0 ZeroDivisionError: division by zero
1.0 / 0.0
--------------------------------------------------------------------------- ZeroDivisionError Traceback (most recent call last) <ipython-input-3-d5317764bbf2> in <module>() ----> 1 1.0 / 0.0 ZeroDivisionError: float division by zero
La división entre enteros en Python 3 devuelve un número real, al contrario que en Python 2 donde devuelve la parte entera.
7 / 3
2.3333333333333335
Se puede forzar que la división sea entera en Python 3 con el operador //
:
7 // 3
2
Se puede elevar un número a otro con el operador **
:
2 ** 16
65536
Otro tipo que nos resultará muy útil son los complejos:
2 + 3j
(2+3j)
1j
1j
# Valor absoluto
abs(2 + 3j)
3.605551275463989
abs(_7)
3.605551275463989
Podemos convertir variables a int, float, complex, str
...
int(18.6)
18
round(18.6)
19
float(1)
1.0
complex(2)
(2+0j)
str(256568)
'256568'
Podemos comprobar el tipo de una variable:
a = 2.
type(a)
float
isinstance(a, float)
True
Otras funciones útiles son:
print('hola mundo')
hola mundo
max(1,5,8,7)
8
min(-1,1,0)
-1
¡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
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:
b = 3.14159
b
3.14159
En una celda podemos escribir código que ocupe varias líneas. Si la última de ellas devuelve un resultado, este se imprimirá.
x, y = 1, 2
x, y
(1, 2)
x, y = y, x
x, y
(2, 1)
Los operadores de comparación son:
==
igual a!=
distinto de<
menor que<=
menor o igual queDevolverán un booleano: True
o False
x == y
False
print(x != y)
True
print(x < y)
print(x <= y)
print(x > y)
print(x >= y)
False False True True
# incluso:
x = 5.
6. < x < 8.
False
Si la ordenación no tiene sentido nos devolverá un error:
1 + 1j < 0 + 1j
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-29-03aab5663e43> in <module>() ----> 1 1 + 1j < 0 + 1j TypeError: '<' not supported between instances of 'complex' and 'complex'
# En las cadenas de texto sí existe un orden
'aaab' > 'ba'
False
True and False
False
not False
True
True or False
True
# Una curiosidad:
(True + True) * 10
20
# La razón...
isinstance(True, int)
True
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.
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)
[1, 2, 3.0, (4+0j), '5'] (1, 2, 3.0, (4+0j), '5') False
Para las tuplas, podemos incluso obviar los paréntesis:
tupla_sin_parentesis = 2,5,6,9,7
type(tupla_sin_parentesis)
tuple
En los dos tipos podemos:
in
:2 in una_lista
True
2 in una_tupla
True
len
:len(una_lista)
5
len(una_tupla)
5
[<inicio>:<final>:<salto>]
: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 2 [1, 2] (1, 2, 3.0) 5 (1, 2, 3.0, (4+0j), '5') [1, 3.0, '5']
Veremos más cosas acerca de indexación en NumPy, así que de momento no te preocupes. Sólo recuerda una cosa:
** Al finalizar esta lección deberías conocer los tipo básicos de datos numéricos y booleanos, saber cómo comprobar su tipo, operar con ellos y definir variables. Además hemos hecho una primera toma de contacto con contenedores de datos como son las listas y las tuplas.**
Las siguientes celdas contienen configuración del Notebook
Para visualizar y utlizar los enlaces a Twitter el notebook debe ejecutarse como seguro
File > Trusted Notebook
# preserve
# Esta celda da el estilo al notebook
from IPython.core.display import HTML
css_file = '../styles/aeropython.css'
HTML(open(css_file, "r").read())