05 - Curso de Python - Operadores aritmeticos y de cadenas

De ChuWiki


Cualquier duda suelo atender en este foro de python

Todo el código de este curso de Python gratuito está en github https://github.com/chuidiang/chuidiang-ejemplos/tree/master/PYTHON/curso-python. Puedes usar línea comandos python para ir siguiendo los ejemplos.

Anterior: 04 - Curso de Python - Condicionales y bucles en Python -- Índice: Curso de Python -- Siguiente: 07 - Curso de Python - Funciones.

Qué es un operador en python[editar]

Los operadores en python son los símbolos que nos permiten sumar, multiplicar y en general hacer cualquier operación con variables que tengan dentro tipos como números, letras o booleanos.

En Python están definidos los siguientes operadores

+       -       *       **      /       //      %      @
<<      >>      &       |       ^       ~       :=
<       >       <=      >=      ==      !=

No todos valen para todos los tipos, vamos a ir explicando y viendo ejemplos de ellos.

Operadores Aritméticos[editar]

Hay cuatro opreadores que no necesitan demasiada explicación: suma +, resta -, multiplicación * y división /. Ahí van ejemplos

>>> 7+3
10
>>> 7-3
4
>>> 8*2
16
>>> 8/2
4.0

Fijate un detalle. La suma, resta y multiplicación de enteros, da un entero. Sin embargo la división da un floatante (número con decimales). El motivo es que la división de dos números enteros, puede dar decimales.

>>> 1/3
0.3333333333333333

Una operación no válida, como dividir por 0, da error.

>>> 1/0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

También hay otro detalle importante a tener en cuenta, si sumas operas números de distintos tipos, como enteros, flotantes o complejos, el resultado se obtiene en el tipo que más detalle da.

>> 1+1.1
2.1
>>> 1 + 1-3j
(2-3j)
>>> 1.2 + 1-3j
(2.2-3j)

Ves que suma de entero y flotante da flotante. Y suma de entero o flotante con cnúmero complejo, da número complejo.

Vamos con los operadores resto de división o módulo %, potencia ** y división entera //

El resto de división o módulo % nos da el resto de dividir uno con otro

>>> 67%2
1

Suele ser bastante útil, por ejemplo, para saber si un número es par o impar. En el primer caso, la división devuelve de resto 0 y en el segundo caso devuelve resto 1. Funciona también con flotantes, pero da error con complejos.

La potencia ** sirve para elevar un número al otro, es decir, multiplicar un número consigo mismo tantas veces como diga el otro. Funciona con enteros, flotantes y complejos.

>>> 2**10
1024

La división entera // nos da el cociente de la división, sin decimales. Funciona con enteros y flotantes, pero no complejos.

>>> 7//2
3
>>> 7.3//2.1
3.0

Hay veces que queremos sumar a una variable un número, por ejemplo

>>> a = 4
>>> a = a+1
>>> a
5

Python permite una sintaxis abreviada, en vez de a = a+1 podemos poner a += 1, es decir, a += se interpreta como a = a +. Esto es válido para el resto de operadores.

>>> a=8
>>> a*=2
>>> a
16

El operador @ se utiliza para la multiplicación de matrices, pero python no tiene por defecto un tipo matriz. Existen módulos adicionales de python que se pueden importar y entonces sí tendríamos disponibilidad de hacer operaciones con matrices. No lo explicamos aquí, porque tendríamos que liarnos a explicar los módulos e importación de los mismos en python, tema que se deja para más adelante.

Como curiosidad adicional, True es equivalente a 1 y False es equivalente a 0, así que podemos hacer cosas como esta

>>> True + True
2

>>> True/True
1.0

>>> True/False
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

Operadores Booelanos[editar]

