for Pythonistas¶

TL;DR: Julia looks and feels a lot like Python, only much faster. It's dynamic, expressive, extensible, with batteries included, in particular for Data Science.

This notebook is an introduction to Julia for Python programmers.

It will go through the most important Python features (such as functions, basic types, list comprehensions, exceptions, generators, modules, packages, and so on) and show you how to code them in Julia.

You can either run this notebook in Google Colab, or using Jupyter on your own machine.

Setup¶

Let's start by installing some libraries needed in this notebook (I'll explain this code later in this notebook). This will take about one minute on Colab.

If you prefer to run this notebook on your machine instead of Google Colab:

• Download this notebook (File > Download .ipynb)

• Install Julia

• Run the following command in a terminal to install IJulia (the Jupyter kernel for Julia), and a few packages we will use:

  julia -e 'using Pkg
          pkg"add IJulia; precompile;"
          pkg"add BenchmarkTools; precompile;"
          pkg"add PyCall; precompile;"
          pkg"add PyPlot; precompile;"'
  

• Next, go to the directory containing this notebook:

  cd /path/to/notebook/directory
  

• Start Jupyter Notebook:

  julia -e 'using IJulia; IJulia.notebook()'
  

  Or replace notebook() with jupyterlab() if you prefer JupyterLab.

  If you do not already have Jupyter installed, IJulia will propose to install it. If you agree, it will automatically install a private Miniconda (just for Julia), and install Jupyter and Python inside it.

• Lastly, open this notebook and skip directly to the next section.

Checking the Installation¶

The versioninfo() function should print your Julia version and some other info about the system (if you ever ask for help or file an issue about Julia, you should always provide this information).

Getting Help¶

To get help on any module, function, variable, or just about anything else, just type ? followed by what you're interested in. For example:

This works in interactive mode only: in Jupyter, Colab and in the Julia shell (called the REPL).

Here are a few more ways to get help and inspect objects in interactive mode:

If you ever ask for help or file an issue about Julia, you should generally provide the output of versioninfo().

And of course, you can also learn and get help here:

• Learning: https://julialang.org/learning/
• Documentation: https://docs.julialang.org/
• Questions & Discussions:
  • https://discourse.julialang.org/
  • http://julialang.slack.com/
  • https://stackoverflow.com/questions/tagged/julia

A First Look at Julia¶

This section will give you an idea of what Julia looks like and what some of its major qualities are: it's expressive, dynamic, flexible, and most of all, super fast.

Estimating π¶

Let's write our first function. It will estimate π using the equation: $π = 4 \times \left(1 - \dfrac{1}{3} + \dfrac{1}{5} - \dfrac{1}{7} + \dfrac{1}{9}-\dfrac{1}{11}+\dots\right)$

There are much better ways to estimate π, but this one is easy to implement.

Compare this with the equivalent Python 3 code:

Pretty similar, right? But notice the small differences:

This example shows that:

• Julia can be just as concise and readable as Python.
• Indentation in Julia is not meaningful like it is in Python. Instead, blocks end with end.
• Many math features are built in Julia and need no imports.
• There's some mathy syntactic sugar, such as 2i (but you can write 2 * i if you prefer).
• In Julia, the return keyword is optional at the end of a function. The result of the last expression is returned (4s in this example).
• Julia loves Unicode and does not hesitate to use Unicode characters like π. However, there are generally plain-ASCII equivalents (e.g., π == pi).

Typing Unicode Characters¶

Typing Unicode characters is easy: for latex symbols like π, just type \pi<tab>. For emojis like 😃, type \:smiley:<tab>.

This works in the REPL, in Jupyter, but unfortunately not in Colab (yet?). As a workaround, you can run the following code to print the character you want, then copy/paste it:

In Julia, using Foo.Bar: a, b corresponds to running from foo.bar import a, b in Python.

More on this later.

Running Python code in Julia¶

Julia lets you easily run Python code using the PyCall module. We installed it earlier, so we just need to import it:

Now that we have imported PyCall, we can use the pyimport() function to import a Python module directly in Julia! For example, let's check which Python version we are using:

In fact, let's run the Python code we discussed earlier (this will take about 15 to 20 seconds to run, because Python is so slow...):

As you can see, running arbitrary Python code is as simple as using py-strings (py"..."). Note that py-strings are not part of the Julia language itself: they are defined by the PyCall module (we will see how this works later).

We can look at the value of p:

Let's compare this to the value we calculated above using Julia:

Perfect, they are exactly equal!

As you can see, it's very easy to mix Julia and Python code. So if there's a module you really love in Python, you can keep using it as long as you want! For example, let's use NumPy:

Notice that PyCall automatically converts some Python types to Julia types, including NumPy arrays. That's really quite convenient! Note that Julia supports multi-dimensional arrays (analog to NumPy arrays) out of the box. Array{Float64, 2} means that it's a 2-dimensional array of 64-bit floats.

PyCall also converts Julia arrays to NumPy arrays when needed:

If you want to use some Julia variable in a py-string, for example exp_a, you can do so by writing $exp_a like this:

If you want to keep using Matplotlib, it's best to use the PyPlot module (which we installed earlier), rather than trying to use pyimport("matplotlib"), as PyPlot provides a more straightforward interface with Julia, and it plays nicely with Jupyter and Colab:

That said, Julia has its own plotting libraries, such as the Plots library, which you may want to check out.

As you can see, Julia's range() function acts much like NumPy's linspace() function, when you use the length argument. However, it acts like Python's range() function when you use the step argument instead (except the upper bound is inclusive). Julia's range() function returns an object which behaves just like an array, except it doesn't actually use any RAM for its elements, it just stores the range parameters. If you want to collect all of the elements into an array, use the collect() function (similar to Python's list() function):

The equivalent Python code is:

# PYTHON
print(list(range(10, 80+1, 20)))
# there's no short-hand for range() in Python
print(np.linspace(10, 80, 5))
step = (80-10)/(5-1) # 17.5
print([i*step + 10 for i in range(5)])

Loop Fusion¶

Did you notice that we wrote sin.(x) ./ x (not sin(x) / x)? This is equivalent to [sin(i) / i for i in x].

This is not just syntactic sugar: it's actually a very powerful Julia feature. Indeed, notice that the array only gets traversed once. Even if we chained more than two dotted operations, the array would still only get traversed once. This is called loop fusion.

In contrast, when using NumPy arrays, sin(x) / x first computes a temporary array containing sin(x) and then it computes the final array. Two loops and two arrays instead of one. NumPy is implemented in C, and has been heavily optimized, but if you chain many operations, it still ends up being slower and using more RAM than Julia.

However, all the extra dots can sometimes make the code a bit harder to read. To avoid that, you can write @. before an expression: every operation will be "dotted" automatically, like this:

Note: Julia's @assert statement starts with an @ sign, just like @., which means that they are macros. In Julia, macros are very powerful metaprogramming tools: a macro is evaluated at parse time, and it can inspect the expression that follows it and then transform it, or even replace it. In practice, you will often use macros, but you will rarely define your own. I'll come back to macros later.

Julia is fast!¶

Let's compare the Julia and Python implementations of the estimate_pi() function:

To get a more precise benchmark, it's preferable to use the BenchmarkTools module. Just like Python's timeit module, it provides tools to benchmark code by running it multiple times. This provides a better estimate of how long each call takes:

If this output is too verbose for you, simply use @btime instead:

Now let's time the Python version. Since the call is so slow, we just run it once (it will take about 15 seconds):

It looks like Julia is over 150 times faster than Python in this case! To be fair, PyCall does add some overhead, but even if you run this code in a separate Python shell, you will see that Julia crushes (pure) Python when it comes to speed.

So why is Julia so much faster than Python? Well, Julia compiles the code on the fly as it runs it.

Okay, let's summarize what we learned so far: Julia is a dynamic language that looks and feels a lot like Python, you can even execute Python code super easily, and pure Julia code runs much faster than pure Python code, because it is compiled on the fly. I hope this convinces you to read on!

Next, let's continue to see how Python's main constructs can be implemented in Julia.

Numbers¶

And the equivalent Python code:

# PYTHON
i = 42
f = 3.14
c = 3.4 + 4.5j

bi = 2**1000 # integers are seemlessly promoted to long integers
from decimal import Decimal
bf = Decimal(1) / 7

from fractions import Fraction
r = Fraction(15, 6) * Fraction(9, 20)

Dividing integers gives floats, like in Python:

For integer division, use ÷ or div():

The % operator is the remainder, not the modulo like in Python. These differ only for negative numbers:

Strings¶

Julia strings use double quotes " or triple quotes """, but not single quotes ':

Use repeat() instead of * to repeat a string, and use * instead of + for concatenation:

The equivalent Python code is:

# PYTHON
s = "tick, " * 10 + "BOOM!"
print(s)

Use join(a, s) instead of s.join(a):

You can also specify a string for the last join:

split() works as you might expect:

Triple quotes work a bit like in Python, but they also remove indentation and ignore the first line feed:

String Interpolation¶

String interpolation uses $variable and $(expression):

This means you must escape the $ sign:

Raw Strings¶

Raw strings use raw"..." instead of r"...":

Characters¶

Single quotes are used for individual Unicode characters:

To be more precise:

• A Julia "character" represents a single Unicode code point (sometimes called a Unicode scalar).
• Multiple code points may be required to produce a single grapheme, i.e., something that readers would recognize as a single character. Such a sequence of code points is called a "Grapheme cluster".

For example, the character é can be represented either using the single code point \u00E9, or the grapheme cluster e + \u0301:

Julia represents any individual character like 'é' using 32-bits (4 bytes):

But strings are represented using the UTF-8 encoding. In this encoding, code points 0 to 127 are represented using one byte, but any code point above 127 is represented using 2 to 6 bytes:

You can iterate through graphemes instead of code points:

String Indexing¶

Characters in a string are indexed based on the position of their starting byte in the UTF-8 representation. For example, the character ê in the string "être" is located at index 1, but the character 't' is located at index 3, since the UTF-8 encoding of ê is 2 bytes long:

If you try to get the character at index 2, you get an exception:

By the way, notice the exception-handling syntax (we'll discuss exceptions later):

You can get a substring easily, using valid character indices:

You can iterate through a string, and it will return all the code points:

Or you can iterate through the valid character indices:

Benefits of representing strings as UTF-8:

• All Unicode characters are supported.
• UTF-8 is fairly compact (at least for Latin scripts).
• It plays nicely with C libraries which expect ASCII characters only, since ASCII characters correspond to the Unicode code points 0 to 127, which UTF-8 encodes exactly like ASCII.

Drawbacks:

• UTF-8 uses a variable number of bytes per character, which makes indexing harder.
  • However, If the language tried to hide this by making s[5] search for the 5th character from the start of the string, then code like for i in 1:length(s); s[i]; end would be unexpectedly inefficient, since at each iteration there would be a search from the beginning of the string, leading to O(n²) performance instead of O(n).

Other useful string functions: ncodeunits(str), codeunit(str, i), thisind(str, i), nextind(str, i, n=1), prevind(str, i, n=1).

Regular Expressions¶

To create a regular expression in Julia, use the r"..." syntax:

The expression r"..." is equivalent to Regex("...") except the former is evaluated at parse time, while the latter is evaluated at runtime, so unless you need to construct a Regex dynamically, you should prefer r"...".

Control Flow¶

if statement¶

Julia's if statement works just like in Python, with a few differences:

• Julia uses elseif instead of Python's elif.
• Julia's logic operators are just like in C-like languages: && means and, || means or, ! means not, and so on.

Julia also has ⊻ for exclusive or (you can type \xor<tab> to get the ⊻ character):

Oh, and notice that true and false are all lowercase, unlike Python's True and False.

Since && is lazy (like and in Python), cond && f() is a common shorthand for if cond; f(); end. Think of it as "cond then f()":

Similarly, cond || f() is a common shorthand for if !cond; f(); end. Think of it as "cond else f()":

All expressions return a value in Julia, including if statements. For example:

When an expression cannot return anything, it returns nothing:

nothing is the single instance of the type Nothing:

for loops¶

You can use for loops just like in Python, as we saw earlier. However, it's also possible to create nested loops on a single line:

The corresponding Python code would look like this:

# PYTHON
from itertools import product

for a, b, c in product(range(1, 3), range(1, 4), range(1, 3)):
    print((a, b, c))

The continue and break keywords work just like in Python. Note that in single-line nested loops, break will exit all loops, not just the inner loop:

Julia does not support the equivalent of Python's for/else construct. You need to write something like this:

The equivalent Python code looks like this:

# PYTHON
for person in ["Joe", "Jane", "Wally", "Jack", "Julia"]: # try removing "Wally"
    print(f"Looking at {person}")
    if person == "Wally":
        break
else:
    print("I did not find Wally.")

Now lets looks at data structures, starting with tuples.

Tuples¶

Julia has tuples, very much like Python. They can contain anything:

Let's look at one element:

Hey! Did you see that? Julia is 1-indexed, like Matlab and other math-oriented programming languages, not 0-indexed like Python and most programming languages. I found it easy to get used to, and in fact I quite like it, but your mileage may vary.

Moreover, the indexing bounds are inclusive. In Python, to get the 1st and 2nd elements of a list or tuple, you would write t[0:2] (or just t[:2]), while in Julia you write t[1:2].

Note that end represents the index of the last element in the tuple. So you must write t[end] instead of t[-1]. Similarly, you must write t[end - 1], not t[-2], and so on.

Like in Python, tuples are immutable:

The syntax for empty and 1-element tuples is the same as in Python:

You can unpack a tuple, just like in Python (it's called "destructuring" in Julia):

It also works with nested tuples, just like in Python:

However, consider this example:

In Python, this would cause a ValueError: too many values to unpack. In Julia, the extra values in the tuple are just ignored.

If you want to capture the extra values in the variable c, you need to do so explicitly:

Or more concisely:

The corresponding Python code is:

# PYTHON
t = (1, "Two", 3, 4, 5)
a, b, *c = t
print(f"a={a}, b={b}, c={c}")

Named Tuples¶

Julia supports named tuples:

The corresponding Python code is:

# PYTHON
from collections import namedtuple

Rating = namedtuple("Rating", ["name", "category", "stars"])
nt = Rating(name="Julia", category="Language", stars=5)
print(nt.name) # prints: Julia
print(nt) # prints: Rating(name='Julia', category='Language', stars=5)

Structs¶

Julia supports structs, which hold multiple named fields, a bit like named tuples:

Structs have a default constructor, which expects all the field values, in order:

You can create other constructors by creating functions with the same name as the struct:

This creates two constructors: the second calls the first, which calls the default constructor. Notice that you can create multiple functions with the same name but different arguments. We will discuss this later.

These two constructors are called "outer constructors", since they are defined outside of the definition of the struct. You can also define "inner constructors":

This time, the outer constructor calls the inner constructor, which calls the new() function. This new() function only works in inner constructors, and of course it creates an instance of the struct.

When you define inner constructors, they replace the default constructor:

Structs usually have very few inner constructors (often just one), which do the heavy duty work, and the checks. Then they may have multiple outer constructors which are mostly there for convenience.

By default, structs are immutable:

However, it is possible to define a mutable struct:

Structs look a lot like Python classes, with instance variables and constructors, but where are the methods? We will discuss this later, in the "Methods" section.

Arrays¶

Let's create a small array:

Indexing and assignments work as you would expect:

Element Type¶

Since we used only integers when creating the array, Julia inferred that the array is only meant to hold integers (NumPy arrays behave the same way). Let's try adding a string:

Nope! We get a MethodError exception, telling us that Julia could not convert the string "Three" to a 64-bit integer (we will discuss exceptions later). If we want an array that can hold any type, like Python's lists can, we must prefix the array with Any, which is Julia's root type (like object in Python):

Prefixing with Float64, or String or any other type works as well:

An empty array is automatically an Any array:

You can use the eltype() function to get an array's element type (the equivalent of NumPy arrays' dtype):

If you create an array containing objects of different types, Julia will do its best to use a type that can hold all the values as precisely as possible. For example, a mix of integers and floats results in a float array:

This is similar to NumPy's behavior:

# PYTHON
np.array([1, 2, 3.0, 4.0]) # => array([1., 2., 3., 4.])

A mix of unrelated types results in an Any array:

If you want to live in a world without type constraints, you can prefix all you arrays with Any, and you will feel like you're coding in Python. But I don't recommend it: the compiler can perform a bunch of optimizations when it knows exactly the type and size of the data the program will handle, so it will run much faster. So when you create an empty array but you know the type of the values it will contain, you might as well prefix it with that type (you don't have to, but it will speed up your program).

Push and Pop¶

To append elements to an array, use the push!() function. By convention, functions whose name ends with a bang ! may modify their arguments:

This is similar to the following Python code:

# PYTHON
a = [1]
a.append(4)
a.extend([9, 16]) # or simply a += [9, 16]

And pop!() works like in Python:

Equivalent to:

# PYTHON
a.pop()

There are many more functions you can call on an array. We will see later how to find them.

Multidimensional Arrays¶

Importantly, Julia arrays can be multidimensional, just like NumPy arrays:

Another syntax for this is:

You can index them much like NumPy arrays:

You can transpose a matrix using the "adjoint" operator ':

As you can see, Julia arrays are closer to NumPy arrays than to Python lists.

Arrays can be concatenated vertically using the vcat() function:

Alternatively, you can use the [M1; M2] syntax:

To concatenate arrays horizontally, use hcat():

Or you can use the [M1 M2] syntax:

As you can see, the semicolon ; is used to concatenate along the 1^st axis, while the space is used to concatenate along the 2^nd axis.

Since Julia 1.7, it's possible to use ;; instead of the space to concatenate along the 2^nd axis, ;;; to concatenate along the 3^rd axis, ;;;; along the 4^th axis, and so on. For example, the following code creates a 4x3x2 array in Julia 1.7+ (however, it creates a vector with numbers 1 to 24 in Julia 1.6 and earlier):

Note that Julia arrays are column-major, as opposed to row-major like NumPy arrays. This means that in memory, the elements are listed by column first (as well as in the syntax in the previous cell). For example, the elements of the previous array are stored in memory in the following order: 1, 2, 3, ..., 24 (whereas NumPy would store them as 1, 13, 5, 17, 9, 21, 2, 14, 6, 18, and so on).

For this reason, the fastest way to iterate over a Julia array using nested for loops is to use the outer for loop for the last dimension, and the inner for loop for the first dimension (the opposite is true with NumPy).

For this reason, in Julia Machine Learning frameworks like Flux, the batch dimension is typically the last one, instead of the first one in Python frameworks like TensorFlow or PyTorch.

You can combine horizontal and vertical concatenation:

Equivalently, you can call the hvcat() function. The first argument specifies the number of arguments to concatenate in each block row:

hvcat() is useful to create a single cell matrix:

Or a column vector (i.e., an n×1 matrix = a matrix with a single column):

If you are using Julia 1.7+, you can use this syntax instead to create a single cell matrix:

Or a column vector:

Alternatively, you can transpose a row vector (but hvcat() and the Julia 1.7 syntax are a bit faster):

The REPL and IJulia call display() to print the result of the last expression in a cell (except when it is nothing). It is fairly verbose:

The println() function is more concise, but be careful not to confuse vectors, column vectors and row vectors (printed with commas, semi-colons and spaces, respectively):

Before Julia 1.7, the column vector was printed as [1; 2; 3; 4], but evaluating [1; 2; 3; 4] would give you a regular vector. That's because [x;y] concatenates x and y vertically, and if x and y are scalars or vectors, you just get a regular vector. Since Julia 1.7, the column vector is printed as [1; 2; 3; 4;;].

Comprehensions¶

List comprehensions are available in Julia, just like in Python (they're usually just called "comprehensions" in Julia):

You can filter elements using an if clause, just like in Python:

• a ∉ b is equivalent to !(a in b) (or a not in b in Python). You can type ∉ with \notin<tab>
• a ∈ b is equivalent to a in b. You can type it with \in<tab>

In Julia, comprehensions can contain nested loops, just like in Python:

Here's the corresponding Python code:

# PYTHON
a = [(i, j) for i in range(1, 4) for j in range(1, i+1)]

Julia comprehensions can also create multi-dimensional arrays (note the different syntax: there is only one for):

Dictionaries¶

The syntax for dictionaries is a bit different than Python:

The equivalent Python code is of course:

d = {"tree": "arbre", "love": "amour", "coffee": "café"}
d["tree"]
d.get("unknown", "pardon?")
d.keys()
d.values()
"love" in d
"love" in d.keys()

Dict comprehensions work as you would expect:

Note that the items (aka "pairs" in Julia) are shuffled, since dictionaries are hash-based, like in Python (although Python sorts them by key for display).

You can easily iterate through the dictionary's pairs like this:

The equivalent code in Python is:

# PYTHON
d = {i: i**2 for i in range(1, 6)}
for k, v in d.items():
    print(f"{k} maps to {v}")

And you can merge dictionaries like this: