Aniuchi Adaobi

In this article, we'll give an introduction to using GraphicsMagick and ImageMagick to manipulate images in Node.js, as well as examples of various supported functions.

Working with Images in Node.js - GraphicsMagick and ImageMagick

<h2 id="introduction">Introduction</h2>
NPM stands for Node Package Manager and refers to either the online project repository or the Command Line Interface (CLI) tool used to interact with the online repository.
Currently, NPM is the world's largest software registry with over 1.4M+ code packages. For example, if you wanted to use Node.js to send emails - you could do a quick search on their repository and find a module like <a rel="nofollow noopener" target="_blank" href="https://www.npmjs.com/package/nodemailer">Nodemailer</a>, which can save you a lot of time.
You might want to share a tool you've created with the community, that streamlines some boilerplate task. In this article, we'll take a look at how to publish a Node.js module to NPM.
<h2 id="gettingstartedwithnpm">Getting Started with NPM</h2>
To publish a module to NPM, we need to have an NPM account. If you don't have one, you can create it <a rel="nofollow noopener" target="_blank" href="https://www.npmjs.com/signup">here</a>.
When you install Node.js, the <code>npm</code> tool is automatically installed as well.
To check whether <code>npm</code> has been installed properly, you can check what the currently installed version is by running:
<pre><code class="hljs">$ npm -v
</code></pre>
Once ascertained that we've indeed got <code>npm</code> installed, we can log in:
<pre><code class="hljs">$ npm login
</code></pre>
The tool will prompt us for our id, email and password created while signing up.
Note: You don't need to have an account to use NPM, but to publish a module, you'll need one as it's tied to you as the author.
<h2 id="creatingapackage">Creating a Package</h2>
Let's create a directory for our project and move into it:
<pre><code class="hljs">$ mkdir publish-to-npm
$ cd publish-to-npm
</code></pre>
Next, we'll initialize the project:
<pre><code class="hljs">$ npm init 
</code></pre>
The command will then prompt you with several questions that, when filled in, produce a <code>package.json</code> file:
<pre><code class="hljs">{
 &quot;name&quot;: &quot;publish-to-npm&quot;,
 &quot;version&quot;: &quot;1.0.0&quot;,
 &quot;description&quot;: &quot;\&quot;Sample module for publishing\&quot;&quot;,
 &quot;main&quot;: &quot;index.js&quot;,
 &quot;scripts&quot;: {
 &quot;test&quot;: &quot;echo \&quot;Error: no test specified\&quot; &amp;&amp; exit 1&quot;
 },
 &quot;author&quot;: &quot;your@email.com&quot;,
 &quot;license&quot;: &quot;ISC&quot;
}
</code></pre>
The main entry point, by default, is the <code>index.js</code>, so we'll want to create that file and add something to it.
If you used the <code>-y</code> flag alongside the <code>init</code> command, these would've been set to their defaults.
<h2 id="addingdependencies">Adding Dependencies</h2>
Let's add some code to our <code>index.js</code> file and add a dependency, such as another NPM module for it to use.
First, we'll install a dependency:
<pre><code class="hljs">$ npm install node-fetch --save
</code></pre>
Then, we'll import it to our <code>index.js</code> file and add some logic:
<pre><code class="hljs">const fetch = require(&#x27;node-fetch&#x27;);

fetch(&#x27;https://google.com&#x27;)
 .then(res =&gt; res.text())
 .then(text =&gt; console.log(text))
</code></pre>
To verify this is working, we can run:
<pre><code class="hljs">$ node index.js
</code></pre>
And the output is:
<pre><code class="hljs">&lt;!doctype html&gt;
&lt;html itemscope=&quot;&quot; itemtype=&quot;http://schema.org/WebPage&quot; lang=&quot;en-RS&quot;&gt;
 &lt;head&gt;
 &lt;meta charset=&quot;UTF-8&quot;&gt;
 &lt;meta content=&quot;origin&quot; name=&quot;referrer&quot;&gt;
 &lt;!-- Rest of the page --&gt;
</code></pre>
When checking the <code>package.json</code> file now, we can see <code>node-fetch</code> in our dependencies:
<pre><code class="hljs">{
 &quot;name&quot;: &quot;publish-to-npm&quot;,
 &quot;version&quot;: &quot;1.0.0&quot;,
 &quot;description&quot;: &quot;\&quot;Sample module for publishing\&quot;&quot;,
 &quot;main&quot;: &quot;index.js&quot;,
 &quot;scripts&quot;: {
 &quot;test&quot;: &quot;echo \&quot;Error: no test specified\&quot; &amp;&amp; exit 1&quot;
 },
 &quot;author&quot;: &quot;your@email.com&quot;,
 &quot;license&quot;: &quot;ISC&quot;
 &quot;dependencies&quot;: {
 &quot;node-fetch&quot;: &quot;2.6.1&quot;
 }
}
</code></pre>
Note: The <code>--save</code> flag tells <code>npm</code> to update the project with the module as a dependency. This has been lifted in the newer versions and the module will be added to the dependency list even without the <code>--save</code> flag, though, for older versions, you'll have to use it.
<h2 id="publishingtonpm">Publishing to NPM</h2>
Now, we can publish the module to NPM via the <code>publish</code> command:
<pre><code class="hljs">$ npm publish
</code></pre>
If you get any error, it's most probably because of a name collision. i.e., a package with the same name already exists on npm. We have to change the name of our project to something unique.
You can search for existing package names through the search bar on the <a rel="nofollow noopener" target="_blank" href="https://www.npmjs.com/">home page</a>.
After you come up with a unique name, you have to change the package name in our <code>package.json</code> file. For the sake of consistency, it's also advised to update the folder name to match the package name.
If you are not able to come up with a unique name, you should check out <a rel="nofollow noopener" target="_blank" href="https://docs.npmjs.com/about-scopes">scoped packages</a>. This essentially gives you your own namespace on NPM, so you can name your packages whatever you want.
It's generally advised that, if you plan to make a module public, you still avoid using the same name as another package to avoid unnecessary confusion. However, it's very practical for personal use.
This is one of those settings we avoided changing by using the <code>-y</code> flag. If you wanted to make a scoped module, you would need to initialize your project with:
<pre><code class="hljs">$ npm init --scope=@your-username
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've written up a simple app and published it to NPM as a public module for other developers to use at their convenience.
You might come across a situation in the future where you don’t find a module readily available to solve your particular problem. You can write the solution yourself and upload it to NPM, and maybe help out other developers with the same problem.

Abhilash Kakumanu

In this article, we'll write a simple Node module and publish it to NPM for other developers to use.

Publishing a Node.js Module to NPM

<h2 id="introduction">Introduction</h2>
String padding refers to adding, usually, non-informative characters to a string to one or both ends of it. This is most often done for output formatting and alignment purposes, but it can have useful practical applications.
A frequent use case for padding strings is outputting table-like information in a table-like fashion. You can do this in a variety of ways, including using Pandas to convert your data to an actual table. This way, Python would handle the output formatting on its own.
In this article, we'll cover how to pad strings in Python.
Say, we've got these three lists:
<pre><code class="hljs">medicine1 = [&#x27;Morning&#x27;, &#x27;dispirine&#x27;, &#x27;1 mg&#x27;]
medicine2 = [&#x27;Noon&#x27;, &#x27;arinic&#x27;, &#x27;2 mg&#x27;]
medicine3 = [&#x27;Evening&#x27;, &#x27;Long_capsule_name&#x27;, &#x27;32 mg&#x27;]
</code></pre>
We can form these into a string, using the <code>join()</code> function:
<pre><code class="hljs">print(str.join(&#x27; &#x27;, medicine1))
print(str.join(&#x27; &#x27;, medicine2))
print(str.join(&#x27; &#x27;, medicine3))
</code></pre>
Would give us the rather untidy output of:
<pre><code class="hljs">Morning Dispirine 1 mg
Noon Arinic 2 mg
Evening Long_capsule_name 32 mg
</code></pre>
To combat this, we could write <code>for</code>/<code>while</code> loops and append spaces to the strings until they reached a certain length, and make sure that all the data is aligned properly for easy visual inspection. Or, we could use built-in functions that can achieve the same goal.
The functions we'll be taking a look at in this article are: <a href="#ljust"><code>ljust()</code></a>, <a href="#center"><code>center()</code></a>, <a href="#rjust"><code>rjust()</code></a>, <a href="#zfill"><code>zfill()</code></a> and <a href="#format"><code>format()</code></a>. Any of these functions can be used to add a certain number of characters to either end of strings, including spaces.
<h2 id="paddingtypes">Padding Types</h2>
Before we take a closer look at the functions mentioned above, we'll take a look at different types of padding so we can reference them when talking about the functions.
<h3 id="leftpadding">Left Padding</h3>
Adding left padding to a string means adding a given character at the start of a string to make it of the specified length. Left padding, outside of simple formatting and alignment reasons can be really useful when naming files that start with a number generated in a sequence.
For example, you need to name 11 files, and each of them starts with a number from 1 to 11. If you simply added the number at the beginning of the file, most operating systems would sort the files in the following order: <code>1</code>, <code>10</code>, <code>11</code>, <code>2</code>, and so on.
This happens of course because of the rules of lexicographical sorting, but you can avoid these situations by naming files with one or more leading zeroes, depending on how many files you expect, i.e.: <code>01</code>, <code>02</code>, <code>03</code>...
This can be achieved by effectively left padding the numbers with the appropriate number of zeroes, which keeps their original value.
This gives the effect of strings being left-justified.
<h3 id="centerpadding">Center Padding</h3>
This means that the given character is added in equal measure to both sides of the string until the new string reaches the given length. Using this effectively centers the string in the provided length:
<div>This is a normal string.</div>
<div style="text-align:center">This is a center padded string.</div>
<h3 id="rightpadding">Right Padding</h3>
Right padding is analogous to left padding - the given character is added to the end of the string until the string reaches a certain length.
<h2 id="pythonfunctionsforstringpadding">Python Functions For String Padding</h2>
Python offers many functions to format and handle strings, their use depends on the use case and the developer's personal preference. Most of the functions we'll discuss deal with text justification which is essentially adding padding to one side of the string. For example, for a string to be left-justified, we need to add padding to the end (right side) of the string.
Note: In all the functions that expect a <code>width</code> or <code>len</code> parameter, in case the original string is longer than the specified <code>width</code> or <code>len</code> the entire string will be kept without changes. This can have the undesired effect of long strings ruining the formatting, so when choosing a <code>width</code> value, make sure you take your longest string into account or a top length boundary.
<h3 id="ljust">ljust()</h3>
The <code>ljust()</code> function aligns a string to the left by adding right padding.
The <code>ljust()</code> function takes two parameters: <code>width</code> and <code>fillchar</code>. The <code>width</code> is mandatory and specifies the length of the string after adding padding, while the second parameter is optional and represents the character added pad the original string.
The default value is a space character, i.e. <code>' '</code>. This is a particularly good option to use when printing table-like data, like in our example at the beginning:
<pre><code class="hljs">medicine1 = [&#x27;Morning&#x27;, &#x27;Dispirine&#x27;, &#x27;1 mg&#x27;]
medicine2 = [&#x27;Noon&#x27;, &#x27;Arinic&#x27;, &#x27;2 mg&#x27;]
medicine3 = [&#x27;Evening&#x27;, &#x27;Long_capsule_name&#x27;, &#x27;32 mg&#x27;]

for medicine in [medicine1, medicine2, medicine3]:
 for entry in medicine:
 print(entry.ljust(25), end=&#x27;&#x27;)
 print()
</code></pre>
Which gives us the output:
<pre><code class="hljs">Morning Dispirine 1 mg 
Noon Arinic 2 mg 
Evening Long_capsule_name 32 mg 
</code></pre>
<h3 id="center">center()</h3>
The <code>center()</code> function aligns a string in the center of the specified <code>width</code>, by adding padding equally to both sides. The parameters are the same as with the <code>ljust()</code> function, a required <code>width</code>, and optional <code>fillchar</code> parameter:
<pre><code class="hljs">list_of_strings = [&quot;This can give us&quot;, &quot;text that&#x27;s center aligned&quot;, &quot;within the specified width&quot;]

for s in list_of_strings:
 print(s.center(50, &#x27; &#x27;))
</code></pre>
Output:
<pre><code class="hljs"> This can give us 
 text that&#x27;s center aligned 
 within the specified width 
</code></pre>
<h3 id="rjust">rjust()</h3>
Analogous to the previous two functions, <code>rjust()</code> aligns the string to the right by adding padding to the left (beginning) of the string.
Again, the parameters are the required <code>width</code> and optional <code>fillchar</code>. Like we mentioned previously, this function is very useful when naming files that start with numbers because of the more intuitive sorting:
<pre><code class="hljs">list_of_names_original = []
list_of_names_padded = []

for n in range(1, 13):
 list_of_names_original.append(str(n) + &quot;_name&quot;)
 list_of_names_padded.append(str(n).rjust(2, &#x27;0&#x27;) + &quot;_name&quot;)

print(&quot;Lexicographical sorting without padding:&quot;)
print(sorted(list_of_names_original))
print()

print(&quot;Lexicographical sorting with padding:&quot;)
print(sorted(list_of_names_padded))
</code></pre>
Running this code would give us:
<pre><code class="hljs">Lexicographical sorting without padding:
[&#x27;10_name&#x27;, &#x27;11_name&#x27;, &#x27;12_name&#x27;, &#x27;1_name&#x27;, &#x27;2_name&#x27;, &#x27;3_name&#x27;, &#x27;4_name&#x27;, &#x27;5_name&#x27;, &#x27;6_name&#x27;, &#x27;7_name&#x27;, &#x27;8_name&#x27;, &#x27;9_name&#x27;]

Lexicographical sorting with padding:
[&#x27;01_name&#x27;, &#x27;02_name&#x27;, &#x27;03_name&#x27;, &#x27;04_name&#x27;, &#x27;05_name&#x27;, &#x27;06_name&#x27;, &#x27;07_name&#x27;, &#x27;08_name&#x27;, &#x27;09_name&#x27;, &#x27;10_name&#x27;, &#x27;11_name&#x27;, &#x27;12_name&#x27;]
</code></pre>
<h3 id="zfill">zfill()</h3>
The <code>zfill()</code> function performs very similarly to using <code>rjust()</code> with zero as the specified character. It left-pads the given string with zeros until the string reaches the specified length.
The only difference is that in case our string starts with a plus(<code>+</code>) or minus(<code>-</code>) sign, the padding will start after that sign:
<pre><code class="hljs">neutral = &#x27;15&#x27;
positive = &#x27;+15&#x27;
negative = &#x27;-15&#x27;
length = 4

print(neutral.zfill(length))
print(positive.zfill(length+1))
print(negative.zfill(length+1))
</code></pre>
This is done to keep the original value of the number in case the string was a number. Running this code would give us:
<pre><code class="hljs">0015
+0015
-0015
</code></pre>
<h3 id="format">format()</h3>
The <code>format()</code> function is the most advanced in the list. This single function can be used for left, right, and even center padding. It is also used for <a target="_blank" href="/formatting-strings-with-python/">other formatting</a> too, but we'll only take a look at the padding functionality it provides.
It returns the string after formatting the specified values and putting them inside the string placeholders which are defined by <code>{}</code>.
The placeholders can be identified by either named indexes, numbered indexes, or even empty curly brackets. A quick example of how these placeholders look before we see how we can use this function to add padding:
<pre><code class="hljs">print(&quot;Placeholders can given by {0}, or with {value}&quot;.format(&quot;adding a number&quot;, value=&quot;a named value&quot;))
print(&quot;They can also be given {}, without adding a {} or {}&quot;.format(&quot;implicitly&quot;, &quot;number&quot;, &quot;name&quot;))
</code></pre>
Which would give us:
<pre><code class="hljs">Placeholders can given by adding a number, or with a named value
They can also be given implicitly, without adding a number or name
</code></pre>
These placeholders accept a variety of formatting options. Let's see how we can achieve different types of string padding by using these options:
<ul>
<li>
Left Padding: Use <code>&gt;</code> inside the placeholder and a number to specify the desired width, to right align a string (append characters at the start):
<pre><code class="hljs">txt = &quot;We {:&gt;8} Python.&quot;
print(txt.format(&#x27;love&#x27;))
</code></pre>
Which gives us:
<pre><code class="hljs">We love Python.
</code></pre>
</li>
<li>
Center Padding: Similarly, we can use <code>^</code> for center padding/alignment:
<pre><code class="hljs">txt = &quot;We {:^8} Python.&quot;
print(txt.format(&#x27;love&#x27;)) 
</code></pre>
<pre><code class="hljs">We love Python.
</code></pre>
</li>
<li>
Right Padding: Use <code>&lt;</code> inside placeholders to left align a string:
<pre><code class="hljs">txt = &quot;We {:&lt;8} Python.&quot;
print(txt.format(&#x27;love&#x27;)) 
</code></pre>
<pre><code class="hljs">We love Python.
</code></pre>
</li>
</ul>
You can also append characters other than white spaces, by adding the specified characters before the <code>&gt;</code>, <code>^</code> or <code>&lt;</code> character:
<pre><code class="hljs">print(&#x27;{:*^50}&#x27;.format(&#x27;Center padding with a specific character&#x27;))
</code></pre>
<pre><code class="hljs">*****Center padding with a specific character*****
</code></pre>
You can read more about the different possibilities of the <code>format()</code> function in our <a target="_blank" href="/formatting-strings-with-python/">Guide to Formatting Strings with Python</a>.
<h2 id="conclusion">Conclusion</h2>
Adding padding to strings in Python is a relatively straight-forward process that can noticeably increase the readability of your output, especially if the data you have can be read in a table-like fashion.
In this article, we've covered the <code>ljust()</code>, <code>rjust()</code>, <code>center()</code>, <code>zfill()</code> and <code>format()</code> function as built-in approaches to string padding in Python.

Muhammad Hashir Hassan

In this article, we take a look at what types of padding exist, and examples of how to efficiently add it in Python using ljust(), center(), rjust(), zfill() and format().

Padding Strings in Python

<h2 id="introduction">Introduction</h2>
Replacing all or n occurrences of a substring in a given string is a fairly common problem of string manipulation and text processing in general. JavaScript offers a few ways to get this done fairly easily.
In this tutorial, we'll cover some examples of how to replace occurrences of a substring in a string, using JavaScript.
We'll be working with this sentence:
<pre><code class="hljs">The grey-haired husky has one blue and one brown eye.
</code></pre>
We'll want to replace the word <code>&quot;blue&quot;</code> with <code>&quot;hazel&quot;</code>.
<h2 id="replace">replace()</h2>
The simplest way to do this is to use the built-in <code>replace()</code> function. It accepts a regular expression as the first argument, and the word(s) we're replacing the old ones with as the second argument. Alternatively, it accepts a string as the first argument too.
Since strings are immutable in JavaScript, this operation returns a new string. So if we want to make the changes permanent, we'll have to assign the result to a new string on return.
Let's see how we can use the function:
<pre><code class="hljs">const regex = /blue/;

let originalStr = &#x27;The grey-haired husky has one blue and one brown eye.&#x27;;
let newStr = originalStr.replace(regex, &#x27;hazel&#x27;);

console.log(originalStr);
console.log(newStr);
</code></pre>
Here, we've used a regular expression literal instead of instantiating a <code>RegExp</code> instance. This results in:
<pre><code class="hljs">The grey-haired husky has one blue and one brown eye.
The grey-haired husky has one hazel and one brown eye.
</code></pre>
Alternatively, we could've defined the regular expression as:
<pre><code class="hljs">let regex = new RegExp(&#x27;blue&#x27;);
</code></pre>
The result would've been the same. The difference between a regex literal and a <code>RegExp</code> object is that literals are compiled ahead of execution, while the object is compiled at runtime.
The former is more efficient if the regular expression stays constant, while the latter is typically used if the regex can be dynamic, such as an expression defined by the user.
To perform a case-insensitive replacement, you can pass the <code>i</code> flag to the regular expression:
<pre><code class="hljs">const regex = /blue/i;

let originalStr = &#x27;The grey-haired husky has one Blue and one brown eye.&#x27;;
let newStr = originalStr.replace(regex, &#x27;hazel&#x27;);

console.log(originalStr);
console.log(newStr);
</code></pre>
Now, this results in:
<pre><code class="hljs">The grey-haired husky has one Blue and one brown eye.
The grey-haired husky has one hazel and one brown eye.
</code></pre>
Without the <code>i</code> flag, <code>Blue</code> wouldn't match to the <code>/blue/</code> regex.
Finally, you can use a string instead of a regular expression:
<pre><code class="hljs">let originalStr = &#x27;The grey-haired husky has one blue and one brown eye.&#x27;;
let newStr = originalStr.replace(&#x27;blue&#x27;, &#x27;hazel&#x27;);

console.log(originalStr);
console.log(newStr);
</code></pre>
This also results in:
<pre><code class="hljs">The grey-haired husky has one blue and one brown eye.
The grey-haired husky has one hazel and one brown eye.
</code></pre>
Note: This approach works only for the first occurrence of the search string. To replace all occurrences, you can use the <code>replaceAll()</code> function.
If we update the string:
<pre><code class="hljs">let originalStr = &#x27;The grey-haired husky a blue left eye and a blue right eye.&#x27;;
let newStr = originalStr.replace(&#x27;blue&#x27;, &#x27;hazel&#x27;);
</code></pre>
The result would be:
<pre><code class="hljs">The grey-haired husky has a blue left eye and a blue right eye.
The grey-haired husky has a hazel left eye and a blue right eye.
</code></pre>
Notice how only the first occurance of &quot;blue&quot; is replaced, but not the second.
Note that we actually can replace all instances of a string when using the regex approach and <code>.replace()</code>. To make this happen, we'll want to use the <code>g</code> regex flag, which stands for &quot;global&quot;. This matches all instances in a string. For example:
<pre><code class="hljs">const regex = /blue/g;

let originalStr = &#x27;The grey-haired husky a blue left eye and a blue right eye.&#x27;;
let newStr = originalStr.replace(regex, &#x27;hazel&#x27;);

console.log(originalStr);
console.log(newStr);
</code></pre>
<pre><code class="hljs">The grey-haired husky has a blue left eye and a blue right eye.
The grey-haired husky has a hazel left eye and a hazel right eye.
</code></pre>
<h2 id="replaceall">replaceAll()</h2>
As of August 2020, as defined by the ECMAScript 2021 specification, we can use the <code>replaceAll()</code> function to replace all instances of a string.
It accepts a string we're searching for and a string we'd like to replace it with:
<pre><code class="hljs">let originalStr = &#x27;The grey-haired husky has a blue left eye and a blue right eye.&#x27;;
let newStr = originalStr.replaceAll(&#x27;blue&#x27;, &#x27;hazel&#x27;);

console.log(originalStr);
console.log(newStr);
</code></pre>
This results in:
<pre><code class="hljs">The grey-haired husky has a blue left eye and a blue right eye.
The grey-haired husky has a hazel left eye and a hazel right eye.
</code></pre>
Now all instances of the search word have been replaced.
<h2 id="splitandjoin">split() and join()</h2>
If <code>replaceAll()</code> isn't supported in your JavaScript runtime, you can use the trusty old <code>split()</code> and <code>join()</code> approach:
<pre><code class="hljs">let originalStr = &#x27;The grey-haired husky has a blue left eye and a blue right eye.&#x27;;
let newStr = originalStr.split(&#x27;blue&#x27;).join(&#x27;hazel&#x27;);

console.log(originalStr);
console.log(newStr);
</code></pre>
The <code>split()</code> function splits the string into an array of substrings on the given string - <code>'blue'</code>. Upon splitting, we have an array of:
<pre><code class="hljs">[&quot;The grey-haired husky has a &quot;, &quot; left eye and a &quot;, &quot; right eye.&quot;]
</code></pre>
Then, when se use <code>join()</code> with a string, we join it back into the original sentence, with the string passed to the function inserted in the breaks.
Now, we're left with all occurrences of the original string replaced with a new one:
<pre><code class="hljs">The grey-haired husky has a blue left eye and a blue right eye.
The grey-haired husky has a hazel left eye and a hazel right eye.
</code></pre>
Note: While this approach does work, it is not recommended for use if one of the other previously explained methods are available to use. The reason for this is that the purpose behind this approach is not as obvious at first-glance, and therefore it makes the code less readable.
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over a few examples of how you can replace occurrences of a substring in a string, using JavaScript.

David Landup

In this tutorial, we'll go over examples of how to replace all or a single occurrence(s) of a substring in a string using JavaScript. We'll use the replace(), replaceAll(), split() and join() functions.

Replace Occurrences of a Substring in a String with JavaScript

Replace Occurrences of a Substring in String with JavaScript

<h2 id="introduction">Introduction</h2>
Facial detection is a powerful and common use-case of Machine Learning. It can be used to automate routine tasks such as tracking school attendance, assist law enforcement, secure devices through biometric authentication, and even power fun experiences like <a target="_blank" rel="noopener noreferrer" href="https://www.banuba.com/tint-makeup-virtual-try-on">virtual makeup try-ons</a> that track facial features in real time.
In this article, we'll perform facial detection in Python, using OpenCV.
<h2 id="opencv">OpenCV</h2>
OpenCV is one of the most popular computer vision libraries. It was written in C and C++ and also provides support for Python, besides Java and MATLAB. While it's not the fastest library out there, it's easy to work with and provides a high-level interface, allowing developers to write stable code.
Let's install OpenCV so that we can use it in our Python code:
<pre><code class="hljs">$ pip install opencv-contrib-python
</code></pre>
Alternatively, you can install <code>opencv-python</code> for just the main modules of OpenCV. The <code>opencv-contrib-python</code> contains the main modules as well as the contrib modules which provide extended functionality.
<h2 id="detectingfacesinanimageusingopencv">Detecting Faces in an Image Using OpenCV</h2>
With OpenCV installed, we can import it as <code>cv2</code> in our code.
To read an image in, we will use the <code>imread()</code> function, along with the path to the image we want to process. The <code>imread()</code> function simply loads the image from the specified file in an <code>ndarray</code>. If the image could not be read, for example in case of a missing file or an unsupported format, the function will return <code>None</code>.
We will be using an image from <a rel='nofollow noopener' target='_blank' href='https://www.kaggle.com/mksaad/wider-face-a-face-detection-benchmark'>Kaggle dataset</a>:
<pre><code class="hljs">import cv2

path_to_image = &#x27;Parade_12.jpg&#x27;
original_image = cv2.imread(path_to_image)
</code></pre>
The full RGB information isn't necessary for facial detection. The color holds a lot of irrelevant information on the image, so it's more efficient to just remove it and work with a grayscale image. Additionally, the Viola-Jones algorithm, which works under the hood with OpenCV, checks the difference in intensity of an image's area. Grayscale images point this difference out more dramatically.
Note: In the case of color images, the decoded images will have the channels stored in BGR order, so when changing them to grayscale, we need to use the <code>cv2.COLOR_BGR2GRAY</code> flag:
<pre><code class="hljs">image = cv2.cvtColor(original_image, cv2.COLOR_BGR2GRAY)
</code></pre>
This could have been done directly when using <code>imread()</code>, by setting the <code>cv2.IMREAD_GRAYSCALE</code> flag:
<pre><code class="hljs">original_image = cv2.imread(path_to_image, cv2.IMREAD_GRAYSCALE)
</code></pre>
The OpenCV library comes with several pre-trained classifiers that are trained to find different things, like faces, eyes, smiles, upper bodies, etc.
The <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Haar-like_feature">Haar</a> features for detecting these objects are stored as XML, and depending on how you installed OpenCV, can most often be found in <code>Lib\site-packages\cv2\data</code>. They can also be found in the <a rel='nofollow noopener' target='_blank' href='https://github.com/opencv/opencv/tree/master/data/haarcascades'>OpenCV GitHub repository</a>.
In order to access them from code, you can use a <code>cv2.data.haarcascades</code> and add the name of the XML file you'd like to use.
We can choose which Haar features we want to use for our object detection, by adding the file path to the <code>CascadeClassifier()</code> constructor, which uses pre-trained models for object detection:
<pre><code class="hljs">face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + &quot;haarcascade_frontalface_default.xml&quot;)
</code></pre>
Now, we can use this <code>face_cascade</code> object to detect faces in the Image:
<pre><code class="hljs">detected_faces = face_cascade.detectMultiScale(image=image, scaleFactor=1.3, minNeighbors=4)
</code></pre>
When object detection models are trained, they are trained to detect faces of a certain size and might miss faces that are bigger or smaller than they expect. With this in mind, the image is resized several times in the hopes that a face will end up being a &quot;detectable&quot; size. The <code>scaleFactor</code> lets OpenCV know how much to scale the images. In our case, <code>1.3</code> means that it can scale <code>30%</code> down to try and match the faces better.
As for the <code>minNeighbors</code> parameter, it's used to control the number of false positives and false negatives. It defines the minimum number of positive rectangles (detect facial features) that need to be adjacent to a positive rectangle in order for it to be considered actually positive. If <code>minNeighbors</code> is set to <code>0</code>, the slightest hint of a face will be counted as a definitive face, even if no other facial features are detected near it.
Both the <code>scaleFactor</code> and <code>minNeighbors</code> parameters are somewhat arbitrary and set experimentally. We have chosen values that worked well for us, and gave no false positives, with the trade-off of more false negatives (undetected faces).
The <code>detectMultiScale()</code> method returns a list of rectangles of all the detected objects (faces in our first case). Each element in the list represents a unique face. This list contains tuples, <code>(x, y, w, h)</code>, where the <code>x, y</code> values represent the top-left coordinates of the rectangle, while the <code>w, h</code> values represent the width and height of the rectangle, respectively.
We can use the returned list of rectangles, and use the <code>cv2.rectangle()</code> function to easily draw the rectangles where a face was detected. Keep in mind that the color provided needs to be a tuple in RGB order:
<pre><code class="hljs">for (x, y, width, height) in detected_faces:
 cv2.rectangle(
 image,
 (x, y),
 (x + width, y + height),
 color,
 thickness=2
 )
</code></pre>
Now, let's put that all together:
<pre><code class="hljs">import cv2

def draw_found_faces(detected, image, color: tuple):
 for (x, y, width, height) in detected:
 cv2.rectangle(
 image,
 (x, y),
 (x + width, y + height),
 color,
 thickness=2
 )

path_to_image = &#x27;Parade_12.jpg&#x27;
original_image = cv2.imread(path_to_image)

if original_image is not None:
 # Convert image to grayscale
 image = cv2.cvtColor(original_image, cv2.COLOR_BGR2GRAY)

 # Create Cascade Classifiers
 face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + &quot;haarcascade_frontalface_default.xml&quot;)
 profile_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + &quot;haarcascade_profileface.xml&quot;)
 
 # Detect faces using the classifiers
 detected_faces = face_cascade.detectMultiScale(image=image, scaleFactor=1.3, minNeighbors=4)
 detected_profiles = profile_cascade.detectMultiScale(image=image, scaleFactor=1.3, minNeighbors=4)

 # Filter out profiles
 profiles_not_faces = [x for x in detected_profiles if x not in detected_faces]

 # Draw rectangles around faces on the original, colored image
 draw_found_faces(detected_faces, original_image, (0, 255, 0)) # RGB - green
 draw_found_faces(detected_profiles, original_image, (0, 0, 255)) # RGB - red

 # Open a window to display the results
 cv2.imshow(f&#x27;Detected Faces in {path_to_image}&#x27;, original_image)
 # The window will close as soon as any key is pressed (not a mouse click)
 cv2.waitKey(0) 
 cv2.destroyAllWindows()
else:
 print(f&#x27;En error occurred while trying to load {path_to_image}&#x27;)
</code></pre>
We used two different models on this picture. The default model for detecting front-facing faces, and a model built to better detect faces looking to the side.
Faces detected with the <code>frontalface</code> model are outlined in green, and faces detected with the <code>profileface</code> model are outlined with red. Most of the faces the first model found would have also been found by the second, so we only drew red rectangles where the <code>profileface</code> model detected a face but <code>frontalface</code> didn't:
<pre><code class="hljs">profiles_not_faces = [x for x in detected_profiles if x not in detected_faces]
</code></pre>
The <code>imshow()</code> method simply shows the passed image in a window with the provided title. With the picture we selected, this would provide the following output:
<img src="https://stackabuse.s3.amazonaws.com/media/facial-detection-in-python-with-opencv-1.png" alt="frontal and profile face detection">
Using different values for <code>scaleFactor</code> and <code>minNeighbors</code> will give us different results. For example, using <code>scaleFactor = 1.1</code> and <code>minNeighbors = 4</code> gives us more false positives and true positives with both models:
<img src="https://stackabuse.s3.amazonaws.com/media/facial-detection-in-python-with-opencv-4.png" alt="face detection lower scale factor">
We can see that the algorithm isn't perfect, but it is very efficient. This is most notable when working with real-time data, such as a video feed from a webcam.
<h2 id="realtimefacedetectionusingawebcam">Real-Time Face Detection Using a Webcam</h2>
Video streams are simply streams of images. With the efficiency of the Viola-Jones algorithm, we can do face detection in real-time.
The steps we need to take are very similar to the previous example with only one image - we'll be performing this on each image in the stream.
To get the video stream, we'll use the <code>cv2.VideoCapture</code> class. The constructor for this class takes an integer parameter representing the video stream. On most machines, the webcam can be accessed by passing <code>0</code>, but on machines with several video streams, you might need to try out different values.
Next, we need to read individual images from the input stream. This is done with the <code>read()</code> function, which returns <code>retval</code> and <code>image</code>. The <code>image</code> is simply the retrieved frame. The <code>retval</code> return value is used to detect whether a frame has been retrieved or not, and will be <code>False</code> if it hasn't.
However, it tends to be inconsistent with video input streams (doesn't detect that the webcam has been disconnected, for example), so we will be ignoring this value.
Let's go ahead and modify the previous code to handle a video stream:
<pre><code class="hljs">import cv2

def draw_found_faces(detected, image, color: tuple):
 for (x, y, width, height) in detected:
 cv2.rectangle(
 image,
 (x, y),
 (x + width, y + height),
 color,
 thickness=2
 )

# Capturing the Video Stream
video_capture = cv2.VideoCapture(0)

# Creating the cascade objects
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + &quot;haarcascade_frontalface_default.xml&quot;)
eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + &quot;haarcascade_eye_tree_eyeglasses.xml&quot;)

while True:
 # Get individual frame
 _, frame = video_capture.read()
 # Covert the frame to grayscale
 grayscale_image = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
 
 # Detect all the faces in that frame
 detected_faces = face_cascade.detectMultiScale(image=grayscale_image, scaleFactor=1.3, minNeighbors=4)
 detected_eyes = eye_cascade.detectMultiScale(image=grayscale_image, scaleFactor=1.3, minNeighbors=4)
 draw_found_faces(detected_faces, frame, (0, 0, 255))
 draw_found_faces(detected_eyes, frame, (0, 255, 0))

 # Display the updated frame as a video stream
 cv2.imshow(&#x27;Webcam Face Detection&#x27;, frame)

 # Press the ESC key to exit the loop
 # 27 is the code for the ESC key
 if cv2.waitKey(1) == 27:
 break

# Releasing the webcam resource
video_capture.release()

# Destroy the window that was showing the video stream
cv2.destroyAllWindows()
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've created a facial detection application using Python and OpenCV.
Using the OpenCV library is very straight-forward for basic object detection programs. Experimentally adjusting the <code>scaleFactor</code> and <code>minNeighbors</code> parameters for the types of images you'd like to process can give pretty accurate results very efficiently.

Guest Contributor

In this article, we'll perform facial detection on images and a live webcam using Python and OpenCV.

Facial Detection in Python with OpenCV

In this tutorial, we'll see how to generate PDF files in Node.js using PDFKit, how to customize them, align text, add images, scale images, etc.

Generating PDF Files in Node.js with PDFKit

<h2 id="introduction">Introduction</h2>
In Java, working with files and directories is rather common. We are also often interested in the contents of those files and directories.
Depending on the contents of the file, we might want to behave differently. We might be writing some data into a file and we first want to check if it already contains some information before overwriting it. Similarly, we might be wanting to delete a directory if it's empty. The knowledge of whether it's empty or not can, in such cases, be of vital importance.
In this tutorial, we'll go over some examples of how to check if a file or directory is empty in Java.
<h2 id="checkifafileisemptyinjava">Check if a File is Empty in Java</h2>
There are two ways to check if a <code>File</code> is empty.
We'll be working with two files, one empty and one non-empty:
<pre><code class="hljs">09/17/2020 01:00 PM 0 file
09/17/2020 01:00 PM 2 file2
</code></pre>
<code>file</code> is <code>0</code> bytes in length, while <code>file2</code> is <code>2</code> bytes in length.
It's worth noting that before performing any operations on a file or directory, you should <a target="_blank" href="/java-check-if-a-file-or-directory-exists/">check if a file or directory exists</a>, as well as their type to avoid running the wrong methods.
<h3 id="usingfilelength">Using File.length()</h3>
According to its <a rel="nofollow noopener" target="_blank" href="https://docs.oracle.com/javase/7/docs/api/java/io/File.html">documentation</a>, a <code>File</code> object is &quot;an abstract representation of file and directory pathnames&quot;. Each <code>File</code> object has methods for obtaining information about that specific file.
Let's go ahead and create a simple helper method that returns <code>true</code> if the <code>File</code>'s length is <code>0</code> and <code>false</code> otherwise:
<pre><code class="hljs">public boolean isFileEmpty(File file) {
 return file.length() == 0;
}
</code></pre>
Now, let's test it out on an empty and non-empty file:
<pre><code class="hljs">File file1 = new File(&quot;/file&quot;);
File file2 = new File(&quot;/file2&quot;);

System.out.println(isFileEmpty(file1));
System.out.println(isFileEmpty(file2));
</code></pre>
This code returns:
<pre><code class="hljs">true
false
</code></pre>
<h3 id="usingbufferedreader">Using BufferedReader</h3>
Another way to check if the <code>File</code>'s length is <code>0</code> or not is to use the <code>BufferedReader</code>. It allows us to reach character contents from streams (such as files). If there are no contents in the file, it's empty:
<pre><code class="hljs">public boolean isFileEmpty(File file) {
 BufferedReader br = new BufferedReader(new FileReader(file)); 
 return br.readLine() == null;
}
</code></pre>
The method's declaration remains the same as before: it accepts a <code>File</code> and returns a <code>boolean</code>. Though this time, we've instantiated a <code>BufferedReader</code> and provided it with a <code>FileReader</code> which accepts our <code>File</code>. It's slightly more complex than before but it gets the job done just as well.
Then, if the <code>BufferedReader</code> has nothing to read from the file, we know it's empty.
Again, let's test this out on an empty and a non-empty file:
<pre><code class="hljs">File file1 = new File(&quot;/file&quot;);
File file2 = new File(&quot;/file2&quot;);

System.out.println(isFileEmpty(file1));
System.out.println(isFileEmpty(file2));
</code></pre>
This code returns:
<pre><code class="hljs">true
false
</code></pre>
<h2 id="checkifdirectoryisemptyinjava">Check if Directory is Empty in Java</h2>
There's two ways to check if a directory is empty in Java, as well.
<h3 id="usingfilelist">Using File.list()</h3>
The <code>File</code> class has a convenient method for collecting all files and directories (entries, meaning both files and directories) inside a given directory. We can use this method to check if the number of such entries is zero:
<pre><code class="hljs">public boolean isDirectoryEmpty(File directory) { 
 String[] files = directory.list();
 return files.length == 0; 
}
</code></pre>
The method returns an array of entry names. If the <code>length</code> of this array is <code>0</code>, the directory is empty.
Let's run this on an empty and non-empty directory:
<pre><code class="hljs">File directory1 = new File(&quot;/empty_directory&quot;);
File directory2 = new File(&quot;/directory&quot;);

System.out.println(isDirectoryEmpty(directory1));
System.out.println(isDirectoryEmpty(directory1));
</code></pre>
This returns:
<pre><code class="hljs">true
false
</code></pre>
<h3 id="usingadirectorystream">Using a DirectoryStream</h3>
Another quick, albeit more advanced, technique involves using streams. First, we create a new <code>DirectoryStream</code> by calling <code>Files.newDirectoryStream()</code> class. This method accepts a <code>Path</code> so we need to convert our <code>File</code> into a <code>Path</code> by calling the <code>toPath()</code> method:
<pre><code class="hljs">public boolean isDirectoryEmpty(File directory) throws IOException {
 DirectoryStream&lt;Path&gt; stream = Files.newDirectoryStream(directory.toPath());
 return !stream.iterator().hasNext(); 
}
</code></pre>
Then, we collect the stream's iterator and check if it contains a next entry by calling <code>hasNext()</code>. If it doesn't contain at least one entry, the directory is empty.
Let's run this code:
<pre><code class="hljs">File directory1 = new File(&quot;/empty_directory&quot;);
File directory2 = new File(&quot;/directory&quot;);

System.out.println(isDirectoryEmpty(directory1));
System.out.println(isDirectoryEmpty(directory1));
</code></pre>
And this results in:
<pre><code class="hljs">true
false
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've laid down a few examples for checking whether files and directories are empty. First, we've checked if files are empty using the <code>File</code> class and its <code>length()</code> method, followed by a <code>BufferedReader</code> approach.
Then, we've checked if a directory is empty by using <code>File.list()</code> and by creating a <code>DirectoryStream</code>.

Luka Čupić

In this tutorial, we'll go over code examples of how to check if a file or directory is empty in Java using the File, Files and DirectoryStream classes.

Java: Check if File or Directory is Empty

<h2 id="introduction">Introduction</h2>
Replacing all or n occurrences of a substring in a given string is a fairly common problem of string manipulation and text processing in general. Luckily, most of these tasks are made easy in Python by its vast array of built-in functions, including this one.
Let's say, we have a string that contains the following sentence:
<pre><code class="hljs">The brown-eyed man drives a brown car.
</code></pre>
Our goal is to replace the word <code>&quot;brown&quot;</code> with the word <code>&quot;blue&quot;</code>:
<pre><code class="hljs">The blue-eyed man drives a blue car.
</code></pre>
In this article, we'll be using the <code>replace()</code> function as well as the <code>sub()</code> and <code>subn()</code> functions with patterns to replace all occurrences of a substring from a string.
<h2 id="replace">replace()</h2>
The simplest way to do this is by using the built-in function - <code>replace()</code> :
<pre><code class="hljs">string.replace(oldStr, newStr, count)
</code></pre>
The first two parameters are required, while the third one is optional. <code>oldStr</code> is the substring we want to replace with the <code>newStr</code>. What's worth noting is that the function returns a new string, with the performed transformation, without affecting the original one.
Let's give it a try:
<pre><code class="hljs">string_a = &quot;The brown-eyed man drives a brown car.&quot;
string_b = string_a.replace(&quot;brown&quot;, &quot;blue&quot;)
print(string_a)
print(string_b)
</code></pre>
We've performed the operation on <code>string_a</code>, packed the result into <code>string_b</code> and printed them both.
This code results in:
<pre><code class="hljs">The brown-eyed man drives a brown car.
The blue-eyed man drives a blue car.
</code></pre>
Again, the string in memory that <code>string_a</code> is pointing to remains unchanged. Strings in Python are immutable, which simply means you can't change a string. However, you can re-assign the reference variable to a new value.
To seemingly perform this operation in-place, we can simply re-assign <code>string_a</code> to itself after the operation:
<pre><code class="hljs">string_a = string_a.replace(&quot;brown&quot;, &quot;blue&quot;)
print(string_a)
</code></pre>
Here, the new string generated by the <code>replace()</code> method is assigned to the <code>string_a</code> variable.
<h3 id="replacenoccurrencesofasubstring">Replace n Occurrences of a Substring</h3>
Now, what if we don't wish to change all occurrences of a substring? What if we want to replace the first n?
That's where the third parameter of the <code>replace()</code> function comes in. It represents the number of substrings that are going to be replaced. The following code only replaces the first occurrence of the word <code>&quot;brown&quot;</code> with the word <code>&quot;blue&quot;</code>:
<pre><code class="hljs">string_a = &quot;The brown-eyed man drives a brown car.&quot;
string_a = string_a.replace(&quot;brown&quot;, &quot;blue&quot;, 1)
print(string_a)
</code></pre>
And this prints:
<pre><code class="hljs">The blue-eyed man drives a brown car.
</code></pre>
By default, the third parameter is set to change all occurrences.
<h2 id="substringoccurrenceswithregularexpressions">Substring Occurrences with Regular Expressions</h2>
To escalate the problem even further, let's say we want to not only replace all occurrences of a certain substring, but replace all substrings that fit a certain pattern. Even this can be done with a one-liner, using regular expressions, and the standard library's <code>re</code> module.
Regular expressions are a complex topic with a wide range of use in computer science, so we won't go too much in-depth in this article but if you need a quick start you can check out our guide on <a target="_blank" href="/introduction-to-regular-expressions-in-python/">Regular Expressions in Python</a>.
In its essence, a regular expression defines a pattern. For example, let's say we have a text about people who own cats and dogs, and we want to change both terms with the word <code>&quot;pet&quot;</code>. First, we need to define a pattern that matches both terms like - <code>(cat|dog)</code>.
<h3 id="usingthesubfunction">Using the sub() Function</h3>
With the pattern sorted out, we're going to use the <code>re.sub()</code> function which has the following syntax:
<pre><code class="hljs">re.sub(pattern, repl, string, count, flags)
</code></pre>
The first argument is the pattern we're searching for (a string or a <code>Pattern</code> object), <code>repl</code> is what we're going to insert (can be a string or a function; if it is a string, any backslash escapes in it are processed) and <code>string</code> is the string we're searching in.
Optional arguments are <code>count</code> and <code>flags</code> which indicate how many occurrences need to be replaced and the flags used to process the regular expression, respectively.
If the pattern doesn't match any substring, the original string will be returned unchanged:
<pre><code class="hljs">import re
string_a = re.sub(r&#x27;(cat|dog)&#x27;, &#x27;pet&#x27;, &quot;Mark owns a dog and Mary owns a cat.&quot;)
print(string_a)
</code></pre>
This code prints:
<pre><code class="hljs">Mark owns a pet and Mary owns a pet.
</code></pre>
<h3 id="caseinsensitivepatternmatching">Case-Insensitive Pattern Matching</h3>
To perform case-insensitive pattern matching, for example, we'll set the flag parameter to <code>re.IGNORECASE</code>:
<pre><code class="hljs">import re
string_a = re.sub(r&#x27;(cats|dogs)&#x27;, &quot;Pets&quot;, &quot;DoGs are a man&#x27;s best friend&quot;, flags=re.IGNORECASE)
print(string_a)
</code></pre>
Now any case-combination of <code>&quot;dogs&quot;</code> will also be included. When matching the pattern against multiple strings, to avoid copying it in multiple places, we can define a <code>Pattern</code> object. They also have a <code>sub()</code> function with the syntax:
<pre><code class="hljs">Pattern.sub(repl, string, count)
</code></pre>
<h3 id="usingpatternobjects">Using Pattern Objects</h3>
Let's define a <code>Pattern</code> for cats and dogs and check a couple of sentences:
<pre><code class="hljs">import re
pattern = re.compile(r&#x27;(Cats|Dogs)&#x27;)
string_a = pattern.sub(&quot;Pets&quot;, &quot;Dogs are a man&#x27;s best friend.&quot;)
string_b = pattern.sub(&quot;Animals&quot;, &quot;Cats enjoy sleeping.&quot;)
print(string_a)
print(string_b)
</code></pre>
Which gives us the output:
<pre><code class="hljs">Pets are a man&#x27;s best friend.
Animals enjoy sleeping.
</code></pre>
<h3 id="thesubnfunction">The subn() Function</h3>
There's also a <code>subn()</code> method with the syntax:
<pre><code class="hljs">re.subn(pattern, repl, string, count, flags)
</code></pre>
The <code>subn()</code> function returns a tuple with the string and number of matches in the String we've searched:
<pre><code class="hljs">import re
string_a = re.subn(r&#x27;(cats|dogs)&#x27;, &#x27;Pets&#x27;, &quot;DoGs are a mans best friend&quot;, flags=re.IGNORECASE)
print(string_a)
</code></pre>
The tuple looks like:
<pre><code class="hljs">(&#x27;Pets are a mans best friend&#x27;, 1)
</code></pre>
A <code>Pattern</code> object contains a similar <code>subn()</code> function:
<pre><code class="hljs">Pattern.subn(repl, string, count)
</code></pre>
And it's used in a very similar way:
<pre><code class="hljs">import re
pattern = re.compile(r&#x27;(Cats|Dogs)&#x27;)
string_a = pattern.subn(&quot;Pets&quot;, &quot;Dogs are a man&#x27;s best friend.&quot;)
string_b = pattern.subn(&quot;Animals&quot;, &quot;Cats enjoy sleeping.&quot;)
print(string_a)
print(string_b)
</code></pre>
This results in:
<pre><code class="hljs">(&quot;Pets are a man&#x27;s best friend.&quot;, 1)
(&#x27;Animals enjoy sleeping.&#x27;, 1)
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Python offers easy and simple functions for string handling. The easiest way to replace all occurrences of a given substring in a string is to use the <code>replace()</code> function.
If needed, the standard library's <code>re</code> module provides a more diverse toolset that can be used for more niche problems like finding patterns and case-insensitive searches.

Kristina Popovic

In this tutorial, we'll showcase how to replace all or *n* occurrences of a substring from a string in python using replace(), sub() and subn() with regular expressions and examples.

Replace Occurrences of a Substring in a String with Python

Replace Occurrences of a Substring in String with Python

Mehreen Saeed

Introduction to kernel density estimation using scikit-learn. Examples of using different kernel and bandwidth parameters for optimization. 