Los operadores booleanos son los que devuelven un booleano (True o False o los que nos permiten operador con booleanos. Los primeros ya los vimos en Condiciones, así que no los repetiremos aquí. Nos faltan, sin embargo, los operadores que permiten hacer operciones AND, OR, NOT y XOR.

Por un lador, tenemos los operadores &, |, ^ que hacen un AND, un OR y un OR exclusivo de bits. Se pueden usar con enteros y harán operaciones bit a bit de los valores de los enteros. Esto lo vemos en el siguiente apartado. Sin embargo, también funcionan con Booleanos para hacer las mismas operaciones

>>> True & False
False
>>> True | False
True
>>> True ^ False
True
>>> True ^ True
False

No tenemos de esta forma el operador NOT. Otra alternativa es usar las palabras and, or, not, pero nos faltaría el OR exclusivo

>>> True and False
False
>>> True or False
True
>>> not True
False

Operadores de bits[editar]

Los enteros tienen una representación binaria en la variable. Por ejemplo, un 1 es un 1, un 2 es un 10, un 3 es un 11, un 4 es un 100 y así sucesivamente. Los operadores de bits manejan estos bits que representan los enteros. Por ejemplo, si hacemos un and & de 1 y de 2, que en binario es 01 y 10, obtendremos 00. Si hacemos un OR |, obtendremos 11 (un 3) y si hacemos un OR exclusivo, obtendremos también 11 (un 3)

# 01 & 10 -> 00
>>> 1 & 2
0

# 01 | 10 -> 11
>>> 1 | 2
3

# 01 ^ 10 -> 11
>>> 1 ^ 2
3

También podemos desplazar los bits a izquierda o derecha con los operadores << y >> respectivamnente. Por ejemplo, un 2 en binario es 10. Si lo desplazamos a la izquierda una posición, se añadirán un cero por el lado derecho. Es decir 10 << 1, daría 100, es decir, un 4. Desplazar a la izquierda una posición es equivalente, en binario, a multiplicar por 10, es decir, por 2 en decimal.

>>> 4 << 1
8
>>> 10 << 1
20

De la misma forma, podemos desplazar a la derecha, perdiendo la últimca cifra binaria. Si desplazamos una posición el 3, que en binario es 11, obtendremos en binario un 1, perdiendo el 1 de la derecha del todo. El resultado decimal es 1. Desplazar a la derecha es equivalente a dividir entre 2, quedándonos la parte entera de la división

>>> 4 >> 1
2
>>> 5 >> 1
2
>>> 6 >> 1
3

Estas operaciones de bits no suelen ser muy útiles en general, pero si cobran importancia si estamos leyendo datos, principalmente de equipos hardware pequeños, que suelen entregar datos usando bits. Va un pequeño ejemplo que puedes saltarte si ves que es muy liado. Basta de momento con que te quedes que existe esta posibilidad, manipular los bits de un entero.

Como acabamos de comentar, estas operaciones de bits con enteros suelen ser útiles cuando cada bit del entero significa una cosa. Por ejemplo, imagina un sistema hardware que tiene ocho tipos de fallos y te los devuelve en un entero de 8 bits. El primer bit a 1 es que hay el fallo pepito en el sistema, si esta a 0 es que no lo hay, el siguiente bit significa otro tipo de fallo, etc. Imagina, por ejemplo, que nos devuelve los siguientes fallos 001010000, es decir, hay dos fallos representados por dos bits. ¿Como podemos analizar esto desde codigo?. Pues lo más fácil es usar estos operadores de bits.

>>> fallos = 0b001010000
>>> fallos
80

Si escribes un número con 0b delante, python entiende que está en binario. Hemos puesto el error en binario y vemos que la variable vale 80, es decir, el valor en decimal correspondiente a ese número binario. ¿Como vemos si el sexto bit empeznado a contar por la derecha está a 1 o 0?. La operación & nos lo dice fácilmente

>>> fallos = 0b001010000
>>> fallos
80
>>> fallos & 0b001000000
64
>>> sin_fallos = 0b00000000
>>> sin_fallos & 0b001000000
0

Si hacemos un and, bit a bit, con un binario que solo tenga a 1 el bit que nos interesa investigar, obtendremos 0 si ese bit no está levantado en las alarmas y un número distinto de cero si está levantado en las alarmas.

Operaciones con cadenas[editar]

Las cadenas de texto además de los operadores suelen tener muchas funciones útiles. Veamos operadores primero, luego vamos con algunas funciones útiles

La suma de dos cadenas devuelve las dos cadenas una detrás de otra

>>> 'hola ' + 'mundo'
'hola mundo'

Si la multiplicamos por un numero N, se repite N veces

>>> 'hola '*3
'hola hola hola '

Como vimos en [03 - Curso de Python - Listas Tuplas y Diccionarios en Python#Acceso a los elementos de la lista|Acceso a los elementos de la lista]], se pueden obtener los caracteres que nos interesen dentro de la cadena usando su posición, empezando por 0

>>> 'hola'[1]
'o'
>>> 'hola'[:2]
'ho'
>>> 'hola'[2:']
>>> 'hola'[2:]
'la'
>>> 'hola'[1:3]
'ol'

La cadena es inmutable, esto quiere decir que no podemos cambair un caracter haciendo esto

>>> a = 'hola'
>>> a[1] = 'p'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

La función len() nos dice cuantos caracteres tiene una cadena

>>> len('hola')
4

Podemos convertir cualquier otro tipo de dato a cadena usando la función str(). Por ejemplo, sumar cadena más número da error, por lo que es necesario convertir primero el número a cadena

>>> 'hola' + 5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

>>> 'hola' + str(5)
'hola5'

Podemos ver si un caracter o un trozo de cadena está en la cadena con in o si no está con not in

>>> 'a' in 'hola'
True
>>> 'b' not in 'hola'
True
>>> 'ho' in 'hola'
True
>>> 'oh' in 'hola'
False

La función count() nos indica cuantas veces aparece un caracter o secuencia de caracteres en la cadena

>>> 'hola hola'.count('h')
2

>>> 'hola hola'.count('ol')
2

La función index() nos indica la posición de un caracter o secuencia en la cadena. Admite un segundo parámetro para que empiece a buscar no desde el principio, sino desde done le digamos, pudiendo así encontrar otras posiciones si está repetido

>>> 'hola hola'.index('o')
1
>>> 'hola hola'.index('o',2)
6

La función replace() permite obtener una nueva cadena en la que se ha reemplado un trozo de cadena por otra cosa. En el siguiente ejemplo ponemos en mayúscula la h de hola.

>>> 'hola'.replace('h','H')
'Hola'

La función strip() elimina todos los espacios en blanco que haya al principio o final de la cadena. Si se le pasa como parámtro una cadena con caracteres, eliminará esos caracteres en vez de los espacios si están al principio o final de la cadena.

# Elimina espacios delante y detrás de la cadena.
>>> ' hola '.strip()
'hola'

# Elimina haches y oes al principio y final de la cadena. Como hay espacios y no se lo hemos dicho, no elimina nada.
>>> ' hola '.strip('ho')
' hola '

# Repetimos, haches, oes y espacios.
>>> ' hola '.strip('ho ')
'la'

Las funciones upper() y lower() convierten la cadena a mayúsculas o minúsculas respectivamente

>>> 'hola'.upper()
'HOLA'
>>> 'Hola'.lower()
'hola'

Las funciones isupper() e islower() devuelve si la cadena ya esá totalmente convertida a mayúsculas o a minúsculas.

>>> 'Hola'.isupper()
False
>>> 'hola'.islower()
True

La función split() permite separar una cadena en trozos usando algún separador. Comentamos los ejemplos en el mismo trozo de código

# Si no se pone parametro, por defecto, separa por espacios
# Aqui separa por espacios y devuelve una lista [] con cuatro elementos.
>>> '1 2 3 4'.split()
['1', '2', '3', '4']
# Aqui como no hay espacios, no separa nada, devuelve una lista [] con un único elemento que es
# la cadena completa
>>> '1,2,3,4'.split()
['1,2,3,4']

# Si ponemos un caracter o cadena como parámetro, separa por ese caracter o cadena
>>> '1,2,3,4'.split(',')
['1', '2', '3', '4']

# Si el separador esta repetido varias veces seguidas, devuelve cadenas vacías.
>>> '1,2,3,,,,4'.split(',')
['1', '2', '3', '', '', '', '4']
# Curiosamente, esto no pasa con los espacios y la opción por defecto.
>>> '1 2 3   4'.split()
['1', '2', '3', '4']
# Debemos poner explicitamente un separados espacio si queremos que nos de cadenas vacias.
>>> '1 2 3   4'.split(' ')
['1', '2', '3', '', '', '4']

# Podemos indicar cuantos items separados queremos, aquí decimos dos, así que nos separa dos
# itemas, el 1 y el 2, y nos devuelve el resto como un único tercer item.
>>> '1,2,3,,,,4'.split(',',2)
['1', '2', '3,,,,4']

Podemos comparar cadenas alfabéticamente con los operadores <, <=, >, >=, ==, !=-

>>> # Tres nombres, uno repetido pero con mayúscula al principio.
>>> nombre1='juan'
>>> nombre2='Juan'
>>> nombre3='pedro'

>>> # No son iguales, distingue mayúsculas y minúsculas
>>> nombre1 == nombre2
False

>>> # La minúscula es mayor que la mayúscula, es decir, va detrás alfabéticamente
>>> # Esto no tiene sentido en la vida real, pero si a nivel de bytes, hay que
>>> # tenerlo en cuenta.
>>> nombre1 > nombre2
True

# una cadena no es mayor que sí misma.
>>> nombre1 > nombre1
False

# pero si es mayor o igual a sí misma.
>>> nombre1 >= nombre1
True

# La minúscula no va alfabéticamente antes que la mayúscula.
>>> nombre1 < nombre2
False

# juan va antes alfabéticamente que pedro.
>>> nombre1 <=nombre3
True

# juan y Juan no son iguales, distingue la mayúscula y la minúscula
>>> nombre1 != nombre2
True

Anterior: 04 - Curso de Python - Condicionales y bucles en Python -- Índice: Curso de Python -- Siguiente: 07 - Curso de Python - Funciones.