PDF de programación - ['Python'] * 40 - Cuarenta características de Python que quizás no conoces

["Python"] * 40

Cuarenta características de Python que quizás no conoces
Víctor Terrón — http://github.com/vterron

Introducción

Unknown Unknowns

unknowns. That is to say there are things that we now know we

don’t know. But there are also unknown unknowns. There are things

“There are things we know that we know. There are known

we do not know we don’t know” [Donald Rumsfeld, 2002]

En Python hay funcionalidades increíbles, imprescindibles una
vez que las conoces, que podríamos no echar en falta jamás
porque ni siquiera sabíamos que existían.

El propósito de esta charla es presentar una serie de aspectos
interesantes de Python que en estos años he descubierto que
mucha gente, incluso programadores veteranos, desconoce.

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

2

Introducción

Unknown Unknowns

Algunas de las funcionalidades que vamos a discutir
aquí son muy prácticas y otras curiosidades de
indiscutiblemente escasa o nula utilidad en nuestro
día a día. Pero todos ellos son conceptos sencillos de
entender y que merece la pena saber que están ahí,
incluso si no los usamos... por ahora.
Tenemos 1:15 minutos para cada uno de los puntos,
así que muchos de ellos sólo vamos a poder verlos
muy por encima. Pero al menos habrán dejado de ser
unknown unknowns.

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

3

Introducción

¡No os limitéis a escuchar!

No suele ser divertido escuchar a nadie hablar durante casi
una hora. Participad, intervenid, criticad, opinad. ¡Si digo

algo que no tiene ningún sentido, corregidme!

El código fuente está disponible en:

http://github.com/vterron/PyConES-2013

Erratas, correcciones, enlaces interesantes...

¿enviará alguien algún pull request antes de que termine esta charla?

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

4

Introducción

¿Listos?

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

5

Los diez primeros

1. Intercambiar dos variables

Normalmente, en otros lenguajes de programación,

tenemos que usar una variable temporal para almacenar

uno de los dos valores.

Por ejemplo, en C

int x , y;
int tmp ;
tmp = x;
x = y;
y = x;

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

6

Los diez primeros

1. Intercambiar dos variables
Python nos permite hacer

a, b = b, a

>>> a = 5
>>> b = 7
>>> a, b = b, a
>>> a
7
>>> b
5

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

7

Los diez primeros

1. Intercambiar dos variables

Desde nuestro punto de vista, ambas asignaciones ocurren

simultáneamente. La clave está en que tanto

a, b como b, a son tuplas.

Las expresiones en Python se evalúan de izquierda a
derecha. En una asignación, el lado derecho se evalúa
antes que el derecho. Por tanto:

El lado derecho de la asignación es evaluado, creando
una tupla de dos elementos en memoria, cuyos
elementos son los objetos designados por los
identificadores b y a.

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

8

Los diez primeros

1. Intercambiar dos variables

El lado izquierdo es evaluado: Python ve que estamos
asignando una tupla de dos elementos a otra tupla de
dos elementos, así que desempaqueta (tuple unpack)
la tupla y los asigna uno a uno:

Al primer elemento de la tupla de la izquierda, a, le
asigna el primer elemento de la tupla que se ha creado en
memoria a la derecha, el objeto que antes tenía el
identificador b. Así, el nuevo a es el antiguo b.

Del mismo modo, el nuevo b pasa a ser el antiguo a.

Explicación detallada en Stack Overflow:

http://stackoverflow.com/a/14836456/184363

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

9

Los diez primeros

1. Intercambiar dos variables

¿Cómo se declara una tupla de un único elemento?

o, para más claridad,

1,

(1,)

Es la coma, no el paréntesis, el constructor de la tupla

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

10

Los diez primeros

1. Intercambiar dos variables

Los paréntesis por sí mismos no crean una tupla: Python evalúa la

expresión dentro de los mismos y devuelve el valor resultante:

Esto sólo suma dos números

>>> 2 + (1)
3

Esto intenta sumar entero y tupla (y fracasa)

>>> 2 + (1 ,)
Traceback ( most recent call last ):

File " <stdin >" , line 1, in <module >

TypeError : unsupported operand type (s) for +: ’int ’ and ’ tuple ’

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

11

Los diez primeros

2. Encadenamiento de operadores lógicos

En vez de escribir

x => y and y < z

A diferencia de C, todos los operadores lógicos tienen la misma

prioridad, y pueden ser encadenados de forma arbitraria.

Mucho mejor

x <= y < z

Las dos expresiones de arriba son equivalentes, aunque en la segunda
x sólo se evalúa una vez. En ambos casos, z no llega a evaluarse si

no se cumple que x <= y (lazy evaluation).

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

12

Los diez primeros

3. 0.1 + 0.2 != 0.3

¿Por qué 0.1 + 0.2 == 0.3 es False?

>>> 0.1 + 0.2 == 0.3
False

Porque los números flotantes se representan internamente,

en cualquier ordenador, como fracciones binarias. Por

