Archive for February, 2017

Python : Basic statistics with the numpy module

The numpy module features some useful functions for statistics, like “mean()” and “median()”:

For example let´s consider a 2D array with age and height of some people and print out some statistics:

#! /usr/bin/env python
import numpy as np

#age, height in meters
person = [[11,1.56],[4, 0.80], [44, 1.88], [23, 1.68], [55, 1.74]]

np_person = np.array(person)


age = np_person[:,0]

height = np_person[:,1]
print("average age: " + str(np.mean(age)))
print("average height: " + str(np.mean(height)))

#the standard deviation is also rounded to two decimals only.
std_height= round(np.std(height),2)

print("standard deviation of the height: "+ str(std_height))

corr = np.corrcoef(np_person[:,0], np_person[:,1])
print("Correlation: " + str(corr))

The code can be also found on github:

Python scripting with Linux: which shebang?

If you want to execute python scripts with Linux you need to add the shebang line: “#! /usr/bin/env python”

It must be added on top of the file.

The shebang will allow you to run the script as any other script. Among the many options to run it, assuming the script name is “script”, one is:

> ./

The file must be made executable:

>  sudo chmod +x

Assuming we want to print an homogenous array created with the numpy module, a script might include the module import too:

#! /usr/bin/env python

import numpy as np

array1 = np.array([1,2,3,4])



It will print the following lines:

[1 2 3 4]
<type ‘numpy.ndarray’>



Files and directories in Java: the NIO.2 Approach

In the previous post I told you about the old fashioned way to handle files in java.
In this article we will focus on the new API.
The File class is no longer used. We will use the “Path” class instead.
Files is a utility class to create either files or directories, that takes a path in the constructor:

	Path filePath=Paths.get("/home/laura/demo.txt");
	Path dirPath=Paths.get("/home/laura/newdir");
	Path nestedDirPath=Paths.get("/home/laura/newdir3/newdir4");

The “createDirectories” method created the whole file system structure (the nested directories).

With NIO.2 copying or deleting a file or directory have become a matter of one line of code, thanks to the very straightforward methods “copy”, “delete”, etc.

Many things can be achieved with the utility classes Files and Paths.

Java IO: Handling characters files efficiently

Let´s take a look a the classic IO file handling in java.
First let´s start with the “File” class.
The File class is not used to read or write data. It´s used to create or delete files and directories, for searching and working with paths.
So it´s not used for the files or directories content.

The File class constructor does not create anything on the hard drive. As you can see in the following snippet, you need to use the createNewFile method for it:

		File file = new File("/home/laura/demo.txt");
		System.out.println("Does the file exists?"+file.exists());
		boolean created = file.createNewFile();
		System.out.println("File created?"+created);
		System.out.println("Does the file exists?"+file.exists());

The createNewFile method returns “false” if the file already exists.

If the goal is handling text files, you don´t need to use any Stream class. All you need is a writer one. The basic option is to use the naked “FileReader” and “FileWriter” classes:

		FileWriter fileWriter= new FileWriter(file);
		fileWriter.write("hello world. this is a text file.");
		FileReader fileReader= new FileReader(file);
		char[] in = new char[100];		
		int size =;
		System.out.println("File size:"+size);
		for(char c: in){

The FileReader method “read” delivers the amount of character read.

Notice that after writing the text into the file, you need to call the method “flush”. It´s necessary to call it to make sure that the whole data flows into the file before closing the writer.

So far so good. But this simple way shown above is not the most elegant solution out there, because we have been using an array (that has a fixed size)!

A much better approach is wrapping it up using the classes BufferedReader and BufferedWriter:

		FileWriter fileWriter= new FileWriter(file);
		BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
		bufferedWriter.write("hello world. this is a text file.");
		bufferedWriter.write("You are using the buffered reader now!");			
		FileReader fileReader= new FileReader(file);
		BufferedReader bufferedReader = new BufferedReader(fileReader);
		String data;			

Notice that buffered reader also has a method called “readLine”, that you wouldn´t get with a simple File reader.
Once you close a writer it cannot be reopened again. You get an exception if you use it after closing it!

Debugging and Testing in Java : enabling assertions

For testing and debugging purposes you can enable the assertions evaluation with the VM parameter “-ea” ( or “-enableassertions” if you prefer the whole thing).

The assertions remain in the code and are just ignored at runtime if you don´t enable them. You can think of them as an aid in case of need.

The following method throws an exception if the parameter given is not a String containing “Laura”:

         private void testFirstName(String firstName){

               System.out.println("The given first name is Laura");

A string message can be displayed in the stack trace, by adding a second expression to the assertion, like :

	private void testFirstName(String firstName){
		assert(firstName.equals("Laura")) : "the name "+ firstName+ " is not Laura!";
		System.out.println("The given first name is Laura");

The output in this second case would be something like:

Exception in thread "main" java.lang.AssertionError: the name Anna is not Laura!
at com.demo.AssertionsDemo.testFirstName(
at com.demo.AssertionsDemo.main(

Since Java 1.4 “assert” has become a keyword.

Assertions can be disabled with the VM option “-da” or “-disableassertions”. Although the assertions are disabled by default, the manual disabling might make sense if you don´t want to enable the assertions for all the classes.

For example if you want to run a java jar file (for example “demo.jar”), but disabling the assertions for one of its classes (ex. “”) you need to use the following parameters:

> java -jar -ea -da:com.demo.Demo

To disable them for the whole “com.demo” package (including subpackages):

> java -jar -ea -da:com.demo...

So entering VM parameters like “-ea:” or “-ea:” allow you to select which assertions to evaluate.