Operators and control flow

Operators

Pythons tiene siete operadores básicos:

Operator	Name	Description
`a + b`	Suma	Suma de `a` y `b`
`a - b`	Resta	Resta of `a` y `b`
`a * b`	Multiplicación	Producto of `a` y `b`
`a / b`	División	Cociente de `a` y `b`
`a // b`	División sin resto	Cociente de `a` y `b`, sacando la fracción
`a % b`	Modulo	Resto de la división `a` por `b`
`a ** b`	Potencia	`a` a la `b` potencia
`-a`	Negación	El negativo de `a`
`+a`	Suma unaria	`a` no cambia (no sé para qué sirve)



In [1]:

    
(4 + 8) * (6.5 - 3)









    Out[1]:





42.0



In [2]:

    
# división
print(11 / 2)

5.5



In [3]:

    
# División entera, el normal en C, por ejemplo, si el tipo es int
print(11 // 2)

Ops bitwise

El punto fuerte de las compus son las operaciones sobre enteros. Y los enteros están hechos de bits, asi que hay algunas ops que son más faciles que otras. Esta es la lista de los 6 ops de Python que trabajan con enteros a nivel de bits:

Operator	Name	Description
`a & b`	Bitwise AND	Bits en ambos `a` y `b`
`a \| b`	Bitwise OR	Bits en `a` o `b` or both
`a ^ b`	Bitwise XOR	Bits en `a` o `b` pero no en ambos
`a << b`	Bit shift left	Desplaza bits de `a` a la izquierda `b` posiciones
`a >> b`	Bit shift right	Desplaza bits de `a` a la derecha `b` posiciones
`~a`	Bitwise NOT	Negación de los bits en 1 de `a`

JvdP dice que estos operadores son usados mucho menos que los de más arriba. Es cierto, sin embargo, las operaciones sobre bits son indispensables cuando hacemos zip, por ejemplo. Para ver cómo actuan estos operadores, tenemos que saber la representación binaria de los números. En Python podemos hacer eso con la función bin(), que toma un entero como argumento, así:



In [8]:

    
bin(16383)









    Out[8]:





'0b11111111111111'



In [10]:

    
2**9









    Out[10]:





512



In [20]:

    
hex(20)









    Out[20]:





'0x14'

Como ven, el resultado tiene un 0b al principio, que nos dice que el número es binario (0x, para hexa, supongo). El resto the los números indican que el número 10 se representa como la suma de $1 \cdot 2^3 + 0 \cdot 2^2 + 1 \cdot 2^1 + 0 \cdot 2^0$.



In [21]:

    
bin(4)









    Out[21]:





'0b100'



In [22]:

    
4 | 10









    Out[22]:





14



In [23]:

    
bin(4 | 10)









    Out[23]:





'0b1110'



In [24]:

    
bin(1)









    Out[24]:





'0b1'

Usualmente son ops mas rápidos que los otros (por ejemplo para potencias de 2!)



In [25]:

    
bin(1<<1)









    Out[25]:





'0b10'



In [26]:

    
bin(1<<2)









    Out[26]:





'0b100'



In [27]:

    
bin(4)









    Out[27]:





'0b100'

Ops de asignación

Ya vimos como las variables se asignan con el ops =, y los valores se guardan para usarlos despues:



In [29]:

    
a = 24
print(a)



In [37]:

    
a + 2









    Out[37]:





36



In [31]:

    
print(a)

Es decir, también podríamos querer modificar ese valor con uno nuevo sin perder el anterior.



In [38]:

    
a += 2  # equivalent to a = a + 2
print(a)

Esta clase de operación (hasta tiene nombre: acumulador) que Python tiene una lista de operadores de "actualización" (no sé si se llaman así en español... traduje literalmente), uno para cada op de los que vimos más arriba.


`a += b`	`a -= b`	`a *= b`	`a /= b`
`a //= b`	`a %= b`	`a **= b`	`a &= b`
`a \|= b`	`a ^= b`	`a <<= b`	`a >>= b`

Comparison ops

La otra "casta" de operaciones que es vital para programar es la de comparaciones: las que retornan verdadero (True) o falso (False). Los ops de comparación son listados en la siguiente tabla:

Operación	Descripción	Operación	Descripción
`a == b`	`a` igual a `b`	`a != b`	`a` diferente de `b`
`a < b`	`a` menor que `b`	`a > b`	`a` mayor que `b`
`a <= b`	`a` menor o igual a `b`	`a >= b`	`a` mayor o igual a `b`



In [39]:

    
# 25 is odd
25 % 2 == 1









    Out[39]:





True



In [40]:

    
# 66 is odd
66 % 2 == 1









    Out[40]:





False



In [41]:

    
# check if a is between 15 and 30
a = 25
15 < a < 30









    Out[41]:





True



In [42]:

    
-1 == ~0









    Out[42]:





True

Twos-complement!

Ops booleanos

Cuando trabajamos con valores booleanos (V o F), Python tiene operadores lógicos especiales para compararlos:



In [44]:

    
x = 4
(x < 6) and (x > 2)









    Out[44]:





True



In [45]:

    
(x > 10) or (x % 2 == 0)









    Out[45]:





True



In [46]:

    
not(x < 6)









    Out[46]:





False

Ops de identidad y membresía (!!)

Operator	Description
`a is b`	V si `a` y `b` son objetos idénticos
`a is not b`	V si `a` y `b` no son objetos idénticos
`a in b`	V si `a` está en `b`
`a not in b`	V si `a` no está en `b`

Ops de identidad: `is` e `is not`

Estos operadores chequean si dos objetos son los mismos. Ya se van a acordar del ejemplo de un par de clases anteriores.



In [57]:

    
a = [1, 2, 3]
b = [1, 2, 3]



In [58]:

    
a == b









    Out[58]:





True



In [59]:

    
a is b









    Out[59]:





False



In [54]:

    
a is not b









    Out[54]:





True

And this is what identical objects look like:



In [60]:

    
a = [1, 2, 3]
b = a
a is b









    Out[60]:





True

En el primer ejemplo las variables están apuntando a objetos diferentes. El op is chequea que los punteros sean los mismos. Tengan cuidado entonces cuando usan is, cuando de verdad van a querer decir ==.

Ops de membresía

Los ops de membresía buscan los valores que nos interesan en objetos complejos, por ejemplo:



In [61]:

    
1 in [1, 2, 3]









    Out[61]:





True



In [62]:

    
2 not in [1, 2, 3]









    Out[62]:





False



In [ ]:



In [ ]:



In [ ]:



In [ ]:



In [ ]:



In [ ]:



In [ ]:



In [ ]:



In [ ]:



In [ ]:



In [ ]:



In [ ]:



In [ ]:



In [ ]:



In [ ]: