Haskell y Python

El primero al final

PorJosé A. Alonso 16-agosto-202214-diciembre-2022

Definir la función

   rota1 :: [a] -> [a]

1	rota1 :: [a] -> [a]

tal que (rota1 xs) es la lista obtenida poniendo el primer elemento de xs al final de la lista. Por ejemplo,

   rota1 [3,2,5,7]  ==  [2,5,7,3]

1	rota1 [3,2,5,7] == [2,5,7,3]

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

import Test.QuickCheck

-- 1ª solución
-- ===========

rota1a :: [a] -> [a]
rota1a [] = []
rota1a xs = tail xs ++ [head xs]

-- 2ª solución
-- ===========

rota1b :: [a] -> [a]
rota1b []     = []
rota1b (x:xs) = xs ++ [x]

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_rota1 :: [Int] -> Bool
prop_rota1 xs =
  rota1a xs == rota1b xs

-- La comprobación es
--    λ> quickCheck prop_rota1
--    +++ OK, passed 100 tests.

import Test.QuickCheck

-- 1ª solución

-- ===========

rota1a :: [a] -> [a]

rota1a [] = []

rota1a xs = tail xs ++ [head xs]

-- 2ª solución

-- ===========

rota1b :: [a] -> [a]

rota1b [] = []

rota1b (x:xs) = xs ++ [x]

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_rota1 :: [Int] -> Bool

prop_rota1 xs =

rota1a xs == rota1b xs

-- La comprobación es

-- λ> quickCheck prop_rota1

-- +++ OK, passed 100 tests.

El código se encuentra en GitHub.

Soluciones en Python

from typing import TypeVar
from hypothesis import given, strategies as st

A = TypeVar('A')

# 1ª solución
def rota1a(xs: list[A]) -> list[A]:
    if xs == []:
        return []
    return xs[1:] + [xs[0]]

# 2ª solución
def rota1b(xs: list[A]) -> list[A]:
    if xs == []:
        return []
    ys = xs[1:]
    ys.append(xs[0])
    return ys

# 3ª solución
def rota1c(xs: list[A]) -> list[A]:
    if xs == []:
        return []
    y, *ys = xs
    return ys + [y]

# La equivalencia de las definiciones es
@given(st.lists(st.integers()))
def test_rota1(xs: list[int]) -> None:
    assert rota1a(xs) == rota1b(xs) == rota1c(xs)

# La comprobación es
#    src> poetry run pytest -q el_primero_al_final.py
#    1 passed in 0.20s

from typing import TypeVar

from hypothesis import given, strategies as st

A = TypeVar('A')

# 1ª solución

def rota1a(xs: list[A]) -> list[A]:

if xs == []:

return []

return xs[1:] + [xs[0]]

# 2ª solución

def rota1b(xs: list[A]) -> list[A]:

if xs == []:

return []

ys = xs[1:]

ys.append(xs[0])

return ys

# 3ª solución

def rota1c(xs: list[A]) -> list[A]:

if xs == []:

return []

y, *ys = xs

return ys + [y]

# La equivalencia de las definiciones es

@given(st.lists(st.integers()))

def test_rota1(xs: list[int]) -> None:

assert rota1a(xs) == rota1b(xs) == rota1c(xs)

# La comprobación es

# src> poetry run pytest -q el_primero_al_final.py

# 1 passed in 0.20s

El código se encuentra en GitHub.

Comentarios

El primer elemento de la lista xs se calcula
- en Haskell, con head xs
- en Python, con xs[0]
El resto de la lista xs se calcula
- en Haskell, con tail xs
- en Python, con xs[1:]
La concatenación de las listas xse ysse calcula
- en Haskell, con xs ++ ys
- en Python, con xs + ys
En Python. xs.append(x) modifica la lista xs añadiéndole x al final. Por ejemplo,

>>> xs = [3, 2, 5]
>>> xs.append(1)
>>> xs
[3, 2, 5, 1]

>>> xs = [3, 2, 5]

>>> xs.append(1)

>>> xs

[3, 2, 5, 1]

Máximo de tres números

PorJosé A. Alonso 15-agosto-202214-diciembre-2022

Definir la función

   maxTres :: Int -> Int -> Int -> Int

1	maxTres :: Int -> Int -> Int -> Int

tal que (maxTres x y z) es el máximo de x, y y z. Por ejemplo,

   maxTres 6 2 4  ==  6
   maxTres 6 7 4  ==  7
   maxTres 6 7 9  ==  9

maxTres 6 2 4 == 6

maxTres 6 7 4 == 7

maxTres 6 7 9 == 9

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Solución en Haskell

maxTres :: Int -> Int -> Int -> Int
maxTres x y z = max x (max y z)

1 2	maxTres :: Int -> Int -> Int -> Int maxTres x y z = max x (max y z)

El código se encuentra en GitHub.

Soluciones en Python

def maxTres(x: int, y: int, z: int) -> int:
    return max(x, max(y, z))

1 2	def maxTres(x: int, y: int, z: int) -> int: return max(x, max(y, z))

El código se encuentra en GitHub.

Comentarios

El máximo de x e y se escribe
- en Haskell, max x y y
- en Python, max(x, y).

Último dígito

PorJosé A. Alonso 12-agosto-202214-diciembre-2022

Definir la función

   ultimoDigito :: Int -> Int

1	ultimoDigito :: Int -> Int

tal que (ultimoDigito x) es el último dígito del número x. Por ejemplo,

   ultimoDigito 325  ==  5

1	ultimoDigito 325 == 5

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Solución en Haskell

ultimoDigito :: Int -> Int
ultimoDigito x = rem x 10

1 2	ultimoDigito :: Int -> Int ultimoDigito x = rem x 10

El código se encuentra en GitHub.

Solución en Python

def ultimoDigito(x: int) -> int:
    return x % 10

1 2	def ultimoDigito(x: int) -> int: return x % 10

El código se encuentra en GitHub.

Comentarios

El resto de la división entera se x entre y sn ecribe
- en Haskell, rem x y,
- en Python, x % y.

Área de la corona circular

PorJosé A. Alonso 11-agosto-202214-diciembre-2022

Definir la función

   areaDeCoronaCircular :: Double -> Double -> Double

1	areaDeCoronaCircular :: Double -> Double -> Double

tal que (areaDeCoronaCircular r1 r2) es el área de una corona circular de radio interior r1 y radio exterior r2. Por ejemplo,

   areaDeCoronaCircular 1 2 == 9.42477796076938
   areaDeCoronaCircular 2 5 == 65.97344572538566
   areaDeCoronaCircular 3 5 == 50.26548245743669

areaDeCoronaCircular 1 2 == 9.42477796076938

areaDeCoronaCircular 2 5 == 65.97344572538566

areaDeCoronaCircular 3 5 == 50.26548245743669

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Solución en Haskell

areaDeCoronaCircular :: Double -> Double -> Double
areaDeCoronaCircular r1 r2 = pi*(r2^2 -r1^2)

1 2	areaDeCoronaCircular :: Double -> Double -> Double areaDeCoronaCircular r1 r2 = pi*(r2^2 -r1^2)

El código se encuentra en GitHub.

Solución en Python

from math import pi

def areaDeCoronaCircular(r1: float, r2: float) -> float:
    return pi * (r2 ** 2 - r1 ** 2)

from math import pi

def areaDeCoronaCircular(r1: float, r2: float) -> float:

return pi * (r2 ** 2 - r1 ** 2)

El código se encuentra en GitHub.

Comentarios

La diferencia de dos números x e y se escribe en Python igual que en Haskell: x - y.

Volumen de la esfera

PorJosé A. Alonso 10-agosto-202214-diciembre-2022

Definir la función

   volumenEsfera :: Double -> Double

1	volumenEsfera :: Double -> Double

tal que (volumenEsfera r) es el volumen de la esfera de radio r. Por ejemplo,

   volumenEsfera 10  ==  4188.790204786391

1	volumenEsfera 10 == 4188.790204786391

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Solución en Haskell

volumenEsfera :: Double -> Double
volumenEsfera r = (4/3)*pi*r^3

