1/12/2015 Operaciones aritméticas elementales. Python.

 Bartolomé Sintes Marco

Operaciones aritméticas elementales
En esta lección se tratan las operaciones aritméticas elementales en Python.
Variables numéricas enteras y decimales
Las cuatro operaciones básicas
La división en Python
Cociente de una división
Resto de una división
Potencias y raíces
Asignaciones aumentadas
Redondear un número
La función round()
Redondear al entero anterior o posterior
Representación de números decimales en binario

Variables numéricas enteras y decimales
Existen dos tipos de variables numéricas: enteras (sin decimales) y decimales (con decimales). Según
cómo  se  escriba  el  número,  Python  lo  asignará  a  una  variable  entera  o  decimal.  En  el  ejemplo
siguiente, la variable a será de tipo entero, mientras que la variable b será de tipo decimal:

>>> a = 3
>>> b = 4.5

Al hacer operaciones en las que intervienen números decimales, el resultado es decimal. En el caso
de que el resultado no tenga parte decimal, Python escribe 0 como parte decimal para que seamos
conscientes de que el resultado es un número decimal:

>>> 3 * 3
9
>>> 4.5 * 3
13.5
>>> 4.5 * 2
9.0

De la misma manera, si escribimos 0 como parte decimal Python considera el número como decimal.

>>> 3 * 3.0
9.0

Así, en el ejemplo siguiente, la variable a es de tipo entero, mientras que b es de tipo decimal, aunque
el valor sea el mismo:

>>> a = 3
>>> b = 3.0

Al  hacer  operaciones  en  las  que  intervienen  números  enteros,  el  resultado  es  entero,  salvo  que  el
resultado  pueda  dar  en  general  decimales,  en  cuyo  caso  el  resultado  es  decimal.  Por  ejemplo,  la
división entre enteros puede ser decimal, por lo que la división entre enteros siempre es decimal.

>>> 9 * 3
http://www.mclibre.org/consultar/python/lecciones/python_operaciones_matematicas.html 1/8
1/12/2015 Operaciones aritméticas elementales. Python. Bartolomé Sintes Marco

27
>>> 9 / 3
3.0

Nota:
En las versones 2.X de Python, el resultado de la división de dos números enteros era también
un  número  entero  (el  cociente  de  la  división  entre  esos  dos  números),  lo  que  podía  producir
resultados no esperados, como se comenta en la sección de diferencias entre Python 2 y Python
3.

Al realizar operaciones con decimales, los resultados pueden presentar errores de redondeo:

>>> distancia = 100.0
>>> tiempo = 3.0
>>> distancia / tiempo
33.333333333333336

Este  error,  que  se  comenta  con  más  detalles  más  adelante  en  esta  lección,  se  debe  a  que  Python
almacena los números decimales en binario y lo que provoca errores de redondeo al pasar de decimal
a  binario  y  viceversa.  Es  un  error  que  sufren  casi  todos  los  lenguajes  de  programación.  Si
necesitamos precisión absoluta, hay formas de resolver el problema utilizando bibliotecas específicas.

Las cuatro operaciones básicas
Las  cuatro  operaciones  aritméticas  básicas  son  la  suma  (+),  la  resta  (­),  la  multiplicación  (*)  y  la
división  (/).  Cuando  en  una  fórmula  aparecen  varias  operaciones,  Python  las  efectúa  aplicando  las
reglas usuales de prioridad de las operaciones. En caso de querer que las operaciones se realicen en
otro orden, se pueden utilizar paréntesis.

La división en Python
Al dividir dos números enteros en Python 3, el resultado es un número decimal:

>>> distancia = 100
>>> tiempo = 4
>>> distancia / tiempo
25.0

Nota:
En las versones 2.X de Python, el resultado de la división de dos números enteros era también
un  número  entero:  el  cociente  de  la  división  entre  esos  dos  números,  lo  que  podía  producir
resultados no esperados, como se comenta en la sección de diferencias entre Python 2 y Python
3.

Cociente de una división

El  cociente  de  una  división  se  calcula  con  el  operador  //.  El  resultado  será  de  tipo  entero  o  decimal
dependiendo del tipo de los números empleados (pero en caso de ser decimal, la parte decimal será
cero). Por ejemplo:

>>> 10 // 3

http://www.mclibre.org/consultar/python/lecciones/python_operaciones_matematicas.html 2/8
1/12/2015 Operaciones aritméticas elementales. Python. Bartolomé Sintes Marco

3
>>> 10 // 4
2
>>> 20.0 // 7
2.0
>>> 20 // 6.0
3.0

El  operador  cociente  //  tiene  la  misma  prioridad  que  las  cuatro  operaciones  básicas  (suma,  resta,
multiplicación, división):

>>> 26 // 5 / 2
2.5
>>> (26//5) / 2
2.5
>>> 26 // (5/2)
10.0

Resto de una división

El resto de una división se calcula con el operador %. Por ejemplo:

>>> 10 % 3
1
>>> 10 % 4
2
>>> 10 % 5
0

Se  puede  calcular  el  resto  de  una  división  entre  números  decimales,  pero  pueden  aparecer  los
problemas de redondeo comentados anteriormente.

>>> 10.2 % 3
1.1999999999999993 # El resultado correcto es 1.2
>>> 10 % 4.2
1.5999999999999996 # El resultado correcto es 1.6
>>> 10.1 % 5.1
5.0                # Este resultado coincide con el resultado correcto

El  operador  resto  %  tiene  la  misma  prioridad  que  las  cuatro  operaciones  básicas  (suma,  resta,
multiplicación, división):

>>> 26 % 5 / 2
0.5
>>> (26%5) / 2
0.5
>>> 26 % (5/2)
1.0

Potencias y raíces

http://www.mclibre.org/consultar/python/lecciones/python_operaciones_matematicas.html 3/8
1/12/2015 Operaciones aritméticas elementales. Python. Bartolomé Sintes Marco

Las potencias se calculan con el operador **, teniendo en cuenta que x**y = xy . Utilizando exponentes
negativos o decimales se pueden calcular potencias inversas o raíces n­ésimas. Por ejemplo

>>> 2 ** 3
8
>>> 10 ** ‐4
0.0001           # Recuerde que a‐b= 1/ab
>>> 9 ** 0.5
3.0              # Recuerde que a1/b es la raíz b‐ésima de a
>>> (‐1) ** 0.5  # Esto va a dar error porque es la raíz cuadrada de ‐1
Traceback (most recent call last):
  File "<pyshell#7>", line 1, in ?
    (‐1)**0.5 ValueError: negative number cannot be raised to a fractional power
>>> ‐9 ** 0.5    # Esto no da error porque hace primero la raíz y luego le pone el ‐
‐3

También  se  pueden  calcular  potencias  o  raíces  mediante  la  función  pow(x,y).  Si  se  da  un  tercer
argumento,  pow(x,  y,  z),  la  función  calcula  primero  x  elevado  a  y  y  después  calcula  el  resto  de  la
división por z.

>>> pow(2, 3)
8
>>> pow(4, 0.5)
2.0
>>> pow(2, 3, 5)
3

Asignaciones aumentadas
Cuando  una  variabe  se  modifica  a  partir  de  su  propio  valor,  se  puede  utilizar  la  denominada
"asignación  aumentada",  una  notación  compacta  que  existe  también  en  otros  lenguajes  de
programación.
Nota:
Por ejemplo:

>>> a = 10
>>> a += 5
>>> a
15

es equivalente a:

>>> a = 10
>>> a = a + 5
>>> a
15

En general:
Asignación aumentada: a += b a ­= b a *= b a /= b a **= b a //= b a %= b
es equivalente a: a = a + b a = a ­ b a = a * b a = a / b a = a ** b a = a // b a = a % b
http://www.mclibre.org/consultar/python/lecciones/python_operaciones_matematicas.html 4/8
1/12/2015 Operaciones aritméticas elementales. Python. Bartolomé Sintes Marco

Nota:  Las  dos  notaciones  son  completamente  equivalentes  en  el  caso  de  los  objetos  inmutables
(números, cadenas, tuplas), pero en el caso de los objetos mutables (listas, diccionarios, etc.) hay un
pequeña diferencia que se comenta en la lección Variables 2
Lo que no se permite en Python son los operadores incremento (++) o decremento (­­) que sí existen
en otros lenguajes de programación:

>>> a = 5
>>> a++
SyntaxError: invalid syntax

Redondear un número
Aunque  no  se  puede  dar  una  regla  válida  en  todas  las  situaciones,  normalmente  es  conveniente
redondear  el  resultado  de  un  cálculo  cuando  se  muestra  al  usuario,  sobre  todo  si  tiene  muchos
decimales, para facilitar su lectura.
Lo  que  no  se  debe  hacer  nunca  es  redondear  resultados  intermedios  que  se  vayan  a  utilizar  en
cálculos posteriores, porque el resultado final será diferente.

La función round()

Para  redondear  un  número  (por  ejemplo,  cuando  se  muestra  al  usuario  el  resultado  final  de  un
cálculo),  se  puede  utilizar  la  función  round().  La  función  round()  admite  uno  o  dos  argumentos
numéricos.
Si sólo hay un argumento, la función devuelve el argumento redondeado al entero más próximo:

>>> round(4.35)
4
>>> round(4.62)
5
>>> round(‐4.35)
‐4
>>> round(‐4.62)
‐5    

Si  se  escriben  dos  argumentos,  siendo  el  segundo  un  número  entero,  la  función  round()
devuelve el argumento redondeado en la posición decimal indicada por el segundo argumento.

>>> round(4.3527, 2)
4.35
>>> round(4.3527, 1)
4.4
>>> round(4.3527, 3)
4.353    

Si  el  segundo  argumento  es  0,  se  redondea  como  si  sólo  hubiera  un  argumento,  pero  la
diferencia es que el resultado es decimal y no entero.

>>> round(4.3527, 0)
4.0    

Si el segundo argumento es negativo, se redondea a decenas, centenas, etc.
http://www.mclibre.org/consultar/python/lecciones/python_operaciones_matematicas.html 5/8
1/12/2015 Operaciones aritméticas elementales. Python. Bartolomé Sintes Marco

>>> round(43527, ‐2)
43500
>>> round(43527, ‐1)
43530
>>> round(43527, ‐3)
44000    

En  general,  la  función  round()  redondea  correctamente  al  número  más  próximo  del  orden  de
magnitud  deseado  (entero,  décimas,  decenas,  centésimas,  centenas,  etc).  El  problema  es
cuando el número a redondear está justo enmedio (por ejemplo, redondear 3.5 a entero, 4.85 a
décimas,  etc.).  En  Matemáticas  se  suele  redondear  siempre  hacia  arriba,  pero  en  Python  se
sigue otro criterio:
Cuando se redondea a enteros, decenas, centenas, etc., Python redondea de manera que
la última cifra (la redondeada) sea par.

>>> round(3.5)
4
>>> round(4.5)
4
>>> round(5.5)
6
>>> round(6.5)
6        

>>> round(450, ‐2)
400
>>> round(350, ‐2)
400
>>> round(250, ‐2)
200
>>> round(150, ‐2)
200
>>> round(50, ‐2)
0

Cuando  se  redondea  a  décimas,  centésimas,  etc.,  Python  redondea  en  unos casos para
arriba y en otros para abajo:

>>> round(3.15, 1)
3.1
>>> round(3.25, 1)
3.2
>>> round(3.35, 1)
3.4
>>> round(3.45, 1)
3.5
>>> round(3.55, 1)
3.5
>>> round(3.65, 1)
3.6        

>>> round(0.315, 2)
http://www.mclibre.org/consultar/python/lecciones/python_operaciones_matematicas.html 6/8
1/12/2015 Operaciones aritméticas elementales. Python. Bartolomé Sintes Marco

0.32
>>> round(0.325, 2)
0.33
>>> round(0.335, 2)
0.34
>>> round(0.345, 2)
0.34
>>> round(0.355, 2)
0.35
>>> round(0.365, 2)
0.36        

Este  redondeo  se  debe  a  la  forma  en  que  Python  representa  internamente  los  números
decimales. Es un problema que presentan la mayoría de lenguajes de programación y se
explica en el apartado siguiente.

Redondear al entero anterior o posterior

Para  redondear  un  número  al  entero  anterior  o  posterior,  se  pueden  utilizar  la  funciones  floor()  and
ceil(), que están incluidas en la biblioteca math. Estas funciones sólo admiten un argumento numérico
y devuelven valores enteros.
Antes de utilizar estas funciones, hay que importarlas, o se generará un error.

>>> floor(5 / 2)
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    floor(5 / 2)
NameError: name 'floor' is not defined
>>> ceil(5 / 2)
Traceback (most recent call last):
  File "<pyshell#0>", line 2, in <module>
    ceil(5 / 2)
NameError: name 'ceil' is not defined

>>> from math import floor
>>> floor(5 / 2)
2
>>> from math import ceil
>>> ceil(5 / 2)
3

Representación de números decimales en binario
En Pyhton los números decimales se almacenan internamente en binario con 53 bits de precisión (en
concreto, se trata del formato de coma flotante de doble precisión de la norma IEEE­754). Cuando un
programa  pide  a  Python  un  cálculo  con  números  decimales,  Python  convierte  esos  números
decimales a binario, realiza la operación en binario y convierte el resultado de nuevo en decimal para
mostrarselo al usuario.
El  problema  es  que  muchos  números  decimales  no  se  pueden  representarse  de  forma  exacta  en
binario, por lo que los resultados no pueden ser exactos. Eso explica, por ejemplo, los resultados del
http://www.mclibre.org/consultar/python/lecciones/python_operaciones_matematicas.html 7/8
1/12/2015 Operaciones aritméticas elementales. Python. Bartolomé Sintes Marco

ejemplo anterior:

>>> round(3.45, 1)
3.5
>>> round(3.55, 1)
3.5        

En  el  primer  ejemplo,  al  convertir  3.45  a  binario  con  53  bits  de  precisión,  el  valor  obtenido  es
realmente  3.45000000000000017763568394002504646778106689453125,  es  decir,  ligeramente
mayor que 3.45, por lo que al redondear con décimas, Python muestra el valor 3.5.
En  el  segundo  ejemplo,  al  convertir  3.55  a  binario  con  53  bits  de  precisión,  el  valor  obtenido  es
realmente  3.54999999999999982236431605997495353221893310546875,  es  decir,  ligeramente
inferior que 3.55, por lo que al redondear con décimas, Python muestra también el valor 3.5.
Nota:
Para ver el valor que se obtiene al convertir un número decimal a binario se puede utilizar el tipo
Decimal de la biblioteca decimal:

>>> from decimal import Decimal
>>> Decimal(3.45)
Decimal('3.45000000000000017763568394002504646778106689453125')
>>> Decimal(3.55)
Decimal('3.54999999999999982236431605997495353221893310546875')

El problema del redondeo se agudiza cuando se hacen operaciones, puesto que los errores pueden
acumularse (aunque a veces se compensan y pasan desapercibidos).
En algunos casos extremos, el error es apreciable en cálculos muy sencillos:

>>> 0.1 + 0.1 + 0.1
0.30000000000000004

En  la  mayoría  de  situaciones,  estos  errores  no  tienen  consecuencias  importantes  en  los  resultados
finales,  pero  si  en  una  aplicación  concreta  se  necesita  total  exactitud,  se  deben  utilizar  bibliotecas
específicas.  Python  incluye  la  biblioteca  decimal  y  existen  bibliotecas  como  mpmath  que  admiten
precisión arbitraria.

Para saber más:
IEEE­754 precisión simple, precisión doble (Wikipedia en inglés)
Manual de Python 3: limitaciones de los decimales en Python
Artículo The perils of Floating Point, de Bruce M. Bush
Arítculo What Every Computer Scientist Should Know About Floating­Point Arithmetic, de David
Goldberg

Cosas que faltan: abs(x); complex(real[, imag]); max(s[, args...]); min(s[, args...]);

Última modificación de esta página: 1 de febrero de 2015

Introducción a la programación con Python por Bartolomé Sintes Marco
se distribuye bajo una Licencia Creative Commons Reconocimiento­CompartirIgual 4.0 Internacional
(CC BY­SA 4.0).

http://www.mclibre.org/consultar/python/lecciones/python_operaciones_matematicas.html 8/8