Creado en 1990 por Guido van Rossum

Definición y evolución del lenguaje recogido en PEPs (Python Enhancement Proposals)

Ejemplo:

import math

número = input("Introduce un número [0, 1, 2, ...]: ")
número = int(número)  # convierte texto a número entero

print('El factorial de', número, 'es', math.factorial(número))

# de forma alternativa:

# print('El factorial de %s es %s' % (número, math.factorial(número)))
# print('El factorial de {} es {}'.format(número, math.factorial(número)))
# print(f'El factorial de {número} es {math.factorial(número)}')

• Actualmente dos versiones principales activas:
  • Python 2.7 (soporte hasta 1/1/2020)
  • Python 3.x (3.6, 3.7) ←

python x.y.z
x: versión principal, incompatibles entre sí [2, 3]
y: versión secundaria, normalmente compatibles
z: versión menor (errores y seguridad)

$ python -V
Python 3.7.3

Línea temporal de versiones, en rojo: versión obsoleta

• Lenguaje de alto nivel, interpretado, orientado a objetos

Alto nivel

Código ejemplo en C++

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h> 
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <err.h>

char response[] = "HTTP/1.1 200 OK\r\n"
"Content-Type: text/html; charset=UTF-8\r\n\r\n"
"Hello, world!\r\n";

int main()
{
  int one = 1, client_fd;
  struct sockaddr_in svr_addr, cli_addr;
  socklen_t sin_len = sizeof(cli_addr);

  int sock = socket(AF_INET, SOCK_STREAM, 0);
  if (sock < 0)
    err(1, "can't open socket");

  setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(int));

  int port = 8080;
  svr_addr.sin_family = AF_INET;
  svr_addr.sin_addr.s_addr = INADDR_ANY;
  svr_addr.sin_port = htons(port);

  if (bind(sock, (struct sockaddr *) &svr_addr, sizeof(svr_addr)) == -1) {
    close(sock);
    err(1, "Can't bind");
  }
 
  listen(sock, 5);
  while (1) {
    client_fd = accept(sock, (struct sockaddr *) &cli_addr, &sin_len);

    if (client_fd == -1) {
      perror("Can't accept");
      continue;
    }

    write(client_fd, response, sizeof(response) - 1); /*-1:'\0'*/
    close(client_fd);
  }
}

Equivalente python

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello World!"

Flask.run(app, port=8080)

Interpretado

Interpretado

Práctica

intérprete python

Diferentes paradigmas de programación

Data Science

Machine Learning

Desarrollo Web

(p.e. pinterest, instagram, linkedin, …)

Desarrollo software (scripts, prototipos, …)

como “pegamento” entre componentes escritos en otros lenguajes

Automatización de procesos software

Automatización de procesos software

The 2018 Top Programming Languages, IEEE

gran soporte en foros, comunidades, conferencias, …

stackoverflow

Worldwide, Python is the most popular language, Python grew the most in the last 5 years (PYPL)

fuente: stackoverflow

Diferentes distribuciones para Windows:

Podemos ejecutar código python:

Cada entorno tiene un único intérprete python + librerías

¿Solución?

• Funcionan como un marco aislado y seguro
• Independientes entre sí
• Permiten especificar versiones de Python (2.7.10, 3.6.6, 3.6.7, …)
• Facilmente reproducibles y exportables (Portabilidad)
  • p.e. replicar un entorno preexistente
• De “usar y tirar” (p.e. probar nuevas versiones de código o librerías)

Por defecto partiremos de un entorno global/base

Regla general: evitar usar el intérprete global del sistema y el entorno base

Conda (anaconda/miniconda)

• Gestor de paquetes multi-lenguaje (python/R/…)
• Transparente: no instala ficheros fuera de su directorio
• Distribución multipropósito, gestiona paquetes adicionales (p.e. git, librerías, …)
• Coexistencia de entornos con diferentes librerías y versiones de python

• Por defecto nos encontraremos en un entorno llamado base

Alternativas (más bajo nivel):

• python + pipenv
• python + virtualenvwrapper (lazy) # Instalación #### Instalación

Determinar la plataforma sobre la que se va a instalar

https://www.anaconda.com/download/
con chocolatey:

> choco install anaconda3 vscode -y

🕐 7-15 minutos

Entorno virtual con Navigator

• Ejecutar “Anaconda Navigator” y crear un nuevo entorno (distinto a base) con diferentes librerías instaladas, p.e.:

Entorno virtual en modo texto

• Ejecutar Anaconda prompt o acceder a la terminal desde vscode
• Verificar que conda está instalado:

(base) > conda info
(base) > conda --help

Crear un entorno virtual con pandas, scrapy, jupyter, bs4 y pyjstat.

• Inicializar el entorno virtual. Ejemplos:

(base) > conda create --name entorno-01
(base) > conda create --name entorno-02 python=2.7 --yes
# crea entorno con paquetes preinstalados
(base) > conda create -n entorno-03 python=3.7 pandas scipy -y

• Acceder (activar) el entorno virtual:

(base) > conda activate entorno-03
(entorno-03) > conda list  # muestra paquetes instalados

Crear un entorno virtual con pandas, scrapy, jupyter, bs4 y pyjstat.

# instala librerías gestionadas por conda
(entorno 03) > conda install pandas scrapy jupyter bs4 --yes

# instala paquetes no gestionados por conda desde PyPI (Python Package Index)
(entorno-03) > pip install -y pyjstat 
# o bien desde el repositorio git
(entorno-03) > pip install -e ^
"git+https://github.com/predicador37/pyjstat.git#egg=pyjstat-git"

• Exportar entorno virtual (distribuible y replicable)

# exportar definición del entorno
(entorno-03) > conda list --export > requirements.txt  # solo dependencias
(entorno-03) > conda env export > entorno-03.yml  # entorno + dependencias
# salir del entorno (vuelve al entorno base)
(entorno-03) > conda deactivate
(base) >

• Acceder al entorno virtual y mostrar librerías instaladas

(base) > conda activate entorno-03
(entorno-03) > conda list  # muestra paquetes instalados

# instala paquetes adicionales
(entorno-03) > conda install seaborn -y

• Resumen comandos conda
• Guía de usuario pip

Integración con el entorno virtual de cada proyecto

• Seleccionar intérprete + nombre del entorno
• terminal > ipython / python o bien “Python: ejecutar REPL”

Linter

• Analizador del código, detecta errores de sintaxis, estilo, …
• Necesario instalar en cada entorno (preinstalado en base)
  • Paleta de comandos > Python: seleccionar Linter > flake8

flake8

• Comprueba conformidad con PEP8, complejidad de McCabe, errores de sintaxis…
• Permite ignorar/silenciar diferentes avisos, excluir ficheros del análisis, …

Depuración de errores

• Errores de sintaxis
• Avisos del linter

#!/bin/env python3
import requests

URL='https://elpais.com'
r = requests.get(url)  # crear un breakpoint aquí

print(f'Código de respuesta: {r.status_code}')
print(f'Recibidos {len(r.text)} Bytes de contenido')

• No hay delimitadores de línea (tipo ‘;’)
• Jerarquía del código según nivel de indentación
• Indentar código con espacios
• Comentar código con « # »
• Importar librerías al inicio
• Código agrupado con líneas en blanco
• Recomendado: Longitud de línea < 80 caracteres

cuaderno jupyter

cuaderno jupyter (offline)

Palabras reservadas

import builtins
import keyword


print(', '.join(keyword.kwlist))
False, None, True, and, as, assert, async, await, break, class,
continue, def, del, elif, else, except, finally, for, from,
global, if, import, in, is, lambda, nonlocal, not, or, pass,
raise, return, try, while, with, yield

print(dir(builtins))
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException',
'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning',
'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError',
'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning',
'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',
'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning',
'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError',
'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError',
'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError',
'NameError', 'None', 'NotADirectoryError', 'NotImplemented',
'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning',
'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError',
'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration',
'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit',
'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError',
'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError',
'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError',
'Warning', 'ZeroDivisionError', '__IPYTHON__', '__build_class__', '__debug__',
'__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__',
'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray',
'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright',
'credits', 'delattr', 'dict', 'dir', 'display', 'divmod', 'enumerate', 'eval',
'exec', 'filter', 'float', 'format', 'frozenset', 'get_ipython', 'getattr',
'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int',
'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map',
'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow',
'print', 'property', 'range', 'repr', 'reversed', 'round', 'set', 'setattr',
'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type',
'vars', 'zip']

