Tutorial de Python 3 para programación en oTree

David Klinowski

Documento adaptado de:

oTree's Python tutorial

Learn Python in Y minutes

Y distribuido bajo la misma licencia.

Tipos de data y operadores:
In [1]:
3
Out[1]:
3
In [2]:
1 + 1
Out[2]:
2
In [3]:
8 - 1
Out[3]:
7
In [4]:
10 * 2
Out[4]:
20

División decimal:

In [5]:
35 / 5
Out[5]:
7.0

División entera:

In [6]:
35 // 5
Out[6]:
7

Paréntesis para establecer precedencia de operaciones:

In [7]:
(1 + 3) * 2
Out[7]:
8

Datos Booleanos y operadores:

In [8]:
True and False
Out[8]:
False
In [9]:
True or False
Out[9]:
True
In [10]:
not True
Out[10]:
False
In [11]:
not False
Out[11]:
True
In [12]:
1 == 1
Out[12]:
True
In [13]:
1 == 2
Out[13]:
False
In [14]:
1 != 1
Out[14]:
False
In [15]:
1 != 2
Out[15]:
True
In [16]:
1 < 10
Out[16]:
True
In [17]:
1 > 10
Out[17]:
False
In [18]:
2 >= 2
Out[18]:
True
In [19]:
1 < 2 < 3
Out[19]:
True
In [20]:
1 < 2 > 3
Out[20]:
False

Cadenas de caracteres se crean con ' o "":

In [21]:
'Estos son caracteres.'
Out[21]:
'Estos son caracteres.'
In [22]:
"Estos también son caracteres."
Out[22]:
'Estos también son caracteres.'

Las cadenas de caracteres se pueden sumar:

In [23]:
'Hola, ' + '¿qué tal?'
Out[23]:
'Hola, ¿qué tal?'

Las cadenas de caracteres pueden ser tratadas como listas de caracteres y extraérseles elementos:

In [24]:
'Estos son caracteres.'[0]
Out[24]:
'E'

El método format permite alterar una cadena de caracteres:

In [25]:
'Un triángulo tiene {} lados'.format(3)
Out[25]:
'Un triángulo tiene 3 lados'

La instrucción para imprimir en Python es "print":

In [26]:
print('Soy Python. Mucho gusto.')

Soy Python. Mucho gusto.
Variables:

No hace falta declarar variables antes de asignarles valores:

In [27]:
mi_var = 5  # la convención de nombres de variables es todo en minúsucula y con pisos "_"
In [28]:
mi_var
Out[28]:
5

Para aumentar y disminuir variables:

In [29]:
x = 0
x
Out[29]:
0
In [30]:
x += 1
x
Out[30]:
1
In [31]:
x -= 2
x
Out[31]:
-1

Las variables tipo list manejas sequencias de datos y se definen con braquets [ ]:

In [32]:
mi_lista = []
mi_lista
Out[32]:
[]
In [33]:
otra_lista = [4, 5, 6, 5]
otra_lista
Out[33]:
[4, 5, 6, 5]

append permite añadir elementos al final de la lista:

In [34]:
mi_lista.append(1)
mi_lista
Out[34]:
[1]
In [35]:
mi_lista.append(2)
mi_lista
Out[35]:
[1, 2]
In [36]:
mi_lista.append('c')
mi_lista
Out[36]:
[1, 2, 'c']
In [37]:
mi_lista.append(4)
mi_lista
Out[37]:
[1, 2, 'c', 4]

Para acceder y asignar valores a elementos de una lista:

In [38]:
mi_lista[0]  # primer elemento
Out[38]:
1
In [39]:
mi_lista[1]  # segundo elemento
Out[39]:
2
In [40]:
mi_lista[2]  # tercer elemento
Out[40]:
'c'
In [41]:
mi_lista[3]  # cuarto elemento
Out[41]:
4
In [42]:
mi_lista[-1]  # último elemento
Out[42]:
4
In [43]:
mi_lista[0] = 'a'
mi_lista
Out[43]:
['a', 2, 'c', 4]

Para acceder a una porción de una lista:

In [44]:
mi_lista[0:2]  # primeros dos elementos
Out[44]:
['a', 2]
In [45]:
mi_lista[0:3]  # primeros tres elementos
Out[45]:
['a', 2, 'c']
In [46]:
mi_lista[1:]  # del segundo al último elemento
Out[46]:
[2, 'c', 4]

Añadir una lista a otra:

In [47]:
mi_lista + otra_lista
Out[47]:
['a', 2, 'c', 4, 4, 5, 6, 5]

El operador in permite evaluar la existencia de un elemento en una lista:

In [48]:
1 in mi_lista
Out[48]:
False
In [49]:
'c' in mi_lista
Out[49]:
True

La función len() permite obtener el tamaño de una lista:

In [50]:
len(mi_lista)
Out[50]:
4

Las variables tipo dict manejan mapeos entre llaves y valores, y se definen con {'llave' : valor}:

In [51]:
mi_dict = {}
mi_dict
Out[51]:
{}
In [52]:
patas_dict = {'perro': 4, 'araña': 8, 'pez': 0}
patas_dict
Out[52]:
{'araña': 8, 'perro': 4, 'pez': 0}

Para acceder al valor de una llave:

In [53]:
patas_dict['perro']
Out[53]:
4

Para evaluar la existencia de una llave en un dict:

In [54]:
'araña' in patas_dict
Out[54]:
True
In [55]:
'gato' in patas_dict
Out[55]:
False
In [56]:
8 in patas_dict
Out[56]:
False

Para agregar un nuevo elemento a un dict:

In [57]:
patas_dict['gato'] = 4
patas_dict
Out[57]:
{'araña': 8, 'gato': 4, 'perro': 4, 'pez': 0}
Estructuras de control

Nota: Las estructuras en Python deben estar correctamente espaciadas del margen izquierdo para que funcionen.

In [58]:
x = 5

if x > 10:
    print('La variable es mayor que 10.')
elif x == 10:
    print('La variable es igual a 10.')
else:
    print('La variable es menor que 10.')

La variable es menor que 10.
In [59]:
for animal in ['lobo', 'perro', 'gato']:
    print('El {} tiene patas.'.format(animal))

El lobo tiene patas.
El perro tiene patas.
El gato tiene patas.
Funciones

Las funciones se definen de antemano y no se ejecutan hasta ser llamadas más adelante.

Para definir una función:

In [60]:
def sumar(x, y):
    print('El primer número es {} y el segundo número es {}'.format(x, y))
    return x + y

Para llamar una función:

In [61]:
sumar(5, 4)

El primer número es 5 y el segundo número es 4
Out[61]:
9
Clases

Las clases permiten crear objetos con variables y funciones ya definidas.

Para crear una clase con una variable y una función:

In [62]:
class Cuadrupedo:
    patas = 4
    
    def explicar_locomocion(self):
        print('El cuadrúpedo se desplaza por la tierra.')

Para crear un objeto que pertenezca a la clase:

In [63]:
perro = Cuadrupedo()

Para acceder a una variable de un objeto:

In [64]:
perro.patas
Out[64]:
4

Para acceder a una función de un objeto:

In [65]:
perro.explicar_locomocion()

El cuadrúpedo se desplaza por la tierra.

Para asignar un valor a una variable de un objeto:

In [66]:
perro.patas = 2
perro.patas
Out[66]:
2

Para crear una clase ("sibling") que hereda las variables y definiciones de otra ("parent"):

In [67]:
class Peludo(Cuadrupedo):
    tiene_pelaje = True
In [68]:
gato = Peludo()
In [69]:
gato.tiene_pelaje
Out[69]:
True
In [70]:
gato.patas
Out[70]:
4