1 2	volumenEsfera :: Double -> Double volumenEsfera r = (4/3)pir^3

El código se encuentra en GitHub.

Solución en Python

from math import pi

def volumenEsfera(r: float) -> float:
    return (4 / 3) * pi * r ** 3

from math import pi

def volumenEsfera(r: float) -> float:

return (4 / 3) * pi * r ** 3

El código se encuentra en GitHub.

Comentarios

El número $\pi$ se representa igual en Python que en Haskell; pero, en Python. para usarlo hay que importarlo de la librería math.
La potencia de número x elevado al entero n se escribe
- en Haskell, x^n y
- en Python, x ** n.

Suma de monedas

PorJosé A. Alonso 9-agosto-202214-diciembre-2022

Definir la función

   sumaMonedas :: Int -> Int -> Int -> Int -> Int -> Int

1	sumaMonedas :: Int -> Int -> Int -> Int -> Int -> Int

tal que (sumaMonedas a b c d e) es la suma de los euros correspondientes a a monedas de 1 euro, b de 2 euros, c de 5 euros, d de 10 euros y e de 20 euros. Por ejemplo,

   sumaMonedas 0 0 0 0 1  ==  20
   sumaMonedas 0 0 8 0 3  == 100
   sumaMonedas 1 1 1 1 1  ==  38

sumaMonedas 0 0 0 0 1 == 20

sumaMonedas 0 0 8 0 3 == 100

sumaMonedas 1 1 1 1 1 == 38

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Soluciones en Haskell

sumaMonedas :: Int -> Int -> Int -> Int -> Int -> Int
sumaMonedas a b c d e = 1*a+2*b+5*c+10*d+20*e

1 2	sumaMonedas :: Int -> Int -> Int -> Int -> Int -> Int sumaMonedas a b c d e = 1a+2b+5c+10d+20*e

El código se encuentra en GitHub.

Soluciones en Python

def sumaMonedas(a: int, b: int, c: int, d: int, e: int) -> int:
    return 1 * a + 2 * b + 5 * c + 10 * d + 20 * e

1 2	def sumaMonedas(a: int, b: int, c: int, d: int, e: int) -> int: return 1 * a + 2 * b + 5 * c + 10 * d + 20 * e

El código se encuentra en GitHub.

Comentarios

El producto de dos números x e y se escribe en Python igual que en Haskell: x * y.

Media aritmética de tres números

PorJosé A. Alonso 8-agosto-202214-diciembre-2022

Definir la función

   media3 :: Float -> Float -> Float -> Float

1	media3 :: Float -> Float -> Float -> Float

tal que (media3 x y z) es la media aritmética de los números x, y y z. Por ejemplo,

   media3 1 3 8     ==  4.0
   media3 (-1) 0 7  ==  2.0
   media3 (-3) 0 3  ==  0.0

media3 1 3 8 == 4.0

media3 (-1) 0 7 == 2.0

media3 (-3) 0 3 == 0.0

Soluciones

A continuación se muestran las soluciones en Haskell y las soluciones en Python.

Solución en Haskell

media3 :: Float -> Float -> Float -> Float
media3 x y z = (x+y+z)/3

1 2	media3 :: Float -> Float -> Float -> Float media3 x y z = (x+y+z)/3

El código se encuentra en GitHub.

Soluciones en Python

def media3(x: float, y: float, z: float) -> float:
    return (x + y + z)/3

1 2	def media3(x: float, y: float, z: float) -> float: return (x + y + z)/3

El código se encuentra en GitHub.

Comentarios

Los comentarios irán resaltando las diferencias de la solución en Python respecto de la de Haskell (que no se hayan comentado en ningún ejercicio anterior).
La estructura de la definición en Python es

def <nombre de la función>(<argumento 1>,...,<argumento n>):
    # type: <signatura de la función>
    ...
    return <resultado>

def <nombre de la función>(<argumento 1>,...,<argumento n>):

# type: <signatura de la función>

...

return <resultado>