ejemplo, 1.25 es equivalente a 1/2 + 3/4.

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

13

Los diez primeros

3. 0.1 + 0.2 != 0.3

La mayor parte de las fracciones decimales no puede ser representada

exactamente con una fracción binaria. Lo máximo que los números flotantes

pueden hacer es aproximar su valor real — con bastantes decimales, pero nunca

el exacto.

>>> print " %.30 f" % 0.1
0.100000000000000005551115123126
>>> print " %.30 f" % 0.2
0.200000000000000011102230246252
>>> print " %.30 f" % 0.3
0.299999999999999988897769753748

Lo mismo ocurre en base decimal con, por ejemplo, el número 1/3. Por más
decimales con que se represente, 0.333333... no deja de ser una aproximación.

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

14

Los diez primeros

3. 0.1 + 0.2 != 0.3

Normalmente no somos conscientes de esto porque Python por defecto nos

muestra una aproximación del valor real de los números flotantes,

redondeándolos a una representación práctica para nosotros.

>>> print 0.1
0.1
>>> print 0.2
0.2
>>> print 0.3
0.3
>>> 0.1 + 0.2
0.30000000000000004

Floating Point Arithmetic: Issues and Limitations

http://docs.python.org/2/tutorial/floatingpoint.html

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

15

Los diez primeros

3. 0.1 + 0.2 != 0.3

Nunca deberíamos comparar números flotantes directamente

Una opción, simple, es comprobar si ambos valores son lo

"suficientemente iguales" usando un valor máximo de error absoluto

admisible, normalmente llamado epsilon.

>>> epsilon = 1e -10
>>> abs ((0.1 + 0.2) - 0.3) < epsilon
True
>>> abs ((0.1 + 0.2) - 0.3)
5.5511151231257827 e -17

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

16

Los diez primeros

3. 0.1 + 0.2 != 0.3

En caso de no conocer el rango de los números

con los que vamos a trabajar, tenemos que
compararlos en términos de error relativo

("son iguales al 99.999%).

Comparing Floating Point Numbers, 2012 Edition

http://randomascii.wordpress.com/2012/02/25/

comparing-floating-point-numbers-2012-edition/

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

17

Los diez primeros

3. 0.1 + 0.2 != 0.3

En Python tenemos el módulo decimal

>>> import decimal
>>> x = decimal . Decimal (" 0.1 ")
>>> y = decimal . Decimal (" 0.2 ")
>>> z = decimal . Decimal (" 0.3 ")
>>> x + y == z
True

decimal — Decimal fixed point and floating point arithmetic

http://docs.python.org/2/library/decimal.html

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

18

Los diez primeros

4. int(True) == 1

El valor numérico de True es 1; el de False, 0

>>> int ( True )
1
>>> int ( False )
0
>>> 37 + True
38
>>> 7 / False
Traceback ( most recent call last ):

File " <stdin >" , line 1, in <module >

ZeroDivisionError : float division

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

19

Los diez primeros

4. int(True) == 1

De hecho, la clase bool hereda de int

>>> issubclass ( bool , int )
True
>>> isinstance ( True , int )
True
>>> bool . mro ()
[< type ’bool ’>, <type ’int ’>, <type ’ object ’ >]

PEP 285: Adding a bool type [2002]

http://www.python.org/dev/peps/pep-0285/

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

20

Los diez primeros

5. import this

El Zen de Python

Los principios filosóficos en los que se cimenta Python

>>> import this
The Zen of Python , by Tim Peters

Beautiful is better than ugly .
Explicit is better than implicit .
Simple is better than complex .
Complex is better than complicated .
Flat is better than nested .
Sparse is better than dense .
Readability counts .
[...]

PEP 20: The Zen of Python [2004]

http://www.python.org/dev/peps/pep-0020/

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

21

Los diez primeros

5. import this

Algo bastante más desconocido: el contenido del módulo this.py
está cifrado con el algoritmo ROT13 — cada letra sustituida por la

que está trece posiciones por delante en el alfabeto:

>>> import inspect
>>> print inspect . getsource ( this )
s = """ Gur Mra bs Clguba , ol Gvz Crgref

Ornhgvshy vf orggre guna htyl .
Rkcyvpvg vf orggre guna vzcyvpvg .
Fvzcyr vf orggre guna pbzcyrk .
Pbzcyrk vf orggre guna pbzcyvpngrq .
Syng vf orggre guna arfgrq .
Fcnefr vf orggre guna qrafr .
Ernqnovyvgl pbhagf .
[...]

http://www.wefearchange.org/2010/06/import-this-and-zen-of-python.html

this and The Zen of Python

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

22

Los diez primeros

6. El módulo antigravedad

import antigravity

http://xkcd.com/353/

Añadido en Python 3, pero también está disponible en Python 2.7

Víctor Terrón (IAA-CSIC)

["Python"] * 40

23 de noviembre de 2013

23

Los diez primeros

6. El módulo antigra