Operadores¶

Definición de variable¶

Una variable es un espacio dentro de nuestro código que nos permite almacenar y acceder a ciertos datos en el momento que lo necesitemos

Los nombres de variables en Python se definen de la siguiente forma:

• Cualquier cantidad de letras (A-Z, a-z), dígitos (0-9) and el símbolo _ (guión bajo).
• Una variable no puede empezar con un dígito.
• Se sigue la norma snake_case.

Ejemplos válidos:

• fecha_matriculacion, nombre_usuario

Ejemplos no válidos:

• 1aaaa, _*?

Operador de asignación¶

Se corresponde con el símbolo =.
Sirve para asignar datos a variables.

En la actualizad, cuando definimos una variable (no siempre hay que hacerlo) aplicamos un concepto llamado Type Hint.
Este nos permite indicar qué dato debe guardar una variable concreta.

Recordemos que Python es dinámicamente tipado, por lo que en una variable podemos meter lo que queramos, el Type Hinting simplemente es una buena práctica para hacer nuestro código más legible. No obliga a que una variable tenga un dato concreto.

In [1]:

entero : int = 1
entero

entero : int = 1 entero

Out[1]:

1

In [2]:

decimal : float = 1.0
decimal

decimal : float = 1.0 decimal

Out[2]:

1.0

In [3]:

cierto : bool = True
cierto

cierto : bool = True cierto

Out[3]:

True

In [4]:

cadena_texto : str = 'cadena'
cadena_texto

cadena_texto : str = 'cadena' cadena_texto

Out[4]:

'cadena'

In [5]:

lista : list = [1, 2, '1']
lista

lista : list = [1, 2, '1'] lista

Out[5]:

[1, 2, '1']

In [6]:

tupla : tuple = (1, 2, 3)

tupla : tuple = (1, 2, 3)

In [7]:

conjunto : set = {1, 2, 3, 3, 3, 3, 3}
conjunto

conjunto : set = {1, 2, 3, 3, 3, 3, 3} conjunto

Out[7]:

{1, 2, 3}

In [8]:

diccionario : dict = {'persona' : 23}
diccionario

diccionario : dict = {'persona' : 23} diccionario

Out[8]:

{'persona': 23}

In [9]:

nada : None = None
nada

nada : None = None nada

Operadores aritméticos¶

En python existen 7 operaciones aritméticas a nuestra disposición por defecto.

Operaciones:

• Suma: +
• Resta: -
• Producto: *
• División: /
• Potencia: **
• División Entera: //
• Módulo o resto: %

Números (Int y Float)¶

In [10]:

1 + 42

1 + 42

Out[10]:

43

In [11]:

4 - 10

4 - 10

Out[11]:

-6

In [12]:

3 * 4 * 2

3 * 4 * 2

Out[12]:

24

In [13]:

6 / 2

6 / 2

Out[13]:

3.0

In [14]:

2 ** 3

2 ** 3

Out[14]:

8

In [15]:

6 // 2

6 // 2

Out[15]:

3

In [16]:

3 % 2

3 % 2

Out[16]:

1

Podemos combinarlas como queramos.
Recordemos que la prioridad es PEMDAS (Paréntesis, Exponente, Multiplicación, División, Adicion, Subtracción)

In [17]:

1 + 2 * 3 // 4

1 + 2 * 3 // 4

Out[17]:

2

In [18]:

1 + (2 * 3) // 4

1 + (2 * 3) // 4

Out[18]:

2

In [19]:

(2 + 2) * (3 + 4)

(2 + 2) * (3 + 4)

Out[19]:

28

In [20]:

2 ** 3 / 4

2 ** 3 / 4

Out[20]:

2.0

In [21]:

2 ** (3 / 4)

2 ** (3 / 4)

Out[21]:

1.681792830507429

Bool¶

In [22]:

True + True

True + True

Out[22]:

2

In [23]:

True / False

True / False

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
c:\Users\sergi\Documents\repos\python_course\tutoriales\02_operadores.ipynb Cell 33 line 1
----> <a href='vscode-notebook-cell:/c%3A/Users/sergi/Documents/repos/python_course/tutoriales/02_operadores.ipynb#X44sZmlsZQ%3D%3D?line=0'>1</a> True / False

ZeroDivisionError: division by zero

In [24]:

False * True

False * True

Out[24]:

0

Secuencias (String, List, Tuple)¶

• La suma de sencuencias concatena secuencias
• secuencia * n genera una nueva secuencia replicada n veces
• El resto de operaciones da error

