Comparing F# to Python

3 min readMar 26, 2021


scripting with #r NuGet and comparing some python syntax

F#5 in action in vscode + ionide

Getting Started

mkdir fsx && cd fsx; touch new.fsx; code .


Ionide is a great F# cross-platform IDE plug-in for VScode, it works pretty well for F# scripting but sometimes might need you to clear cache or restart vscode though.

I will also compare a bit of F# and Python between the lines, as python is the de-facto standard for scripting in 2021.

A function in Python

def sum(a,b): 
return a + b

The same function in F#

let sum a b = a + b // or quicker, let sum = (+)

A class in Python

class Dog:
species = "Canis familiaris"

def __init__(self, name, age): = name
self.age = age

def description(self):
return f"{} is {self.age} years old"

def speak(self, sound):
return f"{} says {sound}"

A class in F#

type Dog(name,age) =
member val Description =
$"{name} is {age} years old"
member this.Speak(sound) =
$"{name} says {sound}"
member val Species = "canis familiaris"

Manipulating Sequences (*)

F#: with the pipe operator |> and List module functions:

let sumOfEvenNumbersFromOneTo100Adding1 =
|> List.filter (fun x -> x % 2 = 0)
|> (fun x -> x + 1)
|> List.sum //2600

Python: using the list module (there is no pipe operator, more verbose)

sample2 = range(1,101) # 1..100
filteredList = list(filter(lambda x : x % 2 == 0, sample2))
addOneList = list(map(lambda x : x + 1 , filteredList))
total = sum(addOneList) # 2600

List Comprehensions (*)

F#: list comprehensions are a powerful construct enabled by computation expressions, so regular F# code is valid within a list comprehension!

let listComprehension =
for x in [1..100] do
let z = "hello" // just to show you can!
if x % 2 = 0 then
yield x + 1 // value is returned whenever we want

Python: also has list comprehensions, but not all Python code is valid within a list comprehension but just a subset, kind of like a “query subset” of Python?

list_comprehension = 
x + 1 # value is always returned at the top
for x in range(1,101) # 1..100
if x % 2 == 0

As we see both languages allow for working with data and sequences, but in my view F# beats Python both in succinctness, typing and capabilities here.

Reading a JSON file

As an example task, we want to read some fields in a json file, so parse it and display the captured value on the console.

In Python

import json
with open('test.json', 'r') as myfile:
data =
obj = json.loads(data)

In F# with JsonParser

#r "nuget: FSharp.Data"
open FSharp.Data
open FSharp.Data.JsonExtensions // ? op
let result =
(__SOURCE_DIRECTORY__ + "/test.json")
|> System.IO.File.ReadAllText
|> JsonValue.Parse
printfn $"{result?Hello}"

In F# with Type Providers

#r "nuget: FSharp.Data"
open FSharp.Data
let jsonFilePath = __SOURCE_DIRECTORY__ + @"/test.json"
type MyJson = JsonProvider<jsonFilePath>
let result = MyJson.Load(__SOURCE_DIRECTORY__ + "/prod.json")
printfn $"{result.Hello}" //strongly typed!

Reading a CSV file



import csv

with open('test.csv') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')

for row in csv_reader:
print(row[0]) //Name


#r "nuget: FSharp.Data"
open FSharp.Data
let csvPath = __SOURCE_DIRECTORY__ + "/test.csv"
type MyCsv = CsvProvider<csvPath, ",">
for row in MyCsv.GetSample().Rows do
printfn $"{row.Name}" // first column header = Name

Plotting some lines with Plotly


import as px

df = list(range(1, 11)) //1...10
fig = px.line(df)


#r "nuget: XPlot.Plotly"

open XPlot.Plotly

[ 1 .. 10 ] |> Chart.Line |> Chart.Show

Starting a local web server


from flask import Flask

app = Flask(__name__)

def index():
return 'Hello World!''', port=81)


#r "nuget: Suave"
open Suave
startWebServer defaultConfig (Successful.OK "Hello World!")