if __name__ == "__main__":

(base) python circunferencia.py 35

import sys
import math

def area(radio):
    return math.pi * (radio ** 2)

def longitud(radio):
    return 2 * math.pi * radio

print('Hola mundo')

# entra aquí cuando se ejecuta desde un intérprete
if __name__ == "__main__":
    radio = float(sys.argv[1])  # sys.argv[] son los argumentos de entrada
    print(
        "La longitud de una circunferencia de radio {}cm es {:.2f}cm^2."
        .format(radio, longitud(radio))
    )
    print("El area de una circunferencia de radio {1}cm es {0:.2f}cm^2."
          .format(area(radio), radio))

Proyecto ejemplo

proyecto/
    README.rst
    LICENSE
    setup.py
    requirements.txt
    entorno_conda.yml
    ejemplo/__init__.py
    ejemplo/core.py
    ejemplo/helpers.py
    docs/conf.py
    docs/index.rst
    tests/unitarios.py
    tests/funcionales.py

nombre del paquete
descripción del proyecto
licencia [2]
distribución/empaquetado [3]
descripción de las dependencias
descripción del entorno
el código en sí
" "
" "
documentación del proyecto
" "
funciones de test del proyecto
" "

Cómo importar módulos

from pandas import *
from numpy import *

f = array([1, 2, 3, 4])  # ndarray es de pandas o numpy?

from numpy import array
from pandas import *

f = array([1, 2, 3, 4])  # seguro que ndarray es de numpy?

import pandas as pd  # renombrar para abreviar o por convención
import numpy

f = numpy.array([1, 2, 3, 4])

Parte 1

• Abrir una consola ipython
• In[n] identifica las entradas de comandos
• comandos mágicos (solamente para ipython)
  • comienzan por el caracter ‘%’
  • ejemplo: %run, %matplotlib, %load, %who
• Ctrl+R activa la búsqueda en el historial
  • %hist, %history para visualizarlo
• _ guarda la salida del último comando &sup4;

• [TAB] autocompleta (p.e. import st[TAB])
  • muy útil para ver los métodos/atributos de un módulo/clase

In[]: import st[TAB]
In[]: import string


In[]: string.[TAB]
   string.Formatter       string.ascii_uppercase string.octdigits
   string.Template        string.capwords        string.printable
   string.ascii_letters   string.digits          string.punctuation
   string.ascii_lowercase string.hexdigits       string.whitespace

Ejemplos

In[1]: ?  # muestra ayuda del intérprete ipython
In[2]: ? dict  # muestra ayuda breve de un método/clase/...
In[3]: help(dict)  # muestra ayuda completa
In[4]: import math
In[5]: math.sq[TAB]
In[5]: math.sqrt(94)
In[6]: a = _  # recupera última salida
In[7]: dir(math)  # muestra todos los métodos

• Importa la librería math
• Convierte 67 grados a radianes (math.radians)
• Calcula el cuadrado (n²) del resultado (operador ** o math.pow)
• Verifica si el resultado es mayor que 16/13

Solución

Parte 2

:::

Solución

Descargar el cuaderno de ejemplo en el directorio python y ejecutar línea por línea.

(o bien ejecutarlo en forma remota con Binder)

Exportar entorno virtual (II)

• Copia y restauración de dependencias con pip (requirements.txt)
  • independiente de conda

(entorno-01) pip freeze > requirements.txt
(entorno-01) conda activate entorno-03
(entorno-03) pip install -r requirements.txt

Documentación oficial

• Tutorial de python
• Guías de estilo:
  • PEP8
  • Guía de estilo de Google
• Cuadernos Jupyter para Data Science

Otros recursos en línea

• Librería standard de Python
• Guía de referencia de Python
• Guía para principiantes
• The Hitchhiker’s Guide to Python!
• Stackoverflow
• Stackoverflow en español
• awesome python

• Permite gestionar un entorno virtual y sus dependencias

Instala pipenv y crea un entorno virtual nuevo

$ mkdir proyecto
$ cd proyecto
$ pipenv --python=3.7 [--three]

Instala distintos paquetes dentro del entorno virtual

$ pipenv install bpython
$ pip install 'pandas=='  # muestra versiones disponibles [OJO! pip]
$ pipenv install 'pandas==0.23.1' 'requests==2.2.1'
$ pipenv install 'lxml==3.*'  # bloquea solamente la rama 3.x
$ pipenv install 'untangle==1.1.*'  # bloquea versiones [major, minor]
$ pipenv install -r requirements.txt  # instala desde un fichero requirements
$ pipenv lock -r > requirements.txt  # exporta a fichero requirements

Para comprobar los paquetes instalados, mostrar el contenido de Pipfile

$ cat Pipfile
$ cat Pipfile.lock

Otras funcionalidades útiles con pipenv:

# muestra dónde instala realmente el entorno
$ pipenv --venv

# muestra gráfico de dependencias
$ pipenv graph

# muestra vulnerabilidades con los paquetes instalados
$ pipenv check

Acceder al intérprete propio del entorno:

$ pipenv shell
$ python  # o bpython/ipython si está instalado

# o bien: pipenv run python

Ejecutar código cargando librerías propias del entorno:

>>> import pandas as pd
>>> URL_crypto = 'https://api.coinmarketcap.com/v1/ticker/'
>>> cc = pd.read_json(URL) 
>>> cc.set_index('id', inplace=True)
>>> cc[cc['price_usd'] < 300.0]

# desinstala todos los paquetes no especificados en `Pipfile.lock`
$ pipenv clean

# destruye el entorno virtual
$ pipenv --rm

Restaura un entorno virtual desde los ficheros Pipfile y Pipfile.lock:

$ pipenv install

Reference counting

• Usado por python para la gestión de memoria
• Cuenta las referencias a cada objeto creado
• Cuando la cuenta es 0, la memoria reservada se libera

import sys

a = []
b = a
sys.getrefcount(a)
3

GC: Garbage Collector

Utiliza 2 algoritmos para la gestión de memoria:

• Reference counting: libera objetos sin referencias en un programa
  • ejecutado en “tiempo real”
• Referencias cíclicas: se ejecuta periódicamente

Ejemplo

foo = []

# 2 referencias, 1 de la variable foo y una de la llamada a getrefcount
print(sys.getrefcount(foo))

def bar(a):
    # 4 referencias
    # variable foo, argumento a función, getrefcount + pila interna de python
    print(sys.getrefcount(a))

bar(foo)
# 2 referencias, se limpiaron las propias de la función
print(sys.getrefcount(foo))

GIL: Global Interpreter Lock

Ejemplo práctico: programa limitado por CPU, ejecución secuencial

# single_threaded.py
import time

COUNT = 50000000

def countdown(n):
    while n>0:
        n -= 1

start = time.time()
countdown(COUNT)
end = time.time()

print('Tiempo de ejecución {:.2f} segundos'.format(end - start))

$ python single_threaded.py
Tiempo de ejecución 2.30 segundos

Programa limitado por CPU, ejecución concurrente (multithread)

# multi_threaded.py
import time
from threading import Thread

COUNT = 50000000

def countdown(n):
    while n>0:
        n -= 1

thread_1 = Thread(target=countdown, args=(COUNT//2,))
thread_2 = Thread(target=countdown, args=(COUNT//2,))
start = time.time()
thread_1.start()
thread_2.start()
thread_1.join()
thread_2.join()
end = time.time()

print('Tiempo de ejecución {:.2f} segundos'.format(end - start))

$ python multi_threaded.py
Tiempo de ejecución 2.85 segundos

Programa limitado por CPU, ejecución concurrente (multiprocess)

# multi_process.py
import time
from multiprocessing import Pool

COUNT = 50000000

def countdown(n):
    while n>0:
        n -= 1

start = time.time()
with Pool(2) as p:  # bypass del GIL
    p.map(countdown, 2* [COUNT//2])
end = time.time()

print('Tiempo de ejecución {:.2f} segundos'.format(end - start))

$ python multi_threaded.py
Tiempo de ejecución 1.32 segundos

cuaderno jupyter (offline)

cuaderno jupyter (binder)