La suma de dos números x e y se escribe en Python igual que en Haskell: x + y.
El cociente de dos números decimales x e y se escribe en Python igual que en Haskell: x / y.

Curso de introducción a la programación con Haskell y Python

PorJosé A. Alonso 7-agosto-202210-agosto-2022

Mañana comenzará en Exercitium un curso práctico de introducción a la programación con Haskell y Python.

Diariamente, se publicará un ejercicio con sus soluciones en Haskell y en Python. El orden de los ejercicios se corresponde con el de los temas del curso de Programación funcional con Haskell. Además, en cada ejercicio se comentarán las diferencias entre ambos lenguajes y se irá extendiendo la tabla de equivalencia entre Haskell y Python.

Las soluciones de los ejercicios con Haskell se irán añadiendo al repositorio Exercitium em GitHub. Están como un proyecto con Stack (en concreto, la LTS-18.24) de forma que se puede verificar los ejemplos con

stack test

1	stack test

Las soluciones de los ejercicios con Python se irán añadiendo al repositorio Exercitium-Python em GitHub. Están como un proyecto con Poetry que usa la versión 3.10 de Python. También se pueden verificar los ejemplos con

poetry run pytest

1	poetry run pytest

He intentado escribir soluciones en Python parecidas a la de Haskell, conservando el estilo funcional. De todas formas, en los comentarios se pueden escribir definiciones alternativas en cualquiera de los lenguajes.

Los libros de Haskell en los que me he basado son

Algorithms: A functional programming approach de F. Rabhi y G. Lapalme.
Algorithm design with Haskell de E. Bird y J. Gibbons.
An introduction to functional programming systems using Haskell de A.J.T. Davie.
An introduction to functional programming through lambda calculus de G. Michaelson.
¡Aprende Haskell por el bien de todos! de M. Lipovača.
Beautiful code, compelling evidence (Functional programming for information visualization) de J.R. Heard.
Beginning Haskell (A project based approach). ~ A. Serrano.
Categories and Haskell de J.W. Buurlage.
Category theory applied to functional programming J.P. Villa.
Computational semantics and type theory de J. van Eijck.
Computational semantics with functional programming de J. van Eijck y C. Unger.
Developing web applications with Haskell and Yesod de M. Snoyman.
Discrete mathematics using a computer de J. O’Donnell, C. Hall y R. Page.
Domain-specific languages of Mathematics de P. Jansson, C. Ionescu y J.P. Bernardy.
Ejercicios de programación funcional con Haskell de J.A. Alonso y M.J. Hidalgo.
Exámenes de programación funcional con Haskell de J.A. Alonso y als.
Functional programming and graph algorithms de D.J. King.
Get programming with Haskell de W. Kurt.
Haskell cookbook de Y. Sajanikar.
Haskell data analysis cookbook de N. Shukla.
Haskell design patterns de R. Lemmer.
Haskell financial data modeling and predictive analytics de P. Ryzhov.
Haskell high performance programming de S. Thomasson.
Haskell (Notes for professionals).
Haskell programming from first principles de C. Allen y J. Moronuki.
Haskell quick syntax reference de S.L. Nita y M. Mihailescu.
Haskell tutorial and cookbook de M. Watson.
Haskell (The craft of functional programming) de S. Thompson.
Introducción a la programación funcional con Haskell de R. Bird.
Introduction to computation Haskell, logic and automata de D. Sannella, M. Fourman, H. Peng y P. Wadler.
Learn you a Haskell for great good! de M. Lipovaca y J. Brock.
Learning Haskell data analysis de J. Church.
Parallel and concurrent programming in Haskell. S. Marlow.
Pearls of functional algorithm design de R. Bird.
Piensa en Haskell de J.A. Alonso y M.J. Hidalgo.
Practical Haskell (A real World guide to programming) de A. Serrano.
Practical Web development with Haskell de E. Putrady.
Practical concurrent Haskell (with big data applications) de S.L. Nita y M. Mihailescu.
Programming in Haskell (2nd edition) de G. Hutton.
Purely functional data structures de D. Okasaki.
Real world Haskell de B. O’Sullivan, J. Goerzen y D. Stewart.
Temas de programación funcional de J.A. Alonso.
The Dao of functional programming de B. Milewski.
The Haskell school of music (from signals to symphonies) de P. Hudak.
The Haskell road to logic, maths and programming de K. Doets y J van Eijck.
Thinking functionally with Haskell de R. Bird.
Thinking with types de S. Maguire.
Yet another Haskell tutorial de Hal Daume III et al.

Los libros de Python en los que me he basado son

Advanced guide to Python 3 programming de J. Hunt.
Algorithmic problem solving with Python de J.B. Schneider, S.L. Broschat y J. Dahmen.
Aprenda a pensar como un programador con Python de A. Downey, J. Elkner y C. Meyers.
Aprende a programar en Python como si estuvieras en el siglo XXI de J.J. Merelo.
Artificial intelligence with Python de P. Joshi.
Automate the boring stuff with Python de A. Sweigart.
A beginners guide to Python 3 programming de J. Hunt.
A concise introduction to programming in Python de M.J. Johnson.
A functional start to computing with Python de T. Herman.
A primer on scientific programming with Python de H.P. Langtangen.
A programmer’s introduction to mathematics de J. Kun.
A very basic introduction to scientific Python programming de H.P. Langtangen.
Basic cheat sheet for Python de Swigartpdf
Beginning Python (From novice to professional) de M.L. Hetland.
Clean Python (Elegant coding in Python) de S. Kapil.
Competitive programming in Python de C. Durr y J.L. Vie.
Computational physics with Python de E. Ayars.
Computational quantum mechanics de J. Izaac y J. Wang.
Data science from scratch (First principles with Python) de J. Grus.
Data structures and algorithms in Python de M.T. Goodrich, R. Tamassia y M.H.Goldwasser.
Doing math with Python de A. Saha.
Effective computation in physics de A. Scopatz y K.D. Huff.
El lenguaje Python de D. Masip.
Fluent Python de L. Ramalho.
Functional Python programming de D.F. Lott.
Functional programming in Python de D. Mertz.
Fundamentals of Python (From first programs through data structures) de K.A. Lambert.
Hacking secret ciphers with Python de A. Sweigart.
Introducción a la programación con Python 3 de A. Marzal. I. Gracia y P. García.
Introduction a l’algorithmique avec Python de P. Olivier.
Introduction to Python for computational science and engineering de H. ~ Fangohr.
Introduction to Python for econometrics, statistics and data analysis. ~ Sheppard-14.pdf
Introduction to Python for science and engineering de D.J. Pine.
Introduction to Python for scientists and engineers de S. Nagar.
Introduction to computation and programming using Python de J.V. Guttag.
Introduction to recursive programming de M. Rubio.
Learning to program using Python de C. Jackson.
Lectures on mathematical computing with Python de J. Gopalakrishnan.
Mastering Python de R. van Hattem.
Problem solving with algorithms and data structures using Python de B. Miller y D. Ranum.
Programmation en Python pour les mathématiques de A. Casamayou P. Chauvin y G. Connan.
Programming and mathematical thinking de A.M. Stavely.
Programming for computations (A gentle introduction to numerical simulations with Python 3.6) de S. Linge y H.P. Langtangen.
Programming with Python de T.R. Padmanabhan.
Python 3 for absolute beginners de T. Hall y J-P Stacey.
Python algorithms (Mastering basic algorithms in the Python language) de M.L. Lie.
Python descriptors de J. Zimmerman.
Python programming (An introduction to computer science) de J. Zelle.
Python scientific lecture notes de V. Haenel, E. Gouillart y G. Varoquaux..
Scipy Lecture Notes (One document to learn numerics, science, and data with Python) de G. Varoquaux et als.
Serious Python de J. Danjou.
The Python workbook (A brief introduction with exercises and solutions) de B. Stephenson.

El primero al final

Máximo de tres números

Último dígito

Área de la corona circular

Volumen de la esfera

Suma de monedas

Media aritmética de tres números

Curso de introducción a la programación con Haskell y Python

Entradas recientes

Buscar

Correo electrónico