Regular

So, now you’ve learnt about Scala lists. As you could see in the previous
examples, Scala has a very functional kind of lists, as these are immutable.

If you are ever to use Scala as a functional programming language this is the
way to go. I really recommend you to, at least, try to learn this paradigm, as
it is design purpose and has many advantages. But, then again, even now I
sometimes go back to imperative programming in Scala myself because is more
natural to me. Scala as imperative language is pretty similar to Java, so as a
side effect I ended up learning how to read Java code (I knew some Java but only
the basics, learning Scala my Java understanding improved a lot).

But, lets say that functional programming is way too much to deal with now and
you want to know a type more similar to Python lists, the oldie but goodie
mutable lists. You have a couple of options of data structures available in
Scala, I’ll present two of the most commons.

Scala Arrays

Ok, if my university’s data structure teacher sees me presenting Scala arrays as
an option for a “mutable” list he probably would take away my degree and force
me to redo the Computer Sciences career all over again.

An array is not a list and will never be one. But, for someone who comes
from a Python environment, it’s probably an easy option to replace a immutable
list for a mutable version.

Arrays are the simplest and one of the oldest (if not the oldest) data
structure you’ll ever face with. In fact, most high-level programming languages
lists are internally implemented as arrays. If you’ve ever deal with a real old
imperative programming language (I’m looking at you C developer), you are
familiar to the concept of array. The thing is that Python doesn’t really have
them (at least not internally, you’ll have to import a module for dealing with
arrays).

Arrays have some pros and cons in programming, as every data structure. Among
the most common pros of an array you’ll find the efficiency they carry in
comparison to lists. As arrays are represented as collection of elements (of the
same type) stored in a continuous space of memory. They differ from lists in
that you’ll have an index for all the elements (which makes the access time of a
constant order) and in general are faster to make operations than in lists which
can have chunks of elements sparse in many places.

Following with the series in this crash course from Python to Scala, today I’ll
introduce one of the most useful Scala’s data structures and make the comparison
to Python.

Scala Lists

Starting off with one of the most used data structures in Scala (and in
functional languages in general) and also the most common data structure in
Python as well: the lists.

A list in Scala is a data structure to represent a collection of values of the
same type. Lists are very used in Python, and the concept is quite similar in
Scala, with a couple of exceptions. First, in Python are written as a list of
comma-separated values between square brackets. The empty list, is represented
as a pair of empty square brackets:

Following my series of tutorial of Scala for Python programmers, I’ll start to
talk about something most Python programmers don’t usually pay attention to
because the language doesn’t require it to do so.

Scala Types

I’m talking about data types. It’s not that Python doesn’t have types for its
variables, but as it is a dynamically typed programming language, you usually
don’t care about the type of the variable. At least not unless you try to add a
number and a letter: you cannot add apple and oranges, naturally you cannot add
strings and numbers (not at least without conversion first):

In general terms, however, Python won’t bother about the type you are giving to
your variables: actually, you won’t be able to declare a type for them as Python
will infer it. So, this is perfectly normal for a Python program:

string="This is a string"print(string)# Will output "This is a string"string+100# Invalid. Will result in a TypeError exception.string=100# Perfectly valid. `string` type will be int from now on.print(string)# Will output 100string+100# Valid. Will result in 200.

This is the first post in a series in which I’ll try to give a nice insight for
the Scala Language to a programmer with background in Python. I chose to do
these posts since, at least when I started this series, the “Scala for people
coming from Python” tutorial was a work in progress.

First of all I’ll state some of my background (in case you didn’t check my
about page), in a kind of a disclaimer. There
are people out there who are experts in Python. I’m not one of them. I only have
a background of 4 years in this language, and only work with the 2.X version
(started with 2.5 until 2.7). Never even try to learn Python 3. Also, there are
experts on Scala as well, I’m not one of those either. In fact, my Scala
knowledge is far from deep, I learned Scala at the end of last year and been
using it since then (along with Python).

There are people out there who are experts in Python. I’m not one of them. […]
Also, there are experts on Scala as well, I’m not one of those either.

Once you know this, I’ll just say I have enough knowledge of both Scala and
Python to get by. I’ve done some projects in Django and some projects in Play
Framework, but nothing really impressive. The reason I’m doing this set of
tutorials is because when I started to learn Scala I didn’t have one and many
times I end up in Stackoverflow looking for how to do in Scala things I did in
Python.

As every programmer trying to learn a new language, I think is suitable for me
to start this professional blog with a Hello World. So, in this first blog post
I say Hello World!

This is the first blog I’ve created that has relation with what I do for a
living. The only other surviving blog is a personal one (and is in Spanish
also).

The aim of this place is to write about Computer Sciences problems and solutions
I came across to overcome them, most of them of course are programming ones.

As I said in my about page, I was for a long time a Python programmer, but now I
turn myself into the world of Scala and it has so interesting I’ve practically
abandoned my old time coding Python skills (of course, with Python, is never
that hard to return).