<h2 id="whatareiterators">What are Iterators?</h2>
An iterator in Python refers to an object that we can iterate upon. The iterator consists of countable values, and it is possible to traverse through these values, one by one.
The iterator simply implements the Python's iterator protocol. The iterator protocol is a Python class which comes with two special methods, namely <code>__iter__()</code> and <code>__next__()</code>. With these two methods, the iterator is able to compute the next value in the iteration.
With iterators, it is easy for us to work with sequences of items in Python. We don't have to allocate computing resources to all the items in the sequence, rather we iterate upon single item at a time which helps us save the memory space.
In this article, we will study how to work with iterators in Python.
<h2 id="iterableobjectsinpython">Iterable Objects in Python</h2>
An iterable is an object capable of returning an iterator. An iterable can represent both finite and infinite data sources. The iterable directly or indirectly implements the two methods: <code>__iter__()</code> and <code>__next__()</code>. The <code>__iter__()</code> method returns the iterator object while the <code>__next__()</code> method helps us traverse the elements in the iterable object.
Examples of iterable objects in Python include Lists, dictionaries, tuples, and sets.
<h2 id="creatinganiterator">Creating an Iterator</h2>
In Python, we create an iterator by implementing the <code>__iter__()</code> and <code>__next__()</code> methods on the object. Consider the following example:
<pre><code class="hljs">class IterationExample:
 def __iter__(self):
 self.x = 0
 return self

 def __next__(self):
 y = self.x
 self.x += 1
 return y

classinstance = IterationExample()
element = iter(classinstance)
</code></pre>
We have created an iterator named <code>element</code> that prints numbers from 0 to N. We first created an instance of the class and we gave it the name <code>classinstance</code>. We then called the <code>iter()</code> built-in method and passed the name of the class instance as the parameter. This creates the iterator object.
Let us now discuss how to use an iterator to actually iterate through the items.
<h2 id="iteratingthroughaniterator">Iterating through an Iterator</h2>
The <code>next()</code> method helps us iterate through the elements of an iterator. Let us demonstrate this with the example given above:
<pre><code class="hljs">class IterationExample:
 def __iter__(self):
 self.x = 0
 return self

 def __next__(self):
 y = self.x
 self.x += 1
 return y

classinstance = IterationExample()
element = iter(classinstance)

print(next(element))
print(next(element))
print(next(element))
print(next(element))
print(next(element))
print(next(element))
print(next(element))
print(next(element))
print(next(element))
print(next(element))
</code></pre>
Output
<pre><code class="hljs">0
1
2
3
4
5
6
7
8
9
</code></pre>
In the script above, we called the <code>next()</code> method and passed the name of the iterator element to the method as the parameter. Every time we do this, the iterator moves to the next element in the sequence. Here is another example:
<pre><code class="hljs"># create a list
list1 = [0, 5, 10, 15]

# create an iterator
element = iter(list1)

## use next() to traverse/iterate through the list elements

# prints first element, 0
print(next(element))

# prints second element, 5
print(next(element))

## next(element) is similar to element.__next__()

# prints third element, 10
print(element.__next__())

# prints fourth element, 15
print(element.__next__())
</code></pre>
Output
<pre><code class="hljs">0
5
10
15
</code></pre>
In the script above, we created a list named <code>list1</code>, which has 4 integers. An iterator named <code>element</code> has been created. The <code>next()</code> method has helped us iterate through the list elements.
<h2 id="iterationwiththeforloop">Iteration with the &quot;for&quot; Loop</h2>
The <code>for</code> loop helps us iterate through any object capable of returning an iterator. For example:
<pre><code class="hljs"># create a list
list1 = [0, 5, 10, 15]

# create an iterator
element = iter(list1)

# iterate with a for loop
for x in element:
 print(x)
</code></pre>
Output
<pre><code class="hljs">0
5
10
15
</code></pre>
In the above code, we created a variable named <code>x</code>, which is used to iterate through the iterator <code>element</code> via a <code>for</code> loop.
<h2 id="infiniteiterators">Infinite Iterators</h2>
An infinite iterator is an iterator with infinite number of iterations. We must be extra careful when dealing with infinite iterators. Consider the following example:
<pre><code class="hljs">class IterationExample:
 def __iter__(self):
 self.x = 0
 return self

 def __next__(self):
 y = self.x
 self.x += 1
 return y

classinstance = IterationExample()
element = iter(classinstance)

for x in element:
 print(x)
</code></pre>
The above code will run forever. To stop it, you will have to intervene manually. Here is another example demonstrating how to create an infinite iterator in Python:
<pre><code class="hljs">class Infinite:
 # Print all even numbers

 def __iter__(self):
 self.x = 0
 return self

 def __next__(self):
 x = self.x
 self.x += 2
 return x
</code></pre>
The code should return all even numbers, starting from 0. We can run the code as demonstrated below:
<pre><code class="hljs">&gt;&gt;&gt; y = iter(Infinite())
&gt;&gt;&gt; next(y)
0
&gt;&gt;&gt; next(y)
2
&gt;&gt;&gt; next(y)
4
&gt;&gt;&gt; next(y)
6
&gt;&gt;&gt; next(y)
8
&gt;&gt;&gt; next(y)
10
&gt;&gt;&gt;
</code></pre>
And the above chain can continue forever. This shows that with an infinite iterator, we can have an infinite number of items without having to store all of them in the memory.
In the next section, we will see how we can implement a mechanism to break out of such infinite iterators.
<h2 id="stoppinganiteration">Stopping an Iteration</h2>
In the previous section, we saw how to create an infinite iterator in Python. However, iterators are not usually meant for infinite iteration in Python. It is always convenient to implement a terminating condition.
We can stop an iterator from executing forever using the <code>StopIteration</code> statement. We only need to add a terminating condition in the <code>__next__()</code> method which will raise an error once the specified number of iterations has been reached. Here is an example:
<pre><code class="hljs">class StoppingIteration:
 def __iter__(self):
 self.x = 1
 return self

 def __next__(self):
 if self.x &lt;= 5:
 y = self.x
 self.x += 1
 return y
 else:
 raise StopIteration

classinstance = StoppingIteration()
element = iter(classinstance)

for a in element:
 print(a)
</code></pre>
Output
<pre><code class="hljs">1
2
3
4
5
</code></pre>
The execution halts after 5 iterations. This is because of the <code>self.x &lt;= 5:</code> condition added within the <code>__next__()</code> method. If the iterator is called after reaching 5, it will raise <code>StopIteration</code> event. Consider the example given below:
<pre><code class="hljs">class StoppingIteration:
 def __init__(self, max = 0):
 self.max = max

 def __iter__(self):
 self.x = 1
 return self

 def __next__(self):
 if self.x &lt;= self.max:
 val = 3 ** self.x
 self.x += 1
 return val
 else:
 raise StopIteration
</code></pre>
Let us create an iterator then iterate through it:
<pre><code class="hljs">&gt;&gt;&gt; y = StoppingIteration(3)
&gt;&gt;&gt; z = iter(y)
&gt;&gt;&gt; next(z)
3
&gt;&gt;&gt; next(z)
9
&gt;&gt;&gt; next(z)
27
&gt;&gt;&gt; next(z)
Traceback (most recent call last):
 File &quot;&lt;pyshell#5&gt;&quot;, line 1, in &lt;module&gt;
 next(z)
 File &quot;C:\Users\admin\iteration.py&quot;, line 17, in __next__
 raise StopIteration
StopIteration
&gt;&gt;&gt;
</code></pre>
The terminating condition has been implemented in the following section of our code:
<pre><code class="hljs">if self.x &lt;= self.max:
 val = 3 ** self.x
</code></pre>
We passed a value of 3 to the iterator, meaning that the iterator should not iterate beyond 27, that is, 3^3.
<h2 id="conclusion">Conclusion</h2>
Iterators are extremely useful, especially if you need to iterate through a large sequence of items. Iterators allow you to iterate through a sequence of items one at a time without having to load all the items in to memory at once.
In this article, we saw how to create iterators in Python and how to iterate through items in an iterator. We also saw how to create an infinite iterator and how to add terminating condition to an infinite iterator.

Nicholas Samuel

Introduction to Python Iterators

<h2 id="introduction">Introduction</h2>
One of the most &quot;obscure&quot; features of Python that almost all Python programmers use, even the beginner ones, but don't really understand, is context managers. You've probably seen them in the form of <code>with</code> statements, usually first encountered when you learn opening files in Python. Although context managers seem a little strange at first, when we really dive into them, understand the motivation and techniques behind it, we get access to a new weapon in our programming arsenal. So without further ado, let's dive into it!
<h2 id="motivationresourcemanagement">Motivation: Resource Management</h2>
<blockquote>
&quot;Necessity is the mother of invention&quot;
</blockquote>
To really understand what a context manager is and how we can use it, we must first investigate the motivations behind it — the necessities that gave rise to this &quot;invention&quot;.
The primary motivation behind context managers is resource management. When a program wants to get access to a resource on the computer, it asks the OS for it, and the OS, in turn, provides it with a handle for that resource. Some common examples of such resources are files and network ports. What's important to understand is that these resources have limited availability, for example, a network port can be used by a single process at a time, and there are a limited number of ports available. So whenever we open a resource, we have to remember to close it, so that the resource is freed. But unfortunately, it's easier said than done.
The most straightforward way to accomplish proper resource management would be calling the <code>close</code> function after we're done with the resource:
<pre><code class="hljs">opened_file = open(&#x27;readme.txt&#x27;)
text = opened_file.read()
...
opened_file.close()
</code></pre>
Here we are opening a file named <code>readme.txt</code>, reading the file and saving its contents in a string <code>text</code>, and then when we're done with it, closing the file by calling the <code>close()</code> method of the <code>opened_file</code> object. Now at first glance this might seem okay, but actually, it's not robust at all. If anything unexpected happens between opening the file and closing the file, causing the program to fail to execute the line containing the <code>close</code> statement, there would be a resource leak. These unexpected events are what we call <code>exceptions</code>, a common one would be when someone forcefully closes the program while it's executing.
Now, the proper way to handle this would be using Exception handling, using <code>try...else</code> blocks:
<pre><code class="hljs">try:
 opened_file = open(&#x27;readme.txt&#x27;)
 text = opened_file.read()
 #...
else:
 opened_file.close()
</code></pre>
Python always makes sure the code in the <code>else</code> block is executed, regardless of anything that might happen. This is the way programmers in other languages would handle resource management, but Python programmers get a special mechanism that lets them implement the same functionality without all the boilerplate. This is where context managers come into play!
<h2 id="implementingcontextmanagers">Implementing Context Managers</h2>
Now that we are done with the most crucial part about understanding context managers, we can jump into implementing them. For this tutorial, we will implement a custom <code>File</code> class. It's totally redundant as Python already provides this, but nevertheless, it'll be a good learning exercise as we'll always be able to relate back to the <code>File</code> class that's already there in the standard library.
The standard and &quot;lower-level&quot; way of implementing a context manager is defining two &quot;magic&quot; methods in the class you want to implement resource management for, <code>__enter__</code>and <code>__exit__</code>. If you're getting lost-thinking, &quot;what's this magic method thingy? I've never heard of this before&quot; - well, if you've started doing object-oriented programming in Python, you surely have encountered a magic method already, the method <code>__init__</code>.
For lack of better words, they're special methods that you can define to make your classes smarter or add &quot;magic&quot; to them. You can find a nice reference list of all the magic methods available in Python <a rel="nofollow" target="_blank" href="https://rszalski.github.io/magicmethods/">here</a>.
Anyway, getting back to the topic, before we start implementing these two magic methods, we'll have to understand their purpose. <code>__enter__</code> is the method that gets called when we open the resource, or to put it in a slightly more technical way - when we &quot;enter&quot; the runtime context. The <code>with</code> statement will bind this method's return value to the target specified in the <code>as</code> clause of the statement:
<pre><code class="hljs">class FileManager:
 def __init__(self, filename):
 self.filename = filename
 
 def __enter__(self):
 self.opened_file = open(self.filename)
 return self.opened_file
</code></pre>
As you can see, the <code>__enter__</code> method is opening the resource - the file, and returning it. When we use this <code>FileManager</code> in a <code>with</code> statement, this method will be called and its return value will be bind to the target variable you mentioned in the <code>as</code> clause:
<pre><code class="hljs">with FileManager(&#x27;readme.txt&#x27;) as file:
 text = file.read()
</code></pre>
Let's break it down part-by-part. Firstly, an instance of the <code>FileManager</code> class is created when we instantiate it, passing the filename <code>&quot;readme.txt&quot;</code> to the constructor. Then, the <code>with</code> statement starts working on it - it calls the <code>__enter__</code> method of that <code>FileManager</code> object and assigns the returned value to the <code>file</code> variable mentioned in the <code>as</code> clause. Then, inside the <code>with</code> block, we can do whatever we want to do with the opened resource.
The other important part of the puzzle is the <code>__exit__</code> method. The <code>__exit__</code> method contains clean-up code which must be executed after we're done with the resource, no matter what. The instructions in this method will be similar to the ones in the <code>else</code> block we discussed before while discussing exception handling. To reiterate, the <code>__exit__</code> method contains instructions to properly close the resource handler, so that the resource is freed for further use by other programs in the OS.
Now let's take a look at how we might write this method:
<pre><code class="hljs">class FileManager:
 def __exit__(self. *exc):
 self.opened_file.close()
</code></pre>
Whenever the instances of this class will be used in a <code>with</code> statement, this <code>__exit__</code> method will be called before the program leaves the <code>with</code> block, or before the program halts due to some exception. Now let's look at the whole <code>FileManager</code> class so that we have a complete idea:
<pre><code class="hljs">class FileManager:
 def __init__(self, filename):
 self.filename = filename
 
 def __enter__(self):
 self.opened_file = open(self.filename)
 return self.opened_file
 
 def __exit__(self, *exc):
 self.opened_file.close()
</code></pre>
Simple enough, right? We just defined the opening and cleaning-up actions in the respective magic methods, and Python will take care of resource management wherever this class might be used. That brings us to the next topic, the different ways we can use context manager classes, such as this <code>FileManager</code> class.
<h2 id="usingcontextmanagers">Using Context Managers</h2>
There's not much to explain here, so instead of writing long paragraphs, let's take a look at a few code-snippets in this section:
<pre><code class="hljs">file = FileManager(&#x27;readme.txt&#x27;)
with file as managed_file:
 text = managed_file.read()
 print(text)
</code></pre>
<pre><code class="hljs">with FileManager(&#x27;readme.txt&#x27;) as managed_file:
 text = managed_file.read()
 print(text)
</code></pre>
<pre><code class="hljs">def open_file(filename):
 file = FileManager(filename)
 return file

with open_file(&#x27;readme.txt&#x27;) as managed_file:
 text = managed_file.read()
 print(text)
</code></pre>
You can see that the key thing to remember is,
<ol>
<li>The object passed to the <code>with</code> statement must have <code>__enter__</code> and <code>__exit__</code> methods.</li>
<li>The <code>__enter__</code> method must return the resource that's to be used in the <code>with</code> block.</li>
</ol>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Important: There are some subtleties I left out, to make the discussion to-the-point. For the exact specifications of these magic methods, refer to the Python documentation <a rel="nofollow" target="_blank" href="https://docs.python.org/3/library/stdtypes.html#context-manager-types">here</a>.

 </div>
 </div>
 </div>
 <h2 id="using_contextlib_">Using <code>_contextlib_</code></h2>
The <a rel="nofollow" target="_blank" href="https://www.python.org/dev/peps/pep-0020/">Zen of Python</a> - Python's guiding principle as a list of aphorisms - states:
<blockquote>
&quot;Simple is better than complex&quot;
</blockquote>
To really drive this point home, Python developers have created a library named <a rel="nofollow" target="_blank" href="https://docs.python.org/3/library/contextlib.html">contextlib</a> containing utilities regarding context managers, as if they didn't simplify the problem of resource management enough. We are going to demonstrate only one of them briefly here, but we recommend you to check out the official Python docs for more information.
<pre><code class="hljs">from contextlib import contextmanager

@contextmanager
def open_file(filename):
 opened_file = open(filename)
 try:
 yield opened_file
 finally:
 opened_file.close()
</code></pre>
Like the code above, we can simply define a function that <code>yield</code>s the protected resource in a <code>try</code> statement, closing it in the subsequent <code>finally</code> statement. Another way to understand it:
<ul>
<li>All the contents you'd otherwise put in the <code>__enter__</code> method, except the <code>return</code> statement, goes before the <code>try</code> block here — basically the instructions for opening the resource.</li>
<li>Instead of returning the resource, you <code>yield</code> it, inside a <code>try</code> block.</li>
<li>The contents of the <code>__exit__</code> method goes inside the corresponding <code>finally</code> block.</li>
</ul>
Once we have such a function, we can decorate it using the <code>contextlib.contextmanager</code> decorator and we're good:
<pre><code class="hljs">with open_file(&#x27;readme.txt&#x27;) as managed_file:
 text = managed_file.read()
 print(text)
</code></pre>
As you can see, the decorated <code>open_file</code> function returns a context manager and we can use that directly. This lets us achieve the same effect as creating the <code>FileManager</code> class, without all the hassle.
<h2 id="conclusion">Conclusion</h2>
If you're feeling enthusiastic and want to read more about context managers, I encourage you to check out the following links:
<ul>
<li><a rel="nofollow" target="_blank" href="https://docs.python.org/3/reference/compound_stmts.html#with">https://docs.python.org/3/reference/compound_stmts.html#with</a></li>
<li><a rel="nofollow" target="_blank" href="https://docs.python.org/3/reference/datamodel.html#context-managers">https://docs.python.org/3/reference/datamodel.html#context-managers</a></li>
<li><a rel="nofollow" target="_blank" href="https://docs.python.org/3/library/contextlib.html">https://docs.python.org/3/library/contextlib.html</a></li>
<li><a rel="nofollow" target="_blank" href="https://rszalski.github.io/magicmethods/">https://rszalski.github.io/magicmethods/</a></li>
</ul>

Guest Contributor

Python Context Managers

Introduction to Python's Collections Module

Adam McQuistan

Automating AWS EC2 Management with Python and Boto3

<h2 id="introduction">Introduction</h2>
The term <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Comma-separated_values">CSV</a> is an abbreviation that stands for comma-separated values.
A CSV file is a plain text file that contains data formatted according to the CSV standard. It has distinct lines which represent records and each field in the record is separated from another by a comma.
It's very convenient to store tabular data in CSV:
<pre><code class="hljs">Name,Surname,Age,Gender
John,Snow,26,M
Clair,White,33,F
Fancy,Brown,78,F
</code></pre>
Here, the first row represents the titles of the columns/fields of our CSV records and then there are 3 records that represent certain people. As you can see, the values are delimited by commas and each record starts on a new row.
<blockquote>
Hey, but what if we want to include commas or line breaks to some of the fields that are stored in the CSV format?
</blockquote>
There are several approaches to solving this issue, for example, we could wrap up such values in double quotes. Some of the CVS implementations don't support this feature by design, though.
<h2 id="csvstandardization">CSV Standardization</h2>
One of the most commonly used CSV standards is described in the <a rel="nofollow" target="_blank" href="https://tools.ietf.org/html/rfc4180">RFC4180</a>.
According to it, the CSV format is described by these 7 rules:
<ol>
<li>Each record is located on a separate line, delimited by a line break (CRLF).</li>
<li>The last record in the file may or may not have an ending line break.</li>
<li>There may be an optional header line appearing as the first line of the file with the same format as normal record lines. This header will contain names corresponding to the fields in the file and should contain the same number of fields as the records in the rest of the file (the presence or absence of the header line should be indicated via the optional &quot;header&quot; parameter of this MIME type).</li>
<li>Within the header and each record, there may be one or more fields, separated by commas. Each line should contain the same number of fields throughout the file. Spaces are considered part of a field and should not be ignored. The last field in the record must not be followed by a comma.</li>
<li>Each field may or may not be enclosed in double quotes (however some programs, such as Microsoft Excel, do not use double quotes at all). If fields are not enclosed with double quotes, then double quotes may not appear inside the fields.</li>
<li>Fields containing line breaks (CRLF), double quotes, and commas should be enclosed in double-quotes.</li>
<li>If double-quotes are used to enclose fields, then a double-quote appearing inside a field must be escaped by preceding it with another double quote.</li>
</ol>
If you're interested in reading more with multiple examples, you can study the original RFC4180 document, linked above.
<h2 id="readingcsvfilesinnodejs">Reading CSV Files in Node.js</h2>
To read a CSV file in Node.js, we could use nothing else than just the <code>fs</code> module, as in essence the CSV file is a plain text file.
If you're interested in reading more about <a target="_blank" href="/read-files-with-node-js/">Reading Files with Node.js</a> or <a target="_blank" href="/writing-to-files-in-node-js/">Writing Files with Node.js</a>, we've got both covered!
However, there are a couple of helpful modules that could handle generating or parsing the CSV content for us. We'll start by installing the module <code>csv-parser</code>:
<pre><code class="hljs">$ npm i -s csv-parser
</code></pre>
Then, let's put the CSV data from the beginning of the article to a file called <code>data.csv</code> and follow up with a very simple example:
<pre><code class="hljs">const csv = require(&#x27;csv-parser&#x27;);
const fs = require(&#x27;fs&#x27;);

fs.createReadStream(&#x27;data.csv&#x27;)
 .pipe(csv())
 .on(&#x27;data&#x27;, (row) =&gt; {
 console.log(row);
 })
 .on(&#x27;end&#x27;, () =&gt; {
 console.log(&#x27;CSV file successfully processed&#x27;);
 });
</code></pre>
Here, we create a <code>readStream</code> using the <code>fs</code> module, pipe it into the <code>csv</code> object that will then fire the <code>data</code> event each time a new row from the CSV file is processed. The <code>end</code> event is triggered when all the rows from the CSV file are processed and we log a short message to the console to indicate that.
For demonstration purposes, we just <code>console.log</code> each processed row and after running the code, you'll see this output in your console:
<pre><code class="hljs">Row {
 Name: &#x27;John&#x27;,
 &#x27;Surname&#x27;: &#x27;Snow&#x27;,
 &#x27;Age&#x27;: &#x27;26&#x27;,
 &#x27;Gender&#x27;: &#x27;M&#x27; }
Row {
 Name: &#x27;Clair&#x27;,
 &#x27;Surname&#x27;: &#x27;White&#x27;,
 &#x27;Age&#x27;: &#x27;33&#x27;,
 &#x27;Gender&#x27;: &#x27;F&#x27; }
Row {
 Name: &#x27;Fancy&#x27;,
 &#x27;Surname&#x27;: &#x27;Brown&#x27;,
 &#x27;Age&#x27;: &#x27;78&#x27;,
 &#x27;Gender&#x27;: &#x27;F&#x27; }
CSV file successfully processed
</code></pre>
<h2 id="writingcsvfilesinnodejs">Writing CSV Files in Node.js</h2>
Remembering the fact that CSV files are just plain text files, we could always limit ourselves to using only the native <code>fs</code> module, but to make our life easier, we'll use another common <code>npm</code> module, <code>csv-writer</code>.
First goes the installation:
<pre><code class="hljs">$ npm i -s csv-writer
</code></pre>
Then, the code:
<pre><code class="hljs">const createCsvWriter = require(&#x27;csv-writer&#x27;).createObjectCsvWriter;
const csvWriter = createCsvWriter({
 path: &#x27;out.csv&#x27;,
 header: [
 {id: &#x27;name&#x27;, title: &#x27;Name&#x27;},
 {id: &#x27;surname&#x27;, title: &#x27;Surname&#x27;},
 {id: &#x27;age&#x27;, title: &#x27;Age&#x27;},
 {id: &#x27;gender&#x27;, title: &#x27;Gender&#x27;},
 ]
});

const data = [
 {
 name: &#x27;John&#x27;,
 surname: &#x27;Snow&#x27;,
 age: 26,
 gender: &#x27;M&#x27;
 }, {
 name: &#x27;Clair&#x27;,
 surname: &#x27;White&#x27;,
 age: 33,
 gender: &#x27;F&#x27;,
 }, {
 name: &#x27;Fancy&#x27;,
 surname: &#x27;Brown&#x27;,
 age: 78,
 gender: &#x27;F&#x27;
 }
];

csvWriter
 .writeRecords(data)
 .then(()=&gt; console.log(&#x27;The CSV file was written successfully&#x27;));
</code></pre>
The <code>csv-writer</code> module requires an initial configuration where we provide it with the name of the resulting CSV file and the <code>header</code> configuration.
Note: In our JavaScript object, all properties are in lowercase, but in the CSV file the first letters of them should be capitalized.
After the config is done, all we need to do is call the <code>writeRecords</code> function, pass in the <code>data</code> array that represents the data structure that should be written to the CSV file.
Once this process is done, we'll print an informational message to the console stating that the program has completed.
<h3 id="usingthefastcsvmodule">Using the fast-csv Module</h3>
The Node.js ecosystem and <code>npm</code> provides a lot of options to read and write CSV files. We'll show another example of a popular CSV module and take a look at how we can write our data array using the <code>fast-csv</code> module as an alternative.
First, we have to install the module:
<pre><code class="hljs">$ npm i -s fast-csv
</code></pre>
<pre><code class="hljs">const fastcsv = require(&#x27;fast-csv&#x27;);
const fs = require(&#x27;fs&#x27;);
const ws = fs.createWriteStream(&quot;out.csv&quot;);
fastcsv
 .write(data, { headers: true })
 .pipe(ws);
</code></pre>
The API is a bit different, but the result is identical. In just a couple of lines of code, we managed to write the array of JavaScript objects to a CSV file that could be later used by a variety of other applications.
<h2 id="conclusion">Conclusion</h2>
Reading and writing CSV files with Node.js is a common development task as a CSV format is commonly used to store structured tabular data. Many <code>npm</code> modules provide this functionality, so you should choose the one that suits best to your needs and has ongoing support.

Vasyl Lagutin

Reading and Writing CSV Files with Node.js

David Landup

Linked List Programming Interview Questions

Usman Malik

Using Plotly Library for Interactive Data Visualization in Python

<h2 id="introduction">Introduction</h2>
<a rel="nofollow" target="_blank" href="https://vuejs.org/">Vue.js</a> is rocketing to unexpected heights after surpassing <a rel="nofollow" target="_blank" href="https://reactjs.org/">React.js</a> in GitHub stars, in spite of not being backed by any major company, and the release of their new Command-line Interface (CLI) tool might very well bump them even higher!
Scaffolding a Vue project from scratch can be a daunting thing to approach, especially if you are not particularly comfortable with Vue.js.
This is why <a rel="nofollow" target="_blank" href="https://cli.vuejs.org/">Vue CLI</a> is a must-have tool under your arsenal to make sure your projects are set up properly from the get-go, letting you pick from a handful of templates and let the CLI make all the hard work boilerplate code be done for you.
Excitingly enough, this last summer has brought us Vue CLI 3.0, introducing a bunch of cool new features like the Vue Graphical User Interface, making creating a project and managing dependencies easier than ever before!
<h3 id="cliservice">CLI Service</h3>
The CLI Service is a development dependency built on top of <a rel="nofollow" target="_blank" href="https://webpack.js.org/">Webpack</a>, a static module bundler for JavaScript applications - which is quite similar to react-scripts for React.js.
It is responsible for loading the plugins, making sure the webpack configuration is optimized, and enables us to have basic commands for managing our application (serve, build, lint, etc.).
<h2 id="prerequisites">Prerequisites</h2>
For the Vue CLI to work you would need to install <a rel="nofollow" target="_blank" href="https://nodejs.org/en/">Node.js (version 8.9+)</a> on your computer, to make sure you are able to use <a rel="nofollow" target="_blank" href="https://www.npmjs.com/">NPM (Node Package Manager)</a>, or <a rel="nofollow" target="_blank" href="https://yarnpkg.com/lang/en/">Yarn</a>, depending on your preferred manager.
<h2 id="installation">Installation</h2>
Once Node is downloaded, installing the Vue CLI is as simple as running a simple command in your command line:
<pre><code class="hljs">$ npm install -g @vue/cli
</code></pre>
Or, for yarn:
<pre><code class="hljs">$ yarn global add @vue/cli
</code></pre>
<h2 id="yourfirstvuejsproject">Your First Vue.js Project</h2>
Once you have installed the Vue CLI globally you will be able to access the <code>vue</code> command from anywhere in your computer and you will need it to create your boilerplate projects.
There are multiple ways to go about creating a project just running commands:
<pre><code class="hljs">$ vue create &lt;project name&gt;
</code></pre>
This is the bash way of doing things. When you enter the command you will be prompted several times for some configuration information to create your project.
First off it will ask you if you'd like to use a preset:
<pre><code class="hljs">Vue CLI v3.2.1
? Please pick a preset:
&gt; default (babel, eslint)
 Manually select features
</code></pre>
For the sake of this tutorial we will choose Manually select features to scroll through all the different pages you will be prompted with:
<pre><code class="hljs">Check the features needed for your project: (Press &lt;space&gt; to select, &lt;a&gt; to toggle all, &lt;i&gt; to invert selection)
&gt;(*) Babel
 ( ) TypeScript
 ( ) Progressive Web App (PWA) Support
 ( ) Router
 ( ) Vuex
 ( ) CSS Preprocessors
 (*) Linter / Formatter
 ( ) Unit Testing
 ( ) E2E Testing
</code></pre>
Here you can pick which are the features you want your project to have:
<ul>
<li>Babel for transpiling your code to ES5 JavaScript, which every browser can understand.</li>
<li>Typescript if you want to have strong typings and access more modern features on your JavaScript code.</li>
<li>Progressive Web App (PWA) Support if you desire to make use of PWA driven features like service-workers and offline support.</li>
<li>Router which will add the Vue-router package which is an awesome routing tool for your Single Page Applications (SPA). You will be prompted, if you pick this option, to choose if you want to have the History mode enabled for the router, which removes the <code>#</code> sign from all your endpoints.</li>
<li>Vuex to have a centralized store for your states and manage the global data of your application, as well as managing how data in your components is changed and from where from within Vue Devtools. (See <a rel="nofollow" target="_blank" href="https://github.com/vuejs/vue-devtools">Vue Devtools</a>).</li>
<li>CSS Preprocessors to pick your CSS pre-processor of choice, if you pick this option you will be prompted to pick between Sass/Less, Less, or Stylus.</li>
<li>Linter / Formatter this will add linting to your project to make sure your code is up to par with code standards. If you pick this option and you've picked Typescript you will be prompted to pick a linter / formatter as such, if you haven't chosen typescript, you won't get prompted for TSLint.</li>
</ul>
<pre><code class="hljs">? Pick a linter / formatter config: (Use arrow keys)
&gt; TSLint
 ESLint with error prevention only
 ESLint + Airbnb config
 ESLint + Standard config
 ESLint + Prettier
</code></pre>
Furthermore, you can choose if you want to add gitHooks to your configuration. These will run your linting/formatting scripts when saving or committing to your git repository.
<pre><code class="hljs">? Pick additional lint features: (Press &lt;space&gt; to select, &lt;a&gt; to toggle all, &lt;i&gt; to invert selection)
&gt;(*) Lint on save
 ( ) Lint and fix on commit
</code></pre>
<ul>
<li>Unit Testing will let you pick your unit testing framework of choice.</li>
</ul>
<pre><code class="hljs">? Pick a unit testing solution: (Use arrow keys)
&gt; Mocha + Chai
 Jest
</code></pre>
<ul>
<li>E2E Testing just as Unit Testing, will prompt you to pick your E2E testing environment.</li>
</ul>
<pre><code class="hljs">? Pick a E2E testing solution: (Use arrow keys)
 Cypress (Chrome only)
 Nightwatch (Selenium-based)
</code></pre>
After all these options, you will need to decide if you want to have all the configurations in separate files or simply added as objects inside the <code>package.json</code> file.
Additionally, you'll be asked if you want to save this configuration as a preset as well as if you want to pick npm or yarn as your desired package manager.
<h2 id="cliplugins">CLI Plugins</h2>
Some built-in plugins can be added using the command, such as <a rel="nofollow" target="_blank" href="https://vuetifyjs.com/">Vuetify</a>, a Material Design Framework for Vue.js:
<pre><code class="hljs">$ vue add &lt;plugin name&gt;
</code></pre>
A Vue CLI plugin as their names start with either <code>@vue/cli-plugin-</code> or <code>vue-cli-plugin-</code> - depending if they are built-in or third party plugins.
When you run the vue-cli-service, it automatically loads all CLI plugins listed inside the <code>package.json</code> file.
Congratulations, you have just created your very first Vue CLI project!
<h2 id="vuegraphicaluserinterface">Vue Graphical User Interface</h2>
If you don't want to go through the hassle of command lines, or you are simply not fond of dark backgrounds with white lines, you can always use the Vue GUI accessible by this command:
<pre><code class="hljs">$ vue ui
</code></pre>
When this command is run, a server will start up on <a rel="nofollow" target="_blank" href="http://localhost:8000">http://localhost:8000</a>.
Here you can create your projects in the same fashion as you would with the command line, but with a nice user interface.
<img src="https://s3.amazonaws.com/stackabuse/media/getting-started-with-vue-cli-3-x-1.png" alt="create_project">
Plus, you can manage your dependencies without the need of managing them out from <code>package.json</code>, which comes with the desired version for each package:
<img src="https://s3.amazonaws.com/stackabuse/media/getting-started-with-vue-cli-3-x-2.png" alt="dependencies">
Further configuration and widgets can be set up, and a few tasks can be automatically run from the Vue UI - Such as running a vulnerability check for your dependencies that may have security issues, setting up a port that you can kill to shut down your application, and enable the news feed to have the latest updates from the Vue team!
<img src="https://s3.amazonaws.com/stackabuse/media/getting-started-with-vue-cli-3-x-3.png" alt="further">
<pre><code class="hljs">$ vue-init &lt; template &gt; &lt; project name &gt;
</code></pre>
Whenever you want to use a Vue CLI 2.x legacy template, you need to install the <code>vue-init</code> service:
<pre><code class="hljs">$ npm install -g @vue/cli-init
</code></pre>
and then:
<pre><code class="hljs">$ vue init webpack my-project
</code></pre>
Then you will be able to set up your project as you would with a regular project.
<h2 id="folderstructure">Folder Structure</h2>
<img src="https://s3.amazonaws.com/stackabuse/media/getting-started-with-vue-cli-3-x-4.png" alt="folder_structure">
Each created project comes in with several folders which are set up for ease of use:
<ul>
<li>/node_modules this is where all the packaged dependencies will be installed in, by default they are installed whenever you create a project.</li>
<li>/public here is where the <code>index.html</code> lives and where all the public assets, manifests, and service-workers should be created.</li>
<li>/src where the main bread and meat of your work will be added, most other files from other folders are pre-configured, but this is where you add all your custom code and components.</li>
<li>/src/assets where you add your images, icons, fonts, that will, later on, be added to the <code>/dist</code> folder.</li>
<li>/src/components this is where you add your components, specifically your single components which do not represent a whole page.</li>
<li>/src/views here you have your layout components.</li>
<li>/test where your unit / e2e tests live.</li>
</ul>
Plus, a /plugins folder will be added as long as you have used the <code>vue add</code> command, where all your plugins will be installed.
Additionally, <code>main.js</code>, <code>router.js</code>, <code>store.js</code>, and <code>App.vue</code> will be auto-generated according to your configurations selected during the creation, along with some boilerplate examples.
<h2 id="thepackagejsonfile">The package.json File</h2>
This is one of the most important files, which holds most of your projects configuration, like the name, version, automated scripts you can use via NPM, and dependencies, which are third-party packages you can use in your project:
<pre><code class="hljs">{
 &quot;name&quot;: &quot;vue-cli-test&quot;,
 &quot;version&quot;: &quot;0.1.0&quot;,
 &quot;private&quot;: true,
 &quot;scripts&quot;: {
 &quot;serve&quot;: &quot;vue-cli-service serve&quot;,
 &quot;build&quot;: &quot;vue-cli-service build&quot;,
 &quot;lint&quot;: &quot;vue-cli-service lint&quot;,
 &quot;test:unit&quot;: &quot;vue-cli-service test:unit&quot;
 },
 &quot;dependencies&quot;: {
 &quot;vue&quot;: &quot;^2.5.17&quot;,
 &quot;vue-router&quot;: &quot;^3.0.1&quot;,
 &quot;vuex&quot;: &quot;^3.0.1&quot;
 },
 &quot;devDependencies&quot;: {
 &quot;@vue/cli-plugin-babel&quot;: &quot;^3.2.0&quot;,
 &quot;@vue/cli-plugin-eslint&quot;: &quot;^3.2.0&quot;,
 &quot;@vue/cli-plugin-unit-jest&quot;: &quot;^3.2.0&quot;,
 &quot;@vue/cli-service&quot;: &quot;^3.2.0&quot;,
 &quot;@vue/eslint-config-prettier&quot;: &quot;^4.0.0&quot;,
 &quot;@vue/test-utils&quot;: &quot;^1.0.0-beta.20&quot;,
 &quot;babel-core&quot;: &quot;7.0.0-bridge.0&quot;,
 &quot;babel-eslint&quot;: &quot;^10.0.1&quot;,
 &quot;babel-jest&quot;: &quot;^23.6.0&quot;,
 &quot;eslint&quot;: &quot;^5.8.0&quot;,
 &quot;eslint-plugin-vue&quot;: &quot;^5.0.0-0&quot;,
 &quot;node-sass&quot;: &quot;^4.9.0&quot;,
 &quot;sass-loader&quot;: &quot;^7.0.1&quot;,
 &quot;vue-template-compiler&quot;: &quot;^2.5.17&quot;
 },
 &quot;eslintConfig&quot;: {
 &quot;root&quot;: true,
 &quot;env&quot;: {
 &quot;node&quot;: true
 },
 &quot;extends&quot;: [
 &quot;plugin:vue/essential&quot;,
 &quot;@vue/prettier&quot;
 ],
 &quot;rules&quot;: {},
 &quot;parserOptions&quot;: {
 &quot;parser&quot;: &quot;babel-eslint&quot;
 }
 },
 &quot;browserslist&quot;: [
 &quot;&gt; 1%&quot;,
 &quot;last 2 versions&quot;,
 &quot;not ie &lt;= 8&quot;
 ]
}
</code></pre>
The scripts tag unveils your main handles for managing your application.
Running the following will start your development server with hot reloading:
<pre><code class="hljs">$ npm run serve
</code></pre>
This means that it will notice file changes so that you do not have to restart the server each time you update your code or resources.
Now, to create a <code>/dist</code> folder which will package all of your applications, no webpack or any extra configurations needed, we'll use:
<pre><code class="hljs">$ npm run build
</code></pre>
It will deliver an <code>index.html</code>, with all the JavaScript files injected automatically, and <code>js</code>, <code>css</code>, and <code>img</code> folders for these named assets.
Moreover, if you desire to watch all your files and process them using your <code>eslint</code> or prettier configurations you can use:
<pre><code class="hljs">$ npm run lint
</code></pre>
Accordingly, unit tests, located inside the <code>/tests</code> folder can be run with the following command:
<pre><code class="hljs">$ npm run test:unit
</code></pre>
Plus, <code>package.json</code> can hold specific configuration for linting, formatting, pre-commit hooks, and many more!
<h2 id="deployment">Deployment</h2>
The <code>/dist</code> folder can be handled to upload your bundled app to GitHub Pages, Heroku, Amazon S3, BitBucket Pages, and many other services.
Depending on your host service of choice, you will need to set up the <code>/dist</code> folder to match your server needs, this can be easily done via the <code>vue.config.js</code> file (or through the Vue UI configuration tab for that matter), which has to be created in the root folder of your project:
<pre><code class="hljs">module.exports = {}
</code></pre>
Here you can add your configuration needed for the server deployment such as the <code>baseUrl</code>.
If your server is waiting for your application to be hosted in a specific endpoint, such as: <code>http://www.testsite.com/test</code> - you will need to set up your <code>baseUrl</code> to accommodate to that endpoint:
<pre><code class="hljs">module.exports = {
 baseUrl: &#x27;/test&#x27;
}
</code></pre>
On the other hand, if your server is waiting for your static files to be in a specific folder, you can also specify it, or if you wanted to have the <code>/dist</code> folder named differently you can choose your <code>outputDir</code>:
<pre><code class="hljs">module.exports = {
 baseUrl: &#x27;/test&#x27;,
 assetsDir: &#x27;static&#x27;,
 outputDir: &#x27;app&#x27;
}
</code></pre>
These are just examples of the many configurations you can add to your project.
You could add all of these inside your <code>package.json</code> inside the <code>vue</code> property, but notice that you will have to use JSON-compatible values only.
<h2 id="conclusion">Conclusion</h2>
Vue.js is growing strong amongst the other main JavaScript frameworks. It is quite approachable, straight-forward, and very resilient.
Even though it is easy to use, newcomers can have quite a rough time setting up their projects properly, especially if you are not very keen on the command line.
Luckily, Evan You, Vue's creator is always thinking ahead, and is always stepping up for his fellow developers, making configuring and setting up new apps as easy as 1, 2, 3!
For further information you can visit, <a rel="nofollow" target="_blank" href="https://cli.vuejs.org/">Vue CLI's Official Page</a>.

Lucas Otero

Getting Started with Vue CLI 3.x

<h2 id="introduction">Introduction</h2>
Even for someone not interested in computer programming, the usefulness of generating random numbers in certain circumstances is something obvious. In most board games we throw dice to generate an unpredictable number that defines the player's next move. Also, we can all agree that playing any card game would be pointless without a proper shuffle between rounds.
But random numbers are not only important in relatively trivial fields like entertainment or gambling. They're especially crucial in the field of cryptography. In order to ensure safe transmission of data, every time a secure connection is necessary, a random key has to be generated. Many different kinds of electronic communication use this kind of security. It's very important for the key to be difficult to guess - the best way to ensure that is by making it random since the moment someone guesses the key, they are able to decipher the message - and the communication is not secure anymore.
<h2 id="truerandomnessvspseudorandomness">True Randomness vs Pseudo-randomness</h2>
Random numbers can be obtained as a result of applying methods called random number generators (RNG), which can be divided into two categories: true random-number generators (TRNGs – also called hardware random number generators) and pseudo-random number generators (PRNGS).
<h3 id="truerandomnumbergenerators">True Random Number Generators</h3>
The true random number generators are methods which derive randomness, or unpredictability, from unpredictable aspects of physical processes. These methods do not directly produce numbers, but rather states, that can then be interpreted as numbers – this is why they are usually called random event generators (REGs). Some of them, which use macroscopic events, are commonly known – methods like throwing dice, flipping coins or shuffling cards.
These true random number generators often use more complicated physical phenomena. Some of them, like radioactive decay, thermal noise or radio noise, derive their unpredictability from peculiarities of quantum mechanics. Other methods use the unpredictability of <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Atmospheric_noise">atmospheric noise</a> or even the <a rel="nofollow" target="_blank" href="https://www.fastcompany.com/90137157/the-hardest-working-office-design-in-america-encrypts-your-data-with-lava-lamps">behavior of lava lamps</a>.
<h3 id="pseudorandomnumbergenerators">Pseudo Random Number Generators</h3>
The truth is, very often generating numbers that are actually, truly random, is not necessary. In many cases, all we need are sets of numbers that seem random. This kind of data can be derived from pseudo-random number generators. These are algorithms that use a tiny portion of information (called a seed) and then apply complicated mathematical formulas in order to generate deterministic sets of numbers resembling truly random sets. The seed may be a value derived from a true random number generator, or another source, like the system's clock or the current datetime.
Running the generator multiple times using the same seed will result in the same output every time. The resulting numbers are mostly unrecognizable from numbers derived from true random number generators, although there actually are some hidden regularities in their distribution. Still, for many applications, this kind of deterministic pseudo-randomness is absolutely sufficient.
<h2 id="pythonrandommodule">Python Random Module</h2>
Python, obviously offers a super easy-to-use toolkit to handle random numbers. A module, for some reason called <code>random</code>, implements a pseudo-random number generator, and contains methods that let us directly solve many different programming issues where randomness comes into play.
The <code>random</code> module is based on <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Mersenne_Twister">Marsenne Twister</a> - a very popular algorithm, which is the default pseudo-random number generator not only for Python, but also for many other popular software systems such as Microsoft Excel, MATLAB, R, or PHP. Its important advantages include permissive licensing, random-likeness confirmed by many statistical tests, and relatively high speed compared to other PRNGs.
<h2 id="therandommethod">The random() Method</h2>
The most important method of the <code>random</code> module is the <code>random()</code> method. Most of the other functions depend on it. The <code>random()</code> method generates a random float in range (0.0, 1.0).
<pre><code class="hljs">&gt;&gt;&gt; import random
&gt;&gt;&gt; random.random()
0.8474337369372327
</code></pre>
<h2 id="theseedmethod">The seed() Method</h2>
If we don't set a seed for our pseudo-random number generation, the default seed is the current system time. However, we can set the exact value of the seed manually - which comes in handy especially if we want to replicate our pseudo-random results in the future. For this purpose, we can use the <code>random.seed()</code> method.
<pre><code class="hljs">&gt;&gt;&gt; random.seed(5)
&gt;&gt;&gt; random.random()
0.6229016948897019
&gt;&gt;&gt; random.random()
0.7417869892607294
&gt;&gt;&gt; random.random()
0.7951935655656966
&gt;&gt;&gt; random.seed(5)
&gt;&gt;&gt; random.random()
0.6229016948897019
</code></pre>
The <code>random.seed()</code> method influences all methods of the <code>random</code> module that we use after calling it. In the example shown above, we set the seed to <code>5</code> and then execute the <code>random.random()</code> function multiple times. It is important to note that the user-defined seed is used only the first time another <code>random</code> method is executed - after that, the seeds for the following methods are modified using the previously generated random values.
This lets Python come up with new numbers every time. But still, after re-setting the seed using the <code>random.seed()</code> method, we can reproduce the exact same sequence of pseudo-random numbers at any time. This is very useful for things like running tests. If you give the same seed every time you run a test that uses one of <code>random</code>'s methods then you will still be able to know what the output should be for the tests.
<h2 id="otherexamplesoftherandommodule">Other Examples of the random Module</h2>
The <code>random.random()</code> method, which gives us a random float value from a certain range, would be enough even for an inexperienced Python developer to design any kind of random-based manipulations around it. You can probably imagine throwing in an <code>if</code> or two to write a function that randomly draws value from a list or returns a random integer instead of a float. Well, the <code>random</code> module lets us take care of those tasks automatically as well. Below, I show a couple of cool methods that simplify common randomized operations. You can get to know the entire potential of the <code>random</code> module in <a rel="nofollow" target="_blank" href="https://docs.python.org/3/library/random.html">Python's official documentation</a>.
<pre><code class="hljs">&gt;&gt;&gt; random.randint(1,10)
4
</code></pre>
The <code>random.randint()</code> method takes two arguments describing the range from which the method draws a random integer.
<pre><code class="hljs">&gt;&gt;&gt; random.randrange(2,10,2)
2
&gt;&gt;&gt; random.randrange(2,10,2)
4
&gt;&gt;&gt; random.randrange(2,10,2)
8
&gt;&gt;&gt; random.randrange(2,10,2)
6
</code></pre>
In the script above, the <code>random.randrange()</code> method is similar to <code>random.randint()</code> but it also lets us define the third argument, which is the step point of the defined range. In the example above, we only require even numbers from a range between 2 and 10.
<pre><code class="hljs">&gt;&gt;&gt; cards = [&#x27;ace_spades&#x27;,&#x27;10_hearts&#x27;,&#x27;3_diamonds&#x27;,&#x27;king_hearts&#x27;]
&gt;&gt;&gt; random.choice(cards)
&#x27;10_hearts&#x27;
</code></pre>
In the above script, the <code>random.choice()</code> method picks a random element from a list.
<pre><code class="hljs">&gt;&gt;&gt; cards = [&#x27;ace_spades&#x27;,&#x27;10_hearts&#x27;,&#x27;3_diamonds&#x27;,&#x27;king_hearts&#x27;]
&gt;&gt;&gt; random.shuffle(cards)
&gt;&gt;&gt; print(cards)
[&#x27;king_hearts&#x27;, &#x27;3_diamonds&#x27;, &#x27;ace_spades&#x27;, &#x27;10_hearts&#x27;]
</code></pre>
In the previous script, the <code>random.shuffle()</code> method shuffles a list of elements. It is important to note that it alters the list in-place - which means it returns <code>None</code> and actually modifies our <code>cards</code> variable.
<h2 id="conclusions">Conclusions</h2>
Getting good random numbers, for serious applications such as cryptography, is not an easy task. But when a solid, pseudo-random number is sufficient for our application, Python, as always, comes with a number of super simple ways to quickly reach our goal.