In [25]:

'hola ' + 'mundo'

'hola ' + 'mundo'

Out[25]:

'hola mundo'

In [26]:

'palabra ' * 3

'palabra ' * 3

Out[26]:

'palabra palabra palabra '

In [27]:

[1] + [3]

[1] + [3]

Out[27]:

[1, 3]

In [28]:

[1] * 4

[1] * 4

Out[28]:

[1, 1, 1, 1]

In [29]:

(1, ) + ('a', (1, ))

(1, ) + ('a', (1, ))

Out[29]:

(1, 'a', (1,))

In [30]:

(1, [1, 2]) * 2

(1, [1, 2]) * 2

Out[30]:

(1, [1, 2], 1, [1, 2])

Set¶

Solo funciona la resta como diferencia asimétrica

In [31]:

{1, 2} - {1, 2, 3}

{1, 2} - {1, 2, 3}

Out[31]:

set()

In [32]:

{1, 2, 3} - {1, 2}

{1, 2, 3} - {1, 2}

Out[32]:

{3}

Dict y None¶

Da error cualquier operación

In [33]:

{ 'a' : 1 } + {'a' : 1}

{ 'a' : 1 } + {'a' : 1}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
c:\Users\sergi\Documents\repos\python_course\tutoriales\02_operadores.ipynb Cell 46 line 1
----> <a href='vscode-notebook-cell:/c%3A/Users/sergi/Documents/repos/python_course/tutoriales/02_operadores.ipynb#X63sZmlsZQ%3D%3D?line=0'>1</a> { 'a' : 1 } + {'a' : 1}

TypeError: unsupported operand type(s) for +: 'dict' and 'dict'

In [34]:

None + None

None + None

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
c:\Users\sergi\Documents\repos\python_course\tutoriales\02_operadores.ipynb Cell 47 line 1
----> <a href='vscode-notebook-cell:/c%3A/Users/sergi/Documents/repos/python_course/tutoriales/02_operadores.ipynb#X64sZmlsZQ%3D%3D?line=0'>1</a> None + None

TypeError: unsupported operand type(s) for +: 'NoneType' and 'NoneType'

Ejercicios¶

• Sumar varios números en una misma sentencia
• Combinar operadores y paréntesis para formar cálculos largos
• Usar variables y operadores

Operadores bit a bit (bitwise)¶

Lo único que entienden las computadoras son 0s y 1s.

Todo está representado en binario.

Las siguientes operaciones se realizan normalmente sobre los números enteros.

Operaciones:

• AND: &
• OR: |
• XOR: ^
• NOT: ~
• SHIFT LEFT: <<
• SHIFT RIGHT: >>

AND¶

La sintaxis es int & int.

Cuando aplicamos esta operación lo que hacemos es ejecutar bit a bit la puerta lógica AND.
Solo obtenemos 1 cuando ambos valores sean 1.

AND:

• 0 & 0 -> 0
• 0 & 1 -> 0
• 1 & 0 -> 0
• 1 & 1 -> 1

In [35]:

"""

1 = 001
2 = 010
3 = 011
4 = 100
5 = 101
6 = 110
7 = 111

2 & 5 = 010 & 101 = 000 = 0
1 & 5 = 001 & 101 = 001 = 1

"""

2 & 5, 1 & 5

""" 1 = 001 2 = 010 3 = 011 4 = 100 5 = 101 6 = 110 7 = 111 2 & 5 = 010 & 101 = 000 = 0 1 & 5 = 001 & 101 = 001 = 1 """ 2 & 5, 1 & 5

Out[35]:

(0, 1)

OR¶

La sintaxis es int | int.

Cuando aplicamos esta operación lo que hacemos es ejecutar bit a bit la puerta lógica OR.
Cuando alguno de los valores sea 1, obtenemos 1.

OR:

• 0 | 0 -> 0
• 0 | 1 -> 1
• 1 | 0 -> 1
• 1 | 1 -> 1

In [36]:

"""

1 = 001
2 = 010
3 = 011
4 = 100
5 = 101
6 = 110
7 = 111

2 | 5 = 010 | 101 = 111 = 7
1 | 5 = 001 | 101 = 101 = 5

"""

2 | 5, 1 | 5

""" 1 = 001 2 = 010 3 = 011 4 = 100 5 = 101 6 = 110 7 = 111 2 | 5 = 010 | 101 = 111 = 7 1 | 5 = 001 | 101 = 101 = 5 """ 2 | 5, 1 | 5

Out[36]:

(7, 5)

XOR¶

La sintaxis es int ^ int.

Cuando aplicamos esta operación lo que hacemos es ejecutar bit a bit la puerta lógica XOR.
Se conoce como o exclusivo porque solo obtenemos 1 cuando los valores son distintos.

XOR:

• 0 ^ 0 -> 0
• 0 ^ 1 -> 1
• 1 ^ 0 -> 1
• 1 ^ 1 -> 0

In [37]:

"""

1 = 001
2 = 010
3 = 011
4 = 100
5 = 101
6 = 110
7 = 111

2 ^ 5 = 010 ^ 101 = 111 = 7
1 ^ 5 = 001 ^ 101 = 100 = 4

"""

2 ^ 5, 1 ^ 5

""" 1 = 001 2 = 010 3 = 011 4 = 100 5 = 101 6 = 110 7 = 111 2 ^ 5 = 010 ^ 101 = 111 = 7 1 ^ 5 = 001 ^ 101 = 100 = 4 """ 2 ^ 5, 1 ^ 5

Out[37]:

(7, 4)

NOT¶

La sintaxis ~int.

Cuando aplicamos esta operación lo que hacemos es ejecutar bit a bit la puerta lógica NOT.
Lo que es 1 se hace 0 y lo que es 0 se hace 1.

NOT:

• ~0 -> 1
• ~1 -> 0

In [38]:

"""

1 = 001
2 = 010
3 = 011
4 = 100
5 = 101
6 = 110
7 = 111

~2 = ~010 = 101 = 5
~1 = ~001 = 110 = 6

"""

~0, ~1

""" 1 = 001 2 = 010 3 = 011 4 = 100 5 = 101 6 = 110 7 = 111 ~2 = ~010 = 101 = 5 ~1 = ~001 = 110 = 6 """ ~0, ~1

Out[38]:

(-1, -2)

SHIFT LEFT¶

La sintaxis int << int.

Cuando aplicamos esta operación lo que hacemos es desplazar los bit del número n veces a la izquierda.

In [39]:

"""

1 = 001
2 = 010
3 = 011
4 = 100
5 = 101
6 = 110
7 = 111

1 << 1 = 001 << 1 = 010 = 2

"""

1 << 1

""" 1 = 001 2 = 010 3 = 011 4 = 100 5 = 101 6 = 110 7 = 111 1 << 1 = 001 << 1 = 010 = 2 """ 1 << 1

Out[39]:

2

SHIFT RIGHT¶

La sintaxis int >> int.

Cuando aplicamos esta operación lo que hacemos es desplazar los bit del número n veces a la derecha.

In [40]:

"""

1 = 001
2 = 010
3 = 011
4 = 100
5 = 101
6 = 110
7 = 111

7 >> 1 = 111 >> 1 = 011 = 3

"""

7 >> 1

""" 1 = 001 2 = 010 3 = 011 4 = 100 5 = 101 6 = 110 7 = 111 7 >> 1 = 111 >> 1 = 011 = 3 """ 7 >> 1

Out[40]:

3

Ejercicios¶

• Extraer el tercer y quinto bit (a la vez) de los números 255 y 250

Operadores lógicos¶

Estas operaciones trabajan bajo el concepto de verdad y mentira. En otras palabras:

• En las operaciones aritméticas trabajamos con números y obtenemos números como resultado (Salvo en Secuencias y Sets que obtenemos Secuencias y Sets respectivamente).
• En las operaciones bit a bit trabajamos con bits y obtenemos números representados con los bits modificados como resultado.

De igual manera, en las operaciones lógicas trabajamos con Bools que representan los valores True y False y obtenemos Bools como resultado
(Salvo en el caso de AND y OR pero eso ya lo dejo como investigación para quien tenga curiosidad).

Operaciones:

• AND: and
• OR: or
• NOT: not
• IS: is
• IN: in
• EQUALS: ==
• NOT EQUALS: !=
• GREATER: >
• LESSER: <
• GREATER OR EQUALS: >=
• LESSER OR EQUALS: <=

AND¶

La sintaxis es bool and bool.

Funciona igual que vimos en las operaciones bit a bit. La diferencia es que trabajamos con bools.

AND:

• False and False -> False
• False and True -> False
• True and False -> False
• True and True -> True

In [41]:

False and False

False and False

Out[41]:

False

In [42]:

False and True

False and True

Out[42]:

False

In [43]:

True and False

True and False

Out[43]:

False

In [44]:

True and True

True and True

Out[44]:

True

OR¶

La sintaxis es bool or bool.

Funciona igual que vimos en las operaciones bit a bit. La diferencia es que trabajamos con bools.

OR:

• False or False -> False
• False or True -> True
• True or False -> True
• True or True -> True

In [45]:

False or False

False or False

Out[45]:

False

In [46]:

False or True

False or True

Out[46]:

True

In [47]:

True or False

True or False

Out[47]:

True

In [48]:

True or True

True or True

Out[48]:

True

NOT¶

La sintaxis es not bool.

Funciona igual que vimos en las operaciones bit a bit. La diferencia es que trabajamos con bools.

NOT:

• not False -> True
• not True -> False

In [49]:

not False

not False

Out[49]:

True

In [50]:

not True

not True

Out[50]:

False

IS¶

La sintaxis es data is data.

Compara si 2 datos son idénticos. Es decir, están guardados exactamente en la misma posicion de memoria.

In [51]:

[1, 2] is [1, 2]

[1, 2] is [1, 2]

Out[51]:

False

In [52]:

lista_1 : list = [1, 2]
lista_2 : list = lista_1

lista_1 is lista_2

lista_1 : list = [1, 2] lista_2 : list = lista_1 lista_1 is lista_2

Out[52]:

True

IN¶

La sintaxis es data in data.

Estudia si un dato está en otro dato que agrupe otros datos como los strings, lists, tuples, sets, and dicts.

In [53]:

'a' in 'abcdefghijklmnopqrstuvwxyz'

'a' in 'abcdefghijklmnopqrstuvwxyz'

Out[53]:

True

In [54]:

1 in [2, 3, 4]

1 in [2, 3, 4]

Out[54]:

False

En el caso de los diccionarios, se comprueba si data está entre las claves. No entre los valores.

In [55]:

'a' in {'a' : 1}

'a' in {'a' : 1}

Out[55]:

True

In [56]:

'a' in {1 : 'a'}

'a' in {1 : 'a'}

Out[56]:

False

EQUALS¶

La sintaxis es data == data.

Compara si dos variables guardan el mismo valor. No comparamos si guardan el mismo valor en la misma posicion de memoria. Estamos viendo si los valores que contienen coinciden.

In [57]:

[1, 2] == [1, 2]

[1, 2] == [1, 2]

Out[57]:

True

In [58]:

1 == 'a'

1 == 'a'

Out[58]:

False

In [59]:

1 == 1

1 == 1

Out[59]:

True

NOT EQUALS¶

La sintaxis es data != data.

Compara si dos variables no guardan el mismo valor.

In [60]:

1 != 0

1 != 0

Out[60]:

True

In [61]:

'a' != 'a'

'a' != 'a'

Out[61]:

False

GREATER¶

La sintaxis es data > data.

Compara si un dato es mayor que otro.

Nota: Se puede escribir dato1 > dato2 > dato3 en una misma sentencia.

In [62]:

1 > 2

1 > 2

Out[62]:

False

In [63]:

2 > 1

2 > 1

Out[63]:

True

LESSER¶

La sintaxis es data < data.

Compara si un dato es menor que otro.

Nota: Se puede escribir dato1 < dato2 < dato3 en una misma sentencia.

In [64]:

1 < 2

1 < 2

Out[64]:

True

In [65]:

3 < 2

3 < 2

Out[65]:

False

GREATER OR EQUALS¶

La sintaxis es data >= data.

Compara si un dato es mayor o igual que otro.

Nota: Se puede escribir dato1 >= dato2 >= dato3 en una misma sentencia.

In [66]:

1 >= -1

1 >= -1

Out[66]:

True

In [67]:

0 >= -1 >= -2

0 >= -1 >= -2

Out[67]:

True

LESSER OR EQUALS¶

La sintaxis es data <= data.

Compara si un dato es menor o igual que otro.

Nota: Se puede escribir dato1 <= dato2 <= dato3 en una misma sentencia.

In [68]:

0 <= 1 <= 10

0 <= 1 <= 10

Out[68]:

True

Extra¶

Se pueden combinar las operaciones <, >, <=, >= de la forma A >= B < C, ...

In [69]:

1 <= 2 > 0

1 <= 2 > 0

Out[69]:

True

Ejercicios¶

• Comparar números con listas
• Comparar strings entre sí
• Usa los operadores and, or y not con otros tipos de datos como listas, sets, ...